ruby-cbc 0.1.9 → 0.2.1

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

@@ -1,324 +0,0 @@
-/* $Id: CbcParam.hpp 1573 2011-01-05 01:12:36Z lou $ */
-// 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 CbcParam_H
-#define CbcParam_H
-
-#include "OsiSolverInterface.hpp"
-#include "CbcModel.hpp"
-class ClpSimplex;
-/*! \brief Parameter codes
-
-  Parameter type ranges are allocated as follows
-  <ul>
-    <li>   1 -- 100	double parameters
-    <li> 101 -- 200	integer parameters
-    <li> 201 -- 250	string parameters
-    <li> 251 -- 300	cuts etc(string but broken out for clarity)
-    <li> 301 -- 400	`actions'
-  </ul>
-
-  `Actions' do not necessarily invoke an immediate action; it's just that they
-  don't fit neatly into the parameters array.
-
-  This coding scheme is in flux.
-  CBC_PARAM_STR_NODESTRATEGY, 
-  CBC_PARAM_STR_BRANCHSTRATEGY, 
-  CBC_PARAM_NOTUSED_ADDCUTSSTRATEGY,
-  CLP_PARAM_ACTION_CLEARCUTS, 
-  CBC_PARAM_NOTUSED_OSLSTUFF, 
-  CBC_PARAM_NOTUSED_CBCSTUFF are not used at present (03.10.24).
-*/
-
-enum CbcParameterType
-
-{ CBC_PARAM_GENERALQUERY = -100, 
-  CBC_PARAM_FULLGENERALQUERY,
-
-  CLP_PARAM_DBL_PRIMALTOLERANCE = 1, 
-  CLP_PARAM_DBL_DUALTOLERANCE, 
-  CBC_PARAM_DBL_CUTOFF, 
-  CLP_PARAM_DBL_TIMELIMIT,
-  CLP_PARAM_DBL_DUALBOUND, 
-  CLP_PARAM_DBL_PRIMALWEIGHT,  
-  CLP_PARAM_DBL_OBJSCALE, 
-  CLP_PARAM_DBL_RHSSCALE,
-
-  CBC_PARAM_DBL_INFEASIBILITYWEIGHT = 51, 
-  CBC_PARAM_DBL_INTEGERTOLERANCE, 
-  CBC_PARAM_DBL_INCREMENT, 
-  CBC_PARAM_DBL_ALLOWABLEGAP,
-
-  CBC_PARAM_DBL_DJFIX = 81, 
-  CBC_PARAM_DBL_GAPRATIO, 
-  CBC_PARAM_DBL_TIGHTENFACTOR,
-
-  CLP_PARAM_INT_LOGLEVEL = 101, 
-  CLP_PARAM_INT_SOLVERLOGLEVEL, 
-  CBC_PARAM_INT_MAXNODES, 
-  CBC_PARAM_INT_STRONGBRANCHING,
-  CLP_PARAM_INT_MAXFACTOR, 
-  CLP_PARAM_INT_PERTVALUE, 
-  CLP_PARAM_INT_MAXITERATION, 
-  CLP_PARAM_INT_PRESOLVEPASS, 
-  CLP_PARAM_INT_IDIOT, 
-  CLP_PARAM_INT_SPRINT,
-  CLP_PARAM_INT_OUTPUTFORMAT, 
-  CLP_PARAM_INT_SLPVALUE, 
-  CLP_PARAM_INT_PRESOLVEOPTIONS, 
-  CLP_PARAM_INT_PRINTOPTIONS, 
-  CLP_PARAM_INT_SPECIALOPTIONS,
-
-  CLP_PARAM_STR_DIRECTION = 201, 
-  CLP_PARAM_STR_DUALPIVOT, 
-  CLP_PARAM_STR_SCALING, 
-  CLP_PARAM_STR_ERRORSALLOWED, 
-  CLP_PARAM_STR_KEEPNAMES, 
-  CLP_PARAM_STR_SPARSEFACTOR,
-  CLP_PARAM_STR_PRIMALPIVOT, 
-  CLP_PARAM_STR_PRESOLVE, 
-  CLP_PARAM_STR_CRASH, 
-  CLP_PARAM_STR_BIASLU, 
-  CLP_PARAM_STR_PERTURBATION, 
-  CLP_PARAM_STR_MESSAGES, 
-  CLP_PARAM_STR_AUTOSCALE,
-  CLP_PARAM_STR_CHOLESKY, 
-  CLP_PARAM_STR_KKT, 
-  CLP_PARAM_STR_BARRIERSCALE, 
-  CLP_PARAM_STR_GAMMA, 
-  CLP_PARAM_STR_CROSSOVER, 
-  CLP_PARAM_STR_PFI, 
-  CLP_PARAM_NOTUSED_ALGORITHM,
-
-  CBC_PARAM_STR_NODESTRATEGY = 251, 
-  CBC_PARAM_STR_BRANCHSTRATEGY, 
-  CBC_PARAM_NOTUSED_ADDCUTSSTRATEGY,
-  CBC_PARAM_STR_GOMORYCUTS, 
-  CBC_PARAM_STR_PROBINGCUTS, 
-  CBC_PARAM_STR_KNAPSACKCUTS, 
-  CBC_PARAM_NOTUSED_ODDHOLECUTS,
-  CBC_PARAM_STR_ROUNDING, 
-  CBC_PARAM_STR_SOLVER, 
-  CBC_PARAM_STR_CLIQUECUTS, 
-  CBC_PARAM_STR_COSTSTRATEGY, 
-  CBC_PARAM_STR_FLOWCUTS, 
-  CBC_PARAM_STR_MIXEDCUTS,
-  CBC_PARAM_STR_TWOMIRCUTS, 
-  CBC_PARAM_STR_PREPROCESS,
-
-  CLP_PARAM_ACTION_DIRECTORY = 301, 
-  CLP_PARAM_ACTION_IMPORT, 
-  CLP_PARAM_ACTION_EXPORT, 
-  CLP_PARAM_ACTION_RESTORE, 
-  CLP_PARAM_ACTION_SAVE, 
-  CLP_PARAM_ACTION_DUALSIMPLEX, 
-  CLP_PARAM_ACTION_PRIMALSIMPLEX,
-  CLP_PARAM_ACTION_MAXIMIZE, 
-  CLP_PARAM_ACTION_MINIMIZE, 
-  CLP_PARAM_ACTION_EXIT, 
-  CLP_PARAM_ACTION_STDIN, 
-  CLP_PARAM_ACTION_UNITTEST, 
-  CLP_PARAM_ACTION_NETLIB_DUAL, 
-  CLP_PARAM_ACTION_NETLIB_PRIMAL, 
-  CLP_PARAM_ACTION_SOLUTION,
-  CLP_PARAM_ACTION_TIGHTEN, 
-  CLP_PARAM_ACTION_FAKEBOUND, 
-  CLP_PARAM_ACTION_HELP, 
-  CLP_PARAM_ACTION_PLUSMINUS, 
-  CLP_PARAM_ACTION_NETWORK, 
-  CLP_PARAM_ACTION_ALLSLACK, 
-  CLP_PARAM_ACTION_REVERSE, 
-  CLP_PARAM_ACTION_BARRIER, 
-  CLP_PARAM_ACTION_NETLIB_BARRIER,
-  CLP_PARAM_ACTION_REALLY_SCALE, 
-  CLP_PARAM_ACTION_BASISIN, 
-  CLP_PARAM_ACTION_BASISOUT, 
-  CLP_PARAM_ACTION_SOLVECONTINUOUS, 
-  CBC_PARAM_ACTION_BAB, 
-  CBC_PARAM_ACTION_MIPLIB, 
-  CLP_PARAM_ACTION_CLEARCUTS,
-  CLP_VERSION_NOTUSED_PRINTVERSION,
-
-  CBC_PARAM_NOTUSED_OSLSTUFF = 401, 
-  CBC_PARAM_NOTUSED_CBCSTUFF,
-
-  CBC_PARAM_NOTUSED_INVALID = 1000
-};
-
-
-/// Very simple class for setting parameters
-
-class CbcParam {
-
-public:
-
-    /**@name Constructor and destructor */
-    //@{
-    /// Constructors
-    CbcParam (  );
-    CbcParam (std::string name, std::string help,
-              double lower, double upper, CbcParameterType type, bool display = true);
-    CbcParam (std::string name, std::string help,
-              int lower, int upper, CbcParameterType type, bool display = true);
-    // Other strings will be added by insert
-    CbcParam (std::string name, std::string help, std::string firstValue,
-              CbcParameterType type, int defaultIndex = 0, bool display = true);
-    // Action
-    CbcParam (std::string name, std::string help,
-              CbcParameterType type, int indexNumber = -1, bool display = true);
-    /// Copy constructor.
-    CbcParam(const CbcParam &);
-    /// Assignment operator. This copies the data
-    CbcParam & operator=(const CbcParam & rhs);
-    /// Destructor
-    ~CbcParam (  );
-    //@}
-
-    /**@name stuff */
-    //@{
-    /// Insert string (only valid for keywords)
-    void append(std::string keyWord);
-    /// Adds one help line
-    void addHelp(std::string keyWord);
-    /// Returns name
-    inline std::string  name(  ) const {
-        return name_;
-    };
-    /// Returns short help
-    inline std::string  shortHelp(  ) const {
-        return shortHelp_;
-    };
-    /// Sets a double parameter (nonzero code if error)
-    int setDoubleParameter(CbcModel & model, double value) const;
-    /// Gets a double parameter
-    double doubleParameter(CbcModel & model) const;
-    /// Sets a int parameter (nonzero code if error)
-    int setIntParameter(CbcModel & model, int value) const;
-    /// Gets a int parameter
-    int intParameter(CbcModel & model) const;
-    /// Sets a double parameter (nonzero code if error)
-    int setDoubleParameter(ClpSimplex * model, double value) const;
-    /// Gets a double parameter
-    double doubleParameter(ClpSimplex * model) const;
-    /// Sets a int parameter (nonzero code if error)
-    int setIntParameter(ClpSimplex * model, int value) const;
-    /// Gets a int parameter
-    int intParameter(ClpSimplex * model) const;
-    /// Sets a double parameter (nonzero code if error)
-    int setDoubleParameter(OsiSolverInterface * model, double value) const;
-    /// Gets a double parameter
-    double doubleParameter(OsiSolverInterface * model) const;
-    /// Sets a int parameter (nonzero code if error)
-    int setIntParameter(OsiSolverInterface * model, int value) const;
-    /// Gets a int parameter
-    int intParameter(OsiSolverInterface * model) const;
-    /// Checks a double parameter (nonzero code if error)
-    int checkDoubleParameter(double value) const;
-    /// Returns name which could match
-    std::string matchName (  ) const;
-    /// Returns parameter option which matches (-1 if none)
-    int parameterOption ( std::string check ) const;
-    /// Prints parameter options
-    void printOptions (  ) const;
-    /// Returns current parameter option
-    inline std::string currentOption (  ) const {
-        return definedKeyWords_[currentKeyWord_];
-    }
-    /// Sets current parameter option
-    inline void setCurrentOption ( int value ) {
-        currentKeyWord_ = value;
-    }
-    /// Sets int value
-    inline void setIntValue ( int value ) {
-        intValue_ = value;
-    }
-    inline int intValue () const {
-        return intValue_;
-    }
-    /// Sets double value
-    inline void setDoubleValue ( double value ) {
-        doubleValue_ = value;
-    }
-    inline double doubleValue () const {
-        return doubleValue_;
-    }
-    /// Sets string value
-    inline void setStringValue ( std::string value ) {
-        stringValue_ = value;
-    }
-    inline std::string stringValue () const {
-        return stringValue_;
-    }
-    /// Returns 1 if matches minimum, 2 if matches less, 0 if not matched
-    int matches (std::string input) const;
-    /// type
-    inline CbcParameterType type() const {
-        return type_;
-    }
-    /// whether to display
-    inline bool displayThis() const {
-        return display_;
-    }
-    /// Set Long help
-    inline void setLonghelp(const std::string help) {
-        longHelp_ = help;
-    }
-    /// Print Long help
-    void printLongHelp() const;
-    /// Print action and string
-    void printString() const;
-    /// type for classification
-    inline int indexNumber() const {
-        return indexNumber_;
-    }
-private:
-    /// gutsOfConstructor
-    void gutsOfConstructor();
-    //@}
-////////////////// data //////////////////
-private:
-
-    /**@name data
-     We might as well throw all type data in - could derive?
-    */
-    //@{
-    // Type see CbcParameterType
-    CbcParameterType type_;
-    /// If double == okay
-    double lowerDoubleValue_;
-    double upperDoubleValue_;
-    /// If int == okay
-    int lowerIntValue_;
-    int upperIntValue_;
-    // Length of name
-    unsigned int lengthName_;
-    // Minimum match
-    unsigned int lengthMatch_;
-    /// set of valid strings
-    std::vector<std::string> definedKeyWords_;
-    /// Name
-    std::string name_;
-    /// Short help
-    std::string shortHelp_;
-    /// Long help
-    std::string longHelp_;
-    /// Action
-    CbcParameterType action_;
-    /// Current keyWord (if a keyword parameter)
-    int currentKeyWord_;
-    /// Display on ?
-    bool display_;
-    /// Integer parameter - current value
-    int intValue_;
-    /// Double parameter - current value
-    double doubleValue_;
-    /// String parameter - current value
-    std::string stringValue_;
-    /// index number to use for display purposes
-    int indexNumber_;
-    //@}
-};
-#endif	/* CbcParam_H */
-

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

@@ -1,110 +0,0 @@
-// $Id: CbcPartialNodeInfo.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 CbcPartialNodeInfo_H
-#define CbcPartialNodeInfo_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;
-/** \brief Holds information for recreating a subproblem by incremental change
-	   from the parent.
-
-  A CbcPartialNodeInfo object contains changes to the bounds and basis, and
-  additional cuts, required to recreate a subproblem by modifying and
-  augmenting the parent subproblem.
-*/
-
-class CbcPartialNodeInfo : public CbcNodeInfo {
-
-public:
-
-    /** \brief Modify model according to information at node
-
-        The routine modifies the model according to bound and basis change
-        information at node and adds any cuts to the addCuts array.
-    */
-    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
-    CbcPartialNodeInfo ();
-
-    // Constructor from current state
-    CbcPartialNodeInfo (CbcNodeInfo * parent, CbcNode * owner,
-                        int numberChangedBounds, const int * variables,
-                        const double * boundChanges,
-                        const CoinWarmStartDiff *basisDiff) ;
-
-    // Copy constructor
-    CbcPartialNodeInfo ( const CbcPartialNodeInfo &);
-
-    // Destructor
-    ~CbcPartialNodeInfo ();
-
-    /// Clone
-    virtual CbcNodeInfo * clone() const;
-    /// Basis diff information
-    inline const CoinWarmStartDiff *basisDiff() const {
-        return basisDiff_ ;
-    }
-    /// Which variable (top bit if upper bound changing)
-    inline const int * variables() const {
-        return variables_;
-    }
-    // New bound
-    inline const double * newBounds() const {
-        return newBounds_;
-    }
-    /// Number of bound changes
-    inline int numberChangedBounds() const {
-        return numberChangedBounds_;
-    }
-protected:
-    /* Data values */
-
-    /// Basis diff information
-    CoinWarmStartDiff *basisDiff_ ;
-    /// Which variable (top bit if upper bound changing)
-    int * variables_;
-    // New bound
-    double * newBounds_;
-    /// Number of bound changes
-    int numberChangedBounds_;
-private:
-
-    /// Illegal Assignment operator
-    CbcPartialNodeInfo & operator=(const CbcPartialNodeInfo& rhs);
-};
-
-#endif //CbcPartialNodeInfo_H
-

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

@@ -1,279 +0,0 @@
-// $Id: CbcSOS.hpp 2070 2014-09-08 09:24:45Z 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/9/2009-- carved out of CbcBranchActual
-
-#ifndef CbcSOS_H
-#define CbcSOS_H
-
-/** \brief Branching object for Special Ordered Sets of type 1 and 2.
-
-  SOS1 are an ordered set of variables where at most one variable can be
-  non-zero. SOS1 are commonly defined with binary variables (interpreted as
-  selection between alternatives) but this is not necessary.  An SOS1 with
-  all binary variables is a special case of a clique (setting any one
-  variable to 1 forces all others to 0).
-
-  In theory, the implementation makes no assumptions about integrality in
-  Type 1 sets. In practice, there are places where the code seems to have been
-  written with a binary SOS mindset. Current development of SOS branching
-  objects is proceeding in OsiSOS.
-
-  SOS2 are an ordered set of variables in which at most two consecutive
-  variables can be non-zero and must sum to 1 (interpreted as interpolation
-  between two discrete values). By definition the variables are non-integer.
-*/
-
-class CbcSOS : public CbcObject {
-
-public:
-
-    // Default Constructor
-    CbcSOS ();
-
-	/** \brief Constructor with SOS type and member information
-
-    Type specifies SOS 1 or 2. Identifier is an arbitrary value.
-
-    Which should be an array of variable indices with numberMembers entries.
-    Weights can be used to assign arbitrary weights to variables, in the order
-    they are specified in which. If no weights are provided, a default array of
-    0, 1, 2, ... is generated.
-	*/
-
-    CbcSOS (CbcModel * model, int numberMembers,
-            const int * which, const double * weights, int identifier,
-            int type = 1);
-
-    // Copy constructor
-    CbcSOS ( const CbcSOS &);
-
-    /// Clone
-    virtual CbcObject * clone() const;
-
-    // Assignment operator
-    CbcSOS & operator=( const CbcSOS& rhs);
-
-    // Destructor
-    virtual ~CbcSOS ();
-
-    /// 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) ;
-
-
-
-    /** 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 & data) ;
-    using CbcObject::solverBranch ;
-    /** Create an OsiSolverBranch object
-
-        This returns NULL if branch not represented by bound changes
-    */
-    virtual OsiSolverBranch * solverBranch() const;
-    /// Redoes data when sequence numbers change
-    virtual void redoSequenceEtc(CbcModel * model, int numberColumns, const int * originalColumns);
-
-    /// Construct an OsiSOS object
-    OsiSOS * osiObject(const OsiSolverInterface * solver) const;
-    /// Number of members
-    inline int numberMembers() const {
-        return numberMembers_;
-    }
-
-    /// Members (indices in range 0 ... numberColumns-1)
-    inline const int * members() const {
-        return members_;
-    }
-
-    /// SOS type
-    inline int sosType() const {
-        return sosType_;
-    }
-    /// Down number times
-    inline int numberTimesDown() const {
-        return numberTimesDown_;
-    }
-    /// Up number times
-    inline int numberTimesUp() const {
-        return numberTimesUp_;
-    }
-
-    /** Array of weights */
-    inline const double * weights() const {
-        return weights_;
-    }
-
-    /// Set number of members
-    inline void setNumberMembers(int n) {
-        numberMembers_ = n;
-    }
-
-    /// Members (indices in range 0 ... numberColumns-1)
-    inline int * mutableMembers() const {
-        return members_;
-    }
-
-    /** Array of weights */
-    inline double * mutableWeights() const {
-        return weights_;
-    }
-
-    /** \brief Return true if object can take part in normal heuristics
-    */
-    virtual bool canDoHeuristics() const {
-        return (sosType_ == 1 && integerValued_);
-    }
-    /// Set whether set is integer valued or not
-    inline void setIntegerValued(bool yesNo) {
-        integerValued_ = yesNo;
-    }
-private:
-    /// data
-
-    /// Members (indices in range 0 ... numberColumns-1)
-    int * members_;
-  /** \brief Weights for individual members
-
-    Arbitrary weights for members. Can be used to attach meaning to variable
-    values independent of objective coefficients. For example, if the SOS set
-    comprises binary variables used to choose a facility of a given size, the
-    weight could be the corresponding facilty size. Fractional values of the
-    SOS variables can then be used to estimate ideal facility size.
-
-    Weights cannot be completely arbitrary. From the code, they must be
-    differ by at least 1.0e-7
-  */
-
-    double * weights_;
-    /// Current pseudo-shadow price estimate down
-    mutable double shadowEstimateDown_;
-    /// Current pseudo-shadow price estimate up
-    mutable double shadowEstimateUp_;
-    /// Down pseudo ratio
-    double downDynamicPseudoRatio_;
-    /// Up pseudo ratio
-    double upDynamicPseudoRatio_;
-    /// Number of times we have gone down
-    int numberTimesDown_;
-    /// Number of times we have gone up
-    int numberTimesUp_;
-    /// Number of members
-    int numberMembers_;
-    /// SOS type
-    int sosType_;
-    /// Whether integer valued
-    bool integerValued_;
-    /// Whether odd values e.g. negative
-    bool oddValues_;
-};
-
-/** Branching object for Special ordered sets
-
-    Variable_ is the set id number (redundant, as the object also holds a
-    pointer to the set.
- */
-class CbcSOSBranchingObject : public CbcBranchingObject {
-
-public:
-
-    // Default Constructor
-    CbcSOSBranchingObject ();
-
-    // Useful constructor
-    CbcSOSBranchingObject (CbcModel * model,  const CbcSOS * clique,
-                           int way,
-                           double separator);
-
-    // Copy constructor
-    CbcSOSBranchingObject ( const CbcSOSBranchingObject &);
-
-    // Assignment operator
-    CbcSOSBranchingObject & operator=( const CbcSOSBranchingObject& rhs);
-
-    /// Clone
-    virtual CbcBranchingObject * clone() const;
-
-    // Destructor
-    virtual ~CbcSOSBranchingObject ();
-
-    using CbcBranchingObject::branch ;
-    /// Does next branch and updates state
-    virtual double branch();
-    /** Update bounds in solver as in 'branch' and update given bounds.
-        branchState is -1 for 'down' +1 for 'up' */
-    virtual void fix(OsiSolverInterface * solver,
-                     double * lower, double * upper,
-                     int branchState) const ;
-
-    /** 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() {
-        CbcBranchingObject::previousBranch();
-        computeNonzeroRange();
-    }
-
-    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 SoSBranchObj;
-    }
-
-    /** 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);
-
-    /** Fill out the \c firstNonzero_ and \c lastNonzero_ data members */
-    void computeNonzeroRange();
-
-private:
-    /// data
-    const CbcSOS * set_;
-    /// separator
-    double separator_;
-    /** The following two members describe the range in the members_ of the
-        original object that whose upper bound is not fixed to 0. This is not
-        necessary for Cbc to function correctly, this is there for heuristics so
-        that separate branching decisions on the same object can be pooled into
-        one branching object. */
-    int firstNonzero_;
-    int lastNonzero_;
-};
-#endif
-