ruby-cbc 0.1.9

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

@@ -0,0 +1,349 @@
+// $Id: CbcNodeInfo.hpp 2048 2014-07-16 09:29:16Z 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).
+
+// Edwin 11/24/09 carved from CbcNode
+
+#ifndef CbcNodeInfo_H
+#define CbcNodeInfo_H
+
+#include <string>
+#include <vector>
+
+#include "CoinWarmStartBasis.hpp"
+#include "CoinSearchTree.hpp"
+#include "CbcBranchBase.hpp"
+
+class OsiSolverInterface;
+class OsiSolverBranch;
+
+class OsiCuts;
+class OsiRowCut;
+class OsiRowCutDebugger;
+class CoinWarmStartBasis;
+class CbcCountRowCut;
+class CbcModel;
+class CbcNode;
+class CbcSubProblem;
+class CbcGeneralBranchingObject;
+
+//#############################################################################
+/** Information required to recreate the subproblem at this node
+
+  When a subproblem is initially created, it is represented by a CbcNode
+  object and an attached CbcNodeInfo object.
+
+  The CbcNode contains information needed while the subproblem remains live.
+  The CbcNode is deleted when the last branch arm has been evaluated.
+
+  The CbcNodeInfo contains information required to maintain the branch-and-cut
+  search tree structure (links and reference counts) and to recreate the
+  subproblem for this node (basis, variable bounds, cutting planes). A
+  CbcNodeInfo object remains in existence until all nodes have been pruned from
+  the subtree rooted at this node.
+
+  The principle used to maintain the reference count is that the reference
+  count is always the sum of all potential and actual children of the node.
+  Specifically,
+  <ul>
+    <li> Once it's determined how the node will branch, the reference count
+	 is set to the number of potential children (<i>i.e.</i>, the number
+	 of arms of the branch).
+    <li> As each child is created by CbcNode::branch() (converting a potential
+	 child to the active subproblem), the reference count is decremented.
+    <li> If the child survives and will become a node in the search tree
+	 (converting the active subproblem into an actual child), increment the
+	 reference count.
+  </ul>
+  Notice that the active subproblem lives in a sort of limbo, neither a
+  potential or an actual node in the branch-and-cut tree.
+
+  CbcNodeInfo objects come in two flavours. A CbcFullNodeInfo object contains
+  a full record of the information required to recreate a subproblem.
+  A CbcPartialNodeInfo object expresses this information in terms of
+  differences from the parent.
+*/
+
+class CbcNodeInfo {
+
+public:
+
+    /** \name Constructors & destructors */
+//@{
+    /** Default Constructor
+
+      Creates an empty NodeInfo object.
+    */
+    CbcNodeInfo ();
+
+    /// Copy constructor
+    CbcNodeInfo ( const CbcNodeInfo &);
+
+#ifdef JJF_ZERO
+    /** Construct with parent
+
+      Creates a NodeInfo object which knows its parent and assumes it will
+      in turn have two children.
+    */
+    CbcNodeInfo (CbcNodeInfo * parent);
+#endif
+
+    /** Construct with parent and owner
+
+      As for `construct with parent', and attached to \p owner.
+    */
+    CbcNodeInfo (CbcNodeInfo * parent, CbcNode * owner);
+
+    /** Destructor
+
+      Note that the destructor will recursively delete the parent if this
+      nodeInfo is the last child.
+    */
+    virtual ~CbcNodeInfo();
+//@}
+
+
+    /** \brief Modify model according to information at node
+
+        The routine modifies the model according to bound and basis
+        information at node and adds any cuts to the addCuts array.
+    */
+    virtual void applyToModel (CbcModel *model, CoinWarmStartBasis *&basis,
+                               CbcCountRowCut **addCuts,
+                               int &currentNumberCuts) const = 0 ;
+    /// Just apply bounds to one variable - force means overwrite by lower,upper (1=>infeasible)
+    virtual int applyBounds(int iColumn, double & lower, double & upper, int force) = 0;
+
+    /** Builds up row basis backwards (until original model).
+        Returns NULL or previous one to apply .
+        Depends on Free being 0 and impossible for cuts
+    */
+    virtual CbcNodeInfo * buildRowBasis(CoinWarmStartBasis & basis) const = 0;
+    /// Clone
+    virtual CbcNodeInfo * clone() const = 0;
+    /// Called when number branches left down to zero
+    virtual void allBranchesGone() {}
+#ifndef JJF_ONE
+    /// Increment number of references
+    inline void increment(int amount = 1) {
+        numberPointingToThis_ += amount;/*printf("CbcNodeInfo %x incremented by %d to %d\n",this,amount,numberPointingToThis_);*/
+    }
+
+    /// Decrement number of references and return number left
+    inline int decrement(int amount = 1) {
+        numberPointingToThis_ -= amount;/*printf("CbcNodeInfo %x decremented by %d to %d\n",this,amount,numberPointingToThis_);*/
+        return numberPointingToThis_;
+    }
+#else
+    /// Increment number of references
+    void increment(int amount = 1);
+    /// Decrement number of references and return number left
+    int decrement(int amount = 1);
+#endif
+    /** Initialize reference counts
+
+      Initialize the reference counts used for tree maintenance.
+    */
+
+    inline void initializeInfo(int number) {
+        numberPointingToThis_ = number;
+        numberBranchesLeft_ = number;
+    }
+
+    /// Return number of branches left in object
+    inline int numberBranchesLeft() const {
+        return numberBranchesLeft_;
+    }
+
+    /// Set number of branches left in object
+    inline void setNumberBranchesLeft(int value) {
+        numberBranchesLeft_ = value;
+    }
+
+    /// Return number of objects pointing to this
+    inline int numberPointingToThis() const {
+        return numberPointingToThis_;
+    }
+
+    /// Set number of objects pointing to this
+    inline void setNumberPointingToThis(int number) {
+        numberPointingToThis_ = number;
+    }
+
+    /// Increment number of objects pointing to this
+    inline void incrementNumberPointingToThis() {
+        numberPointingToThis_ ++;
+    }
+
+    /// Say one branch taken
+    inline int branchedOn() {
+        numberPointingToThis_--;
+        numberBranchesLeft_--;
+        return numberBranchesLeft_;
+    }
+
+    /// Say thrown away
+    inline void throwAway() {
+        numberPointingToThis_ -= numberBranchesLeft_;
+        numberBranchesLeft_ = 0;
+    }
+
+    /// Parent of this
+    CbcNodeInfo * parent() const {
+        return parent_;
+    }
+    /// Set parent null
+    inline void nullParent() {
+        parent_ = NULL;
+    }
+
+    void addCuts(OsiCuts & cuts, int numberToBranch, //int * whichGenerator,
+                 int numberPointingToThis);
+    void addCuts(int numberCuts, CbcCountRowCut ** cuts, int numberToBranch);
+    /** Delete cuts (decrements counts)
+        Slow unless cuts in same order as saved
+    */
+    void deleteCuts(int numberToDelete, CbcCountRowCut ** cuts);
+    void deleteCuts(int numberToDelete, int * which);
+
+    /// Really delete a cut
+    void deleteCut(int whichOne);
+
+    /// Decrement active cut counts
+    void decrementCuts(int change = 1);
+
+    /// Increment active cut counts
+    void incrementCuts(int change = 1);
+
+    /// Decrement all active cut counts in chain starting at parent
+    void decrementParentCuts(CbcModel * model, int change = 1);
+
+    /// Increment all active cut counts in parent chain
+    void incrementParentCuts(CbcModel * model, int change = 1);
+
+    /// Array of pointers to cuts
+    inline CbcCountRowCut ** cuts() const {
+        return cuts_;
+    }
+
+    /// Number of row cuts (this node)
+    inline int numberCuts() const {
+        return numberCuts_;
+    }
+    inline void setNumberCuts(int value) {
+        numberCuts_ = value;
+    }
+
+    /// Set owner null
+    inline void nullOwner() {
+        owner_ = NULL;
+    }
+    const inline CbcNode * owner() const {
+        return owner_;
+    }
+    inline CbcNode * mutableOwner() const {
+        return owner_;
+    }
+    /// The node number
+    inline int nodeNumber() const {
+        return nodeNumber_;
+    }
+    inline void setNodeNumber(int node) {
+        nodeNumber_ = node;
+    }
+    /** Deactivate node information.
+        1 - bounds
+        2 - cuts
+        4 - basis!
+	8 - just marked
+	16 - symmetry branching worked
+    */
+    void deactivate(int mode = 3);
+    /// Say if normal
+    inline bool allActivated() const {
+        return ((active_&7) == 7);
+    }
+    /// Say if marked
+    inline bool marked() const {
+        return ((active_&8) != 0);
+    }
+    /// Mark
+    inline void mark() {
+        active_ |= 8;
+    }
+    /// Unmark
+    inline void unmark() {
+        active_ &= ~8;
+    }
+    /// Get symmetry value (true worked at this node)
+    inline bool symmetryWorked() const
+    { return (active_&16) !=0;}
+    /// Say symmetry worked at this node)
+    inline void setSymmetryWorked()
+    { active_ |= 16;}
+
+    /// Branching object for the parent
+    inline const OsiBranchingObject * parentBranch() const {
+        return parentBranch_;
+    }
+    /// If we need to take off parent based data
+    void unsetParentBasedData();
+protected:
+
+    /** Number of other nodes pointing to this node.
+
+      Number of existing and potential search tree nodes pointing to this node.
+      `Existing' means referenced by #parent_ of some other CbcNodeInfo.
+      `Potential' means children still to be created (#numberBranchesLeft_ of
+      this CbcNodeInfo).
+    */
+    int numberPointingToThis_;
+
+    /// parent
+    CbcNodeInfo * parent_;
+
+    /// Copy of the branching object of the parent when the node is created
+    OsiBranchingObject * parentBranch_;
+
+    /// Owner
+    CbcNode * owner_;
+
+    /// Number of row cuts (this node)
+    int numberCuts_;
+
+    /// The node number
+    int nodeNumber_;
+
+    /// Array of pointers to cuts
+    CbcCountRowCut ** cuts_;
+
+    /** Number of rows in problem (before these cuts).  This
+        means that for top of chain it must be rows at continuous */
+    int numberRows_;
+
+    /** Number of branch arms left to explore at this node
+
+      \todo There seems to be redundancy between this field and
+        CbcBranchingObject::numberBranchesLeft_. It'd be good to sort out if
+        both are necessary.
+    */
+    int numberBranchesLeft_;
+    /** Active node information.
+        1 - bounds
+        2 - cuts
+        4 - basis!
+    */
+    int active_;
+
+private:
+
+    /// Illegal Assignment operator
+    CbcNodeInfo & operator=(const CbcNodeInfo& rhs);
+
+    /// routine common to constructors
+    void setParentBasedData();
+};
+
+#endif // CbcNodeInfo_H
+

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

@@ -0,0 +1,272 @@
+// $Id: CbcObject.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 CbcObject_H
+#define CbcObject_H
+
+#include <string>
+#include <vector>
+#include "OsiBranchingObject.hpp"
+class OsiSolverInterface;
+class OsiSolverBranch;
+
+class CbcModel;
+class CbcNode;
+class CbcNodeInfo;
+class CbcBranchingObject;
+class OsiChooseVariable;
+class CbcObjectUpdateData;
+//#############################################################################
+
+/** Abstract base class for `objects'.
+    It now just has stuff that OsiObject does not have
+
+  The branching model used in Cbc is based on the idea of an <i>object</i>.
+  In the abstract, an object is something that has a feasible region, can be
+  evaluated for infeasibility, can be branched on (<i>i.e.</i>, there's some
+  constructive action to be taken to move toward feasibility), and allows
+  comparison of the effect of branching.
+
+  This class (CbcObject) is the base class for an object. To round out the
+  branching model, the class CbcBranchingObject describes how to perform a
+  branch, and the class CbcBranchDecision describes how to compare two
+  CbcBranchingObjects.
+
+  To create a new type of object you need to provide three methods:
+  #infeasibility(), #feasibleRegion(), and #createCbcBranch(), described below.
+
+  This base class is primarily virtual to allow for any form of structure.
+  Any form of discontinuity is allowed.
+
+  \todo The notion that all branches are binary (two arms) is wired into the
+	implementation of CbcObject, CbcBranchingObject, and
+	CbcBranchDecision. Changing this will require a moderate amount of
+	recoding.
+ */
+// This can be used if object wants to skip strong branching
+typedef struct {
+    CbcBranchingObject * possibleBranch; // what a branch would do
+    double upMovement; // cost going up (and initial away from feasible)
+    double downMovement; // cost going down
+    int numIntInfeasUp ; // without odd ones
+    int numObjInfeasUp ; // just odd ones
+    bool finishedUp; // true if solver finished
+    int numItersUp ; // number of iterations in solver
+    int numIntInfeasDown ; // without odd ones
+    int numObjInfeasDown ; // just odd ones
+    bool finishedDown; // true if solver finished
+    int numItersDown; // number of iterations in solver
+    int objectNumber; // Which object it is
+    int fix; // 0 if no fix, 1 if we can fix up, -1 if we can fix down
+} CbcStrongInfo;
+
+class CbcObject : public OsiObject {
+
+public:
+
+    // Default Constructor
+    CbcObject ();
+
+    // Useful constructor
+    CbcObject (CbcModel * model);
+
+    // Copy constructor
+    CbcObject ( const CbcObject &);
+
+    // Assignment operator
+    CbcObject & operator=( const CbcObject& rhs);
+
+    /// Clone
+    virtual CbcObject * clone() const = 0;
+
+    /// Destructor
+    virtual ~CbcObject ();
+
+    /** Infeasibility of the object
+
+        This is some measure of the infeasibility of the object. It should be
+        scaled to be in the range [0.0, 0.5], with 0.0 indicating the object
+        is satisfied.
+
+        The preferred branching direction is returned in preferredWay,
+
+        This is used to prepare for strong branching but should also think of
+        case when no strong branching
+
+        The object may also compute an estimate of cost of going "up" or "down".
+        This will probably be based on pseudo-cost ideas
+    */
+#ifdef CBC_NEW_STYLE_BRANCH
+    virtual double infeasibility(const OsiBranchingInformation * info,
+                                 int &preferredWay) const = 0;
+#else
+    virtual double infeasibility(const OsiBranchingInformation * /*info*/,
+                                 int &preferredWay) const {
+        return infeasibility(preferredWay);
+    }
+    virtual double infeasibility(int &/*preferredWay*/) const {
+        throw CoinError("Need code", "infeasibility", "CbcBranchBase");
+    }
+#endif
+
+    /** For the variable(s) referenced by the object,
+        look at the current solution and set bounds to match the solution.
+    */
+    virtual void feasibleRegion() = 0;
+    /// Dummy one for compatibility
+    virtual double feasibleRegion(OsiSolverInterface * solver, const OsiBranchingInformation * info) const;
+
+    /** For the variable(s) referenced by the object,
+        look at the current solution and set bounds to match the solution.
+        Returns measure of how much it had to move solution to make feasible
+    */
+    virtual double feasibleRegion(OsiSolverInterface * solver) const ;
+
+    /** Create a branching object and indicate which way to branch first.
+
+        The branching object has to know how to create branches (fix
+        variables, etc.)
+    */
+#ifdef CBC_NEW_STYLE_BRANCH
+    virtual CbcBranchingObject * createCbcBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) = 0;
+#else
+  virtual CbcBranchingObject * createCbcBranch(OsiSolverInterface *
+                                               /* solver */,
+                                               const OsiBranchingInformation *
+                                               /* info */, int /* way */) {
+        // return createBranch(solver, info, way);
+      return NULL;
+    }
+    virtual OsiBranchingObject * createBranch(OsiSolverInterface * /*solver*/,
+            const OsiBranchingInformation * /*info*/, int /*way*/) const {
+        throw CoinError("Need code", "createBranch", "CbcBranchBase");
+    }
+#endif
+    /** Create an Osibranching object and indicate which way to branch first.
+
+        The branching object has to know how to create branches (fix
+        variables, etc.)
+    */
+    virtual OsiBranchingObject * createOsiBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) const;
+    /** Create an OsiSolverBranch object
+
+        This returns NULL if branch not represented by bound changes
+    */
+    virtual OsiSolverBranch * solverBranch() const;
+
+    /** \brief Given a valid solution (with reduced costs, etc.),
+        return a branching object which would give a new feasible
+        point in a good direction.
+
+        If the method cannot generate a feasible point (because there aren't
+        any, or because it isn't bright enough to find one), it should
+        return null.
+    */
+    virtual CbcBranchingObject * preferredNewFeasible() const {
+        return NULL;
+    }
+
+    /** \brief Given a valid solution (with reduced costs, etc.),
+        return a branching object which would give a new feasible
+        point in a bad direction.
+
+        If the method cannot generate a feasible point (because there aren't
+        any, or because it isn't bright enough to find one), it should
+        return null.
+    */
+    virtual CbcBranchingObject * notPreferredNewFeasible() const {
+        return NULL;
+    }
+
+    /** Reset variable bounds to their original values.
+
+      Bounds may be tightened, so it may be good to be able to set this info in object.
+     */
+    virtual void resetBounds(const OsiSolverInterface * ) {}
+
+    /** Returns floor and ceiling i.e. closest valid points
+    */
+    virtual void floorCeiling(double & floorValue, double & ceilingValue, double value,
+                              double tolerance) const;
+
+    /** Pass in information on branch just done and create CbcObjectUpdateData instance.
+        If object does not need data then backward pointer will be NULL.
+        Assumes can get information from solver */
+    virtual CbcObjectUpdateData createUpdateInformation(const OsiSolverInterface * solver,
+            const CbcNode * node,
+            const CbcBranchingObject * branchingObject);
+
+    /// Update object by CbcObjectUpdateData
+    virtual void updateInformation(const CbcObjectUpdateData & ) {}
+
+    /// Identifier (normally column number in matrix)
+    inline int id() const {
+        return id_;
+    }
+
+    /** Set identifier (normally column number in matrix)
+        but 1000000000 to 1100000000 means optional branching object
+        i.e. code would work without it */
+    inline void setId(int value) {
+        id_ = value;
+    }
+
+    /** Return true if optional branching object
+        i.e. code would work without it */
+    inline bool optionalObject() const {
+        return (id_ >= 1000000000 && id_ < 1100000000);
+    }
+
+    /// Get position in object_ list
+    inline int position() const {
+        return position_;
+    }
+
+    /// Set position in object_ list
+    inline void setPosition(int position) {
+        position_ = position;
+    }
+
+    /// update model
+    inline void setModel(CbcModel * model) {
+        model_ = model;
+    }
+
+    /// Return model
+    inline CbcModel * model() const {
+        return  model_;
+    }
+
+    /// If -1 down always chosen first, +1 up always, 0 normal
+    inline int preferredWay() const {
+        return preferredWay_;
+    }
+    /// Set -1 down always chosen first, +1 up always, 0 normal
+    inline void setPreferredWay(int value) {
+        preferredWay_ = value;
+    }
+    /// Redoes data when sequence numbers change
+    virtual void redoSequenceEtc(CbcModel * , int , const int * ) {}
+    /// Initialize for branching
+    virtual void initializeForBranching(CbcModel * ) {}
+
+protected:
+    /// data
+
+    /// Model
+    CbcModel * model_;
+    /// Identifier (normally column number in matrix)
+    int id_;
+    /// Position in object list
+    int position_;
+    /// If -1 down always chosen first, +1 up always, 0 normal
+    int preferredWay_;
+
+};
+
+#endif
+

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

@@ -0,0 +1,64 @@
+// $Id: CbcObjectUpdateData.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 CbcObjectUpdateData_H
+#define CbcObjectUpdateData_H
+
+#include "CbcObject.hpp"
+/*  This stores data so an object can be updated
+ */
+class CbcObjectUpdateData {
+
+public:
+
+    /// Default Constructor
+    CbcObjectUpdateData ();
+
+    /// Useful constructor
+    CbcObjectUpdateData (CbcObject * object,
+                         int way,
+                         double change,
+                         int status,
+                         int intDecrease_,
+                         double branchingValue);
+
+    /// Copy constructor
+    CbcObjectUpdateData ( const CbcObjectUpdateData &);
+
+    /// Assignment operator
+    CbcObjectUpdateData & operator=( const CbcObjectUpdateData& rhs);
+
+    /// Destructor
+    virtual ~CbcObjectUpdateData ();
+
+
+public:
+    /// data
+
+    /// Object
+    CbcObject * object_;
+    /// Branch as defined by instance of CbcObject
+    int way_;
+    /// Object number
+    int objectNumber_;
+    /// Change in objective
+    double change_;
+    /// Status 0 Optimal, 1 infeasible, 2 unknown
+    int status_;
+    /// Decrease in number unsatisfied
+    int intDecrease_;
+    /// Branching value
+    double branchingValue_;
+    /// Objective value before branching
+    double originalObjective_;
+    /// Current cutoff
+    double cutoff_;
+
+};
+
+#endif
+