diff options
Diffstat (limited to 'thirdparty/linux/include/coin/CbcFullNodeInfo.hpp')
-rw-r--r-- | thirdparty/linux/include/coin/CbcFullNodeInfo.hpp | 161 |
1 files changed, 161 insertions, 0 deletions
diff --git a/thirdparty/linux/include/coin/CbcFullNodeInfo.hpp b/thirdparty/linux/include/coin/CbcFullNodeInfo.hpp new file mode 100644 index 0000000..c4704bd --- /dev/null +++ b/thirdparty/linux/include/coin/CbcFullNodeInfo.hpp @@ -0,0 +1,161 @@ +// $Id: CbcFullNodeInfo.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/24/09 carved from CbcNode + +#ifndef CbcFullNodeInfo_H +#define CbcFullNodeInfo_H + +#include <string> +#include <vector> + +#include "CoinWarmStartBasis.hpp" +#include "CoinSearchTree.hpp" +#include "CbcBranchBase.hpp" +#include "CbcNodeInfo.hpp" + +class OsiSolverInterface; +class OsiSolverBranch; + +class OsiCuts; +class OsiRowCut; +class OsiRowCutDebugger; +class CoinWarmStartBasis; +class CbcCountRowCut; +class CbcModel; +class CbcNode; +class CbcSubProblem; +class CbcGeneralBranchingObject; + +//############################################################################# +/** Information required to recreate the subproblem at this node + + When a subproblem is initially created, it is represented by a CbcNode + object and an attached CbcNodeInfo object. + + The CbcNode contains information needed while the subproblem remains live. + The CbcNode is deleted when the last branch arm has been evaluated. + + The CbcNodeInfo contains information required to maintain the branch-and-cut + search tree structure (links and reference counts) and to recreate the + subproblem for this node (basis, variable bounds, cutting planes). A + CbcNodeInfo object remains in existence until all nodes have been pruned from + the subtree rooted at this node. + + The principle used to maintain the reference count is that the reference + count is always the sum of all potential and actual children of the node. + Specifically, + <ul> + <li> Once it's determined how the node will branch, the reference count + is set to the number of potential children (<i>i.e.</i>, the number + of arms of the branch). + <li> As each child is created by CbcNode::branch() (converting a potential + child to the active subproblem), the reference count is decremented. + <li> If the child survives and will become a node in the search tree + (converting the active subproblem into an actual child), increment the + reference count. + </ul> + Notice that the active subproblem lives in a sort of limbo, neither a + potential or an actual node in the branch-and-cut tree. + + CbcNodeInfo objects come in two flavours. A CbcFullNodeInfo object contains + a full record of the information required to recreate a subproblem. + A CbcPartialNodeInfo object expresses this information in terms of + differences from the parent. +*/ + + +/** \brief Holds complete information for recreating a subproblem. + + A CbcFullNodeInfo object contains all necessary information (bounds, basis, + and cuts) required to recreate a subproblem. + + \todo While there's no explicit statement, the code often makes the implicit + assumption that an CbcFullNodeInfo structure will appear only at the + root node of the search tree. Things will break if this assumption + is violated. +*/ + +class CbcFullNodeInfo : public CbcNodeInfo { + +public: + + /** \brief Modify model according to information at node + + The routine modifies the model according to bound information at node, + creates a new basis according to information at node, but with the size + passed in through basis, and adds any cuts to the addCuts array. + + \note The basis passed in via basis is solely a vehicle for passing in + the desired basis size. It will be deleted and a new basis returned. + */ + virtual void applyToModel (CbcModel *model, CoinWarmStartBasis *&basis, + CbcCountRowCut **addCuts, + int ¤tNumberCuts) const ; + + /// Just apply bounds to one variable - force means overwrite by lower,upper (1=>infeasible) + virtual int applyBounds(int iColumn, double & lower, double & upper, int force) ; + + /** Builds up row basis backwards (until original model). + Returns NULL or previous one to apply . + Depends on Free being 0 and impossible for cuts + */ + virtual CbcNodeInfo * buildRowBasis(CoinWarmStartBasis & basis) const ; + // Default Constructor + CbcFullNodeInfo (); + + /** Constructor from continuous or satisfied + */ + CbcFullNodeInfo (CbcModel * model, + int numberRowsAtContinuous); + + // Copy constructor + CbcFullNodeInfo ( const CbcFullNodeInfo &); + + // Destructor + ~CbcFullNodeInfo (); + + /// Clone + virtual CbcNodeInfo * clone() const; + /// Lower bounds + inline const double * lower() const { + return lower_; + } + /// Set a bound + inline void setColLower(int sequence, double value) + { lower_[sequence]=value;} + /// Mutable lower bounds + inline double * mutableLower() const { + return lower_; + } + /// Upper bounds + inline const double * upper() const { + return upper_; + } + /// Set a bound + inline void setColUpper(int sequence, double value) + { upper_[sequence]=value;} + /// Mutable upper bounds + inline double * mutableUpper() const { + return upper_; + } +protected: + // Data + /** Full basis + + This MUST BE A POINTER to avoid cutting extra information in derived + warm start classes. + */ + CoinWarmStartBasis *basis_; + int numberIntegers_; + // Bounds stored in full + double * lower_; + double * upper_; +private: + /// Illegal Assignment operator + CbcFullNodeInfo & operator=(const CbcFullNodeInfo& rhs); +}; +#endif //CbcFullNodeInfo_H + |