ruby-cbc 0.1.9 → 0.2.1

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

@@ -1,252 +0,0 @@
-// Copyright (C) 2003, International Business Machines
-// Corporation and others.  All Rights Reserved.
-// This code is licensed under the terms of the Eclipse Public License (EPL).
-
-#ifndef OsiPresolve_H
-#define OsiPresolve_H
-#include "OsiSolverInterface.hpp"
-
-class CoinPresolveAction;
-#include "CoinPresolveMatrix.hpp"
-
-
-/*! \class OsiPresolve
-    \brief OSI interface to COIN problem simplification capabilities
-
-  COIN provides a number of classes which implement problem simplification
-  algorithms (CoinPresolveAction, CoinPrePostsolveMatrix, and derived
-  classes). The model of operation is as follows:
-  <ul>
-    <li>
-      Create a copy of the original problem.
-    </li>
-    <li>
-      Subject the copy to a series of transformations (the <i>presolve</i>
-      methods) to produce a presolved model. Each transformation is also
-      expected to provide a method to reverse the transformation (the
-      <i>postsolve</i> method). The postsolve methods are collected in a
-      linked list; the postsolve method for the final presolve transformation
-      is at the head of the list.
-    </li>
-    <li>
-      Hand the presolved problem to the solver for optimization.
-    </li>
-    <li>
-      Apply the collected postsolve methods to the presolved problem
-      and solution, restating the solution in terms of the original problem.
-    </li>
-  </ul>
-
-  The COIN presolve algorithms are unaware of OSI. The OsiPresolve class takes
-  care of the interface. Given an OsiSolverInterface \c origModel, it will take
-  care of creating a clone properly loaded with the presolved problem and ready
-  for optimization. After optimization, it will apply postsolve
-  transformations and load the result back into \c origModel.
-  
-  Assuming a problem has been loaded into an
-  \c OsiSolverInterface \c origModel, a bare-bones application looks like this:
-  \code
-  OsiPresolve pinfo ;
-  OsiSolverInterface *presolvedModel ;
-  // Return an OsiSolverInterface loaded with the presolved problem.
-  presolvedModel = pinfo.presolvedModel(*origModel,1.0e-8,false,numberPasses) ;
-  presolvedModel->initialSolve() ;
-  // Restate the solution and load it back into origModel.
-  pinfo.postsolve(true) ;
-  delete presolvedModel ;
-  \endcode
-*/
-
-
-
-class OsiPresolve {
-public:
-  /// Default constructor (empty object)
-  OsiPresolve();
-
-  /// Virtual destructor
-  virtual ~OsiPresolve();
-
-  /*! \brief Create a new OsiSolverInterface loaded with the presolved problem.
-
-    This method implements the first two steps described in the class
-    documentation.  It clones \c origModel and applies presolve
-    transformations, storing the resulting list of postsolve
-    transformations.  It returns a pointer to a new OsiSolverInterface loaded
-    with the presolved problem, or NULL if the problem is infeasible or
-    unbounded.  If \c keepIntegers is true then bounds may be tightened in
-    the original. Bounds will be moved by up to \c feasibilityTolerance to
-    try and stay feasible. When \c doStatus is true, the current solution will
-    be transformed to match the presolved model.
-
-    This should be paired with postsolve(). It is up to the client to
-    destroy the returned OsiSolverInterface, <i>after</i> calling postsolve().
-    
-    This method is virtual. Override this method if you need to customize
-    the steps of creating a model to apply presolve transformations.
-
-    In some sense, a wrapper for presolve(CoinPresolveMatrix*).
-  */
-  virtual OsiSolverInterface *presolvedModel(OsiSolverInterface & origModel,
-					     double feasibilityTolerance=0.0,
-					     bool keepIntegers=true,
-					     int numberPasses=5,
-                                             const char * prohibited=NULL,
-					     bool doStatus=true,
-					     const char * rowProhibited=NULL);
-
-  /*! \brief Restate the solution to the presolved problem in terms of the
-	     original problem and load it into the original model.
-  
-    postsolve() restates the solution in terms of the original problem and
-    updates the original OsiSolverInterface supplied to presolvedModel().  If
-    the problem has not been solved to optimality, there are no guarantees.
-    If you are using an algorithm like simplex that has a concept of a basic
-    solution, then set updateStatus
-
-    The advantage of going back to the original problem is that it
-    will be exactly as it was, <i>i.e.</i>, 0.0 will not become 1.0e-19.
-
-    Note that if you modified the original problem after presolving, then you
-    must ``undo'' these modifications before calling postsolve().
-
-    In some sense, a wrapper for postsolve(CoinPostsolveMatrix&).
-  */
-  virtual void postsolve(bool updateStatus=true);
-
-  /*! \brief Return a pointer to the presolved model. */
-  OsiSolverInterface * model() const;
-
-  /// Return a pointer to the original model
-  OsiSolverInterface * originalModel() const;
-
-  /// Set the pointer to the original model
-  void setOriginalModel(OsiSolverInterface *model);
-
-  /// Return a pointer to the original columns
-  const int * originalColumns() const;
-
-  /// Return a pointer to the original rows
-  const int * originalRows() const;
-
-  /// Return number of rows in original model
-  inline int getNumRows() const
-  { return nrows_;}
-
-  /// Return number of columns in original model
-  inline int getNumCols() const
-  { return ncols_;}
-
-  /** "Magic" number. If this is non-zero then any elements with this value
-      may change and so presolve is very limited in what can be done
-      to the row and column.  This is for non-linear problems.
-  */
-  inline void setNonLinearValue(double value)
-  { nonLinearValue_ = value;}
-  inline double nonLinearValue() const
-    { return nonLinearValue_;}
-  /*! \brief Fine control over presolve actions
-  
-    Set/clear the following bits to allow or suppress actions:
-      - 0x01 allow duplicate column processing on integer columns
-	     and dual stuff on integers
-      - 0x02 switch off actions which can change +1 to something else
-      	     (doubleton, tripleton, implied free)
-      - 0x04 allow transfer of costs from singletons and between integer
-      	     variables (when advantageous)
-      - 0x08 do not allow x+y+z=1 transform
-      - 0x10 allow actions that don't easily unroll
-      - 0x20 allow dubious gub element reduction
-
-    GUB element reduction is only partially implemented in CoinPresolve (see
-    gubrow_action) and willl cause an abort at postsolve. It's not clear
-    what's meant by `dual stuff on integers'.
-    -- lh, 110605 --
-  */
-  inline void setPresolveActions(int action)
-  { presolveActions_  = (presolveActions_&0xffff0000)|(action&0xffff);}
-
-private:
-  /*! Original model (solver interface loaded with the original problem).
-
-      Must not be destroyed until after postsolve().
-  */
-  OsiSolverInterface * originalModel_;
-
-  /*! Presolved  model (solver interface loaded with the presolved problem)
-  
-    Must be destroyed by the client (using delete) after postsolve().
-  */
-  OsiSolverInterface * presolvedModel_;
-
-  /*! "Magic" number. If this is non-zero then any elements with this value
-      may change and so presolve is very limited in what can be done
-      to the row and column.  This is for non-linear problems.
-      One could also allow for cases where sign of coefficient is known.
-  */
-  double nonLinearValue_;
-
-  /// Original column numbers
-  int * originalColumn_;
-
-  /// Original row numbers
-  int * originalRow_;
-
-  /// The list of transformations applied.
-  const CoinPresolveAction *paction_;
-
-  /*! \brief Number of columns in original model.
-
-    The problem will expand back to its former size as postsolve
-    transformations are applied. It is efficient to allocate data structures
-    for the final size of the problem rather than expand them as needed.
-  */
-  int ncols_;
-
-  /*! \brief Number of rows in original model. */
-  int nrows_;
-
-  /*! \brief Number of nonzero matrix coefficients in the original model. */
-  CoinBigIndex nelems_;
-
-  /** Whether we want to skip dual part of presolve etc.
-      1 bit allows duplicate column processing on integer columns
-      and dual stuff on integers
-      4 transfers costs to integer variables
-  */
-  int presolveActions_;
-  /// Number of major passes
-  int numberPasses_;
-
-protected:
-  /*! \brief Apply presolve transformations to the problem.
-  
-    Handles the core activity of applying presolve transformations.
-    
-    If you want to apply the individual presolve routines differently, or
-    perhaps add your own to the mix, define a derived class and override
-    this method
-  */
-  virtual const CoinPresolveAction *presolve(CoinPresolveMatrix *prob);
-
-  /*! \brief Reverse presolve transformations to recover the solution
-	     to the original problem.
-
-    Handles the core activity of applying postsolve transformations.
-
-    Postsolving is pretty generic; just apply the transformations in reverse
-    order. You will probably only be interested in overriding this method if
-    you want to add code to test for consistency while debugging new presolve
-    techniques.
-  */
-  virtual void postsolve(CoinPostsolveMatrix &prob);
-
-  /*! \brief Destroys queued postsolve actions.
-  
-    <i>E.g.</i>, when presolve() determines the problem is infeasible, so that
-    it will not be necessary to actually solve the presolved problem and
-    convert the result back to the original problem.
-  */
-  void gutsOfDestroy();
-};
-#endif

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

@@ -1,331 +0,0 @@
-// 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 OsiRowCut_H
-#define OsiRowCut_H
-
-#include "CoinPackedVector.hpp"
-
-#include "OsiCollections.hpp"
-#include "OsiCut.hpp"
-
-//#define OSI_INLINE_ROWCUT_METHODS
-#ifdef OSI_INLINE_ROWCUT_METHODS
-#define OsiRowCut_inline inline
-#else
-#define OsiRowCut_inline
-#endif
-
-/** Row Cut Class
-
-A row cut has:
-  <ul>
-  <li>a lower bound<br>
-  <li>an upper bound<br>
-  <li>a vector of row elements
-  </ul>
-*/
-class OsiRowCut : public OsiCut {
-   friend void OsiRowCutUnitTest(const OsiSolverInterface * baseSiP,    
-				 const std::string & mpsDir);
-
-public:
-  
-  /**@name Row bounds */
-  //@{
-    /// Get lower bound
-    OsiRowCut_inline double lb() const;
-    /// Set lower bound
-    OsiRowCut_inline void setLb(double lb);
-    /// Get upper bound
-    OsiRowCut_inline double ub() const;
-    /// Set upper bound
-    OsiRowCut_inline void setUb(double ub);
-  //@}
-
-  /**@name Row rhs, sense, range */
-  //@{
-    /// Get sense ('E', 'G', 'L', 'N', 'R')
-    char sense() const;
-    /// Get right-hand side
-    double rhs() const;
-    /// Get range (ub - lb for 'R' rows, 0 otherwise)
-    double range() const;
-  //@}
-
-  //-------------------------------------------------------------------
-  /**@name Row elements  */
-  //@{
-    /// Set row elements
-    OsiRowCut_inline void setRow( 
-      int size, 
-      const int * colIndices, 
-      const double * elements,
-      bool testForDuplicateIndex = COIN_DEFAULT_VALUE_FOR_DUPLICATE);
-    /// Set row elements from a packed vector
-    OsiRowCut_inline void setRow( const CoinPackedVector & v );
-    /// Get row elements
-    OsiRowCut_inline const CoinPackedVector & row() const;
-    /// Get row elements for changing
-    OsiRowCut_inline CoinPackedVector & mutableRow() ;
-  //@}
-
-  /**@name Comparison operators  */
-  //@{
-#if __GNUC__ != 2 
-    using OsiCut::operator== ;
-#endif
-    /** equal - true if lower bound, upper bound, row elements,
-        and OsiCut are equal.
-    */
-    OsiRowCut_inline bool operator==(const OsiRowCut& rhs) const; 
-
-#if __GNUC__ != 2 
-    using OsiCut::operator!= ;
-#endif
-    /// not equal
-    OsiRowCut_inline bool operator!=(const OsiRowCut& rhs) const; 
-  //@}
-  
-    
-  //----------------------------------------------------------------
-  /**@name Sanity checks on cut */
-  //@{
-    /** Returns true if the cut is consistent.
-        This checks to ensure that:
-        <ul>
-        <li>The row element vector does not have duplicate indices
-        <li>The row element vector indices are >= 0
-        </ul>
-    */
-    OsiRowCut_inline bool consistent() const; 
-
-    /** Returns true if cut is consistent with respect to the solver
-        interface's model.
-        This checks to ensure that
-        <ul>
-        <li>The row element vector indices are < the number of columns
-            in the model
-        </ul>
-    */
-    OsiRowCut_inline bool consistent(const OsiSolverInterface& im) const;
-
-    /** Returns true if the row cut itself is infeasible and cannot be satisfied.       
-        This checks whether
-        <ul>
-        <li>the lower bound is strictly greater than the
-            upper bound.
-        </ul>
-    */
-    OsiRowCut_inline bool infeasible(const OsiSolverInterface &im) const;
-    /** Returns infeasibility of the cut with respect to solution 
-	passed in i.e. is positive if cuts off that solution.  
-	solution is getNumCols() long..
-    */
-    virtual double violated(const double * solution) const;
-  //@}
-
-  /**@name Arithmetic operators. Apply CoinPackedVector methods to the vector */
-  //@{
-    /// add <code>value</code> to every vector entry
-    void operator+=(double value)
-	{ row_ += value; }
-
-    /// subtract <code>value</code> from every vector entry
-    void operator-=(double value)
-	{ row_ -= value; }
-
-    /// multiply every vector entry by <code>value</code>
-    void operator*=(double value)
-	{ row_ *= value; }
-
-    /// divide every vector entry by <code>value</code>
-    void operator/=(double value)
-	{ row_ /= value; }
-  //@}
-
-  /// Allow access row sorting function
-  void sortIncrIndex()
-	{row_.sortIncrIndex();}
-
-  /**@name Constructors and destructors */
-  //@{
-    /// Assignment operator
-    OsiRowCut & operator=( const OsiRowCut& rhs);
-  
-    /// Copy constructor 
-    OsiRowCut ( const OsiRowCut &);  
-
-    /// Clone
-    virtual OsiRowCut * clone() const;
-  
-    /// Default Constructor 
-    OsiRowCut ();
-
-    /** \brief Ownership Constructor
-
-      This constructor assumes ownership of the vectors passed as parameters
-      for indices and elements. \p colIndices and \p elements will be NULL
-      on return.
-    */
-    OsiRowCut(double cutlb, double cutub,
- 		     int capacity, int size,
- 		     int *&colIndices, double *&elements);
-  
-    /// Destructor 
-    virtual ~OsiRowCut ();
-  //@}
-
-  /**@name Debug stuff */
-  //@{
-    /// Print cuts in collection
-  virtual void print() const ;
-  //@}
-   
-private:
-  
- 
-  /**@name Private member data */
-  //@{
-    /// Row elements
-    CoinPackedVector row_;
-    /// Row lower bound
-    double lb_;
-    /// Row upper bound
-    double ub_;
-  //@}
-};
-
-#ifdef OSI_INLINE_ROWCUT_METHODS
-
-//-------------------------------------------------------------------
-// Set/Get lower & upper bounds
-//-------------------------------------------------------------------
-double OsiRowCut::lb() const { return lb_; }
-void OsiRowCut::setLb(double lb) { lb_ = lb; }
-double OsiRowCut::ub() const { return ub_; }
-void OsiRowCut::setUb(double ub) { ub_ = ub; }
-
-//-------------------------------------------------------------------
-// Set row elements
-//------------------------------------------------------------------- 
-void OsiRowCut::setRow(int size, 
-		       const int * colIndices, const double * elements)
-{
-  row_.setVector(size,colIndices,elements);
-}
-void OsiRowCut::setRow( const CoinPackedVector & v )
-{
-  row_ = v;
-}
-
-//-------------------------------------------------------------------
-// Get the row
-//-------------------------------------------------------------------
-const CoinPackedVector & OsiRowCut::row() const 
-{ 
-  return row_; 
-}
-
-//-------------------------------------------------------------------
-// Get the row so we can change
-//-------------------------------------------------------------------
-CoinPackedVector & OsiRowCut::mutableRow() 
-{ 
-  return row_; 
-}
-
-//----------------------------------------------------------------
-// == operator 
-//-------------------------------------------------------------------
-bool
-OsiRowCut::operator==(const OsiRowCut& rhs) const
-{
-  if ( this->OsiCut::operator!=(rhs) ) return false;
-  if ( row() != rhs.row() ) return false;
-  if ( lb() != rhs.lb() ) return false;
-  if ( ub() != rhs.ub() ) return false;
-  return true;
-}
-bool
-OsiRowCut::operator!=(const OsiRowCut& rhs) const
-{
-  return !( (*this)==rhs );
-}
-
-
-//----------------------------------------------------------------
-// consistent & infeasible 
-//-------------------------------------------------------------------
-bool OsiRowCut::consistent() const
-{
-  const CoinPackedVector & r=row();
-  r.duplicateIndex("consistent", "OsiRowCut");
-  if ( r.getMinIndex() < 0 ) return false;
-  return true;
-}
-bool OsiRowCut::consistent(const OsiSolverInterface& im) const
-{  
-  const CoinPackedVector & r=row();
-  if ( r.getMaxIndex() >= im.getNumCols() ) return false;
-
-  return true;
-}
-bool OsiRowCut::infeasible(const OsiSolverInterface &im) const
-{
-  if ( lb() > ub() ) return true;
-
-  return false;
-}
-
-#endif
-
-/** Row Cut Class which refers back to row which created it.
-    It may be useful to strengthen a row rather than add a cut.  To do this
-    we need to know which row is strengthened.  This trivial extension
-    to OsiRowCut does that.
-
-*/
-class OsiRowCut2 : public OsiRowCut {
-
-public:
-  
-  /**@name Which row */
-  //@{
-  /// Get row
-  inline int whichRow() const
-  { return whichRow_;}
-  /// Set row
-  inline void setWhichRow(int row)
-  { whichRow_=row;}
-  //@}
-  
-  /**@name Constructors and destructors */
-  //@{
-  /// Assignment operator
-  OsiRowCut2 & operator=( const OsiRowCut2& rhs);
-  
-  /// Copy constructor 
-  OsiRowCut2 ( const OsiRowCut2 &);  
-  
-  /// Clone
-  virtual OsiRowCut * clone() const;
-  
-  /// Default Constructor 
-  OsiRowCut2 (int row=-1);
-  
-  /// Destructor 
-  virtual ~OsiRowCut2 ();
-  //@}
-
-private:
-  
- 
-  /**@name Private member data */
-  //@{
-  /// Which row
-  int whichRow_;
-  //@}
-};
-#endif