00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012 #ifndef CouenneMINLPInterface_hpp
00013 #define CouenneMINLPInterface_hpp
00014
00015
00016
00017
00018
00019
00020 #include "OsiSolverInterface.hpp"
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031 #include "CouenneTypes.hpp"
00032
00033 namespace Ipopt {
00034 class OptionsList;
00035 }
00036
00037 namespace Couenne {
00038
00039 class expression;
00040 class CouenneProblem;
00041
00042
00043
00044
00046
00047 enum Solver {
00048 EIpopt=0,
00049 EFilterSQP,
00050 EAll
00051 };
00052
00054
00058
00059 class CouenneMINLPInterface: public OsiSolverInterface {
00060
00061 public:
00062
00065 void setObj (int index, expression *newObj) {}
00066
00068 void setInitSol (const CouNumber *sol);
00069
00072 CouNumber solve (CouNumber *solution);
00073
00075 CouenneProblem *problem () const
00076 {return problem_;}
00077
00079 Ipopt::OptionsList *options () const
00080 {return options_;}
00081
00082 private:
00083
00085 CouenneProblem *problem_;
00086
00088 Ipopt::OptionsList *options_;
00089
00091 virtual std::string appName ()
00092 {return "couenne";}
00093
00094
00095 #if 0
00096
00097
00098 public:
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124
00125
00126
00127
00128
00129
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139
00140
00141
00142
00143
00144
00145
00146
00147
00148
00149
00150
00151
00152
00153
00154
00155
00156
00157
00158
00159
00160
00161
00162
00163
00164
00165
00166
00167
00168
00169
00170
00171
00173
00174
00175 CouenneMINLPInterface ();
00176
00178 void initialize(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions,
00179 Ipopt::SmartPtr<Ipopt::OptionsList> options,
00180 Ipopt::SmartPtr<Ipopt::Journalist> journalist_,
00181 Ipopt::SmartPtr<TMINLP> tminlp);
00182
00184 void setModel(Ipopt::SmartPtr<TMINLP> tminlp);
00185
00187 void setSolver(Ipopt::SmartPtr<TNLPSolver> app);
00188
00190 void use(Ipopt::SmartPtr<TMINLP2TNLP> tminlp2tnlp){
00191 problem_ = tminlp2tnlp;}
00192
00194 CouenneMINLPInterface (const CouenneMINLPInterface &);
00195
00197 OsiSolverInterface * clone (bool copyData = true) const;
00198
00200 CouenneMINLPInterface & operator=(const CouenneMINLPInterface& rhs);
00201
00203 virtual ~CouenneMINLPInterface ();
00204
00206 void readOptionFile(const std::string & fileName);
00207
00209 const Ipopt::SmartPtr<Ipopt::OptionsList> options() const;
00210
00212 Ipopt::SmartPtr<Ipopt::OptionsList> options();
00213
00214
00216
00217
00218 virtual void initialSolve();
00219
00225
00226 virtual void resolve();
00227
00231
00232 virtual void resolveForCost(int numretry, bool keepWs);
00233
00236
00237 virtual void resolveForRobustness(int numretry);
00238
00240 virtual void branchAndBound()
00241 {
00242
00243 }
00245
00246
00247
00249
00250
00251 virtual bool isAbandoned () const;
00252 virtual bool isProvenOptimal () const;
00253 virtual bool isProvenPrimalInfeasible () const;
00254 virtual bool isProvenDualInfeasible () const;
00255 virtual bool isPrimalObjectiveLimitReached () const;
00256 virtual bool isDualObjectiveLimitReached () const;
00257 virtual bool isIterationLimitReached () const;
00258
00260 void continuingOnAFailure()
00261 {
00262 hasContinuedAfterNlpFailure_ = true;
00263 }
00264
00266 bool hasContinuedOnAFailure()
00267 {
00268 return hasContinuedAfterNlpFailure_;
00269 }
00270
00272 void ignoreFailures()
00273 {
00274 pretendFailIsInfeasible_ = 2;
00275 }
00276
00278 void forceInfeasible()
00279 {
00280 problem_->set_obj_value(1e200);
00281 }
00282
00284 void forceBranchable()
00285 {
00286 problem_->set_obj_value(-1e200);
00287 problem_->force_fractionnal_sol();
00288 }
00290
00291
00292
00294
00302
00306
00308
00309 bool setIntParam(OsiIntParam key, int value);
00310
00311 bool setDblParam(OsiDblParam key, double value);
00312
00313 bool setStrParam(OsiStrParam key, const std::string & value);
00314
00315 bool getIntParam(OsiIntParam key, int& value) const;
00316
00317 bool getDblParam(OsiDblParam key, double& value) const;
00318
00319 bool getStrParam(OsiStrParam key, std::string& value) const;
00320
00321
00322 inline double getPushFact() const
00323 {
00324 return pushValue_;
00325 }
00326
00328
00329
00330
00332
00333
00334
00335
00336
00337
00338
00339
00340
00341
00343
00344
00345
00346 virtual int getNumCols() const;
00347
00349 virtual int getNumRows() const;
00350
00352 const OsiSolverInterface::OsiNameVec& getVarNames() ;
00354 virtual const double * getColLower() const;
00355
00357 virtual const double * getColUpper() const;
00358
00360
00361
00362
00363
00364
00365
00366
00367
00368 virtual const char * getRowSense() const;
00369
00371
00372
00373
00374
00375
00376
00377
00378 virtual const double * getRightHandSide() const;
00379
00381
00382
00383
00384
00385
00386
00387
00388 virtual const double * getRowRange() const;
00389
00391 virtual const double * getRowLower() const;
00392
00394 virtual const double * getRowUpper() const;
00395
00398 virtual double getObjSense() const
00399 {
00400 return 1;
00401 }
00402
00404 virtual bool isContinuous(int colNumber) const;
00405
00407 virtual bool isBinary(int columnNumber) const;
00408
00412 virtual bool isInteger (int columnNumber) const;
00413
00415 virtual bool isIntegerNonBinary(int columnNumber) const;
00416
00418 virtual bool isFreeBinary(int columnNumber) const;
00419
00421 virtual double getInfinity() const;
00422
00424 const int * getPriorities() const
00425 {
00426 const TMINLP::BranchingInfo * branch = tminlp_->branchingInfo();
00427 if(branch)
00428 return branch->priorities;
00429 else return NULL;
00430 }
00431
00433 const int * getBranchingDirections() const
00434 {
00435 const TMINLP::BranchingInfo * branch = tminlp_->branchingInfo();
00436 if(branch)
00437 return branch->branchingDirections;
00438 else return NULL;
00439 }
00440
00441 const double * getUpPsCosts() const
00442 {
00443 const TMINLP::BranchingInfo * branch = tminlp_->branchingInfo();
00444 if(branch)
00445 return branch->upPsCosts;
00446 else return NULL;
00447 }
00448
00449 const double * getDownPsCosts() const
00450 {
00451 const TMINLP::BranchingInfo * branch = tminlp_->branchingInfo();
00452 if(branch)
00453 return branch->downPsCosts;
00454 else return NULL;
00455 }
00456
00458
00460
00461
00463 virtual const double * getColSolution() const;
00464
00466 virtual const double * getRowPrice() const;
00467
00469 virtual const double * getReducedCost() const;
00470
00473 virtual const double * getRowActivity() const;
00474
00475
00480
00481 virtual int getIterationCount () const;
00482
00484 int nCallOptimizeTNLP()
00485 {
00486 return nCallOptimizeTNLP_;
00487 }
00488
00490 double totalNlpSolveTime()
00491 {
00492 return totalNlpSolveTime_;
00493 }
00494
00496 int totalIterations()
00497 {
00498 return totalIterations_;
00499 }
00500
00501
00503
00504
00506
00508
00511 virtual void setColLower( int elementIndex, double elementValue );
00512
00515 virtual void setColUpper( int elementIndex, double elementValue );
00516
00519
00520 virtual void setColLower(const double * array);
00521
00524
00525 virtual void setColUpper(const double * array);
00526
00527
00530 virtual void setRowLower( int elementIndex, double elementValue );
00531
00533 virtual void setRowUpper( int elementIndex, double elementValue );
00534
00536 virtual void setRowType(int index, char sense, double rightHandSide,
00537 double range);
00538
00539
00544 virtual void setObjSense(double s);
00545
00549
00550 virtual void setColSolution(const double *colsol);
00551
00555
00556 virtual void setRowPrice(const double * rowprice);
00557
00559
00560
00561
00563
00564
00566
00571
00572 virtual CoinWarmStart *getEmptyWarmStart () const;
00573
00575 virtual CoinWarmStart* getWarmStart() const;
00576
00579 virtual bool setWarmStart(const CoinWarmStart* warmstart);
00580
00581 void setExposeWarmStart(bool value) {
00582 exposeWarmStart_ = value;
00583 }
00584
00585 bool getExposeWarmStart() {
00586 return exposeWarmStart_;
00587 }
00588
00589 void randomStartingPoint();
00590
00591
00592 virtual bool basisIsAvailable() const
00593 {
00594
00595 throw SimpleError("Needs coding for this interface", "basisIsAvailable");
00596 }
00597
00598
00600
00601
00603
00604
00605 virtual void setContinuous(int index);
00607 virtual void setInteger(int index);
00609
00610
00611 void setNumIterationSuspect(int value)
00612 {
00613 numIterationSuspect_ = value;
00614 }
00615
00622
00623
00625
00626 virtual int getNumElements() const
00627 {
00628 return -1;
00629 }
00630
00631
00635
00636 virtual const double * getObjCoefficients() const;
00637
00639
00640 virtual const CoinPackedMatrix * getMatrixByRow() const
00641 {
00642 return NULL;
00643 }
00644
00645
00647
00648 virtual const CoinPackedMatrix * getMatrixByCol() const
00649 {
00650 return NULL;
00651 }
00652
00654
00655 virtual void setObjCoeff( int elementIndex, double elementValue )
00656 {
00657 throw SimpleError("CouenneMINLPInterface does not implement this function.",
00658 "setObjCoeff");
00659 }
00660
00662
00663 virtual void addCol(const CoinPackedVectorBase& vec,
00664 const double collb, const double colub,
00665 const double obj)
00666 {
00667 throw SimpleError("CouenneMINLPInterface does not implement this function.",
00668 "addCol");
00669 }
00670
00672
00673 virtual void deleteCols(const int num, const int * colIndices)
00674 {
00675 throw SimpleError("CouenneMINLPInterface does not implement this function.",
00676 "deleteCols");
00677 }
00678
00680
00681 virtual void addRow(const CoinPackedVectorBase& vec,
00682 const double rowlb, const double rowub)
00683 {
00684 throw SimpleError("CouenneMINLPInterface does not implement this function.",
00685 "addRow");
00686 }
00687
00689
00690 virtual void addRow(const CoinPackedVectorBase& vec,
00691 const char rowsen, const double rowrhs,
00692 const double rowrng)
00693 {
00694 throw SimpleError("CouenneMINLPInterface model does not implement this function.",
00695 "addRow");
00696 }
00698
00699 virtual void deleteRows(const int num, const int * rowIndices)
00700 {
00701 if(num)
00702 freeCachedRowRim();
00703 problem_->removeCuts(num, rowIndices);
00704 }
00705
00706
00708
00709 virtual void loadProblem(const CoinPackedMatrix& matrix,
00710 const double* collb, const double* colub,
00711 const double* obj,
00712 const double* rowlb, const double* rowub)
00713 {
00714 throw SimpleError("CouenneMINLPInterface does not implement this function.",
00715 "loadProblem");
00716 }
00717
00718
00720
00721 virtual void assignProblem(CoinPackedMatrix*& matrix,
00722 double*& collb, double*& colub, double*& obj,
00723 double*& rowlb, double*& rowub)
00724 {
00725 throw SimpleError("CouenneMINLPInterface does not implement this function.",
00726 "assignProblem");
00727 }
00728
00730
00731 virtual void loadProblem(const CoinPackedMatrix& matrix,
00732 const double* collb, const double* colub,
00733 const double* obj,
00734 const char* rowsen, const double* rowrhs,
00735 const double* rowrng)
00736 {
00737 throw SimpleError("CouenneMINLPInterface does not implement this function.",
00738 "loadProblem");
00739 }
00740
00742
00743 virtual void assignProblem(CoinPackedMatrix*& matrix,
00744 double*& collb, double*& colub, double*& obj,
00745 char*& rowsen, double*& rowrhs,
00746 double*& rowrng)
00747 {
00748 throw SimpleError("CouenneMINLPInterface does not implement this function.",
00749 "assignProblem");
00750 }
00751
00752
00754
00755 virtual void loadProblem(const int numcols, const int numrows,
00756 const int* start, const int* index,
00757 const double* value,
00758 const double* collb, const double* colub,
00759 const double* obj,
00760 const double* rowlb, const double* rowub)
00761 {
00762 throw SimpleError("CouenneMINLPInterface does not implement this function.",
00763 "loadProblem");
00764 }
00765
00767
00768 virtual void loadProblem(const int numcols, const int numrows,
00769 const int* start, const int* index,
00770 const double* value,
00771 const double* collb, const double* colub,
00772 const double* obj,
00773 const char* rowsen, const double* rowrhs,
00774 const double* rowrng)
00775 {
00776 throw SimpleError("CouenneMINLPInterface model does not implement this function.",
00777 "loadProblem");
00778 }
00779
00781
00782 virtual int readMps(const char *filename,
00783 const char *extension = "mps")
00784 {
00785 throw SimpleError("CouenneMINLPInterface does not implement this function.",
00786 "readMps");
00787 }
00788
00789
00791
00792 virtual void writeMps(const char *filename,
00793 const char *extension = "mps",
00794 double objSense=0.0) const
00795 {
00796 throw SimpleError("CouenneMINLPInterface does not implement this function.",
00797 "writeMps");
00798 }
00799
00801 virtual std::vector<double*> getDualRays(int maxNumRays) const
00802 {
00803 throw SimpleError("CouenneMINLPInterface does not implement this function.",
00804 "getDualRays");
00805 }
00806
00808 virtual std::vector<double*> getPrimalRays(int maxNumRays) const
00809 {
00810 throw SimpleError("CouenneMINLPInterface does not implement this function.",
00811 "getPrimalRays");
00812 }
00813
00815
00816
00817
00818
00819
00820
00821
00823
00825 void turnOffSolverOutput(){
00826 app_->turnOffOutput();}
00827 void turnOnSolverOutput(){
00828 app_->turnOnOutput();}
00830
00832
00833
00834 virtual double getObjValue() const;
00835
00837
00839 const TMINLP2TNLP * problem() const
00840 {
00841 return GetRawPtr(problem_);
00842 }
00843
00844 TMINLP2TNLP * problem()
00845 {
00846 return GetRawPtr(problem_);
00847 }
00848
00849 const TMINLP * model() const
00850 {
00851 return GetRawPtr(tminlp_);
00852 }
00853
00854 Bonmin::TMINLP * model()
00855 {
00856 return GetRawPtr(tminlp_);
00857 }
00858
00859 const Bonmin::TNLPSolver * solver() const
00860 {
00861 return GetRawPtr(app_);
00862 }
00863
00864 TNLPSolver * solver()
00865 {
00866 return GetRawPtr(app_);
00867 }
00869
00870
00871
00872
00873
00874
00875
00876 virtual void extractLinearRelaxation(OsiSolverInterface &si, const double *x,
00877 bool getObj = 1);
00878
00882
00883 virtual void extractLinearRelaxation(OsiSolverInterface &si, bool getObj = 1,
00884 bool solveNlp = 1){
00885 if(solveNlp)
00886 initialSolve();
00887 extractLinearRelaxation(si, getColSolution(), getObj);
00888 if(solveNlp){
00889 app_->enableWarmStart();
00890 setColSolution(problem()->x_sol());
00891 setRowPrice(problem()->duals_sol());
00892 }
00893 }
00894
00898 void getOuterApproximation(OsiCuts &cs, bool getObj, const double * x2, bool global)
00899 {
00900 getOuterApproximation(cs, getColSolution(), getObj, x2, global);
00901 }
00902
00906 void getOuterApproximation(OsiCuts &cs, const double * x, bool getObj, const double * x2, bool global){
00907 getOuterApproximation(cs, x, getObj, x2, 0., global);}
00908
00912 virtual void getOuterApproximation(OsiCuts &cs, const double * x, bool getObj, const double * x2,
00913 double theta, bool global);
00914
00916 virtual void getConstraintOuterApproximation(OsiCuts & cs, int constraintNumber,
00917 const double * x,
00918 const double * x2, bool global);
00919
00921 void getConstraintOuterApproximation(OsiCuts & cs, int constraintNumber,
00922 const double * x2, bool global){
00923 getConstraintOuterApproximation(cs, constraintNumber, getColSolution(),x2,global);
00924 }
00925
00927 void getBendersCut(OsiCuts &cs, const double * x, const double *lambda, bool getObj = 1);
00928
00936 double getFeasibilityOuterApproximation(int n, const double * x_bar,const int *ind, OsiCuts &cs, bool addOnlyViolated, bool global);
00937
00946
00947 double solveFeasibilityProblem(int n, const double * x_bar, const int* ind, double a, double s, int L);
00948
00956
00957 double solveFeasibilityProblem(int n, const double * x_bar, const int* ind, int L, double cutoff);
00958
00961 void switchToFeasibilityProblem(int n, const double * x_bar, const int* ind, double a, double s, int L);
00962
00965 void switchToFeasibilityProblem(int n, const double * x_bar, const int* ind,
00966 double rhs_local_branching_constraint);
00967
00969 void switchToOriginalProblem();
00971
00974
00975
00976 enum OaMessagesTypes {
00977 CUT_NOT_VIOLATED_ENOUGH = 0,
00978 VIOLATED_OA_CUT_GENERATED,
00979 OA_CUT_GENERATED,
00980 OA_MESSAGES_DUMMY_END
00981 };
00982
00984 class OaMessages :public CoinMessages{
00985 public:
00987 OaMessages();
00988 };
00989
00991 class OaMessageHandler : public CoinMessageHandler{
00992 public:
00994 OaMessageHandler():CoinMessageHandler(){
00995 }
00997 OaMessageHandler(FILE * fp):CoinMessageHandler(fp){
00998 }
01000 virtual ~OaMessageHandler(){
01001 }
01003 OaMessageHandler(const OaMessageHandler &other):
01004 CoinMessageHandler(other){}
01006 OaMessageHandler(const CoinMessageHandler &other):
01007 CoinMessageHandler(other){}
01009 OaMessageHandler & operator=(const OaMessageHandler &rhs){
01010 CoinMessageHandler::operator=(rhs);
01011 return *this;}
01013 virtual CoinMessageHandler* clone() const{
01014 return new OaMessageHandler(*this);}
01016 void print(OsiRowCut &row);
01017 };
01018
01019 void setOaMessageHandler(const CoinMessageHandler &handler){
01020 delete oaHandler_;
01021 oaHandler_ = new OaMessageHandler(handler);
01022 }
01024
01025
01027
01028 virtual ApplyCutsReturnCode applyCuts(const OsiCuts & cs,
01029 double effectivenessLb = 0.0){
01030 freeCachedRowRim();
01031 problem_->addCuts(cs);
01032 ApplyCutsReturnCode rc;
01033 return rc;}
01034
01036 virtual void applyRowCuts(int numberCuts, const OsiRowCut * cuts);
01037
01038
01040 virtual void applyRowCuts(int numberCuts, const OsiRowCut ** cuts)
01041 {
01042 if(numberCuts)
01043 freeCachedRowRim();
01044 problem_->addCuts(numberCuts, cuts);
01045 }
01046
01048 obj the objective value of x.
01049 double getConstraintsViolation(const double * x, double & obj);
01050
01052 value where obj is the estimated objective value of x.
01053 double getNonLinearitiesViolation(const double *x, const double obj);
01054
01055
01056
01057 void extractInterfaceParams();
01058
01059
01061 virtual void setAppDefaultOptions(Ipopt::SmartPtr<Ipopt::OptionsList> Options);
01062
01064 static void registerOptions (Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions);
01065
01066 Ipopt::SmartPtr<Bonmin::RegisteredOptions> regOptions(){
01067 if(IsValid(app_))
01068 return app_->roptions();
01069 else
01070 return NULL;
01071 }
01072
01074
01075
01076 void SetStrongBrachingSolver(Ipopt::SmartPtr<StrongBranchingSolver> strong_branching_solver);
01079 virtual void markHotStart();
01083 virtual void solveFromHotStart();
01086 virtual void unmarkHotStart();
01088
01089 protected:
01090
01092
01093 enum RandomGenerationType{
01094 uniform =0, perturb=1, perturb_suffix=2};
01096 int initializeJacobianArrays();
01097
01099
01100
01101
01103 void solveAndCheckErrors(bool doResolve, bool throwOnFailure,
01104 const char * whereFrom);
01105
01106
01108
01109 virtual void applyRowCut( const OsiRowCut & rc )
01110 {
01111 const OsiRowCut * cut = &rc;
01112 problem_->addCuts(1, &cut);
01113 }
01115
01116 virtual void applyColCut( const OsiColCut & cc )
01117 {
01118 throw SimpleError("Ipopt model does not implement this function.",
01119 "applyColCut");
01120 }
01121
01122
01123
01124
01126
01128
01129
01130 Ipopt::SmartPtr<TMINLP> tminlp_;
01132 Ipopt::SmartPtr<TMINLP2TNLP> problem_;
01134 Ipopt::SmartPtr<Ipopt::TNLP> problem_to_optimize_;
01136 bool feasibility_mode_;
01138 Ipopt::SmartPtr<TNLPSolver> app_;
01139
01141 std::list<Ipopt::SmartPtr<TNLPSolver> > debug_apps_;
01143 bool testOthers_;
01145
01147 CoinWarmStart* warmstart_;
01148
01150
01151
01152 void freeCachedColRim();
01154 void freeCachedRowRim();
01156 void freeCachedData();
01159 void extractSenseRhsAndRange() const;
01161 mutable char *rowsense_;
01162
01164 mutable double *rhs_;
01165
01167 mutable double *rowrange_;
01170 mutable double *reducedCosts_;
01172 double OsiDualObjectiveLimit_;
01174 mutable bool hasVarNamesFile_;
01176
01177 int nCallOptimizeTNLP_;
01179 double totalNlpSolveTime_;
01181 int totalIterations_;
01183 double maxRandomRadius_;
01185 int randomGenerationType_;
01187 double max_perturbation_;
01189 double pushValue_;
01191 int numRetryInitial_;
01193 int numRetryResolve_;
01195 int numRetryInfeasibles_;
01197 int numRetryUnsolved_;
01199 Messages messages_;
01203 int pretendFailIsInfeasible_;
01205 bool hasContinuedAfterNlpFailure_;
01208 int numIterationSuspect_ ;
01212 bool hasBeenOptimized_;
01216 mutable double * obj_;
01218 static bool hasPrintedOptions;
01219
01221 Ipopt::SmartPtr<TNLP2FPNLP> feasibilityProblem_;
01222
01223
01225
01226
01227 int * jRow_;
01229 int * jCol_;
01231 double * jValues_;
01233 int nnz_jac;
01235
01237 Ipopt::TNLP::LinearityType * constTypes_;
01239
01240 int nNonLinear_;
01242 double tiny_;
01244 double veryTiny_;
01246 double infty_;
01248 TNLPSolver::ReturnStatus optimizationStatus_;
01250 bool exposeWarmStart_;
01252 bool firstSolve_;
01254 SmartPtr<CutStrengthener> cutStrengthener_;
01255
01258
01259
01260 OaMessages oaMessages_;
01262 OaMessageHandler * oaHandler_;
01264 protected:
01266 void createApplication(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions,
01267 Ipopt::SmartPtr<Ipopt::OptionsList> options,
01268 Ipopt::SmartPtr<Ipopt::Journalist> journalist);
01270 CouenneMINLPInterface(Ipopt::SmartPtr<TNLPSolver> app);
01271
01273 bool internal_setWarmStart(const CoinWarmStart* ws);
01274
01276 CoinWarmStart* internal_getWarmStart() const;
01277 private:
01279 SmartPtr<StrongBranchingSolver> strong_branching_solver_;
01281 TNLPSolver::ReturnStatus optimizationStatusBeforeHotStart_;
01282 static const char * OPT_SYMB;
01283 static const char * FAILED_SYMB;
01284 static const char * INFEAS_SYMB;
01285 static const char * UNBOUND_SYMB;
01287 const char * statusAsString(TNLPSolver::ReturnStatus r){
01288 if(r == TNLPSolver::solvedOptimal || r == TNLPSolver::solvedOptimalTol){
01289 return OPT_SYMB;}
01290 else if(r == TNLPSolver::provenInfeasible){
01291 return INFEAS_SYMB;}
01292 else if(r == TNLPSolver::unbounded){
01293 return UNBOUND_SYMB;}
01294 else return FAILED_SYMB;
01295 }
01296 const char * statusAsString(){
01297 return statusAsString(optimizationStatus_);}
01298 #endif
01299 };
01300 }
01301
01302 #endif
01303