Cgl 0.60.2

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
CglPreProcess.hpp
Go to the documentation of this file.
1 // Copyright (C) 2005, International Business Machines
2 // Corporation and others. All Rights Reserved.
3 // This code is licensed under the terms of the Eclipse Public License (EPL).
4
5 #ifndef CglPreProcess_H
6 #define CglPreProcess_H
7
8 #include <string>
9 #include <vector>
10
11 #include "CoinMessageHandler.hpp"
12 #include "OsiSolverInterface.hpp"
13 #include "CglStored.hpp"
14 #include "OsiPresolve.hpp"
15 #include "CglCutGenerator.hpp"
16
17 //#############################################################################
18
37 class CglPreProcess {
38
39 public:
41
42
51 OsiSolverInterface *preProcess(OsiSolverInterface &model,
52 bool makeEquality = false, int numberPasses = 5);
64 OsiSolverInterface *preProcessNonDefault(OsiSolverInterface &model,
65 int makeEquality = 0, int numberPasses = 5,
66 int tuning = 0);
69 void postProcess(OsiSolverInterface &model, int deleteStuff = 2);
77 int tightenPrimalBounds(OsiSolverInterface &model, double factor = 0.0);
84 OsiSolverInterface *someFixed(OsiSolverInterface &model,
85 double fractionToKeep = 0.25,
86 bool fixContinuousAsWell = false,
87 char *keep = NULL) const;
92 OsiSolverInterface *cliqueIt(OsiSolverInterface &model,
93 double cliquesNeeded = 0.0) const;
95 int reducedCostFix(OsiSolverInterface &model);
97
98 //---------------------------------------------------------------------------
99
114 void setCutoff(double value);
115
117 double getCutoff() const;
119 inline OsiSolverInterface *originalModel() const
120 {
121 return originalModel_;
122 }
124 inline void setOriginalModel(OsiSolverInterface *originalModel)
125 {
126 originalModel_ = originalModel;
127 }
129 inline OsiSolverInterface *startModel() const
130 {
131 return startModel_;
132 }
134 inline int numberSolvers() const
135 {
136 return numberSolvers_;
137 }
139 inline OsiSolverInterface *modelAtPass(int iPass) const
140 {
141 if (iPass >= 0 && iPass < numberSolvers_)
142 return model_[iPass];
143 else
144 return NULL;
145 }
147 inline OsiSolverInterface *modifiedModel(int iPass) const
148 {
149 if (iPass >= 0 && iPass < numberSolvers_)
150 return modifiedModel_[iPass];
151 else
152 return NULL;
153 }
155 inline OsiPresolve *presolve(int iPass) const
156 {
157 if (iPass >= 0 && iPass < numberSolvers_)
158 return presolve_[iPass];
159 else
160 return NULL;
161 }
163 inline void setPresolve(int iPass, OsiPresolve *presolve)
164 {
165 if (iPass >= 0 && iPass < numberSolvers_)
166 presolve_[iPass] = presolve;
167 }
170 const int *originalColumns();
173 const int *originalRows();
175 inline int numberSOS() const
176 {
177 return numberSOS_;
178 }
180 inline const int *typeSOS() const
181 {
182 return typeSOS_;
183 }
185 inline const int *startSOS() const
186 {
187 return startSOS_;
188 }
190 inline const int *whichSOS() const
191 {
192 return whichSOS_;
193 }
195 inline const double *weightSOS() const
196 {
197 return weightSOS_;
198 }
200 void passInProhibited(const char *prohibited, int numberColumns);
202 inline const char *prohibited()
203 {
204 return prohibited_;
205 }
207 inline int numberIterationsPre() const
208 {
209 return numberIterationsPre_;
210 }
212 inline int numberIterationsPost() const
213 {
214 return numberIterationsPost_;
215 }
222 void passInRowTypes(const char *rowTypes, int numberRows);
229 inline const char *rowTypes()
230 {
231 return rowType_;
232 }
234 inline const CglStored &cuts() const
235 {
236 return cuts_;
237 }
239 inline const CglStored *cutsPointer() const
240 {
241 return &cuts_;
242 }
244 void update(const OsiPresolve *pinfo, const OsiSolverInterface *solver);
246 inline int options() const
247 {
248 return options_;
249 }
251 inline void setOptions(int value)
252 {
253 options_ = value;
254 }
256
258
259 inline int numberCutGenerators() const
261 {
262 return numberCutGenerators_;
263 }
265 inline CglCutGenerator **cutGenerators() const
266 {
267 return generator_;
268 }
270 inline CglCutGenerator *cutGenerator(int i) const
271 {
272 return generator_[i];
273 }
276 void addCutGenerator(CglCutGenerator *generator);
278
288 void setApplicationData(void *appData);
289
291 void *getApplicationData() const;
293
294 //---------------------------------------------------------------------------
295
298 void passInMessageHandler(CoinMessageHandler *handler);
301 void newLanguage(CoinMessages::Language language);
302 inline void setLanguage(CoinMessages::Language language)
303 {
304 newLanguage(language);
305 }
307 inline CoinMessageHandler *messageHandler() const
308 {
309 return handler_;
310 }
312 inline CoinMessages messages()
313 {
314 return messages_;
315 }
317 inline CoinMessages *messagesPointer()
318 {
319 return &messages_;
320 }
322 //---------------------------------------------------------------------------
323
325
326 CglPreProcess();
328
330 CglPreProcess(const CglPreProcess &rhs);
331
333 CglPreProcess &operator=(const CglPreProcess &rhs);
334
336 ~CglPreProcess();
337
339 void gutsOfDestructor();
340
342 void setTimeLimit(const double timeLimit, const bool useElapsedTime);
343
345 void setKeepColumnNames(const bool keep);
346
348 private:
350
351
355 OsiSolverInterface *modified(OsiSolverInterface *model,
356 bool constraints,
357 int &numberChanges,
358 int iBigPass,
359 int numberPasses);
361 void createOriginalIndices();
363 void makeInteger();
365
366 //---------------------------------------------------------------------------
367
368 private:
370
371
373 OsiSolverInterface *originalModel_;
375 OsiSolverInterface *startModel_;
377 int numberSolvers_;
379 OsiSolverInterface **model_;
381 OsiSolverInterface **modifiedModel_;
383 OsiPresolve **presolve_;
384
386 CoinMessageHandler *handler_;
387
393 bool defaultHandler_;
394
396 CoinMessages messages_;
397
399 void *appData_;
401 int *originalColumn_;
403 int *originalRow_;
405 int numberCutGenerators_;
407 CglCutGenerator **generator_;
409 int numberSOS_;
411 int *typeSOS_;
413 int *startSOS_;
415 int *whichSOS_;
417 double *weightSOS_;
419 int numberProhibited_;
421 int numberIterationsPre_;
423 int numberIterationsPost_;
425 char *prohibited_;
427 int numberRowType_;
436 int options_;
443 char *rowType_;
445 CglStored cuts_;
446
448 bool useElapsedTime_;
449
451 double timeLimit_;
452
454 bool keepColumnNames_;
455
457 double getCurrentCPUTime() const;
458
460 };
461
463 class CglBK {
464
465 public:
467
468 void bronKerbosch();
471 OsiSolverInterface *newSolver(const OsiSolverInterface &model);
473
474 //---------------------------------------------------------------------------
475
485
486
487 //---------------------------------------------------------------------------
488
490
491 CglBK();
493
495 CglBK(const OsiSolverInterface &model, const char *rowType,
496 int numberElements);
497
499 CglBK(const CglBK &rhs);
500
502 CglBK &operator=(const CglBK &rhs);
503
505 ~CglBK();
506
508
509 //---------------------------------------------------------------------------
510
511 private:
513
514 int *candidates_;
517 char *mark_;
519 CoinBigIndex *start_;
521 int *otherColumn_;
523 int *originalRow_;
525 int *dominated_;
527 CoinPackedMatrix *cliqueMatrix_;
529 const char *rowType_;
531 int numberColumns_;
533 int numberRows_;
535 int numberPossible_;
537 int numberCandidates_;
539 int firstNot_;
541 int numberIn_;
543 int left_;
544 int lastColumn_;
546 };
550 // for hashing
551 typedef struct {
552 int index, next;
553 } CglHashLink;
554 class OsiRowCut;
555 class CglUniqueRowCuts {
556 public:
557 CglUniqueRowCuts(int initialMaxSize = 0, int hashMultiplier = 4);
558 ~CglUniqueRowCuts();
559 CglUniqueRowCuts(const CglUniqueRowCuts &rhs);
560 CglUniqueRowCuts &operator=(const CglUniqueRowCuts &rhs);
561 inline OsiRowCut *cut(int sequence) const
562 {
563 return rowCut_[sequence];
564 }
565 inline int numberCuts() const
566 {
567 return numberCuts_;
568 }
569 inline int sizeRowCuts() const
570 {
571 return numberCuts_;
572 }
573 inline OsiRowCut *rowCutPtr(int sequence)
574 {
575 return rowCut_[sequence];
576 }
577 void eraseRowCut(int sequence);
578 // insert cut
579 inline void insert(const OsiRowCut &cut)
580 {
581 insertIfNotDuplicate(cut);
582 }
583 // Return 0 if added, 1 if not
584 int insertIfNotDuplicate(const OsiRowCut &cut);
585 // Add in cuts as normal cuts (and delete)
586 void addCuts(OsiCuts &cs);
587
588 private:
589 OsiRowCut **rowCut_;
591 CglHashLink *hash_;
592 int size_;
593 int hashMultiplier_;
594 int numberCuts_;
595 int lastHash_;
596 };
597 #endif
598
599 /* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
600 */
CglPreProcess::rowType_
char * rowType_
Row types (may be NULL) Carried around and corresponds to existing rows -1 added by preprocess e...
Definition: CglPreProcess.hpp:443
CglPreProcess::weightSOS
const double * weightSOS() const
Weights for each SOS column.
Definition: CglPreProcess.hpp:195
CglPreProcess::gutsOfDestructor
void gutsOfDestructor()
Clears out as much as possible.
CglUniqueRowCuts::numberCuts
int numberCuts() const
Definition: CglPreProcess.hpp:565
CglPreProcess::tightenPrimalBounds
int tightenPrimalBounds(OsiSolverInterface &model, double factor=0.0)
Tightens primal bounds to make dual and branch and cutfaster.
CglBK
For Bron-Kerbosch.
Definition: CglPreProcess.hpp:463
CglPreProcess::numberRowType_
int numberRowType_
Number of rows in original row types.
Definition: CglPreProcess.hpp:427
CglPreProcess::newLanguage
void newLanguage(CoinMessages::Language language)
Set language.
CglPreProcess::model_
OsiSolverInterface ** model_
Copies of solver at various stages after presolve.
Definition: CglPreProcess.hpp:379
CglPreProcess::numberSolvers
int numberSolvers() const
Number of solvers.
Definition: CglPreProcess.hpp:134
CglUniqueRowCuts::CglUniqueRowCuts
CglUniqueRowCuts(int initialMaxSize=0, int hashMultiplier=4)
CglPreProcess::handler_
CoinMessageHandler * handler_
Message handler.
Definition: CglPreProcess.hpp:386
CglPreProcess::timeLimit_
double timeLimit_
time limit (default COIN_DBL_MAX)
Definition: CglPreProcess.hpp:451
CglPreProcess::addCutGenerator
void addCutGenerator(CglCutGenerator *generator)
Add one generator - up to user to delete generators.
CglUniqueRowCuts::cut
OsiRowCut * cut(int sequence) const
Definition: CglPreProcess.hpp:561
CglPreProcess::numberIterationsPost_
int numberIterationsPost_
Number of iterations done in PostProcessing.
Definition: CglPreProcess.hpp:423
CglHashLink
Only store unique row cuts.
Definition: CglPreProcess.hpp:551
CglPreProcess::cuts_
CglStored cuts_
Cuts from dropped rows.
Definition: CglPreProcess.hpp:445
CglPreProcess::keepColumnNames_
bool keepColumnNames_
keep column names
Definition: CglPreProcess.hpp:454
CglStored
Stored Cut Generator Class.
Definition: CglStored.hpp:16
CglCutGenerator.hpp
CglPreProcess::cutGenerators
CglCutGenerator ** cutGenerators() const
Get the list of cut generators.
Definition: CglPreProcess.hpp:265
CglPreProcess::update
void update(const OsiPresolve *pinfo, const OsiSolverInterface *solver)
Update prohibited and rowType.
CglUniqueRowCuts::sizeRowCuts
int sizeRowCuts() const
Definition: CglPreProcess.hpp:569
CglBK::left_
int left_
For acceleration.
Definition: CglPreProcess.hpp:543
CglPreProcess::setApplicationData
void setApplicationData(void *appData)
Set application data.
CglBK::dominated_
int * dominated_
How many times each original row dominated.
Definition: CglPreProcess.hpp:525
CglPreProcess::operator=
CglPreProcess & operator=(const CglPreProcess &rhs)
Assignment operator.
OsiCuts
Collections of row cuts and column cuts.
Definition: OsiCuts.hpp:19
CglPreProcess::setLanguage
void setLanguage(CoinMessages::Language language)
Definition: CglPreProcess.hpp:302
CglBK::otherColumn_
int * otherColumn_
Other column/node.
Definition: CglPreProcess.hpp:521
CglHashLink::next
int next
Definition: CglPreProcess.hpp:552
CglPreProcess::weightSOS_
double * weightSOS_
Weights for each SOS column.
Definition: CglPreProcess.hpp:417
CglBK::operator=
CglBK & operator=(const CglBK &rhs)
Assignment operator.
CglBK::numberIn_
int numberIn_
Current number in clique.
Definition: CglPreProcess.hpp:541
CglBK::numberColumns_
int numberColumns_
Number of original columns.
Definition: CglPreProcess.hpp:531
CglPreProcess::presolve_
OsiPresolve ** presolve_
Matching presolve information.
Definition: CglPreProcess.hpp:383
CglBK::~CglBK
~CglBK()
Destructor.
CglBK::numberPossible_
int numberPossible_
Number possible.
Definition: CglPreProcess.hpp:535
CglPreProcess::setOriginalModel
void setOriginalModel(OsiSolverInterface *originalModel)
Set original model (probably acopy)
Definition: CglPreProcess.hpp:124
CglPreProcess::getCurrentCPUTime
double getCurrentCPUTime() const
current elapsed or cpu time
CoinMessageHandler
Base class for message handling.
Definition: CoinMessageHandler.hpp:345
CglPreProcess::startModel_
OsiSolverInterface * startModel_
Solver after making clique equalities (may == original)
Definition: CglPreProcess.hpp:375
CglPreProcess::cliqueIt
OsiSolverInterface * cliqueIt(OsiSolverInterface &model, double cliquesNeeded=0.0) const
Replace cliques by more maximal cliques Returns NULL if rows not reduced by greater than cliquesNeede...
CglPreProcess::appData_
void * appData_
Pointer to user-defined data structure.
Definition: CglPreProcess.hpp:399
CglBK::newSolver
OsiSolverInterface * newSolver(const OsiSolverInterface &model)
Creates strengthened smaller model.
OsiSolverInterface
Abstract Base Class for describing an interface to a solver.
Definition: OsiSolverInterface.hpp:61
CglBK::lastColumn_
int lastColumn_
Definition: CglPreProcess.hpp:544
CglBK::originalRow_
int * originalRow_
Original row (in parallel with otherColumn_)
Definition: CglPreProcess.hpp:523
CglPreProcess::numberSOS_
int numberSOS_
Number of SOS if found.
Definition: CglPreProcess.hpp:409
CglBK::bronKerbosch
void bronKerbosch()
For recursive Bron-Kerbosch.
CglPreProcess::originalColumn_
int * originalColumn_
Original column numbers.
Definition: CglPreProcess.hpp:401
CglPreProcess::numberIterationsPre_
int numberIterationsPre_
Number of iterations done in PreProcessing.
Definition: CglPreProcess.hpp:421
CglBK::mark_
char * mark_
Array to mark stuff.
Definition: CglPreProcess.hpp:517
CglPreProcess::setOptions
void setOptions(int value)
Set options.
Definition: CglPreProcess.hpp:251
CglBK::candidates_
int * candidates_
Current candidates (created at each level)
Definition: CglPreProcess.hpp:515
CglUniqueRowCuts::size_
int size_
Definition: CglPreProcess.hpp:592
CglPreProcess::preProcessNonDefault
OsiSolverInterface * preProcessNonDefault(OsiSolverInterface &model, int makeEquality=0, int numberPasses=5, int tuning=0)
preProcess problem - returning new problem.
CoinMessageHandler.hpp
This is a first attempt at a message handler.
CglPreProcess::numberIterationsPre
int numberIterationsPre() const
Number of iterations PreProcessing.
Definition: CglPreProcess.hpp:207
CglPreProcess::useElapsedTime_
bool useElapsedTime_
use elapsed (wallclock time) or cpu time
Definition: CglPreProcess.hpp:448
CglPreProcess::whichSOS
const int * whichSOS() const
Columns in SOS.
Definition: CglPreProcess.hpp:190
CglPreProcess::someFixed
OsiSolverInterface * someFixed(OsiSolverInterface &model, double fractionToKeep=0.25, bool fixContinuousAsWell=false, char *keep=NULL) const
Fix some of problem - returning new problem.
CglCutGenerator
Cut Generator Base Class.
Definition: CglCutGenerator.hpp:23
CglPreProcess::numberSOS
int numberSOS() const
Number of SOS if found.
Definition: CglPreProcess.hpp:175
CglPreProcess::numberIterationsPost
int numberIterationsPost() const
Number of iterations PostProcessing.
Definition: CglPreProcess.hpp:212
CglPreProcess::numberSolvers_
int numberSolvers_
Number of solvers at various stages.
Definition: CglPreProcess.hpp:377
CglUniqueRowCuts::eraseRowCut
void eraseRowCut(int sequence)
CglUniqueRowCuts::addCuts
void addCuts(OsiCuts &cs)
CglPreProcess::passInMessageHandler
void passInMessageHandler(CoinMessageHandler *handler)
Pass in Message handler (not deleted at end)
OsiPresolve.hpp
CglPreProcess::cutGenerator
CglCutGenerator * cutGenerator(int i) const
Get the specified cut generator.
Definition: CglPreProcess.hpp:270
CglPreProcess::passInRowTypes
void passInRowTypes(const char *rowTypes, int numberRows)
Pass in row types 0 normal 1 cut rows - will be dropped if remain in At end of preprocess cut rows wi...
CglUniqueRowCuts::insert
void insert(const OsiRowCut &cut)
Definition: CglPreProcess.hpp:579
cut
Definition: Cgl012cut.hpp:153
CglPreProcess::originalModel
OsiSolverInterface * originalModel() const
The original solver associated with this model.
Definition: CglPreProcess.hpp:119
CglUniqueRowCuts::lastHash_
int lastHash_
Definition: CglPreProcess.hpp:595
CglUniqueRowCuts::numberCuts_
int numberCuts_
Definition: CglPreProcess.hpp:594
CglPreProcess::modelAtPass
OsiSolverInterface * modelAtPass(int iPass) const
Copies of solver at various stages after presolve.
Definition: CglPreProcess.hpp:139
CglPreProcess::startSOS_
int * startSOS_
Start of each SOS.
Definition: CglPreProcess.hpp:413
CglUniqueRowCuts::hash_
CglHashLink * hash_
Hash table.
Definition: CglPreProcess.hpp:591
CglUniqueRowCuts::operator=
CglUniqueRowCuts & operator=(const CglUniqueRowCuts &rhs)
CglPreProcess::originalColumns
const int * originalColumns()
Return a pointer to the original columns (with possible clique slacks) MUST be called before postProc...
CglPreProcess::modifiedModel_
OsiSolverInterface ** modifiedModel_
Copies of solver at various stages after presolve after modifications.
Definition: CglPreProcess.hpp:381
CglPreProcess::messagesPointer
CoinMessages * messagesPointer()
Return pointer to messages.
Definition: CglPreProcess.hpp:317
OsiRowCut
Row Cut Class.
Definition: OsiRowCut.hpp:29
CglPreProcess::cuts
const CglStored & cuts() const
Return cuts from dropped rows.
Definition: CglPreProcess.hpp:234
CglPreProcess::CglPreProcess
CglPreProcess()
Constructor.
CglPreProcess::createOriginalIndices
void createOriginalIndices()
create original columns and rows
CglPreProcess::numberCutGenerators_
int numberCutGenerators_
Number of cut generators.
Definition: CglPreProcess.hpp:405
CglBK::cliqueMatrix_
CoinPackedMatrix * cliqueMatrix_
Clique entries.
Definition: CglPreProcess.hpp:527
CglPreProcess::modified
OsiSolverInterface * modified(OsiSolverInterface *model, bool constraints, int &numberChanges, int iBigPass, int numberPasses)
Return model with useful modifications.
CglPreProcess::cutsPointer
const CglStored * cutsPointer() const
Return pointer to cuts from dropped rows.
Definition: CglPreProcess.hpp:239
CoinPackedMatrix
Sparse Matrix Base Class.
Definition: CoinPackedMatrix.hpp:79
CglUniqueRowCuts::hashMultiplier_
int hashMultiplier_
Definition: CglPreProcess.hpp:593
OsiPresolve
OSI interface to COIN problem simplification capabilities.
Definition: OsiPresolve.hpp:59
CglPreProcess::whichSOS_
int * whichSOS_
Columns in SOS.
Definition: CglPreProcess.hpp:415
CglBK::rowType_
const char * rowType_
points to row types
Definition: CglPreProcess.hpp:529
CglPreProcess::setCutoff
void setCutoff(double value)
Set cutoff bound on the objective function.
CglPreProcess::originalModel_
OsiSolverInterface * originalModel_
The original solver associated with this model.
Definition: CglPreProcess.hpp:373
CglPreProcess::startModel
OsiSolverInterface * startModel() const
Solver after making clique equalities (may == original)
Definition: CglPreProcess.hpp:129
OsiSolverInterface.hpp
CoinMessages::Language
Language
Supported languages.
Definition: CoinMessageHandler.hpp:148
CglPreProcess::presolve
OsiPresolve * presolve(int iPass) const
Matching presolve information.
Definition: CglPreProcess.hpp:155
CoinBigIndex
int CoinBigIndex
Definition: Coin_C_defines.h:136
CglPreProcess::modifiedModel
OsiSolverInterface * modifiedModel(int iPass) const
Copies of solver at various stages after presolve after modifications.
Definition: CglPreProcess.hpp:147
CglPreProcess::postProcess
void postProcess(OsiSolverInterface &model, int deleteStuff=2)
Creates solution in original model deleteStuff 0 - don&#39;t, 1 do (but not if infeasible), 2 always.
CglPreProcess::generator_
CglCutGenerator ** generator_
Cut generators.
Definition: CglPreProcess.hpp:407
CglPreProcess::passInProhibited
void passInProhibited(const char *prohibited, int numberColumns)
Pass in prohibited columns.
CglUniqueRowCuts::rowCutPtr
OsiRowCut * rowCutPtr(int sequence)
Definition: CglPreProcess.hpp:573
CglPreProcess::setTimeLimit
void setTimeLimit(const double timeLimit, const bool useElapsedTime)
Set time limit.
CglPreProcess::options_
int options_
Options 1 - original model had integer bounds before tightening 2 - don&#39;t do probing 4 - don&#39;t do dup...
Definition: CglPreProcess.hpp:436
CglBK::start_
CoinBigIndex * start_
Starts for graph (numberPossible+1)
Definition: CglPreProcess.hpp:519
CglPreProcess::defaultHandler_
bool defaultHandler_
Flag to say if handler_ is the default handler.
Definition: CglPreProcess.hpp:393
CglPreProcess::preProcess
OsiSolverInterface * preProcess(OsiSolverInterface &model, bool makeEquality=false, int numberPasses=5)
preProcess problem - returning new problem.
CglBK::numberRows_
int numberRows_
Number of original rows.
Definition: CglPreProcess.hpp:533
CglPreProcess::rowTypes
const char * rowTypes()
Updated row types - may be NULL Carried around and corresponds to existing rows -1 added by preproces...
Definition: CglPreProcess.hpp:229
CglPreProcess::typeSOS_
int * typeSOS_
Type of each SOS.
Definition: CglPreProcess.hpp:411
CglBK::firstNot_
int firstNot_
First not (stored backwards from numberPossible_)
Definition: CglPreProcess.hpp:539
CglPreProcess::prohibited_
char * prohibited_
Columns which should not be presolved e.g. SOS.
Definition: CglPreProcess.hpp:425
CglPreProcess::startSOS
const int * startSOS() const
Start of each SOS.
Definition: CglPreProcess.hpp:185
CglPreProcess::numberCutGenerators
int numberCutGenerators() const
Get the number of cut generators.
Definition: CglPreProcess.hpp:260
CglUniqueRowCuts
Definition: CglPreProcess.hpp:555
CglPreProcess::prohibited
const char * prohibited()
Updated prohibited columns.
Definition: CglPreProcess.hpp:202
CglPreProcess::makeInteger
void makeInteger()
Make continuous variables integer.
CglPreProcess::setKeepColumnNames
void setKeepColumnNames(const bool keep)
Keeps original column names.
CglPreProcess
Class for preProcessing and postProcessing.
Definition: CglPreProcess.hpp:37
CglPreProcess::options
int options() const
Get options.
Definition: CglPreProcess.hpp:246
CglPreProcess::messageHandler
CoinMessageHandler * messageHandler() const
Return handler.
Definition: CglPreProcess.hpp:307
CglUniqueRowCuts::~CglUniqueRowCuts
~CglUniqueRowCuts()
CglUniqueRowCuts::rowCut_
OsiRowCut ** rowCut_
Definition: CglPreProcess.hpp:589
CglPreProcess::messages
CoinMessages messages()
Return messages.
Definition: CglPreProcess.hpp:312
CglPreProcess::getApplicationData
void * getApplicationData() const
Get application data.
CglPreProcess::numberProhibited_
int numberProhibited_
Number of columns in original prohibition set.
Definition: CglPreProcess.hpp:419
CglPreProcess::reducedCostFix
int reducedCostFix(OsiSolverInterface &model)
If we have a cutoff - fix variables.
CglPreProcess::~CglPreProcess
~CglPreProcess()
Destructor.
CglBK::CglBK
CglBK()
Default constructor.
CglPreProcess::getCutoff
double getCutoff() const
Get the cutoff bound on the objective function - always as minimize.
CglPreProcess::originalRows
const int * originalRows()
Return a pointer to the original rows MUST be called before postProcess otherwise you just get 0...
CglStored.hpp
CglPreProcess::setPresolve
void setPresolve(int iPass, OsiPresolve *presolve)
Set matching presolve information.
Definition: CglPreProcess.hpp:163
CoinMessages
Class to hold and manipulate an array of massaged messages.
Definition: CoinMessageHandler.hpp:140
CglBK::numberCandidates_
int numberCandidates_
Current number of candidates.
Definition: CglPreProcess.hpp:537
CglPreProcess::typeSOS
const int * typeSOS() const
Type of each SOS.
Definition: CglPreProcess.hpp:180
CglUniqueRowCuts::insertIfNotDuplicate
int insertIfNotDuplicate(const OsiRowCut &cut)
CglPreProcess::messages_
CoinMessages messages_
Cgl messages.
Definition: CglPreProcess.hpp:396
CglPreProcess::originalRow_
int * originalRow_
Original row numbers.
Definition: CglPreProcess.hpp:403