ruby-cbc 0.1.9 → 0.2.1

data/ext/ruby-cbc/install/include/coin/OsiCbcSolverInterface.hpp

@@ -1,764 +0,0 @@
-// $Id: OsiCbcSolverInterface.hpp 1899 2013-04-09 18:12:08Z stefan $
-// Copyright (C) 2000, International Business Machines
-// Corporation and others.  All Rights Reserved.
-// This code is licensed under the terms of the Eclipse Public License (EPL).
-
-#ifndef OsiCbcSolverInterface_H
-#define OsiCbcSolverInterface_H
-
-#include <string>
-#include <cfloat>
-#include <map>
-#include "CbcModel.hpp"
-#include "CoinPackedMatrix.hpp"
-#include "OsiSolverInterface.hpp"
-#include "CbcStrategy.hpp"
-#include "CoinWarmStartBasis.hpp"
-
-class OsiRowCut;
-class OsiClpSolverInterface;
-static const double OsiCbcInfinity = COIN_DBL_MAX;
-
-//#############################################################################
-
-/** Cbc Solver Interface
-    
-Instantiation of OsiCbcSolverInterface for the Model Algorithm.
-
-*/
-
-class OsiCbcSolverInterface :
-  virtual public OsiSolverInterface {
-  friend void OsiCbcSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);
-  
-public:
-  //---------------------------------------------------------------------------
-  /**@name Solve methods */
-  //@{
-  /// Solve initial LP relaxation 
-  virtual void initialSolve();
-  
-  /// Resolve an LP relaxation after problem modification
-  virtual void resolve();
-  
-  /// Invoke solver's built-in enumeration algorithm
-  virtual void branchAndBound();
-  //@}
-  
-  //---------------------------------------------------------------------------
-  /**@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 cbc 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;
-  // Set a hint parameter - overrides OsiSolverInterface
-  virtual bool setHintParam(OsiHintParam key, bool yesNo=true,
-                            OsiHintStrength strength=OsiHintTry,
-                            void * otherInformation=NULL);
-  /// Get a hint parameter
-    virtual bool getHintParam(OsiHintParam key, bool& yesNo,
-			      OsiHintStrength& strength,
-			      void *& otherInformation) const;
-
-  using OsiSolverInterface::getHintParam ;
-  /// Get a hint parameter
-    virtual bool getHintParam(OsiHintParam key, bool& yesNo,
-			      OsiHintStrength& strength) const;
-  //@}
-  
-  //---------------------------------------------------------------------------
-  ///@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;
-  //@}
-  
-  //---------------------------------------------------------------------------
-  /**@name WarmStart related methods */
-  //@{
-  
-  /*! \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);
-  //@}
-  
-  //---------------------------------------------------------------------------
-  /**@name Hotstart related methods (primarily used in strong branching). <br>
-     The user can create a hotstart (a snapshot) of the optimization process
-     then reoptimize over and over again always starting from there.<br>
-     <strong>NOTE</strong>: between hotstarted optimizations only
-     bound changes are allowed. */
-  //@{
-  /// Create a hotstart point of the optimization process
-  virtual void markHotStart();
-  /// Optimize starting from the hotstart
-  virtual void solveFromHotStart();
-  /// Delete the snapshot
-  virtual void unmarkHotStart();
-  //@}
-  
-  //---------------------------------------------------------------------------
-  /**@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.
-  */
-  //@{
-  /**@name Methods related to querying the input data */
-  //@{
-  /// Get number of columns
-  virtual int getNumCols() const;
-  
-  /// Get number of rows
-  virtual int getNumRows() const;
-  
-  /// Get number of nonzero elements
-  virtual int getNumElements() const ;
-  
-  /// 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 undefined
-      </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 pointer to array[getNumCols()] of objective function coefficients
-  virtual const double * getObjCoefficients() const; 
-  
-  /// Get objective function sense (1 for min (default), -1 for max)
-  virtual double getObjSense() const ;
-  
-  /// Return true if column is continuous
-  virtual bool isContinuous(int colNumber) const;
-  
-  
-  /// Get pointer to row-wise copy of matrix
-  virtual const CoinPackedMatrix * getMatrixByRow() const;
-  
-  /// Get pointer to column-wise copy of matrix
-  virtual const CoinPackedMatrix * getMatrixByCol() const;
-  
-  /// Get solver's value for infinity
-  virtual double getInfinity() const;
-  //@}
-  
-  /**@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 objective function value
-  virtual double getObjValue() const;
-  
-  /** Get how many iterations it took to solve the problem (whatever
-      "iteration" mean to the solver. */
-  virtual int getIterationCount() const ;
-  
-  /** Get as many dual rays as the solver can provide. (In case of proven
-      primal infeasibility there should be at least one.)
-
-      The first getNumRows() ray components will always be associated with
-      the row duals (as returned by getRowPrice()). If \c fullRay is true,
-      the final getNumCols() entries will correspond to the ray components
-      associated with the nonbasic variables. If the full ray is requested
-      and the method cannot provide it, it will throw an exception.
-
-      <strong>NOTE for implementers of solver interfaces:</strong> <br>
-      The double pointers in the vector should point to arrays of length
-      getNumRows() and they should be allocated via new[]. <br>
-      
-      <strong>NOTE for users of solver interfaces:</strong> <br>
-      It is the user's responsibility to free the double pointers in the
-      vector using delete[].
-  */
-  virtual std::vector<double*> getDualRays(int maxNumRays,
-					   bool fullRay = false) const;
-  /** Get as many primal rays as the solver can provide. (In case of proven
-      dual infeasibility there should be at least one.)
-      
-      <strong>NOTE for implementers of solver interfaces:</strong> <br>
-      The double pointers in the vector should point to arrays of length
-      getNumCols() and they should be allocated via new[]. <br>
-      
-      <strong>NOTE for users of solver interfaces:</strong> <br>
-      It is the user's responsibility to free the double pointers in the
-      vector using delete[].
-  */
-  virtual std::vector<double*> getPrimalRays(int maxNumRays) const;
-  
-  //@}
-
-  /*! \name Methods for row and column names.
-
-    Because OsiCbc is a pass-through class, it's necessary to override any
-    virtual method in order to be sure we catch an override by the underlying
-    solver. See the OsiSolverInterface class documentation for detailed
-    descriptions.
-  */
-  //@{
-
-    /*! \brief Generate a standard name of the form Rnnnnnnn or Cnnnnnnn */
-
-    virtual std::string dfltRowColName(char rc,
-				 int ndx, unsigned digits = 7) const ;
-
-    /*! \brief Return the name of the objective function */
-
-    virtual std::string getObjName (unsigned maxLen = std::string::npos) const ;
-
-    /*! \brief Set the name of the objective function */
-
-    virtual void setObjName (std::string name) ;
-
-    /*! \brief Return the name of the row.  */
-
-    virtual std::string getRowName(int rowIndex,
-				   unsigned maxLen = std::string::npos) const ;
-
-    /*! \brief Return a pointer to a vector of row names */
-
-    virtual const OsiNameVec &getRowNames() ;
-
-    /*! \brief Set a row name */
-
-    virtual void setRowName(int ndx, std::string name) ;
-
-    /*! \brief Set multiple row names */
-
-    virtual void setRowNames(OsiNameVec &srcNames,
-		     int srcStart, int len, int tgtStart) ;
-
-    /*! \brief Delete len row names starting at index tgtStart */
-
-    virtual void deleteRowNames(int tgtStart, int len) ;
-  
-    /*! \brief Return the name of the column */
-
-    virtual std::string getColName(int colIndex,
-				   unsigned maxLen = std::string::npos) const ;
-
-    /*! \brief Return a pointer to a vector of column names */
-
-    virtual const OsiNameVec &getColNames() ;
-
-    /*! \brief Set a column name */
-
-    virtual void setColName(int ndx, std::string name) ;
-
-    /*! \brief Set multiple column names */
-
-    virtual void setColNames(OsiNameVec &srcNames,
-		     int srcStart, int len, int tgtStart) ;
-
-    /*! \brief Delete len column names starting at index tgtStart */
-    virtual void deleteColNames(int tgtStart, int len) ;
-
-  //@}
-
-  //@}
-  
-  //---------------------------------------------------------------------------
-  
-  /**@name Problem modifying methods */
-  //@{
-  //-------------------------------------------------------------------------
-  /**@name Changing bounds on variables and constraints */
-  //@{
-  /** Set an objective function coefficient */
-  virtual void setObjCoeff( int elementIndex, double elementValue );
-
-  using OsiSolverInterface::setColLower ;
-  /** Set a single column lower bound<br>
-      Use -DBL_MAX for -infinity. */
-  virtual void setColLower( int elementIndex, double elementValue );
-  
-  using OsiSolverInterface::setColUpper ;
-  /** Set a single column upper bound<br>
-      Use DBL_MAX for infinity. */
-  virtual void setColUpper( int elementIndex, double elementValue );
-  
-  /** Set a single column lower and upper bound */
-  virtual void setColBounds( int elementIndex,
-                             double lower, double upper );
-  
-  /** Set the bounds on a number of columns simultaneously<br>
-      The default implementation just invokes setColLower() and
-      setColUpper() over and over again.
-      @param indexFirst,indexLast pointers to the beginning and after the
-      end of the array of the indices of the variables whose
-      <em>either</em> bound changes
-      @param boundList the new lower/upper bound pairs for the variables
-  */
-  virtual void setColSetBounds(const int* indexFirst,
-                               const int* indexLast,
-                               const double* boundList);
-  
-  /** Set a single row lower bound<br>
-      Use -DBL_MAX for -infinity. */
-  virtual void setRowLower( int elementIndex, double elementValue );
-  
-  /** Set a single row upper bound<br>
-      Use DBL_MAX for infinity. */
-  virtual void setRowUpper( int elementIndex, double elementValue ) ;
-  
-  /** Set a single row lower and upper bound */
-  virtual void setRowBounds( int elementIndex,
-                             double lower, double upper ) ;
-  
-  /** Set the type of a single row<br> */
-  virtual void setRowType(int index, char sense, double rightHandSide,
-                          double range);
-  
-  /** Set the bounds on a number of rows simultaneously<br>
-      The default implementation just invokes setRowLower() and
-      setRowUpper() over and over again.
-      @param indexFirst,indexLast pointers to the beginning and after the
-      end of the array of the indices of the constraints whose
-      <em>either</em> bound changes
-      @param boundList the new lower/upper bound pairs for the constraints
-  */
-  virtual void setRowSetBounds(const int* indexFirst,
-                               const int* indexLast,
-                               const double* boundList);
-  
-  /** Set the type of a number of rows simultaneously<br>
-      The default implementation just invokes setRowType()
-      over and over again.
-      @param indexFirst,indexLast pointers to the beginning and after the
-      end of the array of the indices of the constraints whose
-      <em>any</em> characteristics changes
-      @param senseList the new senses
-      @param rhsList   the new right hand sides
-      @param rangeList the new ranges
-  */
-  virtual void setRowSetTypes(const int* indexFirst,
-                              const int* indexLast,
-                              const char* senseList,
-                              const double* rhsList,
-                              const double* rangeList);
-  //@}
-  
-  //-------------------------------------------------------------------------
-  /**@name Integrality related changing methods */
-  //@{
-  /** 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 the variables listed in indices (which is of length len) to be
-      continuous variables */
-  virtual void setContinuous(const int* indices, int len);
-  /** Set the variables listed in indices (which is of length len) to be
-      integer variables */
-  virtual void setInteger(const int* indices, int len);
-  //@}
-  
-  //-------------------------------------------------------------------------
-  /// Set objective function sense (1 for min (default), -1 for max,)
-  virtual void setObjSense(double s ); 
-  
-  /** Set the primal solution column values
-      
-  colsol[numcols()] is an array of values of the problem column
-  variables. These values are copied to memory owned by the
-  solver object or the solver.  They will be returned as the
-  result of colsol() until changed by another call to
-  setColsol() or by a call to any solver routine.  Whether the
-  solver makes use of the solution in any way is
-  solver-dependent. 
-  */
-  virtual void setColSolution(const double * colsol);
-  
-  /** Set dual solution vector
-      
-  rowprice[numrows()] is an array of values of the problem row
-  dual variables. These values are copied to memory owned by the
-  solver object or the solver.  They will be returned as the
-  result of rowprice() until changed by another call to
-  setRowprice() or by a call to any solver routine.  Whether the
-  solver makes use of the solution in any way is
-  solver-dependent. 
-  */
-  virtual void setRowPrice(const double * rowprice);
-  
-  //-------------------------------------------------------------------------
-  /**@name Methods to expand a problem.<br>
-     Note that if a column is added then by default it will correspond to a
-     continuous variable. */
-  //@{
-  using OsiSolverInterface::addCol ;
-  /** */
-  virtual void addCol(const CoinPackedVectorBase& vec,
-                      const double collb, const double colub,   
-                      const double obj);
-  /** Add a column (primal variable) to the problem. */
-  virtual void addCol(int numberElements, const int * rows, const double * elements,
-                      const double collb, const double colub,   
-                      const double obj) ;
-
-  using OsiSolverInterface::addCols ;
-  /** */
-  virtual void addCols(const int numcols,
-                       const CoinPackedVectorBase * const * cols,
-                       const double* collb, const double* colub,   
-                       const double* obj);
-  /** */
-  virtual void deleteCols(const int num, const int * colIndices);
-  
-  using OsiSolverInterface::addRow ;
-  /** */
-  virtual void addRow(const CoinPackedVectorBase& vec,
-                      const double rowlb, const double rowub);
-  /** */
-  virtual void addRow(const CoinPackedVectorBase& vec,
-                      const char rowsen, const double rowrhs,   
-                      const double rowrng);
-
-  using OsiSolverInterface::addRows ;
-  /** */
-  virtual void addRows(const int numrows,
-                       const CoinPackedVectorBase * const * rows,
-                       const double* rowlb, const double* rowub);
-  /** */
-  virtual void addRows(const int numrows,
-                       const CoinPackedVectorBase * const * rows,
-                       const char* rowsen, const double* rowrhs,   
-                       const double* rowrng);
-  /** */
-  virtual void deleteRows(const int num, const int * rowIndices);
-  
-  //-----------------------------------------------------------------------
-  /** Apply a collection of row cuts which are all effective.
-      applyCuts seems to do one at a time which seems inefficient.
-  */
-  virtual void applyRowCuts(int numberCuts, const OsiRowCut * cuts);
-  /** Apply a collection of row cuts which are all effective.
-      applyCuts seems to do one at a time which seems inefficient.
-      This uses array of pointers
-  */
-  virtual void applyRowCuts(int numberCuts, const OsiRowCut ** cuts);
-  //@}
-  //@}
-  
-  //---------------------------------------------------------------------------
-  
-public:
-  
-  /**@name Methods to input a problem */
-  //@{
-  /** Load in an problem by copying the arguments (the constraints on the
-      rows are given by lower and upper bounds). If a pointer is 0 then the
-      following values are the default:
-      <ul>
-      <li> <code>colub</code>: all columns have upper bound infinity
-      <li> <code>collb</code>: all columns have lower bound 0 
-      <li> <code>rowub</code>: all rows have upper bound infinity
-      <li> <code>rowlb</code>: all rows have lower bound -infinity
-      <li> <code>obj</code>: all variables have 0 objective coefficient
-      </ul>
-  */
-  virtual void loadProblem(const CoinPackedMatrix& matrix,
-                           const double* collb, const double* colub,   
-                           const double* obj,
-                           const double* rowlb, const double* rowub);
-  
-  /** Load in an problem by assuming ownership of the arguments (the
-      constraints on the rows are given by lower and upper bounds). For
-      default values see the previous method.  <br>
-      <strong>WARNING</strong>: The arguments passed to this method will be
-      freed using the C++ <code>delete</code> and <code>delete[]</code>
-      functions. 
-  */
-  virtual void assignProblem(CoinPackedMatrix*& matrix,
-    			     double*& collb, double*& colub, double*& obj,
-    			     double*& rowlb, double*& rowub);
-  
-  /** Load in an problem by copying the arguments (the constraints on the
-      rows are given by sense/rhs/range triplets). If a pointer is 0 then the
-      following values are the default:
-      <ul>
-      <li> <code>colub</code>: all columns have upper bound infinity
-      <li> <code>collb</code>: all columns have lower bound 0 
-      <li> <code>obj</code>: all variables have 0 objective coefficient
-      <li> <code>rowsen</code>: all rows are >=
-      <li> <code>rowrhs</code>: all right hand sides are 0
-      <li> <code>rowrng</code>: 0 for the ranged rows
-      </ul>
-  */
-  virtual void loadProblem(const CoinPackedMatrix& matrix,
-    			   const double* collb, const double* colub,
-    			   const double* obj,
-    			   const char* rowsen, const double* rowrhs,   
-    			   const double* rowrng);
-  
-  /** Load in an problem by assuming ownership of the arguments (the
-      constraints on the rows are given by sense/rhs/range triplets). For
-      default values see the previous method. <br>
-      <strong>WARNING</strong>: The arguments passed to this method will be
-      freed using the C++ <code>delete</code> and <code>delete[]</code>
-      functions. 
-  */
-  virtual void assignProblem(CoinPackedMatrix*& matrix,
-    			     double*& collb, double*& colub, double*& obj,
-    			     char*& rowsen, double*& rowrhs,
-    			     double*& rowrng);
-  
-  /** Just like the other loadProblem() methods except that the matrix is
-      given in a standard column major ordered format (without gaps). */
-  virtual void loadProblem(const int numcols, const int numrows,
-                           const CoinBigIndex * start, const int* index,
-                           const double* value,
-                           const double* collb, const double* colub,   
-                           const double* obj,
-                           const double* rowlb, const double* rowub);
-  
-  /** Just like the other loadProblem() methods except that the matrix is
-      given in a standard column major ordered format (without gaps). */
-  virtual void loadProblem(const int numcols, const int numrows,
-                           const CoinBigIndex * 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);
-
-  using OsiSolverInterface::readMps ;
-  /** Read an mps file from the given filename (defaults to Osi reader) - returns
-      number of errors (see OsiMpsReader class) */
-  virtual int readMps(const char *filename,
-                      const char *extension = "mps") ;
-  
-  /** Write the problem into an mps file of the given filename.
-      If objSense is non zero then -1.0 forces the code to write a
-      maximization objective and +1.0 to write a minimization one.
-      If 0.0 then solver can do what it wants */
-  virtual void writeMps(const char *filename,
-                        const char *extension = "mps",
-                        double objSense=0.0) const;
-  /** Write the problem into an mps file of the given filename,
-      names may be null.  formatType is
-      0 - normal
-      1 - extra accuracy 
-      2 - IEEE hex (later)
-      
-      Returns non-zero on I/O error
-  */
-  virtual int writeMpsNative(const char *filename, 
-                             const char ** rowNames, const char ** columnNames,
-                             int formatType=0,int numberAcross=2,
-                             double objSense=0.0) const ;
-  //@}
-  
-  /**@name Message handling (extra for Cbc messages).
-     Normally I presume you would want the same language.
-     If not then you could use underlying model pointer */
-  //@{
-  /// Set language
-  void newLanguage(CoinMessages::Language language);
-  void setLanguage(CoinMessages::Language language)
-  {newLanguage(language);}
-  //@}
-  //---------------------------------------------------------------------------
-  
-  /**@name Cbc specific public interfaces */
-  //@{
-  /// Get pointer to Cbc model
-  inline CbcModel * getModelPtr() const 
-  { return modelPtr_;}
-  /// Get pointer to underlying solver
-  inline OsiSolverInterface * getRealSolverPtr() const 
-  { return modelPtr_->solver();}
-  /// Set cutoff bound on the objective function.
-  inline void setCutoff(double value) 
-  { modelPtr_->setCutoff(value);}
-  /// Get the cutoff bound on the objective function - always as minimize
-  inline double getCutoff() const
-  { return modelPtr_->getCutoff();}
-  /// Set the CbcModel::CbcMaxNumNode maximum node limit 
-  inline void setMaximumNodes( int value)
-  { modelPtr_->setMaximumNodes(value);}
-  /// Get the CbcModel::CbcMaxNumNode maximum node limit
-  inline int getMaximumNodes() const
-  { return modelPtr_->getMaximumNodes();}
-  /// Set the CbcModel::CbcMaxNumSol maximum number of solutions
-  inline void setMaximumSolutions( int value) 
-  { modelPtr_->setMaximumSolutions(value);}
-  /// Get the CbcModel::CbcMaxNumSol maximum number of solutions 
-  inline int getMaximumSolutions() const 
-  { return modelPtr_->getMaximumSolutions();}
-  /// Set the CbcModel::CbcMaximumSeconds maximum number of seconds 
-  inline void setMaximumSeconds( double value) 
-  { modelPtr_->setMaximumSeconds(value);}
-  /// Get the CbcModel::CbcMaximumSeconds maximum number of seconds 
-  inline double getMaximumSeconds() const 
-  { return modelPtr_->getMaximumSeconds();}
-  /// Node limit reached?
-  inline bool isNodeLimitReached() const
-  { return modelPtr_->isNodeLimitReached();}
-  /// Solution limit reached?
-  inline bool isSolutionLimitReached() const
-  { return modelPtr_->isSolutionLimitReached();}
-  /// Get how many Nodes it took to solve the problem.
-  inline int getNodeCount() const
-  { return modelPtr_->getNodeCount();}
-    /// Final status of problem - 0 finished, 1 stopped, 2 difficulties
-    inline int status() const
-  { return modelPtr_->status();}
-  /** Pass in a message handler
-  
-    It is the client's responsibility to destroy a message handler installed
-    by this routine; it will not be destroyed when the solver interface is
-    destroyed. 
-  */
-  virtual void passInMessageHandler(CoinMessageHandler * handler);
-  //@}
-  
-  //---------------------------------------------------------------------------
-  
-  /**@name Constructors and destructors */
-  //@{
-  /// Default Constructor
-  OsiCbcSolverInterface (OsiSolverInterface * solver=NULL,
-                         CbcStrategy * strategy=NULL);
-  
-  /// Clone
-  virtual OsiSolverInterface * clone(bool copyData = true) const;
-  
-  /// Copy constructor 
-  OsiCbcSolverInterface (const OsiCbcSolverInterface &);
-#if 0    
-  /// Borrow constructor - only delete one copy
-  OsiCbcSolverInterface (CbcModel * rhs, bool reallyOwn=false);
-  
-  /// Releases so won't error
-  void releaseCbc();
-#endif    
-  /// Assignment operator 
-  OsiCbcSolverInterface & operator=(const OsiCbcSolverInterface& rhs);
-  
-  /// Destructor 
-  virtual ~OsiCbcSolverInterface ();
-  
-  //@}
-  //---------------------------------------------------------------------------
-  
-protected:
-  ///@name Protected methods
-  //@{
-  /** Apply a row cut (append to constraint matrix). */
-  virtual void applyRowCut(const OsiRowCut& rc);
-  
-  /** Apply a column cut (adjust one or more bounds). */
-  virtual void applyColCut(const OsiColCut& cc);
-  //@}
-  /**@name Protected member data */
-  //@{
-  /// Cbc model represented by this class instance
-  mutable CbcModel * modelPtr_;
-  //@}
-};
-// So unit test can find out if NDEBUG set
-bool OsiCbcHasNDEBUG();
-
-//#############################################################################
-/** A function that tests the methods in the OsiCbcSolverInterface class. */
-void OsiCbcSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);
-
-#endif