//#############################################################################
void
MibSHeuristic::lowerObjHeuristic()
{
/*
optimize wrt to lower-level objective
over current feasible lp feasible region
*/
MibSModel * model = MibSModel_;
OsiSolverInterface * oSolver = model->getSolver();
//OsiSolverInterface * hSolver = new OsiCbcSolverInterface();
OsiSolverInterface* hSolver = new OsiSymSolverInterface();
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");
if(0){
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);
}
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");
}
if(0){
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);
}
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();
//OsiSolverInterface * hSolver = new OsiCbcSolverInterface();
OsiSolverInterface * hSolver = new OsiSymSolverInterface();
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 */
if(0){
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);
}
hSolver->branchAndBound();
if(0)
hSolver->writeLp("objcutheuristic");
if(hSolver->isProvenOptimal()){
MibSSolution *mibSol = NULL;
OsiSolverInterface * lSolver = model->bS_->setUpModel(hSolver, true);
if(0){
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);
}
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
MibSHeuristic::greedyHeuristic()
{
MibSModel * model = MibSModel_;
//OsiSolverInterface * oSolver = model->getSolver();
OsiSolverInterface * oSolver = model->solver();
double uObjSense(oSolver->getObjSense());
double lObjSense(model->getLowerObjSense());
int lCols(model->getLowerDim());
int uCols(model->getUpperDim());
int * uColIndices = model->getUpperColInd();
int * lColIndices = model->getLowerColInd();
double * lObjCoeffs = model->getLowerObjCoeffs();
double * intCost = model->getInterdictCost();
double intBudget = model->getInterdictBudget();
int tCols(uCols + lCols);
assert(tCols == oSolver->getNumCols());
int i(0), ind_min_wt(0);
double usedBudget(0.0);
double * fixedVars = new double[lCols];
double * testsol = new double[tCols];
CoinZeroN(fixedVars, lCols);
CoinZeroN(testsol, tCols);
std::multimap<double, int> lObjCoeffsOrd;
for(i = 0; i < lCols; i++)
lObjCoeffsOrd.insert(std::pair<double, int>(lObjCoeffs[i] * lObjSense, i));
if(!bestSol_)
bestSol_ = new double[tCols];
//initialize the best solution information
//bestObjVal_ = model->getSolver()->getInfinity() * uObjSense;
//CoinZeroN(bestSol_, tCols);
std::multimap<double, int>::iterator iter;
//std::multimap<double, int>::iterator first;
//std::multimap<double, int>::iterator last;
//int dist = std::distance(first, last);
srandom((unsigned) time(NULL));
int randchoice(0);
if(0)
std::cout << "randchoice " << randchoice << std::endl;
double cost(0.0);
//starting from the largest, fix corr upper-level variables
//then, with these fixed, solve the lower-level problem
//this yields a feasible solution
iter = lObjCoeffsOrd.begin();
while((usedBudget < intBudget) && (iter != lObjCoeffsOrd.end())){
ind_min_wt = iter->second;
cost = intCost[ind_min_wt];
testsol[uColIndices[ind_min_wt]] = 1.0;
double min_wt = iter->first;
if(0){
std::cout << "upper: " << ind_min_wt << " "
<< uColIndices[ind_min_wt] << " "
<< oSolver->getColUpper()[uColIndices[ind_min_wt]] << " "
<< oSolver->getColLower()[uColIndices[ind_min_wt]] << std::endl;
std::cout << "lower: " << ind_min_wt << " "
<< lColIndices[ind_min_wt] << " "
<< oSolver->getColUpper()[lColIndices[ind_min_wt]] << std::endl;
}
//if((oSolver->getColUpper()[uColIndices[ind_min_wt]] == 1.0)
//&& (oSolver->getColUpper()[lColIndices[ind_min_wt]] > 0)){
if(oSolver->getColUpper()[uColIndices[ind_min_wt]] > etol_){
//if(((usedBudget + cost) <= intBudget)
// && checkLowerFeasibility(oSolver, testsol)){
if((usedBudget + cost) <= intBudget){
//FIXME: SHOULD BE CHECKING FOR CURRENT BOUNDS HERE
//fix the corresponding upper-level variable to 1
randchoice = random() % 2;
if(0)
std::cout << "randchoice " << random << std::endl;
if(randchoice){
fixedVars[ind_min_wt] = 1.0;
usedBudget += intCost[ind_min_wt];
}
}
}
else{
testsol[uColIndices[ind_min_wt]] = 0;
//break;
}
iter++;
}
/*
now we find a feasible solution by fixing upper-level vars
and solving the lower-level problem
*/
double * incumbentSol = new double[tCols];
double * colsol = new double[tCols];
CoinZeroN(colsol, tCols);
for(i = 0; i < uCols; i++){
colsol[uColIndices[i]] = fixedVars[i];
if(fixedVars[i] == 1.0)
if(0)
std::cout << "fixed " << i << std::endl;
}
bfSol * sol = getBilevelSolution(colsol, lObjSense * oSolver->getInfinity());
if(sol){
double incumbentObjVal = sol->getObjVal();
CoinCopyN(sol->getColumnSol(), tCols, incumbentSol);
MibSSolution * mibSol = new MibSSolution(tCols,
incumbentSol,
incumbentObjVal,
model);
model->storeSolution(BlisSolutionTypeHeuristic, mibSol);
}
//bestObjVal_ = incumbentObjVal;
//CoinCopyN(incumbentSol, tCols, bestSol_);
delete [] incumbentSol;
delete [] testsol;
//delete [] colsol;
//delete [] fixedVars;
//delete sol;
}
//-----------------------------------------------------------------------------
// Generate Lift-and-Project cuts
//-------------------------------------------------------------------
void CglLiftAndProject::generateCuts(const OsiSolverInterface& si, OsiCuts& cs,
const CglTreeInfo /*info*/)
{
// Assumes the mixed 0-1 problem
//
// min {cx: <Atilde,x> >= btilde}
//
// is in canonical form with all bounds,
// including x_t>=0, -x_t>=-1 for x_t binary,
// explicitly stated in the constraint matrix.
// See ~/COIN/Examples/Cgl2/cgl2.cpp
// for a general purpose "convert" function.
// Reference [BCC]: Balas, Ceria, and Corneujols,
// "A lift-and-project cutting plane algorithm
// for mixed 0-1 program", Math Prog 58, (1993)
// 295-324.
// This implementation uses Normalization 1.
// Given canonical problem and
// the lp-relaxation solution, x,
// the LAP cut generator attempts to construct
// a cut for every x_j such that 0<x_j<1
// [BCC:307]
// x_j is the strictly fractional binary variable
// the cut is generated from
int j = 0;
// Get basic problem information
// let Atilde be an m by n matrix
const int m = si.getNumRows();
const int n = si.getNumCols();
const double * x = si.getColSolution();
// Remember - Atildes may have gaps..
const CoinPackedMatrix * Atilde = si.getMatrixByRow();
const double * AtildeElements = Atilde->getElements();
const int * AtildeIndices = Atilde->getIndices();
const CoinBigIndex * AtildeStarts = Atilde->getVectorStarts();
const int * AtildeLengths = Atilde->getVectorLengths();
const int AtildeFullSize = AtildeStarts[m];
const double * btilde = si.getRowLower();
// Set up memory for system (10) [BCC:307]
// (the problem over the norm intersected
// with the polar cone)
//
// min <<x^T,Atilde^T>,u> + x_ju_0
// s.t.
// <B,w> = (0,...,0,beta_,beta)^T
// w is nonneg for all but the
// last two entries, which are free.
// where
// w = (u,v,v_0,u_0)in BCC notation
// u and v are m-vectors; u,v >=0
// v_0 and u_0 are free-scalars, and
//
// B = Atilde^T -Atilde^T -e_j e_j
// btilde^T e_0^T 0 0
// e_0^T btilde^T 1 0
// ^T indicates Transpose
// e_0 is a (AtildeNCols x 1) vector of all zeros
// e_j is e_0 with a 1 in the jth position
// Storing B in column order. B is a (n+2 x 2m+2) matrix
// But need to allow for possible gaps in Atilde.
// At each iteration, only need to change 2 cols and objfunc
// Sane design of OsiSolverInterface does not permit mucking
// with matrix.
// Because we must delete and add cols to alter matrix,
// and we can only add columns on the end of the matrix
// put the v_0 and u_0 columns on the end.
// rather than as described in [BCC]
// Initially allocating B with space for v_0 and u_O cols
// but not populating, for efficiency.
// B without u_0 and v_0 is a (n+2 x 2m) size matrix.
int twoM = 2*m;
int BNumRows = n+2;
int BNumCols = twoM+2;
int BFullSize = 2*AtildeFullSize+twoM+3;
double * BElements = new double[BFullSize];
int * BIndices = new int[BFullSize];
CoinBigIndex * BStarts = new CoinBigIndex [BNumCols+1];
int * BLengths = new int[BNumCols];
int i, ij, k=0;
int nPlus1=n+1;
int offset = AtildeStarts[m]+m;
for (i=0; i<m; i++){
for (ij=AtildeStarts[i];ij<AtildeStarts[i]+AtildeLengths[i];ij++){
BElements[k]=AtildeElements[ij];
BElements[k+offset]=-AtildeElements[ij];
BIndices[k]= AtildeIndices[ij];
BIndices[k+offset]= AtildeIndices[ij];
k++;
}
BElements[k]=btilde[i];
BElements[k+offset]=btilde[i];
BIndices[k]=n;
BIndices[k+offset]=nPlus1;
BStarts[i]= AtildeStarts[i]+i;
BStarts[i+m]=offset+BStarts[i];// = AtildeStarts[m]+m+AtildeStarts[i]+i
BLengths[i]= AtildeLengths[i]+1;
BLengths[i+m]= AtildeLengths[i]+1;
k++;
}
BStarts[twoM]=BStarts[twoM-1]+BLengths[twoM-1];
// Cols that will be deleted each iteration
int BNumColsLessOne=BNumCols-1;
int BNumColsLessTwo=BNumCols-2;
const int delCols[2] = {BNumColsLessOne, BNumColsLessTwo};
// Set lower bound on u and v
// u_0, v_0 will be reset as free
const double solverINFINITY = si.getInfinity();
double * BColLowers = new double[BNumCols];
double * BColUppers = new double[BNumCols];
CoinFillN(BColLowers,BNumCols,0.0);
CoinFillN(BColUppers,BNumCols,solverINFINITY);
// Set row lowers and uppers.
// The rhs is zero, for but the last two rows.
// For these the rhs is beta_
double * BRowLowers = new double[BNumRows];
double * BRowUppers = new double[BNumRows];
CoinFillN(BRowLowers,BNumRows,0.0);
CoinFillN(BRowUppers,BNumRows,0.0);
BRowLowers[BNumRows-2]=beta_;
BRowUppers[BNumRows-2]=beta_;
BRowLowers[BNumRows-1]=beta_;
BRowUppers[BNumRows-1]=beta_;
// Calculate base objective <<x^T,Atilde^T>,u>
// Note: at each iteration coefficient u_0
// changes to <x^T,e_j>
// w=(u,v,beta,v_0,u_0) size 2m+3
// So, BOjective[2m+2]=x[j]
double * BObjective= new double[BNumCols];
double * Atildex = new double[m];
CoinFillN(BObjective,BNumCols,0.0);
Atilde->times(x,Atildex); // Atildex is size m, x is size n
CoinDisjointCopyN(Atildex,m,BObjective);
// Number of cols and size of Elements vector
// in B without the v_0 and u_0 cols
int BFullSizeLessThree = BFullSize-3;
// Load B matrix into a column orders CoinPackedMatrix
CoinPackedMatrix * BMatrix = new CoinPackedMatrix(true, BNumRows,
BNumColsLessTwo,
BFullSizeLessThree,
BElements,BIndices,
BStarts,BLengths);
// Assign problem into a solver interface
// Note: coneSi will cleanup the memory itself
OsiSolverInterface * coneSi = si.clone(false);
coneSi->assignProblem (BMatrix, BColLowers, BColUppers,
BObjective,
BRowLowers, BRowUppers);
// Problem sense should default to "min" by default,
// but just to be virtuous...
coneSi->setObjSense(1.0);
// The plot outline from here on down:
// coneSi has been assigned B without the u_0 and v_0 columns
// Calculate base objective <<x^T,Atilde^T>,u>
// bool haveWarmStart = false;
// For (j=0; j<n, j++)
// if (!isBinary(x_j) || x_j<=0 || x_j>=1) continue;
// // IMPROVEME: if(haveWarmStart) check if j attractive
// add {-e_j,0,-1} matrix column for v_0
// add {e_j,0,0} matrix column for u_0
// objective coefficient for u_0 is x_j
// if (haveWarmStart)
// set warmstart info
// solve min{objw:Bw=0; w>=0,except v_0, u_0 free}
// if (bounded)
// get warmstart info
// haveWarmStart=true;
// ustar = optimal u solution
// ustar_0 = optimal u_0 solution
// alpha^T= <ustar^T,Atilde> -ustar_0e_j^T
// (double check <alpha^T,x> >= beta_ should be violated)
// add <alpha^T,x> >= beta_ to cutset
// endif
// delete column for u_0 // this deletes all column info.
// delete column for v_0
// endFor
// clean up memory
// return 0;
int * nVectorIndices = new int[n];
CoinIotaN(nVectorIndices, n, 0);
bool haveWarmStart = false;
bool equalObj1, equalObj2;
CoinRelFltEq eq;
double v_0Elements[2] = {-1,1};
double u_0Elements[1] = {1};
CoinWarmStart * warmStart = 0;
double * ustar = new double[m];
CoinFillN(ustar, m, 0.0);
double* alpha = new double[n];
CoinFillN(alpha, n, 0.0);
for (j=0;j<n;j++){
if (!si.isBinary(j)) continue; // Better to ask coneSi? No!
// coneSi has no binInfo.
equalObj1=eq(x[j],0);
equalObj2=eq(x[j],1);
if (equalObj1 || equalObj2) continue;
// IMPROVEME: if (haveWarmStart) check if j attractive;
// AskLL:wanted to declare u_0 and v_0 packedVec outside loop
// and setIndices, but didn't see a method to do that(?)
// (Could "insert". Seems inefficient)
int v_0Indices[2]={j,nPlus1};
int u_0Indices[1]={j};
//
CoinPackedVector v_0(2,v_0Indices,v_0Elements,false);
CoinPackedVector u_0(1,u_0Indices,u_0Elements,false);
#if CGL_DEBUG
const CoinPackedMatrix *see1 = coneSi->getMatrixByRow();
#endif
coneSi->addCol(v_0,-solverINFINITY,solverINFINITY,0);
coneSi->addCol(u_0,-solverINFINITY,solverINFINITY,x[j]);
if(haveWarmStart) {
coneSi->setWarmStart(warmStart);
coneSi->resolve();
}
else {
#if CGL_DEBUG
const CoinPackedMatrix *see2 = coneSi->getMatrixByRow();
#endif
coneSi->initialSolve();
}
if(coneSi->isProvenOptimal()){
warmStart = coneSi->getWarmStart();
haveWarmStart=true;
const double * wstar = coneSi->getColSolution();
CoinDisjointCopyN(wstar, m, ustar);
Atilde->transposeTimes(ustar,alpha);
alpha[j]+=wstar[BNumCols-1];
#if debug
int p;
double sum;
for(p=0;p<n;p++)sum+=alpha[p]*x[p];
if (sum<=beta_){
throw CoinError("Cut not violated",
"cutGeneration",
"CglLiftAndProject");
}
#endif
// add <alpha^T,x> >= beta_ to cutset
OsiRowCut rc;
rc.setRow(n,nVectorIndices,alpha);
rc.setLb(beta_);
rc.setUb(solverINFINITY);
cs.insert(rc);
}
// delete col for u_o and v_0
coneSi->deleteCols(2,delCols);
// clean up memory
}
// clean up
delete [] alpha;
delete [] ustar;
delete [] nVectorIndices;
// BMatrix, BColLowers,BColUppers, BObjective, BRowLowers, BRowUppers
// are all freed by OsiSolverInterface destructor (?)
delete [] BLengths;
delete [] BStarts;
delete [] BIndices;
delete [] BElements;
}
void
HeuristicInnerApproximation::extractInnerApproximation(Bonmin::OsiTMINLPInterface & nlp, OsiSolverInterface &si,
const double * x, bool getObj) {
printf("************ Start extracting inner approx");
int n;
int m;
int nnz_jac_g;
int nnz_h_lag;
Ipopt::TNLP::IndexStyleEnum index_style;
Bonmin::TMINLP2TNLP * problem = nlp.problem();
//Get problem information
problem->get_nlp_info(n, m, nnz_jac_g, nnz_h_lag, index_style);
Bonmin::vector<int> jRow(nnz_jac_g);
Bonmin::vector<int> jCol(nnz_jac_g);
Bonmin::vector<double> jValues(nnz_jac_g);
problem->eval_jac_g(n, NULL, 0, m, nnz_jac_g, jRow(), jCol(), NULL);
if(index_style == Ipopt::TNLP::FORTRAN_STYLE)//put C-style
{
for(int i = 0 ; i < nnz_jac_g ; i++){
jRow[i]--;
jCol[i]--;
}
}
//get Jacobian
problem->eval_jac_g(n, x, 1, m, nnz_jac_g, NULL, NULL,
jValues());
Bonmin::vector<double> g(m);
problem->eval_g(n, x, 1, m, g());
Bonmin::vector<int> nonLinear(m);
//store non linear constraints (which are to be removed from IA)
int numNonLinear = 0;
const double * rowLower = nlp.getRowLower();
const double * rowUpper = nlp.getRowUpper();
const double * colLower = nlp.getColLower();
const double * colUpper = nlp.getColUpper();
assert(m == nlp.getNumRows());
double infty = si.getInfinity();
double nlp_infty = nlp.getInfinity();
Bonmin::vector<Ipopt::TNLP::LinearityType> constTypes(m);
Bonmin::vector<Ipopt::TNLP::LinearityType> varTypes(n);
problem->get_constraints_linearity(m, constTypes());
problem->get_variables_linearity(n, varTypes());
for (int i = 0; i < m; i++) {
if (constTypes[i] == Ipopt::TNLP::NON_LINEAR) {
nonLinear[numNonLinear++] = i;
}
}
Bonmin::vector<double> rowLow(m - numNonLinear);
Bonmin::vector<double> rowUp(m - numNonLinear);
int ind = 0;
for (int i = 0; i < m; i++) {
if (constTypes[i] != Ipopt::TNLP::NON_LINEAR) {
if (rowLower[i] > -nlp_infty) {
// printf("Lower %g ", rowLower[i]);
rowLow[ind] = (rowLower[i]);
} else
rowLow[ind] = -infty;
if (rowUpper[i] < nlp_infty) {
// printf("Upper %g ", rowUpper[i]);
rowUp[ind] = (rowUpper[i]);
} else
rowUp[ind] = infty;
ind++;
}
}
CoinPackedMatrix mat(true, jRow(), jCol(), jValues(), nnz_jac_g);
mat.setDimensions(m, n); // In case matrix was empty, this should be enough
//remove non-linear constraints
mat.deleteRows(numNonLinear, nonLinear());
int numcols = nlp.getNumCols();
Bonmin::vector<double> obj(numcols);
for (int i = 0; i < numcols; i++)
obj[i] = 0.;
si.loadProblem(mat, nlp.getColLower(), nlp.getColUpper(),
obj(), rowLow(), rowUp());
const Bonmin::TMINLP::VariableType* variableType = problem->var_types();
for (int i = 0; i < n; i++) {
if ((variableType[i] == Bonmin::TMINLP::BINARY) || (variableType[i] == Bonmin::TMINLP::INTEGER))
si.setInteger(i);
}
if (getObj) {
bool addObjVar = false;
if (problem->hasLinearObjective()) {
double zero;
Bonmin::vector<double> x0(n, 0.);
problem->eval_f(n, x0(), 1, zero);
si.setDblParam(OsiObjOffset, -zero);
//Copy the linear objective and don't create a dummy variable.
problem->eval_grad_f(n, x, 1, obj());
si.setObjective(obj());
} else {
addObjVar = true;
}
if (addObjVar) {
nlp.addObjectiveFunction(si, x);
}
}
// Hassan IA initial description
int InnerDesc = 1;
if (InnerDesc == 1) {
OsiCuts cs;
double * p = CoinCopyOfArray(colLower, n);
double * pp = CoinCopyOfArray(colLower, n);
double * up = CoinCopyOfArray(colUpper, n);
for (int i = 0; i < n; i++) {
if (p[i] < -1e3){
p[i] = pp[i] = -1e3;
}
if (up[i] > 1e2){
up[i] = 1e2;
}
}
const int& nbAp = nbAp_;
printf("Generating approximation with %i points.\n", nbAp);
std::vector<double> step(n);
int n_lin = 0;
for (int i = 0; i < n; i++) {
//if ((variableType[i] == Bonmin::TMINLP::BINARY) || (variableType[i] == Bonmin::TMINLP::INTEGER)) {
if (varTypes[i] == Ipopt::TNLP::LINEAR) {
n_lin ++;
step[i] = 0;
p[i] = pp[i] = up[i] = 0;
}
else {
step[i] = (up[i] - p[i]) / (nbAp);
}
}
printf("Number of linears %i\n", n_lin);
for (int j = 1; j < nbAp; j++) {
for (int i = 0; i < n; i++) {
pp[i] += step[i];
}
for (int i = 0; (i < m ); i++) {
if (constTypes[i] == Ipopt::TNLP::LINEAR) continue;
bool status = getMyInnerApproximation(nlp, cs, i, p, pp);// Generate a chord connecting the two points
if(status == false){
printf("Error in generating inner approximation\n");
exit(1);
}
}
std::copy(pp, pp+n, p);
}
for(int i = 0; (i< m); i++) {
if (constTypes[i] == Ipopt::TNLP::LINEAR) continue;
getMyInnerApproximation(nlp, cs, i, p, up);// Generate a chord connecting the two points
}
delete [] p;
delete [] pp;
delete [] up;
si.applyCuts(cs);
}
printf("************ Done extracting inner approx ********");
}
//-------------------------------------------------------------------
// Given the model data, a row of the model, and a LP solution,
// this function tries to generate a violated lifted simple generalized
// flow cover.
//-------------------------------------------------------------------
bool
CglFlowCover::generateOneFlowCut( const OsiSolverInterface & si,
const int rowLen,
int* ind,
double* coef,
char sense,
double rhs,
OsiRowCut& flowCut,
double& violation ) const
{
bool generated = false;
const double* xlp = si.getColSolution();
const int numCols = si.getNumCols();
double* up = new double [rowLen];
double* x = new double [rowLen];
double* y = new double [rowLen];
CglFlowColType* sign = new CglFlowColType [rowLen];
int i, j;
double value, LB, UB;
CglFlowVLB VLB;
CglFlowVUB VUB;
static int count=0;
++count;
CGLFLOW_DEBUG=false;
doLift=true;
// Get integer types
const char * columnType = si.getColType ();
for (i = 0; i < rowLen; ++i) {
if ( xlp[ind[i]] - floor(xlp[ind[i]]) > EPSILON_ && ceil(xlp[ind[i]]) - xlp[ind[i]] > EPSILON_ )
break;
}
if (i == rowLen) {
delete [] sign;
delete [] up;
delete [] x;
delete [] y;
return generated;
}
//-------------------------------------------------------------------------
if (sense == 'G') flipRow(rowLen, coef, rhs); // flips everything,
// but the sense
if(CGLFLOW_DEBUG) {
std::cout << "***************************" << std::endl;
std::cout << "Generate Flow cover -- initial constraint, converted to L sense..." << std::endl;
std::cout << "Rhs = " << rhs << std::endl;
std::cout << "coef [var_index]" << " -- " << "xlp[var_index]" << '\t' << "vub_coef[vub_index] vub_lp_value OR var_index_col_ub" << std::endl;
for(int iD = 0; iD < rowLen; ++iD) {
VUB = getVubs(ind[iD]);
std::cout << std::setw(5) << coef[iD] << "[" << std::setw(5) << ind[iD] << "] -- "
<< std::setw(20) << xlp[ind[iD]] << '\t';
if (VUB.getVar() != UNDEFINED_) {
std::cout << std::setw(20) << VUB.getVal() << "[" << std::setw(5) << VUB.getVar() << "]"
<< std::setw(20) << xlp[VUB.getVar()] << std::endl;
}
else
std::cout << std::setw(20) << si.getColUpper()[ind[iD]] << " " << std::setw(20) << 1.0 << std::endl;
}
}
//-------------------------------------------------------------------------
// Generate conservation inequality and capacity equalities from
// the given row.
for (i = 0; i < rowLen; ++i) {
VLB = getVlbs(ind[i]);
LB = ( VLB.getVar() != UNDEFINED_ ) ?
VLB.getVal() : si.getColLower()[ind[i]];
VUB = getVubs(ind[i]);
UB = ( VUB.getVar() != UNDEFINED_ ) ?
VUB.getVal() : si.getColUpper()[ind[i]];
if (LB < -EPSILON_) { // Only consider rows whose variables are all
delete [] sign; // non-negative (LB>= 0).
delete [] up;
delete [] x;
delete [] y;
return generated;
}
if ( columnType[ind[i]]==1 ) { // Binary variable
value = coef[i];
if (value > EPSILON_)
sign[i] = CGLFLOW_COL_BINPOS;
else {
sign[i] = CGLFLOW_COL_BINNEG;
value = -value;
}
up[i] = value;
x[i] = xlp[ind[i]];
y[i] = value * x[i];
}
else {
value = coef[i];
if (value > EPSILON_)
sign[i] = CGLFLOW_COL_CONTPOS;
else {
sign[i] = CGLFLOW_COL_CONTNEG;
value = -value;
}
up[i] = value* UB;
x[i] = (VUB.getVar() != UNDEFINED_) ? xlp[VUB.getVar()] : 1.0;
y[i] = value * xlp[ind[i]];
}
}
//-------------------------------------------------------------------------
// Find a initial cover (C+, C-) in (N+, N-)
double knapRHS = rhs;
double tempSum = 0.0;
double tempMin = INFTY_;
CglFlowColCut * candidate = new CglFlowColCut [rowLen];
CglFlowColCut * label = new CglFlowColCut [rowLen];
double* ratio = new double [rowLen];
int t = -1;
for (i = 0; i < rowLen; ++i) {
candidate[i] = label[i] = CGLFLOW_COL_OUTCUT;
ratio[i] = INFTY_;
switch(sign[i]) {
case CGLFLOW_COL_CONTPOS:
case CGLFLOW_COL_BINPOS:
if( y[i] > EPSILON_ ) {
ratio[i] = (1.0 - x[i]) / up[i];
if( y[i] > up[i] * x[i] - EPSILON_ ) { // Violated
candidate[i] = CGLFLOW_COL_PRIME;
tempSum += up[i];
}
else {
candidate[i] = CGLFLOW_COL_SECONDARY;
}
}
break;
case CGLFLOW_COL_CONTNEG:
case CGLFLOW_COL_BINNEG:
if( up[i] > ( (1.0 - EPSILON_) * INFTY_ ) ) { // UB is infty
label[i] = CGLFLOW_COL_INCUT;
}
else {
knapRHS += up[i];
if( y[i] < up[i] ) {
candidate[i] = CGLFLOW_COL_PRIME;
ratio[i] = x[i] / up[i];
tempSum += up[i];
}
}
break;
}
}
double diff, tempD, lambda;
int xID = -1;
if (knapRHS >1.0e10) {
if(CGLFLOW_DEBUG) {
std::cout << "knapsack RHS too large. RETURN." << std::endl;
}
delete [] sign;
delete [] up;
delete [] x;
delete [] y;
delete [] candidate;
delete [] label;
delete [] ratio;
return generated;
}
while (tempSum < knapRHS + EPSILON_) { // Not a cover yet
diff = INFTY_;
for (i = 0; i < rowLen; ++i) {
if (candidate[i] == CGLFLOW_COL_SECONDARY) {
tempD = up[i] * x[i] - y[i];
if (tempD < diff - EPSILON_) {
diff = tempD;
xID = i;
}
}
}
if( diff > (1.0 - EPSILON_) * INFTY_ ) { // NO cover exits.
delete [] sign;
delete [] up;
delete [] x;
delete [] y;
delete [] candidate;
delete [] label;
delete [] ratio;
return generated;
}
else {
tempSum += up[xID];
candidate[xID] = CGLFLOW_COL_PRIME;
}
}
// Solve the knapsack problem to get an initial cover
tempSum = 0.0;
for (i = 0; i < rowLen; ++i) {
if (candidate[i] == CGLFLOW_COL_PRIME && ratio[i] < EPSILON_) {
//Zero ratio
label[i] = CGLFLOW_COL_INCUT;
tempSum += up[i];
}
}
while (tempSum < knapRHS + EPSILON_) {
tempMin = INFTY_;
xID=-1;
for (i = 0; i < rowLen; i++) { // Search the col with minimum ratio
if (candidate[i] == CGLFLOW_COL_PRIME && label[i] == 0 &&
ratio[i] < tempMin) {
tempMin = ratio[i];
xID = i;
}
}
if (xID>=0) {
label[xID] = CGLFLOW_COL_INCUT;
tempSum += up[xID];
} else {
if(CGLFLOW_DEBUG) {
std::cout << "knapsack RHS too large B. RETURN." << std::endl;
}
delete [] sign;
delete [] up;
delete [] x;
delete [] y;
delete [] candidate;
delete [] label;
delete [] ratio;
return generated;
}
}
// Reduce to a minimal cover
for (i = 0; i < rowLen; ++i) {
if (label[i] == CGLFLOW_COL_INCUT && ratio[i] > EPSILON_) {
if (tempSum - up[i] > knapRHS + EPSILON_) {
label[i] = CGLFLOW_COL_OUTCUT;
tempSum -= up[i];
}
}
}
for (i = 0; i < rowLen; ++i) {
if (label[i] == CGLFLOW_COL_INCUT && ratio[i] < EPSILON_) {
if (tempSum - up[i] > knapRHS + EPSILON_) {
label[i] = CGLFLOW_COL_OUTCUT;
tempSum -= up[i];
}
}
}
// Due to the way to handle N-
for(i = 0; i < rowLen; ++i) {
if( sign[i] < 0 )
label[i] = label[i]==CGLFLOW_COL_OUTCUT?CGLFLOW_COL_INCUT:CGLFLOW_COL_OUTCUT;
}
// No cover, no cut.
bool emptyCover = true;
for (i = 0; i < rowLen; ++i) {
if (label[i] == CGLFLOW_COL_INCUT) {
emptyCover = false;
break;
}
}
if (emptyCover) {
if(CGLFLOW_DEBUG) {
std::cout << "No cover. RETURN." << std::endl;
}
delete [] sign;
delete [] up;
delete [] x;
delete [] y;
delete [] candidate;
delete [] label;
delete [] ratio;
return generated;
}
lambda = tempSum - knapRHS;
if(CGLFLOW_DEBUG) {
double sum_mj_Cplus = 0.0;
double sum_mj_Cminus= 0.0;
// double checkLambda; // variable not used anywhere (LL)
// print out the knapsack variables
std::cout << "Knapsack Cover: C+" << std::endl;
for (i = 0; i < rowLen; ++i) {
if ( label[i] == CGLFLOW_COL_INCUT && sign[i] > 0 ) {
std::cout << ind[i] << '\t' << up[i] << std::endl;
sum_mj_Cplus += up[i];
}
}
std::cout << "Knapsack Cover: C-" << std::endl;
for (i = 0; i < rowLen; ++i) {
if ( label[i] == CGLFLOW_COL_INCUT && sign[i] < 0 ) {
std::cout << ind[i] << '\t' << up[i] << std::endl;
sum_mj_Cminus += up[i];
}
}
// rlh: verified "lambda" is lambda in the paper.
// lambda = (sum coefficients in C+) - (sum of VUB
// coefficients in C-) - rhs-orig-constraint
std::cout << "lambda = " << lambda << std::endl;
}
//-------------------------------------------------------------------------
// Generate a violated SGFC
int numCMinus = 0;
int numPlusPlus = 0;
double* rho = new double [rowLen];
double* xCoef = new double [rowLen];
double* yCoef = new double [rowLen];
double cutRHS = rhs;
double temp = 0.0;
double sum = 0.0;
double minPlsM = INFTY_;
double minNegM = INFTY_;
for(i = 0; i < rowLen; ++i) {
rho[i] = 0.0;
xCoef[i] = 0.0;
yCoef[i] = 0.0;
}
// Project out variables in C-
// d^' = d + sum_{i in C^-} m_i. Now cutRHS = d^'
for (i = 0; i < rowLen; ++i) {
if ( label[i] == CGLFLOW_COL_INCUT && sign[i] < 0 ) {
cutRHS += up[i];
++numCMinus;
}
}
// (1) Compute the coefficients of the simple generalized flow cover
// (2) Compute minPlsM, minNegM and sum
//
// sum = sum_{i in C+\C++} m_i + sum_{i in L--} m_i = m. Page 15.
// minPlsM = min_{i in C++} m_i
// minNegM = min_{i in L-} m_i
temp = cutRHS;
for (i = 0; i < rowLen; ++i) {
if (label[i] == CGLFLOW_COL_INCUT && sign[i] > 0) { // C+
yCoef[i] = 1.0;
if ( up[i] > lambda + EPSILON_ ) { // C++
++numPlusPlus;
xCoef[i] = lambda - up[i];
cutRHS += xCoef[i];
if( up[i] < minPlsM ) {
minPlsM = up[i];
}
}
else { // C+\C++
xCoef[i] = 0.0; // rlh: is this necesarry? (xCoef initialized to zero)
sum += up[i];
}
}
if (label[i] != CGLFLOW_COL_INCUT && sign[i] < 0) { // N-\C-
temp += up[i];
if ( up[i] > lambda) { // L-
if(CGLFLOW_DEBUG) {
std::cout << "Variable " << ind[i] << " is in L-" << std::endl;
}
yCoef[i] = 0.0;
xCoef[i] = -lambda;
label[i] = CGLFLOW_COL_INLMIN;
if ( up[i] < minNegM ) {
minNegM = up[i];
}
}
else { // L--
if(CGLFLOW_DEBUG) {
std::cout << "Variable " << ind[i] << " is in L-- " << std::endl;
}
yCoef[i] = -1.0;
xCoef[i] = 0.0; // rlh: is this necesarry? (xCoef initialized to zero)
label[i] = CGLFLOW_COL_INLMINMIN;
sum += up[i];
}
}
}
// Sort the upper bounds (m_i) of variables in C++ and L-.
int ix;
int index = 0;
double temp1 = 0.0;
double* mt = new double [rowLen];
double* M = new double [rowLen + 1];
// order to look at variables
int * order = new int [rowLen];
int nLook=0;
for (int i = 0; i < rowLen; ++i) {
if ( (label[i] == CGLFLOW_COL_INCUT && sign[i] > 0) ||
label[i] == CGLFLOW_COL_INLMIN ) { // C+ || L-
// possible
M[nLook]=-up[i];
order[nLook++]=i;
}
}
CoinSort_2(M,M+nLook,order);
int kLook=0;
while (kLook<nLook) {
ix = UNDEFINED_;
i = order[kLook];
kLook++;
if ( (label[i] == CGLFLOW_COL_INCUT && sign[i] > 0) ||
label[i] == CGLFLOW_COL_INLMIN ) { // C+ || L-
if ( up[i] > lambda ) { // C++ || L-(up[i] > lambda)
ix = i;
}
}
if( ix == UNDEFINED_ ) break;
mt[index++] = up[ix]; // Record m_i in C++ and L-(not all) in descending order.
if( label[ix] == CGLFLOW_COL_INLMIN )
label[ix] = CGLFLOW_COL_INLMINDONE;
else
label[ix] = CGLFLOW_COL_INCUTDONE;
}
//printf("mins %g %g\n",minNegM,minPlsM);
if( index == 0 || numPlusPlus == 0) {
// No column in C++ and L-(not all). RETURN.
if(CGLFLOW_DEBUG) {
std::cout << "index = 0. RETURN." << std::endl;
}
delete [] sign;
delete [] up;
delete [] x;
delete [] y;
delete [] candidate;
delete [] label;
delete [] ratio;
delete [] rho;
delete [] xCoef;
delete [] yCoef;
delete [] mt;
delete [] M;
delete [] order;
return generated;
}
for ( i = 0; i < rowLen; i++ ) {
switch( label[i] ) {
case CGLFLOW_COL_INCUTDONE:
label[i] = CGLFLOW_COL_INCUT;
break;
case CGLFLOW_COL_INLMIN:
case CGLFLOW_COL_INLMINDONE:
case CGLFLOW_COL_INLMINMIN:
label[i] = CGLFLOW_COL_OUTCUT;
break;
case CGLFLOW_COL_INCUT:
case CGLFLOW_COL_OUTCUT:
case CGLFLOW_COL_PRIME:
case CGLFLOW_COL_SECONDARY:
break;
}
}
temp1 = temp;
/* Get t */
t = 0;
for ( i = 0; i < index; ++i ) {
if ( mt[i] < minPlsM ) {
t = i;
break;
}
}
if (i == index) {
t = index;
}
/* Compute M_i */
M[0] = 0.0;
for ( i = 1; i <= index; ++i ) {
M[i] = M[(i-1)] + mt[(i-1)];
if(CGLFLOW_DEBUG) {
std::cout << "t = " << t << std::endl;
std::cout << "mt[" << std::setw(5) << (i-1) << "]=" << std::setw(2) << ", M[" << std::setw(5) << i << "]=" << std::setw(20) << M[i] << std::endl;
}
}
// Exit if very big M
if (M[index]>1.0e30) { // rlh: should test for huge col UB earler
// no sense doing all this work in that case.
if(CGLFLOW_DEBUG) {
std::cout << "M[index]>1.0e30. RETURN." << std::endl;
delete [] sign;
delete [] up;
delete [] x;
delete [] y;
delete [] candidate;
delete [] label;
delete [] ratio;
delete [] rho;
delete [] xCoef;
delete [] yCoef;
delete [] mt;
delete [] M;
delete [] order;
return generated;
}
}
/* Get ml */
double ml = CoinMin(sum, lambda);
if(CGLFLOW_DEBUG) {
// sum = sum_{i in C+\C++} m_i + sum_{i in L--} m_i = m. Page 15.
std::cout << "ml = CoinMin(m, lambda) = CoinMin(" << sum << ", " << lambda << ") =" << ml << std::endl;
}
/* rho_i = max[0, m_i - (minPlsM - lamda) - ml */
if (t < index ) { /* rho exits only for t <= index-1 */
value = (minPlsM - lambda) + ml;
for (i = t; i < index; ++i) {
rho[i] = CoinMax(0.0, mt[i] - value);
if(CGLFLOW_DEBUG) {
std::cout << "rho[" << std::setw(5) << i << "]=" << std::setw(20) << rho[i] << std::endl;
}
}
}
// Calculate the violation
violation = -cutRHS;
for ( i = 0; i < rowLen; ++i ) {
#ifdef CGLFLOW_DEBUG2
if(CGLFLOW_DEBUG) {
std::cout << "i = " << i << " ind = " << ind[i] << " sign = "
<< sign[i]
<< " coef = " << coef[i] << " x = " << x[i] << " xCoef = "
<< xCoef[i] << " y = " << y[i] << " yCoef = " << yCoef[i]
<< " up = " << up[i] << " label = " << label[i] << std::endl;
}
#endif
violation += y[i] * yCoef[i] + x[i] * xCoef[i];
}
if(CGLFLOW_DEBUG) {
std::cout << "violation = " << violation << std::endl;
}
// double violationBeforeLift=violation; // variable not used anywhere (LL)
if(doLift && fabs(violation) > TOLERANCE_ ) { // LIFTING
double estY, estX;
double movement = 0.0;
double dPrimePrime = temp + cutRHS;
bool lifted = false;
for( i = 0; i < rowLen; ++i ) {
if ( (label[i] != CGLFLOW_COL_INCUT) && (sign[i] > 0) ) {/* N+\C+*/
lifted = liftPlus(estY, estX,
index, up[i],
lambda,
y[i], x[i],
dPrimePrime, M);
xCoef[i] = -estX;
yCoef[i] = estY;
if(CGLFLOW_DEBUG) {
if (lifted) {
printf("Success: Lifted col %i (up_i=%f,yCoef[i]=%f,xCoef[i]=%f) in N+\\C+\n",
ind[i], up[i], yCoef[i], xCoef[i]);
}
else {
printf("Failed to Lift col %i (m_i=%f) in N+\\C+\n",
ind[i], up[i]);
}
}
}
if (label[i] == CGLFLOW_COL_INCUT && sign[i] < 0) {
/* C- */
liftMinus(movement, t,
index, up[i],
dPrimePrime,
lambda, ml,
M, rho);
if(movement > EPSILON_) {
if(CGLFLOW_DEBUG) {
printf("Success: Lifted col %i in C-, movement=%f\n",
ind[i], movement);
}
lifted = true;
xCoef[i] = -movement;
cutRHS -= movement;
}
else {
if(CGLFLOW_DEBUG) {
printf("Failed to Lift col %i in C-, g=%f\n",
ind[i], movement);
}
}
}
}
}
//-------------------------------------------------------------------
// Calculate the violation
violation = -cutRHS;
for ( i = 0; i < rowLen; ++i ) {
#ifdef CGLFLOW_DEBUG2
if(CGLFLOW_DEBUG) {
std::cout << "i = " << i << " ind = " << ind[i] << " sign = "
<< sign[i]
<< " coef = " << coef[i] << " x = " << x[i] << " xCoef = "
<< xCoef[i] << " y = " << y[i] << " yCoef = " << yCoef[i]
<< " up = " << up[i] << " label = " << label[i] << std::endl;
}
#endif
violation += y[i] * yCoef[i] + x[i] * xCoef[i];
}
if(CGLFLOW_DEBUG) {
std::cout << "violation = " << violation << std::endl;
}
int cutLen = 0;
char cutSense = 'L';
int* cutInd = 0;
double* cutCoef = 0;
// If violated, transform the inequality back to original system
if ( violation > TOLERANCE_ ) {
cutLen = 0;
cutSense = 'L';
cutInd = new int [numCols];
cutCoef = new double [numCols];
for ( i = 0; i < rowLen; ++i ) {
VUB = getVubs(ind[i]);
if ( ( sign[i] == CGLFLOW_COL_CONTPOS ) ||
( sign[i] == CGLFLOW_COL_CONTNEG ) ) {
if ( fabs( yCoef[i] ) > EPSILON_ ) {
if ( sign[i] == CGLFLOW_COL_CONTPOS )
cutCoef[cutLen] = coef[i] * yCoef[i];
else
cutCoef[cutLen] = -coef[i] * yCoef[i];
cutInd[cutLen++] = ind[i];
}
if ( fabs( xCoef[i] ) > EPSILON_ ) {
if ( VUB.getVar() != UNDEFINED_ ) {
cutCoef[cutLen] = xCoef[i];
cutInd[cutLen++] = VUB.getVar();
}
else
cutRHS -= xCoef[i];
}
}
if ( ( sign[i] == CGLFLOW_COL_BINPOS ) ||
( sign[i] == CGLFLOW_COL_BINNEG ) ) {
if (fabs(yCoef[i]) > EPSILON_ || fabs(xCoef[i]) > EPSILON_) {
if (sign[i] == CGLFLOW_COL_BINPOS)
cutCoef[cutLen] = coef[i] * yCoef[i] + xCoef[i];
else
cutCoef[cutLen] = -coef[i] * yCoef[i] + xCoef[i];
cutInd[cutLen++] = ind[i];
}
}
}
for ( i = 0; i < cutLen; ++i ) {
for ( j = 0; j < i; j++ ) {
if ( cutInd[j] == cutInd[i] ) { /* Duplicate*/
cutCoef[j] += cutCoef[i];
cutInd[i] = -1;
}
}
}
for ( j = 0, i = 0; i < cutLen; ++i ) {
if ( ( cutInd[i] == -1 ) || ( fabs( cutCoef[i]) < EPSILON_ ) ){
/* Small coeff*/
}
else {
cutCoef[j] = cutCoef[i];
cutInd[j] = cutInd[i];
j++;
}
}
cutLen = j;
// Skip if no elements ? - bug somewhere
assert (cutLen);
// Recheck the violation.
violation = 0.0;
for (i = 0; i < cutLen; ++i)
violation += cutCoef[i] * xlp[cutInd[i]];
violation -= cutRHS;
if ( violation > TOLERANCE_ ) {
flowCut.setRow(cutLen, cutInd, cutCoef);
flowCut.setLb(-1.0 * si.getInfinity());
flowCut.setUb(cutRHS);
flowCut.setEffectiveness(violation);
generated = true;
if(CGLFLOW_DEBUG) {
std::cout << "generateOneFlowCover(): Found a cut" << std::endl;
}
}
else {
if(CGLFLOW_DEBUG) {
std::cout << "generateOneFlowCover(): Lost a cut" << std::endl;
}
}
}
//-------------------------------------------------------------------------
delete [] sign;
delete [] up;
delete [] x;
delete [] y;
delete [] candidate;
delete [] label;
delete [] ratio;
delete [] rho;
delete [] xCoef;
delete [] yCoef;
delete [] mt;
delete [] M;
delete [] order;
delete [] cutInd;
delete [] cutCoef;
return generated;
}
void
HeuristicInnerApproximation::extractInnerApproximation(OsiTMINLPInterface & nlp, OsiSolverInterface &si,
const double * x, bool getObj) {
int n;
int m;
int nnz_jac_g;
int nnz_h_lag;
Ipopt::TNLP::IndexStyleEnum index_style;
TMINLP2TNLP * problem = nlp.problem();
//Get problem information
problem->get_nlp_info(n, m, nnz_jac_g, nnz_h_lag, index_style);
vector<int> jRow(nnz_jac_g);
vector<int> jCol(nnz_jac_g);
vector<double> jValues(nnz_jac_g);
problem->eval_jac_g(n, NULL, 0, m, nnz_jac_g, jRow(), jCol(), NULL);
if(index_style == Ipopt::TNLP::FORTRAN_STYLE)//put C-style
{
for(int i = 0 ; i < nnz_jac_g ; i++){
jRow[i]--;
jCol[i]--;
}
}
//get Jacobian
problem->eval_jac_g(n, x, 1, m, nnz_jac_g, NULL, NULL,
jValues());
vector<double> g(m);
problem->eval_g(n, x, 1, m, g());
vector<int> nonLinear(m);
//store non linear constraints (which are to be removed from IA)
int numNonLinear = 0;
const double * rowLower = nlp.getRowLower();
const double * rowUpper = nlp.getRowUpper();
const double * colLower = nlp.getColLower();
const double * colUpper = nlp.getColUpper();
assert(m == nlp.getNumRows());
double infty = si.getInfinity();
double nlp_infty = nlp.getInfinity();
vector<Ipopt::TNLP::LinearityType> constTypes(m);
problem->get_constraints_linearity(m, constTypes());
for (int i = 0; i < m; i++) {
if (constTypes[i] == Ipopt::TNLP::NON_LINEAR) {
nonLinear[numNonLinear++] = i;
}
}
vector<double> rowLow(m - numNonLinear);
vector<double> rowUp(m - numNonLinear);
int ind = 0;
for (int i = 0; i < m; i++) {
if (constTypes[i] != Ipopt::TNLP::NON_LINEAR) {
if (rowLower[i] > -nlp_infty) {
// printf("Lower %g ", rowLower[i]);
rowLow[ind] = (rowLower[i]);
} else
rowLow[ind] = -infty;
if (rowUpper[i] < nlp_infty) {
// printf("Upper %g ", rowUpper[i]);
rowUp[ind] = (rowUpper[i]);
} else
rowUp[ind] = infty;
ind++;
}
}
CoinPackedMatrix mat(true, jRow(), jCol(), jValues(), nnz_jac_g);
mat.setDimensions(m, n); // In case matrix was empty, this should be enough
//remove non-linear constraints
mat.deleteRows(numNonLinear, nonLinear());
int numcols = nlp.getNumCols();
vector<double> obj(numcols);
for (int i = 0; i < numcols; i++)
obj[i] = 0.;
si.loadProblem(mat, nlp.getColLower(), nlp.getColUpper(),
obj(), rowLow(), rowUp());
const Bonmin::TMINLP::VariableType* variableType = problem->var_types();
for (int i = 0; i < n; i++) {
if ((variableType[i] == TMINLP::BINARY) || (variableType[i]
== TMINLP::INTEGER))
si.setInteger(i);
}
if (getObj) {
bool addObjVar = false;
if (problem->hasLinearObjective()) {
double zero;
vector<double> x0(n, 0.);
problem->eval_f(n, x0(), 1, zero);
si.setDblParam(OsiObjOffset, -zero);
//Copy the linear objective and don't create a dummy variable.
problem->eval_grad_f(n, x, 1, obj());
si.setObjective(obj());
} else {
addObjVar = true;
}
if (addObjVar) {
nlp.addObjectiveFunction(si, x);
}
}
// Hassan IA initial description
int InnerDesc = 1;
if (InnerDesc == 1) {
OsiCuts cs;
double * p = CoinCopyOfArray(colLower, n);
double * pp = CoinCopyOfArray(colLower, n);
double * up = CoinCopyOfArray(colUpper, n);
const int& nbAp = nbAp_;
std::vector<int> nbG(m, 0);// Number of generated points for each nonlinear constraint
std::vector<double> step(n);
for (int i = 0; i < n; i++) {
if (colUpper[i] > 1e08) {
up[i] = 0;
}
if (colUpper[i] > 1e08 || colLower[i] < -1e08 || (variableType[i]
== TMINLP::BINARY) || (variableType[i] == TMINLP::INTEGER)) {
step[i] = 0;
} else
step[i] = (up[i] - colLower[i]) / (nbAp);
if (colLower[i] < -1e08) {
p[i] = 0;
pp[i] = 0;
}
}
vector<double> g_p(m);
vector<double> g_pp(m);
for (int j = 1; j <= nbAp; j++) {
for (int i = 0; i < n; i++) {
pp[i] += step[i];
}
problem->eval_g(n, p, 1, m, g_p());
problem->eval_g(n, pp, 1, m, g_pp());
double diff = 0;
int varInd = 0;
for (int i = 0; (i < m && constTypes[i] == Ipopt::TNLP::NON_LINEAR); i++) {
if (varInd == n - 1)
varInd = 0;
diff = std::abs(g_p[i] - g_pp[i]);
if (nbG[i] < nbAp - 1) {
getMyInnerApproximation(nlp, cs, i, p, pp);// Generate a chord connecting the two points
p[varInd] = pp[varInd];
nbG[i]++;
}
varInd++;
}
}
for(int i = 0; (i< m && constTypes[i] == Ipopt::TNLP::NON_LINEAR); i++) {
// getConstraintOuterApproximation(cs, i, colUpper, NULL, true);// Generate Tangents at current point
getMyInnerApproximation(nlp, cs, i, p, up);// Generate a chord connecting the two points
}
delete [] p;
delete [] pp;
delete [] up;
si.applyCuts(cs);
}
}
int
main(void)
{
// Create a problem pointer. We use the base class here.
OsiSolverInterface *si;
// When we instantiate the object, we need a specific derived class.
si = new OSIXXX;
// Build our own instance from scratch
/*
* This section adapted from Matt Galati's example
* on the COIN-OR Tutorial website.
*
* Problem from Bertsimas, Tsitsiklis page 21
*
* optimal solution: x* = (1,1)
*
* minimize -1 x0 - 1 x1
* s.t 1 x0 + 2 x1 <= 3
* 2 x0 + 1 x1 <= 3
* x0 >= 0
* x1 >= 0
*/
int n_cols = 2;
double *objective = new double[n_cols];//the objective coefficients
double *col_lb = new double[n_cols];//the column lower bounds
double *col_ub = new double[n_cols];//the column upper bounds
//Define the objective coefficients.
//minimize -1 x0 - 1 x1
objective[0] = -1.0;
objective[1] = -1.0;
//Define the variable lower/upper bounds.
// x0 >= 0 => 0 <= x0 <= infinity
// x1 >= 0 => 0 <= x1 <= infinity
col_lb[0] = 0.0;
col_lb[1] = 0.0;
col_ub[0] = si->getInfinity();
col_ub[1] = si->getInfinity();
int n_rows = 2;
double *row_lb = new double[n_rows]; //the row lower bounds
double *row_ub = new double[n_rows]; //the row upper bounds
//Define the constraint matrix.
CoinPackedMatrix *matrix = new CoinPackedMatrix(false,0,0);
matrix->setDimensions(0, n_cols);
//1 x0 + 2 x1 <= 3 => -infinity <= 1 x0 + 2 x2 <= 3
CoinPackedVector row1;
row1.insert(0, 1.0);
row1.insert(1, 2.0);
row_lb[0] = -1.0 * si->getInfinity();
row_ub[0] = 3.0;
matrix->appendRow(row1);
//2 x0 + 1 x1 <= 3 => -infinity <= 2 x0 + 1 x1 <= 3
CoinPackedVector row2;
row2.insert(0, 2.0);
row2.insert(1, 1.0);
row_lb[1] = -1.0 * si->getInfinity();
row_ub[1] = 3.0;
matrix->appendRow(row2);
//load the problem to OSI
si->loadProblem(*matrix, col_lb, col_ub, objective, row_lb, row_ub);
//write the MPS file to a file called example.mps
si->writeMps("example");
// Solve the (relaxation of the) problem
si->initialSolve();
// Check the solution
if ( si->isProvenOptimal() ) {
std::cout << "Found optimal solution!" << std::endl;
std::cout << "Objective value is " << si->getObjValue() << std::endl;
int n = si->getNumCols();
const double *solution;
solution = si->getColSolution();
// We could then print the solution or examine it.
} else {
std::cout << "Didn't find optimal solution." << std::endl;
// Could then check other status functions.
}
return 0;
}
//#############################################################################
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;
}
OsiSolverInterface* cpropagation_preprocess(CPropagation *cp, int nindexes[])
{
if(cp->varsToFix == 0)
{
/* printf("There are no variables to remove from the problem!\n"); */
return NULL; /* returns a pointer to original solver */
}
const double *colLb = problem_vars_lower_bound(cp->problem), *colUb = problem_vars_upper_bound(cp->problem);
const double *objCoef = problem_vars_obj_coefs(cp->problem);
const char *ctype = problem_vars_type(cp->problem);
double sumFixedObj = 0.0; /* stores the sum of objective coefficients of all variables fixed to 1 */
OsiSolverInterface *preProcSolver = new OsiClpSolverInterface();
preProcSolver->setIntParam(OsiNameDiscipline, 2);
preProcSolver->messageHandler()->setLogLevel(0);
preProcSolver->setHintParam(OsiDoReducePrint,true,OsiHintTry);
//preProcSolver->setObjName(cp->solver->getObjName());
for(int i = 0, j = 0; i < problem_num_cols(cp->problem); i++)
{
nindexes[i] = -1;
if(cp->isToFix[i] == UNFIXED)
{
preProcSolver->addCol(0, NULL, NULL, colLb[i], colUb[i], objCoef[i]);
preProcSolver->setColName(j, problem_var_name(cp->problem, i));
if(problem_var_type(cp->problem, i) == CONTINUOUS)
preProcSolver->setContinuous(j);
else
preProcSolver->setInteger(j);
nindexes[i] = j++;
}
else if(cp->isToFix[i] == ACTIVATE)
sumFixedObj += objCoef[i];
}
if(fabs(sumFixedObj) > EPS)
{
/* adding a variable with cost equals to the sum of all coefficients of variables fixed to 1 */
preProcSolver->addCol(0, NULL, NULL, 1.0, 1.0, sumFixedObj);
preProcSolver->setColName(preProcSolver->getNumCols()-1, "sumFixedObj");
preProcSolver->setInteger(preProcSolver->getNumCols()-1);
}
for(int idxRow = 0; idxRow < problem_num_rows(cp->problem); idxRow++)
{
const int nElements = problem_row_size(cp->problem, idxRow);
const int *idxs = problem_row_idxs(cp->problem, idxRow);
const double *coefs = problem_row_coefs(cp->problem, idxRow);
vector< int > vidx; vidx.reserve(problem_num_cols(cp->problem));
vector< double > vcoef; vcoef.reserve(problem_num_cols(cp->problem));
double activeCoefs = 0.0;
for(int i = 0; i < nElements; i++)
{
if(cp->isToFix[idxs[i]] == UNFIXED)
{
assert(nindexes[idxs[i]] >= 0 && nindexes[idxs[i]] < problem_num_cols(cp->problem));
vidx.push_back(nindexes[idxs[i]]);
vcoef.push_back(coefs[i]);
}
else if(cp->isToFix[idxs[i]] == ACTIVATE)
activeCoefs += coefs[i];
}
if(!vidx.empty())
{
double rlb, rub;
const char sense = problem_row_sense(cp->problem, idxRow);
if(sense == 'E')
{
rlb = problem_row_rhs(cp->problem, idxRow) - activeCoefs;
rub = problem_row_rhs(cp->problem, idxRow) - activeCoefs;
}
else if(sense == 'L')
{
rlb = preProcSolver->getInfinity();
rub = problem_row_rhs(cp->problem, idxRow) - activeCoefs;
}
else if(sense == 'G')
{
rlb = problem_row_rhs(cp->problem, idxRow) - activeCoefs;
rub = preProcSolver->getInfinity();
}
else
{
fprintf(stderr, "Error: invalid type of constraint!\n");
exit(EXIT_FAILURE);
}
preProcSolver->addRow((int)vcoef.size(), &vidx[0], &vcoef[0], rlb, rub);
preProcSolver->setRowName(idxRow, problem_row_name(cp->problem, idxRow));
}
}
return preProcSolver;
}
