ruby-cbc 0.1.9

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

@@ -0,0 +1,142 @@
+/* $Id: CbcCompareBase.hpp 1573 2011-01-05 01:12:36Z lou $ */
+// 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 CbcCompareBase_H
+#define CbcCompareBase_H
+
+
+//#############################################################################
+/*  These are alternative strategies for node traversal.
+    They can take data etc for fine tuning
+
+    At present the node list is stored as a heap and the "test"
+    comparison function returns true if node y is better than node x.
+
+    This is rather inflexible so if the comparison functions wants
+    it can signal to use alternative criterion on a complete pass
+    throgh tree.
+
+*/
+#include "CbcNode.hpp"
+#include "CbcConfig.h"
+
+class CbcModel;
+class CbcTree;
+class CbcCompareBase {
+public:
+    // Default Constructor
+    CbcCompareBase () {
+        test_ = NULL;
+        threaded_ = false;
+    }
+
+    /*! \brief Reconsider behaviour after discovering a new solution.
+    
+      This allows any method to change its behaviour. It is called
+      after each solution.
+
+      The method should return true if changes are made which will
+      alter the evaluation criteria applied to a node. (So that in
+      cases where the search tree is sorted, it can be properly
+      rebuilt.)
+    */
+    virtual bool newSolution(CbcModel * ) { return (false) ; }
+
+    /*! \brief Reconsider behaviour after discovering a new solution.
+    
+      This allows any method to change its behaviour. It is called
+      after each solution.
+
+      The method should return true if changes are made which will
+      alter the evaluation criteria applied to a node. (So that in
+      cases where the search tree is sorted, it can be properly
+      rebuilt.)
+    */
+    virtual bool newSolution(CbcModel * ,
+                             double ,
+                             int ) { return (false) ; }
+
+    // This allows any method to change behavior as it is called
+    // after every 1000 nodes.
+    // Return true if want tree re-sorted
+    virtual bool every1000Nodes(CbcModel * , int ) {
+        return false;
+    }
+
+    /** Returns true if wants code to do scan with alternate criterion
+        NOTE - this is temporarily disabled
+    */
+    virtual bool fullScan() const {
+        return false;
+    }
+
+    virtual ~CbcCompareBase() {}
+    /// Create C++ lines to get to current state
+    virtual void generateCpp( FILE * ) {}
+
+    // Copy constructor
+    CbcCompareBase ( const CbcCompareBase & rhs) {
+        test_ = rhs.test_;
+        threaded_ = rhs.threaded_;
+    }
+
+    // Assignment operator
+    CbcCompareBase & operator=( const CbcCompareBase& rhs) {
+        if (this != &rhs) {
+            test_ = rhs.test_;
+            threaded_ = rhs.threaded_;
+        }
+        return *this;
+    }
+
+    /// Clone
+    virtual CbcCompareBase * clone() const {
+        abort();
+        return NULL;
+    }
+
+    /// This is test function
+    virtual bool test (CbcNode * , CbcNode * ) {
+        return true;
+    }
+
+    /// This is alternate test function
+    virtual bool alternateTest (CbcNode * x, CbcNode * y) {
+        return test(x, y);
+    }
+
+    bool operator() (CbcNode * x, CbcNode * y) {
+        return test(x, y);
+    }
+    /// Further test if everything else equal
+    inline bool equalityTest (CbcNode * x, CbcNode * y) const {
+        assert (x);
+        assert (y);
+        if (!threaded_) {
+            CbcNodeInfo * infoX = x->nodeInfo();
+            assert (infoX);
+            int nodeNumberX = infoX->nodeNumber();
+            CbcNodeInfo * infoY = y->nodeInfo();
+            assert (infoY);
+            int nodeNumberY = infoY->nodeNumber();
+            assert (nodeNumberX != nodeNumberY);
+            return (nodeNumberX > nodeNumberY);
+        } else {
+            assert (x->nodeNumber() != y->nodeNumber());
+            return (x->nodeNumber() > y->nodeNumber());
+        }
+    }
+    /// Say threaded
+    inline void sayThreaded() {
+        threaded_ = true;
+    }
+protected:
+    CbcCompareBase * test_;
+    // If not threaded we can use better way to break ties
+    bool threaded_;
+};
+
+#endif
+

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

@@ -0,0 +1,120 @@
+// $Id: CbcCompareDefault.hpp 1899 2013-04-09 18:12:08Z stefan $
+// 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).
+
+//Edwin 11/25/09 carved out of CbcCompareActual
+
+#ifndef CbcCompareDefault_H
+#define CbcCompareDefault_H
+
+
+//#############################################################################
+/*  These are alternative strategies for node traversal.
+    They can take data etc for fine tuning
+
+    At present the node list is stored as a heap and the "test"
+    comparison function returns true if node y is better than node x.
+
+*/
+#include "CbcNode.hpp"
+#include "CbcCompareBase.hpp"
+#include "CbcCompare.hpp"
+
+class CbcModel;
+
+/* This is an example of a more complex rule with data
+   It is default after first solution
+   If weight is 0.0 then it is computed to hit first solution
+   less 5%
+*/
+class CbcCompareDefault  : public CbcCompareBase {
+public:
+    /// Default Constructor
+    CbcCompareDefault () ;
+    /// Constructor with weight
+    CbcCompareDefault (double weight);
+
+    /// Copy constructor
+    CbcCompareDefault ( const CbcCompareDefault &rhs);
+
+    /// Assignment operator
+    CbcCompareDefault & operator=( const CbcCompareDefault& rhs);
+
+    /// Clone
+    virtual CbcCompareBase * clone() const;
+    /// Create C++ lines to get to current state
+    virtual void generateCpp( FILE * fp);
+
+    ~CbcCompareDefault() ;
+    /* This returns true if weighted value of node y is less than
+       weighted value of node x */
+    virtual bool test (CbcNode * x, CbcNode * y) ;
+
+    using CbcCompareBase::newSolution ;
+    /// This allows method to change behavior as it is called
+    /// after each solution
+    virtual bool newSolution(CbcModel * model,
+                             double objectiveAtContinuous,
+                             int numberInfeasibilitiesAtContinuous) ;
+    /// This allows method to change behavior
+    /// Return true if want tree re-sorted
+    virtual bool every1000Nodes(CbcModel * model, int numberNodes);
+
+    /* if weight == -1.0 then fewest infeasibilities (before solution)
+       if -2.0 then do breadth first just for first 1000 nodes
+       if -3.0 then depth first before solution
+    */
+    inline double getWeight() const {
+        return weight_;
+    }
+    inline void setWeight(double weight) {
+        weight_ = weight;
+    }
+    /// Cutoff
+    inline double getCutoff() const {
+        return cutoff_;
+    }
+    inline void setCutoff(double cutoff) {
+        cutoff_ = cutoff;
+    }
+    /// Best possible solution
+    inline double getBestPossible() const {
+        return bestPossible_;
+    }
+    inline void setBestPossible(double bestPossible) {
+        bestPossible_ = bestPossible;
+    }
+    /// Depth above which want to explore first
+    inline void setBreadthDepth(int value) {
+        breadthDepth_ = value;
+    }
+    /// Start dive
+    void startDive(CbcModel * model);
+    /// Clean up diving (i.e. switch off or prepare)
+    void cleanDive();
+protected:
+    /// Weight for each infeasibility
+    double weight_;
+    /// Weight for each infeasibility - computed from solution
+    double saveWeight_;
+    /// Cutoff
+    double cutoff_;
+    /// Best possible solution
+    double bestPossible_;
+    /// Number of solutions
+    int numberSolutions_;
+    /// Tree size (at last check)
+    int treeSize_;
+    /// Depth above which want to explore first
+    int breadthDepth_;
+    /// Chosen node from estimated (-1 is off)
+    int startNodeNumber_;
+    /// Node number when dive started
+    int afterNodeNumber_;
+    /// Indicates doing setup for diving
+    bool setupForDiving_ ;
+};
+
+#endif //CbcCompareDefault_H
+

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

@@ -0,0 +1,47 @@
+// $Id: CbcCompareDepth.hpp 1899 2013-04-09 18:12:08Z stefan $
+// 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).
+
+//Edwin 11/24/09 carved out of CbcCompareActual
+
+#ifndef CbcCompareDepth_H
+#define CbcCompareDepth_H
+
+
+//#############################################################################
+/*  These are alternative strategies for node traversal.
+    They can take data etc for fine tuning
+
+    At present the node list is stored as a heap and the "test"
+    comparison function returns true if node y is better than node x.
+
+*/
+#include "CbcNode.hpp"
+#include "CbcCompareBase.hpp"
+#include "CbcCompare.hpp"
+class CbcModel;
+// This is default before first solution
+class CbcCompareDepth : public CbcCompareBase {
+public:
+    // Default Constructor
+    CbcCompareDepth () ;
+
+    ~CbcCompareDepth();
+    // Copy constructor
+    CbcCompareDepth ( const CbcCompareDepth &rhs);
+
+    // Assignment operator
+    CbcCompareDepth & operator=( const CbcCompareDepth& rhs);
+
+    /// Clone
+    virtual CbcCompareBase * clone() const;
+    /// Create C++ lines to get to current state
+    virtual void generateCpp( FILE * fp);
+
+    // This returns true if the depth of node y is greater than depth of node x
+    virtual bool test (CbcNode * x, CbcNode * y);
+};
+
+#endif
+

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

@@ -0,0 +1,48 @@
+// $Id: CbcCompareEstimate.hpp 1899 2013-04-09 18:12:08Z stefan $
+// 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).
+
+//Edwin 11/25/09 carved out of CbcCompareActual
+
+#ifndef CbcCompareEstimate_H
+#define CbcCompareEstimate_H
+
+
+//#############################################################################
+/*  These are alternative strategies for node traversal.
+    They can take data etc for fine tuning
+
+    At present the node list is stored as a heap and the "test"
+    comparison function returns true if node y is better than node x.
+
+*/
+#include "CbcNode.hpp"
+#include "CbcCompareBase.hpp"
+#include "CbcCompare.hpp"
+class CbcModel;
+
+/* This is when rounding is being done
+*/
+class CbcCompareEstimate  : public CbcCompareBase {
+public:
+    // Default Constructor
+    CbcCompareEstimate () ;
+    ~CbcCompareEstimate() ;
+    // Copy constructor
+    CbcCompareEstimate ( const CbcCompareEstimate &rhs);
+
+    // Assignment operator
+    CbcCompareEstimate & operator=( const CbcCompareEstimate& rhs);
+
+    /// Clone
+    virtual CbcCompareBase * clone() const;
+    /// Create C++ lines to get to current state
+    virtual void generateCpp( FILE * fp);
+
+    virtual bool test (CbcNode * x, CbcNode * y) ;
+};
+
+
+#endif //CbcCompareEstimate_H
+

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

@@ -0,0 +1,49 @@
+// $Id: CbcCompareObjective.hpp 1899 2013-04-09 18:12:08Z stefan $
+// 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).
+
+//Edwin 11/25/09 carved out of CbcCompareActual
+
+#ifndef CbcCompareObjective_H
+#define CbcCompareObjective_H
+
+
+//#############################################################################
+/*  These are alternative strategies for node traversal.
+    They can take data etc for fine tuning
+
+    At present the node list is stored as a heap and the "test"
+    comparison function returns true if node y is better than node x.
+
+*/
+#include "CbcNode.hpp"
+#include "CbcCompareBase.hpp"
+#include "CbcCompare.hpp"
+
+class CbcModel;
+
+class CbcCompareObjective  : public CbcCompareBase {
+public:
+    // Default Constructor
+    CbcCompareObjective ();
+
+    virtual ~CbcCompareObjective();
+    // Copy constructor
+    CbcCompareObjective ( const CbcCompareObjective &rhs);
+
+    // Assignment operator
+    CbcCompareObjective & operator=( const CbcCompareObjective& rhs);
+
+    /// Clone
+    virtual CbcCompareBase * clone() const;
+    /// Create C++ lines to get to current state
+    virtual void generateCpp( FILE * fp);
+
+    /* This returns true if objective value of node y is less than
+       objective value of node x */
+    virtual bool test (CbcNode * x, CbcNode * y);
+};
+
+#endif //CbcCompareObjective_H
+

data/ext/ruby-cbc/install/include/coin/CbcConfig.h

@@ -0,0 +1,14 @@
+/* src/config_cbc.h.  Generated by configure.  */
+/* src/config_cbc.h.in. */
+
+/* Version number of project */
+#define CBC_VERSION "2.9.7"
+
+/* Major Version number of project */
+#define CBC_VERSION_MAJOR 2
+
+/* Minor Version number of project */
+#define CBC_VERSION_MINOR 9
+
+/* Release Version number of project */
+#define CBC_VERSION_RELEASE 7

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

@@ -0,0 +1,49 @@
+// $Id: CbcConsequence.hpp 1899 2013-04-09 18:12:08Z stefan $
+// 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).
+
+// Edwin 11/12/2009 carved from CbcBranchBase
+
+#ifndef CbcConsequence_H
+#define CbcConsequence_H
+
+class OsiSolverInterface;
+
+/** Abstract base class for consequent bounds.
+    When a variable is branched on it normally interacts with other variables by
+    means of equations.  There are cases where we want to step outside LP and do something
+    more directly e.g. fix bounds.  This class is for that.
+
+    At present it need not be virtual as only instance is CbcFixVariable, but ...
+
+ */
+
+class CbcConsequence {
+
+public:
+
+    // Default Constructor
+    CbcConsequence ();
+
+    // Copy constructor
+    CbcConsequence ( const CbcConsequence & rhs);
+
+    // Assignment operator
+    CbcConsequence & operator=( const CbcConsequence & rhs);
+
+    /// Clone
+    virtual CbcConsequence * clone() const = 0;
+
+    /// Destructor
+    virtual ~CbcConsequence ();
+
+    /** Apply to an LP solver.  Action depends on state
+     */
+    virtual void applyToSolver(OsiSolverInterface * solver, int state) const = 0;
+
+protected:
+};
+
+#endif
+

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

@@ -0,0 +1,168 @@
+/* $Id: CbcCountRowCut.hpp 2094 2014-11-18 11:15:36Z forrest $ */
+// 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 CbcCountRowCut_H
+#define CbcCountRowCut_H
+
+
+class OsiCuts;
+class OsiRowCut;
+class CbcNodeInfo;
+
+//#############################################################################
+/** \brief OsiRowCut augmented with bookkeeping
+
+  CbcCountRowCut is an OsiRowCut object augmented with bookkeeping
+  information: a reference count and information that specifies the
+  the generator that created the cut and the node to which it's associated.
+
+  The general principles for handling the reference count are as follows:
+  <ul>
+    <li> Once it's determined how the node will branch, increment the
+	 reference count under the assumption that all children will use
+         all cuts currently tight at the node and will survive to be placed
+	 in the search tree.
+    <li> As this assumption is proven incorrect (a cut becomes loose, or a
+	 child is fathomed), decrement the reference count accordingly.
+  </ul>
+  When all possible uses of a cut have been demonstrated to be unnecessary,
+  the reference count (#numberPointingToThis_) will fall to zero. The
+  CbcCountRowCut object (and its included OsiRowCut object) are then deleted.
+*/
+
+class CbcCountRowCut : public OsiRowCut {
+
+public:
+
+    /** @name Constructors & destructors */
+    //@{
+
+    /// Default Constructor
+    CbcCountRowCut ();
+
+    /// `Copy' constructor using an OsiRowCut
+    CbcCountRowCut ( const OsiRowCut &);
+
+    /// `Copy' constructor using an OsiRowCut and an CbcNodeInfo
+    CbcCountRowCut(const OsiRowCut &, CbcNodeInfo *, int whichOne,
+                   int whichGenerator = -1, int numberPointingToThis = 0);
+
+    /** Destructor
+
+      \note The destructor will reach out (via #owner_) and NULL the
+      reference to the cut in the owner's
+      \link CbcNodeInfo::cuts_ cuts_ \endlink list.
+    */
+    virtual ~CbcCountRowCut ();
+    //@}
+
+    /// Increment the number of references
+    void increment(int change = 1);
+
+    /// Decrement the number of references and return the number left.
+    int decrement(int change = 1);
+
+    /** \brief Set the information associating this cut with a node
+
+      An CbcNodeInfo object and an index in the cut set of the node.
+      For locally valid cuts, the node will be the  search tree node where the
+      cut was generated. For globally valid cuts, it's the node where the cut
+      was activated.
+    */
+    void setInfo(CbcNodeInfo *, int whichOne);
+
+    /// Number of other CbcNodeInfo objects pointing to this row cut
+    inline int numberPointingToThis() {
+        return numberPointingToThis_;
+    }
+
+    /// Which generator for cuts - as user order
+    inline int whichCutGenerator() const {
+        return whichCutGenerator_;
+    }
+
+    /// Returns true if can drop cut if slack basic
+    bool canDropCut(const OsiSolverInterface * solver, int row) const;
+
+#ifdef CHECK_CUT_COUNTS
+    // Just for printing sanity checks
+    int tempNumber_;
+#endif
+
+private:
+
+    /// Standard copy is illegal (reference counts would be incorrect)
+    CbcCountRowCut(const CbcCountRowCut &);
+
+    /// Standard assignment is illegal (reference counts would be incorrect)
+    CbcCountRowCut & operator=(const CbcCountRowCut& rhs);
+
+    /// Backward pointer to owning CbcNodeInfo
+    CbcNodeInfo * owner_;
+
+    /// Index of cut in owner's cut set
+    /// (\link CbcNodeInfo::cuts_ cuts_ \endlink).
+    int ownerCut_;
+
+    /// Number of other CbcNodeInfo objects pointing to this cut
+    int numberPointingToThis_;
+
+    /** Which generator created this cut 
+	(add 10000 if globally valid)
+	if -1 then from global cut pool
+	-2 cut branch
+        -3 unknown
+    */
+    int whichCutGenerator_;
+
+};
+/**
+   Really for Conflict cuts to -
+   a) stop duplicates
+   b) allow half baked cuts
+   The whichRow_ field in OsiRowCut2 is used for a type
+   0 - normal 
+   1 - processed cut (conflict)
+   2 - unprocessed cut i.e. dual ray computation
+*/
+// for hashing
+typedef struct {
+  int index, next;
+} CoinHashLink;
+class CbcRowCuts {
+public:
+
+  CbcRowCuts(int initialMaxSize=0, int hashMultiplier=4 );
+  ~CbcRowCuts();
+  CbcRowCuts(const CbcRowCuts& rhs);
+  CbcRowCuts& operator=(const CbcRowCuts& rhs);
+  inline OsiRowCut2 * cut(int sequence) const
+  { return rowCut_[sequence];}
+  inline int numberCuts() const
+  { return numberCuts_;}
+  inline int sizeRowCuts() const
+  { return numberCuts_;}
+  inline OsiRowCut * rowCutPtr(int sequence)
+  { return rowCut_[sequence];}
+  void eraseRowCut(int sequence);
+  // Return 0 if added, 1 if not, -1 if not added because of space
+  int addCutIfNotDuplicate(const OsiRowCut & cut,int whichType=0);
+  // Return 0 if added, 1 if not, -1 if not added because of space
+  int addCutIfNotDuplicateWhenGreedy(const OsiRowCut & cut,int whichType=0);
+  // Add in cuts as normal cuts (and delete)
+  void addCuts(OsiCuts & cs);
+  // Truncate
+  void truncate(int numberAfter);
+private:
+  OsiRowCut2 ** rowCut_;
+  /// Hash table
+  CoinHashLink *hash_;
+  int size_;
+  int hashMultiplier_;
+  int numberCuts_;
+  int lastHash_;
+};
+#endif
+