source: trunk/Clp/src/ClpEventHandler.hpp @ 2470

Last change on this file since 2470 was 2385, checked in by unxusr, 11 months ago

formatting

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 5.3 KB
Line 
1/* $Id: ClpEventHandler.hpp 2385 2019-01-06 19:43:06Z stefan $ */
2// Copyright (C) 2004, International Business Machines
3// Corporation and others.  All Rights Reserved.
4// This code is licensed under the terms of the Eclipse Public License (EPL).
5
6#ifndef ClpEventHandler_H
7#define ClpEventHandler_H
8
9#include "ClpSimplex.hpp"
10/** Base class for Clp event handling
11
12This is just here to allow for event handling.  By event I mean a Clp event
13e.g. end of values pass.
14
15One use would be to let a user handle a system event e.g. Control-C.  This could be done
16by deriving a class MyEventHandler which knows about such events.  If one occurs
17MyEventHandler::event() could clear event status and return 3 (stopped).
18
19Clp would then return to user code.
20
21As it is called every iteration this should be fine grained enough.
22
23User can derive and construct from CbcModel  - not pretty
24
25*/
26
27class ClpEventHandler {
28
29public:
30  /** enums for what sort of event.
31
32         These will also be returned in ClpModel::secondaryStatus() as int
33     */
34  enum Event {
35    endOfIteration = 100, // used to set secondary status
36    endOfFactorization, // after gutsOfSolution etc
37    endOfValuesPass,
38    node, // for Cbc
39    treeStatus, // for Cbc
40    solution, // for Cbc
41    theta, // hit in parametrics
42    pivotRow, // used to choose pivot row
43    presolveStart, // ClpSolve presolve start
44    presolveSize, // sees if ClpSolve presolve too big or too small
45    presolveInfeasible, // ClpSolve presolve infeasible
46    presolveBeforeSolve, // ClpSolve presolve before solve
47    presolveAfterFirstSolve, // ClpSolve presolve after solve
48    presolveAfterSolve, // ClpSolve presolve after solve
49    presolveEnd, // ClpSolve presolve end
50    goodFactorization, // before gutsOfSolution
51    complicatedPivotIn, // in modifyCoefficients
52    noCandidateInPrimal, // tentative end
53    looksEndInPrimal, // About to declare victory (or defeat)
54    endInPrimal, // Victory (or defeat)
55    beforeStatusOfProblemInPrimal,
56    startOfStatusOfProblemInPrimal,
57    complicatedPivotOut, // in modifyCoefficients
58    noCandidateInDual, // tentative end
59    looksEndInDual, // About to declare victory (or defeat)
60    endInDual, // Victory (or defeat)
61    beforeStatusOfProblemInDual,
62    startOfStatusOfProblemInDual,
63    startOfIterationInDual,
64    updateDualsInDual,
65    beforeDeleteRim,
66    endOfCreateRim,
67    slightlyInfeasible,
68    modifyMatrixInMiniPresolve,
69    moreMiniPresolve,
70    modifyMatrixInMiniPostsolve,
71    beforeChooseIncoming,
72    afterChooseIncoming,
73    beforeCreateNonLinear,
74    afterCreateNonLinear,
75    startOfCrossover, // in Idiot
76    noTheta // At end (because no pivot)
77  };
78  /**@name Virtual method that the derived classes should provide.
79      The base class instance does nothing and as event() is only useful method
80      it would not be very useful NOT providing one!
81     */
82  //@{
83  /** This can do whatever it likes.  If return code -1 then carries on
84         if 0 sets ClpModel::status() to 5 (stopped by event) and will return to user.
85         At present if <-1 carries on and if >0 acts as if 0 - this may change.
86         For ClpSolve 2 -> too big return status of -2 and -> too small 3
87     */
88  virtual int event(Event whichEvent);
89  /** This can do whatever it likes.  Return code -1 means no action.
90         This passes in something
91     */
92  virtual int eventWithInfo(Event whichEvent, void *info);
93  //@}
94
95  /**@name Constructors, destructor */
96
97  //@{
98  /** Default constructor. */
99  ClpEventHandler(ClpSimplex *model = NULL);
100  /** Destructor */
101  virtual ~ClpEventHandler();
102  // Copy
103  ClpEventHandler(const ClpEventHandler &);
104  // Assignment
105  ClpEventHandler &operator=(const ClpEventHandler &);
106  /// Clone
107  virtual ClpEventHandler *clone() const;
108
109  //@}
110
111  /**@name Sets/gets */
112
113  //@{
114  /** set model. */
115  void setSimplex(ClpSimplex *model);
116  /// Get model
117  inline ClpSimplex *simplex() const
118  {
119    return model_;
120  }
121  //@}
122
123protected:
124  /**@name Data members
125        The data members are protected to allow access for derived classes. */
126  //@{
127  /// Pointer to simplex
128  ClpSimplex *model_;
129  //@}
130};
131/** Base class for Clp disaster handling
132
133This is here to allow for disaster handling.  By disaster I mean that Clp
134would otherwise give up
135
136*/
137
138class ClpDisasterHandler {
139
140public:
141  /**@name Virtual methods that the derived classe should provide.
142     */
143  //@{
144  /// Into simplex
145  virtual void intoSimplex() = 0;
146  /// Checks if disaster
147  virtual bool check() const = 0;
148  /// saves information for next attempt
149  virtual void saveInfo() = 0;
150  /// Type of disaster 0 can fix, 1 abort
151  virtual int typeOfDisaster();
152  //@}
153
154  /**@name Constructors, destructor */
155
156  //@{
157  /** Default constructor. */
158  ClpDisasterHandler(ClpSimplex *model = NULL);
159  /** Destructor */
160  virtual ~ClpDisasterHandler();
161  // Copy
162  ClpDisasterHandler(const ClpDisasterHandler &);
163  // Assignment
164  ClpDisasterHandler &operator=(const ClpDisasterHandler &);
165  /// Clone
166  virtual ClpDisasterHandler *clone() const = 0;
167
168  //@}
169
170  /**@name Sets/gets */
171
172  //@{
173  /** set model. */
174  void setSimplex(ClpSimplex *model);
175  /// Get model
176  inline ClpSimplex *simplex() const
177  {
178    return model_;
179  }
180  //@}
181
182protected:
183  /**@name Data members
184        The data members are protected to allow access for derived classes. */
185  //@{
186  /// Pointer to simplex
187  ClpSimplex *model_;
188  //@}
189};
190#endif
191
192/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
193*/
Note: See TracBrowser for help on using the repository browser.