00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013 #ifndef OsiTMINLPInterface_H
00014 #define OsiTMINLPInterface_H
00015
00016 #define INT_BIAS 0e-8
00017
00018 #include <string>
00019 #include <iostream>
00020
00021 #include "OsiSolverInterface.hpp"
00022 #include "CoinWarmStartBasis.hpp"
00023
00024 #include "BonCutStrengthener.hpp"
00025
00026
00027 namespace Bonmin {
00028 class TMINLP;
00029 class TMINLP2TNLP;
00030 class TNLP2FPNLP;
00031 class TNLPSolver;
00032 class RegisteredOptions;
00033 class StrongBranchingSolver;
00034
00036 enum Solver{
00037 EIpopt=0 ,
00038 EFilterSQP ,
00039 EAll
00040 };
00047 class OsiTMINLPInterface : public OsiSolverInterface
00048 {
00049 friend class BonminParam;
00050
00051 public:
00052
00053
00054
00059 class SimpleError : public CoinError
00060 {
00061 private:
00062 SimpleError();
00063
00064 public:
00066 SimpleError(std::string message,
00067 std::string methodName,
00068 std::string f = std::string(),
00069 int l = -1)
00070 :
00071 CoinError(message,methodName,std::string("OsiTMINLPInterface"), f, l)
00072 {}
00073 }
00074 ;
00075
00076 #ifdef __LINE__
00077 #define SimpleError(x, y) SimpleError((x), (y), __FILE__, __LINE__)
00078 #endif
00079
00080
00081 TNLPSolver::UnsolvedError * newUnsolvedError(int num, Ipopt::SmartPtr<TMINLP2TNLP> problem, std::string name){
00082 return app_->newUnsolvedError(num, problem, name);
00083 }
00084
00085
00086 enum WarmStartModes{
00087 None,
00088 FakeBasis,
00089 Optimum,
00090 InteriorPoint};
00091
00093 enum MessagesTypes{
00094 SOLUTION_FOUND,
00095 INFEASIBLE_SOLUTION_FOUND,
00096 UNSOLVED_PROBLEM_FOUND,
00097 WARNING_RESOLVING ,
00098 WARN_SUCCESS_WS,
00099 WARN_SUCCESS_RANDOM,
00100 WARN_CONTINUING_ON_FAILURE,
00101 SUSPECT_PROBLEM,
00102 SUSPECT_PROBLEM2,
00103 IPOPT_SUMMARY ,
00104 BETTER_SOL ,
00105 LOG_HEAD,
00106 LOG_FIRST_LINE,
00107 LOG_LINE,
00108 ALTERNATE_OBJECTIVE,
00109 WARN_RESOLVE_BEFORE_INITIAL_SOLVE ,
00112 ERROR_NO_TNLPSOLVER ,
00113 WARNING_NON_CONVEX_OA ,
00114 SOLVER_DISAGREE_STATUS ,
00115 SOLVER_DISAGREE_VALUE ,
00116 OSITMINLPINTERFACE_DUMMY_END
00117 };
00118
00119
00120
00121
00123 class Messages : public CoinMessages
00124 {
00125 public:
00127 Messages();
00128 };
00129
00130
00131
00132
00133
00136
00137 OsiTMINLPInterface();
00138
00140 void initialize(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions,
00141 Ipopt::SmartPtr<Ipopt::OptionsList> options,
00142 Ipopt::SmartPtr<Ipopt::Journalist> journalist,
00143 const std::string & prefix,
00144 Ipopt::SmartPtr<TMINLP> tminlp);
00145
00147 void initialize(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions,
00148 Ipopt::SmartPtr<Ipopt::OptionsList> options,
00149 Ipopt::SmartPtr<Ipopt::Journalist> journalist,
00150 Ipopt::SmartPtr<TMINLP> tminlp){
00151 initialize(roptions, options, journalist, "bonmin.", tminlp);
00152 }
00153
00155 void setModel(Ipopt::SmartPtr<TMINLP> tminlp);
00157 void setSolver(Ipopt::SmartPtr<TNLPSolver> app);
00159 void use(Ipopt::SmartPtr<TMINLP2TNLP> tminlp2tnlp);
00162 OsiTMINLPInterface (const OsiTMINLPInterface &);
00163
00165 OsiSolverInterface * clone(bool copyData = true) const;
00166
00168 OsiTMINLPInterface & operator=(const OsiTMINLPInterface& rhs);
00169
00171 virtual ~OsiTMINLPInterface ();
00172
00173
00175 void readOptionFile(const std::string & fileName);
00176
00178 const Ipopt::SmartPtr<Ipopt::OptionsList> options() const;
00180 Ipopt::SmartPtr<Ipopt::OptionsList> options();
00181
00182 const char * prefix() const{
00183 if(!IsValid(app_)) {
00184 messageHandler()->message(ERROR_NO_TNLPSOLVER, messages_)<<CoinMessageEol;
00185 return NULL;
00186 }
00187 else
00188 return app_->prefix();
00189 }
00191
00194
00195 virtual void initialSolve();
00196
00198 virtual void initialSolve(const char * whereFrom);
00199
00205 virtual void resolve();
00206
00212 virtual void resolve(const char * whereFrom);
00213
00216 virtual void resolveForCost(int numretry, bool keepWs);
00217
00221 virtual void resolveForRobustness(int numretry);
00222
00224 virtual void branchAndBound()
00225 {
00226 throw SimpleError("Function not implemented for OsiTMINLPInterface","branchAndBound()");
00227 }
00229
00230
00231
00232
00234
00235
00236 virtual bool isAbandoned() const;
00238 virtual bool isProvenOptimal() const;
00240 virtual bool isProvenPrimalInfeasible() const;
00242 virtual bool isProvenDualInfeasible() const;
00244 virtual bool isPrimalObjectiveLimitReached() const;
00246 virtual bool isDualObjectiveLimitReached() const;
00248 virtual bool isIterationLimitReached() const;
00249
00251 void continuingOnAFailure()
00252 {
00253 hasContinuedAfterNlpFailure_ = true;
00254 }
00255
00256
00257
00258
00259 double getNewCutoffDecr()
00260 {
00261 return newCutoffDecr;
00262 }
00263
00264 void setNewCutoffDecr(double d)
00265 {
00266 newCutoffDecr = d;
00267 }
00268
00269
00271 bool hasContinuedOnAFailure()
00272 {
00273 return hasContinuedAfterNlpFailure_;
00274 }
00276 void ignoreFailures()
00277 {
00278 pretendFailIsInfeasible_ = 2;
00279 }
00281 void forceInfeasible()
00282 {
00283 problem_->set_obj_value(1e200);
00284 }
00286 void forceBranchable()
00287 {
00288 problem_->set_obj_value(-1e200);
00289 problem_->force_fractionnal_sol();
00290 }
00292
00293
00294
00310
00311 bool setIntParam(OsiIntParam key, int value);
00312
00313 bool setDblParam(OsiDblParam key, double value);
00314
00315 bool setStrParam(OsiStrParam key, const std::string & value);
00316
00317 bool getIntParam(OsiIntParam key, int& value) const;
00318
00319 bool getDblParam(OsiDblParam key, double& value) const;
00320
00321 bool getStrParam(OsiStrParam key, std::string& value) const;
00322
00323
00324 inline double getPushFact() const
00325 {
00326 return pushValue_;
00327 }
00328
00330
00331
00332
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
00368 virtual const char * getRowSense() const;
00369
00378 virtual const double * getRightHandSide() const;
00379
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
00413 virtual bool isInteger(int columnNumber) const;
00414
00416 virtual bool isIntegerNonBinary(int columnNumber) const;
00417
00419 virtual bool isFreeBinary(int columnNumber) const;
00420
00422 virtual double getInfinity() const;
00423
00425 const int * getPriorities() const
00426 {
00427 const TMINLP::BranchingInfo * branch = tminlp_->branchingInfo();
00428 if(branch)
00429 return branch->priorities;
00430 else return NULL;
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 const double * getUpPsCosts() const
00441 {
00442 const TMINLP::BranchingInfo * branch = tminlp_->branchingInfo();
00443 if(branch)
00444 return branch->upPsCosts;
00445 else return NULL;
00446 }
00447 const double * getDownPsCosts() const
00448 {
00449 const TMINLP::BranchingInfo * branch = tminlp_->branchingInfo();
00450 if(branch)
00451 return branch->downPsCosts;
00452 else return NULL;
00453 }
00454
00455
00457
00460
00461 virtual const double * getColSolution() const;
00462
00464 virtual const double * getRowPrice() const;
00465
00467 virtual const double * getReducedCost() const;
00468
00471 virtual const double * getRowActivity() const;
00472
00473
00478 virtual int getIterationCount() const;
00479
00481 int nCallOptimizeTNLP()
00482 {
00483 return nCallOptimizeTNLP_;
00484 }
00486 double totalNlpSolveTime()
00487 {
00488 return totalNlpSolveTime_;
00489 }
00491 int totalIterations()
00492 {
00493 return totalIterations_;
00494 }
00495
00496
00498
00502
00505 virtual void setColLower( int elementIndex, double elementValue );
00506
00509 virtual void setColUpper( int elementIndex, double elementValue );
00510
00514 virtual void setColLower(const double * array);
00515
00519 virtual void setColUpper(const double * array);
00520
00521
00524 virtual void setRowLower( int elementIndex, double elementValue );
00525
00528 virtual void setRowUpper( int elementIndex, double elementValue );
00529
00531 virtual void setRowType(int index, char sense, double rightHandSide,
00532 double range);
00533
00534
00539 virtual void setObjSense(double s);
00540
00545 virtual void setColSolution(const double *colsol);
00546
00551 virtual void setRowPrice(const double * rowprice);
00552
00554
00555
00556
00559
00566 virtual CoinWarmStart *getEmptyWarmStart () const;
00567
00569 virtual CoinWarmStart* getWarmStart() const;
00570
00573 virtual bool setWarmStart(const CoinWarmStart* warmstart);
00574
00575 void setWarmStartMode(int mode) {
00576 warmStartMode_ = (WarmStartModes) mode;
00577 }
00578 WarmStartModes getWarmStartMode() {
00579 return warmStartMode_;
00580 }
00581
00582 void randomStartingPoint();
00583
00584
00585 virtual bool basisIsAvailable() const
00586 {
00587
00588 throw SimpleError("Needs coding for this interface", "basisIsAvailable");
00589 }
00590
00591
00593
00594
00598 virtual void setContinuous(int index);
00600 virtual void setInteger(int index);
00602
00603
00604 void setNumIterationSuspect(int value)
00605 {
00606 numIterationSuspect_ = value;
00607 }
00608
00614
00617 virtual int getNumElements() const
00618 {
00619 return -1;
00620 }
00621
00622
00627 virtual const double * getObjCoefficients() const;
00628
00631 virtual const CoinPackedMatrix * getMatrixByRow() const
00632 {
00633 return NULL;
00634 }
00635
00636
00639 virtual const CoinPackedMatrix * getMatrixByCol() const
00640 {
00641 return NULL;
00642 }
00643
00646 virtual void setObjCoeff( int elementIndex, double elementValue )
00647 {
00648 throw SimpleError("OsiTMINLPInterface does not implement this function.",
00649 "setObjCoeff");
00650 }
00651
00654 virtual void addCol(const CoinPackedVectorBase& vec,
00655 const double collb, const double colub,
00656 const double obj)
00657 {
00658 throw SimpleError("OsiTMINLPInterface does not implement this function.",
00659 "addCol");
00660 }
00663 virtual void deleteCols(const int num, const int * colIndices)
00664 {
00665 throw SimpleError("OsiTMINLPInterface does not implement this function.",
00666 "deleteCols");
00667 }
00668
00671 virtual void addRow(const CoinPackedVectorBase& vec,
00672 const double rowlb, const double rowub)
00673 {
00674 throw SimpleError("OsiTMINLPInterface does not implement this function.",
00675 "addRow");
00676 }
00679 virtual void addRow(const CoinPackedVectorBase& vec,
00680 const char rowsen, const double rowrhs,
00681 const double rowrng)
00682 {
00683 throw SimpleError("OsiTMINLPInterface model does not implement this function.",
00684 "addRow");
00685 }
00688 virtual void deleteRows(const int num, const int * rowIndices)
00689 {
00690 if(num)
00691 freeCachedRowRim();
00692 problem_->removeCuts(num, rowIndices);
00693 }
00694
00695
00698 virtual void loadProblem(const CoinPackedMatrix& matrix,
00699 const double* collb, const double* colub,
00700 const double* obj,
00701 const double* rowlb, const double* rowub)
00702 {
00703 throw SimpleError("OsiTMINLPInterface does not implement this function.",
00704 "loadProblem");
00705 }
00706
00707
00710 virtual void assignProblem(CoinPackedMatrix*& matrix,
00711 double*& collb, double*& colub, double*& obj,
00712 double*& rowlb, double*& rowub)
00713 {
00714 throw SimpleError("OsiTMINLPInterface does not implement this function.",
00715 "assignProblem");
00716 }
00717
00720 virtual void loadProblem(const CoinPackedMatrix& matrix,
00721 const double* collb, const double* colub,
00722 const double* obj,
00723 const char* rowsen, const double* rowrhs,
00724 const double* rowrng)
00725 {
00726 throw SimpleError("OsiTMINLPInterface does not implement this function.",
00727 "loadProblem");
00728 }
00729
00732 virtual void assignProblem(CoinPackedMatrix*& matrix,
00733 double*& collb, double*& colub, double*& obj,
00734 char*& rowsen, double*& rowrhs,
00735 double*& rowrng)
00736 {
00737 throw SimpleError("OsiTMINLPInterface does not implement this function.",
00738 "assignProblem");
00739 }
00740
00741
00744 virtual void loadProblem(const int numcols, const int numrows,
00745 const int* start, const int* index,
00746 const double* value,
00747 const double* collb, const double* colub,
00748 const double* obj,
00749 const double* rowlb, const double* rowub)
00750 {
00751 throw SimpleError("OsiTMINLPInterface does not implement this function.",
00752 "loadProblem");
00753 }
00754
00757 virtual void loadProblem(const int numcols, const int numrows,
00758 const int* start, const int* index,
00759 const double* value,
00760 const double* collb, const double* colub,
00761 const double* obj,
00762 const char* rowsen, const double* rowrhs,
00763 const double* rowrng)
00764 {
00765 throw SimpleError("OsiTMINLPInterface model does not implement this function.",
00766 "loadProblem");
00767 }
00768
00771 virtual int readMps(const char *filename,
00772 const char *extension = "mps")
00773 {
00774 throw SimpleError("OsiTMINLPInterface does not implement this function.",
00775 "readMps");
00776 }
00777
00778
00781 virtual void writeMps(const char *filename,
00782 const char *extension = "mps",
00783 double objSense=0.0) const
00784 {
00785 throw SimpleError("OsiTMINLPInterface does not implement this function.",
00786 "writeMps");
00787 }
00788
00790 virtual std::vector<double*> getDualRays(int maxNumRays, bool fullRay = false) const
00791 {
00792 throw SimpleError("OsiTMINLPInterface does not implement this function.",
00793 "getDualRays");
00794 }
00795
00797 virtual std::vector<double*> getPrimalRays(int maxNumRays) const
00798 {
00799 throw SimpleError("OsiTMINLPInterface does not implement this function.",
00800 "getPrimalRays");
00801 }
00802
00804
00805
00806
00807
00808
00809
00810
00814 void setSolverOutputToDefault(){
00815 app_->setOutputToDefault();}
00816 void forceSolverOutput(int log_level){
00817 app_->forceSolverOutput(log_level);}
00819
00822
00823 virtual double getObjValue() const;
00824
00826
00828 const TMINLP2TNLP * problem() const
00829 {
00830 return GetRawPtr(problem_);
00831 }
00832
00833 TMINLP2TNLP * problem()
00834 {
00835 return GetRawPtr(problem_);
00836 }
00837
00838 const TMINLP * model() const
00839 {
00840 return GetRawPtr(tminlp_);
00841 }
00842
00843 Bonmin::TMINLP * model()
00844 {
00845 return GetRawPtr(tminlp_);
00846 }
00847
00848 const Bonmin::TNLPSolver * solver() const
00849 {
00850 return GetRawPtr(app_);
00851 }
00852
00853 const std::list<Ipopt::SmartPtr<TNLPSolver> >& debug_apps() const{
00854 return debug_apps_;
00855 }
00856
00857 TNLPSolver * solver()
00858 {
00859 return GetRawPtr(app_);
00860 }
00869 virtual void extractLinearRelaxation(OsiSolverInterface &si, const double *x,
00870 bool getObj = 1);
00871
00873 virtual void addObjectiveFunction(OsiSolverInterface &si, const double * x);
00874 #if 1
00875
00879 virtual void extractLinearRelaxation(OsiSolverInterface &si, bool getObj = 1,
00880 bool solveNlp = 1){
00881 if(solveNlp)
00882 initialSolve("build initial OA");
00883 extractLinearRelaxation(si, getColSolution(), getObj);
00884 if(solveNlp){
00885 app_->enableWarmStart();
00886 setColSolution(problem()->x_sol());
00887 setRowPrice(problem()->duals_sol());
00888 }
00889 }
00890 #endif
00891
00894 void getOuterApproximation(OsiCuts &cs, int getObj, const double * x2, bool global)
00895 {
00896 getOuterApproximation(cs, getColSolution(), getObj, x2, global);
00897 }
00898
00902 void getOuterApproximation(OsiCuts &cs, const double * x, int getObj, const double * x2, bool global){
00903 getOuterApproximation(cs, x, getObj, x2, 0., global);}
00904
00908 virtual void getOuterApproximation(OsiCuts &cs, const double * x, int getObj, const double * x2,
00909 double theta, bool global);
00910
00912 virtual void getConstraintOuterApproximation(OsiCuts & cs, int constraintNumber,
00913 const double * x,
00914 const double * x2, bool global);
00915
00917 void getConstraintOuterApproximation(OsiCuts & cs, int constraintNumber,
00918 const double * x2, bool global){
00919 getConstraintOuterApproximation(cs, constraintNumber, getColSolution(),x2,global);
00920 }
00921
00922
00924 void getBendersCut(OsiCuts &cs, bool global);
00925
00935 double solveFeasibilityProblem(int n, const double * x_bar, const int* ind, double a, double s, int L);
00936
00945 double solveFeasibilityProblem(int n, const double * x_bar, const int* ind, int L, double cutoff);
00946
00949 void switchToFeasibilityProblem(int n, const double * x_bar, const int* ind, double a, double s, int L);
00950
00953 void switchToFeasibilityProblem(int n, const double * x_bar, const int* ind,
00954 double rhs_local_branching_constraint);
00955
00957 void switchToOriginalProblem();
00958
00960 void round_and_check(double tolerance,
00961 OsiObject ** objects = 0, int nObjects = -1){
00962 if(!problem_->check_solution(objects, nObjects)){
00963 optimizationStatus_ = TNLPSolver::provenInfeasible;
00964 }
00965 }
00967
00972 enum OaMessagesTypes {
00973 CUT_NOT_VIOLATED_ENOUGH = 0,
00974 VIOLATED_OA_CUT_GENERATED,
00975 OA_CUT_GENERATED,
00976 OA_MESSAGES_DUMMY_END};
00978 class OaMessages :public CoinMessages{
00979 public:
00981 OaMessages();
00982 };
00984 class OaMessageHandler : public CoinMessageHandler{
00985 public:
00987 OaMessageHandler():CoinMessageHandler(){
00988 }
00990 OaMessageHandler(FILE * fp):CoinMessageHandler(fp){
00991 }
00993 virtual ~OaMessageHandler(){
00994 }
00996 OaMessageHandler(const OaMessageHandler &other):
00997 CoinMessageHandler(other){}
00999 OaMessageHandler(const CoinMessageHandler &other):
01000 CoinMessageHandler(other){}
01002 OaMessageHandler & operator=(const OaMessageHandler &rhs){
01003 CoinMessageHandler::operator=(rhs);
01004 return *this;}
01006 virtual CoinMessageHandler* clone() const{
01007 return new OaMessageHandler(*this);}
01009 void print(OsiRowCut &row);
01010 };
01011 void setOaMessageHandler(const CoinMessageHandler &handler){
01012 delete oaHandler_;
01013 oaHandler_ = new OaMessageHandler(handler);
01014 }
01016
01017
01020 virtual ApplyCutsReturnCode applyCuts(const OsiCuts & cs,
01021 double effectivenessLb = 0.0){
01022 freeCachedRowRim();
01023 problem_->addCuts(cs);
01024 ApplyCutsReturnCode rc;
01025 return rc;}
01026
01028 virtual void applyRowCuts(int numberCuts, const OsiRowCut * cuts);
01029
01030
01032 virtual void applyRowCuts(int numberCuts, const OsiRowCut ** cuts)
01033 {
01034 if(numberCuts)
01035 freeCachedRowRim();
01036 problem_->addCuts(numberCuts, cuts);
01037 }
01038
01041 double getConstraintsViolation(const double * x, double & obj);
01042
01045 double getNonLinearitiesViolation(const double *x, const double obj);
01046
01047
01048
01049 void extractInterfaceParams();
01050
01051
01053 virtual void setAppDefaultOptions(Ipopt::SmartPtr<Ipopt::OptionsList> Options);
01054
01056 static void registerOptions (Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions);
01057
01058 Ipopt::SmartPtr<Bonmin::RegisteredOptions> regOptions(){
01059 if(IsValid(app_))
01060 return app_->roptions();
01061 else
01062 return NULL;
01063 }
01064
01067
01068 void SetStrongBrachingSolver(Ipopt::SmartPtr<StrongBranchingSolver> strong_branching_solver);
01071 virtual void markHotStart();
01075 virtual void solveFromHotStart();
01078 virtual void unmarkHotStart();
01080
01082 void get_tolerances(double &tiny, double&very_tiny, double &infty){
01083 tiny = tiny_;
01084 very_tiny = veryTiny_;
01085 infty = infty_;
01086 }
01087
01088 protected:
01089
01091
01092 enum RandomGenerationType{
01093 uniform =0, perturb=1, perturb_suffix=2};
01095 int initializeJacobianArrays();
01096
01098
01099 virtual std::string appName()
01100 {
01101 return "bonmin";
01102 }
01104
01105
01106
01108 void solveAndCheckErrors(bool doResolve, bool throwOnFailure,
01109 const char * whereFrom);
01110
01111
01114 virtual void applyRowCut( const OsiRowCut & rc )
01115 {
01116 const OsiRowCut * cut = &rc;
01117 problem_->addCuts(1, &cut);
01118 }
01121 virtual void applyColCut( const OsiColCut & cc )
01122 {
01123 throw SimpleError("Ipopt model does not implement this function.",
01124 "applyColCut");
01125 }
01126
01127
01128
01129
01131
01135 Ipopt::SmartPtr<TMINLP> tminlp_;
01137 Ipopt::SmartPtr<TMINLP2TNLP> problem_;
01139 Ipopt::SmartPtr<Ipopt::TNLP> problem_to_optimize_;
01141 bool feasibility_mode_;
01143 Ipopt::SmartPtr<TNLPSolver> app_;
01144
01146 std::list<Ipopt::SmartPtr<TNLPSolver> > debug_apps_;
01148 bool testOthers_;
01150
01152 CoinWarmStart* warmstart_;
01153
01157 void freeCachedColRim();
01159 void freeCachedRowRim();
01161 void freeCachedData();
01164 void extractSenseRhsAndRange() const;
01166 mutable char *rowsense_;
01167
01169 mutable double *rhs_;
01170
01172 mutable double *rowrange_;
01175 mutable double *reducedCosts_;
01177 double OsiDualObjectiveLimit_;
01179 mutable bool hasVarNamesFile_;
01181
01182 int nCallOptimizeTNLP_;
01184 double totalNlpSolveTime_;
01186 int totalIterations_;
01188 double maxRandomRadius_;
01190 int randomGenerationType_;
01192 double max_perturbation_;
01194 double pushValue_;
01196 int numRetryInitial_;
01198 int numRetryResolve_;
01200 int numRetryInfeasibles_;
01202 int numRetryUnsolved_;
01204 double infeasibility_epsilon_;
01205
01206
01207
01209 int dynamicCutOff_;
01211 double coeff_var_threshold_;
01213 double first_perc_for_cutoff_decr_;
01215 double second_perc_for_cutoff_decr_;
01216
01217
01219 Messages messages_;
01223 int pretendFailIsInfeasible_;
01224
01225 mutable int pretendSucceededNext_;
01226
01228 bool hasContinuedAfterNlpFailure_;
01231 int numIterationSuspect_ ;
01235 bool hasBeenOptimized_;
01239 mutable double * obj_;
01241 static bool hasPrintedOptions;
01242
01244 Ipopt::SmartPtr<TNLP2FPNLP> feasibilityProblem_;
01245
01246
01250 int * jRow_;
01252 int * jCol_;
01254 double * jValues_;
01256 int nnz_jac;
01258
01260 Ipopt::TNLP::LinearityType * constTypes_;
01263 int nNonLinear_;
01265 double tiny_;
01267 double veryTiny_;
01269 double infty_;
01271 TNLPSolver::ReturnStatus optimizationStatus_;
01273 WarmStartModes warmStartMode_;
01275 bool firstSolve_;
01277 Ipopt::SmartPtr<CutStrengthener> cutStrengthener_;
01278
01283 OaMessages oaMessages_;
01285 OaMessageHandler * oaHandler_;
01287
01288 double newCutoffDecr;
01289 protected:
01291 void createApplication(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions,
01292 Ipopt::SmartPtr<Ipopt::OptionsList> options,
01293 Ipopt::SmartPtr<Ipopt::Journalist> journalist,
01294 const std::string & prefix);
01296 OsiTMINLPInterface(Ipopt::SmartPtr<TNLPSolver> app);
01297
01299 bool internal_setWarmStart(const CoinWarmStart* ws);
01300
01302 CoinWarmStart* internal_getWarmStart() const;
01303
01305 CoinWarmStart* build_fake_basis() const;
01306 private:
01307
01309 Ipopt::SmartPtr<StrongBranchingSolver> strong_branching_solver_;
01311 TNLPSolver::ReturnStatus optimizationStatusBeforeHotStart_;
01312 static const char * OPT_SYMB;
01313 static const char * FAILED_SYMB;
01314 static const char * INFEAS_SYMB;
01315 static const char * TIME_SYMB;
01316 static const char * UNBOUND_SYMB;
01318 const char * statusAsString(TNLPSolver::ReturnStatus r){
01319 if(r == TNLPSolver::solvedOptimal || r == TNLPSolver::solvedOptimalTol){
01320 return OPT_SYMB;}
01321 else if(r == TNLPSolver::provenInfeasible){
01322 return INFEAS_SYMB;}
01323 else if(r == TNLPSolver::unbounded){
01324 return UNBOUND_SYMB;}
01325 else if(r == TNLPSolver::timeLimit){
01326 return TIME_SYMB;}
01327 else return FAILED_SYMB;
01328 }
01329 const char * statusAsString(){
01330 return statusAsString(optimizationStatus_);}
01331 };
01332 }
01333 #endif