diff options
author | harpreet | 2016-07-01 00:11:55 +0530 |
---|---|---|
committer | harpreet | 2016-07-01 00:11:55 +0530 |
commit | 89b96cb79cbe75ba8c1afea61b3caca37a083f62 (patch) | |
tree | 1b879fb0dce2406c1c49bf5bdabcedfb12ff020c /thirdparty/windows/include/coin/ClpNode.hpp | |
parent | 10e2e4d8b4a7592a8631ddac8e8d1664d6f0b9e3 (diff) | |
download | FOSSEE-Optimization-toolbox-89b96cb79cbe75ba8c1afea61b3caca37a083f62.tar.gz FOSSEE-Optimization-toolbox-89b96cb79cbe75ba8c1afea61b3caca37a083f62.tar.bz2 FOSSEE-Optimization-toolbox-89b96cb79cbe75ba8c1afea61b3caca37a083f62.zip |
Windows Included
Diffstat (limited to 'thirdparty/windows/include/coin/ClpNode.hpp')
-rw-r--r-- | thirdparty/windows/include/coin/ClpNode.hpp | 349 |
1 files changed, 349 insertions, 0 deletions
diff --git a/thirdparty/windows/include/coin/ClpNode.hpp b/thirdparty/windows/include/coin/ClpNode.hpp new file mode 100644 index 0000000..671d62f --- /dev/null +++ b/thirdparty/windows/include/coin/ClpNode.hpp @@ -0,0 +1,349 @@ +/* $Id: ClpNode.hpp 1910 2013-01-27 02:00:13Z stefan $ */ +// Copyright (C) 2008, International Business Machines +// Corporation and others. All Rights Reserved. +// This code is licensed under the terms of the Eclipse Public License (EPL). + +#ifndef ClpNode_H +#define ClpNode_H + +#include "CoinPragma.hpp" + +// This implements all stuff for Clp fathom +/** This contains what is in a Clp "node" + + */ + +class ClpFactorization; +class ClpDualRowSteepest; +class ClpNodeStuff; +class ClpNode { + +public: + /**@name Useful methods */ + //@{ + /** Applies node to model + 0 - just tree bounds + 1 - tree bounds and basis etc + 2 - saved bounds and basis etc + */ + void applyNode(ClpSimplex * model, int doBoundsEtc ); + /// Choose a new variable + void chooseVariable(ClpSimplex * model, ClpNodeStuff * info); + /// Fix on reduced costs + int fixOnReducedCosts(ClpSimplex * model); + /// Create odd arrays + void createArrays(ClpSimplex * model); + /// Clean up as crunch is different model + void cleanUpForCrunch(); + //@} + + /**@name Gets and sets */ + //@{ + /// Objective value + inline double objectiveValue() const { + return objectiveValue_; + } + /// Set objective value + inline void setObjectiveValue(double value) { + objectiveValue_ = value; + } + /// Primal solution + inline const double * primalSolution() const { + return primalSolution_; + } + /// Dual solution + inline const double * dualSolution() const { + return dualSolution_; + } + /// Initial value of integer variable + inline double branchingValue() const { + return branchingValue_; + } + /// Sum infeasibilities + inline double sumInfeasibilities() const { + return sumInfeasibilities_; + } + /// Number infeasibilities + inline int numberInfeasibilities() const { + return numberInfeasibilities_; + } + /// Relative depth + inline int depth() const { + return depth_; + } + /// Estimated solution value + inline double estimatedSolution() const { + return estimatedSolution_; + } + /** Way for integer variable -1 down , +1 up */ + int way() const; + /// Return true if branch exhausted + bool fathomed() const; + /// Change state of variable i.e. go other way + void changeState(); + /// Sequence number of integer variable (-1 if none) + inline int sequence() const { + return sequence_; + } + /// If odd arrays exist + inline bool oddArraysExist() const { + return lower_ != NULL; + } + /// Status array + inline const unsigned char * statusArray() const { + return status_; + } + //@} + + /**@name Constructors, destructor */ + //@{ + /** Default constructor. */ + ClpNode(); + /// Constructor from model + ClpNode (ClpSimplex * model, const ClpNodeStuff * stuff, int depth); + /// Does work of constructor (partly so gdb will work) + void gutsOfConstructor(ClpSimplex * model, const ClpNodeStuff * stuff, + int arraysExist, int depth); + /** Destructor */ + virtual ~ClpNode(); + //@} + + /**@name Copy methods (at present illegal - will abort) */ + //@{ + /** The copy constructor. */ + ClpNode(const ClpNode&); + /// Operator = + ClpNode& operator=(const ClpNode&); + //@} + +protected: +// For state of branch + typedef struct { + unsigned int firstBranch: 1; // nonzero if first branch on variable is up + unsigned int branch: 2; // 0 means do first branch next, 1 second, 2 finished + unsigned int spare: 29; + } branchState; + /**@name Data */ + //@{ + /// Initial value of integer variable + double branchingValue_; + /// Value of objective + double objectiveValue_; + /// Sum of infeasibilities + double sumInfeasibilities_; + /// Estimated solution value + double estimatedSolution_; + /// Factorization + ClpFactorization * factorization_; + /// Steepest edge weights + ClpDualRowSteepest * weights_; + /// Status vector + unsigned char * status_; + /// Primal solution + double * primalSolution_; + /// Dual solution + double * dualSolution_; + /// Integer lower bounds (only used in fathomMany) + int * lower_; + /// Integer upper bounds (only used in fathomMany) + int * upper_; + /// Pivot variables for factorization + int * pivotVariables_; + /// Variables fixed by reduced costs (at end of branch) 0x10000000 added if fixed to UB + int * fixed_; + /// State of branch + branchState branchState_; + /// Sequence number of integer variable (-1 if none) + int sequence_; + /// Number of infeasibilities + int numberInfeasibilities_; + /// Relative depth + int depth_; + /// Number fixed by reduced cost + int numberFixed_; + /// Flags - 1 duals scaled + int flags_; + /// Maximum number fixed by reduced cost + int maximumFixed_; + /// Maximum rows so far + int maximumRows_; + /// Maximum columns so far + int maximumColumns_; + /// Maximum Integers so far + int maximumIntegers_; + //@} +}; +class ClpNodeStuff { + +public: + /**@name Constructors, destructor */ + //@{ + /** Default constructor. */ + ClpNodeStuff(); + /** Destructor */ + virtual ~ClpNodeStuff(); + //@} + + /**@name Copy methods (only copies ints etc, nulls arrays) */ + //@{ + /** The copy constructor. */ + ClpNodeStuff(const ClpNodeStuff&); + /// Operator = + ClpNodeStuff& operator=(const ClpNodeStuff&); + /// Zaps stuff 1 - arrays, 2 ints, 3 both + void zap(int type); + //@} + + + /**@name Fill methods */ + //@{ + /** Fill with pseudocosts */ + void fillPseudoCosts(const double * down, const double * up, + const int * priority, + const int * numberDown, const int * numberUp, + const int * numberDownInfeasible, const int * numberUpInfeasible, + int number); + /// Update pseudo costs + void update(int way, int sequence, double change, bool feasible); + /// Return maximum number of nodes + int maximumNodes() const; + /// Return maximum space for nodes + int maximumSpace() const; + //@} + +public: + /**@name Data */ + //@{ + /// Integer tolerance + double integerTolerance_; + /// Integer increment + double integerIncrement_; + /// Small change in branch + double smallChange_; + /// Down pseudo costs + double * downPseudo_; + /// Up pseudo costs + double * upPseudo_; + /// Priority + int * priority_; + /// Number of times down + int * numberDown_; + /// Number of times up + int * numberUp_; + /// Number of times down infeasible + int * numberDownInfeasible_; + /// Number of times up infeasible + int * numberUpInfeasible_; + /// Copy of costs (local) + double * saveCosts_; + /// Array of ClpNodes + ClpNode ** nodeInfo_; + /// Large model if crunched + ClpSimplex * large_; + /// Which rows in large model + int * whichRow_; + /// Which columns in large model + int * whichColumn_; +#ifndef NO_FATHOM_PRINT + /// Cbc's message handler + CoinMessageHandler * handler_; +#endif + /// Number bounds in large model + int nBound_; + /// Save of specialOptions_ (local) + int saveOptions_; + /** Options to pass to solver + 1 - create external reduced costs for columns + 2 - create external reduced costs for rows + 4 - create external row activity (columns always done) + Above only done if feasible + 32 - just create up to nDepth_+1 nodes + 65536 - set if activated + */ + int solverOptions_; + /// Maximum number of nodes to do + int maximumNodes_; + /// Number before trust from CbcModel + int numberBeforeTrust_; + /// State of search from CbcModel + int stateOfSearch_; + /// Number deep + int nDepth_; + /// Number nodes returned (-1 if fathom aborted) + int nNodes_; + /// Number of nodes explored + int numberNodesExplored_; + /// Number of iterations + int numberIterations_; + /// Type of presolve - 0 none, 1 crunch + int presolveType_; +#ifndef NO_FATHOM_PRINT + /// Depth passed in + int startingDepth_; + /// Node at which called + int nodeCalled_; +#endif + //@} +}; +class ClpHashValue { + +public: + /**@name Useful methods */ + //@{ + /// Return index or -1 if not found + int index(double value) const; + /// Add value to list and return index + int addValue(double value) ; + /// Number of different entries + inline int numberEntries() const { + return numberHash_; + } + //@} + + /**@name Constructors, destructor */ + //@{ + /** Default constructor. */ + ClpHashValue(); + /** Useful constructor. */ + ClpHashValue(ClpSimplex * model); + /** Destructor */ + virtual ~ClpHashValue(); + //@} + + /**@name Copy method */ + //@{ + /** The copy constructor. */ + ClpHashValue(const ClpHashValue&); + /// = + ClpHashValue& operator=(const ClpHashValue&); + //@} +private: + /**@name private stuff */ + //@{ + /** returns hash */ + int hash(double value) const; + /// Resizes + void resize(bool increaseMax); + //@} + +protected: + /**@name Data members + The data members are protected to allow access for derived classes. */ + //@{ + /// Data + // for hashing + typedef struct { + double value; + int index, next; + } CoinHashLink; + /// Hash table + mutable CoinHashLink *hash_; + /// Number of entries in hash table + int numberHash_; + /// Maximum number of entries in hash table i.e. size + int maxHash_; + /// Last used space + int lastUsed_; + //@} +}; +#endif |