ruby-cbc 0.1.9 → 0.2.1

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

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

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