00001
00021 #include "OSGeneral.h"
00022 #include "OSInstance.h"
00023 #include "OSMathUtil.h"
00024 #include "OSErrorClass.h"
00025 #include "OSParameters.h"
00026
00027 #include<stack>
00028 #include<iostream>
00029 #include<sstream>
00030
00031
00032 #define DEBUG_ISEQUAL_ROUTINES
00033
00034 using namespace std;
00035 using std::ostringstream;
00036
00037
00038 OSInstance::OSInstance():
00039 bVariablesModified(false),
00040 bObjectivesModified(false),
00041 bConstraintsModified(false),
00042 bAMatrixModified(false),
00043 m_sInstanceName(""),
00044 m_sInstanceSource(""),
00045 m_sInstanceDescription(""),
00046 m_bProcessVariables(false),
00047 m_iVariableNumber(-1),
00048 m_iNumberOfIntegerVariables( 0),
00049 m_iNumberOfBinaryVariables( 0),
00050 m_iNumberOfSemiContinuousVariables( 0),
00051 m_iNumberOfSemiIntegerVariables( 0),
00052 m_iNumberOfStringVariables( 0),
00053 m_iNumberOfQuadraticRowIndexes( 0),
00054 m_bQuadraticRowIndexesProcessed( false),
00055 m_miQuadRowIndexes( NULL),
00056 m_iNumberOfNonlinearExpressionTreeIndexes( 0),
00057 m_bNonlinearExpressionTreeIndexesProcessed( false),
00058 m_miNonlinearExpressionTreeIndexes( NULL),
00059 m_iNumberOfNonlinearExpressionTreeModIndexes( 0),
00060 m_bNonlinearExpressionTreeModIndexesProcessed( false),
00061 m_miNonlinearExpressionTreeModIndexes( NULL),
00062 m_msVariableNames(NULL),
00063
00064
00065 m_mcVariableTypes(NULL),
00066 m_mdVariableLowerBounds(NULL),
00067 m_mdVariableUpperBounds(NULL),
00068 m_bProcessObjectives(false),
00069 m_iObjectiveNumber(-1),
00070 m_iObjectiveNumberNonlinear( 0),
00071 m_msObjectiveNames(NULL),
00072 m_msMaxOrMins(NULL),
00073 m_miNumberOfObjCoef(NULL),
00074 m_mdObjectiveConstants(NULL),
00075 m_mdObjectiveWeights(NULL),
00076 m_mObjectiveCoefficients(NULL),
00077 m_bGetDenseObjectives(false),
00078 m_mmdDenseObjectiveCoefficients(NULL),
00079 m_bProcessConstraints(false),
00080 m_iConstraintNumber(-1),
00081 m_iConstraintNumberNonlinear( 0),
00082 m_msConstraintNames(NULL),
00083 m_mdConstraintLowerBounds(NULL),
00084 m_mdConstraintUpperBounds(NULL),
00085 m_mdConstraintConstants( NULL),
00086 m_mcConstraintTypes(NULL),
00087 m_bProcessLinearConstraintCoefficients(false),
00088 m_iLinearConstraintCoefficientNumber(-1),
00089 m_bColumnMajor(true),
00090 m_binitForAlgDiff( false),
00091 m_linearConstraintCoefficientsInColumnMajor(NULL),
00092 m_linearConstraintCoefficientsInRowMajor(NULL),
00093 m_bProcessQuadraticTerms(false),
00094 m_iQuadraticTermNumber(-1),
00095 m_mdConstraintFunctionValues( NULL),
00096 m_mdObjectiveFunctionValues( NULL),
00097 m_iJacValueSize( 0),
00098 m_miJacStart( NULL),
00099 m_miJacIndex( NULL),
00100 m_mdJacValue( NULL),
00101 m_miJacNumConTerms( NULL),
00102 m_sparseJacMatrix( NULL),
00103 m_iHighestTaylorCoeffOrder(-1),
00104 m_quadraticTerms( NULL),
00105 m_bQTermsAdded( false),
00106 m_iNumberOfNonlinearVariables( 0),
00107 m_bProcessNonlinearExpressions( false),
00108 m_iNonlinearExpressionNumber( -1),
00109 m_miNonlinearExpressionIndexes( NULL),
00110 m_bProcessExpressionTrees( false),
00111 m_bProcessExpressionTreesMod( false),
00112 m_LagrangianExpTree(NULL),
00113 m_bLagrangianExpTreeCreated( false),
00114 m_LagrangianSparseHessian( NULL),
00115 m_bLagrangianSparseHessianCreated( false),
00116 m_miNonLinearVarsReverseMap( NULL),
00117 m_bAllNonlinearVariablesIndex( false),
00118 m_bOSADFunIsCreated( false),
00119 m_bCppADTapesBuilt( false),
00120 m_bCppADMustReTape( false),
00121 m_bDuplicateExpressionTreesMap( false),
00122 m_bNonLinearStructuresInitialized( false),
00123 m_bSparseJacobianCalculated( false),
00124 m_iHighestOrderEvaluated( -1),
00125 m_mmdObjGradient( NULL),
00126 m_bProcessTimeDomain( false),
00127 m_bProcessTimeStages( false),
00128 m_bProcessTimeInterval( false),
00129 m_bFiniteTimeStages( false),
00130 m_iNumberOfTimeStages(-1),
00131 m_msTimeDomainStageNames(NULL),
00132 m_miTimeDomainStageVariableNumber(NULL),
00133 m_mmiTimeDomainStageVarList(NULL),
00134 m_miTimeDomainStageConstraintNumber(NULL),
00135 m_mmiTimeDomainStageConList(NULL),
00136 m_miTimeDomainStageObjectiveNumber(NULL),
00137 m_mmiTimeDomainStageObjList(NULL),
00138 bUseExpTreeForFunEval( false)
00139
00140 {
00141 #ifdef DEBUG
00142 cout << "Inside OSInstance Constructor" << endl;
00143 #endif
00144 this->instanceHeader = new GeneralFileHeader();
00145 this->instanceData = new InstanceData();
00146 }
00147
00148 OSInstance::~OSInstance(){
00149 #ifdef DEBUG
00150 cout << "OSInstance Destructor Called" << endl;
00151 #endif
00152 std::map<int, OSExpressionTree*>::iterator posMapExpTree;
00153
00154
00155 if(this->instanceData->variables->numberOfVariables > 0 && m_bProcessVariables == true){
00156 delete[] m_msVariableNames;
00157 m_msVariableNames = NULL;
00158 delete[] m_mcVariableTypes;
00159 m_mcVariableTypes = NULL;
00160 delete[] m_mdVariableLowerBounds;
00161 m_mdVariableLowerBounds = NULL;
00162 delete[] m_mdVariableUpperBounds;
00163 m_mdVariableUpperBounds = NULL;
00164 }
00165
00166
00167 if(m_bProcessConstraints == true){
00168 delete[] m_msConstraintNames;
00169 m_msConstraintNames = NULL;
00170 delete[] m_mcConstraintTypes;
00171 m_mcConstraintTypes = NULL;
00172 delete[] m_mdConstraintConstants;
00173 m_mdConstraintConstants = NULL;
00174 delete[] m_mdConstraintLowerBounds;
00175 m_mdConstraintLowerBounds = NULL;
00176 delete[] m_mdConstraintUpperBounds;
00177 m_mdConstraintUpperBounds = NULL;
00178 }
00179
00180
00181 int i;
00182
00183 if(m_bProcessObjectives == true ){
00184 for(i = 0; i < instanceData->objectives->numberOfObjectives; i++){
00185 #ifdef DEBUG
00186 std::cout << "Delete m_mObjectiveCoefficients[i]" << std::endl;
00187 #endif
00188 delete m_mObjectiveCoefficients[i];
00189 m_mObjectiveCoefficients[i] = NULL;
00190 }
00191 #ifdef DEBUG
00192 std::cout << "Delete m_msObjectiveNames" << std::endl;
00193 std::cout << "Delete m_msMaxOrMins" << std::endl;
00194 std::cout << "Delete m_miNumberOfObjCoef" << std::endl;
00195 std::cout << "Delete m_mdObjectiveConstants" << std::endl;
00196 std::cout << "Delete m_mdObjectiveWeights" << std::endl;
00197 #endif
00198 delete[] m_msObjectiveNames;
00199 m_msObjectiveNames = NULL;
00200 delete[] m_msMaxOrMins;
00201 m_msMaxOrMins = NULL;
00202 delete[] m_miNumberOfObjCoef;
00203 m_miNumberOfObjCoef = NULL;
00204 delete[] m_mdObjectiveConstants;
00205 m_mdObjectiveConstants = NULL;
00206 delete[] m_mdObjectiveWeights;
00207 m_mdObjectiveWeights = NULL;
00208 delete[] m_mObjectiveCoefficients;
00209 m_mObjectiveCoefficients = NULL;
00210 }
00211
00212 if(m_bGetDenseObjectives == true){
00213 for(i = 0; i < instanceData->objectives->numberOfObjectives; i++){
00214
00215 #ifdef DEBUG
00216 std::cout << "delete m_mmdDenseObjectiveCoefficients[i]" << std::endl;
00217 #endif
00218 delete[] m_mmdDenseObjectiveCoefficients[i];
00219 m_mmdDenseObjectiveCoefficients[i] = NULL;
00220 }
00221 delete[] m_mmdDenseObjectiveCoefficients;
00222 m_mmdDenseObjectiveCoefficients = NULL;
00223 }
00224
00225
00226
00227
00228
00229
00230 if( m_linearConstraintCoefficientsInColumnMajor != NULL) delete m_linearConstraintCoefficientsInColumnMajor;
00231 if (m_linearConstraintCoefficientsInRowMajor != NULL ) delete m_linearConstraintCoefficientsInRowMajor;
00232
00233
00234 if( (m_binitForAlgDiff == true) ){
00235 delete[] m_miNonLinearVarsReverseMap;
00236 m_miNonLinearVarsReverseMap = NULL;
00237 if(instanceData->objectives->numberOfObjectives > 0 && m_mmdObjGradient != NULL){
00238
00239 #ifdef DEBUG
00240 std::cout << "The number of objectives = " << instanceData->objectives->numberOfObjectives << std::endl;
00241 #endif
00242 for(i = 0; i < instanceData->objectives->numberOfObjectives; i++){
00243 #ifdef DEBUG
00244 std::cout << "deleting Objective function gradient " << i << std::endl;
00245 #endif
00246 delete[] m_mmdObjGradient[i];
00247
00248 m_mmdObjGradient[i] = NULL;
00249 }
00250 delete[] m_mmdObjGradient;
00251 m_mmdObjGradient = NULL;
00252 }
00253 }
00254
00255
00256
00257 if(m_bNonLinearStructuresInitialized == true ){
00258 delete[] m_mdObjectiveFunctionValues;
00259 m_mdObjectiveFunctionValues = NULL;
00260 delete[] m_mdConstraintFunctionValues;
00261 m_mdConstraintFunctionValues = NULL;
00262 }
00263 if(m_bSparseJacobianCalculated == true){
00264 delete[] m_miJacStart;
00265 m_miJacStart = NULL;
00266 delete[] m_miJacIndex;
00267 m_miJacIndex = NULL;
00268 delete[] m_mdJacValue;
00269 m_mdJacValue = NULL;
00270 delete[] m_miJacNumConTerms;
00271 m_miJacNumConTerms = NULL;
00272 }
00273 if( m_bLagrangianExpTreeCreated == true){
00274 delete m_LagrangianExpTree;
00275 m_LagrangianExpTree = NULL;
00276 }
00277 if( m_bLagrangianSparseHessianCreated == true){
00278 delete m_LagrangianSparseHessian;
00279 m_LagrangianSparseHessian = NULL;
00280 }
00281 if( m_bSparseJacobianCalculated == true){
00282 delete m_sparseJacMatrix;
00283 m_sparseJacMatrix = NULL;
00284 }
00285 if( (instanceData->quadraticCoefficients->qTerm != NULL) && (m_bProcessQuadraticTerms == true) ){
00286 delete m_quadraticTerms;
00287 m_quadraticTerms = NULL;
00288 }
00289 if( (instanceData->quadraticCoefficients->qTerm != NULL) && (m_bQuadraticRowIndexesProcessed == true) ){
00290 delete[] m_miQuadRowIndexes;
00291 m_miQuadRowIndexes = NULL;
00292 }
00293
00294
00295
00296 if( (m_bProcessExpressionTrees == true) && (m_bDuplicateExpressionTreesMap == false) ) {
00297 for(posMapExpTree = m_mapExpressionTrees.begin(); posMapExpTree != m_mapExpressionTrees.end(); ++posMapExpTree){
00298 std::cout << "Deleting an expression tree from the map for row " << posMapExpTree->first << std::endl;
00299 delete m_mapExpressionTrees[ posMapExpTree->first ];
00300 }
00301 }
00302 if( m_bDuplicateExpressionTreesMap == true) {
00303 for(posMapExpTree = m_mapExpressionTreesMod.begin(); posMapExpTree != m_mapExpressionTreesMod.end(); ++posMapExpTree){
00304 #ifdef DEBUG
00305 std::cout << "Deleting an expression tree from m_mapExpressionTreesMod" << std::endl;
00306 #endif
00307 delete m_mapExpressionTreesMod[ posMapExpTree->first ];
00308 }
00309 }
00310
00312 if( (m_bNonlinearExpressionTreeIndexesProcessed == true) && (m_mapExpressionTrees.size() > 0) ){
00313 std::cout << "Deleting m_miNonlinearExpressionTreeIndexes" << std::endl;
00314 delete[] m_miNonlinearExpressionTreeIndexes;
00315 std::cout << "Done Deleting m_miNonlinearExpressionTreeIndexes" << std::endl;
00316 m_miNonlinearExpressionTreeIndexes = NULL;
00317 }
00318 if( (m_bNonlinearExpressionTreeModIndexesProcessed == true) && (m_mapExpressionTreesMod.size() > 0) ){
00319 std::cout << "Deleting m_miNonlinearExpressionTreeModIndexes" << std::endl;
00320 delete[] m_miNonlinearExpressionTreeModIndexes;
00321 std::cout << "Done Deleting m_miNonlinearExpressionTreeModIndexes" << std::endl;
00322 m_miNonlinearExpressionTreeModIndexes = NULL;
00323 }
00324 if(m_bOSADFunIsCreated == true){
00325 try{
00326 #ifdef COIN_HAS_CPPAD
00327 delete Fad;
00328 Fad = NULL;
00329 #else
00330 throw ErrorClass( "Error: An Algorithmic Differentiation Package Not Available");
00331 #endif
00332 }
00333 catch(const ErrorClass& eclass){
00334 throw ErrorClass( eclass.errormsg);
00335 }
00336 }
00337
00338
00339
00340
00341
00342 if (m_msTimeDomainStageNames != NULL) {
00343 delete[] m_msTimeDomainStageNames;
00344 m_msTimeDomainStageNames = NULL;
00345 }
00346
00347 if (m_miTimeDomainStageVariableNumber != NULL) {
00348 delete[] m_miTimeDomainStageVariableNumber;
00349 m_miTimeDomainStageVariableNumber = NULL;
00350 }
00351
00352 if (m_mmiTimeDomainStageVarList != NULL) {
00353 for (int i = 0; i < m_iNumberOfTimeStages; i ++)
00354 delete[] m_mmiTimeDomainStageVarList[i];
00355 delete[] m_mmiTimeDomainStageVarList;
00356 m_mmiTimeDomainStageVarList = NULL;
00357 }
00358
00359 if (m_miTimeDomainStageConstraintNumber != NULL) {
00360 delete[] m_miTimeDomainStageConstraintNumber;
00361 m_miTimeDomainStageConstraintNumber = NULL;
00362 }
00363
00364 if (m_mmiTimeDomainStageConList != NULL) {
00365 for (int i = 0; i < m_iNumberOfTimeStages; i ++)
00366 delete[] m_mmiTimeDomainStageConList[i];
00367 delete[] m_mmiTimeDomainStageConList;
00368 m_mmiTimeDomainStageConList = NULL;
00369 }
00370
00371 if (m_miTimeDomainStageObjectiveNumber != NULL) {
00372 delete[] m_miTimeDomainStageObjectiveNumber;
00373 m_miTimeDomainStageObjectiveNumber = NULL;
00374 }
00375
00376 if (m_mmiTimeDomainStageObjList != NULL) {
00377 for (int i = 0; i < m_iNumberOfTimeStages; i ++)
00378 delete[] m_mmiTimeDomainStageObjList[i];
00379 delete[] m_mmiTimeDomainStageObjList;
00380 m_mmiTimeDomainStageObjList = NULL;
00381 }
00382
00383
00384
00385 delete instanceHeader;
00386 instanceHeader = NULL;
00387
00388 delete instanceData;
00389 instanceData = NULL;
00390 }
00391
00392 InstanceHeader::InstanceHeader():
00393 description(""),
00394 name(""),
00395 source("")
00396
00397 {
00398 #ifdef DEBUG
00399 cout << "Inside the InstanceHeader Constructor" << endl;
00400 #endif
00401 }
00402
00403
00404 InstanceHeader::~InstanceHeader(){
00405 #ifdef DEBUG
00406 cout << "Inside the InstanceHeader Destructor" << endl;
00407 #endif
00408 }
00409
00410 Variable::Variable():
00411 lb(0.0),
00412 ub(OSDBL_MAX),
00413
00414 type('C'),
00415 name("")
00416
00417 {
00418 #ifdef DEBUG
00419 cout << "Inside the Variable Constructor" << endl;
00420 #endif
00421 }
00422
00423 Variable::~Variable(){
00424 #ifdef DEBUG
00425 cout << "Inside the Variable Destructor" << endl;
00426 #endif
00427 }
00428
00429 Variables::Variables(){
00430 #ifdef DEBUG
00431 cout << "Inside the Variables Constructor" << endl;
00432 #endif
00433 numberOfVariables = 0;
00434 var = NULL;
00435 }
00436
00437 Variables::~Variables(){
00438 #ifdef DEBUG
00439 cout << "Inside the Variables Destructor" << endl;
00440 #endif
00441 int i;
00442 if(numberOfVariables > 0 && var != NULL){
00443 for(i = 0; i < numberOfVariables; i++){
00444 #ifdef DEBUG
00445 cout << "Deleting var[ i]" << endl;
00446 #endif
00447 delete var[i];
00448 var[i] = NULL;
00449 }
00450 }
00451 if (var != NULL)
00452 delete[] var;
00453 var = NULL;
00454 }
00455
00456 ObjCoef::ObjCoef():
00457 idx(-1),
00458 value(0.0)
00459 {
00460 #ifdef DEBUG
00461 cout << "Inside the Coef Constructor" << endl;
00462 #endif
00463 }
00464
00465 ObjCoef::~ObjCoef(){
00466 #ifdef DEBUG
00467 cout << "Inside the ObjCoef Destructor" << endl;
00468 #endif
00469 }
00470
00471 Objective::Objective():
00472 name("") ,
00473 maxOrMin("min"),
00474 constant(0.0),
00475 weight(OSNAN),
00476 numberOfObjCoef(0),
00477 coef(NULL)
00478 {
00479
00480 #ifdef DEBUG
00481 cout << "Inside the Objective Constructor" << endl;
00482 #endif
00483 }
00484
00485 Objective::~Objective(){
00486 #ifdef DEBUG
00487 cout << "Inside the Objective Destructor" << endl;
00488 #endif
00489 int i;
00490 if(numberOfObjCoef > 0 && coef != NULL){
00491 for(i = 0; i < numberOfObjCoef; i++){
00492 delete coef[i];
00493 coef[i] = NULL;
00494 }
00495 }
00496 if (coef != NULL)
00497 delete[] coef;
00498 coef = NULL;
00499 }
00500
00501 Objectives::Objectives()
00502 {
00503 #ifdef DEBUG
00504 cout << "Inside the Objectives Constructor" << endl;
00505 #endif
00506 numberOfObjectives = 0;
00507 obj = NULL;
00508 }
00509
00510 Objectives::~Objectives(){
00511 #ifdef DEBUG
00512 cout << "Inside the Objectives Destructor" << endl;
00513 #endif
00514 int i;
00515 if(numberOfObjectives > 0 && obj != NULL){
00516 for(i = 0; i < numberOfObjectives; i++){
00517 delete obj[i];
00518 obj[i] = NULL;
00519 }
00520 }
00521 if (obj != NULL)
00522 delete[] obj;
00523 obj = NULL;
00524 }
00525
00526 Constraint::Constraint():
00527 name(""),
00528 constant(0.0),
00529 lb(-OSDBL_MAX),
00530 ub(OSDBL_MAX)
00531
00532 {
00533 #ifdef DEBUG
00534 cout << "Inside the Constraint Constructor" << endl;
00535 #endif
00536 }
00537
00538 Constraint::~Constraint(){
00539 #ifdef DEBUG
00540 cout << "Inside the Constraint Destructor" << endl;
00541 #endif
00542 }
00543
00544 Constraints::Constraints():
00545 numberOfConstraints(0),
00546 con(NULL)
00547 {
00548 #ifdef DEBUG
00549 cout << "Inside the Constraints Constructor" << endl;
00550 #endif
00551 }
00552
00553 Constraints::~Constraints(){
00554 #ifdef DEBUG
00555 cout << "Inside the Constraints Destructor" << endl;
00556 #endif
00557 int i;
00558 if(numberOfConstraints > 0 && con != NULL){
00559 for( i = 0; i < numberOfConstraints; i++){
00560 delete con[i];
00561 con[i] = NULL;
00562 }
00563 }
00564 if (con != NULL)
00565 delete[] con;
00566 con = NULL;
00567 }
00568
00569
00570
00571 LinearConstraintCoefficients::LinearConstraintCoefficients():
00572 numberOfValues(0) ,
00573 iNumberOfStartElements( 0)
00574 {
00575 #ifdef DEBUG
00576 cout << "Inside the LinearConstraintCoefficients Constructor" << endl;
00577 #endif
00578 start = new IntVector();
00579 rowIdx = new IntVector();
00580 colIdx = new IntVector();
00581 value = new DoubleVector();
00582
00583 }
00584
00585
00586 LinearConstraintCoefficients::~LinearConstraintCoefficients(){
00587 #ifdef DEBUG
00588 cout << "Inside the LinearConstraintCoefficients Destructor" << endl;
00589 #endif
00590 delete start;
00591 start = NULL;
00592 delete rowIdx;
00593 rowIdx = NULL;
00594 delete colIdx;
00595 colIdx = NULL;
00596 delete value;
00597 value = NULL;
00598 }
00599
00600 QuadraticTerm::QuadraticTerm():
00601
00602 idx(0),
00603 idxOne(-1),
00604 idxTwo(-1),
00605 coef(0.0)
00606
00607 {
00608 #ifdef DEBUG
00609 cout << "Inside the QuadraticTerm Constructor" << endl;
00610 #endif
00611 }
00612
00613
00614 QuadraticTerm::~QuadraticTerm(){
00615 #ifdef DEBUG
00616 cout << "Inside the QuadraticTerm Destructor" << endl;
00617 #endif
00618 }
00619
00620
00621
00622 QuadraticCoefficients::QuadraticCoefficients():
00623 numberOfQuadraticTerms(0),
00624 qTerm(NULL)
00625 {
00626 #ifdef DEBUG
00627 cout << "Inside the QuadraticCoefficients Constructor" << endl;
00628 #endif
00629 }
00630
00631
00632 QuadraticCoefficients::~QuadraticCoefficients(){
00633 #ifdef DEBUG
00634 cout << "Inside the QuadraticCoefficients Destructor" << endl;
00635 #endif
00636 int i;
00637 if(numberOfQuadraticTerms > 0 && qTerm != NULL){
00638 for( i = 0; i < numberOfQuadraticTerms; i++){
00639 delete qTerm[i];
00640 qTerm[i] = NULL;
00641 }
00642 }
00643 if (qTerm != NULL)
00644 delete[] qTerm;
00645 qTerm = NULL;
00646 }
00647
00648
00649 Nl::Nl(){
00650 idx = 0;
00651 osExpressionTree = NULL;
00652 m_bDeleteExpressionTree = true;
00653 }
00654
00655
00656 Nl::~Nl(){
00657 #ifdef DEBUG
00658 cout << "Inside the Nl Destructor" << endl;
00659 #endif
00660
00661
00662 if( m_bDeleteExpressionTree == true){
00663 delete osExpressionTree;
00664 osExpressionTree = NULL;
00665 }
00666 }
00667
00668
00669
00670 NonlinearExpressions::NonlinearExpressions():
00671 numberOfNonlinearExpressions(0) ,
00672 nl(NULL)
00673 {
00674 #ifdef DEBUG
00675 cout << "Inside the NonlinearExpressions Constructor" << endl;
00676 #endif
00677 }
00678
00679 NonlinearExpressions::~NonlinearExpressions(){
00680 #ifdef DEBUG
00681 cout << "Inside the NonlinearExpressions Destructor" << endl;
00682 cout << "NUMBER OF NONLINEAR EXPRESSIONS = " << numberOfNonlinearExpressions << endl;
00683 #endif
00684 int i;
00685 if(numberOfNonlinearExpressions > 0 && nl != NULL){
00686 for( i = 0; i < numberOfNonlinearExpressions; i++){
00687 #ifdef DEBUG
00688 cout << "DESTROYING EXPRESSION " << nl[ i]->idx << endl;
00689 #endif
00690 if(nl != NULL){
00691 if(nl[i] != NULL){
00692 delete nl[i];
00693 nl[i] = NULL;
00694 }
00695 }
00696 }
00697 }
00698 if(nl != NULL){
00699 delete[] nl;
00700 }
00701 nl = NULL;
00702 }
00703
00704
00705 TimeDomainStageVar::TimeDomainStageVar():
00706 idx(0)
00707 {
00708 #ifdef DEBUG
00709 cout << "Inside the Stage Objectives Var Constructor" << endl;
00710 #endif
00711 }
00712
00713
00714 TimeDomainStageVar::~TimeDomainStageVar()
00715 {
00716 #ifdef DEBUG
00717 cout << "Inside the Stage Objectives Var Destructor" << endl;
00718 #endif
00719 }
00720
00721
00722 TimeDomainStageVariables::TimeDomainStageVariables():
00723 numberOfVariables(0),
00724 startIdx(-1)
00725 {
00726 #ifdef DEBUG
00727 cout << "Inside the Stage Variables Constructor" << endl;
00728 #endif
00729 var = NULL;
00730 }
00731
00732 TimeDomainStageVariables::~TimeDomainStageVariables()
00733 {
00734 #ifdef DEBUG
00735 cout << "Inside the Stage Variables Destructor" << endl;
00736 #endif
00737 if (numberOfVariables > 0 && var != NULL){
00738 for (int i = 0; i < numberOfVariables; i++) {
00739 delete var[i];
00740 var[i] = NULL;
00741 }
00742 }
00743 if (var != NULL)
00744 delete [] var;
00745 var = NULL;
00746 }
00747
00748 TimeDomainStageCon::TimeDomainStageCon():
00749 idx(0)
00750 {
00751 #ifdef DEBUG
00752 cout << "Inside the Stage Objectives Con Constructor" << endl;
00753 #endif
00754 }
00755
00756
00757 TimeDomainStageCon::~TimeDomainStageCon()
00758 {
00759 #ifdef DEBUG
00760 cout << "Inside the Stage Objectives Con Destructor" << endl;
00761 #endif
00762 }
00763
00764
00765 TimeDomainStageConstraints::TimeDomainStageConstraints():
00766 numberOfConstraints(0),
00767 startIdx(-1)
00768 {
00769 #ifdef DEBUG
00770 cout << "Inside the Stage Constraints Constructor" << endl;
00771 #endif
00772 con = NULL;
00773 }
00774
00775 TimeDomainStageConstraints::~TimeDomainStageConstraints()
00776 {
00777 #ifdef DEBUG
00778 cout << "Inside the Stage Constraints Destructor" << endl;
00779 #endif
00780 if (numberOfConstraints > 0 && con != NULL){
00781 for (int i = 0; i < numberOfConstraints; i++) {
00782 delete con[i];
00783 con[i] = NULL;
00784 }
00785 }
00786 if (con != NULL)
00787 delete [] con;
00788 con = NULL;
00789 }
00790
00791 TimeDomainStageObj::TimeDomainStageObj():
00792 idx(0)
00793 {
00794 #ifdef DEBUG
00795 cout << "Inside the Stage Objectives Obj Constructor" << endl;
00796 #endif
00797 }
00798
00799
00800 TimeDomainStageObj::~TimeDomainStageObj()
00801 {
00802 #ifdef DEBUG
00803 cout << "Inside the Stage Objectives Obj Destructor" << endl;
00804 #endif
00805 }
00806
00807
00808 TimeDomainStageObjectives::TimeDomainStageObjectives():
00809 numberOfObjectives(0),
00810 startIdx(-1)
00811 {
00812 #ifdef DEBUG
00813 cout << "Inside the Stage Objectives Constructor" << endl;
00814 #endif
00815 obj = NULL;
00816 }
00817
00818 TimeDomainStageObjectives::~TimeDomainStageObjectives()
00819 {
00820 #ifdef DEBUG
00821 cout << "Inside the Stage Objectives Destructor" << endl;
00822 #endif
00823 if (numberOfObjectives > 0 && obj != NULL){
00824 for (int i = 0; i < numberOfObjectives; i++) {
00825 delete obj[i];
00826 obj[i] = NULL;
00827 }
00828 }
00829 if (obj != NULL)
00830 delete [] obj;
00831 obj = NULL;
00832 }
00833
00834 TimeDomainStage::TimeDomainStage():
00835 name("")
00836 {
00837 #ifdef DEBUG
00838 cout << "Inside the Stage Constructor" << endl;
00839 #endif
00840 variables = NULL;
00841 constraints = NULL;
00842 objectives = NULL;
00843 }
00844
00845
00846 TimeDomainStage::~TimeDomainStage(){
00847 #ifdef DEBUG
00848 cout << "Inside the Stage Destructor" << endl;
00849 #endif
00850 if (variables != NULL)
00851 { delete variables;
00852 variables = NULL;
00853 }
00854 if (constraints != NULL)
00855 { delete constraints;
00856 constraints = NULL;
00857 }
00858 if (objectives != NULL)
00859 { delete objectives;
00860 objectives = NULL;
00861 }
00862 }
00863
00864
00865 TimeDomainStages::TimeDomainStages():
00866 numberOfStages(0),
00867 stage(NULL)
00868 {
00869 #ifdef DEBUG
00870 cout << "Inside the Stages Constructor" << endl;
00871 #endif
00872 }
00873
00874
00875 TimeDomainStages::~TimeDomainStages(){
00876 #ifdef DEBUG
00877 cout << "Inside the Stages Destructor" << endl;
00878 #endif
00879 int i;
00880 if(numberOfStages > 0 && stage != NULL){
00881 for( i = 0; i < numberOfStages; i++){
00882 delete stage[i];
00883 stage[i] = NULL;
00884 }
00885 }
00886 if (stage != NULL)
00887 delete[] stage;
00888 stage = NULL;
00889 }
00890
00891 TimeDomainInterval::TimeDomainInterval():
00892 start(0.0),
00893 horizon(0.0)
00894 {
00895 #ifdef DEBUG
00896 cout << "Inside the Interval Constructor" << endl;
00897 #endif
00898 }
00899
00900
00901 TimeDomainInterval::~TimeDomainInterval(){
00902 #ifdef DEBUG
00903 cout << "Inside the Interval Destructor" << endl;
00904 #endif
00905 }
00906
00907 TimeDomain::TimeDomain()
00908 {
00909 #ifdef DEBUG
00910 cout << "Inside the TimeDomain Constructor" << endl;
00911 #endif
00912 stages = NULL;
00913 interval = NULL;
00914 }
00915
00916 TimeDomain::~TimeDomain()
00917 {
00918 #ifdef DEBUG
00919 cout << "Inside the TimeDomain Destructor" << endl;
00920 #endif
00921 if (stages != NULL)
00922 { delete stages;
00923 stages = NULL;
00924 }
00925 if (interval != NULL)
00926 { delete interval;
00927 interval = NULL;
00928 }
00929 }
00930
00931
00932 InstanceData::InstanceData(){
00933 #ifdef DEBUG
00934 cout << "Inside the InstanceData Constructor" << endl;
00935 #endif
00936 variables = new Variables();
00937 objectives = new Objectives();
00938 constraints = new Constraints();
00939 linearConstraintCoefficients = new LinearConstraintCoefficients();
00940 quadraticCoefficients = new QuadraticCoefficients();
00941 nonlinearExpressions = new NonlinearExpressions();
00942 timeDomain = NULL;
00943 }
00944
00945 InstanceData::~InstanceData(){
00946 #ifdef DEBUG
00947 cout << "Inside the InstanceData Destructor" << endl;
00948 #endif
00949 if (variables != NULL)
00950 {
00951 delete variables;
00952 variables = NULL;
00953 }
00954
00955 if (objectives != NULL)
00956 {
00957 delete objectives;
00958 objectives = NULL;
00959 }
00960
00961 if (constraints != NULL)
00962 {
00963 delete constraints;
00964 constraints = NULL;
00965 }
00966
00967 if (linearConstraintCoefficients != NULL)
00968 {
00969 delete linearConstraintCoefficients;
00970 linearConstraintCoefficients = NULL;
00971 }
00972
00973 if (quadraticCoefficients != NULL)
00974 {
00975 delete quadraticCoefficients;
00976 quadraticCoefficients = NULL;
00977 }
00978
00979 if (nonlinearExpressions != NULL)
00980 {
00981 delete nonlinearExpressions;
00982 nonlinearExpressions = NULL;
00983 }
00984
00985 if (timeDomain != NULL)
00986 {
00987 delete timeDomain;
00988 timeDomain = NULL;
00989 }
00990 }
00991
00992 string OSInstance::getInstanceName(){
00993 if (m_sInstanceName.length() <= 0){
00994 if (instanceHeader == NULL)
00995 throw ErrorClass("instanceHeader object undefined in method getInstanceName()");
00996 m_sInstanceName = instanceHeader->name;
00997 }
00998 return m_sInstanceName;
00999 }
01000
01001 string OSInstance::getInstanceSource(){
01002 if (m_sInstanceSource.length() <= 0){
01003 if (instanceHeader == NULL)
01004 throw ErrorClass("instanceHeader object undefined in method getInstanceSource()");
01005 m_sInstanceSource = instanceHeader->source;
01006 }
01007 return m_sInstanceSource;
01008 }
01009
01010 string OSInstance::getInstanceDescription(){
01011 if (m_sInstanceDescription.length() <= 0){
01012 if (instanceHeader == NULL)
01013 throw ErrorClass("instanceHeader object undefined in method getInstanceDescription()");
01014 m_sInstanceDescription = instanceHeader->description;
01015 }
01016 return m_sInstanceDescription;
01017 }
01018
01019 int OSInstance::getVariableNumber(){
01020 if (m_iVariableNumber == -1){
01021 if (instanceData == NULL || instanceData->variables == NULL)
01022 throw ErrorClass("data object undefined in method getVariableNumber()");
01023 m_iVariableNumber = instanceData->variables->numberOfVariables;
01024 }
01025 return m_iVariableNumber;
01026 }
01027
01028 bool OSInstance::processVariables() {
01029 if(m_bProcessVariables == true && bVariablesModified == false) return true;
01030
01031 int i = 0;
01032 int varType;
01033 int n = getVariableNumber();
01034 try{
01035 m_iNumberOfBinaryVariables = 0;
01036 m_iNumberOfIntegerVariables = 0;
01037 m_iNumberOfStringVariables = 0;
01038 if(n > 0){
01039 if(m_bProcessVariables != true ){
01040 m_mcVariableTypes = new char[n];
01041 m_mdVariableLowerBounds = new double[n];
01042 m_mdVariableUpperBounds = new double[n];
01043 m_msVariableNames = new string[n];
01044 m_bProcessVariables = true;
01045 }
01046
01047 for(i = 0; i < n; i++){
01048 if(instanceData->variables->var[i] == NULL) throw ErrorClass("processVariables(): var element was never defined");
01049 varType = returnVarType(instanceData->variables->var[i]->type);
01050 switch (varType)
01051 {
01052 case 0:
01053 {
01054 throw ErrorClass("unknown variable type");
01055 break;
01056 }
01057 case ENUM_VARTYPE_CONTINUOUS:
01058 {
01059 break;
01060 }
01061 case ENUM_VARTYPE_BINARY:
01062 {
01063 m_iNumberOfBinaryVariables++;
01064 break;
01065 }
01066 case ENUM_VARTYPE_INTEGER:
01067 {
01068 m_iNumberOfIntegerVariables++;
01069 break;
01070 }
01071 case ENUM_VARTYPE_STRING:
01072 {
01073 m_iNumberOfStringVariables++;
01074 break;
01075 }
01076 case ENUM_VARTYPE_SEMICONTINUOUS:
01077 {
01078 m_iNumberOfSemiContinuousVariables++;
01079 break;
01080 }
01081 case ENUM_VARTYPE_SEMIINTEGER:
01082 {
01083 m_iNumberOfSemiIntegerVariables++;
01084 break;
01085 }
01086 default:
01087 {
01088 throw ErrorClass("variable type not yet implemented");
01089 break;
01090 }
01091 }
01092 m_mcVariableTypes[i] = instanceData->variables->var[i]->type;
01093 m_mdVariableLowerBounds[i] = instanceData->variables->var[i]->lb;
01094 m_mdVariableUpperBounds[i] = instanceData->variables->var[i]->ub;
01095 if(instanceData->variables->var[i]->name.length() > 0)
01096 m_msVariableNames[i] = instanceData->variables->var[i]->name;
01097 else
01098 m_msVariableNames[i] = "";
01099 }
01100 }
01101 return true;
01102 }
01103 catch(const ErrorClass& eclass){
01104 throw ErrorClass( eclass.errormsg);
01105 }
01106 }
01107
01108 string* OSInstance::getVariableNames() {
01109 processVariables();
01110 return m_msVariableNames;
01111 }
01112
01113 char* OSInstance::getVariableTypes() {
01114 processVariables();
01115 return m_mcVariableTypes;
01116 }
01117
01118 int OSInstance::getNumberOfBinaryVariables() {
01119 processVariables();
01120 return m_iNumberOfBinaryVariables;
01121 }
01122
01123 int OSInstance::getNumberOfIntegerVariables() {
01124 processVariables();
01125 return m_iNumberOfIntegerVariables;
01126 }
01127
01128 int OSInstance::getNumberOfSemiContinuousVariables() {
01129 processVariables();
01130 return m_iNumberOfSemiContinuousVariables;
01131 }
01132
01133 int OSInstance::getNumberOfSemiIntegerVariables() {
01134 processVariables();
01135 return m_iNumberOfSemiIntegerVariables;
01136 }
01137
01138 int OSInstance::getNumberOfStringVariables() {
01139 processVariables();
01140 return m_iNumberOfStringVariables;
01141 }
01142
01143 double* OSInstance::getVariableLowerBounds() {
01144 processVariables();
01145 return m_mdVariableLowerBounds;
01146 }
01147
01148 double* OSInstance::getVariableUpperBounds() {
01149 processVariables();
01150 return m_mdVariableUpperBounds;
01151 }
01152
01153
01154 int OSInstance::getObjectiveNumber(){
01155 if (m_iObjectiveNumber == -1){
01156 if (instanceData == NULL || instanceData->objectives == NULL)
01157 throw ErrorClass("data object undefined in method getObjectiveNumber()");
01158 m_iObjectiveNumber = instanceData->objectives->numberOfObjectives;
01159 }
01160 return m_iObjectiveNumber;
01161 }
01162
01163 bool OSInstance::processObjectives() {
01164 if(m_bProcessObjectives == true && bObjectivesModified == false) return true;
01165
01166 int i = 0;
01167 int j = 0;
01168 int n = getObjectiveNumber();
01169 if (n == 0 || instanceData->objectives->obj == NULL) return true;
01170 try{
01171 if (n > 0){
01172 if(m_bProcessObjectives != true){
01173 m_msMaxOrMins = new string[n];
01174 m_miNumberOfObjCoef = new int[n];
01175 m_mdObjectiveConstants = new double[n];
01176 m_mdObjectiveWeights = new double[n];
01177 m_mObjectiveCoefficients = new SparseVector*[n];
01178 m_msObjectiveNames = new string[n];
01179 for(i = 0; i < n; i++){
01180 if(instanceData->objectives->obj[i] == NULL) throw ErrorClass("processObjectives(): obj element was never defined");
01181 m_mObjectiveCoefficients[i] = new SparseVector(instanceData->objectives->obj[i]->numberOfObjCoef);
01182
01183 }
01184 m_bProcessObjectives = true;
01185 }
01186
01187 for(i = 0; i < n; i++){
01188 if(instanceData->objectives->obj[i] == NULL) throw ErrorClass("processObjectives(): obj element was never defined");
01189 if((instanceData->objectives->obj[i]->maxOrMin.compare("max") != 0) && (instanceData->objectives->obj[i]->maxOrMin.compare("min") != 0 )) throw ErrorClass("wrong objective maxOrMin");
01190 m_msMaxOrMins[i] = instanceData->objectives->obj[i]->maxOrMin;
01191 m_miNumberOfObjCoef[i] = instanceData->objectives->obj[i]->numberOfObjCoef;
01192 m_mdObjectiveConstants[i] = instanceData->objectives->obj[i]->constant;
01193 m_mdObjectiveWeights[i] = instanceData->objectives->obj[i]->weight;
01194 if(instanceData->objectives->obj[i]->coef == NULL && m_miNumberOfObjCoef[i] != 0){
01195 throw ErrorClass("objective coefficient number inconsistent with objective coefficient array");
01196 }
01197 if(instanceData->objectives->obj[i]->coef != NULL){
01198 for(j = 0; j < m_mObjectiveCoefficients[i]->number; j++){
01199 m_mObjectiveCoefficients[i]->indexes[j] = instanceData->objectives->obj[i]->coef[j]->idx;
01200 m_mObjectiveCoefficients[i]->values[j] = instanceData->objectives->obj[i]->coef[j]->value;
01201 }
01202 }
01203 if(instanceData->objectives->obj[i]->name.length() > 0)
01204 m_msObjectiveNames[i] = instanceData->objectives->obj[i]->name;
01205 else
01206 m_msObjectiveNames[i] = "";
01207 }
01208 }
01209 return true;
01210 }
01211 catch(const ErrorClass& eclass){
01212 throw ErrorClass( eclass.errormsg);
01213 }
01214 }
01215
01216 string* OSInstance::getObjectiveNames() {
01217 processObjectives();
01218 return m_msObjectiveNames;
01219 }
01220
01221 string* OSInstance::getObjectiveMaxOrMins() {
01222 processObjectives();
01223 return m_msMaxOrMins;
01224 }
01225
01226 int* OSInstance::getObjectiveCoefficientNumbers(){
01227 processObjectives();
01228 return m_miNumberOfObjCoef;
01229 }
01230
01231 double* OSInstance::getObjectiveConstants() {
01232 processObjectives();
01233 return m_mdObjectiveConstants;
01234 }
01235
01236 double* OSInstance::getObjectiveWeights() {
01237 processObjectives();
01238 return m_mdObjectiveWeights;
01239 }
01240
01241 SparseVector** OSInstance::getObjectiveCoefficients() {
01242 processObjectives();
01243 return m_mObjectiveCoefficients;
01244 }
01245
01246
01247 double** OSInstance::getDenseObjectiveCoefficients() {
01248 if(m_bGetDenseObjectives == true && bObjectivesModified == false) return m_mmdDenseObjectiveCoefficients;
01249 int i, j, numobjcoef;
01250 SparseVector *sparsevec;
01251 int m = getObjectiveNumber();
01252 int n = getVariableNumber();
01253 if (m == 0 || instanceData->objectives->obj == NULL) return NULL;
01254 if (m_bGetDenseObjectives != true){
01255 m_mmdDenseObjectiveCoefficients = new double*[m];
01256 for(i = 0; i < m; i++){
01257 m_mmdDenseObjectiveCoefficients[ i] = new double[n];
01258 }
01259 m_bGetDenseObjectives = true;
01260 }
01261
01262 for(i = 0; i < m; i++){
01263 sparsevec = this->getObjectiveCoefficients()[i];
01264 for(j = 0; j < n; j++){
01265 m_mmdDenseObjectiveCoefficients[ i][j] = 0.0;
01266 }
01267 sparsevec = this->getObjectiveCoefficients()[i];
01268 numobjcoef = sparsevec->number;
01269 for(j = 0; j < numobjcoef; j++){
01270 m_mmdDenseObjectiveCoefficients[i][ sparsevec->indexes[ j]]
01271 = sparsevec->values[ j];
01272 }
01273 }
01274 return m_mmdDenseObjectiveCoefficients;
01275 }
01276
01277
01278 int OSInstance::getConstraintNumber(){
01279 if (m_iConstraintNumber == -1){
01280 if (instanceData == NULL || instanceData->constraints == NULL)
01281 throw ErrorClass("data object undefined in method getConstraintNumber()");
01282 m_iConstraintNumber = instanceData->constraints->numberOfConstraints;
01283 }
01284 return m_iConstraintNumber;
01285 }
01286
01287 bool OSInstance::processConstraints() {
01288 if(m_bProcessConstraints == true && bConstraintsModified == false) return true;
01289
01290 int i = 0;
01291 ostringstream outStr;
01292 int n = getConstraintNumber();
01293 if (n == 0 || instanceData->constraints->con == NULL) return true;
01294 try{
01295 if(n > 0){
01296 if(m_bProcessConstraints != true){
01297 m_mdConstraintLowerBounds = new double[n];
01298 m_mdConstraintUpperBounds = new double[n];
01299 m_mdConstraintConstants = new double[n];
01300 m_mcConstraintTypes = new char[n];
01301 m_msConstraintNames = new string[n];
01302 m_bProcessConstraints = true;
01303 }
01304 for(i = 0; i < n; i++){
01305 if(instanceData->constraints->con[i] == NULL) throw ErrorClass("processConstraints(): con element was never defined");
01306 m_mdConstraintLowerBounds[i] = instanceData->constraints->con[i]->lb;
01307 m_mdConstraintUpperBounds[i] = instanceData->constraints->con[i]->ub;
01308 m_mdConstraintConstants[i] = instanceData->constraints->con[i]->constant;
01309 if(m_mdConstraintLowerBounds[i] == OSDBL_MAX || m_mdConstraintUpperBounds[i] == -OSDBL_MAX) {
01310 outStr << "Constraint " ;
01311 outStr << i;
01312 outStr << " is infeasible";
01313 throw ErrorClass( outStr.str() );
01314 }
01315 else if(m_mdConstraintLowerBounds[i] > m_mdConstraintUpperBounds[i]) {
01316 outStr << "Constraint " ;
01317 outStr << i;
01318 outStr << " is infeasible";
01319 throw ErrorClass( outStr.str());
01320 }
01321 else if(m_mdConstraintLowerBounds[i] == -OSDBL_MAX && m_mdConstraintUpperBounds[i] == OSDBL_MAX)
01322 m_mcConstraintTypes[i] = 'U';
01323 else if(m_mdConstraintLowerBounds[i] == m_mdConstraintUpperBounds[i])
01324 m_mcConstraintTypes[i] = 'E';
01325 else if(m_mdConstraintLowerBounds[i] == -OSDBL_MAX)
01326 m_mcConstraintTypes[i] = 'L';
01327 else if(m_mdConstraintUpperBounds[i] == OSDBL_MAX)
01328 m_mcConstraintTypes[i] = 'G';
01329 else m_mcConstraintTypes[i] = 'R';
01330 if(instanceData->constraints->con[i]->name.length() > 0)
01331 m_msConstraintNames[i] = instanceData->constraints->con[i]->name;
01332 else
01333 m_msConstraintNames[i] = "";
01334 }
01335 }
01336 return true;
01337 }
01338 catch(const ErrorClass& eclass){
01339 throw ErrorClass( eclass.errormsg);
01340 }
01341 }
01342
01343
01344 string* OSInstance::getConstraintNames() {
01345 processConstraints();
01346 return m_msConstraintNames;
01347 }
01348
01349
01350 double* OSInstance::getConstraintLowerBounds() {
01351 processConstraints();
01352 return m_mdConstraintLowerBounds;
01353 }
01354
01355 char* OSInstance::getConstraintTypes() {
01356 processConstraints();
01357 return m_mcConstraintTypes;
01358 }
01359
01360 double* OSInstance::getConstraintUpperBounds() {
01361 processConstraints();
01362 return m_mdConstraintUpperBounds;
01363 }
01364
01365
01366 int OSInstance::getLinearConstraintCoefficientNumber(){
01367 if(this->getVariableNumber() <= 0 || this->getConstraintNumber() <= 0) return 0;
01368 if(m_iLinearConstraintCoefficientNumber == -1){
01369 if (instanceData == NULL || instanceData->linearConstraintCoefficients == NULL)
01370 throw ErrorClass("data object undefined in method getLinearConstraintCoefficientNumber()");
01371 m_iLinearConstraintCoefficientNumber = instanceData->linearConstraintCoefficients->numberOfValues;
01372 }
01373 return m_iLinearConstraintCoefficientNumber;
01374 }
01375
01376 bool OSInstance::processLinearConstraintCoefficients() {
01377 if(m_bProcessLinearConstraintCoefficients == true && bAMatrixModified == false) return true;
01378
01379 try{
01380 int n = getLinearConstraintCoefficientNumber();
01381 if((instanceData->linearConstraintCoefficients == NULL ) || (n == 0) ) return true;
01382
01383 if((instanceData->linearConstraintCoefficients->value == NULL ) || (n == 0) ) return true;
01384
01385 if((instanceData->linearConstraintCoefficients->colIdx != NULL && instanceData->linearConstraintCoefficients->colIdx->el != NULL)
01386 && (instanceData->linearConstraintCoefficients->rowIdx != NULL && instanceData->linearConstraintCoefficients->rowIdx->el != NULL))
01387 throw ErrorClass("ambiguous linear constraint coefficient major");
01388 else if(instanceData->linearConstraintCoefficients->value->el == NULL) return true;
01389 else{
01390 if(instanceData->linearConstraintCoefficients->rowIdx->el != NULL){
01391 m_bColumnMajor = true;
01392 if(m_bProcessLinearConstraintCoefficients != true){
01393 m_linearConstraintCoefficientsInColumnMajor = new SparseMatrix();
01394 m_linearConstraintCoefficientsInColumnMajor->bDeleteArrays = false;
01395 m_bProcessLinearConstraintCoefficients = true;
01396 }
01397 m_linearConstraintCoefficientsInColumnMajor->isColumnMajor = true;
01398 m_linearConstraintCoefficientsInColumnMajor->valueSize = n;
01399 m_linearConstraintCoefficientsInColumnMajor->startSize = instanceData->variables->numberOfVariables + 1;
01400 }
01401 else{
01402 m_bColumnMajor = false;
01403 if(m_bProcessLinearConstraintCoefficients != true){
01404 m_linearConstraintCoefficientsInRowMajor = new SparseMatrix();
01405 m_linearConstraintCoefficientsInRowMajor->bDeleteArrays = false;
01406 m_bProcessLinearConstraintCoefficients = true;
01407 }
01408 m_linearConstraintCoefficientsInRowMajor->isColumnMajor = false;
01409 m_linearConstraintCoefficientsInRowMajor->valueSize = n;
01410 m_linearConstraintCoefficientsInRowMajor->startSize = instanceData->constraints->numberOfConstraints + 1;
01411 }
01412 }
01413 if(m_bColumnMajor == true){
01414 m_linearConstraintCoefficientsInColumnMajor->values = instanceData->linearConstraintCoefficients->value->el;
01415 m_linearConstraintCoefficientsInColumnMajor->indexes = instanceData->linearConstraintCoefficients->rowIdx->el;
01416 m_linearConstraintCoefficientsInColumnMajor->starts = instanceData->linearConstraintCoefficients->start->el;
01417 }
01418 else{
01419 m_linearConstraintCoefficientsInRowMajor->values = instanceData->linearConstraintCoefficients->value->el;
01420 m_linearConstraintCoefficientsInRowMajor->indexes = instanceData->linearConstraintCoefficients->colIdx->el;
01421 m_linearConstraintCoefficientsInRowMajor->starts = instanceData->linearConstraintCoefficients->start->el;
01422 }
01423 return true;
01424 }
01425 catch(const ErrorClass& eclass){
01426 throw ErrorClass( eclass.errormsg);
01427 }
01428 }
01429
01430 bool OSInstance::getLinearConstraintCoefficientMajor() {
01431 processLinearConstraintCoefficients();
01432 return m_bColumnMajor;
01433 }
01434
01435 SparseMatrix* OSInstance::getLinearConstraintCoefficientsInColumnMajor() {
01436 processLinearConstraintCoefficients();
01437 if(getVariableNumber() == 0) return NULL;
01438 if(m_linearConstraintCoefficientsInColumnMajor != NULL) return m_linearConstraintCoefficientsInColumnMajor;
01439 if(!m_bColumnMajor){
01440 if(m_linearConstraintCoefficientsInRowMajor == NULL) return NULL;
01441 m_linearConstraintCoefficientsInColumnMajor =
01442 MathUtil::convertLinearConstraintCoefficientMatrixToTheOtherMajor(false,
01443 m_linearConstraintCoefficientsInRowMajor->startSize,
01444 m_linearConstraintCoefficientsInRowMajor->valueSize,
01445 m_linearConstraintCoefficientsInRowMajor->starts,
01446 m_linearConstraintCoefficientsInRowMajor->indexes,
01447 m_linearConstraintCoefficientsInRowMajor->values,
01448 getVariableNumber());
01449 }
01450 return m_linearConstraintCoefficientsInColumnMajor;
01451 }
01452
01453 SparseMatrix* OSInstance::getLinearConstraintCoefficientsInRowMajor() {
01454 processLinearConstraintCoefficients();
01455 if(m_linearConstraintCoefficientsInRowMajor != NULL) return m_linearConstraintCoefficientsInRowMajor;
01456 if(m_bColumnMajor){
01457 if(m_linearConstraintCoefficientsInColumnMajor == NULL) return NULL;
01458 m_linearConstraintCoefficientsInRowMajor =
01459 MathUtil::convertLinearConstraintCoefficientMatrixToTheOtherMajor(true,
01460 m_linearConstraintCoefficientsInColumnMajor->startSize,
01461 m_linearConstraintCoefficientsInColumnMajor->valueSize,
01462 m_linearConstraintCoefficientsInColumnMajor->starts,
01463 m_linearConstraintCoefficientsInColumnMajor->indexes,
01464 m_linearConstraintCoefficientsInColumnMajor->values,
01465 getConstraintNumber());
01466 }
01467 return m_linearConstraintCoefficientsInRowMajor;
01468 }
01469
01470
01471 int OSInstance::getNumberOfQuadraticTerms(){
01472 if(m_iQuadraticTermNumber == -1){
01473 if (instanceData == NULL || instanceData->quadraticCoefficients == NULL)
01474 throw ErrorClass("data object undefined in method getNumberOfQuadraticTerms()");
01475 m_iQuadraticTermNumber = instanceData->quadraticCoefficients->numberOfQuadraticTerms;
01476 }
01477 return m_iQuadraticTermNumber;
01478 }
01479
01480 QuadraticTerms* OSInstance::getQuadraticTerms() {
01481 if(m_bProcessQuadraticTerms) return m_quadraticTerms;
01482 m_bProcessQuadraticTerms = true;
01483 int n = getNumberOfQuadraticTerms();
01484 if(instanceData->quadraticCoefficients->qTerm == NULL) return NULL;
01485 try{
01486 int i = 0;
01487 QuadraticCoefficients* quadraticCoefs = instanceData->quadraticCoefficients;
01488 if(!quadraticCoefs->qTerm && n != 0)
01489 throw ErrorClass("quadratic term number inconsistent with quadratic term array");
01490 m_quadraticTerms = new QuadraticTerms();
01491 if(n > 0){
01492 m_quadraticTerms->rowIndexes = new int[n];
01493 m_quadraticTerms->varOneIndexes = new int[n];
01494 m_quadraticTerms->varTwoIndexes = new int[n];
01495 m_quadraticTerms->coefficients = new double[n];
01496 }
01497 for(i = 0; i < n; i++){
01498 m_quadraticTerms->rowIndexes[i] = quadraticCoefs->qTerm[i]->idx;
01499 m_quadraticTerms->varOneIndexes[i] = quadraticCoefs->qTerm[i]->idxOne;
01500 m_quadraticTerms->varTwoIndexes[i] = quadraticCoefs->qTerm[i]->idxTwo;
01501 m_quadraticTerms->coefficients[i] = quadraticCoefs->qTerm[i]->coef;
01502 }
01503 return m_quadraticTerms;
01504 }
01505 catch(const ErrorClass& eclass){
01506 throw ErrorClass( eclass.errormsg);
01507 }
01508 }
01509
01510 int OSInstance::getNumberOfQuadraticRowIndexes() {
01511 if(m_bQuadraticRowIndexesProcessed == false) getQuadraticRowIndexes();
01512 return m_iNumberOfQuadraticRowIndexes;
01513 }
01514
01515 int* OSInstance::getQuadraticRowIndexes() {
01516 if(m_bQuadraticRowIndexesProcessed == true) return m_miQuadRowIndexes;
01517 m_bQuadraticRowIndexesProcessed = true;
01518 int n = getNumberOfQuadraticTerms();
01519 if(n <= 0) return NULL;
01520 QuadraticTerms *qTerms = NULL;
01521 qTerms = getQuadraticTerms();
01522 std::map<int, int> foundIdx;
01523 std::map<int, int>::iterator pos;
01524 int i;
01525 try{
01526 for(i = 0; i < n; i++){
01527
01528 foundIdx[ qTerms->rowIndexes[ i] ];
01529 }
01530
01531 m_iNumberOfQuadraticRowIndexes = foundIdx.size();
01532 m_miQuadRowIndexes = new int[ m_iNumberOfQuadraticRowIndexes ] ;
01533 i = 0;
01534 for(pos = foundIdx.begin(); pos != foundIdx.end(); ++pos){
01535 m_miQuadRowIndexes[ i++] = pos->first;
01536 }
01537 foundIdx.clear();
01538 return m_miQuadRowIndexes;
01539 }
01540 catch(const ErrorClass& eclass){
01541 throw ErrorClass( eclass.errormsg);
01542 }
01543 }
01544
01545
01546 int OSInstance::getNumberOfNonlinearExpressions(){
01547 if(m_iNonlinearExpressionNumber == -1){
01548 if (instanceData == NULL || instanceData->nonlinearExpressions == NULL)
01549 throw ErrorClass("data object undefined in method getNumberOfNonlinearExpressions()");
01550 m_iNonlinearExpressionNumber = instanceData->nonlinearExpressions->numberOfNonlinearExpressions;
01551 }
01552 return m_iNonlinearExpressionNumber;
01553 }
01554
01555 int OSInstance::getNumberOfNonlinearExpressionTreeIndexes() {
01556 if(m_bNonlinearExpressionTreeIndexesProcessed == false) getNonlinearExpressionTreeIndexes();
01557 return m_iNumberOfNonlinearExpressionTreeIndexes;
01558 }
01559
01560 int* OSInstance::getNonlinearExpressionTreeIndexes(){
01561 if(m_bNonlinearExpressionTreeIndexesProcessed == true) return m_miNonlinearExpressionTreeIndexes;
01562 m_bNonlinearExpressionTreeIndexesProcessed = true;
01563 std::map<int, OSExpressionTree*> expTrees;
01564 expTrees = getAllNonlinearExpressionTrees();
01565 std::map<int, OSExpressionTree*>::iterator pos;
01566 try{
01567
01568 m_iNumberOfNonlinearExpressionTreeIndexes = expTrees.size();
01569 m_miNonlinearExpressionTreeIndexes = new int[ m_iNumberOfNonlinearExpressionTreeIndexes ] ;
01570 int i = 0;
01571 for(pos = expTrees.begin(); pos != expTrees.end(); ++pos){
01572 m_miNonlinearExpressionTreeIndexes[ i++] = pos->first;
01573 }
01574 expTrees.clear();
01575 return m_miNonlinearExpressionTreeIndexes;
01576 }
01577 catch(const ErrorClass& eclass){
01578 throw ErrorClass( eclass.errormsg);
01579 }
01580 }
01581
01582 int OSInstance::getNumberOfNonlinearExpressionTreeModIndexes() {
01583 if(m_bNonlinearExpressionTreeModIndexesProcessed == false) getNonlinearExpressionTreeModIndexes();
01584 return m_iNumberOfNonlinearExpressionTreeModIndexes;
01585 }
01586
01587 int* OSInstance::getNonlinearExpressionTreeModIndexes(){
01588 if(m_bNonlinearExpressionTreeModIndexesProcessed == true) return m_miNonlinearExpressionTreeModIndexes;
01589 m_bNonlinearExpressionTreeModIndexesProcessed = true;
01590 std::map<int, OSExpressionTree*> expTrees;
01591 expTrees = getAllNonlinearExpressionTreesMod();
01592 std::map<int, OSExpressionTree*>::iterator pos;
01593 try{
01594
01595 m_iNumberOfNonlinearExpressionTreeModIndexes = expTrees.size();
01596 m_miNonlinearExpressionTreeModIndexes = new int[ m_iNumberOfNonlinearExpressionTreeModIndexes ] ;
01597 int i = 0;
01598 for(pos = expTrees.begin(); pos != expTrees.end(); ++pos){
01599 m_miNonlinearExpressionTreeModIndexes[ i++] = pos->first;
01600 }
01601 expTrees.clear();
01602 return m_miNonlinearExpressionTreeModIndexes;
01603 }
01604 catch(const ErrorClass& eclass){
01605 throw ErrorClass( eclass.errormsg);
01606 }
01607 }
01608
01609 int OSInstance::getNumberOfNonlinearConstraints(){
01610 if( m_bProcessExpressionTrees == false )
01611 getAllNonlinearExpressionTrees();
01612 return m_iConstraintNumberNonlinear;
01613 }
01614
01615 int OSInstance::getNumberOfNonlinearObjectives(){
01616 if( m_bProcessExpressionTrees == false )
01617 getAllNonlinearExpressionTrees();
01618 return m_iObjectiveNumberNonlinear;
01619 }
01620
01621 OSExpressionTree* OSInstance::getNonlinearExpressionTree(int rowIdx){
01622 if( m_bProcessExpressionTrees == false ){
01623 getAllNonlinearExpressionTrees();
01624 }
01625 if( m_mapExpressionTrees.find( rowIdx) != m_mapExpressionTrees.end()) return m_mapExpressionTrees[ rowIdx];
01626 else return NULL ;
01627
01629
01631
01632
01633
01634
01635 }
01636
01637 OSExpressionTree* OSInstance::getNonlinearExpressionTreeMod(int rowIdx){
01638 if( m_bProcessExpressionTreesMod == false ){
01639 getAllNonlinearExpressionTreesMod();
01640 }
01641 if( m_mapExpressionTreesMod.find( rowIdx) != m_mapExpressionTreesMod.end()) return m_mapExpressionTreesMod[ rowIdx];
01642 else return NULL ;
01643
01645
01647
01648
01649
01650
01651 }
01652
01653 std::vector<OSnLNode*> OSInstance::getNonlinearExpressionTreeInPostfix( int rowIdx){
01654
01655 if( m_bProcessExpressionTrees == false ) getAllNonlinearExpressionTrees();
01656 std::vector<OSnLNode*> postfixVec;
01657 try{
01658 if( m_mapExpressionTrees.find( rowIdx) != m_mapExpressionTrees.end()){
01659 OSExpressionTree* expTree = getNonlinearExpressionTree( rowIdx);
01660 postfixVec = expTree->m_treeRoot->getPostfixFromExpressionTree();
01661 }
01662 else{
01663 throw ErrorClass("Error in getNonlinearExpressionTreeInPostfix, rowIdx not valid");
01664 }
01665 return postfixVec;
01666 }
01667 catch(const ErrorClass& eclass){
01668 throw ErrorClass( eclass.errormsg);
01669 }
01670 }
01671
01672 std::string OSInstance::getNonlinearExpressionTreeInInfix( int rowIdx_){
01673 if( m_binitForAlgDiff == false) this->initForAlgDiff();
01674 if( m_bProcessExpressionTrees == false ) getAllNonlinearExpressionTrees();
01675 std::string resultString;
01676 resultString = "";
01677 unsigned int i;
01678 unsigned int j;
01679 unsigned int n;
01680 ostringstream outStr;
01681 std::vector<OSnLNode*> postfixVec;
01682 int rowIdx = rowIdx_;
01683 OSnLNode *nlnode = NULL ;
01684 OSnLNodeNumber *nlnodeNum = NULL;
01685 OSnLNodeVariable *nlnodeVar = NULL;
01686 OSnLNodeSum *nlnodeSum = NULL;
01687 OSnLNodeProduct *nlnodeProduct = NULL;
01688 OSnLNodeMin *nlnodeMin = NULL;
01689 OSnLNodeMax *nlnodeMax = NULL;
01690 std::string tmp1 = "";
01691 std::string tmp2 = "";
01692 std::string tmp3 = "";
01693 std::stack<OSnLNode*> opStack;
01694 std::stack<std::string> tmpStack;
01695 std::stack<std::string> sumStack;
01696 std::stack<std::string> productStack;
01697 std::stack<std::string> minStack;
01698 std::stack<std::string> maxStack;
01699
01700 try{
01701 if( m_mapExpressionTrees.find( rowIdx) != m_mapExpressionTrees.end()){
01702
01703
01704
01705 OSExpressionTree* exptree = this->getNonlinearExpressionTree( rowIdx);
01706 if(exptree != NULL) {
01707 postfixVec = this->getNonlinearExpressionTreeInPostfix( rowIdx);
01708 n = postfixVec.size();
01709
01710 for (i = 0 ; i < n; i++){
01711 nlnode = postfixVec[ n - 1 - i];
01712 opStack.push( nlnode);
01713
01714 }
01715
01716 #if 0
01717 std::cout << std::endl << std::endl << std::endl << std::endl;
01718 n = opStack.size();
01719 for(i = 0; i < n; i++){
01720 std::cout << opStack.top()->getTokenName() << std::endl;
01721 }
01722
01723 #endif
01724 n = opStack.size();
01725 for(i = 0; i < n; i++){
01726
01727 nlnode = opStack.top();
01728
01729 switch (nlnode->inodeInt) {
01730 case OS_NUMBER:
01731 nlnodeNum = (OSnLNodeNumber*)nlnode;
01732 tmpStack.push( os_dtoa_format(nlnodeNum->value) );
01733 break;
01734
01735 case OS_PI:
01736 tmpStack.push( "PI" );
01737 break;
01738
01739 case OS_E:
01740 tmpStack.push( "E" );
01741 break;
01742
01743 case OS_VARIABLE:
01744 outStr.str("");
01745
01746 nlnodeVar = (OSnLNodeVariable*)nlnode;
01747
01748 if( (nlnodeVar->coef > 1.0) || (nlnodeVar->coef < 1.0) ){
01749 outStr << "(";
01750 outStr << os_dtoa_format(nlnodeVar->coef);
01751 outStr << "*x_";
01752 outStr << nlnodeVar->idx;
01753 outStr << ")";
01754 tmpStack.push(outStr.str() );
01755
01756 }else{
01757 outStr << "x_";
01758 outStr << nlnodeVar->idx;
01759 tmpStack.push(outStr.str() );
01760
01761 }
01762 break;
01763
01764 case OS_PLUS :
01765 if( tmpStack.size() < nlnode->inumberOfChildren) throw ErrorClass("There is an error in the OSExpression Tree -- Problem writing plus operater");
01766 tmp1 = tmpStack.top();
01767 tmpStack.pop();
01768 tmp2 = tmpStack.top();
01769 tmpStack.pop();
01770 tmpStack.push("(" + tmp2 + " + " + tmp1 + ")");
01771 break;
01772
01773 case OS_SUM :
01774 if( tmpStack.size() < nlnode->inumberOfChildren) throw ErrorClass("There is an error in the OSExpression Tree -- Problem writing sum operater");
01775
01776 nlnodeSum = (OSnLNodeSum*)nlnode;
01777 outStr.str("");
01778 for(j = 0; j < nlnodeSum->inumberOfChildren; j++){
01779 sumStack.push( tmpStack.top() );
01780 tmpStack.pop();
01781 }
01782 outStr << "(";
01783 for(j = 0; j < nlnodeSum->inumberOfChildren; j++){
01784 outStr << sumStack.top();
01785 if (j < nlnodeSum->inumberOfChildren - 1) outStr << " + ";
01786 sumStack.pop();
01787 }
01788 outStr << ")";
01789 tmpStack.push( outStr.str() );
01790
01791 break;
01792
01793 case OS_MINUS :
01794 if( tmpStack.size() < nlnode->inumberOfChildren) throw ErrorClass("There is an error in the OSExpression Tree -- Problem writing minus operater");
01795 tmp1 = tmpStack.top();
01796 tmpStack.pop();
01797 tmp2 = tmpStack.top();
01798 tmpStack.pop();
01799 tmpStack.push("(" + tmp2 + " - " + tmp1 + ")");
01800 break;
01801
01802 case OS_NEGATE :
01803 if( tmpStack.size() < nlnode->inumberOfChildren) throw ErrorClass("There is an error in the OSExpression Tree -- -- Problem writing negate operater");
01804 tmp1 = tmpStack.top();
01805 tmpStack.pop();
01806 tmpStack.push( "-"+ tmp1 );
01807 break;
01808
01809 case OS_TIMES :
01810 if( tmpStack.size() < nlnode->inumberOfChildren) throw ErrorClass("There is an error in the OSExpression Tree -- Problem writing times operater");
01811 tmp1 = tmpStack.top();
01812 tmpStack.pop();
01813 tmp2 = tmpStack.top();
01814 tmpStack.pop();
01815 tmpStack.push("(" + tmp2 + "*" + tmp1 + ")");
01816 break;
01817
01818 case OS_DIVIDE :
01819 if( tmpStack.size() < nlnode->inumberOfChildren) throw ErrorClass("There is an error in the OSExpression Tree -- Problem writing divide operater");
01820 tmp1 = tmpStack.top();
01821 tmpStack.pop();
01822 tmp2 = tmpStack.top();
01823 tmpStack.pop();
01824 tmpStack.push("(" + tmp2 + " / " + tmp1 + ")");
01825 break;
01826
01827 case OS_POWER :
01828 if( tmpStack.size() < nlnode->inumberOfChildren) throw ErrorClass("There is an error in the OSExpression Tree -- Problem writing power operater");
01829 tmp1 = tmpStack.top();
01830 tmpStack.pop();
01831 tmp2 = tmpStack.top();
01832 tmpStack.pop();
01833 tmpStack.push("(" + tmp2 + " ^ " + tmp1 + ")");
01834 break;
01835
01836 case OS_ABS :
01837 if( tmpStack.size() < nlnode->inumberOfChildren) throw ErrorClass("There is an error in the OSExpression Tree -- Problem writing abs operater");
01838 tmp1 = tmpStack.top();
01839 tmpStack.pop();
01840 tmpStack.push( "abs( "+ tmp1 + ")");
01841 break;
01842
01843 case OS_ERF :
01844 if( tmpStack.size() < nlnode->inumberOfChildren) throw ErrorClass("There is an error in the OSExpression Tree -- Problem writing erf operater");
01845 tmp1 = tmpStack.top();
01846 tmpStack.pop();
01847 tmpStack.push( "erf( "+ tmp1 + ")");
01848 break;
01849
01850
01851 case OS_SQUARE :
01852 if( tmpStack.size() < nlnode->inumberOfChildren) throw ErrorClass("There is an error in the OSExpression Tree -- Problem writing square operater ");
01853 tmp1 = tmpStack.top();
01854 tmpStack.pop();
01855 tmpStack.push( "("+ tmp1 + ")^2");
01856 break;
01857
01858 case OS_LN :
01859 if( tmpStack.size() < nlnode->inumberOfChildren) throw ErrorClass("There is an error in the OSExpression Tree -- Problem writing ln operater");
01860 tmp1 = tmpStack.top();
01861 tmpStack.pop();
01862 tmpStack.push( "ln( "+ tmp1 + ")");
01863 break;
01864
01865 case OS_EXP :
01866 if( tmpStack.size() < nlnode->inumberOfChildren) throw ErrorClass("There is an error in the OSExpression Tree -- Problem writing exp operater");
01867 tmp1 = tmpStack.top();
01868 tmpStack.pop();
01869 tmpStack.push( "exp( "+ tmp1 + ")");
01870 break;
01871
01872 case OS_SIN :
01873 if( tmpStack.size() < nlnode->inumberOfChildren) throw ErrorClass("There is an error in the OSExpression Tree -- Problem writing sin operater");
01874 tmp1 = tmpStack.top();
01875 tmpStack.pop();
01876 tmpStack.push( "sin( "+ tmp1 + ")");
01877 break;
01878
01879 case OS_COS :
01880 if( tmpStack.size() < nlnode->inumberOfChildren) throw ErrorClass("There is an error in the OSExpression Tree -- Problem writing cos operater ");
01881 tmp1 = tmpStack.top();
01882 tmpStack.pop();
01883 tmpStack.push( "cos( "+ tmp1 + ")");
01884 break;
01885
01886 case OS_SQRT :
01887 if( tmpStack.size() < nlnode->inumberOfChildren) throw ErrorClass("There is an error in the OSExpression Tree -- Problem writing cos operater ");
01888 tmp1 = tmpStack.top();
01889 tmpStack.pop();
01890 tmpStack.push( "sqrt( "+ tmp1 + ")");
01891 break;
01892
01893 case OS_MIN :
01894 if( tmpStack.size() < nlnode->inumberOfChildren) throw ErrorClass("There is an error in the OSExpression Tree -- Problem writing min operater");
01895
01896 nlnodeMin = (OSnLNodeMin*)nlnode;
01897 outStr.str("");
01898 for(j = 0; j < nlnodeMin->inumberOfChildren; j++){
01899 minStack.push( tmpStack.top() );
01900 tmpStack.pop();
01901 }
01902 outStr << "min(";
01903 for(j = 0; j < nlnodeMin->inumberOfChildren; j++){
01904 outStr << minStack.top();
01905 if (j < nlnodeMin->inumberOfChildren - 1) outStr << " , ";
01906 minStack.pop();
01907 }
01908 outStr << ")";
01909 tmpStack.push( outStr.str() );
01910 break;
01911
01912 case OS_MAX :
01913 if( tmpStack.size() < nlnode->inumberOfChildren) throw ErrorClass("There is an error in the OSExpression Tree -- Problem writing max operater");
01914
01915 nlnodeMax = (OSnLNodeMax*)nlnode;
01916 outStr.str("");
01917 for(j = 0; j < nlnodeMax->inumberOfChildren; j++){
01918 maxStack.push( tmpStack.top() );
01919 tmpStack.pop();
01920 }
01921 outStr << "max(";
01922 for(j = 0; j < nlnodeMax->inumberOfChildren; j++){
01923 outStr << maxStack.top();
01924 if (j < nlnodeMax->inumberOfChildren - 1) outStr << " , ";
01925 maxStack.pop();
01926 }
01927 outStr << ")";
01928 tmpStack.push( outStr.str() );
01929 break;
01930
01931 case OS_IF :
01932
01933 if( tmpStack.size() < nlnode->inumberOfChildren) throw ErrorClass("There is an error in the OSExpression Tree -- Problem writing if operater ");
01934 if(nlnode->inumberOfChildren != 3)throw ErrorClass("The if node must have three children");
01935 tmp1 = tmpStack.top();
01936 tmpStack.pop();
01937 tmp2 = tmpStack.top();
01938 tmpStack.pop();
01939 tmp3 = tmpStack.top();
01940 tmpStack.pop();
01941 tmpStack.push( "if(" + tmp3 + "," + tmp2 + "," + tmp1 +")" );
01942 break;
01943
01944 case OS_PRODUCT :
01945 if( tmpStack.size() < nlnode->inumberOfChildren) throw ErrorClass("There is an error in the OSExpression Tree -- Problem writing product operater");
01946
01947 nlnodeProduct = (OSnLNodeProduct*)nlnode;
01948 outStr.str("");
01949 for(j = 0; j < nlnodeProduct->inumberOfChildren; j++){
01950 productStack.push( tmpStack.top() );
01951 tmpStack.pop();
01952 }
01953 outStr << "(";
01954 for(j = 0; j < nlnodeProduct->inumberOfChildren; j++){
01955 outStr << productStack.top();
01956 if (j < nlnodeProduct->inumberOfChildren - 1) outStr << " * ";
01957 productStack.pop();
01958 }
01959 outStr << ")";
01960 tmpStack.push( outStr.str() );
01961
01962 break;
01963
01964 default:
01965 throw ErrorClass("operator " + nlnode->getTokenName() + " not supported");
01966 break;
01967 }
01968 opStack.pop();
01969 }
01970 postfixVec.clear();
01971 if(tmpStack.size() != 1) throw ErrorClass( "There is an error in the OSExpression Tree -- stack size should be 1 at end");
01972 resultString = tmpStack.top();
01973
01974 tmpStack.pop();
01975
01976 return resultString;
01977 }
01978 else{
01979
01980 return "";
01981 }
01982 }
01983 else{
01984 throw ErrorClass("Error in getNonlinearExpressionTreeInInfix, rowIdx not valid");
01985 }
01986 return resultString;
01987 }
01988 catch(const ErrorClass& eclass){
01989 throw ErrorClass( eclass.errormsg);
01990 }
01991 }
01992
01993
01994 std::string OSInstance::printModel( ){
01995 std::string resultString = "";
01996 ostringstream outStr;
01997 outStr << "";
01998 int numCon;
01999 int numObj;
02000 int numVar;
02001 int i;
02002 numCon = this->getConstraintNumber();
02003 numObj = this->getObjectiveNumber();
02004 numVar = this->getVariableNumber();
02005 this->initForAlgDiff( );
02006 outStr << std::endl;
02007 outStr << "Objectives:" << std::endl;
02008 for(i = 0; i < numObj; i++){
02009 if( this->getObjectiveMaxOrMins()[0] == "min"){
02010 outStr << "min ";
02011 }
02012 else{
02013 outStr << "max ";
02014 }
02015 outStr << this->printModel( i - numObj);
02016 }
02017 outStr << std::endl;
02018 outStr << "Constraints:" << std::endl;
02019 for(i = 0; i < numCon; i++){
02020 outStr << this->printModel( i);
02021 }
02022
02023 outStr << std::endl;
02024 outStr << "Variables:" << std::endl;
02025 if(m_bProcessVariables != true || bVariablesModified == true ) this->processVariables();
02026 for(i = 0; i < numVar; i++){
02027
02028
02029 if(this->instanceData->variables->numberOfVariables > 0 && this->instanceData->variables->var[ i ]->name.size() > 0){
02030 outStr << this->instanceData->variables->var[ i ]->name;
02031 }else{
02032 outStr << "x_";
02033 outStr << i;
02034 }
02035
02036
02037
02038
02039 outStr << " Type = " ;
02040 outStr << m_mcVariableTypes[i];
02041 outStr << " Lower Bound = ";
02042 outStr << os_dtoa_format( m_mdVariableLowerBounds[i]) ;
02043 outStr << " Upper Bound = ";
02044 outStr << os_dtoa_format( m_mdVariableUpperBounds[i]) ;
02045 outStr << std::endl;
02046 }
02047
02048
02049
02050
02051
02052
02053
02054
02055
02056 return outStr.str() ;
02057 }
02058
02059
02060 std::string OSInstance::printModel(int rowIdx ){
02061 std::string resultString = "";
02062 ostringstream outStr;
02063 outStr << "";
02064
02065 int j;
02066 int row_nonz = 0;
02067 int obj_nonz = 0;
02068 int varIdx = 0;
02069 bool addedLinearTerm = false;
02070
02071
02072 this->initForAlgDiff( );
02073
02074 if( rowIdx >= 0){
02075 if( m_bProcessConstraints != true || bConstraintsModified == true) this->processConstraints() ;
02076 if( m_mdConstraintLowerBounds[ rowIdx] > -OSDBL_MAX){
02077 if(m_mdConstraintLowerBounds[ rowIdx] < m_mdConstraintUpperBounds[ rowIdx]){
02078 outStr << os_dtoa_format( m_mdConstraintLowerBounds[ rowIdx] );
02079 outStr << " <= ";
02080 }
02081 }
02082
02083 if(this->instanceData->linearConstraintCoefficients != NULL && this->instanceData->linearConstraintCoefficients->numberOfValues > 0){
02084 if(m_linearConstraintCoefficientsInRowMajor == NULL)
02085 m_linearConstraintCoefficientsInRowMajor = this->getLinearConstraintCoefficientsInRowMajor();
02086 row_nonz = m_linearConstraintCoefficientsInRowMajor->starts[ rowIdx + 1] - m_linearConstraintCoefficientsInRowMajor->starts[ rowIdx];
02087
02088 for(j = 0; j < row_nonz; j++){
02089 varIdx = m_linearConstraintCoefficientsInRowMajor->indexes[ m_linearConstraintCoefficientsInRowMajor->starts[ rowIdx] + j];
02090
02091 if(m_bSparseJacobianCalculated == false || (m_mapExpressionTreesMod.find( rowIdx) == m_mapExpressionTreesMod.end() ) ||
02092 ( (*m_mapExpressionTreesMod[ rowIdx]->mapVarIdx).find( varIdx) == (*m_mapExpressionTreesMod[ rowIdx]->mapVarIdx).end()) ){
02093 outStr << os_dtoa_format( m_linearConstraintCoefficientsInRowMajor->values[ m_linearConstraintCoefficientsInRowMajor->starts[ rowIdx] + j] );
02094 outStr << "*";
02095
02096 if(this->instanceData->variables->numberOfVariables > 0 && this->instanceData->variables->var[ varIdx ]->name.size() > 0){
02097 outStr << this->instanceData->variables->var[ varIdx ]->name;
02098 }else{
02099 outStr << "x_";
02100 outStr << varIdx;
02101 }
02102
02103
02104 if( j < row_nonz - 1) outStr << " + ";
02105 addedLinearTerm = true;
02106 }
02107 }
02108 }
02109 }else{
02110 if(m_bProcessObjectives != true || bObjectivesModified == true) this->processObjectives() ;
02111 int obj_idx = -rowIdx - 1;
02112 obj_nonz = m_miNumberOfObjCoef[ obj_idx];
02113 for(j = 0; j < obj_nonz; j++){
02114 outStr << os_dtoa_format( m_mObjectiveCoefficients[obj_idx]->values[j] );
02115 outStr << "*";
02116 if(this->instanceData->variables->numberOfVariables > 0 && this->instanceData->variables->var[ m_mObjectiveCoefficients[obj_idx]->indexes[j] ]->name.size() > 0){
02117 outStr << this->instanceData->variables->var[ m_mObjectiveCoefficients[obj_idx]->indexes[j] ]->name;
02118 }else{
02119 outStr << "x_";
02120 outStr << m_mObjectiveCoefficients[obj_idx]->indexes[j] ;
02121 }
02122 if( j < obj_nonz - 1) outStr << " + ";
02123 }
02124 }
02125 if( this->getNonlinearExpressionTree( rowIdx) != NULL){
02126 if( (addedLinearTerm == true) || (obj_nonz > 0) ) outStr << " + " ;
02127 outStr << getNonlinearExpressionTreeInInfix( rowIdx);
02128
02129 }
02130
02131 if( rowIdx >= 0){
02132 if( m_bProcessConstraints != true ) this->processConstraints() ;
02133 if( m_mdConstraintUpperBounds[ rowIdx] < OSDBL_MAX){
02134 if(m_mdConstraintLowerBounds[ rowIdx] < m_mdConstraintUpperBounds[ rowIdx]){
02135 outStr << " <= ";
02136 }else{
02137 outStr << " = ";
02138 }
02139 outStr << os_dtoa_format( m_mdConstraintUpperBounds[ rowIdx] );
02140 outStr << " ";
02141 outStr << this->getConstraintNames()[ rowIdx] ;
02142 }
02143 }
02144 outStr << std::endl;
02145 resultString = outStr.str();
02146 return resultString;
02147 }
02148
02149
02150 std::vector<OSnLNode*> OSInstance::getNonlinearExpressionTreeModInPostfix( int rowIdx){
02151
02152 if( m_bProcessExpressionTreesMod == false ) getAllNonlinearExpressionTreesMod();
02153 std::vector<OSnLNode*> postfixVec;
02154 try{
02155 if( m_mapExpressionTreesMod.find( rowIdx) != m_mapExpressionTreesMod.end()){
02156 OSExpressionTree* expTree = getNonlinearExpressionTreeMod( rowIdx);
02157 postfixVec = expTree->m_treeRoot->getPostfixFromExpressionTree();
02158
02159 }
02160 else{
02161 throw ErrorClass("Error in getNonlinearExpressionTreeModInPostfix, rowIdx not valid");
02162 }
02163 return postfixVec;
02164 }
02165 catch(const ErrorClass& eclass){
02166 throw ErrorClass( eclass.errormsg);
02167 }
02168 }
02169
02170
02171 std::vector<OSnLNode*> OSInstance::getNonlinearExpressionTreeInPrefix( int rowIdx){
02172
02173 if( m_bProcessExpressionTrees == false ) getAllNonlinearExpressionTrees();
02174 std::vector<OSnLNode*> prefixVec;
02175 try{
02176 if( m_mapExpressionTrees.find( rowIdx) != m_mapExpressionTrees.end()){
02177 OSExpressionTree* expTree = getNonlinearExpressionTree( rowIdx);
02178 prefixVec = expTree->m_treeRoot->getPrefixFromExpressionTree();
02179
02180 }
02181 else{
02182 throw ErrorClass("Error in getNonlinearExpressionTreeInPrefix, rowIdx not valid");
02183 }
02184 return prefixVec;
02185 }
02186 catch(const ErrorClass& eclass){
02187 throw ErrorClass( eclass.errormsg);
02188 }
02189 }
02190
02191 std::vector<OSnLNode*> OSInstance::getNonlinearExpressionTreeModInPrefix( int rowIdx){
02192
02193 if( m_bProcessExpressionTreesMod == false ) getAllNonlinearExpressionTreesMod();
02194 std::vector<OSnLNode*> prefixVec;
02195 try{
02196 if( m_mapExpressionTreesMod.find( rowIdx) != m_mapExpressionTreesMod.end()){
02197 OSExpressionTree* expTree = getNonlinearExpressionTreeMod( rowIdx);
02198 prefixVec = expTree->m_treeRoot->getPrefixFromExpressionTree();
02199
02200 }
02201 else{
02202 throw ErrorClass("Error in getNonlinearExpressionTreeInPrefix, rowIdx not valid");
02203 }
02204 return prefixVec;
02205 }
02206 catch(const ErrorClass& eclass){
02207 throw ErrorClass( eclass.errormsg);
02208 }
02209 }
02210
02211 std::map<int, OSExpressionTree*> OSInstance::getAllNonlinearExpressionTrees(){
02212
02213 if(m_bProcessExpressionTrees == true) return m_mapExpressionTrees;
02214 std::map<int, int> foundIdx;
02215 std::map<int, int>::iterator pos;
02216 OSnLNodePlus *nlNodePlus;
02217 OSExpressionTree *expTree;
02218 m_iObjectiveNumberNonlinear = 0;
02219 m_iConstraintNumberNonlinear = 0;
02220 int i;
02221
02222 if( instanceData->nonlinearExpressions->numberOfNonlinearExpressions > 0 && instanceData->nonlinearExpressions->nl != NULL){
02223 for( i = 0; i < instanceData->nonlinearExpressions->numberOfNonlinearExpressions; i++){
02224 instanceData->nonlinearExpressions->nl[i]->m_bDeleteExpressionTree = false;
02225 }
02226 }
02227 int index;
02228
02229 for(i = 0; i < instanceData->nonlinearExpressions->numberOfNonlinearExpressions; i++){
02230 index = instanceData->nonlinearExpressions->nl[ i]->idx;
02231 if(foundIdx.find( index) != foundIdx.end() ){
02232
02233
02234
02235
02236
02237
02238
02239 nlNodePlus = new OSnLNodePlus();
02240
02241 expTree = instanceData->nonlinearExpressions->nl[ i]->osExpressionTree;
02242
02243 nlNodePlus->m_mChildren[ 0] = m_mapExpressionTrees[ index]->m_treeRoot;
02244 nlNodePlus->m_mChildren[ 1] = instanceData->nonlinearExpressions->nl[ i]->osExpressionTree->m_treeRoot;
02245
02246 instanceData->nonlinearExpressions->nl[ foundIdx[ index] ]->m_bDeleteExpressionTree = true;
02247 instanceData->nonlinearExpressions->nl[ foundIdx[ index] ]->osExpressionTree->bDestroyNlNodes = false;
02248
02249 m_mapExpressionTrees[ index] = expTree;
02250 m_mapExpressionTrees[ index]->m_treeRoot = nlNodePlus;
02251 foundIdx[ index] = i;
02252 }
02253 else{
02254
02255 m_mapExpressionTrees[ index] = instanceData->nonlinearExpressions->nl[ i]->osExpressionTree;
02256 m_mapExpressionTrees[ index]->m_treeRoot = instanceData->nonlinearExpressions->nl[ i]->osExpressionTree->m_treeRoot;
02257 foundIdx[ index] = i;
02258 }
02259
02260 }
02261
02262 for(pos = foundIdx.begin(); pos != foundIdx.end(); ++pos){
02263 if(pos->first == -1) {
02264 m_iObjectiveNumberNonlinear++;
02265 }
02266 else m_iConstraintNumberNonlinear++;
02267 }
02268 foundIdx.clear();
02269 m_bProcessExpressionTrees = true;
02270 return m_mapExpressionTrees;
02271 }
02272
02273 std::map<int, OSExpressionTree*> OSInstance::getAllNonlinearExpressionTreesMod(){
02274 if( m_bProcessExpressionTreesMod == true ) return m_mapExpressionTreesMod;
02275 m_bProcessExpressionTreesMod = true;
02276
02277 if( m_bNonLinearStructuresInitialized == false) initializeNonLinearStructures( );
02278 return m_mapExpressionTreesMod;
02279 }
02280
02281
02282 std::string OSInstance::getTimeDomainFormat()
02283 { if (instanceData->timeDomain == NULL)
02284 return "";
02285 if (instanceData->timeDomain->interval != NULL)
02286 return "interval";
02287 if (instanceData->timeDomain->stages != NULL)
02288 return "stages";
02289 return "";
02290 }
02291
02292 int OSInstance::getTimeDomainStageNumber()
02293 { if (instanceData->timeDomain == NULL)
02294 return 1;
02295 if (instanceData->timeDomain->interval != NULL)
02296 ;
02297 if (instanceData->timeDomain->stages == NULL)
02298 return 1;
02299 return instanceData->timeDomain->stages->numberOfStages;
02300 }
02301
02302 std::string* OSInstance::getTimeDomainStageNames()
02303 { if (instanceData->timeDomain == NULL)
02304 return NULL;
02305 if (instanceData->timeDomain->interval != NULL)
02306 return NULL;
02307 if (instanceData->timeDomain->stages == NULL)
02308 return NULL;
02309 if (m_msTimeDomainStageNames != NULL)
02310 delete [] m_msTimeDomainStageNames;
02311 if (instanceData->timeDomain->stages->numberOfStages == 0)
02312 return NULL;
02313 m_msTimeDomainStageNames = new std::string[instanceData->timeDomain->stages->numberOfStages];
02314 for (int i = 0; i < instanceData->timeDomain->stages->numberOfStages; i++)
02315 m_msTimeDomainStageNames[i] = instanceData->timeDomain->stages->stage[i]->name;
02316 return m_msTimeDomainStageNames;
02317 }
02318
02319 int* OSInstance::getTimeDomainStageNumberOfVariables()
02320 { if (instanceData->timeDomain == NULL)
02321 return NULL;
02322 if (instanceData->timeDomain->interval != NULL)
02323 return NULL;
02324 if (instanceData->timeDomain->stages == NULL)
02325 return NULL;
02326 if (m_miTimeDomainStageVariableNumber != NULL)
02327 delete [] m_miTimeDomainStageVariableNumber;
02328 if (instanceData->timeDomain->stages->numberOfStages == 0)
02329 return NULL;
02330 m_miTimeDomainStageVariableNumber = new int[instanceData->timeDomain->stages->numberOfStages];
02331 for (int i = 0; i < instanceData->timeDomain->stages->numberOfStages; i++)
02332 m_miTimeDomainStageVariableNumber[i] = instanceData->timeDomain->stages->stage[i]->variables->numberOfVariables;
02333 return m_miTimeDomainStageVariableNumber;
02334 }
02335
02336 int* OSInstance::getTimeDomainStageNumberOfConstraints()
02337 { if (instanceData->timeDomain == NULL)
02338 return NULL;
02339 if (instanceData->timeDomain->interval != NULL)
02340 return NULL;
02341 if (instanceData->timeDomain->stages == NULL)
02342 return NULL;
02343 if (m_miTimeDomainStageConstraintNumber != NULL)
02344 delete [] m_miTimeDomainStageConstraintNumber;
02345 if (instanceData->timeDomain->stages->numberOfStages == 0)
02346 return NULL;
02347 m_miTimeDomainStageConstraintNumber = new int[instanceData->timeDomain->stages->numberOfStages];
02348 for (int i = 0; i < instanceData->timeDomain->stages->numberOfStages; i++)
02349 m_miTimeDomainStageConstraintNumber[i] = instanceData->timeDomain->stages->stage[i]->constraints->numberOfConstraints;
02350 return m_miTimeDomainStageConstraintNumber;
02351 }
02352
02353 int* OSInstance::getTimeDomainStageNumberOfObjectives()
02354 { if (instanceData->timeDomain == NULL)
02355 return NULL;
02356 if (instanceData->timeDomain->interval != NULL)
02357 return NULL;
02358 if (instanceData->timeDomain->stages == NULL)
02359 return NULL;
02360 if (m_miTimeDomainStageObjectiveNumber != NULL)
02361 delete [] m_miTimeDomainStageObjectiveNumber;
02362 if (instanceData->timeDomain->stages->numberOfStages == 0)
02363 return NULL;
02364 m_miTimeDomainStageObjectiveNumber = new int[instanceData->timeDomain->stages->numberOfStages];
02365 for (int i = 0; i < instanceData->timeDomain->stages->numberOfStages; i++)
02366 m_miTimeDomainStageObjectiveNumber[i] = instanceData->timeDomain->stages->stage[i]->objectives->numberOfObjectives;
02367 return m_miTimeDomainStageObjectiveNumber;
02368 }
02369
02370 int** OSInstance::getTimeDomainStageVarList()
02371 { if (instanceData->timeDomain == NULL)
02372 return NULL;
02373 if (instanceData->timeDomain->interval != NULL)
02374 return NULL;
02375 if (instanceData->timeDomain->stages == NULL)
02376 return NULL;
02377 if (m_miTimeDomainStageVariableNumber == NULL)
02378 return NULL;
02379 if (m_mmiTimeDomainStageVarList != NULL){
02380 for (int i = 0; i < m_iNumberOfTimeStages; i ++)
02381 delete[] m_mmiTimeDomainStageVarList[i];
02382 delete[] m_mmiTimeDomainStageVarList;
02383 m_mmiTimeDomainStageVarList = NULL;
02384 }
02385
02386
02387 if (instanceData->timeDomain->stages->numberOfStages == 0)
02388 return NULL;
02389 m_iNumberOfTimeStages = instanceData->timeDomain->stages->numberOfStages;
02390 m_mmiTimeDomainStageVarList = new int*[instanceData->timeDomain->stages->numberOfStages];
02391 int timeDomainStageNumberVar;
02392 for (int i = 0; i < instanceData->timeDomain->stages->numberOfStages; i++)
02393 {
02394 timeDomainStageNumberVar = m_miTimeDomainStageVariableNumber[i];
02395 m_mmiTimeDomainStageVarList[i] = new int[ timeDomainStageNumberVar ];
02396 if (instanceData->timeDomain->stages->stage[i]->variables->startIdx == -1)
02397 for (int j = 0; j < m_miTimeDomainStageVariableNumber[i]; j++)
02398 m_mmiTimeDomainStageVarList[i][j] = instanceData->timeDomain->stages->stage[i]->variables->var[j]->idx;
02399 else
02400 for (int j = 0; j < m_miTimeDomainStageVariableNumber[i]; j++)
02401 m_mmiTimeDomainStageVarList[i][j] = instanceData->timeDomain->stages->stage[i]->variables->startIdx + j;
02402 }
02403 return m_mmiTimeDomainStageVarList;
02404 }
02405
02406 int** OSInstance::getTimeDomainStageConList()
02407 { if (instanceData->timeDomain == NULL)
02408 return NULL;
02409 if (instanceData->timeDomain->interval != NULL)
02410 return NULL;
02411 if (instanceData->timeDomain->stages == NULL)
02412 return NULL;
02413 if (m_miTimeDomainStageConstraintNumber == NULL)
02414 return NULL;
02415 if (m_mmiTimeDomainStageConList != NULL){
02416
02417 for (int i = 0; i < m_iNumberOfTimeStages; i ++)
02418 delete[] m_mmiTimeDomainStageConList[i];
02419 delete[] m_mmiTimeDomainStageConList;
02420 m_mmiTimeDomainStageConList = NULL;
02421 }
02422
02423 if (instanceData->timeDomain->stages->numberOfStages == 0)
02424 return NULL;
02425 m_iNumberOfTimeStages = instanceData->timeDomain->stages->numberOfStages;
02426 m_mmiTimeDomainStageConList = new int*[instanceData->timeDomain->stages->numberOfStages];
02427 int numTimeDomainStageCon;
02428 for (int i = 0; i < instanceData->timeDomain->stages->numberOfStages; i++)
02429 {
02430 numTimeDomainStageCon = m_miTimeDomainStageConstraintNumber[i];
02431 m_mmiTimeDomainStageConList[i] = new int[ numTimeDomainStageCon];
02432 if (instanceData->timeDomain->stages->stage[i]->constraints->startIdx == -1)
02433 for (int j = 0; j < m_miTimeDomainStageConstraintNumber[i]; j++)
02434 m_mmiTimeDomainStageConList[i][j] = instanceData->timeDomain->stages->stage[i]->constraints->con[j]->idx;
02435 else
02436 for (int j = 0; j < m_miTimeDomainStageConstraintNumber[i]; j++)
02437 m_mmiTimeDomainStageConList[i][j] = instanceData->timeDomain->stages->stage[i]->constraints->startIdx + j;
02438 }
02439 return m_mmiTimeDomainStageConList;
02440 }
02441
02442 int** OSInstance::getTimeDomainStageObjList()
02443 { if (instanceData->timeDomain == NULL)
02444 return NULL;
02445 if (instanceData->timeDomain->interval != NULL)
02446 return NULL;
02447 if (instanceData->timeDomain->stages == NULL)
02448 return NULL;
02449 if (m_miTimeDomainStageObjectiveNumber == NULL)
02450 return NULL;
02451 if (m_mmiTimeDomainStageObjList != NULL){
02452 for (int i = 0; i < m_iNumberOfTimeStages; i ++)
02453 delete[] m_mmiTimeDomainStageObjList[i];
02454 delete[] m_mmiTimeDomainStageObjList;
02455 m_mmiTimeDomainStageObjList = NULL;
02456 }
02457 if (instanceData->timeDomain->stages->numberOfStages == 0)
02458 return NULL;
02459 m_iNumberOfTimeStages = instanceData->timeDomain->stages->numberOfStages;
02460 m_mmiTimeDomainStageObjList = new int*[instanceData->timeDomain->stages->numberOfStages];
02461 int numTimeDomainStageObjNum;
02462 for (int i = 0; i < instanceData->timeDomain->stages->numberOfStages; i++)
02463 {
02464 numTimeDomainStageObjNum = m_miTimeDomainStageObjectiveNumber[i];
02465 m_mmiTimeDomainStageObjList[i] = new int[ numTimeDomainStageObjNum];
02466 if (instanceData->timeDomain->stages->stage[i]->objectives->startIdx == 0)
02467 for (int j = 0; j < m_miTimeDomainStageObjectiveNumber[i]; j++)
02468 m_mmiTimeDomainStageObjList[i][j] = instanceData->timeDomain->stages->stage[i]->objectives->obj[j]->idx;
02469 else
02470 for (int j = 0; j < m_miTimeDomainStageObjectiveNumber[i]; j++)
02471 m_mmiTimeDomainStageObjList[i][j] = instanceData->timeDomain->stages->stage[i]->objectives->startIdx - j;
02472 }
02473 return m_mmiTimeDomainStageObjList;
02474 }
02475
02476 double OSInstance::getTimeDomainIntervalStart()
02477 { if (instanceData->timeDomain == NULL)
02478 return 0.0;
02479 if (instanceData->timeDomain->stages != NULL)
02480 return 0.0;
02481 if (instanceData->timeDomain->interval == NULL)
02482 return 0.0;
02483 return instanceData->timeDomain->interval->start;
02484 }
02485
02486 double OSInstance::getTimeDomainIntervalHorizon()
02487 { if (instanceData->timeDomain == NULL)
02488 return 0.0;
02489 if (instanceData->timeDomain->stages != NULL)
02490 return 0.0;
02491 if (instanceData->timeDomain->interval == NULL)
02492 return 0.0;
02493 return instanceData->timeDomain->interval->horizon;
02494 }
02495
02496
02497
02498
02499
02500
02501 bool OSInstance::setInstanceSource(string source){
02502 instanceHeader->source = source;
02503 return true;
02504 }
02505
02506 bool OSInstance::setInstanceDescription(string description){
02507 instanceHeader->description = description;
02508 return true;
02509 }
02510
02511
02512 bool OSInstance::setInstanceName(string name){
02513 instanceHeader->name = name;
02514 return true;
02515 }
02516
02517
02518 bool OSInstance::setVariableNumber(int number){
02519
02520 if(number < 0) return false;
02521
02522
02523
02524
02525 if(instanceData->variables == NULL) instanceData->variables = new Variables();
02526 instanceData->variables->numberOfVariables = number;
02527 if(instanceData->variables->var == NULL && number > 0){
02528 instanceData->variables->var = new Variable*[number];
02529 }
02530 return true;
02531 }
02532
02533
02534 bool OSInstance::addVariable(int index, string name, double lowerBound, double upperBound, char type){
02535 if (verifyVarType(type) == false) type = 'C';
02536 instanceData->variables->var[index] = new Variable();
02537 if(index < 0 || instanceData->variables->numberOfVariables <= 0 || index >= instanceData->variables->numberOfVariables) return false;
02538 instanceData->variables->var[index]->name = name;
02539 instanceData->variables->var[index]->lb = lowerBound;
02540 instanceData->variables->var[index]->ub = upperBound;
02541 instanceData->variables->var[index]->type = type;
02542
02543
02544 return true;
02545 }
02546
02547
02548 bool OSInstance::setVariables(int number, string *names, double *lowerBounds,
02549 double *upperBounds, char *types){
02550 if(number <= 0) return false;
02551 try{
02552 if(instanceData->variables == NULL){
02553 throw ErrorClass("There is no variables object");
02554 }
02555 if(instanceData->variables->numberOfVariables != number){
02556 throw ErrorClass("input number of variables not equal to number in class");
02557 }
02558
02559 int i;
02560 for(i = 0; i < number; i++){
02561 instanceData->variables->var[ i] = new Variable();
02562 }
02563 if(names != NULL){
02564 for(i = 0; i < number; i++) instanceData->variables->var[i]->name = names[i];
02565 }
02566 if(lowerBounds != NULL){
02567 for(i = 0; i < number; i++){
02568 instanceData->variables->var[i]->lb = lowerBounds[i];
02569 }
02570 }
02571 if(upperBounds != NULL){
02572 for(i = 0; i < number; i++){
02573 instanceData->variables->var[i]->ub = upperBounds[i];
02574 }
02575 }
02576 if(types != NULL){
02577 for(i = 0; i < number; i++){
02578 instanceData->variables->var[i]->type = types[i];
02579 if(verifyVarType(types[i]) == false) types[i] = 'C';
02580 }
02581 }
02582
02583
02584
02585
02586
02587
02588
02589
02590 return true;
02591 }
02592 catch(const ErrorClass& eclass){
02593 throw ErrorClass( eclass.errormsg);
02594 }
02595 }
02596
02597
02598
02599 bool OSInstance::setObjectiveNumber(int number){
02600 if(number < 0) return false;
02601 if(instanceData->objectives == NULL) instanceData->objectives = new Objectives();
02602 if(number == 0){
02603 instanceData->objectives->numberOfObjectives = 0;
02604 instanceData->objectives->obj = 0;
02605 return true;
02606 }
02607 instanceData->objectives->numberOfObjectives = number;
02608 instanceData->objectives->obj = new Objective*[number];
02609 return true;
02610 }
02611
02612 bool OSInstance::addObjective(int index, string name, string maxOrMin, double constant, double weight, SparseVector *objectiveCoefficients){
02613 if(index >= 0 || instanceData->objectives->numberOfObjectives <= 0 || abs(index) > instanceData->objectives->numberOfObjectives) return false;
02614 int arrayIndex = abs(index) -1;
02615 if(instanceData->objectives->obj == NULL) return false;
02616 instanceData->objectives->obj[arrayIndex] = new Objective();
02617 instanceData->objectives->obj[arrayIndex]->name = name;
02618 if( (maxOrMin != "max") && (maxOrMin != "min") ) return false;
02619 else instanceData->objectives->obj[arrayIndex]->maxOrMin = maxOrMin;
02620 instanceData->objectives->obj[arrayIndex]->constant = constant;
02621 instanceData->objectives->obj[arrayIndex]->weight = weight;
02622 int n = objectiveCoefficients->number;
02623 instanceData->objectives->obj[arrayIndex]->numberOfObjCoef = n;
02624 if(n == 0){
02625 instanceData->objectives->obj[arrayIndex]->coef = 0;
02626 }
02627 else{
02628 int i = 0;
02629 instanceData->objectives->obj[arrayIndex]->coef = new ObjCoef*[n];
02630 for(i = 0; i < n; i++) instanceData->objectives->obj[arrayIndex]->coef[i] = new ObjCoef();
02631 for(i = 0; i < n; i++){
02632 instanceData->objectives->obj[arrayIndex]->coef[i]->idx = objectiveCoefficients->indexes[i];
02633 instanceData->objectives->obj[arrayIndex]->coef[i]->value = objectiveCoefficients->values[i];
02634 }
02635 }
02636 return true;
02637 }
02638
02639 bool OSInstance::setObjectives(int number, string *names, string *maxOrMins, double *constants, double *weights, SparseVector **objectiveCoefficients){
02640 if(number < 0) return false;
02641 try{
02642 if(instanceData->objectives == NULL){
02643 throw ErrorClass("there is no objectives object");
02644 }
02645 if(instanceData->objectives->numberOfObjectives != number){
02646 throw ErrorClass("input number of objective not equal to number in class");
02647 }
02648 if(number == 0) return true;
02649 int i = 0;
02650 for(i = 0; i < number; i++)instanceData->objectives->obj[i] = new Objective();
02651 int j = 0;
02652 if(names != NULL){
02653 for(i = 0; i < number; i++) instanceData->objectives->obj[i]->name = names[i];
02654 }
02655 if(maxOrMins != NULL){
02656 for(i = 0; i < number; i++){
02657 if(maxOrMins[i] == "" || (maxOrMins[i].compare("max") != 0 && maxOrMins[i].compare("min") !=0)) return false;
02658 instanceData->objectives->obj[i]->maxOrMin = maxOrMins[i];
02659 }
02660 }
02661 if(constants != NULL){
02662 for(i = 0; i < number; i++) instanceData->objectives->obj[i]->constant = constants[i];
02663 }
02664 if(weights != NULL){
02665 for(i = 0; i < number; i++) instanceData->objectives->obj[i]->weight = weights[i];
02666 }
02667 if(objectiveCoefficients != NULL){
02668 for(i = 0; i < number; i++){
02669 int n = (&objectiveCoefficients[i] == NULL || objectiveCoefficients[i]->indexes == NULL)?0:objectiveCoefficients[i]->number;
02670 instanceData->objectives->obj[i]->numberOfObjCoef = n;
02671 if(n == 0){
02672 instanceData->objectives->obj[i]->coef = NULL;
02673 }
02674 else{
02675 instanceData->objectives->obj[i]->coef = new ObjCoef*[n];
02676 for(j = 0; j < n; j++){
02677 instanceData->objectives->obj[i]->coef[j] = new ObjCoef();
02678 instanceData->objectives->obj[i]->coef[j]->idx = objectiveCoefficients[i]->indexes[j];
02679 instanceData->objectives->obj[i]->coef[j]->value = objectiveCoefficients[i]->values[j];
02680 }
02681 }
02682 }
02683 }
02684 return true;
02685 }
02686 catch(const ErrorClass& eclass){
02687 throw ErrorClass( eclass.errormsg);
02688 }
02689 }
02690
02691
02692 bool OSInstance::setConstraintNumber(int number){
02693 if(number < 0) return false;
02694 if(instanceData->constraints == NULL) instanceData->constraints = new Constraints();
02695 if(number == 0){
02696 instanceData->constraints->numberOfConstraints = 0;
02697 instanceData->constraints->con = 0;
02698 return true;
02699 }
02700 instanceData->constraints->numberOfConstraints = number;
02701 if(instanceData->constraints->con == 0 ){
02702 instanceData->constraints->con = new Constraint*[number];
02703 }
02704 return true;
02705 }
02706
02707 bool OSInstance::addConstraint(int index, string name, double lowerBound, double upperBound, double constant) {
02708 instanceData->constraints->con[ index] = new Constraint();
02709 if(index < 0 || instanceData->constraints->numberOfConstraints <= 0 || index >= instanceData->constraints->numberOfConstraints) return false;
02710 instanceData->constraints->con[ index]->name = name;
02711 if(lowerBound != -OSDBL_MAX && lowerBound != -OSDBL_MAX) instanceData->constraints->con[ index]->lb = lowerBound;
02712 if(upperBound != OSDBL_MAX && upperBound != OSDBL_MAX)instanceData->constraints->con[ index]->ub = upperBound;
02713 instanceData->constraints->con[ index]->constant = constant;
02714 return true;
02715 }
02716
02717
02718 bool OSInstance::setConstraints(int number, string* names, double* lowerBounds, double* upperBounds, double* constants){
02719 if(number < 0) return false;
02720 if(number == 0){
02721
02722
02723
02724
02725 return true;
02726 }
02727 try{
02728
02729 if(instanceData->constraints == NULL){
02730 throw ErrorClass("there is no constraints object");
02731 }
02732 if(instanceData->constraints->numberOfConstraints != number){
02733 throw ErrorClass("input number of constraints not equal to number in class");
02734 }
02735 int i = 0;
02736 for(i = 0; i < number; i++){
02737 instanceData->constraints->con[i] = new Constraint();
02738 }
02739 if(names != NULL){
02740 for(i = 0; i < number; i++) instanceData->constraints->con[i]->name = names[i];
02741 }
02742 if(lowerBounds != NULL){
02743 for(i = 0; i < number; i++){
02744 if(lowerBounds[i] != -OSDBL_MAX && lowerBounds[i] != -OSDBL_MAX)instanceData->constraints->con[i]->lb = lowerBounds[i];
02745 }
02746 }
02747 if(upperBounds != NULL){
02748 for(i = 0; i < number; i++){
02749 if(upperBounds[i] != OSDBL_MAX && upperBounds[i] != OSDBL_MAX)instanceData->constraints->con[i]->ub = upperBounds[i];
02750 }
02751 }
02752 if(constants != NULL){
02753 for(i = 0; i < number; i++) instanceData->constraints->con[i]->constant = constants[i];
02754 }
02755 return true;
02756 }
02757 catch(const ErrorClass& eclass){
02758 throw ErrorClass( eclass.errormsg);
02759 }
02760 }
02761
02762 bool OSInstance::setLinearConstraintCoefficients(int numberOfValues, bool isColumnMajor,
02763 double* values, int valuesBegin, int valuesEnd,
02764 int* indexes, int indexesBegin, int indexesEnd,
02765 int* starts, int startsBegin, int startsEnd)
02766 {
02767 if(numberOfValues < 0) return false;
02768 if(instanceData->linearConstraintCoefficients == NULL)
02769 instanceData->linearConstraintCoefficients = new LinearConstraintCoefficients() ;
02770 if(numberOfValues == 0) return true;
02771 if((values == 0 ) ||
02772 (valuesBegin < 0 || (valuesEnd - valuesBegin + 1) != numberOfValues) ||
02773 (indexes == 0) ||
02774 (indexesBegin < 0 || (indexesEnd - indexesBegin + 1) != numberOfValues) ||
02775 (starts == 0 ) ||
02776 (startsBegin < 0 || startsBegin >= startsEnd)) return false;
02777 instanceData->linearConstraintCoefficients->numberOfValues = numberOfValues;
02778 int i = 0;
02779
02780 if(instanceData->linearConstraintCoefficients->start == NULL) instanceData->linearConstraintCoefficients->start = new IntVector();
02781 if(startsBegin == 0 ){
02782 instanceData->linearConstraintCoefficients->start->el = starts;
02783 }
02784 else{
02785 instanceData->linearConstraintCoefficients->start->el = new int[startsEnd - startsBegin + 1];
02786 int k = 0;
02787 for(i = startsBegin; i <= startsEnd; i++){
02788 instanceData->linearConstraintCoefficients->start->el[k] = starts[i];
02789 k++;
02790 }
02791 }
02792
02793 if(instanceData->linearConstraintCoefficients->value == NULL) instanceData->linearConstraintCoefficients->value = new DoubleVector();
02794 if(valuesBegin == 0 ){
02795 instanceData->linearConstraintCoefficients->value->el = values;
02796 }
02797 else{
02798 instanceData->linearConstraintCoefficients->value->el = new double[numberOfValues];
02799 int k = 0;
02800 for(i = valuesBegin; i <= valuesEnd; i++){
02801 instanceData->linearConstraintCoefficients->value->el[k] = values[i];
02802 k++;
02803 }
02804 }
02805
02806 if(instanceData->linearConstraintCoefficients->rowIdx == NULL) instanceData->linearConstraintCoefficients->rowIdx = new IntVector();
02807 if(instanceData->linearConstraintCoefficients->colIdx == NULL) instanceData->linearConstraintCoefficients->colIdx = new IntVector();
02808 if(isColumnMajor){
02809 if(indexesBegin == 0 ){
02810 instanceData->linearConstraintCoefficients->rowIdx->el = indexes;
02811 }
02812 else{
02813 instanceData->linearConstraintCoefficients->rowIdx->el = new int[numberOfValues];
02814 int k = 0;
02815 for(i = indexesBegin; i <= indexesEnd; i++){
02816 instanceData->linearConstraintCoefficients->rowIdx->el[k] = indexes[i];
02817 k++;
02818 }
02819 }
02820 }
02821 else{
02822 if(indexesBegin == 0 ){
02823 instanceData->linearConstraintCoefficients->colIdx->el = indexes;
02824 }
02825 else{
02826 instanceData->linearConstraintCoefficients->colIdx->el = new int[numberOfValues];
02827 int k = 0;
02828 for(i = indexesBegin; i <= indexesEnd; i++){
02829 instanceData->linearConstraintCoefficients->colIdx->el[k] = indexes[i];
02830 k++;
02831 }
02832 }
02833 }
02834 return true;
02835 }
02836
02837 bool OSInstance::setQuadraticTerms(int number,
02838 int* rowIndexes, int* varOneIndexes, int* varTwoIndexes, double* coefficients,
02839 int begin, int end){
02840 if(number < 0) return false;
02841 if(number != (end - begin) + 1) return false;
02842 if(number == 0){
02843 instanceData->quadraticCoefficients = 0;
02844 return true;
02845 }
02846 if( ((end - begin + 1) != number) ||
02847 (rowIndexes == 0) ||
02848 (varOneIndexes == 0) ||
02849 (varTwoIndexes == 0) ||
02850 (coefficients == 0) ) return false;
02851 instanceData->quadraticCoefficients = new QuadraticCoefficients();
02852 instanceData->quadraticCoefficients->numberOfQuadraticTerms = number;
02853 int i = 0;
02854 instanceData->quadraticCoefficients->qTerm = new QuadraticTerm*[number];
02855 for(i = 0; i < number; i++) instanceData->quadraticCoefficients->qTerm[i] = new QuadraticTerm();
02856 int k = 0;
02857 for(i = begin; i <= end; i++){
02858 instanceData->quadraticCoefficients->qTerm[k]->idx = rowIndexes[i];
02859 instanceData->quadraticCoefficients->qTerm[k]->idxOne = varOneIndexes[i];
02860 instanceData->quadraticCoefficients->qTerm[k]->idxTwo = varTwoIndexes[i];
02861 instanceData->quadraticCoefficients->qTerm[k]->coef = coefficients[i];
02862 k++;
02863 }
02864 return true;
02865 }
02866
02867 bool OSInstance::setQuadraticTermsInNonlinearExpressions(int numQPTerms, int* rowIndexes, int* varOneIndexes, int* varTwoIndexes, double* coefficients){
02868 instanceData->nonlinearExpressions->numberOfNonlinearExpressions = numQPTerms;
02869 instanceData->nonlinearExpressions->nl = new Nl*[ numQPTerms ];
02870
02871 OSnLNode *nlNodePoint;
02872 OSnLNodeVariable *nlNodeVariablePoint;
02873 std::vector<OSnLNode*> nlNodeVec;
02874
02875
02876 int i;
02877 for(i = 0; i < numQPTerms; i++){
02878 instanceData->nonlinearExpressions->nl[ i] = new Nl();
02879 instanceData->nonlinearExpressions->nl[ i]->idx = rowIndexes[ i];
02880 instanceData->nonlinearExpressions->nl[ i]->osExpressionTree = new OSExpressionTree();
02881
02882 nlNodeVariablePoint = new OSnLNodeVariable();
02883 nlNodeVariablePoint->idx = varOneIndexes[ i];
02884
02885 nlNodeVariablePoint->coef = coefficients[ i];
02886 nlNodeVec.push_back( nlNodeVariablePoint);
02887
02888 nlNodeVariablePoint = new OSnLNodeVariable();
02889 nlNodeVariablePoint->idx = varTwoIndexes[ i];
02890 nlNodeVec.push_back( nlNodeVariablePoint);
02891
02892 nlNodePoint = new OSnLNodeTimes();
02893 nlNodeVec.push_back( nlNodePoint);
02894
02895
02896 instanceData->nonlinearExpressions->nl[ i]->osExpressionTree->m_treeRoot =
02897 nlNodeVec[ 0]->createExpressionTreeFromPostfix( nlNodeVec);
02898 nlNodeVec.clear();
02899 }
02900 return true;
02901 }
02902
02903 bool OSInstance::initializeNonLinearStructures( ){
02904 std::map<int, OSExpressionTree*>::iterator posMapExpTree;
02905 if( m_bNonLinearStructuresInitialized == true) return true;
02906 if( m_bProcessVariables == false) processVariables();
02907 if( m_bProcessObjectives == false) processObjectives();
02908 if( m_bProcessConstraints == false) processConstraints();
02909 m_iVariableNumber = instanceData->variables->numberOfVariables;
02910 m_iConstraintNumber = instanceData->constraints->numberOfConstraints;
02911 m_iObjectiveNumber = instanceData->objectives->numberOfObjectives;
02912
02913 if( m_bProcessExpressionTrees == false) getAllNonlinearExpressionTrees();
02914
02915 if( m_bDuplicateExpressionTreesMap == false) duplicateExpressionTreesMap();
02916
02917 for(posMapExpTree = m_mapExpressionTreesMod.begin(); posMapExpTree != m_mapExpressionTreesMod.end(); ++posMapExpTree){
02918 (posMapExpTree->second)->getVariableIndiciesMap() ;
02919 }
02920
02921 if(getNumberOfQuadraticTerms() > 0) addQTermsToExressionTree();
02922
02923 getAllNonlinearVariablesIndexMap( );
02924 getDenseObjectiveCoefficients();
02925 m_mdConstraintFunctionValues = new double[ this->instanceData->constraints->numberOfConstraints];
02926 m_mdObjectiveFunctionValues = new double[ this->instanceData->objectives->numberOfObjectives];
02927
02928 m_bNonLinearStructuresInitialized = true;
02929 m_bProcessVariables = true;
02930 m_bProcessObjectives = true;
02931 m_bProcessConstraints = true;
02932 m_bProcessExpressionTrees = true;
02933 m_bDuplicateExpressionTreesMap = true;
02934 return true;
02935 }
02936
02937 SparseJacobianMatrix *OSInstance::getJacobianSparsityPattern( ){
02938
02939
02940
02941
02942
02943
02944 if( m_bSparseJacobianCalculated == true) return m_sparseJacMatrix;
02945
02946
02947 getLinearConstraintCoefficientMajor();
02948
02949 if( m_bNonLinearStructuresInitialized == false) initializeNonLinearStructures( );
02950 try{
02951 if( m_bColumnMajor == true){
02952 if( getSparseJacobianFromColumnMajor( ) == false) throw ErrorClass("An error occurred in getSpareJacobianFromColumnMajor");
02953 }
02954 else {
02955 if( getSparseJacobianFromRowMajor( ) == false) throw ErrorClass("An error occurred in getSpareJacobianFromRowMajor");
02956 }
02957 }
02958 catch(const ErrorClass& eclass){
02959 throw ErrorClass( eclass.errormsg);
02960 }
02961
02962 m_sparseJacMatrix = new SparseJacobianMatrix();
02963
02964
02965 m_sparseJacMatrix->bDeleteArrays = false;
02966 m_sparseJacMatrix->valueSize = m_iJacValueSize;
02967 m_sparseJacMatrix->starts = m_miJacStart;
02968 m_sparseJacMatrix->conVals = m_miJacNumConTerms;
02969 m_sparseJacMatrix->indexes = m_miJacIndex;
02970 m_sparseJacMatrix->values = m_mdJacValue;
02971 m_bSparseJacobianCalculated = true;
02972 return m_sparseJacMatrix;
02973 }
02974
02975 bool OSInstance::addQTermsToExressionTree(){
02976 int i, k, idx;
02977
02978 int numQTerms = instanceData->quadraticCoefficients->numberOfQuadraticTerms;
02979 if(numQTerms <= 0 || m_bQTermsAdded == true) return true;
02980 OSnLNodeVariable* nlNodeVariableOne;
02981 OSnLNodeVariable* nlNodeVariableTwo;
02982 OSnLNodeTimes* nlNodeTimes;
02983 OSnLNodePlus* nlNodePlus;
02984 OSExpressionTree* expTree;
02985 getQuadraticTerms();
02986
02987 for(i = 0; i < numQTerms; i++){
02988 idx = m_quadraticTerms->rowIndexes[ i];
02989
02990
02991 if( m_mapExpressionTreesMod.find( idx) != m_mapExpressionTreesMod.end() ) {
02992
02993
02994
02995 nlNodeVariableOne = new OSnLNodeVariable();
02996 nlNodeVariableOne->idx = m_quadraticTerms->varOneIndexes[ i];
02997
02998
02999 expTree = m_mapExpressionTreesMod[ idx];
03000 if( expTree->m_bIndexMapGenerated == false) expTree->getVariableIndiciesMap();
03001 if( (*expTree->mapVarIdx).find( nlNodeVariableOne->idx) == (*expTree->mapVarIdx).end() ){
03002
03003 k = (*expTree->mapVarIdx).size();
03004 (*expTree->mapVarIdx)[ nlNodeVariableOne->idx] = k + 1;
03005 #ifdef DEBUG
03006 std::cout << "ADDED THE FOLLOWING VAIRABLE TO THE MAP" << nlNodeVariableOne->idx << std::endl;
03007 #endif
03008 }
03009 nlNodeVariableOne->coef = m_quadraticTerms->coefficients[ i];
03010 nlNodeVariableTwo = new OSnLNodeVariable();
03011 nlNodeVariableTwo->idx = m_quadraticTerms->varTwoIndexes[ i];
03012
03013
03014 if( (*expTree->mapVarIdx).find( nlNodeVariableTwo->idx) == (*expTree->mapVarIdx).end() ){
03015
03016 k = (*expTree->mapVarIdx).size();
03017 (*expTree->mapVarIdx)[ nlNodeVariableTwo->idx] = k + 1;
03018 #ifdef DEBUG
03019 std::cout << "ADDED THE FOLLOWING VAIRABLE TO THE MAP" << nlNodeVariableTwo->idx << std::endl;
03020 #endif
03021 }
03022 nlNodeVariableTwo->coef = 1.;
03023
03024 nlNodeTimes = new OSnLNodeTimes();
03025 nlNodeTimes->m_mChildren[ 0] = nlNodeVariableOne;
03026 nlNodeTimes->m_mChildren[ 1] = nlNodeVariableTwo;
03027
03028 nlNodePlus = new OSnLNodePlus();
03029 nlNodePlus->m_mChildren[ 0] = expTree->m_treeRoot;
03030 nlNodePlus->m_mChildren[ 1] = nlNodeTimes;
03031
03032 expTree->m_treeRoot = nlNodePlus ;
03033
03034 if(expTree->m_bIndexMapGenerated == true){
03035 delete expTree->mapVarIdx;
03036 expTree->mapVarIdx = NULL;
03037 expTree->m_bIndexMapGenerated = false;
03038 }
03039
03040
03041
03042 }
03043 else{
03044
03045 nlNodeVariableOne = new OSnLNodeVariable();
03046 nlNodeVariableOne->idx = m_quadraticTerms->varOneIndexes[ i];
03047 nlNodeVariableOne->coef = m_quadraticTerms->coefficients[ i];
03048 nlNodeVariableTwo = new OSnLNodeVariable();
03049 nlNodeVariableTwo->idx = m_quadraticTerms->varTwoIndexes[ i];
03050 nlNodeVariableTwo->coef = 1.;
03051
03052 nlNodeTimes = new OSnLNodeTimes();
03053 nlNodeTimes->m_mChildren[ 0] = nlNodeVariableOne;
03054 nlNodeTimes->m_mChildren[ 1] = nlNodeVariableTwo;
03055
03056 expTree = new OSExpressionTree();
03057 expTree->m_treeRoot = nlNodeTimes ;
03058 expTree->mapVarIdx = expTree->getVariableIndiciesMap();
03059 m_mapExpressionTreesMod[ idx ] = expTree;
03060 if(idx < 0){
03061 m_iObjectiveNumberNonlinear++;
03062 m_bProcessExpressionTrees = true;
03063 }
03064 else{
03065 m_iConstraintNumberNonlinear++;
03066 m_bProcessExpressionTrees = true;
03067 }
03068 #ifdef DEBUG
03069 std::cout << "NUMBER OF EXPRESSION TREES = " << m_mapExpressionTreesMod.size() <<std::endl;
03070 std::cout << "NUMBER OF NONLINEAR OBJECTIVES = " << getNumberOfNonlinearObjectives() <<std::endl;
03071 #endif
03072 }
03073
03074 if(m_iNonlinearExpressionNumber <= 0) m_mapExpressionTrees = m_mapExpressionTreesMod;
03075 m_bQTermsAdded =true;
03076 }
03077 return true;
03078 }
03079
03080 double OSInstance::calculateFunctionValue(int idx, double *x, bool new_x){
03081 try{
03082
03083 int i, j;
03084 double dvalue = 0;
03085 if( m_binitForAlgDiff == false) initForAlgDiff();
03086 if( m_bSparseJacobianCalculated == false) getJacobianSparsityPattern();
03087 if(idx >= 0){
03088
03089 if( getConstraintNumber() <= idx ) throw
03090 ErrorClass("constraint index not valid in OSInstance::calculateFunctionValue");
03091 if( new_x == false) return *(m_mdConstraintFunctionValues + idx);
03092
03093 if( m_mapExpressionTreesMod.find( idx) != m_mapExpressionTreesMod.end() ){
03094 dvalue = m_mapExpressionTreesMod[ idx]->calculateFunction( x, new_x);
03095
03096 }
03097
03098
03099 i = m_sparseJacMatrix->starts[ idx];
03100 j = m_sparseJacMatrix->starts[ idx + 1 ];
03101
03102 while ( (i - m_sparseJacMatrix->starts[ idx]) < m_sparseJacMatrix->conVals[ idx] ){
03103
03104
03105 dvalue += m_sparseJacMatrix->values[ i]*x[ m_sparseJacMatrix->indexes[ i] ];
03106 i++;
03107 }
03108
03109 dvalue += m_mdConstraintConstants[ idx ];
03110 return dvalue;
03111 }
03112 else{
03113
03114 if( getObjectiveNumber() <= ( abs( idx) - 1) ) throw
03115 ErrorClass("objective function index not valid in OSInstance::calculateFunctionValue");
03116 if( new_x == false) return *(m_mdObjectiveFunctionValues + ( abs( idx) - 1));
03117
03118 if( m_mapExpressionTreesMod.find( idx) != m_mapExpressionTreesMod.end() ){
03119 dvalue = m_mapExpressionTreesMod[ idx]->calculateFunction( x, new_x);
03120 }
03121
03122 SparseVector **objCoef = getObjectiveCoefficients();
03123 SparseVector *obj = objCoef[ abs( idx) - 1];
03124 for(i = 0; i < obj->number; i++){
03125 dvalue += x[ obj->indexes[i]]*(obj->values[ i]);
03126 }
03127
03128 dvalue += m_mdObjectiveConstants[ abs( idx) - 1 ];
03129
03130 *(m_mdObjectiveFunctionValues + ( abs( idx) - 1)) = dvalue;
03131 return *(m_mdObjectiveFunctionValues + ( abs( idx) - 1));
03132 }
03133 }
03134 catch(const ErrorClass& eclass){
03135 throw ErrorClass( eclass.errormsg);
03136 }
03137 }
03138
03139
03140 double *OSInstance::calculateAllConstraintFunctionValues( double* x, double *objLambda, double *conLambda,
03141 bool new_x, int highestOrder){
03142 try{
03143 if( new_x == true || (highestOrder > m_iHighestOrderEvaluated) )
03144 getIterateResults(x, objLambda, conLambda, new_x, highestOrder);
03145 }
03146 catch(const ErrorClass& eclass){
03147 throw ErrorClass( eclass.errormsg);
03148 }
03149 return m_mdConstraintFunctionValues;
03150 }
03151
03152
03153 double *OSInstance::calculateAllConstraintFunctionValues(double* x, bool new_x){
03154 try{
03155 m_iHighestOrderEvaluated = -1;
03156 if( new_x == false) return m_mdConstraintFunctionValues;
03157 int idx, numConstraints;
03158 numConstraints = getConstraintNumber();
03159
03160 for(idx = 0; idx < numConstraints; idx++){
03161 m_mdConstraintFunctionValues[ idx] = calculateFunctionValue(idx, x, new_x);
03162 }
03163
03164 }
03165 catch(const ErrorClass& eclass){
03166 throw ErrorClass( eclass.errormsg);
03167 }
03168 return m_mdConstraintFunctionValues;
03169 }
03170
03171
03172 double *OSInstance::calculateAllObjectiveFunctionValues( double* x, double *objLambda, double *conLambda,
03173 bool new_x, int highestOrder){
03174 try{
03175 if( new_x == true || (highestOrder > m_iHighestOrderEvaluated) )
03176 getIterateResults(x, objLambda, conLambda, new_x, highestOrder);
03177 }
03178 catch(const ErrorClass& eclass){
03179 throw ErrorClass( eclass.errormsg);
03180 }
03181 return m_mdObjectiveFunctionValues;
03182 }
03183
03184
03185 double *OSInstance::calculateAllObjectiveFunctionValues( double* x, bool new_x){
03186 try{
03187 m_iHighestOrderEvaluated = -1;
03188
03189 if( new_x == false) return m_mdObjectiveFunctionValues;
03190 int idx, numObjectives;
03191 numObjectives = getObjectiveNumber();
03192
03193 for(idx = 0; idx < numObjectives; idx++){
03194 m_mdObjectiveFunctionValues[ idx] = calculateFunctionValue(-idx -1, x, new_x);
03195 }
03196 }
03197 catch(const ErrorClass& eclass){
03198 throw ErrorClass( eclass.errormsg);
03199 }
03200 return m_mdObjectiveFunctionValues;
03201 }
03202
03203
03204 SparseJacobianMatrix *OSInstance::calculateAllConstraintFunctionGradients(double* x, double *objLambda, double *conLambda,
03205 bool new_x, int highestOrder){
03206 try{
03207 if(highestOrder < 1 ) throw ErrorClass("When calling calculateAllConstraintFunctionGradients highestOrder should be 1 or 2");
03208 if( new_x == true || (highestOrder > m_iHighestOrderEvaluated) )
03209 getIterateResults(x, objLambda, conLambda, new_x, highestOrder);
03210 }
03211 catch(const ErrorClass& eclass){
03212 throw ErrorClass( eclass.errormsg);
03213 }
03214 return m_sparseJacMatrix;
03215 }
03216
03217
03218
03219 SparseVector *OSInstance::calculateConstraintFunctionGradient(double* x, double *objLambda, double *conLambda,
03220 int idx, bool new_x, int highestOrder){
03221 try{
03222 if(highestOrder < 1 ) throw ErrorClass("When calling calculateConstraintFunctionGradient highestOrder should be 1 or 2");
03223 if(idx < 0 || idx >= instanceData->constraints->numberOfConstraints )
03224 throw ErrorClass("invalid index passed to calculateConstraintFunctionGrad");
03225 SparseVector *sp;
03226 sp = new SparseVector();
03227 sp->bDeleteArrays = true;
03228 int i;
03229 if( new_x == true || (highestOrder > m_iHighestOrderEvaluated) )
03230 getIterateResults(x, objLambda, conLambda, new_x, highestOrder);
03231 sp->number = m_miJacStart[ idx + 1] - m_miJacStart[ idx];
03232 sp->values = new double[ sp->number];
03233 sp->indexes = new int[ sp->number];
03234 for(i = 0; i < sp->number; i++){
03235 sp->values[ i] = m_mdJacValue[ m_miJacStart[ idx] + i];
03236 sp->indexes[ i] = m_miJacIndex[ m_miJacStart[ idx] + i];
03237 }
03238 return sp;
03239 }
03240 catch(const ErrorClass& eclass){
03241 throw ErrorClass( eclass.errormsg);
03242 }
03243 }
03244
03245
03246 SparseVector *OSInstance::calculateConstraintFunctionGradient(double* x, int idx, bool new_x){
03247 try{
03248 if(idx < 0 || idx >= instanceData->constraints->numberOfConstraints )
03249 throw ErrorClass("invalid index passed to calculateConstraintFunctionGrad");
03250 SparseVector *sp;
03251 sp = new SparseVector();
03252 sp->bDeleteArrays = true;
03253 int i;
03254 if( new_x == true || (1 > m_iHighestOrderEvaluated) )
03255 getIterateResults(x, NULL, NULL, new_x, 1);
03256 sp->number = m_miJacStart[ idx + 1] - m_miJacStart[ idx];
03257 sp->values = new double[ sp->number];
03258 sp->indexes = new int[ sp->number];
03259 for(i = 0; i < sp->number; i++){
03260 sp->values[ i] = m_mdJacValue[ m_miJacStart[ idx] + i];
03261 sp->indexes[ i] = m_miJacIndex[ m_miJacStart[ idx] + i];
03262 }
03263 return sp;
03264 }
03265 catch(const ErrorClass& eclass){
03266 throw ErrorClass( eclass.errormsg);
03267 }
03268 }
03269
03270
03271 double **OSInstance::calculateAllObjectiveFunctionGradients(double* x, double *objLambda, double *conLambda,
03272 bool new_x, int highestOrder){
03273 try{
03274 if(highestOrder < 1 ) throw ErrorClass("When calling calculateAllObjectiveFunctionGradients highestOrder should be 1 or 2");
03275 if( new_x == true || (highestOrder > m_iHighestOrderEvaluated) ) {
03276 std::map<int, OSExpressionTree*>::iterator posMapExpTree;
03277 for(posMapExpTree = m_mapExpressionTreesMod.begin(); posMapExpTree != m_mapExpressionTreesMod.end(); ++posMapExpTree){
03278 if(posMapExpTree->first < 0){
03279 m_mmdObjGradient[ abs( posMapExpTree->first) - 1 ] = calculateObjectiveFunctionGradient(x, objLambda, conLambda,
03280 posMapExpTree->first, new_x, highestOrder);
03281 }
03282 }
03283 }
03284 }
03285 catch(const ErrorClass& eclass){
03286 throw ErrorClass( eclass.errormsg);
03287 }
03288 return m_mmdObjGradient;
03289 }
03290
03291 double *OSInstance::calculateObjectiveFunctionGradient(double* x, double *objLambda, double *conLambda,
03292 int objIdx, bool new_x, int highestOrder){
03293
03294
03295
03296 try{
03297 if(highestOrder < 1 ) throw ErrorClass("When calling calculateObjectiveFunctionGradient highestOrder should be 1 or 2");
03298 if( new_x == true || (highestOrder > m_iHighestOrderEvaluated) ) {
03299 int domainIdx = 0;
03300 std::map<int, OSExpressionTree*>::iterator posMapExpTree;
03301 std::map<int, int>::iterator posVarIndexMap;
03302 int iHighestOrderEvaluatedStore;
03303 unsigned int i;
03304 iHighestOrderEvaluatedStore = m_iHighestOrderEvaluated;
03305 for(posMapExpTree = m_mapExpressionTreesMod.begin(); posMapExpTree != m_mapExpressionTreesMod.end(); ++posMapExpTree){
03306
03307 if(posMapExpTree->first == objIdx){
03308 if( new_x == true ){
03309 if( m_vdX.size() > 0) m_vdX.clear();
03310 for(posVarIndexMap = m_mapAllNonlinearVariablesIndex.begin(); posVarIndexMap != m_mapAllNonlinearVariablesIndex.end(); ++posVarIndexMap){
03311 m_vdX.push_back( x[ posVarIndexMap->first]) ;
03312 }
03313 if( (m_bOSADFunIsCreated == false || m_bCppADMustReTape == true ) && (m_mapExpressionTreesMod.size() > 0) ) {
03314 createOSADFun( m_vdX);
03315 }
03316 }
03317
03318 if(( new_x == true ) || (m_iHighestOrderEvaluated < 0) )this->forwardAD(0, m_vdX);
03319
03320 if(( new_x == true ) || (m_iHighestOrderEvaluated < 1) ) {
03321 m_vdRangeUnitVec[ domainIdx] = 1.;
03322 m_vdYjacval = this->reverseAD(1, m_vdRangeUnitVec);
03323 for(i = 0; i < m_iNumberOfNonlinearVariables; i++){
03324 m_mmdObjGradient[ abs( objIdx) - 1 ][ m_miNonLinearVarsReverseMap[ i]] = m_vdYjacval[ i] +
03325 m_mmdDenseObjectiveCoefficients[ abs( objIdx) - 1][ m_miNonLinearVarsReverseMap[ i]];
03326 }
03327 }
03328 m_iHighestOrderEvaluated = iHighestOrderEvaluatedStore;
03329 m_vdRangeUnitVec[ domainIdx] = 0.;
03330
03331 break;
03332 }
03333 domainIdx++;
03334 }
03335 }
03336 }
03337 catch(const ErrorClass& eclass){
03338 throw ErrorClass( eclass.errormsg);
03339 }
03340 return m_mmdObjGradient[abs( objIdx) - 1];
03341 }
03342
03343
03344 double *OSInstance::calculateObjectiveFunctionGradient(double* x, int objIdx, bool new_x){
03345 try{
03346 int domainIdx = 0;
03347 std::map<int, OSExpressionTree*>::iterator posMapExpTree;
03348 std::map<int, int>::iterator posVarIndexMap;
03349 unsigned int i;
03350 int iHighestOrderEvaluatedStore;
03351 iHighestOrderEvaluatedStore = m_iHighestOrderEvaluated;
03352 for(posMapExpTree = m_mapExpressionTreesMod.begin(); posMapExpTree != m_mapExpressionTreesMod.end(); ++posMapExpTree){
03353 if(posMapExpTree->first == objIdx){
03354 if( new_x == true ){
03355 if( m_vdX.size() > 0) m_vdX.clear();
03356 for(posVarIndexMap = m_mapAllNonlinearVariablesIndex.begin(); posVarIndexMap != m_mapAllNonlinearVariablesIndex.end(); ++posVarIndexMap){
03357 m_vdX.push_back( x[ posVarIndexMap->first]) ;
03358 }
03359 if( (m_bOSADFunIsCreated == false || m_bCppADMustReTape == true ) && (m_mapExpressionTreesMod.size() > 0) ) {
03360 createOSADFun( m_vdX);
03361 }
03362 }
03363
03364 if(( new_x == true ) || (m_iHighestOrderEvaluated < 0) )this->forwardAD(0, m_vdX);
03365
03366 if(( new_x == true ) || (m_iHighestOrderEvaluated < 1) ) {
03367 m_vdRangeUnitVec[ domainIdx] = 1.;
03368 m_vdYjacval = this->reverseAD(1, m_vdRangeUnitVec);
03369 for(i = 0; i < m_iNumberOfNonlinearVariables; i++){
03370 m_mmdObjGradient[ abs( objIdx) - 1 ][ m_miNonLinearVarsReverseMap[ i]] = m_vdYjacval[ i] +
03371 m_mmdDenseObjectiveCoefficients[ abs( objIdx) - 1][ m_miNonLinearVarsReverseMap[ i]];
03372 }
03373 }
03374 m_iHighestOrderEvaluated = iHighestOrderEvaluatedStore;
03375 m_vdRangeUnitVec[ domainIdx] = 0.;
03376
03377 break;
03378 }
03379 domainIdx++;
03380 }
03381 }
03382 catch(const ErrorClass& eclass){
03383 throw ErrorClass( eclass.errormsg);
03384 }
03385 return m_mmdObjGradient[abs( objIdx) - 1];
03386 }
03387
03388 SparseHessianMatrix *OSInstance::calculateLagrangianHessian( double* x, double *objLambda, double *conLambda,
03389 bool new_x, int highestOrder){
03390 try{
03391 if(highestOrder != 2 ) throw ErrorClass("When calling calculateLagrangianHessian highestOrder should be 2");
03392 if( new_x == true || (highestOrder > m_iHighestOrderEvaluated) ) {
03393
03394 getIterateResults(x, objLambda, conLambda, new_x, highestOrder);
03395 }
03396 }
03397 catch(const ErrorClass& eclass){
03398 throw ErrorClass( eclass.errormsg);
03399 }
03400 return m_LagrangianSparseHessian;
03401 }
03402
03403 SparseHessianMatrix *OSInstance::calculateHessian(double* x, int idx, bool new_x){
03404 try{
03405 if(idx < -instanceData->objectives->numberOfObjectives || idx >= instanceData->constraints->numberOfConstraints )
03406 throw ErrorClass("invalid index passed to calculateHessian");
03407 double *objLambda = new double[ getObjectiveNumber() ];
03408 double *conLambda = new double[ getConstraintNumber() ];
03409
03410
03411 int i;
03412
03413 for(i = 0; i < getObjectiveNumber(); i++){
03414 objLambda[ i] = 0.0;
03415 }
03416 for(i = 0; i < getConstraintNumber(); i++){
03417 conLambda[ i] = 0.0;
03418 }
03419
03420
03421 if(idx < 0){
03422 objLambda[ abs(idx) - 1] = 1.0;
03423 }
03424 else{
03425 conLambda[ idx] = 1.0;
03426 }
03427 if( new_x == true || (2 > m_iHighestOrderEvaluated) ) {
03428 getIterateResults(x, objLambda, conLambda, new_x, 2);
03429
03430 }
03431 delete[] objLambda;
03432 delete[] conLambda;
03433 }
03434 catch(const ErrorClass& eclass){
03435 throw ErrorClass( eclass.errormsg);
03436 }
03437 return m_LagrangianSparseHessian;
03438 }
03439
03440
03441
03442 bool OSInstance::getSparseJacobianFromColumnMajor( ){
03443
03444 if( m_bColumnMajor == false) return false;
03445 int iNumRowStarts = getConstraintNumber() + 1;
03446 int i,j, iTemp;
03447 int iNumVariableStarts = getVariableNumber() ;
03448 int *start = NULL;
03449 int *index = NULL;
03450 double *value = NULL;
03451 if(this->instanceData->linearConstraintCoefficients->numberOfValues > 0){
03452 start = this->instanceData->linearConstraintCoefficients->start->el;
03453 index = this->instanceData->linearConstraintCoefficients->rowIdx->el;
03454 value = this->instanceData->linearConstraintCoefficients->value->el;
03455 }
03456 m_miJacStart = new int[ iNumRowStarts];
03457 m_miJacNumConTerms = new int[ getConstraintNumber()];
03458 OSnLNodePlus *nlNodePlus;
03459 OSnLNodeVariable *nlNodeVariable;
03460 OSExpressionTree *expTree = NULL;
03461
03462 for ( i = 0; i < iNumRowStarts; i++){
03463 m_miJacStart [ i ] = 0;
03464
03465 if( m_mapExpressionTreesMod.find( i) != m_mapExpressionTreesMod.end() ){
03466
03467 m_mapExpressionTreesMod[ i]->getVariableIndiciesMap();
03468
03469 }
03470 }
03471
03472 if(this->instanceData->linearConstraintCoefficients->numberOfValues > 0){
03473
03474 for (i = 0; i < iNumVariableStarts; i++){
03475 for (j = start[i]; j < start[ i + 1 ]; j++){
03476
03477
03478
03479
03480
03481
03482 if( (m_mapExpressionTreesMod.find( index[ j]) != m_mapExpressionTreesMod.end() ) &&
03483 ( (*m_mapExpressionTreesMod[ index[ j]]->mapVarIdx).find( i) != (*m_mapExpressionTreesMod[ index[ j]]->mapVarIdx).end()) ){
03484
03485
03486
03487
03488 if( value[j] > 0 || value[j] < 0){
03489 expTree = m_mapExpressionTreesMod[ index[j] ];
03490 nlNodeVariable = new OSnLNodeVariable();
03491 nlNodeVariable->coef = value[ j];
03492 nlNodeVariable->idx = i;
03493 nlNodePlus = new OSnLNodePlus();
03494 nlNodePlus->m_mChildren[ 0] = m_mapExpressionTreesMod[ index[ j] ]->m_treeRoot;
03495 nlNodePlus->m_mChildren[ 1] = nlNodeVariable;
03496
03497 expTree->m_treeRoot = nlNodePlus ;
03498
03499
03500
03501
03502 }
03503 }
03504 else{
03505 m_miJacStart[ index[j] + 1] ++;
03506 }
03507 }
03508 }
03509 }
03510
03511
03512
03513
03514 m_miJacStart[0] = 0;
03515 for (i = 1; i < iNumRowStarts; i++ ){
03516 m_miJacNumConTerms[ i - 1] = m_miJacStart[i];
03517 if( m_mapExpressionTreesMod.find( i - 1) != m_mapExpressionTreesMod.end() ){
03518 m_miJacStart[i] += (m_miJacStart[i - 1] + (*m_mapExpressionTreesMod[ i - 1]->mapVarIdx).size() );
03519 }
03520 else{
03521 m_miJacStart[i] += m_miJacStart[i - 1];
03522 }
03523 }
03524
03525 m_iJacValueSize = m_miJacStart[ iNumRowStarts - 1];
03526 m_miJacIndex = new int[ m_iJacValueSize];
03527 m_mdJacValue = new double[ m_iJacValueSize ];
03528
03529 if(this->instanceData->linearConstraintCoefficients->numberOfValues > 0){
03530
03531 for (i = 0; i < iNumVariableStarts; i++){
03532
03533
03534 for (j = start[i]; j < start[ i + 1 ]; j++){
03535
03536
03537 if( (m_mapExpressionTreesMod.find( index[ j]) == m_mapExpressionTreesMod.end() ) ||
03538 ( (*m_mapExpressionTreesMod[ index[ j]]->mapVarIdx).find( i) == (*m_mapExpressionTreesMod[ index[ j]]->mapVarIdx).end()) ){
03539 iTemp = m_miJacStart[ index[j]];
03540 m_miJacIndex[ iTemp] = i;
03541 m_mdJacValue[ iTemp] = value[j];
03542 m_miJacStart[ index[j]]++;
03543 }
03544 }
03545 }
03546 }
03547
03548 std::map<int, int>::iterator posVarIdx;
03549
03550 for (i = 0; i < iNumRowStarts - 1; i++ ){
03551 m_miJacStart[ i] = m_miJacStart [ i] - m_miJacNumConTerms[ i] ;
03552 iTemp = m_miJacStart[ i] + m_miJacNumConTerms[ i];
03553
03554 if( m_mapExpressionTreesMod.find( i) != m_mapExpressionTreesMod.end() ){
03555 for(posVarIdx = (*m_mapExpressionTreesMod[ i]->mapVarIdx).begin(); posVarIdx
03556 != (*m_mapExpressionTreesMod[ i]->mapVarIdx).end(); ++posVarIdx){
03557 m_miJacIndex[ iTemp] = posVarIdx->first;
03558 m_mdJacValue[ iTemp] = 0;
03559 iTemp++;
03560 }
03561 }
03562 }
03563 #ifdef DEBUG
03564 std::cout << "HERE ARE ROW STARTS:" << std::endl;
03565 for (i = 0; i < iNumRowStarts; i++ ){
03566 std::cout << m_miJacStart[ i] << " ";
03567 }
03568 std::cout << std::endl << std::endl;
03569 std::cout << "HERE ARE VARIABLE INDICIES:" << std::endl;
03570 for (i = 0; i < m_miJacStart[ iNumRowStarts - 1]; i++ ){
03571 std::cout << m_miJacIndex[ i] << " ";
03572 }
03573 std::cout << std::endl << std::endl;
03574 std::cout << "HERE ARE VALUES:" << std::endl;
03575 for (i = 0; i < m_miJacStart[ iNumRowStarts - 1]; i++ ){
03576 std::cout << m_mdJacValue[ i] << " ";
03577 }
03578 std::cout << std::endl << std::endl;
03579
03580 std::cout << "HERE ARE NUMBER OF CONSTANT TERMS:" << std::endl;
03581 for (i = 0; i < iNumRowStarts - 1; i++ ){
03582 std::cout << m_miJacNumConTerms[ i ] << " ";
03583 }
03584 std::cout << std::endl << std::endl;
03585 #endif
03586 return true;
03587 }
03588
03589
03590
03591 bool OSInstance::getSparseJacobianFromRowMajor( ){
03592
03593 if( m_bColumnMajor == true) return false;
03594 int iNumJacRowStarts = getConstraintNumber() + 1;
03595 std::map<int, int>::iterator posVarIdx;
03596 int i,j, k;
03597 int *start = NULL;
03598 int *index = NULL;
03599 double *value = NULL;
03600 if(this->instanceData->linearConstraintCoefficients->numberOfValues > 0){
03601 start = this->instanceData->linearConstraintCoefficients->start->el;
03602 index = this->instanceData->linearConstraintCoefficients->colIdx->el;
03603 value = this->instanceData->linearConstraintCoefficients->value->el;
03604 }
03605 m_miJacStart = new int[ iNumJacRowStarts];
03606 m_miJacNumConTerms = new int[ getConstraintNumber()];
03607 OSnLNodePlus *nlNodePlus;
03608 OSnLNodeVariable *nlNodeVariable;
03609
03610
03611 for ( i = 0; i < iNumJacRowStarts; i++){
03612 m_miJacStart [ i ] = 0;
03613
03614 if( m_mapExpressionTreesMod.find( i) != m_mapExpressionTreesMod.end() ){
03615
03616 m_mapExpressionTreesMod[ i]->getVariableIndiciesMap();
03617
03618 }
03619 }
03620 int loopLimit = getConstraintNumber();
03621
03622
03623 if(this->instanceData->linearConstraintCoefficients->numberOfValues > 0){
03624
03625 for (i = 0; i < loopLimit; i++){
03626 m_miJacNumConTerms[ i] = 0;
03627 for (j = start[i]; j < start[ i + 1 ]; j++){
03628
03629
03630
03631 if( (m_mapExpressionTreesMod.find( i) != m_mapExpressionTreesMod.end() ) &&
03632 ( (*m_mapExpressionTreesMod[ i]->mapVarIdx).find( index[ j]) != (*m_mapExpressionTreesMod[ i]->mapVarIdx).end()) ){
03633
03634
03635
03636 if(value[ j] > 0 || value[j] < 0){
03637 nlNodeVariable = new OSnLNodeVariable();
03638 nlNodeVariable->coef = value[ j];
03639 nlNodeVariable->idx = index[ j];
03640 nlNodePlus = new OSnLNodePlus();
03641 nlNodePlus->m_mChildren[ 0] = m_mapExpressionTreesMod[ i ]->m_treeRoot;
03642 nlNodePlus->m_mChildren[ 1] = nlNodeVariable;
03643
03644
03645
03646
03647 m_mapExpressionTreesMod[ i ]->m_treeRoot = nlNodePlus;
03648 }
03649 }
03650 else{
03651
03652 m_miJacNumConTerms[ i]++;
03653 }
03654 }
03655 }
03656 }
03657
03658 m_miJacStart[0] = 0;
03659 for (i = 1; i < iNumJacRowStarts; i++ ){
03660 if( m_mapExpressionTreesMod.find( i - 1) != m_mapExpressionTreesMod.end() ){
03661 m_miJacStart[i] = m_miJacStart[i - 1] + (m_miJacNumConTerms[ i - 1] + (*m_mapExpressionTreesMod[ i - 1]->mapVarIdx).size() );
03662 }
03663 else{
03664 m_miJacStart[i] = m_miJacStart[i - 1] + m_miJacNumConTerms[ i - 1];
03665 }
03666 }
03667
03668
03669 m_iJacValueSize = m_miJacStart[ iNumJacRowStarts - 1];
03670 m_miJacIndex = new int[ m_iJacValueSize];
03671 m_mdJacValue = new double[ m_iJacValueSize ];
03672
03673
03674 if(this->instanceData->linearConstraintCoefficients->numberOfValues > 0){
03675 for (i = 0; i < loopLimit; i++){
03676 k = 0;
03677 for (j = start[i]; j < start[ i + 1 ]; j++){
03678 if( (m_mapExpressionTreesMod.find( i) == m_mapExpressionTreesMod.end() ) ||
03679 ( (*m_mapExpressionTreesMod[ i]->mapVarIdx).find( index[ j]) == (*m_mapExpressionTreesMod[ i]->mapVarIdx).end()) ){
03680 m_miJacIndex[ m_miJacStart[i] + k ] = index[ j];
03681 m_mdJacValue[ m_miJacStart[i] + k ] = value[ j];
03682 k++;
03683 }
03684 }
03685 }
03686 }
03687
03688 for (i = 0; i < loopLimit; i++ ){
03689 k = m_miJacStart[i] + m_miJacNumConTerms[ i ];
03690
03691 if( m_mapExpressionTreesMod.find( i) != m_mapExpressionTreesMod.end() ){
03692 for(posVarIdx = (*m_mapExpressionTreesMod[ i]->mapVarIdx).begin(); posVarIdx
03693 != (*m_mapExpressionTreesMod[ i]->mapVarIdx).end(); ++posVarIdx){
03694 m_miJacIndex[ k] = posVarIdx->first;
03695 m_mdJacValue[ k] = 0;
03696 k++;
03697 }
03698 }
03699 }
03700 #ifdef DEBUG
03701 std::cout << "HERE ARE ROW STARTS:" << std::endl;
03702 for (i = 0; i < iNumJacRowStarts; i++ ){
03703 std::cout << m_miJacStart[ i] << " ";
03704 }
03705 std::cout << std::endl << std::endl;
03706 std::cout << "HERE ARE VARIABLE INDICIES:" << std::endl;
03707 for (i = 0; i < m_miJacStart[ iNumJacRowStarts - 1]; i++ ){
03708 std::cout << m_miJacIndex[ i] << " ";
03709 }
03710 std::cout << std::endl << std::endl;
03711 std::cout << "HERE ARE VALUES:" << std::endl;
03712 for (i = 0; i < m_miJacStart[ iNumJacRowStarts - 1]; i++ ){
03713 std::cout << m_mdJacValue[ i] << " ";
03714 }
03715 std::cout << std::endl << std::endl;
03716
03717 std::cout << "HERE ARE NUMBER OF CONSTANT TERMS:" << std::endl;
03718 for (i = 0; i < iNumJacRowStarts - 1; i++ ){
03719 std::cout << m_miJacNumConTerms[ i ] << " ";
03720 }
03721 std::cout << std::endl << std::endl;
03722 #endif
03723 return true;
03724 }
03725
03726 OSExpressionTree* OSInstance::getLagrangianExpTree( ){
03727 if( m_bLagrangianExpTreeCreated == true) return m_LagrangianExpTree;
03728
03729
03730
03731 if(m_bSparseJacobianCalculated == false) getJacobianSparsityPattern( );
03732 std::map<int, OSExpressionTree*>::iterator posMapExpTree;
03733 OSnLNodeTimes* nlNodeTimes = NULL;
03734 OSnLNodeVariable* nlNodeVariable = NULL;
03735 OSnLNodeSum* nlNodeSum = NULL;
03736 int numChildren = 0;
03737 int rowIdx;
03738
03739 nlNodeSum = new OSnLNodeSum();
03740 nlNodeSum->inumberOfChildren = m_mapExpressionTreesMod.size();
03741 nlNodeSum->m_mChildren = new OSnLNode*[ nlNodeSum->inumberOfChildren];
03742
03743 m_LagrangianExpTree = new OSExpressionTree();
03744 m_LagrangianExpTree->m_treeRoot = nlNodeSum;
03745
03746 for(posMapExpTree = m_mapExpressionTreesMod.begin(); posMapExpTree != m_mapExpressionTreesMod.end(); ++posMapExpTree){
03747
03748 nlNodeVariable = new OSnLNodeVariable();
03749 nlNodeVariable->coef = 1.;
03750
03751
03752 rowIdx = posMapExpTree->first;
03753 if(rowIdx >= 0){
03754 nlNodeVariable->idx = instanceData->variables->numberOfVariables + rowIdx;
03755 }
03756 else{
03757 nlNodeVariable->idx = instanceData->variables->numberOfVariables +
03758 instanceData->constraints->numberOfConstraints + (abs(rowIdx) - 1);
03759 }
03760
03761 nlNodeTimes = new OSnLNodeTimes();
03762 nlNodeTimes->m_mChildren[ 0] = nlNodeVariable;
03763 nlNodeTimes->m_mChildren[ 1] = m_mapExpressionTreesMod[ posMapExpTree->first ]->m_treeRoot;
03764
03765 nlNodeSum->m_mChildren[ numChildren] = nlNodeTimes;
03766 numChildren++;
03767 }
03768
03769 m_LagrangianExpTree->getVariableIndiciesMap();
03770
03771
03772
03773
03774 m_bLagrangianExpTreeCreated = true;
03775 return m_LagrangianExpTree;
03776 }
03777
03778 std::map<int, int> OSInstance::getAllNonlinearVariablesIndexMap( ){
03779 if(m_bAllNonlinearVariablesIndex == true) return m_mapAllNonlinearVariablesIndex;
03780
03781
03782 std::map<int, OSExpressionTree*>::iterator posMapExpTree;
03783 std::map<int, int>::iterator posVarIdx;
03784 OSExpressionTree *expTree;
03785 for(posMapExpTree = m_mapExpressionTreesMod.begin(); posMapExpTree != m_mapExpressionTreesMod.end(); ++posMapExpTree){
03786
03787 expTree = posMapExpTree->second;
03788 if(expTree->m_bIndexMapGenerated == false)expTree->getVariableIndiciesMap();
03789 for(posVarIdx = (*expTree->mapVarIdx).begin(); posVarIdx != (*expTree->mapVarIdx).end(); ++posVarIdx){
03790 if( m_mapAllNonlinearVariablesIndex.find( posVarIdx->first) == m_mapAllNonlinearVariablesIndex.end() ){
03791
03792 m_mapAllNonlinearVariablesIndex[ posVarIdx->first] = 1;
03793 }
03794 }
03795 }
03796 m_miNonLinearVarsReverseMap = new int[m_mapAllNonlinearVariablesIndex.size()];
03797
03798 int kount = 0;
03799
03800 for(posVarIdx = m_mapAllNonlinearVariablesIndex.begin(); posVarIdx !=m_mapAllNonlinearVariablesIndex.end(); ++posVarIdx){
03801 posVarIdx->second = kount;
03802 m_miNonLinearVarsReverseMap[ kount] = posVarIdx->first;
03803 kount++;
03804 #ifdef DEBUG
03805 std::cout << "POSITION FIRST = " << posVarIdx->first ;
03806 std::cout << " POSITION SECOND = " << posVarIdx->second << std::endl;
03807 #endif
03808 }
03809 m_iNumberOfNonlinearVariables = kount;
03810
03811 m_bAllNonlinearVariablesIndex = true;
03812 return m_mapAllNonlinearVariablesIndex;
03813 }
03814
03815 SparseHessianMatrix* OSInstance::getLagrangianHessianSparsityPattern( ){
03816
03817 if( m_bLagrangianSparseHessianCreated == true) return m_LagrangianSparseHessian;
03818 if( m_iNumberOfNonlinearVariables == 0) return NULL;
03819 if( m_binitForAlgDiff == false ) initForAlgDiff();
03820 unsigned int i = 0;
03821 unsigned int j;
03822 int numNonz = 0;
03823
03824
03825 std::vector<double> vx;
03826 std::map<int, int>::iterator posMap1, posMap2;
03827 if( (m_bOSADFunIsCreated == false || m_bCppADMustReTape == true ) && (m_mapExpressionTreesMod.size() > 0) ) {
03828 for(posMap1 = m_mapAllNonlinearVariablesIndex.begin(); posMap1 != m_mapAllNonlinearVariablesIndex.end(); ++posMap1){
03829 vx.push_back( 1.0) ;
03830 }
03831 createOSADFun( vx);
03832 }
03833
03834
03835
03836
03837
03838
03839
03840
03841
03842
03843
03844
03845
03846
03847
03848
03849
03850
03851
03852
03853
03854
03855
03856
03857
03858
03859
03860
03861
03862
03863
03864
03865
03866
03867 numNonz = getADSparsityHessian();
03868
03869
03870 i = 0;
03871
03872 m_LagrangianSparseHessian = new SparseHessianMatrix();
03873 m_LagrangianSparseHessian->bDeleteArrays = true;
03874 m_LagrangianSparseHessian->hessDimension = numNonz;
03875
03876 m_LagrangianSparseHessian->hessRowIdx = new int[m_LagrangianSparseHessian->hessDimension];
03877 m_LagrangianSparseHessian->hessColIdx = new int[m_LagrangianSparseHessian->hessDimension];
03878 m_LagrangianSparseHessian->hessValues = new double[m_LagrangianSparseHessian->hessDimension];
03879
03880 numNonz = 0;
03881 for(posMap1 = m_mapAllNonlinearVariablesIndex.begin(); posMap1 != m_mapAllNonlinearVariablesIndex.end(); ++posMap1){
03882
03883 j = i;
03884 for(posMap2 = posMap1; posMap2 != m_mapAllNonlinearVariablesIndex.end(); ++posMap2){
03885
03886 if(m_vbLagHessNonz[ i*m_iNumberOfNonlinearVariables + j] == true){
03887 *(m_LagrangianSparseHessian->hessRowIdx + numNonz) = posMap1->first;
03888 *(m_LagrangianSparseHessian->hessColIdx + numNonz) = posMap2->first;
03889 numNonz++;
03890 }
03891
03892 j++;
03893 }
03894 i++;
03895 }
03896 #ifdef DEBUG
03897 std::cout << "HESSIAN SPARSITY PATTERN" << std::endl;
03898 int kj;
03899 for(kj = 0; kj < m_LagrangianSparseHessian->hessDimension; kj++){
03900 std::cout << "Row Index = " << *(m_LagrangianSparseHessian->hessRowIdx + kj) << std::endl;
03901 std::cout << "Column Index = " << *(m_LagrangianSparseHessian->hessColIdx + kj) << std::endl;
03902 }
03903 #endif
03904
03905 m_bLagrangianSparseHessianCreated = true;
03906 return m_LagrangianSparseHessian;
03907 }
03908
03909
03910 void OSInstance::duplicateExpressionTreesMap(){
03911
03912
03913 if(m_bDuplicateExpressionTreesMap == false){
03914
03915 if( m_bProcessExpressionTrees == false) getAllNonlinearExpressionTrees();
03916 m_mapExpressionTreesMod = m_mapExpressionTrees;
03917 m_bDuplicateExpressionTreesMap = true;
03918 return;
03919 }
03920 else{
03921 return;
03922 }
03923 }
03924
03925
03926
03927 bool OSInstance::getIterateResults( double *x, double *objLambda, double* conMultipliers,
03928 bool new_x, int highestOrder){
03929 try{
03930 if( m_binitForAlgDiff == false) initForAlgDiff();
03931 std::map<int, int>::iterator posVarIndexMap;
03932
03933 if(new_x == true){
03934 if( m_vdX.size() > 0) m_vdX.clear();
03935 for(posVarIndexMap = m_mapAllNonlinearVariablesIndex.begin(); posVarIndexMap != m_mapAllNonlinearVariablesIndex.end(); ++posVarIndexMap){
03936 m_vdX.push_back( x[ posVarIndexMap->first]) ;
03937 }
03938 if( (m_bOSADFunIsCreated == false || m_bCppADMustReTape == true ) && (m_mapExpressionTreesMod.size() > 0) ) {
03939 createOSADFun( m_vdX);
03940 }
03941 }
03942 else{
03943 if( m_vdX.size() == 0) {
03944 for(posVarIndexMap = m_mapAllNonlinearVariablesIndex.begin(); posVarIndexMap != m_mapAllNonlinearVariablesIndex.end(); ++posVarIndexMap){
03945 m_vdX.push_back( x[ posVarIndexMap->first]) ;
03946 }
03947 if( (m_bOSADFunIsCreated == false || m_bCppADMustReTape == true ) && (m_mapExpressionTreesMod.size() > 0) ) {
03948 createOSADFun( m_vdX);
03949 }
03950 }
03951 }
03952 switch( highestOrder){
03953 case 0:
03954 if(new_x == true || m_iHighestOrderEvaluated < 0){
03955 if(bUseExpTreeForFunEval == true){
03956 calculateAllConstraintFunctionValues( x, new_x);
03957 calculateAllObjectiveFunctionValues( x, new_x);
03958 }
03959 else{
03960 getZeroOrderResults(x, objLambda, conMultipliers);
03961 }
03962
03963 }
03964 break;
03965 case 1:
03966 if(new_x == true || m_iHighestOrderEvaluated < 0)
03967 getZeroOrderResults(x, objLambda, conMultipliers);
03968 if(new_x == true || m_iHighestOrderEvaluated < 1)
03969 getFirstOrderResults(x, objLambda, conMultipliers);
03970 break;
03971 case 2:
03972 if(new_x == true || m_iHighestOrderEvaluated < 0)
03973 getZeroOrderResults(x, objLambda, conMultipliers);
03974 if(new_x == true || m_iHighestOrderEvaluated < 2)
03975 getSecondOrderResults(x, objLambda, conMultipliers);
03976 break;
03977 default:
03978 throw ErrorClass("Derivative should be order 0, 1, or 2");
03979 }
03980 return true;
03981 }
03982 catch(const ErrorClass& eclass){
03983 throw ErrorClass( eclass.errormsg);
03984 }
03985 }
03986
03987
03988 bool OSInstance::getZeroOrderResults(double *x, double *objLambda, double *conMultipliers){
03989 try{
03990
03991 int i, j, rowNum, objNum;
03992 if( m_mapExpressionTreesMod.size() > 0){
03993 m_vdYval = this->forwardAD(0, m_vdX);
03994 }
03995
03996 for(rowNum = 0; rowNum < m_iConstraintNumber; rowNum++){
03997 m_mdConstraintFunctionValues[ rowNum] = 0.0;
03998 if( m_mapExpressionTreesMod.find( rowNum) != m_mapExpressionTreesMod.end() ){
03999 m_mdConstraintFunctionValues[ rowNum] = m_vdYval[ m_mapOSADFunRangeIndex[ rowNum]];
04000 }
04001
04002
04003 i = m_sparseJacMatrix->starts[ rowNum];
04004 j = m_sparseJacMatrix->starts[ rowNum + 1 ];
04005 while ( (i - m_sparseJacMatrix->starts[ rowNum]) < m_sparseJacMatrix->conVals[ rowNum] ){
04006 m_mdConstraintFunctionValues[ rowNum] += m_sparseJacMatrix->values[ i]*x[ m_sparseJacMatrix->indexes[ i] ];
04007 i++;
04008 }
04009
04010 m_mdConstraintFunctionValues[ rowNum] += m_mdConstraintConstants[ rowNum ];
04011 #ifdef DEBUG
04012 std::cout << "Constraint " << rowNum << " function value = " << m_mdConstraintFunctionValues[ rowNum ] << std::endl;
04013 #endif
04014 }
04015
04016 for(objNum = 0; objNum < m_iObjectiveNumber; objNum++){
04017 m_mdObjectiveFunctionValues[ objNum] = 0.0;
04018 if( m_mapExpressionTreesMod.find( -objNum -1) != m_mapExpressionTreesMod.end() ){
04019 m_mdObjectiveFunctionValues[ objNum] = m_vdYval[ objNum];
04020 }
04021 for(i = 0; i < m_iVariableNumber; i++){
04022 m_mdObjectiveFunctionValues[ objNum] += m_mmdDenseObjectiveCoefficients[ objNum][i]*x[ i];
04023 }
04024 #ifdef DEBUG
04025 std::cout << "Objective " << objNum << " function value = " << m_mdObjectiveFunctionValues[ objNum] << std::endl;
04026 #endif
04027 }
04028 return true;
04029 }
04030 catch(const ErrorClass& eclass){
04031 throw ErrorClass( eclass.errormsg);
04032 }
04033 }
04034
04035
04036
04037 bool OSInstance::getFirstOrderResults(double *x, double *objLambda, double *conMultipliers){
04038 try{
04039
04040 unsigned int i, j;
04041 int rowNum, jacIndex;
04042 unsigned int jstart, jend;
04043 int idx;
04044 OSExpressionTree *expTree = NULL;
04045 int domainIdx = 0;
04046 std::map<int, OSExpressionTree*>::iterator posMapExpTree;
04047 std::map<int, int>::iterator posVarIdx;
04048
04054 if(m_iNumberOfNonlinearVariables >= m_mapExpressionTreesMod.size() ){
04055
04056
04057 for(posMapExpTree = m_mapExpressionTreesMod.begin(); posMapExpTree != m_mapExpressionTreesMod.end(); ++posMapExpTree){
04058 idx = posMapExpTree->first;
04059
04060 if(idx >= 0){
04061 m_vdRangeUnitVec[ domainIdx] = 1.;
04062 m_mapExpressionTreesMod[ idx]->getVariableIndiciesMap();
04063 m_vdYjacval = this->reverseAD(1, m_vdRangeUnitVec);
04064
04065 jstart = m_miJacStart[ idx] + m_miJacNumConTerms[ idx];
04066 jend = m_miJacStart[ idx + 1 ];
04067 if( (*m_mapExpressionTreesMod[ idx]->mapVarIdx).size() != (jend - jstart)) throw
04068 ErrorClass("number of partials not consistent");
04069 j = 0;
04070 jacIndex = 0;
04071 for(posVarIdx = m_mapAllNonlinearVariablesIndex.begin(); posVarIdx
04072 != m_mapAllNonlinearVariablesIndex.end(); ++posVarIdx){
04073
04074
04075
04076
04077
04078 if( (*m_mapExpressionTreesMod[ idx]->mapVarIdx).find( posVarIdx->first) != (*m_mapExpressionTreesMod[ idx]->mapVarIdx).end()){
04079 m_mdJacValue[ jstart] = m_vdYjacval[ jacIndex];
04080 jstart++;
04081 j++;
04082 }
04083 jacIndex++;
04084 }
04085
04086 m_vdRangeUnitVec[ domainIdx] = 0.;
04087 domainIdx++;
04088 }
04089 else{
04090
04091
04092 domainIdx++;
04093 }
04094 }
04095 }
04096 else{
04097
04098 for(i = 0; i < m_iNumberOfNonlinearVariables; i++){
04099 m_vdDomainUnitVec[i] = 1.;
04100 rowNum = 0;
04101 if( m_mapExpressionTreesMod.size() > 0){
04102 m_vdYjacval = this->forwardAD(1, m_vdDomainUnitVec);
04103 }
04104
04105
04106 for(posMapExpTree = m_mapExpressionTreesMod.begin(); posMapExpTree != m_mapExpressionTreesMod.end(); ++posMapExpTree){
04107 idx = posMapExpTree->first;
04108
04109 if(idx >= 0){
04110
04111
04112
04113
04114 expTree = m_mapExpressionTreesMod[ idx];
04115 if( (*expTree->mapVarIdx).find( m_miNonLinearVarsReverseMap[ i]) != (*expTree->mapVarIdx).end() ){
04116 jacIndex = (*m_mapExpressionTreesMod[ idx]->mapVarIdx)[ m_miNonLinearVarsReverseMap[ i]];
04117 jstart = m_miJacStart[ idx] + m_miJacNumConTerms[ idx];
04118
04119 m_mdJacValue[ jstart + jacIndex] = m_vdYjacval[m_iObjectiveNumberNonlinear + rowNum];
04120 }
04121 rowNum++;
04122 }
04123 }
04124
04125 m_vdDomainUnitVec[i] = 0.;
04126 }
04127 }
04128 #ifdef DEBUG
04129 int k;
04130 std::cout << "JACOBIAN DATA " << std::endl;
04131 for(idx = 0; idx < m_iConstraintNumber; idx++){
04132 for(k = *(m_sparseJacMatrix->starts + idx); k < *(m_sparseJacMatrix->starts + idx + 1); k++){
04133 std::cout << "row idx = " << idx << " col idx = "<< *(m_sparseJacMatrix->indexes + k)
04134 << " value = " << *(m_sparseJacMatrix->values + k) << std::endl;
04135 }
04136 }
04137 #endif
04138 return true;
04139 }
04140 catch(const ErrorClass& eclass){
04141 throw ErrorClass( eclass.errormsg);
04142 }
04143 }
04144
04145
04146 bool OSInstance::getSecondOrderResults(double *x, double *objLambda, double *conMultipliers){
04147 try{
04148
04149 unsigned int i, j;
04150 int rowNum, jacIndex;
04151 int jstart, idx;
04152 OSExpressionTree *expTree = NULL;
04153 int hessValuesIdx = 0;
04154 if( m_bLagrangianSparseHessianCreated == false) getLagrangianHessianSparsityPattern( );
04155 std::map<int, OSExpressionTree*>::iterator posMapExpTree;
04156 std::map<int, int>::iterator posVarIndexMap;
04157 if( objLambda == NULL) throw ErrorClass("must have a multiplier for the objective function even if zero when calling getSecondOrderResults");
04158 if( conMultipliers == NULL) throw ErrorClass("cannot have a null vector of lagrange multipliers when calling getSecondOrderResults -- okay if zero");
04159 if( m_vdLambda.size() > 0) m_vdLambda.clear();
04160 for(posMapExpTree = m_mapExpressionTreesMod.begin(); posMapExpTree != m_mapExpressionTreesMod.end(); ++posMapExpTree){
04161 if( posMapExpTree->first >= 0){
04162 m_vdLambda.push_back( conMultipliers[ posMapExpTree->first]);
04163 }
04164 else{
04165
04166 m_vdLambda.push_back( objLambda[ abs(posMapExpTree->first) - 1] );
04167 }
04168 }
04169 for(i = 0; i < m_iNumberOfNonlinearVariables; i++){
04170 m_vdDomainUnitVec[i] = 1.;
04171 rowNum = 0;
04172 if( m_mapExpressionTreesMod.size() > 0){
04173 m_vdYjacval = this->forwardAD(1, m_vdDomainUnitVec);
04174 }
04175
04176
04177 for(posMapExpTree = m_mapExpressionTreesMod.begin(); posMapExpTree != m_mapExpressionTreesMod.end(); ++posMapExpTree){
04178 idx = posMapExpTree->first;
04179
04180 if(idx >= 0){
04181
04182
04183
04184
04185 expTree = m_mapExpressionTreesMod[ idx];
04186 if( (*expTree->mapVarIdx).find( m_miNonLinearVarsReverseMap[ i]) != (*expTree->mapVarIdx).end() ){
04187 jacIndex = (*m_mapExpressionTreesMod[ idx]->mapVarIdx)[ m_miNonLinearVarsReverseMap[ i]];
04188 jstart = m_miJacStart[ idx] + m_miJacNumConTerms[ idx];
04189 m_mdJacValue[ jstart + jacIndex] = m_vdYjacval[m_iObjectiveNumberNonlinear + rowNum];
04190 }
04191 rowNum++;
04192 }
04193 else{
04194
04195
04196 m_mmdObjGradient[ (abs( idx) - 1)][ m_miNonLinearVarsReverseMap[ i]] = m_vdYjacval[ (abs( idx) - 1)] +
04197 m_mmdDenseObjectiveCoefficients[ (abs( idx) - 1)][ m_miNonLinearVarsReverseMap[ i]];
04198 }
04199 }
04200
04201 if( m_mapExpressionTreesMod.size() > 0){
04202 m_vdw = reverseAD(2, m_vdLambda);
04203 }
04204 for(j = i; j < m_iNumberOfNonlinearVariables; j++){
04205 if( m_vbLagHessNonz[i*m_iNumberOfNonlinearVariables + j] == true){
04206 m_LagrangianSparseHessian->hessValues[ hessValuesIdx] = m_vdw[ j*2 + 1];
04207 #ifdef DEBUG
04208 std::cout << "reverse 2 " << m_LagrangianSparseHessian->hessValues[ hessValuesIdx] << std::endl;
04209 #endif
04210 hessValuesIdx++;
04211 }
04212 }
04213
04214
04215 m_vdDomainUnitVec[i] = 0.;
04216 }
04217 #ifdef DEBUG
04218 int k;
04219 std::cout << "JACOBIAN DATA " << std::endl;
04220 for(idx = 0; idx < m_iConstraintNumber; idx++){
04221 for(k = *(m_sparseJacMatrix->starts + idx); k < *(m_sparseJacMatrix->starts + idx + 1); k++){
04222 std::cout << "row idx = " << idx << " col idx = "<< *(m_sparseJacMatrix->indexes + k)
04223 << " value = " << *(m_sparseJacMatrix->values + k) << std::endl;
04224 }
04225 }
04226 #endif
04227 return true;
04228 }
04229 catch(const ErrorClass& eclass){
04230 throw ErrorClass( eclass.errormsg);
04231 }
04232 }
04233
04234 bool OSInstance::initForAlgDiff(){
04235 if( m_binitForAlgDiff == true ) return true;
04236 initializeNonLinearStructures( );
04237 initObjGradients();
04238 getAllNonlinearVariablesIndexMap( );
04239
04240
04241
04242 std::map<int, OSExpressionTree*>::iterator posMapExpTree;
04243 for(posMapExpTree = m_mapExpressionTreesMod.begin(); posMapExpTree != m_mapExpressionTreesMod.end(); ++posMapExpTree){
04244 if(posMapExpTree->second->bADMustReTape == true) m_bCppADMustReTape = true;
04245 }
04246
04247 #ifdef DEBUG
04248 std::cout << "RETAPE == " << m_bCppADMustReTape << std::endl;
04249 #endif
04250 unsigned int i;
04251 for(i = 0; i < m_iNumberOfNonlinearVariables; i++){
04252 m_vdDomainUnitVec.push_back( 0.0 );
04253 }
04254 for(i = 0; i < m_mapExpressionTreesMod.size(); i++){
04255 m_vdRangeUnitVec.push_back( 0.0 );
04256 }
04257 m_binitForAlgDiff = true;
04258
04259
04260 return true;
04261 }
04262
04263 bool OSInstance::initObjGradients(){
04264 int i, j;
04265 int m, n;
04266 m = getObjectiveNumber();
04267 n = getVariableNumber();
04268 getDenseObjectiveCoefficients();
04269 if(m <= 0){
04270 m_mmdObjGradient = NULL;
04271 return true;
04272 }
04273 m_mmdObjGradient = new double*[m];
04274 for(i = 0; i < m; i++){
04275 m_mmdObjGradient[i] = new double[n];
04276 for(j = 0; j < n; j++){
04277 m_mmdObjGradient[i][j] = m_mmdDenseObjectiveCoefficients[ i][j];
04278 #ifdef DEBUG
04279 std::cout << "m_mmdObjGradient[i][j] = " << m_mmdObjGradient[i][j] << std::endl;
04280 #endif
04281 }
04282 }
04283 return true;
04284 }
04293 bool OSInstance::setTimeDomain(std::string format)
04294 { if ((format != "stages") && (format != "interval") && (format != "none"))
04295 return false;
04296 if (instanceData->timeDomain == NULL)
04297 { instanceData->timeDomain = new TimeDomain();
04298 }
04299 if (format == "stages")
04300 { if (instanceData->timeDomain->interval != NULL)
04301 { delete instanceData->timeDomain->interval;
04302 instanceData->timeDomain->interval = NULL;
04303 }
04304 if (instanceData->timeDomain->stages == NULL)
04305 instanceData->timeDomain->stages = new TimeDomainStages();
04306 m_sTimeDomainFormat = format;
04307 }
04308 if (format == "interval")
04309 { if (instanceData->timeDomain->stages != NULL)
04310 { delete instanceData->timeDomain->stages;
04311 instanceData->timeDomain->stages = NULL;
04312 }
04313 if (instanceData->timeDomain->interval == NULL)
04314 instanceData->timeDomain->interval = new TimeDomainInterval();
04315 m_sTimeDomainFormat = format;
04316 }
04317 if (format == "none")
04318 { if (instanceData->timeDomain->stages != NULL)
04319 { delete instanceData->timeDomain->stages;
04320 instanceData->timeDomain->stages = NULL;
04321 }
04322 if (instanceData->timeDomain->interval != NULL)
04323 { delete instanceData->timeDomain->interval;
04324 instanceData->timeDomain->interval = NULL;
04325 }
04326 m_sTimeDomainFormat = "";
04327 }
04328 return true;
04329 }
04330
04334 bool OSInstance::setTimeDomainStages(int number, std::string *names)
04335 { if (instanceData->timeDomain == NULL)
04336 instanceData->timeDomain = new TimeDomain();
04337 if (instanceData->timeDomain->interval != NULL)
04338 return false;
04339 if (instanceData->timeDomain->stages == NULL)
04340 { instanceData->timeDomain->stages = new TimeDomainStages;
04341 }
04342 else
04343 { if (instanceData->timeDomain->stages->numberOfStages != number)
04344 { for (int i = 0; i < instanceData->timeDomain->stages->numberOfStages; i++)
04345 { if (instanceData->timeDomain->stages->stage[i]->variables != NULL)
04346 { delete instanceData->timeDomain->stages->stage[i]->variables;
04347 instanceData->timeDomain->stages->stage[i]->variables = NULL;
04348 }
04349 if (instanceData->timeDomain->stages->stage[i]->constraints != NULL)
04350 { delete instanceData->timeDomain->stages->stage[i]->constraints;
04351 instanceData->timeDomain->stages->stage[i]->constraints = NULL;
04352 }
04353 if (instanceData->timeDomain->stages->stage[i]->objectives != NULL)
04354 { delete instanceData->timeDomain->stages->stage[i]->objectives;
04355 instanceData->timeDomain->stages->stage[i]->objectives = NULL;
04356 }
04357 delete instanceData->timeDomain->stages->stage[i];
04358 instanceData->timeDomain->stages->stage[i] = NULL;
04359 }
04360 delete []instanceData->timeDomain->stages->stage;
04361 instanceData->timeDomain->stages->stage = NULL;
04362 }
04363 }
04364 if (number != 0 )
04365 { if (instanceData->timeDomain->stages->stage == NULL)
04366 instanceData->timeDomain->stages->stage = new TimeDomainStage*[number];
04367 for (int i = 0; i < number; i++)
04368 { instanceData->timeDomain->stages->stage[i] = new TimeDomainStage();
04369 }
04370 instanceData->timeDomain->stages->numberOfStages = number;
04371 }
04372 for (int i = 0; i < number; i++)
04373
04374 { if (instanceData->timeDomain->stages->stage[i]->variables != NULL)
04375 { delete instanceData->timeDomain->stages->stage[i]->variables;
04376 instanceData->timeDomain->stages->stage[i]->variables = NULL;
04377 }
04378 instanceData->timeDomain->stages->stage[i]->variables = new TimeDomainStageVariables();
04379 if (instanceData->timeDomain->stages->stage[i]->constraints != NULL)
04380 { delete instanceData->timeDomain->stages->stage[i]->constraints;
04381 instanceData->timeDomain->stages->stage[i]->constraints = NULL;
04382 }
04383 instanceData->timeDomain->stages->stage[i]->constraints = new TimeDomainStageConstraints();
04384 if (instanceData->timeDomain->stages->stage[i]->objectives != NULL)
04385 { delete instanceData->timeDomain->stages->stage[i]->objectives;
04386 instanceData->timeDomain->stages->stage[i]->objectives = NULL;
04387 }
04388 instanceData->timeDomain->stages->stage[i]->objectives = new TimeDomainStageObjectives();
04389 instanceData->timeDomain->stages->stage[i]->objectives->numberOfObjectives = instanceData->objectives->numberOfObjectives;
04390 instanceData->timeDomain->stages->stage[i]->objectives->obj = new TimeDomainStageObj*[instanceData->objectives->numberOfObjectives];
04391 for (int j = 0; j < instanceData->objectives->numberOfObjectives; j++)
04392 { instanceData->timeDomain->stages->stage[i]->objectives->obj[j] = new TimeDomainStageObj();
04393 instanceData->timeDomain->stages->stage[i]->objectives->obj[j]->idx = -(j+1);
04394 }
04395 if (names != NULL)
04396 instanceData->timeDomain->stages->stage[i]->name = names[i];
04397 }
04398 return true;
04399 }
04400
04404 bool OSInstance::setTimeDomainStageVariablesOrdered(int numberOfStages, int *numberOfVariables, int *startIdx)
04405 { if (instanceData->timeDomain == NULL)
04406 instanceData->timeDomain = new TimeDomain();
04407 if (instanceData->timeDomain->interval != NULL)
04408 return false;
04409 if (instanceData->timeDomain->stages == NULL)
04410 instanceData->timeDomain->stages = new TimeDomainStages();
04411 if (instanceData->timeDomain->stages != NULL)
04412 { if ((instanceData->timeDomain->stages->numberOfStages != numberOfStages) &&
04413 (instanceData->timeDomain->stages->numberOfStages != 0))
04414 return false;
04415 }
04416 if (instanceData->timeDomain->stages->numberOfStages == 0)
04417 { instanceData->timeDomain->stages->numberOfStages = numberOfStages;
04418 if (instanceData->timeDomain->stages->stage == NULL)
04419 instanceData->timeDomain->stages->stage = new TimeDomainStage*[numberOfStages];
04420 for (int i = 0; i < numberOfStages; i++)
04421 instanceData->timeDomain->stages->stage[i] = new TimeDomainStage();
04422 }
04423 int checksum = 0;
04424 for (int i = 0; i < numberOfStages; i++)
04425
04426 { if (instanceData->timeDomain->stages->stage[i]->variables != NULL)
04427 { delete instanceData->timeDomain->stages->stage[i]->variables;
04428 instanceData->timeDomain->stages->stage[i]->variables = NULL;
04429 }
04430 instanceData->timeDomain->stages->stage[i]->variables = new TimeDomainStageVariables();
04431 instanceData->timeDomain->stages->stage[i]->variables->startIdx = startIdx[i];
04432 instanceData->timeDomain->stages->stage[i]->variables->numberOfVariables = numberOfVariables[i];
04433 checksum += numberOfVariables[i];
04434 }
04435 return (checksum == instanceData->variables->numberOfVariables);
04436 }
04437
04441 bool OSInstance::setTimeDomainStageVariablesUnordered(int numberOfStages, int *numberOfVariables, int **varIndex)
04442 { if (instanceData->timeDomain == NULL)
04443 instanceData->timeDomain = new TimeDomain();
04444 if (instanceData->timeDomain->interval != NULL)
04445 return false;
04446 if (instanceData->timeDomain->stages == NULL)
04447 instanceData->timeDomain->stages = new TimeDomainStages();
04448 if (instanceData->timeDomain->stages != NULL)
04449 { if ((instanceData->timeDomain->stages->numberOfStages != numberOfStages) &&
04450 (instanceData->timeDomain->stages->numberOfStages != 0))
04451 return false;
04452 }
04453 if (instanceData->timeDomain->stages->numberOfStages == 0 )
04454 { instanceData->timeDomain->stages->numberOfStages = numberOfStages;
04455 if (instanceData->timeDomain->stages->stage == NULL)
04456 instanceData->timeDomain->stages->stage = new TimeDomainStage*[numberOfStages];
04457 for (int i = 0; i < numberOfStages; i++)
04458 instanceData->timeDomain->stages->stage[i] = new TimeDomainStage();
04459 }
04460 int checksum = 0;
04461 for (int i = 0; i < numberOfStages; i++)
04462
04463 { if (instanceData->timeDomain->stages->stage[i]->variables != NULL)
04464 { delete instanceData->timeDomain->stages->stage[i]->variables;
04465 instanceData->timeDomain->stages->stage[i]->variables = NULL;
04466 }
04467 instanceData->timeDomain->stages->stage[i]->variables = new TimeDomainStageVariables();
04468 instanceData->timeDomain->stages->stage[i]->variables->numberOfVariables = numberOfVariables[i];
04469 instanceData->timeDomain->stages->stage[i]->variables->var = new TimeDomainStageVar*[numberOfVariables[i]];
04470 for (int j = 0; j < numberOfVariables[i]; j++)
04471 { instanceData->timeDomain->stages->stage[i]->variables->var[j] = new TimeDomainStageVar();
04472 instanceData->timeDomain->stages->stage[i]->variables->var[j]->idx = varIndex[i][j];
04473 }
04474 checksum += numberOfVariables[i];
04475 }
04476 if (checksum != instanceData->variables->numberOfVariables) return false;
04477 int *checkvar = new int[instanceData->variables->numberOfVariables];
04478 for (int j = 0; j < instanceData->variables->numberOfVariables; j++)
04479 checkvar[j] = -1;
04480 int k;
04481 for (int i = 0; i < numberOfStages; i++)
04482 for (int j = 0; j < instanceData->timeDomain->stages->stage[i]->variables->numberOfVariables; j++)
04483 { k = instanceData->timeDomain->stages->stage[i]->variables->var[j]->idx;
04484 if (checkvar[k] != -1)
04485 { delete [] checkvar;
04486 checkvar = NULL;
04487 return false;
04488 }
04489 checkvar[k] = instanceData->timeDomain->stages->stage[i]->variables->var[j]->idx;
04490 }
04491 delete [] checkvar;
04492 checkvar = NULL;
04493 return true;
04494 }
04495
04499 bool OSInstance::setTimeDomainStageConstraintsOrdered(int numberOfStages, int *numberOfConstraints, int *startIdx)
04500 { if (instanceData->timeDomain == NULL)
04501 instanceData->timeDomain = new TimeDomain();
04502 if (instanceData->timeDomain->interval != NULL)
04503 return false;
04504 if (instanceData->timeDomain->stages == NULL)
04505 instanceData->timeDomain->stages = new TimeDomainStages();
04506 if (instanceData->timeDomain->stages != NULL)
04507 { if ((instanceData->timeDomain->stages->numberOfStages != numberOfStages) &&
04508 (instanceData->timeDomain->stages->numberOfStages != 0))
04509 return false;
04510 }
04511 if (instanceData->timeDomain->stages->numberOfStages == 0 )
04512 { instanceData->timeDomain->stages->numberOfStages = numberOfStages;
04513 if (instanceData->timeDomain->stages->stage == NULL)
04514 instanceData->timeDomain->stages->stage = new TimeDomainStage*[numberOfStages];
04515 for (int i = 0; i < numberOfStages; i++)
04516 instanceData->timeDomain->stages->stage[i] = new TimeDomainStage();
04517 }
04518 int checksum = 0;
04519 for (int i = 0; i < numberOfStages; i++)
04520
04521 { if (instanceData->timeDomain->stages->stage[i]->constraints != NULL)
04522 { delete instanceData->timeDomain->stages->stage[i]->constraints;
04523 instanceData->timeDomain->stages->stage[i]->constraints = NULL;
04524 }
04525 instanceData->timeDomain->stages->stage[i]->constraints = new TimeDomainStageConstraints();
04526 instanceData->timeDomain->stages->stage[i]->constraints->startIdx = startIdx[i];
04527 instanceData->timeDomain->stages->stage[i]->constraints->numberOfConstraints = numberOfConstraints[i];
04528 checksum += numberOfConstraints[i];
04529 }
04530 return (checksum == instanceData->constraints->numberOfConstraints);
04531 }
04532
04536 bool OSInstance::setTimeDomainStageConstraintsUnordered(int numberOfStages, int *numberOfConstraints, int **conIndex)
04537 { if (instanceData->timeDomain == NULL)
04538 instanceData->timeDomain = new TimeDomain();
04539 if (instanceData->timeDomain->interval != NULL)
04540 return false;
04541 if (instanceData->timeDomain->stages == NULL)
04542 instanceData->timeDomain->stages = new TimeDomainStages();
04543 if (instanceData->timeDomain->stages != NULL)
04544 { if ((instanceData->timeDomain->stages->numberOfStages != numberOfStages) &&
04545 (instanceData->timeDomain->stages->numberOfStages != 0))
04546 return false;
04547 }
04548 if ( instanceData->timeDomain->stages->numberOfStages == 0 )
04549 { instanceData->timeDomain->stages->numberOfStages = numberOfStages;
04550 if (instanceData->timeDomain->stages->stage == NULL)
04551 instanceData->timeDomain->stages->stage = new TimeDomainStage*[numberOfStages];
04552 for (int i = 0; i < numberOfStages; i++)
04553 instanceData->timeDomain->stages->stage[i] = new TimeDomainStage();
04554 }
04555 int checksum = 0;
04556 for (int i = 0; i < numberOfStages; i++)
04557
04558 { if (instanceData->timeDomain->stages->stage[i]->constraints != NULL)
04559 { delete instanceData->timeDomain->stages->stage[i]->constraints;
04560 instanceData->timeDomain->stages->stage[i]->constraints = NULL;
04561 }
04562 instanceData->timeDomain->stages->stage[i]->constraints = new TimeDomainStageConstraints();
04563 instanceData->timeDomain->stages->stage[i]->constraints->numberOfConstraints = numberOfConstraints[i];
04564 instanceData->timeDomain->stages->stage[i]->constraints->con = new TimeDomainStageCon*[numberOfConstraints[i]];
04565 for (int j = 0; j < numberOfConstraints[i]; j++)
04566 { instanceData->timeDomain->stages->stage[i]->constraints->con[j] = new TimeDomainStageCon();
04567 instanceData->timeDomain->stages->stage[i]->constraints->con[j]->idx = conIndex[i][j];
04568 }
04569 checksum += numberOfConstraints[i];
04570 }
04571 if (checksum != instanceData->constraints->numberOfConstraints) return false;
04572 int *checkvar = new int[instanceData->constraints->numberOfConstraints];
04573 for (int j = 0; j < instanceData->constraints->numberOfConstraints; j++)
04574 checkvar[j] = -1;
04575 int k;
04576 for (int i = 0; i < numberOfStages; i++)
04577 for (int j = 0; j < instanceData->timeDomain->stages->stage[i]->constraints->numberOfConstraints; j++)
04578 { k = instanceData->timeDomain->stages->stage[i]->constraints->con[j]->idx;
04579 if (checkvar[k] != -1)
04580 { delete [] checkvar;
04581 checkvar = NULL;
04582 return false;
04583 }
04584 checkvar[k] = instanceData->timeDomain->stages->stage[i]->constraints->con[j]->idx;
04585 }
04586 delete [] checkvar;
04587 checkvar = NULL;
04588 return true;
04589 }
04590
04594 bool OSInstance::setTimeDomainStageObjectivesOrdered(int numberOfStages, int *numberOfObjectives, int *startIdx)
04595 { if (instanceData->timeDomain == NULL)
04596 instanceData->timeDomain = new TimeDomain();
04597 if (instanceData->timeDomain->interval != NULL)
04598 return false;
04599 if (instanceData->timeDomain->stages == NULL)
04600 instanceData->timeDomain->stages = new TimeDomainStages();
04601 if (instanceData->timeDomain->stages != NULL)
04602 { if ((instanceData->timeDomain->stages->numberOfStages != numberOfStages) &&
04603 (instanceData->timeDomain->stages->numberOfStages != 0))
04604 return false;
04605 }
04606 if (instanceData->timeDomain->stages->numberOfStages == 0)
04607 { instanceData->timeDomain->stages->numberOfStages = numberOfStages;
04608 if (instanceData->timeDomain->stages->stage == NULL)
04609 instanceData->timeDomain->stages->stage = new TimeDomainStage*[numberOfStages];
04610 for (int i = 0; i < numberOfStages; i++)
04611 instanceData->timeDomain->stages->stage[i] = new TimeDomainStage();
04612 }
04613 for (int i = 0; i < numberOfStages; i++)
04614
04615 { if (instanceData->timeDomain->stages->stage[i]->objectives != NULL)
04616 { delete instanceData->timeDomain->stages->stage[i]->objectives;
04617 instanceData->timeDomain->stages->stage[i]->objectives = NULL;
04618 }
04619 instanceData->timeDomain->stages->stage[i]->objectives = new TimeDomainStageObjectives();
04620 instanceData->timeDomain->stages->stage[i]->objectives->startIdx = startIdx[i];
04621 instanceData->timeDomain->stages->stage[i]->objectives->numberOfObjectives = numberOfObjectives[i];
04622 }
04623 return true;
04624 }
04625
04629 bool OSInstance::setTimeDomainStageObjectivesUnordered(int numberOfStages, int *numberOfObjectives, int **objIndex)
04630 { if (instanceData->timeDomain == NULL)
04631 instanceData->timeDomain = new TimeDomain();
04632 if (instanceData->timeDomain->interval != NULL)
04633 return false;
04634 if (instanceData->timeDomain->stages == NULL)
04635 instanceData->timeDomain->stages = new TimeDomainStages();
04636 if (instanceData->timeDomain->stages != NULL)
04637 { if ((instanceData->timeDomain->stages->numberOfStages != numberOfStages) &&
04638 (instanceData->timeDomain->stages->numberOfStages != 0))
04639 return false;
04640 }
04641 if (instanceData->timeDomain->stages->numberOfStages == 0)
04642 { instanceData->timeDomain->stages->numberOfStages = numberOfStages;
04643 if (instanceData->timeDomain->stages->stage == NULL)
04644 instanceData->timeDomain->stages->stage = new TimeDomainStage*[numberOfStages];
04645 for (int i = 0; i < numberOfStages; i++)
04646 instanceData->timeDomain->stages->stage[i] = new TimeDomainStage();
04647 }
04648 for (int i = 0; i < numberOfStages; i++)
04649
04650 { if (instanceData->timeDomain->stages->stage[i]->objectives != NULL)
04651 { delete instanceData->timeDomain->stages->stage[i]->objectives;
04652 instanceData->timeDomain->stages->stage[i]->objectives = NULL;
04653 }
04654 instanceData->timeDomain->stages->stage[i]->objectives = new TimeDomainStageObjectives();
04655 instanceData->timeDomain->stages->stage[i]->objectives->numberOfObjectives = numberOfObjectives[i];
04656 instanceData->timeDomain->stages->stage[i]->objectives->obj = new TimeDomainStageObj*[numberOfObjectives[i]];
04657 for (int j = 0; j < numberOfObjectives[i]; j++)
04658 { instanceData->timeDomain->stages->stage[i]->objectives->obj[j] = new TimeDomainStageObj();
04659 instanceData->timeDomain->stages->stage[i]->objectives->obj[j]->idx = objIndex[i][j];
04660 }
04661 }
04662 int *checkvar = new int[instanceData->objectives->numberOfObjectives];
04663 for (int j = 0; j < instanceData->objectives->numberOfObjectives; j++)
04664 checkvar[j] = 0;
04665 int k;
04666 for (int i = 0; i < numberOfStages; i++)
04667 for (int j = 0; j < instanceData->timeDomain->stages->stage[i]->objectives->numberOfObjectives; j++)
04668 { k = -instanceData->timeDomain->stages->stage[i]->objectives->obj[j]->idx-1;
04669 checkvar[k] = instanceData->timeDomain->stages->stage[i]->objectives->obj[j]->idx;
04670 }
04671 for (int i = 0; i < instanceData->objectives->numberOfObjectives; i++)
04672 if (checkvar[i] == 0)
04673 { delete [] checkvar;
04674 checkvar = NULL;
04675 return false;
04676 }
04677 delete [] checkvar;
04678 checkvar = NULL;
04679 return true;
04680 }
04681
04685 bool OSInstance::setTimeDomainInterval(double start, double horizon)
04686 { if (instanceData->timeDomain == NULL)
04687 instanceData->timeDomain = new TimeDomain();
04688 if (instanceData->timeDomain->stages != NULL)
04689 return false;
04690 if (instanceData->timeDomain->interval == NULL)
04691 instanceData->timeDomain->interval = new TimeDomainInterval();
04692 instanceData->timeDomain->interval->start = start;
04693 instanceData->timeDomain->interval->horizon = horizon;
04694 return true;
04695 }
04696
04697
04698 bool OSInstance::createOSADFun(std::vector<double> vdX){
04699 try{
04700 if(m_bOSADFunIsCreated == true) return true;
04701
04702 if(m_binitForAlgDiff == false) initForAlgDiff();
04703
04704
04705 std::map<int, OSExpressionTree*>::iterator posMapExpTree;
04706 unsigned int i;
04707 size_t n = vdX.size();
04708 #ifdef COIN_HAS_CPPAD
04709
04710 CppAD::vector< AD<double> > vdaX( n );
04711 for(i = 0; i < n; i++){
04712 vdaX[ i] = vdX[ i];
04713
04714 }
04715
04716 CppAD::Independent( vdaX);
04722 CppAD::vector< AD<double> > m_vFG;
04723 int kount = 0;
04724 for(posMapExpTree = m_mapExpressionTreesMod.begin(); posMapExpTree != m_mapExpressionTreesMod.end(); ++posMapExpTree){
04725 m_vFG.push_back( (posMapExpTree->second)->m_treeRoot->constructADTape(&m_mapAllNonlinearVariablesIndex, &vdaX) );
04726
04727 if( m_mapOSADFunRangeIndex.find( posMapExpTree->first) == m_mapOSADFunRangeIndex.end() ){
04728
04729 m_mapOSADFunRangeIndex[ posMapExpTree->first] = kount;
04730 kount++;
04731 }
04732 }
04733
04734
04735 Fad = new CppAD::ADFun<double>(vdaX, m_vFG);
04736
04737
04738 m_iHighestTaylorCoeffOrder = -1;
04739 m_bOSADFunIsCreated = true;
04740 #else
04741 throw ErrorClass( "Error: An Algorithmic Differentiation Package Not Available");
04742 #endif
04743
04744 return true;
04745 }
04746 catch(const ErrorClass& eclass){
04747 throw ErrorClass( eclass.errormsg);
04748 }
04749 }
04750
04751
04752 std::vector<double> OSInstance::forwardAD(int p, std::vector<double> vdX){
04753 try{
04754
04755 if(m_bOSADFunIsCreated == false) createOSADFun( vdX);
04756 if(p > (m_iHighestTaylorCoeffOrder + 1) ) throw
04757 ErrorClass( "trying to calculate a p order forward when p-1 Taylor coefficient not available");
04758
04759 m_iHighestTaylorCoeffOrder = p;
04760 m_iHighestOrderEvaluated = p;
04761
04762
04763
04764 #ifdef COIN_HAS_CPPAD
04765 return (*Fad).Forward(p, vdX);
04766 #else
04767 throw ErrorClass( "Error: An Algorithmic Differentiation Package Not Available");
04768 #endif
04769
04770 }
04771 catch(const ErrorClass& eclass){
04772 throw ErrorClass( eclass.errormsg);
04773 }
04774 }
04775
04776
04777 std::vector<double> OSInstance::reverseAD(int p, std::vector<double> vdlambda){
04778 try{
04779 #ifndef COIN_HAS_CPPAD
04780 throw ErrorClass( "Error: An Algorithmic Differentiation Package Not Available");
04781 #endif
04782 if(p == 0) throw
04783 ErrorClass( "reverseAD must have p >= 1");
04784 if(p > (m_iHighestTaylorCoeffOrder + 1) ) throw
04785 ErrorClass( "trying to calculate a p order reverse when p-1 Taylor coefficient not available");
04786
04787
04788
04789 m_iHighestOrderEvaluated = p;
04790 #ifdef COIN_HAS_CPPAD
04791 return (*Fad).Reverse(p, vdlambda);
04792 #else
04793 throw ErrorClass( "Error: An Algorithmic Differentiation Package Not Available");
04794 #endif
04795
04796 }
04797 catch(const ErrorClass& eclass){
04798 throw ErrorClass( eclass.errormsg);
04799 }
04800 }
04801
04802
04803 int OSInstance::getADSparsityHessian(){
04804
04805 unsigned int i;
04806 int numNonz;
04807 numNonz = 0;
04808 try{
04809 std::vector<bool> r(m_iNumberOfNonlinearVariables * m_iNumberOfNonlinearVariables);
04810 unsigned int j;
04811 for(i = 0; i < m_iNumberOfNonlinearVariables; i++) {
04812 for(j = 0; j < m_iNumberOfNonlinearVariables; j++)
04813 r[ i * m_iNumberOfNonlinearVariables + j ] = false;
04814 r[ i * m_iNumberOfNonlinearVariables + i] = true;
04815 }
04816
04817
04818 #ifdef COIN_HAS_CPPAD
04819 (*Fad).ForSparseJac(m_iNumberOfNonlinearVariables, r);
04820 #else
04821 throw ErrorClass( "Error: An Algorithmic Differentiation Package Not Available");
04822 #endif
04823
04824
04825 unsigned int m = m_mapExpressionTreesMod.size();
04826 std::vector<bool> e( m);
04827
04828 for(i = 0; i < m; i++) e[i] = true;
04829
04830
04831 #ifdef COIN_HAS_CPPAD
04832 m_vbLagHessNonz = (*Fad).RevSparseHes(m_iNumberOfNonlinearVariables, e);
04833 #else
04834 throw ErrorClass( "Error: An Algorithmic Differentiation Package Not Available");
04835 #endif
04836
04837 for(i = 0; i < m_iNumberOfNonlinearVariables; i++){
04838
04839 for(j = i; j < m_iNumberOfNonlinearVariables; j++){
04840 if(m_vbLagHessNonz[ i*m_iNumberOfNonlinearVariables + j] == true) numNonz++;
04841
04842 }
04843
04844 }
04845 return numNonz;
04846 }
04847 catch(const ErrorClass& eclass){
04848 throw ErrorClass( eclass.errormsg);
04849 }
04850 }
04851
04852
04853
04854
04855
04856
04857
04858 bool OSInstance::IsEqual(OSInstance *that)
04859 {
04860 #ifdef DEBUG_ISEQUAL_ROUTINES
04861 cout << "Start comparing in OSInstance" << endl;
04862 #endif
04863 if (this == NULL)
04864 { if (that == NULL)
04865 return true;
04866 else
04867 {
04868 #ifdef DEBUG_ISEQUAL_ROUTINES
04869 cout << "First object is NULL, second is not" << endl;
04870 #endif
04871 return false;
04872 }
04873 }
04874 else
04875 { if (that == NULL)
04876 {
04877 #ifdef DEBUG_ISEQUAL_ROUTINES
04878 cout << "Second object is NULL, first is not" << endl;
04879 #endif
04880 return false;
04881 }
04882 else
04883 {
04884 if (!this->instanceHeader->IsEqual(that->instanceHeader))
04885 return false;
04886 if (!this->instanceData->IsEqual(that->instanceData))
04887 return false;
04888
04889 return true;
04890 }
04891 }
04892 }
04893
04894
04895 bool InstanceHeader::IsEqual(InstanceHeader *that)
04896 {
04897 #ifdef DEBUG_ISEQUAL_ROUTINES
04898 cout << "Start comparing in InstanceHeader" << endl;
04899 #endif
04900 if (this == NULL)
04901 { if (that == NULL)
04902 return true;
04903 else
04904 {
04905 #ifdef DEBUG_ISEQUAL_ROUTINES
04906 cout << "First object is NULL, second is not" << endl;
04907 #endif
04908 return false;
04909 }
04910 }
04911 else
04912 { if (that == NULL)
04913 {
04914 #ifdef DEBUG_ISEQUAL_ROUTINES
04915 cout << "Second object is NULL, first is not" << endl;
04916 #endif
04917 return false;
04918 }
04919 else
04920 {
04921 if (this->description != that->description)
04922 return false;
04923 if (this->name != that->name)
04924 return false;
04925 if (this->source != that->source)
04926 return false;
04927
04928 return true;
04929 }
04930 }
04931 }
04932
04933 bool InstanceData::IsEqual(InstanceData *that)
04934 {
04935 #ifdef DEBUG_ISEQUAL_ROUTINES
04936 cout << "Start comparing in InstanceData" << endl;
04937 #endif
04938 if (this == NULL)
04939 { if (that == NULL)
04940 return true;
04941 else
04942 {
04943 #ifdef DEBUG_ISEQUAL_ROUTINES
04944 cout << "First object is NULL, second is not" << endl;
04945 #endif
04946 return false;
04947 }
04948 }
04949 else
04950 { if (that == NULL)
04951 {
04952 #ifdef DEBUG_ISEQUAL_ROUTINES
04953 cout << "Second object is NULL, first is not" << endl;
04954 #endif
04955 return false;
04956 }
04957 else
04958 {
04959 if (!this->variables->IsEqual(that->variables))
04960 return false;
04961 if (!this->objectives->IsEqual(that->objectives))
04962 return false;
04963 if (!this->constraints->IsEqual(that->constraints))
04964 return false;
04965 if (!this->linearConstraintCoefficients->IsEqual(that->linearConstraintCoefficients))
04966 return false;
04967 if (!this->quadraticCoefficients->IsEqual(that->quadraticCoefficients))
04968 return false;
04969 if (!this->nonlinearExpressions->IsEqual(that->nonlinearExpressions))
04970 return false;
04971
04972 return true;
04973 }
04974 }
04975 }
04976
04977 bool Variables::IsEqual(Variables *that)
04978 {
04979 #ifdef DEBUG_ISEQUAL_ROUTINES
04980 cout << "Start comparing in Variables" << endl;
04981 #endif
04982 if (this == NULL)
04983 { if (that == NULL)
04984 return true;
04985 else
04986 {
04987 #ifdef DEBUG_ISEQUAL_ROUTINES
04988 cout << "First object is NULL, second is not" << endl;
04989 #endif
04990 return false;
04991 }
04992 }
04993 else
04994 { if (that == NULL)
04995 {
04996 #ifdef DEBUG_ISEQUAL_ROUTINES
04997 cout << "Second object is NULL, first is not" << endl;
04998 #endif
04999 return false;
05000 }
05001 else
05002 {
05003 if (this->numberOfVariables != that->numberOfVariables)
05004 return false;
05005 for (int i=0; i<this->numberOfVariables; i++)
05006 if (!this->var[i]->IsEqual(that->var[i]))
05007 return false;
05008
05009 return true;
05010 }
05011 }
05012 }
05013
05014 bool Variable::IsEqual(Variable *that)
05015 {
05016 #ifdef DEBUG_ISEQUAL_ROUTINES
05017 cout << "Start comparing in Variable" << endl;
05018 #endif
05019 if (this == NULL)
05020 { if (that == NULL)
05021 return true;
05022 else
05023 {
05024 #ifdef DEBUG_ISEQUAL_ROUTINES
05025 cout << "First object is NULL, second is not" << endl;
05026 #endif
05027 return false;
05028 }
05029 }
05030 else
05031 { if (that == NULL)
05032 {
05033 #ifdef DEBUG_ISEQUAL_ROUTINES
05034 cout << "Second object is NULL, first is not" << endl;
05035 #endif
05036 return false;
05037 }
05038 else
05039 {
05040 if (this->lb != that->lb)
05041 return false;
05042 if (this->ub != that->ub)
05043 return false;
05044 if (this->type != that->type)
05045 return false;
05046 if (this->name != that->name)
05047 return false;
05048
05049 return true;
05050 }
05051 }
05052 }
05053
05054 bool Objectives::IsEqual(Objectives *that)
05055 {
05056 #ifdef DEBUG_ISEQUAL_ROUTINES
05057 cout << "Start comparing in Objectives" << endl;
05058 #endif
05059 if (this == NULL)
05060 { if (that == NULL)
05061 return true;
05062 else
05063 {
05064 #ifdef DEBUG_ISEQUAL_ROUTINES
05065 cout << "First object is NULL, second is not" << endl;
05066 #endif
05067 return false;
05068 }
05069 }
05070 else
05071 { if (that == NULL)
05072 {
05073 #ifdef DEBUG_ISEQUAL_ROUTINES
05074 cout << "Second object is NULL, first is not" << endl;
05075 #endif
05076 return false;
05077 }
05078 else
05079 {
05080 if (this->numberOfObjectives != that->numberOfObjectives)
05081 return false;
05082 for (int i=0; i<this->numberOfObjectives; i++)
05083 if (!this->obj[i]->IsEqual(that->obj[i]))
05084 return false;
05085
05086 return true;
05087 }
05088 }
05089 }
05090
05091 bool Objective::IsEqual(Objective *that)
05092 {
05093 #ifdef DEBUG_ISEQUAL_ROUTINES
05094 cout << "Start comparing in Objective" << endl;
05095 #endif
05096 if (this == NULL)
05097 { if (that == NULL)
05098 return true;
05099 else
05100 {
05101 #ifdef DEBUG_ISEQUAL_ROUTINES
05102 cout << "First object is NULL, second is not" << endl;
05103 #endif
05104 return false;
05105 }
05106 }
05107 else
05108 { if (that == NULL)
05109 {
05110 #ifdef DEBUG_ISEQUAL_ROUTINES
05111 cout << "Second object is NULL, first is not" << endl;
05112 #endif
05113 return false;
05114 }
05115 else
05116 {
05117 if (this->name != that->name)
05118 return false;
05119 if (this->maxOrMin != that->maxOrMin)
05120 return false;
05121 if (this->constant != that->constant)
05122 return false;
05123 if (this->weight != that->weight)
05124 return false;
05125 if (this->numberOfObjCoef != that->numberOfObjCoef)
05126 return false;
05127
05128 for (int i=0; i<this->numberOfObjCoef; i++)
05129 if (!this->coef[i]->IsEqual(that->coef[i]))
05130 return false;
05131
05132 return true;
05133 }
05134 }
05135 }
05136
05137 bool ObjCoef::IsEqual(ObjCoef *that)
05138 {
05139 #ifdef DEBUG_ISEQUAL_ROUTINES
05140 cout << "Start comparing in ObjCoef" << endl;
05141 #endif
05142 if (this == NULL)
05143 { if (that == NULL)
05144 return true;
05145 else
05146 {
05147 #ifdef DEBUG_ISEQUAL_ROUTINES
05148 cout << "First object is NULL, second is not" << endl;
05149 #endif
05150 return false;
05151 }
05152 }
05153 else
05154 { if (that == NULL)
05155 {
05156 #ifdef DEBUG_ISEQUAL_ROUTINES
05157 cout << "Second object is NULL, first is not" << endl;
05158 #endif
05159 return false;
05160 }
05161 else
05162 {
05163 if (this->idx != that->idx)
05164 return false;
05165 if (this->value != that->value)
05166 return false;
05167
05168 return true;
05169 }
05170 }
05171 }
05172
05173 bool Constraints::IsEqual(Constraints *that)
05174 {
05175 #ifdef DEBUG_ISEQUAL_ROUTINES
05176 cout << "Start comparing in Constraints" << endl;
05177 #endif
05178 if (this == NULL)
05179 { if (that == NULL)
05180 return true;
05181 else
05182 {
05183 #ifdef DEBUG_ISEQUAL_ROUTINES
05184 cout << "First object is NULL, second is not" << endl;
05185 #endif
05186 return false;
05187 }
05188 }
05189 else
05190 { if (that == NULL)
05191 {
05192 #ifdef DEBUG_ISEQUAL_ROUTINES
05193 cout << "Second object is NULL, first is not" << endl;
05194 #endif
05195 return false;
05196 }
05197 else
05198 {
05199 if (this->numberOfConstraints != that->numberOfConstraints)
05200 return false;
05201 for (int i=0; i<this->numberOfConstraints; i++)
05202 if (!this->con[i]->IsEqual(that->con[i]))
05203 return false;
05204
05205 return true;
05206 }
05207 }
05208 }
05209
05210 bool Constraint::IsEqual(Constraint *that)
05211 {
05212 #ifdef DEBUG_ISEQUAL_ROUTINES
05213 cout << "Start comparing in Constraint" << endl;
05214 #endif
05215 if (this == NULL)
05216 { if (that == NULL)
05217 return true;
05218 else
05219 {
05220 #ifdef DEBUG_ISEQUAL_ROUTINES
05221 cout << "First object is NULL, second is not" << endl;
05222 #endif
05223 return false;
05224 }
05225 }
05226 else
05227 { if (that == NULL)
05228 {
05229 #ifdef DEBUG_ISEQUAL_ROUTINES
05230 cout << "Second object is NULL, first is not" << endl;
05231 #endif
05232 return false;
05233 }
05234 else
05235 {
05236 if (this->name != that->name)
05237 return false;
05238 if (this->constant != that->constant)
05239 return false;
05240 if (this->lb != that->lb)
05241 return false;
05242 if (this->ub != that->ub)
05243 return false;
05244
05245 return true;
05246 }
05247 }
05248 }
05249
05250 bool LinearConstraintCoefficients::IsEqual(LinearConstraintCoefficients *that)
05251 {
05252 #ifdef DEBUG_ISEQUAL_ROUTINES
05253 cout << "Start comparing in LinearConstraintCoefficients" << endl;
05254 #endif
05255 if (this == NULL)
05256 { if (that == NULL)
05257 return true;
05258 else
05259 {
05260 #ifdef DEBUG_ISEQUAL_ROUTINES
05261 cout << "First object is NULL, second is not" << endl;
05262 #endif
05263 return false;
05264 }
05265 }
05266 else
05267 { if (that == NULL)
05268 {
05269 #ifdef DEBUG_ISEQUAL_ROUTINES
05270 cout << "Second object is NULL, first is not" << endl;
05271 #endif
05272 return false;
05273 }
05274 else
05275 {
05276 if (this->numberOfValues != that->numberOfValues)
05277 return false;
05278
05279 if (!this->start->IsEqual(that->start))
05280 return false;
05281 if (!this->rowIdx->IsEqual(that->rowIdx))
05282 return false;
05283 if (!this->colIdx->IsEqual(that->colIdx))
05284 return false;
05285 if (!this->value->IsEqual(that->value))
05286 return false;
05287
05288 return true;
05289 }
05290 }
05291 }
05292
05293 bool QuadraticCoefficients::IsEqual(QuadraticCoefficients *that)
05294 {
05295 #ifdef DEBUG_ISEQUAL_ROUTINES
05296 cout << "Start comparing in QuadraticCoefficients" << endl;
05297 #endif
05298 if (this == NULL)
05299 { if (that == NULL)
05300 return true;
05301 else
05302 {
05303 #ifdef DEBUG_ISEQUAL_ROUTINES
05304 cout << "First object is NULL, second is not" << endl;
05305 #endif
05306 return false;
05307 }
05308 }
05309 else
05310 { if (that == NULL)
05311 {
05312 #ifdef DEBUG_ISEQUAL_ROUTINES
05313 cout << "Second object is NULL, first is not" << endl;
05314 #endif
05315 return false;
05316 }
05317 else
05318 {
05319 if (this->numberOfQuadraticTerms != that->numberOfQuadraticTerms)
05320 return false;
05321 for (int i=0; i<this->numberOfQuadraticTerms; i++)
05322 if (!this->qTerm[i]->IsEqual(that->qTerm[i]))
05323 return false;
05324
05325 return true;
05326 }
05327 }
05328 }
05329
05330
05331 bool QuadraticTerm::IsEqual(QuadraticTerm *that)
05332 {
05333 #ifdef DEBUG_ISEQUAL_ROUTINES
05334 cout << "Start comparing in QuadraticTerm" << endl;
05335 #endif
05336 if (this == NULL)
05337 { if (that == NULL)
05338 return true;
05339 else
05340 {
05341 #ifdef DEBUG_ISEQUAL_ROUTINES
05342 cout << "First object is NULL, second is not" << endl;
05343 #endif
05344 return false;
05345 }
05346 }
05347 else
05348 { if (that == NULL)
05349 {
05350 #ifdef DEBUG_ISEQUAL_ROUTINES
05351 cout << "Second object is NULL, first is not" << endl;
05352 #endif
05353 return false;
05354 }
05355 else
05356 {
05357 if (this->idx != that->idx)
05358 return false;
05359 if (this->idxOne != that->idxOne)
05360 return false;
05361 if (this->idxTwo != that->idxTwo)
05362 return false;
05363 if (this->coef != that->coef)
05364 return false;
05365
05366 return true;
05367 }
05368 }
05369 }
05370
05371 bool NonlinearExpressions::IsEqual(NonlinearExpressions *that)
05372 {
05373 #ifdef DEBUG_ISEQUAL_ROUTINES
05374 cout << "Start comparing in NonlinearExpressions" << endl;
05375 #endif
05376 if (this == NULL)
05377 { if (that == NULL)
05378 return true;
05379 else
05380 {
05381 #ifdef DEBUG_ISEQUAL_ROUTINES
05382 cout << "First object is NULL, second is not" << endl;
05383 #endif
05384 return false;
05385 }
05386 }
05387 else
05388 { if (that == NULL)
05389 {
05390 #ifdef DEBUG_ISEQUAL_ROUTINES
05391 cout << "Second object is NULL, first is not" << endl;
05392 #endif
05393 return false;
05394 }
05395 else
05396 {
05397 if (this->numberOfNonlinearExpressions != that->numberOfNonlinearExpressions)
05398 return false;
05399
05400 for (int i=0; i<this->numberOfNonlinearExpressions; i++)
05401 if (!this->nl[i]->IsEqual(that->nl[i]))
05402 return false;
05403
05404 return true;
05405 }
05406 }
05407 }
05408
05409
05410
05411 bool Nl::IsEqual(Nl *that)
05412 {
05413 #ifdef DEBUG_ISEQUAL_ROUTINES
05414 cout << "Start comparing in Nl" << endl;
05415 #endif
05416 if (this == NULL)
05417 { if (that == NULL)
05418 return true;
05419 else
05420 {
05421 #ifdef DEBUG_ISEQUAL_ROUTINES
05422 cout << "First object is NULL, second is not" << endl;
05423 #endif
05424 return false;
05425 }
05426 }
05427 else
05428 { if (that == NULL)
05429 {
05430 #ifdef DEBUG_ISEQUAL_ROUTINES
05431 cout << "Second object is NULL, first is not" << endl;
05432 #endif
05433 return false;
05434 }
05435 else
05436 {
05437 if (this->idx != that->idx)
05438 return false;
05439 if (!this->osExpressionTree->IsEqual(that->osExpressionTree))
05440 return false;
05441
05442 return true;
05443 }
05444 }
05445 }
05446
05447