CglProbing Class Reference

#include <CglProbing.hpp>

Inheritance diagram for CglProbing:

List of all members.

Public Member Functions
Generate Cuts
virtual void	generateCuts (const OsiSolverInterface &si, OsiCuts &cs) const
int	generateCutsAndModify (const OsiSolverInterface &si, OsiCuts &cs)
snapshot
void	snapshot (const OsiSolverInterface &si, char *possible=NULL)
deleteSnapshot
void	deleteSnapshot ()
	Deletes snapshot.
Get tighter column bounds
const double *	tightLower () const
	Lower.
const double *	tightUpper () const
	Upper.
Get possible freed up row bounds - only valid after mode==3
const double *	relaxedRowLower () const
	Lower.
const double *	relaxedRowUpper () const
	Upper.
Change mode
void	setMode (int mode)
	Set.
int	getMode () const
	Get.
Change maxima
void	setMaxPass (int value)
	Set maximum number of passes per node.
int	getMaxPass () const
	Get maximum number of passes per node.
void	setMaxProbe (int value)
	Set maximum number of unsatisfied variables to look at.
int	getMaxProbe () const
	Get maximum number of unsatisfied variables to look at.
void	setMaxLook (int value)
	Set maximum number of variables to look at in one probe.
int	getMaxLook () const
	Get maximum number of variables to look at in one probe.
Stop or restart row cuts (otherwise just fixing from probing)
void	setRowCuts (int type)
int	rowCuts () const
	Get.
Whether use objective as constraint
void	setUsingObjective (bool yesNo)
	Set.
int	getUsingObjective () const
	Get.
Constructors and destructors
	CglProbing ()
	Default constructor.
	CglProbing (const CglProbing &)
	Copy constructor.
CglProbing &	operator= (const CglProbing &rhs)
	Assignment operator.
virtual	~CglProbing ()
	Destructor.
virtual void	refreshSolver (OsiSolverInterface *solver)
	This can be used to refresh any inforamtion.
Private Member Functions
probe
int	probe (const OsiSolverInterface &si, const OsiRowCutDebugger *debugger, OsiCuts &cs, double *colLower, double *colUpper, CoinPackedMatrix *rowCopy, double *rowLower, double *rowUpper, char *intVar, double *minR, double *maxR, int *markR, int *look, int nlook) const
	Does probing and adding cuts.
int	gutsOfGenerateCuts (const OsiSolverInterface &si, OsiCuts &cs, double *rowLower, double *rowUpper, double *colLower, double *colUpper) const
Private Attributes
Private member data
CoinPackedMatrix *	rowCopy_
	Row copy.
double *	rowLower_
	Lower bounds on rows.
double *	rowUpper_
	Upper bounds on rows.
double *	colLower_
	Lower bounds on columns.
double *	colUpper_
	Upper bounds on columns.
int	numberRows_
	Number of rows in snapshot (0 if no snapshot).
int	numberColumns_
	Number of columns in snapshot (must == current).
double	primalTolerance_
	Tolerance to see if infeasible.
int	mode_
	Mode - 0 lazy using snapshot, 1 just unsatisfied, 2 all.
int	rowCuts_
int	maxPass_
	Maximum number of passes to do in probing.
int	maxProbe_
	Maximum number of unsatisfied variables to probe.
int	maxStack_
	Maximum number of variables to look at in one probe.
bool	usingObjective_
	Whether to include objective as constraint.
int	numberIntegers_
	Number of integer variables.
disaggregation *	cutVector_
Friends
void	CglProbingUnitTest (const OsiSolverInterface *siP, const std::string mpdDir)

---

Detailed Description

Probing Cut Generator Class

Definition at line 11 of file CglProbing.hpp.

---

Member Function Documentation

void CglProbing::generateCuts (  const OsiSolverInterface &  si, OsiCuts &  cs )  const [virtual]

Generate probing/disaggregation cuts for the model of the solver interface, si. This is a simplification of probing ideas put into OSL about ten years ago. The only known documentation is a copy of a talk handout - we think Robin Lougee-Heimer has a copy! For selected integer variables (e.g. unsatisfied ones) the effect of setting them up or down is investigated. Setting a variable up may in turn set other variables (continuous as well as integer). There are various possible results: 1) It is shown that problem is infeasible (this may also be because objective function or reduced costs show worse than best solution). If the other way is feasible we can generate a column cut (and continue probing), if not feasible we can say problem infeasible. 2) If both ways are feasible, it can happen that x to 0 implies y to 1 and x to 1 implies y to 1 (again a column cut). More common is that x to 0 implies y to 1 and x to 1 implies y to 0 so we could substitute for y which might lead later to more powerful cuts. This is not done in this code as there is no mechanism for returning information. 3) When x to 1 a constraint went slack by c. We can tighten the constraint ax + .... <= b (where a may be zero) to (a+c)x + .... <= b. If this cut is violated then it is generated. 4) Similarly we can generate implied disaggregation cuts Note - differences to cuts in OSL. a) OSL had structures intended to make this faster. b) The "chaining" in 2) was done c) Row cuts modified original constraint rather than adding cut b) This code can cope with general integer variables. Insert the generated cuts into OsiCut, cs. If a "snapshot" of a matrix exists then this will be used. Presumably this will give global cuts and will be faster. No check is done to see if cuts will be global. Otherwise use current matrix. Both row cuts and column cuts may be returned The mode options are: 0) Only unsatisfied integer variables will be looked at. If no information exists for that variable then probing will be done so as a by-product you "may" get a fixing or infeasibility. This will be fast and is only available if a snapshot exists (otherwise as 1). The bounds in the snapshot are the ones used. 1) Look at unsatisfied integer variables, using current bounds. Probing will be done on all looked at. 2) Look at all integer variables, using current bounds. Probing will be done on all If generateCutsAndModify is used then new relaxed row bounds and tightened coliumn bounds are generated Returns number of infeasibilities Implements CglCutGenerator. Definition at line 369 of file CglProbing.cpp. References gutsOfGenerateCuts(). { #ifdef CGL_DEBUG const OsiRowCutDebugger * debugger = si.getRowCutDebugger(); if (debugger&&debugger->onOptimalPath(si)) { printf("On optimal path %d\n",nPath); nPath++; int nCols=si.getNumCols(); int i; const double * solution = si.getColSolution(); const double * lower = si.getColLower(); const double * upper = si.getColUpper(); const double * optimal = debugger->optimalSolution(); const double * objective = si.getObjCoefficients(); double objval1=0.0,objval2=0.0; for (i=0;i<nCols;i++) { printf("%d %g %g %g %g\n",i,lower[i],solution[i],upper[i],optimal[i]); objval1 += solution[i]*objective[i]; objval2 += optimal[i]*objective[i]; assert(optimal[i]>=lower[i]&&optimal[i]<=upper[i]); } printf("current obj %g, integer %g\n",objval1,objval2); } #endif int nRows=si.getNumRows(); double * rowLower = new double[nRows+1]; double * rowUpper = new double[nRows+1]; int nCols=si.getNumCols(); double * colLower = new double[nCols]; double * colUpper = new double[nCols]; int ninfeas=gutsOfGenerateCuts(si,cs,rowLower,rowUpper,colLower,colUpper); if (ninfeas) { // generate infeasible cut and return OsiRowCut rc; rc.setLb(DBL_MAX); rc.setUb(0.0); cs.insert(rc); #ifdef CGL_DEBUG const OsiRowCutDebugger * debugger = si.getRowCutDebugger(); if (debugger&&debugger->onOptimalPath(si)) assert(!debugger->invalidCut(rc)); #endif } delete [] rowLower; delete [] rowUpper; delete [] colLower; delete [] colUpper; }

int CglProbing::gutsOfGenerateCuts (  const OsiSolverInterface &  si, OsiCuts &  cs, double *  rowLower, double *  rowUpper, double *  colLower, double *  colUpper )  const [private]

Does most of work of generateCuts Returns number of infeasibilities Definition at line 482 of file CglProbing.cpp. References colLower_, colUpper_, CoinPackedVector::getElements(), CoinPackedVector::getIndices(), CoinPackedVector::getNumElements(), CglProbing::disaggregation::index, CoinPackedVector::insert(), CglProbing::disaggregation::lastLBWhenAt0, CglProbing::disaggregation::lastLBWhenAt1, CglProbing::disaggregation::lastUBWhenAt0, CglProbing::disaggregation::lastUBWhenAt1, maxProbe_, mode_, CglProbing::disaggregation::newValue, numberColumns_, numberIntegers_, numberRows_, primalTolerance_, probe(), rowCopy_, rowLower_, rowUpper_, CglProbing::disaggregation::sequence, and usingObjective_. Referenced by generateCuts(). { // Get basic problem information int nRows; CoinPackedMatrix * rowCopy=NULL; // get branch and bound cutoff double cutoff; si.getDblParam(OsiDualObjectiveLimit,cutoff); cutoff *= si.getObjSense(); if (fabs(cutoff)>1.0e30) assert (cutoff>1.0e30); int mode=mode_; int nCols=si.getNumCols(); // get integer variables char * intVar = new char[nCols]; int i; int numberIntegers=0; for (i=0;i<nCols;i++) { if (si.isInteger(i)) { intVar[i]=1; numberIntegers++; } else { intVar[i]=0; } } int ninfeas=0; // see if using cached copy or not if (!numberRows_) { // create from current nRows=si.getNumRows(); // mode==0 is invalid if going from current matrix if (mode==0) mode=1; rowCopy = new CoinPackedMatrix(*si.getMatrixByRow()); // add in objective if there is a cutoff if (cutoff<1.0e30&&usingObjective_) { int * columns = new int[nCols]; double * elements = new double[nCols]; int n=0; const double * objective = si.getObjCoefficients(); bool maximize = (si.getObjSense()==-1); for (i=0;i<nCols;i++) { if (objective[i]) { elements[n]= (maximize) ? -objective[i] : objective[i]; columns[n++]=i; } } rowCopy->appendRow(n,columns,elements); delete [] columns; delete [] elements; memcpy(rowLower,si.getRowLower(),nRows*sizeof(double)); memcpy(rowUpper,si.getRowUpper(),nRows*sizeof(double)); rowLower[nRows]=-DBL_MAX; rowUpper[nRows]=cutoff; nRows++; } else { memcpy(rowLower,si.getRowLower(),nRows*sizeof(double)); memcpy(rowUpper,si.getRowUpper(),nRows*sizeof(double)); } memcpy(colLower,si.getColLower(),nCols*sizeof(double)); memcpy(colUpper,si.getColUpper(),nCols*sizeof(double)); } else { // use snapshot nRows=numberRows_; assert(nCols==numberColumns_); rowCopy = rowCopy_; rowLower = new double[nRows]; rowUpper = new double[nRows]; memcpy(rowLower,rowLower_,nRows*sizeof(double)); memcpy(rowUpper,rowUpper_,nRows*sizeof(double)); rowLower[nRows-1]=-DBL_MAX; if (usingObjective_) { rowUpper[nRows-1]=cutoff; } else { rowUpper[nRows-1]=DBL_MAX; } memcpy(colLower,colLower_,nCols*sizeof(double)); memcpy(colUpper,colUpper_,nCols*sizeof(double)); if (mode) { // tighten bounds to reflect state of problem const double * lower = si.getColLower(); const double * upper = si.getColUpper(); for (i=0;i<nCols;i++) { if (colLower[i]<lower[i]) colLower[i]=lower[i]; if (colUpper[i]>upper[i]) colUpper[i]=upper[i]; } } } #ifdef CGL_DEBUG const OsiRowCutDebugger * debugger = si.getRowCutDebugger(); if (debugger&&!debugger->onOptimalPath(si)) debugger = NULL; #else const OsiRowCutDebugger * debugger = NULL; #endif const int * column = rowCopy->getIndices(); const int * rowStart = rowCopy->getVectorStarts(); const int * rowLength = rowCopy->getVectorLengths(); const double * rowElements = rowCopy->getElements(); if (mode) { ninfeas= tighten(colLower, colUpper, column, rowElements, rowStart, rowLength, rowLower, rowUpper, nRows, nCols, intVar, 2, primalTolerance_); if (!ninfeas) { // create column cuts where integer bounds have changed { const double * lower = si.getColLower(); const double * upper = si.getColUpper(); const double * colsol = si.getColSolution(); int numberChanged=0,ifCut=0; CoinPackedVector lbs; CoinPackedVector ubs; for (i = 0; i < nCols; ++i) { if (intVar[i]) { colUpper[i] = min(upper[i],floor(colUpper[i]+1.0e-4)); if (colUpper[i]<upper[i]-1.0e-8) { if (colUpper[i]<colsol[i]-1.0e-8) ifCut=1; ubs.insert(i,colUpper[i]); numberChanged++; } colLower[i] = max(lower[i],ceil(colLower[i]-1.0e-4)); if (colLower[i]>lower[i]+1.0e-8) { if (colLower[i]>colsol[i]+1.0e-8) ifCut=1; lbs.insert(i,colLower[i]); numberChanged++; } } } if (numberChanged) { OsiColCut cc; cc.setUbs(ubs); cc.setLbs(lbs); if (ifCut) { cc.setEffectiveness(100.0); } else { cc.setEffectiveness(1.0e-5); } #ifdef CGL_DEBUG checkBounds(debugger,cc); #endif cs.insert(cc); } } int * markR = new int [nRows]; double * minR = new double [nRows]; double * maxR = new double [nRows]; int * look = new int[nCols]; int nLook=0; // get min max etc for rows tighten2(colLower, colUpper, column, rowElements, rowStart, rowLength, rowLower, rowUpper, minR , maxR , markR, nRows, nCols); // decide what to look at if (mode==1) { const double * colsol = si.getColSolution(); double_int_pair * array = new double_int_pair [nCols]; for (i=0;i<nCols;i++) { if (intVar[i]&&colUpper[i]-colLower[i]>1.0e-8) { double away = fabs(0.5-(colsol[i]-floor(colsol[i]))); if (away<0.49999) { array[nLook].infeasibility=away; array[nLook++].sequence=i; } } } std::sort(array,array+nLook,double_int_pair_compare()); nLook=min(nLook,maxProbe_); for (i=0;i<nLook;i++) { look[i]=array[i].sequence; } delete [] array; } else { for (i=0;i<nCols;i++) { if (intVar[i]&&colUpper[i]-colLower[i]>1.0e-8) { look[nLook++]=i; } } } ninfeas= probe(si, debugger, cs, colLower, colUpper, rowCopy, rowLower, rowUpper, intVar, minR, maxR, markR, look,nLook); delete [] look; delete [] markR; delete [] minR; delete [] maxR; } } else { // global cuts from previous calculations // could check more thoroughly that integers are correct assert(numberIntegers==numberIntegers_); // make up list of new variables to look at int * markR = new int [nRows]; double * minR = new double [nRows]; double * maxR = new double [nRows]; int * look = new int[nCols]; int nLook=0; const double * colsol = si.getColSolution(); for (i=0;i<numberIntegers_;i++) { int j=cutVector_[i].sequence; if (!cutVector_[i].newValue&&colUpper[j]-colLower[j]>1.0e-8) { double away = fabs(0.5-(colsol[j]-floor(colsol[j]))); if (away<0.4999999) { look[nLook++]=j; } } } // get min max etc for rows tighten2(colLower, colUpper, column, rowElements, rowStart, rowLength, rowLower, rowUpper, minR , maxR , markR, nRows, nCols); OsiCuts csNew; ninfeas= probe(si, debugger, csNew, colLower, colUpper, rowCopy, rowLower, rowUpper, intVar, minR, maxR, markR, look,nLook); if (!ninfeas) { // go through row cuts int nCuts = csNew.sizeRowCuts(); int iCut; // need space for backward lookup // just for ones being looked at int * backward = new int [2*nCols]; int * onList = backward + nCols; for (i=0;i<numberIntegers_;i++) { int j=cutVector_[i].sequence; backward[j]=i; onList[j]=0; } for (i=0;i<nLook;i++) { onList[look[i]]=1; } // first do counts // we know initialized to zero for (iCut=0;iCut<nCuts;iCut++) { OsiRowCut rcut; CoinPackedVector rpv; rcut = csNew.rowCut(iCut); rpv = rcut.row(); assert(rpv.getNumElements()==2); const int * indices = rpv.getIndices(); double* elements = rpv.getElements(); double lb=rcut.lb(); // find out which integer i=backward[indices[1]]; if (lb==-DBL_MAX) { // UB if (elements[1]<0.0) { cutVector_[i].lastUBWhenAt0++; } else { cutVector_[i].lastUBWhenAt1++; } } else { // LB if (elements[1]>0.0) { cutVector_[i].lastLBWhenAt0++; } else { cutVector_[i].lastLBWhenAt1++; } } } // allocate space for (i=0;i<numberIntegers_;i++) { int j=cutVector_[i].sequence; if (onList[j]&&!cutVector_[i].newValue) { disaggregation thisOne=cutVector_[i]; int total; // set to start of each type cutVector_[i].lastUBWhenAt0 =0; total = thisOne.lastUBWhenAt0; cutVector_[i].lastUBWhenAt1 = total; total += thisOne.lastUBWhenAt1; cutVector_[i].lastLBWhenAt0 = total; total += thisOne.lastLBWhenAt0; cutVector_[i].lastLBWhenAt1 = total; total += thisOne.lastLBWhenAt1; cutVector_[i].newValue=new double[total]; cutVector_[i].index=new int[total]; } } // now put in for (iCut=0;iCut<nCuts;iCut++) { OsiRowCut rcut; CoinPackedVector rpv; int iput; rcut = csNew.rowCut(iCut); rpv = rcut.row(); assert(rpv.getNumElements()==2); const int * indices = rpv.getIndices(); double* elements = rpv.getElements(); double lb=rcut.lb(); // find out which integer i=backward[indices[1]]; if (lb==-DBL_MAX) { // UB if (elements[1]<0.0) { iput=cutVector_[i].lastUBWhenAt0; cutVector_[i].newValue[iput]=elements[1]; cutVector_[i].index[iput]=indices[0]; cutVector_[i].lastUBWhenAt0++; } else { iput=cutVector_[i].lastUBWhenAt1; cutVector_[i].newValue[iput]=elements[1]; cutVector_[i].index[iput]=indices[0]; cutVector_[i].lastUBWhenAt1++; } } else { // LB if (elements[1]>0.0) { iput=cutVector_[i].lastLBWhenAt0; cutVector_[i].newValue[iput]=elements[1]; cutVector_[i].index[iput]=indices[0]; cutVector_[i].lastLBWhenAt0++; } else { iput=cutVector_[i].lastLBWhenAt1; cutVector_[i].newValue[iput]=elements[1]; cutVector_[i].index[iput]=indices[0]; cutVector_[i].lastLBWhenAt1++; } } } // now see if any disaggregation cuts are violated for (i=0;i<numberIntegers_;i++) { int j=cutVector_[i].sequence; double upperInt=colUpper_[j]; double lowerInt=colLower_[j]; double solInt=colsol[j]; double down = solInt-lowerInt; double up = upperInt-solInt; double lower, upper, solValue; int icol; double newSol,value,newValue; int index[2]; double element[2]; if (colUpper[j]-colLower[j]>1.0e-8) { double away = fabs(0.5-(colsol[j]-floor(colsol[j]))); if (away<0.4999999) { disaggregation thisOne=cutVector_[i]; int k; OsiRowCut rc; // UB changes when integer goes to lb for (k=0;k<thisOne.lastUBWhenAt0;k++) { icol = thisOne.index[k]; value = thisOne.newValue[k]; // new U - old U solValue=colsol[icol]; upper=colUpper_[icol]; newValue= value + upper; if (solValue > newValue - value * down + primalTolerance_) { rc.setLb(-DBL_MAX); rc.setUb(newValue + lowerInt*value); index[0]=icol; element[0]=1.0; index[1]=j; element[1]= value; // effectiveness is how far j moves newSol = (rc.ub()-solValue)/element[1]; if (mode_) assert(newSol>solInt); rc.setEffectiveness(newSol-solInt); if (rc.effectiveness()>1.0e-3) { rc.setRow(2,index,element); #ifdef CGL_DEBUG if (debugger) assert(!debugger->invalidCut(rc)); #endif cs.insert(rc); } } } // UB changes when integer goes to ub for (k=thisOne.lastUBWhenAt0;k<thisOne.lastUBWhenAt1;k++) { icol = thisOne.index[k]; value = thisOne.newValue[k]; // new U - old U solValue=colsol[icol]; upper=colUpper_[icol]; newValue= value + upper; if (solValue > newValue - value * up + primalTolerance_) { rc.setLb(-DBL_MAX); rc.setUb(newValue - upperInt*value); index[0]=icol; element[0]=1.0; index[1]=j; element[1]= value; // effectiveness is how far j moves newSol = (rc.ub()-solValue)/element[1]; if (mode_) assert(newSol>solInt); rc.setEffectiveness(newSol-solInt); if (rc.effectiveness()>1.0e-3) { rc.setRow(2,index,element); #ifdef CGL_DEBUG if (debugger) assert(!debugger->invalidCut(rc)); #endif cs.insert(rc); } } } // LB changes when integer goes to lb for (k=thisOne.lastUBWhenAt1;k<thisOne.lastLBWhenAt0;k++) { icol = thisOne.index[k]; value = thisOne.newValue[k]; // new L - old L solValue=colsol[icol]; lower=colLower_[icol]; newValue= value + lower; if (solValue < newValue - value * down - primalTolerance_) { rc.setLb(newValue + lowerInt*value); rc.setUb(DBL_MAX); index[0]=icol; element[0]=1.0; index[1]=j; element[1]= value; // effectiveness is how far j moves newSol = (rc.lb()-solValue)/element[1]; if (mode_) assert(newSol>solInt); rc.setEffectiveness(newSol-solInt); if (rc.effectiveness()>1.0e-3) { rc.setRow(2,index,element); #ifdef CGL_DEBUG if (debugger) assert(!debugger->invalidCut(rc)); #endif cs.insert(rc); } } } // LB changes when integer goes to ub for (k=thisOne.lastLBWhenAt0;k<thisOne.lastLBWhenAt1;k++) { icol = thisOne.index[k]; value = thisOne.newValue[k]; // new L - old L solValue=colsol[icol]; lower=colLower_[icol]; newValue= value + lower; if (solValue < newValue - value * up - primalTolerance_) { rc.setLb(newValue - upperInt*value); rc.setUb(DBL_MAX); index[0]=icol; element[0]=1.0; index[1]=j; element[1]= value; // effectiveness is how far j moves newSol = (rc.lb()-solValue)/element[1]; if (mode_) assert(newSol>solInt); rc.setEffectiveness(newSol-solInt); if (rc.effectiveness()>1.0e-3) { rc.setRow(2,index,element); #ifdef CGL_DEBUG if (debugger) assert(!debugger->invalidCut(rc)); #endif cs.insert(rc); } } } } } } delete [] backward; } delete [] look; delete [] markR; delete [] minR; delete [] maxR; } // delete stuff if (!numberRows_) { delete rowCopy; } else { delete [] rowLower; delete [] rowUpper; } delete [] intVar; return ninfeas; }

void CglProbing::setRowCuts (  int  type  )

Set 0 no cuts, 1 just disaggregation type, 2 coefficient ( 3 both) Definition at line 2225 of file CglProbing.cpp. References rowCuts_. { if (type>=0&&type<4) rowCuts_=type; }

void CglProbing::snapshot (  const OsiSolverInterface &  si, char *  possible = NULL )

Create a copy of matrix which is to be used this is to speed up process and to give global cuts Can give an array with 1 set to select, 0 to ignore column bounds are tightened If array given then values of 1 will be set to 0 if redundant Definition at line 2046 of file CglProbing.cpp. References colLower_, colUpper_, deleteSnapshot(), numberColumns_, numberIntegers_, numberRows_, primalTolerance_, rowCopy_, rowLower_, and rowUpper_. { deleteSnapshot(); // Get basic problem information numberColumns_=si.getNumCols(); numberRows_=si.getNumRows(); colLower_ = new double[numberColumns_]; colUpper_ = new double[numberColumns_]; memcpy(colLower_,si.getColLower(),numberColumns_*sizeof(double)); memcpy(colUpper_,si.getColUpper(),numberColumns_*sizeof(double)); rowLower_= new double [numberRows_+1]; rowUpper_= new double [numberRows_+1]; memcpy(rowLower_,si.getRowLower(),numberRows_*sizeof(double)); memcpy(rowUpper_,si.getRowUpper(),numberRows_*sizeof(double)); int i; if (possible) { for (i=0;i<numberRows_;i++) { if (!possible[i]) { rowLower_[i]=-DBL_MAX; rowUpper_[i]=DBL_MAX; } } } char * intVar = new char[numberColumns_]; numberIntegers_=0; for (i=0;i<numberColumns_;i++) { if (si.isInteger(i)) { intVar[i]=1; numberIntegers_++; } else { intVar[i]=0; } } rowCopy_ = new CoinPackedMatrix(*si.getMatrixByRow()); const int * column = rowCopy_->getIndices(); const int * rowStart = rowCopy_->getVectorStarts(); const int * rowLength = rowCopy_->getVectorLengths(); const double * rowElements = rowCopy_->getElements(); int ninfeas= tighten(colLower_, colUpper_, column, rowElements, rowStart, rowLength, rowLower_, rowUpper_, numberRows_, numberColumns_, intVar, 5, primalTolerance_); assert (!ninfeas); // do integer stuff for mode 0 cutVector_ = new disaggregation [numberIntegers_]; memset(cutVector_,0,numberIntegers_*sizeof(disaggregation)); numberIntegers_=0; for (i=0;i<numberColumns_;i++) { if (intVar[i]) { cutVector_[numberIntegers_++].sequence=i; } } delete [] intVar; // now delete rows if (possible) { for (i=0;i<numberRows_;i++) { if (rowLower_[i]<-1.0e30&&rowUpper_[i]>1.0e30) possible[i]=0; } } int * index = new int[numberRows_]; int nDrop=0,nKeep=0; for (i=0;i<numberRows_;i++) { if (rowLower_[i]<-1.0e30&&rowUpper_[i]>1.0e30) { index[nDrop++]=i; } else { rowLower_[nKeep]=rowLower_[i]; rowUpper_[nKeep++]=rowUpper_[i]; } } numberRows_=nKeep; if (nDrop) rowCopy_->deleteRows(nDrop,index); delete [] index; // add in objective int * columns = new int[numberColumns_]; double * elements = new double[numberColumns_]; int n=0; const double * objective = si.getObjCoefficients(); bool maximize = (si.getObjSense()==-1); for (i=0;i<numberColumns_;i++) { if (objective[i]) { elements[n]= (maximize) ? -objective[i] : objective[i]; columns[n++]=i; } } rowCopy_->appendRow(n,columns,elements); delete [] columns; delete [] elements; numberRows_++; }

---

Friends And Related Function Documentation

void CglProbingUnitTest (  const OsiSolverInterface *  siP, const std::string  mpdDir )  [friend]

A function that tests the methods in the CglProbing class. The only reason for it not to be a member method is that this way it doesn't have to be compiled into the library. And that's a gain, because the library should be compiled with optimization on, but this method should be compiled with debugging. Definition at line 24 of file CglProbingTest.cpp. { CoinRelFltEq eq(0.000001); // Test default constructor { CglProbing aGenerator; } // Test copy & assignment { CglProbing rhs; { CglProbing bGenerator; CglProbing cGenerator(bGenerator); rhs=bGenerator; } } { OsiCuts osicuts; CglProbing test1; OsiSolverInterface * siP = baseSiP->clone(); int i; int nColCuts; int nRowCuts; std::string fn = mpsDir+"p0033"; siP->readMps(fn.c_str(),"mps"); siP->initialSolve(); // just unsatisfied variables test1.generateCuts(*siP,osicuts); nColCuts = osicuts.sizeColCuts(); nRowCuts = osicuts.sizeRowCuts(); std::cout<<"There are "<<nRowCuts<<" probing cuts"<<std::endl; { std::cout<<"there are "<<nColCuts<<" probing column cuts"<<std::endl; const double * lo = siP->getColLower(); const double * up = siP->getColUpper(); for (i=0; i<nColCuts; i++){ OsiColCut ccut; CoinPackedVector cpv; ccut = osicuts.colCut(i); cpv = ccut.lbs(); int n = cpv.getNumElements(); int j; const int * indices = cpv.getIndices(); double* elements = cpv.getElements(); for (j=0;j<n;j++) { int icol=indices[j]; if (elements[j]>lo[icol]) std::cout<<"Can increase lb on "<<icol<<" from "<<lo[icol]<< " to "<<elements[j]<<std::endl; } cpv = ccut.ubs(); n = cpv.getNumElements(); indices = cpv.getIndices(); elements = cpv.getElements(); for (j=0;j<n;j++) { int icol=indices[j]; if (elements[j]<up[icol]) std::cout<<"Can decrease ub on "<<icol<<" from "<<up[icol]<< " to "<<elements[j]<<std::endl; } } } for (i=0; i<nRowCuts; i++){ OsiRowCut rcut; CoinPackedVector rpv; const double * colsol = siP->getColSolution(); rcut = osicuts.rowCut(i); rpv = rcut.row(); const int n = rpv.getNumElements(); const int * indices = rpv.getIndices(); double* elements = rpv.getElements(); double sum2=0.0; int k=0; double lb=rcut.lb(); double ub=rcut.ub(); for (k=0; k<n; k++){ int column=indices[k]; sum2 += colsol[column]*elements[k]; } if (sum2 >ub + 1.0e-7 ||sum2 < lb - 1.0e-7) { std::cout<<"Cut "<<i<<" lb "<<lb<<" solution "<<sum2<<" ub "<<ub<<std::endl; for (k=0; k<n; k++){ int column=indices[k]; std::cout<<"(col="<<column<<",el="<<elements[k]<<",sol="<< colsol[column]<<") "; } std::cout <<std::endl; } } CoinPackedVector check; int index[] = {6,32}; double el[] = {1,1}; check.setVector(2,index,el); assert (osicuts.sizeRowCuts()==2); // sort Elements in increasing order CoinPackedVector rpv=osicuts.rowCut(1).row(); rpv.sortIncrIndex(); assert (check==rpv); assert (osicuts.rowCut(1).lb()==1.0); // now all variables osicuts=OsiCuts(); test1.setMode(2); test1.generateCuts(*siP,osicuts); nColCuts = osicuts.sizeColCuts(); nRowCuts = osicuts.sizeRowCuts(); std::cout<<"There are "<<nRowCuts<<" probing cuts"<<std::endl; { std::cout<<"there are "<<nColCuts<<" probing column cuts"<<std::endl; const double * lo = siP->getColLower(); const double * up = siP->getColUpper(); for (i=0; i<nColCuts; i++){ OsiColCut ccut; CoinPackedVector cpv; ccut = osicuts.colCut(i); cpv = ccut.lbs(); int n = cpv.getNumElements(); int j; const int * indices = cpv.getIndices(); double* elements = cpv.getElements(); for (j=0;j<n;j++) { int icol=indices[j]; if (elements[j]>lo[icol]) std::cout<<"Can increase lb on "<<icol<<" from "<<lo[icol]<< " to "<<elements[j]<<std::endl; } cpv = ccut.ubs(); n = cpv.getNumElements(); indices = cpv.getIndices(); elements = cpv.getElements(); for (j=0;j<n;j++) { int icol=indices[j]; if (elements[j]<up[icol]) std::cout<<"Can decrease ub on "<<icol<<" from "<<up[icol]<< " to "<<elements[j]<<std::endl; } } } for (i=0; i<nRowCuts; i++){ OsiRowCut rcut; CoinPackedVector rpv; const double * colsol = siP->getColSolution(); rcut = osicuts.rowCut(i); rpv = rcut.row(); const int n = rpv.getNumElements(); const int * indices = rpv.getIndices(); double* elements = rpv.getElements(); double sum2=0.0; int k=0; double lb=rcut.lb(); double ub=rcut.ub(); for (k=0; k<n; k++){ int column=indices[k]; sum2 += colsol[column]*elements[k]; } if (sum2 >ub + 1.0e-7 ||sum2 < lb - 1.0e-7) { std::cout<<"Cut "<<i<<" lb "<<lb<<" solution "<<sum2<<" ub "<<ub<<std::endl; for (k=0; k<n; k++){ int column=indices[k]; std::cout<<"(col="<<column<<",el="<<elements[k]<<",sol="<< colsol[column]<<") "; } std::cout <<std::endl; } } assert (osicuts.sizeRowCuts()==10); delete siP; } }

---

Member Data Documentation

int CglProbing::rowCuts_ [private]

Row cuts flag 0 no cuts, 1 just disaggregation type, 2 coefficient ( 3 both) Definition at line 232 of file CglProbing.hpp. Referenced by operator=(), probe(), rowCuts(), and setRowCuts().

---

The documentation for this class was generated from the following files:

• CglProbing.hpp
• CglProbing.cpp

---