ruby-cbc 0.1.9 → 0.2.1

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

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