ruby-cbc 0.1.9

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

@@ -0,0 +1,272 @@
+// Name:     CglRedSplitParam.hpp
+// Author:   Francois Margot
+//           Tepper School of Business
+//           Carnegie Mellon University, Pittsburgh, PA 15213
+//           email: fmargot@andrew.cmu.edu
+// Date:     11/24/06
+//
+// $Id: CglRedSplitParam.hpp 1122 2013-04-06 20:39:53Z stefan $
+//-----------------------------------------------------------------------------
+// Copyright (C) 2006, Francois Margot and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef CglRedSplitParam_H
+#define CglRedSplitParam_H
+
+#include "CglParam.hpp"
+
+
+  /**@name CglRedSplit Parameters */
+  //@{
+
+  /** Class collecting parameters the Reduced-and-split cut generator.
+
+      Parameters of the generator are listed below. Modifying the default 
+      values for parameters other than the last four might result in 
+      invalid cuts.
+
+      - LUB: Value considered large for the absolute value of a lower or upper
+             bound on a variable. See method setLUB().
+      - MAXDYN: Maximum ratio between largest and smallest non zero 
+                coefficients in a cut. See method setMAXDYN().
+      - MAXDYN_LUB: Maximum ratio between largest and smallest non zero 
+                    coefficients in a cut involving structural variables with
+		    lower or upper bound in absolute value larger than LUB.
+                    Should logically be larger or equal to MAXDYN.
+                    See method setMAXDYN_LUB().
+      - EPS_ELIM: Precision for deciding if a coefficient is zero when 
+                  eliminating slack variables. See method setEPS_ELIM().
+      - EPS_COEFF_LUB: Precision for deciding if a coefficient of a 
+                       generated cut is zero when the corresponding 
+                       variable has a lower or upper bound larger than 
+                       LUB in absolute value. See method setEPS_COEFF_LUB().
+      - MINVIOL: Minimum violation for the current basic solution in 
+                 a generated cut. See method setMINVIOL().
+      - USE_INTSLACKS: Use integer slacks to generate cuts. (not implemented).
+                       See method setUSE_INTSLACKS().
+      - USE_CG2: Use alternative formula to generate a mixed integer Gomory
+                 cut (see methods CglRedSPlit::generate_cgcut() 
+                 and CglRedSPlit::generate_cgcut_2()). See method setUSE_CG2().
+      - normIsZero: Norm of a vector is considered zero if smaller than
+                    this value. See method setNormIsZero(). 
+      - minReduc: Reduction is performed only if the norm of the vector is
+                  reduced by this fraction. See method setMinReduc().
+      - away: Look only at basic integer variables whose current value
+              is at least this value from being integer. See method setAway().
+      - maxTab: Controls the number of rows selected for the generation. See
+                method setMaxTab().
+  */
+  //@}
+
+class CglRedSplitParam : public CglParam {
+
+public:
+
+  /**@name Set/get methods */
+  //@{
+  /** Set away, the minimum distance from being integer used for selecting 
+      rows for cut generation;  all rows whose pivot variable should be 
+      integer but is more than away from integrality will be selected; 
+      Default: 0.05 */
+  virtual void setAway(const double value);
+  /// Get value of away
+  inline double getAway() const {return away_;}
+
+ /** Set the value of LUB, value considered large for the absolute value of
+      a lower or upper bound on a variable;
+      Default: 1000 */
+  virtual void setLUB(const double value);
+  /** Get the value of LUB */
+  inline double getLUB() const {return LUB;}
+
+  /** Set the value of EPS_ELIM, epsilon for values of coefficients when 
+      eliminating slack variables;
+      Default: 1e-12 */
+  void setEPS_ELIM(const double value);
+  /** Get the value of EPS_ELIM */
+  double getEPS_ELIM() const {return EPS_ELIM;}
+  
+  /** Set EPS_RELAX_ABS */
+  virtual void setEPS_RELAX_ABS(const double eps_ra);
+  /** Get value of EPS_RELAX_ABS */
+  inline double getEPS_RELAX_ABS() const {return EPS_RELAX_ABS;}
+
+  /** Set EPS_RELAX_REL */
+  virtual void setEPS_RELAX_REL(const double eps_rr);
+  /** Get value of EPS_RELAX_REL */
+  inline double getEPS_RELAX_REL() const {return EPS_RELAX_REL;}
+
+  // Set the maximum ratio between largest and smallest non zero 
+  // coefficients in a cut. Default: 1e8.
+  virtual void setMAXDYN(double value);
+  /** Get the value of MAXDYN */
+  inline double getMAXDYN() const {return MAXDYN_LUB;}
+
+  // Set the maximum ratio between largest and smallest non zero 
+  // coefficient in a cut involving structural variables with
+  // lower or upper bound in absolute value larger than LUB.
+  // Should logically be larger or equal to MAXDYN. Default: 1e13.
+  virtual void setMAXDYN_LUB(double value);
+  /** Get the value of MAXDYN_LUB */
+  inline double getMAXDYN_LUB() const {return MAXDYN_LUB;}
+
+  /** Set the value of EPS_COEFF_LUB, epsilon for values of coefficients for 
+      variables with absolute value of lower or upper bound larger than LUB;
+      Default: 1e-13 */
+  virtual void setEPS_COEFF_LUB(const double value);
+  /** Get the value of EPS_COEFF_LUB */
+  inline double getEPS_COEFF_LUB() const {return EPS_COEFF_LUB;}
+
+  /** Set the value of MINVIOL, the minimum violation for the current 
+      basic solution in a generated cut. Default: 1e-7 */
+  virtual void setMINVIOL(double value);
+  /** Get the value of MINVIOL */
+  inline double getMINVIOL() const {return MINVIOL;}
+
+  /** Set the value of USE_INTSLACKS. Default: 0 */
+  virtual void setUSE_INTSLACKS(int value);
+  /** Get the value of USE_INTSLACKS */
+  inline int getUSE_INTSLACKS() const {return USE_INTSLACKS;}
+
+  /** Set the value of USE_CG2. Default: 0 */
+  virtual void setUSE_CG2(int value);
+  /** Get the value of USE_CG2 */
+  inline int getUSE_CG2() const {return USE_CG2;}
+
+  /** Set the value of normIsZero, the threshold for considering a norm to be 
+      0; Default: 1e-5 */
+  virtual void setNormIsZero(const double value);
+  /** Get the value of normIsZero */
+  inline double getNormIsZero() const {return normIsZero;}
+
+  /** Set the value of minReduc, threshold for relative norm improvement for
+   performing  a reduction; Default: 0.05 */
+  virtual void setMinReduc(const double value);
+  /// Get the value of minReduc
+  inline double getMinReduc() const {return minReduc;}
+
+  /** Set the maximum allowed value for (mTab * mTab * CoinMax(mTab, nTab)) where 
+      mTab is the number of rows used in the combinations and nTab is the 
+      number of continuous non basic variables. The work of the generator is 
+      proportional to (mTab * mTab * CoinMax(mTab, nTab)). Reducing the value of 
+      maxTab makes the generator faster, but weaker. Default: 1e7. */
+  virtual void setMaxTab(const double value);
+  /// Get the value of maxTab
+  inline double getMaxTab() const {return maxTab_;}
+  //@}
+
+  /**@name Constructors and destructors */
+  //@{
+  /// Default constructor 
+  CglRedSplitParam(const double lub = 1000.0,
+		   const double eps_elim = 1e-12,
+		   const double eps_relax_abs = 1e-8,
+		   const double eps_relax_rel = 0.0,
+		   const double max_dyn = 1e8,
+		   const double max_dyn_lub = 1e13,
+		   const double eps_coeff_lub = 1e-13,
+		   const double min_viol = 1e-7,
+		   const int use_int_slacks = 0,
+		   const int use_cg2 = 0,
+		   const double norm_zero = 1e-5,
+		   const double min_reduc = 0.05,
+		   const double away = 0.05,
+		   const double max_tab = 1e7);
+
+   /// Constructor from CglParam
+  CglRedSplitParam(const CglParam &source,
+		   const double lub = 1000.0,
+		   const double eps_elim = 1e-12,
+		   const double eps_relax_abs = 1e-8,
+		   const double eps_relax_rel = 0.0,
+		   const double max_dyn = 1e8,
+		   const double max_dyn_lub = 1e13,
+		   const double eps_coeff_lub = 1e-13,
+		   const double min_viol = 1e-7,
+		   const int use_int_slacks = 0,
+		   const int use_cg2 = 0,
+		   const double norm_zero = 1e-5,
+		   const double min_reduc = 0.05,
+		   const double away = 0.05,
+		   const double max_tab = 1e7);
+
+  /// Copy constructor 
+  CglRedSplitParam(const CglRedSplitParam &source);
+
+  /// Clone
+  virtual CglRedSplitParam* clone() const;
+
+  /// Assignment operator 
+  virtual CglRedSplitParam& operator=(const CglRedSplitParam &rhs);
+
+  /// Destructor 
+  virtual ~CglRedSplitParam();
+  //@}
+
+protected:
+
+  /**@name Parameters */
+  //@{
+
+  /** Value considered large for the absolute value of lower or upper 
+      bound on a variable. Default: 1000. */
+  double LUB;
+
+  /** Epsilon for value of coefficients when eliminating slack variables. 
+      Default: 1e-12. */
+   double EPS_ELIM;
+
+  /** Value added to the right hand side of each generated cut to relax it.
+      Default: 1e-8 */
+  double EPS_RELAX_ABS;
+
+  /** For a generated cut with right hand side rhs_val, 
+      EPS_RELAX_EPS * fabs(rhs_val) is used to relax the constraint.
+      Default: 0 */
+  double EPS_RELAX_REL;
+
+  // Maximum ratio between largest and smallest non zero 
+  // coefficients in a cut. Default: 1e8.
+  double MAXDYN;
+
+  // Maximum ratio between largest and smallest non zero 
+  // coefficients in a cut involving structural variables with
+  // lower or upper bound in absolute value larger than LUB.
+  // Should logically be larger or equal to MAXDYN. Default: 1e13.
+  double MAXDYN_LUB;
+
+  /// Epsilon for value of coefficients for variables with absolute value of
+  /// lower or upper bound larger than LUB. Default: 1e-13.
+  double EPS_COEFF_LUB;
+
+  /// Minimum violation for the current basic solution in a generated cut.
+  /// Default: 1e-7.
+  double MINVIOL;
+
+  /// Use integer slacks to generate cuts if USE_INTSLACKS = 1. Default: 0.
+  int USE_INTSLACKS;
+
+  /// Use second way to generate a mixed integer Gomory cut 
+  /// (see methods generate_cgcut()) and generate_cgcut_2()). Default: 0.
+  int USE_CG2;
+
+  /// Norm of a vector is considered zero if smaller than normIsZero;
+  /// Default: 1e-5.
+  double normIsZero;
+
+  /// Minimum reduction in percent that must be achieved by a potential 
+  /// reduction step in order to be performed; Between 0 and 1, default: 0.05.
+  double minReduc;
+
+  /// Use row only if pivot variable should be integer but is more 
+  /// than away_ from being integer.
+  double away_;
+  
+  /// Maximum value for (mTab * mTab * CoinMax(mTab, nTab)). See method 
+  /// setMaxTab().
+  double maxTab_;
+
+  //@}
+};
+
+#endif

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

@@ -0,0 +1,240 @@
+// LAST EDIT: 
+//-----------------------------------------------------------------------------
+// Implementation of Residual Capacity Inequalities
+// Francisco Barahona (barahon@us.ibm.com)
+//         
+// date: May 18, 2006
+//-----------------------------------------------------------------------------
+// Copyright (C) 2004, International Business Machines Corporation and others. 
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+
+#ifndef CglResidualCapacity_H
+#define CglResidualCapacity_H
+
+#include <iostream>
+#include <fstream>
+//#include <vector>
+
+#include "CoinError.hpp"
+
+#include "CglCutGenerator.hpp"
+
+//=============================================================================
+
+#ifndef CGL_DEBUG
+#define CGL_DEBUG 0
+#endif
+
+//=============================================================================
+
+
+
+
+//=============================================================================
+
+/** Residual Capacity Inequalities Cut Generator Class
+
+ References: 
+    T Magnanti, P Mirchandani, R Vachani,
+    "The convex hull of two core capacitated network design problems,"
+    Math Programming 60 (1993), 233-250.
+    
+    A Atamturk, D Rajan,
+    "On splittable and unsplittable flow capacitated network design 
+    arc-set polyhedra," Math Programming 92 (2002), 315-333. **/
+
+class CglResidualCapacity : public CglCutGenerator {
+    
+    friend void CglResidualCapacityUnitTest(const OsiSolverInterface * siP,
+					    const std::string mpdDir );
+    
+    
+private:
+    //---------------------------------------------------------------------------
+    // Enumeration constants that describe the various types of rows
+    enum RowType {
+	/**   row of the type a_1 c_1 +  + a_k c_k - d z_1 -  - d z_p <= b,
+	      where c_i are continuous variables and z_j are integer variables
+	*/
+	ROW_L,
+	/**  row of the type -a_1 c_1 -  - a_k c_k + d z_1 +  + d z_p >= b,
+	     where c_i are continuous variables and z_j are integer variables
+	*/
+	ROW_G,
+	/** equation that can be treated as ROW_L and ROW_G
+	 */
+	ROW_BOTH,
+	/** Other types of rows
+	 */
+	ROW_OTHER
+    };
+    
+    
+public:
+    /**@name Get and Set Parameters */
+    //@{
+    /// Set Epsilon
+    void setEpsilon(double value);
+    /// Get Epsilon
+    double getEpsilon() const;
+    /// Set Tolerance
+    void setTolerance(double value);
+    /// Get Tolerance
+    double getTolerance() const;
+    /// Set doPreproc
+    void setDoPreproc(int value);
+    /// Get doPreproc
+    bool getDoPreproc() const;
+    //@}
+
+    /**@name Generate Cuts */
+    //@{
+    /** Generate Residual Capacity cuts for the model data 
+	contained in si. The generated cuts are inserted 
+	in the collection of cuts cs. 
+    */
+    virtual void generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
+			      const CglTreeInfo info = CglTreeInfo());
+    //@}
+    
+    //---------------------------------------------------------------------------
+    /**@name Constructors and destructors */
+    //@{
+    /// Default constructor 
+    CglResidualCapacity ();
+    
+    /// Alternate Constructor 
+    CglResidualCapacity ( const double tolerance );
+    
+    /// Copy constructor 
+    CglResidualCapacity (
+			 const CglResidualCapacity &);
+    
+    /// Clone
+    virtual CglCutGenerator * clone() const;
+    
+    /// Assignment operator 
+    CglResidualCapacity &
+    operator=(
+	      const CglResidualCapacity& rhs);
+    
+    /// Destructor 
+    virtual
+    ~CglResidualCapacity ();
+    /// This is to refresh preprocessing
+    virtual void refreshPrep();
+    //@}
+    
+    
+    
+private:
+    //--------------------------------------------------------------------------
+    // Private member methods
+    
+    // Construct
+    void gutsOfConstruct ( const double tolerance);
+    
+    // Delete
+    void gutsOfDelete();
+    
+    // Copy
+    void gutsOfCopy (const CglResidualCapacity& rhs);
+    
+    // Do preprocessing.
+    // It determines the type of each row. 
+    // It may change sense and RHS for ranged rows
+    void resCapPreprocess(const OsiSolverInterface& si);
+    
+    // Determine the type of a given row.
+    RowType determineRowType(const OsiSolverInterface& si,
+			     const int rowLen, const int* ind, 
+			     const double* coef, const char sense, 
+			     const double rhs,
+			     const double* colLowerBound,
+			     const double* colUpperBound) const;
+    // helps the function above
+    bool treatAsLessThan(const OsiSolverInterface& si,
+			 const int rowLen, const int* ind, 
+			 const double* coef,
+			 const double rhs,
+			 const double* colLowerBound,
+			 const double* colUpperBound) const;
+    
+    // Generate Residual Capacity cuts
+    void generateResCapCuts( const OsiSolverInterface& si,
+			     const double* xlp,
+			     const double* colUpperBound,
+			     const double* colLowerBound,
+			     const CoinPackedMatrix& matrixByRow,
+			     const double* LHS,
+			     const double* coefByRow,
+			     const int* colInds,
+			     const int* rowStarts,
+			     const int* rowLengths,
+			     OsiCuts& cs ) const;
+    
+
+    // Residual Capacity separation 
+    bool resCapSeparation(const OsiSolverInterface& si,
+			  const int rowLen, const int* ind, 
+			  const double* coef,
+			  const double rhs,
+			  const double *xlp,  
+			  const double* colUpperBound,
+			  const double* colLowerBound,
+			  OsiRowCut& resCapCut) const;
+    
+      
+
+private:
+    //---------------------------------------------------------------------------
+    // Private member data
+    /** Tolerance used for numerical purposes, default value: 1.e-6 **/
+    double EPSILON_;
+    /** If violation of a cut is greater that this number, 
+	the cut is accepted, default value: 1.e-4 **/
+    double TOLERANCE_;
+    /** Controls the preprocessing of the matrix to identify rows suitable for
+        cut generation.<UL>
+     <LI> -1: preprocess according to solver settings;
+     <LI> 0: Do preprocessing only if it has not yet been done;
+     <LI> 1: Do preprocessing.
+     </UL>
+	 Default value: -1 **/
+    int doPreproc_;
+    // The number of rows of the problem.
+    int numRows_;
+    // The number columns of the problem.
+    int numCols_;
+    // Indicates whether preprocessing has been done.
+    bool doneInitPre_;
+    // Array with the row types of the rows in the model.
+    RowType* rowTypes_;
+    // The indices of the rows of the initial matrix
+    int* indRows_;
+    // Sense of rows (modified if ranges)
+    char * sense_;
+    // RHS of rows (modified if ranges)
+    double * RHS_;
+    // The number of rows of type ROW_L
+    int numRowL_;
+    // The indices of the rows of type ROW_L
+    int* indRowL_;
+    // The number of rows of type ROW_G
+    int numRowG_;
+    // The indices of the rows of type ROW_G
+    int* indRowG_;
+};
+
+//#############################################################################
+/** A function that tests the methods in the CglResidualCapacity class. The
+    only reason for it not to be a member method is that this way it doesn't
+    have to be compiled into the library. And that's a gain, because the
+    library should be compiled with optimization on, but this method should be
+    compiled with debugging. */
+void CglResidualCapacityUnitTest(const OsiSolverInterface * siP,
+				 const std::string mpdDir);
+
+  
+#endif

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

@@ -0,0 +1,174 @@
+// $Id: CglSimpleRounding.hpp 1149 2013-10-21 18:23:53Z tkr $
+// 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 CglSimpleRounding_H
+#define CglSimpleRounding_H
+
+#include <string>
+
+#include "CglCutGenerator.hpp"
+#include "CoinPackedMatrix.hpp"
+
+/** Simple Rounding Cut Generator Class
+
+ This class generates simple rounding cuts via the following method:
+    For each contraint,
+      attempt to derive a <= inequality in all integer variables
+      by netting out any continuous variables.
+      Divide the resulting integer inequality through by 
+      the greatest common denomimator (gcd) of the lhs coefficients.
+      Round down the rhs.
+
+ Warning: Use with careful attention to data precision.
+
+ (Reference: Nemhauser and Wolsey, Integer and Combinatorial Optimization, 1988, pg 211.)
+*/
+
+class CglSimpleRounding : public CglCutGenerator {
+   friend void CglSimpleRoundingUnitTest(const OsiSolverInterface * siP,
+					 const std::string mpdDir );
+ 
+public:
+
+  /**@name Generate Cuts */
+  //@{
+  /** Generate simple rounding cuts for the model accessed through the solver interface. 
+  Insert generated cuts into the cut set cs.
+  */
+  virtual void generateCuts( const OsiSolverInterface & si, OsiCuts & cs,
+			     const CglTreeInfo info = CglTreeInfo());
+  //@}
+
+  /**@name Constructors and destructors */
+  //@{
+  /// Default constructor 
+  CglSimpleRounding ();
+ 
+  /// Copy constructor 
+  CglSimpleRounding (
+    const CglSimpleRounding &);
+
+  /// Clone
+  virtual CglCutGenerator * clone() const;
+
+  /// Assignment operator 
+  CglSimpleRounding &
+    operator=(
+    const CglSimpleRounding& rhs);
+  
+  /// Destructor 
+  virtual
+    ~CglSimpleRounding ();
+  /// Create C++ lines to get to current state
+  virtual std::string generateCpp( FILE * fp);
+  //@}
+
+private:
+  
+  // Private member methods
+   
+  /**@name Private methods */
+  //@{
+  
+  /// Derive a <= inequality in integer variables from the rowIndex-th constraint
+  bool deriveAnIntegerRow(
+                          const OsiSolverInterface & si,
+                          int rowIndex,
+                          const CoinShallowPackedVector & matrixRow, 
+                          CoinPackedVector & irow,
+                          double & b,
+                          bool * negative) const;
+  
+
+  /** Given a vector of doubles, x, with size elements and a positive tolerance,
+     dataTol, this method returns the smallest power of 10 needed so that
+     x[i]*10**power "is integer" for all i=0,...,size-1.
+  
+     ** change of definition of dataTol so that it refers to original
+     data, not to scaled data as that seems to lead to problems.
+
+     So if xScaled is x[i]*10**power and xInt is rounded(xScaled)
+     then fabs(xScaled-xInt) <= dataTol*10**power.  This means that
+     dataTol should be smaller - say 1.0e-12 rather tahn 1.0e-8
+
+     Returns -number of times overflowed  if the power is so big that it will
+     cause overflow (i.e. integer stored will be bigger than 2**31).
+     Test in cut generator.
+  */ 
+  int power10ToMakeDoubleAnInt( 
+       int size,               // the length of the vector x
+       const double * x,   
+       double dataTol ) const; // the precision of the data, i.e. the positive
+                               // epsilon, which is equivalent to zero
+
+  /**@name Greatest common denominators methods */
+  //@{
+  /// Returns the greatest common denominator of two positive integers, a and b.
+  inline  int gcd(int a, int b) const; 
+  
+  /** Returns the greatest common denominator of a vector of
+      positive integers, vi, of length n.
+  */
+  inline  int gcdv(int n, const int * const vi) const; 
+  //@}
+
+  //@}
+  
+  /**@name Private member data */
+  //@{
+  /// A value within an epsilon_ neighborhood of 0  is considered to be 0.
+  double epsilon_;
+  //@}
+};
+
+
+//-------------------------------------------------------------------
+// Returns the greatest common denominator of two 
+// positive integers, a and b, found using Euclid's algorithm 
+//-------------------------------------------------------------------
+int 
+CglSimpleRounding::gcd(int a, int b) const
+{
+  if(a > b) {
+    // Swap a and b
+    int temp = a;
+    a = b;
+    b = temp;
+  }
+  int remainder = b % a;
+  if (remainder == 0) return a;
+  else return gcd(remainder,a);
+}
+
+//-------------------------------------------------------------------
+// Returns the greatest common denominator of a vector of
+// positive integers, vi, of length n.
+//-------------------------------------------------------------------
+int 
+CglSimpleRounding::gcdv(int n, const int* const vi) const
+{
+  if (n==0)
+    abort();
+
+  if (n==1)
+    return vi[0];
+
+  int retval=gcd(vi[0], vi[1]);
+  for (int i=2; i<n; i++){
+     retval=gcd(retval,vi[i]);
+  }
+  return retval;
+}
+
+//#############################################################################
+/** A function that tests the methods in the CglSimpleRounding class. The
+    only reason for it not to be a member method is that this way it doesn't
+    have to be compiled into the library. And that's a gain, because the
+    library should be compiled with optimization on, but this method should be
+    compiled with debugging. */
+void CglSimpleRoundingUnitTest(const OsiSolverInterface * siP,
+			       const std::string mpdDir );
+  
+#endif