ruby-cbc 0.1.9

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

@@ -0,0 +1,166 @@
+// $Id: CbcNWay.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/9/2009-- carved out of CbcBranchActual
+
+/** Define an n-way class for variables.
+    Only valid value is one at UB others at LB
+    Normally 0-1
+*/
+#ifndef CbcNWay_H
+#define CbcNWay_H
+
+class CbcNWay : public CbcObject {
+
+public:
+
+    // Default Constructor
+    CbcNWay ();
+
+    /** Useful constructor (which are matrix indices)
+    */
+    CbcNWay (CbcModel * model, int numberMembers,
+             const int * which, int identifier);
+
+    // Copy constructor
+    CbcNWay ( const CbcNWay &);
+
+    /// Clone
+    virtual CbcObject * clone() const;
+
+    /// Assignment operator
+    CbcNWay & operator=( const CbcNWay& rhs);
+
+    /// Destructor
+    virtual ~CbcNWay ();
+
+    /// Set up a consequence for a single member
+    void setConsequence(int iColumn, const CbcConsequence & consequence);
+
+    /// Applies a consequence for a single member
+    void applyConsequence(int iSequence, int state) const;
+
+    /// Infeasibility - large is 0.5 (and 0.5 will give this)
+    virtual double infeasibility(const OsiBranchingInformation * info,
+                                 int &preferredWay) const;
+
+    using CbcObject::feasibleRegion ;
+    /// This looks at solution and sets bounds to contain solution
+    virtual void feasibleRegion();
+
+    /// Creates a branching object
+    virtual CbcBranchingObject * createCbcBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) ;
+
+    /// Number of members
+    inline int numberMembers() const {
+        return numberMembers_;
+    }
+
+    /// Members (indices in range 0 ... numberColumns-1)
+    inline const int * members() const {
+        return members_;
+    }
+    /// Redoes data when sequence numbers change
+    virtual void redoSequenceEtc(CbcModel * model, int numberColumns, const int * originalColumns);
+
+protected:
+    /// data
+    /// Number of members
+    int numberMembers_;
+
+    /// Members (indices in range 0 ... numberColumns-1)
+    int * members_;
+    /// Consequences (normally NULL)
+    CbcConsequence ** consequence_;
+};
+/** N way branching Object class.
+    Variable is number of set.
+ */
+class CbcNWayBranchingObject : public CbcBranchingObject {
+
+public:
+
+    // Default Constructor
+    CbcNWayBranchingObject ();
+
+    /** Useful constructor - order had matrix indices
+        way_ -1 corresponds to setting first, +1 to second, +3 etc.
+        this is so -1 and +1 have similarity to normal
+    */
+    CbcNWayBranchingObject (CbcModel * model,  const CbcNWay * nway,
+                            int numberBranches, const int * order);
+
+    // Copy constructor
+    CbcNWayBranchingObject ( const CbcNWayBranchingObject &);
+
+    // Assignment operator
+    CbcNWayBranchingObject & operator=( const CbcNWayBranchingObject& rhs);
+
+    /// Clone
+    virtual CbcBranchingObject * clone() const;
+
+    // Destructor
+    virtual ~CbcNWayBranchingObject ();
+
+    using CbcBranchingObject::branch ;
+    /// Does next branch and updates state
+    virtual double branch();
+
+#ifdef JJF_ZERO
+    // FIXME: what do we need to do here?
+    /** Reset every information so that the branching object appears to point to
+        the previous child. This method does not need to modify anything in any
+        solver. */
+    virtual void previousBranch();
+#endif
+
+    using CbcBranchingObject::print ;
+    /** \brief Print something about branch - only if log level high
+    */
+    virtual void print();
+    /** The number of branch arms created for this branching object
+    */
+    virtual int numberBranches() const {
+        return numberInSet_;
+    }
+    /// Is this a two way object (-1 down, +1 up)
+    virtual bool twoWay() const {
+        return false;
+    }
+
+    /** Return the type (an integer identifier) of \c this */
+    virtual CbcBranchObjType type() const {
+        return NWayBranchObj;
+    }
+
+    /** Compare the original object of \c this with the original object of \c
+        brObj. Assumes that there is an ordering of the original objects.
+        This method should be invoked only if \c this and brObj are of the same
+        type.
+        Return negative/0/positive depending on whether \c this is
+        smaller/same/larger than the argument.
+    */
+    virtual int compareOriginalObject(const CbcBranchingObject* brObj) const;
+
+    /** 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);
+
+private:
+    /// order of branching - points back to CbcNWay
+    int * order_;
+    /// Points back to object
+    const CbcNWay * object_;
+    /// Number in set
+    int numberInSet_;
+};
+#endif

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

@@ -0,0 +1,351 @@
+/* $Id: CbcNode.hpp 1957 2013-08-27 15:19:55Z 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 CbcNode_H
+#define CbcNode_H
+
+#include <string>
+#include <vector>
+
+#include "CoinWarmStartBasis.hpp"
+#include "CoinSearchTree.hpp"
+#include "CbcBranchBase.hpp"
+#include "CbcNodeInfo.hpp"
+#include "CbcFullNodeInfo.hpp"
+#include "CbcPartialNodeInfo.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 while the node is live
+
+  When a subproblem is initially created, it is represented by an CbcNode
+  object and an attached CbcNodeInfo object.
+
+  The CbcNode contains information (depth, branching instructions), that's
+  needed while the subproblem remains `live', <i>i.e.</i>, while the
+  subproblem is not fathomed and there are branch arms still be be
+  evaluated.  The CbcNode is deleted when the last branch arm has been
+  evaluated.
+
+  The CbcNodeInfo object contains the information needed to maintain the
+  search tree and recreate the subproblem for the node. It remains in
+  existence until there are no nodes remaining in the subtree rooted at this
+  node.
+*/
+
+class CbcNode : public CoinTreeNode {
+
+public:
+
+    /// Default Constructor
+    CbcNode ();
+
+    /// Construct and increment parent reference count
+    CbcNode (CbcModel * model, CbcNode * lastNode);
+
+    /// Copy constructor
+    CbcNode (const CbcNode &);
+
+    /// Assignment operator
+    CbcNode & operator= (const CbcNode& rhs);
+
+    /// Destructor
+    ~CbcNode ();
+
+    /** Create a description of the subproblem at this node
+
+      The CbcNodeInfo structure holds the information (basis & variable bounds)
+      required to recreate the subproblem for this node. It also links the node
+      to its parent (via the parent's CbcNodeInfo object).
+
+      If lastNode == NULL, a CbcFullNodeInfo object will be created. All
+      parameters except \p model are unused.
+
+      If lastNode != NULL, a CbcPartialNodeInfo object will be created. Basis and
+      bounds information will be stored in the form of differences between the
+      parent subproblem and this subproblem.
+      (More precisely, \p lastws, \p lastUpper, \p lastLower,
+      \p numberOldActiveCuts, and \p numberNewCuts are used.)
+    */
+    void
+    createInfo(CbcModel * model,
+               CbcNode * lastNode,
+               const CoinWarmStartBasis *lastws,
+               const double * lastLower, const double * lastUpper,
+               int numberOldActiveCuts, int numberNewCuts);
+
+    /** Create a branching object for the node
+
+      The routine scans the object list of the model and selects a set of
+      unsatisfied objects as candidates for branching. The candidates are
+      evaluated, and an appropriate branch object is installed.
+
+      The numberPassesLeft is decremented to stop fixing one variable each time
+      and going on and on (e.g. for stock cutting, air crew scheduling)
+
+      If evaluation determines that an object is monotone or infeasible,
+      the routine returns immediately. In the case of a monotone object,
+      the branch object has already been called to modify the model.
+
+      Return value:
+      <ul>
+        <li>  0: A branching object has been installed
+        <li> -1: A monotone object was discovered
+        <li> -2: An infeasible object was discovered
+      </ul>
+    */
+    int chooseBranch (CbcModel * model,
+                      CbcNode * lastNode,
+                      int numberPassesLeft);
+    /** Create a branching object for the node - when dynamic pseudo costs
+
+      The routine scans the object list of the model and selects a set of
+      unsatisfied objects as candidates for branching. The candidates are
+      evaluated, and an appropriate branch object is installed.
+      This version gives preference in evaluation to variables which
+      have not been evaluated many times.  It also uses numberStrong
+      to say give up if last few tries have not changed incumbent.
+      See Achterberg, Koch and Martin.
+
+      The numberPassesLeft is decremented to stop fixing one variable each time
+      and going on and on (e.g. for stock cutting, air crew scheduling)
+
+      If evaluation determines that an object is monotone or infeasible,
+      the routine returns immediately. In the case of a monotone object,
+      the branch object has already been called to modify the model.
+
+      Return value:
+      <ul>
+        <li>  0: A branching object has been installed
+        <li> -1: A monotone object was discovered
+        <li> -2: An infeasible object was discovered
+        <li> >0: Number of quich branching objects (and branches will be non NULL)
+      </ul>
+    */
+    int chooseDynamicBranch (CbcModel * model,
+                             CbcNode * lastNode,
+                             OsiSolverBranch * & branches,
+                             int numberPassesLeft);
+    /** Create a branching object for the node
+
+      The routine scans the object list of the model and selects a set of
+      unsatisfied objects as candidates for branching. The candidates are
+      evaluated, and an appropriate branch object is installed.
+
+      The numberPassesLeft is decremented to stop fixing one variable each time
+      and going on and on (e.g. for stock cutting, air crew scheduling)
+
+      If evaluation determines that an object is monotone or infeasible,
+      the routine returns immediately. In the case of a monotone object,
+      the branch object has already been called to modify the model.
+
+      Return value:
+      <ul>
+        <li>  0: A branching object has been installed
+        <li> -1: A monotone object was discovered
+        <li> -2: An infeasible object was discovered
+      </ul>
+      Branch state:
+      <ul>
+        <li> -1: start
+        <li> -1: A monotone object was discovered
+        <li> -2: An infeasible object was discovered
+      </ul>
+    */
+    int chooseOsiBranch (CbcModel * model,
+                         CbcNode * lastNode,
+                         OsiBranchingInformation * usefulInfo,
+                         int branchState);
+    /** Create a branching object for the node
+
+      The routine scans the object list of the model and selects a set of
+      unsatisfied objects as candidates for branching. It then solves a
+      series of problems and a CbcGeneral branch object is installed.
+
+      If evaluation determines that an object is infeasible,
+      the routine returns immediately.
+
+      Return value:
+      <ul>
+        <li>  0: A branching object has been installed
+        <li> -2: An infeasible object was discovered
+      </ul>
+    */
+    int chooseClpBranch (CbcModel * model,
+                         CbcNode * lastNode);
+    int analyze(CbcModel * model, double * results);
+    /// Decrement active cut counts
+    void decrementCuts(int change = 1);
+
+    /// Decrement all active cut counts in chain starting at parent
+    void decrementParentCuts(CbcModel * model, int change = 1);
+
+    /// Nulls out node info
+    void nullNodeInfo();
+    /** Initialize reference counts in attached CbcNodeInfo
+
+      This is a convenience routine, which will initialize the reference counts
+      in the attached CbcNodeInfo object based on the attached
+      OsiBranchingObject.
+
+      \sa CbcNodeInfo::initializeInfo(int).
+    */
+    void initializeInfo();
+
+    /// Does next branch and updates state
+    int branch(OsiSolverInterface * solver);
+
+    /** Double checks in case node can change its mind!
+        Returns objective value
+        Can change objective etc */
+    double checkIsCutoff(double cutoff);
+    // Information to make basis and bounds
+    inline CbcNodeInfo * nodeInfo() const {
+        return nodeInfo_;
+    }
+
+    // Objective value
+    inline double objectiveValue() const {
+        return objectiveValue_;
+    }
+    inline void setObjectiveValue(double value) {
+        objectiveValue_ = value;
+    }
+    /// Number of arms defined for the attached OsiBranchingObject.
+    inline int numberBranches() const {
+        if (branch_)
+            return (branch_->numberBranches()) ;
+        else
+            return (-1) ;
+    }
+
+    /* Active arm of the attached OsiBranchingObject.
+
+     In the simplest instance, coded -1 for the down arm of the branch, +1 for
+     the up arm. But see OsiBranchingObject::way()
+       Use nodeInfo--.numberBranchesLeft_ to see how active
+    */
+    int way() const;
+    /// Depth in branch-and-cut search tree
+    inline int depth() const {
+        return depth_;
+    }
+    /// Set depth in branch-and-cut search tree
+    inline void setDepth(int value) {
+        depth_ = value;
+    }
+    /// Get the number of objects unsatisfied at this node.
+    inline int numberUnsatisfied() const {
+        return numberUnsatisfied_;
+    }
+    /// Set the number of objects unsatisfied at this node.
+    inline void setNumberUnsatisfied(int value) {
+        numberUnsatisfied_ = value;
+    }
+    /// Get sum of "infeasibilities" reported by each object
+    inline double sumInfeasibilities() const {
+        return sumInfeasibilities_;
+    }
+    /// Set sum of "infeasibilities" reported by each object
+    inline void setSumInfeasibilities(double value) {
+        sumInfeasibilities_ = value;
+    }
+    // Guessed objective value (for solution)
+    inline double guessedObjectiveValue() const {
+        return guessedObjectiveValue_;
+    }
+    inline void setGuessedObjectiveValue(double value) {
+        guessedObjectiveValue_ = value;
+    }
+    /// Branching object for this node
+    inline const OsiBranchingObject * branchingObject() const {
+        return branch_;
+    }
+    /// Modifiable branching object for this node
+    inline OsiBranchingObject * modifiableBranchingObject() const {
+        return branch_;
+    }
+    /// Set branching object for this node (takes ownership)
+    inline void setBranchingObject(OsiBranchingObject * branchingObject) {
+        branch_ = branchingObject;
+    }
+    /// The node number
+    inline int nodeNumber() const {
+        return nodeNumber_;
+    }
+    inline void setNodeNumber(int node) {
+        nodeNumber_ = node;
+    }
+    /// Returns true if on tree
+    inline bool onTree() const {
+        return (state_&1) != 0;
+    }
+    /// Sets true if on tree
+    inline void setOnTree(bool yesNo) {
+        if (yesNo) state_ |= 1;
+        else state_ &= ~1;
+    }
+    /// Returns true if active
+    inline bool active() const {
+        return (state_&2) != 0;
+    }
+    /// Sets true if active
+    inline void setActive(bool yesNo) {
+        if (yesNo) state_ |= 2;
+        else state_ &= ~2;
+    }
+    /// Get state (really for debug)
+    inline int getState() const
+    { return state_;}
+    /// Set state (really for debug)
+    inline void setState(int value)
+    { state_ = value;}
+    /// Print
+    void print() const;
+    /// Debug
+    inline void checkInfo() const {
+        assert (nodeInfo_->numberBranchesLeft() ==
+                branch_->numberBranchesLeft());
+    }
+
+private:
+    // Data
+    /// Information to make basis and bounds
+    CbcNodeInfo * nodeInfo_;
+    /// Objective value
+    double objectiveValue_;
+    /// Guessed satisfied Objective value
+    double guessedObjectiveValue_;
+    /// Sum of "infeasibilities" reported by each object
+    double sumInfeasibilities_;
+    /// Branching object for this node
+    OsiBranchingObject * branch_;
+    /// Depth of the node in the search tree
+    int depth_;
+    /// The number of objects unsatisfied at this node.
+    int numberUnsatisfied_;
+    /// The node number
+    int nodeNumber_;
+    /** State
+        1 - on tree
+        2 - active
+    */
+    int state_;
+};
+
+
+#endif
+