ruby-cbc 0.1.9 → 0.2.1

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

@@ -1,204 +0,0 @@
-// Copyright (C) 2002, International Business Machines
-// Corporation and others.  All Rights Reserved.
-// This code is licensed under the terms of the Eclipse Public License (EPL).
-
-#ifndef CglGomory_H
-#define CglGomory_H
-
-#include <string>
-
-#include "CglCutGenerator.hpp"
-
-class CoinWarmStartBasis;
-/** Gomory Cut Generator Class */
-class CglGomory : public CglCutGenerator {
-   friend void CglGomoryUnitTest(const OsiSolverInterface * siP,
-				  const std::string mpdDir );
- 
-public:
-    
-  
-  /**@name Generate Cuts */
-  //@{
-  /** Generate Mixed Integer Gomory cuts for the model of the 
-      solver interface, si.
-
-      Insert the generated cuts into OsiCut, cs.
-
-      There is a limit option, which will only generate cuts with
-      less than this number of entries.
-
-      We can also only look at 0-1 variables a certain distance
-      from integer.
-  */
-  virtual void generateCuts( const OsiSolverInterface & si, OsiCuts & cs,
-			     const CglTreeInfo info = CglTreeInfo());
-  /** Generates cuts given matrix and solution etc,
-      returns number of cuts generated */
-  int generateCuts( const OsiRowCutDebugger * debugger, 
-		    OsiCuts & cs,
-		    const CoinPackedMatrix & columnCopy,
-		    const CoinPackedMatrix & rowCopy,
-		    const double * colsol,
-		    const double * colLower, const double * colUpper,
-		    const double * rowLower, const double * rowUpper,
-		    const char * intVar ,
-		    const CoinWarmStartBasis* warm,
-                    const CglTreeInfo info = CglTreeInfo());
-  /** Generates cuts given matrix and solution etc,
-      returns number of cuts generated (no row copy passed in) */
-  int generateCuts( const OsiRowCutDebugger * debugger, 
-		    OsiCuts & cs,
-		    const CoinPackedMatrix & columnCopy,
-		    const double * colsol,
-		    const double * colLower, const double * colUpper,
-		    const double * rowLower, const double * rowUpper,
-		    const char * intVar ,
-		    const CoinWarmStartBasis* warm,
-                    const CglTreeInfo info = CglTreeInfo());
-
-  /// Return true if needs optimal basis to do cuts (will return true)
-  virtual bool needsOptimalBasis() const { return true; }
-  //@}
-
-  /**@name Change way Gomory works */
-  //@{
-  /// Pass in a copy of original solver (clone it)
-  void passInOriginalSolver(OsiSolverInterface * solver);
-  /// Returns original solver
-  inline OsiSolverInterface * originalSolver() const
-  { return originalSolver_;}
-  /// Set type - 0 normal, 1 add original matrix one, 2 replace
-  inline void setGomoryType(int type)
-  { gomoryType_=type;}
-  /// Return type
-  inline int gomoryType() const
-  { return gomoryType_;}
-  //@}
-
-  /**@name Change limit on how many variables in cut (default 50) */
-  //@{
-  /// Set
-  void setLimit(int limit);
-  /// Get
-  int getLimit() const;
-  /// Set at root (if <normal then use normal)
-  void setLimitAtRoot(int limit);
-  /// Get at root
-  int getLimitAtRoot() const;
-  /// Return maximum length of cut in tree
-  virtual int maximumLengthOfCutInTree() const;
-  //@}
-
-  /**@name Change criterion on which variables to look at.  All ones
-   more than "away" away from integrality will be investigated 
-  (default 0.05) */
-  //@{
-  /// Set away
-  void setAway(double value);
-  /// Get away
-  double getAway() const;
-  /// Set away at root
-  void setAwayAtRoot(double value);
-  /// Get away at root
-  double getAwayAtRoot() const;
-  //@}
-
-  /**@name Change criterion on which the cut id relaxed if the code
-           thinks the factorization has inaccuracies.  The relaxation to
-	   RHS is smallest of -
-	   1) 1.0e-4
-	   2) conditionNumberMultiplier * condition number of factorization
-	   3) largestFactorMultiplier * largest (dual*element) forming tableau
-	      row
-  */
-  //@{
-  /// Set ConditionNumberMultiplier
-  void setConditionNumberMultiplier(double value);
-  /// Get ConditionNumberMultiplier
-  double getConditionNumberMultiplier() const;
-  /// Set LargestFactorMultiplier
-  void setLargestFactorMultiplier(double value);
-  /// Get LargestFactorMultiplier
-  double getLargestFactorMultiplier() const;
-  //@}
-
-  /**@name change factorization */
-  //@{
-   /// Set/unset alternative factorization
-   inline void useAlternativeFactorization(bool yes=true)
-   { alternateFactorization_= (yes) ? 1 : 0;} 
-   /// Get whether alternative factorization being used
-   inline bool alternativeFactorization() const
-   { return (alternateFactorization_!=0);} 
-  //@}
-
-  /**@name Constructors and destructors */
-  //@{
-  /// Default constructor 
-  CglGomory ();
- 
-  /// Copy constructor 
-  CglGomory (
-    const CglGomory &);
-
-  /// Clone
-  virtual CglCutGenerator * clone() const;
-
-  /// Assignment operator 
-  CglGomory &
-    operator=(
-    const CglGomory& rhs);
-  
-  /// Destructor 
-  virtual
-    ~CglGomory ();
-  /// Create C++ lines to get to current state
-  virtual std::string generateCpp( FILE * fp);
-  /// This can be used to refresh any inforamtion
-  virtual void refreshSolver(OsiSolverInterface * solver);
-  //@}
-      
-private:
-  
- // Private member methods
-
-  // Private member data
-
-  /**@name Private member data */
-  //@{
-  /// Only investigate if more than this away from integrality
-  double away_;
-  /// Only investigate if more than this away from integrality (at root)
-  double awayAtRoot_;
-  /// Multiplier for conditionNumber cut relaxation
-  double conditionNumberMultiplier_;
-  /// Multiplier for largest factor cut relaxation
-  double largestFactorMultiplier_;
-  /// Original solver
-  OsiSolverInterface * originalSolver_;
-  /// Limit - only generate if fewer than this in cut
-  int limit_;
-  /// Limit - only generate if fewer than this in cut (at root)
-  int limitAtRoot_;
-  /// Dynamic limit in tree
-  int dynamicLimitInTree_;
-  /// Number of times stalled
-  int numberTimesStalled_;
-  /// nonzero to use alternative factorization
-  int alternateFactorization_;
-  /// Type - 0 normal, 1 add original matrix one, 2 replace
-  int gomoryType_;
-  //@}
-};
-
-//#############################################################################
-/** A function that tests the methods in the CglGomory 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 CglGomoryUnitTest(const OsiSolverInterface * siP,
-			const std::string mpdDir );
-  
-#endif

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

@@ -1,310 +0,0 @@
-// $Id: CglKnapsackCover.hpp 1201 2014-03-07 17:24:04Z forrest $
-// 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 CglKnapsackCover_H
-#define CglKnapsackCover_H
-
-#include <string>
-
-#include "CglCutGenerator.hpp"
-#include "CglTreeInfo.hpp"
-
-/** Knapsack Cover Cut Generator Class */
-class CglKnapsackCover : public CglCutGenerator {
-   friend void CglKnapsackCoverUnitTest(const OsiSolverInterface * siP,
-					const std::string mpdDir );
-
-public:
-   /** A method to set which rows should be tested for knapsack covers */
-   void setTestedRowIndices(int num, const int* ind);
-
-   /**@name Generate Cuts */
-  //@{
-  /** Generate knapsack cover cuts for the model of the solver interface, si. 
-      Insert the generated cuts into OsiCut, cs.
-  */
-  virtual void generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
-			    const CglTreeInfo info = CglTreeInfo());
-  //@}
-
-  /**@name Constructors and destructors */
-  //@{
-  /// Default constructor 
-  CglKnapsackCover ();
- 
-  /// Copy constructor 
-  CglKnapsackCover (
-    const CglKnapsackCover &);
-
-  /// Clone
-  virtual CglCutGenerator * clone() const;
-
-  /// Assignment operator 
-  CglKnapsackCover &
-    operator=(
-    const CglKnapsackCover& rhs);
-  
-  /// Destructor 
-  virtual
-    ~CglKnapsackCover ();
-  /// Create C++ lines to get to current state
-  virtual std::string generateCpp( FILE * fp);
-  /// This can be used to refresh any information
-  virtual void refreshSolver(OsiSolverInterface * solver);
-  //@}
-
-
-  /**@name Sets and gets */
-  //@{
-  /// Set limit on number in knapsack
-  inline void setMaxInKnapsack(int value)
-           { if (value>0) maxInKnapsack_ = value;}
-  /// get limit on number in knapsack
-  inline int getMaxInKnapsack() const
-           {return maxInKnapsack_;}
-  /// Switch off expensive cuts
-  inline void switchOffExpensive()
-  { expensiveCuts_=false;}
-  /// Switch on expensive cuts
-  inline void switchOnExpensive()
-  { expensiveCuts_=true;}
-private:
-  
- // Private member methods
-
-
-  /**@name Private methods */
-  //@{
-
-  /** deriveAKnapsack 
-                 returns 1 if it is able to derive
-                 a (canonical) knapsack inequality
-                in binary variables of the form ax<=b 
-                 from the rowIndex-th  row in the model, 
-                returns 0 otherwise.
-  */
-  int deriveAKnapsack(
-    const OsiSolverInterface & si, 
-    OsiCuts & cs,
-    CoinPackedVector & krow,
-    bool treatAsLRow,
-    double & b,
-    int *  complement,
-    double *  xstar,
-    int rowIndex,
-    int numberElements,
-    const int * index,
-    const double * element);
-
-  int deriveAKnapsack(
-    const OsiSolverInterface & si, 
-    OsiCuts & cs,
-    CoinPackedVector & krow,
-    double & b,
-    int *  complement,
-    double *  xstar,
-    int rowIndex,
-    const CoinPackedVectorBase & matrixRow);
-
-  /** Find a violated minimal cover from 
- a canonical form knapsack inequality by
- solving the -most- violated cover problem
- and postprocess to ensure minimality
-  */
-  int findExactMostViolatedMinCover(
-      int nCols, 
-      int row,
-      CoinPackedVector & krow,
-      double b, 
-      double *  xstar, 
-      CoinPackedVector & cover,
-      CoinPackedVector & remainder);
-
-  /** Find the most violate minimum cover by solving the lp-relaxation of the
-      most-violate-min-cover problem 
-  */
-  int findLPMostViolatedMinCover(
-      int nCols,
-      int row,
-      CoinPackedVector & krow,
-      double & b,
-      double * xstar, 
-      CoinPackedVector & cover,
-      CoinPackedVector & remainder);
-  
-/// find a minimum cover by a simple greedy approach
-  int findGreedyCover(
-      int row,
-      CoinPackedVector & krow,
-      double & b,
-      double * xstar,
-      CoinPackedVector & cover,
-      CoinPackedVector & remainder
-      );
-
-  /// lift the cover inequality
-  int liftCoverCut(
-     double & b,
-     int nRowElem,
-     CoinPackedVector & cover,
-     CoinPackedVector & remainder,
-     CoinPackedVector & cut );
- 
-  /// sequence-independent lift and uncomplement and add the resulting cut to the cut set
-  int liftAndUncomplementAndAdd(
-     double rowub,
-     CoinPackedVector & krow,
-     double & b,
-     int * complement,
-     int row,
-     CoinPackedVector & cover,
-     CoinPackedVector & remainder,
-     OsiCuts & cs );
-
-  /// sequence-dependent lift, uncomplement and add the resulting cut to the cut set
-void seqLiftAndUncomplementAndAdd(
-      int nCols,
-      double * xstar, 
-      int * complement,
-      int row,
-      int nRowElem,
-      double & b,
-      CoinPackedVector & cover,      // need not be violated
-      CoinPackedVector & remainder,
-      OsiCuts & cs );
-
-  /// sequence-dependent lift binary variables either up or down, uncomplement and add to the cut set
-void liftUpDownAndUncomplementAndAdd(
-         int nCols,
-         double * xstar, 
-         int * complement,
-         int row,
-         int nRowElem,
-         double & b,
-
-         // the following 3 packed vectors partition the krow:
-         CoinPackedVector & fracCover, // vars have frac soln values in lp relaxation
-                                       // and form cover with the vars atOne
-         CoinPackedVector & atOne,     // vars have soln value of 1 in lp relaxation
-                                       // and together with fracCover form minimal (?) cover. 
-         CoinPackedVector & remainder,
-         OsiCuts & cs );
-
-  /// find a cover using a variation of the logic found in OSL (w/o SOS)
-  int findPseudoJohnAndEllisCover (
-     int row,
-     CoinPackedVector & krow,
-     double & b,
-     double * xstar,                     
-     CoinPackedVector & cover,  
-     CoinPackedVector & remainder);
-
-  /// find a cover using the basic logic found in OSL (w/o SOS)
-  int findJohnAndEllisCover (
-     int row,
-     CoinPackedVector & krow,
-     double & b,
-     double * xstar,                     
-     CoinPackedVector & fracCover,  
-     CoinPackedVector & atOnes,  
-     CoinPackedVector & remainder);
-
-
-  /** A C-style implementation of the Horowitz-Sahni exact solution 
-   procedure for solving knapsack problem. 
-   
-   (ToDo: implement the more efficient dynamic programming approach)
-
-   (Reference: Martello and Toth, Knapsack Problems, Wiley, 1990, p30.)
-  */
-  int exactSolveKnapsack(
-      int n, 
-      double c, 
-      double const *pp, 
-      double const *ww,
-      double & z, 
-      int * x);
-  /// For testing gub stuff
-  int gubifyCut(CoinPackedVector & cut);
-public:
-  /** Creates cliques for use by probing.
-      Only cliques >= minimumSize and < maximumSize created
-      Can also try and extend cliques as a result of probing (root node).
-      Returns number of cliques found.
-  */
-  int createCliques( OsiSolverInterface & si, 
-		    int minimumSize=2, int maximumSize=100, bool extendCliques=false);
-private:
-  /// Delete all clique information
-  void deleteCliques();
-  //@}
-
-  // Private member data
-
-  /**@name Private member data */
-  //@{
-  /// epsilon
-  double epsilon_;  
-  /// Tolerance to use for violation - bigger than epsilon_
-  double epsilon2_;
-  /// 1-epsilon
-  double onetol_;  
-  /// Maximum in knapsack
-  int maxInKnapsack_;
-  /** which rows to look at. If specified, only these rows will be considered
-      for generating knapsack covers. Otherwise all rows will be tried */
-  int numRowsToCheck_;
-  int* rowsToCheck_;
-  /// exactKnapsack can be expensive - this switches off some
-  bool expensiveCuts_;
-  /// Cliques
-  /// **** TEMP so can reference from listing
-  const OsiSolverInterface * solver_;
-  int whichRow_;
-  int * complement_;
-  double * elements_;
-  /// Number of cliques
-  int numberCliques_;
-  /// Clique type
-  typedef struct {
-    unsigned int equality:1; //  nonzero if clique is ==
-  } CliqueType;
-  CliqueType * cliqueType_;
-  /// Start of each clique
-  int * cliqueStart_;
-  /// Entries for clique
-  CliqueEntry * cliqueEntry_;
-  /** Start of oneFixes cliques for a column in matrix or -1 if not
-      in any clique */
-  int * oneFixStart_;
-  /** Start of zeroFixes cliques for a column in matrix or -1 if not
-      in any clique */
-  int * zeroFixStart_;
-  /// End of fixes for a column
-  int * endFixStart_;
-  /// Clique numbers for one or zero fixes
-  int * whichClique_;
-  /// Number of columns
-  int numberColumns_;
-  /** For each column with nonzero in row copy this gives a clique "number".
-      So first clique mentioned in row is always 0.  If no entries for row
-      then no cliques.  If sequence > numberColumns then not in clique.
-  */
-  //CliqueEntry * cliqueRow_;
-  /// cliqueRow_ starts for each row
-  //int * cliqueRowStart_;
-  //@}
-};
-
-//#############################################################################
-/** A function that tests the methods in the CglKnapsackCover 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 CglKnapsackCoverUnitTest(const OsiSolverInterface * siP,
-			      const std::string mpdDir );
-  
-#endif