// Create result
void OsiSolverResult::createResult(const OsiSolverInterface &solver, const double *lowerBefore,
const double *upperBefore)
{
delete[] primalSolution_;
delete[] dualSolution_;
if (solver.isProvenOptimal() && !solver.isDualObjectiveLimitReached()) {
objectiveValue_ = solver.getObjValue() * solver.getObjSense();
CoinWarmStartBasis *basis = dynamic_cast< CoinWarmStartBasis * >(solver.getWarmStart());
assert(basis);
basis_ = *basis;
int numberRows = basis_.getNumArtificial();
int numberColumns = basis_.getNumStructural();
assert(numberColumns == solver.getNumCols());
assert(numberRows == solver.getNumRows());
primalSolution_ = CoinCopyOfArray(solver.getColSolution(), numberColumns);
dualSolution_ = CoinCopyOfArray(solver.getRowPrice(), numberRows);
fixed_.addBranch(-1, numberColumns, lowerBefore, solver.getColLower(),
upperBefore, solver.getColUpper());
} else {
// infeasible
objectiveValue_ = COIN_DBL_MAX;
basis_ = CoinWarmStartBasis();
;
primalSolution_ = NULL;
dualSolution_ = NULL;
}
}
int main( int argc, char **argv )
{
if ( argc < 2 )
{
printf("Invalid number of parameters!\n");
exit( EXIT_FAILURE );
}
char problemName[ 256 ];
getFileName( problemName, argv[1] );
clock_t start = clock();
OsiClpSolverInterface *realSolver = new OsiClpSolverInterface();
realSolver->getModelPtr()->setPerturbation(50); /* makes CLP faster for hard instances */
OsiSolverInterface *solver = (OsiSolverInterface*) realSolver;
parseParameters( argc, argv );
readLP( solver, argv[1] );
FILE *log = NULL;
if(!output.empty())
{
log = fopen(output.c_str(), "a");
if(!log)
{
printf("Could not open the file!\n");
exit(EXIT_FAILURE);
}
}
const int numCols = solver->getNumCols(), numRows = solver->getNumRows();
int pass = 0, newCuts = 0, totalCuts = 0;
double pTime, opt, cgTime;
CGraph *cgraph = NULL;
if(sepMethod == Npsep)
cgraph = build_cgraph_osi( solver );
if(!optFile.empty())
{
getOptimals();
if(optimals.find(problemName) == optimals.end())
{
fprintf(stderr, "ERROR: optimal value not found!\n");
exit(EXIT_FAILURE);
}
opt = optimals[problemName];
}
solver->initialSolve();
if (!solver->isProvenOptimal())
{
if (solver->isAbandoned())
{
fprintf( stderr, "LP solver abandoned due to numerical dificulties.\n" );
exit( EXIT_FAILURE );
}
if (solver->isProvenPrimalInfeasible())
{
fprintf( stderr, "LP solver says PRIMAL INFEASIBLE.\n" );
exit( EXIT_FAILURE );
}
if (solver->isProvenDualInfeasible())
{
fprintf( stderr, "LP solver says DUAL INFEASIBLE.\n" );
exit( EXIT_FAILURE );
}
if (solver->isPrimalObjectiveLimitReached())
{
fprintf( stderr, "LP solver says isPrimalObjectiveLimitReached.\n" );
exit( EXIT_FAILURE );
}
if (solver->isDualObjectiveLimitReached())
{
fprintf( stderr, "LP solver says isDualObjectiveLimitReached.\n" );
exit( EXIT_FAILURE );
}
if (solver->isIterationLimitReached())
{
fprintf( stderr, "LP solver says isIterationLimitReached.\n" );
exit( EXIT_FAILURE );
}
fprintf( stderr, "ERROR: Could not solve LP relaxation to optimality. Checking status...\n" );
exit( EXIT_FAILURE );
}
double initialBound = solver->getObjValue();
printf("%.2lf %d %d %.7lf", ((double)(clock()-start)) / ((double)CLOCKS_PER_SEC), pass, 0, solver->getObjValue());
if(!optFile.empty())
{
printf(" %.7lf %.7lf", opt, abs_mip_gap(solver->getObjValue(), opt));
}
printf("\n");
do
{
clock_t startSep = clock();
newCuts = 0;
switch (sepMethod)
{
case Npsep:
{
CglEClique cliqueGen;
OsiCuts cuts;
CglTreeInfo info;
info.level = 0;
info.pass = 1;
vector<string> varNames = getVarNames(solver->getColNames(), numCols);
cliqueGen.parseParameters( argc, (const char**)argv );
cliqueGen.setCGraph( cgraph );
cliqueGen.setGenOddHoles( true ); //allow (or not) inserting odd hole cuts
cliqueGen.colNames = &varNames;
cliqueGen.generateCuts( *solver, cuts, info );
newCuts = cuts.sizeCuts();
solver->applyCuts( cuts );
}
break;
case CglSepM:
{
CglClique cliqueGen;
OsiCuts cuts;
CglTreeInfo info;
info.level = 0;
info.pass = 1;
cliqueGen.setMinViolation( MIN_VIOLATION );
cliqueGen.setStarCliqueReport(false);
cliqueGen.setRowCliqueReport(false);
cliqueGen.generateCuts( *solver, cuts, info );
newCuts = cuts.sizeCuts();
solver->applyCuts( cuts );
}
break;
Default:
{
fprintf( stderr, "Separation Method does not recognized!\n" );
exit( EXIT_FAILURE );
}
}
pTime = ((double)(clock()-start)) / ((double)CLOCKS_PER_SEC);
if(pTime > MAX_TIME) break;
totalCuts += newCuts;
++pass;
if (newCuts)
{
solver->resolve();
if (!solver->isProvenOptimal())
{
if (solver->isAbandoned())
{
fprintf( stderr, "LP solver abandoned due to numerical dificulties.\n" );
exit( EXIT_FAILURE );
}
if (solver->isProvenPrimalInfeasible())
{
fprintf( stderr, "LP solver says PRIMAL INFEASIBLE.\n" );
exit( EXIT_FAILURE );
}
if (solver->isProvenDualInfeasible())
{
fprintf( stderr, "LP solver says DUAL INFEASIBLE.\n" );
exit( EXIT_FAILURE );
}
if (solver->isPrimalObjectiveLimitReached())
{
fprintf( stderr, "LP solver says isPrimalObjectiveLimitReached.\n" );
exit( EXIT_FAILURE );
}
if (solver->isDualObjectiveLimitReached())
{
fprintf( stderr, "LP solver says isDualObjectiveLimitReached.\n" );
exit( EXIT_FAILURE );
}
if (solver->isIterationLimitReached())
{
fprintf( stderr, "LP solver says isIterationLimitReached.\n" );
exit( EXIT_FAILURE );
}
fprintf( stderr, "ERROR: Could not solve LP relaxation. Exiting.\n" );
exit( EXIT_FAILURE );
}
pTime = ((double)(clock()-start)) / ((double)CLOCKS_PER_SEC);
if(pTime > MAX_TIME) break;
double sepTime = ((double)(clock()-startSep)) / ((double)CLOCKS_PER_SEC);
printf("%.2lf %d %d %.7lf", sepTime, pass, newCuts, solver->getObjValue());
if(!optFile.empty())
printf(" %.7lf %.7lf", opt, abs_mip_gap(solver->getObjValue(), opt));
printf("\n");
}
}
while ( (newCuts>0) && (pass<MAX_PASSES) ) ;
if(log)
{
double totalTime = ((double)(clock()-start)) / ((double)CLOCKS_PER_SEC);
fprintf(log, "%s %.2lf %d %d %.7lf", problemName, totalTime, pass - 1, totalCuts, solver->getObjValue());
if(!optFile.empty())
fprintf(log, " %.7lf", abs_mip_gap(solver->getObjValue(), opt));
fprintf(log, "\n");
}
if(cgraph)
cgraph_free( &cgraph );
delete realSolver;
return EXIT_SUCCESS;
}
TNLPSolver::ReturnStatus LpBranchingSolver::
solveFromHotStart(OsiTMINLPInterface* tminlp_interface)
{
TNLPSolver::ReturnStatus retstatus = TNLPSolver::solvedOptimal;
// updated the bounds of the linear solver
std::vector<int> diff_low_bnd_index;
std::vector<double> diff_low_bnd_value;
std::vector<int> diff_up_bnd_index;
std::vector<double> diff_up_bnd_value;
// Get the bounds. We assume that the bounds in the linear solver
// are always the original ones
const int numCols = tminlp_interface->getNumCols();
const double* colLow_orig = lin_->getColLower();
const double* colUp_orig = lin_->getColUpper();
const double* colLow = tminlp_interface->getColLower();
const double* colUp = tminlp_interface->getColUpper();
OsiSolverInterface * lin = lin_;
// eventualy clone lin_
if(warm_start_mode_ == Clone){
lin = lin_->clone();
// std::cout<<"Cloning it"<<std::endl;
}
// Set the bounds on the LP solver according to the changes in
// tminlp_interface
for (int i=0; i<numCols; i++) {
const double& lo = colLow[i];
if (colLow_orig[i] < lo) {
if(warm_start_mode_ == Basis){
diff_low_bnd_value.push_back(colLow_orig[i]);
diff_low_bnd_index.push_back(i);
}
lin->setColLower(i,lo);
}
const double& up = colUp[i];
if (colUp_orig[i] > up) {
if(warm_start_mode_ == Basis){
diff_up_bnd_index.push_back(i);
diff_up_bnd_value.push_back(colUp_orig[i]);
}
lin->setColUpper(i,lo);
}
}
if(warm_start_mode_ == Basis){
lin->setWarmStart(warm_);
}
lin->resolve();
double obj = lin->getObjValue();
bool go_on = true;
if (lin->isProvenPrimalInfeasible() ||
lin->isDualObjectiveLimitReached()) {
retstatus = TNLPSolver::provenInfeasible;
go_on = false;
}
else if (lin->isIterationLimitReached()) {
retstatus = TNLPSolver::iterationLimit;
go_on = false;
}
else {
if (maxCuttingPlaneIterations_ > 0 && go_on) {
double violation;
obj = ecp_->doEcpRounds(*lin, true, &violation);
if (obj == COIN_DBL_MAX) {
retstatus = TNLPSolver::provenInfeasible;
}
else if (violation <= 1e-8) {
retstatus = TNLPSolver::solvedOptimal;
}
}
}
tminlp_interface->problem()->set_obj_value(obj);
tminlp_interface->problem()->Set_x_sol(numCols, lin_->getColSolution());
//restore the original bounds
if(warm_start_mode_ == Basis){
for (unsigned int i = 0; i < diff_low_bnd_index.size(); i++) {
lin_->setColLower(diff_low_bnd_index[i],diff_low_bnd_value[i]);
}
for (unsigned int i = 0; i < diff_up_bnd_index.size(); i++) {
lin_->setColUpper(diff_up_bnd_index[i],diff_up_bnd_value[i]);
}
}
else {
delete lin;
}
return retstatus;
}
/// OaDecomposition method
double
OaFeasibilityChecker::performOa(OsiCuts & cs, solverManip &lpManip,
BabInfo * babInfo, double &cutoff,const CglTreeInfo & info) const
{
bool isInteger = true;
bool feasible = 1;
OsiSolverInterface * lp = lpManip.si();
OsiBranchingInformation branch_info(lp,false);
//int numcols = lp->getNumCols();
double milpBound = -COIN_DBL_MAX;
int numberPasses = 0;
double * nlpSol = NULL;
int numberCutsBefore = cs.sizeRowCuts();
while (isInteger && feasible ) {
numberPasses++;
//setup the nlp
//Fix the variable which have to be fixed, after having saved the bounds
double * colsol = const_cast<double *>(lp->getColSolution());
branch_info.solution_ = colsol;
fixIntegers(*nlp_,branch_info, parameters_.cbcIntegerTolerance_,objects_, nObjects_);
//Now solve the NLP get the cuts, and intall them in the local LP
nlp_->resolve(txt_id);
if (post_nlp_solve(babInfo, cutoff)) {
//nlp solved and feasible
// Update the cutoff
double ub = nlp_->getObjValue();
cutoff = ub > 0 ? ub *(1 - parameters_.cbcCutoffIncrement_) : ub*(1 + parameters_.cbcCutoffIncrement_);
// Update the lp solver cutoff
lp->setDblParam(OsiDualObjectiveLimit, cutoff);
}
// Get the cuts outer approximation at the current point
nlpSol = const_cast<double *>(nlp_->getColSolution());
const double * toCut = (parameter().addOnlyViolated_)?
colsol:NULL;
if(cut_count_ <= maximum_oa_cuts_ && type_ == OA)
nlp_->getOuterApproximation(cs, nlpSol, 1, toCut,
true);
else {//if (type_ == Benders)
nlp_->getBendersCut(cs, parameter().global_);
}
if(pol_ == DetectCycles)
nlp_->getBendersCut(savedCuts_, parameter().global_);
int numberCuts = cs.sizeRowCuts() - numberCutsBefore;
cut_count_ += numberCuts;
if (numberCuts > 0)
installCuts(*lp, cs, numberCuts);
lp->resolve();
double objvalue = lp->getObjValue();
//milpBound = max(milpBound, lp->getObjValue());
feasible = (lp->isProvenOptimal() &&
!lp->isDualObjectiveLimitReached() && (objvalue<cutoff)) ;
//if value of integers are unchanged then we have to get out
bool changed = true;//if lp is infeasible we don't have to check anything
isInteger = 0;
// if(!fixed)//fathom on bounds
// milpBound = 1e200;
if (feasible) {
changed = isDifferentOnIntegers(*nlp_, objects_, nObjects_,
0.1,
nlp_->getColSolution(), lp->getColSolution());
}
if (changed) {
branch_info.solution_ = lp->getColSolution();
isInteger = integerFeasible(*lp,branch_info, parameters_.cbcIntegerTolerance_,
objects_, nObjects_);
}
else {
isInteger = 0;
// if(!fixed)//fathom on bounds
milpBound = 1e200;
}
#ifdef OA_DEBUG
printf("Obj value after cuts %g, %d rows\n",lp->getObjValue(),
numberCuts) ;
#endif
}
int num_cuts_now = cs.sizeRowCuts();
if(pol_ == KeepAll){
for(int i = numberCutsBefore ; i < num_cuts_now ; i++){
cs.rowCut(i).setEffectiveness(99.9e99);
}
}
#ifdef OA_DEBUG
debug_.printEndOfProcedureDebugMessage(cs, true, cutoff, milpBound, isInteger, feasible, std::cout);
std::cout<<"milpBound found: "<<milpBound<<std::endl;
#endif
return milpBound;
}
// mex function usage:
// [x,y,status] = mexosi(n_vars,n_cons,A,x_lb,x_ub,c,Ax_lb,Ax_ub,isMIP,isQP,vartype,Q,options)
// 0 1 2 3 4 5 6 7 8 9 10 11 12
void mexFunction(int nlhs, mxArray *plhs[],int nrhs, const mxArray *prhs[])
{
// Enable printing in MATLAB
int loglevel = 0;
DerivedHandler *mexprinter = new DerivedHandler(); // assumed open
mexprinter->setLogLevel(loglevel);
// check that we have the right number of inputs
if(nrhs < 10) mexErrMsgTxt("At least 10 inputs required in call to mexosi. Bug in osi.m?...");
// check that we have the right number of outputs
if(nlhs < 3) mexErrMsgTxt("At least 3 ouptuts required in call to mexosi. Bug in osi.m?...");
// Get pointers to input values
const int n_vars = (int)*mxGetPr(prhs[0]);
const int n_cons = (int)*mxGetPr(prhs[1]);
const mxArray *A = prhs[2];
const double *x_lb = mxGetPr(prhs[3]);
const double *x_ub = mxGetPr(prhs[4]);
const double *c = mxGetPr(prhs[5]);
const double *Ax_lb = mxGetPr(prhs[6]);
const double *Ax_ub = mxGetPr(prhs[7]);
const bool isMIP = (bool)*(mxLogical*)mxGetData(prhs[8]);
const bool isQP = (bool)*(mxLogical*)mxGetData(prhs[9]);
mxLogical *isinteger = (mxLogical*)mxGetData(prhs[10]);
const mxArray* Q = prhs[11];
// process the options
int returnStatus = 0;
// extract row/col/value data from A
const mwIndex * A_col_starts = mxGetJc(A);
const mwIndex * A_row_index = mxGetIr(A);
const double * A_data = mxGetPr(A);
// figure out the number of non-zeros in A
int nnz = (int)(A_col_starts[n_vars] - A_col_starts[0]); // number of non-zeros
//mexPrintf("nnz = %d, n_vars = %d, n_cons = %d\n",nnz,n_vars,n_cons);
// we need to convert these into other types of indices for Coin to use them
std::vector<CoinBigIndex> A_col_starts_coin(A_col_starts,A_col_starts+n_vars+1);
std::vector<int> A_row_index_coin(A_row_index,A_row_index+nnz);
// declare the solver
OsiSolverInterface* pSolver;
// initialize the solver
if ( isMIP ) {
pSolver = new OsiCbcSolverInterface;
} else {
pSolver = new OsiClpSolverInterface;
}
// OsiCbcSolverInterface is deprecated and CbcModel should be used instead but don't
// know how to get that working with loadProblem.
// OsiCbcSolverInterface solver1;
// CbcModel model(solver1);
// CbcMain0(model);
// OsiSolverInterface * pSolver = model.solver();
if (nrhs>12) { // get stuff out of the options structure if provided
// Finish me
}
// mexPrintf("Setting Log Level to 0.\n");
// load the problem
mexPrintf("Loading the problem.\n");
pSolver->loadProblem( n_vars, n_cons, // problem size
&A_col_starts_coin[0], &A_row_index_coin[0], A_data, // the A matrix
x_lb, x_ub, c, // the objective and bounds
Ax_lb, Ax_ub ); // the constraint bounds
// pSolver->messageHandler()->setLogLevel(0); // This doesn't seem to work
pSolver->setHintParam(OsiDoReducePrint,true,OsiHintTry);
// deal with integer inputs
if ( isMIP ) {
for(int i=0;i<n_vars;i++) {
if (isinteger[i]) pSolver->setInteger(i);
}
}
if (isQP) {
error("QP is not working yet");
// need to call loadQuadraticObjective here ???
}
// CbcModel model(pSolver);
// model.solver()->setHintParam(OsiDoReducePrint,true,OsiHintTry);
// solve the problem
//mexPrintf("Trying to solve the problem.\n");
if (isMIP) {
pSolver->branchAndBound();
// model.branchAndBound();
} else {
// model.initialSolve();
pSolver->initialSolve();
}
// Allocate memory for return data
plhs[0] = mxCreateDoubleMatrix(n_vars,1, mxREAL); // for the solution
plhs[1] = mxCreateDoubleMatrix(n_cons,1, mxREAL); // for the constraint prices
plhs[2] = mxCreateDoubleMatrix(1,1, mxREAL); // for the return status
double *x = mxGetPr(plhs[0]);
double *y = mxGetPr(plhs[1]);
double *returncode = mxGetPr(plhs[2]);
// Copy solutions if available
if ( pSolver->isProvenOptimal() ) {
// if ( model.isProvenOptimal() ) {
// if ( model.solver()->isProvenOptimal() ) {
//mexPrintf("Solution found.\n");
// extract the solutions
const double * solution = pSolver->getColSolution();
const double * dualvars = pSolver->getRowPrice();
// copy the solution to the outpus
memcpy(x,solution,n_vars*sizeof(double));
memcpy(y,dualvars,n_cons*sizeof(double));
*returncode = 1;
} else {
if ( pSolver->isProvenPrimalInfeasible() ) {
mexPrintf("Primal problem is proven infeasible.\n");
*returncode = 0;
} else if ( pSolver->isProvenDualInfeasible() ) {
mexPrintf("Dual problem is proven infeasible.\n");
*returncode = -1;
} else if ( pSolver->isPrimalObjectiveLimitReached() ) {
mexPrintf("The primal objective limit was reached.\n");
*returncode = -2;
} else if ( pSolver->isDualObjectiveLimitReached() ) {
mexPrintf("The dual objective limit was reached.\n");
*returncode = -3;
} else if ( pSolver->isIterationLimitReached() ) {
mexPrintf("The iteration limit was reached\n");
*returncode = -4;
}
}
// clean up memory
if ( mexprinter!= NULL) delete mexprinter;
delete pSolver;
}
//Solver function
int sci_rmps(char *fname)
{
//creating a problem pointer using base class of OsiSolverInterface and
//instantiate the object using derived class of ClpSolverInterface
OsiSolverInterface* si = new OsiClpSolverInterface();
// Error management variable
SciErr sciErr;
//data declarations
int *piAddressVarOne = NULL; //pointer used to access argument of the function
char* ptr; //pointer to point to address of file name
double* options_; //options to set maximum iterations
CheckInputArgument(pvApiCtx, 2,2 ); //Check we have exactly two arguments as input or not
CheckOutputArgument(pvApiCtx, 6, 6); //Check we have exactly six arguments on output side or not
//Getting the input arguments from Scilab
//Getting the MPS file path
//Reading mps file
getStringFromScilab(1,&ptr);
std::cout<<ptr;
//get options from Scilab
if(getFixedSizeDoubleMatrixInList(2 , 2 , 1 , 1 , &options_))
{
return 1;
}
//Read the MPS file
si->readMps(ptr);
//setting options for maximum iterations
si->setIntParam(OsiMaxNumIteration,options_[0]);
//Solve the problem
si->initialSolve();
//Quering about the problem
//get number of variables
double numVars_;
numVars_ = si->getNumCols();
//get number of constraint equations
double numCons_;
numCons_ = si->getNumRows();
//Output the solution to Scilab
//get solution for x
const double* xValue = si->getColSolution();
//get objective value
double objValue = si->getObjValue();
//get Status value
double status;
if(si->isProvenOptimal())
status=0;
else if(si->isProvenPrimalInfeasible())
status=1;
else if(si->isProvenDualInfeasible())
status=2;
else if(si->isIterationLimitReached())
status=3;
else if(si->isAbandoned())
status=4;
else if(si->isPrimalObjectiveLimitReached())
status=5;
else if(si->isDualObjectiveLimitReached())
status=6;
//get number of iterations
double iterations = si->getIterationCount();
//get reduced cost
const double* reducedCost = si->getReducedCost();
//get dual vector
const double* dual = si->getRowPrice();
returnDoubleMatrixToScilab(1 , 1 , numVars_ , xValue);
returnDoubleMatrixToScilab(2 , 1 , 1 , &objValue);
returnDoubleMatrixToScilab(3 , 1 , 1 , &status);
returnDoubleMatrixToScilab(4 , 1 , 1 , &iterations);
returnDoubleMatrixToScilab(5 , 1 , numVars_ , reducedCost);
returnDoubleMatrixToScilab(6 , 1 , numCons_ , dual);
free(xValue);
free(dual);
free(reducedCost);
}
BlisReturnStatus
BlisStrongBranch(BlisModel *model, double objValue, int colInd, double x,
const double *saveLower, const double *saveUpper,
bool &downKeep, bool &downFinished, double &downDeg,
bool &upKeep, bool &upFinished, double &upDeg)
{
BlisReturnStatus status = BlisReturnStatusOk;
int lpStatus = 0;
int j, numIntInfDown, numObjInfDown;
double newObjValue;
OsiSolverInterface * solver = model->solver();
int numCols = solver->getNumCols();
const double * lower = solver->getColLower();
const double * upper = solver->getColUpper();
// Restore bounds
int numDiff = 0;
BlisSolution* ksol = NULL;
int ind = model->getIntObjIndices()[colInd];
BlisObjectInt *intObj = dynamic_cast<BlisObjectInt *>(model->objects(ind));
#ifdef BLIS_DEBUG_MORE
for (j = 0; j < numCols; ++j) {
if (saveLower[j] != lower[j]) {
//solver->setColLower(j, saveLower[j]);
++numDiff;
}
if (saveUpper[j] != upper[j]) {
//solver->setColUpper(j, saveUpper[j]);
++numDiff;
}
}
std::cout << "BEFORE: numDiff = " << numDiff << std::endl;
#endif
//------------------------------------------------------
// Branching down.
//------------------------------------------------------
solver->setColUpper(colInd, floor(x));
solver->solveFromHotStart();
newObjValue = solver->getObjSense() * solver->getObjValue();
downDeg = newObjValue - objValue;
if (solver->isProvenOptimal()) {
lpStatus = 0; // optimal
#ifdef BLIS_DEBUG_MORE
printf("STRONG: COL[%d]: downDeg=%g, x=%g\n", colInd, downDeg, x);
#endif
// Update pseudocost
intObj->pseudocost().update(-1, downDeg, x);
model->setSharedObjectMark(ind);
// Check if ip feasible
ksol = model->feasibleSolution(numIntInfDown, numObjInfDown);
if (ksol) {
#ifdef BLIS_DEBUG_MORE
printf("STRONG:Down:found a feasible solution\n");
#endif
model->storeSolution(BlisSolutionTypeStrong, ksol);
downKeep = false;
}
else {
downKeep = true;
}
downFinished = true;
}
else if (solver->isIterationLimitReached() &&
!solver->isDualObjectiveLimitReached()) {
lpStatus = 2; // unknown
downKeep = true;
downFinished = false;
}
else {
downDeg = 1.0e20;
lpStatus = 1; // infeasible
downKeep = false;
downFinished = false;
}
#ifdef BLIS_DEBUG_MORE
std::cout << "Down: lpStatus = " << lpStatus << std::endl;
#endif
// restore bounds
numDiff = 0;
for (j = 0; j < numCols; ++j) {
if (saveLower[j] != lower[j]) {
solver->setColLower(j, saveLower[j]);
++numDiff;
}
if (saveUpper[j] != upper[j]) {
solver->setColUpper(j, saveUpper[j]);
++numDiff;
}
}
#ifdef BLIS_DEBUG
assert(numDiff > 0);
//std::cout << "numDiff = " << numDiff << std::endl;
#endif
//----------------------------------------------
// Branching up.
//----------------------------------------------
solver->setColLower(colInd, ceil(x));
solver->solveFromHotStart();
newObjValue = solver->getObjSense() * solver->getObjValue();
upDeg = newObjValue - objValue;
if (solver->isProvenOptimal()) {
lpStatus = 0; // optimal
#ifdef BLIS_DEBUG_MORE
printf("STRONG: COL[%d]: upDeg=%g, x=%g\n", colInd, upDeg, x);
#endif
// Update pseudocost
intObj->pseudocost().update(1, upDeg, x);
model->setSharedObjectMark(ind);
// Check if IP feasible
ksol = model->feasibleSolution(numIntInfDown, numObjInfDown);
if (ksol) {
#ifdef BLIS_DEBUG_MORE
printf("STRONG:Up:found a feasible solution\n");
#endif
model->storeSolution(BlisSolutionTypeStrong, ksol);
upKeep = false;
}
else {
upKeep = true;
}
upFinished = true;
}
else if (solver->isIterationLimitReached()
&&!solver->isDualObjectiveLimitReached()) {
lpStatus = 2; // unknown
upKeep = true;
upFinished = false;
}
else {
lpStatus = 1; // infeasible
upKeep = false;
upFinished = false;
upDeg = 1.0e20;
}
#ifdef BLIS_DEBUG_MORE
std::cout << "STRONG: Up: lpStatus = " << lpStatus << std::endl;
#endif
// restore bounds
for (j = 0; j < numCols; ++j) {
if (saveLower[j] != lower[j]) {
solver->setColLower(j,saveLower[j]);
}
if (saveUpper[j] != upper[j]) {
solver->setColUpper(j,saveUpper[j]);
}
}
return status;
}
