ruby-cbc 0.1.9

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

@@ -0,0 +1,206 @@
+/* $Id: CbcBranchDynamic.hpp 1573 2011-01-05 01:12:36Z lou $ */
+// 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 CbcBranchDynamic_H
+#define CbcBranchDynamic_H
+
+#include "CoinPackedMatrix.hpp"
+#include "CbcSimpleIntegerDynamicPseudoCost.hpp"
+#include "CbcBranchActual.hpp"
+
+/** Branching decision dynamic class
+
+  This class implements a simple algorithm
+  (betterBranch()) for choosing a branching variable when dynamic pseudo costs.
+*/
+
+class CbcBranchDynamicDecision : public CbcBranchDecision {
+public:
+    // Default Constructor
+    CbcBranchDynamicDecision ();
+
+    // Copy constructor
+    CbcBranchDynamicDecision ( const CbcBranchDynamicDecision &);
+
+    virtual ~CbcBranchDynamicDecision();
+
+    /// Clone
+    virtual CbcBranchDecision * clone() const;
+
+    /// Initialize, <i>e.g.</i> before the start of branch selection at a node
+    virtual void initialize(CbcModel * model);
+
+    /** \brief Compare two branching objects. Return nonzero if \p thisOne is
+           better than \p bestSoFar.
+
+      The routine compares branches using the values supplied in \p numInfUp and
+      \p numInfDn until a solution is found by search, after which it uses the
+      values supplied in \p changeUp and \p changeDn. The best branching object
+      seen so far and the associated parameter values are remembered in the
+      \c CbcBranchDynamicDecision object. The nonzero return value is +1 if the
+      up branch is preferred, -1 if the down branch is preferred.
+
+      As the names imply, the assumption is that the values supplied for
+      \p numInfUp and \p numInfDn will be the number of infeasibilities reported
+      by the branching object, and \p changeUp and \p changeDn will be the
+      estimated change in objective. Other measures can be used if desired.
+
+      Because an \c CbcBranchDynamicDecision object remembers the current best
+      branching candidate (#bestObject_) as well as the values used in the
+      comparison, the parameter \p bestSoFar is redundant, hence unused.
+    */
+    virtual int betterBranch(CbcBranchingObject * thisOne,
+                             CbcBranchingObject * bestSoFar,
+                             double changeUp, int numInfUp,
+                             double changeDn, int numInfDn);
+    /** Sets or gets best criterion so far */
+    virtual void setBestCriterion(double value);
+    virtual double getBestCriterion() const;
+    /** Says whether this method can handle both methods -
+        1 better, 2 best, 3 both */
+    virtual int whichMethod() {
+        return 3;
+    }
+
+    /** Saves a clone of current branching object.  Can be used to update
+        information on object causing branch - after branch */
+    virtual void saveBranchingObject(OsiBranchingObject * object) ;
+    /** Pass in information on branch just done.
+        assumes object can get information from solver */
+    virtual void updateInformation(OsiSolverInterface * solver,
+                                   const CbcNode * node);
+
+
+private:
+
+    /// Illegal Assignment operator
+    CbcBranchDynamicDecision & operator=(const CbcBranchDynamicDecision& rhs);
+
+    /// data
+
+    /// "best" so far
+    double bestCriterion_;
+
+    /// Change up for best
+    double bestChangeUp_;
+
+    /// Number of infeasibilities for up
+    int bestNumberUp_;
+
+    /// Change down for best
+    double bestChangeDown_;
+
+    /// Number of infeasibilities for down
+    int bestNumberDown_;
+
+    /// Pointer to best branching object
+    CbcBranchingObject * bestObject_;
+};
+/** Simple branching object for an integer variable with pseudo costs
+
+  This object can specify a two-way branch on an integer variable. For each
+  arm of the branch, the upper and lower bounds on the variable can be
+  independently specified.
+
+  Variable_ holds the index of the integer variable in the integerVariable_
+  array of the model.
+*/
+
+class CbcDynamicPseudoCostBranchingObject : public CbcIntegerBranchingObject {
+
+public:
+
+    /// Default constructor
+    CbcDynamicPseudoCostBranchingObject ();
+
+    /** Create a standard floor/ceiling branch object
+
+      Specifies a simple two-way branch. Let \p value = x*. One arm of the
+      branch will be is lb <= x <= floor(x*), the other ceil(x*) <= x <= ub.
+      Specify way = -1 to set the object state to perform the down arm first,
+      way = 1 for the up arm.
+    */
+    CbcDynamicPseudoCostBranchingObject (CbcModel *model, int variable,
+                                         int way , double value,
+                                         CbcSimpleIntegerDynamicPseudoCost * object) ;
+
+    /** Create a degenerate branch object
+
+      Specifies a `one-way branch'. Calling branch() for this object will
+      always result in lowerValue <= x <= upperValue. Used to fix a variable
+      when lowerValue = upperValue.
+    */
+
+    CbcDynamicPseudoCostBranchingObject (CbcModel *model, int variable, int way,
+                                         double lowerValue, double upperValue) ;
+
+    /// Copy constructor
+    CbcDynamicPseudoCostBranchingObject ( const CbcDynamicPseudoCostBranchingObject &);
+
+    /// Assignment operator
+    CbcDynamicPseudoCostBranchingObject & operator= (const CbcDynamicPseudoCostBranchingObject& rhs);
+
+    /// Clone
+    virtual CbcBranchingObject * clone() const;
+
+    /// Destructor
+    virtual ~CbcDynamicPseudoCostBranchingObject ();
+
+    /// Does part of constructor
+    void fillPart (int variable,
+                   int way , double value,
+                   CbcSimpleIntegerDynamicPseudoCost * object) ;
+
+    using CbcBranchingObject::branch ;
+    /** \brief Sets the bounds for the variable according to the current arm
+           of the branch and advances the object state to the next arm.
+           This version also changes guessed objective value
+    */
+    virtual double branch();
+
+    /** Some branchingObjects may claim to be able to skip
+        strong branching.  If so they have to fill in CbcStrongInfo.
+        The object mention in incoming CbcStrongInfo must match.
+        Returns nonzero if skip is wanted */
+    virtual int fillStrongInfo( CbcStrongInfo & info);
+
+    /// Change in guessed
+    inline double changeInGuessed() const {
+        return changeInGuessed_;
+    }
+    /// Set change in guessed
+    inline void setChangeInGuessed(double value) {
+        changeInGuessed_ = value;
+    }
+    /// Return object
+    inline CbcSimpleIntegerDynamicPseudoCost * object() const {
+        return object_;
+    }
+    /// Set object
+    inline void setObject(CbcSimpleIntegerDynamicPseudoCost * object) {
+        object_ = object;
+    }
+
+    /** Return the type (an integer identifier) of \c this */
+    virtual CbcBranchObjType type() const {
+        return DynamicPseudoCostBranchObj;
+    }
+
+    // LL: compareOriginalObject and compareBranchingObject are inherited from
+    // CbcIntegerBranchingObject thus need not be declared/defined here. After
+    // all, this kind of branching object is simply using pseudocosts to make
+    // decisions, but once the decisions are made they are the same kind as in
+    // the underlying class.
+
+protected:
+    /// Change in guessed objective value for next branch
+    double changeInGuessed_;
+    /// Pointer back to object
+    CbcSimpleIntegerDynamicPseudoCost * object_;
+
+};
+
+#endif
+

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

@@ -0,0 +1,242 @@
+/* $Id: CbcBranchLotsize.hpp 1573 2011-01-05 01:12:36Z lou $ */
+// Copyright (C) 2004, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef CbcBranchLotsize_H
+#define CbcBranchLotsize_H
+
+#include "CbcBranchBase.hpp"
+/** Lotsize class */
+
+
+class CbcLotsize : public CbcObject {
+
+public:
+
+    // Default Constructor
+    CbcLotsize ();
+
+    /* Useful constructor - passed model index.
+       Also passed valid values - if range then pairs
+    */
+    CbcLotsize (CbcModel * model, int iColumn,
+                int numberPoints, const double * points, bool range = false);
+
+    // Copy constructor
+    CbcLotsize ( const CbcLotsize &);
+
+    /// Clone
+    virtual CbcObject * clone() const;
+
+    // Assignment operator
+    CbcLotsize & operator=( const CbcLotsize& rhs);
+
+    // Destructor
+    ~CbcLotsize ();
+
+    /// Infeasibility - large is 0.5
+    virtual double infeasibility(const OsiBranchingInformation * info,
+                                 int &preferredWay) const;
+
+    using CbcObject::feasibleRegion ;
+    /** Set bounds to contain the current solution.
+
+      More precisely, for the variable associated with this object, take the
+      value given in the current solution, force it within the current bounds
+      if required, then set the bounds to fix the variable at the integer
+      nearest the solution value.
+    */
+    virtual void feasibleRegion();
+
+    /// Creates a branching object
+    virtual CbcBranchingObject * createCbcBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) ;
+
+    /** \brief Given a valid solution (with reduced costs, etc.),
+        return a branching object which would give a new feasible
+        point in the good direction.
+
+      The preferred branching object will force the variable to be +/-1 from
+      its current value, depending on the reduced cost and objective sense.  If
+      movement in the direction which improves the objective is impossible due
+      to bounds on the variable, the branching object will move in the other
+      direction.  If no movement is possible, the method returns NULL.
+
+      Only the bounds on this variable are considered when determining if the new
+      point is feasible.
+    */
+    virtual CbcBranchingObject * preferredNewFeasible() const;
+
+    /** \brief Given a valid solution (with reduced costs, etc.),
+        return a branching object which would give a new feasible
+        point in a bad direction.
+
+      As for preferredNewFeasible(), but the preferred branching object will
+      force movement in a direction that degrades the objective.
+    */
+    virtual CbcBranchingObject * notPreferredNewFeasible() const ;
+
+    /** Reset original upper and lower bound values from the solver.
+
+      Handy for updating bounds held in this object after bounds held in the
+      solver have been tightened.
+     */
+    virtual void resetBounds(const OsiSolverInterface * solver);
+
+    /** Finds range of interest so value is feasible in range range_ or infeasible
+        between hi[range_] and lo[range_+1].  Returns true if feasible.
+    */
+    bool findRange(double value) const;
+
+    /** Returns floor and ceiling
+    */
+    virtual void floorCeiling(double & floorLotsize, double & ceilingLotsize, double value,
+                              double tolerance) const;
+
+    /// Model column number
+    inline int modelSequence() const {
+        return columnNumber_;
+    }
+    /// Set model column number
+    inline void setModelSequence(int value) {
+        columnNumber_ = value;
+    }
+
+    /** Column number if single column object -1 otherwise,
+        so returns >= 0
+        Used by heuristics
+    */
+    virtual int columnNumber() const;
+    /// Original variable bounds
+    inline double originalLowerBound() const {
+        return bound_[0];
+    }
+    inline double originalUpperBound() const {
+        return bound_[rangeType_*numberRanges_-1];
+    }
+    /// Type - 1 points, 2 ranges
+    inline int rangeType() const {
+        return rangeType_;
+    }
+    /// Number of points
+    inline int numberRanges() const {
+        return numberRanges_;
+    }
+    /// Ranges
+    inline double * bound() const {
+        return bound_;
+    }
+    /** \brief Return true if object can take part in normal heuristics
+    */
+    virtual bool canDoHeuristics() const {
+        return false;
+    }
+
+private:
+    /// Just for debug (CBC_PRINT defined in CbcBranchLotsize.cpp)
+    void printLotsize(double value, bool condition, int type) const;
+
+private:
+    /// data
+
+    /// Column number in model
+    int columnNumber_;
+    /// Type - 1 points, 2 ranges
+    int rangeType_;
+    /// Number of points
+    int numberRanges_;
+    // largest gap
+    double largestGap_;
+    /// Ranges
+    double * bound_;
+    /// Current range
+    mutable int range_;
+};
+
+/** Lotsize branching object
+
+  This object can specify a two-way branch on an integer variable. For each
+  arm of the branch, the upper and lower bounds on the variable can be
+  independently specified.
+
+  Variable_ holds the index of the integer variable in the integerVariable_
+  array of the model.
+*/
+
+class CbcLotsizeBranchingObject : public CbcBranchingObject {
+
+public:
+
+    /// Default constructor
+    CbcLotsizeBranchingObject ();
+
+    /** Create a lotsize floor/ceiling branch object
+
+      Specifies a simple two-way branch. Let \p value = x*. One arm of the
+      branch will be is lb <= x <= valid range below(x*), the other valid range above(x*) <= x <= ub.
+      Specify way = -1 to set the object state to perform the down arm first,
+      way = 1 for the up arm.
+    */
+    CbcLotsizeBranchingObject (CbcModel *model, int variable,
+                               int way , double value, const CbcLotsize * lotsize) ;
+
+    /** Create a degenerate branch object
+
+      Specifies a `one-way branch'. Calling branch() for this object will
+      always result in lowerValue <= x <= upperValue. Used to fix in valid range
+    */
+
+    CbcLotsizeBranchingObject (CbcModel *model, int variable, int way,
+                               double lowerValue, double upperValue) ;
+
+    /// Copy constructor
+    CbcLotsizeBranchingObject ( const CbcLotsizeBranchingObject &);
+
+    /// Assignment operator
+    CbcLotsizeBranchingObject & operator= (const CbcLotsizeBranchingObject& rhs);
+
+    /// Clone
+    virtual CbcBranchingObject * clone() const;
+
+    /// Destructor
+    virtual ~CbcLotsizeBranchingObject ();
+
+    using CbcBranchingObject::branch ;
+    /** \brief Sets the bounds for the variable according to the current arm
+           of the branch and advances the object state to the next arm.
+    */
+    virtual double branch();
+
+    using CbcBranchingObject::print ;
+    /** \brief Print something about branch - only if log level high
+    */
+    virtual void print();
+
+    /** Return the type (an integer identifier) of \c this */
+    virtual CbcBranchObjType type() const {
+        return LotsizeBranchObj;
+    }
+
+    // LL: compareOriginalObject can be inherited from the CbcBranchingObject
+    // since variable_ uniquely defines the lot sizing object.
+
+    /** Compare the \c this with \c brObj. \c this and \c brObj must be os the
+        same type and must have the same original object, but they may have
+        different feasible regions.
+        Return the appropriate CbcRangeCompare value (first argument being the
+        sub/superset if that's the case). In case of overlap (and if \c
+        replaceIfOverlap is true) replace the current branching object with one
+        whose feasible region is the overlap.
+     */
+    virtual CbcRangeCompare compareBranchingObject
+    (const CbcBranchingObject* brObj, const bool replaceIfOverlap = false);
+
+protected:
+    /// Lower [0] and upper [1] bounds for the down arm (way_ = -1)
+    double down_[2];
+    /// Lower [0] and upper [1] bounds for the up arm (way_ = 1)
+    double up_[2];
+};
+
+#endif
+

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

@@ -0,0 +1,94 @@
+// $Id: CbcBranchToFixLots.hpp 1899 2013-04-09 18:12:08Z stefan $
+// Copyright (C) 2004, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+// Edwin 11/13/2009-- carved out of CbcBranchCut
+
+#ifndef CbcBranchToFixLots_H
+#define CbcBranchToFixLots_H
+
+#include "CbcBranchCut.hpp"
+#include "CbcBranchBase.hpp"
+#include "OsiRowCut.hpp"
+#include "CoinPackedMatrix.hpp"
+
+/** Define a branch class that branches so that one way variables are fixed
+    while the other way cuts off that solution.
+    a) On reduced cost
+    b) When enough ==1 or <=1 rows have been satisfied (not fixed - satisfied)
+*/
+
+
+class CbcBranchToFixLots : public CbcBranchCut {
+
+public:
+
+    // Default Constructor
+    CbcBranchToFixLots ();
+
+    /** Useful constructor - passed reduced cost tolerance and fraction we would like fixed.
+        Also depth level to do at.
+        Also passed number of 1 rows which when clean triggers fix
+        Always does if all 1 rows cleaned up and number>0 or if fraction columns reached
+        Also whether to create branch if can't reach fraction.
+    */
+    CbcBranchToFixLots (CbcModel * model, double djTolerance,
+                        double fractionFixed, int depth,
+                        int numberClean = 0,
+                        const char * mark = NULL,
+                        bool alwaysCreate = false);
+
+    // Copy constructor
+    CbcBranchToFixLots ( const CbcBranchToFixLots &);
+
+    /// Clone
+    virtual CbcObject * clone() const;
+
+    // Assignment operator
+    CbcBranchToFixLots & operator=( const CbcBranchToFixLots& rhs);
+
+    // Destructor
+    ~CbcBranchToFixLots ();
+
+    /** Does a lot of the work,
+        Returns 0 if no good, 1 if dj, 2 if clean, 3 if both
+	FIXME: should use enum or equivalent to make these numbers clearer.
+    */
+    int shallWe() const;
+
+    /// Infeasibility for an integer variable - large is 0.5, but also can be infinity when known infeasible.
+    virtual double infeasibility(const OsiBranchingInformation * info,
+                                 int &preferredWay) const;
+    /** \brief Return true if object can take part in normal heuristics
+    */
+    virtual bool canDoHeuristics() const {
+        return true;
+    }
+
+    /// Creates a branching object
+    virtual CbcBranchingObject * createCbcBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) ;
+    /// Redoes data when sequence numbers change
+    virtual void redoSequenceEtc(CbcModel * model, int numberColumns, const int * originalColumns);
+
+
+protected:
+    /// data
+
+    /// Reduced cost tolerance i.e. dj has to be >= this before fixed
+    double djTolerance_;
+    /// We only need to make sure this fraction fixed
+    double fractionFixed_;
+    /// Never fix ones marked here
+    char * mark_;
+    /// Matrix by row
+    CoinPackedMatrix matrixByRow_;
+    /// Do if depth multiple of this
+    int depth_;
+    /// number of ==1 rows which need to be clean
+    int numberClean_;
+    /// If true then always create branch
+    bool alwaysCreate_;
+};
+#endif
+