source: trunk/Clp/src/ClpSolve.hpp @ 2259

Last change on this file since 2259 was 2259, checked in by forrest, 3 years ago

for avx stuff

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 14.1 KB
Line 
1/* $Id: ClpSolve.hpp 2259 2017-03-27 08:37:20Z forrest $ */
2// Copyright (C) 2003, 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   Authors
7
8   John Forrest
9
10 */
11#ifndef ClpSolve_H
12#define ClpSolve_H
13
14/**
15    This is a very simple class to guide algorithms.  It is used to tidy up
16    passing parameters to initialSolve and maybe for output from that
17
18*/
19
20class ClpSolve  {
21
22public:
23
24     /** enums for solve function */
25     enum SolveType {
26          useDual = 0,
27          usePrimal,
28          usePrimalorSprint,
29          useBarrier,
30          useBarrierNoCross,
31          automatic,
32          tryDantzigWolfe,
33          tryBenders,
34          notImplemented
35     };
36     enum PresolveType {
37          presolveOn = 0,
38          presolveOff,
39          presolveNumber,
40          presolveNumberCost
41     };
42
43     /**@name Constructors and destructor and copy */
44     //@{
45     /// Default constructor
46     ClpSolve (  );
47     /// Constructor when you really know what you are doing
48     ClpSolve ( SolveType method, PresolveType presolveType,
49                int numberPasses, int options[6],
50                int extraInfo[6], int independentOptions[3]);
51     /// Generates code for above constructor
52     void generateCpp(FILE * fp);
53     /// Copy constructor.
54     ClpSolve(const ClpSolve &);
55     /// Assignment operator. This copies the data
56     ClpSolve & operator=(const ClpSolve & rhs);
57     /// Destructor
58     ~ClpSolve (  );
59     //@}
60
61     /**@name Functions most useful to user */
62     //@{
63     /** Special options - bits
64     0      4 - use crash (default allslack in dual, idiot in primal)
65         8 - all slack basis in primal
66     2      16 - switch off interrupt handling
67     3      32 - do not try and make plus minus one matrix
68         64 - do not use sprint even if problem looks good
69      */
70     /** which translation is:
71         which:
72         0 - startup in Dual  (nothing if basis exists).:
73                      0 - no basis
74           1 - crash
75           2 - use initiative about idiot! but no crash
76         1 - startup in Primal (nothing if basis exists):
77                      0 - use initiative
78           1 - use crash
79           2 - use idiot and look at further info
80           3 - use sprint and look at further info
81           4 - use all slack
82           5 - use initiative but no idiot
83           6 - use initiative but no sprint
84           7 - use initiative but no crash
85                      8 - do allslack or idiot
86                      9 - do allslack or sprint
87           10 - slp before
88           11 - no nothing and primal(0)
89         2 - interrupt handling - 0 yes, 1 no (for threadsafe)
90         3 - whether to make +- 1matrix - 0 yes, 1 no
91         4 - for barrier
92                      0 - dense cholesky
93           1 - Wssmp allowing some long columns
94           2 - Wssmp not allowing long columns
95           3 - Wssmp using KKT
96                      4 - Using Florida ordering
97           8 - bit set to do scaling
98           16 - set to be aggressive with gamma/delta?
99                      32 - Use KKT
100         5 - for presolve
101                      1 - switch off dual stuff
102         6 - extra switches
103                     
104     */
105     void setSpecialOption(int which, int value, int extraInfo = -1);
106     int getSpecialOption(int which) const;
107
108     /// Solve types
109     void setSolveType(SolveType method, int extraInfo = -1);
110     SolveType getSolveType();
111
112     // Presolve types
113     void setPresolveType(PresolveType amount, int extraInfo = -1);
114     PresolveType getPresolveType();
115     int getPresolvePasses() const;
116     /// Extra info for idiot (or sprint)
117     int getExtraInfo(int which) const;
118     /** Say to return at once if infeasible,
119         default is to solve */
120     void setInfeasibleReturn(bool trueFalse);
121     inline bool infeasibleReturn() const {
122          return independentOptions_[0] != 0;
123     }
124     /// Whether we want to do dual part of presolve
125     inline bool doDual() const {
126          return (independentOptions_[1] & 1) == 0;
127     }
128     inline void setDoDual(bool doDual_) {
129          if (doDual_) independentOptions_[1]  &= ~1;
130          else independentOptions_[1] |= 1;
131     }
132     /// Whether we want to do singleton part of presolve
133     inline bool doSingleton() const {
134          return (independentOptions_[1] & 2) == 0;
135     }
136     inline void setDoSingleton(bool doSingleton_) {
137          if (doSingleton_) independentOptions_[1]  &= ~2;
138          else independentOptions_[1] |= 2;
139     }
140     /// Whether we want to do doubleton part of presolve
141     inline bool doDoubleton() const {
142          return (independentOptions_[1] & 4) == 0;
143     }
144     inline void setDoDoubleton(bool doDoubleton_) {
145          if (doDoubleton_) independentOptions_[1]  &= ~4;
146          else independentOptions_[1] |= 4;
147     }
148     /// Whether we want to do tripleton part of presolve
149     inline bool doTripleton() const {
150          return (independentOptions_[1] & 8) == 0;
151     }
152     inline void setDoTripleton(bool doTripleton_) {
153          if (doTripleton_) independentOptions_[1]  &= ~8;
154          else independentOptions_[1] |= 8;
155     }
156     /// Whether we want to do tighten part of presolve
157     inline bool doTighten() const {
158          return (independentOptions_[1] & 16) == 0;
159     }
160     inline void setDoTighten(bool doTighten_) {
161          if (doTighten_) independentOptions_[1]  &= ~16;
162          else independentOptions_[1] |= 16;
163     }
164     /// Whether we want to do forcing part of presolve
165     inline bool doForcing() const {
166          return (independentOptions_[1] & 32) == 0;
167     }
168     inline void setDoForcing(bool doForcing_) {
169          if (doForcing_) independentOptions_[1]  &= ~32;
170          else independentOptions_[1] |= 32;
171     }
172     /// Whether we want to do impliedfree part of presolve
173     inline bool doImpliedFree() const {
174          return (independentOptions_[1] & 64) == 0;
175     }
176     inline void setDoImpliedFree(bool doImpliedfree) {
177          if (doImpliedfree) independentOptions_[1]  &= ~64;
178          else independentOptions_[1] |= 64;
179     }
180     /// Whether we want to do dupcol part of presolve
181     inline bool doDupcol() const {
182          return (independentOptions_[1] & 128) == 0;
183     }
184     inline void setDoDupcol(bool doDupcol_) {
185          if (doDupcol_) independentOptions_[1]  &= ~128;
186          else independentOptions_[1] |= 128;
187     }
188     /// Whether we want to do duprow part of presolve
189     inline bool doDuprow() const {
190          return (independentOptions_[1] & 256) == 0;
191     }
192     inline void setDoDuprow(bool doDuprow_) {
193          if (doDuprow_) independentOptions_[1]  &= ~256;
194          else independentOptions_[1] |= 256;
195     }
196     /// Whether we want to do singleton column part of presolve
197     inline bool doSingletonColumn() const {
198          return (independentOptions_[1] & 512) == 0;
199     }
200     inline void setDoSingletonColumn(bool doSingleton_) {
201          if (doSingleton_) independentOptions_[1]  &= ~512;
202          else independentOptions_[1] |= 512;
203     }
204     /// Whether we want to kill small substitutions
205     inline bool doKillSmall() const {
206          return (independentOptions_[1] & 8192) == 0;
207     }
208     inline void setDoKillSmall(bool doKill) {
209          if (doKill) independentOptions_[1]  &= ~8192;
210          else independentOptions_[1] |= 8192;
211     }
212     /// Set whole group
213     inline int presolveActions() const {
214          return independentOptions_[1] & 0xffffff;
215     }
216     inline void setPresolveActions(int action) {
217          independentOptions_[1]  = (independentOptions_[1] & 0xff000000) | (action & 0xffffff);
218     }
219     /// Largest column for substitution (normally 3)
220     inline int substitution() const {
221          return independentOptions_[2];
222     }
223     inline void setSubstitution(int value) {
224          independentOptions_[2] = value;
225     }
226     inline void setIndependentOption(int type,int value) {
227          independentOptions_[type]  = value;
228     }
229     inline int independentOption(int type) const {
230          return independentOptions_[type];
231     }
232     //@}
233
234////////////////// data //////////////////
235private:
236
237     /**@name data.
238     */
239     //@{
240     /// Solve type
241     SolveType method_;
242     /// Presolve type
243     PresolveType presolveType_;
244     /// Amount of presolve
245     int numberPasses_;
246     /// Options - last is switch for OsiClp
247     int options_[7];
248     /// Extra information
249     int extraInfo_[7];
250     /** Extra algorithm dependent options
251         0 - if set return from clpsolve if infeasible
252         1 - To be copied over to presolve options
253         2 - max substitution level
254         If Dantzig Wolfe/benders 0 is number blocks, 2 is #passes (notional)
255     */
256     int independentOptions_[3];
257     //@}
258};
259
260/// For saving extra information to see if looping.
261class ClpSimplexProgress {
262
263public:
264
265
266     /**@name Constructors and destructor and copy */
267     //@{
268     /// Default constructor
269     ClpSimplexProgress (  );
270
271     /// Constructor from model
272     ClpSimplexProgress ( ClpSimplex * model );
273
274     /// Copy constructor.
275     ClpSimplexProgress(const ClpSimplexProgress &);
276
277     /// Assignment operator. This copies the data
278     ClpSimplexProgress & operator=(const ClpSimplexProgress & rhs);
279     /// Destructor
280     ~ClpSimplexProgress (  );
281     /// Resets as much as possible
282     void reset();
283     /// Fill from model
284     void fillFromModel ( ClpSimplex * model );
285
286     //@}
287
288     /**@name Check progress */
289     //@{
290     /** Returns -1 if okay, -n+1 (n number of times bad) if bad but action taken,
291         >=0 if give up and use as problem status
292     */
293     int looping (  );
294     /// Start check at beginning of whileIterating
295     void startCheck();
296     /// Returns cycle length in whileIterating
297     int cycle(int in, int out, int wayIn, int wayOut);
298
299     /// Returns previous objective (if -1) - current if (0)
300     double lastObjective(int back = 1) const;
301     /// Set real primal infeasibility and move back
302     void setInfeasibility(double value);
303     /// Returns real primal infeasibility (if -1) - current if (0)
304     double lastInfeasibility(int back = 1) const;
305     /// Returns number of primal infeasibilities (if -1) - current if (0)
306     int numberInfeasibilities(int back = 1) const;
307     /// Modify objective e.g. if dual infeasible in dual
308     void modifyObjective(double value);
309     /// Returns previous iteration number (if -1) - current if (0)
310     int lastIterationNumber(int back = 1) const;
311     /// clears all iteration numbers (to switch off panic)
312     void clearIterationNumbers();
313     /// Odd state
314     inline void newOddState() {
315          oddState_ = - oddState_ - 1;
316     }
317     inline void endOddState() {
318          oddState_ = abs(oddState_);
319     }
320     inline void clearOddState() {
321          oddState_ = 0;
322     }
323     inline int oddState() const {
324          return oddState_;
325     }
326     /// number of bad times
327     inline int badTimes() const {
328          return numberBadTimes_;
329     }
330     inline void clearBadTimes() {
331          numberBadTimes_ = 0;
332     }
333     /// number of really bad times
334     inline int reallyBadTimes() const {
335          return numberReallyBadTimes_;
336     }
337     inline void incrementReallyBadTimes() {
338          numberReallyBadTimes_++;
339     }
340     /// number of times flagged
341     inline int timesFlagged() const {
342          return numberTimesFlagged_;
343     }
344     inline void clearTimesFlagged() {
345          numberTimesFlagged_ = 0;
346     }
347     inline void incrementTimesFlagged() {
348          numberTimesFlagged_++;
349     }
350
351     //@}
352     /**@name Data  */
353#define CLP_PROGRESS 5
354     //#define CLP_PROGRESS_WEIGHT 10
355     //@{
356     /// Objective values
357     double objective_[CLP_PROGRESS];
358     /// Sum of infeasibilities for algorithm
359     double infeasibility_[CLP_PROGRESS];
360     /// Sum of real primal infeasibilities for primal
361     double realInfeasibility_[CLP_PROGRESS];
362#ifdef CLP_PROGRESS_WEIGHT
363     /// Objective values for weights
364     double objectiveWeight_[CLP_PROGRESS_WEIGHT];
365     /// Sum of infeasibilities for algorithm for weights
366     double infeasibilityWeight_[CLP_PROGRESS_WEIGHT];
367     /// Sum of real primal infeasibilities for primal for weights
368     double realInfeasibilityWeight_[CLP_PROGRESS_WEIGHT];
369     /// Drop  for weights
370     double drop_;
371     /// Best? for weights
372     double best_;
373#endif
374     /// Initial weight for weights
375     double initialWeight_;
376#define CLP_CYCLE 12
377     /// For cycle checking
378     //double obj_[CLP_CYCLE];
379     int in_[CLP_CYCLE];
380     int out_[CLP_CYCLE];
381     char way_[CLP_CYCLE];
382     /// Pointer back to model so we can get information
383     ClpSimplex * model_;
384     /// Number of infeasibilities
385     int numberInfeasibilities_[CLP_PROGRESS];
386     /// Iteration number at which occurred
387     int iterationNumber_[CLP_PROGRESS];
388#ifdef CLP_PROGRESS_WEIGHT
389     /// Number of infeasibilities for weights
390     int numberInfeasibilitiesWeight_[CLP_PROGRESS_WEIGHT];
391     /// Iteration number at which occurred for weights
392     int iterationNumberWeight_[CLP_PROGRESS_WEIGHT];
393#endif
394     /// Number of times checked (so won't stop too early)
395     int numberTimes_;
396     /// Number of times it looked like loop
397     int numberBadTimes_;
398     /// Number really bad times
399     int numberReallyBadTimes_;
400     /// Number of times no iterations as flagged
401     int numberTimesFlagged_;
402     /// If things are in an odd state
403     int oddState_;
404     //@}
405};
406
407#include "ClpConfig.h"
408#if CLP_HAS_ABC
409#include "AbcCommon.hpp"
410/// For saving extra information to see if looping.
411class AbcSimplexProgress : public ClpSimplexProgress {
412
413public:
414
415
416     /**@name Constructors and destructor and copy */
417     //@{
418     /// Default constructor
419     AbcSimplexProgress (  );
420
421     /// Constructor from model
422     AbcSimplexProgress ( ClpSimplex * model );
423
424     /// Copy constructor.
425     AbcSimplexProgress(const AbcSimplexProgress &);
426
427     /// Assignment operator. This copies the data
428     AbcSimplexProgress & operator=(const AbcSimplexProgress & rhs);
429     /// Destructor
430     ~AbcSimplexProgress (  );
431
432     //@}
433
434     /**@name Check progress */
435     //@{
436     /** Returns -1 if okay, -n+1 (n number of times bad) if bad but action taken,
437         >=0 if give up and use as problem status
438     */
439     int looping (  );
440
441     //@}
442     /**@name Data  */
443     //@}
444};
445#endif
446#endif
Note: See TracBrowser for help on using the repository browser.