ruby-cbc 0.1.9

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

@@ -0,0 +1,1005 @@
+// Copyright (C) 2006, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef OsiBranchingObject_H
+#define OsiBranchingObject_H
+
+#include <cassert>
+#include <string>
+#include <vector>
+
+#include "CoinError.hpp"
+#include "CoinTypes.hpp"
+
+class OsiSolverInterface;
+class OsiSolverBranch;
+
+class OsiBranchingObject;
+class OsiBranchingInformation;
+
+//#############################################################################
+//This contains the abstract base class for an object and for branching.
+//It also contains a simple integer class
+//#############################################################################
+
+/** Abstract base class for `objects'.
+
+  The branching model used in Osi is based on the idea of an <i>object</i>.
+  In the abstract, an object is something that has a feasible region, can be
+  evaluated for infeasibility, can be branched on (<i>i.e.</i>, there's some
+  constructive action to be taken to move toward feasibility), and allows
+  comparison of the effect of branching.
+
+  This class (OsiObject) is the base class for an object. To round out the
+  branching model, the class OsiBranchingObject describes how to perform a
+  branch, and the class OsiBranchDecision describes how to compare two
+  OsiBranchingObjects.
+
+  To create a new type of object you need to provide three methods:
+  #infeasibility(), #feasibleRegion(), and #createBranch(), described below.
+
+  This base class is primarily virtual to allow for any form of structure.
+  Any form of discontinuity is allowed.
+
+  As there is an overhead in getting information from solvers and because
+  other useful information is available there is also an OsiBranchingInformation 
+  class which can contain pointers to information.
+  If used it must at minimum contain pointers to current value of objective,
+  maximum allowed objective and pointers to arrays for bounds and solution
+  and direction of optimization.  Also integer and primal tolerance.
+  
+  Classes which inherit might have other information such as depth, number of
+  solutions, pseudo-shadow prices etc etc.
+  May be easier just to throw in here - as I keep doing
+*/
+class OsiObject {
+
+public:
+  
+  /// Default Constructor 
+  OsiObject ();
+  
+  /// Copy constructor 
+  OsiObject ( const OsiObject &);
+  
+  /// Assignment operator 
+  OsiObject & operator=( const OsiObject& rhs);
+  
+  /// Clone
+  virtual OsiObject * clone() const=0;
+  
+  /// Destructor 
+  virtual ~OsiObject ();
+  
+  /** Infeasibility of the object
+      
+    This is some measure of the infeasibility of the object. 0.0 
+    indicates that the object is satisfied.
+  
+    The preferred branching direction is returned in whichWay, where for
+    normal two-way branching 0 is down, 1 is up
+  
+    This is used to prepare for strong branching but should also think of
+    case when no strong branching
+  
+    The object may also compute an estimate of cost of going "up" or "down".
+    This will probably be based on pseudo-cost ideas
+
+    This should also set mutable infeasibility_ and whichWay_
+    This is for instant re-use for speed
+
+    Default for this just calls infeasibility with OsiBranchingInformation
+    NOTE - Convention says that an infeasibility of COIN_DBL_MAX means 
+    object has worked out it can't be satisfied!
+  */
+  double infeasibility(const OsiSolverInterface * solver,int &whichWay) const ;
+  // Faster version when more information available
+  virtual double infeasibility(const OsiBranchingInformation * info, int &whichWay) const =0;
+  // This does NOT set mutable stuff
+  virtual double checkInfeasibility(const OsiBranchingInformation * info) const;
+  
+  /** For the variable(s) referenced by the object,
+      look at the current solution and set bounds to match the solution.
+      Returns measure of how much it had to move solution to make feasible
+  */
+  virtual double feasibleRegion(OsiSolverInterface * solver) const ;
+  /** For the variable(s) referenced by the object,
+      look at the current solution and set bounds to match the solution.
+      Returns measure of how much it had to move solution to make feasible
+      Faster version
+  */
+  virtual double feasibleRegion(OsiSolverInterface * solver, const OsiBranchingInformation * info) const =0;
+  
+  /** Create a branching object and indicate which way to branch first.
+      
+      The branching object has to know how to create branches (fix
+      variables, etc.)
+  */
+  virtual OsiBranchingObject * createBranch(OsiSolverInterface * /*solver*/,
+					    const OsiBranchingInformation * /*info*/,
+					    int /*way*/) const {throw CoinError("Need code","createBranch","OsiBranchingObject"); return NULL; }
+  
+  /** \brief Return true if object can take part in normal heuristics
+  */
+  virtual bool canDoHeuristics() const 
+  {return true;}
+  /** \brief Return true if object can take part in move to nearest heuristic
+  */
+  virtual bool canMoveToNearest() const 
+  {return false;}
+  /** Column number if single column object -1 otherwise,
+      Used by heuristics
+  */
+  virtual int columnNumber() const;
+  /// Return Priority - note 1 is highest priority
+  inline int priority() const
+  { return priority_;}
+  /// Set priority
+  inline void setPriority(int priority)
+  { priority_ = priority;}
+  /** \brief Return true if branch should only bound variables
+  */
+  virtual bool boundBranch() const 
+  {return true;}
+  /// Return true if knows how to deal with Pseudo Shadow Prices
+  virtual bool canHandleShadowPrices() const
+  { return false;}
+  /// Return maximum number of ways branch may have
+  inline int numberWays() const
+  { return numberWays_;}
+  /// Set maximum number of ways branch may have
+  inline void setNumberWays(int numberWays)
+  { numberWays_ = static_cast<short int>(numberWays) ; }
+  /** Return preferred way to branch.  If two
+      then way=0 means down and 1 means up, otherwise
+      way points to preferred branch
+  */
+  inline void setWhichWay(int way)
+  { whichWay_ = static_cast<short int>(way) ; }
+  /** Return current preferred way to branch.  If two
+      then way=0 means down and 1 means up, otherwise
+      way points to preferred branch
+  */
+  inline int whichWay() const
+  { return whichWay_;}
+  /// Get pre-emptive preferred way of branching - -1 off, 0 down, 1 up (for 2-way)
+  virtual int preferredWay() const
+  { return -1;}
+  /// Return infeasibility
+  inline double infeasibility() const
+  { return infeasibility_;}
+  /// Return "up" estimate (default 1.0e-5)
+  virtual double upEstimate() const;
+  /// Return "down" estimate (default 1.0e-5)
+  virtual double downEstimate() const;
+  /** Reset variable bounds to their original values.
+    Bounds may be tightened, so it may be good to be able to reset them to
+    their original values.
+   */
+  virtual void resetBounds(const OsiSolverInterface * ) {}
+  /**  Change column numbers after preprocessing
+   */
+  virtual void resetSequenceEtc(int , const int * ) {}
+  /// Updates stuff like pseudocosts before threads
+  virtual void updateBefore(const OsiObject * ) {}
+  /// Updates stuff like pseudocosts after threads finished
+  virtual void updateAfter(const OsiObject * , const OsiObject * ) {}
+
+protected:
+  /// data
+
+  /// Computed infeasibility
+  mutable double infeasibility_;
+  /// Computed preferred way to branch 
+  mutable short whichWay_;
+  /// Maximum number of ways on branch
+  short  numberWays_;
+  /// Priority
+  int priority_;
+
+};
+/// Define a class to add a bit of complexity to OsiObject
+/// This assumes 2 way branching
+
+
+class OsiObject2 : public OsiObject {
+
+public:
+
+  /// Default Constructor 
+  OsiObject2 ();
+
+  /// Copy constructor 
+  OsiObject2 ( const OsiObject2 &);
+   
+  /// Assignment operator 
+  OsiObject2 & operator=( const OsiObject2& rhs);
+
+  /// Destructor 
+  virtual ~OsiObject2 ();
+  
+  /// Set preferred way of branching - -1 off, 0 down, 1 up (for 2-way)
+  inline void setPreferredWay(int value)
+  {preferredWay_=value;}
+  
+  /// Get preferred way of branching - -1 off, 0 down, 1 up (for 2-way)
+  virtual int preferredWay() const
+  { return preferredWay_;}
+protected:
+  /// Preferred way of branching - -1 off, 0 down, 1 up (for 2-way)
+  int preferredWay_;
+  /// "Infeasibility" on other way
+  mutable double otherInfeasibility_;
+  
+};
+
+/** \brief Abstract branching object base class
+
+  In the abstract, an OsiBranchingObject 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 OsiObject for an overview of the two classes (OsiObject and
+  OsiBranchingObject) which make up Osi's branching
+  model.
+*/
+
+class OsiBranchingObject {
+
+public:
+
+  /// Default Constructor 
+  OsiBranchingObject ();
+
+  /// Constructor 
+  OsiBranchingObject (OsiSolverInterface * solver, double value);
+  
+  /// Copy constructor 
+  OsiBranchingObject ( const OsiBranchingObject &);
+   
+  /// Assignment operator 
+  OsiBranchingObject & operator=( const OsiBranchingObject& rhs);
+
+  /// Clone
+  virtual OsiBranchingObject * clone() const=0;
+
+  /// Destructor 
+  virtual ~OsiBranchingObject ();
+
+  /// The number of branch arms created for this branching object
+  inline int numberBranches() const
+  {return numberBranches_;}
+
+  /// The number of branch arms left for this branching object
+  inline int numberBranchesLeft() const
+  {return numberBranches_-branchIndex_;}
+
+  /// Increment the number of branch arms left for this branching object
+  inline void incrementNumberBranchesLeft()
+  { numberBranches_ ++;}
+
+  /** Set the number of branch arms left for this branching object
+      Just for forcing
+  */
+  inline void setNumberBranchesLeft(int /*value*/)
+  {/*assert (value==1&&!branchIndex_);*/ numberBranches_=1;}
+
+  /// Decrement the number of branch arms left for this branching object
+  inline void decrementNumberBranchesLeft()
+  {branchIndex_++;}
+
+  /** \brief Execute the actions required to branch, as specified by the
+	     current state of the branching object, and advance the object's
+	     state. 
+	     Returns change in guessed objective on next branch
+  */
+  virtual double branch(OsiSolverInterface * solver)=0;
+  /** \brief Execute the actions required to branch, as specified by the
+	     current state of the branching object, and advance the object's
+	     state. 
+	     Returns change in guessed objective on next branch
+  */
+  virtual double branch() {return branch(NULL);}
+  /** \brief Return true if branch should fix variables
+  */
+  virtual bool boundBranch() const 
+  {return true;}
+  /** Get the state of the branching object
+      This is just the branch index
+  */
+  inline int branchIndex() const
+  {return branchIndex_;}
+
+  /** Set the state of the branching object.
+  */
+  inline void setBranchingIndex(int branchIndex)
+  { branchIndex_ = static_cast<short int>(branchIndex) ; }
+
+  /// Current value
+  inline double value() const
+  {return value_;}
+  
+  /// Return pointer back to object which created
+  inline const OsiObject * originalObject() const
+  {return  originalObject_;}
+  /// Set pointer back to object which created
+  inline void setOriginalObject(const OsiObject * object)
+  {originalObject_=object;}
+  /** Double checks in case node can change its mind!
+      Returns objective value
+      Can change objective etc */
+  virtual void checkIsCutoff(double ) {}
+  /// For debug
+  int columnNumber() const;
+  /** \brief Print something about branch - only if log level high
+  */
+  virtual void print(const OsiSolverInterface * =NULL) const {}
+
+protected:
+
+  /// Current value - has some meaning about branch
+  double value_;
+
+  /// Pointer back to object which created
+  const OsiObject * originalObject_;
+
+  /** Number of branches
+  */
+  int numberBranches_;
+
+  /** The state of the branching object. i.e. branch index
+      This starts at 0 when created
+  */
+  short branchIndex_;
+
+};
+/* This contains information
+   This could also contain pseudo shadow prices
+   or information for dealing with computing and trusting pseudo-costs
+*/
+class OsiBranchingInformation {
+
+public:
+  
+  /// Default Constructor 
+  OsiBranchingInformation ();
+  
+  /** Useful Constructor 
+      (normalSolver true if has matrix etc etc)
+      copySolution true if constructot should make a copy
+  */
+  OsiBranchingInformation (const OsiSolverInterface * solver, bool normalSolver,bool copySolution=false);
+  
+  /// Copy constructor 
+  OsiBranchingInformation ( const OsiBranchingInformation &);
+  
+  /// Assignment operator 
+  OsiBranchingInformation & operator=( const OsiBranchingInformation& rhs);
+  
+  /// Clone
+  virtual OsiBranchingInformation * clone() const;
+  
+  /// Destructor 
+  virtual ~OsiBranchingInformation ();
+  
+  // Note public
+public:
+  /// data
+
+  /** State of search
+      0 - no solution
+      1 - only heuristic solutions
+      2 - branched to a solution 
+      3 - no solution but many nodes
+  */
+  int stateOfSearch_;
+  /// Value of objective function (in minimization sense)
+  double objectiveValue_;
+  /// Value of objective cutoff (in minimization sense)
+  double cutoff_;
+  /// Direction 1.0 for minimization, -1.0 for maximization
+  double direction_;
+  /// Integer tolerance
+  double integerTolerance_;
+  /// Primal tolerance
+  double primalTolerance_;
+  /// Maximum time remaining before stopping on time
+  double timeRemaining_;
+  /// Dual to use if row bound violated (if negative then pseudoShadowPrices off)
+  double defaultDual_;
+  /// Pointer to solver
+  mutable const OsiSolverInterface * solver_;
+  /// The number of columns
+  int numberColumns_;
+  /// Pointer to current lower bounds on columns
+  mutable const double * lower_;
+  /// Pointer to current solution
+  mutable const double * solution_;
+  /// Pointer to current upper bounds on columns
+  mutable const double * upper_;
+  /// Highly optional target (hot start) solution
+  const double * hotstartSolution_;
+  /// Pointer to duals
+  const double * pi_;
+  /// Pointer to row activity
+  const double * rowActivity_;
+  /// Objective
+  const double * objective_;
+  /// Pointer to current lower bounds on rows
+  const double * rowLower_;
+  /// Pointer to current upper bounds on rows
+  const double * rowUpper_;
+  /// Elements in column copy of matrix
+  const double * elementByColumn_;
+  /// Column starts
+  const CoinBigIndex * columnStart_;
+  /// Column lengths
+  const int * columnLength_;
+  /// Row indices
+  const int * row_;
+  /** Useful region of length CoinMax(numberColumns,2*numberRows)
+      This is allocated and deleted before OsiObject::infeasibility
+      It is zeroed on entry and should be so on exit
+      It only exists if defaultDual_>=0.0
+  */
+  double * usefulRegion_;
+  /// Useful index region to go with usefulRegion_
+  int * indexRegion_;
+  /// Number of solutions found
+  int numberSolutions_;
+  /// Number of branching solutions found (i.e. exclude heuristics)
+  int numberBranchingSolutions_;
+  /// Depth in tree
+  int depth_;
+  /// TEMP
+  bool owningSolution_;
+};
+
+/// This just adds two-wayness to a branching object
+
+class OsiTwoWayBranchingObject : public OsiBranchingObject {
+
+public:
+
+  /// Default constructor 
+  OsiTwoWayBranchingObject ();
+
+  /** Create a standard tw0-way branch object
+
+    Specifies a simple two-way branch.
+    Specify way = -1 to set the object state to perform the down arm first,
+    way = 1 for the up arm.
+  */
+  OsiTwoWayBranchingObject (OsiSolverInterface *solver,const OsiObject * originalObject,
+			     int way , double value) ;
+    
+  /// Copy constructor 
+  OsiTwoWayBranchingObject ( const OsiTwoWayBranchingObject &);
+   
+  /// Assignment operator 
+  OsiTwoWayBranchingObject & operator= (const OsiTwoWayBranchingObject& rhs);
+
+  /// Destructor 
+  virtual ~OsiTwoWayBranchingObject ();
+
+  using OsiBranchingObject::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.
+	     state. 
+	     Returns change in guessed objective on next branch
+  */
+  virtual double branch(OsiSolverInterface * solver)=0;
+
+  inline int firstBranch() const { return firstBranch_; }
+  /// Way returns -1 on down +1 on up
+  inline int way() const
+  { return !branchIndex_ ? firstBranch_ : -firstBranch_;}
+protected:
+  /// Which way was first branch -1 = down, +1 = up
+  int firstBranch_;
+};
+/// Define a single integer class
+
+
+class OsiSimpleInteger : public OsiObject2 {
+
+public:
+
+  /// Default Constructor 
+  OsiSimpleInteger ();
+
+  /// Useful constructor - passed solver index
+  OsiSimpleInteger (const OsiSolverInterface * solver, int iColumn);
+  
+  /// Useful constructor - passed solver index and original bounds
+  OsiSimpleInteger (int iColumn, double lower, double upper);
+  
+  /// Copy constructor 
+  OsiSimpleInteger ( const OsiSimpleInteger &);
+   
+  /// Clone
+  virtual OsiObject * clone() const;
+
+  /// Assignment operator 
+  OsiSimpleInteger & operator=( const OsiSimpleInteger& rhs);
+
+  /// Destructor 
+  virtual ~OsiSimpleInteger ();
+  
+  using OsiObject::infeasibility ;
+  /// Infeasibility - large is 0.5
+  virtual double infeasibility(const OsiBranchingInformation * info, int & whichWay) const;
+
+  using OsiObject::feasibleRegion ;
+  /** Set bounds to fix the variable at the current (integer) value.
+
+    Given an integer value, set the lower and upper bounds to fix the
+    variable. Returns amount it had to move variable.
+  */
+  virtual double feasibleRegion(OsiSolverInterface * solver, const OsiBranchingInformation * info) const;
+
+  /** Creates a branching object
+
+    The preferred direction is set by \p way, 0 for down, 1 for up.
+  */
+  virtual OsiBranchingObject * createBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) const;
+
+
+  /// Set solver column number
+  inline void setColumnNumber(int value)
+  {columnNumber_=value;}
+  
+  /** Column number if single column object -1 otherwise,
+      so returns >= 0
+      Used by heuristics
+  */
+  virtual int columnNumber() const;
+
+  /// Original bounds
+  inline double originalLowerBound() const
+  { return originalLower_;}
+  inline void setOriginalLowerBound(double value)
+  { originalLower_=value;}
+  inline double originalUpperBound() const
+  { return originalUpper_;}
+  inline void setOriginalUpperBound(double value)
+  { originalUpper_=value;}
+  /** Reset variable bounds to their original values.
+    Bounds may be tightened, so it may be good to be able to reset them to
+    their original values.
+   */
+  virtual void resetBounds(const OsiSolverInterface * solver) ;
+  /**  Change column numbers after preprocessing
+   */
+  virtual void resetSequenceEtc(int numberColumns, const int * originalColumns);
+  
+  /// Return "up" estimate (default 1.0e-5)
+  virtual double upEstimate() const;
+  /// Return "down" estimate (default 1.0e-5)
+  virtual double downEstimate() const;
+  /// Return true if knows how to deal with Pseudo Shadow Prices
+  virtual bool canHandleShadowPrices() const
+  { return false;}
+protected:
+  /// data
+  /// Original lower bound
+  double originalLower_;
+  /// Original upper bound
+  double originalUpper_;
+  /// Column number in solver
+  int columnNumber_;
+  
+};
+/** Simple branching object for an integer variable
+
+  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. 0 -> down, 1-> up.
+*/
+
+class OsiIntegerBranchingObject : public OsiTwoWayBranchingObject {
+
+public:
+
+  /// Default constructor 
+  OsiIntegerBranchingObject ();
+
+  /** Create a standard floor/ceiling branch object
+
+    Specifies a simple two-way branch. Let \p value = x*. One arm of the
+    branch will be 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.
+  */
+  OsiIntegerBranchingObject (OsiSolverInterface *solver,const OsiSimpleInteger * originalObject,
+			     int way , double value) ;
+  /** Create a standard floor/ceiling branch object
+
+    Specifies a simple two-way branch in a more flexible way. One arm of the
+    branch will be lb <= x <= downUpperBound, the other upLowerBound <= x <= ub.
+    Specify way = -1 to set the object state to perform the down arm first,
+    way = 1 for the up arm.
+  */
+  OsiIntegerBranchingObject (OsiSolverInterface *solver,const OsiSimpleInteger * originalObject,
+			     int way , double value, double downUpperBound, double upLowerBound) ;
+    
+  /// Copy constructor 
+  OsiIntegerBranchingObject ( const OsiIntegerBranchingObject &);
+   
+  /// Assignment operator 
+  OsiIntegerBranchingObject & operator= (const OsiIntegerBranchingObject& rhs);
+
+  /// Clone
+  virtual OsiBranchingObject * clone() const;
+
+  /// Destructor 
+  virtual ~OsiIntegerBranchingObject ();
+  
+  using OsiBranchingObject::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.
+	     state. 
+	     Returns change in guessed objective on next branch
+  */
+  virtual double branch(OsiSolverInterface * solver);
+
+  using OsiBranchingObject::print ;
+  /** \brief Print something about branch - only if log level high
+  */
+  virtual void print(const OsiSolverInterface * solver=NULL);
+
+protected:
+  // Probably could get away with just value which is already stored 
+  /// 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];
+};
+
+
+/** Define Special Ordered Sets of type 1 and 2.  These do not have to be
+    integer - so do not appear in lists of integers.
+    
+    which_ points columns of matrix
+*/
+
+
+class OsiSOS : public OsiObject2 {
+
+public:
+
+  // Default Constructor 
+  OsiSOS ();
+
+  /** Useful constructor - which are indices
+      and  weights are also given.  If null then 0,1,2..
+      type is SOS type
+  */
+  OsiSOS (const OsiSolverInterface * solver, int numberMembers,
+	   const int * which, const double * weights, int type=1);
+  
+  // Copy constructor 
+  OsiSOS ( const OsiSOS &);
+   
+  /// Clone
+  virtual OsiObject * clone() const;
+
+  // Assignment operator 
+  OsiSOS & operator=( const OsiSOS& rhs);
+
+  // Destructor 
+  virtual ~OsiSOS ();
+  
+  using OsiObject::infeasibility ;
+  /// Infeasibility - large is 0.5
+  virtual double infeasibility(const OsiBranchingInformation * info,int & whichWay) const;
+
+  using OsiObject::feasibleRegion ;
+  /** Set bounds to fix the variable at the current (integer) value.
+
+    Given an integer value, set the lower and upper bounds to fix the
+    variable. Returns amount it had to move variable.
+  */
+  virtual double feasibleRegion(OsiSolverInterface * solver, const OsiBranchingInformation * info) const;
+
+  /** Creates a branching object
+
+    The preferred direction is set by \p way, 0 for down, 1 for up.
+  */
+  virtual OsiBranchingObject * createBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) const;
+  /// Return "up" estimate (default 1.0e-5)
+  virtual double upEstimate() const;
+  /// Return "down" estimate (default 1.0e-5)
+  virtual double downEstimate() const;
+  
+  /// Redoes data when sequence numbers change
+  virtual void resetSequenceEtc(int numberColumns, const int * originalColumns);
+  
+  /// 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_;}
+
+  /// SOS type
+  inline int setType() const
+  {return sosType_;}
+
+  /** Array of weights */
+  inline const double * weights() 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;}
+  /// Return true if knows how to deal with Pseudo Shadow Prices
+  virtual bool canHandleShadowPrices() const
+  { return true;}
+  /// Set number of members
+  inline void setNumberMembers(int value)
+  {numberMembers_=value;}
+
+  /// Members (indices in range 0 ... numberColumns-1)
+  inline int * mutableMembers() const
+  {return members_;}
+
+  /// Set SOS type
+  inline void setSosType(int value)
+  {sosType_=value;}
+
+  /** Array of weights */
+  inline  double * mutableWeights() const
+  { return weights_;}
+protected:
+  /// data
+
+  /// Members (indices in range 0 ... numberColumns-1)
+  int * members_;
+  /// Weights
+  double * weights_;
+
+  /// Number of members
+  int numberMembers_;
+  /// SOS type
+  int sosType_;
+  /// Whether integer valued
+  bool integerValued_;
+};
+
+/** Branching object for Special ordered sets
+
+ */
+class OsiSOSBranchingObject : public OsiTwoWayBranchingObject {
+
+public:
+
+  // Default Constructor 
+  OsiSOSBranchingObject ();
+
+  // Useful constructor
+  OsiSOSBranchingObject (OsiSolverInterface * solver,  const OsiSOS * originalObject,
+			    int way,
+			 double separator);
+  
+  // Copy constructor 
+  OsiSOSBranchingObject ( const OsiSOSBranchingObject &);
+   
+  // Assignment operator 
+  OsiSOSBranchingObject & operator=( const OsiSOSBranchingObject& rhs);
+
+  /// Clone
+  virtual OsiBranchingObject * clone() const;
+
+  // Destructor 
+  virtual ~OsiSOSBranchingObject ();
+  
+  using OsiBranchingObject::branch ;
+  /// Does next branch and updates state
+  virtual double branch(OsiSolverInterface * solver);
+
+  using OsiBranchingObject::print ;
+  /** \brief Print something about branch - only if log level high
+  */
+  virtual void print(const OsiSolverInterface * solver=NULL);
+private:
+  /// data
+};
+/** Lotsize class */
+
+
+class OsiLotsize : public OsiObject2 {
+
+public:
+
+  // Default Constructor 
+  OsiLotsize ();
+
+  /* Useful constructor - passed model index.
+     Also passed valid values - if range then pairs
+  */
+  OsiLotsize (const OsiSolverInterface * solver, int iColumn,
+	      int numberPoints, const double * points, bool range=false);
+  
+  // Copy constructor 
+  OsiLotsize ( const OsiLotsize &);
+   
+  /// Clone
+  virtual OsiObject * clone() const;
+
+  // Assignment operator 
+  OsiLotsize & operator=( const OsiLotsize& rhs);
+
+  // Destructor 
+  virtual ~OsiLotsize ();
+  
+  using OsiObject::infeasibility ;
+  /// Infeasibility - large is 0.5
+  virtual double infeasibility(const OsiBranchingInformation * info, int & whichWay) const;
+
+  using OsiObject::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.  Returns amount it had to move variable.
+  */
+  virtual double feasibleRegion(OsiSolverInterface * solver, const OsiBranchingInformation * info) const;
+
+  /** Creates a branching object
+
+    The preferred direction is set by \p way, 0 for down, 1 for up.
+  */
+  virtual OsiBranchingObject * createBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) const;
+
+
+  /// Set solver column number
+  inline void setColumnNumber(int value)
+  {columnNumber_=value;}
+  
+  /** Column number if single column object -1 otherwise,
+      so returns >= 0
+      Used by heuristics
+  */
+  virtual int columnNumber() 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, double integerTolerance) const;
+  
+  /** Returns floor and ceiling
+  */
+  virtual void floorCeiling(double & floorLotsize, double & ceilingLotsize, double value,
+			    double tolerance) const;
+  
+  /// Original 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_;}
+  /**  Change column numbers after preprocessing
+   */
+  virtual void resetSequenceEtc(int numberColumns, const int * originalColumns);
+  
+  /// Return "up" estimate (default 1.0e-5)
+  virtual double upEstimate() const;
+  /// Return "down" estimate (default 1.0e-5)
+  virtual double downEstimate() const;
+  /// Return true if knows how to deal with Pseudo Shadow Prices
+  virtual bool canHandleShadowPrices() const
+  { return true;}
+  /** \brief Return true if object can take part in normal heuristics
+  */
+  virtual bool canDoHeuristics() const 
+  {return false;}
+
+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 OsiLotsizeBranchingObject : public OsiTwoWayBranchingObject {
+
+public:
+
+  /// Default constructor 
+  OsiLotsizeBranchingObject ();
+
+  /** 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.
+  */
+  OsiLotsizeBranchingObject (OsiSolverInterface *solver,const OsiLotsize * originalObject, 
+			     int way , double value) ;
+  
+  /// Copy constructor 
+  OsiLotsizeBranchingObject ( const OsiLotsizeBranchingObject &);
+   
+  /// Assignment operator 
+  OsiLotsizeBranchingObject & operator= (const OsiLotsizeBranchingObject& rhs);
+
+  /// Clone
+  virtual OsiBranchingObject * clone() const;
+
+  /// Destructor 
+  virtual ~OsiLotsizeBranchingObject ();
+
+  using OsiBranchingObject::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.
+	     state. 
+	     Returns change in guessed objective on next branch
+  */
+  virtual double branch(OsiSolverInterface * solver);
+
+  using OsiBranchingObject::print ;
+  /** \brief Print something about branch - only if log level high
+  */
+  virtual void print(const OsiSolverInterface * solver=NULL);
+
+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