ruby-cbc 0.1.9 → 0.2.1

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

@@ -1,100 +0,0 @@
-// $Id: CbcBranchDefaultDecision.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 CbcBranchDefaultDecision_H
-#define CbcBranchDefaultDecision_H
-
-#include "CbcBranchBase.hpp"
-/** Branching decision default class
-
-  This class implements a simple default algorithm
-  (betterBranch()) for choosing a branching variable.
-*/
-
-class CbcBranchDefaultDecision : public CbcBranchDecision {
-public:
-    // Default Constructor
-    CbcBranchDefaultDecision ();
-
-    // Copy constructor
-    CbcBranchDefaultDecision ( const CbcBranchDefaultDecision &);
-
-    virtual ~CbcBranchDefaultDecision();
-
-    /// Clone
-    virtual CbcBranchDecision * clone() const;
-
-    /// Initialize, <i>e.g.</i> before the start of branch selection at a node
-    virtual void initialize(CbcModel * model);
-
-    /** \brief Compare two branching objects. Return nonzero if \p thisOne is
-           better than \p bestSoFar.
-
-      The routine compares branches using the values supplied in \p numInfUp and
-      \p numInfDn until a solution is found by search, after which it uses the
-      values supplied in \p changeUp and \p changeDn. The best branching object
-      seen so far and the associated parameter values are remembered in the
-      \c CbcBranchDefaultDecision object. The nonzero return value is +1 if the
-      up branch is preferred, -1 if the down branch is preferred.
-
-      As the names imply, the assumption is that the values supplied for
-      \p numInfUp and \p numInfDn will be the number of infeasibilities reported
-      by the branching object, and \p changeUp and \p changeDn will be the
-      estimated change in objective. Other measures can be used if desired.
-
-      Because an \c CbcBranchDefaultDecision object remembers the current best
-      branching candidate (#bestObject_) as well as the values used in the
-      comparison, the parameter \p bestSoFar is redundant, hence unused.
-    */
-    virtual int betterBranch(CbcBranchingObject * thisOne,
-                             CbcBranchingObject * bestSoFar,
-                             double changeUp, int numInfUp,
-                             double changeDn, int numInfDn);
-    /** Sets or gets best criterion so far */
-    virtual void setBestCriterion(double value);
-    virtual double getBestCriterion() const;
-
-    /** \brief Compare N branching objects. Return index of best
-        and sets way of branching in chosen object.
-
-      This routine is used only after strong branching.
-    */
-
-    virtual int
-    bestBranch (CbcBranchingObject ** objects, int numberObjects, int numberUnsatisfied,
-                double * changeUp, int * numberInfeasibilitiesUp,
-                double * changeDown, int * numberInfeasibilitiesDown,
-                double objectiveValue) ;
-private:
-
-    /// Illegal Assignment operator
-    CbcBranchDefaultDecision & operator=(const CbcBranchDefaultDecision& rhs);
-
-    /// data
-
-    /// "best" so far
-    double bestCriterion_;
-
-    /// Change up for best
-    double bestChangeUp_;
-
-    /// Number of infeasibilities for up
-    int bestNumberUp_;
-
-    /// Change down for best
-    double bestChangeDown_;
-
-    /// Pointer to best branching object
-    CbcBranchingObject * bestObject_;
-
-    /// Number of infeasibilities for down
-    int bestNumberDown_;
-
-};
-
-#endif
-

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

@@ -1,206 +0,0 @@
-/* $Id: CbcBranchDynamic.hpp 1573 2011-01-05 01:12:36Z lou $ */
-// Copyright (C) 2005, International Business Machines
-// Corporation and others.  All Rights Reserved.
-// This code is licensed under the terms of the Eclipse Public License (EPL).
-
-#ifndef CbcBranchDynamic_H
-#define CbcBranchDynamic_H
-
-#include "CoinPackedMatrix.hpp"
-#include "CbcSimpleIntegerDynamicPseudoCost.hpp"
-#include "CbcBranchActual.hpp"
-
-/** Branching decision dynamic class
-
-  This class implements a simple algorithm
-  (betterBranch()) for choosing a branching variable when dynamic pseudo costs.
-*/
-
-class CbcBranchDynamicDecision : public CbcBranchDecision {
-public:
-    // Default Constructor
-    CbcBranchDynamicDecision ();
-
-    // Copy constructor
-    CbcBranchDynamicDecision ( const CbcBranchDynamicDecision &);
-
-    virtual ~CbcBranchDynamicDecision();
-
-    /// Clone
-    virtual CbcBranchDecision * clone() const;
-
-    /// Initialize, <i>e.g.</i> before the start of branch selection at a node
-    virtual void initialize(CbcModel * model);
-
-    /** \brief Compare two branching objects. Return nonzero if \p thisOne is
-           better than \p bestSoFar.
-
-      The routine compares branches using the values supplied in \p numInfUp and
-      \p numInfDn until a solution is found by search, after which it uses the
-      values supplied in \p changeUp and \p changeDn. The best branching object
-      seen so far and the associated parameter values are remembered in the
-      \c CbcBranchDynamicDecision object. The nonzero return value is +1 if the
-      up branch is preferred, -1 if the down branch is preferred.
-
-      As the names imply, the assumption is that the values supplied for
-      \p numInfUp and \p numInfDn will be the number of infeasibilities reported
-      by the branching object, and \p changeUp and \p changeDn will be the
-      estimated change in objective. Other measures can be used if desired.
-
-      Because an \c CbcBranchDynamicDecision object remembers the current best
-      branching candidate (#bestObject_) as well as the values used in the
-      comparison, the parameter \p bestSoFar is redundant, hence unused.
-    */
-    virtual int betterBranch(CbcBranchingObject * thisOne,
-                             CbcBranchingObject * bestSoFar,
-                             double changeUp, int numInfUp,
-                             double changeDn, int numInfDn);
-    /** Sets or gets best criterion so far */
-    virtual void setBestCriterion(double value);
-    virtual double getBestCriterion() const;
-    /** Says whether this method can handle both methods -
-        1 better, 2 best, 3 both */
-    virtual int whichMethod() {
-        return 3;
-    }
-
-    /** Saves a clone of current branching object.  Can be used to update
-        information on object causing branch - after branch */
-    virtual void saveBranchingObject(OsiBranchingObject * object) ;
-    /** Pass in information on branch just done.
-        assumes object can get information from solver */
-    virtual void updateInformation(OsiSolverInterface * solver,
-                                   const CbcNode * node);
-
-
-private:
-
-    /// Illegal Assignment operator
-    CbcBranchDynamicDecision & operator=(const CbcBranchDynamicDecision& rhs);
-
-    /// data
-
-    /// "best" so far
-    double bestCriterion_;
-
-    /// Change up for best
-    double bestChangeUp_;
-
-    /// Number of infeasibilities for up
-    int bestNumberUp_;
-
-    /// Change down for best
-    double bestChangeDown_;
-
-    /// Number of infeasibilities for down
-    int bestNumberDown_;
-
-    /// Pointer to best branching object
-    CbcBranchingObject * bestObject_;
-};
-/** Simple branching object for an integer variable with pseudo costs
-
-  This object can specify a two-way branch on an integer variable. For each
-  arm of the branch, the upper and lower bounds on the variable can be
-  independently specified.
-
-  Variable_ holds the index of the integer variable in the integerVariable_
-  array of the model.
-*/
-
-class CbcDynamicPseudoCostBranchingObject : public CbcIntegerBranchingObject {
-
-public:
-
-    /// Default constructor
-    CbcDynamicPseudoCostBranchingObject ();
-
-    /** Create a standard floor/ceiling branch object
-
-      Specifies a simple two-way branch. Let \p value = x*. One arm of the
-      branch will be is lb <= x <= floor(x*), the other ceil(x*) <= x <= ub.
-      Specify way = -1 to set the object state to perform the down arm first,
-      way = 1 for the up arm.
-    */
-    CbcDynamicPseudoCostBranchingObject (CbcModel *model, int variable,
-                                         int way , double value,
-                                         CbcSimpleIntegerDynamicPseudoCost * object) ;
-
-    /** Create a degenerate branch object
-
-      Specifies a `one-way branch'. Calling branch() for this object will
-      always result in lowerValue <= x <= upperValue. Used to fix a variable
-      when lowerValue = upperValue.
-    */
-
-    CbcDynamicPseudoCostBranchingObject (CbcModel *model, int variable, int way,
-                                         double lowerValue, double upperValue) ;
-
-    /// Copy constructor
-    CbcDynamicPseudoCostBranchingObject ( const CbcDynamicPseudoCostBranchingObject &);
-
-    /// Assignment operator
-    CbcDynamicPseudoCostBranchingObject & operator= (const CbcDynamicPseudoCostBranchingObject& rhs);
-
-    /// Clone
-    virtual CbcBranchingObject * clone() const;
-
-    /// Destructor
-    virtual ~CbcDynamicPseudoCostBranchingObject ();
-
-    /// Does part of constructor
-    void fillPart (int variable,
-                   int way , double value,
-                   CbcSimpleIntegerDynamicPseudoCost * object) ;
-
-    using CbcBranchingObject::branch ;
-    /** \brief Sets the bounds for the variable according to the current arm
-           of the branch and advances the object state to the next arm.
-           This version also changes guessed objective value
-    */
-    virtual double branch();
-
-    /** 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 & info);
-
-    /// Change in guessed
-    inline double changeInGuessed() const {
-        return changeInGuessed_;
-    }
-    /// Set change in guessed
-    inline void setChangeInGuessed(double value) {
-        changeInGuessed_ = value;
-    }
-    /// Return object
-    inline CbcSimpleIntegerDynamicPseudoCost * object() const {
-        return object_;
-    }
-    /// Set object
-    inline void setObject(CbcSimpleIntegerDynamicPseudoCost * object) {
-        object_ = object;
-    }
-
-    /** Return the type (an integer identifier) of \c this */
-    virtual CbcBranchObjType type() const {
-        return DynamicPseudoCostBranchObj;
-    }
-
-    // LL: compareOriginalObject and compareBranchingObject are inherited from
-    // CbcIntegerBranchingObject thus need not be declared/defined here. After
-    // all, this kind of branching object is simply using pseudocosts to make
-    // decisions, but once the decisions are made they are the same kind as in
-    // the underlying class.
-
-protected:
-    /// Change in guessed objective value for next branch
-    double changeInGuessed_;
-    /// Pointer back to object
-    CbcSimpleIntegerDynamicPseudoCost * object_;
-
-};
-
-#endif
-

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

@@ -1,242 +0,0 @@
-/* $Id: CbcBranchLotsize.hpp 1573 2011-01-05 01:12:36Z lou $ */
-// 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).
-
-#ifndef CbcBranchLotsize_H
-#define CbcBranchLotsize_H
-
-#include "CbcBranchBase.hpp"
-/** Lotsize class */
-
-
-class CbcLotsize : public CbcObject {
-
-public:
-
-    // Default Constructor
-    CbcLotsize ();
-
-    /* Useful constructor - passed model index.
-       Also passed valid values - if range then pairs
-    */
-    CbcLotsize (CbcModel * model, int iColumn,
-                int numberPoints, const double * points, bool range = false);
-
-    // Copy constructor
-    CbcLotsize ( const CbcLotsize &);
-
-    /// Clone
-    virtual CbcObject * clone() const;
-
-    // Assignment operator
-    CbcLotsize & operator=( const CbcLotsize& rhs);
-
-    // Destructor
-    ~CbcLotsize ();
-
-    /// Infeasibility - large is 0.5
-    virtual double infeasibility(const OsiBranchingInformation * info,
-                                 int &preferredWay) const;
-
-    using CbcObject::feasibleRegion ;
-    /** Set bounds to contain the current solution.
-
-      More precisely, for the variable associated with this object, take the
-      value given in the current solution, force it within the current bounds
-      if required, then set the bounds to fix the variable at the integer
-      nearest the solution value.
-    */
-    virtual void feasibleRegion();
-
-    /// Creates a branching object
-    virtual CbcBranchingObject * createCbcBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) ;
-
-    /** \brief Given a valid solution (with reduced costs, etc.),
-        return a branching object which would give a new feasible
-        point in the good direction.
-
-      The preferred branching object will force the variable to be +/-1 from
-      its current value, depending on the reduced cost and objective sense.  If
-      movement in the direction which improves the objective is impossible due
-      to bounds on the variable, the branching object will move in the other
-      direction.  If no movement is possible, the method returns NULL.
-
-      Only the bounds on this variable are considered when determining if the new
-      point is feasible.
-    */
-    virtual CbcBranchingObject * preferredNewFeasible() const;
-
-    /** \brief Given a valid solution (with reduced costs, etc.),
-        return a branching object which would give a new feasible
-        point in a bad direction.
-
-      As for preferredNewFeasible(), but the preferred branching object will
-      force movement in a direction that degrades the objective.
-    */
-    virtual CbcBranchingObject * notPreferredNewFeasible() const ;
-
-    /** Reset original upper and lower bound values from the solver.
-
-      Handy for updating bounds held in this object after bounds held in the
-      solver have been tightened.
-     */
-    virtual void resetBounds(const OsiSolverInterface * solver);
-
-    /** Finds range of interest so value is feasible in range range_ or infeasible
-        between hi[range_] and lo[range_+1].  Returns true if feasible.
-    */
-    bool findRange(double value) const;
-
-    /** Returns floor and ceiling
-    */
-    virtual void floorCeiling(double & floorLotsize, double & ceilingLotsize, double value,
-                              double tolerance) const;
-
-    /// Model column number
-    inline int modelSequence() const {
-        return columnNumber_;
-    }
-    /// Set model column number
-    inline void setModelSequence(int value) {
-        columnNumber_ = value;
-    }
-
-    /** Column number if single column object -1 otherwise,
-        so returns >= 0
-        Used by heuristics
-    */
-    virtual int columnNumber() const;
-    /// Original variable bounds
-    inline double originalLowerBound() const {
-        return bound_[0];
-    }
-    inline double originalUpperBound() const {
-        return bound_[rangeType_*numberRanges_-1];
-    }
-    /// Type - 1 points, 2 ranges
-    inline int rangeType() const {
-        return rangeType_;
-    }
-    /// Number of points
-    inline int numberRanges() const {
-        return numberRanges_;
-    }
-    /// Ranges
-    inline double * bound() const {
-        return bound_;
-    }
-    /** \brief Return true if object can take part in normal heuristics
-    */
-    virtual bool canDoHeuristics() const {
-        return false;
-    }
-
-private:
-    /// Just for debug (CBC_PRINT defined in CbcBranchLotsize.cpp)
-    void printLotsize(double value, bool condition, int type) const;
-
-private:
-    /// data
-
-    /// Column number in model
-    int columnNumber_;
-    /// Type - 1 points, 2 ranges
-    int rangeType_;
-    /// Number of points
-    int numberRanges_;
-    // largest gap
-    double largestGap_;
-    /// Ranges
-    double * bound_;
-    /// Current range
-    mutable int range_;
-};
-
-/** Lotsize branching object
-
-  This object can specify a two-way branch on an integer variable. For each
-  arm of the branch, the upper and lower bounds on the variable can be
-  independently specified.
-
-  Variable_ holds the index of the integer variable in the integerVariable_
-  array of the model.
-*/
-
-class CbcLotsizeBranchingObject : public CbcBranchingObject {
-
-public:
-
-    /// Default constructor
-    CbcLotsizeBranchingObject ();
-
-    /** Create a lotsize floor/ceiling branch object
-
-      Specifies a simple two-way branch. Let \p value = x*. One arm of the
-      branch will be is lb <= x <= valid range below(x*), the other valid range above(x*) <= x <= ub.
-      Specify way = -1 to set the object state to perform the down arm first,
-      way = 1 for the up arm.
-    */
-    CbcLotsizeBranchingObject (CbcModel *model, int variable,
-                               int way , double value, const CbcLotsize * lotsize) ;
-
-    /** Create a degenerate branch object
-
-      Specifies a `one-way branch'. Calling branch() for this object will
-      always result in lowerValue <= x <= upperValue. Used to fix in valid range
-    */
-
-    CbcLotsizeBranchingObject (CbcModel *model, int variable, int way,
-                               double lowerValue, double upperValue) ;
-
-    /// Copy constructor
-    CbcLotsizeBranchingObject ( const CbcLotsizeBranchingObject &);
-
-    /// Assignment operator
-    CbcLotsizeBranchingObject & operator= (const CbcLotsizeBranchingObject& rhs);
-
-    /// Clone
-    virtual CbcBranchingObject * clone() const;
-
-    /// Destructor
-    virtual ~CbcLotsizeBranchingObject ();
-
-    using CbcBranchingObject::branch ;
-    /** \brief Sets the bounds for the variable according to the current arm
-           of the branch and advances the object state to the next arm.
-    */
-    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 LotsizeBranchObj;
-    }
-
-    // LL: compareOriginalObject can be inherited from the CbcBranchingObject
-    // since variable_ uniquely defines the lot sizing object.
-
-    /** 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);
-
-protected:
-    /// Lower [0] and upper [1] bounds for the down arm (way_ = -1)
-    double down_[2];
-    /// Lower [0] and upper [1] bounds for the up arm (way_ = 1)
-    double up_[2];
-};
-
-#endif
-