CouenneMINLPInterface.hpp

Go to the documentation of this file.

/* $Id: CouenneMINLPInterface.hpp 490 2011-01-14 16:07:12Z pbelotti $
 *
 * Name:    CouenneMINLPInterface
 * Author:  Pietro Belotti
 * Purpose: MINLP interface with computation of gradient and Jacobian
 *          through CouenneExpressions
 *
 * (C) Pietro Belotti 2010
 * This file is licensed under the Eclipse Public License (EPL)
 */

#ifndef CouenneMINLPInterface_hpp
#define CouenneMINLPInterface_hpp

//#define INT_BIAS 0e-8

//#include <string>
//#include <iostream>

#include "OsiSolverInterface.hpp"

// #include "CoinWarmStartBasis.hpp"

// #include "BonTMINLP.hpp"
// #include "BonTMINLP2TNLP.hpp"
// #include "BonTNLP2FPNLP.hpp"
//#include "BonTNLPSolver.hpp"
//#include "BonCutStrengthener.hpp"
//#include "BonRegisteredOptions.hpp"

#include "CouenneTypes.hpp"

namespace Ipopt {
  class OptionsList;
}

namespace Couenne {

  class expression;
  class CouenneProblem;

  //class RegisteredOptions;
  //class StrongBranchingSolver;


  enum Solver {
    EIpopt=0,   
    EFilterSQP, 
    EAll        
  };



  class CouenneMINLPInterface: public OsiSolverInterface {

  public:

    void setObj (int index, expression *newObj) {}

    void setInitSol (const CouNumber *sol);

    CouNumber solve (CouNumber *solution);

    CouenneProblem *problem () const
    {return problem_;}

    Ipopt::OptionsList *options () const
    {return options_;}

  private:

    CouenneProblem *problem_;

    Ipopt::OptionsList *options_;

    virtual std::string appName ()
    {return "couenne";}


#if 0
    //friend class BonminParam;

  public:

    //     /// Error class to throw exceptions from CouenneMINLPInterface.
    //      *  Inherited from CoinError, we just want to have a different class to be able to catch
    //      *  errors thrown by CouenneMINLPInterface.
    //      

    //     class SimpleError: public CoinError {

    //     private:
    //       SimpleError();

    //     public:
    //       ///Alternate constructor using strings
    //       SimpleError(std::string message,
    //            std::string methodName,
    //            std::string f = std::string(),
    //            int l = -1):
    //         CoinError(message,methodName,std::string("CouenneMINLPInterface"), f, l)  {}
    //     };

    // #ifdef __LINE__
    // #define SimpleError(x, y) SimpleError((x), (y), __FILE__, __LINE__)
    // #endif

    //   // Error when problem is not solved
    //   TNLPSolver::UnsolvedError * newUnsolvedError(int num, Ipopt::SmartPtr<TMINLP2TNLP> problem, std::string name){
    //     return app_ -> newUnsolvedError (num, problem, name);
    //   }
    //   //#############################################################################


    //   /// Type of the messages specifically outputed by CouenneMINLPInterface.
    //   enum MessagesTypes{
    //     SOLUTION_FOUND///found a feasible solution,
    //     INFEASIBLE_SOLUTION_FOUND///found an infeasible problem,
    //     UNSOLVED_PROBLEM_FOUND///found an unsolved problem,
    //     WARNING_RESOLVING /// Warn that a problem is resolved,
    //     WARN_SUCCESS_WS/// Problem not solved with warm start but solved without,
    //     WARN_SUCCESS_RANDOM/// Subproblem not solve with warm start but solved with random point,
    //     WARN_CONTINUING_ON_FAILURE/// a failure occured but is continuing,
    //     SUSPECT_PROBLEM/// Output the number of the problem.,
    //     SUSPECT_PROBLEM2/// Output the number of the problem.,
    //     IPOPT_SUMMARY /// Output summary statistics on Ipopt solution.,
    //     BETTER_SOL /// Found a better solution with random values.,
    //     LOG_HEAD/// Head of "civilized" log.,
    //     LOG_FIRST_LINE/// First line (first solve) of log.,
    //     LOG_LINE///standard line (retry solving) of log.,
    //     ALTERNATE_OBJECTIVE/// Recomputed integer feasible with alternate objective function,
    //     WARN_RESOLVE_BEFORE_INITIAL_SOLVE /// resolve() has been called but there
    //                                               was no previous call to initialSolve().
    //                                          ,
    //     ERROR_NO_TNLPSOLVER /// Trying to access non-existent TNLPSolver,
    //     WARNING_NON_CONVEX_OA /// Warn that there are equality or ranged constraints and OA may works bad.,
    //     SOLVER_DISAGREE_STATUS /// Different solver gives different status for problem.,
    //     SOLVER_DISAGREE_VALUE /// Different solver gives different optimal value for problem.,
    //     OSITMINLPINTERFACE_DUMMY_END
    //   };

    //#############################################################################


    //   /// Messages outputed by an CouenneMINLPInterface. 
    // class Messages : public CoinMessages
    //   {
    //   public:
    //     /// Constructor
    //     Messages();
    //   };


    //#############################################################################



    CouenneMINLPInterface ();

    void initialize(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions,
                    Ipopt::SmartPtr<Ipopt::OptionsList> options,
                    Ipopt::SmartPtr<Ipopt::Journalist> journalist_,
                    Ipopt::SmartPtr<TMINLP> tminlp);

    void setModel(Ipopt::SmartPtr<TMINLP> tminlp);

    void setSolver(Ipopt::SmartPtr<TNLPSolver> app);

    void use(Ipopt::SmartPtr<TMINLP2TNLP> tminlp2tnlp){
      problem_ = tminlp2tnlp;}

    CouenneMINLPInterface (const CouenneMINLPInterface &);

    OsiSolverInterface * clone (bool copyData = true) const;

    CouenneMINLPInterface & operator=(const CouenneMINLPInterface& rhs);

    virtual ~CouenneMINLPInterface ();

    void readOptionFile(const std::string & fileName);

    const Ipopt::SmartPtr<Ipopt::OptionsList> options() const;

    Ipopt::SmartPtr<Ipopt::OptionsList> options();

    //---------------------------------------------------------------------------

    virtual void initialSolve();

    
    virtual void resolve();

    
    virtual void resolveForCost(int numretry, bool keepWs);

    
    virtual void resolveForRobustness(int numretry);

    virtual void branchAndBound()
    {
      //throw SimpleError ("Function not implemented for CouenneMINLPInterface","branchAndBound()");
    }


    //---------------------------------------------------------------------------


    virtual bool isAbandoned ()                   const; 
    virtual bool isProvenOptimal ()               const; 
    virtual bool isProvenPrimalInfeasible ()      const; 
    virtual bool isProvenDualInfeasible ()        const; 
    virtual bool isPrimalObjectiveLimitReached () const; 
    virtual bool isDualObjectiveLimitReached ()   const; 
    virtual bool isIterationLimitReached ()       const; 

    void continuingOnAFailure()
    {
      hasContinuedAfterNlpFailure_ = true;
    }

    bool hasContinuedOnAFailure()
    {
      return hasContinuedAfterNlpFailure_;
    }

    void ignoreFailures()
    {
      pretendFailIsInfeasible_ = 2;
    }

    void forceInfeasible()
    {
      problem_->set_obj_value(1e200);
    }

    void forceBranchable()
    {
      problem_->set_obj_value(-1e200);
      problem_->force_fractionnal_sol();
    }


    //---------------------------------------------------------------------------

    
    
    // Set an integer parameter
    bool setIntParam(OsiIntParam key, int value);
    // Set an double parameter
    bool setDblParam(OsiDblParam key, double value);
    // Set a string parameter
    bool setStrParam(OsiStrParam key, const std::string & value);
    // Get an integer parameter
    bool getIntParam(OsiIntParam key, int& value) const;
    // Get an double parameter
    bool getDblParam(OsiDblParam key, double& value) const;
    // Get a string parameter
    bool getStrParam(OsiStrParam key, std::string& value) const;

    // Get the push values for starting point
    inline double getPushFact() const
    {
      return pushValue_;
    }



    //---------------------------------------------------------------------------

    //        These methods call the solver's query routines to return
    //        information about the problem referred to by the current object.
    //        Querying a problem that has no data associated with it result in
    //        zeros for the number of rows and columns, and NULL pointers from
    //        the methods that return vectors.
    
    //        Const pointers returned from any data-query method are valid as
    //        long as the data is unchanged and the solver is not called.
    

    virtual int getNumCols() const;

    virtual int getNumRows() const;

    const OsiSolverInterface::OsiNameVec& getVarNames() ;
    virtual const double * getColLower() const;

    virtual const double * getColUpper() const;

    //  <ul>
    //  <li>'L': <= constraint
    //  <li>'E': =  constraint
    //  <li>'G': >= constraint
    //  <li>'R': ranged constraint
    //  <li>'N': free constraint
    //  </ul>
    
    virtual const char * getRowSense() const;

    //  <ul>
    //  <li> if rowsense()[i] == 'L' then rhs()[i] == rowupper()[i]
    //  <li> if rowsense()[i] == 'G' then rhs()[i] == rowlower()[i]
    //  <li> if rowsense()[i] == 'R' then rhs()[i] == rowupper()[i]
    //  <li> if rowsense()[i] == 'N' then rhs()[i] == 0.0
    //  </ul>
    
    virtual const double * getRightHandSide() const;

    //          <ul>
    //  <li> if rowsense()[i] == 'R' then
    //  rowrange()[i] == rowupper()[i] - rowlower()[i]
    //  <li> if rowsense()[i] != 'R' then
    //  rowrange()[i] is 0.0
    //  </ul>
    
    virtual const double * getRowRange() const;

    virtual const double * getRowLower() const;

    virtual const double * getRowUpper() const;

    virtual double getObjSense() const
    {
      return 1;
    }

    virtual bool isContinuous(int colNumber) const;

    virtual bool isBinary(int columnNumber) const;

    virtual bool isInteger (int columnNumber) const;

    virtual bool isIntegerNonBinary(int columnNumber) const;

    virtual bool isFreeBinary(int columnNumber) const;

    virtual double getInfinity() const;

    const int * getPriorities() const
    {
      const TMINLP::BranchingInfo * branch = tminlp_->branchingInfo();
      if(branch)
        return branch->priorities;
      else return NULL;
    }

    const int * getBranchingDirections() const
    {
      const TMINLP::BranchingInfo * branch = tminlp_->branchingInfo();
      if(branch)
        return branch->branchingDirections;
      else return NULL;
    }

    const double * getUpPsCosts() const
    {
      const TMINLP::BranchingInfo * branch = tminlp_->branchingInfo();
      if(branch)
        return branch->upPsCosts;
      else return NULL;
    }

    const double * getDownPsCosts() const
    {
      const TMINLP::BranchingInfo * branch = tminlp_->branchingInfo();
      if(branch)
        return branch->downPsCosts;
      else return NULL;
    }




    virtual const double * getColSolution() const;

    virtual const double * getRowPrice() const;

    virtual const double * getReducedCost() const;

    virtual const double * getRowActivity() const;


        
    virtual int getIterationCount () const;

    int nCallOptimizeTNLP()
    {
      return nCallOptimizeTNLP_;
    }

    double totalNlpSolveTime()
    {
      return totalNlpSolveTime_;
    }

    int totalIterations()
    {
      return totalIterations_;
    }



    //-------------------------------------------------------------------------
     

    virtual void setColLower( int elementIndex, double elementValue );

    virtual void setColUpper( int elementIndex, double elementValue );

    
    virtual void setColLower(const double * array);

    
    virtual void setColUpper(const double * array);


    virtual void setRowLower( int elementIndex, double elementValue );

    virtual void setRowUpper( int elementIndex, double elementValue );

    virtual void setRowType(int index, char sense, double rightHandSide,
                            double range);


    virtual void setObjSense(double s);

    
    virtual void setColSolution(const double *colsol);

    
    virtual void setRowPrice(const double * rowprice);



    //---------------------------------------------------------------------------



    
    virtual CoinWarmStart *getEmptyWarmStart () const;

    virtual CoinWarmStart* getWarmStart() const;

    virtual bool setWarmStart(const CoinWarmStart* warmstart);

    void setExposeWarmStart(bool value) {
      exposeWarmStart_ = value;
    }

    bool getExposeWarmStart() {
      return exposeWarmStart_;
    }

    void randomStartingPoint();

    //Returns true if a basis is available
    virtual bool basisIsAvailable() const
    {
      // Throw an exception
      throw SimpleError("Needs coding for this interface", "basisIsAvailable");
    }



    //-------------------------------------------------------------------------

    virtual void setContinuous(int index);
    virtual void setInteger(int index);

    //Set numIterationSuspect_
    void setNumIterationSuspect(int value)
    {
      numIterationSuspect_ = value;
    }



     
    virtual int getNumElements() const
    {
      return -1;
    }


     
    virtual const double * getObjCoefficients() const;

     
    virtual const CoinPackedMatrix * getMatrixByRow() const
    {
      return NULL;
    }


     
    virtual const CoinPackedMatrix * getMatrixByCol() const
    {
      return NULL;
    }

     
    virtual void setObjCoeff( int elementIndex, double elementValue )
    {
      throw SimpleError("CouenneMINLPInterface does not implement this function.",
                        "setObjCoeff");
    }

     
    virtual void addCol(const CoinPackedVectorBase& vec,
                        const double collb, const double colub,
                        const double obj)
    {
      throw SimpleError("CouenneMINLPInterface does not implement this function.",
                        "addCol");
    }

     
    virtual void deleteCols(const int num, const int * colIndices)
    {
      throw SimpleError("CouenneMINLPInterface does not implement this function.",
                        "deleteCols");
    }

     
    virtual void addRow(const CoinPackedVectorBase& vec,
                        const double rowlb, const double rowub)
    {
      throw SimpleError("CouenneMINLPInterface does not implement this function.",
                        "addRow");
    }

     
    virtual void addRow(const CoinPackedVectorBase& vec,
                        const char rowsen, const double rowrhs,
                        const double rowrng)
    {
      throw SimpleError("CouenneMINLPInterface model does not implement this function.",
                        "addRow");
    }
     
    virtual void deleteRows(const int num, const int * rowIndices)
    {
      if(num)
        freeCachedRowRim();
      problem_->removeCuts(num, rowIndices);
    }


     
    virtual void loadProblem(const CoinPackedMatrix& matrix,
                             const double* collb, const double* colub,
                             const double* obj,
                             const double* rowlb, const double* rowub)
    {
      throw SimpleError("CouenneMINLPInterface does not implement this function.",
                        "loadProblem");
    }


     
    virtual void assignProblem(CoinPackedMatrix*& matrix,
                               double*& collb, double*& colub, double*& obj,
                               double*& rowlb, double*& rowub)
    {
      throw SimpleError("CouenneMINLPInterface does not implement this function.",
                        "assignProblem");
    }

     
    virtual void loadProblem(const CoinPackedMatrix& matrix,
                             const double* collb, const double* colub,
                             const double* obj,
                             const char* rowsen, const double* rowrhs,
                             const double* rowrng)
    {
      throw SimpleError("CouenneMINLPInterface does not implement this function.",
                        "loadProblem");
    }

     
    virtual void assignProblem(CoinPackedMatrix*& matrix,
                               double*& collb, double*& colub, double*& obj,
                               char*& rowsen, double*& rowrhs,
                               double*& rowrng)
    {
      throw SimpleError("CouenneMINLPInterface does not implement this function.",
                        "assignProblem");
    }


     
    virtual void loadProblem(const int numcols, const int numrows,
                             const int* start, const int* index,
                             const double* value,
                             const double* collb, const double* colub,
                             const double* obj,
                             const double* rowlb, const double* rowub)
    {
      throw SimpleError("CouenneMINLPInterface does not implement this function.",
                        "loadProblem");
    }

     
    virtual void loadProblem(const int numcols, const int numrows,
                             const int* start, const int* index,
                             const double* value,
                             const double* collb, const double* colub,
                             const double* obj,
                             const char* rowsen, const double* rowrhs,
                             const double* rowrng)
    {
      throw SimpleError("CouenneMINLPInterface model does not implement this function.",
                        "loadProblem");
    }

     
    virtual int readMps(const char *filename,
                        const char *extension = "mps")
    {
      throw SimpleError("CouenneMINLPInterface does not implement this function.",
                        "readMps");
    }


     
    virtual void writeMps(const char *filename,
                          const char *extension = "mps",
                          double objSense=0.0) const
    {
      throw SimpleError("CouenneMINLPInterface does not implement this function.",
                        "writeMps");
    }

    virtual std::vector<double*> getDualRays(int maxNumRays) const
    {
      throw SimpleError("CouenneMINLPInterface does not implement this function.",
                        "getDualRays");
    }

    virtual std::vector<double*> getPrimalRays(int maxNumRays) const
    {
      throw SimpleError("CouenneMINLPInterface does not implement this function.",
                        "getPrimalRays");
    }



  
    //---------------------------------------------------------------------------



     
    void turnOffSolverOutput(){
      app_->turnOffOutput();}
    void turnOnSolverOutput(){
      app_->turnOnOutput();}


    virtual double getObjValue() const;


    const TMINLP2TNLP * problem() const
    {
      return GetRawPtr(problem_);
    }

    TMINLP2TNLP * problem()
    {
      return GetRawPtr(problem_);
    }

    const TMINLP * model() const
    {
      return GetRawPtr(tminlp_);
    }
  
    Bonmin::TMINLP * model()
    {
      return GetRawPtr(tminlp_);
    }
  
    const Bonmin::TNLPSolver * solver() const
    {
      return GetRawPtr(app_);
    } 
 
    TNLPSolver * solver()
    {
      return GetRawPtr(app_);
    } 


     
    virtual void extractLinearRelaxation(OsiSolverInterface &si, const double *x, 
                                         bool getObj = 1);

     
    virtual void extractLinearRelaxation(OsiSolverInterface &si, bool getObj = 1,
                                         bool solveNlp = 1){
      if(solveNlp)
        initialSolve();
      extractLinearRelaxation(si, getColSolution(), getObj); 
      if(solveNlp){
        app_->enableWarmStart();
        setColSolution(problem()->x_sol());
        setRowPrice(problem()->duals_sol());
      }
    }

    void getOuterApproximation(OsiCuts &cs, bool getObj, const double * x2, bool global)
    {
      getOuterApproximation(cs, getColSolution(), getObj, x2, global);
    }

    void getOuterApproximation(OsiCuts &cs, const double * x, bool getObj, const double * x2, bool global){
      getOuterApproximation(cs, x, getObj, x2, 0., global);}

    virtual void getOuterApproximation(OsiCuts &cs, const double * x, bool getObj, const double * x2,
                                       double theta, bool global);

    virtual void getConstraintOuterApproximation(OsiCuts & cs, int constraintNumber,
                                                 const double * x, 
                                                 const double * x2, bool global);

    void getConstraintOuterApproximation(OsiCuts & cs, int constraintNumber,
                                         const double * x2, bool global){
      getConstraintOuterApproximation(cs, constraintNumber, getColSolution(),x2,global);
    }

    void getBendersCut(OsiCuts &cs, const double * x, const double *lambda, bool getObj = 1);

    double getFeasibilityOuterApproximation(int n, const double * x_bar,const int *ind, OsiCuts &cs, bool addOnlyViolated, bool global);

     
    double solveFeasibilityProblem(int n, const double * x_bar, const int* ind, double a, double s, int L);

     
    double solveFeasibilityProblem(int n, const double * x_bar, const int* ind, int L, double cutoff);

    void switchToFeasibilityProblem(int n, const double * x_bar, const int* ind, double a, double s, int L);

    void switchToFeasibilityProblem(int n, const double * x_bar, const int* ind,
                                    double rhs_local_branching_constraint);

    void switchToOriginalProblem();


    enum OaMessagesTypes {
      CUT_NOT_VIOLATED_ENOUGH = 0, 
      VIOLATED_OA_CUT_GENERATED,   
      OA_CUT_GENERATED,            
      OA_MESSAGES_DUMMY_END        
    };
    
    class OaMessages :public CoinMessages{
    public:
      OaMessages();
    };

    class OaMessageHandler : public CoinMessageHandler{
    public:
      OaMessageHandler():CoinMessageHandler(){
      }
      OaMessageHandler(FILE * fp):CoinMessageHandler(fp){
      }
      virtual ~OaMessageHandler(){
      }
      OaMessageHandler(const OaMessageHandler &other):
        CoinMessageHandler(other){}
      OaMessageHandler(const CoinMessageHandler &other):
        CoinMessageHandler(other){}
      OaMessageHandler & operator=(const OaMessageHandler &rhs){
        CoinMessageHandler::operator=(rhs);
        return *this;}
      virtual CoinMessageHandler* clone() const{
        return new OaMessageHandler(*this);}
      void print(OsiRowCut &row);
    };

    void setOaMessageHandler(const CoinMessageHandler &handler){
      delete oaHandler_;
      oaHandler_ = new OaMessageHandler(handler);
    }

    //-----------------------------------------------------------------------
     
    virtual ApplyCutsReturnCode applyCuts(const OsiCuts & cs,
                                          double effectivenessLb = 0.0){
      freeCachedRowRim();
      problem_->addCuts(cs);
      ApplyCutsReturnCode rc;
      return rc;}

    virtual void applyRowCuts(int numberCuts, const OsiRowCut * cuts);


    virtual void applyRowCuts(int numberCuts, const OsiRowCut ** cuts)
    {
      if(numberCuts)
        freeCachedRowRim();
      problem_->addCuts(numberCuts, cuts);
    }

        obj the objective value of x.
    double getConstraintsViolation(const double * x, double & obj);

        value where obj is the estimated objective value of x.
    double getNonLinearitiesViolation(const double *x, const double obj);

    //---------------------------------------------------------------------------

    void extractInterfaceParams();


    virtual void setAppDefaultOptions(Ipopt::SmartPtr<Ipopt::OptionsList> Options);

    static void registerOptions (Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions);
  
    Ipopt::SmartPtr<Bonmin::RegisteredOptions> regOptions(){
      if(IsValid(app_))
        return app_->roptions();
      else
        return NULL;
    }


    void SetStrongBrachingSolver(Ipopt::SmartPtr<StrongBranchingSolver> strong_branching_solver);
    virtual void markHotStart();
    virtual void solveFromHotStart();
    virtual void unmarkHotStart();

  protected:
  

    enum RandomGenerationType{
      uniform =0, perturb=1, perturb_suffix=2};
    int initializeJacobianArrays();



    void solveAndCheckErrors(bool doResolve, bool throwOnFailure,
                             const char * whereFrom);


     
    virtual void applyRowCut( const OsiRowCut & rc )
    {
      const OsiRowCut * cut = &rc;
      problem_->addCuts(1, &cut);
    }
     
    virtual void applyColCut( const OsiColCut & cc )
    {
      throw SimpleError("Ipopt model does not implement this function.",
                        "applyColCut");
    }

    //  /// Read the name of the variables in an ampl .col file. 
    //  void readVarNames() const;



    Ipopt::SmartPtr<TMINLP> tminlp_;
    Ipopt::SmartPtr<TMINLP2TNLP> problem_;
    Ipopt::SmartPtr<Ipopt::TNLP> problem_to_optimize_;
    bool feasibility_mode_;
    Ipopt::SmartPtr<TNLPSolver> app_;

    std::list<Ipopt::SmartPtr<TNLPSolver> > debug_apps_;
    bool testOthers_;

    CoinWarmStart* warmstart_;


    void freeCachedColRim();
    void freeCachedRowRim();
    void freeCachedData();
    void extractSenseRhsAndRange() const;
    mutable char    *rowsense_;

    mutable double  *rhs_;

    mutable double  *rowrange_;
    mutable double  *reducedCosts_;
    double OsiDualObjectiveLimit_;
    mutable bool hasVarNamesFile_;
    int nCallOptimizeTNLP_;
    double totalNlpSolveTime_;
    int totalIterations_;
    double maxRandomRadius_;
    int randomGenerationType_;
    double max_perturbation_;
    double pushValue_;
    int numRetryInitial_;
    int numRetryResolve_;
    int numRetryInfeasibles_;
    int numRetryUnsolved_;
    Messages messages_;
    int pretendFailIsInfeasible_;
    bool hasContinuedAfterNlpFailure_;
    int numIterationSuspect_ ;
    bool hasBeenOptimized_;
    mutable double * obj_;
    static bool hasPrintedOptions;

    Ipopt::SmartPtr<TNLP2FPNLP> feasibilityProblem_;



    int * jRow_;
    int * jCol_;
    double * jValues_;
    int nnz_jac;

    Ipopt::TNLP::LinearityType * constTypes_;
     
    int nNonLinear_;
    double tiny_;
    double veryTiny_;
    double infty_;
    TNLPSolver::ReturnStatus optimizationStatus_;
    bool exposeWarmStart_;
    bool firstSolve_;
    SmartPtr<CutStrengthener> cutStrengthener_;


    OaMessages oaMessages_;
    OaMessageHandler * oaHandler_;
  protected:
    void createApplication(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions,
                           Ipopt::SmartPtr<Ipopt::OptionsList> options,
                           Ipopt::SmartPtr<Ipopt::Journalist> journalist);
    CouenneMINLPInterface(Ipopt::SmartPtr<TNLPSolver> app);

    bool internal_setWarmStart(const CoinWarmStart* ws);

    CoinWarmStart* internal_getWarmStart() const; 
  private:
    SmartPtr<StrongBranchingSolver> strong_branching_solver_;
    TNLPSolver::ReturnStatus optimizationStatusBeforeHotStart_;
    static const char * OPT_SYMB;
    static const char * FAILED_SYMB;
    static const char * INFEAS_SYMB;
    static const char * UNBOUND_SYMB;
    const char * statusAsString(TNLPSolver::ReturnStatus r){
      if(r == TNLPSolver::solvedOptimal || r == TNLPSolver::solvedOptimalTol){
        return OPT_SYMB;} 
      else if(r == TNLPSolver::provenInfeasible){
        return INFEAS_SYMB;}
      else if(r == TNLPSolver::unbounded){
        return UNBOUND_SYMB;}
      else return FAILED_SYMB;
    }
    const char * statusAsString(){
      return statusAsString(optimizationStatus_);}
#endif
  };
}

#endif