ruby-cbc 0.1.9 → 0.2.1

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

@@ -1,161 +0,0 @@
-// $Id: CbcFullNodeInfo.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/24/09 carved from CbcNode
-
-#ifndef CbcFullNodeInfo_H
-#define CbcFullNodeInfo_H
-
-#include <string>
-#include <vector>
-
-#include "CoinWarmStartBasis.hpp"
-#include "CoinSearchTree.hpp"
-#include "CbcBranchBase.hpp"
-#include "CbcNodeInfo.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.
-*/
-
-
-/** \brief Holds complete information for recreating a subproblem.
-
-  A CbcFullNodeInfo object contains all necessary information (bounds, basis,
-  and cuts) required to recreate a subproblem.
-
-  \todo While there's no explicit statement, the code often makes the implicit
-	assumption that an CbcFullNodeInfo structure will appear only at the
-	root node of the search tree. Things will break if this assumption
-	is violated.
-*/
-
-class CbcFullNodeInfo : public CbcNodeInfo {
-
-public:
-
-    /** \brief Modify model according to information at node
-
-        The routine modifies the model according to bound information at node,
-        creates a new basis according to information at node, but with the size
-        passed in through basis, and adds any cuts to the addCuts array.
-
-      \note The basis passed in via basis is solely a vehicle for passing in
-        the desired basis size. It will be deleted and a new basis returned.
-    */
-    virtual void applyToModel (CbcModel *model, CoinWarmStartBasis *&basis,
-                               CbcCountRowCut **addCuts,
-                               int &currentNumberCuts) const ;
-
-    /// 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) ;
-
-    /** 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 ;
-    // Default Constructor
-    CbcFullNodeInfo ();
-
-    /** Constructor from continuous or satisfied
-    */
-    CbcFullNodeInfo (CbcModel * model,
-                     int numberRowsAtContinuous);
-
-    // Copy constructor
-    CbcFullNodeInfo ( const CbcFullNodeInfo &);
-
-    // Destructor
-    ~CbcFullNodeInfo ();
-
-    /// Clone
-    virtual CbcNodeInfo * clone() const;
-    /// Lower bounds
-    inline const double * lower() const {
-        return lower_;
-    }
-    /// Set a bound
-    inline void setColLower(int sequence, double value)
-    { lower_[sequence]=value;}
-    /// Mutable lower bounds
-    inline double * mutableLower() const {
-        return lower_;
-    }
-    /// Upper bounds
-    inline const double * upper() const {
-        return upper_;
-    }
-    /// Set a bound
-    inline void setColUpper(int sequence, double value)
-    { upper_[sequence]=value;}
-    /// Mutable upper bounds
-    inline double * mutableUpper() const {
-        return upper_;
-    }
-protected:
-    // Data
-    /** Full basis
-
-      This MUST BE A POINTER to avoid cutting extra information in derived
-      warm start classes.
-    */
-    CoinWarmStartBasis *basis_;
-    int numberIntegers_;
-    // Bounds stored in full
-    double * lower_;
-    double * upper_;
-private:
-    /// Illegal Assignment operator
-    CbcFullNodeInfo & operator=(const CbcFullNodeInfo& rhs);
-};
-#endif //CbcFullNodeInfo_H
-

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

@@ -1,60 +0,0 @@
-// $Id: CbcGeneral.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/10/2009-- carved out of CbcBranchActual
-
-#ifndef CbcGeneral_H
-#define CbcGeneral_H
-
-#include "CbcBranchBase.hpp"
-/** Define a catch all class.
-    This will create a list of subproblems
-*/
-
-
-class CbcGeneral : public CbcObject {
-
-public:
-
-    // Default Constructor
-    CbcGeneral ();
-
-    /** Useful constructor
-        Just needs to point to model.
-    */
-    CbcGeneral (CbcModel * model);
-
-    // Copy constructor
-    CbcGeneral ( const CbcGeneral &);
-
-    /// Clone
-    virtual CbcObject * clone() const = 0;
-
-    // Assignment operator
-    CbcGeneral & operator=( const CbcGeneral& rhs);
-
-    // Destructor
-    ~CbcGeneral ();
-
-    /// Infeasibility - large is 0.5
-    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() = 0;
-
-    /// 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) = 0;
-
-protected:
-    /// data
-};
-
-#endif
-

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

@@ -1,279 +0,0 @@
-// $Id: CbcGeneralDepth.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/10/2009-- carved out of CbcBranchActual
-
-#ifndef CbcGeneralDepth_H
-#define CbcGeneralDepth_H
-
-#include "CbcGeneral.hpp"
-#include "CbcBranchBase.hpp"
-#include "CbcSubProblem.hpp"
-
-#ifdef COIN_HAS_CLP
-
-/** Define a catch all class.
-    This will create a list of subproblems using partial evaluation
-*/
-#include "ClpSimplex.hpp"
-#include "ClpNode.hpp"
-
-
-class CbcGeneralDepth : public CbcGeneral {
-
-public:
-
-    // Default Constructor
-    CbcGeneralDepth ();
-
-    /** Useful constructor
-        Just needs to point to model.
-        Initial version does evaluation to depth N
-        This is stored in CbcModel but may be
-        better here
-    */
-    CbcGeneralDepth (CbcModel * model, int maximumDepth);
-
-    // Copy constructor
-    CbcGeneralDepth ( const CbcGeneralDepth &);
-
-    /// Clone
-    virtual CbcObject * clone() const;
-
-    // Assignment operator
-    CbcGeneralDepth & operator=( const CbcGeneralDepth& rhs);
-
-    // Destructor
-    ~CbcGeneralDepth ();
-
-    /// Infeasibility - large is 0.5
-    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) ;
-    /// Return maximum number of nodes
-    inline int maximumNodes() const {
-        return maximumNodes_;
-    }
-    /// Get maximum depth
-    inline int maximumDepth() const {
-        return maximumDepth_;
-    }
-    /// Set maximum depth
-    inline void setMaximumDepth(int value) {
-        maximumDepth_ = value;
-    }
-    /// Return number of nodes
-    inline int numberNodes() const {
-        return numberNodes_;
-    }
-    /// Get which solution
-    inline int whichSolution() const {
-        return whichSolution_;
-    }
-    /// Get ClpNode info
-    inline ClpNode * nodeInfo(int which) {
-        return nodeInfo_->nodeInfo_[which];
-    }
-
-    /// Redoes data when sequence numbers change
-    virtual void redoSequenceEtc(CbcModel * model, int numberColumns, const int * originalColumns);
-
-protected:
-    /// data
-    /// Maximum depth
-    int maximumDepth_;
-    /// Maximum nodes
-    int maximumNodes_;
-    /// Which node has solution (or -1)
-    mutable int whichSolution_;
-    /// Number of valid nodes (including whichSolution_)
-    mutable int numberNodes_;
-    /// For solving nodes
-    mutable ClpNodeStuff * nodeInfo_;
-};
-/** Branching object for general objects
-
- */
-class CbcNode;
-class CbcGeneralBranchingObject : public CbcBranchingObject {
-
-public:
-
-    // Default Constructor
-    CbcGeneralBranchingObject ();
-
-    // Useful constructor
-    CbcGeneralBranchingObject (CbcModel * model);
-
-    // Copy constructor
-    CbcGeneralBranchingObject ( const CbcGeneralBranchingObject &);
-
-    // Assignment operator
-    CbcGeneralBranchingObject & operator=( const CbcGeneralBranchingObject& rhs);
-
-    /// Clone
-    virtual CbcBranchingObject * clone() const;
-
-    // Destructor
-    virtual ~CbcGeneralBranchingObject ();
-
-    using CbcBranchingObject::branch ;
-    /// Does next branch and updates state
-    virtual double branch();
-    /** Double checks in case node can change its mind!
-        Can change objective etc */
-    virtual void checkIsCutoff(double cutoff);
-
-    using CbcBranchingObject::print ;
-    /** \brief Print something about branch - only if log level high
-    */
-    virtual void print();
-    /// Fill in current objective etc
-    void state(double & objectiveValue, double & sumInfeasibilities,
-               int & numberUnsatisfied, int which) const;
-    /// Set CbcNode
-    inline void setNode(CbcNode * node) {
-        node_ = node;
-    }
-    /** Return the type (an integer identifier) of \c this */
-    virtual CbcBranchObjType type() const {
-        return GeneralDepthBranchObj;
-    }
-
-    /** 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);
-    /// Number of subproblems
-    inline int numberSubProblems() const {
-        return numberSubProblems_;
-    }
-    /// Decrement number left and return number
-    inline int decrementNumberLeft() {
-        numberSubLeft_--;
-        return numberSubLeft_;
-    }
-    /// Which node we want to use
-    inline int whichNode() const {
-        return whichNode_;
-    }
-    /// Set which node we want to use
-    inline void setWhichNode(int value) {
-        whichNode_ = value;
-    }
-    // Sub problem
-    const CbcSubProblem * subProblem(int which) const {
-        return subProblems_ + which;
-    }
-
-public:
-    /// data
-    // Sub problems
-    CbcSubProblem * subProblems_;
-    /// Node
-    CbcNode * node_;
-    /// Number of subproblems
-    int numberSubProblems_;
-    /// Number of subproblems left
-    int numberSubLeft_;
-    /// Which node we want to use (-1 for default)
-    int whichNode_;
-    /// Number of rows
-    int numberRows_;
-};
-/** Branching object for general objects - just one
-
- */
-class CbcOneGeneralBranchingObject : public CbcBranchingObject {
-
-public:
-
-    // Default Constructor
-    CbcOneGeneralBranchingObject ();
-
-    // Useful constructor
-    CbcOneGeneralBranchingObject (CbcModel * model,
-                                  CbcGeneralBranchingObject * object,
-                                  int whichOne);
-
-    // Copy constructor
-    CbcOneGeneralBranchingObject ( const CbcOneGeneralBranchingObject &);
-
-    // Assignment operator
-    CbcOneGeneralBranchingObject & operator=( const CbcOneGeneralBranchingObject& rhs);
-
-    /// Clone
-    virtual CbcBranchingObject * clone() const;
-
-    // Destructor
-    virtual ~CbcOneGeneralBranchingObject ();
-
-    using CbcBranchingObject::branch ;
-    /// Does next branch and updates state
-    virtual double branch();
-    /** Double checks in case node can change its mind!
-        Can change objective etc */
-    virtual void checkIsCutoff(double cutoff);
-
-    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 OneGeneralBranchingObj;
-    }
-
-    /** 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);
-
-public:
-    /// data
-    /// Object
-    CbcGeneralBranchingObject * object_;
-    /// Which one
-    int whichOne_;
-};
-#endif //COIN_HAS_CLP
-#endif
-