ruby-cbc 0.1.9 → 0.2.1

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

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

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