Structure updated and intqpipopt files added

1 files changed, 1342 insertions, 0 deletions

diff --git a/newstructure/thirdparty/linux/include/coin/BonOsiTMINLPInterface.hpp b/newstructure/thirdparty/linux/include/coin/BonOsiTMINLPInterface.hpp
new file mode 100644
index 0000000..3d95545
--- /dev/null
+++ b/newstructure/thirdparty/linux/include/coin/BonOsiTMINLPInterface.hpp
@@ -0,0 +1,1342 @@
+// (C) Copyright International Business Machines Corporation, Carnegie Mellon University 2004, 2007
+// All Rights Reserved.
+// This code is published under the Eclipse 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;
+
+  /** Solvers for solving nonlinear programs.*/
+  enum Solver{
+    EIpopt=0 /** <a href="http://projects.coin-or.org/Ipopt"> Ipopt </a> interior point algorithm.*/,
+    EFilterSQP /** <a href="http://www-unix.mcs.anl.gov/~leyffer/solvers.html"> filterSQP </a> Sequential Quadratic Programming algorithm.*/,
+    EAll/** Use all solvers.*/
+  };
+/**
+   This is class provides an Osi interface for a Mixed Integer Linear Program
+   expressed as a TMINLP
+   (so that we can use it for example as the continuous solver in Cbc).
+*/
+
+class OsiTMINLPInterface : public OsiSolverInterface
+{
+  friend class BonminParam;
+
+public:
+
+  //#############################################################################
+
+  /**Error class to throw exceptions from OsiTMINLPInterface.
+   * Inherited from CoinError, we just want to have a different class to be able to catch
+   * errors thrown by OsiTMINLPInterface.
+  */
+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("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};
+
+  /** Type of the messages specifically written by OsiTMINLPInterface.*/
+  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 written by an OsiTMINLPInterface. */
+class Messages : public CoinMessages
+  {
+  public:
+    /// Constructor
+    Messages();
+  };
+
+
+  //#############################################################################
+
+
+  /**@name Constructors and destructors */
+  //@{
+  /// Default Constructor
+  OsiTMINLPInterface();
+
+  /** Facilitator to initialize interface. */
+  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);
+
+  /** Facilitator to initialize interface. */
+  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);
+  }
+
+  /** Set the model to be solved by interface.*/
+  void setModel(Ipopt::SmartPtr<TMINLP> tminlp);
+  /** Set the solver to be used by interface.*/
+  void setSolver(Ipopt::SmartPtr<TNLPSolver> app);
+  /** Sets the TMINLP2TNLP to be used by the interface.*/
+  void use(Ipopt::SmartPtr<TMINLP2TNLP> tminlp2tnlp);
+  /** Copy constructor
+  */
+  OsiTMINLPInterface (const OsiTMINLPInterface &);
+
+  /** Virtual copy constructor */
+  OsiSolverInterface * clone(bool copyData = true) const;
+
+  /// Assignment operator
+  OsiTMINLPInterface & operator=(const OsiTMINLPInterface& rhs);
+
+  /// Destructor
+  virtual ~OsiTMINLPInterface ();
+
+
+  /// Read parameter file
+  void readOptionFile(const std::string & fileName);
+
+  /// Retrieve OsiTMINLPApplication option list
+  const Ipopt::SmartPtr<Ipopt::OptionsList> options() const;
+  /// Retrieve OsiTMINLPApplication option list
+  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();
+  }
+  //@}
+  //---------------------------------------------------------------------------
+  /**@name Solve methods */
+  //@{
+  /// Solve initial continuous relaxation
+  virtual void initialSolve();
+
+  /// Solve initial continuous relaxation (precising from where)
+  virtual void initialSolve(const char * whereFrom);
+
+  /** Resolve the continuous relaxation after problem modification.
+      initialSolve may or may not have been called before this is called. In
+      any case, this must solve the problem, and speed the process up if it
+      can reuse any remnants of data that might exist from a previous solve.
+   */
+  virtual void resolve();
+
+  /** Resolve the continuous relaxation after problem modification.
+      initialSolve may or may not have been called before this is called. In
+      any case, this must solve the problem, and speed the process up if it
+      can reuse any remnants of data that might exist from a previous solve.
+   */
+  virtual void resolve(const char * whereFrom);
+
+  /** Resolve the problem with different random starting points to try to find
+      a better solution (only makes sense for a non-convex problem.*/
+  virtual void resolveForCost(int numretry, bool keepWs);
+
+  /** Method to be called when a problem has failed to be solved. Will try
+      to resolve it with different settings.
+  */
+  virtual void resolveForRobustness(int numretry);
+
+  /// Nescessary for compatibility with OsiSolverInterface but does nothing.
+  virtual void branchAndBound()
+  {
+    throw SimpleError("Function not implemented for OsiTMINLPInterface","branchAndBound()");
+  }
+  //@}
+
+
+
+  //---------------------------------------------------------------------------
+  ///@name Methods returning info on how the solution process terminated
+  //@{
+  /// Are there a numerical difficulties?
+  virtual bool isAbandoned() const;
+  /// Is optimality proven?
+  virtual bool isProvenOptimal() const;
+  /// Is primal infeasiblity proven?
+  virtual bool isProvenPrimalInfeasible() const;
+  /// Is dual infeasiblity proven?
+  virtual bool isProvenDualInfeasible() const;
+  /// Is the given primal objective limit reached?
+  virtual bool isPrimalObjectiveLimitReached() const;
+  /// Is the given dual objective limit reached?
+  virtual bool isDualObjectiveLimitReached() const;
+  /// Iteration limit reached?
+  virtual bool isIterationLimitReached() const;
+
+  ///Warn solver that branch-and-bound is continuing after a failure
+  void continuingOnAFailure()
+  {
+    hasContinuedAfterNlpFailure_ = true;
+  }
+
+
+  //Added by Claudia
+  
+  double getNewCutoffDecr()
+  {
+    return newCutoffDecr;
+  }
+
+  void setNewCutoffDecr(double d)
+  {
+    newCutoffDecr = d;
+  }
+
+
+  /// Did we continue on a failure
+  bool hasContinuedOnAFailure()
+  {
+    return hasContinuedAfterNlpFailure_;
+  }
+  /// tell to ignore the failures (don't throw, don't fathom, don't report)
+  void ignoreFailures()
+  {
+    pretendFailIsInfeasible_ = 2;
+  }
+  /// Force current solution to be infeasible
+  void forceInfeasible()
+  {
+    problem_->set_obj_value(1e200);
+  }
+  /// Force current solution to be branched on (make it fractionnal with small objective)
+  void forceBranchable()
+  {
+    problem_->set_obj_value(-1e200);
+    problem_->force_fractionnal_sol();
+  }
+  //@}
+
+
+  //---------------------------------------------------------------------------
+  /**@name Parameter set/get methods
+
+     The set methods return true if the parameter was set to the given value,
+     false otherwise. There can be various reasons for failure: the given
+     parameter is not applicable for the solver (e.g., refactorization
+     frequency for the clp algorithm), the parameter is not yet implemented
+     for the solver or simply the value of the parameter is out of the range
+     the solver accepts. If a parameter setting call returns false check the
+     details of your solver.
+
+     The get methods return true if the given parameter is applicable for the
+     solver and is implemented. In this case the value of the parameter is
+     returned in the second argument. Otherwise they return false.
+  */
+  //@{
+  // 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_;
+  }
+
+  //@}
+
+
+  //---------------------------------------------------------------------------
+  /**@name Problem information methods
+
+     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.
+  */
+  //@{
+  /// Get number of columns
+  virtual int getNumCols() const;
+
+  /// Get number of rows
+  virtual int getNumRows() const;
+
+  ///get name of variables
+  const OsiSolverInterface::OsiNameVec& getVarNames() ;
+  /// Get pointer to array[getNumCols()] of column lower bounds
+  virtual const double * getColLower() const;
+
+  /// Get pointer to array[getNumCols()] of column upper bounds
+  virtual const double * getColUpper() const;
+
+  /** Get pointer to array[getNumRows()] of row constraint senses.
+      <ul>
+      <li>'L': <= constraint
+      <li>'E': =  constraint
+      <li>'G': >= constraint
+      <li>'R': ranged constraint
+      <li>'N': free constraint
+      </ul>
+  */
+  virtual const char * getRowSense() const;
+
+  /** Get pointer to array[getNumRows()] of rows right-hand sides
+      <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;
+
+  /** Get pointer to array[getNumRows()] of row ranges.
+      <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;
+
+  /// Get pointer to array[getNumRows()] of row lower bounds
+  virtual const double * getRowLower() const;
+
+  /// Get pointer to array[getNumRows()] of row upper bounds
+  virtual const double * getRowUpper() const;
+
+  /** Get objective function sense (1 for min (default), -1 for max)
+   * Always minimizes */
+  virtual double getObjSense() const
+  {
+    return 1;
+  }
+
+  /// Return true if column is continuous
+  virtual bool isContinuous(int colNumber) const;
+
+  /// Return true if column is binary
+  virtual bool isBinary(int columnNumber) const;
+
+  /** Return true if column is integer.
+      Note: This function returns true if the the column
+      is binary or a general integer.
+  */
+  virtual bool isInteger(int columnNumber) const;
+
+  /// Return true if column is general integer
+  virtual bool isIntegerNonBinary(int columnNumber) const;
+
+  /// Return true if column is binary and not fixed at either bound
+  virtual bool isFreeBinary(int columnNumber) const;
+
+  /// Get solver's value for infinity
+  virtual double getInfinity() const;
+
+  ///Get priorities on integer variables.
+  const int * getPriorities() const
+  {
+    const TMINLP::BranchingInfo * branch = tminlp_->branchingInfo();
+    if(branch)
+      return branch->priorities;
+    else return NULL;
+  }
+  ///get prefered branching directions
+  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;
+  }
+
+
+  //@}
+
+  /**@name Methods related to querying the solution */
+  //@{
+  /// Get pointer to array[getNumCols()] of primal solution vector
+  virtual const double * getColSolution() const;
+
+  /// Get pointer to array[getNumRows()] of dual prices
+  virtual const double * getRowPrice() const;
+
+  /// Get a pointer to array[getNumCols()] of reduced costs
+  virtual const double * getReducedCost() const;
+
+  /** Get pointer to array[getNumRows()] of row activity levels (constraint
+      matrix times the solution vector */
+  virtual const double * getRowActivity() const;
+
+
+  /** Get how many iterations it took to solve the problem (whatever
+      "iteration" mean to the solver.
+      * \todo Figure out what it could mean for Ipopt.
+      */
+  virtual int getIterationCount() const;
+
+  /** get total number of calls to solve.*/
+  int nCallOptimizeTNLP()
+  {
+    return nCallOptimizeTNLP_;
+  }
+  /** get total time taken to solve NLP's. */
+  double totalNlpSolveTime()
+  {
+    return totalNlpSolveTime_;
+  }
+  /** get total number of iterations */
+  int totalIterations()
+  {
+    return totalIterations_;
+  }
+
+
+  //@}
+  //-------------------------------------------------------------------------
+  /**@name Methods to modify the objective, bounds, and solution
+  */
+  //@{
+
+  /** Set a single column lower bound.
+      Use -getInfinity() for -infinity. */
+  virtual void setColLower( int elementIndex, double elementValue );
+
+  /** Set a single column upper bound.
+      Use getInfinity() for infinity. */
+  virtual void setColUpper( int elementIndex, double elementValue );
+
+  /** Set the lower bounds for all columns
+      array [getNumCols()] is an array of values for the objective.
+  */
+  virtual void setColLower(const double * array);
+
+  /** Set the upper bounds for all columns
+      array [getNumCols()] is an array of values for the objective.
+  */
+  virtual void setColUpper(const double * array);
+
+
+  /** Set a single row lower bound.
+      Use -getInfinity() for -infinity. */
+  virtual void setRowLower( int elementIndex, double elementValue );
+
+  /** Set a single row upper bound.
+      Use getInfinity() for infinity. */
+  virtual void setRowUpper( int elementIndex, double elementValue );
+
+  /** Set the type of a single row */
+  virtual void setRowType(int index, char sense, double rightHandSide,
+      double range);
+
+
+  /** \brief Set the objective function sense (disabled).
+   * (1 for min (default), -1 for max)
+   \todo Make it work.
+   \bug Can not treat maximisation problems. */
+  virtual void setObjSense(double s);
+
+  /** Set the primal solution variable values
+      Set the values for the starting point.
+      \warning getColSolution will never return this vector (unless it is optimal).
+  */
+  virtual void setColSolution(const double *colsol);
+
+  /** Set dual solution variable values.
+      set the values for the starting point.
+      \warning getRowPrice will never return this vector (unless it is optimal).
+  */
+  virtual void setRowPrice(const double * rowprice);
+
+  //@}
+
+
+  //---------------------------------------------------------------------------
+  /**@name WarmStart related methods (those should really do nothing for the moment)*/
+  //@{
+
+  /*! \brief Get an empty warm start object
+
+  This routine returns an empty CoinWarmStartBasis object. Its purpose is
+  to provide a way to give a client a warm start basis object of the
+  appropriate type, which can resized and modified as desired.
+  */
+  virtual CoinWarmStart *getEmptyWarmStart () const;
+
+  /** Get warmstarting information */
+  virtual CoinWarmStart* getWarmStart() const;
+
+  /** Set warmstarting information. Return true/false depending on whether
+      the warmstart information was accepted or not. */
+  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");
+  }
+
+
+  //@}
+
+  //-------------------------------------------------------------------------
+  /**@name Methods to set variable type */
+  //@{
+  /** Set the index-th variable to be a continuous variable */
+  virtual void setContinuous(int index);
+  /** Set the index-th variable to be an integer variable */
+  virtual void setInteger(int index);
+  //@}
+
+  //Set numIterationSuspect_
+  void setNumIterationSuspect(int value)
+  {
+    numIterationSuspect_ = value;
+  }
+
+  /**@name Dummy functions
+   * Functions which have to be implemented in an OsiSolverInterface,
+   * but which do not do anything (but throwing exceptions) here in the case of a
+   * minlp solved using an nlp solver for continuous relaxations */
+  //@{
+
+  /** Cbc will understand that no matrix exsits if return -1
+  */
+  virtual int getNumElements() const
+  {
+    return -1;
+  }
+
+
+  /** This returns the objective function gradient at the current
+   *  point.  It seems to be required for Cbc's pseudo cost
+   *  initialization
+  */
+  virtual const double * getObjCoefficients() const;
+
+  /** We have to keep this but it will return NULL.
+   */
+  virtual const CoinPackedMatrix * getMatrixByRow() const
+  {
+      return NULL;
+  }
+
+
+  /** We have to keep this but it will return NULL.
+   */
+  virtual const CoinPackedMatrix * getMatrixByCol() const
+  {
+      return NULL;
+  }
+
+  /** We have to keep this but it will throw an error.
+  */
+  virtual void setObjCoeff( int elementIndex, double elementValue )
+  {
+    throw SimpleError("OsiTMINLPInterface does not implement this function.",
+        "setObjCoeff");
+  }
+
+  /** We have to keep this but it will throw an error.
+  */
+  virtual void addCol(const CoinPackedVectorBase& vec,
+      const double collb, const double colub,
+      const double obj)
+  {
+    throw SimpleError("OsiTMINLPInterface does not implement this function.",
+        "addCol");
+  }
+  /** We have to keep this but it will throw an error.
+  */
+  virtual void deleteCols(const int num, const int * colIndices)
+  {
+    throw SimpleError("OsiTMINLPInterface does not implement this function.",
+        "deleteCols");
+  }
+
+  /** We have to keep this but it will throw an error.
+  */
+  virtual void addRow(const CoinPackedVectorBase& vec,
+      const double rowlb, const double rowub)
+  {
+    throw SimpleError("OsiTMINLPInterface does not implement this function.",
+        "addRow");
+  }
+  /** We have to keep this but it will throw an error.
+  */
+  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");
+  }
+  /** We have to keep this but it will throw an error.
+  */
+  virtual void deleteRows(const int num, const int * rowIndices)
+  {
+    if(num)
+      freeCachedRowRim();
+     problem_->removeCuts(num, rowIndices);
+  }
+
+
+  /** We have to keep this but it will throw an error
+  */
+  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");
+  }
+
+
+  /** We have to keep this but it will throw an error.
+  */
+  virtual void assignProblem(CoinPackedMatrix*& matrix,
+      double*& collb, double*& colub, double*& obj,
+      double*& rowlb, double*& rowub)
+  {
+    throw SimpleError("OsiTMINLPInterface does not implement this function.",
+        "assignProblem");
+  }
+
+  /** We have to keep this but it will throw an error.
+  */
+  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");
+  }
+
+  /** We have to keep this but it will throw an error.
+  */
+  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");
+  }
+
+
+  /** We have to keep this but it will throw an error.
+  */
+  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");
+  }
+
+  /** We have to keep this but it will throw an error.
+  */
+  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");
+  }
+
+  /** We have to keep this but it will throw an error.
+  */
+  virtual int readMps(const char *filename,
+      const char *extension = "mps")
+  {
+    throw SimpleError("OsiTMINLPInterface does not implement this function.",
+        "readMps");
+  }
+
+
+  /** We have to keep this but it will throw an error.
+  */
+  virtual void writeMps(const char *filename,
+      const char *extension = "mps",
+      double objSense=0.0) const
+  {
+    throw SimpleError("OsiTMINLPInterface does not implement this function.",
+        "writeMps");
+  }
+
+  /** Throws an error */
+  virtual std::vector<double*> getDualRays(int maxNumRays, bool fullRay = false) const
+  {
+    throw SimpleError("OsiTMINLPInterface does not implement this function.",
+        "getDualRays");
+  }
+
+  /** Throws an error */
+  virtual std::vector<double*> getPrimalRays(int maxNumRays) const
+  {
+    throw SimpleError("OsiTMINLPInterface does not implement this function.",
+        "getPrimalRays");
+  }
+
+  //@}
+
+
+  
+  //---------------------------------------------------------------------------
+
+
+
+  /**@name Control of Ipopt output
+   */
+  //@{
+  void setSolverOutputToDefault(){
+  app_->setOutputToDefault();}
+  void forceSolverOutput(int log_level){
+  app_->forceSolverOutput(log_level);}
+  //@}
+
+  /**@name Sets and Getss */
+  //@{
+  /// Get objective function value (can't use default)
+  virtual double getObjValue() const;
+
+  //@}
+
+  /** get pointer to the TMINLP2TNLP adapter */
+  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_);
+  } 
+  /** \name Methods to build outer approximations */
+  //@{
+  /** \name Methods to build outer approximations */
+  //@{
+  /** \brief Extract a linear relaxation of the MINLP.
+   * Use user-provided point to build first-order outer-approximation constraints at the optimum.
+   * And put it in an OsiSolverInterface.
+   */
+  virtual void extractLinearRelaxation(OsiSolverInterface &si, const double *x, 
+                                       bool getObj = 1);
+
+  /** Add constraint corresponding to objective function.*/
+  virtual void addObjectiveFunction(OsiSolverInterface &si, const double * x);
+#if 1
+  /** \brief Extract a linear relaxation of the MINLP.
+   * Solve the continuous relaxation and takes first-order outer-approximation constraints at the optimum.
+   * The put everything in an OsiSolverInterface.
+   */
+  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
+  /** Get the outer approximation constraints at the current optimal point.
+      If x2 is different from NULL only add cuts violated by x2.
+   (Only get outer-approximations of nonlinear constraints of the problem.)*/
+  void getOuterApproximation(OsiCuts &cs, int getObj, const double * x2, bool global)
+{
+  getOuterApproximation(cs, getColSolution(), getObj, x2, global);
+}
+
+  /** Get the outer approximation constraints at provided point.
+      If x2 is different from NULL only add cuts violated by x2.
+   (Only get outer-approximations of nonlinear constraints of the problem.)*/
+  void getOuterApproximation(OsiCuts &cs, const double * x, int getObj, const double * x2, bool global){
+    getOuterApproximation(cs, x, getObj, x2, 0., global);}
+
+  /** Get the outer approximation constraints at provided point.
+      If x2 is different from NULL only add cuts violated by x2 by more than delta.
+   (Only get outer-approximations of nonlinear constraints of the problem.)*/
+  virtual void getOuterApproximation(OsiCuts &cs, const double * x, int getObj, const double * x2,
+                                     double theta, bool global);
+
+ /** Get the outer approximation at provided point for given constraint. */
+  virtual void getConstraintOuterApproximation(OsiCuts & cs, int constraintNumber,
+                                               const double * x, 
+                                               const double * x2, bool global);
+
+ /** Get the outer approximation at current optimal point for given constraint. */
+  void getConstraintOuterApproximation(OsiCuts & cs, int constraintNumber,
+                                       const double * x2, bool global){
+     getConstraintOuterApproximation(cs, constraintNumber, getColSolution(),x2,global);
+  }
+
+
+/** Get a benders cut from solution.*/
+void getBendersCut(OsiCuts &cs, bool global);
+
+  /** Given a point x_bar this solves the problem of finding the point which minimize a convex 
+    *combination between the distance to  x_bar and the original objective function f(x):
+   * \f$ min a * (\sum\limits_{i=1}^n  ||x_{ind[i]} -\overline{x}_i)||_L) + (1 - a)* s *f(x) \f$
+   * \return Distance between feasibility set a x_bar on components in ind
+   * \param n number of elements in array x_bar and ind
+   * \param s scaling of the original objective.
+   * \param a Combination to take between feasibility and original objective (must be between 0 and 1).
+   * \param L L-norm to use (can be either 1 or 2).
+   */
+  double solveFeasibilityProblem(size_t n, const double * x_bar, const int* ind, double a, double s, int L);
+
+  /** Given a point x_bar this solves the problem of finding the point which minimize
+    * the distance to x_bar while satisfying the additional cutoff constraint:
+   * \f$ min \sum\limits_{i=1}^n  ||x_{ind[i]} -\overline{x}_i)||_L$
+   * \return Distance between feasibility set a x_bar on components in ind
+   * \param n number of elements in array x_bar and ind
+   * \param L L-norm to use (can be either 1 or 2).
+   * \param cutoff objective function value of a known integer feasible solution
+   */
+  double solveFeasibilityProblem(size_t n, const double * x_bar, const int* ind, int L, double cutoff);
+
+  /** Given a point x_bar setup feasibility problem and switch so that every call to initialSolve or resolve will
+      solve it.*/
+  void switchToFeasibilityProblem(size_t n, const double * x_bar, const int* ind, double a, double s, int L);
+
+  /** Given a point x_bar setup feasibility problem and switch so that every call to initialSolve or resolve will
+      solve it. This is to be used in the local branching heuristic */
+  void switchToFeasibilityProblem(size_t n, const double * x_bar, const int* ind,
+				  double rhs_local_branching_constraint);
+
+  /** switch back to solving original problem.*/
+  void switchToOriginalProblem();
+  
+  /** round solution and check its feasibility.*/
+  void round_and_check(double tolerance,
+                       OsiObject ** objects = 0, int nObjects = -1){
+    if(!problem_->check_solution(objects, nObjects)){
+      optimizationStatus_ = TNLPSolver::provenInfeasible;
+    }
+  }
+  //@}
+
+  /** \name output for OA cut generation
+       \todo All OA code here should be moved to a separate class sometime.*/
+  //@{
+  /** OA Messages types.*/
+  enum OaMessagesTypes {
+    CUT_NOT_VIOLATED_ENOUGH = 0/** Says that one cut has been generarted, where from, which is the violation.*/,
+    VIOLATED_OA_CUT_GENERATED/** Cut is not violated enough, give violation.*/,
+    OA_CUT_GENERATED/** Print the cut which has been generated.*/,
+    OA_MESSAGES_DUMMY_END/** Dummy end.*/};
+  /** Class to store OA Messages.*/
+  class OaMessages :public CoinMessages{
+     public:
+     /** Default constructor.*/
+     OaMessages();
+  };
+  /** Like a CoinMessageHandler but can print a cut also.*/
+  class OaMessageHandler : public CoinMessageHandler{
+    public:
+    /** Default constructor.*/
+    OaMessageHandler():CoinMessageHandler(){
+    }
+    /** Constructor to put to file pointer (fp won't be closed).*/
+    OaMessageHandler(FILE * fp):CoinMessageHandler(fp){
+    }
+    /** Destructor.*/
+    virtual ~OaMessageHandler(){
+    }
+    /** Copy constructor.*/
+    OaMessageHandler(const OaMessageHandler &other):
+    CoinMessageHandler(other){}
+    /** Constructor from a regular CoinMessageHandler.*/
+    OaMessageHandler(const CoinMessageHandler &other):
+    CoinMessageHandler(other){}
+    /** Assignment operator.*/
+    OaMessageHandler & operator=(const OaMessageHandler &rhs){
+       CoinMessageHandler::operator=(rhs);
+       return *this;}
+    /** Virtual copy */
+    virtual CoinMessageHandler* clone() const{
+      return new OaMessageHandler(*this);}
+    /** print an OsiRowCut.*/
+    void print(OsiRowCut &row);
+  };
+  void setOaMessageHandler(const CoinMessageHandler &handler){
+    delete oaHandler_;
+    oaHandler_ = new OaMessageHandler(handler);
+  }
+  //@}
+
+    //-----------------------------------------------------------------------
+    /** Apply a collection of cuts.
+    */
+    virtual ApplyCutsReturnCode applyCuts(const OsiCuts & cs,
+					  double effectivenessLb = 0.0){
+       freeCachedRowRim();
+      problem_->addCuts(cs);
+      ApplyCutsReturnCode rc;
+      return rc;}
+
+   /** Add a collection of linear cuts to problem formulation.*/
+  virtual void applyRowCuts(int numberCuts, const OsiRowCut * cuts);
+
+
+  /** Add a collection of linear cuts to the problem formulation */
+  virtual void applyRowCuts(int numberCuts, const OsiRowCut ** cuts)
+  {
+    if(numberCuts)
+      freeCachedRowRim();
+    problem_->addCuts(numberCuts, cuts);
+  }
+
+ /** Get infinity norm of constraint violation for x. Put into
+     obj the objective value of x.*/
+ double getConstraintsViolation(const double * x, double & obj);
+
+  /** Get infinity norm of constraint violation for x and error in objective
+      value where obj is the estimated objective value of x.*/
+  double getNonLinearitiesViolation(const double *x, const double obj);
+
+//---------------------------------------------------------------------------
+
+  void extractInterfaceParams();
+
+
+  /** To set some application specific defaults. */
+  virtual void setAppDefaultOptions(Ipopt::SmartPtr<Ipopt::OptionsList> Options);
+
+  /** Register all possible options to Bonmin */
+  static void registerOptions (Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions);
+  
+  Ipopt::SmartPtr<Bonmin::RegisteredOptions> regOptions(){
+    if(IsValid(app_))
+      return app_->roptions();
+    else
+      return NULL;
+  }
+
+  /** @name Methods related to strong branching */
+  //@{
+  /// Set the strong branching solver
+  void SetStrongBrachingSolver(Ipopt::SmartPtr<StrongBranchingSolver> strong_branching_solver);
+  /// Create a hot start snapshot of the optimization process.  In our
+  /// case, we initialize the StrongBrachingSolver.
+  virtual void markHotStart();
+  /// Optimize starting from the hot start snapshot. In our case, we
+  /// call the StrongBranchingSolver to give us an approximate
+  /// solution for the current state of the bounds
+  virtual void solveFromHotStart();
+  /// Delete the hot start snapshot. In our case we deactivate the
+  /// StrongBrachingSolver.
+  virtual void unmarkHotStart();
+  //@}
+
+  /// Get values of tiny_ and very_tiny_
+  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};
+  /// Initialize data structures for storing the jacobian
+  int initializeJacobianArrays();
+
+  ///@name Virtual callbacks for application specific stuff
+  //@{
+  virtual std::string  appName()
+  {
+    return "bonmin";
+  }
+  //@}
+  ///@name Protected methods
+  //@{
+
+  /** Call Ipopt to solve or resolve the problem and check for errors.*/
+  void solveAndCheckErrors(bool doResolve, bool throwOnFailure,
+      const char * whereFrom);
+
+
+  /** Add a linear cut to the problem formulation.
+  */
+  virtual void applyRowCut( const OsiRowCut & rc )
+  {
+    const OsiRowCut * cut = &rc;
+    problem_->addCuts(1, &cut);
+  }
+  /** We have to keep this but it will throw an error.
+  */
+  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;
+
+  //@}
+
+  /**@name Model and solver */
+  //@{
+  /** TMINLP model.*/
+  Ipopt::SmartPtr<TMINLP> tminlp_;
+  /** Adapter for a MINLP to a NLP */
+  Ipopt::SmartPtr<TMINLP2TNLP> problem_;
+  /** Problem currently optimized (may be problem_ or feasibilityProblem_)*/
+  Ipopt::SmartPtr<Ipopt::TNLP> problem_to_optimize_;
+  /** Is true if and only if in feasibility mode.*/
+  bool feasibility_mode_;
+  /** Solver for a TMINLP. */
+  Ipopt::SmartPtr<TNLPSolver> app_;
+
+  /** Alternate solvers for TMINLP.*/
+  std::list<Ipopt::SmartPtr<TNLPSolver> > debug_apps_;
+  /** Do we use the other solvers?*/
+  bool testOthers_;
+  //@}
+
+  /** Warmstart information for reoptimization */
+  CoinWarmStart* warmstart_;
+
+  /**@name Cached information on the problem */
+  //@{
+  /** Free cached data relative to variables */
+  void freeCachedColRim();
+  /** Free cached data relative to constraints */
+  void freeCachedRowRim();
+  /** Free all cached data*/
+  void freeCachedData();
+  /** Extract rowsense_ vector rhs_ vector and rowrange_ vector from the lower and upper bounds
+   *  on the constraints */
+  void extractSenseRhsAndRange() const;
+  /// Pointer to dense vector of row sense indicators
+  mutable char    *rowsense_;
+
+  /// Pointer to dense vector of row right-hand side values
+  mutable double  *rhs_;
+
+  /// Pointer to dense vector of slack upper bounds for range constraints (undefined for non-range rows)
+  mutable double  *rowrange_;
+  /** Pointer to dense vector of reduced costs
+      \warning Always 0. with Ipopt*/
+  mutable double  *reducedCosts_;
+  /** DualObjectiveLimit is used to store the cutoff in Cbc*/
+  double OsiDualObjectiveLimit_;
+  /** does the file variable names exists (will check automatically).*/
+  mutable bool hasVarNamesFile_;
+  //@}
+  /// number of time NLP has been solved
+  int nCallOptimizeTNLP_;
+  /// Total solution time of NLP
+  double totalNlpSolveTime_;
+  /// toatal number of iterations
+  int totalIterations_;
+  /// max radius for random point
+  double maxRandomRadius_;
+  /// Method to pick a random starting point.
+  int randomGenerationType_;
+  /// Maximum perturbation value
+  double max_perturbation_;
+  /// Ipopt value for pushing initial point inside the bounds
+  double pushValue_;
+  /// Number of times problem will be resolved in initialSolve (root node)
+  int numRetryInitial_;
+  /// Number of times problem will be resolved in resolve
+  int numRetryResolve_;
+  /// Number of times infeasible problem will be resolved.
+  int numRetryInfeasibles_;
+  /// Number of times problem will be resolved in case of a failure
+  int numRetryUnsolved_;
+  /// If infeasibility for a problem is less than this, let's be carrefull. It might be feasible
+  double infeasibility_epsilon_;
+
+
+  //Added by Claudia
+  /// Dynamic cutOff_
+  int dynamicCutOff_;
+  /// coeff_var_threshold_
+  double coeff_var_threshold_;
+  /// first_perc_for_cutoff_decr_
+  double first_perc_for_cutoff_decr_;
+  /// second_perc_for_cutoff_decr_
+  double second_perc_for_cutoff_decr_;
+ 
+
+  /** Messages specific to an OsiTMINLPInterface. */
+  Messages messages_;
+  /** If not 0 when a problem is not solved (failed to be solved)
+      will pretend that it is infeasible. If == 1 will care
+      (i.e. record the fact issue messages to user), if ==2 don't care (somebody else will) */
+  int pretendFailIsInfeasible_;
+
+  mutable int pretendSucceededNext_;
+
+  /** did we ever continue optimization ignoring a failure. */
+  bool hasContinuedAfterNlpFailure_;
+  /** number iterations above which a problem is considered suspect (-1 is considered \f$+ \infty \f$).
+  	If in a call to solve a problem takes more than that number of iterations it will be output to files.*/
+  int numIterationSuspect_ ;
+  /** Has problem been optimized since last change (include setColSolution).
+     If yes getColSolution will return Ipopt point, otherwise will return
+     initial point.*/
+  bool hasBeenOptimized_;
+  /** A fake objective function (all variables to 1) to please Cbc
+      pseudo costs initialization.  AW: I changed this, it will now be
+      the objective gradient at current point. */
+  mutable double * obj_;
+  /** flag to say wether options have been printed or not.*/
+  static bool hasPrintedOptions;
+
+  /** Adapter for TNLP to a feasibility problem */
+  Ipopt::SmartPtr<TNLP2FPNLP> feasibilityProblem_;
+
+  /** Adapter for TMINLP to an Osi LP  */
+  Ipopt::SmartPtr<TMINLP2OsiLP> linearizer_;
+
+  /** \name Arrays to store Jacobian matrix */
+  //@{
+  /** Row indices.*/
+  int * jRow_;
+  /** Column indices.*/
+  int * jCol_;
+  /** Values */
+  double * jValues_;
+  /** Number of elements.*/
+  int nnz_jac;
+  //@}
+
+  ///Store the types of the constraints (linear and nonlinear).
+  Ipopt::TNLP::LinearityType * constTypes_;
+  /** Number of nonlinear constraint
+   */
+  int nNonLinear_;
+  /** Value for small non-zero element which we will try to remove cleanly in OA cuts.*/
+  double tiny_;
+  /** Value for small non-zero element which we will take the risk to ignore in OA cuts.*/
+  double veryTiny_;
+  /** Amount by which to relax OA constraints RHSes*/
+  double rhsRelax_;
+  /** Value for infinity. */
+  double infty_;
+  /** status of last optimization. */
+  TNLPSolver::ReturnStatus optimizationStatus_;
+  /** Flag indicating if the warm start methods actually do something.*/
+  WarmStartModes warmStartMode_;
+  /** Is it the first solve (for random starting point at root options).*/
+  bool firstSolve_;
+  /** Object for strengthening cuts */
+  Ipopt::SmartPtr<CutStrengthener> cutStrengthener_;
+
+  /** \name output for OA cut generation
+       \todo All OA code here should be moved to a separate class sometime.*/
+  //@{
+  /** OA Messages.*/
+  OaMessages oaMessages_;
+  /** OA Message handler. */
+  OaMessageHandler * oaHandler_;
+  //@}
+
+  double newCutoffDecr;
+protected:
+  /** Facilitator to create an application. */
+  void createApplication(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions,
+                         Ipopt::SmartPtr<Ipopt::OptionsList> options,
+                         Ipopt::SmartPtr<Ipopt::Journalist> journalist,
+                         const std::string & prefix);
+  ///Constructor without model only for derived classes
+  OsiTMINLPInterface(Ipopt::SmartPtr<TNLPSolver> app);
+
+  /** Internal set warm start.*/
+  bool internal_setWarmStart(const CoinWarmStart* ws);
+
+  /** internal get warm start.*/
+  CoinWarmStart* internal_getWarmStart() const; 
+
+  /** Procedure that builds a fake basis. Only tries to make basis consistent with constraints activity.*/
+  CoinWarmStart* build_fake_basis() const; 
+private:
+
+  /** solver to be used for all strong branching solves */
+  Ipopt::SmartPtr<StrongBranchingSolver> strong_branching_solver_;
+  /** status of last optimization before hot start was marked. */
+  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;
+  /** Get status as a char * for log.*/
+  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