void AMPLOsiUT::setUp()
{
EnvPtr env = (EnvPtr) new Environment();
env->setLogLevel(LogNone);
iface_ = (MINOTAUR_AMPL::AMPLInterfacePtr) new AMPLInterface(env);
engine_ptr_ = (OsiLPEnginePtr) new OsiLPEngine(env);
}
void setInitialOptions(EnvPtr env)
{
env->getOptions()->findBool("presolve")->setValue(true);
env->getOptions()->findBool("use_native_cgraph")->setValue(true);
env->getOptions()->findBool("nl_presolve")->setValue(true);
env->getOptions()->findBool("separability")->setValue(false);
env->getOptions()->findBool("perspective")->setValue(false);
}
MultilinearTermsHandler::MultilinearTermsHandler(EnvPtr env, ProblemPtr problem)
: env_(env), problem_(problem)
{
logger_ = env->getLogger();
eTol_ = env->getOptions()->findDouble("ml_feastol")->getValue();
maxGroupSize_ = (UInt) env_->getOptions()->findInt("ml_max_group_size")->getValue();
augmentCoverFactor_ = env_->getOptions()->findDouble("ml_cover_augmentation_factor")->getValue();
initialTermCoverSize_ = 0;
}
ExprPtr Sym::eval()
{
EnvPtr env = get_current_env();
ExprPtr value = env->value_of(static_pointer_cast<Sym>(shared_from_this()));
if (value == nullptr) {
ostringstream oss;
oss << "void variable " << m_name;
throw Error(oss.str());
}
return value;
}
RandomBrancher::RandomBrancher(EnvPtr env, HandlerVector handlers)
{
logger_ = env->getLogger();
timer_ = env->getNewTimer();
stats_ = new RandomBrStats();
stats_->calls = 0;
stats_->time = 0.0;
handlers_ = handlers;
seed_ = env->getOptions()->findInt("rand_seed")->getValue();
if (seed_ == 0) {
srand(time(NULL));
} else {
srand(seed_);
}
}
ParQGHandler::ParQGHandler(EnvPtr env, ProblemPtr minlp, EnginePtr nlpe)
: env_(env),
minlp_(minlp),
nlCons_(0),
nlpe_(nlpe),
nlpStatus_(EngineUnknownStatus),
objVar_(VariablePtr()),
oNl_(false),
rel_(RelaxationPtr()),
relobj_(0.0)
{
intTol_ = env_->getOptions()->findDouble("int_tol")->getValue();
solAbsTol_ = env_->getOptions()->findDouble("feasAbs_tol")->getValue();
solRelTol_ = env_->getOptions()->findDouble("feasRel_tol")->getValue();
npATol_ = env_->getOptions()->findDouble("solAbs_tol")->getValue();
npRTol_ = env_->getOptions()->findDouble("solRel_tol")->getValue();
logger_ = env->getLogger();
stats_ = new ParQGStats();
stats_->nlpS = 0;
stats_->nlpF = 0;
stats_->nlpI = 0;
stats_->nlpIL = 0;
stats_->cuts = 0;
}
void writeSol(EnvPtr env, VarVector *orig_v,
PresolverPtr pres, SolutionPtr sol, SolveStatus status,
MINOTAUR_AMPL::AMPLInterface* iface)
{
if (sol) {
sol = pres->getPostSol(sol);
}
if (env->getOptions()->findFlag("AMPL")->getValue() ||
true == env->getOptions()->findBool("write_sol_file")->getValue()) {
iface->writeSolution(sol, status);
} else if (sol && env->getLogger()->getMaxLevel()>=LogExtraInfo &&
env->getOptions()->findBool("display_solution")->getValue()) {
sol->writePrimal(env->getLogger()->msgStream(LogExtraInfo), orig_v);
}
}
SOS1Handler::SOS1Handler(EnvPtr env, ProblemPtr problem)
: env_(env)
{
logger_ = env->getLogger();
modProb_ = true;
modRel_ = true;
zTol_ = 1e-6;
problem_ = problem;
}
IpoptEngine::IpoptEngine(EnvPtr env)
: bndChanged_(false),
consChanged_(false),
env_(env),
etol_(1e-7),
myapp_(0),
mynlp_(0),
sol_(IpoptSolPtr()), // NULL
strBr_(false),
timer_(0),
ws_(IpoptWarmStartPtr()) // NULL
{
#if defined(USE_IPOPT)
problem_ = ProblemPtr(); // NULL
logger_ = (LoggerPtr) new Logger((LogLevel) env->getOptions()->
findInt("engine_log_level")->getValue());
myapp_ = new Ipopt::IpoptApplication();
setOptionsForRepeatedSolve();
status_ = EngineError;
if (env->getOptions()->findBool("use_warmstart")->getValue()==true) {
prepareWs_ = true;
useWs_ = true;
} else {
prepareWs_ = false;
useWs_ = false;
}
timer_ = env->getNewTimer();
stats_ = new IpoptStats();
stats_->calls = 0;
stats_->strCalls = 0;
stats_->time = 0;
stats_->ptime = 0;
stats_->strTime = 0;
stats_->iters = 0;
stats_->strIters = 0;
#else
assert(!"ipopt engine can only be called when compiled with ipopt!")
#endif
}
void AMPLOsiUT::testOsiBnB()
{
EnvPtr env = (EnvPtr) new Environment();
char file_name[] = "instances/milp";
HandlerVector handlers;
ReliabilityBrancherPtr br;
EnginePtr e;
int err = 0;
env->startTimer(err);
ProblemPtr p = iface_->readInstance(file_name);
BranchAndBound *bab = new BranchAndBound(env, p);
IntVarHandlerPtr v_hand = (IntVarHandlerPtr) new IntVarHandler(env, p);
LinearHandlerPtr l_hand = (LinearHandlerPtr) new LinearHandler(env, p);
handlers.push_back(v_hand);
handlers.push_back(l_hand);
v_hand->setModFlags(false, true);
l_hand->setModFlags(false, true);
EngineFactory efac(env);
e = efac.getLPEngine();
PCBProcessorPtr nproc = (PCBProcessorPtr) new PCBProcessor(env, e, handlers);
br= (ReliabilityBrancherPtr) new ReliabilityBrancher(env, handlers);
br->setEngine(e);
nproc->setBrancher(br);
bab->setNodeProcessor(nproc);
NodeIncRelaxerPtr nr = (NodeIncRelaxerPtr) new NodeIncRelaxer(env, handlers);
bab->setNodeRelaxer(nr);
nr->setEngine(e);
nr->setModFlag(false);
p->setNativeDer();
bab->shouldCreateRoot(true);
bab->setLogLevel(LogNone);
bab->solve();
CPPUNIT_ASSERT(bab->getUb() == 1.0);
delete bab;
}
Transformer::Transformer(EnvPtr env, ConstProblemPtr p)
: env_(env),
p_(p),
yLfs_(0),
yUniExprs_(0),
yVars_(0),
zTol_(1e-12)
{
logger_ = (LoggerPtr) new Logger((LogLevel)(env->getOptions()
->findInt("trans_log_level")
->getValue()));
}
void loadProblem(EnvPtr env, MINOTAUR_AMPL::AMPLInterface* iface,
ProblemPtr &oinst, double *obj_sense)
{
Timer *timer = env->getNewTimer();
OptionDBPtr options = env->getOptions();
JacobianPtr jac;
HessianOfLagPtr hess;
const std::string me("qg: ");
timer->start();
oinst = iface->readInstance(options->findString("problem_file")->getValue());
env->getLogger()->msgStream(LogInfo) << me
<< "time used in reading instance = " << std::fixed
<< std::setprecision(2) << timer->query() << std::endl;
// display the problem
oinst->calculateSize();
if (options->findBool("display_problem")->getValue()==true) {
oinst->write(env->getLogger()->msgStream(LogNone), 12);
}
if (options->findBool("display_size")->getValue()==true) {
oinst->writeSize(env->getLogger()->msgStream(LogNone));
}
// create the jacobian
if (false==options->findBool("use_native_cgraph")->getValue()) {
jac = (MINOTAUR_AMPL::AMPLJacobianPtr)
new MINOTAUR_AMPL::AMPLJacobian(iface);
oinst->setJacobian(jac);
// create the hessian
hess = (MINOTAUR_AMPL::AMPLHessianPtr)
new MINOTAUR_AMPL::AMPLHessian(iface);
oinst->setHessian(hess);
}
// set initial point
oinst->setInitialPoint(iface->getInitialPoint(),
oinst->getNumVars()-iface->getNumDefs());
if (oinst->getObjective() &&
oinst->getObjective()->getObjectiveType()==Maximize) {
*obj_sense = -1.0;
env->getLogger()->msgStream(LogInfo) << me
<< "objective sense: maximize (will be converted to Minimize)"
<< std::endl;
} else {
*obj_sense = 1.0;
env->getLogger()->msgStream(LogInfo) << me
<< "objective sense: minimize" << std::endl;
}
delete timer;
}
PresolverPtr presolve(EnvPtr env, ProblemPtr p, size_t ndefs,
HandlerVector &handlers)
{
PresolverPtr pres = PresolverPtr(); // NULL
const std::string me("qg: ");
p->calculateSize();
if (env->getOptions()->findBool("presolve")->getValue() == true) {
LinearHandlerPtr lhandler = (LinearHandlerPtr) new LinearHandler(env, p);
handlers.push_back(lhandler);
if (p->isQP() || p->isQuadratic() || p->isLinear() ||
true==env->getOptions()->findBool("use_native_cgraph")->getValue()) {
lhandler->setPreOptPurgeVars(true);
lhandler->setPreOptPurgeCons(true);
lhandler->setPreOptCoeffImp(true);
} else {
lhandler->setPreOptPurgeVars(false);
lhandler->setPreOptPurgeCons(false);
lhandler->setPreOptCoeffImp(false);
}
if (ndefs>0) {
lhandler->setPreOptDualFix(false);
} else {
lhandler->setPreOptDualFix(true);
}
if (!p->isLinear() &&
true==env->getOptions()->findBool("use_native_cgraph")->getValue() &&
true==env->getOptions()->findBool("nl_presolve")->getValue()
) {
NlPresHandlerPtr nlhand = (NlPresHandlerPtr) new NlPresHandler(env, p);
handlers.push_back(nlhand);
}
// write the names.
env->getLogger()->msgStream(LogExtraInfo) << me
<< "handlers used in presolve:" << std::endl;
for (HandlerIterator h = handlers.begin(); h != handlers.end();
++h) {
env->getLogger()->msgStream(LogExtraInfo) << me
<< (*h)->getName() << std::endl;
}
}
pres = (PresolverPtr) new Presolver(p, env, handlers);
pres->standardize();
if (env->getOptions()->findBool("presolve")->getValue() == true) {
pres->solve();
}
return pres;
}
//For separability detection: Check separability if problem is not linear.
//TransSepPtr sepDetection(EnvPtr env, ProblemPtr p)
void sepDetection(EnvPtr env, ProblemPtr p)
{
TransSepPtr sep = TransSepPtr();
const std::string me("PDEqg: ");
if (env->getOptions()->findBool("separability")->getValue() == true) {
if (p -> isLinear()) {
env ->getLogger()->msgStream(LogInfo) << me
<< "Problem is linear, skipping separability detection"
<< std::endl;
} else {
sep = (TransSepPtr) new TransSep(env, p);
sep->findSep();
env ->getLogger()->msgStream(LogDebug) << me
<< "Is problem separable? - "<< sep->getStatus()
<< std::endl;
}
}
}
int showInfo(EnvPtr env)
{
OptionDBPtr options = env->getOptions();
const std::string me("qg: ");
if (options->findBool("display_options")->getValue() ||
options->findFlag("=")->getValue()) {
options->write(std::cout);
return 1;
}
if (options->findBool("display_help")->getValue() ||
options->findFlag("?")->getValue()) {
showHelp();
return 1;
}
if (options->findBool("display_version")->getValue() ||
options->findFlag("v")->getValue()) {
env->getLogger()->msgStream(LogNone) << me <<
"Minotaur version " << env->getVersion() << std::endl;
env->getLogger()->msgStream(LogNone) << me
<< "Quesada-Grossmann (LP/NLP) algorithm for convex MINLP" << std::endl;
return 1;
}
if (options->findString("problem_file")->getValue()=="") {
showHelp();
return 1;
}
env->getLogger()->msgStream(LogInfo)
<< me << "Minotaur version " << env->getVersion() << std::endl
<< me << "Quesada-Grossmann (LP/NLP) algorithm for convex MINLP"
<< std::endl;
return 0;
}
void writeBnbStatus(EnvPtr env, BranchAndBound *bab, double obj_sense)
{
const std::string me("qg: ");
int err = 0;
if (bab) {
env->getLogger()->msgStream(LogInfo)
<< me << std::fixed << std::setprecision(4)
<< "best solution value = " << obj_sense*bab->getUb() << std::endl
<< me << std::fixed << std::setprecision(4)
<< "best bound estimate from remaining nodes = "
<< obj_sense*bab->getLb() << std::endl
<< me << "gap = " << std::max(0.0,bab->getUb() - bab->getLb())
<< std::endl
<< me << "gap percentage = " << bab->getPerGap() << std::endl
<< me << "time used (s) = " << std::fixed << std::setprecision(2)
<< env->getTime(err) << std::endl
<< me << "status of branch-and-bound: "
<< getSolveStatusString(bab->getStatus()) << std::endl;
env->stopTimer(err); assert(0==err);
} else {
env->getLogger()->msgStream(LogInfo)
<< me << std::fixed << std::setprecision(4)
<< "best solution value = " << INFINITY << std::endl
<< me << std::fixed << std::setprecision(4)
<< "best bound estimate from remaining nodes = " << INFINITY << std::endl
<< me << "gap = " << INFINITY << std::endl
<< me << "gap percentage = " << INFINITY << std::endl
<< me << "time used (s) = " << std::fixed << std::setprecision(2)
<< env->getTime(err) << std::endl
<< me << "status of branch-and-bound: "
<< getSolveStatusString(NotStarted) << std::endl;
env->stopTimer(err); assert(0==err);
}
}
int main(int argc, char* argv[])
{
EnvPtr env = (EnvPtr) new Environment();
OptionDBPtr options;
MINOTAUR_AMPL::AMPLInterfacePtr iface = MINOTAUR_AMPL::AMPLInterfacePtr();
ProblemPtr inst;
SolutionPtr sol, sol2;
double obj_sense =1.0;
// jacobian is read from AMPL interface and passed on to branch-and-bound
JacobianPtr jPtr;
// hessian is read from AMPL interface and passed on to branch-and-bound
MINOTAUR_AMPL::AMPLHessianPtr hPtr;
// the branch-and-bound
BranchAndBound *bab = 0;
PresolverPtr pres;
EngineFactory *efac;
const std::string me("qg: ");
BrancherPtr br = BrancherPtr(); // NULL
PCBProcessorPtr nproc;
NodeIncRelaxerPtr nr;
//handlers
HandlerVector handlers;
IntVarHandlerPtr vHand;
LinearHandlerPtr lHand;
QGAdvHandlerPtr qgHand;
RCHandlerPtr rcHand;
//engines
EnginePtr nlp_e;
EnginePtr proj_nlp_e;
EnginePtr l1proj_nlp_e;
LPEnginePtr lin_e; // lp engine
LoggerPtr logger_ = (LoggerPtr) new Logger(LogInfo);
VarVector *orig_v=0;
int err = 0;
// start timing.
env->startTimer(err);
if (err) {
goto CLEANUP;
}
setInitialOptions(env);
iface = (MINOTAUR_AMPL::AMPLInterfacePtr)
new MINOTAUR_AMPL::AMPLInterface(env, "qg");
// parse options
env->readOptions(argc, argv);
options = env->getOptions();
options->findString("interface_type")->setValue("AMPL");
if (0!=showInfo(env)) {
goto CLEANUP;
}
loadProblem(env, iface, inst, &obj_sense);
// Initialize engines
nlp_e = getNLPEngine(env, inst); //Engine for Original problem
efac = new EngineFactory(env);
lin_e = efac->getLPEngine(); // lp engine
delete efac;
// get presolver.
orig_v = new VarVector(inst->varsBegin(), inst->varsEnd());
pres = presolve(env, inst, iface->getNumDefs(), handlers);
handlers.clear();
if (Finished != pres->getStatus() && NotStarted != pres->getStatus()) {
env->getLogger()->msgStream(LogInfo) << me
<< "status of presolve: "
<< getSolveStatusString(pres->getStatus()) << std::endl;
writeSol(env, orig_v, pres, SolutionPtr(), pres->getStatus(), iface);
writeBnbStatus(env, bab, obj_sense);
goto CLEANUP;
}
if (options->findBool("solve")->getValue()==true) {
if (true==options->findBool("use_native_cgraph")->getValue()) {
inst->setNativeDer();
}
// Initialize the handlers for branch-and-cut
lHand = (LinearHandlerPtr) new LinearHandler(env, inst);
lHand->setModFlags(false, true);
handlers.push_back(lHand);
assert(lHand);
vHand = (IntVarHandlerPtr) new IntVarHandler(env, inst);
vHand->setModFlags(false, true);
handlers.push_back(vHand);
assert(vHand);
// Use of perspective handler is user choice
if (env->getOptions()->findBool("perspective")->getValue() == true) {
PerspCutHandlerPtr pcHand = (PerspCutHandlerPtr) new
PerspCutHandler(env, inst);
pcHand->findPRCons();
if (pcHand->getStatus()) {
qgHand = (QGAdvHandlerPtr) new QGAdvHandler(env, inst, nlp_e, pcHand);
} else {
qgHand = (QGAdvHandlerPtr) new QGAdvHandler(env, inst, nlp_e);
}
} else {
qgHand = (QGAdvHandlerPtr) new QGAdvHandler(env, inst, nlp_e);
}
qgHand->setModFlags(false, true);
handlers.push_back(qgHand);
assert(qgHand);
if (options->findBool("rc_fix")->getValue()) {
rcHand = (RCHandlerPtr) new RCHandler(env);
rcHand->setModFlags(false, true);
handlers.push_back(rcHand);
assert(rcHand);
}
// report name
env->getLogger()->msgStream(LogExtraInfo) << me << "handlers used:"
<< std::endl;
for (HandlerIterator h = handlers.begin(); h != handlers.end(); ++h) {
env->getLogger()->msgStream(LogExtraInfo) << me << (*h)->getName()
<< std::endl;
}
// Only store bound-changes of relaxation (not problem)
nr = (NodeIncRelaxerPtr) new NodeIncRelaxer(env, handlers);
nr->setModFlag(false);
nr->setEngine(lin_e);
nproc = (PCBProcessorPtr) new PCBProcessor(env, lin_e, handlers);
if (env->getOptions()->findString("brancher")->getValue() == "rel") {
ReliabilityBrancherPtr rel_br =
(ReliabilityBrancherPtr) new ReliabilityBrancher(env, handlers);
rel_br->setEngine(lin_e);
nproc->setBrancher(rel_br);
br = rel_br;
} else if (env->getOptions()->findString("brancher")->getValue()
== "maxvio") {
MaxVioBrancherPtr mbr = (MaxVioBrancherPtr)
new MaxVioBrancher(env, handlers);
nproc->setBrancher(mbr);
br = mbr;
} else if (env->getOptions()->findString("brancher")->getValue()
== "lex") {
LexicoBrancherPtr lbr = (LexicoBrancherPtr)
new LexicoBrancher(env, handlers);
br = lbr;
}
nproc->setBrancher(br);
env->getLogger()->msgStream(LogExtraInfo) << me <<
"brancher used = " << br->getName() << std::endl;
bab = new BranchAndBound(env, inst);
bab->setNodeRelaxer(nr);
bab->setNodeProcessor(nproc);
bab->shouldCreateRoot(true);
// start solving
bab->solve();
bab->writeStats(env->getLogger()->msgStream(LogExtraInfo));
//bab->writeStats(std::cout);
nlp_e->writeStats(env->getLogger()->msgStream(LogExtraInfo));
lin_e->writeStats(env->getLogger()->msgStream(LogExtraInfo));
for (HandlerVector::iterator it=handlers.begin(); it!=handlers.end();
++it) {
//(*it)->writeStats(std::cout);
(*it)->writeStats(env->getLogger()->msgStream(LogExtraInfo));
}
writeSol(env, orig_v, pres, bab->getSolution(), bab->getStatus(), iface);
writeBnbStatus(env, bab, obj_sense);
}
CLEANUP:
if (iface) {
delete iface;
}
if (orig_v) {
delete orig_v;
}
if (bab) {
delete bab;
}
return 0;
}
int main()
{
// Generate output.
ofstream output;
output.open("numknapcov.txt");
// Generate input.
ifstream input;
input.open("list.txt");
// Check if input is opened succesfully.
if (input.is_open() == false) {
cerr << "Input file read error." << endl;
output << "Input file read error." << endl;
exit(0);
}
/********************************************************************************/
// Headers for output data.
output << "Statistics of knapsack cover cuts applied to root relaxation." << endl;
output << "problem " << "vars " << "cons " << "lincons " << "knapcons " << "knapcov "
<< "knaps " << "totalcuts " << "cuts " << "violknapcuts " << "initobj "
<< "endobj " << "gapclosed " << "timeinit " << "timecut " << "timemod"
<< endl;
/********************************************************************************/
// loop to test all problems in list.txt
while (input.good()) {
// problem name
string pname;
getline(input, pname);
// At the end of file just exit from loop.
if (pname.empty()) {
break;
}
cout << "Problem considered is: " << pname << endl;
// Real stuff begins.
// Ampl interface, jacobian and hessian.
MINOTAUR_AMPL::AMPLInterfacePtr iface = MINOTAUR_AMPL::AMPLInterfacePtr();
JacobianPtr jPtr; //! Jacobian read from AMPL
HessianOfLagPtr hPtr; //! Hessian read from AMPL
// environment, timers and options:
EnvPtr env = (EnvPtr) new Environment();
OptionDBPtr options;
// problem to be solved.
ProblemPtr minlp;
// solver pointers, including status.
FilterSQPEngine e(env);
EngineStatus status;
// Presolver.
PresolverPtr pres;
// give parameters.
UInt argc2 = 2;
std::string arg1 = "bnb";
std::string arg2 = pname;
char** argv2 = new char* [2];
argv2[0] = &arg1[0];
argv2[1] = &arg2[0];
// Default options
env->getOptions()->findBool("presolve")->setValue(false);
env->getOptions()->findBool("use_native_cgraph")->setValue(true);
env->getOptions()->findBool("nl_presolve")->setValue(false);
// parse options
env->readOptions(argc2, argv2);
options = env->getOptions();
options->findString("interface_type")->setValue("AMPL");
// read minlp from AMPL.
iface = (MINOTAUR_AMPL::AMPLInterfacePtr) new MINOTAUR_AMPL::AMPLInterface(env);
minlp = iface->readInstance(pname);
// Timer is obtained.
Timer * timer = env->getNewTimer();
// Nonlinearize objective function.
Bool MIPCONSIDERED = false;
if (MIPCONSIDERED == true) {
ObjectivePtr initobjfun = minlp->getObjective();
if (initobjfun->getObjectiveType() == Maximize) {
cerr << "Objective type is Maximize, change it to Minimize." << endl;
exit(0);
}
LinearFunctionPtr lfinitobj = initobjfun->getLinearFunction();
// NonlinearFunctionPtr nlfobj = (NonlinearFunctionPtr) new NonlinearFunction();
CGraphPtr nlfobj = (CGraphPtr) new CGraph();
logobj(lfinitobj, nlfobj);
FunctionPtr logobjfun = (FunctionPtr) new Function(nlfobj);
ObjectiveType otyp = Minimize;
minlp->changeObj(logobjfun, 0);
}
minlp->calculateSize();
minlp->prepareForSolve();
// Change format of problem to be suitable for Minotaur.
HandlerVector handlers;
// Use presolver to standardize problem.
//pres = (PresolverPtr) new Presolver(minlp, env, handlers);
//pres->standardize();
minlp->calculateSize();
minlp->prepareForSolve();
minlp->setJacobian(jPtr);
minlp->setHessian(hPtr);
minlp->setNativeDer();
minlp->calculateSize();
minlp->prepareForSolve();
minlp->setNativeDer();
//minlp->write(std::cout);
/**************************************************************/
// Given problem statistics .
// Number of variables.
UInt numvars = minlp->getNumVars();
// number of constraints.
UInt numcons = minlp->getNumCons();
// linear constraints.
UInt numlin = minlp->getNumLinCons();
/*************************************************************/
// set option for engine to resolve to solve NLP repeatedly.
// Probbaly does nothing.
e.setOptionsForRepeatedSolve();
// load problem.
e.load(minlp);
// Solve problem.
timer->start();
status = e.solve();
/********************************************************************/
// Solution time of relaxation.
Double timeinit = timer->query();
timer->stop();
// Solution objective value
Double initobj = e.getSolutionValue();
/********************************************************************/
std::cout << "Relaxation objective value = " << initobj << std::endl;
// Get solution from engine.
ConstSolutionPtr sol = e.getSolution();
// Construct relaxation.
RelaxationPtr rel = (RelaxationPtr) new Relaxation(minlp);
// Time for cut generation.
timer->start();
// Generate kanpsack cover cuts.
CoverCutGeneratorPtr knapgen =
(CoverCutGeneratorPtr) new CoverCutGenerator(rel, sol, env);
/*******************************************************************/
Double timecut = timer->query();
timer->stop();
/*******************************************************************/
// Get statistics of cut generator.
ConstCovCutGenStatsPtr knapstats = knapgen->getStats();
/*******************************************************************/
// Knapsack cut generator statistics.
// knapsack constraints.
UInt numknap = (knapgen->getKnapsackList())->getNumKnaps();
// knapsacks that has cover sets.
UInt numknapcov = knapgen->getNumCons();
// knapsack subproblems solved, i.e number of lifting subproblems solved.
UInt knaps = knapstats->knaps;
// cover cuts including duplicates.
UInt totalcuts = knapstats->totalcuts;
// cuts without duplicates.
UInt numknapcuts = knapstats->cuts;
// violated cuts.
UInt violknapcuts = knapstats->violated;
/*******************************************************************/
std::cout << "Number of knapsack cover cuts to be applied is: "
<< knapstats->violated << std::endl;
// Get the violated cuts from generator.
CutVector knapcuts = knapgen->getViolatedCutList();
// Iterators for cuts
CutVectorConstIter it;
CutVectorConstIter begin = knapcuts.begin();
CutVectorConstIter end = knapcuts.end();
// Apply the cuts to the problem.
// Violation list.
DoubleVector knapviols = knapgen->getViolList();
UInt curknap = 0;
Double maxviol = 0.0;
for (it=begin; it!=end; ++it) {
std::cout << "Violation obtained from this constraint is: "
<< knapviols[curknap] << std::endl;
ConstraintPtr newcons = rel->newConstraint((*it)->getFunction(), (*it)->getLb(), (*it)->getUb());
if (maxviol < knapviols[curknap]) {
maxviol = knapviols[curknap];
}
// add constraint to engine does not do anything.
// Thus, we add constraint to the relaxation and reload it to engine.
// e.addConstraint(newcons);
}
/*******************************************************************/
// Solution time of knapsack cover cuts added problem.
Double timemod = 0.0;
// Objective value after adding knapsack cover cuts.
Double endobj = 0.0;
// Gap closed by using knapsack cover cuts.
Double gapknap = 0.0;
/*******************************************************************/
if (violknapcuts >= 1) {
// Reload problem to engine.
// Check if we should reload the modified problem.
e.clear();
const Double * xupdated;
if (WARMSTART == 1) {
// Set initial point as the solution of root solution.
xupdated = sol->getPrimal();
rel->setInitialPoint(xupdated);
}
// Load the modified problem.
e.load(rel);
// warmstart continues.
if (WARMSTART == 1) {
// Before presolve, we set initial primal and
// dual solutions as the root solution.
SolutionPtr solupdated = (SolutionPtr) new Solution(initobj, xupdated, rel);
// Create new dual solution.
const Double * dualofvars = sol->getDualOfVars();
solupdated->setDualOfVars(dualofvars);
const Double * initdualofcons = sol->getDualOfCons();
UInt numconsupdated = rel->getNumCons();
Double * dualofcons = new Double[numconsupdated];
memcpy(dualofcons, initdualofcons, numcons*sizeof(Double));
for (UInt indexx = numcons; indexx < numconsupdated; ++indexx) {
dualofcons[indexx] = 0.0;
}
solupdated->setDualOfCons(dualofcons);
FilterWSPtr warmstart = (FilterWSPtr) new FilterSQPWarmStart();
warmstart->setPoint(solupdated);
e.loadFromWarmStart(warmstart);
delete [] dualofcons;
}
// Solution time after adding knapsack cover cuts to relaxation.
timer->start();
// Resolve the problem.
e.solve();
/*******************************************************************/
// Solution time of knapsack cover cuts added problem.
timemod = timer->query();
timer->stop();
// Objective value after adding knapsack cover cuts.
endobj = e.getSolutionValue();
// Gap closed by using knapsack cover cuts.
gapknap = (endobj-initobj)/fabs(initobj) * 100;
/*******************************************************************/
} else {
/*******************************************************************/
// Solution time of knapsack cover cuts added problem.
timemod = timeinit;
// Objective value after adding knapsack cover cuts.
endobj = initobj;
// Gap closed by using knapsack cover cuts.
gapknap = 0.0;
/*******************************************************************/
}
std::cout << "Objective value of relaxation after adding cuts: "
<< endobj << std::endl;
cout << pname << " " << numvars << " " << numcons << " " << numlin
<< " " << numknap
<< " " << numknapcov << " " << knaps << " " << totalcuts
<< " " << numknapcuts << " " << violknapcuts
<< std::fixed << std::setprecision(2)
<< " " << initobj << " " << endobj
<< " " << gapknap << " " << timeinit << " " << timecut
<< " " << timemod << endl;
if (numknap >= 1) {
// Save output data.
output << pname << " " << numvars << " " << numcons << " " << numlin
<< " " << numknap
<< " " << numknapcov << " " << knaps << " " << totalcuts
<< " " << numknapcuts << " " << violknapcuts
<< std::fixed << std::setprecision(2)
<< " " << initobj << " " << endobj
<< " " << gapknap << " " << timeinit << " " << timecut
<< " " << timemod << endl;
}
delete iface;
delete [] argv2;
}
output.close();
input.close();
return 0;
}
EnvPtr Env::InitializeGlobalEnv()
{
EnvPtr global = make_shared<Env>();
global->AddProcedure("+", [] (const List& lst) -> LispData {
auto summator = [] (const LispData& a, const DataPtr b) -> LispData {
if (a.GetType() == integer_type && b->GetType() == integer_type) {
return LispData(a.GetInt() + b->GetInt());
}
else {
return LispData(a.GetFloat() + b->GetFloat());
}
};
return accumulate(begin(lst), end(lst), LispData(0L), summator);
});
global->AddProcedure("-", [] (const List& lst) -> LispData {
if (lst.size() != 2) {
throw WrongArity("-");
}
LispData a = *lst.front();
LispData b = *lst.back();
if (a.GetType() == integer_type && b.GetType() == integer_type) {
return LispData(a.GetInt() - b.GetInt());
}
else {
return LispData(a.GetFloat() - b.GetFloat());
}
});
global->AddProcedure("*", [] (const List& lst) -> LispData {
auto multiplicator = [] (const LispData& a, const DataPtr b) -> LispData {
if (a.GetType() == integer_type && b->GetType() == integer_type) {
return LispData(a.GetInt() * b->GetInt());
}
else {
return LispData(a.GetFloat() * b->GetFloat());
}
};
return accumulate(begin(lst), end(lst), LispData(1), multiplicator);
});
global->AddProcedure("/", [] (const List& lst) -> LispData {
if (lst.size() != 2) {
throw WrongArity("/");
}
LispData a = *lst.front();
LispData b = *lst.back();
if (fabs(b.GetFloat()) < 1e-15) {
throw runtime_error("Zero division");
}
if (a.GetType() == integer_type && b.GetType() == integer_type) {
return LispData(a.GetInt() / b.GetInt());
}
else {
return LispData(a.GetFloat() / b.GetFloat());
}
});
global->AddProcedure("=", [] (const List& lst) -> LispData {
if (lst.size() != 2) {
throw WrongArity("=");
}
LispData a = *lst.front();
LispData b = *lst.back();
return LispData(a.GetFloat() == b.GetFloat());
});
global->AddProcedure("cons", [] (const List& lst) -> LispData {
if (lst.size() != 2) {
throw WrongArity("cons");
}
return LispData(lst);
});
global->AddProcedure("car", [] (const List& lst) -> LispData {
if (lst.size() != 1) {
throw WrongArity("car");
}
if (lst.front()->GetType() != list_type) {
throw runtime_error("Not pair type given to 'car'.");
}
return LispData(*lst.front()->GetListRef()->front());
});
global->AddProcedure("cdr", [] (const List& lst) -> LispData {
if (lst.size() != 1) {
throw WrongArity("cdr");
}
auto pair = lst.front();
if (pair->GetType() != list_type || pair->GetListRef()->size() != 2) {
throw runtime_error("Not pair type given to 'cdr'.");
}
return LispData(*pair->GetListRef()->back());
});
global->AddProcedure("null?", [] (const List& lst) -> LispData {
if (lst.size() != 1) {
throw WrongArity("null?");
}
auto pair = lst.front();
if (pair->GetType() != list_type) {
throw runtime_error("Not pair type given to 'null?'.");
}
return LispData(pair->GetListRef()->empty());
});
(*global)["nil"] = LispData(List());
global->AddProcedure("exit", [] (const List&) -> LispData {
exit(0);
});
return global;
}
//! main routine implementing outer approximation
int main(int argc, char** argv)
{
//! Declaration of Variables ============================================
//! interface to AMPL (NULL):
MINOTAUR_AMPL::AMPLInterfacePtr iface = MINOTAUR_AMPL::AMPLInterfacePtr();
MINOTAUR_AMPL::JacobianPtr jPtr; //! Jacobian read from AMPL
MINOTAUR_AMPL::HessianOfLagPtr hPtr; //! Hessian read from AMPL
//! environment, timers, options:
EnvPtr env = (EnvPtr) new Environment();
TimerFactory *tFactory = new TimerFactory();
Timer *timer=tFactory->getTimer();
OptionDBPtr options; //! AMPL and MINOTAUR options
//! problem pointers (MINLP, NLP, MILP):
ProblemPtr minlp; //! MINLP instance to be solved
ProblemPtr milp; //! MILP master problem
//! solver pointers, including status
FilterSQPEngine e(env); //! NLP engine: FilterSQP
EngineStatus status;
//! pointers to manipulate variables & constraints
VariablePtr v, objVar; //! variable pointer (objective)
ObjectivePtr objFun; //! remember objective function pt.
//! local variables
Double *x, *xsoln;
Double *lobnd, *upbnd;
Double objfLo = -INFINITY, objfUp = INFINITY, objfNLP, objfMIP;
Double tol = 1E-2;
Int feasibleNLP = 0, iterOA = 1, n;
// ======================================================================
//! start the timer
timer->start();
//! make sure solver is used correctly
if (argc < 2) {
usage();
return -1;
}
//! add AMPL options & flags to environment: flags (options without values)
options = env->getOptions();
add_ampl_flags(options);
env->readOptions(argc, argv); //! parse options
if (!checkUserOK(options,env)) goto CLEANUP; //! check if user needs help
//! read MINLP from AMPL & create Hessian/Jacobian for NLP solves
iface = (MINOTAUR_AMPL::AMPLInterfacePtr) new MINOTAUR_AMPL::AMPLInterface(env);
minlp = iface->readInstance(options->findString("problem_file")->getValue(),false);
jPtr = (MINOTAUR_AMPL::JacobianPtr) new MINOTAUR_AMPL::Jacobian(iface);
hPtr = (MINOTAUR_AMPL::HessianOfLagPtr) new MINOTAUR_AMPL::HessianOfLag(iface);
minlp->setJacobian(jPtr);
minlp->setHessian(hPtr);
//! Display number of constraints and variables, and MINLP problem
minlp->calculateSize();
n = minlp->getNumVars();
std::cout << "No. of vars, cons = " << minlp->getNumVars()
<< minlp->getNumCons() << std::endl;
std::cout << std::endl << "The MINLP problem is: " << std::endl;
minlp->write(std::cout);
//! load the MINLP into the NLP solver (FilterSQP)
e.load(minlp);
//! get initial point & save original bounds
x = new Double[n];
xsoln = new Double[n];
lobnd = new Double[n];
upbnd = new Double[n];
std::copy(iface->getInitialPoint(),iface->getInitialPoint()+n,x);
for (VariableConstIterator i=minlp->varsBegin(); i!=minlp->varsEnd(); ++i) {
v = *i;
lobnd[v->getId()] = v->getLb();
upbnd[v->getId()] = v->getUb();
}
//! initialize the MILP master problem by copying variables & linear c/s
milp = (ProblemPtr) new Problem();
objFun = minlp->getObjective();
objVar = VariablePtr();
initMaster(minlp, milp, objVar, objFun, x);
while ((objfLo <= objfUp)&&(iterOA<4)){
std::cout << "Iteration " << iterOA << std::endl
<< "===============" << std::endl << std::endl;
//! set-up and solve NLP(y) with fixed integers
solveNLP(minlp, e, x, objfNLP, feasibleNLP, n);
std::cout << "Solved NLP " << iterOA << " objective = " << objfNLP
<< " NLPfeasible = " << feasibleNLP << std::endl;
if (feasibleNLP && (objfNLP-tol < objfUp)) {
objfUp = objfNLP - tol;
std::copy(x,x+n,xsoln);
}
//! update MILP master problem by adding outer approximations
updateMaster(minlp, milp, objVar, objFun, objfUp, x, n);
//! solve MILP master problem
solveMaster(env, milp, x, &objfMIP, n);
objfLo = objfMIP;
iterOA = iterOA + 1;
} // end while (objfLo <= objfUp)
//! output final result & timing
std::cout << std::endl << "END outer-approximation: f(x) = " << objfUp
<< " time used = " << timer->query() << std::endl;
CLEANUP:
//! free storage
delete timer;
delete tFactory;
if (minlp) {
minlp->clear();
delete [] x;
delete [] xsoln;
delete [] lobnd;
delete [] upbnd;
}
if (milp) {
milp->clear();
}
return 0;
} // end outer approximation main
