casadi 3.7.2__cp314-none-manylinux2014_x86_64.whl

casadi/include/coin/OsiBranchingObject.hpp

@@ -0,0 +1,1097 @@
+// 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
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/