ruby-cbc 0.1.9 → 0.2.1

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

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

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