//#############################################################################
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;
}
//#############################################################################
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;
}
//#############################################################################
bfSol*
MibSHeuristic::getBilevelSolution1(const double * sol)
{
/*
Find a bilevel feasible solution by solving the LL problem
for a fixed UL solution, given by the UL portion of sol
*/
MibSModel * model = MibSModel_;
OsiSolverInterface * oSolver = model->getSolver();
OsiSolverInterface * lSolver = new OsiCbcSolverInterface(oSolver);
//double uObjSense(model->getSolver()->getObjSense());
double lObjSense(model->getLowerObjSense());
int lCols(model->getLowerDim());
int uCols(model->getUpperDim());
int * lColIndices = model->getLowerColInd();
int uRowNum = model->getUpperRowNum();
int lRowNum = model->getLowerRowNum();
int * uRowIndices = model->getUpperRowInd();
int * lRowIndices = model->getLowerRowInd();
int * uColIndices = model->getUpperColInd();
double * lObjCoeffs = model->getLowerObjCoeffs();
int tCols(uCols + lCols);
int i(0), index(0);
/* delete the UL rows */
lSolver->deleteRows(uRowNum, uRowIndices);
/* Fix the UL variables to their current value in sol */
for(i = 0; i < uCols; i++){
index = uColIndices[i];
lSolver->setColLower(index, sol[index]);
lSolver->setColUpper(index, sol[index]);
}
/* Set the objective to the LL objective coefficients */
double * nObjCoeffs = new double[tCols];
CoinZeroN(nObjCoeffs, tCols);
for(i = 0; i < lCols; i++){
index = lColIndices[i];
nObjCoeffs[index] = lObjCoeffs[i] * lObjSense;
}
lSolver->setObjective(nObjCoeffs);
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()){
double objVal(0.0);
for(i = 0; i < tCols; i++)
objVal += lSolver->getColSolution()[i] * oSolver->getObjCoefficients()[i];
double * colsol = new double[tCols];
CoinCopyN(lSolver->getColSolution(), tCols, colsol);
bfSol * bfsol =
new bfSol(objVal, colsol);
delete lSolver;
return bfsol;
}
else{
delete lSolver;
return NULL;
}
}
//#############################################################################
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
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;
}
