ruby-cbc 0.1.9 → 0.2.1

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

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

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

@@ -1,125 +0,0 @@
-// $Id: CglStored.hpp 1119 2013-04-06 20:24:18Z stefan $
-// Copyright (C) 2005, International Business Machines
-// Corporation and others.  All Rights Reserved.
-// This code is licensed under the terms of the Eclipse Public License (EPL).
-
-#ifndef CglStored_H
-#define CglStored_H
-
-#include <string>
-
-#include "CglCutGenerator.hpp"
-
-class CoinWarmStartBasis;
-class CglTreeProbingInfo;
-/** Stored Cut Generator Class */
-class CglStored : public CglCutGenerator {
- 
-public:
-    
-  
-  /**@name Generate Cuts */
-  //@{
-  /** Generate Mixed Integer Stored cuts for the model of the 
-      solver interface, si.
-
-      Insert the generated cuts into OsiCut, cs.
-
-      This generator just looks at previously stored cuts
-      and inserts any that are violated by enough
-  */
-  virtual void generateCuts( const OsiSolverInterface & si, OsiCuts & cs,
-			     const CglTreeInfo info = CglTreeInfo());
-  //@}
-
-  /**@name Change criterion on whether to include cut.
-   Violations of more than this will be added to current cut list
-  (default 1.0e-5) */
-  //@{
-  /// Set
-  inline void setRequiredViolation(double value)
-  { requiredViolation_=value;}
-  /// Get
-  inline double getRequiredViolation() const
-  { return requiredViolation_;}
-  /// Takes over ownership of probing info
-  inline void setProbingInfo(CglTreeProbingInfo * info)
-  { probingInfo_ = info;}
-  //@}
-
-  /**@name Cut stuff */
-  //@{
-  /// Add cuts
-  void addCut(const OsiCuts & cs);
-  /// Add a row cut
-  void addCut(const OsiRowCut & cut);
-  /// Add a row cut from a packed vector
-  void addCut(double lb, double ub, const CoinPackedVector & vector);
-  /// Add a row cut from elements
-  void addCut(double lb, double ub, int size, const int * colIndices, const double * elements);
-  inline int sizeRowCuts() const
-  { return cuts_.sizeRowCuts();}
-  const OsiRowCut * rowCutPointer(int index) const
-  { return cuts_.rowCutPtr(index);}
-  /// Save stuff
-  void saveStuff(double bestObjective, const double * bestSolution,
-		 const double * lower, const double * upper);
-  /// Best solution (or NULL)
-  inline const double * bestSolution() const
-  { return bestSolution_;}
-  /// Best objective
-  double bestObjective() const;
-  /// Tight lower bounds
-  const double * tightLower() const
-  { return bounds_;} 
-  /// Tight upper bounds
-  const double * tightUpper() const
-  { return bounds_+numberColumns_;} 
-  //@}
-
-  /**@name Constructors and destructors */
-  //@{
-  /// Default constructor 
-  CglStored (int numberColumns=0);
- 
-  /// Copy constructor 
-  CglStored (const CglStored & rhs);
-
-  /// Constructor from file
-  CglStored (const char * fileName);
-
-  /// Clone
-  virtual CglCutGenerator * clone() const;
-
-  /// Assignment operator 
-  CglStored &
-    operator=(const CglStored& rhs);
-  
-  /// Destructor 
-  virtual
-    ~CglStored ();
-  //@}
-      
-protected:
-  
- // Protected member methods
-
-  // Protected member data
-
-  /**@name Protected member data */
-  //@{
-  /// Only add if more than this requiredViolation
-  double requiredViolation_;
-  /// Pointer to probing information
-  CglTreeProbingInfo * probingInfo_;
-  /// Cuts
-  OsiCuts cuts_;
-  /// Number of columns in model
-  int numberColumns_;
-  /// Best solution (objective at end)
-  double * bestSolution_;
-  /// Tight bounds
-  double * bounds_;
-  //@}
-};
-#endif

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

@@ -1,180 +0,0 @@
-// $Id: CglTreeInfo.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 CglTreeInfo_H
-#define CglTreeInfo_H
-
-#include "OsiCuts.hpp"
-#include "OsiSolverInterface.hpp"
-#include "CoinHelperFunctions.hpp"
-class CglStored;
-/** Information about where the cut generator is invoked from. */
-
-class CglTreeInfo {
-public:
-  /// The level of the search tree node 
-  int level;
-  /** How many times the cut generator was already invoked in this search tree
-      node */
-  int pass;
-  /** The number of rows in the original formulation. Some generators may not
-      want to consider already generated rows when generating new ones. */
-  int formulation_rows;
-  /** Options 
-      1 - treat costed integers as important
-      2 - switch off some stuff as variables semi-integer
-      4 - set global cut flag if at root node
-      8 - set global cut flag if at root node and first pass
-      16 - set global cut flag and make cuts globally valid
-      32 - last round of cuts did nothing - maybe be more aggressive
-      64 - in preprocessing stage
-      128 - looks like solution
-      256 - want alternate cuts
-      512 - in sub tree (i.e. parent model)
-      1024 - in must call again mode or after everything mode
-  */
-  int options;
-  /// Set true if in tree (to avoid ambiguity at first branch)
-  bool inTree;
-  /** Replacement array.  Before Branch and Cut it may be beneficial to strengthen rows
-      rather than adding cuts.  If this array is not NULL then the cut generator can
-      place a pointer to the stronger cut in this array which is number of rows in size.
-
-      A null (i.e. zero elements and free rhs) cut indicates that the row is useless 
-      and can be removed.
-
-      The calling function can then replace those rows.
-  */
-  OsiRowCut ** strengthenRow;
-  /// Optional pointer to thread specific random number generator
-  CoinThreadRandom * randomNumberGenerator;
-  /// Default constructor 
-  CglTreeInfo ();
- 
-  /// Copy constructor 
-  CglTreeInfo (
-    const CglTreeInfo &);
-  /// Clone
-  virtual CglTreeInfo * clone() const;
-
-  /// Assignment operator 
-  CglTreeInfo &
-    operator=(
-    const CglTreeInfo& rhs);
-  
-  /// Destructor 
-  virtual
-    ~CglTreeInfo ();
-  /// Take action if cut generator can fix a variable (toValue -1 for down, +1 for up)
-  virtual bool fixes(int , int , int ,bool) {return false;}
-  /** Initalizes fixing arrays etc - returns >0 if we want to save info
-      0 if we don't and -1 if is to be used */
-  virtual int initializeFixing(const OsiSolverInterface * ) {return 0;}
-  
-};
-
-/** Derived class to pick up probing info. */
-typedef struct {
-  //unsigned int oneFixed:1; //  nonzero if variable to 1 fixes all
-  //unsigned int sequence:31; //  variable (in matrix) (but also see cliqueRow_)
-  unsigned int fixes;
-} CliqueEntry;
-
-class CglTreeProbingInfo : public CglTreeInfo {
-public:
-  /// Default constructor 
-  CglTreeProbingInfo ();
-  /// Constructor from model
-  CglTreeProbingInfo (const OsiSolverInterface * model);
- 
-  /// Copy constructor 
-  CglTreeProbingInfo (
-    const CglTreeProbingInfo &);
-  /// Clone
-  virtual CglTreeInfo * clone() const;
-
-  /// Assignment operator 
-  CglTreeProbingInfo &
-    operator=(
-    const CglTreeProbingInfo& rhs);
-  
-  /// Destructor 
-  virtual
-    ~CglTreeProbingInfo ();
-  OsiSolverInterface * analyze(const OsiSolverInterface & si, int createSolver=0,
-			       int numberExtraCliques=0,const int * starts=NULL,
-			       const CliqueEntry * entries=NULL,const char * type=NULL);
-  /** Take action if cut generator can fix a variable 
-      (toValue -1 for down, +1 for up)
-      Returns true if still room, false if not  */
-  virtual bool fixes(int variable, int toValue, int fixedVariable,bool fixedToLower);
-  /** Initalizes fixing arrays etc - returns >0 if we want to save info
-      0 if we don't and -1 if is to be used */
-  virtual int initializeFixing(const OsiSolverInterface * model) ;
-  /// Fix entries in a solver using implications
-  int fixColumns(OsiSolverInterface & si) const;
-  /// Fix entries in a solver using implications for one variable
-  int fixColumns(int iColumn, int value, OsiSolverInterface & si) const;
-  /// Packs down entries
-  int packDown();
-  /// Generate cuts from implications
-  void generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
-		    const CglTreeInfo info) const;
-  /// Entries for fixing variables
-  inline CliqueEntry * fixEntries()
-  { convert(); return fixEntry_;}
-  /// Starts of integer variable going to zero
-  inline int * toZero()
-  { convert(); return toZero_;}
-  /// Starts of integer variable going to one
-  inline int * toOne()
-  { convert(); return toOne_;}
-  /// List of 0-1 integer variables
-  inline int * integerVariable() const
-  { return integerVariable_;}
-  /// Backward look up
-  inline int * backward() const
-  { return backward_;}
-  /// Number of variables
-  inline int numberVariables() const
-  { return numberVariables_;}
-  /// Number of 0-1 variables
-  inline int numberIntegers() const
-  { return numberIntegers_;}
-private:
-  /// Converts to ordered
-  void convert();
-protected:
-  /// Entries for fixing variables
-  CliqueEntry * fixEntry_;
-  /// Starts of integer variable going to zero
-  int * toZero_;
-  /// Starts of integer variable going to one
-  int * toOne_;
-  /// List of 0-1 integer variables
-  int * integerVariable_;
-  /// Backward look up
-  int * backward_;
-  /// Entries for fixing variable when collecting
-  int * fixingEntry_;
-  /// Number of variables
-  int numberVariables_;
-  /// Number of 0-1 variables
-  int numberIntegers_;
-  /// Maximum number in fixEntry_
-  int maximumEntries_;
-  /// Number entries in fixingEntry_ (and fixEntry_) or -2 if correct style
-  int numberEntries_;
-};
-inline int sequenceInCliqueEntry(const CliqueEntry & cEntry)
-{ return cEntry.fixes&0x7fffffff;}
-inline void setSequenceInCliqueEntry(CliqueEntry & cEntry,int sequence)
-{ cEntry.fixes = sequence|(cEntry.fixes&0x80000000);}
-inline bool oneFixesInCliqueEntry(const CliqueEntry & cEntry)
-{ return (cEntry.fixes&0x80000000)!=0;}
-inline void setOneFixesInCliqueEntry(CliqueEntry & cEntry,bool oneFixes)
-{ cEntry.fixes = (oneFixes ? 0x80000000 : 0)|(cEntry.fixes&0x7fffffff);}
-
-#endif