BonOsiTMINLPInterface.hpp

Go to the documentation of this file.

// (C) Copyright International Business Machines Corporation, Carnegie Mellon University 2004, 2007
// All Rights Reserved.
// This code is published under the Common Public License.
//
// Authors :
// Pierre Bonami, Carnegie Mellon University,
// Carl D. Laird, Carnegie Mellon University,
// Andreas Waechter, International Business Machines Corporation
//
// Date : 12/01/2004


#ifndef OsiTMINLPInterface_H
#define OsiTMINLPInterface_H

#define INT_BIAS 0e-8

#include <string>
#include <iostream>

#include "OsiSolverInterface.hpp"
#include "CoinWarmStartBasis.hpp"

#include "BonCutStrengthener.hpp"
//#include "BonRegisteredOptions.hpp"

namespace Bonmin {
  class TMINLP;
  class TMINLP2TNLP;
  class TMINLP2OsiLP;
  class TNLP2FPNLP;
  class TNLPSolver;
  class RegisteredOptions;
  class StrongBranchingSolver;

  enum Solver{
    EIpopt=0 ,
    EFilterSQP ,
    EAll
  };
class OsiTMINLPInterface : public OsiSolverInterface
{
  friend class BonminParam;

public:

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

class SimpleError : public CoinError
  {
  private:
    SimpleError();

  public:
    SimpleError(std::string message,
        std::string methodName,
        std::string f = std::string(),
        int l = -1)
        :
        CoinError(message,methodName,std::string("OsiTMINLPInterface"), 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);
  }
  //#############################################################################

  enum WarmStartModes{
   None,
   FakeBasis,
   Optimum,
   InteriorPoint};

  enum MessagesTypes{
    SOLUTION_FOUND,
    INFEASIBLE_SOLUTION_FOUND,
    UNSOLVED_PROBLEM_FOUND,
    WARNING_RESOLVING ,
    WARN_SUCCESS_WS,
    WARN_SUCCESS_RANDOM,
    WARN_CONTINUING_ON_FAILURE,
    SUSPECT_PROBLEM,
    SUSPECT_PROBLEM2,
    IPOPT_SUMMARY ,
    BETTER_SOL ,
    LOG_HEAD,
    LOG_FIRST_LINE,
    LOG_LINE,
    ALTERNATE_OBJECTIVE,
    WARN_RESOLVE_BEFORE_INITIAL_SOLVE ,
    ERROR_NO_TNLPSOLVER ,
    WARNING_NON_CONVEX_OA ,
    SOLVER_DISAGREE_STATUS ,
    SOLVER_DISAGREE_VALUE ,
    OSITMINLPINTERFACE_DUMMY_END
  };

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


class Messages : public CoinMessages
  {
  public:
    Messages();
  };


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



  OsiTMINLPInterface();

  void initialize(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions,
                  Ipopt::SmartPtr<Ipopt::OptionsList> options,
                  Ipopt::SmartPtr<Ipopt::Journalist> journalist,
                  const std::string & prefix,
                  Ipopt::SmartPtr<TMINLP> tminlp);

  void initialize(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions,
                  Ipopt::SmartPtr<Ipopt::OptionsList> options,
                  Ipopt::SmartPtr<Ipopt::Journalist> journalist,
                  Ipopt::SmartPtr<TMINLP> tminlp){
     initialize(roptions, options, journalist, "bonmin.", tminlp);
  }

  void setModel(Ipopt::SmartPtr<TMINLP> tminlp);
  void setSolver(Ipopt::SmartPtr<TNLPSolver> app);
  void use(Ipopt::SmartPtr<TMINLP2TNLP> tminlp2tnlp);
  OsiTMINLPInterface (const OsiTMINLPInterface &);

  OsiSolverInterface * clone(bool copyData = true) const;

  OsiTMINLPInterface & operator=(const OsiTMINLPInterface& rhs);

  virtual ~OsiTMINLPInterface ();


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

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

  const char * prefix() const{
  if(!IsValid(app_)) {
    messageHandler()->message(ERROR_NO_TNLPSOLVER, messages_)<<CoinMessageEol;
    return NULL;
  }
  else
    return app_->prefix();
  }
  //---------------------------------------------------------------------------

  virtual void initialSolve();

  virtual void initialSolve(const char * whereFrom);

  virtual void resolve();

  virtual void resolve(const char * whereFrom);

  virtual void resolveForCost(int numretry, bool keepWs);

  virtual void resolveForRobustness(int numretry);

  virtual void branchAndBound()
  {
    throw SimpleError("Function not implemented for OsiTMINLPInterface","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;
  }


  //Added by Claudia
  
  double getNewCutoffDecr()
  {
    return newCutoffDecr;
  }

  void setNewCutoffDecr(double d)
  {
    newCutoffDecr = d;
  }


  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_;
  }



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

  virtual int getNumCols() const;

  virtual int getNumRows() const;

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

  virtual const double * getColUpper() const;

  virtual const char * getRowSense() const;

  virtual const double * getRightHandSide() const;

  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 setWarmStartMode(int mode) {
    warmStartMode_ = (WarmStartModes) mode;
  }
  WarmStartModes getWarmStartMode() {
    return warmStartMode_;
  }

  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("OsiTMINLPInterface does not implement this function.",
        "setObjCoeff");
  }

  virtual void addCol(const CoinPackedVectorBase& vec,
      const double collb, const double colub,
      const double obj)
  {
    throw SimpleError("OsiTMINLPInterface does not implement this function.",
        "addCol");
  }
  virtual void deleteCols(const int num, const int * colIndices)
  {
    throw SimpleError("OsiTMINLPInterface does not implement this function.",
        "deleteCols");
  }

  virtual void addRow(const CoinPackedVectorBase& vec,
      const double rowlb, const double rowub)
  {
    throw SimpleError("OsiTMINLPInterface does not implement this function.",
        "addRow");
  }
  virtual void addRow(const CoinPackedVectorBase& vec,
      const char rowsen, const double rowrhs,
      const double rowrng)
  {
    throw SimpleError("OsiTMINLPInterface 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("OsiTMINLPInterface does not implement this function.",
        "loadProblem");
  }


  virtual void assignProblem(CoinPackedMatrix*& matrix,
      double*& collb, double*& colub, double*& obj,
      double*& rowlb, double*& rowub)
  {
    throw SimpleError("OsiTMINLPInterface 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("OsiTMINLPInterface 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("OsiTMINLPInterface 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("OsiTMINLPInterface 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("OsiTMINLPInterface model does not implement this function.",
        "loadProblem");
  }

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


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

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

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



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



  void setSolverOutputToDefault(){
  app_->setOutputToDefault();}
  void forceSolverOutput(int log_level){
  app_->forceSolverOutput(log_level);}


  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_);
  } 
 
  const std::list<Ipopt::SmartPtr<TNLPSolver> >& debug_apps() const{
    return debug_apps_;
  }

  TNLPSolver * solver()
  {
    return GetRawPtr(app_);
  } 
  virtual void extractLinearRelaxation(OsiSolverInterface &si, const double *x, 
                                       bool getObj = 1);

  virtual void addObjectiveFunction(OsiSolverInterface &si, const double * x);
#if 1

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

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

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

  virtual void getOuterApproximation(OsiCuts &cs, const double * x, int 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, bool global);

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

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

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

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

  void switchToOriginalProblem();
  
  void round_and_check(double tolerance,
                       OsiObject ** objects = 0, int nObjects = -1){
    if(!problem_->check_solution(objects, nObjects)){
      optimizationStatus_ = TNLPSolver::provenInfeasible;
    }
  }

  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);
  }

 double getConstraintsViolation(const double * x, double & obj);

  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();

  void get_tolerances(double &tiny, double&very_tiny, double &rhsRelax, double &infty){
    tiny = tiny_;
    very_tiny = veryTiny_;
    rhsRelax = rhsRelax_;
    infty = infty_;
  }

  void set_linearizer(Ipopt::SmartPtr<TMINLP2OsiLP> linearizer);

  Ipopt::SmartPtr<TMINLP2OsiLP> linearizer();
protected:
  

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


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



  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_;
  double infeasibility_epsilon_;


  //Added by Claudia
  int dynamicCutOff_;
  double coeff_var_threshold_;
  double first_perc_for_cutoff_decr_;
  double second_perc_for_cutoff_decr_;
 

  Messages messages_;
  int pretendFailIsInfeasible_;

  mutable int pretendSucceededNext_;

  bool hasContinuedAfterNlpFailure_;
  int numIterationSuspect_ ;
  bool hasBeenOptimized_;
  mutable double * obj_;
  static bool hasPrintedOptions;

  Ipopt::SmartPtr<TNLP2FPNLP> feasibilityProblem_;

  Ipopt::SmartPtr<TMINLP2OsiLP> linearizer_;

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

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

  OaMessages oaMessages_;
  OaMessageHandler * oaHandler_;

  double newCutoffDecr;
protected:
  void createApplication(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions,
                         Ipopt::SmartPtr<Ipopt::OptionsList> options,
                         Ipopt::SmartPtr<Ipopt::Journalist> journalist,
                         const std::string & prefix);
  OsiTMINLPInterface(Ipopt::SmartPtr<TNLPSolver> app);

  bool internal_setWarmStart(const CoinWarmStart* ws);

  CoinWarmStart* internal_getWarmStart() const; 

  CoinWarmStart* build_fake_basis() const; 
private:

  Ipopt::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 * TIME_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 if(r == TNLPSolver::timeLimit){
      return TIME_SYMB;}
    else return FAILED_SYMB;
  }
  const char * statusAsString(){
    return statusAsString(optimizationStatus_);}
};
}
#endif