diff options
Diffstat (limited to 'thirdparty/linux/include/coin/CbcBranchingObject.hpp')
| -rw-r--r-- | thirdparty/linux/include/coin/CbcBranchingObject.hpp | 236 |
1 files changed, 236 insertions, 0 deletions
diff --git a/thirdparty/linux/include/coin/CbcBranchingObject.hpp b/thirdparty/linux/include/coin/CbcBranchingObject.hpp new file mode 100644 index 0000000..803108d --- /dev/null +++ b/thirdparty/linux/include/coin/CbcBranchingObject.hpp @@ -0,0 +1,236 @@ +// $Id: CbcBranchingObject.hpp 1899 2013-04-09 18:12:08Z stefan $ +// Copyright (C) 2002, International Business Machines +// Corporation and others. All Rights Reserved. +// This code is licensed under the terms of the Eclipse Public License (EPL). + +// Edwin 11/12/2009 carved from CbcBranchBase + +#ifndef CbcBranchingObject_H +#define CbcBranchingObject_H + +#include <string> +#include <vector> +#include "CbcBranchBase.hpp" +#include "OsiBranchingObject.hpp" + + +// The types of objects that will be derived from this class. +enum CbcBranchObjType + { + SimpleIntegerBranchObj = 100, + SimpleIntegerDynamicPseudoCostBranchObj = 101, + CliqueBranchObj = 102, + LongCliqueBranchObj = 103, + SoSBranchObj = 104, + NWayBranchObj = 105, + FollowOnBranchObj = 106, + DummyBranchObj = 107, + GeneralDepthBranchObj = 108, + OneGeneralBranchingObj = 110, + CutBranchingObj = 200, + LotsizeBranchObj = 300, + DynamicPseudoCostBranchObj = 400 + }; + +/** \brief Abstract branching object base class + Now just difference with OsiBranchingObject + + In the abstract, an CbcBranchingObject 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 CbcObject for an overview of the three classes (CbcObject, + CbcBranchingObject, and CbcBranchDecision) which make up cbc's branching + model. +*/ + +class CbcBranchingObject : public OsiBranchingObject { + +public: + + /// Default Constructor + CbcBranchingObject (); + + /// Constructor + CbcBranchingObject (CbcModel * model, int variable, int way , double value); + + /// Copy constructor + CbcBranchingObject ( const CbcBranchingObject &); + + /// Assignment operator + CbcBranchingObject & operator=( const CbcBranchingObject& rhs); + + /// Clone + virtual CbcBranchingObject * clone() const = 0; + + /// Destructor + virtual ~CbcBranchingObject (); + + /** Some branchingObjects may claim to be able to skip + strong branching. If so they have to fill in CbcStrongInfo. + The object mention in incoming CbcStrongInfo must match. + Returns nonzero if skip is wanted */ + virtual int fillStrongInfo( CbcStrongInfo & ) { + return 0; + } + /// Reset number of branches left to original + inline void resetNumberBranchesLeft() { + branchIndex_ = 0; + } + /// Set number of branches to do + inline void setNumberBranches(int value) { + branchIndex_ = 0; + numberBranches_ = value; + } + + /** \brief Execute the actions required to branch, as specified by the + current state of the branching object, and advance the object's + state. Mainly for diagnostics, whether it is true branch or + strong branching is also passed. + Returns change in guessed objective on next branch + */ + virtual double branch() = 0; + /** \brief Execute the actions required to branch, as specified by the + current state of the branching object, and advance the object's + state. Mainly for diagnostics, whether it is true branch or + strong branching is also passed. + Returns change in guessed objective on next branch + */ + virtual double branch(OsiSolverInterface * ) { + return branch(); + } + /** Update bounds in solver as in 'branch' and update given bounds. + branchState is -1 for 'down' +1 for 'up' */ + virtual void fix(OsiSolverInterface * , + double * , double * , + int ) const {} + + /** Change (tighten) bounds in object to reflect bounds in solver. + Return true if now fixed */ + virtual bool tighten(OsiSolverInterface * ) {return false;} + + /** Reset every information so that the branching object appears to point to + the previous child. This method does not need to modify anything in any + solver. */ + virtual void previousBranch() { + assert(branchIndex_ > 0); + branchIndex_--; + way_ = -way_; + } + + using OsiBranchingObject::print ; + /** \brief Print something about branch - only if log level high + */ + virtual void print() const {} + + /** \brief Index identifying the associated CbcObject within its class. + + The name is misleading, and typically the index will <i>not</i> refer + directly to a variable. + Rather, it identifies an CbcObject within the class of similar + CbcObjects + + <i>E.g.</i>, for an CbcSimpleInteger, variable() is the index of the + integer variable in the set of integer variables (<i>not</i> the index of + the variable in the set of all variables). + */ + inline int variable() const { + return variable_; + } + + /** Get the state of the branching object + + Returns a code indicating the active arm of the branching object. + The precise meaning is defined in the derived class. + + \sa #way_ + */ + inline int way() const { + return way_; + } + + /** Set the state of the branching object. + + See #way() + */ + inline void way(int way) { + way_ = way; + } + + /// update model + inline void setModel(CbcModel * model) { + model_ = model; + } + /// Return model + inline CbcModel * model() const { + return model_; + } + + /// Return pointer back to object which created + inline CbcObject * object() const { + return originalCbcObject_; + } + /// Set pointer back to object which created + inline void setOriginalObject(CbcObject * object) { + originalCbcObject_ = object; + } + + // Methods used in heuristics + + /** Return the type (an integer identifier) of \c this. + See definition of CbcBranchObjType above for possibilities + */ + + virtual CbcBranchObjType type() const = 0; + + /** Compare the original object of \c this with the original object of \c + brObj. Assumes that there is an ordering of the original objects. + This method should be invoked only if \c this and brObj are of the same + type. + Return negative/0/positive depending on whether \c this is + smaller/same/larger than the argument. + */ + virtual int compareOriginalObject(const CbcBranchingObject* brObj) const { + const CbcBranchingObject* br = dynamic_cast<const CbcBranchingObject*>(brObj); + return variable() - br->variable(); + } + + /** Compare the \c this with \c brObj. \c this and \c brObj must be of 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) = 0; + +protected: + + /// The model that owns this branching object + CbcModel * model_; + /// Pointer back to object which created + CbcObject * originalCbcObject_; + + /// Branching variable (0 is first integer) + int variable_; + // was - Way to branch - -1 down (first), 1 up, -2 down (second), 2 up (second) + /** The state of the branching object. + + Specifies the active arm of the branching object. Coded as -1 to take + the `down' arm, +1 for the `up' arm. `Down' and `up' are defined based on + the natural meaning (floor and ceiling, respectively) for a simple integer. + The precise meaning is defined in the derived class. + */ + int way_; + +}; +#endif + |