Cbc  2.9.9
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
CglFlowCover.hpp
Go to the documentation of this file.
1 // $Id: CglFlowCover.hpp 1369 2017-03-30 08:21:03Z forrest $
2 //-----------------------------------------------------------------------------
3 // name: Cgl Lifted Simple Generalized Flow Cover Cut Generator
4 // author: Yan Xu email: yan.xu@sas.com
5 // Jeff Linderoth email: jtl3@lehigh.edu
6 // Martin Savelsberg email: martin.savelsbergh@isye.gatech.edu
7 // date: 05/01/2003
8 // comments: please scan this file for '???' and read the comments
9 //-----------------------------------------------------------------------------
10 // Copyright (C) 2003, Yan Xu, Jeff Linderoth, Martin Savelsberg and others.
11 // All Rights Reserved.
12 // This code is published under the Eclipse Public License.
13 
14 #ifndef CglFlowCover_H
15 #define CglFlowCover_H
16 
17 #include <iostream>
18 
19 #include "CoinError.hpp"
20 
21 #include "CglCutGenerator.hpp"
22 
23 //=============================================================================
24 
25 //=============================================================================
26 
37 };
38 
40 };
41 
63 };
64 
97 };
98 
99 //=============================================================================
100 
103 {
104 protected:
105  int varInd_;
106  double upper_;
108 public:
109  CglFlowVUB() : varInd_(-1), upper_(-1) {}
110 
111  CglFlowVUB(const CglFlowVUB& source) {
112  varInd_= source.varInd_;
113  upper_ = source.upper_;
114  }
115 
117  if (this == &rhs)
118  return *this;
119  varInd_= rhs.varInd_;
120  upper_ = rhs.upper_;
121  return *this;
122  }
123 
128  inline int getVar() const { return varInd_; }
129  inline double getVal() const { return upper_; }
130  inline void setVar(const int v) { varInd_ = v; }
131  inline void setVal(const double v) { upper_ = v; }
133 };
134 
135 //=============================================================================
136 
139 
141 std::ostream& operator<<( std::ostream& os, const CglFlowVUB &v );
142 
143 //=============================================================================
144 
149  friend void CglFlowCoverUnitTest(const OsiSolverInterface * siP,
150  const std::string mpdDir );
151 
152 public:
153 
163  void flowPreprocess(const OsiSolverInterface& si);
164 
171  virtual void generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
172  const CglTreeInfo info = CglTreeInfo());
174 
178  inline int getMaxNumCuts() const { return maxNumCuts_; }
179  inline void setMaxNumCuts(int mc) { maxNumCuts_ = mc; }
181 
185  inline int getNumFlowCuts() { return numFlowCuts_; }
186  inline void setNumFlowCuts(int fc) { numFlowCuts_ = fc; }
187  inline void incNumFlowCuts(int fc = 1) { numFlowCuts_ += fc; }
189 
190  //-------------------------------------------------------------------------
193  CglFlowCover ();
195 
197  CglFlowCover (
198  const CglFlowCover &);
199 
201  virtual CglCutGenerator * clone() const;
202 
204  CglFlowCover &
205  operator=(
206  const CglFlowCover& rhs);
207 
209  virtual
210  ~CglFlowCover ();
212  virtual std::string generateCpp( FILE * fp);
214 
215 private:
216  //-------------------------------------------------------------------------
217  // Private member functions
218 
222  bool generateOneFlowCut( const OsiSolverInterface & si,
223  const int rowLen,
224  int* ind,
225  double* coef,
226  char sense,
227  double rhs,
228  OsiRowCut& flowCut,
229  double& violation );
230 
231 
233  void flipRow(int rowLen, double* coef, double& rhs) const;
234 
236  void flipRow(int rowLen, double* coef, char& sen, double& rhs) const;
237 
240  int rowLen, int* ind,
241  double* coef, char sen,
242  double rhs) const;
244  void liftMinus(double &movement, /* Output */
245  int t,
246  int r,
247  double z,
248  double dPrimePrime,
249  double lambda,
250  double ml,
251  double *M,
252  double *rho) const;
253 
254  bool liftPlus(double &alpha,
255  double &beta,
256  int r,
257  double m_j,
258  double lambda,
259  double y_j,
260  double x_j,
261  double dPrimePrime,
262  double *M) const;
263 
264 
265  //-------------------------------------------------------------------------
266  //**@name Query and set the row type of a givne row. */
268  inline const CglFlowRowType* getRowTypes() const
269  { return rowTypes_; }
270  inline CglFlowRowType getRowType(const int i) const
271  { return rowTypes_[i]; }
273  inline void setRowTypes(CglFlowRowType* rt)
274  { rowTypes_ = rt; rt = 0; }
275  inline void setRowTypes(const CglFlowRowType rt, const int i) {
276  if (rowTypes_ != 0)
277  rowTypes_[i] = rt;
278  else {
279  std::cout << "ERROR: Should allocate memory for rowType_ before "
280  << "using it " << std::endl;
281  throw CoinError("Forgot to allocate memory for rowType_",
282  "setRowType", "CglFlowCover");
283  }
284  }
286 
287  //-------------------------------------------------------------------------
288  //**@name Query and set vubs. */
290  inline const CglFlowVUB* getVubs() const { return vubs_; }
291  inline const CglFlowVUB& getVubs(int i) const { return vubs_[i]; }
293  inline void setVubs(CglFlowVUB* vubs) { vubs_ = vubs; vubs = 0; }
294  inline void setVubs(const CglFlowVUB& vub, int i) {
295  if (vubs_ != 0)
296  vubs_[i] = vub;
297  else {
298  std::cout << "ERROR: Should allocate memory for vubs_ before "
299  << "using it " << std::endl;
300  throw CoinError("Forgot to allocate memory for vubs_", "setVubs",
301  "CglFlowCover");
302  }
303  }
304  inline void printVubs(std::ostream& os) const {
305  for (int i = 0; i < numCols_; ++i) {
306  os << "ix: " << i << ", " << vubs_[i];
307  }
308  }
310 
311  //-------------------------------------------------------------------------
312  //**@name Query and set vlbs. */
314  inline const CglFlowVLB* getVlbs() const { return vlbs_; }
315  inline const CglFlowVLB& getVlbs(int i) const { return vlbs_[i]; }
317  inline void setVlbs(CglFlowVLB* vlbs) { vlbs_ = vlbs; vlbs = 0; }
318  inline void setVlbs(const CglFlowVLB& vlb, int i) {
319  if (vlbs_ != 0)
320  vlbs_[i] = vlb;
321  else {
322  std::cout << "ERROR: Should allocate memory for vlbs_ before "
323  << "using it " << std::endl;
324  throw CoinError("Forgot to allocate memory for vlbs_", "setVlbs",
325  "CglFlowCover");
326  }
327  }
329 
330 private:
331  //------------------------------------------------------------------------
332  // Private member data
333 
337  double EPSILON_;
341  double INFTY_;
343  double TOLERANCE_;
347  int numRows_;
349  int numCols_;
360 };
361 
362 //#############################################################################
369  const std::string mpdDir );
370 
371 #endif
The column is in cover now.
Error Class thrown by an exception.
Definition: CoinError.hpp:42
The column is a positive binary variable.
CglFlowVUB CglFlowVLB
Variable lower bound class, which is the same as vub.
int getMaxNumCuts() const
void setVlbs(CglFlowVLB *vlbs)
Set CglFlowVLBs,take over the ownership.
void setVlbs(const CglFlowVLB &vlb, int i)
void printVubs(std::ostream &os) const
void liftMinus(double &movement, int t, int r, double z, double dPrimePrime, double lambda, double ml, double *M, double *rho) const
Lift functions.
The column is in L-.
double EPSILON_
Tolerance used for numerical purpose.
Information about where the cut generator is invoked from.
Definition: CglTreeInfo.hpp:15
Collections of row cuts and column cuts.
Definition: OsiCuts.hpp:19
CglFlowColCut
This enumerative constant describes the various stati of vars in a cut or not.
const CglFlowRowType * getRowTypes() const
void incNumFlowCuts(int fc=1)
CglFlowRowType getRowType(const int i) const
CglFlowCover & operator=(const CglFlowCover &rhs)
Assignment operator.
double TOLERANCE_
If violation of a cut is greater that this number, the cut is useful.
bool generateOneFlowCut(const OsiSolverInterface &si, const int rowLen, int *ind, double *coef, char sense, double rhs, OsiRowCut &flowCut, double &violation)
Based a given row, a LP solution and other model data, this function tries to generate a violated lif...
void flipRow(int rowLen, double *coef, double &rhs) const
Transform a row from &quot;&gt;=&quot; to &quot;&lt;=&quot;, and vice versa.
int maxNumCuts_
The maximum number of flow cuts to be generated.
bool doneInitPre_
Indicate whether initial flow preprecessing has been done.
Abstract Base Class for describing an interface to a solver.
The column is a positive continous variable.
void flowPreprocess(const OsiSolverInterface &si)
Do the following tasks:
void setVar(const int v)
All variables are binary.
Rows can not be classfied into other types and the row sense is &#39;E&#39;.
double INFTY_
Very large number.
After the row is flipped to &#39;L&#39;, the row has exactly two variables: one is negative binary and the ot...
The row sense is &#39;E&#39;, the row has exactly two variables: one is binary and the other is a continous...
void setRowTypes(CglFlowRowType *rt)
Set rowtypes, take over the ownership.
The column is decided to be in L-.
CglFlowVUB(const CglFlowVUB &source)
The column is in L–.
The column(variable) is a negative binary variable.
The column is a negative continous variable.
CglFlowVUB * vubs_
The array of CglFlowVUBs.
Cut Generator Base Class.
double getVal() const
The row type of this row is NOT defined yet.
Lifed Simple Generalized Flow Cover Cut Generator Class.
void setRowTypes(const CglFlowRowType rt, const int i)
const CglFlowVLB & getVlbs(int i) const
int UNDEFINED_
The variable upper bound of a flow is not indentified yet.
The column is NOT in cover.
void setVubs(const CglFlowVUB &vub, int i)
CglFlowVLB * vlbs_
The array of CglFlowVLBs.
int numFlowCuts_
The number flow cuts found.
Rows can not be classfied into other types and the row sense is NOT &#39;E&#39;.
This enumerative constant describes the various stati of vars in determining the cover.
int getNumFlowCuts()
Row Cut Class.
Definition: OsiRowCut.hpp:29
CglFlowColStatus
CglFlowRowType determineOneRowType(const OsiSolverInterface &si, int rowLen, int *ind, double *coef, char sen, double rhs) const
Determine the type of a given row.
CglFlowColType
This enumerative constant describes the various col types.
CglFlowVUB()
The Value of the associated upper bound.
const CglFlowVLB * getVlbs() const
The column is a secondary candidate.
void CglFlowCoverUnitTest(const OsiSolverInterface *siP, const std::string mpdDir)
A function that tests the methods in the CglFlowCover class.
After the row is flipped to &#39;L&#39;, the row has exactlytwo variables: one is positive binary and the oth...
void setVal(const double v)
double upper_
The index of the associated 0-1 variable.
void setMaxNumCuts(int mc)
virtual std::string generateCpp(FILE *fp)
Create C++ lines to get to current state.
virtual void generateCuts(const OsiSolverInterface &si, OsiCuts &cs, const CglTreeInfo info=CglTreeInfo())
Generate Lifed Simple Generalized flow cover cuts for the model data contained in si...
const CglFlowVUB & getVubs(int i) const
CglFlowRowType
This enumerative constant describes the various row types.
bool liftPlus(double &alpha, double &beta, int r, double m_j, double lambda, double y_j, double x_j, double dPrimePrime, double *M) const
CglFlowCover()
Default constructor.
friend void CglFlowCoverUnitTest(const OsiSolverInterface *siP, const std::string mpdDir)
A function that tests the methods in the CglFlowCover class.
All variables are NOT binary and the row sense is NOT &#39;E&#39;.
int numCols_
The number columns of the problem.
int getVar() const
virtual CglCutGenerator * clone() const
Clone.
void setVubs(CglFlowVUB *vubs)
Set CglFlowVUBs,take over the ownership.
CglFlowRowType * rowTypes_
CglFlowRowType of the rows in model.
CglFlowVUB & operator=(const CglFlowVUB &rhs)
The row has one binary and 2 or more other types of variables and the row sense is &#39;E&#39;...
int numRows_
The number rows of the problem.
std::ostream & operator<<(std::ostream &s, const CoinParam &param)
A stream output function for a CoinParam object.
All variables are NOT binary and the row sense is &#39;E&#39;.
The column is decided to be in cover.
virtual ~CglFlowCover()
Destructor.
bool firstProcess_
First time preprocessing.
Variable upper bound class.
The row has one binary and 2 or more other types of variables and the row sense is NOT &#39;E&#39;...
void setNumFlowCuts(int fc)
const CglFlowVUB * getVubs() const