diff options
Diffstat (limited to 'build/Bonmin/include/coin/CbcBranchLotsize.hpp')
| -rw-r--r-- | build/Bonmin/include/coin/CbcBranchLotsize.hpp | 242 |
1 files changed, 242 insertions, 0 deletions
diff --git a/build/Bonmin/include/coin/CbcBranchLotsize.hpp b/build/Bonmin/include/coin/CbcBranchLotsize.hpp new file mode 100644 index 0000000..4ba6510 --- /dev/null +++ b/build/Bonmin/include/coin/CbcBranchLotsize.hpp @@ -0,0 +1,242 @@ +/* $Id: CbcBranchLotsize.hpp 1573 2011-01-05 01:12:36Z lou $ */ +// Copyright (C) 2004, International Business Machines +// Corporation and others. All Rights Reserved. +// This code is licensed under the terms of the Eclipse Public License (EPL). + +#ifndef CbcBranchLotsize_H +#define CbcBranchLotsize_H + +#include "CbcBranchBase.hpp" +/** Lotsize class */ + + +class CbcLotsize : public CbcObject { + +public: + + // Default Constructor + CbcLotsize (); + + /* Useful constructor - passed model index. + Also passed valid values - if range then pairs + */ + CbcLotsize (CbcModel * model, int iColumn, + int numberPoints, const double * points, bool range = false); + + // Copy constructor + CbcLotsize ( const CbcLotsize &); + + /// Clone + virtual CbcObject * clone() const; + + // Assignment operator + CbcLotsize & operator=( const CbcLotsize& rhs); + + // Destructor + ~CbcLotsize (); + + /// Infeasibility - large is 0.5 + virtual double infeasibility(const OsiBranchingInformation * info, + int &preferredWay) const; + + using CbcObject::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. + */ + virtual void feasibleRegion(); + + /// Creates a branching object + virtual CbcBranchingObject * createCbcBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) ; + + /** \brief Given a valid solution (with reduced costs, etc.), + return a branching object which would give a new feasible + point in the good direction. + + The preferred branching object will force the variable to be +/-1 from + its current value, depending on the reduced cost and objective sense. If + movement in the direction which improves the objective is impossible due + to bounds on the variable, the branching object will move in the other + direction. If no movement is possible, the method returns NULL. + + Only the bounds on this variable are considered when determining if the new + point is feasible. + */ + virtual CbcBranchingObject * preferredNewFeasible() const; + + /** \brief Given a valid solution (with reduced costs, etc.), + return a branching object which would give a new feasible + point in a bad direction. + + As for preferredNewFeasible(), but the preferred branching object will + force movement in a direction that degrades the objective. + */ + virtual CbcBranchingObject * notPreferredNewFeasible() 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) const; + + /** Returns floor and ceiling + */ + virtual void floorCeiling(double & floorLotsize, double & ceilingLotsize, double value, + double tolerance) const; + + /// Model column number + inline int modelSequence() const { + return columnNumber_; + } + /// Set model column number + inline void setModelSequence(int value) { + columnNumber_ = value; + } + + /** Column number if single column object -1 otherwise, + so returns >= 0 + Used by heuristics + */ + virtual int columnNumber() const; + /// Original variable 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_; + } + /** \brief Return true if object can take part in normal heuristics + */ + virtual bool canDoHeuristics() const { + return false; + } + +private: + /// Just for debug (CBC_PRINT defined in CbcBranchLotsize.cpp) + void printLotsize(double value, bool condition, int type) const; + +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 CbcLotsizeBranchingObject : public CbcBranchingObject { + +public: + + /// Default constructor + CbcLotsizeBranchingObject (); + + /** 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. + */ + CbcLotsizeBranchingObject (CbcModel *model, int variable, + int way , double value, const CbcLotsize * lotsize) ; + + /** Create a degenerate branch object + + Specifies a `one-way branch'. Calling branch() for this object will + always result in lowerValue <= x <= upperValue. Used to fix in valid range + */ + + CbcLotsizeBranchingObject (CbcModel *model, int variable, int way, + double lowerValue, double upperValue) ; + + /// Copy constructor + CbcLotsizeBranchingObject ( const CbcLotsizeBranchingObject &); + + /// Assignment operator + CbcLotsizeBranchingObject & operator= (const CbcLotsizeBranchingObject& rhs); + + /// Clone + virtual CbcBranchingObject * clone() const; + + /// Destructor + virtual ~CbcLotsizeBranchingObject (); + + using CbcBranchingObject::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. + */ + virtual double branch(); + + using CbcBranchingObject::print ; + /** \brief Print something about branch - only if log level high + */ + virtual void print(); + + /** Return the type (an integer identifier) of \c this */ + virtual CbcBranchObjType type() const { + return LotsizeBranchObj; + } + + // LL: compareOriginalObject can be inherited from the CbcBranchingObject + // since variable_ uniquely defines the lot sizing object. + + /** Compare the \c this with \c brObj. \c this and \c brObj must be os the + same type and must have the same original object, but they may have + different feasible regions. + Return the appropriate CbcRangeCompare value (first argument being the + sub/superset if that's the case). In case of overlap (and if \c + replaceIfOverlap is true) replace the current branching object with one + whose feasible region is the overlap. + */ + virtual CbcRangeCompare compareBranchingObject + (const CbcBranchingObject* brObj, const bool replaceIfOverlap = false); + +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 + |