int SolverFormulacaoPadrao::Populate(const PopulateOptions& options,
PopulateStatus* output_status) {
lp_->setRepeatPresolve(0);
lp_->setRepairFrequency(-1);
lp_->setAdvance(OPT_FALSE);
lp_->setPopulateLimit(options.num_max_solutions());
lp_->setSolPoolGap(options.gap());
lp_->setSolPoolReplace(options.replace_mode());
lp_->setSolPoolIntensity(options.intensity());
if (options.max_time() > 0)
lp_->setTimeLimit(options.max_time());
if (options.cut_off_value() < Globals::Infinity())
lp_->setMIPCutOff(options.cut_off_value() - 1);
int status = lp_->populate();
LOG(INFO) << "status: " << status << ", num: " << lp_->getSolPoolNumSols() << ", avg: "
<< lp_->getSolPoolMeanObjVal() << ", replaced: " << lp_->getSolPoolNumReplacedSols();
if (output_status != NULL) {
output_status->status = status;
output_status->gap_absolute = GetGapAbsolute();
output_status->gap_relative = GetGapRelative();
output_status->mean_objective_value = lp_->getSolPoolMeanObjVal();
output_status->num_replaced_sols = lp_->getSolPoolNumSols();
if (status == OPTSTAT_FEASIBLE || status == OPTSTAT_MIPOPTIMAL) {
// First adds the incumbent
GenerateSolution(&output_status->final_sol);
output_status->solution_set.push_back(output_status->final_sol);
// Adds all the solution pool
vector<double> x(lp_->getNumCols());
for (int i = 0; i < lp_->getSolPoolNumSols(); ++i) {
lp_->getSolPoolX(i, &x[0]);
output_status->solution_set.push_back(ProblemSolution(Globals::instance()));
GenerateSolution(
x, lp_, &vHash_, &cHash_,
&output_status->solution_set[output_status->solution_set.size() - 1]);
if (output_status->solution_set[output_status->solution_set.size() - 1] ==
output_status->solution_set[0])
output_status->solution_set.pop_back();
}
}
}
return status;
}
int PerformKMeans(TRAININGSET *pTS, CODEBOOK *pCB, PARTITIONING *pP,
int clus, int repeats, int InitMethod,
int quietLevel, int useInitial)
{
PARTITIONING Pnew, Pinit;
CODEBOOK CBnew, CBinit;
llong distance[BookSize(pTS)];
llong distanceInit[BookSize(pTS)];
double totalTime, error, currError;
int i, better, iter, totalIter;
SetClock(&totalTime);
totalIter = 0;
currError = error = 0;
if ((clus < 1) || (BookSize(pTS) < clus) || (repeats < 1))
{
return 1; /* clustering failed */
}
InitializeSolutions(pTS, pCB, pP, &CBnew, &Pnew, &CBinit, &Pinit,
distanceInit, clus, useInitial);
PrintHeader(quietLevel);
/* perform repeats time full K-means */
for (i = 0; i < repeats; i++)
{
better = iter = 0;
GenerateSolution(pTS, &CBnew, &Pnew, &CBinit, &Pinit, distance,
distanceInit, InitMethod, useInitial);
KMeansIterate(pTS, &CBnew, &Pnew, distance, quietLevel, i, &iter,
&totalTime, &error, useInitial);
totalIter += iter;
/* got better result */
if ((i == 0) || (error < currError))
{
CopyCodebook(&CBnew, pCB);
CopyPartitioning(&Pnew, pP);
currError = error;
better = 1;
}
PrintRepeat(quietLevel, repeats, i, iter, error, GetClock(totalTime), better);
}
PrintFooterKM(quietLevel, currError, repeats, GetClock(totalTime), totalIter);
FreeCodebook(&CBnew);
FreePartitioning(&Pnew);
FreeCodebook(&CBinit);
FreePartitioning(&Pinit);
return 0;
} /* PerformKmeans() */
int SolverFormulacaoPadrao::Solve(const SolverOptions& options,
SolverStatus* output_status) {
int status = SolveTLAndUB(options.max_time(), options.cut_off_value(),
options.only_first_solution());
if (output_status != NULL) {
output_status->status = status;
output_status->gap_absolute = GetGapAbsolute();
output_status->gap_relative = GetGapRelative();
if (status == OPTSTAT_FEASIBLE || status == OPTSTAT_MIPOPTIMAL)
GenerateSolution(&output_status->final_sol);
}
return status;
}
/* static */ OPTSTAT SolverFormulacaoPadrao::GetFirstIntegerSolution(
const ProblemData& p,
ProblemSolution* sol) {
OPT_CPLEX* lp = new OPT_CPLEX;
VariableFormulacaoPadraoHash vHash;
ConstraintFormulacaoPadraoHash cHash;
lp->createLP("FormulacaoPadraoFirstInteger", OPTSENSE_MINIMIZE, PROB_MIP);
CreateVarTaskAssignment(p, OPT_COL::VAR_BINARY, &vHash, lp);
CreateConsMachineCapacity(p, &vHash, &cHash, lp);
CreateConsOneMachinePerTask(p, &vHash, &cHash, lp);
lp->setNumIntSols(1);
lp->optimize(METHOD_MIP);
vector<double> x(lp->getNumCols());
lp->getX(&x[0]);
GenerateSolution(x, lp, &vHash, &cHash, sol);
OPTSTAT status = lp->getStat();
delete lp;
return status;
}
/* static */ OPTSTAT SolverFormulacaoPadrao::GetIntegerSolutionWithTimeLimit(
const ProblemData& p,
int time_limit,
ProblemSolution* sol) {
OPT_CPLEX* lp = new OPT_CPLEX;
VariableFormulacaoPadraoHash vHash;
ConstraintFormulacaoPadraoHash cHash;
lp->createLP("FormulacaoPadraoFirstInteger", OPTSENSE_MINIMIZE, PROB_MIP);
CreateVarTaskAssignment(p, OPT_COL::VAR_BINARY, &vHash, lp);
CreateConsMachineCapacity(p, &vHash, &cHash, lp);
CreateConsOneMachinePerTask(p, &vHash, &cHash, lp);
lp->setMIPScreenLog(Globals::SolverLog());
// Maximum 1.5 gigs, store the rest on disk (uncompressed).
lp->setWorkMem(1100);
lp->setTreLim(1500);
lp->setNodeFileInd(2);
lp->setParallelMode(-1);
if (time_limit > 0)
lp->setTimeLimit(time_limit);
lp->optimize(METHOD_MIP);
if (lp->getStat() == OPTSTAT_INFEASIBLE || lp->getStat() == OPTSTAT_NOINTEGER) {
lp->setNumIntSols(1);
lp->optimize(METHOD_MIP);
}
vector<double> x(lp->getNumCols());
lp->getX(&x[0]);
GenerateSolution(x, lp, &vHash, &cHash, sol);
OPTSTAT status = lp->getStat();
delete lp;
return status;
}
void SolverFormulacaoPadrao::GenerateSolution(ProblemSolution* sol) {
vector<double> x(lp_->getNumCols());
lp_->getX(&x[0]);
GenerateSolution(x, lp_, &vHash_, &cHash_, sol);
}
