ruby-cbc 0.1.9 → 0.2.1

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

@@ -1,94 +0,0 @@
-// $Id: CbcBranchToFixLots.hpp 1899 2013-04-09 18:12:08Z stefan $
-// Copyright (C) 2004, International Business Machines
-// Corporation and others.  All Rights Reserved.
-// This code is licensed under the terms of the Eclipse Public License (EPL).
-
-// Edwin 11/13/2009-- carved out of CbcBranchCut
-
-#ifndef CbcBranchToFixLots_H
-#define CbcBranchToFixLots_H
-
-#include "CbcBranchCut.hpp"
-#include "CbcBranchBase.hpp"
-#include "OsiRowCut.hpp"
-#include "CoinPackedMatrix.hpp"
-
-/** Define a branch class that branches so that one way variables are fixed
-    while the other way cuts off that solution.
-    a) On reduced cost
-    b) When enough ==1 or <=1 rows have been satisfied (not fixed - satisfied)
-*/
-
-
-class CbcBranchToFixLots : public CbcBranchCut {
-
-public:
-
-    // Default Constructor
-    CbcBranchToFixLots ();
-
-    /** Useful constructor - passed reduced cost tolerance and fraction we would like fixed.
-        Also depth level to do at.
-        Also passed number of 1 rows which when clean triggers fix
-        Always does if all 1 rows cleaned up and number>0 or if fraction columns reached
-        Also whether to create branch if can't reach fraction.
-    */
-    CbcBranchToFixLots (CbcModel * model, double djTolerance,
-                        double fractionFixed, int depth,
-                        int numberClean = 0,
-                        const char * mark = NULL,
-                        bool alwaysCreate = false);
-
-    // Copy constructor
-    CbcBranchToFixLots ( const CbcBranchToFixLots &);
-
-    /// Clone
-    virtual CbcObject * clone() const;
-
-    // Assignment operator
-    CbcBranchToFixLots & operator=( const CbcBranchToFixLots& rhs);
-
-    // Destructor
-    ~CbcBranchToFixLots ();
-
-    /** Does a lot of the work,
-        Returns 0 if no good, 1 if dj, 2 if clean, 3 if both
-	FIXME: should use enum or equivalent to make these numbers clearer.
-    */
-    int shallWe() const;
-
-    /// Infeasibility for an integer variable - large is 0.5, but also can be infinity when known infeasible.
-    virtual double infeasibility(const OsiBranchingInformation * info,
-                                 int &preferredWay) const;
-    /** \brief Return true if object can take part in normal heuristics
-    */
-    virtual bool canDoHeuristics() const {
-        return true;
-    }
-
-    /// 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);
-
-
-protected:
-    /// data
-
-    /// Reduced cost tolerance i.e. dj has to be >= this before fixed
-    double djTolerance_;
-    /// We only need to make sure this fraction fixed
-    double fractionFixed_;
-    /// Never fix ones marked here
-    char * mark_;
-    /// Matrix by row
-    CoinPackedMatrix matrixByRow_;
-    /// Do if depth multiple of this
-    int depth_;
-    /// number of ==1 rows which need to be clean
-    int numberClean_;
-    /// If true then always create branch
-    bool alwaysCreate_;
-};
-#endif
-

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

@@ -1,236 +0,0 @@
-// $Id: CbcBranchingObject.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 CbcBranchingObject_H
-#define CbcBranchingObject_H
-
-#include <string>
-#include <vector>
-#include "CbcBranchBase.hpp"
-#include "OsiBranchingObject.hpp"
-
-
-// The types of objects that will be derived from this class.
-enum CbcBranchObjType
-  {
-    SimpleIntegerBranchObj = 100,
-    SimpleIntegerDynamicPseudoCostBranchObj = 101,
-    CliqueBranchObj = 102,
-    LongCliqueBranchObj = 103,
-    SoSBranchObj = 104,
-    NWayBranchObj = 105,
-    FollowOnBranchObj = 106,
-    DummyBranchObj = 107,
-    GeneralDepthBranchObj = 108,
-    OneGeneralBranchingObj = 110,
-    CutBranchingObj = 200,
-    LotsizeBranchObj = 300,
-    DynamicPseudoCostBranchObj = 400
-  };
-
-/** \brief Abstract branching object base class
-    Now just difference with OsiBranchingObject
-
-  In the abstract, an CbcBranchingObject contains instructions for how to
-  branch. We want an abstract class so that we can describe how to branch on
-  simple objects (<i>e.g.</i>, integers) and more exotic objects
-  (<i>e.g.</i>, cliques or hyperplanes).
-
-  The #branch() method is the crucial routine: it is expected to be able to
-  step through a set of branch arms, executing the actions required to create
-  each subproblem in turn. The base class is primarily virtual to allow for
-  a wide range of problem modifications.
-
-  See CbcObject for an overview of the three classes (CbcObject,
-  CbcBranchingObject, and CbcBranchDecision) which make up cbc's branching
-  model.
-*/
-
-class CbcBranchingObject : public OsiBranchingObject {
-
-public:
-
-    /// Default Constructor
-    CbcBranchingObject ();
-
-    /// Constructor
-    CbcBranchingObject (CbcModel * model, int variable, int way , double value);
-
-    /// Copy constructor
-    CbcBranchingObject ( const CbcBranchingObject &);
-
-    /// Assignment operator
-    CbcBranchingObject & operator=( const CbcBranchingObject& rhs);
-
-    /// Clone
-    virtual CbcBranchingObject * clone() const = 0;
-
-    /// Destructor
-    virtual ~CbcBranchingObject ();
-
-    /** Some branchingObjects may claim to be able to skip
-        strong branching.  If so they have to fill in CbcStrongInfo.
-        The object mention in incoming CbcStrongInfo must match.
-        Returns nonzero if skip is wanted */
-    virtual int fillStrongInfo( CbcStrongInfo & ) {
-        return 0;
-    }
-    /// Reset number of branches left to original
-    inline void resetNumberBranchesLeft() {
-        branchIndex_ = 0;
-    }
-    /// Set number of branches to do
-    inline void setNumberBranches(int value) {
-        branchIndex_ = 0;
-        numberBranches_ = value;
-    }
-
-    /** \brief Execute the actions required to branch, as specified by the
-           current state of the branching object, and advance the object's
-           state.  Mainly for diagnostics, whether it is true branch or
-           strong branching is also passed.
-           Returns change in guessed objective on next branch
-    */
-    virtual double branch() = 0;
-    /** \brief Execute the actions required to branch, as specified by the
-           current state of the branching object, and advance the object's
-           state.  Mainly for diagnostics, whether it is true branch or
-           strong branching is also passed.
-           Returns change in guessed objective on next branch
-    */
-    virtual double branch(OsiSolverInterface * ) {
-        return branch();
-    }
-    /** Update bounds in solver as in 'branch' and update given bounds.
-        branchState is -1 for 'down' +1 for 'up' */
-    virtual void fix(OsiSolverInterface * ,
-                     double * , double * ,
-                     int ) const {}
-
-    /** Change (tighten) bounds in object to reflect bounds in solver.
-	Return true if now fixed */
-    virtual bool tighten(OsiSolverInterface * ) {return false;}
-
-    /** 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() {
-        assert(branchIndex_ > 0);
-        branchIndex_--;
-        way_ = -way_;
-    }
-
-    using OsiBranchingObject::print ;
-    /** \brief Print something about branch - only if log level high
-    */
-    virtual void print() const {}
-
-    /** \brief Index identifying the associated CbcObject within its class.
-
-      The name is misleading, and typically the index will <i>not</i> refer
-      directly to a variable.
-      Rather, it identifies an CbcObject within the class of similar
-      CbcObjects
-
-      <i>E.g.</i>, for an CbcSimpleInteger, variable() is the index of the
-      integer variable in the set of integer variables (<i>not</i> the index of
-      the variable in the set of all variables).
-    */
-    inline int variable() const {
-        return variable_;
-    }
-
-    /** Get the state of the branching object
-
-      Returns a code indicating the active arm of the branching object.
-      The precise meaning is defined in the derived class.
-
-      \sa #way_
-    */
-    inline int way() const {
-        return way_;
-    }
-
-    /** Set the state of the branching object.
-
-      See #way()
-    */
-    inline void way(int way) {
-        way_ = way;
-    }
-
-    /// update model
-    inline void setModel(CbcModel * model) {
-        model_ = model;
-    }
-    /// Return model
-    inline CbcModel * model() const {
-        return  model_;
-    }
-
-    /// Return pointer back to object which created
-    inline CbcObject * object() const {
-        return  originalCbcObject_;
-    }
-    /// Set pointer back to object which created
-    inline void setOriginalObject(CbcObject * object) {
-        originalCbcObject_ = object;
-    }
-
-    // Methods used in heuristics
-
-    /** Return the type (an integer identifier) of \c this.
-        See definition of CbcBranchObjType above for possibilities
-    */
-    
-    virtual CbcBranchObjType type() const = 0;
-
-    /** 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 {
-        const CbcBranchingObject* br = dynamic_cast<const CbcBranchingObject*>(brObj);
-        return variable() - br->variable();
-    }
-
-    /** Compare the \c this with \c brObj. \c this and \c brObj must be of 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) = 0;
-
-protected:
-
-    /// The model that owns this branching object
-    CbcModel * model_;
-    /// Pointer back to object which created
-    CbcObject * originalCbcObject_;
-
-    /// Branching variable (0 is first integer)
-    int variable_;
-    // was - Way to branch - -1 down (first), 1 up, -2 down (second), 2 up (second)
-    /** The state of the branching object.
-
-      Specifies the active arm of the branching object. Coded as -1 to take
-      the `down' arm, +1 for the `up' arm. `Down' and `up' are defined based on
-      the natural meaning (floor and ceiling, respectively) for a simple integer.
-      The precise meaning is defined in the derived class.
-    */
-    int way_;
-
-};
-#endif
-

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

@@ -1,303 +0,0 @@
-// $Id: CbcClique.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
-
-#ifndef CbcClique_H
-#define CbcClique_H
-
-/** \brief Branching object for cliques
-
-  A clique is defined to be a set of binary variables where fixing any one
-  variable to its `strong' value fixes all other variables. An example is the
-  most common SOS1 construction: a set of binary variables x_j s.t.  SUM{j}
-  x_j = 1.  Setting any one variable to 1 forces all other variables to 0.
-  (See comments for CbcSOS below.)
-
-  Other configurations are possible, however: Consider x1-x2+x3 <= 0.
-  Setting x1 (x3) to 1 forces x2 to 1 and x3 (x1) to 0. Setting x2 to 0
-  forces x1 and x3 to 0.
-
-  The proper point of view to take when interpreting CbcClique is
-  `generalisation of SOS1 on binary variables.' To get into the proper frame
-  of mind, here's an example.
-  
-  Consider the following sequence, where x_j = (1-y_j):
-  \verbatim
-     x1 + x2 + x3 <=  1		all strong at 1
-     x1 - y2 + x3 <=  0		y2 strong at 0; x1, x3 strong at 1
-    -y1 - y2 + x3 <= -1		y1, y2 strong at 0, x3 strong at 1
-    -y1 - y2 - y3 <= -2		all strong at 0
-  \endverbatim
-  The first line is a standard SOS1 on binary variables.
-  
-  Variables with +1 coefficients are `SOS-style' and variables with -1
-  coefficients are `non-SOS-style'. So #numberNonSOSMembers_ simply tells you
-  how many variables have -1 coefficients. The implicit rhs for a clique is
-  1-numberNonSOSMembers_.
-*/
-class CbcClique : public CbcObject {
-
-public:
-
-    /// Default Constructor
-    CbcClique ();
-
-    /** Useful constructor (which are integer indices) slack can denote a slack
-	in set.  If type == NULL then as if 1
-    */
-    CbcClique (CbcModel * model, int cliqueType, int numberMembers,
-               const int * which, const char * type,
-               int identifier, int slack = -1);
-
-    /// Copy constructor
-    CbcClique ( const CbcClique &);
-
-    /// Clone
-    virtual CbcObject * clone() const;
-
-    /// Assignment operator
-    CbcClique & operator=( const CbcClique& rhs);
-
-    /// Destructor
-    virtual ~CbcClique ();
-
-    /// 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) ;
-    /// Number of members
-    inline int numberMembers() const {
-        return numberMembers_;
-    }
-    /** \brief Number of variables with -1 coefficient
-      
-      Number of non-SOS members, i.e., fixing to zero is strong.
-      See comments at head of class, and comments for #type_.
-    */
-    inline int numberNonSOSMembers() const {
-        return numberNonSOSMembers_;
-    }
-
-    /// Members (indices in range 0 ... numberIntegers_-1)
-    inline const int * members() const {
-        return members_;
-    }
-
-    /*! \brief Type of each member, i.e., which way is strong.
-  
-      This also specifies whether a variable has a +1 or -1 coefficient.
-	- 0 => -1 coefficient, 0 is strong value
-	- 1 => +1 coefficient, 1 is strong value
-      If unspecified, all coefficients are assumed to be positive.
-      
-      Indexed as 0 .. numberMembers_-1
-    */
-    inline char type(int index) const {
-        if (type_) return type_[index];
-        else return 1;
-    }
-
-    /// Clique type: 0 is <=, 1 is ==
-    inline int cliqueType() const {
-        return cliqueType_;
-    }
-    /// Redoes data when sequence numbers change
-    virtual void redoSequenceEtc(CbcModel * model, int numberColumns, const int * originalColumns);
-
-protected:
-    /// data
-    /// Number of members
-    int numberMembers_;
-
-    /// Number of Non SOS members i.e. fixing to zero is strong
-    int numberNonSOSMembers_;
-
-    /// Members (indices in range 0 ... numberIntegers_-1)
-    int * members_;
-
-    /** \brief Strong value for each member.
-
-      This also specifies whether a variable has a +1 or -1 coefficient.
-        - 0 => -1 coefficient, 0 is strong value
-        - 1 => +1 coefficient, 1 is strong value
-      If unspecified, all coefficients are assumed to be positive.
-    
-      Indexed as 0 .. numberMembers_-1
-    */
-    char * type_;
-
-    /** \brief Clique type
-
-      0 defines a <= relation, 1 an equality. The assumed value of the rhs is
-      numberNonSOSMembers_+1. (See comments for the class.)
-    */
-    int cliqueType_;
-
-    /** \brief Slack variable for the clique
-  
-      Identifies the slack variable for the clique (typically added to convert
-      a <= relation to an equality). Value is sequence number within clique
-      menbers.
-    */
-    int slack_;
-};
-
-/** Branching object for unordered cliques
-
-    Intended for cliques which are long enough to make it worthwhile
-    but <= 64 members.  There will also be ones for long cliques.
-
-    Variable_ is the clique id number (redundant, as the object also holds a
-    pointer to the clique.
- */
-class CbcCliqueBranchingObject : public CbcBranchingObject {
-
-public:
-
-    // Default Constructor
-    CbcCliqueBranchingObject ();
-
-    // Useful constructor
-    CbcCliqueBranchingObject (CbcModel * model,  const CbcClique * clique,
-                              int way,
-                              int numberOnDownSide, const int * down,
-                              int numberOnUpSide, const int * up);
-
-    // Copy constructor
-    CbcCliqueBranchingObject ( const CbcCliqueBranchingObject &);
-
-    // Assignment operator
-    CbcCliqueBranchingObject & operator=( const CbcCliqueBranchingObject& rhs);
-
-    /// Clone
-    virtual CbcBranchingObject * clone() const;
-
-    // Destructor
-    virtual ~CbcCliqueBranchingObject ();
-
-    using CbcBranchingObject::branch ;
-    /// Does next branch and updates state
-    virtual double branch();
-
-    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 CliqueBranchObj;
-    }
-
-    /** 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 of 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:
-    /// data
-    const CbcClique * clique_;
-    /// downMask - bit set to fix to weak bounds, not set to leave unfixed
-    unsigned int downMask_[2];
-    /// upMask - bit set to fix to weak bounds, not set to leave unfixed
-    unsigned int upMask_[2];
-};
-
-/** Unordered Clique Branching Object class.
-    These are for cliques which are > 64 members
-    Variable is number of clique.
- */
-class CbcLongCliqueBranchingObject : public CbcBranchingObject {
-
-public:
-
-    // Default Constructor
-    CbcLongCliqueBranchingObject ();
-
-    // Useful constructor
-    CbcLongCliqueBranchingObject (CbcModel * model,  const CbcClique * clique,
-                                  int way,
-                                  int numberOnDownSide, const int * down,
-                                  int numberOnUpSide, const int * up);
-
-    // Copy constructor
-    CbcLongCliqueBranchingObject ( const CbcLongCliqueBranchingObject &);
-
-    // Assignment operator
-    CbcLongCliqueBranchingObject & operator=( const CbcLongCliqueBranchingObject& rhs);
-
-    /// Clone
-    virtual CbcBranchingObject * clone() const;
-
-    // Destructor
-    virtual ~CbcLongCliqueBranchingObject ();
-
-    using CbcBranchingObject::branch ;
-    /// Does next branch and updates state
-    virtual double branch();
-
-    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 LongCliqueBranchObj;
-    }
-
-    /** 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:
-    /// data
-    const CbcClique * clique_;
-    /// downMask - bit set to fix to weak bounds, not set to leave unfixed
-    unsigned int * downMask_;
-    /// upMask - bit set to fix to weak bounds, not set to leave unfixed
-    unsigned int * upMask_;
-};
-
-#endif
-