diff options
Diffstat (limited to 'thirdparty/linux/include/coin/ClpEventHandler.hpp')
| -rw-r--r-- | thirdparty/linux/include/coin/ClpEventHandler.hpp | 187 |
1 files changed, 187 insertions, 0 deletions
diff --git a/thirdparty/linux/include/coin/ClpEventHandler.hpp b/thirdparty/linux/include/coin/ClpEventHandler.hpp new file mode 100644 index 0000000..aeed324 --- /dev/null +++ b/thirdparty/linux/include/coin/ClpEventHandler.hpp @@ -0,0 +1,187 @@ +/* $Id: ClpEventHandler.hpp 2156 2015-08-07 14:51:42Z forrest $ */ +// 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 ClpEventHandler_H +#define ClpEventHandler_H + +#include "ClpSimplex.hpp" +/** Base class for Clp event handling + +This is just here to allow for event handling. By event I mean a Clp event +e.g. end of values pass. + +One use would be to let a user handle a system event e.g. Control-C. This could be done +by deriving a class MyEventHandler which knows about such events. If one occurs +MyEventHandler::event() could clear event status and return 3 (stopped). + +Clp would then return to user code. + +As it is called every iteration this should be fine grained enough. + +User can derive and construct from CbcModel - not pretty + +*/ + +class ClpEventHandler { + +public: + /** enums for what sort of event. + + These will also be returned in ClpModel::secondaryStatus() as int + */ + enum Event { + endOfIteration = 100, // used to set secondary status + endOfFactorization, // after gutsOfSolution etc + endOfValuesPass, + node, // for Cbc + treeStatus, // for Cbc + solution, // for Cbc + theta, // hit in parametrics + pivotRow, // used to choose pivot row + presolveStart, // ClpSolve presolve start + presolveSize, // sees if ClpSolve presolve too big or too small + presolveInfeasible, // ClpSolve presolve infeasible + presolveBeforeSolve, // ClpSolve presolve before solve + presolveAfterFirstSolve, // ClpSolve presolve after solve + presolveAfterSolve, // ClpSolve presolve after solve + presolveEnd, // ClpSolve presolve end + goodFactorization, // before gutsOfSolution + complicatedPivotIn, // in modifyCoefficients + noCandidateInPrimal, // tentative end + looksEndInPrimal, // About to declare victory (or defeat) + endInPrimal, // Victory (or defeat) + beforeStatusOfProblemInPrimal, + startOfStatusOfProblemInPrimal, + complicatedPivotOut, // in modifyCoefficients + noCandidateInDual, // tentative end + looksEndInDual, // About to declare victory (or defeat) + endInDual, // Victory (or defeat) + beforeStatusOfProblemInDual, + startOfStatusOfProblemInDual, + startOfIterationInDual, + updateDualsInDual, + endOfCreateRim, + slightlyInfeasible, + modifyMatrixInMiniPresolve, + moreMiniPresolve, + modifyMatrixInMiniPostsolve, + startOfCrossover, // in Idiot + noTheta // At end (because no pivot) + }; + /**@name Virtual method that the derived classes should provide. + The base class instance does nothing and as event() is only useful method + it would not be very useful NOT providing one! + */ + //@{ + /** This can do whatever it likes. If return code -1 then carries on + if 0 sets ClpModel::status() to 5 (stopped by event) and will return to user. + At present if <-1 carries on and if >0 acts as if 0 - this may change. + For ClpSolve 2 -> too big return status of -2 and -> too small 3 + */ + virtual int event(Event whichEvent); + /** This can do whatever it likes. Return code -1 means no action. + This passes in something + */ + virtual int eventWithInfo(Event whichEvent, void * info) ; + //@} + + + /**@name Constructors, destructor */ + + //@{ + /** Default constructor. */ + ClpEventHandler(ClpSimplex * model = NULL); + /** Destructor */ + virtual ~ClpEventHandler(); + // Copy + ClpEventHandler(const ClpEventHandler&); + // Assignment + ClpEventHandler& operator=(const ClpEventHandler&); + /// Clone + virtual ClpEventHandler * clone() const; + + //@} + + /**@name Sets/gets */ + + //@{ + /** set model. */ + void setSimplex(ClpSimplex * model); + /// Get model + inline ClpSimplex * simplex() const { + return model_; + } + //@} + + +protected: + /**@name Data members + The data members are protected to allow access for derived classes. */ + //@{ + /// Pointer to simplex + ClpSimplex * model_; + //@} +}; +/** Base class for Clp disaster handling + +This is here to allow for disaster handling. By disaster I mean that Clp +would otherwise give up + +*/ + +class ClpDisasterHandler { + +public: + /**@name Virtual methods that the derived classe should provide. + */ + //@{ + /// Into simplex + virtual void intoSimplex() = 0; + /// Checks if disaster + virtual bool check() const = 0; + /// saves information for next attempt + virtual void saveInfo() = 0; + /// Type of disaster 0 can fix, 1 abort + virtual int typeOfDisaster(); + //@} + + + /**@name Constructors, destructor */ + + //@{ + /** Default constructor. */ + ClpDisasterHandler(ClpSimplex * model = NULL); + /** Destructor */ + virtual ~ClpDisasterHandler(); + // Copy + ClpDisasterHandler(const ClpDisasterHandler&); + // Assignment + ClpDisasterHandler& operator=(const ClpDisasterHandler&); + /// Clone + virtual ClpDisasterHandler * clone() const = 0; + + //@} + + /**@name Sets/gets */ + + //@{ + /** set model. */ + void setSimplex(ClpSimplex * model); + /// Get model + inline ClpSimplex * simplex() const { + return model_; + } + //@} + + +protected: + /**@name Data members + The data members are protected to allow access for derived classes. */ + //@{ + /// Pointer to simplex + ClpSimplex * model_; + //@} +}; +#endif |