CglOddHole Class Reference

#include <CglOddHole.hpp>

Inheritance diagram for CglOddHole:

List of all members.

Public Member Functions
Generate Cuts
virtual void	generateCuts (const OsiSolverInterface &si, OsiCuts &cs) const
Create Row List
void	createRowList (const OsiSolverInterface &si, const int *possible=NULL)
void	createRowList (int numberRows, const int *whichRow)
	This version passes in a list - 1 marks possible.
Create Clique List
void	createCliqueList (int numberCliques, const int *cliqueStart, const int *cliqueMember)
Number Possibilities
int	numberPossible ()
	Returns how many rows might give odd hole cuts.
Gets and Sets
double	getMinimumViolation () const
	Minimum violation.
void	setMinimumViolation (double value)
double	getMinimumViolationPer () const
	Minimum violation per entry.
void	setMinimumViolationPer (double value)
int	getMaximumEntries () const
	Maximum number of entries in a cut.
void	setMaximumEntries (int value)
Constructors and destructors
	CglOddHole ()
	Default constructor.
	CglOddHole (const CglOddHole &)
	Copy constructor.
CglOddHole &	operator= (const CglOddHole &rhs)
	Assignment operator.
virtual	~CglOddHole ()
	Destructor.
virtual void	refreshSolver (OsiSolverInterface *solver)
	This can be used to refresh any inforamtion.
Private Member Functions
Private methods
void	generateCuts (const OsiRowCutDebugger *debugger, const CoinPackedMatrix &rowCopy, const double *solution, const double *dj, OsiCuts &cs, const int *suitableRow, const int *fixedColumn, bool packed)
Private Attributes
Private member data
int *	suitableRows_
	list of suitableRows
int *	startClique_
	start of each clique
int *	member_
	clique members
double	epsilon_
	epsilon
double	onetol_
	1-epsilon
double	minimumViolation_
	Minimum violation.
double	minimumViolationPer_
	Minimum violation per entry.
int	maximumEntries_
	Maximum number of entries in a cut.
int	numberRows_
	number of rows when suitability tested
int	numberCliques_
	number of cliques
Friends
void	CglOddHoleUnitTest (const OsiSolverInterface *siP, const std::string mpdDir)

---

Detailed Description

Odd Hole Cut Generator Class

Definition at line 11 of file CglOddHole.hpp.

---

Member Function Documentation

void CglOddHole::createCliqueList (  int  numberCliques, const int *  cliqueStart, const int *  cliqueMember )

Create a list of extra row cliques which may not be in matrix At present these are classical cliques Definition at line 661 of file CglOddHole.cpp. References member_, numberCliques_, and startClique_. { numberCliques_=numberCliques; startClique_=new int[numberCliques_+1]; memcpy(startClique_,cliqueStart,(numberCliques_+1)*sizeof(int)); int length=startClique_[numberCliques_]; member_=new int[length]; memcpy(member_,cliqueMember,length*sizeof(int)); }

void CglOddHole::createRowList (  const OsiSolverInterface &  si, const int *  possible = NULL )

Create a list of rows which might yield cuts this is to speed up process The possible parameter is a list to cut down search Definition at line 585 of file CglOddHole.cpp. References epsilon_, numberRows_, and suitableRows_. Referenced by generateCuts(). { // Get basic problem information int nRows=si.getNumRows(); const CoinPackedMatrix * rowCopy = si.getMatrixByRow(); const int * column = rowCopy->getIndices(); const int * rowStart = rowCopy->getVectorStarts(); const int * rowLength = rowCopy->getVectorLengths(); int rowIndex; delete [] suitableRows_; numberRows_=nRows; const double * rowElements = rowCopy->getElements(); const double * rowupper = si.getRowUpper(); const double * rowlower = si.getRowLower(); const double * collower = si.getColLower(); const double * colupper = si.getColUpper(); suitableRows_=new int[nRows]; if (possible) { memcpy(suitableRows_,possible,nRows*sizeof(int)); } else { int i; for (i=0;i<nRows;i++) { suitableRows_[i]=1; } } for (rowIndex=0; rowIndex<nRows; rowIndex++){ double rhs1=rowupper[rowIndex]; double rhs2=rowlower[rowIndex]; if (suitableRows_[rowIndex]) { int i; bool goodRow=true; for (i=rowStart[rowIndex]; i<rowStart[rowIndex]+rowLength[rowIndex];i++) { int thisCol=column[i]; if (colupper[thisCol]-collower[thisCol]>epsilon_) { // could allow general integer variables but unlikely if (!si.isBinary(thisCol) ) { goodRow=false; break; } if (fabs(rowElements[i]-1.0)>epsilon_) { goodRow=false; break; } } else { rhs1 -= collower[thisCol]*rowElements[i]; rhs2 -= collower[thisCol]*rowElements[i]; } } if (fabs(rhs1-1.0)>epsilon_&&fabs(rhs2-1.0)>epsilon_) { goodRow=false; } if (goodRow) { suitableRows_[rowIndex]=1; } else { suitableRows_[rowIndex]=0; } } } }

void CglOddHole::generateCuts (  const OsiRowCutDebugger *  debugger, const CoinPackedMatrix &  rowCopy, const double *  solution, const double *  dj, OsiCuts &  cs, const int *  suitableRow, const int *  fixedColumn, bool  packed )  [private]

Generate cuts from matrix copy and solution If packed true then <=1 rows, otherwise >=1 rows. Definition at line 147 of file CglOddHole.cpp. References CoinPackedVectorBase::dotProduct(), maximumEntries_, minimumViolation_, minimumViolationPer_, and CoinPackedVector::sortIncrIndex(). { CoinPackedMatrix columnCopy = rowCopy; columnCopy.reverseOrdering(); // Get basic problem information int nRows=columnCopy.getNumRows(); int nCols=columnCopy.getNumCols(); const int * column = rowCopy.getIndices(); const int * rowStart = rowCopy.getVectorStarts(); const int * rowLength = rowCopy.getVectorLengths(); const int * row = columnCopy.getIndices(); const int * columnStart = columnCopy.getVectorStarts(); const int * columnLength = columnCopy.getVectorLengths(); // we need only look at suitable rows and variables with unsatisfied 0-1 // lookup from true row to compressed matrix int * mrow = new int[nRows]; // lookup from true column to compressed int * lookup = new int[nCols]; // number of columns in compressed matrix int nSmall=0; int i; //do lookup from true sequence to compressed int n=0; for (i=0;i<nRows;i++) { if (suitableRow[i]>0) { mrow[i]=n++; } else { mrow[i]=-1; } } for (i=0;i<nCols;i++) { if (!fixedColumn[i]) { lookup[i]=nSmall++; } else { lookup[i]=-1; } } int nSmall2=2*nSmall; // we don't know how big matrix will be #define MAXELS 50000 int maxels=MAXELS; //How do I do reallocs in C++? // 1.0 - value x(i) - value x(j) for each node pair (or reverse if cover) double * cost = (double *) malloc(maxels*sizeof(double)); // arc i.e. j which can be reached from i int * to= (int *) malloc(maxels*sizeof(int)); //original row for each arc int * rowfound=(int *) malloc(maxels*sizeof(int)); // start of each column int * starts=new int[2*nSmall+1]; starts[0]=0; // useful array for marking if already connected int * mark =new int[nSmall2]; memset(mark,0,nSmall2*sizeof(int)); n=0; //number of elements in matrix for (i=0;i<nCols;i++) { int icol=lookup[i]; if (icol>=0) { // column in compressed matrix int k; double dd=1.0000001-solution[i]; mark[icol]=1; // reallocate if matrix reached size limit if (n+nCols>maxels) { maxels*=2; cost=(double *) realloc(cost,maxels*sizeof(int)); to=(int *) realloc(to,maxels*sizeof(int)); rowfound=(int *) realloc(rowfound,maxels*sizeof(int)); } // get all other connected variables for (k=columnStart[i];k<columnStart[i]+columnLength[i];k++) { int irow=row[k]; int jrow=mrow[irow]; // but only if row in compressed matrix if (jrow>=0) { int j; for (j=rowStart[irow];j<rowStart[irow]+rowLength[irow];j++) { int jcol=column[j]; int kcol=lookup[jcol]; if (kcol>=0&&!mark[kcol]) { cost[n]=dd-solution[jcol]; to[n]=kcol; rowfound[n++]=irow;//original row mark[kcol]=1; } } } } starts[icol+1]=n; // zero out markers for next column mark[icol]=0; for (k=starts[icol];k<starts[icol+1];k++) { int ito=to[k]; if (ito<0||ito>=nSmall) abort(); mark[to[k]]=0; } } } //if cover then change sign - otherwise make sure positive if (packed) { for (i=0;i<n;i++) { if (cost[i]<1.0e-10) { cost[i]=1.0e-10; } } } else { for (i=0;i<n;i++) { cost[i]=-cost[i]; if (cost[i]<1.0e-10) { cost[i]=1.0e-10; } } } // we are going to double size if (2*n>maxels) { maxels=2*n; cost=(double *) realloc(cost,maxels*sizeof(int)); to=(int *) realloc(to,maxels*sizeof(int)); rowfound=(int *) realloc(rowfound,maxels*sizeof(int)); } /* copy and make bipartite*/ for (i=0;i<nSmall;i++) { int k,j=i+nSmall; for (k=starts[i];k<starts[i+1];k++) { int ito=to[k]; to[n]=ito; to[k]=ito+nSmall; cost[n]=cost[k]; rowfound[n++]=rowfound[k];; } starts[j+1]=n; } //random numbers to winnow out duplicate cuts double * check = new double[nCols]; CoinSeedRandom(13579); for (i=0;i<nCols;i++) { check[i]=CoinDrand48(); } // Shortest path algorithm from Dijkstra - is there a better one? typedef struct { double cost; //cost to starting node int back; //previous node } Path; typedef struct { double cost; //cost to starting node int node; //node } Item; Item * stack = new Item [nSmall2]; Path * path = new Path [nSmall2]; // arrays below are used only if looks promising // allocate here // we don't know how many cuts will be generated int ncuts=0; int maxcuts=1000; double * hash = (double *) malloc(maxcuts*sizeof(double)); // to clean (should not be needed) int * clean = new int[nSmall2]; int * candidate = new int[CoinMax(nSmall2,nCols)]; double * element = new double[nCols]; // in case we want to sort double_double_int_triple * sortit = new double_double_int_triple [nCols]; memset(mark,0,nSmall2*sizeof(int)); int * countcol = new int[nCols]; memset(countcol,0,nCols*sizeof(int)); int bias = packed ? 0 : 1; //amount to add before halving // If nSmall large then should do a randomized subset // Improvement 1 int icol; for (icol=0;icol<nSmall;icol++) { int j; int jcol=icol+nSmall; int istack=1; for (j=0;j<nSmall2;j++) { path[j].cost=1.0e70; path[j].back=nSmall2+1; } path[icol].cost=0.0; path[icol].back=-1; stack[0].cost=0.0; stack[0].node=icol; mark[icol]=1; while(istack) { Item thisItem=stack[--istack]; double thisCost=thisItem.cost; int inode=thisItem.node; int k; mark[inode]=0; //say available for further work // See if sorting every so many would help (and which way)? // Improvement 2 for (k=starts[inode];k<starts[inode+1];k++) { int jnode=to[k]; if (!mark[jnode]&&thisCost+cost[k]<path[jnode].cost-1.0e-12) { path[jnode].cost=thisCost+cost[k]; path[jnode].back=inode; // add to stack stack[istack].cost=path[jnode].cost; stack[istack++].node=jnode; mark[jnode]=1; #ifdef CGL_DEBUG assert (istack<=nSmall2); #endif } } } bool good=(path[jcol].cost<0.9999); if (good) { /* try */ int ii; int nrow2=0; int nclean=0; double sum=0; #ifdef CGL_DEBUG printf("** %d ",jcol-nSmall); #endif ii=1; candidate[0]=jcol; while(jcol!=icol) { int jjcol; jcol=path[jcol].back; if (jcol>=nSmall) { jjcol=jcol-nSmall; } else { jjcol=jcol; } #ifdef CGL_DEBUG printf(" %d",jjcol); #endif if (mark[jjcol]) { // good=false; // probably means this is from another cycle (will have been found) // one of cycles must be zero cost // printf("variable already on chain!\n"); } else { mark[jjcol]=1; clean[nclean++]=jjcol; candidate[ii++]=jcol; #ifdef CGL_DEBUG assert (ii<=nSmall2); #endif } } #ifdef CGL_DEBUG printf("\n"); #endif for (j=0;j<nclean;j++) { int k=clean[j]; mark[k]=0; } if (good) { int k; for (k=ii-1;k>0;k--) { int jk,kk=candidate[k]; int ix=0; for (jk=starts[kk];jk<starts[kk+1];jk++) { int ito=to[jk]; if (ito==candidate[k-1]) { ix=1; // back to original row mrow[nrow2++]=rowfound[jk]; break; } } if (!ix) { good=false; } } if ((nrow2&1)!=1) { good=false; } if (good) { int nincut=0; for (k=0;k<nrow2;k++) { int j,irow=mrow[k]; for (j=rowStart[irow];j<rowStart[irow]+rowLength[irow];j++) { int icol=column[j]; if (!countcol[icol]) candidate[nincut++]=icol; countcol[icol]++; } } #ifdef CGL_DEBUG printf("true constraint %d",nrow2); #endif nrow2=nrow2>>1; double rhs=nrow2; if (!packed) rhs++; // +1 for cover ii=0; for (k=0;k<nincut;k++) { int jcol=candidate[k]; if (countcol[jcol]) { #ifdef CGL_DEBUG printf(" %d %d",jcol,countcol[jcol]); #endif int ihalf=(countcol[jcol]+bias)>>1; if (ihalf) { element[ii]=ihalf; sum+=solution[jcol]*element[ii]; /*printf("%d %g %g\n",jcol,element[ii],sumall[jcol]);*/ candidate[ii++]=jcol; } countcol[jcol]=0; } } #ifdef CGL_DEBUG printf("\n"); #endif OsiRowCut rc; double violation=0.0; if (packed) { violation = sum-rhs; rc.setLb(-DBL_MAX); rc.setUb(rhs); } else { // other way for cover violation = rhs-sum; rc.setUb(DBL_MAX); rc.setLb(rhs); } if (violation<minimumViolation_) { #ifdef CGL_DEBUG printf("why no cut\n"); #endif good=false; } else { if (((double) ii) * minimumViolationPer_>violation|| ii>maximumEntries_) { #ifdef CGL_DEBUG printf("why no cut\n"); #endif if (packed) { // sort and see if we can get down to length // relax by taking out ones with solution 0.0 nincut=ii; for (k=0;k<nincut;k++) { int jcol=candidate[k]; double value = fabs(dj[jcol]); if (solution[jcol]) value = -solution[jcol]; sortit[k].dj=value; sortit[k].element=element[k]; sortit[k].sequence=jcol; } // sort std::sort(sortit,sortit+nincut,double_double_int_triple_compare()); nincut = min(nincut,maximumEntries_); sum=0.0; for (k=0;k<nincut;k++) { int jcol=sortit[k].sequence; candidate[k]=jcol; element[k]=sortit[k].element; sum+=solution[jcol]*element[k]; } violation = sum-rhs; ii=nincut; if (violation<minimumViolation_) { good=false; } } else { good=false; } } } if (good) { //this assumes not many cuts int j; #if 0 double value=0.0; for (j=0;j<ii;j++) { int icol=candidate[j]; value += check[icol]*element[j]; } #else CoinPackedVector candidatePv(ii,candidate,element); candidatePv.sortIncrIndex(); double value = candidatePv.dotProduct(check); #endif for (j=0;j<ncuts;j++) { if (value==hash[j]) { //could check equality - quicker just to assume break; } } if (j==ncuts) { //new if (ncuts==maxcuts) { maxcuts *= 2; hash = (double *) realloc(hash,maxcuts*sizeof(double)); } hash[ncuts++]=value; rc.setRow(ii,candidate,element); #ifdef CGL_DEBUG printf("sum %g rhs %g %d\n",sum,rhs,ii); if (debugger) assert(!debugger->invalidCut(rc)); #endif cs.insert(rc); } } } /* end of adding cut */ } } } delete [] countcol; delete [] element; delete [] candidate; delete [] sortit; delete [] clean; delete [] path; delete [] stack; free(hash); delete [] check; delete [] mark; delete [] starts; delete [] lookup; delete [] mrow; free(rowfound); free(to); free(cost); }

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

Generate odd hole cuts for the model of the solver interface, si. This looks at all rows of type sum x(i) <= 1 (or == 1) (x 0-1) and sees if there is an odd cycle cut. See Grotschel, Lovasz and Schrijver (1988) for method. This is then lifted by using the corresponding Chvatal cut i.e. Take all rows in cycle and add them together. RHS will be odd so weaken all odd coefficients so 1.0 goes to 0.0 etc - then constraint is sum even(j)*x(j) <= odd which can be replaced by sum (even(j)/2)*x(j) <= (odd-1.0)/2. A similar cut can be generated for sum x(i) >= 1. Insert the generated cuts into OsiCut, cs. This is only done for rows with unsatisfied 0-1 variables. If there are many of these it will be slow. Improvements would do a randomized subset and also speed up shortest path algorithm used. Implements CglCutGenerator. Definition at line 32 of file CglOddHole.cpp. References createRowList(), epsilon_, numberRows_, onetol_, and suitableRows_. { // Get basic problem information int nRows=si.getNumRows(); int nCols=si.getNumCols(); const CoinPackedMatrix * rowCopy = si.getMatrixByRow(); // Could do cliques and extra OSL cliques // For moment just easy ones // If no information exists then get a list of suitable rows // If it does then suitable rows are subset of information CglOddHole temp; int * checkRow = new int[nRows]; int i; if (!suitableRows_) { for (i=0;i<nRows;i++) { checkRow[i]=1; } } else { // initialize and extend rows to current size memset(checkRow,0,nRows*sizeof(int)); memcpy(checkRow,suitableRows_,CoinMin(nRows,numberRows_)*sizeof(int)); } temp.createRowList(si,checkRow); // now cut down further by only allowing rows with fractional solution double * solution = new double[nCols]; memcpy(solution,si.getColSolution(),nCols*sizeof(double)); const int * column = rowCopy->getIndices(); const int * rowStart = rowCopy->getVectorStarts(); const int * rowLength = rowCopy->getVectorLengths(); const double * collower = si.getColLower(); const double * colupper = si.getColUpper(); int * suitable = temp.suitableRows_; // At present I am using new and delete as easier to see arrays in debugger int * fixed = new int[nCols]; // mark fixed columns for (i=0;i<nCols;i++) { if (si.isBinary(i) ) { fixed[i]=0; if (colupper[i]-collower[i]<epsilon_) { solution[i]=0.0; fixed[i]=2; } else if (solution[i]<epsilon_) { solution[i]=0.0; fixed[i]=-1; } else if (solution[i]>onetol_) { solution[i]=1.0; fixed[i]=+1; } } else { //mark as fixed even if not (can not intersect any interesting rows) solution[i]=0.0; fixed[i]=3; } } // first do packed const double * rowlower = si.getRowLower(); const double * rowupper = si.getRowUpper(); for (i=0;i<nRows;i++) { if (suitable[i]) { int k; double sum=0.0; if (rowupper[i]>1.001) suitable[i]=-1; for (k=rowStart[i]; k<rowStart[i]+rowLength[i];k++) { int icol=column[k]; if (!fixed[icol]) sum += solution[icol]; } if (sum<0.9) suitable[i]=-1; //say no good } } #ifdef CGL_DEBUG const OsiRowCutDebugger * debugger = si.getRowCutDebugger(); if (debugger&&!debugger->onOptimalPath(si)) debugger = NULL; #else const OsiRowCutDebugger * debugger = NULL; #endif temp.generateCuts(debugger, *rowCopy,solution, si.getReducedCost(),cs,suitable,fixed,true); // now cover //if no >= then skip bool doCover=false; int nsuitable=0; for (i=0;i<nRows;i++) { suitable[i]=abs(suitable[i]); if (suitable[i]) { int k; double sum=0.0; if (rowlower[i]<0.999) sum=2.0; if (rowupper[i]>1.001) doCover=true; for (k=rowStart[i]; k<rowStart[i]+rowLength[i];k++) { int icol=column[k]; if (!fixed[icol]) sum += solution[icol]; if (fixed[icol]==1) sum=2.0; //don't use if any at 1 } if (sum>1.1) { suitable[i]=-1; //say no good } else { nsuitable++; } } } if (doCover&&nsuitable) temp.generateCuts(debugger, *rowCopy,solution,si.getReducedCost(), cs,suitable,fixed,false); delete [] checkRow; delete [] solution; delete [] fixed; }

---

Friends And Related Function Documentation

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

A function that tests the methods in the CglOddHole 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 23 of file CglOddHoleTest.cpp. { CoinRelFltEq eq(0.000001); // Test default constructor { CglOddHole aGenerator; } // Test copy & assignment { CglOddHole rhs; { CglOddHole bGenerator; CglOddHole cGenerator(bGenerator); rhs=bGenerator; } } // test on simple case { const int nRows=3; const int nCols=3; const int nEls=6; const double elem[]={1.0,1.0,1.0,1.0,1.0,1.0}; const int row[]={0,1,0,2,1,2}; const int start[]={0,2,4}; const int len[]={2,2,2}; CoinPackedMatrix matrix(true,nRows,nCols,nEls,elem,row,start,len); const double sol[]={0.5,0.5,0.5}; const double dj[]={0,0,0}; const int which[]={1,1,1}; const int fixed[]={0,0,0}; OsiCuts cs; CglOddHole test1; test1.generateCuts(NULL,matrix,sol,dj,cs,which,fixed,true); CoinPackedVector check; int index[] = {0,1,2}; double el[] = {1,1,1}; check.setVector(3,index,el); //assert (cs.sizeRowCuts()==2); assert (cs.sizeRowCuts()==1); // sort Elements in increasing order CoinPackedVector rpv=cs.rowCut(0).row(); rpv.sortIncrIndex(); assert (check==rpv); } // Testcase /u/rlh/osl2/mps/scOneInt.mps // Model has 3 continous, 2 binary, and 1 general // integer variable. { OsiSolverInterface * siP = baseSiP->clone(); std::string fn = mpsDir+"scOneInt"; siP->readMps(fn.c_str(),"mps"); #if 0 CglOddHole cg; int nCols=siP->getNumCols(); // Test the siP methods for detecting // variable type int numCont=0, numBinary=0, numIntNonBinary=0, numInt=0; for (int thisCol=0; thisCol<nCols; thisCol++) { if ( siP->isContinuous(thisCol) ) numCont++; if ( siP->isBinary(thisCol) ) numBinary++; if ( siP->isIntegerNonBinary(thisCol) ) numIntNonBinary++; if ( siP->isInteger(thisCol) ) numInt++; } assert(numCont==3); assert(numBinary==2); assert(numIntNonBinary==1); assert(numInt==3); // Test initializeCutGenerator siP->initialSolve(); assert(xstar !=NULL); for (i=0; i<nCols; i++){ assert(complement[i]==0); } int nRows=siP->getNumRows(); for (i=0; i<nRows; i++){ int vectorsize = siP->getMatrixByRow()->getVectorSize(i); assert(vectorsize==2); } kccg.cleanUpCutGenerator(complement,xstar); #endif delete siP; } }

---

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

• CglOddHole.hpp
• CglOddHole.cpp

---