limp-cbc-0.3.2.0: cbits/coin/OsiBranchingObject.hpp
// 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