ruby-cbc 0.1.9 → 0.2.1

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

@@ -1,324 +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 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

@@ -1,35 +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 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

@@ -1,19 +0,0 @@
-/* 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

@@ -1,245 +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 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