Structure updated and intqpipopt files added

1 files changed, 0 insertions, 1342 deletions

diff --git a/build/Bonmin/include/coin/BonOsiTMINLPInterface.hpp b/build/Bonmin/include/coin/BonOsiTMINLPInterface.hpp
deleted file mode 100644
index 3d95545..0000000
--- a/build/Bonmin/include/coin/BonOsiTMINLPInterface.hpp
+++ /dev/null
@@ -1,1342 +0,0 @@
-// (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