ruby-cbc 0.1.9

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

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

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

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