int
NlpSolveHeuristic::solution (double & objectiveValue, double * newSolution) {
int noSolution = 1, maxTime = 2;
// do heuristic the usual way, but if for any reason (time is up, no
// better solution found) there is no improvement, get the best
// solution from the GlobalCutOff object in the pointer to the
// CouenneProblem and return it instead.
//
// Although this should be handled by Cbc, very often this doesn't
// happen.
// int nodeDepth = -1;
const int depth = (model_ -> currentNode ()) ? model_ -> currentNode () -> depth () : 0;
if (depth <= 0)
couenne_ -> Jnlst () -> Printf (J_ERROR, J_COUENNE, "NLP Heuristic: "); fflush (stdout);
try {
if (CoinCpuTime () > couenne_ -> getMaxCpuTime ())
throw maxTime;
OsiSolverInterface * solver = model_ -> solver();
OsiAuxInfo * auxInfo = solver->getAuxiliaryInfo();
Bonmin::BabInfo * babInfo = dynamic_cast <Bonmin::BabInfo *> (auxInfo);
if(babInfo){
babInfo->setHasNlpSolution(false);
if(babInfo->infeasibleNode()){
throw noSolution;
}
}
// if too deep in the BB tree, only run NLP heuristic if
// feasibility is low
bool too_deep = false;
// check depth
if (numberSolvePerLevel_ > -1) {
if (numberSolvePerLevel_ == 0)
throw maxTime;
//if (CoinDrand48 () > pow (2., numberSolvePerLevel_ - depth))
if (CoinDrand48 () > 1. / CoinMax
(1., (double) ((depth - numberSolvePerLevel_) *
(depth - numberSolvePerLevel_))))
too_deep = true;
}
if (too_deep)
throw maxTime;
double *lower = new double [couenne_ -> nVars ()];
double *upper = new double [couenne_ -> nVars ()];
CoinFillN (lower, couenne_ -> nVars (), -COUENNE_INFINITY);
CoinFillN (upper, couenne_ -> nVars (), COUENNE_INFINITY);
CoinCopyN (solver->getColLower(), nlp_ -> getNumCols (), lower);
CoinCopyN (solver->getColUpper(), nlp_ -> getNumCols (), upper);
/*printf ("-- int candidate, before: ");
for (int i=0; i<couenne_ -> nOrig (); i++)
printf ("[%g %g] ", lower [i], upper [i]);
printf ("\n");*/
const double * solution = solver->getColSolution();
OsiBranchingInformation info (solver, true);
const int & numberObjects = model_->numberObjects();
OsiObject ** objects = model_->objects();
double maxInfeasibility = 0;
bool haveRoundedIntVars = false;
for (int i = 0 ; i < numberObjects ; i++) {
CouenneObject * couObj = dynamic_cast <CouenneObject *> (objects [i]);
if (couObj) {
if (too_deep) { // only test infeasibility if BB level is high
int dummy;
double infeas;
maxInfeasibility = CoinMax ( maxInfeasibility, infeas = couObj->infeasibility(&info, dummy));
if (maxInfeasibility > maxNlpInf_){
delete [] lower;
delete [] upper;
throw noSolution;
}
}
} else {
OsiSimpleInteger * intObj = dynamic_cast<OsiSimpleInteger *>(objects[i]);
if (intObj) {
const int & i = intObj -> columnNumber ();
// Round the variable in the solver
double value = solution [i];
if (value < lower[i])
value = lower[i];
else if (value > upper[i])
value = upper[i];
double rounded = floor (value + 0.5);
if (fabs (value - rounded) > COUENNE_EPS) {
haveRoundedIntVars = true;
//value = rounded;
}
// fix bounds anyway, if a better candidate is not found
// below at least we have an integer point
//lower[i] = upper[i] = value;
}
else{
// Probably a SOS object -- do not stop here
//throw CoinError("Bonmin::NlpSolveHeuristic","solution",
//"Unknown object.");
}
}
}
// if here, it means the infeasibility is not too high. Generate a
// better integer point as there are rounded integer variables
bool skipOnInfeasibility = false;
double *Y = new double [couenne_ -> nVars ()];
CoinFillN (Y, couenne_ -> nVars (), 0.);
CoinCopyN (solution, nlp_ -> getNumCols (), Y);
/*printf ("-- int candidate, upon call: ");
for (int i=0; i<couenne_ -> nOrig (); i++)
if (couenne_ -> Var (i) -> isInteger ())
printf ("[%g <%g> %g] ", lower [i], Y [i], upper [i]);
else printf ("%g ", Y [i]);
printf ("\n");*/
if (haveRoundedIntVars) // create "good" integer candidate for Ipopt
skipOnInfeasibility = (couenne_ -> getIntegerCandidate (solution, Y, lower, upper) < 0);
/*printf ("-- int candidate, after: ");
for (int i=0; i<couenne_ -> nOrig (); i++)
if (couenne_ -> Var (i) -> isInteger ())
printf ("[%g <%g> %g] ", lower [i], Y [i], upper [i]);
else printf ("%g ", Y [i]);
printf ("\n");*/
bool foundSolution = false;
if (haveRoundedIntVars && skipOnInfeasibility)
// no integer initial point could be found, make up some random rounding
for (int i = couenne_ -> nOrigVars (); i--;)
if (couenne_ -> Var (i) -> isDefinedInteger ())
lower [i] = upper [i] = Y [i] =
(CoinDrand48 () < 0.5) ?
floor (Y [i] + COUENNE_EPS) :
ceil (Y [i] - COUENNE_EPS);
else if (lower [i] > upper [i]) {
// sanity check (should avoid problems in ex1263 with
// couenne.opt.obbt)
double swap = lower [i];
lower [i] = upper [i];
upper [i] = swap;
}
{
// printf ("[%g <%g> %g] ", lower [i], Y [i], upper [i]);
/*printf ("int candidate: ");
for (int i=0; i<couenne_ -> nOrig (); i++)
if (couenne_ -> Var (i) -> isInteger ())
printf ("[%g <%g> %g] ", lower [i], Y [i], upper [i]);
else printf ("%g ", Y [i]);
printf ("\n");*/
// Now set column bounds and solve the NLP with starting point
double * saveColLower = CoinCopyOfArray (nlp_ -> getColLower (), nlp_ -> getNumCols ());
double * saveColUpper = CoinCopyOfArray (nlp_ -> getColUpper (), nlp_ -> getNumCols ());
for (int i = nlp_ -> getNumCols (); i--;) {
if (lower [i] > upper [i]) {
double swap = lower [i];
lower [i] = upper [i];
upper [i] = swap;
}
if (Y [i] < lower [i]) Y [i] = lower [i];
else if (Y [i] > upper [i]) Y [i] = upper [i];
}
nlp_ -> setColLower (lower);
nlp_ -> setColUpper (upper);
nlp_ -> setColSolution (Y);
// apply NLP solver /////////////////////////////////
try {
nlp_ -> options () -> SetNumericValue ("max_cpu_time", CoinMax (0.1, couenne_ -> getMaxCpuTime () - CoinCpuTime ()));
nlp_ -> initialSolve ();
}
catch (Bonmin::TNLPSolver::UnsolvedError *E) {}
double obj = (nlp_ -> isProvenOptimal()) ? nlp_ -> getObjValue (): COIN_DBL_MAX;
if (nlp_ -> isProvenOptimal () &&
couenne_ -> checkNLP (nlp_ -> getColSolution (), obj, true) && // true for recomputing obj
(obj < couenne_ -> getCutOff ())) {
// store solution in Aux info
const int nVars = solver->getNumCols();
double* tmpSolution = new double [nVars];
CoinCopyN (nlp_ -> getColSolution(), nlp_ -> getNumCols(), tmpSolution);
//Get correct values for all auxiliary variables
CouenneInterface * couenne = dynamic_cast <CouenneInterface *> (nlp_);
if (couenne)
couenne_ -> getAuxs (tmpSolution);
#ifdef FM_CHECKNLP2
if(!couenne_->checkNLP2(tmpSolution,
0, false, // do not care about obj
true, // stopAtFirstViol
false, // checkAll
couenne_->getFeasTol())) {
#ifdef FM_USE_REL_VIOL_CONS
printf("NlpSolveHeuristic::solution(): ### ERROR: checkNLP(): returns true, checkNLP2() returns false\n");
exit(1);
#endif
}
obj = couenne_->getRecordBestSol()->getModSolVal();
couenne_->getRecordBestSol()->update();
#else
couenne_->getRecordBestSol()->update(tmpSolution, nVars,
obj, couenne_->getFeasTol());
#endif
if (babInfo){
babInfo->setNlpSolution (tmpSolution, nVars, obj);
babInfo->setHasNlpSolution (true);
}
if (obj < objectiveValue) { // found better solution?
const CouNumber
*lb = solver -> getColLower (),
*ub = solver -> getColUpper ();
// check bounds once more after getAux. This avoids false
// asserts in CbcModel.cpp:8305 on integerTolerance violated
for (int i=0; i < nVars; i++, lb++, ub++) {
CouNumber &t = tmpSolution [i];
if (t < *lb) t = *lb;
else if (t > *ub) t = *ub;
}
//printf ("new cutoff %g from BonNlpHeuristic\n", obj);
couenne_ -> setCutOff (obj);
foundSolution = true;
objectiveValue = obj;
CoinCopyN (tmpSolution, nVars, newSolution);
}
delete [] tmpSolution;
}
nlp_ -> setColLower (saveColLower);
nlp_ -> setColUpper (saveColUpper);
delete [] saveColLower;
delete [] saveColUpper;
}
delete [] Y;
delete [] lower;
delete [] upper;
if (depth <= 0) {
if (foundSolution) couenne_ -> Jnlst () -> Printf (J_ERROR, J_COUENNE, "solution found, obj. %g\n", objectiveValue);
else couenne_ -> Jnlst () -> Printf (J_ERROR, J_COUENNE, "no solution.\n");
}
return foundSolution;
}
catch (int &e) {
// forget about using the global cutoff. That has to trickle up to
// Cbc some other way
if (e==noSolution) {if (depth <= 0) couenne_ -> Jnlst () -> Printf (J_ERROR, J_COUENNE, "no solution.\n"); return 0;}
else if (e==maxTime) {if (depth <= 0) couenne_ -> Jnlst () -> Printf (J_ERROR, J_COUENNE, "time limit reached.\n"); return 0;}
else {if (depth <= 0) couenne_ -> Jnlst () -> Printf (J_ERROR, J_COUENNE, "solution found, obj. %g\n", objectiveValue); return 1;}
// // no solution available? Use the one from the global cutoff
// if ((couenne_ -> getCutOff () < objectiveValue) &&
// couenne_ -> getCutOffSol ()) {
// objectiveValue = couenne_ -> getCutOff ();
// CoinCopyN (couenne_ -> getCutOffSol (), couenne_ -> nVars (), newSolution);
// if (depth <= 0)
// couenne_ -> Jnlst () -> Printf (J_ERROR, J_COUENNE, "solution found, obj. %g\n", objectiveValue);
// return 1;
// } else {
// if (depth <= 0 && e==noSolution)
// couenne_ -> Jnlst () -> Printf (J_ERROR, J_COUENNE, "no solution.\n", objectiveValue);
// return 0;
// }
}
}
/** Standard cut generation methods. */
void
OaDecompositionBase::generateCuts(const OsiSolverInterface &si, OsiCuts & cs,
const CglTreeInfo info) {
if (nlp_ == NULL) {
throw CoinError("Error in cut generator for outer approximation no NLP ipopt assigned", "generateCuts", "OaDecompositionBase");
}
// babInfo is used to communicate with the b-and-b solver (Cbc or Bcp).
BabInfo * babInfo = dynamic_cast<BabInfo *> (si.getAuxiliaryInfo());
assert(babInfo);
assert(babInfo->babPtr());
numSols_ = babInfo->babPtr()->model().getSolutionCount ();
CglTreeInfo info_copy = info;
const CbcNode * node = babInfo->babPtr()->model().currentNode();
info_copy.level = (node == NULL) ? 0 : babInfo->babPtr()->model().currentNode()->depth();
if(babInfo->hasSolution()) numSols_ ++;
if (babInfo)
if (!babInfo->mipFeasible())
return;
//Get the continuous solution
const double *colsol = si.getColSolution();
vector<double> savedColLower(nlp_->getNumCols());
CoinCopyN(nlp_->getColLower(), nlp_->getNumCols(), savedColLower());
vector<double> savedColUpper(nlp_->getNumCols());
CoinCopyN(nlp_->getColUpper(), nlp_->getNumCols(), savedColUpper());
OsiBranchingInformation brInfo(nlp_, false);
brInfo.solution_ = colsol;
//Check integer infeasibility
bool isInteger = integerFeasible(*nlp_, brInfo, parameters_.cbcIntegerTolerance_,
objects_, nObjects_);
//Check nodeNumber if it did not change scan savedCuts_ if one is violated force it and exit
int nodeNumber = babInfo->babPtr()->model().getNodeCount();
if(nodeNumber == currentNodeNumber_){
#ifdef OA_DEBUG
printf("OA decomposition recalled from the same node!\n");
#endif
int numCuts = savedCuts_.sizeRowCuts();
for(int i = 0 ; i < numCuts ; i++){
//Check if cuts off solution
if(savedCuts_.rowCut(i).violated(colsol) > 0.){
#ifdef OA_DEBUG
printf("A violated saved cut has been found\n");
#endif
savedCuts_.rowCut(i).setEffectiveness(9.99e99);
cs.insert(savedCuts_.rowCut(i));
savedCuts_.eraseRowCut(i);
return;
i--; numCuts--;
}
}
}
else {
currentNodeNumber_ = nodeNumber;
savedCuts_.dumpCuts();
}
if (!isInteger) {
if (!doLocalSearch(babInfo))//create sub mip solver.
return;
}
//get the current cutoff
double cutoff;
si.getDblParam(OsiDualObjectiveLimit, cutoff);
// Save solvers state if needed
solverManip * lpManip = NULL;
if (lp_ != NULL) {
assert(lp_ == &si);
lpManip = new solverManip(lp_, true, leaveSiUnchanged_, true, true);
}
else {
lpManip = new solverManip(si);
}
lpManip->setObjects(objects_, nObjects_);
double milpBound = performOa(cs, *lpManip, babInfo, cutoff, info_copy);
if(babInfo->hasSolution()){
babInfo->babPtr()->model().setSolutionCount (numSols_ - 1);
}
//Transmit the bound found by the milp
{
if (milpBound>-1e100)
{
// Also store into solver
if (babInfo)
babInfo->setMipBound(milpBound);
}
} //Clean everything :
// Reset the two solvers
if (leaveSiUnchanged_)
lpManip->restore();
delete lpManip;
nlp_->setColLower(savedColLower());
nlp_->setColUpper(savedColUpper());
return;
}
void CouenneCutGenerator::generateCuts (const OsiSolverInterface &si,
OsiCuts &cs,
const CglTreeInfo info)
#if CGL_VERSION_MAJOR == 0 && CGL_VERSION_MINOR <= 57
const
#endif
{
// check if out of time or if an infeasibility cut (iis of type 0)
// was added as a result of, e.g., pruning on BT. If so, no need to
// run this.
if (isWiped (cs) ||
(CoinCpuTime () > problem_ -> getMaxCpuTime ()))
return;
#ifdef FM_TRACE_OPTSOL
double currCutOff = problem_->getCutOff();
double bestVal = 1e50;
CouenneRecordBestSol *rs = problem_->getRecordBestSol();
if(rs->getHasSol()) {
bestVal = rs->getVal();
}
if(currCutOff > bestVal) {
//problem_ -> setCutOff (bestVal - 1e-6); // FIXME: don't add numerical constants
problem_ -> setCutOff (bestVal);
int indObj = problem_->Obj(0)->Body()->Index();
if (indObj >= 0) {
OsiColCut *objCut = new OsiColCut;
objCut->setUbs(1, &indObj, &bestVal);
cs.insert(objCut);
delete objCut;
}
}
#endif
#ifdef FM_PRINT_INFO
if((BabPtr_ != NULL) && (info.level >= 0) && (info.pass == 0) &&
(BabPtr_->model().getNodeCount() > lastPrintLine)) {
printLineInfo();
lastPrintLine += 1;
}
#endif
const int infeasible = 1;
int nInitCuts = cs.sizeRowCuts ();
CouNumber
*&realOpt = problem_ -> bestSol (),
*saveOptimum = realOpt;
if (!firstcall_ && realOpt) {
// have a debug optimal solution. Check if current bounds
// contain it, otherwise pretend it does not exist
CouNumber *opt = realOpt;
const CouNumber
*sol = si.getColSolution (),
*lb = si.getColLower (),
*ub = si.getColUpper ();
int objind = problem_ -> Obj (0) -> Body () -> Index ();
for (int j=0, i=problem_ -> nVars (); i--; j++, opt++, lb++, ub++)
if ((j != objind) &&
((*opt < *lb - COUENNE_EPS * (1 + CoinMin (fabs (*opt), fabs (*lb)))) ||
(*opt > *ub + COUENNE_EPS * (1 + CoinMin (fabs (*opt), fabs (*ub)))))) {
jnlst_ -> Printf (J_VECTOR, J_CONVEXIFYING,
"out of bounds, ignore x%d = %g [%g,%g] opt = %g\n",
problem_ -> nVars () - i - 1, *sol, *lb, *ub, *opt);
// optimal point is not in current bounding box,
// pretend realOpt is NULL until we return from this procedure
realOpt = NULL;
break;
}
}
/*static int count = 0;
char fname [20];
sprintf (fname, "relax_%d", count++);
si.writeLp (fname);
printf ("writing %s\n", fname);*/
jnlst_ -> Printf (J_DETAILED, J_CONVEXIFYING,
"generateCuts: level = %d, pass = %d, intree = %d\n",
info.level, info.pass, info.inTree);
Bonmin::BabInfo * babInfo = dynamic_cast <Bonmin::BabInfo *> (si.getAuxiliaryInfo ());
if (babInfo)
babInfo -> setFeasibleNode ();
double now = CoinCpuTime ();
int ncols = problem_ -> nVars ();
// This vector contains variables whose bounds have changed due to
// branching, reduced cost fixing, or bound tightening below. To be
// used with malloc/realloc/free
t_chg_bounds *chg_bds = new t_chg_bounds [ncols];
/*for (int i=0; i < ncols; i++)
if (problem_ -> Var (i) -> Multiplicity () <= 0) {
chg_bds [i].setLower (t_chg_bounds::UNCHANGED);
chg_bds [i].setUpper (t_chg_bounds::UNCHANGED);
}*/
problem_ -> installCutOff (); // install upper bound
if (firstcall_) {
// First convexification //////////////////////////////////////
// OsiSolverInterface is empty yet, no information can be obtained
// on variables or bounds -- and none is needed since our
// constructor populated *problem_ with variables and bounds. We
// only need to update the auxiliary variables and bounds with
// their current value.
for (int i=0; i < ncols; i++)
if (problem_ -> Var (i) -> Multiplicity () > 0) {
chg_bds [i].setLower (t_chg_bounds::CHANGED);
chg_bds [i].setUpper (t_chg_bounds::CHANGED);
}
// start with FBBT, should take advantage of cutoff found by NLP
// run AFTER initial FBBT...
if (problem_ -> doFBBT () &&
(! (problem_ -> boundTightening (chg_bds, babInfo))))
jnlst_ -> Printf (J_STRONGWARNING, J_CONVEXIFYING,
"Couenne: WARNING, first convexification is infeasible\n");
// For each auxiliary variable replacing the original (nonlinear)
// constraints, check if corresponding bounds are violated, and
// add cut to cs
int nnlc = problem_ -> nCons ();
for (int i=0; i<nnlc; i++) {
if (CoinCpuTime () > problem_ -> getMaxCpuTime ())
break;
// for each constraint
CouenneConstraint *con = problem_ -> Con (i);
// (which has an aux as its body)
int objindex = con -> Body () -> Index ();
if ((objindex >= 0) &&
((con -> Body () -> Type () == AUX) ||
(con -> Body () -> Type () == VAR))) {
// get the auxiliary that is at the lhs
exprVar *conaux = problem_ -> Var (objindex);
if (conaux &&
(conaux -> Type () == AUX) &&
(conaux -> Image ()) &&
(conaux -> Image () -> Linearity () <= LINEAR)) {
// reduce density of problem by adding w >= l rather than
// ax + b >= l for any linear auxiliary defined as w := ax+b
double
lb = (*(con -> Lb ())) (),
ub = (*(con -> Ub ())) ();
OsiColCut newBound;
if (lb > -COUENNE_INFINITY) newBound.setLbs (1, &objindex, &lb);
if (ub < COUENNE_INFINITY) newBound.setUbs (1, &objindex, &ub);
cs.insert (newBound);
// the auxiliary w of constraint w <= b is associated with a
// linear expression w = ax: add constraint ax <= b
/*conaux -> Image () -> generateCuts (conaux, si, cs, this, chg_bds,
conaux -> Index (),
(*(con -> Lb ())) (),
(*(con -> Ub ())) ());*/
// take it from the list of the variables to be linearized
//
// DO NOT decrease multiplicity. Even if it is a linear
// term, its bounds can still be used in implied bounds
//
// Are we sure? That will happen only if its multiplicity is
// nonzero, for otherwise this aux is only used here, and is
// useless elsewhere
//
//conaux -> decreaseMult (); // !!!
}
// also, add constraint w <= b
// not now, do it later
// // if there exists violation, add constraint
// CouNumber l = con -> Lb () -> Value (),
// u = con -> Ub () -> Value ();
// // tighten bounds in Couenne's problem representation
// problem_ -> Lb (index) = CoinMax (l, problem_ -> Lb (index));
// problem_ -> Ub (index) = CoinMin (u, problem_ -> Ub (index));
} else { // body is more than just a variable, but it should be
// linear. If so, generate equivalent linear cut
assert (false); // TODO
}
}
if (jnlst_ -> ProduceOutput (J_ITERSUMMARY, J_CONVEXIFYING)) {
if (cs.sizeRowCuts ()) {
jnlst_ -> Printf (J_ITERSUMMARY, J_CONVEXIFYING,"Couenne: %d constraint row cuts\n",
cs.sizeRowCuts ());
for (int i=0; i<cs.sizeRowCuts (); i++)
cs.rowCutPtr (i) -> print ();
}
if (cs.sizeColCuts ()) {
jnlst_ -> Printf (J_ITERSUMMARY, J_CONVEXIFYING,"Couenne: %d constraint col cuts\n",
cs.sizeColCuts ());
for (int i=0; i<cs.sizeColCuts (); i++)
cs.colCutPtr (i) -> print ();
}
}
} else {
// use new optimum as lower bound for variable associated w/objective
int indobj = problem_ -> Obj (0) -> Body () -> Index ();
// transmit solution from OsiSolverInterface to problem
problem_ -> domain () -> push (&si, &cs);
if (indobj >= 0) {
// Use current value of objvalue's x as a lower bound for bound
// tightening
double lp_bound = problem_ -> domain () -> x (indobj);
//if (problem_ -> Obj (0) -> Sense () == MINIMIZE)
{if (lp_bound > problem_ -> Lb (indobj)) problem_ -> Lb (indobj) = lp_bound;}
//else {if (lp_bound < problem_ -> Ub (indobj)) problem_ -> Ub (indobj) = lp_bound;}
}
updateBranchInfo (si, problem_, chg_bds, info); // info.depth >= 0 || info.pass >= 0
}
// restore constraint bounds before tightening and cut generation
for (int i = problem_ -> nCons (); i--;) {
// for each constraint
CouenneConstraint *con = problem_ -> Con (i);
// (which has an aux as its body)
int objindex = con -> Body () -> Index ();
if ((objindex >= 0) &&
((con -> Body () -> Type () == AUX) ||
(con -> Body () -> Type () == VAR))) {
// if there exists violation, add constraint
CouNumber
l = con -> Lb () -> Value (),
u = con -> Ub () -> Value ();
// tighten bounds in Couenne's problem representation
problem_ -> Lb (objindex) = CoinMax (l, problem_ -> Lb (objindex));
problem_ -> Ub (objindex) = CoinMin (u, problem_ -> Ub (objindex));
}
}
problem_ -> installCutOff (); // install upper bound
fictitiousBound (cs, problem_, false); // install finite lower bound, if currently -inf
int *changed = NULL, nchanged;
// Bound tightening ///////////////////////////////////////////
// do bound tightening only at first pass of cutting plane in a node
// of BB tree (info.pass == 0) or if first call (creation of RLT,
// info.pass == -1)
try {
// Before bound tightening, compute symmetry group. After bound
// tightening is done, we can apply further tightening using orbit
// information.
#ifdef COIN_HAS_NTY
// ChangeBounds (psi -> getColLower (),
// psi -> getColUpper (),
// psi -> getNumCols ());
if (problem_ -> orbitalBranching ())
problem_ -> Compute_Symmetry ();
#endif
// Bound tightening ////////////////////////////////////
/*printf ("== BT ================\n");
for (int i = 0; i < problem_ -> nVars (); i++)
if (problem_ -> Var (i) -> Multiplicity () > 0)
printf ("%4d %+20.8g [%+20.8g,%+20.8g]\n", i,
problem_ -> X (i), problem_ -> Lb (i), problem_ -> Ub (i));
printf("=============================\n");*/
// Reduced Cost BT -- to be done first to use rcost correctly
if (!firstcall_ && // have a linearization already
problem_ -> doRCBT () && // authorized to do reduced cost tightening
problem_ -> redCostBT (&si, chg_bds) && // some variables were tightened with reduced cost
!(problem_ -> btCore (chg_bds))) // in this case, do another round of FBBT
throw infeasible;
// FBBT
if (problem_ -> doFBBT () &&
//(info.pass <= 0) && // do it in subsequent rounds too
(! (problem_ -> boundTightening (chg_bds, babInfo))))
throw infeasible;
// OBBT
if (!firstcall_ && // no obbt if first call (there is no LP to work with)
problem_ -> obbt (this, si, cs, info, babInfo, chg_bds) < 0)
throw infeasible;
// Bound tightening done /////////////////////////////
if ((problem_ -> doFBBT () ||
problem_ -> doOBBT () ||
problem_ -> doABT ()) &&
(jnlst_ -> ProduceOutput (J_VECTOR, J_CONVEXIFYING))) {
jnlst_ -> Printf(J_VECTOR, J_CONVEXIFYING,"== after bt =============\n");
for (int i = 0; i < problem_ -> nVars (); i++)
if (problem_ -> Var (i) -> Multiplicity () > 0)
jnlst_->Printf(J_VECTOR, J_CONVEXIFYING,"%4d %+20.8g [%+20.8g,%+20.8g]\n", i,
problem_ -> X (i), problem_ -> Lb (i), problem_ -> Ub (i));
jnlst_->Printf(J_VECTOR, J_CONVEXIFYING,"=============================\n");
}
// Use orbit info to tighten bounds
#ifdef COIN_HAS_NTY
// TODO: when independent bound tightener, can get original bounds
// through si.getCol{Low,Upp}er()
if (problem_ -> orbitalBranching () && !firstcall_) {
CouNumber
*lb = problem_ -> Lb (),
*ub = problem_ -> Ub ();
std::vector<std::vector<int> > *new_orbits = problem_ -> getNtyInfo () -> getOrbits();
for (int i=0, ii = problem_ -> getNtyInfo () -> getNumOrbits (); ii--; i++){
CouNumber
ll = -COUENNE_INFINITY,
uu = COUENNE_INFINITY;
std::vector <int> orbit = (*new_orbits)[i];
if (orbit.size () <= 1)
continue; // not much to do when only one variable in this orbit
if (jnlst_ -> ProduceOutput (J_VECTOR, J_BOUNDTIGHTENING)) {
printf ("orbit bounds: "); fflush (stdout);
for(int j = 0; j < orbit.size (); j++) {
printf ("x_%d [%g,%g] ", orbit[j], lb [orbit [j]], ub [orbit [j]]);
fflush (stdout);
}
printf ("\n");
}
for (int j = 0; j < orbit.size (); j++) {
int indOrb = orbit [j];
if (indOrb < problem_ -> nVars ()) {
if (lb [indOrb] > ll) ll = lb [indOrb];
if (ub [indOrb] < uu) uu = ub [indOrb];
}
}
jnlst_ -> Printf (J_VECTOR, J_BOUNDTIGHTENING,
" --> new common lower bounds: [%g,--]\n", ll);
for(int j = 0; j < orbit.size (); j++) {
int indOrb = orbit [j];
if (indOrb < problem_ -> nVars ()){
lb [indOrb] = ll;
ub [indOrb] = uu;
}
}
}
delete new_orbits;
}
#endif
// Generate convexification cuts //////////////////////////////
sparse2dense (ncols, chg_bds, changed, nchanged);
double *nlpSol = NULL;
//--------------------------------------------
if (true) {
if (babInfo)
nlpSol = const_cast <double *> (babInfo -> nlpSolution ());
// Aggressive Bound Tightening ////////////////////////////////
int logAbtLev = problem_ -> logAbtLev ();
if (problem_ -> doABT () && // flag is checked, AND
((logAbtLev != 0) || // (parameter is nonzero OR
(info.level == 0)) && // we are at root node), AND
(info.pass == 0) && // at first round of cuts, AND
((logAbtLev < 0) || // (logAbtLev = -1, OR
(info.level <= logAbtLev) || // depth is lower than COU_OBBT_CUTOFF_LEVEL, OR
(CoinDrand48 () < // probability inversely proportional to the level)
pow (2., (double) logAbtLev - (info.level + 1))))) {
jnlst_ -> Printf(J_VECTOR, J_BOUNDTIGHTENING," performing ABT\n");
if (! (problem_ -> aggressiveBT (nlp_, chg_bds, info, babInfo)))
throw infeasible;
sparse2dense (ncols, chg_bds, changed, nchanged);
}
// obtain solution just found by nlp solver
// Auxiliaries should be correct. solution should be the one found
// at the node even if not as good as the best known.
// save violation flag and disregard it while adding cut at NLP
// point (which are not violated by the current, NLP, solution)
bool save_av = addviolated_;
addviolated_ = false;
// save values
problem_ -> domain () -> push
(problem_ -> nVars (),
problem_ -> domain () -> x (),
problem_ -> domain () -> lb (),
problem_ -> domain () -> ub (), false);
// fill originals with nlp values
if (nlpSol) {
CoinCopyN (nlpSol, problem_ -> nOrigVars (), problem_ -> domain () -> x ());
//problem_ -> initAuxs ();
problem_ -> getAuxs (problem_ -> domain () -> x ());
}
if (jnlst_ -> ProduceOutput (J_VECTOR, J_CONVEXIFYING)) {
jnlst_ -> Printf(J_VECTOR, J_CONVEXIFYING,"== genrowcuts on NLP =============\n");
for (int i = 0; i < problem_ -> nVars (); i++)
if (problem_ -> Var (i) -> Multiplicity () > 0)
jnlst_->Printf(J_VECTOR, J_CONVEXIFYING,"%4d %+20.8g [%+20.8g,%+20.8g]\n", i,
problem_ -> X (i),
problem_ -> Lb (i),
problem_ -> Ub (i));
jnlst_->Printf(J_VECTOR, J_CONVEXIFYING,"=============================\n");
}
problem_ -> domain () -> current () -> isNlp () = true;
genRowCuts (si, cs, nchanged, changed, chg_bds); // add cuts
problem_ -> domain () -> pop (); // restore point
addviolated_ = save_av; // restore previous value
// if (!firstcall_) // keep solution if called from extractLinearRelaxation()
if (babInfo)
babInfo -> setHasNlpSolution (false); // reset it after use //AW HERE
} else {
if (jnlst_ -> ProduceOutput (J_VECTOR, J_CONVEXIFYING)) {
jnlst_ -> Printf(J_VECTOR, J_CONVEXIFYING,"== genrowcuts on LP =============\n");
for (int i = 0; i < problem_ -> nVars (); i++)
if (problem_ -> Var (i) -> Multiplicity () > 0)
jnlst_->Printf(J_VECTOR, J_CONVEXIFYING,"%4d %+20.8g [%+20.8g,%+20.8g]\n", i,
problem_ -> X (i),
problem_ -> Lb (i),
problem_ -> Ub (i));
jnlst_->Printf(J_VECTOR, J_CONVEXIFYING,"=============================\n");
}
genRowCuts (si, cs, nchanged, changed, chg_bds);
}
// change tightened bounds through OsiCuts
if (nchanged)
genColCuts (si, cs, nchanged, changed);
if (firstcall_ && (cs.sizeRowCuts () >= 1))
jnlst_->Printf(J_ITERSUMMARY, J_CONVEXIFYING,
"Couenne: %d initial row cuts\n", cs.sizeRowCuts ());
if (realOpt && // this is a good time to check if we have cut the optimal solution
isOptimumCut (realOpt, cs, problem_))
jnlst_->Printf(J_ITERSUMMARY, J_CONVEXIFYING,
"Warning: Optimal solution was cut\n");
}
catch (int exception) {
if ((exception == infeasible) && (!firstcall_)) {
jnlst_ -> Printf (J_ITERSUMMARY, J_CONVEXIFYING,
"Couenne: Infeasible node\n");
WipeMakeInfeas (cs);
}
if (babInfo) // set infeasibility to true in order to skip NLP heuristic
babInfo -> setInfeasibleNode ();
}
delete [] chg_bds;
if (changed)
free (changed);
if (firstcall_) {
jnlst_ -> Printf (J_SUMMARY, J_CONVEXIFYING,
"Couenne: %d cuts (%d row, %d col) for linearization\n",
cs.sizeRowCuts () + cs.sizeColCuts (),
cs.sizeRowCuts (), cs.sizeColCuts ());
fictitiousBound (cs, problem_, true);
firstcall_ = false;
ntotalcuts_ = nrootcuts_ = cs.sizeRowCuts ();
} else {
problem_ -> domain () -> pop ();
ntotalcuts_ += (cs.sizeRowCuts () - nInitCuts);
if (saveOptimum)
realOpt = saveOptimum; // restore debug optimum
}
septime_ += CoinCpuTime () - now;
if (jnlst_ -> ProduceOutput (J_ITERSUMMARY, J_CONVEXIFYING)) {
if (cs.sizeColCuts ()) {
jnlst_ -> Printf (J_ITERSUMMARY, J_CONVEXIFYING,"Couenne col cuts:\n");
for (int i=0; i<cs.sizeColCuts (); i++)
cs.colCutPtr (i) -> print ();
}
}
if (!(info.inTree))
rootTime_ = CoinCpuTime ();
}
