ruby-cbc 0.1.9

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

@@ -0,0 +1,324 @@
+// 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 OsiColCut_H
+#define OsiColCut_H
+
+#include <string>
+
+#include "CoinPackedVector.hpp"
+
+#include "OsiCollections.hpp"
+#include "OsiCut.hpp"
+
+/** Column Cut Class
+
+Column Cut Class has:
+  <ul>
+  <li>a sparse vector of column lower bounds
+  <li>a sparse vector of column upper bounds
+  </ul>
+*/
+class OsiColCut : public OsiCut {
+   friend void OsiColCutUnitTest(const OsiSolverInterface * baseSiP, 
+				 const std::string & mpsDir);
+  
+public:
+  
+  //----------------------------------------------------------------
+  
+  /**@name Setting column bounds */
+  //@{
+  /// Set column lower bounds 
+  inline void setLbs( 
+    int nElements, 
+    const int * colIndices, 
+    const double * lbElements );   
+  
+  /// Set column lower bounds from a packed vector
+  inline void setLbs( const CoinPackedVector & lbs );
+  
+  /// Set column upper bounds 
+  inline void setUbs( 
+    int nElements, 
+    const int * colIndices, 
+    const double * ubElements );
+  
+  /// Set column upper bounds from a packed vector
+  inline void setUbs( const CoinPackedVector & ubs );
+  //@}
+  
+  //----------------------------------------------------------------
+  
+  /**@name Getting column bounds */
+  //@{
+  /// Get column lower bounds
+  inline const CoinPackedVector & lbs() const;
+  /// Get column upper bounds
+  inline const CoinPackedVector & ubs() const;
+  //@}
+  
+  /**@name Comparison operators  */
+  //@{
+#if __GNUC__ != 2 
+  using OsiCut::operator== ;
+#endif
+  /** equal - true if lower bounds, upper bounds, 
+  and OsiCut are equal.
+  */
+  inline virtual bool operator==(const OsiColCut& rhs) const; 
+
+#if __GNUC__ != 2 
+  using OsiCut::operator!= ;
+#endif
+  /// not equal
+  inline virtual bool operator!=(const OsiColCut& rhs) const; 
+  //@}
+  
+  
+  //----------------------------------------------------------------
+  
+  /**@name Sanity checks on cut */
+  //@{
+  /** Returns true if the cut is consistent with respect to itself.
+  This checks to ensure that:
+  <ul>
+  <li>The bound vectors do not have duplicate indices,
+  <li>The bound vectors indices are >=0
+  </ul>
+  */
+  inline virtual bool consistent() const; 
+  
+  /** Returns true if cut is consistent with respect to the solver  
+  interface's model. This checks to ensure that
+  the lower & upperbound packed vectors:
+  <ul>
+  <li>do not have an index >= the number of column is the model.
+  </ul>
+  */
+  inline virtual bool consistent(const OsiSolverInterface& im) const;
+  
+  /** Returns true if the cut is infeasible with respect to its bounds and the 
+  column bounds in the solver interface's models.
+  This checks whether:
+  <ul>
+  <li>the maximum of the new and existing lower bounds is strictly 
+  greater than the minimum of the new and existing upper bounds.
+</ul>
+  */
+  inline virtual 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 Constructors and destructors */
+  //@{
+  /// Assignment operator 
+  OsiColCut & operator=( const OsiColCut& rhs);
+  
+  /// Copy constructor 
+  OsiColCut ( const OsiColCut &);
+  
+  /// Default Constructor 
+  OsiColCut ();
+  
+  /// Clone
+  virtual OsiColCut * clone() const;
+  
+  /// Destructor 
+  virtual ~OsiColCut ();
+  //@}
+  
+  /**@name Debug stuff */
+  //@{
+    /// Print cuts in collection
+  virtual void print() const;
+  //@}
+   
+private:
+  
+  /**@name Private member data */
+  //@{
+  /// Lower bounds
+  CoinPackedVector lbs_;
+  /// Upper bounds
+  CoinPackedVector ubs_;
+  //@}
+  
+};
+
+
+
+//-------------------------------------------------------------------
+// Set lower & upper bound vectors
+//------------------------------------------------------------------- 
+void OsiColCut::setLbs( 
+                       int size, 
+                       const int * colIndices, 
+                       const double * lbElements )
+{
+  lbs_.setVector(size,colIndices,lbElements);
+}
+//
+void OsiColCut::setUbs( 
+                       int size, 
+                       const int * colIndices, 
+                       const double * ubElements )
+{
+  ubs_.setVector(size,colIndices,ubElements);
+}
+//
+void OsiColCut::setLbs( const CoinPackedVector & lbs )
+{
+  lbs_ = lbs;
+}
+//
+void OsiColCut::setUbs( const CoinPackedVector & ubs )
+{
+  ubs_ = ubs;
+}
+
+//-------------------------------------------------------------------
+// Get Column Lower Bounds and Column Upper Bounds
+//-------------------------------------------------------------------
+const CoinPackedVector & OsiColCut::lbs() const 
+{ 
+  return lbs_; 
+}
+//
+const CoinPackedVector & OsiColCut::ubs() const 
+{ 
+  return ubs_; 
+}
+
+//----------------------------------------------------------------
+// == operator 
+//-------------------------------------------------------------------
+bool
+OsiColCut::operator==(
+                      const OsiColCut& rhs) const
+{
+  if ( this->OsiCut::operator!=(rhs) ) 
+    return false;
+  if ( lbs() != rhs.lbs() ) 
+    return false;
+  if ( ubs() != rhs.ubs() ) 
+    return false;
+  return true;
+}
+//
+bool
+OsiColCut::operator!=(
+                      const OsiColCut& rhs) const
+{
+  return !( (*this)==rhs );
+}
+
+//----------------------------------------------------------------
+// consistent & infeasible 
+//-------------------------------------------------------------------
+bool OsiColCut::consistent() const
+{
+  const CoinPackedVector & lb = lbs();
+  const CoinPackedVector & ub = ubs();
+  // Test for consistent cut.
+  // Are packed vectors consistent?
+  lb.duplicateIndex("consistent", "OsiColCut");
+  ub.duplicateIndex("consistent", "OsiColCut");
+  if ( lb.getMinIndex() < 0 ) return false;
+  if ( ub.getMinIndex() < 0 ) return false;
+  return true;
+}
+//
+bool OsiColCut::consistent(const OsiSolverInterface& im) const
+{  
+  const CoinPackedVector & lb = lbs();
+  const CoinPackedVector & ub = ubs();
+  
+  // Test for consistent cut.
+  if ( lb.getMaxIndex() >= im.getNumCols() ) return false;
+  if ( ub.getMaxIndex() >= im.getNumCols() ) return false;
+  
+  return true;
+}
+
+#if 0
+bool OsiColCut::feasible(const OsiSolverInterface &im) const
+{
+  const double * oldColLb = im.getColLower();
+  const double * oldColUb = im.getColUpper();
+  const CoinPackedVector & cutLbs = lbs();
+  const CoinPackedVector & cutUbs = ubs();
+  int i;
+  
+  for ( i=0; i<cutLbs.size(); i++ ) {
+    int colIndx = cutLbs.indices()[i];
+    double newLb;
+    if ( cutLbs.elements()[i] > oldColLb[colIndx] )
+      newLb = cutLbs.elements()[i];
+    else
+      newLb = oldColLb[colIndx];
+
+    double newUb = oldColUb[colIndx];
+    if ( cutUbs.indexExists(colIndx) )
+      if ( cutUbs[colIndx] < newUb ) newUb = cutUbs[colIndx];
+      if ( newLb > newUb ) 
+        return false;
+  }
+  
+  for ( i=0; i<cutUbs.size(); i++ ) {
+    int colIndx = cutUbs.indices()[i];
+    double newUb = cutUbs.elements()[i] < oldColUb[colIndx] ? cutUbs.elements()[i] : oldColUb[colIndx];
+    double newLb = oldColLb[colIndx];
+    if ( cutLbs.indexExists(colIndx) )
+      if ( cutLbs[colIndx] > newLb ) newLb = cutLbs[colIndx];
+      if ( newUb < newLb ) 
+        return false;
+  }
+  
+  return true;
+}
+#endif 
+
+
+bool OsiColCut::infeasible(const OsiSolverInterface &im) const
+{
+  const double * oldColLb = im.getColLower();
+  const double * oldColUb = im.getColUpper();
+  const CoinPackedVector & cutLbs = lbs();
+  const CoinPackedVector & cutUbs = ubs();
+  int i;
+  
+  for ( i=0; i<cutLbs.getNumElements(); i++ ) {
+    int colIndx = cutLbs.getIndices()[i];
+    double newLb= cutLbs.getElements()[i] > oldColLb[colIndx] ?
+       cutLbs.getElements()[i] : oldColLb[colIndx];
+
+    double newUb = oldColUb[colIndx];
+    if ( cutUbs.isExistingIndex(colIndx) )
+      if ( cutUbs[colIndx] < newUb ) newUb = cutUbs[colIndx];
+      if ( newLb > newUb ) 
+        return true;
+  }
+  
+  for ( i=0; i<cutUbs.getNumElements(); i++ ) {
+    int colIndx = cutUbs.getIndices()[i];
+    double newUb = cutUbs.getElements()[i] < oldColUb[colIndx] ?
+       cutUbs.getElements()[i] : oldColUb[colIndx];
+    double newLb = oldColLb[colIndx];
+    if ( cutLbs.isExistingIndex(colIndx) )
+      if ( cutLbs[colIndx] > newLb ) newLb = cutLbs[colIndx];
+      if ( newUb < newLb ) 
+        return true;
+  }
+  
+  return false;
+}
+
+#endif

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

@@ -0,0 +1,35 @@
+// 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 OsiCollections_H
+#define OsiCollections_H
+
+#include <vector>
+
+//Forward declarations
+class OsiColCut;
+class OsiRowCut;
+class OsiCut;
+
+
+
+/* Collection Classes */
+
+/**@name Typedefs for Standard Template Library collections of Osi Objects. */
+//@{
+/// Vector of int
+typedef std::vector<int>    OsiVectorInt;
+/// Vector of double
+typedef std::vector<double> OsiVectorDouble;
+/// Vector of OsiColCut pointers
+typedef std::vector<OsiColCut *> OsiVectorColCutPtr;
+/// Vector of OsiRowCut pointers
+typedef std::vector<OsiRowCut *> OsiVectorRowCutPtr;
+/// Vector of OsiCut pointers
+typedef std::vector<OsiCut *>    OsiVectorCutPtr;
+//@}
+
+
+
+#endif

data/ext/ruby-cbc/install/include/coin/OsiConfig.h

@@ -0,0 +1,19 @@
+/* src/Osi/config_osi.h.  Generated by configure.  */
+/* src/Osi/config_osi.h.in. */
+
+#ifndef __CONFIG_OSI_H__
+#define __CONFIG_OSI_H__
+
+/* Version number of project */
+#define OSI_VERSION "0.107.6"
+
+/* Major Version number of project */
+#define OSI_VERSION_MAJOR 0
+
+/* Minor Version number of project */
+#define OSI_VERSION_MINOR 107
+
+/* Release Version number of project */
+#define OSI_VERSION_RELEASE 6
+
+#endif

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

@@ -0,0 +1,245 @@
+// 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 OsiCut_H
+#define OsiCut_H
+
+#include "OsiCollections.hpp"
+#include "OsiSolverInterface.hpp"
+
+/** Base Class for cut.
+
+The Base cut class contains:
+  <ul>
+  <li>a measure of the cut's effectivness
+  </ul>
+*/
+
+/*
+  COIN_NOTEST_DUPLICATE is rooted in CoinUtils. Check there before you
+  meddle here.
+*/
+#ifdef COIN_FAST_CODE
+#ifndef COIN_NOTEST_DUPLICATE
+#define COIN_NOTEST_DUPLICATE
+#endif
+#endif
+
+#ifndef COIN_NOTEST_DUPLICATE
+#define COIN_DEFAULT_VALUE_FOR_DUPLICATE true
+#else
+#define COIN_DEFAULT_VALUE_FOR_DUPLICATE false
+#endif
+
+
+class OsiCut  {
+  
+public:
+    
+  //-------------------------------------------------------------------
+  /**@name Effectiveness */
+  //@{
+  /// Set effectiveness
+  inline void setEffectiveness( double e ); 
+  /// Get effectiveness
+  inline double effectiveness() const; 
+  //@}
+
+  /**@name GloballyValid */
+  //@{
+  /// Set globallyValid (nonzero true)
+  inline void setGloballyValid( bool trueFalse ) 
+  { globallyValid_=trueFalse ? 1 : 0;}
+  inline void setGloballyValid( ) 
+  { globallyValid_=1;}
+  inline void setNotGloballyValid( ) 
+  { globallyValid_=0;}
+  /// Get globallyValid
+  inline bool globallyValid() const
+  { return globallyValid_!=0;}
+  /// Set globallyValid as integer (nonzero true)
+  inline void setGloballyValidAsInteger( int trueFalse ) 
+  { globallyValid_=trueFalse;}
+  /// Get globallyValid
+  inline int globallyValidAsInteger() const
+  { return globallyValid_;}
+  //@}
+
+  /**@name Debug stuff */
+  //@{
+    /// Print cuts in collection
+  virtual void print() const {}
+  //@}
+   
+#if 0
+  / **@name Times used */
+  / /@{
+  / // Set times used
+  inline void setTimesUsed( int t );
+  / // Increment times used
+  inline void incrementTimesUsed();
+  / // Get times used
+  inline int timesUsed() const;
+  / /@}
+  
+  / **@name Times tested */
+  / /@{
+  / // Set times tested
+  inline void setTimesTested( int t );
+  / // Increment times tested
+  inline void incrementTimesTested();
+  / // Get times tested
+  inline int timesTested() const;
+  / /@}
+#endif
+
+  //----------------------------------------------------------------
+
+  /**@name Comparison operators  */
+  //@{
+    ///equal. 2 cuts are equal if there effectiveness are equal
+    inline virtual bool operator==(const OsiCut& rhs) const; 
+    /// not equal
+    inline virtual bool operator!=(const OsiCut& rhs) const; 
+    /// less than. True if this.effectiveness < rhs.effectiveness
+    inline virtual bool operator< (const OsiCut& rhs) const; 
+    /// less than. True if this.effectiveness > rhs.effectiveness
+    inline virtual bool operator> (const OsiCut& rhs) const; 
+  //@}
+
+  //----------------------------------------------------------------
+  // consistent() - returns true if the cut is consistent with repect to itself.
+  //         This might include checks to ensure that a packed vector
+  //         itself does not have a negative index.
+  // consistent(const OsiSolverInterface& si) - returns true if cut is consistent with
+  //         respect to the solver interface's model. This might include a check to 
+  //         make sure a column index is not greater than the number
+  //         of columns in the problem.
+  // infeasible(const OsiSolverInterface& si) - returns true if the cut is infeasible 
+  //         "with respect to itself". This might include a check to ensure 
+  //         the lower bound is greater than the upper bound, or if the
+  //         cut simply replaces bounds that the new bounds are feasible with 
+  //         respect to the old bounds.
+  //-----------------------------------------------------------------
+  /**@name Sanity checks on cut */
+  //@{
+  /** Returns true if the cut is consistent with respect to itself,
+      without considering any
+      data in the model. For example, it might check to ensure
+      that a column index is not negative.
+  */
+  inline virtual bool consistent() const=0; 
+
+  /** Returns true if cut is consistent when considering the solver
+      interface's model.  For example, it might check to ensure
+      that a column index is not greater than the number of columns
+      in the model. Assumes consistent() is true.
+  */
+  inline virtual bool consistent(const OsiSolverInterface& si) const=0;
+
+  /** Returns true if the cut is infeasible "with respect to itself" and
+      cannot be satisfied. This method does NOT check whether adding the
+      cut to the solver interface's model will make the -model- infeasble.
+      A cut which returns !infeasible(si) may very well make the model
+      infeasible. (Of course, adding a cut with returns infeasible(si) 
+      will make the model infeasible.)
+
+      The "with respect to itself" is in quotes becaues 
+      in the case where the cut
+      simply replaces existing bounds, it may make
+      sense to test infeasibility with respect to the current bounds
+      held in the solver interface's model. For example, if the cut 
+      has a single variable in it, it might check that the maximum
+      of new and existing lower bounds is greater than the minium of 
+      the new and existing upper bounds.
+
+      Assumes that consistent(si) is true.<br>
+      Infeasible cuts can be a useful mechanism for a cut generator to
+      inform the solver interface that its detected infeasibility of the
+      problem.
+  */
+  inline virtual bool infeasible(const OsiSolverInterface &si) const=0;
+
+  /** 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=0;
+  //@}
+
+protected:
+
+  /**@name Constructors and destructors */
+  //@{
+  /// Default Constructor 
+  OsiCut ();
+  
+  /// Copy constructor 
+  OsiCut ( const OsiCut &);
+   
+  /// Assignment operator 
+  OsiCut & operator=( const OsiCut& rhs);
+
+  /// Destructor 
+  virtual ~OsiCut ();
+  //@}
+  
+private:
+  
+  /**@name Private member data */
+  //@{
+  /// Effectiveness
+  double effectiveness_;
+  /// If cut has global validity i.e. can be used anywhere in tree
+  int globallyValid_;
+#if 0
+  /// Times used
+  int timesUsed_;
+  /// Times tested
+  int timesTested_;
+#endif
+  //@}
+};
+
+
+//-------------------------------------------------------------------
+// Set/Get member data
+//-------------------------------------------------------------------
+void OsiCut::setEffectiveness(double e)  { effectiveness_=e; }
+double OsiCut::effectiveness() const { return effectiveness_; }
+
+#if 0
+void OsiCut::setTimesUsed( int t ) { timesUsed_=t; }
+void OsiCut::incrementTimesUsed() { timesUsed_++; }
+int OsiCut::timesUsed() const { return timesUsed_; }
+
+void OsiCut::setTimesTested( int t ) { timesTested_=t; }
+void OsiCut::incrementTimesTested() { timesTested_++; }
+int OsiCut::timesTested() const{ return timesTested_; }
+#endif
+
+//----------------------------------------------------------------
+// == operator 
+//-------------------------------------------------------------------
+bool
+OsiCut::operator==(const OsiCut& rhs) const
+{
+  return effectiveness()==rhs.effectiveness();
+}
+bool
+OsiCut::operator!=(const OsiCut& rhs) const
+{
+  return !( (*this)==rhs );
+}
+bool
+OsiCut::operator< (const OsiCut& rhs) const
+{
+  return effectiveness()<rhs.effectiveness();
+}
+bool
+OsiCut::operator> (const OsiCut& rhs) const
+{
+  return effectiveness()>rhs.effectiveness();
+}
+#endif