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
CglProbing.hpp
Go to the documentation of this file.
1 // $Id: CglProbing.hpp 1387 2017-09-29 11:02:03Z forrest $
2 // Copyright (C) 2002, 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 CglProbing_H
7 #define CglProbing_H
8
9 #include <string>
10
11 #include "CglCutGenerator.hpp"
16 typedef struct {
17 //unsigned int zeroOne:1; // nonzero if affected variable is 0-1
18 //unsigned int whenAtUB:1; // nonzero if fixing happens when this variable at 1
19 //unsigned int affectedToUB:1; // nonzero if affected variable fixed to UB
20 //unsigned int affected:29; // If 0-1 then 0-1 sequence, otherwise true
21 unsigned int affected;
22 } disaggregationAction;
23
25 class CglProbing : public CglCutGenerator {
26 friend void CglProbingUnitTest(const OsiSolverInterface * siP,
27 const std::string mpdDir );
28
29 public:
30
31
99 virtual void generateCuts( const OsiSolverInterface & si, OsiCuts & cs,
100 const CglTreeInfo info = CglTreeInfo());
101 int generateCutsAndModify( const OsiSolverInterface & si, OsiCuts & cs,
102 CglTreeInfo * info);
104
115 int snapshot ( const OsiSolverInterface & si,
116 char * possible=NULL,
117 bool withObjective=true);
119 void deleteSnapshot ( );
125 int createCliques( OsiSolverInterface & si,
126 int minimumSize=2, int maximumSize=100);
128 void deleteCliques();
132 OsiSolverInterface * cliqueModel(const OsiSolverInterface * model,
133 int type);
135
138 const double * tightLower() const;
141 const double * tightUpper() const;
143 const char * tightenBounds() const
144 { return tightenBounds_;}
146
149 const double * relaxedRowLower() const;
152 const double * relaxedRowUpper() const;
154
157 void setMode(int mode);
160 int getMode() const;
162
165 void setMaxPass(int value);
168 int getMaxPass() const;
170 void setLogLevel(int value);
172 int getLogLevel() const;
174 void setMaxProbe(int value);
176 int getMaxProbe() const;
178 void setMaxLook(int value);
180 int getMaxLook() const;
182 void setMaxElements(int value);
184 int getMaxElements() const;
186 void setMaxPassRoot(int value);
188 int getMaxPassRoot() const;
190 void setMaxProbeRoot(int value);
192 int getMaxProbeRoot() const;
194 void setMaxLookRoot(int value);
196 int getMaxLookRoot() const;
198 void setMaxElementsRoot(int value);
200 int getMaxElementsRoot() const;
208 virtual bool mayGenerateRowCutsInTree() const;
210
213 inline int numberThisTime() const
215 { return numberThisTime_;}
217 inline const int * lookedAt() const
218 { return lookedAt_;}
220
223 void setRowCuts(int type);
227 int rowCuts() const;
229 typedef struct {
231 unsigned int equality:1; // nonzero if clique is ==
232 } CliqueType;
233
236 inline int numberCliques() const
238 { return numberCliques_;}
240 inline CliqueType * cliqueType() const
241 { return cliqueType_;}
243 inline CoinBigIndex * cliqueStart() const
244 { return cliqueStart_;}
246 inline CliqueEntry * cliqueEntry() const
247 { return cliqueEntry_;}
249
257 void setUsingObjective(int yesNo);
259 int getUsingObjective() const;
261
264 void tightenThese(const OsiSolverInterface & solver, int number, const int * which);
267
270 CglProbing ();
272
274 CglProbing (
275 const CglProbing &);
276
278 virtual CglCutGenerator * clone() const;
279
281 CglProbing &
282 operator=(
283 const CglProbing& rhs);
284
286 virtual
287 ~CglProbing ();
288
290 virtual void refreshSolver(OsiSolverInterface * solver);
292 virtual std::string generateCpp( FILE * fp);
294
295 private:
296
297 // Private member methods
300 int probe( const OsiSolverInterface & si,
302 const OsiRowCutDebugger * debugger,
303 OsiCuts & cs,
304 double * colLower, double * colUpper, CoinPackedMatrix *rowCopy,
305 CoinPackedMatrix *columnCopy,const CoinBigIndex * rowStartPos,
306 const int * realRow, const double * rowLower, const double * rowUpper,
307 const char * intVar, double * minR, double * maxR, int * markR,
308 CglTreeInfo * info);
310 int probeCliques( const OsiSolverInterface & si,
311 const OsiRowCutDebugger * debugger,
312 OsiCuts & cs,
313 double * colLower, double * colUpper, CoinPackedMatrix *rowCopy,
314 CoinPackedMatrix *columnCopy, const int * realRow,
315 double * rowLower, double * rowUpper,
316 char * intVar, double * minR, double * maxR, int * markR,
317 CglTreeInfo * info);
319 int probeSlacks( const OsiSolverInterface & si,
320 const OsiRowCutDebugger * debugger,
321 OsiCuts & cs,
322 double * colLower, double * colUpper, CoinPackedMatrix *rowCopy,
323 CoinPackedMatrix *columnCopy,
324 double * rowLower, double * rowUpper,
325 char * intVar, double * minR, double * maxR,int * markR,
326 CglTreeInfo * info);
329 int gutsOfGenerateCuts( const OsiSolverInterface & si,
330 OsiCuts & cs,
331 double * rowLower, double * rowUpper,
332 double * colLower, double * colUpper,
333 CglTreeInfo * info);
335 void setupRowCliqueInformation(const OsiSolverInterface & si);
338 int tighten(double *colLower, double * colUpper,
339 const int *column, const double *rowElements,
340 const CoinBigIndex *rowStart,const CoinBigIndex * rowStartPos,
341 const int * rowLength,
342 double *rowLower, double *rowUpper,
343 int nRows,int nCols,char * intVar,int maxpass,
344 double tolerance);
346 void tighten2(double *colLower, double * colUpper,
347 const int *column, const double *rowElements,
348 const CoinBigIndex *rowStart,
349 const int * rowLength,
350 double *rowLower, double *rowUpper,
351 double * minR, double * maxR, int * markR,
352 int nRows);
354
355 // Private member data
356
357 struct disaggregation_struct_tag ;
358 friend struct CglProbing::disaggregation_struct_tag ;
359
362 CoinPackedMatrix * rowCopy_;
365 CoinPackedMatrix * columnCopy_;
367 double * rowLower_;
369 double * rowUpper_;
371 double * colLower_;
373 double * colUpper_;
375 int numberRows_;
377 int numberColumns_;
379 double primalTolerance_;
383 int mode_;
388 int rowCuts_;
390 int maxPass_;
392 int logLevel_;
394 int maxProbe_;
396 int maxStack_;
398 int maxElements_;
400 int maxPassRoot_;
402 int maxProbeRoot_;
404 int maxStackRoot_;
406 int maxElementsRoot_;
408 int usingObjective_;
410 int numberIntegers_;
412 int number01Integers_;
414 int numberThisTime_;
416 int totalTimesCalled_;
418 int * lookedAt_;
420 typedef struct disaggregation_struct_tag {
421 int sequence; // integer variable
422 // index will be NULL if no probing done yet
423 int length; // length of newValue
424 disaggregationAction * index; // columns whose bounds will be changed
425 } disaggregation;
426 disaggregation * cutVector_;
429 int numberCliques_;
431 CliqueType * cliqueType_;
433 CoinBigIndex * cliqueStart_;
435 CliqueEntry * cliqueEntry_;
438 int * oneFixStart_;
441 int * zeroFixStart_;
443 int * endFixStart_;
445 int * whichClique_;
450 CliqueEntry * cliqueRow_;
452 int * cliqueRowStart_;
454 char * tightenBounds_;
456 };
457 inline int affectedInDisaggregation(const disaggregationAction & dis)
458 { return dis.affected&0x1fffffff;}
459 inline void setAffectedInDisaggregation(disaggregationAction & dis,
460 int affected)
461 { dis.affected = affected|(dis.affected&0xe0000000);}
462 #ifdef NDEBUG
463 inline bool zeroOneInDisaggregation(const disaggregationAction & )
464 { return true;}
465 #else
466 inline bool zeroOneInDisaggregation(const disaggregationAction & dis)
467 //{ return (dis.affected&0x80000000)!=0;}
468 { assert ((dis.affected&0x80000000)!=0); return true;}
469 #endif
470 inline void setZeroOneInDisaggregation(disaggregationAction & dis,bool zeroOne)
471 { dis.affected = (zeroOne ? 0x80000000 : 0)|(dis.affected&0x7fffffff);}
472 inline bool whenAtUBInDisaggregation(const disaggregationAction & dis)
473 { return (dis.affected&0x40000000)!=0;}
474 inline void setWhenAtUBInDisaggregation(disaggregationAction & dis,bool whenAtUB)
475 { dis.affected = (whenAtUB ? 0x40000000 : 0)|(dis.affected&0xbfffffff);}
476 inline bool affectedToUBInDisaggregation(const disaggregationAction & dis)
477 { return (dis.affected&0x20000000)!=0;}
478 inline void setAffectedToUBInDisaggregation(disaggregationAction & dis,bool affectedToUB)
479 { dis.affected = (affectedToUB ? 0x20000000 : 0)|(dis.affected&0xdfffffff);}
480
481 //#############################################################################
487 void CglProbingUnitTest(const OsiSolverInterface * siP,
488 const std::string mpdDir );
490 class CglImplication : public CglCutGenerator {
491
492 public:
493
499 virtual void generateCuts( const OsiSolverInterface & si, OsiCuts & cs,
500 const CglTreeInfo info = CglTreeInfo());
502
505 CglImplication ();
507
509 CglImplication (CglTreeProbingInfo * info);
510
512 CglImplication (
513 const CglImplication &);
514
516 virtual CglCutGenerator * clone() const;
517
519 CglImplication &
520 operator=(
521 const CglImplication& rhs);
522
524 virtual
525 ~CglImplication ();
527 virtual std::string generateCpp( FILE * fp);
529
531 inline void setProbingInfo(CglTreeProbingInfo * info)
533 { probingInfo_=info;}
535
536 private:
539 CglTreeProbingInfo * probingInfo_;
542 };
543 #endif
CglProbing::probeCliques
int probeCliques(const OsiSolverInterface &si, const OsiRowCutDebugger *debugger, OsiCuts &cs, double *colLower, double *colUpper, CoinPackedMatrix *rowCopy, CoinPackedMatrix *columnCopy, const int *realRow, double *rowLower, double *rowUpper, char *intVar, double *minR, double *maxR, int *markR, CglTreeInfo *info)
Does probing and adding cuts (with cliques)
CglProbing::gutsOfGenerateCuts
int gutsOfGenerateCuts(const OsiSolverInterface &si, OsiCuts &cs, double *rowLower, double *rowUpper, double *colLower, double *colUpper, CglTreeInfo *info)
Does most of work of generateCuts Returns number of infeasibilities.
CglProbing::getMode
int getMode() const
Get.
CglProbing::getMaxPassRoot
int getMaxPassRoot() const
Get maximum number of passes per node (root node)
CglProbing::probeSlacks
int probeSlacks(const OsiSolverInterface &si, const OsiRowCutDebugger *debugger, OsiCuts &cs, double *colLower, double *colUpper, CoinPackedMatrix *rowCopy, CoinPackedMatrix *columnCopy, double *rowLower, double *rowUpper, char *intVar, double *minR, double *maxR, int *markR, CglTreeInfo *info)
Does probing and adding cuts for clique slacks.
CglProbing::cutVector_
disaggregation * cutVector_
Definition: CglProbing.hpp:426
CglProbing::maxStack_
int maxStack_
Maximum number of variables to look at in one probe.
Definition: CglProbing.hpp:396
CglProbing::colLower_
double * colLower_
Lower bounds on columns.
Definition: CglProbing.hpp:371
CglProbing::setupRowCliqueInformation
void setupRowCliqueInformation(const OsiSolverInterface &si)
Sets up clique information for each row.
CglProbing::CliqueType
Clique type.
Definition: CglProbing.hpp:230
CglProbing::maxProbe_
int maxProbe_
Maximum number of unsatisfied variables to probe.
Definition: CglProbing.hpp:394
CglProbing::getMaxLook
int getMaxLook() const
Get maximum number of variables to look at in one probe.
CglImplication
This just uses implication info.
Definition: CglProbing.hpp:490
CglProbing::setMaxElements
void setMaxElements(int value)
Set maximum number of elements in row for it to be considered.
CglProbing::cliqueRow_
CliqueEntry * cliqueRow_
For each column with nonzero in row copy this gives a clique &quot;number&quot;.
Definition: CglProbing.hpp:450
CglProbing::lookedAt_
int * lookedAt_
Which ones looked at this time.
Definition: CglProbing.hpp:418
CglProbing::getMaxProbe
int getMaxProbe() const
Get maximum number of unsatisfied variables to look at.
CglProbing::maxStackRoot_
int maxStackRoot_
Maximum number of variables to look at in one probe at root.
Definition: CglProbing.hpp:404
CglProbing::setMaxLookRoot
void setMaxLookRoot(int value)
Set maximum number of variables to look at in one probe (root node)
CglProbing::maxElements_
int maxElements_
Maximum number of elements in row for scan.
Definition: CglProbing.hpp:398
CglProbing::numberCliques
int numberCliques() const
Number of cliques.
Definition: CglProbing.hpp:237
CglProbing::setMaxPass
void setMaxPass(int value)
Set maximum number of passes per node.
CglProbing::clone
virtual CglCutGenerator * clone() const
Clone.
CglImplication::probingInfo_
CglTreeProbingInfo * probingInfo_
Pointer to tree probing info.
Definition: CglProbing.hpp:540
CglProbing::numberColumns_
int numberColumns_
Number of columns in problem ( must == current)
Definition: CglProbing.hpp:377
setWhenAtUBInDisaggregation
void setWhenAtUBInDisaggregation(disaggregationAction &dis, bool whenAtUB)
Definition: CglProbing.hpp:474
CglProbing::maxProbeRoot_
int maxProbeRoot_
Maximum number of unsatisfied variables to probe at root.
Definition: CglProbing.hpp:402
CglCutGenerator.hpp
CglProbing::relaxedRowLower
const double * relaxedRowLower() const
Lower.
CglProbing::cliqueEntry
CliqueEntry * cliqueEntry() const
Entries for clique.
Definition: CglProbing.hpp:246
CglProbing::generateCpp
virtual std::string generateCpp(FILE *fp)
Create C++ lines to get to current state.
CglProbing::numberRows_
int numberRows_
Number of rows in snapshot (or when cliqueRow stuff computed)
Definition: CglProbing.hpp:375
CglTreeInfo
Information about where the cut generator is invoked from.
Definition: CglTreeInfo.hpp:15
CglImplication::operator=
CglImplication & operator=(const CglImplication &rhs)
Assignment operator.
CglProbing::maxPass_
int maxPass_
Maximum number of passes to do in probing.
Definition: CglProbing.hpp:390
OsiCuts
Collections of row cuts and column cuts.
Definition: OsiCuts.hpp:19
CglProbing::cliqueType
CliqueType * cliqueType() const
Clique type.
Definition: CglProbing.hpp:240
CglProbing::rowUpper_
double * rowUpper_
Upper bounds on rows.
Definition: CglProbing.hpp:369
CglProbing::number01Integers_
int number01Integers_
Number of 0-1 integer variables.
Definition: CglProbing.hpp:412
CglProbing::disaggregation_struct_tag::index
disaggregationAction * index
Definition: CglProbing.hpp:424
CglProbing::setMode
void setMode(int mode)
Set.
CglProbing::lookedAt
const int * lookedAt() const
Which ones looked at this time.
Definition: CglProbing.hpp:217
CglProbing::disaggregation_struct_tag::sequence
int sequence
Definition: CglProbing.hpp:421
CglImplication::CglImplication
CglImplication()
Default constructor.
CglProbing::endFixStart_
int * endFixStart_
End of fixes for a column.
Definition: CglProbing.hpp:443
CglProbing::cliqueType_
CliqueType * cliqueType_
Clique type.
Definition: CglProbing.hpp:431
setAffectedInDisaggregation
void setAffectedInDisaggregation(disaggregationAction &dis, int affected)
Definition: CglProbing.hpp:459
CglProbing::tightenBounds_
char * tightenBounds_
If not null and [i] !=0 then also tighten even if continuous.
Definition: CglProbing.hpp:454
CglProbing::tightenBounds
const char * tightenBounds() const
Array which says tighten continuous.
Definition: CglProbing.hpp:143
CglProbing::deleteSnapshot
void deleteSnapshot()
Deletes snapshot.
CglProbing::zeroFixStart_
int * zeroFixStart_
Start of zeroFixes cliques for a column in matrix or -1 if not in any clique.
Definition: CglProbing.hpp:441
CglProbing::createCliques
int createCliques(OsiSolverInterface &si, int minimumSize=2, int maximumSize=100)
Creates cliques for use by probing.
CglProbing::tightUpper
const double * tightUpper() const
Upper.
CglProbing::whichClique_
int * whichClique_
Clique numbers for one or zero fixes.
Definition: CglProbing.hpp:445
CglProbing::cliqueRowStart_
int * cliqueRowStart_
cliqueRow_ starts for each row
Definition: CglProbing.hpp:452
CglProbing::logLevel_
int logLevel_
Log level - 0 none, 1 - a bit, 2 - more details.
Definition: CglProbing.hpp:392
CglImplication::setProbingInfo
void setProbingInfo(CglTreeProbingInfo *info)
Set implication.
Definition: CglProbing.hpp:532
OsiSolverInterface
Abstract Base Class for describing an interface to a solver.
Definition: OsiSolverInterface.hpp:61
CglProbing::setMaxLook
void setMaxLook(int value)
Set maximum number of variables to look at in one probe.
CglImplication::clone
virtual CglCutGenerator * clone() const
Clone.
CglProbing::setMaxElementsRoot
void setMaxElementsRoot(int value)
Set maximum number of elements in row for it to be considered (root node)
CglImplication::generateCuts
virtual void generateCuts(const OsiSolverInterface &si, OsiCuts &cs, const CglTreeInfo info=CglTreeInfo())
Generate cuts from implication table Insert generated cuts into the cut set cs.
CglProbing::oneFixStart_
int * oneFixStart_
Start of oneFixes cliques for a column in matrix or -1 if not in any clique.
Definition: CglProbing.hpp:438
CglProbing::totalTimesCalled_
int totalTimesCalled_
Total number of times called.
Definition: CglProbing.hpp:416
disaggregationAction::affected
unsigned int affected
Definition: CglProbing.hpp:21
CglProbing::mode_
int mode_
Mode - 0 lazy using snapshot, 1 just unsatisfied, 2 all.
Definition: CglProbing.hpp:383
CglProbing::cliqueModel
OsiSolverInterface * cliqueModel(const OsiSolverInterface *model, int type)
Create a fake model by adding cliques if type&amp;4 then delete rest of model first, if 1 then add proper...
CglProbing::cliqueEntry_
CliqueEntry * cliqueEntry_
Entries for clique.
Definition: CglProbing.hpp:435
CliqueEntry
Derived class to pick up probing info.
Definition: CglTreeInfo.hpp:86
CglProbing::probe
int probe(const OsiSolverInterface &si, const OsiRowCutDebugger *debugger, OsiCuts &cs, double *colLower, double *colUpper, CoinPackedMatrix *rowCopy, CoinPackedMatrix *columnCopy, const CoinBigIndex *rowStartPos, const int *realRow, const double *rowLower, const double *rowUpper, const char *intVar, double *minR, double *maxR, int *markR, CglTreeInfo *info)
Does probing and adding cuts (without cliques and mode_!=0)
zeroOneInDisaggregation
bool zeroOneInDisaggregation(const disaggregationAction &dis)
Definition: CglProbing.hpp:466
CglProbing::colUpper_
double * colUpper_
Upper bounds on columns.
Definition: CglProbing.hpp:373
CglProbing::numberIntegers_
int numberIntegers_
Number of integer variables.
Definition: CglProbing.hpp:410
CglProbing::maxPassRoot_
int maxPassRoot_
Maximum number of passes to do in probing at root.
Definition: CglProbing.hpp:400
CglProbing::setMaxProbe
void setMaxProbe(int value)
Set maximum number of unsatisfied variables to look at.
CglCutGenerator
Cut Generator Base Class.
Definition: CglCutGenerator.hpp:23
CglProbing::numberCliques_
int numberCliques_
Cliques Number of cliques.
Definition: CglProbing.hpp:429
CglProbing::mayGenerateRowCutsInTree
virtual bool mayGenerateRowCutsInTree() const
Returns true if may generate Row cuts in tree (rather than root node).
disaggregationAction
Only useful type of disaggregation is most normal For now just done for 0-1 variables Can be used for...
Definition: CglProbing.hpp:16
CglProbing::CglProbing
CglProbing()
Default constructor.
affectedToUBInDisaggregation
bool affectedToUBInDisaggregation(const disaggregationAction &dis)
Definition: CglProbing.hpp:476
CglProbing::relaxedRowUpper
const double * relaxedRowUpper() const
Upper.
CglProbing::rowCuts
int rowCuts() const
Get.
CglProbing::primalTolerance_
double primalTolerance_
Tolerance to see if infeasible.
Definition: CglProbing.hpp:379
CglProbing::getUsingObjective
int getUsingObjective() const
Get.
CglImplication::generateCpp
virtual std::string generateCpp(FILE *fp)
Create C++ lines to get to current state.
CglProbing::generateCuts
virtual void generateCuts(const OsiSolverInterface &si, OsiCuts &cs, const CglTreeInfo info=CglTreeInfo())
Generate probing/disaggregation cuts for the model of the solver interface, si.
setZeroOneInDisaggregation
void setZeroOneInDisaggregation(disaggregationAction &dis, bool zeroOne)
Definition: CglProbing.hpp:470
CglProbing::disaggregation
struct CglProbing::disaggregation_struct_tag disaggregation
Disaggregation cuts and for building cliques.
CglProbing::disaggregation_struct_tag::length
int length
Definition: CglProbing.hpp:423
CglProbing::rowLower_
double * rowLower_
Lower bounds on rows.
Definition: CglProbing.hpp:367
CglProbingUnitTest
void CglProbingUnitTest(const OsiSolverInterface *siP, const std::string mpdDir)
A function that tests the methods in the CglProbing class.
CglProbing::cliqueStart
CoinBigIndex * cliqueStart() const
Start of each clique.
Definition: CglProbing.hpp:243
CglProbing::numberThisTime_
int numberThisTime_
Number looked at this time.
Definition: CglProbing.hpp:414
CglProbing::getMaxLookRoot
int getMaxLookRoot() const
Get maximum number of variables to look at in one probe (root node)
CoinPackedMatrix
Sparse Matrix Base Class.
Definition: CoinPackedMatrix.hpp:79
CglProbing::tighten2
void tighten2(double *colLower, double *colUpper, const int *column, const double *rowElements, const CoinBigIndex *rowStart, const int *rowLength, double *rowLower, double *rowUpper, double *minR, double *maxR, int *markR, int nRows)
This just sets minima and maxima on rows.
CglProbing::rowCuts_
int rowCuts_
Row cuts flag 0 no cuts, 1 just disaggregation type, 2 coefficient ( 3 both), 4 just column cuts -n a...
Definition: CglProbing.hpp:388
CglProbing::getMaxElements
int getMaxElements() const
Get maximum number of elements in row for it to be considered.
CglProbing::numberThisTime
int numberThisTime() const
Number looked at this time.
Definition: CglProbing.hpp:214
CglProbing::tightLower
const double * tightLower() const
Lower.
CglImplication::~CglImplication
virtual ~CglImplication()
Destructor.
CglTreeProbingInfo
Definition: CglTreeInfo.hpp:92
CoinBigIndex
int CoinBigIndex
Definition: Coin_C_defines.h:136
CglProbing::cliqueStart_
CoinBigIndex * cliqueStart_
Start of each clique.
Definition: CglProbing.hpp:433
CglProbing::getLogLevel
int getLogLevel() const
Get log level.
CglProbing::setLogLevel
void setLogLevel(int value)
Set log level - 0 none, 1 - a bit, 2 - more details.
setAffectedToUBInDisaggregation
void setAffectedToUBInDisaggregation(disaggregationAction &dis, bool affectedToUB)
Definition: CglProbing.hpp:478
CglProbing::refreshSolver
virtual void refreshSolver(OsiSolverInterface *solver)
This can be used to refresh any inforamtion.
CglProbing::disaggregation_struct_tag
Disaggregation cuts and for building cliques.
Definition: CglProbing.hpp:420
CglProbing::tightenThese
void tightenThese(const OsiSolverInterface &solver, int number, const int *which)
Mark variables to be tightened.
CglProbing::getMaxPass
int getMaxPass() const
Get maximum number of passes per node.
CglProbing::tighten
int tighten(double *colLower, double *colUpper, const int *column, const double *rowElements, const CoinBigIndex *rowStart, const CoinBigIndex *rowStartPos, const int *rowLength, double *rowLower, double *rowUpper, int nRows, int nCols, char *intVar, int maxpass, double tolerance)
This tightens column bounds (and can declare infeasibility) It may also declare rows to be redundant...
CglProbing::snapshot
int snapshot(const OsiSolverInterface &si, char *possible=NULL, bool withObjective=true)
Create a copy of matrix which is to be used this is to speed up process and to give global cuts Can g...
OsiRowCutDebugger
Validate cuts against a known solution.
Definition: OsiRowCutDebugger.hpp:42
CglProbing::setUsingObjective
void setUsingObjective(int yesNo)
Set 0 don&#39;t 1 do -1 don&#39;t even think about it.
CglProbing::CglProbingUnitTest
friend void CglProbingUnitTest(const OsiSolverInterface *siP, const std::string mpdDir)
A function that tests the methods in the CglProbing class.
whenAtUBInDisaggregation
bool whenAtUBInDisaggregation(const disaggregationAction &dis)
Definition: CglProbing.hpp:472
CglProbing::maxElementsRoot_
int maxElementsRoot_
Maximum number of elements in row for scan at root.
Definition: CglProbing.hpp:406
CglProbing::generateCutsAndModify
int generateCutsAndModify(const OsiSolverInterface &si, OsiCuts &cs, CglTreeInfo *info)
CglProbing::usingObjective_
int usingObjective_
Whether to include objective as constraint.
Definition: CglProbing.hpp:408
CglProbing::setMaxProbeRoot
void setMaxProbeRoot(int value)
Set maximum number of unsatisfied variables to look at (root node)
CglProbing::setRowCuts
void setRowCuts(int type)
Set 0 no cuts, 1 just disaggregation type, 2 coefficient ( 3 both)
CglProbing::getMaxElementsRoot
int getMaxElementsRoot() const
Get maximum number of elements in row for it to be considered (root node)
CglProbing::columnCopy_
CoinPackedMatrix * columnCopy_
Column copy (only if snapshot)
Definition: CglProbing.hpp:365
affectedInDisaggregation
int affectedInDisaggregation(const disaggregationAction &dis)
Definition: CglProbing.hpp:457
CglProbing::~CglProbing
virtual ~CglProbing()
Destructor.
CglProbing
Probing Cut Generator Class.
Definition: CglProbing.hpp:25
CglProbing::setMaxPassRoot
void setMaxPassRoot(int value)
Set maximum number of passes per node (root node)
CglProbing::rowCopy_
CoinPackedMatrix * rowCopy_
Row copy (only if snapshot)
Definition: CglProbing.hpp:363
CglProbing::operator=
CglProbing & operator=(const CglProbing &rhs)
Assignment operator.
CglProbing::deleteCliques
void deleteCliques()
Delete all clique information.
CglProbing::getMaxProbeRoot
int getMaxProbeRoot() const
Get maximum number of unsatisfied variables to look at (root node)