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
CglLandPSimplex.hpp
Go to the documentation of this file.
1 // Copyright (C) 2005-2009 Pierre Bonami and others. All Rights Reserved.
2 // Author: Pierre Bonami
3 // Tepper School of Business
4 // Carnegie Mellon University, Pittsburgh, PA 15213
5 // Date: 21/07/05
6 //
7 // $Id: CglLandPSimplex.hpp 1122 2013-04-06 20:39:53Z stefan $
8 //
9 // This code is licensed under the terms of the Eclipse Public License (EPL).
10 //---------------------------------------------------------------------------
11 #ifndef CglLandPSimplex_H
12 #define CglLandPSimplex_H
13
14 #include <iostream>
15 #include <vector>
16
17 #include "CglConfig.h"
18 #include "CglLandP.hpp"
19
20 #include "OsiSolverInterface.hpp"
21 #include "CoinMessage.hpp"
22 #include "CoinMessageHandler.hpp"
23 #include "CoinWarmStartBasis.hpp"
24 #include "CoinPackedMatrix.hpp"
25
26 #ifdef COIN_HAS_OSICLP
27 #include "OsiClpSolverInterface.hpp"
28 #endif
29
30 #include "CglLandPTabRow.hpp"
31 #include "CglLandPUtils.hpp"
32 #include "CglLandPMessages.hpp"
33
34 //#define APPEND_ROW
35 #define OLD_COMPUTATION
36
37 namespace LAP
38 {
40 class DebugData;
41
42 class CglLandPSimplex
43 {
44 public:
46 CglLandPSimplex(const OsiSolverInterface &si,
47 const CglLandP::CachedData &cached,
48 const CglLandP::Parameters &params,
49 Validator &validator);
51 ~CglLandPSimplex();
53 void cacheUpdate(const CglLandP::CachedData &cached, bool reducedSpace = 0);
55 bool resetSolver(const CoinWarmStartBasis * basis);
57 bool optimize(int var, OsiRowCut & cut, const CglLandP::CachedData &cached, const CglLandP::Parameters & params);
59 bool generateMig(int row, OsiRowCut &cut, const CglLandP::Parameters & params);
60
62 int generateExtraCuts(const CglLandP::CachedData &cached, const CglLandP::Parameters & params);
64 int generateExtraCut(int i, const CglLandP::CachedData & cached,
65 const CglLandP::Parameters& params);
66
67 void genThisBasisMigs(const CglLandP::CachedData &cached,
68 const CglLandP::Parameters & params) ;
69
71 int insertAllExtr(OsiCuts & cs, CoinRelFltEq eq);
72
73 void setLogLevel(int level)
74 {
75 handler_->setLogLevel(level);
76 }
77
78
79 void setSi(OsiSolverInterface *si)
80 {
81 si_ = si;
82 #ifdef COIN_HAS_OSICLP
83 OsiClpSolverInterface * clpSi = dynamic_cast<OsiClpSolverInterface *>(si_);
84 if (clpSi)
85 {
86 clp_ = clpSi;
87 }
88 #endif
89 }
90 void freeSi()
91 {
92 assert(si_ != NULL);
93 delete si_;
94 si_ = NULL;
95 #ifdef COIN_HAS_OSICLP
96 clp_ = NULL;
97 #endif
98 }
99
100 Cuts& extraCuts()
101 {
102 return cuts_;
103 }
104 void loadBasis(const OsiSolverInterface &si,
105 std::vector<int> &M1, std::vector<int> &M2,
106 int k);
107
108
109 int getNumCols() const
110 {
111 return ncols_;
112 }
113
114 int getNumRows() const
115 {
116 return nrows_;
117 }
118
119 const CoinWarmStartBasis * getBasis() const
120 {
121 return basis_;
122 }
123 const int * getNonBasics() const
124 {
125 return nonBasics_;
126 }
127
128 const int * getBasics() const
129 {
130 return basics_;
131 }
132
133 void outPivInfo(int ncuts)
134 {
135 handler_->message(RoundStats, messages_)<<ncuts<<numPivots_
136 <<numSourceRowEntered_
137 <<numIncreased_<<CoinMessageEol;
138 }
139 #ifdef APPEND_ROW
140
141 void append_row(int row_num, bool modularize) ;
143 void update_row(TabRow &row);
144
145 void check_mod_row(TabRow &row);
146 #endif
147 protected:
149 bool changeBasis(int incoming, int leaving, int direction,
150 #ifndef OLD_COMPUTATION
151 bool recompute_source_row,
152 #endif
153 bool modularize);
157 int fastFindCutImprovingPivotRow( int &direction, int &gammaSign, double tolerance, bool flagPositiveRows);
159 int rescanReducedCosts( int &direction, int &gammaSign, double tolerance);
161 int fastFindBestPivotColumn(int direction, int gammaSign,
162 double pivotTol, double rhsTol,
163 bool reducedSpace,
164 bool allowNonImproving,
165 double &bestSigma, bool modularize);
166
174 int findBestPivot(int &leaving, int & direction,
175 const CglLandP::Parameters & params);
176
177
180 double computeCglpObjective(const TabRow & row, bool modularize = false) const;
184 inline double strengthenedIntersectionCutCoef(int i, double alpha_i, double beta) const;
187 inline double newRowCoefficient(int j, double gamma) const;
189 void createIntersectionCut(TabRow & row, OsiRowCut &cut) const;
191 double normalizationFactor(const TabRow & row) const;
193 void scaleCut(OsiRowCut & cut, double factor) const;
195 // void createIntersectionCut(double * row);
197 void createMIG( TabRow & row, OsiRowCut &cut) const;
199 void pullTableauRow(TabRow & row) const;
201 void adjustTableauRow(int var, TabRow & row, int direction);
203 void resetOriginalTableauRow(int var, TabRow & row, int direction);
205 inline double getLoBound(int index) const
206 {
207 return lo_bounds_[original_index_[index]];
208 }
210 inline double getUpBound(int index) const
211 {
212 return up_bounds_[original_index_[index]];
213 }
215 inline double getColsolToCut(int index) const
216 {
217 return colsolToCut_[original_index_[index]];
218 }
219 bool isGtConst(int index) const
220 {
221 return (index >= ncols_ && lo_bounds_[original_index_[index]] < -1e-10 && up_bounds_[original_index_[index]] <= 1e-09);
222 }
224 inline void setColsolToCut(int index, double value)
225 {
226 colsolToCut_[original_index_[index]] = value;
227 }
229 inline CoinWarmStartBasis::Status getStatus(int index) const
230 {
231 if (index < ncols_) return basis_->getStructStatus(index);
232 return basis_->getArtifStatus(index - ncols_);
233 }
235 inline bool isInteger(int index) const
236 {
237 return integers_[original_index_[index]];
238 }
240 void computeWeights(CglLandP::LHSnorm norm, CglLandP::Normalization type,
241 CglLandP::RhsWeightType rhs);
243 double normedCoef(double a, int ii) const
244 {
245 if (norm_weights_.empty())
246 {
247 return a;
248 }
249 else
250 {
251 return a*norm_weights_[ii];
252 }
253 }
255 void printTableau(std::ostream & os);
256
258 void printEverything();
260 void printTableauLateX(std::ostream & os);
261 void printRowLateX(std::ostream & os, int i);
262 void printCutLateX(std::ostream & os, int i);
263
265 void printCglpBasis(std::ostream& os = std::cout);
267 void get_M1_M2_M3(const TabRow & row,
268 std::vector<int> &M1,
269 std::vector<int> &M2,
270 std::vector<int> &M3);
272 void eliminate_slacks(double * vec) const;
273 private:
275 CglLandPSimplex();
277 CglLandPSimplex(const CglLandPSimplex&);
279 CglLandPSimplex& operator=(const CglLandPSimplex&);
280 #ifdef COIN_HAS_OSICLP
281
282 OsiClpSolverInterface * clp_;
283 #endif
284
286 void updateM1_M2_M3(TabRow & row, double tolerance, bool alwaysComputeCheap);
288 void removeRows(int nDelete, const int * rowsIdx);
289
290
291 void compute_p_q_r_s(double gamma, int gammaSign, double &p, double & q, double & r , double &s);
292
293
296
297 TabRow row_k_;
299 TabRow original_row_k_;
301 TabRow row_i_;
302 #ifndef NDBEUG
303 TabRow new_row_;
304 #endif
305
306 CoinPackedVector gammas_;
308 std::vector<double> rWk1_;
310 std::vector<double> rWk2_;
312 std::vector<double> rWk3_;
314 std::vector<double> rWk4_;
316 std::vector<int> rIntWork_;
318 bool * rowFlags_;
320 std::vector<bool> col_in_subspace;
322 bool *colCandidateToLeave_;
324 int * basics_;
326 int * nonBasics_;
328 std::vector<int> M1_;
330 std::vector<int> M2_;
332 std::vector<int> M3_;
334 double sigma_;
336 CoinWarmStartBasis * basis_;
338 double * colsolToCut_;
340 double * colsol_;
342 int ncols_orig_;
344 int nrows_orig_;
346 int ncols_;
348 int nrows_;
349 // for fast access to lower bounds (both cols and rows)
350 std::vector<double> lo_bounds_;
351 // for fast access to upper bounds (both cols and rows)
352 std::vector<double> up_bounds_;
354 bool inDegenerateSequence_;
356 double chosenReducedCostVal_;
358 const bool * integers_;
360 std::vector<int> original_index_;
362 Cuts cuts_;
366
367 OsiSolverInterface * si_;
370 bool own_;
372 Validator & validator_;
374 std::vector<double> norm_weights_;
376 double rhs_weight_;
377
379 int nNegativeRcRows_;
381 bool checkBasis();
382
384 int numPivots_;
386 int numSourceRowEntered_;
388 int numIncreased_;
389
391 CoinMessageHandler * handler_;
393 CoinMessages messages_;
394 #ifndef NDEBUG
395 double bestSigma_;
396 #endif
397
398 protected:
402 double computeCglpRedCost(int direction, int gammaSign, double tau);
404 double computeRedCostConstantsInRow();
406 double computeCglpObjective(double gamma, bool strengthen, TabRow &row);
408 double computeCglpObjective(double gamma, bool strengthen);
411 int findCutImprovingPivotRow( int &direction, int &gammaSign, double tolerance);
413 int findBestPivotColumn(int direction,
414 double pivotTol, bool reducedSpace, bool allowDegeneratePivot,
415 bool modularize);
416 #if 1
417 int plotCGLPobj(int direction, double gammaTolerance,
418 double pivotTol, bool reducedSpace, bool allowDegenerate, bool modularize);
419 #endif
420
422 };
423
424
426 double CglLandPSimplex::strengthenedIntersectionCutCoef(int i, double alpha_i, double beta) const
427 {
428 // double ratio = beta/(1-beta);
429 if ( (!integers_[i]))
430 return intersectionCutCoef(alpha_i, beta);
431 else
432 {
433 double f_i = alpha_i - floor(alpha_i);
434 if (f_i < beta)
435 return f_i*(1- beta);
436 else
437 return (1 - f_i)*beta;//(1-beta);
438 }
439 }
440
443 double
444 CglLandPSimplex::newRowCoefficient(int j, double gamma) const
445 {
446 return row_k_[j] + gamma * row_i_[j];
447 }
448
449 }
450 #endif
LAP::CglLandPSimplex::basis_
CoinWarmStartBasis * basis_
Keep track of basis status.
Definition: CglLandPSimplex.hpp:336
CglLandPUtils.hpp
LAP::CglLandPSimplex::original_row_k_
TabRow original_row_k_
Original version of source row (without modularization).
Definition: CglLandPSimplex.hpp:299
LAP::CglLandPSimplex::insertAllExtr
int insertAllExtr(OsiCuts &cs, CoinRelFltEq eq)
insert all extra cuts in cs.
CglLandP::Normalization
Normalization
Normalization.
Definition: CglLandP.hpp:82
LAP::CglLandPSimplex::CglLandPSimplex
CglLandPSimplex()
No default constructor.
LAP::CglLandPSimplex::nonBasics_
int * nonBasics_
Stores the nonBasicVariables.
Definition: CglLandPSimplex.hpp:326
LAP::CglLandPSimplex::lo_bounds_
std::vector< double > lo_bounds_
Definition: CglLandPSimplex.hpp:350
LAP::CglLandPSimplex::optimize
bool optimize(int var, OsiRowCut &cut, const CglLandP::CachedData &cached, const CglLandP::Parameters &params)
Perfom pivots to find the best cuts.
LAP::CglLandPSimplex::ncols_orig_
int ncols_orig_
cached numcols in original problem
Definition: CglLandPSimplex.hpp:342
LAP::CglLandPSimplex::bestSigma_
double bestSigma_
Definition: CglLandPSimplex.hpp:395
LAP::CglLandPSimplex::colCandidateToLeave_
bool * colCandidateToLeave_
Flag columns which have to be considered for leaving the basis.
Definition: CglLandPSimplex.hpp:322
LAP::CglLandPSimplex::resetSolver
bool resetSolver(const CoinWarmStartBasis *basis)
reset the solver to optimal basis
LAP::CglLandPSimplex::rowFlags_
bool * rowFlags_
Flag rows which we don&#39;t want to try anymore.
Definition: CglLandPSimplex.hpp:318
LAP::CglLandPSimplex::rWk1_
std::vector< double > rWk1_
first work vector in row space.
Definition: CglLandPSimplex.hpp:308
LAP::CglLandPSimplex::printTableau
void printTableau(std::ostream &os)
print the tableau of current basis.
CglLandP::Parameters
Class storing parameters.
Definition: CglLandP.hpp:107
CoinWarmStartBasis::getStructStatus
Status getStructStatus(int i) const
Return the status of the specified structural variable.
Definition: CoinWarmStartBasis.hpp:98
LAP::CglLandPSimplex::M2_
std::vector< int > M2_
Stores the variables which are always in M2 for a given k.
Definition: CglLandPSimplex.hpp:330
LAP::CglLandPSimplex::original_index_
std::vector< int > original_index_
Original index of variable before deletions.
Definition: CglLandPSimplex.hpp:360
LAP::CglLandPSimplex::handler_
CoinMessageHandler * handler_
Message handler.
Definition: CglLandPSimplex.hpp:391
LAP::CglLandPSimplex::setColsolToCut
void setColsolToCut(int index, double value)
Access to value in solution to cut (indexed in reduced problem)
Definition: CglLandPSimplex.hpp:224
LAP::CglLandPSimplex::rWk3_
std::vector< double > rWk3_
third work vector in row space.
Definition: CglLandPSimplex.hpp:312
LAP::CglLandPSimplex::operator=
CglLandPSimplex & operator=(const CglLandPSimplex &)
No assignment operator.
LAP::CglLandPSimplex::inDegenerateSequence_
bool inDegenerateSequence_
Say if we are in a sequence of degenerate pivots.
Definition: CglLandPSimplex.hpp:354
LAP::CglLandPSimplex::normalizationFactor
double normalizationFactor(const TabRow &row) const
Compute the normalization factor of the cut.
LAP::CglLandPSimplex::rhs_weight_
double rhs_weight_
Weight for rhs of normalization constraint.*/.
Definition: CglLandPSimplex.hpp:376
LAP::CglLandPSimplex::computeWeights
void computeWeights(CglLandP::LHSnorm norm, CglLandP::Normalization type, CglLandP::RhsWeightType rhs)
Compute normalization weights.
LAP::CglLandPSimplex::nrows_orig_
int nrows_orig_
cached numrows in original problem
Definition: CglLandPSimplex.hpp:344
LAP::CglLandPSimplex::getStatus
CoinWarmStartBasis::Status getStatus(int index) const
Get the basic status of a variable (structural or slack).
Definition: CglLandPSimplex.hpp:229
OsiCuts
Collections of row cuts and column cuts.
Definition: OsiCuts.hpp:19
LAP::CglLandPSimplex::sigma_
double sigma_
stores the cglp value of the normalized cut obtained from row k_
Definition: CglLandPSimplex.hpp:334
OsiClpSolverInterface
Clp Solver Interface.
Definition: OsiClpSolverInterface.hpp:37
LAP::CglLandPSimplex::row_i_
TabRow row_i_
Row of leaving candidate.
Definition: CglLandPSimplex.hpp:301
LAP::CglLandPSimplex::cacheUpdate
void cacheUpdate(const CglLandP::CachedData &cached, bool reducedSpace=0)
Update cached information in case of basis change in a round.
LAP::TabRow
Definition: CglLandPTabRow.hpp:21
LAP::CglLandPSimplex::colsol_
double * colsol_
Pointer to the current basic solution.
Definition: CglLandPSimplex.hpp:340
LAP::CglLandPSimplex::M1_
std::vector< int > M1_
Stores the variables which are always in M1 for a given k.
Definition: CglLandPSimplex.hpp:328
LAP::CglLandPSimplex::pullTableauRow
void pullTableauRow(TabRow &row) const
Get the row i of the tableau.
CoinWarmStartBasis
The default COIN simplex (basis-oriented) warm start class.
Definition: CoinWarmStartBasis.hpp:40
LAP::CglLandPSimplex::rescanReducedCosts
int rescanReducedCosts(int &direction, int &gammaSign, double tolerance)
Rescan reduced costs tables.
LAP::CglLandPSimplex::rWk4_
std::vector< double > rWk4_
fourth work vector in row space.
Definition: CglLandPSimplex.hpp:314
LAP::CglLandPSimplex::generateExtraCut
int generateExtraCut(int i, const CglLandP::CachedData &cached, const CglLandP::Parameters &params)
Generate a constrainte for a row of the tableau different from the source row.
LAP::CglLandPSimplex::genThisBasisMigs
void genThisBasisMigs(const CglLandP::CachedData &cached, const CglLandP::Parameters &params)
LAP::CglLandPSimplex::outPivInfo
void outPivInfo(int ncuts)
Definition: CglLandPSimplex.hpp:133
CglLandP::RhsWeightType
RhsWeightType
RHS weight in normalization.
Definition: CglLandP.hpp:100
LAP::CglLandPSimplex::nNegativeRcRows_
int nNegativeRcRows_
number of rows with a &lt;0 rc in current iteration
Definition: CglLandPSimplex.hpp:379
CoinMessageHandler
Base class for message handling.
Definition: CoinMessageHandler.hpp:345
LAP::CglLandPSimplex::integers_
const bool * integers_
pointer to array of integer info for both structural and slacks
Definition: CglLandPSimplex.hpp:358
CglConfig.h
LAP::CglLandPSimplex::own_
bool own_
Own the data or not?
Definition: CglLandPSimplex.hpp:370
LAP::CglLandPSimplex::computeRedCostConstantsInRow
double computeRedCostConstantsInRow()
Compute the value of sigma and thau (which are constants for a row i as defined in Mike Perregaard th...
LAP::CglLandPSimplex::changeBasis
bool changeBasis(int incoming, int leaving, int direction, bool modularize)
Perform a change in the basis (direction is 1 if leaving variable is going to ub, 0 otherwise) ...
LAP::CglLandPSimplex::numPivots_
int numPivots_
Record the number of pivots.
Definition: CglLandPSimplex.hpp:384
OsiSolverInterface
Abstract Base Class for describing an interface to a solver.
Definition: OsiSolverInterface.hpp:61
LAP::CglLandPSimplex::M3_
std::vector< int > M3_
Stores the variables which could be either in M1 or M2.
Definition: CglLandPSimplex.hpp:332
LAP::CglLandPSimplex::normedCoef
double normedCoef(double a, int ii) const
Evenutaly multiply a by w if normed_weights_ is not empty.
Definition: CglLandPSimplex.hpp:243
LAP::CglLandPSimplex::createIntersectionCut
void createIntersectionCut(TabRow &row, OsiRowCut &cut) const
Create the intersection cut of row k.
LAP::CglLandPSimplex::validator_
Validator & validator_
A pointer to a cut validator.
Definition: CglLandPSimplex.hpp:372
OsiClpSolverInterface.hpp
LAP::CglLandPSimplex::getUpBound
double getUpBound(int index) const
Get upper bound for variable or constraint.
Definition: CglLandPSimplex.hpp:210
LAP::CglLandPSimplex::strengthenedIntersectionCutCoef
double strengthenedIntersectionCutCoef(int i, double alpha_i, double beta) const
return the coefficients of the strengthened intersection cut takes one extra argument seens needs to ...
Definition: CglLandPSimplex.hpp:426
LAP::CglLandPSimplex::printEverything
void printEverything()
Print everything .
LAP::CglLandPSimplex::fastFindCutImprovingPivotRow
int fastFindCutImprovingPivotRow(int &direction, int &gammaSign, double tolerance, bool flagPositiveRows)
Find a row which can be used to perform an improving pivot the fast way (i.e., find the leaving varia...
CglLandP::CachedData
Some informations that will be changed by the pivots and that we want to keep.
Definition: CglLandP.hpp:241
LAP::CglLandPSimplex::chosenReducedCostVal_
double chosenReducedCostVal_
Value for the reduced cost chosen for pivoting.
Definition: CglLandPSimplex.hpp:356
OLD_COMPUTATION
#define OLD_COMPUTATION
Definition: CglLandPSimplex.hpp:35
LAP::RoundStats
Definition: CglLandPMessages.hpp:45
LAP::CglLandPSimplex::get_M1_M2_M3
void get_M1_M2_M3(const TabRow &row, std::vector< int > &M1, std::vector< int > &M2, std::vector< int > &M3)
Put variables in M1 M2 and M3 according to their sign.
CglLandPTabRow.hpp
CoinMessageEol
Definition: CoinMessageHandler.hpp:236
CoinMessageHandler.hpp
This is a first attempt at a message handler.
CoinRelFltEq
Equality to a scaled tolerance.
Definition: CoinFloatEqual.hpp:120
LAP::CglLandPSimplex::rIntWork_
std::vector< int > rIntWork_
integer valued work vector on the rows
Definition: CglLandPSimplex.hpp:316
LAP::CglLandPSimplex::gammas_
CoinPackedVector gammas_
vector to sort the gammas
Definition: CglLandPSimplex.hpp:306
LAP::CglLandPSimplex
Definition: CglLandPSimplex.hpp:42
CoinWarmStartBasis::getArtifStatus
Status getArtifStatus(int i) const
Return the status of the specified artificial variable.
Definition: CoinWarmStartBasis.hpp:132
LAP::CglLandPSimplex::eliminate_slacks
void eliminate_slacks(double *vec) const
Put a vector in structural sapce.
LAP::CglLandPSimplex::findBestPivot
int findBestPivot(int &leaving, int &direction, const CglLandP::Parameters &params)
Find incoming and leaving variables which lead to the most violated adjacent normalized lift-and-proj...
LAP::CglLandPSimplex::findBestPivotColumn
int findBestPivotColumn(int direction, double pivotTol, bool reducedSpace, bool allowDegeneratePivot, bool modularize)
Find the column which leads to the best cut (i.e., find incoming variable).
CglLandP::LHSnorm
LHSnorm
Definition: CglLandP.hpp:90
LAP::CglLandPSimplex::colsolToCut_
double * colsolToCut_
Pointer to the solution to cut (need to be modified after each pivot because we are only considering ...
Definition: CglLandPSimplex.hpp:338
LAP::CglLandPSimplex::fastFindBestPivotColumn
int fastFindBestPivotColumn(int direction, int gammaSign, double pivotTol, double rhsTol, bool reducedSpace, bool allowNonImproving, double &bestSigma, bool modularize)
Find the column which leads to the best cut (i.e., find incoming variable).
LAP::CglLandPSimplex::getNumCols
int getNumCols() const
Definition: CglLandPSimplex.hpp:109
LAP::CglLandPSimplex::~CglLandPSimplex
~CglLandPSimplex()
Destructor.
cut
Definition: Cgl012cut.hpp:153
LAP::CglLandPSimplex::rWk2_
std::vector< double > rWk2_
scond work vector in row space.
Definition: CglLandPSimplex.hpp:310
LAP::intersectionCutCoef
double intersectionCutCoef(double alpha_i, double beta)
return the coefficients of the intersection cut
Definition: CglLandPUtils.hpp:35
LAP::CglLandPSimplex::checkBasis
bool checkBasis()
Check that the basis is correct.
CglLandPMessages.hpp
CglLandP.hpp
LAP::CglLandPSimplex::cuts_
Cuts cuts_
Stores extra cuts which are generated along the procedure.
Definition: CglLandPSimplex.hpp:362
LAP::CglLandPSimplex::basics_
int * basics_
Store the basics variable.
Definition: CglLandPSimplex.hpp:324
LAP::CglLandPSimplex::norm_weights_
std::vector< double > norm_weights_
Weights for the normalization constraint.
Definition: CglLandPSimplex.hpp:374
LAP::CglLandPSimplex::new_row_
TabRow new_row_
Definition: CglLandPSimplex.hpp:303
LAP::CglLandPSimplex::getLoBound
double getLoBound(int index) const
Get lower bound for variable or constraint.
Definition: CglLandPSimplex.hpp:205
LAP::CglLandPSimplex::printTableauLateX
void printTableauLateX(std::ostream &os)
print the tableau of current basis.
OsiRowCut
Row Cut Class.
Definition: OsiRowCut.hpp:29
LAP::CglLandPSimplex::getBasics
const int * getBasics() const
Definition: CglLandPSimplex.hpp:128
LAP::CglLandPSimplex::row_k_
TabRow row_k_
Source row for cut.
Definition: CglLandPSimplex.hpp:297
LAP::CglLandPSimplex::freeSi
void freeSi()
Definition: CglLandPSimplex.hpp:90
LAP::CglLandPSimplex::generateExtraCuts
int generateExtraCuts(const CglLandP::CachedData &cached, const CglLandP::Parameters &params)
Find extra constraints in current tableau.
LAP::CglLandPSimplex::isGtConst
bool isGtConst(int index) const
Definition: CglLandPSimplex.hpp:219
LAP::CglLandPSimplex::setSi
void setSi(OsiSolverInterface *si)
Definition: CglLandPSimplex.hpp:79
LAP::CglLandPSimplex::getBasis
const CoinWarmStartBasis * getBasis() const
Definition: CglLandPSimplex.hpp:119
CoinMessageHandler::message
CoinMessageHandler & message(int messageNumber, const CoinMessages &messages)
Start a message.
LAP::CglLandPSimplex::ncols_
int ncols_
cached number of columns in reduced size problem
Definition: CglLandPSimplex.hpp:346
LAP::CglLandPSimplex::compute_p_q_r_s
void compute_p_q_r_s(double gamma, int gammaSign, double &p, double &q, double &r, double &s)
OsiSolverInterface.hpp
LAP::CglLandPSimplex::removeRows
void removeRows(int nDelete, const int *rowsIdx)
Remove rows from current tableau.
LAP::CglLandPSimplex::messages_
CoinMessages messages_
Messages.
Definition: CglLandPSimplex.hpp:393
LAP::CglLandPSimplex::loadBasis
void loadBasis(const OsiSolverInterface &si, std::vector< int > &M1, std::vector< int > &M2, int k)
CoinWarmStartBasis::Status
Status
Enum for status of variables.
Definition: CoinWarmStartBasis.hpp:56
LAP::CglLandPSimplex::setLogLevel
void setLogLevel(int level)
Definition: CglLandPSimplex.hpp:73
LAP::CglLandPSimplex::si_
OsiSolverInterface * si_
Pointer to the solver interface.
Definition: CglLandPSimplex.hpp:367
LAP::CglLandPSimplex::findCutImprovingPivotRow
int findCutImprovingPivotRow(int &direction, int &gammaSign, double tolerance)
Find a row which can be used to perform an improving pivot return index of the cut or -1 if none exis...
LAP::CglLandPSimplex::up_bounds_
std::vector< double > up_bounds_
Definition: CglLandPSimplex.hpp:352
LAP::CglLandPSimplex::col_in_subspace
std::vector< bool > col_in_subspace
Flag columns which are in the subspace (usualy remove nonbasic structurals in subspace) ...
Definition: CglLandPSimplex.hpp:320
LAP::Cuts
To store extra cuts generated by columns from which they origin.
Definition: CglLandPUtils.hpp:59
LAP::CglLandPSimplex::scaleCut
void scaleCut(OsiRowCut &cut, double factor) const
Scale the cut by factor.
CoinWarmStartBasis.hpp
LAP::CglLandPSimplex::printCglpBasis
void printCglpBasis(std::ostream &os=std::cout)
Print CGLP basis corresponding to current tableau and source row.
CoinMessage.hpp
This file contains the enum for the standard set of Coin messages and a class definition whose sole p...
LAP::CglLandPSimplex::computeCglpRedCost
double computeCglpRedCost(int direction, int gammaSign, double tau)
Compute the reduced cost of Cglp.
LAP::CglLandPSimplex::numSourceRowEntered_
int numSourceRowEntered_
Record the number of times the source row entered the basis.
Definition: CglLandPSimplex.hpp:386
LAP::CglLandPSimplex::numIncreased_
int numIncreased_
Record the number of times that sigma increased.
Definition: CglLandPSimplex.hpp:388
LAP::CglLandPSimplex::getNonBasics
const int * getNonBasics() const
Definition: CglLandPSimplex.hpp:123
LAP::CglLandPSimplex::getNumRows
int getNumRows() const
Definition: CglLandPSimplex.hpp:114
LAP::CglLandPSimplex::extraCuts
Cuts & extraCuts()
Definition: CglLandPSimplex.hpp:100
LAP::CglLandPSimplex::getColsolToCut
double getColsolToCut(int index) const
Access to value in solution to cut (indexed in reduced problem)
Definition: CglLandPSimplex.hpp:215
LAP::CglLandPSimplex::plotCGLPobj
int plotCGLPobj(int direction, double gammaTolerance, double pivotTol, bool reducedSpace, bool allowDegenerate, bool modularize)
LAP::CglLandPSimplex::adjustTableauRow
void adjustTableauRow(int var, TabRow &row, int direction)
Adjust the row of the tableau to reflect leaving variable direction.
CoinPackedVector
Sparse Vector.
Definition: CoinPackedVector.hpp:123
LAP::CglLandPSimplex::resetOriginalTableauRow
void resetOriginalTableauRow(int var, TabRow &row, int direction)
reset the tableau row after a call to adjustTableauRow
LAP::CglLandPSimplex::printRowLateX
void printRowLateX(std::ostream &os, int i)
LAP::CglLandPSimplex::generateMig
bool generateMig(int row, OsiRowCut &cut, const CglLandP::Parameters &params)
Find Gomory cut (i.e.
LAP::CglLandPSimplex::isInteger
bool isInteger(int index) const
Say if variable index by i in current tableau is integer.
Definition: CglLandPSimplex.hpp:235
LAP::CglLandPSimplex::computeCglpObjective
double computeCglpObjective(const TabRow &row, bool modularize=false) const
Compute the objective value of the Cglp for given row and rhs (if strengthening shall be applied row ...
LAP::Validator
Class to validate or reject a cut.
Definition: CglLandPValidator.hpp:26
LAP::CglLandPSimplex::createMIG
void createMIG(TabRow &row, OsiRowCut &cut) const
Create strenghtened row.
CoinMessages
Class to hold and manipulate an array of massaged messages.
Definition: CoinMessageHandler.hpp:140
LAP::CglLandPSimplex::nrows_
int nrows_
Cached number of rows in reduced size problem.
Definition: CglLandPSimplex.hpp:348
CoinPackedMatrix.hpp
CoinMessageHandler::setLogLevel
void setLogLevel(int value)
Set current log (detail) level.
LAP::CglLandPSimplex::printCutLateX
void printCutLateX(std::ostream &os, int i)
LAP::CglLandPSimplex::newRowCoefficient
double newRowCoefficient(int j, double gamma) const
return the coefficient of the new row (combining row_k + gamma row_i).
Definition: CglLandPSimplex.hpp:444
LAP::CglLandPSimplex::updateM1_M2_M3
void updateM1_M2_M3(TabRow &row, double tolerance, bool alwaysComputeCheap)
Update values in M1 M2 and M3 before an iteration.