SCIP_RETCODE SCIPconshdlrBenders::sepaBenders(
SCIP * scip,
SCIP_CONSHDLR * conshdlr,
SCIP_SOL * sol,
whereFrom where,
SCIP_RESULT * result)
{
OsiCuts cs; /**< Benders cut placeholder */
SCIP_Real * vals = NULL; /**< current solution */
#if 1
if (scip_checkpriority_ < 0)
{
/** consider incumbent solutions only */
double primObj = SCIPgetPrimalbound(scip);
double currObj = SCIPgetSolOrigObj(scip, sol);
if (SCIPisLT(scip, primObj, currObj))
{
DSPdebugMessage(" -> primObj %e currObj %e\n", primObj, currObj);
return SCIP_OKAY;
}
}
#endif
/** allocate memory */
SCIP_CALL(SCIPallocMemoryArray(scip, &vals, nvars_));
/** get current solution */
SCIP_CALL(SCIPgetSolVals(scip, sol, nvars_, vars_, vals));
/** TODO The following filter does not work, meaning that it provides suboptimal solution.
* I do not know the reason. */
#if 0
double maxviol = 1.e-10;
for (int j = 0; j < nvars_ - naux_; ++j)
{
SCIP_VARTYPE vartype = SCIPvarGetType(vars_[j]);
if (vartype == SCIP_VARTYPE_CONTINUOUS) continue;
double viol = 0.5 - fabs(vals[j] - floor(vals[j]) - 0.5);
if (viol > maxviol)
maxviol = viol;
}
DSPdebugMessage("maximum violation %e\n", maxviol);
if (where != from_scip_check &&
where != from_scip_enfolp &&
where != from_scip_enfops &&
maxviol > 1.e-7)
{
printf("where %d maxviol %e\n", where, maxviol);
/** free memory */
SCIPfreeMemoryArray(scip, &vals);
return SCIP_OKAY;
}
#endif
#ifdef DSP_DEBUG2
double minvals = COIN_DBL_MAX;
double maxvals = -COIN_DBL_MAX;
double sumvals = 0.;
double ssvals = 0.;
//printf("nvars_ %d naux_ %d nAuxvars_ %d\n", nvars_, naux_, tss_->nAuxvars_);
for (int j = 0; j < nvars_ - naux_; ++j)
{
// if (vals[j] < 0 || vals[j] > 1)
// printf("solution %d has value %e.\n", j, vals[j]);
sumvals += vals[j];
ssvals += vals[j] * vals[j];
minvals = minvals > vals[j] ? vals[j] : minvals;
maxvals = maxvals < vals[j] ? vals[j] : maxvals;
}
DSPdebugMessage("solution: min %e max %e avg %e sum %e two-norm %e\n",
minvals, maxvals, sumvals / nvars_, sumvals, sqrt(ssvals));
#endif
#define SCAN_GLOBAL_CUT_POOL
#ifdef SCAN_GLOBAL_CUT_POOL
if (SCIPgetStage(scip) == SCIP_STAGE_SOLVING ||
SCIPgetStage(scip) == SCIP_STAGE_SOLVED ||
SCIPgetStage(scip) == SCIP_STAGE_EXITSOLVE)
{
bool addedPoolCut = false;
int numPoolCuts = SCIPgetNPoolCuts(scip);
int numCutsToScan = 100;
SCIP_CUT ** poolcuts = SCIPgetPoolCuts(scip);
for (int i = numPoolCuts - 1; i >= 0; --i)
{
if (i < 0) break;
if (numCutsToScan == 0) break;
/** retrieve row */
SCIP_ROW * poolcutrow = SCIPcutGetRow(poolcuts[i]);
/** benders? */
if (strcmp(SCIProwGetName(poolcutrow), "benders") != 0)
continue;
/** counter */
numCutsToScan--;
if (SCIPgetCutEfficacy(scip, sol, poolcutrow) > 1.e-6)
{
if (where == from_scip_sepalp ||
where == from_scip_sepasol ||
where == from_scip_enfolp)
{
/** add cut */
SCIP_Bool infeasible;
SCIP_CALL(SCIPaddCut(scip, sol, poolcutrow,
FALSE, /**< force cut */
&infeasible));
if (infeasible)
*result = SCIP_CUTOFF;
else //if (*result != SCIP_CUTOFF)
*result = SCIP_SEPARATED;
}
else
*result = SCIP_INFEASIBLE;
addedPoolCut = true;
break;
}
}
if (addedPoolCut)
{
DSPdebugMessage("Added pool cut\n");
/** free memory */
SCIPfreeMemoryArray(scip, &vals);
return SCIP_OKAY;
}
}
#endif
/** generate Benders cuts */
assert(tss_);
tss_->generateCuts(nvars_, vals, &cs);
/** If found Benders cuts */
for (int i = 0; i < cs.sizeCuts(); ++i)
{
/** get cut pointer */
OsiRowCut * rc = cs.rowCutPtr(i);
if (!rc) continue;
const CoinPackedVector cutrow = rc->row();
if (cutrow.getNumElements() == 0) continue;
/** is optimality cut? */
bool isOptimalityCut = false;
for (int j = nvars_ - naux_; j < nvars_; ++j)
{
if (cutrow.getMaxIndex() == j)
{
isOptimalityCut = true;
break;
}
}
double efficacy = rc->violated(vals) / cutrow.twoNorm();
SCIP_Bool isEfficacious = efficacy > 1.e-6;
#define KK_TEST
#ifdef KK_TEST
if (SCIPgetStage(scip) == SCIP_STAGE_INITSOLVE ||
SCIPgetStage(scip) == SCIP_STAGE_SOLVING)
{
/** create empty row */
SCIP_ROW * row = NULL;
SCIP_CALL(SCIPcreateEmptyRowCons(scip, &row, conshdlr, "benders", rc->lb(), SCIPinfinity(scip),
FALSE, /**< is row local? */
FALSE, /**< is row modifiable? */
FALSE /**< is row removable? can this be TRUE? */));
/** cache the row extension and only flush them if the cut gets added */
SCIP_CALL(SCIPcacheRowExtensions(scip, row));
/** collect all non-zero coefficients */
for (int j = 0; j < cutrow.getNumElements(); ++j)
SCIP_CALL(SCIPaddVarToRow(scip, row, vars_[cutrow.getIndices()[j]], cutrow.getElements()[j]));
DSPdebugMessage("found Benders (%s) cut: act=%f, lhs=%f, norm=%f, eff=%f, min=%f, max=%f (range=%f)\n",
isOptimalityCut ? "opti" : "feas",
SCIPgetRowLPActivity(scip, row), SCIProwGetLhs(row), SCIProwGetNorm(row),
SCIPgetCutEfficacy(scip, sol, row),
SCIPgetRowMinCoef(scip, row), SCIPgetRowMaxCoef(scip, row),
SCIPgetRowMaxCoef(scip, row)/SCIPgetRowMinCoef(scip, row));
/** flush all changes before adding cut */
SCIP_CALL(SCIPflushRowExtensions(scip, row));
DSPdebugMessage("efficacy %e isEfficatious %d\n", efficacy, isEfficacious);
if (isEfficacious)
{
if (where == from_scip_sepalp ||
where == from_scip_sepasol ||
where == from_scip_enfolp)
{
/** add cut */
SCIP_Bool infeasible;
SCIP_CALL(SCIPaddCut(scip, sol, row,
FALSE, /**< force cut */
&infeasible));
if (infeasible)
*result = SCIP_CUTOFF;
else //if (*result != SCIP_CUTOFF)
*result = SCIP_SEPARATED;
}
else
*result = SCIP_INFEASIBLE;
}
/** add cut to global pool */
SCIP_CALL(SCIPaddPoolCut(scip, row));
DSPdebugMessage("number of cuts in global cut pool: %d\n", SCIPgetNPoolCuts(scip));
/** release the row */
SCIP_CALL(SCIPreleaseRow(scip, &row));
}
else if (isEfficacious &&
where != from_scip_sepalp &&
where != from_scip_sepasol &&
where != from_scip_enfolp)
*result = SCIP_INFEASIBLE;
#else
if (where == from_scip_sepalp ||
where == from_scip_sepasol ||
where == from_scip_enfolp)
{
/** create empty row */
SCIP_ROW * row = NULL;
SCIP_CALL(SCIPcreateEmptyRowCons(scip, &row, conshdlr, "benders", rc->lb(), SCIPinfinity(scip),
FALSE, /**< is row local? */
FALSE, /**< is row modifiable? */
FALSE /**< is row removable? can this be TRUE? */));
/** cache the row extension and only flush them if the cut gets added */
SCIP_CALL(SCIPcacheRowExtensions(scip, row));
/** collect all non-zero coefficients */
for (int j = 0; j < cutrow.getNumElements(); ++j)
SCIP_CALL(SCIPaddVarToRow(scip, row, vars_[cutrow.getIndices()[j]], cutrow.getElements()[j]));
DSPdebugMessage("found Benders (%s) cut: act=%f, lhs=%f, norm=%f, eff=%f, min=%f, max=%f (range=%f)\n",
isOptimalityCut ? "opti" : "feas",
SCIPgetRowLPActivity(scip, row), SCIProwGetLhs(row), SCIProwGetNorm(row),
SCIPgetCutEfficacy(scip, NULL, row),
SCIPgetRowMinCoef(scip, row), SCIPgetRowMaxCoef(scip, row),
SCIPgetRowMaxCoef(scip, row)/SCIPgetRowMinCoef(scip, row));
/** flush all changes before adding cut */
SCIP_CALL(SCIPflushRowExtensions(scip, row));
/** is cut efficacious? */
if (isOptimalityCut)
{
efficacy = SCIPgetCutEfficacy(scip, sol, row);
isEfficacious = SCIPisCutEfficacious(scip, sol, row);
}
else
{
efficacy = rc->violated(vals);
isEfficacious = efficacy > 1.e-6;
}
if (isEfficacious)
{
/** add cut */
SCIP_Bool infeasible;
SCIP_CALL(SCIPaddCut(scip, sol, row,
FALSE, /**< force cut */
&infeasible));
if (infeasible)
*result = SCIP_CUTOFF;
else if (*result != SCIP_CUTOFF)
*result = SCIP_SEPARATED;
}
/** add cut to global pool */
SCIP_CALL(SCIPaddPoolCut(scip, row));
/** release the row */
SCIP_CALL(SCIPreleaseRow(scip, &row));
}
else
{
if (isOptimalityCut)
{
efficacy = rc->violated(vals) / cutrow.twoNorm();
isEfficacious = efficacy > 0.05;
}
else
{
efficacy = rc->violated(vals);
isEfficacious = efficacy > 1.e-6;
}
DSPdebugMessage("%s efficacy %e\n", isOptimalityCut ? "Opti" : "Feas", efficacy);
if (isEfficacious == TRUE)
*result = SCIP_INFEASIBLE;
}
#endif
}
/** free memory */
SCIPfreeMemoryArray(scip, &vals);
return SCIP_OKAY;
}
//===========================================================================//
DecompConstraintSet * ATM_DecompApp::createModelRelax2(const int d){
UtilPrintFuncBegin(m_osLog, m_classTag,
"createModelRelax2()", m_appParam.LogLevel, 2);
int a, t, nRows, pairIndex, nRowsMax;
double rhs, coefA, coefC;
pair<int,int> adP;
vector<int>::const_iterator vi;
const int nSteps = m_appParam.NumSteps;
const int nAtms = m_instance.getNAtms();
const vector<int> & pairsAD = m_instance.getPairsAD();
const double * a_ad = m_instance.get_a_ad(); //dense storage
const double * b_ad = m_instance.get_b_ad(); //dense storage
const double * c_ad = m_instance.get_c_ad(); //dense storage
const double * d_ad = m_instance.get_d_ad(); //dense storage
const double * e_ad = m_instance.get_e_ad(); //dense storage
const double * w_ad = m_instance.get_w_ad(); //dense storage
const double * B_d = m_instance.get_B_d();
const int nCols = numCoreCols();
if(m_appParam.UseTightModel)
nRowsMax = 3*nAtms + 1 + getNAtmsSteps();
else
nRowsMax = 2*nAtms + 1 + (3*getNAtmsSteps());
//---
//--- A'[d] for d in D (independent blocks)
//--- for a in A
//--- f+[a,d] - f-[a,d] =
//--- a[a,d] sum{t in T} (t/n) x1[a,t] +
//--- b[a,d] x2[a] +
//--- c[a,d] sum{t in T} (t/n) z[a,t] +
//--- d[a,d] x3[a] +
//--- e[a,d]
//--- f-[a,d] <= w[a,d] * v[a,d]
//--- sum{a in A} (f+[a,d] - f-[a,d]) <= B[d]
//--- for a in A, t in T:
//--- z[a,t] <= x1[a,t],
//--- z[a,t] <= x2[a],
//--- z[a,t] >= x1[a,t] + x2[a] - 1.
//---
DecompConstraintSet * model = new DecompConstraintSet();
CoinAssertHint(model, "Error: Out of Memory");
model->M = new CoinPackedMatrix(false, 0.0, 0.0);
CoinAssertHint(model->M, "Error: Out of Memory");
model->M->setDimensions(0, nCols);
model->reserve(nRowsMax, nCols);
CoinPackedVector rowBudget;
nRows = 0;
pairIndex = 0;
for(vi = pairsAD.begin(); vi != pairsAD.end(); vi++){
adP = m_instance.getIndexADInv(*vi);
if(d != adP.second){
pairIndex++;
continue;
}
a = adP.first;
//---
//--- sum{a in A} (f+[a,d] - f-[a,d]) <= B[d]
//---
rowBudget.insert(getColOffset_fp() + pairIndex, 1.0);
rowBudget.insert(getColOffset_fm() + pairIndex, -1.0);
//---
//--- f+[a,d] - f-[a,d] =
//--- a[a,d] sum{t in T} (t/n) x1[a,t] +
//--- b[a,d] x2[a] +
//--- c[a,d] sum{t in T} (t/n) z[a,t] +
//--- d[a,d] x3[a] +
//--- e[a,d]
//---
CoinPackedVector row;
string rowName = "demand_def(a_"
+ m_instance.getAtmName(a) + ",d_"
+ m_instance.getDateName(d) + ")";
row.insert(colIndex_fp(pairIndex), 1.0);
row.insert(colIndex_fm(pairIndex), -1.0);
coefA = -a_ad[*vi] / nSteps;
coefC = -c_ad[*vi] / nSteps;
if(m_appParam.UseTightModel){
for(t = 0; t <= nSteps; t++){
row.insert(colIndex_x1(a,t), t * coefA);
row.insert(colIndex_z (a,t), t * coefC);
}
}
else{
for(t = 0; t < nSteps; t++){
row.insert(colIndex_x1(a,t), (t+1) * coefA);
row.insert(colIndex_z (a,t), (t+1) * coefC);
}
}
row.insert(colIndex_x2(a), -b_ad[*vi]);
row.insert(colIndex_x3(a), -d_ad[*vi]);
rhs = e_ad[*vi];
model->appendRow(row, rhs, rhs, rowName);
nRows++;
//---
//--- f-[a,d] <= w[a,d] * v[a,d]
//---
CoinPackedVector rowLink;
string rowNameLink = "linkv(a_"
+ m_instance.getAtmName(a) + ",d_"
+ m_instance.getDateName(d) + ")";
rowLink.insert(colIndex_fm(pairIndex), 1.0);
rowLink.insert(colIndex_v (pairIndex), -w_ad[*vi]);
model->appendRow(rowLink, -DecompInf, 0.0, rowNameLink);
nRows++;
pairIndex++;
}
string rowNameBudget = "budget(d_" + m_instance.getDateName(d) + ")";
model->appendRow(rowBudget, -DecompInf, B_d[d], rowNameBudget);
nRows++;
for(a = 0; a < nAtms; a++)
nRows += createConZtoX(model, a);
assert(nRows <= nRowsMax);
//---
//--- create model columns
//---
createModelColumns(model, -1, d);
UtilPrintFuncEnd(m_osLog, m_classTag,
"createModelRelax2()", m_appParam.LogLevel, 2);
return model;
}
bool OSI_X_SolverWrapper<SOLVERINTERFACE>::setup(const LP_Constraints & cstraints) //cstraints <-> constraints
{
bool bOk = true;
if ( si == NULL )
{
return false;
}
assert(nbParams_ == cstraints.nbParams_);
const unsigned int NUMVAR = cstraints.constraint_mat_.cols();
std::vector<double> col_lb(NUMVAR);//the column lower bounds
std::vector<double> col_ub(NUMVAR);//the column upper bounds
this->nbParams_ = NUMVAR;
si->setObjSense( ((cstraints.bminimize_) ? 1 : -1) );
const Mat & A = cstraints.constraint_mat_;
//Equality constraint will be done by two constraints due to the API limitation ( >= & <=).
const size_t nbLine = A.rows() +
std::count(cstraints.vec_sign_.begin(), cstraints.vec_sign_.end(), LP_Constraints::LP_EQUAL);
std::vector<double> row_lb(nbLine);//the row lower bounds
std::vector<double> row_ub(nbLine);//the row upper bounds
CoinPackedMatrix * matrix = new CoinPackedMatrix(false,0,0);
matrix->setDimensions(0, NUMVAR);
//-- Add row-wise constraint
size_t indexRow = 0;
for (int i=0; i < A.rows(); ++i)
{
Vec temp = A.row(i);
CoinPackedVector row;
if ( cstraints.vec_sign_[i] == LP_Constraints::LP_EQUAL || cstraints.vec_sign_[i] == LP_Constraints::LP_LESS_OR_EQUAL )
{
int coef = 1;
for ( int j = 0; j < A.cols() ; j++ )
{
row.insert(j, coef * temp.data()[j]);
}
row_lb[indexRow] = -1.0 * si->getInfinity();
row_ub[indexRow] = coef * cstraints.constraint_objective_(i);
matrix->appendRow(row);
indexRow++;
}
if ( cstraints.vec_sign_[i] == LP_Constraints::LP_EQUAL || cstraints.vec_sign_[i] == LP_Constraints::LP_GREATER_OR_EQUAL )
{
int coef = -1;
for ( int j = 0; j < A.cols() ; j++ )
{
row.insert(j, coef * temp.data()[j]);
}
row_lb[indexRow] = -1.0 * si->getInfinity();
row_ub[indexRow] = coef * cstraints.constraint_objective_(i);
matrix->appendRow(row);
indexRow++;
}
}
//-- Setup bounds for all the parameters
if (cstraints.vec_bounds_.size() == 1)
{
// Setup the same bound for all the parameters
for (int i=0; i < this->nbParams_; ++i)
{
col_lb[i] = cstraints.vec_bounds_[0].first;
col_ub[i] = cstraints.vec_bounds_[0].second;
}
}
else // each parameter have it's own bounds
{
for (int i=0; i < this->nbParams_; ++i)
{
col_lb[i] = cstraints.vec_bounds_[i].first;
col_ub[i] = cstraints.vec_bounds_[i].second;
}
}
si->loadProblem(*matrix, &col_lb[0], &col_ub[0], cstraints.vec_cost_.empty() ? NULL : &cstraints.vec_cost_[0], &row_lb[0], &row_ub[0] );
delete matrix;
return bOk;
}
/** Clean an OsiCut
\return 1 if min violation is too small
\return 2 if small coefficient can not be removed
\return 3 if dynamic is too big
\return 4 if too many non zero element*/
int
Validator::cleanCut(OsiRowCut & aCut, const double * solCut, const OsiSolverInterface &si, const CglParam& par,
const double * origColLower, const double * origColUpper) const
{
/** Compute fill-in in si */
int numcols = si.getNumCols();
const double * colLower = (origColLower) ? origColLower : si.getColLower();
const double * colUpper = (origColUpper) ? origColUpper : si.getColUpper();
int maxNnz = static_cast<int> (maxFillIn_ * static_cast<double> (numcols));
double rhs = aCut.lb();
assert (aCut.ub()> 1e50);
CoinPackedVector *vec = const_cast<CoinPackedVector *>(&aCut.row());
int * indices = vec->getIndices();
double * elems = vec->getElements();
int n = vec->getNumElements();
/** First compute violation if it is too small exit */
double violation = aCut.violated(solCut);
if (violation < minViolation_)
return 1;
/** Now relax get dynamic and remove tiny elements */
int offset = 0;
rhs -= 1e-8;
double smallest = 1e100;
double biggest = 0;
for (int i = 0 ; i < n ; i++)
{
double val = fabs(elems[i]);
if (val <= par.getEPS()) //try to remove coef
{
if (val>0 && val<1e-20)
{
offset++;
continue;
throw;
}
if (val==0)
{
offset++;
continue;
}
int & iCol = indices[i];
if (elems[i]>0. && colUpper[iCol] < 10000.)
{
offset++;
rhs -= elems[i] * colUpper[iCol];
elems[i]=0;
}
else if (elems[i]<0. && colLower[iCol] > -10000.)
{
offset++;
rhs -= elems[i] * colLower[iCol];
elems[i]=0.;
}
else
{
#ifdef DEBUG
std::cout<<"Small coefficient : "<<elems[i]<<" bounds : ["<<colLower[iCol]<<", "<<colUpper[iCol]<<std::endl;
#endif
numRejected_[SmallCoefficient]++;
return SmallCoefficient;
}
}
else //Not a small coefficient keep it
{
smallest = std::min(val,smallest);
biggest = std::max (val,biggest);
if (biggest > maxRatio_ * smallest)
{
#ifdef DEBUG
std::cout<<"Whaooo "<<biggest/smallest<<std::endl;
#endif
numRejected_[BigDynamic]++;
return BigDynamic;
}
if (offset) //if offset is zero current values are ok otherwise translate
{
int i2 = i - offset;
indices[i2] = indices[i];
elems[i2] = elems[i];
}
}
}
if ((n - offset) > maxNnz)
{
numRejected_[DenseCut] ++;
return DenseCut;
}
if (offset == n)
{
numRejected_[EmptyCut]++;
return EmptyCut;
}
if (offset)
vec->truncate(n - offset);
indices = vec->getIndices();
elems = vec->getElements();
n = vec->getNumElements();
aCut.setLb(rhs);
violation = aCut.violated(solCut);
if (violation < minViolation_)
{
numRejected_[SmallViolation]++;
return SmallViolation;
}
return NoneAccepted;
}
//===========================================================================//
int ATM_DecompApp::createConZtoX(DecompConstraintSet * model,
const int atmIndex){
//---
//--- for a in A, t in T:
//--- z[a,t] = x1[a,t] * x2[a]
//--- <==>
//--- OLD:
//--- for a in A:
//--- sum{t in T} x1[a,t] <= 1 (where, T = 1..n)
//--- for a in A, t in T:
//--- z[a,t] >= 0 <= 1,
//--- z[a,t] <= x1[a,t],
//--- z[a,t] <= x2[a],
//--- z[a,t] >= x1[a,t] + x2[a] - 1.
//--- NEW:
//--- for a in A:
//--- sum{t in T} x1[a,t] = 1 (where, T = 0..n)
//--- sum{t in T} z[a,t] = x2[a]
//--- for a in A, t in T:
//--- z[a,t] >= 0 <= 1,
//--- z[a,t] <= x1[a,t].
//---
int t;
int nRows = 0;
const int nSteps = m_appParam.NumSteps;
if(m_appParam.UseTightModel){
for(t = 0; t <= nSteps; t++){
CoinPackedVector row;
string strAT = "(a_" + m_instance.getAtmName(atmIndex)
+ ",t_" + UtilIntToStr(t) + ")";
string rowName = "ztox1" + strAT;
row.insert(colIndex_z (atmIndex,t), 1.0);
row.insert(colIndex_x1(atmIndex,t), -1.0);
model->appendRow(row, -DecompInf, 0.0, rowName);
nRows++;
}
CoinPackedVector row2;
string rowName2 = "ztox2(a_"
+ m_instance.getAtmName(atmIndex) + ")";
row2.insert(colIndex_x2(atmIndex), -1.0);
for(t = 0; t <= nSteps; t++){
row2.insert(colIndex_z (atmIndex,t), 1.0);
}
model->appendRow(row2, 0.0, 0.0, rowName2);
nRows++;
}
else{
for(t = 0; t < nSteps; t++){
CoinPackedVector row1, row2, row3;
string strAT = "(a_" + m_instance.getAtmName(atmIndex)
+ ",t_" + UtilIntToStr(t+1) + ")";
string rowName1 = "ztox1" + strAT;
string rowName2 = "ztox2" + strAT;
string rowName3 = "ztox3" + strAT;
row1.insert(colIndex_z (atmIndex,t), 1.0);
row1.insert(colIndex_x1(atmIndex,t), -1.0);
model->appendRow(row1, -DecompInf, 0.0, rowName1);
row2.insert(colIndex_z (atmIndex,t), 1.0);
row2.insert(colIndex_x2(atmIndex) , -1.0);
model->appendRow(row2, -DecompInf, 0.0, rowName2);
row3.insert(colIndex_z (atmIndex,t), 1.0);
row3.insert(colIndex_x1(atmIndex,t), -1.0);
row3.insert(colIndex_x2(atmIndex) , -1.0);
model->appendRow(row3, -1.0, DecompInf, rowName3);
nRows+=3;
}
}
return nRows;
}
// --------------------------------------------------------------------- //
int GAP_DecompApp::createModelPartAP(DecompConstraintSet* model)
{
int i, j, colIndex;
int status = GAPStatusOk;
int nTasks = m_instance.getNTasks(); //n
int nMachines = m_instance.getNMachines(); //m
int nCols = nTasks * nMachines;
int nRows = nTasks;
UtilPrintFuncBegin(m_osLog, m_classTag,
"createModelPartAP()", m_appParam.LogLevel, 2);
//---
//--- Build the core model constraints (AP = assignment problem).
//---
//--- m is number of machines (index i)
//--- n is number of tasks (index j)
//---
//--- sum{i in 1..m} x[i,j] = 1, j in 1..n
//---
//--- Example structure: m=3, n=4
//--- x x x = 1 [j=1]
//--- x x x = 1 [j=2]
//--- x x x = 1 [j=3]
//--- x x x = 1 [j=4]
//---
//---
//--- Allocate an empty row-ordered CoinPackedMatrix. Since we plan
//--- to add rows, set the column dimension and let the row dimension
//--- be set dynamically.
//---
model->M = new CoinPackedMatrix(false, 0.0, 0.0);
CoinAssertHint(model->M, "Error: Out of Memory");
model->M->setDimensions(0, nCols);
//---
//--- we know the sizes needed, so reserve space for them (for efficiency)
//---
model->reserve(nRows, nCols);
//---
//--- create one row per task
//--- rowNames are not needed, they are used for debugging
//---
for (j = 0; j < nTasks; j++) {
CoinPackedVector row;
string rowName = "a(j_" + UtilIntToStr(j) + ")";
for (i = 0; i < nMachines; i++) {
colIndex = getIndexIJ(i, j);
row.insert(colIndex, 1.0);
}
model->appendRow(row, 1.0, 1.0, rowName);
}
//---
//--- set the col upper and lower bounds (all in [0,1])
//---
UtilFillN(model->colLB, nCols, 0.0);
UtilFillN(model->colUB, nCols, 1.0);
//---
//--- set the indices of the integer variables of model
//--- (all vars are binary)
//---
UtilIotaN(model->integerVars, nCols, 0);
//---
//--- set column names for debugging
//---
colIndex = 0;
for (i = 0; i < nMachines; i++) {
for (j = 0; j < nTasks; j++) {
string colName = "x("
+ UtilIntToStr(colIndex) + "_"
+ UtilIntToStr(i) + "," + UtilIntToStr(j) + ")";
model->colNames.push_back(colName);
colIndex++;
}
}
UtilPrintFuncEnd(m_osLog, m_classTag,
"createModelPartAP()", m_appParam.LogLevel, 2);
return status;
}
bool OSI_X_SolverWrapper::setup(const LP_Constraints & cstraints) //cstraints <-> constraints
{
if ( si == nullptr )
{
return false;
}
assert(nbParams_ == cstraints.nbParams_);
const unsigned int NUMVAR = cstraints.constraint_mat_.cols();
std::vector<double>
col_lb(NUMVAR), // the column lower bounds
col_ub(NUMVAR); // the column upper bounds
this->nbParams_ = NUMVAR;
si->setObjSense( ((cstraints.bminimize_) ? 1 : -1) );
const Mat & A = cstraints.constraint_mat_;
//Equality constraint will be done by two constraints due to the API limitation ( >= & <=).
const size_t nbLine = A.rows() +
std::count(cstraints.vec_sign_.begin(), cstraints.vec_sign_.end(), LP_Constraints::LP_EQUAL);
// Define default lower and upper bound to [-inf, inf]
std::vector<double>
row_lb(nbLine, -si->getInfinity()), // the row lower bounds
row_ub(nbLine, si->getInfinity()); // the row upper bounds
std::unique_ptr<CoinPackedMatrix> matrix(new CoinPackedMatrix(false,0,0));
matrix->setDimensions(0, NUMVAR);
//-- Add row-wise constraint
size_t indexRow = 0;
for (int i=0; i < A.rows(); ++i)
{
const Vec temp = A.row(i);
CoinPackedVector row;
if (cstraints.vec_sign_[i] == LP_Constraints::LP_EQUAL ||
cstraints.vec_sign_[i] == LP_Constraints::LP_LESS_OR_EQUAL)
{
const int coef = 1;
for ( int j = 0; j < A.cols(); ++j )
{
row.insert(j, coef * temp.data()[j]);
}
row_ub[indexRow] = coef * cstraints.constraint_objective_(i);
matrix->appendRow(row);
++indexRow;
}
if (cstraints.vec_sign_[i] == LP_Constraints::LP_EQUAL ||
cstraints.vec_sign_[i] == LP_Constraints::LP_GREATER_OR_EQUAL)
{
const int coef = -1;
for ( int j = 0; j < A.cols(); ++j )
{
row.insert(j, coef * temp.data()[j]);
}
row_ub[indexRow] = coef * cstraints.constraint_objective_(i);
matrix->appendRow(row);
++indexRow;
}
}
//-- Setup bounds for all the parameters
if (cstraints.vec_bounds_.size() == 1)
{
// Setup the same bound for all the parameters
std::fill(col_lb.begin(), col_lb.end(), cstraints.vec_bounds_[0].first);
std::fill(col_ub.begin(), col_ub.end(), cstraints.vec_bounds_[0].second);
}
else // each parameter have its own bounds
{
for (int i=0; i < this->nbParams_; ++i)
{
col_lb[i] = cstraints.vec_bounds_[i].first;
col_ub[i] = cstraints.vec_bounds_[i].second;
}
}
si->loadProblem(*matrix, &col_lb[0], &col_ub[0], cstraints.vec_cost_.empty() ? nullptr : &cstraints.vec_cost_[0], &row_lb[0], &row_ub[0] );
return true;
}
//#############################################################################
OsiSolverInterface *
MibSBilevel::setUpModel(OsiSolverInterface * oSolver, bool newOsi,
const double *lpSol)
{
/** Create lower-level model with fixed upper-level vars **/
int probType =
model_->MibSPar_->entry(MibSParams::bilevelProblemType);
bool warmStartLL =
model_->MibSPar_->entry(MibSParams::warmStartLL);
bool doDualFixing =
model_->MibSPar_->entry(MibSParams::doDualFixing);
std::string feasCheckSolver =
model_->MibSPar_->entry(MibSParams::feasCheckSolver);
OsiSolverInterface * nSolver;
double etol(model_->etol_);
int i(0), j(0), index1(0), index2(0);
int uCols(model_->getUpperDim());
int lRows(model_->getLowerRowNum());
int lCols(model_->getLowerDim());
int * uColIndices = model_->getUpperColInd();
int * lColIndices = model_->getLowerColInd();
int * lRowIndices = model_->getLowerRowInd();
double objSense(model_->getLowerObjSense());
double * lObjCoeffs = model_->getLowerObjCoeffs();
const CoinPackedMatrix * matrix = oSolver->getMatrixByRow();
double coeff(0.0);
if (!lpSol){
lpSol = oSolver->getColSolution();
}
const double * origRowLb = model_->getOrigRowLb();
const double * origRowUb = model_->getOrigRowUb();
const double * origColLb = model_->getOrigColLb();
const double * origColUb = model_->getOrigColUb();
double * rowUb = new double[lRows];
double * rowLb = new double[lRows];
double * colUb = new double[lCols];
double * colLb = new double[lCols];
//CoinZeroN(rowUb, lRows);
//CoinZeroN(rowLb, lRows);
//CoinZeroN(colUb, lCols);
//CoinZeroN(colLb, lCols);
/** Set the row bounds **/
for(i = 0; i < lRows; i++){
rowLb[i] = origRowLb[lRowIndices[i]];
rowUb[i] = origRowUb[lRowIndices[i]];
}
for(i = 0; i < lCols; i++){
colLb[i] = origColLb[lColIndices[i]];
colUb[i] = origColUb[lColIndices[i]];
}
if (newOsi){
if (feasCheckSolver == "Cbc"){
nSolver = new OsiCbcSolverInterface();
}else if (feasCheckSolver == "SYMPHONY"){
nSolver = new OsiSymSolverInterface();
}else if (feasCheckSolver == "CPLEX"){
#ifdef USE_CPLEX
nSolver = new OsiCpxSolverInterface();
#else
throw CoinError("CPLEX chosen as solver, but it has not been enabled",
"setUpModel", "MibsBilevel");
#endif
}else{
throw CoinError("Unknown solver chosen",
"setUpModel", "MibsBilevel");
}
int * integerVars = new int[lCols];
double * objCoeffs = new double[lCols];
CoinFillN(integerVars, lCols, 0);
//CoinZeroN(objCoeffs, lCols);
int intCnt(0);
/** Fill in array of lower-level integer variables **/
for(i = 0; i < lCols; i++){
index1 = lColIndices[i];
if(oSolver->isInteger(index1)){
integerVars[intCnt] = i;
intCnt++;
}
}
CoinDisjointCopyN(lObjCoeffs, lCols, objCoeffs);
CoinPackedMatrix * newMat = new CoinPackedMatrix(false, 0, 0);
newMat->setDimensions(0, lCols);
double tmp(0.0);
/*
for(i = 0; i < lRows; i++){
CoinPackedVector row;
index1 = lRowIndices[i];
start = matStarts[index1];
end = start + matrix->getVectorSize(index1);
for(j = start; j < end; j++){
index2 = matIndices[j];
//tmp = findIndex(index, lCols, lColIndices);
tmp = binarySearch(0, lCols - 1, index2, lColIndices);
if(tmp > -1)
row.insert(tmp, matElements[j]);
}
newMat->appendRow(row);
}
*/
for(i = 0; i < lRows; i++){
CoinPackedVector row;
index1 = lRowIndices[i];
for(j = 0; j < lCols; j++){
index2 = lColIndices[j];
tmp = matrix->getCoefficient(index1, index2);
row.insert(j, tmp);
}
newMat->appendRow(row);
}
/*
nSolver->assignProblem(newMat, colLb, colUb,
objCoeffs, rowLb, rowUb);
*/
nSolver->loadProblem(*newMat, colLb, colUb,
objCoeffs, rowLb, rowUb);
for(i = 0; i < intCnt; i++){
nSolver->setInteger(integerVars[i]);
}
//nSolver->setInteger(integerVars, intCnt);
nSolver->setObjSense(objSense); //1 min; -1 max
nSolver->setHintParam(OsiDoReducePrint, true, OsiHintDo);
#if 0
if(0){
dynamic_cast<OsiCbcSolverInterface *>
(nSolver)->getModelPtr()->messageHandler()->setLogLevel(0);
}
else{
dynamic_cast<OsiSymSolverInterface *>
(nSolver)->setSymParam("prep_level", -1);
dynamic_cast<OsiSymSolverInterface *>
(nSolver)->setSymParam("verbosity", -2);
dynamic_cast<OsiSymSolverInterface *>
(nSolver)->setSymParam("max_active_nodes", 1);
}
#endif
delete [] integerVars;
}else{
nSolver = solver_;
}
#define SYM_VERSION_IS_WS strcmp(SYMPHONY_VERSION, "WS")
#if SYMPHONY_VERSION_IS_WS
if (feasCheckSolver == "SYMPHONY" && probType == 1 && warmStartLL &&
!newOsi && doDualFixing){ //Interdiction
/** Get upper bound from best known (feasible) lower level solution and try
to fix additional variables by sensitivity analysis **/
std::vector<std::pair<AlpsKnowledge*, double> > solutionPool;
model_->getKnowledgeBroker()->
getAllKnowledges(AlpsKnowledgeTypeSolution, solutionPool);
const double * sol;
double objval, Ub(objSense*nSolver->getInfinity());
BlisSolution* blisSol;
std::vector<std::pair<AlpsKnowledge*, double> >::const_iterator si;
for (si = solutionPool.begin(); si != solutionPool.end(); ++si){
blisSol = dynamic_cast<BlisSolution*>(si->first);
sol = blisSol->getValues();
for (i = 0; i < uCols; i++){
if (lpSol[uColIndices[i]] > 1 - etol &&
sol[lColIndices[i]] > 1-etol){
break;
}
}
if (i == uCols && -objSense*blisSol->getQuality() < Ub){
Ub = -objSense*blisSol->getQuality();
}
}
/** Figure out which variables get fixed by the upper level solution **/
int *newUbInd = new int[uCols];
int *newLbInd = new int[uCols];
double *newUbVal = new double[uCols];
double *newLbVal = new double[uCols];
double newLb;
for (i = 0; i < uCols; i++){
newUbInd[i] = uColIndices[i];
newLbInd[i] = uColIndices[i];
newLbVal[i] = 0;
if (lpSol[uColIndices[i]] > 1 - etol){
newUbVal[i] = 0;
}else{
newUbVal[i] = 1;
}
}
/** If we found an upper bound, then do the dual fixing **/
if (Ub < objSense*nSolver->getInfinity()){
sym_environment *env =
dynamic_cast<OsiSymSolverInterface *>(nSolver)->getSymphonyEnvironment();
for (i = 0; i < uCols; i++){
if (newUbVal[i] == 1){
// Try fixing it to zero
newUbVal[i] = 0;
sym_get_lb_for_new_rhs(env, 0, NULL, NULL, uCols, newLbInd,
newLbVal, uCols, newUbInd, newUbVal,
&newLb);
if (objSense*newLb > Ub + etol){
//Victory! This variable can be fixed to 1 permanently
newLbVal[i] = 1;
}
//Set upper bound back to 1
newUbVal[i] = 1;
if (newLbVal[i] == 0){
// Try fixing it to one
newLbVal[i] = 1;
sym_get_lb_for_new_rhs(env, 0, NULL, NULL, uCols, newLbInd,
newLbVal, uCols, newUbInd, newUbVal,
&newLb);
if (objSense*newLb > Ub + etol){
//Victory! This variable can be fixed to 0 permanently
newUbVal[i] = 0;
}
newLbVal[i] = 0;
}
}
}
}
/** Now set the row bounds to account for fixings **/
/** This is probably very frgaile. Assuming interdiction
rows come last. It would be better to set variable
bounds directly, but this doesn't seem to work right now. **/
int iRowStart = lRows-uCols;
#if 1
for(i = iRowStart; i < lRows; i++){
nSolver->setRowLower(i, newLbVal[i-iRowStart]);
nSolver->setRowUpper(i, newUbVal[i-iRowStart]);
}
#else
for(i = 0; i < uCols; i++){
nSolver->setColLower(i, newLbVal[i]);
nSolver->setColUpper(i, newUbVal[i]);
}
#endif
delete[] newUbInd;
delete[] newLbInd;
delete[] newUbVal;
delete[] newLbVal;
}else{
#endif
//FIXME: NEED TO GET ROW SENSE HERE
/** Get contribution of upper-level columns **/
double * upComp = new double[lRows];
CoinFillN(upComp, lRows, 0.0);
for(i = 0; i < lRows; i++){
index1 = lRowIndices[i];
for(j = 0; j < uCols; j++){
index2 = uColIndices[j];
coeff = matrix->getCoefficient(index1, index2);
if (coeff != 0){
upComp[i] += coeff * lpSol[index2];
}
}
}
/** Correct the row bounds to account for fixed upper-level vars **/
for(i = 0; i < lRows; i++){
nSolver->setRowLower(i, rowLb[i] - upComp[i]);
nSolver->setRowUpper(i, rowUb[i] - upComp[i]);
}
delete [] upComp;
#if SYMPHONY_VERSION_IS_WS
}
#endif
//I don't think this is needed
//if(!getWarmStart())
// setWarmStart(nSolver->getWarmStart());
return nSolver;
}
//--------------------------------------------------------------------------
// test EKKsolution methods.
void
CglProbingUnitTest(
const OsiSolverInterface * baseSiP,
const std::string mpsDir )
{
# ifdef CGL_DEBUG
int i ; // define just once
# endif
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 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;
#ifdef CGL_DEBUG
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;
}
}
#endif
}
#ifdef CGL_DEBUG
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;
}
}
#endif
if (nRowCuts==1) {
CoinPackedVector check;
int index[] = {6,32};
double el[] = {1,1};
check.setVector(2,index,el);
// sort Elements in increasing order
CoinPackedVector rpv=osicuts.rowCut(0).row();
assert (rpv.getNumElements()==2);
rpv.sortIncrIndex();
assert (check==rpv);
assert (osicuts.rowCut(0).lb()==1.0);
}
// now all variables
osicuts=OsiCuts();
test1.setMode(2);
test1.setRowCuts(3);
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;
#ifdef CGL_DEBUG
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;
}
}
#endif
}
#ifdef CGL_DEBUG
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;
}
}
#endif
assert (osicuts.sizeRowCuts()>=4);
delete siP;
}
}
int main (int argc, const char *argv[])
{
// Define your favorite OsiSolver
OsiClpSolverInterface solver1;
// Read in model using argv[1]
// and assert that it is a clean model
std::string mpsFileName;
#if defined(SAMPLEDIR)
mpsFileName = SAMPLEDIR "/p0033.mps";
#else
if (argc < 2) {
fprintf(stderr, "Do not know where to find sample MPS files.\n");
exit(1);
}
#endif
if (argc>=2) mpsFileName = argv[1];
int numMpsReadErrors = solver1.readMps(mpsFileName.c_str(),"");
assert(numMpsReadErrors==0);
double time1 = CoinCpuTime();
/* Options are:
preprocess to do preprocessing
time in minutes
if 2 parameters and numeric taken as time
*/
bool preProcess=false;
double minutes=-1.0;
int nGoodParam=0;
for (int iParam=2; iParam<argc;iParam++) {
if (!strcmp(argv[iParam],"preprocess")) {
preProcess=true;
nGoodParam++;
} else if (!strcmp(argv[iParam],"time")) {
if (iParam+1<argc&&isdigit(argv[iParam+1][0])) {
minutes=atof(argv[iParam+1]);
if (minutes>=0.0) {
nGoodParam+=2;
iParam++; // skip time
}
}
}
}
if (nGoodParam==0&&argc==3&&isdigit(argv[2][0])) {
// If time is given then stop after that number of minutes
minutes = atof(argv[2]);
if (minutes>=0.0)
nGoodParam=1;
}
if (nGoodParam!=argc-2&&argc>=2) {
printf("Usage <file> [preprocess] [time <minutes>] or <file> <minutes>\n");
exit(1);
}
//solver1.getModelPtr()->setLogLevel(0);
solver1.messageHandler()->setLogLevel(0);
solver1.initialSolve();
// Reduce printout
solver1.setHintParam(OsiDoReducePrint,true,OsiHintTry);
CbcModel model(solver1);
model.solver()->setHintParam(OsiDoReducePrint,true,OsiHintTry);
// Set up some cut generators and defaults
// Probing first as gets tight bounds on continuous
CglProbing generator1;
generator1.setUsingObjective(true);
generator1.setMaxPass(1);
generator1.setMaxPassRoot(5);
// Number of unsatisfied variables to look at
generator1.setMaxProbe(10);
generator1.setMaxProbeRoot(1000);
// How far to follow the consequences
generator1.setMaxLook(50);
generator1.setMaxLookRoot(500);
// Only look at rows with fewer than this number of elements
generator1.setMaxElements(200);
generator1.setRowCuts(3);
CglGomory generator2;
// try larger limit
generator2.setLimit(300);
CglKnapsackCover generator3;
CglRedSplit generator4;
// try larger limit
generator4.setLimit(200);
CglClique generator5;
generator5.setStarCliqueReport(false);
generator5.setRowCliqueReport(false);
CglMixedIntegerRounding2 mixedGen;
CglFlowCover flowGen;
// Add in generators
// Experiment with -1 and -99 etc
model.addCutGenerator(&generator1,-1,"Probing");
model.addCutGenerator(&generator2,-1,"Gomory");
model.addCutGenerator(&generator3,-1,"Knapsack");
// model.addCutGenerator(&generator4,-1,"RedSplit");
model.addCutGenerator(&generator5,-1,"Clique");
model.addCutGenerator(&flowGen,-1,"FlowCover");
model.addCutGenerator(&mixedGen,-1,"MixedIntegerRounding");
OsiClpSolverInterface * osiclp = dynamic_cast< OsiClpSolverInterface*> (model.solver());
// go faster stripes
if (osiclp) {
// Turn this off if you get problems
// Used to be automatically set
osiclp->setSpecialOptions(128);
if(osiclp->getNumRows()<300&&osiclp->getNumCols()<500) {
//osiclp->setupForRepeatedUse(2,1);
osiclp->setupForRepeatedUse(0,1);
}
}
// Uncommenting this should switch off most CBC messages
//model.messagesPointer()->setDetailMessages(10,5,5000);
// Allow rounding heuristic
CbcRounding heuristic1(model);
model.addHeuristic(&heuristic1);
// And local search when new solution found
CbcHeuristicLocal heuristic2(model);
model.addHeuristic(&heuristic2);
// Redundant definition of default branching (as Default == User)
CbcBranchUserDecision branch;
model.setBranchingMethod(&branch);
// Definition of node choice
CbcCompareUser compare;
model.setNodeComparison(compare);
// Do initial solve to continuous
model.initialSolve();
// Could tune more
double objValue = model.solver()->getObjSense()*model.solver()->getObjValue();
double minimumDropA=CoinMin(1.0,fabs(objValue)*1.0e-3+1.0e-4);
double minimumDrop= fabs(objValue)*1.0e-4+1.0e-4;
printf("min drop %g (A %g)\n",minimumDrop,minimumDropA);
model.setMinimumDrop(minimumDrop);
if (model.getNumCols()<500)
model.setMaximumCutPassesAtRoot(-100); // always do 100 if possible
else if (model.getNumCols()<5000)
model.setMaximumCutPassesAtRoot(100); // use minimum drop
else
model.setMaximumCutPassesAtRoot(20);
model.setMaximumCutPasses(10);
//model.setMaximumCutPasses(2);
// Switch off strong branching if wanted
// model.setNumberStrong(0);
// Do more strong branching if small
if (model.getNumCols()<5000)
model.setNumberStrong(10);
model.setNumberStrong(20);
//model.setNumberStrong(5);
model.setNumberBeforeTrust(5);
//model.setSizeMiniTree(2);
model.solver()->setIntParam(OsiMaxNumIterationHotStart,100);
// If time is given then stop after that number of minutes
if (minutes>=0.0) {
std::cout<<"Stopping after "<<minutes<<" minutes"<<std::endl;
model.setDblParam(CbcModel::CbcMaximumSeconds,60.0*minutes);
}
// Switch off most output
if (model.getNumCols()<3000) {
model.messageHandler()->setLogLevel(1);
//model.solver()->messageHandler()->setLogLevel(0);
} else {
model.messageHandler()->setLogLevel(2);
model.solver()->messageHandler()->setLogLevel(1);
}
// Default strategy will leave cut generators as they exist already
// so cutsOnlyAtRoot (1) ignored
// numberStrong (2) is 5 (default)
// numberBeforeTrust (3) is 5 (default is 0)
// printLevel (4) defaults (0)
CbcStrategyDefault strategy(true,5,5);
// Set up pre-processing to find sos if wanted
if (preProcess)
strategy.setupPreProcessing(2);
model.setStrategy(strategy);
// Go round adding cuts to cutoff last solution
// Stop after finding 20 best solutions
for (int iPass=0;iPass<20;iPass++) {
time1 = CoinCpuTime();
// Do complete search
model.branchAndBound();
std::cout<<mpsFileName<<" took "<<CoinCpuTime()-time1<<" seconds, "
<<model.getNodeCount()<<" nodes with objective "
<<model.getObjValue()
<<(!model.status() ? " Finished" : " Not finished")
<<std::endl;
// Stop if infeasible
if (model.isProvenInfeasible())
break;
// Print solution if finished - we can't get names from Osi! - so get from OsiClp
assert (model.getMinimizationObjValue()<1.0e50);
OsiSolverInterface * solver = model.solver();
int numberColumns = solver->getNumCols();
const double * solution = model.bestSolution();
//const double * lower = solver->getColLower();
//const double * upper = solver->getColUpper();
// Get names from solver1 (as OsiSolverInterface may lose)
std::vector<std::string> columnNames = *solver1.getModelPtr()->columnNames();
int iColumn;
std::cout<<std::setiosflags(std::ios::fixed|std::ios::showpoint)<<std::setw(14);
std::cout<<"--------------------------------------"<<std::endl;
for (iColumn=0;iColumn<numberColumns;iColumn++) {
double value=solution[iColumn];
if (fabs(value)>1.0e-7&&solver->isInteger(iColumn))
std::cout<<std::setw(6)<<iColumn<<" "
<<columnNames[iColumn]<<" "
<<value
//<<" "<<lower[iColumn]<<" "<<upper[iColumn]
<<std::endl;
}
std::cout<<"--------------------------------------"<<std::endl;
std::cout<<std::resetiosflags(std::ios::fixed|std::ios::showpoint|std::ios::scientific);
/* Now add cut to reference copy.
resetting to reference copy also gets rid of best solution so we
should either save best solution, reset, add cut OR
add cut to reference copy then reset - this is doing latter
*/
OsiSolverInterface * refSolver = model.referenceSolver();
const double * bestSolution = model.bestSolution();
const double * originalLower = refSolver->getColLower();
const double * originalUpper = refSolver->getColUpper();
CoinPackedVector cut;
double rhs = 1.0;
for (iColumn=0;iColumn<numberColumns;iColumn++) {
double value=bestSolution[iColumn];
if (solver->isInteger(iColumn)) {
// only works for 0-1 variables
assert (originalLower[iColumn]==0.0&&
originalUpper[iColumn]==1.0);
// double check integer
assert (fabs(floor(value+0.5)-value)<1.0e-5);
if (value>0.5) {
// at 1.0
cut.insert(iColumn,-1.0);
rhs -= 1.0;
} else {
// at 0.0
cut.insert(iColumn,1.0);
}
}
}
// now add cut
refSolver->addRow(cut,rhs,COIN_DBL_MAX);
model.resetToReferenceSolver();
}
return 0;
}
//--------------------------------------------------------------------------
// ** At present this does not use any solver
void
CglGomoryUnitTest(
const OsiSolverInterface * baseSiP,
const std::string mpsDir )
{
CoinRelFltEq eq(0.000001);
// Test default constructor
{
CglGomory aGenerator;
assert (aGenerator.getLimit()==50);
assert (aGenerator.getAway()==0.05);
}
// Test copy & assignment etc
{
CglGomory rhs;
{
CglGomory bGenerator;
bGenerator.setLimit(99);
bGenerator.setAway(0.2);
CglGomory cGenerator(bGenerator);
rhs=bGenerator;
assert (rhs.getLimit()==99);
assert (rhs.getAway()==0.2);
}
}
// Test explicit form - all integer (pg 125 Wolsey)
if (1) {
OsiCuts osicuts;
CglGomory test1;
int i;
int nOldCuts=0,nRowCuts;
// matrix data
//deliberate hiccup of 2 between 0 and 1
CoinBigIndex start[5]={0,4,7,8,9};
int length[5]={2,3,1,1,1};
int rows[11]={0,2,-1,-1,0,1,2,0,1,2};
double elements[11]={7.0,2.0,1.0e10,1.0e10,-2.0,1.0,-2.0,1,1,1};
CoinPackedMatrix matrix(true,3,5,8,elements,rows,start,length);
// rim data (objective not used just yet)
double rowLower[5]={14.0,3.0,3.0,1.0e10,1.0e10};
double rowUpper[5]={14.0,3.0,3.0,-1.0e10,-1.0e10};
double colLower[7]={0.0,0.0,0.0,0.0,0.0,0.0,0.0};
double colUpper[7]={100.0,100.0,100.0,100.0,100.0,100.0,100.0};
// integer
char intVar[7]={2,2,2,2,2,2,2};
// basis 1
int rowBasis1[3]={-1,-1,-1};
int colBasis1[5]={1,1,-1,-1,1};
CoinWarmStartBasis warm;
warm.setSize(5,3);
for (i=0;i<3;i++) {
if (rowBasis1[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<5;i++) {
if (colBasis1[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 1
double colsol1[5]={20.0/7.0,3.0,0.0,0.0,23.0/7.0};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol1,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts==2);
// cuts always <=
int testCut=0; // test first cut as stronger
double rhs=-6.0;
double testCut1[5]={0.0,0.0,-1.0,-2.0,0.0};
double * cut = testCut1;
double * colsol = colsol1;
for (i=nOldCuts; i<nRowCuts; i++){
OsiRowCut rcut;
CoinPackedVector rpv;
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;
for (k=0; k<n; k++){
int column=indices[k];
sum2 += colsol[column]*elements[k];
}
double ub=rcut.ub();
#ifdef CGL_DEBUG
double lb=rcut.lb();
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;
}
#endif
if (i-nOldCuts==testCut) {
assert( eq(rhs,ub));
assert(n==2);
for (k=0; k<n; k++){
int column=indices[k];
assert (eq(cut[column],elements[k]));
}
// add cut
// explicit slack
matrix.setDimensions(-1,6);
rpv.insert(5,1.0*7.0); // to get cut in book
rowLower[3]=ub;
rowUpper[3]=ub;
matrix.appendRow(rpv);
}
}
nOldCuts=nRowCuts;
// basis 2
int rowBasis2[4]={-1,-1,-1,-1};
int colBasis2[6]={1,1,1,1,-1,-1};
warm.setSize(6,4);
for (i=0;i<4;i++) {
if (rowBasis2[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<6;i++) {
if (colBasis2[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 2
double colsol2[6]={2.0,0.5,1.0,2.5,0.0,0.0};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol2,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts-nOldCuts==2);
// cuts always <=
testCut=0; // test first cut as stronger
rhs=-1.0;
double testCut2[6]={0.0,0.0,0.0,0.0,-1.0,0.0};
cut = testCut2;
colsol = colsol2;
for (i=nOldCuts; i<nRowCuts; i++){
OsiRowCut rcut;
CoinPackedVector rpv;
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;
for (k=0; k<n; k++){
int column=indices[k];
sum2 += colsol[column]*elements[k];
}
double ub=rcut.ub();
#ifdef CGL_DEBUG
double lb=rcut.lb();
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;
}
#endif
if (i-nOldCuts==testCut) {
assert( eq(rhs,ub));
assert(n==1);
for (k=0; k<n; k++){
int column=indices[k];
assert (eq(cut[column],elements[k]));
}
// add cut
// explicit slack
matrix.setDimensions(-1,7);
rpv.insert(6,1.0);
rowLower[4]=ub;
rowUpper[4]=ub;
matrix.appendRow(rpv);
}
}
nOldCuts=nRowCuts;
// basis 3
int rowBasis3[5]={-1,-1,-1,-1,-1};
int colBasis3[7]={1,1,1,1,1,-1,-1};
warm.setSize(7,5);
for (i=0;i<5;i++) {
if (rowBasis3[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<7;i++) {
if (colBasis3[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 3
double colsol3[7]={2.0,1.0,2.0,2.0,1.0,0.0,0.0};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol3,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts==nOldCuts);
}
// Test explicit form - this time with x4 flipped
if (1) {
OsiCuts osicuts;
CglGomory test1;
int i;
int nOldCuts=0,nRowCuts;
// matrix data
//deliberate hiccup of 2 between 0 and 1
CoinBigIndex start[5]={0,4,7,8,9};
int length[5]={2,3,1,1,1};
int rows[11]={0,2,-1,-1,0,1,2,0,1,2};
double elements[11]={7.0,2.0,1.0e10,1.0e10,-2.0,1.0,-2.0,1,-1,1};
CoinPackedMatrix matrix(true,3,5,8,elements,rows,start,length);
// rim data (objective not used just yet)
double rowLower[5]={14.0,-5.0,3.0,1.0e10,1.0e10};
double rowUpper[5]={14.0,-5.0,3.0,-1.0e10,-1.0e10};
double colLower[7]={0.0,0.0,0.0,0.0,0.0,0.0,0.0};
double colUpper[7]={100.0,100.0,100.0,8.0,100.0,100.0,100.0};
// integer
char intVar[7]={2,2,2,2,2,2,2};
// basis 1
int rowBasis1[3]={-1,-1,-1};
int colBasis1[5]={1,1,-1,-1,1};
CoinWarmStartBasis warm;
warm.setSize(5,3);
for (i=0;i<3;i++) {
if (rowBasis1[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<5;i++) {
if (colBasis1[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 1
double colsol1[5]={20.0/7.0,3.0,0.0,8.0,23.0/7.0};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol1,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts==2);
// cuts always <=
int testCut=0; // test first cut as stronger
double rhs=10.0;
double testCut1[5]={0.0,0.0,-1.0,2.0,0.0};
double * cut = testCut1;
double * colsol = colsol1;
for (i=nOldCuts; i<nRowCuts; i++){
OsiRowCut rcut;
CoinPackedVector rpv;
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;
for (k=0; k<n; k++){
int column=indices[k];
sum2 += colsol[column]*elements[k];
}
double ub=rcut.ub();
#ifdef CGL_DEBUG
double lb=rcut.lb();
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;
}
#endif
if (i-nOldCuts==testCut) {
assert( eq(rhs,ub));
assert(n==2);
for (k=0; k<n; k++){
int column=indices[k];
assert (eq(cut[column],elements[k]));
}
// add cut
// explicit slack
matrix.setDimensions(-1,6);
rpv.insert(5,1.0*7.0); // to get cut in book
rowLower[3]=ub;
rowUpper[3]=ub;
matrix.appendRow(rpv);
}
}
nOldCuts=nRowCuts;
// basis 2
int rowBasis2[4]={-1,-1,-1,-1};
int colBasis2[6]={1,1,1,1,-1,-1};
warm.setSize(6,4);
for (i=0;i<4;i++) {
if (rowBasis2[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<6;i++) {
if (colBasis2[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 2
double colsol2[6]={2.0,0.5,1.0,5.5,0.0,0.0};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol2,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts-nOldCuts==2);
// cuts always <=
testCut=0; // test first cut as stronger
rhs=-1.0;
double testCut2[6]={0.0,0.0,0.0,0.0,-1.0,0.0};
cut = testCut2;
colsol = colsol2;
for (i=nOldCuts; i<nRowCuts; i++){
OsiRowCut rcut;
CoinPackedVector rpv;
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;
for (k=0; k<n; k++){
int column=indices[k];
sum2 += colsol[column]*elements[k];
}
double ub=rcut.ub();
#ifdef CGL_DEBUG
double lb=rcut.lb();
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;
}
#endif
if (i-nOldCuts==testCut) {
assert( eq(rhs,ub));
assert(n==1);
for (k=0; k<n; k++){
int column=indices[k];
assert (eq(cut[column],elements[k]));
}
// add cut
// explicit slack
matrix.setDimensions(-1,7);
rpv.insert(6,1.0);
rowLower[4]=ub;
rowUpper[4]=ub;
matrix.appendRow(rpv);
}
}
nOldCuts=nRowCuts;
// basis 3
int rowBasis3[5]={-1,-1,-1,-1,-1};
int colBasis3[7]={1,1,1,1,1,-1,-1};
warm.setSize(7,5);
for (i=0;i<5;i++) {
if (rowBasis3[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<7;i++) {
if (colBasis3[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 3
double colsol3[7]={2.0,1.0,2.0,6.0,1.0,0.0,0.0};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol3,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts==nOldCuts);
}
// Test with slacks
if (1) {
OsiCuts osicuts;
CglGomory test1;
int i;
int nOldCuts=0,nRowCuts;
// matrix data
//deliberate hiccup of 2 between 0 and 1
CoinBigIndex start[5]={0,4};
int length[5]={2,3};
int rows[11]={0,2,-1,-1,0,1,2};
double elements[11]={7.0,2.0,1.0e10,1.0e10,-2.0,1.0,-2.0};
CoinPackedMatrix matrix(true,3,2,5,elements,rows,start,length);
// rim data (objective not used just yet)
double rowLower[5]={-1.0e10,-1.0e10,-1.0e10,1.0e10,1.0e10};
double rowUpper[5]={14.0,3.0,3.0,-1.0e10,-1.0e10};
double colLower[2]={0.0,0.0};
double colUpper[2]={100.0,100.0};
// integer
char intVar[2]={2,2};
// basis 1
int rowBasis1[3]={-1,-1,1};
int colBasis1[2]={1,1};
CoinWarmStartBasis warm;
warm.setSize(2,3);
for (i=0;i<3;i++) {
if (rowBasis1[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<2;i++) {
if (colBasis1[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 1
double colsol1[2]={20.0/7.0,3.0};
test1.generateCuts(NULL, osicuts, matrix,
/* objective,*/ colsol1,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts==1);
// cuts always <=
int testCut=0; // test first cut as stronger
double rhs=2.0;
double testCut1[2]={1.0,0.0};
double * cut = testCut1;
double * colsol = colsol1;
for (i=nOldCuts; i<nRowCuts; i++){
OsiRowCut rcut;
CoinPackedVector rpv;
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;
for (k=0; k<n; k++){
int column=indices[k];
sum2 += colsol[column]*elements[k];
}
double ub=rcut.ub();
#ifdef CGL_DEBUG
double lb=rcut.lb();
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;
}
#endif
if (i-nOldCuts==testCut) {
assert( eq(rhs,ub));
assert(n==1);
for (k=0; k<n; k++){
int column=indices[k];
assert (eq(cut[column],elements[k]));
}
// add cut
rowLower[3]=-1.0e100;
rowUpper[3]=ub;
matrix.appendRow(rpv);
}
}
nOldCuts=nRowCuts;
// basis 2
int rowBasis2[4]={1,1,-1,-1};
int colBasis2[2]={1,1};
warm.setSize(2,4);
for (i=0;i<4;i++) {
if (rowBasis2[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<2;i++) {
if (colBasis2[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 2
double colsol2[2]={2.0,0.5};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol2,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts-nOldCuts==1);
// cuts always <=
testCut=0; // test first cut as stronger
rhs=1.0;
double testCut2[2]={1.0,-1.0};
cut = testCut2;
colsol = colsol2;
for (i=nOldCuts; i<nRowCuts; i++){
OsiRowCut rcut;
CoinPackedVector rpv;
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;
for (k=0; k<n; k++){
int column=indices[k];
sum2 += colsol[column]*elements[k];
}
double ub=rcut.ub();
#ifdef CGL_DEBUG
double lb=rcut.lb();
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;
}
#endif
if (i-nOldCuts==testCut) {
assert( eq(rhs,ub));
assert(n==2);
for (k=0; k<n; k++){
int column=indices[k];
assert (eq(cut[column],elements[k]));
}
// add cut
rowLower[4]=-1.0e100;
rowUpper[4]=ub;
matrix.appendRow(rpv);
}
}
nOldCuts=nRowCuts;
// basis 3
int rowBasis3[5]={1,1,1,-1,-1};
int colBasis3[2]={1,1};
warm.setSize(2,5);
for (i=0;i<5;i++) {
if (rowBasis3[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<2;i++) {
if (colBasis3[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 3
double colsol3[2]={2.0,1.0};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol3,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts==nOldCuts);
}
// swap some rows to G
if (1) {
OsiCuts osicuts;
CglGomory test1;
int i;
int nOldCuts=0,nRowCuts;
// matrix data
//deliberate hiccup of 2 between 0 and 1
CoinBigIndex start[5]={0,4};
int length[5]={2,3};
int rows[11]={0,2,-1,-1,0,1,2};
double elements[11]={-7.0,-2.0,1.0e10,1.0e10,+2.0,1.0,+2.0};
CoinPackedMatrix matrix(true,3,2,5,elements,rows,start,length);
// rim data (objective not used just yet)
double rowUpper[5]={1.0e10,3.0,1.0e10,-1.0e10,-1.0e10};
double rowLower[5]={-14.0,-1.0e10,-3.0,1.0e10,1.0e10};
double colLower[2]={0.0,0.0};
double colUpper[2]={100.0,100.0};
// integer
char intVar[2]={2,2};
// basis 1
int rowBasis1[3]={-1,-1,1};
int colBasis1[2]={1,1};
CoinWarmStartBasis warm;
warm.setSize(2,3);
for (i=0;i<3;i++) {
if (rowBasis1[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<2;i++) {
if (colBasis1[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 1
double colsol1[2]={20.0/7.0,3.0};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol1,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts==1);
// cuts always <=
int testCut=0; // test first cut as stronger
double rhs=2.0;
double testCut1[2]={1.0,0.0};
double * cut = testCut1;
double * colsol = colsol1;
for (i=nOldCuts; i<nRowCuts; i++){
OsiRowCut rcut;
CoinPackedVector rpv;
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;
for (k=0; k<n; k++){
int column=indices[k];
sum2 += colsol[column]*elements[k];
}
double ub=rcut.ub();
#ifdef CGL_DEBUG
double lb=rcut.lb();
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;
}
#endif
if (i-nOldCuts==testCut) {
assert( eq(rhs,ub));
assert(n==1);
for (k=0; k<n; k++){
int column=indices[k];
assert (eq(cut[column],elements[k]));
}
// add cut
rowLower[3]=-1.0e100;
rowUpper[3]=ub;
matrix.appendRow(rpv);
}
}
nOldCuts=nRowCuts;
// basis 2
int rowBasis2[4]={1,1,-1,-1};
int colBasis2[2]={1,1};
warm.setSize(2,4);
for (i=0;i<4;i++) {
if (rowBasis2[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<2;i++) {
if (colBasis2[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 2
double colsol2[2]={2.0,0.5};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol2,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts-nOldCuts==1);
// cuts always <=
testCut=0; // test first cut as stronger
rhs=1.0;
double testCut2[2]={1.0,-1.0};
cut = testCut2;
colsol = colsol2;
for (i=nOldCuts; i<nRowCuts; i++){
OsiRowCut rcut;
CoinPackedVector rpv;
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;
for (k=0; k<n; k++){
int column=indices[k];
sum2 += colsol[column]*elements[k];
}
double ub=rcut.ub();
#ifdef CGL_DEBUG
double lb=rcut.lb();
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;
}
#endif
if (i-nOldCuts==testCut) {
assert( eq(rhs,ub));
assert(n==2);
for (k=0; k<n; k++){
int column=indices[k];
assert (eq(cut[column],elements[k]));
}
// add cut
rowLower[4]=-1.0e100;
rowUpper[4]=ub;
matrix.appendRow(rpv);
}
}
nOldCuts=nRowCuts;
// basis 3
int rowBasis3[5]={1,1,1,-1,-1};
int colBasis3[2]={1,1};
warm.setSize(2,5);
for (i=0;i<5;i++) {
if (rowBasis3[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<2;i++) {
if (colBasis3[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 3
double colsol3[2]={2.0,1.0};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol3,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts==nOldCuts);
}
// NOW mixed integer gomory cuts
// Test explicit form - (pg 130 Wolsey)
// Some arrays left same size as previously although not used in full
if (1) {
OsiCuts osicuts;
CglGomory test1;
int i;
int nOldCuts=0,nRowCuts;
// matrix data
//deliberate hiccup of 2 between 0 and 1
CoinBigIndex start[5]={0,4,7,8,9};
int length[5]={2,3,1,1,1};
int rows[11]={0,2,-1,-1,0,1,2,0,1,2};
double elements[11]={7.0,2.0,1.0e10,1.0e10,-2.0,1.0,-2.0,1,1,1};
CoinPackedMatrix matrix(true,3,5,8,elements,rows,start,length);
// rim data (objective not used just yet)
double rowLower[5]={14.0,3.0,3.0,1.0e10,1.0e10};
double rowUpper[5]={14.0,3.0,3.0,-1.0e10,-1.0e10};
double colLower[7]={0.0,0.0,0.0,0.0,0.0,0.0,0.0};
double colUpper[7]={100.0,100.0,100.0,100.0,100.0,100.0,100.0};
// integer
char intVar[7]={2,0,0,0,0,0,0};
// basis 1
int rowBasis1[3]={-1,-1,-1};
int colBasis1[5]={1,1,-1,-1,1};
CoinWarmStartBasis warm;
warm.setSize(5,3);
for (i=0;i<3;i++) {
if (rowBasis1[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<5;i++) {
if (colBasis1[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 1
double colsol1[5]={20.0/7.0,3.0,0.0,0.0,23.0/7.0};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol1,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts==1);
// cuts always <=
int testCut=0; // test first cut as stronger
double rhs=-6.0/7.0;
double testCut1[5]={0.0,0.0,-1.0/7.0,-2.0/7.0,0.0};
double * cut = testCut1;
double * colsol = colsol1;
for (i=nOldCuts; i<nRowCuts; i++){
OsiRowCut rcut;
CoinPackedVector rpv;
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;
for (k=0; k<n; k++){
int column=indices[k];
sum2 += colsol[column]*elements[k];
}
double ub=rcut.ub();
#ifdef CGL_DEBUG
double lb=rcut.lb();
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;
}
#endif
if (i-nOldCuts==testCut) {
assert( eq(rhs,ub));
assert(n==2);
for (k=0; k<n; k++){
int column=indices[k];
assert (eq(cut[column],elements[k]));
}
// add cut
// explicit slack
matrix.setDimensions(-1,6);
rpv.insert(5,1.0); // to get cut in book
rowLower[3]=ub;
rowUpper[3]=ub;
matrix.appendRow(rpv);
}
}
nOldCuts=nRowCuts;
// basis 2
int rowBasis2[4]={-1,-1,-1,-1};
int colBasis2[6]={1,1,1,1,-1,-1};
warm.setSize(6,4);
for (i=0;i<4;i++) {
if (rowBasis2[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<6;i++) {
if (colBasis2[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 2
double colsol2[6]={2.0,0.5,1.0,2.5,0.0,0.0};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol2,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts==nOldCuts);
}
// Test explicit form - this time with x4 flipped
if (1) {
OsiCuts osicuts;
CglGomory test1;
int i;
int nOldCuts=0,nRowCuts;
// matrix data
//deliberate hiccup of 2 between 0 and 1
CoinBigIndex start[5]={0,4,7,8,9};
int length[5]={2,3,1,1,1};
int rows[11]={0,2,-1,-1,0,1,2,0,1,2};
double elements[11]={7.0,2.0,1.0e10,1.0e10,-2.0,1.0,-2.0,1,-1,1};
CoinPackedMatrix matrix(true,3,5,8,elements,rows,start,length);
// rim data (objective not used just yet)
double rowLower[5]={14.0,-5.0,3.0,1.0e10,1.0e10};
double rowUpper[5]={14.0,-5.0,3.0,-1.0e10,-1.0e10};
double colLower[7]={0.0,0.0,0.0,0.0,0.0,0.0,0.0};
double colUpper[7]={100.0,100.0,100.0,8.0,100.0,100.0,100.0};
// integer
char intVar[7]={2,0,0,0,0,0,0};
// basis 1
int rowBasis1[3]={-1,-1,-1};
int colBasis1[5]={1,1,-1,-1,1};
CoinWarmStartBasis warm;
warm.setSize(5,3);
for (i=0;i<3;i++) {
if (rowBasis1[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<5;i++) {
if (colBasis1[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 1
double colsol1[5]={20.0/7.0,3.0,0.0,8.0,23.0/7.0};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol1,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts==1);
// cuts always <=
int testCut=0;
double rhs=10.0/7.0;
double testCut1[5]={0.0,0.0,-1.0/7.0,2.0/7.0,0.0};
double * cut = testCut1;
double * colsol = colsol1;
for (i=nOldCuts; i<nRowCuts; i++){
OsiRowCut rcut;
CoinPackedVector rpv;
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;
for (k=0; k<n; k++){
int column=indices[k];
sum2 += colsol[column]*elements[k];
}
double ub=rcut.ub();
#ifdef CGL_DEBUG
double lb=rcut.lb();
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;
}
#endif
if (i-nOldCuts==testCut) {
assert( eq(rhs,ub));
assert(n==2);
for (k=0; k<n; k++){
int column=indices[k];
assert (eq(cut[column],elements[k]));
}
// add cut
// explicit slack
matrix.setDimensions(-1,6);
rpv.insert(5,1.0); // to get cut in book
rowLower[3]=ub;
rowUpper[3]=ub;
matrix.appendRow(rpv);
}
}
nOldCuts=nRowCuts;
// basis 2
int rowBasis2[4]={-1,-1,-1,-1};
int colBasis2[6]={1,1,1,1,-1,-1};
warm.setSize(6,4);
for (i=0;i<4;i++) {
if (rowBasis2[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<6;i++) {
if (colBasis2[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 2
double colsol2[6]={2.0,0.5,1.0,5.5,0.0,0.0};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol2,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts==nOldCuts);
}
// Test with slacks
if (1) {
OsiCuts osicuts;
CglGomory test1;
int i;
int nOldCuts=0,nRowCuts;
// matrix data
//deliberate hiccup of 2 between 0 and 1
CoinBigIndex start[5]={0,4};
int length[5]={2,3};
int rows[11]={0,2,-1,-1,0,1,2};
double elements[11]={7.0,2.0,1.0e10,1.0e10,-2.0,1.0,-2.0};
CoinPackedMatrix matrix(true,3,2,5,elements,rows,start,length);
// rim data (objective not used just yet)
double rowLower[5]={-1.0e10,-1.0e10,-1.0e10,1.0e10,1.0e10};
double rowUpper[5]={14.0,3.0,3.0,-1.0e10,-1.0e10};
double colLower[2]={0.0,0.0};
double colUpper[2]={100.0,100.0};
// integer
char intVar[2]={2,0};
// basis 1
int rowBasis1[3]={-1,-1,1};
int colBasis1[2]={1,1};
CoinWarmStartBasis warm;
warm.setSize(2,3);
for (i=0;i<3;i++) {
if (rowBasis1[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<2;i++) {
if (colBasis1[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 1
double colsol1[2]={20.0/7.0,3.0};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol1,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts==1);
// cuts always <=
int testCut=0; // test first cut as stronger
double rhs=2.0;
double testCut1[2]={1.0,0.0};
double * cut = testCut1;
double * colsol = colsol1;
for (i=nOldCuts; i<nRowCuts; i++){
OsiRowCut rcut;
CoinPackedVector rpv;
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;
for (k=0; k<n; k++){
int column=indices[k];
sum2 += colsol[column]*elements[k];
}
double ub=rcut.ub();
#ifdef CGL_DEBUG
double lb=rcut.lb();
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;
}
#endif
if (i-nOldCuts==testCut) {
assert( eq(rhs,ub));
assert(n==1);
for (k=0; k<n; k++){
int column=indices[k];
assert (eq(cut[column],elements[k]));
}
// add cut
rowLower[3]=-1.0e100;
rowUpper[3]=ub;
matrix.appendRow(rpv);
}
}
nOldCuts=nRowCuts;
// basis 2
int rowBasis2[4]={1,1,-1,-1};
int colBasis2[2]={1,1};
warm.setSize(2,4);
for (i=0;i<4;i++) {
if (rowBasis2[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<2;i++) {
if (colBasis2[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 2
double colsol2[2]={2.0,0.5};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol2,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts==nOldCuts);
}
// swap some rows to G
if (1) {
OsiCuts osicuts;
CglGomory test1;
int i;
int nOldCuts=0,nRowCuts;
// matrix data
//deliberate hiccup of 2 between 0 and 1
CoinBigIndex start[5]={0,4};
int length[5]={2,3};
int rows[11]={0,2,-1,-1,0,1,2};
double elements[11]={-7.0,-2.0,1.0e10,1.0e10,+2.0,1.0,+2.0};
CoinPackedMatrix matrix(true,3,2,5,elements,rows,start,length);
// rim data (objective not used just yet)
double rowUpper[5]={1.0e10,3.0,1.0e10,-1.0e10,-1.0e10};
double rowLower[5]={-14.0,-1.0e10,-3.0,1.0e10,1.0e10};
double colLower[2]={0.0,0.0};
double colUpper[2]={100.0,100.0};
// integer
char intVar[2]={2,0};
// basis 1
int rowBasis1[3]={-1,-1,1};
int colBasis1[2]={1,1};
CoinWarmStartBasis warm;
warm.setSize(2,3);
for (i=0;i<3;i++) {
if (rowBasis1[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<2;i++) {
if (colBasis1[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 1
double colsol1[2]={20.0/7.0,3.0};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol1,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts==1);
// cuts always <=
int testCut=0; // test first cut as stronger
double rhs=2.0;
double testCut1[2]={1.0,0.0};
double * cut = testCut1;
double * colsol = colsol1;
for (i=nOldCuts; i<nRowCuts; i++){
OsiRowCut rcut;
CoinPackedVector rpv;
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;
for (k=0; k<n; k++){
int column=indices[k];
sum2 += colsol[column]*elements[k];
}
double ub=rcut.ub();
#ifdef CGL_DEBUG
double lb=rcut.lb();
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;
}
#endif
if (i-nOldCuts==testCut) {
assert( eq(rhs,ub));
assert(n==1);
for (k=0; k<n; k++){
int column=indices[k];
assert (eq(cut[column],elements[k]));
}
// add cut
rowLower[3]=-1.0e100;
rowUpper[3]=ub;
matrix.appendRow(rpv);
}
}
nOldCuts=nRowCuts;
// basis 2
int rowBasis2[4]={1,1,-1,-1};
int colBasis2[2]={1,1};
warm.setSize(2,4);
for (i=0;i<4;i++) {
if (rowBasis2[i]<0) {
warm.setArtifStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setArtifStatus(i,CoinWarmStartBasis::basic);
}
}
for (i=0;i<2;i++) {
if (colBasis2[i]<0) {
warm.setStructStatus(i,CoinWarmStartBasis::atLowerBound);
} else {
warm.setStructStatus(i,CoinWarmStartBasis::basic);
}
}
// solution 2
double colsol2[2]={2.0,0.5};
test1.generateCuts(NULL, osicuts, matrix,
/*objective,*/ colsol2,
colLower, colUpper,
rowLower, rowUpper, intVar, &warm);
nRowCuts = osicuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" gomory cuts"<<std::endl;
assert (nRowCuts==nOldCuts);
}
// Miplib3 problem p0033
if (1) {
// Setup
OsiSolverInterface * siP = baseSiP->clone();
std::string fn(mpsDir+"p0033");
siP->readMps(fn.c_str(),"mps");
siP->activateRowCutDebugger("p0033");
CglGomory test;
// Solve the LP relaxation of the model and
// print out ofv for sake of comparison
siP->initialSolve();
double lpRelaxBefore=siP->getObjValue();
std::cout<<"Initial LP value: "<<lpRelaxBefore<<std::endl;
assert( eq(lpRelaxBefore, 2520.5717391304347) );
// Fails with OsiCpx, OsiXpr:
/**********
double mycs[] = {0, 1, 0, 0, -2.0837010502455788e-19, 1, 0, 0, 1,
0.021739130434782594, 0.35652173913043478,
-6.7220534694101275e-18, 5.3125906451789717e-18,
1, 0, 1.9298798670241979e-17, 0, 0, 0,
7.8875708048320448e-18, 0.5, 0,
0.85999999999999999, 1, 1, 0.57999999999999996,
1, 0, 1, 0, 0.25, 0, 0.67500000000000004};
siP->setColSolution(mycs);
****/
OsiCuts cuts;
// Test generateCuts method
test.generateCuts(*siP,cuts);
int nRowCuts = cuts.sizeRowCuts();
std::cout<<"There are "<<nRowCuts<<" Gomory cuts"<<std::endl;
assert(cuts.sizeRowCuts() > 0);
OsiSolverInterface::ApplyCutsReturnCode rc = siP->applyCuts(cuts);
siP->resolve();
double lpRelaxAfter=siP->getObjValue();
std::cout<<"LP value with cuts: "<<lpRelaxAfter<<std::endl;
//assert( eq(lpRelaxAfter, 2592.1908295194507) );
assert( lpRelaxAfter> 2550.0 );
assert( lpRelaxBefore < lpRelaxAfter );
assert(lpRelaxAfter < 3089.1);
delete siP;
}
}
//-------------------------------------------------------------------
// Set row elements
//-------------------------------------------------------------------
void OsiRowCut::setRow(int size,
const int * colIndices, const double * elements)
{
row_.setVector(size,colIndices,elements);
}
//#############################################################################
void
MibSHeuristic::lowerObjHeuristic()
{
/*
optimize wrt to lower-level objective
over current feasible lp feasible region
*/
MibSModel * model = MibSModel_;
OsiSolverInterface * oSolver = model->getSolver();
#ifndef COIN_HAS_SYMPHONY
OsiSolverInterface * hSolver = new OsiCbcSolverInterface();
#else
OsiSolverInterface* hSolver = new OsiSymSolverInterface();
#endif
double objSense(model->getLowerObjSense());
int lCols(model->getLowerDim());
int uCols(model->getUpperDim());
int * lColIndices = model->getLowerColInd();
int * uColIndices = model->getUpperColInd();
double * lObjCoeffs = model->getLowerObjCoeffs();
//int tCols(lCols + uCols);
int tCols(oSolver->getNumCols());
//assert(tCols == oSolver->getNumCols());
hSolver->loadProblem(*oSolver->getMatrixByCol(),
oSolver->getColLower(), oSolver->getColUpper(),
oSolver->getObjCoefficients(),
oSolver->getRowLower(), oSolver->getRowUpper());
int j(0);
for(j = 0; j < tCols; j++){
if(oSolver->isInteger(j))
hSolver->setInteger(j);
}
double * nObjCoeffs = new double[tCols];
int i(0), index(0);
CoinZeroN(nObjCoeffs, tCols);
for(i = 0; i < lCols; i++){
index = lColIndices[i];
nObjCoeffs[index] = lObjCoeffs[i];
}
//MibS objective sense is the opposite of OSI's!
hSolver->setObjSense(objSense);
hSolver->setObjective(nObjCoeffs);
//double cutoff(model->getCutoff());
double cutoff(model->getKnowledgeBroker()->getIncumbentValue());
if(model->getNumSolutions()){
CoinPackedVector objCon;
//double rhs(cutoff * objSense);
//double smlTol(1.0);
double rhs(cutoff);
for(i = 0; i < tCols; i++){
objCon.insert(i, oSolver->getObjCoefficients()[i]
* oSolver->getObjSense());
}
hSolver->addRow(objCon, - hSolver->getInfinity(), rhs);
}
if(0)
hSolver->writeLp("lobjheurstic");
#ifndef COIN_HAS_SYMPHONY
dynamic_cast<OsiCbcSolverInterface *>
(hSolver)->getModelPtr()->messageHandler()->setLogLevel(0);
#else
dynamic_cast<OsiSymSolverInterface *>
(hSolver)->setSymParam("prep_level", -1);
dynamic_cast<OsiSymSolverInterface *>
(hSolver)->setSymParam("verbosity", -2);
dynamic_cast<OsiSymSolverInterface *>
(hSolver)->setSymParam("max_active_nodes", 1);
#endif
hSolver->branchAndBound();
if(hSolver->isProvenOptimal()){
double upperObjVal(0.0);
/*****************NEW ******************/
MibSSolution *mibSol = NULL;
OsiSolverInterface * lSolver = model->bS_->setUpModel(hSolver, true);
if(0){
lSolver->writeLp("tmp");
}
#ifndef COIN_HAS_SYMPHONY
dynamic_cast<OsiCbcSolverInterface *>
(lSolver)->getModelPtr()->messageHandler()->setLogLevel(0);
#else
dynamic_cast<OsiSymSolverInterface *>
(lSolver)->setSymParam("prep_level", -1);
dynamic_cast<OsiSymSolverInterface *>
(lSolver)->setSymParam("verbosity", -2);
dynamic_cast<OsiSymSolverInterface *>
(lSolver)->setSymParam("max_active_nodes", 1);
#endif
lSolver->branchAndBound();
if (lSolver->isProvenOptimal()){
const double * sol = hSolver->getColSolution();
double objVal(lSolver->getObjValue() * objSense);
double etol(etol_);
double lowerObj = getLowerObj(sol, objSense);
double * optUpperSolutionOrd = new double[uCols];
double * optLowerSolutionOrd = new double[lCols];
CoinZeroN(optUpperSolutionOrd, uCols);
CoinZeroN(optLowerSolutionOrd, lCols);
if(fabs(objVal - lowerObj) < etol){
/** Current solution is bilevel feasible **/
for(i = 0; i < tCols; i++)
upperObjVal +=
hSolver->getColSolution()[i] * oSolver->getObjCoefficients()[i];
mibSol = new MibSSolution(hSolver->getNumCols(),
hSolver->getColSolution(),
upperObjVal,
model);
model->storeSolution(BlisSolutionTypeHeuristic, mibSol);
mibSol = NULL;
}
else{
/* solution is not bilevel feasible, create one that is */
const double * uSol = hSolver->getColSolution();
const double * lSol = lSolver->getColSolution();
int numElements(hSolver->getNumCols());
int i(0), pos(0), index(0);
double * lpSolution = new double[numElements];
double upperObj(0.0);
//FIXME: problem is still here. indices may be wrong.
//also is all this necessary, or can we just paste together uSol and lSol?
//this may be an old comment
for(i = 0; i < numElements; i++){
pos = model->bS_->binarySearch(0, lCols - 1, i, lColIndices);
if(pos < 0){
pos = model->bS_->binarySearch(0, uCols - 1, i, uColIndices);
if (pos >= 0){
optUpperSolutionOrd[pos] = uSol[i];
}
}
else{
optLowerSolutionOrd[pos] = lSol[pos];
}
}
for(i = 0; i < uCols; i++){
index = uColIndices[i];
lpSolution[index] = optUpperSolutionOrd[i];
upperObj +=
optUpperSolutionOrd[i] * oSolver->getObjCoefficients()[index];
}
for(i = 0; i < lCols; i++){
index = lColIndices[i];
lpSolution[index] = optLowerSolutionOrd[i];
upperObj +=
optLowerSolutionOrd[i] * oSolver->getObjCoefficients()[index];
}
if(model->checkUpperFeasibility(lpSolution)){
mibSol = new MibSSolution(hSolver->getNumCols(),
lpSolution,
upperObj * oSolver->getObjSense(),
model);
model->storeSolution(BlisSolutionTypeHeuristic, mibSol);
mibSol = NULL;
}
delete [] lpSolution;
}
}
delete lSolver;
}
delete hSolver;
}
//#############################################################################
void
MibSHeuristic::objCutHeuristic()
{
/* Solve the LP relaxation with the new constraint d^2 y <= d^y* */
MibSModel * model = MibSModel_;
//OsiSolverInterface * oSolver = model->origLpSolver_;
OsiSolverInterface * oSolver = model->getSolver();
#ifndef COIN_HAS_SYMPHONY
OsiSolverInterface * hSolver = new OsiCbcSolverInterface();
#else
OsiSolverInterface * hSolver = new OsiSymSolverInterface();
#endif
double objSense(model->getLowerObjSense());
int lCols(model->getLowerDim());
int uCols(model->getUpperDim());
int tCols(lCols + uCols);
int * lColIndices = model->getLowerColInd();
int * uColIndices = model->getUpperColInd();
double * lObjCoeffs = model->getLowerObjCoeffs();
hSolver->loadProblem(*oSolver->getMatrixByCol(),
oSolver->getColLower(), oSolver->getColUpper(),
oSolver->getObjCoefficients(),
oSolver->getRowLower(), oSolver->getRowUpper());
int j(0);
for(j = 0; j < tCols; j++){
if(oSolver->isInteger(j))
hSolver->setInteger(j);
}
double * optLowerSolutionOrd = model->bS_->optLowerSolutionOrd_;
CoinPackedVector objCon;
int i(0), index(0);
double rhs(0.0);
for(i = 0; i < lCols; i++){
index = lColIndices[i];
objCon.insert(index, lObjCoeffs[i] * objSense);
//should this be ordered? and should lObjCoeffs by at index?
//rhs += optLowerSolutionOrd_[i] * lObjCoeffs[i] * objSense;
rhs += optLowerSolutionOrd[i] * lObjCoeffs[i] * objSense;
}
//Hmm, I think this was wrong before...?
// hSolver->addRow(objCon, - hSolver->getInfinity(), rhs);
hSolver->addRow(objCon, rhs, hSolver->getInfinity());
/* optimize w.r.t. to the UL objective with the new row */
#ifndef COIN_HAS_SYMPHONY
dynamic_cast<OsiCbcSolverInterface *>
(hSolver)->getModelPtr()->messageHandler()->setLogLevel(0);
#else
dynamic_cast<OsiSymSolverInterface *>
(hSolver)->setSymParam("prep_level", -1);
dynamic_cast<OsiSymSolverInterface *>
(hSolver)->setSymParam("verbosity", -2);
dynamic_cast<OsiSymSolverInterface *>
(hSolver)->setSymParam("max_active_nodes", 1);
#endif
hSolver->branchAndBound();
if(0)
hSolver->writeLp("objcutheuristic");
if(hSolver->isProvenOptimal()){
MibSSolution *mibSol = NULL;
OsiSolverInterface * lSolver = model->bS_->setUpModel(hSolver, true);
#ifndef COIN_HAS_SYMPHONY
dynamic_cast<OsiCbcSolverInterface *>
(lSolver)->getModelPtr()->messageHandler()->setLogLevel(0);
#else
dynamic_cast<OsiSymSolverInterface *>
(lSolver)->setSymParam("prep_level", -1);
dynamic_cast<OsiSymSolverInterface *>
(lSolver)->setSymParam("verbosity", -2);
dynamic_cast<OsiSymSolverInterface *>
(lSolver)->setSymParam("max_active_nodes", 1);
#endif
lSolver->branchAndBound();
const double * sol = hSolver->getColSolution();
double objVal(lSolver->getObjValue() * objSense);
double etol(etol_);
double lowerObj = getLowerObj(sol, objSense);
double * optUpperSolutionOrd = new double[uCols];
double * optLowerSolutionOrd = new double[lCols];
CoinZeroN(optUpperSolutionOrd, uCols);
CoinZeroN(optLowerSolutionOrd, lCols);
if(fabs(objVal - lowerObj) < etol){
/** Current solution is bilevel feasible **/
mibSol = new MibSSolution(hSolver->getNumCols(),
hSolver->getColSolution(),
hSolver->getObjValue(),
model);
model->storeSolution(BlisSolutionTypeHeuristic, mibSol);
mibSol = NULL;
}
else{
/* solution is not bilevel feasible, create one that is */
const double * uSol = hSolver->getColSolution();
const double * lSol = lSolver->getColSolution();
//int numElements(lSolver->getNumCols());
int numElements(hSolver->getNumCols());
int i(0), pos(0), index(0);
double * lpSolution = new double[numElements];
double upperObj(0.0);
//FIXME: problem is still here. indices may be wrong.
//also is all this necessary, or can we just paste together uSol and lSol?
for(i = 0; i < numElements; i++){
//index = indices[i];
pos = model->bS_->binarySearch(0, lCols - 1, i, lColIndices);
if(pos < 0){
pos = model->bS_->binarySearch(0, uCols - 1, i, uColIndices);
//optUpperSolutionOrd[pos] = values[i];
//optUpperSolutionOrd[pos] = uSol[pos];
if (pos >= 0){
optUpperSolutionOrd[pos] = uSol[i];
}
}
else{
//optLowerSolutionOrd[pos] = lSol[i];
optLowerSolutionOrd[pos] = lSol[pos];
}
}
for(i = 0; i < uCols; i++){
index = uColIndices[i];
lpSolution[index] = optUpperSolutionOrd[i];
upperObj +=
optUpperSolutionOrd[i] * hSolver->getObjCoefficients()[index];
}
for(i = 0; i < lCols; i++){
index = lColIndices[i];
lpSolution[index] = optLowerSolutionOrd[i];
upperObj +=
optLowerSolutionOrd[i] * hSolver->getObjCoefficients()[index];
}
if(model->checkUpperFeasibility(lpSolution)){
mibSol = new MibSSolution(hSolver->getNumCols(),
lpSolution,
upperObj * hSolver->getObjSense(),
model);
model->storeSolution(BlisSolutionTypeHeuristic, mibSol);
mibSol = NULL;
}
delete [] lpSolution;
}
delete lSolver;
}
delete hSolver;
}
//===========================================================================//
void OSDipApp::createModels() {
UtilPrintFuncBegin(m_osLog, m_classTag, "createModels()",
m_appParam.LogLevel, 2);
int i;
int j;
const int nCols = m_osInterface.getVariableNumber();
const int nRows = m_osInterface.getConstraintNumber();
try{
//First the define the objective function over the entire variable space
//Create the memory for the objective function
m_objective = new double[nCols];
for (i = 0; i < nCols; i++) {
m_objective[i] = m_osInterface.getObjectiveFunctionCoeff()[i];
//std::cout << "obj coeff = " << m_objective[i] << std::endl;
}
setModelObjective( m_objective);
//---
//--- Construct the core matrix.
//---
int nRowsRelax, nRowsCore;
nRowsRelax = 0;
nRowsCore = 0;
std::vector<OtherConstraintOption*> otherConstraintOptions;
std::vector<OtherConstraintOption*>::iterator vit;
//
// Now construct the block matrices
//
int *rowsRelax;
int whichBlock;
DecompConstraintSet *modelRelax = NULL;
std::set<int> blockVars; //variables indexes in the specific block
std::set<int> blockVarsAll; //all variable indexes that appear in a block
std::set<int> blockConAll; //all constraint indexes that appear in a block
std::set<int>::iterator sit;
CoinPackedVector *row;
int *rowVars;
int rowSize;
if (m_osInterface.m_osoption != NULL
&& m_osInterface.m_osoption->getNumberOfOtherConstraintOptions()
> 0) {
otherConstraintOptions
= m_osInterface.m_osoption->getOtherConstraintOptions("Dip");
//iterate over the vector of contraint options
for (vit = otherConstraintOptions.begin(); vit
!= otherConstraintOptions.end(); vit++) {
// see if we have a Core Constraint Set
if( ( (*vit)->name.compare("constraintSet") == 0)
&& ( (*vit)->type.compare("Block") == 0)) {
//get the block number
//ch = new char[(*vit)->value.size() + 1];
//ch[(*vit)->value.size()] = 0;
//memcpy(ch, (*vit)->value.c_str(), (*vit)->value.size());
//whichBlock = atoi(ch);
//delete ch;
whichBlock = atoi( (*vit)->value.c_str() );
// first get the number of constraints in this block
nRowsRelax = (*vit)->numberOfCon;
rowsRelax = new int[nRowsRelax];
//now get the variable indexes for just this block
//first clear indexes from a previous block
blockVars.clear();
for (i = 0; i < nRowsRelax; i++) {
rowsRelax[i] = (*vit)->con[i]->idx;
if( (*vit)->con[i]->idx >= nRows) throw ErrorClass( "found an invalid row index in OSoL file");
m_blocks[ whichBlock].push_back( rowsRelax[i] );
//also add to the set of all rows
if (blockConAll.find( (*vit)->con[i]->idx ) == blockConAll.end()) {
blockConAll.insert( (*vit)->con[i]->idx );
}
//add the variables for this row to the set blockVars
row = m_osInterface.getRow(rowsRelax[i]);
rowSize = row->getNumElements();
rowVars = row->getIndices();
for (j = 0; j < rowSize; j++) {
if (blockVars.find(rowVars[j]) == blockVars.end()) {
blockVars.insert(rowVars[j]);
}
}
delete row;
}//end for or rows in this block
modelRelax = new DecompConstraintSet();
CoinAssertHint(modelRelax, "Error: Out of Memory");
//create the active columns in this block
for (sit = blockVars.begin(); sit != blockVars.end(); sit++) {
modelRelax->activeColumns.push_back( *sit);
//insert into the all variables set also, but throw an execption
//if already there -- same variable cannot be in more than one block
if (blockVarsAll.find( *sit) == blockVarsAll.end()) {
blockVarsAll.insert (*sit);
}else{
throw ErrorClass("Variable " + UtilIntToStr(*sit) + " appears in more than one block");
}
}
//
//
if (m_appParam.LogLevel >= 3) {
(*m_osLog) << "Active Columns : " << whichBlock << endl;
UtilPrintVector(modelRelax->activeColumns, m_osLog);
}
createModelPartSparse(modelRelax, nRowsRelax, rowsRelax); //does not work for cutting planes
//createModelPart(modelRelax, nRowsRelax, rowsRelax);
//modelRelax->fixNonActiveColumns();
m_modelR.insert(make_pair(whichBlock + 1, modelRelax));
setModelRelax(modelRelax, "relax" + UtilIntToStr(whichBlock),
whichBlock);
if (m_appParam.LogLevel >= 3) {
(*m_osLog) << std::endl << std::endl;
(*m_osLog) << "HERE COMES THE DUPLICATION (WHEN createModelPartSparse USED)" << std::endl;
}
UtilPrintVector( modelRelax->activeColumns, m_osLog);
//free local memory
UTIL_DELARR( rowsRelax);
}
}//end for over constraint options
}// if on ospton null
//get the core constraints -- constraints NOT in a block
int *rowsCore = NULL;
int kount = 0;
nRowsCore = nRows - blockConAll.size();
if(nRowsCore <= 0) throw ErrorClass("We need at least one coupling constraint");
rowsCore = new int[nRowsCore];
for(i = 0; i < nRows; i++){
if (blockConAll.find( i ) == blockConAll.end() ){
rowsCore[ kount++] = i;
}
}
if( kount != nRowsCore) throw ErrorClass("There was an error counting coupling constraints");
DecompConstraintSet * modelCore = new DecompConstraintSet();
createModelPart(modelCore, nRowsCore, rowsCore);
setModelCore(modelCore, "core");
//---
//--- save a pointer so we can delete it later
//---
m_modelC = modelCore;
//get the master only variables
//modelCore->masterOnlyCols.push_back(i);
for (i = 0; i < nCols; i++) {
if (blockVarsAll.find(i) == blockVarsAll.end()) {
modelCore->masterOnlyCols.push_back(i);
std::cout << "MASTER ONLY VARIABLE " << i << std::endl;
}
}
//---
//--- create an extra "empty" block for the master-only vars
//--- since I don't know what OSI will do with empty problem
//--- we will make column bounds explicity rows
//---
int nMasterOnlyCols = static_cast<int> (modelCore->masterOnlyCols.size());
if (nMasterOnlyCols) {
if (m_appParam.LogLevel >= 1)
(*m_osLog) << "Create model part Master-Only." << endl;
createModelMasterOnlys2(modelCore->masterOnlyCols);
}
UtilPrintFuncBegin(m_osLog, m_classTag, "printCurrentProblem()",
m_appParam.LogLevel, 2);
//free local memory
UTIL_DELARR( rowsCore);
}//end try
catch(const ErrorClass& eclass){
throw ErrorClass( eclass.errormsg);
}
}// end createModels()
void exprQuad::quadCuts (expression *w, OsiCuts &cs, const CouenneCutGenerator *cg){
#ifdef DEBUG
std::cout<<"Expression has "<< lcoeff_.size () <<" linear terms and "
<< nqterms_ <<" quadratic terms." << std::endl;
printf ("Q:");
for (sparseQ::iterator row = matrix_.begin (); row != matrix_.end (); ++row) {
int xind = row -> first -> Index ();
for (sparseQcol::iterator col = row -> second.begin (); col != row -> second.end (); ++col)
printf (" <%d,%d,%g>", xind, col -> first -> Index (), col -> second);
}
printf ("\nb:");
for (lincoeff::iterator el = lcoeff_.begin (); el != lcoeff_.end (); ++el)
//for (int i=0; i < nlterms_; i++)
printf (" <%d,%g>", el -> first -> Index (), el -> second);//index_ [i], coeff_ [i]);
if (c0_)
printf ("; <c0 = %g>", c0_);
printf ("\nBounds: var val lb ub eigval scaled\n");
int index = 0;
for (std::map <exprVar *, std::pair <CouNumber, CouNumber> >::iterator i = bounds_.begin ();
i != bounds_.end (); ++i, index++) {
printf ("%3d:\t", index);
i -> first -> print (); printf ("\t");
printf (" %8g [%8g, %8g]",
(*(i -> first)) (), i -> second.first, i -> second.second);
CouNumber
lb = cg -> Problem () -> Lb (i -> first -> Index ()),
ub = cg -> Problem () -> Ub (i -> first -> Index ());
if ((eigen_.size () > 0) &&
(fabs (ub-lb) > COUENNE_EPS))
printf (" --> %8g %8g",
eigen_.begin () -> first,
eigen_.begin () -> first / (ub-lb));
printf ("\n");
}
#endif
// Get on which side constraint is violated to get the good lambda
CouNumber
varVal = (*w) (),
exprVal = (*this) (),
lambda =
(eigen_.size () == 0) ? 0. :
(varVal < exprVal) ?
CoinMin (0., eigen_.begin () -> first) : // Use under-estimator
CoinMax (0., eigen_.rbegin () -> first), // Use over-estimator
convVal = 0.;
enum auxSign sign = cg -> Problem () -> Var (w -> Index ()) -> sign ();
// if this is a "semi"-auxiliary, check if necessary to separate
if ((sign == expression::AUX_GEQ && varVal > exprVal) ||
(sign == expression::AUX_LEQ && varVal < exprVal))
return;
const CouenneProblem& problem = *(cg -> Problem ());
const int numcols = problem.nVars ();
const double
*colsol = problem.X (), // current solution
*lower = problem.Lb (), // lower bound
*upper = problem.Ub (); // upper
// compute lower or upper convexification and check if it contains
// the current point
if (fabs (lambda) > COUENNE_EPS) {
convVal = exprVal;
// there is a convexification, check if out of current point
for (std::map <exprVar *, std::pair <CouNumber, CouNumber> >::iterator i = bounds_.begin ();
i != bounds_.end (); ++i) {
int ind = i -> first -> Index ();
CouNumber
xi = colsol [ind],
lb = lower [ind],
ub = upper [ind],
delta = ub-lb;
if (fabs (delta) > COUENNE_EPS)
convVal += lambda * (xi-lb) * (ub-xi) / (delta * delta);
}
if (varVal < exprVal) {if (convVal < varVal) return;}
else {if (convVal > varVal) return;}
}
#ifdef DEBUG
std::cout << "Point to cut: ";
for (int i = 0 ; i < numcols ; i++) std::cout << colsol [i] << ", ";
printf (" (w,f(x),c) = (%g,%g,%g) -- lambda = %g\n", (*w) (), exprVal, convVal, lambda);
#endif
// Initialize by copying $a$ into a dense vector and computing Q x^*
double
*Qxs = new double [numcols], // sparse coefficient vector, $Qx^*$
a0 = -c0_; // constant term
CoinFillN (Qxs, numcols, 0.);
// Compute 2 * Q x^*.
for (sparseQ::iterator row = matrix_.begin (); row != matrix_.end (); ++row) {
int qi = row -> first -> Index ();
for (sparseQcol::iterator col = row -> second.begin (); col != row -> second.end (); ++col) {
int qj = col -> first -> Index ();
CouNumber
qc = col -> second,
xi = colsol [qi],
xj = colsol [qj];
if (qi != qj) {
Qxs [qi] += qc * xj; // contribution of element $q_{ij}$ to (Qx)_i
Qxs [qj] += qc * xi; // $q_{ij}$ (Qx)_j
a0 += 2 * qc * xi * xj;
}
else {
/*
if (fabs (lambda) > COUENNE_EPS) {
CouNumber
lb = lower [qi],
ub = upper [qi],
delta = ub-lb;
if (fabs (delta) > COUENNE_EPS)
qc -= lambda / (delta*delta);
}
*/
// elements on the diagonal are not halved upon reading
a0 += qc * xi * xi;
Qxs [qi] += 2 * qc * xi;
}
}
}
#ifdef DEBUG
printf ("2Qx = ("); for (int i = 0; i < numcols; i++) printf ("%g ", Qxs [i]); printf (")\n");
#endif
// Add a to it.
for (lincoeff::iterator el = lcoeff_.begin (); el != lcoeff_.end (); ++el)
Qxs [el -> first -> Index ()] += el -> second; //coeff_ [i];
// multiply Qx^* by x^*^T again and store the result for the lower
// bound into constant term
/*
for (int i=0; i < numcols; i++){
a0 -= 0.5 * Qxs [i] * colsol [i];
// Qxs [i] *= 2;
}
*/
// And myself
Qxs [w -> Index ()] -= 1;
#ifdef DEBUG
printf ("2Qx = ("); for(int i = 0; i < numcols; i++) printf ("%g ", Qxs [i]); printf (")[%g]\n",a0);
#endif
//a0 -= exprVal;
if (fabs (lambda) > COUENNE_EPS) // Now the part which depends on lambda, if there is one
for (std::map <exprVar *, std::pair <CouNumber, CouNumber> >::iterator i = bounds_.begin ();
i != bounds_.end (); ++i) {
int ind = i -> first -> Index ();
CouNumber
xi = colsol [ind],
lb = lower [ind],
ub = upper [ind],
delta = ub-lb;
if (fabs (delta) > COUENNE_EPS) {
CouNumber normlambda = lambda / (delta*delta),
coeff = normlambda * (lb + ub - 2. * xi);
a0 += normlambda * (lb*ub - xi*xi);
//a0 += coeff * xi - normlambda * (xi - lb) * (ub - xi);
//a0 += normlambda * lb * ub;
Qxs [ind] += coeff;
//Qxs [ind] += normlambda * (lb + ub);
}// else coeff = 0.;
// a0 += lambda [k] * lower [ind] * upper [ind];
// a0 -= lambda [k] * colsol [ind] * colsol [ind];
//Qxs [ind] -= lambda [k] * (colsol [ind]) * 2;
}
// Count the number of non-zeroes
int nnz = 0;
for (int i=0; i < numcols ; i++)
if (fabs (Qxs [i]) > COUENNE_EPS)
nnz++;
#ifdef DEBUG
printf ("2Qx = (");for(int i=0;i<numcols;i++)printf("%g ",Qxs[i]);printf (")[%g], %d nz\n",a0,nnz);
#endif
// Pack the vector into a CoinPackedVector and generate the cut.
CoinPackedVector a (false);
a.reserve (nnz);
#ifdef DEBUG
CouNumber lhs = 0, lhsc = 0,
*optimum = cg -> Problem () -> bestSol (),
*current = cg -> Problem () -> X ();
#endif
for (int i=0; i < numcols; i++)
if (fabs (Qxs [i]) > 1.0e-21) { // why 1.0e-21? Look at CoinPackedMatrix.cpp:2188
// compute violation
#ifdef DEBUG
if (optimum) {
printf ("%+g * %g ", Qxs [i], optimum [i]);
lhs += Qxs [i] * optimum [i];
}
lhsc += Qxs [i] * current [i];
#endif
a.insert (i, Qxs [i]);
}
OsiRowCut cut;
cut.setRow (a);
delete [] Qxs;
if (varVal < exprVal) { //(lambda == dCoeffLo_) {
cut.setUb (a0);
#ifdef DEBUG
if (optimum && (lhs - a0 > COUENNE_EPS)) {
printf ("cut violates optimal solution: %g > %g\n", lhs, a0);
cut.print ();
}
if (lhsc < a0 + COUENNE_EPS){
printf ("cut (+) is not cutting: ");
cut.print ();
}
#endif
// cut.setLb(-COUENNE_INFINITY);
}
else {
cut.setLb (a0);
#ifdef DEBUG
if (optimum && (lhs - a0 < -COUENNE_EPS)) {
printf ("cut violates optimal solution: %g < %g\n", lhs, a0);
cut.print ();
}
if (lhsc > a0 - COUENNE_EPS){
printf ("cut (-) is not cutting: ");
cut.print ();
}
#endif
// cut.setUb(COUENNE_INFINITY);
}
cs.insert (cut);
}
//===========================================================================//
int GAP_DecompApp::createModelPartKP(DecompConstraintSet* model,
vector<int>& whichKnaps)
{
int i, j, b, colIndex;
int status = GAPStatusOk;
int nTasks = m_instance.getNTasks(); //n
int nMachines = m_instance.getNMachines(); //m
int nKnaps = static_cast<int>(whichKnaps.size());
const int* weight = m_instance.getWeight();
const int* capacity = m_instance.getCapacity();
int nCols = nTasks * nMachines;
int nRows = nKnaps;
UtilPrintFuncBegin(m_osLog, m_classTag,
"createModelPartKP()", m_appParam.LogLevel, 2);
//---
//--- Build the relax model constraints (KP = assignment problem).
//---
//--- m is number of machines (index i)
//--- n is number of tasks (index j)
//---
//--- sum{j in 1..n} w[i,j] x[i,j] <= b[i], i in 1..m
//--- x[i,j] in {0,1}, i in 1..m, j in 1..n
//---
//--- Example structure: m=3, n=4
//--- xxxx <= b[i=1]
//--- xxxx <= b[i=2]
//--- xxxx <= b[i=3]
//---
//---
//--- Allocate an empty row-ordered CoinPackedMatrix. Since we plan
//--- to add rows, set the column dimension and let the row dimension
//--- be set dynamically.
//---
model->M = new CoinPackedMatrix(false, 0.0, 0.0);
CoinAssertHint(model->M, "Error: Out of Memory");
model->M->setDimensions(0, nCols);
//---
//--- we know the sizes needed, so reserve space for them (for efficiency)
//---
model->reserve(nRows, nCols);
//---
//--- create one row per knapsack
//--- rowNames are not needed, they are used for debugging
//---
vector<int>::iterator it;
for (it = whichKnaps.begin(); it != whichKnaps.end(); ++it) {
i = *it;
CoinPackedVector row;
string rowName = "k(i_" + UtilIntToStr(i) + ")";
for (j = 0; j < nTasks; j++) {
colIndex = getIndexIJ(i, j);
row.insert(colIndex, weight[colIndex]);
}
model->appendRow(row, -m_infinity, capacity[i], rowName);
}
//---
//--- set the col upper and lower bounds (all in [0,1])
//---
UtilFillN(model->colLB, nCols, 0.0);
UtilFillN(model->colUB, nCols, 1.0);
//---
//--- set the indices of the integer variables of model
//---
UtilIotaN(model->integerVars, nCols, 0);
//---
//--- tell the solver which columns are active (in this block)
//---
for (it = whichKnaps.begin(); it != whichKnaps.end(); ++it) {
b = *it;
for (i = 0; i < nMachines; i++) {
for (j = 0; j < nTasks; j++) {
colIndex = getIndexIJ(i, j);
if (i == b) {
model->activeColumns.push_back(colIndex);
}
}
}
}
//---
//--- set column names for debugging
//---
colIndex = 0;
for (i = 0; i < nMachines; i++) {
for (j = 0; j < nTasks; j++) {
string colName = "x("
+ UtilIntToStr(colIndex) + "_"
+ UtilIntToStr(i) + "," + UtilIntToStr(j) + ")";
model->colNames.push_back(colName);
colIndex++;
}
}
UtilPrintFuncEnd(m_osLog, m_classTag,
"createModelPartKP()", m_appParam.LogLevel, 2);
return status;
}
//===========================================================================//
void MCF_DecompApp::createModelCore(DecompConstraintSet* model)
{
//---
//--- MASTER (A''):
//--- sum{k in K} x[k,i,j] >= l[i,j], for all (i,j) in A
//--- sum{k in K} x[k,i,j] <= u[i,j], for all (i,j) in A
//--- x[k,i,j] integer >= l[i,j] <= u[i,j], for all (i,j) in A
//---
int k, a, colIndex;
int numCommodities = m_instance.m_numCommodities;
int numArcs = m_instance.m_numArcs;
int numCols = numCommodities * numArcs;
int numRows = 2 * numArcs;
MCF_Instance::arc* arcs = m_instance.m_arcs;
UtilPrintFuncBegin(m_osLog, m_classTag,
"createModelCore()", m_appParam.LogLevel, 2);
//---
//--- create space for the model matrix (row-majored)
//---
model->M = new CoinPackedMatrix(false, 0.0, 0.0);
if (!model->M) {
throw UtilExceptionMemory("createModelCore", "MCF_DecompApp");
}
model->M->setDimensions(0, numCols);
model->reserve(numRows, numCols);
//---
//--- create the rows and set the col/row bounds
//---
UtilFillN(model->colLB, numCols, 0.0);
UtilFillN(model->colUB, numCols, m_infinity);
for (a = 0; a < numArcs; a++) {
CoinPackedVector row;
double arcLB = arcs[a].lb;
double arcUB = arcs[a].ub;
for (k = 0; k < numCommodities; k++) {
colIndex = k * numArcs + a;
model->colLB[colIndex] = arcLB;
model->colUB[colIndex] = arcUB;
row.insert(colIndex, 1.0);
}
//TODO: any issue with range constraints?
model->appendRow(row, -m_infinity, arcUB);
string rowNameUB = "capUB(" +
UtilIntToStr(a) + "_" +
UtilIntToStr(arcs[a].tail) + "," +
UtilIntToStr(arcs[a].head) + ")";
model->rowNames.push_back(rowNameUB);
model->appendRow(row, arcLB, m_infinity);
string rowNameLB = "capLB(" +
UtilIntToStr(a) + "_" +
UtilIntToStr(arcs[a].tail) + "," +
UtilIntToStr(arcs[a].head) + ")";
model->rowNames.push_back(rowNameLB);
}
//---
//--- create column names (helps with debugging)
//---
for (k = 0; k < numCommodities; k++) {
for (a = 0; a < numArcs; a++) {
string colName = "x(comm_" + UtilIntToStr(k) + "," +
UtilIntToStr(a) + "_" +
UtilIntToStr(arcs[a].tail) + "," +
UtilIntToStr(arcs[a].head) + ")";
model->colNames.push_back(colName);
}
}
//---
//--- set the indices of the integer variables of model
//---
UtilIotaN(model->integerVars, numCols, 0);
UtilPrintFuncEnd(m_osLog, m_classTag,
"createModelCore()", m_appParam.LogLevel, 2);
}
void
CoinShallowPackedVectorUnitTest()
{
CoinRelFltEq eq;
int i;
// Test default constructor
{
CoinShallowPackedVector r;
assert( r.indices_==NULL );
assert( r.elements_==NULL );
assert( r.nElements_==0 );
}
// Test set and get methods
const int ne = 4;
int inx[ne] = { 1, 3, 4, 7 };
double el[ne] = { 1.2, 3.4, 5.6, 7.8 };
{
CoinShallowPackedVector r;
assert( r.getNumElements()==0 );
// Test setting/getting elements with int* & double* vectors
r.setVector( ne, inx, el );
assert( r.getNumElements()==ne );
for ( i=0; i<ne; i++ ) {
assert( r.getIndices()[i] == inx[i] );
assert( r.getElements()[i] == el[i] );
}
assert ( r.getMaxIndex()==7 );
assert ( r.getMinIndex()==1 );
// try to clear it
r.clear();
assert( r.indices_==NULL );
assert( r.elements_==NULL );
assert( r.nElements_==0 );
// Test setting/getting elements with indices out of order
const int ne2 = 5;
int inx2[ne2] = { 2, 4, 8, 14, 3 };
double el2[ne2] = { 2.2, 4.4, 6.6, 8.8, 3.3 };
r.setVector(ne2,inx2,el2);
assert( r.getNumElements()==ne2 );
for (i = 0; i < ne2; ++i) {
assert( r.getIndices()[i]==inx2[i] );
assert( r.getElements()[i]==el2[i] );
}
assert ( r.getMaxIndex()==14 );
assert ( r.getMinIndex()==2 );
// try to call it once more
assert ( r.getMaxIndex()==14 );
assert ( r.getMinIndex()==2 );
CoinShallowPackedVector r1(ne2,inx2,el2);
assert( r == r1 );
// assignment operator
r1.clear();
r1 = r;
assert( r == r1 );
// assignment from packed vector
CoinPackedVector pv1(ne2,inx2,el2);
r1 = pv1;
assert( r == r1 );
// construction
CoinShallowPackedVector r2(r1);
assert( r2 == r );
// construction from packed vector
CoinShallowPackedVector r3(pv1);
assert( r3 == r );
// test duplicate indices
{
const int ne3 = 4;
int inx3[ne3] = { 2, 4, 2, 3 };
double el3[ne3] = { 2.2, 4.4, 8.8, 6.6 };
r.setVector(ne3,inx3,el3, false);
assert(r.testForDuplicateIndex() == false);
bool errorThrown = false;
try {
r.setTestForDuplicateIndex(true);
}
catch (CoinError& e) {
errorThrown = true;
}
assert( errorThrown );
r.clear();
errorThrown = false;
try {
r.setVector(ne3,inx3,el3);
}
catch (CoinError& e) {
errorThrown = true;
}
assert( errorThrown );
errorThrown = false;
try {
CoinShallowPackedVector r1(ne3,inx3,el3);
}
catch (CoinError& e) {
errorThrown = true;
}
assert( errorThrown );
}
}
// Test copy constructor and assignment operator
{
CoinShallowPackedVector rhs;
{
CoinShallowPackedVector r;
{
CoinShallowPackedVector rC1(r);
assert( 0==r.getNumElements() );
assert( 0==rC1.getNumElements() );
r.setVector( ne, inx, el );
assert( ne==r.getNumElements() );
assert( 0==rC1.getNumElements() );
}
CoinShallowPackedVector rC2(r);
assert( ne==r.getNumElements() );
assert( ne==rC2.getNumElements() );
for ( i=0; i<ne; i++ ) {
assert( r.getIndices()[i] == rC2.getIndices()[i] );
assert( r.getElements()[i] == rC2.getElements()[i] );
}
rhs=rC2;
}
// Test that rhs has correct values even though lhs has gone out of scope
assert( rhs.getNumElements()==ne );
for ( i=0; i<ne; i++ ) {
assert( inx[i] == rhs.getIndices()[i] );
assert( el[i] == rhs.getElements()[i] );
}
}
// Test operator==
{
CoinShallowPackedVector v1,v2;
assert( v1==v2 );
assert( v2==v1 );
assert( v1==v1 );
assert( !(v1!=v2) );
v1.setVector( ne, inx, el );
assert ( !(v1==v2) );
assert ( v1!=v2 );
CoinShallowPackedVector v3(v1);
assert( v3==v1 );
assert( v3!=v2 );
CoinShallowPackedVector v4(v2);
assert( v4!=v1 );
assert( v4==v2 );
}
{
// Test operator[] and isExistingIndex()
const int ne = 4;
int inx[ne] = { 1, 4, 0, 2 };
double el[ne] = { 10., 40., 1., 50. };
CoinShallowPackedVector r;
assert( r[1]==0. );
r.setVector(ne,inx,el);
assert( r[-1]==0. );
assert( r[ 0]==1. );
assert( r[ 1]==10.);
assert( r[ 2]==50.);
assert( r[ 3]==0. );
assert( r[ 4]==40.);
assert( r[ 5]==0. );
assert( r.isExistingIndex(2) );
assert( !r.isExistingIndex(3) );
assert( !r.isExistingIndex(-1) );
assert( r.isExistingIndex(0) );
assert( !r.isExistingIndex(3) );
assert( r.isExistingIndex(4) );
assert( !r.isExistingIndex(5) );
assert ( r.getMaxIndex()==4 );
assert ( r.getMinIndex()==0 );
}
// Test that attemping to get min/max index of a 0,
// length vector
{
CoinShallowPackedVector nullVec;
assert( nullVec.getMaxIndex() == -COIN_INT_MAX/*0*/ );
assert( nullVec.getMinIndex() == COIN_INT_MAX/*0*/ );
}
{
// test dense vector
const int ne = 4;
int inx[ne] = { 1, 4, 0, 2 };
double el[ne] = { 10., 40., 1., 50. };
CoinShallowPackedVector r;
r.setVector(ne,inx,el);
double * dense = r.denseVector(6);
assert(dense[0] == 1.);
assert(dense[1] == 10.);
assert(dense[2] == 50.);
assert(dense[3] == 0.);
assert(dense[4] == 40.);
assert(dense[5] == 0.);
delete[] dense;
// try once more
dense = r.denseVector(7);
assert(dense[0] == 1.);
assert(dense[1] == 10.);
assert(dense[2] == 50.);
assert(dense[3] == 0.);
assert(dense[4] == 40.);
assert(dense[5] == 0.);
assert(dense[6] == 0.);
delete[] dense;
}
#if 0
// what happens when someone sets
// the number of elements to be a negative number
{
const int ne = 4;
int inx1[ne] = { 1, 3, 4, 7 };
double el1[ne] = { 1.2, 3.4, 5.6, 7.8 };
CoinShallowPackedVector v1;
v1.setVector(-ne,inx1,el1);
}
#endif
// Test adding vectors
{
const int ne1 = 5;
int inx1[ne1] = { 1, 3, 4, 7, 5 };
double el1[ne1] = { 1., 5., 6., 2., 9. };
const int ne2 = 4;
int inx2[ne2] = { 7, 4, 2, 1 };
double el2[ne2] = { 7., 4., 2., 1. };
CoinShallowPackedVector v1;
v1.setVector(ne1,inx1,el1);
CoinShallowPackedVector v2;
v2.setVector(ne2,inx2,el2);
CoinPackedVector r = v1 + v2;
const int ner = 6;
int inxr[ner] = { 1, 2, 3, 4, 5, 7 };
double elr[ner] = { 1.+1., 0.+2., 5.+0., 6.+4., 9.+0., 2.+7. };
CoinPackedVector rV;
rV.setVector(ner,inxr,elr);
assert( rV != r );
assert( r.isEquivalent(rV) );
CoinPackedVector p1=v1+3.1415;
for ( i=0; i<p1.getNumElements(); i++ )
assert( eq( p1.getElements()[i], v1.getElements()[i]+3.1415) );
CoinPackedVector p2=(-3.1415) + p1;
assert( p2.isEquivalent(v1) );
}
// Test subtracting vectors
{
const int ne1 = 5;
int inx1[ne1] = { 1, 3, 4, 7, 5 };
double el1[ne1] = { 1., 5., 6., 2., 9. };
const int ne2 = 4;
int inx2[ne2] = { 7, 4, 2, 1 };
double el2[ne2] = { 7., 4., 2., 1. };
CoinShallowPackedVector v1;
v1.setVector(ne1,inx1,el1);
CoinShallowPackedVector v2;
v2.setVector(ne2,inx2,el2);
CoinPackedVector r = v1 - v2;
const int ner = 6;
int inxr[ner] = { 1, 2, 3, 4, 5, 7 };
double elr[ner] = { 1.-1., 0.-2., 5.-0., 6.-4., 9.-0., 2.-7. };
CoinPackedVector rV;
rV.setVector(ner,inxr,elr);
assert( r.isEquivalent(rV) );
CoinPackedVector p1=v1-3.1415;
for ( i=0; i<p1.getNumElements(); i++ )
assert( eq( p1.getElements()[i], v1.getElements()[i]-3.1415) );
}
// Test multiplying vectors
{
const int ne1 = 5;
int inx1[ne1] = { 1, 3, 4, 7, 5 };
double el1[ne1] = { 1., 5., 6., 2., 9. };
const int ne2 = 4;
int inx2[ne2] = { 7, 4, 2, 1 };
double el2[ne2] = { 7., 4., 2., 1. };
CoinShallowPackedVector v1;
v1.setVector(ne1,inx1,el1);
CoinShallowPackedVector v2;
v2.setVector(ne2,inx2,el2);
CoinPackedVector r = v1 * v2;
const int ner = 6;
int inxr[ner] = { 1, 2, 3, 4, 5, 7 };
double elr[ner] = { 1.*1., 0.*2., 5.*0., 6.*4., 9.*0., 2.*7. };
CoinPackedVector rV;
rV.setVector(ner,inxr,elr);
assert( r.isEquivalent(rV) );
CoinPackedVector p1=v1*3.3;
for ( i=0; i<p1.getNumElements(); i++ )
assert( eq( p1.getElements()[i], v1.getElements()[i]*3.3) );
CoinPackedVector p2=(1./3.3) * p1;
assert( p2.isEquivalent(v1) );
}
// Test dividing vectors
{
const int ne1 = 3;
int inx1[ne1] = { 1, 4, 7 };
double el1[ne1] = { 1., 6., 2. };
const int ne2 = 4;
int inx2[ne2] = { 7, 4, 2, 1 };
double el2[ne2] = { 7., 4., 2., 1. };
CoinShallowPackedVector v1;
v1.setVector(ne1,inx1,el1);
CoinShallowPackedVector v2;
v2.setVector(ne2,inx2,el2);
CoinPackedVector r = v1 / v2;
const int ner = 4;
int inxr[ner] = { 1, 2, 4, 7 };
double elr[ner] = { 1./1., 0./2., 6./4., 2./7. };
CoinPackedVector rV;
rV.setVector(ner,inxr,elr);
assert( r.isEquivalent(rV) );
CoinPackedVector p1=v1/3.1415;
for ( i=0; i<p1.getNumElements(); i++ )
assert( eq( p1.getElements()[i], v1.getElements()[i]/3.1415) );
}
// Test sum
{
CoinShallowPackedVector s;
assert( s.sum() == 0 );
int inx = 25;
double value = 45.;
s.setVector(1, &inx, &value);
assert(s.sum()==45.);
const int ne1 = 5;
int inx1[ne1] = { 10, 3, 4, 7, 5 };
double el1[ne1] = { 1., 5., 6., 2., 9. };
s.setVector(ne1,inx1,el1);
assert(s.sum()==1.+5.+6.+2.+9.);
}
// Just another interesting test
{
// Create numerator vector
const int ne1 = 2;
int inx1[ne1] = { 1, 4 };
double el1[ne1] = { 1., 6. };
CoinShallowPackedVector v1(ne1,inx1,el1);
// create denominator vector
const int ne2 = 3;
int inx2[ne2] = { 1, 2, 4 };
double el2[ne2] = { 1., 7., 4.};
CoinShallowPackedVector v2(ne2,inx2,el2);
// Compute ratio
CoinPackedVector ratio = v1 / v2;
// Sort ratios
ratio.sortIncrElement();
// Test that the sort really worked
assert( ratio.getElements()[0] == 0.0/7.0 );
assert( ratio.getElements()[1] == 1.0/1.0 );
assert( ratio.getElements()[2] == 6.0/4.0 );
// Get numerator of of sorted ratio vector
assert( v1[ ratio.getIndices()[0] ] == 0.0 );
assert( v1[ ratio.getIndices()[1] ] == 1.0 );
assert( v1[ ratio.getIndices()[2] ] == 6.0 );
// Get denominator of of sorted ratio vector
assert( v2[ ratio.getIndices()[0] ] == 7.0 );
assert( v2[ ratio.getIndices()[1] ] == 1.0 );
assert( v2[ ratio.getIndices()[2] ] == 4.0 );
}
{
// Test that sample usage works
const int ne = 4;
int inx[ne] = { 1, 4, 0, 2 };
double el[ne] = { 10., 40., 1., 50. };
CoinShallowPackedVector r(ne,inx,el);
assert( r.getIndices()[0]== 1 );
assert( r.getElements()[0]==10. );
assert( r.getIndices()[1]== 4 );
assert( r.getElements()[1]==40. );
assert( r.getIndices()[2]== 0 );
assert( r.getElements()[2]== 1. );
assert( r.getIndices()[3]== 2 );
assert( r.getElements()[3]==50. );
assert( r[ 0]==1. );
assert( r[ 1]==10.);
assert( r[ 2]==50.);
assert( r[ 3]==0. );
assert( r[ 4]==40.);
CoinShallowPackedVector r1;
r1=r;
assert( r==r1 );
CoinPackedVector add = r + r1;
assert( add[0] == 1.+ 1. );
assert( add[1] == 10.+10. );
assert( add[2] == 50.+50. );
assert( add[3] == 0.+ 0. );
assert( add[4] == 40.+40. );
assert( r.sum() == 10.+40.+1.+50. );
}
{
// Test findIndex
const int ne = 4;
int inx[ne] = { 1, -4, 0, 2 };
double el[ne] = { 10., 40., 1., 50. };
CoinShallowPackedVector r(ne,inx,el);
assert( r.findIndex(2) == 3 );
assert( r.findIndex(0) == 2 );
assert( r.findIndex(-4) == 1 );
assert( r.findIndex(1) == 0 );
assert( r.findIndex(3) == -1 );
}
{
// Test construction with testing for duplicates as false
const int ne = 4;
int inx[ne] = { 1, -4, 0, 2 };
double el[ne] = { 10., 40., 1., 50. };
CoinShallowPackedVector r(ne,inx,el,false);
assert( r.isExistingIndex(1) );
assert( r.isExistingIndex(-4) );
assert( r.isExistingIndex(0) );
assert( r.isExistingIndex(2) );
assert( !r.isExistingIndex(3) );
assert( !r.isExistingIndex(-3) );
}
}
//===========================================================================//
void MCF_DecompApp::createModelRelax(DecompConstraintSet* model,
int commId)
{
//---
//--- SUBPROBLEM (A'): (one block for each k in K)
//--- sum{(j,i) in A} x[k,i,j] -
//--- sum{(i,j) in A} x[k,i,j] = d[i,k], for all i in N
//--- x[k,i,j] integer >= l[i,j] <= u[i,j], for all (i,j) in A
//--- For k=(s,t) in K,
//--- d[i,k] = -d[k] if i=s
//--- = d[k] if i=t
//--- = 0, otherwise
//---
int a, i, head, tail, colIndex, source, sink;
int numCommodities = m_instance.m_numCommodities;
int numArcs = m_instance.m_numArcs;
int numNodes = m_instance.m_numNodes;
int numCols = numCommodities * numArcs;
int numRows = numNodes;
MCF_Instance::arc* arcs = m_instance.m_arcs;
MCF_Instance::commodity* commodities = m_instance.m_commodities;
UtilPrintFuncBegin(m_osLog, m_classTag,
"createModelRelax()", m_appParam.LogLevel, 2);
//---
//--- create space for the model matrix (row-majored)
//---
model->M = new CoinPackedMatrix(false, 0.0, 0.0);
if (!model->M) {
throw UtilExceptionMemory("createModelCore", "MCF_DecompApp");
}
model->M->setDimensions(0, numCols);
model->reserve(numRows, numCols);
//---
//--- get this commodity's source and sink node
//---
source = commodities[commId].source;
sink = commodities[commId].sink;
//---
//--- create the rows
//--- NOTE: this is somewhat inefficient (but simple)
//---
for (i = 0; i < numNodes; i++) {
CoinPackedVector row;
for (a = 0; a < numArcs; a++) {
tail = arcs[a].tail;
head = arcs[a].head;
if (head == i) {
colIndex = commId * numArcs + a;
row.insert(colIndex, 1.0);
} else if (tail == i) {
colIndex = commId * numArcs + a;
row.insert(colIndex, -1.0);
}
}
if (i == source)
model->appendRow(row,
-commodities[commId].demand,
-commodities[commId].demand);
else if (i == sink)
model->appendRow(row,
commodities[commId].demand,
commodities[commId].demand);
else {
model->appendRow(row, 0.0, 0.0);
}
string rowName = "flow(" +
UtilIntToStr(commId) + "_" +
UtilIntToStr(i) + "_" +
UtilIntToStr(source) + "," +
UtilIntToStr(sink) + ")";
model->rowNames.push_back(rowName);
}
//---
//--- create a list of the "active" columns (those related
//--- to this commmodity) all other columns are fixed to 0
//---
UtilFillN(model->colLB, numCols, 0.0);
UtilFillN(model->colUB, numCols, 0.0);
colIndex = commId * numArcs;
for (a = 0; a < numArcs; a++) {
double arcLB = arcs[a].lb;
double arcUB = arcs[a].ub;
model->colLB[colIndex] = arcLB;
model->colUB[colIndex] = arcUB;
model->activeColumns.push_back(colIndex);
colIndex++;
}
//---
//--- set the indices of the integer variables of model
//---
UtilIotaN(model->integerVars, numCols, 0);
UtilPrintFuncEnd(m_osLog, m_classTag,
"createModelRelax()", m_appParam.LogLevel, 2);
}
/**Clean cut 2, different algorithm. First check the dynamic of the cut if < maxRatio scale to a biggest coef of 1
otherwise scale it so that biggest coeff is 1 and try removing tinys ( < 1/maxRatio) either succeed or fail */
int
Validator::cleanCut2(OsiRowCut & aCut, const double * solCut, const OsiSolverInterface &si, const CglParam &/* par */,
const double * origColLower, const double * origColUpper) const
{
/** Compute fill-in in si */
int numcols = si.getNumCols();
// int numrows = si.getNumRows();
const double * colLower = (origColLower) ? origColLower : si.getColLower();
const double * colUpper = (origColUpper) ? origColUpper : si.getColUpper();
int maxNnz = static_cast<int> ( maxFillIn_ * static_cast<double> (numcols));
double rhs = aCut.lb();
assert (aCut.ub()> 1e50);
CoinPackedVector *vec = const_cast<CoinPackedVector *>(&aCut.row());
// vec->sortIncrIndex();
int * indices = vec->getIndices();
double * elems = vec->getElements();
int n = vec->getNumElements();
if (n==0)
{
numRejected_[EmptyCut]++;
return EmptyCut;
}
/** First compute violation if it is too small exit */
double violation = aCut.violated(solCut);
if (violation < minViolation_)
return 1;
/** Now relax get dynamic and remove tiny elements */
int offset = 0;
rhs -= 1e-10;
double smallest = fabs(rhs);
double biggest = smallest;
double veryTiny = 1e-20;
for (int i = 0 ; i < n ; i++)
{
double val = fabs(elems[i]);
if (val > veryTiny) //tiny should be very very small
{
smallest = std::min(val,smallest);
biggest = std::max (val,biggest);
}
}
if (biggest > 1e9)
{
#ifdef DEBUG
std::cout<<"Whaooo "<<biggest/smallest<<std::endl;
#endif
numRejected_[BigDynamic]++;
return BigDynamic;
}
//rescale the cut so that biggest is 1e1.
double toBeBiggest = rhsScale_;
rhs *= (toBeBiggest / biggest);
toBeBiggest /= biggest;
for (int i = 0 ; i < n ; i++)
{
elems[i] *= toBeBiggest;
}
if (biggest > maxRatio_ * smallest) //we have to remove some small coefficients
{
double myTiny = biggest * toBeBiggest / maxRatio_;
veryTiny *= toBeBiggest ;
for (int i = 0 ; i < n ; i++)
{
double val = fabs(elems[i]);
if (val < myTiny)
{
if (val< veryTiny)
{
offset++;
continue;
}
int & iCol = indices[i];
if (elems[i]>0. && colUpper[iCol] < 1000.)
{
offset++;
rhs -= elems[i] * colUpper[iCol];
elems[i]=0;
}
else if (elems[i]<0. && colLower[iCol] > -1000.)
{
offset++;
rhs -= elems[i] * colLower[iCol];
elems[i]=0.;
}
else
{
numRejected_[SmallCoefficient]++;
return SmallCoefficient;
}
}
else //Not a small coefficient keep it
{
if (offset) //if offset is zero current values are ok
{
int i2 = i - offset;
indices[i2] = indices[i];
elems[i2] = elems[i];
}
}
}
}
if ((n - offset) > maxNnz)
{
numRejected_[DenseCut] ++;
return DenseCut;
}
if (offset)
vec->truncate(n - offset);
if (vec->getNumElements() == 0 )
{
numRejected_[EmptyCut]++;
return EmptyCut;
}
/** recheck violation */
aCut.setLb(rhs);
violation = aCut.violated(solCut);
if (violation < minViolation_)
{
numRejected_[SmallViolation]++;
return SmallViolation;
}
assert(fabs(rhs)<1e09);
return NoneAccepted;
}
//===========================================================================//
void MCF_DecompApp::createModelRelaxSparse(DecompConstraintSet* model,
int commId)
{
//---
//--- SUBPROBLEM (A'): (one block for each k in K)
//--- sum{(j,i) in A} x[k,i,j] -
//--- sum{(i,j) in A} x[k,i,j] = d[i,k], for all i in N
//--- x[k,i,j] integer >= l[i,j] <= u[i,j], for all (i,j) in A
//--- For k=(s,t) in K,
//--- d[i,k] = -d[k] if i=s
//--- = d[k] if i=t
//--- = 0, otherwise
//---
int a, i, head, tail, origColIndex, source, sink;
int numArcs = m_instance.m_numArcs;
int numNodes = m_instance.m_numNodes;
int numCommodities = m_instance.m_numCommodities;
int numCols = numArcs;
int numRows = numNodes;
int numColsOrig = numArcs * numCommodities;
MCF_Instance::arc* arcs = m_instance.m_arcs;
MCF_Instance::commodity* commodities = m_instance.m_commodities;
UtilPrintFuncBegin(m_osLog, m_classTag,
"createModelRelaxSparse()", m_appParam.LogLevel, 2);
//---
//--- create space for the model matrix (row-majored)
//---
model->M = new CoinPackedMatrix(false, 0.0, 0.0);
if (!model->M) {
throw UtilExceptionMemory("createModelCore", "MCF_DecompApp");
}
model->M->setDimensions(0, numCols);
model->reserve(numRows, numCols);
model->setSparse(numColsOrig);
//---
//--- get this commodity's source and sink node
//---
source = commodities[commId].source;
sink = commodities[commId].sink;
//---
//--- create the rows
//--- NOTE: this is somewhat inefficient (but simple)
//---
for (i = 0; i < numNodes; i++) {
CoinPackedVector row;
for (a = 0; a < numArcs; a++) {
tail = arcs[a].tail;
head = arcs[a].head;
if (head == i) {
row.insert(a, 1.0);
} else if (tail == i) {
row.insert(a, -1.0);
}
}
if (i == source)
model->appendRow(row,
-commodities[commId].demand,
-commodities[commId].demand);
else if (i == sink)
model->appendRow(row,
commodities[commId].demand,
commodities[commId].demand);
else {
model->appendRow(row, 0.0, 0.0);
}
}
//---
//--- set the colLB, colUB, integerVars and sparse mapping
//---
origColIndex = commId * numArcs;
for (a = 0; a < numArcs; a++) {
double arcLB = arcs[a].lb;
double arcUB = arcs[a].ub;
model->pushCol(arcLB, arcUB, true, origColIndex);
origColIndex++;
}
UtilPrintFuncEnd(m_osLog, m_classTag,
"createModelRelaxSparse()", m_appParam.LogLevel, 2);
}
LPSolver::Status LPSolver::optimize(
OptimizationGoal goal, // goal of optimization (minimize or maximize)
Array<double> &obj, // objective function vector
Array<int> &matrixBegin, // matrixBegin[i] = begin of column i
Array<int> &matrixCount, // matrixCount[i] = number of nonzeroes in column i
Array<int> &matrixIndex, // matrixIndex[n] = index of matrixValue[n] in its column
Array<double> &matrixValue, // matrixValue[n] = non-zero value in matrix
Array<double> &rightHandSide, // right-hand side of LP constraints
Array<char> &equationSense, // 'E' == 'G' >= 'L' <=
Array<double> &lowerBound, // lower bound of x[i]
Array<double> &upperBound, // upper bound of x[i]
double &optimum, // optimum value of objective function (if result is lpOptimal)
Array<double> &x // x-vector of optimal solution (if result is lpOptimal)
)
{
if(osi->getNumCols()>0) { // get a fresh one if necessary
delete osi;
osi = CoinManager::createCorrectOsiSolverInterface();
}
const int numRows = rightHandSide.size();
const int numCols = obj.size();
#ifdef OGDF_DEBUG
const int numNonzeroes = matrixIndex.size();
#endif
// assert correctness of array boundaries
OGDF_ASSERT(obj .low() == 0 && obj .size() == numCols);
OGDF_ASSERT(matrixBegin .low() == 0 && matrixBegin .size() == numCols);
OGDF_ASSERT(matrixCount .low() == 0 && matrixCount .size() == numCols);
OGDF_ASSERT(matrixIndex .low() == 0 && matrixIndex .size() == numNonzeroes);
OGDF_ASSERT(matrixValue .low() == 0 && matrixValue .size() == numNonzeroes);
OGDF_ASSERT(rightHandSide.low() == 0 && rightHandSide.size() == numRows);
OGDF_ASSERT(equationSense.low() == 0 && equationSense.size() == numRows);
OGDF_ASSERT(lowerBound .low() == 0 && lowerBound .size() == numCols);
OGDF_ASSERT(upperBound .low() == 0 && upperBound .size() == numCols);
OGDF_ASSERT(x .low() == 0 && x .size() == numCols);
osi->setObjSense(goal==lpMinimize ? 1 : -1);
int i;
CoinPackedVector zero;
for(i = 0; i < numRows; ++i) {
osi->addRow(zero,equationSense[i],rightHandSide[i],0);
}
for(int colNo = 0; colNo < numCols; ++colNo) {
CoinPackedVector cpv;
for(i = matrixBegin[colNo]; i<matrixBegin[colNo]+matrixCount[colNo]; ++i) {
cpv.insert(matrixIndex[i],matrixValue[i]);
}
osi->addCol(cpv,lowerBound[colNo],upperBound[colNo],obj[colNo]);
}
osi->initialSolve();
Status status;
if(osi->isProvenOptimal()) {
optimum = osi->getObjValue();
const double* sol = osi->getColSolution();
for(i = numCols; i-->0;)
x[i]=sol[i];
status = lpOptimal;
OGDF_ASSERT_IF(dlExtendedChecking,
checkFeasibility(matrixBegin,matrixCount,matrixIndex,matrixValue,
rightHandSide,equationSense,lowerBound,upperBound,x));
} else if(osi->isProvenPrimalInfeasible())
status = lpInfeasible;
else if(osi->isProvenDualInfeasible())
status = lpUnbounded;
else
OGDF_THROW_PARAM(AlgorithmFailureException,afcNoSolutionFound);
return status;
}
bool OSI_X_SolverWrapper<SOLVERINTERFACE>::setup(const LP_Constraints & cstraints) //cstraints <-> constraints
{
bool bOk = true;
if ( si == NULL )
{
return false;
}
assert(_nbParams == cstraints._nbParams);
int NUMVAR = cstraints._constraintMat.cols();
int NUMCON = cstraints._constraintMat.rows();
int NUMANZ = cstraints._constraintMat.cols() * cstraints._constraintMat.rows(); //DENSE MATRIX
std::vector<double> col_lb(NUMVAR);//the column lower bounds
std::vector<double> col_ub(NUMVAR);//the column upper bounds
this->_nbParams = NUMVAR;
if (cstraints._bminimize)
{
si->setObjSense( 1 );
}
else
{
si->setObjSense( -1 );
}
const Mat & A = cstraints._constraintMat;
//Equality constraint will be handked by two constraintsdue to the API limitation.
size_t nbLine = A.rows() + std::count(cstraints._vec_sign.begin(), cstraints._vec_sign.end(), EQ);
std::vector<double> row_lb(nbLine);//the row lower bounds
std::vector<double> row_ub(nbLine);//the row upper bounds
CoinPackedMatrix * matrix = new CoinPackedMatrix(false,0,0);
matrix->setDimensions(0, NUMVAR);
//-- Add row-wise constraint
size_t indexRow = 0;
for (int i=0; i < A.rows(); ++i)
{
Vec temp = A.row(i);
CoinPackedVector row;
if ( cstraints._vec_sign[i] == EQ || cstraints._vec_sign[i] == LE )
{
int coef = 1;
for ( int j = 0; j < A.cols() ; j++ )
{
row.insert(j, coef * temp.data()[j]);
}
row_lb[indexRow] = -1.0 * si->getInfinity();
row_ub[indexRow] = coef * cstraints._Cst_objective(i);
matrix->appendRow(row);
indexRow++;
}
if ( cstraints._vec_sign[i] == EQ || cstraints._vec_sign[i] == GE )
{
int coef = -1;
for ( int j = 0; j < A.cols() ; j++ )
{
row.insert(j, coef * temp.data()[j]);
}
row_lb[indexRow] = -1.0 * si->getInfinity();
row_ub[indexRow] = coef * cstraints._Cst_objective(i);
matrix->appendRow(row);
indexRow++;
}
}
//-- Setup bounds
if (cstraints._vec_bounds.size() == 1)
{
// Setup the same bound for all the parameter
for (int i=0; i < this->_nbParams; ++i)
{
col_lb[i] = cstraints._vec_bounds[0].first;
col_ub[i] = cstraints._vec_bounds[0].second;
}
}
else
{
for (int i=0; i < this->_nbParams; ++i)
{
col_lb[i] = cstraints._vec_bounds[i].first;
col_ub[i] = cstraints._vec_bounds[i].second;
}
}
si->loadProblem(*matrix, &col_lb[0], &col_ub[0], cstraints._vec_cost.empty() ? NULL : &cstraints._vec_cost[0], &row_lb[0], &row_ub[0] );
delete matrix;
return bOk;
}
//===========================================================================//
DecompConstraintSet *
ATM_DecompApp::createModelRelax1(const int a,
bool includeCount){
UtilPrintFuncBegin(m_osLog, m_classTag,
"createModelRelax1()", m_appParam.LogLevel, 2);
int t, d, nRows, pairIndex;
double rhs, coefA, coefC;
pair<int,int> adP;
vector<int>::const_iterator vi;
const int nSteps = m_appParam.NumSteps;
const int nDates = m_instance.getNDates();
const vector<int> & pairsAD = m_instance.getPairsAD();
const double * a_ad = m_instance.get_a_ad(); //dense storage
const double * b_ad = m_instance.get_b_ad(); //dense storage
const double * c_ad = m_instance.get_c_ad(); //dense storage
const double * d_ad = m_instance.get_d_ad(); //dense storage
const double * e_ad = m_instance.get_e_ad(); //dense storage
const double * w_ad = m_instance.get_w_ad(); //dense storage
const int nCols = numCoreCols();
int nRowsMax = nDates + 1 + (3*nSteps);
if(includeCount)
nRowsMax += nDates + 1;
//---
//--- for a in A, d in D:
//--- f+[a,d] - f-[a,d] =
//--- a[a,d] sum{t in T} (t/n) x1[a,t] +
//--- b[a,d] x2[a] +
//--- c[a,d] sum{t in T} (t/n) z[a,t] +
//--- d[a,d] x3[a] +
//--- e[a,d]
//--- f-[a,d] <= w[a,d] * v[a,d] (for count)
//--- for a in A:
//--- sum{t in T} x1[a,t] <= 1
//--- sum{d in D} v[a,d] <= K[a] (for count) [OPT]
//Probably not...
//THINK: can't we just post-process this? z=x1*x2
//--- for a in A, t in T:
//--- z[a,t] <= x1[a,t],
//--- z[a,t] <= x2[a],
//--- z[a,t] >= x1[a,t] + x2[a] - 1.
//---
DecompConstraintSet * model = new DecompConstraintSet();
CoinAssertHint(model, "Error: Out of Memory");
model->M = new CoinPackedMatrix(false, 0.0, 0.0);
CoinAssertHint(model->M, "Error: Out of Memory");
model->M->setDimensions(0, nCols);
model->M->reserve(nRowsMax, nCols);
model->rowLB.reserve(nRowsMax);
model->rowUB.reserve(nRowsMax);
//---
//--- for a in A, d in D:
//--- f+[a,d] - f-[a,d] =
//--- a[a,d] sum{t in T} (t/n) x1[a,t] +
//--- b[a,d] x2[a] +
//--- c[a,d] sum{t in T} (t/n) z[a,t] +
//--- d[a,d] x3[a] +
//--- e[a,d]
//--- f-[a,d] <= w[a,d] * v[a,d] (for count)
//---
nRows = 0;
pairIndex = 0;
for(vi = pairsAD.begin(); vi != pairsAD.end(); vi++){
adP = m_instance.getIndexADInv(*vi);
if(a != adP.first){
pairIndex++;
continue;
}
d = adP.second;
CoinPackedVector row;
string rowName = "demand_def(a_"
+ m_instance.getAtmName(a) + ",d_"
+ m_instance.getDateName(d) + ")";
row.insert(colIndex_fp(pairIndex), 1.0);
row.insert(colIndex_fm(pairIndex), -1.0);
coefA = -a_ad[*vi] / nSteps;
coefC = -c_ad[*vi] / nSteps;
if(m_appParam.UseTightModel){
for(t = 0; t <= nSteps; t++){
row.insert(colIndex_x1(a,t), t * coefA);
row.insert(colIndex_z (a,t), t * coefC);
}
}
else{
for(t = 0; t < nSteps; t++){
row.insert(colIndex_x1(a,t), (t+1) * coefA);
row.insert(colIndex_z (a,t), (t+1) * coefC);
}
}
row.insert(colIndex_x2(a), -b_ad[*vi]);
row.insert(colIndex_x3(a), -d_ad[*vi]);
rhs = e_ad[*vi];
model->M->appendRow(row);
model->rowLB.push_back(rhs);
model->rowUB.push_back(rhs);
model->rowNames.push_back(rowName);
nRows++;
CoinPackedVector rowLink;
string rowNameLink = "linkv(a_"
+ m_instance.getAtmName(a) + ",d_"
+ m_instance.getDateName(d) + ")";
rowLink.insert(colIndex_fm(pairIndex), 1.0);
rowLink.insert(colIndex_v (pairIndex), -w_ad[*vi]);
model->M->appendRow(rowLink);
model->rowLB.push_back(-DecompInf);
model->rowUB.push_back(0.0);
model->rowNames.push_back(rowNameLink);
nRows++;
pairIndex++;
}
//---
//--- for a in A:
//--- sum{t in T} x1[a,t] <= 1
//--- sum{d in D} v[a,d] <= K[a] (for count)
//---
nRows += createConPickOne(model, a);
if(includeCount)
nRows += createConCount(model, a);
//---
//--- for a in A, t in T:
//--- z[a,t] <= x1[a,t],
//--- z[a,t] <= x2[a],
//--- z[a,t] >= x1[a,t] + x2[a] - 1.
//---
nRows += createConZtoX(model, a);
//---
//--- create model columns
//---
createModelColumns(model, a);
UtilPrintFuncEnd(m_osLog, m_classTag,
"createModelRelax1()", m_appParam.LogLevel, 2);
return model;
}
//--------------------------------------------------------------------------
// test EKKsolution methods.
void
CglOddHoleUnitTest(
const OsiSolverInterface * baseSiP,
const std::string mpsDir )
{
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 CoinBigIndex 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;
CglTreeInfo info;
info.randomNumberGenerator=NULL;
test1.generateCuts(NULL,matrix,sol,dj,cs,which,fixed,info,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;
}
}
//===========================================================================//
DecompConstraintSet * ATM_DecompApp::createModelRelaxCount(){
UtilPrintFuncBegin(m_osLog, m_classTag,
"createModelRelaxCount()", m_appParam.LogLevel, 2);
int a, d, t, nRows, pairIndex, nRowsMax;
double rhs, coefA, coefC;
pair<int,int> adP;
vector<int>::const_iterator vi;
const int nSteps = m_appParam.NumSteps;
const int nAtms = m_instance.getNAtms();
const int nDates = m_instance.getNDates();
const int nPairs = m_instance.getNPairs();
const int nAtmsSteps = getNAtmsSteps();
const vector<int> & pairsAD = m_instance.getPairsAD();
const double * a_ad = m_instance.get_a_ad(); //dense storage
const double * b_ad = m_instance.get_b_ad(); //dense storage
const double * c_ad = m_instance.get_c_ad(); //dense storage
const double * d_ad = m_instance.get_d_ad(); //dense storage
const double * e_ad = m_instance.get_e_ad(); //dense storage
const double * w_ad = m_instance.get_w_ad(); //dense storage
const double * B_d = m_instance.get_B_d();
const int nCols = numCoreCols();
if(m_appParam.UseTightModel)
nRowsMax = nDates + 2*nAtms + nAtmsSteps + 2*nPairs;
else
nRowsMax = nDates + nAtms + 3*nAtmsSteps + 2*nPairs;
//TODO:
// try the nested idea - so master has ConZtoX and we price without that
// but we solve with gap the harder oracle with those constraints
//---
//--- A' (relax):
//--- for d in D:
//--- sum{a in A} (f+[a,d] - f-[a,d]) <= B[d] <---- makes it hard
//OPT
//--- for a in A:
//--- sum{t in T} x1[a,t] <= 1
//OPT
//--- for a in A, t in T:
//--- z[a,t] <= x1[a,t],
//--- z[a,t] <= x2[a],
//--- z[a,t] >= x1[a,t] + x2[a] - 1.
//--- for a in A, d in D:
//--- f+[a,d] - f-[a,d] =
//--- a[a,d] sum{t in T} (t/n) x1[a,t] +
//--- b[a,d] x2[a] +
//--- c[a,d] sum{t in T} (t/n) z[a,t] +
//--- d[a,d] x3[a] +
//--- e[a,d]
//--- f-[a,d] <= w[a,d] * v[a,d]
//---
DecompConstraintSet * model = new DecompConstraintSet();
CoinAssertHint(model, "Error: Out of Memory");
model->M = new CoinPackedMatrix(false, 0.0, 0.0);
CoinAssertHint(model->M, "Error: Out of Memory");
model->M->setDimensions(0, nCols);
model->reserve(nRowsMax, nCols);
//---
//--- create nDates empty rowBudget packed vectors
//---
vector<CoinPackedVector> rowBudget;
for(d = 0; d < nDates; d++){
CoinPackedVector row;
rowBudget.push_back(row);
}
nRows = 0;
pairIndex = 0;
for(vi = pairsAD.begin(); vi != pairsAD.end(); vi++){
adP = m_instance.getIndexADInv(*vi);
a = adP.first;
d = adP.second;
//---
//--- sum{a in A} (f+[a,d] - f-[a,d]) <= B[d]
//---
rowBudget[d].insert(getColOffset_fp() + pairIndex, 1.0);
rowBudget[d].insert(getColOffset_fm() + pairIndex, -1.0);
//---
//--- f+[a,d] - f-[a,d] =
//--- a[a,d] sum{t in T} (t/n) x1[a,t] +
//--- b[a,d] x2[a] +
//--- c[a,d] sum{t in T} (t/n) z[a,t] +
//--- d[a,d] x3[a] +
//--- e[a,d]
//---
CoinPackedVector row;
string rowName = "demand_def(a_"
+ m_instance.getAtmName(a) + ",d_"
+ m_instance.getDateName(d) + ")";
row.insert(colIndex_fp(pairIndex), 1.0);
row.insert(colIndex_fm(pairIndex), -1.0);
coefA = -a_ad[*vi] / nSteps;
coefC = -c_ad[*vi] / nSteps;
if(m_appParam.UseTightModel){
for(t = 0; t <= nSteps; t++){
row.insert(colIndex_x1(a,t), t * coefA);
row.insert(colIndex_z (a,t), t * coefC);
}
}
else{
for(t = 0; t < nSteps; t++){
row.insert(colIndex_x1(a,t), (t+1) * coefA);
row.insert(colIndex_z (a,t), (t+1) * coefC);
}
}
row.insert(colIndex_x2(a), -b_ad[*vi]);
row.insert(colIndex_x3(a), -d_ad[*vi]);
rhs = e_ad[*vi];
model->appendRow(row, rhs, rhs, rowName);
nRows++;
//---
//--- f-[a,d] <= w[a,d] * v[a,d]
//---
CoinPackedVector rowLink;
string rowNameLink = "linkv(a_"
+ m_instance.getAtmName(a) + ",d_"
+ m_instance.getDateName(d) + ")";
rowLink.insert(colIndex_fm(pairIndex), 1.0);
rowLink.insert(colIndex_v (pairIndex), -w_ad[*vi]);
model->appendRow(rowLink, -DecompInf, 0.0, rowNameLink);
nRows++;
pairIndex++;
}
for(d = 0; d < nDates; d++){
string rowNameBudget = "budget(d_" + m_instance.getDateName(d) + ")";
model->appendRow(rowBudget[d], -DecompInf, B_d[d], rowNameBudget);
nRows++;
}
//---
//--- for a in A:
//--- sum{t in T} x1[a,t] <= 1
//--- for a in A, t in T:
//--- z[a,t] <= x1[a,t],
//--- z[a,t] <= x2[a],
//--- z[a,t] >= x1[a,t] + x2[a] - 1.
//---
//THINK: if you use this, shouldn't we postprocess z=x1*x2?
// putting those constaints in master are unneccessary...
// in fact, why not just do that in block version too...
//for(a = 0; a < nAtms; a++){
//nRows += createConZtoX(model, a);
//nRows += createConPickOne(model, a);
//}
assert(nRows <= nRowsMax);
//---
//--- create model columns
//---
createModelColumns(model);
UtilPrintFuncEnd(m_osLog, m_classTag,
"createModelRelaxCount()", m_appParam.LogLevel, 2);
return model;
}
/** Get an inner-approximation constraint obtained by drawing a chord linking the two given points x and x2.
* This only applies to nonlinear constraints featuring univariate functions (f(x) <= y).**/
bool
HeuristicInnerApproximation::getMyInnerApproximation(Bonmin::OsiTMINLPInterface &si, OsiCuts &cs, int ind,
const double * x, const double * x2) {
int n, m, nnz_jac_g, nnz_h_lag;
Ipopt::TNLP::IndexStyleEnum index_style;
Bonmin::TMINLP2TNLP * problem = si.problem();
problem->get_nlp_info(n, m, nnz_jac_g, nnz_h_lag, index_style);
double infty = si.getInfinity();
CoinPackedVector cut;
double lb = -infty;
double ub = 0;
double g = 0;
double g2 = 0;
double diff = 0;
double a = 0;
problem->eval_gi(n, x, 1, ind, g);
problem->eval_gi(n, x2, 1, ind, g2);
Bonmin::vector<int> jCol(n);
int nnz;
problem->eval_grad_gi(n, x2, 0, ind, nnz, jCol(), NULL);
Bonmin::vector<double> jValues(nnz);
problem->eval_grad_gi(n, x2, 0, ind, nnz, NULL, jValues());
bool add = false;
//printf("const %i nnz %i\n", ind, nnz);
for (int i = 0; i < nnz; i++) {
const int &colIdx = jCol[i];
if(index_style == Ipopt::TNLP::FORTRAN_STYLE) jCol[i]--;
diff = x[colIdx] - x2[colIdx];
if (fabs(diff) >= 1e-8) {
a = (g - g2) / diff;
cut.insert(colIdx, a);
ub = (a * x[colIdx] - g) - fabs(a * x[colIdx] - g)*1e-6;
//printf("const %i col %i p[col] %g pp[col] %g g %g g2 %g diff %g\n",ind, colIdx, x[colIdx], x2[colIdx], g, g2, diff);
add = true;
} else {
cut.insert(colIdx, jValues[i]);
//printf("const %i col %i val %g\n",ind, colIdx, jValues[i]);
}
}
if (add) {
OsiRowCut newCut;
newCut.setGloballyValidAsInteger(1);
newCut.setLb(lb);
//********* Perspective Extension ********//
int binary_id = 0; // index corresponding to the binary variable activating the corresponding constraint
const int* ids = problem->get_const_xtra_id(); // vector of indices corresponding to the binary variable activating the corresponding constraint
// Get the index of the corresponding indicator binary variable
binary_id = (ids == NULL) ? -1 : ids[ind];
if(binary_id>0) {// If this hyperplane is a linearization of a disjunctive constraint, we link its righthand side to the corresponding indicator binary variable
cut.insert(binary_id, -ub); // ∂x ≤ ub => ∂x - ub*z ≤ 0
newCut.setUb(0);
}
else
newCut.setUb(ub);
//********* Perspective Extension ********//
newCut.setRow(cut);
cs.insert(newCut);
//newCut.print();
return true;
}
return false;
}
//#############################################################################
mcSol
MibSHeuristic::solveSubproblem(double beta)
{
/*
optimize wrt to weighted upper-level objective
over current feasible lp feasible region
*/
MibSModel * model = MibSModel_;
OsiSolverInterface * oSolver = model->getSolver();
//OsiSolverInterface * sSolver = new OsiCbcSolverInterface();
OsiSolverInterface* sSolver = new OsiSymSolverInterface();
//sSolver = oSolver->clone();
//OsiSolverInterface * sSolver = tmpSolver;
//OsiSolverInterface * tmpSolver = new OsiSolverInterface(oSolver);
double uObjSense(oSolver->getObjSense());
double lObjSense(model->getLowerObjSense());
int lCols(model->getLowerDim());
int uCols(model->getUpperDim());
int * lColIndices = model->getLowerColInd();
int * uColIndices = model->getUpperColInd();
double * lObjCoeffs = model->getLowerObjCoeffs();
const double * uObjCoeffs = oSolver->getObjCoefficients();
double etol(etol_);
int tCols(uCols + lCols);
assert(tCols == oSolver->getNumCols());
sSolver->loadProblem(*oSolver->getMatrixByCol(),
oSolver->getColLower(), oSolver->getColUpper(),
oSolver->getObjCoefficients(),
oSolver->getRowLower(), oSolver->getRowUpper());
int j(0);
for(j = 0; j < tCols; j++){
if(oSolver->isInteger(j))
sSolver->setInteger(j);
}
double * nObjCoeffs = new double[tCols];
int i(0), index(0);
CoinZeroN(nObjCoeffs, tCols);
/* Multiply the UL columns of the UL objective by beta */
for(i = 0; i < uCols; i++){
index = uColIndices[i];
if(fabs(uObjCoeffs[index]) > etol)
nObjCoeffs[index] = beta * uObjCoeffs[index] * uObjSense;
else
nObjCoeffs[index] = 0.0;
}
/* Multiply the LL columns of the UL objective by beta */
for(i = 0; i < lCols; i++){
index = lColIndices[i];
if(fabs(uObjCoeffs[index]) > etol)
nObjCoeffs[index] = beta* uObjCoeffs[index] * uObjSense;
else
nObjCoeffs[index] = 0.0;
}
/* Add the LL columns of the LL objective multiplied by (1 - beta) */
for(i = 0; i < lCols; i++){
index = lColIndices[i];
if(fabs(lObjCoeffs[i]) > etol)
nObjCoeffs[index] += (1 - beta) * lObjCoeffs[i] * lObjSense;
}
sSolver->setObjective(nObjCoeffs);
//int i(0);
if(0){
for(i = 0; i < sSolver->getNumCols(); i++){
std::cout << "betaobj " << sSolver->getObjCoefficients()[i] << std::endl;
}
}
if(0){
sSolver->writeLp("afterbeta");
//sSolver->writeMps("afterbeta");
}
if(0){
for(i = 0; i < sSolver->getNumCols(); i++){
std::cout << "obj " << sSolver->getObjCoefficients()[i] << std::endl;
std::cout << "upper " << sSolver->getColUpper()[i] << std::endl;
std::cout << "lower " << sSolver->getColLower()[i] << std::endl;
}
}
if(0){
dynamic_cast<OsiCbcSolverInterface *>
(sSolver)->getModelPtr()->messageHandler()->setLogLevel(0);
}
else{
dynamic_cast<OsiSymSolverInterface *>
(sSolver)->setSymParam("prep_level", -1);
dynamic_cast<OsiSymSolverInterface *>
(sSolver)->setSymParam("verbosity", -2);
dynamic_cast<OsiSymSolverInterface *>
(sSolver)->setSymParam("max_active_nodes", 1);
}
//dynamic_cast<OsiSymSolverInterface *> (sSolver)->branchAndBound();
sSolver->branchAndBound();
if(sSolver->isProvenOptimal()){
if(0){
std::cout << "writing lp file." << std::endl;
sSolver->writeLp("afterbeta");
//sSolver->writeMps("afterbeta");
}
double upperObjVal(0.0);
double lowerObjVal(0.0);
for(i = 0; i < tCols; i++){
upperObjVal +=
sSolver->getColSolution()[i] * oSolver->getObjCoefficients()[i];
if(0){
std::cout << "sSolver->getColSolution()[" << i << "] :"
<< sSolver->getColSolution()[i] << std::endl;
}
}
lowerObjVal = getLowerObj(sSolver->getColSolution(), lObjSense);
if(beta == 1.0){
/*
fix upper-level objective to current value and
reoptimize wrt to lower-level objective
*/
//OsiSolverInterface * nSolver = new OsiCbcSolverInterface();
OsiSolverInterface * nSolver = new OsiSymSolverInterface();
nSolver->loadProblem(*oSolver->getMatrixByCol(),
oSolver->getColLower(), oSolver->getColUpper(),
oSolver->getObjCoefficients(),
oSolver->getRowLower(), oSolver->getRowUpper());
for(j = 0; j < tCols; j++){
if(oSolver->isInteger(j))
nSolver->setInteger(j);
}
CoinZeroN(nObjCoeffs, tCols);
for(i = 0; i < lCols; i++){
index = lColIndices[i];
nObjCoeffs[index] = lObjCoeffs[i] * lObjSense;
}
nSolver->setObjective(nObjCoeffs);
CoinPackedVector objCon;
for(i = 0; i < tCols; i++){
objCon.insert(i, uObjCoeffs[i] * uObjSense);
}
nSolver->addRow(objCon, upperObjVal, upperObjVal);
nSolver->writeLp("beta1");
if(0){
dynamic_cast<OsiCbcSolverInterface *>
(nSolver)->getModelPtr()->messageHandler()->setLogLevel(0);
}
else{
dynamic_cast<OsiSymSolverInterface *>
(nSolver)->setSymParam("prep_level", -1);
dynamic_cast<OsiSymSolverInterface *>
(nSolver)->setSymParam("verbosity", -2);
dynamic_cast<OsiSymSolverInterface *>
(nSolver)->setSymParam("max_active_nodes", 1);
}
nSolver->branchAndBound();
double * colsol = new double[tCols];
if(nSolver->isProvenOptimal()){
lowerObjVal = nSolver->getObjValue();
CoinCopyN(nSolver->getColSolution(), tCols, colsol);
}
else{
//just take the current solution
lowerObjVal = sSolver->getObjValue();
CoinCopyN(sSolver->getColSolution(), tCols, colsol);
}
delete[] nObjCoeffs;
nObjCoeffs = 0;
delete sSolver;
delete nSolver;
return mcSol(std::make_pair(upperObjVal, lowerObjVal), colsol);
}
else if(beta == 0.0){
/*
fix lower-level objective to current value and
reoptimize wrt to upper-level objective
*/
//OsiSolverInterface * nSolver = new OsiCbcSolverInterface();
OsiSolverInterface * nSolver = new OsiSymSolverInterface();
nSolver->loadProblem(*oSolver->getMatrixByCol(),
oSolver->getColLower(), oSolver->getColUpper(),
oSolver->getObjCoefficients(),
oSolver->getRowLower(), oSolver->getRowUpper());
for(j = 0; j < tCols; j++){
if(oSolver->isInteger(j))
nSolver->setInteger(j);
}
CoinZeroN(nObjCoeffs, tCols);
for(i = 0; i < tCols; i++)
nObjCoeffs[i] = uObjCoeffs[i] * uObjSense;
nSolver->setObjective(nObjCoeffs);
CoinPackedVector objCon;
for(i = 0; i < lCols; i++){
index = lColIndices[i];
objCon.insert(index, lObjCoeffs[i] * lObjSense);
}
nSolver->addRow(objCon, lowerObjVal, lowerObjVal);
if(0){
dynamic_cast<OsiCbcSolverInterface *>
(nSolver)->getModelPtr()->messageHandler()->setLogLevel(0);
}
else{
dynamic_cast<OsiSymSolverInterface *>
(nSolver)->setSymParam("prep_level", -1);
dynamic_cast<OsiSymSolverInterface *>
(nSolver)->setSymParam("verbosity", -2);
dynamic_cast<OsiSymSolverInterface *>
(nSolver)->setSymParam("max_active_nodes", 1);
}
if(0)
nSolver->writeLp("nSolver");
nSolver->branchAndBound();
double * colsol = new double[tCols];
if(nSolver->isProvenOptimal()){
upperObjVal = nSolver->getObjValue();
CoinCopyN(nSolver->getColSolution(), tCols, colsol);
}
else{
upperObjVal = nSolver->getObjValue();
CoinCopyN(nSolver->getColSolution(), tCols, colsol);
}
delete[] nObjCoeffs;
nObjCoeffs = 0;
delete sSolver;
delete nSolver;
return mcSol(std::make_pair(upperObjVal, lowerObjVal), colsol);
}
else{
//no optimality cut needed here. all solutions are supported.
double * colsol = new double[tCols];
CoinCopyN(sSolver->getColSolution(), tCols, colsol);
delete[] nObjCoeffs;
nObjCoeffs = 0;
delete sSolver;
return mcSol(std::make_pair(upperObjVal, lowerObjVal), colsol);
}
}
else{
//FIXME:SHOULD JUST TAKE THIS OUT. DELETE sSolver and remove it from above
nObjCoeffs = 0;
delete[] nObjCoeffs;
delete sSolver;
std::cout << "Subproblem is not proven optimal." << std::endl;
//return NULL;
//abort();
}
}
void
CglLandPUnitTest(
OsiSolverInterface * si,
const std::string &mpsDir)
{
CoinRelFltEq eq(1e-05);
// Test default constructor
{
CglLandP aGenerator;
assert(aGenerator.parameter().pivotLimit==20);
assert(aGenerator.parameter().maxCutPerRound==5000);
assert(aGenerator.parameter().failedPivotLimit==1);
assert(aGenerator.parameter().degeneratePivotLimit==0);
assert(eq(aGenerator.parameter().pivotTol, 1e-04));
assert(eq(aGenerator.parameter().away, 5e-04));
assert(eq(aGenerator.parameter().timeLimit, COIN_DBL_MAX));
assert(eq(aGenerator.parameter().singleCutTimeLimit, COIN_DBL_MAX));
assert(aGenerator.parameter().useTableauRow==true);
assert(aGenerator.parameter().modularize==false);
assert(aGenerator.parameter().strengthen==true);
assert(aGenerator.parameter().perturb==true);
assert(aGenerator.parameter().pivotSelection==CglLandP::mostNegativeRc);
}
// Test copy constructor
{
CglLandP a;
{
CglLandP b;
b.parameter().pivotLimit = 100;
b.parameter().maxCutPerRound = 100;
b.parameter().failedPivotLimit = 10;
b.parameter().degeneratePivotLimit = 10;
b.parameter().pivotTol = 1e-07;
b.parameter().away = 1e-10;
b.parameter().timeLimit = 120;
b.parameter().singleCutTimeLimit = 15;
b.parameter().useTableauRow = true;
b.parameter().modularize = true;
b.parameter().strengthen = false;
b.parameter().perturb = false;
b.parameter().pivotSelection=CglLandP::bestPivot;
//Test Copy
CglLandP c(b);
assert(c.parameter().pivotLimit == 100);
assert(c.parameter().maxCutPerRound == 100);
assert(c.parameter().failedPivotLimit == 10);
assert(c.parameter().degeneratePivotLimit == 10);
assert(c.parameter().pivotTol == 1e-07);
assert(c.parameter().away == 1e-10);
assert(c.parameter().timeLimit == 120);
assert(c.parameter().singleCutTimeLimit == 15);
assert(c.parameter().useTableauRow == true);
assert(c.parameter().modularize == true);
assert(c.parameter().strengthen == false);
assert(c.parameter().perturb == false);
assert(c.parameter().pivotSelection == CglLandP::bestPivot);
a=b;
assert(a.parameter().pivotLimit == 100);
assert(a.parameter().maxCutPerRound == 100);
assert(a.parameter().failedPivotLimit == 10);
assert(a.parameter().degeneratePivotLimit == 10);
assert(a.parameter().pivotTol == 1e-07);
assert(a.parameter().away == 1e-10);
assert(a.parameter().timeLimit == 120);
assert(a.parameter().singleCutTimeLimit == 15);
assert(a.parameter().useTableauRow == true);
assert(a.parameter().modularize == true);
assert(a.parameter().strengthen == false);
assert(a.parameter().perturb == false);
assert(a.parameter().pivotSelection == CglLandP::bestPivot);
}
}
{
// Maximize 2 x2
// s.t.
// 2x1 + 2x2 <= 3
// -2x1 + 2x2 <= 1
// 7x1 + 4x2 <= 8
// -7x1 + 4x2 <= 1
// x1, x2 >= 0 and x1, x2 integer
// Slacks are s1, s2, s3, s4
//Test that problem is correct
// Optimal Basis is x1, x2, s3, s4 with tableau
// x1 0.25 s1 -0.25 s2 = 0.5
// x2 0.25 s1 0.25 s2 = 1
// -2.75 s1 0.75 s2 s3 = 0.5
// 0.75 s1 -2.75 s2 s4 = 0.5
// z= -0.25 s1 -0.25 s2 = -1
// Gomory cut from variable x1 is x2 <= 0.5
// Can be improved by first pivoting s2 in and s4 out, then s1 in and s3 out
// to x2 <= 0.25
{
int start[2] = {0,4};
int length[2] = {4,4};
int rows[8] = {0,1,2,3,0,1,2,3};
double elements[8] = {2.0,-2.0,7.0,-7.0,2.0,2.0,4.0,4.0};
CoinPackedMatrix columnCopy(true,4,2,8,elements,rows,start,length);
double rowLower[4]={-COIN_DBL_MAX,-COIN_DBL_MAX,
-COIN_DBL_MAX,-COIN_DBL_MAX};
double rowUpper[4]={3.,1.,8.,1.};
double colLower[2]={0.0,0.0};
double colUpper[2]={1.0,1.0};
double obj[2]={-1,-1};
int intVar[2]={0,1};
OsiSolverInterface * siP = si->clone();
siP->loadProblem(columnCopy, colLower, colUpper, obj, rowLower, rowUpper);
siP->setInteger(intVar,2);
CglLandP test;
test.setLogLevel(2);
test.parameter().sepSpace = CglLandP::Full;
siP->resolve();
// Test generateCuts method
{
OsiCuts cuts;
test.generateCuts(*siP,cuts);
cuts.printCuts();
assert(cuts.sizeRowCuts()==1);
OsiRowCut aCut = cuts.rowCut(0);
assert(eq(aCut.lb(), -.0714286));
CoinPackedVector row = aCut.row();
if (row.getNumElements() == 1)
{
assert(row.getIndices()[0]==1);
assert(eq(row.getElements()[0], -4*.0714286));
}
else if (row.getNumElements() == 2)
{
assert(row.getIndices()[0]==0);
assert(eq(row.getElements()[0], 0.));
assert(row.getIndices()[1]==1);
assert(eq(row.getElements()[1], -1));
}
OsiSolverInterface::ApplyCutsReturnCode rc = siP->applyCuts(cuts);
siP->resolve();
}
if (0)
{
OsiCuts cuts;
test.generateCuts(*siP,cuts);
cuts.printCuts();
assert(cuts.sizeRowCuts()==1);
OsiRowCut aCut = cuts.rowCut(0);
CoinPackedVector row = aCut.row();
if (row.getNumElements() == 1)
{
assert(row.getIndices()[0]==1);
assert(eq(row.getElements()[0], -1));
}
else if (row.getNumElements() == 2)
{
assert(row.getIndices()[0]==0);
assert(eq(row.getElements()[0], 0.));
assert(row.getIndices()[1]==1);
assert(eq(row.getElements()[1], -1));
}
assert(eq(aCut.lb(), 0.));
OsiSolverInterface::ApplyCutsReturnCode rc = siP->applyCuts(cuts);
siP->resolve();
}
delete siP;
}
}
if (1) //Test on p0033
{
// Setup
OsiSolverInterface * siP = si->clone();
std::string fn(mpsDir+"p0033");
siP->readMps(fn.c_str(),"mps");
siP->activateRowCutDebugger("p0033");
CglLandP test;
// Solve the LP relaxation of the model and
// print out ofv for sake of comparison
siP->initialSolve();
double lpRelaxBefore=siP->getObjValue();
assert( eq(lpRelaxBefore, 2520.5717391304347) );
#ifdef CGL_DEBUG
printf("\n\nOrig LP min=%f\n",lpRelaxBefore);
#endif
OsiCuts cuts;
// Test generateCuts method
test.generateCuts(*siP,cuts);
OsiSolverInterface::ApplyCutsReturnCode rc = siP->applyCuts(cuts);
siP->resolve();
double lpRelaxAfter=siP->getObjValue();
//assert( eq(lpRelaxAfter, 2592.1908295194507) );
std::cout<<"Relaxation after "<<lpRelaxAfter<<std::endl;
assert( lpRelaxAfter> 2840. );
#ifdef CGL_DEBUG
printf("\n\nOrig LP min=%f\n",lpRelaxBefore);
printf("\n\nFinal LP min=%f\n",lpRelaxAfter);
#endif
assert( lpRelaxBefore < lpRelaxAfter );
delete siP;
}
if (1) //test again with modularization
{
// Setup
OsiSolverInterface * siP = si->clone();
std::string fn(mpsDir+"p0033");
siP->readMps(fn.c_str(),"mps");
siP->activateRowCutDebugger("p0033");
CglLandP test;
test.parameter().modularize = true;
// Solve the LP relaxation of the model and
// print out ofv for sake of comparison
siP->initialSolve();
double lpRelaxBefore=siP->getObjValue();
assert( eq(lpRelaxBefore, 2520.5717391304347) );
#ifdef CGL_DEBUG
printf("\n\nOrig LP min=%f\n",lpRelaxBefore);
#endif
OsiCuts cuts;
// Test generateCuts method
test.generateCuts(*siP,cuts);
OsiSolverInterface::ApplyCutsReturnCode rc = siP->applyCuts(cuts);
siP->resolve();
double lpRelaxAfter=siP->getObjValue();
//assert( eq(lpRelaxAfter, 2592.1908295194507) );
std::cout<<"Relaxation after "<<lpRelaxAfter<<std::endl;
assert( lpRelaxAfter> 2840. );
#ifdef CGL_DEBUG
printf("\n\nOrig LP min=%f\n",lpRelaxBefore);
printf("\n\nFinal LP min=%f\n",lpRelaxAfter);
#endif
assert( lpRelaxBefore < lpRelaxAfter );
delete siP;
}
if (1) //test again with alternate pivoting rule
{
// Setup
OsiSolverInterface * siP = si->clone();
std::string fn(mpsDir+"p0033");
siP->readMps(fn.c_str(),"mps");
siP->activateRowCutDebugger("p0033");
CglLandP test;
test.parameter().pivotSelection = CglLandP::bestPivot;
// Solve the LP relaxation of the model and
// print out ofv for sake of comparison
siP->initialSolve();
double lpRelaxBefore=siP->getObjValue();
assert( eq(lpRelaxBefore, 2520.5717391304347) );
#ifdef CGL_DEBUG
printf("\n\nOrig LP min=%f\n",lpRelaxBefore);
#endif
OsiCuts cuts;
// Test generateCuts method
test.generateCuts(*siP,cuts);
OsiSolverInterface::ApplyCutsReturnCode rc = siP->applyCuts(cuts);
siP->resolve();
double lpRelaxAfter=siP->getObjValue();
//assert( eq(lpRelaxAfter, 2592.1908295194507) );
std::cout<<"Relaxation after "<<lpRelaxAfter<<std::endl;
assert( lpRelaxAfter> 2840. );
#ifdef CGL_DEBUG
printf("\n\nOrig LP min=%f\n",lpRelaxBefore);
printf("\n\nFinal LP min=%f\n",lpRelaxAfter);
#endif
assert( lpRelaxBefore < lpRelaxAfter );
delete siP;
}
if (1) //Finally test code in documentation
{
// Setup
OsiSolverInterface * siP = si->clone();
std::string fn(mpsDir+"p0033");
siP->readMps(fn.c_str(),"mps");
siP->activateRowCutDebugger("p0033");
CglLandP landpGen;
landpGen.parameter().timeLimit = 10.;
landpGen.parameter().pivotLimit = 2;
// Solve the LP relaxation of the model and
// print out ofv for sake of comparison
siP->initialSolve();
double lpRelaxBefore=siP->getObjValue();
assert( eq(lpRelaxBefore, 2520.5717391304347) );
#ifdef CGL_DEBUG
printf("\n\nOrig LP min=%f\n",lpRelaxBefore);
#endif
OsiCuts cuts;
// Test generateCuts method
landpGen.generateCuts(*siP, cuts);
OsiSolverInterface::ApplyCutsReturnCode rc = siP->applyCuts(cuts);
siP->resolve();
double lpRelaxAfter=siP->getObjValue();
//assert( eq(lpRelaxAfter, 2592.1908295194507) );
std::cout<<"Relaxation after "<<lpRelaxAfter<<std::endl;
assert( lpRelaxAfter> 2840. );
#ifdef CGL_DEBUG
printf("\n\nOrig LP min=%f\n",lpRelaxBefore);
printf("\n\nFinal LP min=%f\n",lpRelaxAfter);
#endif
assert( lpRelaxBefore < lpRelaxAfter );
delete siP;
}
}