Go to the documentation of this file.
10 class CoinPresolveAction;
11 #include "CoinPresolveMatrix.hpp"
42 double feasibilityTolerance = 0.0,
43 bool keepIntegers =
true,
45 bool dropNames =
false,
46 bool doRowObjective =
false,
47 const char *prohibitedRows = NULL,
48 const char *prohibitedColumns = NULL);
54 double feasibilityTolerance = 0.0,
55 bool keepIntegers =
true,
57 bool dropNames =
false,
58 bool doRowObjective =
false);
78 nonLinearValue_ = value;
82 return nonLinearValue_;
87 return (presolveActions_ & 1) == 0;
92 presolveActions_ &= ~1;
94 presolveActions_ |= 1;
99 return (presolveActions_ & 2) == 0;
104 presolveActions_ &= ~2;
106 presolveActions_ |= 2;
111 return (presolveActions_ & 4) == 0;
116 presolveActions_ &= ~4;
118 presolveActions_ |= 4;
123 return (presolveActions_ & 8) == 0;
128 presolveActions_ &= ~8;
130 presolveActions_ |= 8;
135 return (presolveActions_ & 16) == 0;
140 presolveActions_ &= ~16;
142 presolveActions_ |= 16;
147 return (presolveActions_ & 32) == 0;
152 presolveActions_ &= ~32;
154 presolveActions_ |= 32;
159 return (presolveActions_ & 64) == 0;
164 presolveActions_ &= ~64;
166 presolveActions_ |= 64;
171 return (presolveActions_ & 128) == 0;
176 presolveActions_ &= ~128;
178 presolveActions_ |= 128;
183 return (presolveActions_ & 256) == 0;
188 presolveActions_ &= ~256;
190 presolveActions_ |= 256;
195 return (presolveActions_ & 32768) != 0;
200 presolveActions_ |= 32768;
202 presolveActions_ &= ~32768;
207 return (presolveActions_ & 65536) != 0;
212 presolveActions_ |= 65536;
214 presolveActions_ &= ~65536;
219 return (presolveActions_ & 512) == 0;
224 presolveActions_ &= ~512;
226 presolveActions_ |= 512;
231 return (presolveActions_ & 1024) == 0;
236 presolveActions_ &= ~1024;
238 presolveActions_ |= 1024;
243 return (presolveActions_ & 2048) != 0;
248 presolveActions_ &= ~2048;
250 presolveActions_ |= 2048;
255 return (presolveActions_ & 4096) != 0;
260 presolveActions_ &= ~4096;
262 presolveActions_ |= 4096;
268 return (presolveActions_ & (8192 | 16384)) >> 13;
272 presolveActions_ &= ~(8192 | 16384);
273 presolveActions_ |= value << 13;
278 return presolveActions_ & 0xffffff;
282 presolveActions_ = (presolveActions_ & 0xff000000) | (action & 0xffffff);
287 substitution_ = value;
292 presolveActions_ |= 0x80000000;
305 virtual void postsolve(
bool updateStatus =
true);
322 double nonLinearValue_;
324 int *originalColumn_;
328 double *rowObjective_;
330 const CoinPresolveAction *paction_;
339 CoinBigIndex nelems_;
345 std::string saveFile_;
352 int presolveActions_;
358 virtual const CoinPresolveAction *
presolve(CoinPresolveMatrix *prob);
365 virtual void postsolve(CoinPostsolveMatrix &prob);
368 double feasibilityTolerance,
373 const char *prohibitedRows = NULL,
374 const char *prohibitedColumns = NULL);
This solves LPs using the simplex method.
bool doIntersection() const
Whether we want to allow duplicate intersections.
void setDoTripleton(bool doTripleton)
void destroyPresolve()
Gets rid of presolve actions (e.g.when infeasible)
ClpSimplex * presolvedModel(ClpSimplex &si, double feasibilityTolerance=0.0, bool keepIntegers=true, int numberPasses=5, bool dropNames=false, bool doRowObjective=false, const char *prohibitedRows=NULL, const char *prohibitedColumns=NULL)
bool doTighten() const
Whether we want to do tighten part of presolve.
void statistics()
Asks for statistics.
bool doTwoxTwo() const
Whether we want to do twoxtwo part of presolve.
void setNonLinearValue(double value)
"Magic" number.
void setDoDupcol(bool doDupcol)
void setDoDoubleton(bool doDoubleton)
void setDoSingleton(bool doSingleton)
ClpSimplex * originalModel() const
Return pointer to original model.
virtual ClpSimplex * gutsOfPresolvedModel(ClpSimplex *originalModel, double feasibilityTolerance, bool keepIntegers, int numberPasses, bool dropNames, bool doRowObjective, const char *prohibitedRows=NULL, const char *prohibitedColumns=NULL)
This is main part of Presolve.
bool doTransfer() const
Whether we want to do transfer part of presolve.
virtual ~ClpPresolve()
Virtual destructor.
void setDoTwoxtwo(bool doTwoxTwo)
bool doGubrow() const
Whether we want to do gubrow part of presolve.
void setDoTighten(bool doTighten)
void setDoIntersection(bool doIntersection)
bool doDupcol() const
Whether we want to do dupcol part of presolve.
int presolveStatus() const
Return presolve status (0,1,2)
int presolvedModelToFile(ClpSimplex &si, std::string fileName, double feasibilityTolerance=0.0, bool keepIntegers=true, int numberPasses=5, bool dropNames=false, bool doRowObjective=false)
This version saves data in a file.
bool doSingleton() const
Whether we want to do singleton part of presolve.
void setDoDuprow(bool doDuprow)
void setDoImpliedFree(bool doImpliedfree)
int zeroSmall() const
How much we want to zero small values from aggregation - ratio 0 - 1.0e-12, 1 1.0e-11,...
bool doForcing() const
Whether we want to do forcing part of presolve.
ClpPresolve()
Default constructor.
bool doDependency() const
Whether we want to do dependency part of presolve.
const int * originalRows() const
return pointer to original rows
void setSubstitution(int value)
Substitution level.
This is the Clp interface to CoinPresolve.
bool doSingletonColumn() const
Whether we want to do singleton column part of presolve.
ClpSimplex * model() const
Return pointer to presolved model, Up to user to destroy.
double nonLinearValue() const
void setPresolveActions(int action)
void setDoForcing(bool doForcing)
void setDoTransfer(bool doTransfer)
virtual void postsolve(bool updateStatus=true)
bool doDual() const
Whether we want to do dual part of presolve.
bool doDuprow() const
Whether we want to do duprow part of presolve.
bool doDoubleton() const
Whether we want to do doubleton part of presolve.
bool doTripleton() const
Whether we want to do tripleton part of presolve.
int presolveActions() const
Set whole group.
void setDoDependency(bool doDependency)
void setDoGubrow(bool doGubrow)
const int * originalColumns() const
return pointer to original columns
void setOriginalModel(ClpSimplex *model)
Set pointer to original model.
void setZeroSmall(int value)
void setDoDual(bool doDual)
void setDoSingletonColumn(bool doSingleton)
bool doImpliedFree() const
Whether we want to do impliedfree part of presolve.
virtual const CoinPresolveAction * presolve(CoinPresolveMatrix *prob)
If you want to apply the individual presolve routines differently, or perhaps add your own to the mix...