long GenModelCplex::Solve()
{
if(!bcreated)
throw string("Solve() not available : Problem not created yet");
CplexData* d = static_cast<CplexData*>(solverdata);
int status = 0;
if(boolParam.count("qp") > 0 && boolParam["qp"])
status = CPXqpopt(d->env, d->lp);
else if(boolParam.count("mip") > 0 && boolParam["mip"])
status = CPXmipopt(d->env, d->lp);
else if(strParam.count("algo") > 0 && strParam["algo"] == "interior")
status = CPXbaropt(d->env, d->lp);
else if(strParam.count("algo") > 0 && strParam["algo"] == "dual")
status = CPXdualopt(d->env, d->lp);
else if(strParam.count("algo") > 0 && strParam["algo"] == "primal")
status = CPXprimopt(d->env, d->lp);
else if(strParam.count("algo") > 0 && strParam["algo"] == "concurrent")
{
//printf("choosing concurrent algo\n");
CPXsetintparam (d->env, CPX_PARAM_LPMETHOD, CPX_ALG_CONCURRENT);
status = CPXlpopt(d->env, d->lp);
}
else if(strParam.count("algo") > 0 && strParam["algo"] == "sifting")
{
CPXsetintparam (d->env, CPX_PARAM_LPMETHOD, CPX_ALG_SIFTING);
status = CPXlpopt(d->env, d->lp);
}
else
status = CPXlpopt(d->env, d->lp);
return 0;
}
Solution cplex_solve(TSP tsp, Solution prev, CPLEX cplex) {
double distance;
double *x = malloc(tsp.cols * sizeof(double));
Solution solution;
solution.i = prev.i + 1;
solution.n = 0;
solution.subtours = malloc(sizeof(Subtour *) * (tsp.n / 3));
struct timespec cplex_start = timer_start();
CPXmipopt(cplex.env, cplex.lp); // solve the next cycle
CPXsolution(cplex.env, cplex.lp, NULL, &solution.distance, x,
NULL, NULL, NULL);
solution.cplex_time = timer_end(cplex_start);
struct timespec code_start = timer_start();
// Collect all active solution variables
int count = 0;
int *vars = malloc(sizeof(int) * tsp.n);
for (int i = 0; i < tsp.cols; ++i) {
if (x[i] == 0) continue;
vars[count++] = i;
if (count == tsp.n) break; // All active solution vars found
}
while (subtour_exists(tsp, vars)) {
subtour_insert(subtour_get(tsp, vars), solution.subtours, &(solution.n));
}
free(vars);
solution.work_time = timer_end(code_start);
return solution;
}
void CplexSolver::run() {
CPXchgobjsen(_env, _prob, _is_minimize ? CPX_MIN : CPX_MAX);
if (_is_mip) {
CPXsetintparam(_env, CPX_PARAM_SOLUTIONTARGET, CPX_SOLUTIONTARGET_OPTIMALGLOBAL);
CPXmipopt(_env, _prob);
} else
CPXlpopt(_env, _prob);
}
double solve()
{
const int numcols = vars_.size();
const int numrows = bnd_.size();
int status;
lp_ = CPXcreateprob(env_, &status, "PRactIP");
if (lp_==NULL)
throw std::runtime_error("failed to create LP");
unsigned int n_nonzero=0;
for (unsigned int i=0; i!=m_.size(); ++i)
n_nonzero += m_[i].size();
std::vector<int> matbeg(numcols, 0);
std::vector<int> matcnt(numcols, 0);
std::vector<int> matind(n_nonzero);
std::vector<double> matval(n_nonzero);
for (unsigned int i=0, k=0; i!=m_.size(); ++i)
{
matbeg[i] = i==0 ? 0 : matbeg[i-1]+matcnt[i-1];
matcnt[i] = m_[i].size();
for (unsigned int j=0; j!=m_[i].size(); ++j, ++k)
{
matind[k] = m_[i][j].first;
matval[k] = m_[i][j].second;
}
}
m_.clear();
status = CPXcopylp(env_, lp_, numcols, numrows,
dir_==IP::MIN ? CPX_MIN : CPX_MAX,
&coef_[0], &rhs_[0], &bnd_[0],
&matbeg[0], &matcnt[0], &matind[0], &matval[0],
&vlb_[0], &vub_[0], &rngval_[0] );
vlb_.clear();
vub_.clear();
status = CPXcopyctype(env_, lp_, &vars_[0]);
vars_.clear();
CPXsetintparam(env_, CPXPARAM_MIP_Display, 0);
CPXsetintparam(env_, CPXPARAM_Barrier_Display, 0);
CPXsetintparam(env_, CPXPARAM_Tune_Display, 0);
CPXsetintparam(env_, CPXPARAM_Network_Display, 0);
CPXsetintparam(env_, CPXPARAM_Sifting_Display, 0);
CPXsetintparam(env_, CPXPARAM_Simplex_Display, 0);
status = CPXmipopt(env_, lp_);
double objval;
status = CPXgetobjval(env_, lp_, &objval);
res_cols_.resize(CPXgetnumcols(env_, lp_));
status = CPXgetx(env_, lp_, &res_cols_[0], 0, res_cols_.size()-1);
return objval;
}
void SSCplex::Solve( void )
{
// the solver
#if( MIP )
status = CPXmipopt (env, lp);
if ( status ) {
stop("Failed to optimize MIP.\n", status);
}
int solstat = CPXgetstat (env, lp);
cout << "Solstat " << solstat << endl;
status = CPXgetmipobjval (env, lp, &objval);
if ( status )
stop("No MIP objective value available. Exiting...\n", status);
// get the best solution
int begin = 0;
int end = begin + NArcs;
status = CPXgetmipx (env, lp, Y, begin, end-1);
int k = 0;
bool found = false;
while( !found && ( k < lev_card ))
if( Y[k] )
{
found = true;
cout << "vf 0 on VM " << k << endl;
}
else
k++;
for( int h = 0; h < h_len - 1; h++ )
{
found = false;
int i = 0;
while( !found && ( i < lev_card ))
{
int j = 0;
int offset = lev_card + h * (lev_card * lev_card) + i * lev_card;
while( !found && ( j < lev_card ))
{
if( Y[offset + j] )
{
found = true;
cout << "vf " << h+1 << " on VM " << j << endl;
}
else
j++;
}
i++;
}
}
#endif
}//END SolveMIP
void IPSolve()
{
int status;
status = CPXmipopt (env, lp);
if ( status ) {
printf ("Failed to optimize IP\n");
getch();
exit(-1);
}
}
void PartitionedColoringModel::solve() {
int status;
// Optimizamos el problema.
status = CPXmipopt(this->cplexEnvironment, this->linearProblem);
if(status) {
cerr << "Problema optimizando CPLEX" << endl;
exit(1);
}
}
int
main (int argc, char *argv[])
{
int uselogcallback = 0;
LOGINFO myloginfo;
int usetimelimcallback = 0;
TIMELIMINFO mytimeliminfo;
int useterminate = 0;
volatile int terminator;
CPXENVptr env = NULL;
CPXLPptr lp = NULL;
int solstat;
int status = 0;
/* Check the command line arguments */
if (( argc != 3 ) ||
( strchr ("lta", argv[2][0]) == NULL ) ) {
usage (argv[0]);
goto TERMINATE;
}
switch (argv[2][0]) {
case 'l':
uselogcallback = 1;
break;
case 't':
usetimelimcallback = 1;
break;
case 'a':
useterminate = 1;
break;
default:
break;
}
/* Initialize the CPLEX environment */
env = CPXopenCPLEX (&status);
/* If an error occurs, the status value indicates the reason for
failure. A call to CPXgeterrorstring will produce the text of
the error message. Note that CPXopenCPLEX produces no output,
so the only way to see the cause of the error is to use
CPXgeterrorstring. For other CPLEX routines, the errors will
be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */
if ( env == NULL ) {
char errmsg[CPXMESSAGEBUFSIZE];
fprintf (stderr, "Could not open CPLEX environment.\n");
CPXgeterrorstring (env, status, errmsg);
fprintf (stderr, "%s", errmsg);
goto TERMINATE;
}
/* Turn on output to the screen */
status = CPXsetintparam (env, CPXPARAM_ScreenOutput, CPX_ON);
if ( status ) {
fprintf (stderr,
"Failure to turn on screen indicator, error %d.\n", status);
goto TERMINATE;
}
/* Create the problem, using the filename as the problem name */
lp = CPXcreateprob (env, &status, argv[1]);
/* A returned pointer of NULL may mean that not enough memory
was available or there was some other problem. In the case of
failure, an error message will have been written to the error
channel from inside CPLEX. In this example, the setting of
the parameter CPXPARAM_ScreenOutput causes the error message to
appear on stdout. Note that most CPLEX routines return
an error code to indicate the reason for failure. */
if ( lp == NULL ) {
fprintf (stderr, "Failed to create LP.\n");
goto TERMINATE;
}
/* Now read the file, and copy the data into the created lp */
status = CPXreadcopyprob (env, lp, argv[1], NULL);
if ( status ) {
fprintf (stderr, "Failed to read and copy the problem data.\n");
goto TERMINATE;
}
if ( usetimelimcallback ) {
double t;
status = CPXgettime (env, &t);
if ( status ) {
fprintf (stderr, "Failed to initialize timer.\n");
goto TERMINATE;
}
mytimeliminfo.acceptablegap = 10.0;
mytimeliminfo.aborted = 0;
mytimeliminfo.timestart = t;
mytimeliminfo.timelim = 1.0;
status = CPXsetinfocallbackfunc (env, timelimcallback, &mytimeliminfo);
if ( status ) {
fprintf (stderr, "Failed to set time limit callback function.\n");
goto TERMINATE;
}
}
else if ( uselogcallback ) {
/* Set overall node limit in case callback conditions are not met */
status = CPXsetintparam (env, CPXPARAM_MIP_Limits_Nodes, 5000);
if ( status ) goto TERMINATE;
status = CPXgettime (env, &myloginfo.timestart);
if ( status ) {
fprintf (stderr, "Failed to query time.\n");
goto TERMINATE;
}
status = CPXgetdettime (env, &myloginfo.dettimestart);
if ( status ) {
fprintf (stderr, "Failed to query deterministic time.\n");
goto TERMINATE;
}
myloginfo.numcols = CPXgetnumcols (env, lp);
myloginfo.lastincumbent = CPXgetobjsen (env, lp) * 1e+35;
myloginfo.lastlog = -10000;
status = CPXsetinfocallbackfunc (env, logcallback, &myloginfo);
if ( status ) {
fprintf (stderr, "Failed to set logging callback function.\n");
goto TERMINATE;
}
/* Turn off CPLEX logging */
status = CPXsetintparam (env, CPXPARAM_MIP_Display, 0);
if ( status ) goto TERMINATE;
}
else if ( useterminate) {
status = CPXsetterminate (env, &terminator);
if ( status ) {
fprintf (stderr, "Failed to set terminator.\n");
goto TERMINATE;
}
/* Typically, you would pass the terminator variable to
another thread or pass it to an interrupt handler,
and monitor for some event to occur. When it does,
set terminator to a non-zero value.
To illustrate its use without creating a thread or
an interrupt handler, terminate immediately by setting
terminator before the solve.
*/
terminator = 1;
}
/* Optimize the problem and obtain solution. */
status = CPXmipopt (env, lp);
if ( status ) {
fprintf (stderr, "Failed to optimize MIP.\n");
goto TERMINATE;
}
solstat = CPXgetstat (env, lp);
printf ("Solution status %d.\n", solstat);
TERMINATE:
/* Free up the problem as allocated by CPXcreateprob, if necessary */
if ( lp != NULL ) {
int xstatus = CPXfreeprob (env, &lp);
if ( xstatus ) {
fprintf (stderr, "CPXfreeprob failed, error code %d.\n", xstatus);
status = xstatus;
}
}
/* Free up the CPLEX environment, if necessary */
if ( env != NULL ) {
int xstatus = CPXcloseCPLEX (&env);
/* Note that CPXcloseCPLEX produces no output,
so the only way to see the cause of the error is to use
CPXgeterrorstring. For other CPLEX routines, the errors will
be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */
if ( status ) {
char errmsg[CPXMESSAGEBUFSIZE];
fprintf (stderr, "Could not close CPLEX environment.\n");
CPXgeterrorstring (env, status, errmsg);
fprintf (stderr, "%s", errmsg);
status = xstatus;
}
}
return (status);
} /* END main */
OptSolutionData* CPLEXRunSolver(int ProbType) {
OptSolutionData* NewSolution = NULL;
int Status = 0;
if (ProbType == LP) {
Status = CPXsetintparam (CPLEXenv, CPX_PARAM_LPMETHOD, CPX_ALG_AUTOMATIC);
if (Status) {
FErrorFile() << "Failed to set the optimization method." << endl;
FlushErrorFile();
return NULL;
}
Status = CPXsetintparam (CPLEXenv, CPX_PARAM_SIMDISPLAY, 0);
if (Status) {
FErrorFile() << "Failed to set the optimization method." << endl;
FlushErrorFile();
return NULL;
}
Status = CPXchgprobtype(CPLEXenv, CPLEXModel, CPXPROB_LP);
Status = CPXlpopt(CPLEXenv, CPLEXModel);
} else if(ProbType == MILP || ProbType == MIQP) {
//Setting the bound tightening on high
Status = CPXsetintparam (CPLEXenv, CPX_PARAM_BNDSTRENIND, 1);
if (Status) {
FErrorFile() << "Failed to set the optimization method." << endl;
FlushErrorFile();
return NULL;
}
//Setting tolerance to 1e-9 instead of 1e-6
double tolerance = atof(GetParameter("Solver tolerance").data());
Status = CPXsetdblparam(CPLEXenv,CPX_PARAM_EPRHS, tolerance);
if (Status) {
FErrorFile() << "Failed to set the optimization method." << endl;
FlushErrorFile();
return NULL;
}
Status = CPXsetdblparam(CPLEXenv,CPX_PARAM_EPINT, tolerance);
if (Status) {
FErrorFile() << "Failed to set the optimization method." << endl;
FlushErrorFile();
return NULL;
}
//Deactivates all messages from MIP solver
Status = CPXchgprobtype(CPLEXenv, CPLEXModel, CPXPROB_MILP);
Status = CPXmipopt (CPLEXenv, CPLEXModel);
} else if(ProbType == QP) {
Status = CPXqpopt (CPLEXenv, CPLEXModel);
}
if (Status ) {
cout << "Failed to optimize LP." << endl;
return NULL;
}
int Temp = CPXgetstat (CPLEXenv, CPLEXModel);
NewSolution = new OptSolutionData;
if (Temp == CPX_STAT_UNBOUNDED) {
cout << "Model is unbounded" << endl;
FErrorFile() << "Model is unbounded" << endl;
FlushErrorFile();
NewSolution->Status = UNBOUNDED;
return NewSolution;
} else if (Temp == CPX_STAT_INFEASIBLE) {
cout << "Model is infeasible" << endl;
FErrorFile() << "Model is infeasible" << endl;
FlushErrorFile();
NewSolution->Status = INFEASIBLE;
return NewSolution;
} else if (Temp == CPX_STAT_INForUNBD ) {
cout << "Model is infeasible or unbounded" << endl;
FErrorFile() << "Model is infeasible or unbounded" << endl;
FlushErrorFile();
NewSolution->Status = INFEASIBLE;
return NewSolution;
} else {
NewSolution->Status = SUCCESS;
}
int NumberColumns = CPXgetnumcols (CPLEXenv, CPLEXModel);
int NumberRows = CPXgetnumrows (CPLEXenv, CPLEXModel);
NewSolution->NumVariables = NumberColumns;
NewSolution->SolutionData.resize(NumberColumns);
double* x = new double[NumberColumns];
if (ProbType == MILP || ProbType == MIQP) {
Status = CPXgetmipobjval (CPLEXenv, CPLEXModel, &(NewSolution->Objective));
Status = CPXgetmipx (CPLEXenv, CPLEXModel, x, 0, NumberColumns-1);
} else {
Status = CPXsolution(CPLEXenv,CPLEXModel,NULL,&(NewSolution->Objective),x,NULL,NULL,NULL);
}
if ( Status ) {
cout << "Failed to obtain objective value." << endl;
delete [] x;
NewSolution->Status = INFEASIBLE;
return NewSolution;
}
cout << "Objective value: " << NewSolution->Objective << endl;
/*
string* StrNames = new string[NumberColumns];
char** Names = new char*[NumberColumns];
char* NameStore = new char[7*NumberColumns];
int Surplus = 0;
Status = CPXgetcolname(CPLEXenv, CPLEXModel, Names, NameStore, 7*NumberColumns, &Surplus, 0, NumberColumns-1);
if (Status) {
FErrorFile() << "Failed to get column names." << endl;
FlushErrorFile();
delete [] StrNames;
delete [] Names;
delete [] NameStore;
delete [] x;
delete NewSolution;
return NULL;
}
*/
for (int i=0; i < NumberColumns; i++) {
//StrNames[i].assign(Names[i]);
//StrNames[i] = StrNames[i].substr(1, StrNames[i].length()-1);
//NewSolution->SolutionData[atoi(StrNames[i].data())-1] = x[i];
NewSolution->SolutionData[i] = x[i];
}
/*
delete [] StrNames;
delete [] Names;
delete [] NameStore;
*/
delete [] x;
return NewSolution;
}
int main(int argc, char **argv)
{
int status = 0;
CPXENVptr env = NULL;
CPXLPptr lp = NULL;
double obj[NUMCOLS];
double lb[NUMCOLS];
double ub[NUMCOLS];
double x[NUMCOLS];
int rmatbeg[NUMROWS];
int rmatind[NUMNZ];
double rmatval[NUMNZ];
double rhs[NUMROWS];
char sense[NUMROWS];
char ctype[NUMCOLS];
int solstat;
double objval;
env = CPXopenCPLEX (&status);
CPXsetintparam(env, CPX_PARAM_MIPCBREDLP, CPX_OFF);
CPXsetintparam(env, CPX_PARAM_PRELINEAR, CPX_OFF);
/* Turn on traditional search for use with control callbacks */
// status = CPXsetintparam (env, CPXPARAM_MIP_Strategy_Search,
// CPX_MIPSEARCH_TRADITIONAL);
lp = CPXcreateprob(env, &status, "lpex1");
//CPXchgprobtype(env, lp, CPXPROB_MILP);
CPXchgobjsen (env, lp, CPX_MAX);
status = CPXsetlazyconstraintcallbackfunc (env, callback,
NULL);
lb[0] = 0.0;
ub[0] = 40.0;
lb[1] = 0.0;
ub[1] = CPX_INFBOUND;
lb[2] = 0.0;
ub[2] = CPX_INFBOUND;
obj[0] = 1.0;
obj[1] = 2.0;
obj[2] = 3.0;
status = CPXnewcols (env, lp, NUMCOLS, obj, lb, ub, NULL, NULL);
rmatbeg[0] = 0;
rmatind[0] = 0; rmatind[1] = 1; rmatind[2] = 2;
rmatval[0] = -1.0; rmatval[1] = 1.0; rmatval[2] = 1.0; sense[0] = 'L'; rhs[0] = 20.0;
rmatbeg[1] = 3;
rmatind[3] = 0; rmatind[4] = 1; rmatind[5] = 2;
rmatval[3] = 1.0; rmatval[4] = -3.0; rmatval[5] = 1.0; sense[1] = 'L'; rhs[1] = 30.0;
ctype[0] = 'I'; ctype[1] = 'C'; ctype[2] = 'I';
// status = CPXaddusercuts (env, lp, cutcnt, cutnzcnt, cutrhs,
// cutsense, cutbeg, cutind, cutval, NULL);
//status = CPXaddusercuts(env, lp, NUMROWS, NUMNZ, rhs, sense, rmatbeg, rmatind, rmatval, NULL );
status = CPXaddrows (env, lp, 0, NUMROWS, NUMNZ, rhs, sense, rmatbeg, rmatind, rmatval, NULL, NULL);
status = CPXcopyctype (env, lp, ctype);
// cuts
int cmatbeg[1] = {0};
int cmatind[3] = {0,1,2};
double cmatval[3] = {1,0,0};
char csense[1] = {'L'};
double crhs[1] = {20};
//CPXaddusercuts doesnt work for some f*****g reason
//status = CPXaddlazyconstraints(env, lp, 1, 3, crhs, csense, cmatbeg, cmatind, cmatval, NULL );
if ( status ) {
fprintf (stderr, "Some f*****g error, status = %d.\n", status);
}
status = CPXmipopt (env, lp);
/* Write the output to the screen. */
// solstat = CPXgetstat (env, lp);
// printf ("\nSolution status = %d\n", solstat);
// status = CPXgetobjval (env, lp, &objval);
// printf ("Solution value = %f\n\n", objval);
status = CPXsolution (env, lp, &solstat, &objval, x, NULL, NULL, NULL);
printf ("\nSolution status = %d\n", solstat);
printf ("Solution value = %f\n", objval);
printf ("Solution= [%f, %f, %f]\n\n", x[0], x[1], x[2]);
printf("This is great stuff\n");
return 0;
}
int
main (int argc, char *argv[])
{
/* Declare and allocate space for the variables and arrays where we will
store the optimization results including the status, objective value,
and variable values. */
int solstat;
double objval;
double *x = NULL;
CPXENVptr env = NULL;
CPXLPptr lp = NULL;
int status;
int j;
int cur_numcols;
/* Check the command line arguments */
if ( argc != 2 ) {
usage (argv[0]);
goto TERMINATE;
}
/* Initialize the CPLEX environment */
env = CPXopenCPLEX (&status);
/* If an error occurs, the status value indicates the reason for
failure. A call to CPXgeterrorstring will produce the text of
the error message. Note that CPXopenCPLEX produces no output,
so the only way to see the cause of the error is to use
CPXgeterrorstring. For other CPLEX routines, the errors will
be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */
if ( env == NULL ) {
char errmsg[CPXMESSAGEBUFSIZE];
fprintf (stderr, "Could not open CPLEX environment.\n");
CPXgeterrorstring (env, status, errmsg);
fprintf (stderr, "%s", errmsg);
goto TERMINATE;
}
/* Turn on output to the screen */
status = CPXsetintparam (env, CPXPARAM_ScreenOutput, CPX_ON);
if ( status ) {
fprintf (stderr,
"Failure to turn on screen indicator, error %d.\n", status);
goto TERMINATE;
}
/* Create the problem, using the filename as the problem name */
lp = CPXcreateprob (env, &status, argv[1]);
/* A returned pointer of NULL may mean that not enough memory
was available or there was some other problem. In the case of
failure, an error message will have been written to the error
channel from inside CPLEX. In this example, the setting of
the parameter CPXPARAM_ScreenOutput causes the error message to
appear on stdout. Note that most CPLEX routines return
an error code to indicate the reason for failure. */
if ( lp == NULL ) {
fprintf (stderr, "Failed to create LP.\n");
goto TERMINATE;
}
/* Now read the file, and copy the data into the created lp */
status = CPXreadcopyprob (env, lp, argv[1], NULL);
if ( status ) {
fprintf (stderr, "Failed to read and copy the problem data.\n");
goto TERMINATE;
}
/* Optimize the problem and obtain solution. */
status = CPXmipopt (env, lp);
if ( status ) {
fprintf (stderr, "Failed to optimize MIP.\n");
goto TERMINATE;
}
solstat = CPXgetstat (env, lp);
printf ("Solution status %d.\n", solstat);
status = CPXgetobjval (env, lp, &objval);
if ( status ) {
fprintf (stderr,"Failed to obtain objective value.\n");
goto TERMINATE;
}
printf ("Objective value %.10g\n", objval);
/* The size of the problem should be obtained by asking CPLEX what
the actual size is. cur_numcols stores the current number
of columns. */
cur_numcols = CPXgetnumcols (env, lp);
/* Allocate space for solution */
x = (double *) malloc (cur_numcols*sizeof(double));
if ( x == NULL ) {
fprintf (stderr, "No memory for solution values.\n");
goto TERMINATE;
}
status = CPXgetx (env, lp, x, 0, cur_numcols-1);
if ( status ) {
fprintf (stderr, "Failed to obtain solution.\n");
goto TERMINATE;
}
/* Write out the solution */
for (j = 0; j < cur_numcols; j++) {
printf ( "Column %d: Value = %17.10g\n", j, x[j]);
}
TERMINATE:
/* Free up the solution */
free_and_null ((char **) &x);
/* Free up the problem as allocated by CPXcreateprob, if necessary */
if ( lp != NULL ) {
status = CPXfreeprob (env, &lp);
if ( status ) {
fprintf (stderr, "CPXfreeprob failed, error code %d.\n", status);
}
}
/* Free up the CPLEX environment, if necessary */
if ( env != NULL ) {
status = CPXcloseCPLEX (&env);
/* Note that CPXcloseCPLEX produces no output,
so the only way to see the cause of the error is to use
CPXgeterrorstring. For other CPLEX routines, the errors will
be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */
if ( status ) {
char errmsg[CPXMESSAGEBUFSIZE];
fprintf (stderr, "Could not close CPLEX environment.\n");
CPXgeterrorstring (env, status, errmsg);
fprintf (stderr, "%s", errmsg);
}
}
return (status);
} /* END main */
int
main (int argc, char *argv[])
{
/* Declare and allocate space for the variables and arrays where we will
store the optimization results including the status, objective value,
maximum bound violation, variable values, and basis. */
int solnstat, solnmethod, solntype;
double objval, maxviol;
double *x = NULL;
CPXENVptr env = NULL;
CPXLPptr lp = NULL;
int status = 0;
int j;
int cur_numrows, cur_numcols;
/* Check the command line arguments */
if (( argc != 2 )) {
usage (argv[0]);
goto TERMINATE;
}
/* Initialize the CPLEX environment */
env = CPXopenCPLEX (&status);
/* If an error occurs, the status value indicates the reason for
failure. A call to CPXgeterrorstring will produce the text of
the error message. Note that CPXopenCPLEX produces no output,
so the only way to see the cause of the error is to use
CPXgeterrorstring. For other CPLEX routines, the errors will
be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */
if ( env == NULL ) {
char errmsg[CPXMESSAGEBUFSIZE];
fprintf (stderr, "Could not open CPLEX environment.\n");
CPXgeterrorstring (env, status, errmsg);
fprintf (stderr, "%s", errmsg);
goto TERMINATE;
}
/* Turn on output to the screen */
status = CPXsetintparam (env, CPXPARAM_ScreenOutput, CPX_ON);
if ( status ) {
fprintf (stderr,
"Failure to turn on screen indicator, error %d.\n", status);
goto TERMINATE;
}
/* Create the problem, using the filename as the problem name */
lp = CPXcreateprob (env, &status, argv[1]);
/* A returned pointer of NULL may mean that not enough memory
was available or there was some other problem. In the case of
failure, an error message will have been written to the error
channel from inside CPLEX. In this example, the setting of
the parameter CPXPARAM_ScreenOutput causes the error message to
appear on stdout. Note that most CPLEX routines return
an error code to indicate the reason for failure. */
if ( lp == NULL ) {
fprintf (stderr, "Failed to create LP.\n");
goto TERMINATE;
}
/* Now read the file, and copy the data into the created lp */
status = CPXreadcopyprob (env, lp, argv[1], NULL);
if ( status ) {
fprintf (stderr, "Failed to read and copy the problem data.\n");
goto TERMINATE;
}
if ( CPXgetprobtype (env, lp) != CPXPROB_MIQP ) {
fprintf (stderr, "Input file is not a MIQP. Exiting.\n");
goto TERMINATE;
}
/* Optimize the problem and obtain solution. */
status = CPXsetintparam (env, CPXPARAM_SolutionTarget,
CPX_SOLUTIONTARGET_OPTIMALGLOBAL);
if ( status ) goto TERMINATE;
status = CPXmipopt (env, lp);
if ( status ) {
fprintf (stderr, "Failed to optimize nonconvex MIQP.\n");
goto TERMINATE;
}
solnstat = CPXgetstat (env, lp);
if ( solnstat == CPXMIP_UNBOUNDED ||
solnstat == CPX_STAT_UNBOUNDED ) {
printf ("Model is unbounded\n");
goto TERMINATE;
}
else if ( solnstat == CPXMIP_INFEASIBLE ||
solnstat == CPX_STAT_INFEASIBLE ) {
printf ("Model is infeasible\n");
goto TERMINATE;
}
else if ( solnstat == CPX_STAT_INForUNBD ) {
printf ("Model is infeasible or unbounded\n");
goto TERMINATE;
}
status = CPXsolninfo (env, lp, &solnmethod, &solntype, NULL, NULL);
if ( status ) {
fprintf (stderr, "Failed to obtain solution info.\n");
goto TERMINATE;
}
printf ("Solution status %d, solution method %d\n", solnstat, solnmethod);
if ( solntype == CPX_NO_SOLN ) {
fprintf (stderr, "Solution not available.\n");
goto TERMINATE;
}
status = CPXgetobjval (env, lp, &objval);
if ( status ) {
fprintf (stderr, "Failed to obtain objective value.\n");
goto TERMINATE;
}
printf ("Objective value %.10g.\n", objval);
/* The size of the problem should be obtained by asking CPLEX what
the actual size is. cur_numrows and cur_numcols store the
current number of rows and columns, respectively. */
cur_numcols = CPXgetnumcols (env, lp);
cur_numrows = CPXgetnumrows (env, lp);
/* Retrieve solution vector */
x = (double *) malloc (cur_numcols*sizeof(double));
if ( x == NULL ) {
fprintf (stderr, "No memory for solution.\n");
goto TERMINATE;
}
status = CPXgetx (env, lp, x, 0, cur_numcols-1);
if ( status ) {
fprintf (stderr, "Failed to obtain primal solution.\n");
goto TERMINATE;
}
/* Write out the solution */
for (j = 0; j < cur_numcols; j++) {
printf ( "Column %d: Value = %17.10g", j, x[j]);
printf ("\n");
}
/* Display the maximum bound violation. */
status = CPXgetdblquality (env, lp, &maxviol, CPX_MAX_PRIMAL_INFEAS);
if ( status ) {
fprintf (stderr, "Failed to obtain bound violation.\n");
goto TERMINATE;
}
printf ("Maximum bound violation = %17.10g\n", maxviol);
TERMINATE:
/* Free up the basis and solution */
free_and_null ((char **) &x);
/* Free up the problem, if necessary */
if ( lp != NULL ) {
status = CPXfreeprob (env, &lp);
if ( status ) {
fprintf (stderr, "CPXfreeprob failed, error code %d.\n", status);
}
}
/* Free up the CPLEX environment, if necessary */
if ( env != NULL ) {
status = CPXcloseCPLEX (&env);
/* Note that CPXcloseCPLEX produces no output,
so the only way to see the cause of the error is to use
CPXgeterrorstring. For other CPLEX routines, the errors will
be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */
if ( status ) {
char errmsg[CPXMESSAGEBUFSIZE];
fprintf (stderr, "Could not close CPLEX environment.\n");
CPXgeterrorstring (env, status, errmsg);
fprintf (stderr, "%s", errmsg);
}
}
return (status);
} /* END main */
/* This routine initializes the cplex enviorement, sets screen as an output for cplex errors and notifications,
and sets parameters for cplex. It calls for a mixed integer program solution and frees the environment.
To Do:
Declare the parameters for the problem and fill them accordingly. After creating the program thus, copy it into cplex.
Define any integer or binary variables as needed, and change their type before the call to CPXmipopt to solve problem.
Use CPXwriteprob to output the problem in lp format, in the name of cluster_editing.lp.
Read solution (both objective function value and variables assignment).
Communicate to pass the problem and the solution between the modules in the best way you see.
*/
int cluster()
{
/* Declare and allocate space for the variables and arrays where we
will store the optimization results including the status, objective
value and variable values. */
CPXENVptr p_env = NULL;
CPXLPptr p_lp = NULL;
int status;
/* Initialize the CPLEX environment */
p_env = CPXopenCPLEX (&status);
/* If an error occurs, the status value indicates the reason for
failure. A call to CPXgeterrorstring will produce the text of
the error message. Note that CPXopenCPLEX produces no output,
so the only way to see the cause of the error is to use
CPXgeterrorstring. For other CPLEX routines, the errors will
be seen if the CPX_PARAM_SCRIND indicator is set to CPX_ON. */
if ( p_env == NULL ) {
char errmsg[1024];
fprintf (stderr, "Error: Could not open CPLEX environment.\n");
CPXgeterrorstring (p_env, status, errmsg);
fprintf (stderr, "%s", errmsg);
goto TERMINATE;
}
/* Turn on output to the screen */
status = CPXsetintparam (p_env, CPX_PARAM_SCRIND, CPX_ON);
if ( status ) {
fprintf (stderr,
"Error: Failure to turn on screen indicator, error %d.\n", status);
goto TERMINATE;
}
/* Create the problem. */
p_lp = CPXcreateprob (p_env, &status, probname);
/* A returned pointer of NULL may mean that not enough memory
was available or there was some other problem. In the case of
failure, an error message will have been written to the error
channel from inside CPLEX. The setting of
the parameter CPX_PARAM_SCRIND causes the error message to
appear on stdout. */
if ( p_lp == NULL ) {
fprintf (stderr, "Error: Failed to create problem.\n");
goto TERMINATE;
}
/* Use CPXcopylp to transfer the ILP part of the problem data into the cplex pointer lp */
CPXcopylp (p_env, p_lp, numcols, numrows, objsen, obj, rhs, sense, matbeg, matcnt, matind, matval, lb, ub, 0);
CPXchgctype(p_env, p_lp, cnt, indices, ctype);
/* Optimize the problem. */
status = CPXmipopt (p_env, p_lp);
if ( status ) {
fprintf (stderr, "Error: Failed to optimize problem.\n");
goto TERMINATE;
}
status = CPXsolution(p_env, p_lp, &solstat, &objval, x, NULL, NULL, NULL);
if ( status ) {
fprintf (stderr, "Error: Failed to get solution variables.\n");
goto TERMINATE;
}
/* Write a copy of the problem to a file.
Please put into probname the following string: Output Directory + "clustering_solution.lp" to create clustering_solution.lp in your output directory */
status = CPXwriteprob (p_env, p_lp, probname, NULL);
if ( status ) {
fprintf (stderr, "Error: Failed to write LP to disk.\n");
goto TERMINATE;
}
TERMINATE:
/* Free up the problem as allocated by CPXcreateprob, if necessary */
if ( p_lp != NULL ) {
status = CPXfreeprob (p_env, &p_lp);
if ( status ) {
fprintf (stderr, "Error: CPXfreeprob failed, error code %d.\n", status);
}
}
/* Free up the CPLEX environment, if necessary */
if ( p_env != NULL ) {
status = CPXcloseCPLEX (&p_env);
/* Note that CPXcloseCPLEX produces no output,
so the only way to see the cause of the error is to use
CPXgeterrorstring. For other CPLEX routines, the errors will
be seen if the CPX_PARAM_SCRIND indicator is set to CPX_ON. */
if ( status ) {
char errmsg[1024];
fprintf (stderr, "Could not close CPLEX environment.\n");
CPXgeterrorstring (p_env, status, errmsg);
fprintf (stderr, "%s", errmsg);
}
}
return (status);
}
//*******************************************************************
int CSolver:: MipOptimize() {
int rcStatus;
char buff[100];
int bFailed ;
bFailed = 0;
SetProblemType('M'); // sets callback data flags
m_cbData.bMip = true;
CPXsetmipcallbackfunc(m_env,lpcallback, &m_cbData);
//! m_status = CPXmipoptimize(m_env,m_lp);
m_status = CPXmipopt(m_env, m_lp);
if (m_status != 0) {
CPXgeterrorstring(m_env, m_status, m_error);
sprintf(buff, "CPXmipoptimize failed return code = %d", m_status );
Message(buff);
Message(m_error);
bFailed = 1;
return -1;
}
CPXsetmipcallbackfunc(m_env,NULL,NULL);
m_lpstat = CPXgetstat(m_env,m_lp);
if( bFailed == 1) {
sprintf(buff, "CPXgetstat value = %d", m_lpstat);
Message(buff);
}
CreateSolArrays();
// get solution and place into arrays
//! CPXgetmobjval(m_env, m_lp, &m_obj);
CPXgetobjval(m_env, m_lp, &m_obj);
//! rcStatus = CPXgetmx(m_env,m_lp, m_x, 0, m_nObjItems-1 );
rcStatus = CPXgetx(m_env, m_lp, m_x, 0, m_nObjItems - 1);
if ( rcStatus ){
CPXgeterrorstring(m_env, m_status, m_error);
Message(m_error);
return -1;
}
//! rcStatus = CPXgetmslack(m_env, m_lp, m_slack, 0, m_nRhsItems-1 );
rcStatus = CPXgetslack(m_env, m_lp, m_slack, 0, m_nRhsItems - 1);
if ( rcStatus ){
CPXgeterrorstring(m_env, m_status, m_error);
Message(m_error);
return -1;
}
// save the basis to arrays
// m_status = CPXgetbase(m_env, m_lp, m_pCstat, m_pRstat);
// if ( m_status ) {
// Message("Getting basis failed!");
// return -1;
// }
return 0;
}
int
main (void)
{
/* Declare variables and arrays where we will store the
optimization results including the status, objective value,
and variable values. */
int solstat;
double objval;
double x[2*NUMEDGES]; /* One flow variable and one fixed charge indicator
for each edge */
CPXENVptr env = NULL;
CPXLPptr lp = NULL;
int status;
int j;
/* Initialize the CPLEX environment */
env = CPXopenCPLEX (&status);
/* If an error occurs, the status value indicates the reason for
failure. A call to CPXgeterrorstring will produce the text of
the error message. Note that CPXopenCPLEX produces no output,
so the only way to see the cause of the error is to use
CPXgeterrorstring. For other CPLEX routines, the errors will
be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */
if ( env == NULL ) {
char errmsg[CPXMESSAGEBUFSIZE];
fprintf (stderr, "Could not open CPLEX environment.\n");
CPXgeterrorstring (env, status, errmsg);
fprintf (stderr, "%s", errmsg);
goto TERMINATE;
}
/* Turn on output to the screen */
status = CPXsetintparam (env, CPXPARAM_ScreenOutput, CPX_ON);
if ( status ) {
fprintf (stderr,
"Failure to turn on screen indicator, error %d.\n", status);
goto TERMINATE;
}
/* Create the problem. */
lp = CPXcreateprob (env, &status, "fixnet");
/* A returned pointer of NULL may mean that not enough memory
was available or there was some other problem. In the case of
failure, an error message will have been written to the error
channel from inside CPLEX. In this example, the setting of
the parameter CPXPARAM_ScreenOutput causes the error message to
appear on stdout. */
if ( lp == NULL ) {
fprintf (stderr, "Failed to create LP.\n");
goto TERMINATE;
}
/* Build the fixed-charge network flow model using
indicator constraints. */
status = buildnetwork (env, lp);
if ( status ) {
fprintf (stderr, "Failed to build network.\n");
goto TERMINATE;
}
/* Optimize the problem and obtain solution. */
status = CPXmipopt (env, lp);
if ( status ) {
fprintf (stderr, "Failed to optimize MIP.\n");
goto TERMINATE;
}
solstat = CPXgetstat (env, lp);
/* Write solution status and objective to the screen. */
printf ("\nSolution status = %d\n", solstat);
status = CPXgetobjval (env, lp, &objval);
if ( status ) {
fprintf (stderr, "No MIP objective value available. Exiting...\n");
goto TERMINATE;
}
printf ("Solution value = %f\n", objval);
printf ("Solution vector:\n");
dumpx (env, lp);
status = CPXgetx (env, lp, x, 0, 2*NUMEDGES-1);
if ( status ) {
fprintf (stderr, "Failed to get optimal integer x.\n");
goto TERMINATE;
}
/* Make sure flow satisfies fixed-charge constraints */
for (j = 0; j < NUMEDGES; j++) {
if ( x[j] > 0.0001 && x[NUMEDGES+j] < 0.9999 ) {
printf ("WARNING : Edge from %d to %d has non-zero flow %.3f\n",
orig[j], dest[j], x[j]);
printf (" : fixed-charge indicator has value %.6f.\n",
x[NUMEDGES+j]);
}
}
printf("\n");
/* Finally, write a copy of the problem to a file. */
status = CPXwriteprob (env, lp, "fixnet.lp", NULL);
if ( status ) {
fprintf (stderr, "Failed to write LP to disk.\n");
goto TERMINATE;
}
/* Free problem */
status = CPXfreeprob (env, &lp);
if ( status ) {
fprintf (stderr, "CPXfreeprob failed, error code %d.\n", status);
goto TERMINATE;
}
TERMINATE:
/* Free up the problem as allocated by CPXcreateprob, if necessary */
if ( lp != NULL ) {
status = CPXfreeprob (env, &lp);
if ( status ) {
fprintf (stderr, "CPXfreeprob failed, error code %d.\n", status);
}
}
/* Free up the CPLEX environment, if necessary */
if ( env != NULL ) {
status = CPXcloseCPLEX (&env);
/* Note that CPXcloseCPLEX produces no output,
so the only way to see the cause of the error is to use
CPXgeterrorstring. For other CPLEX routines, the errors will
be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */
if ( status ) {
char errmsg[CPXMESSAGEBUFSIZE];
fprintf (stderr, "Could not close CPLEX environment.\n");
CPXgeterrorstring (env, status, errmsg);
fprintf (stderr, "%s", errmsg);
}
}
return (status);
} /* END main */
// solve the current problem
int cplex_solver::solve() {
int nb_objectives = objectives.size();
int mipstat, status;
// Presolving the problem
time_t ptime = time(NULL);
if (CPXpresolve(env, lp, CPX_ALG_NONE)) return 0;
time_t ctime = time(NULL);
_timeCount += difftime(ctime, ptime);
// Solve the objectives in a lexical order
for (int i = first_objective; i < nb_objectives; i++) {
ptime = ctime;
// Solve the mip problem
if (CPXmipopt (env, lp)) return ERROR;
ctime = time(NULL);
_solutionCount += CPXgetsolnpoolnumsolns(env, lp) + CPXgetsolnpoolnumreplaced(env, lp);
_timeCount += difftime(ctime, ptime);
_nodeCount += CPXgetnodecnt(env, lp);
// Get solution status
if ((mipstat = CPXgetstat(env, lp)) == CPXMIP_OPTIMAL) {
if (i < nb_objectives - 1) {
// Get next non empty objective
// (must be done here to avoid conflicting method calls
int previ = i, nexti, nexti_nb_coeffs = 0;
for (; i < nb_objectives - 1; i++) {
nexti = i + 1;
nexti_nb_coeffs = objectives[nexti]->nb_coeffs;
if (nexti_nb_coeffs > 0) break;
}
if (nexti_nb_coeffs > 0) { // there is one more objective to solve
// Set objective constraint value to objval
int index[1];
double values[1];
index[0] = previ;
values[0] = objective_value();
if (verbosity >= DEFAULT)
printf(">>>> Objective value %d = %f\n", previ, values[0]);
{
int status, begin[2];
double rhs[1];
begin[0] = 0;
rhs[0] = values[0]; //ub;
int n = objectives[previ]->nb_coeffs;
begin[1] = n - 1;
status = CPXaddrows(env, lp, 0, 1, n, rhs, "E", begin, objectives[previ]->sindex, objectives[previ]->coefficients, NULL, NULL);
if (status) {
fprintf(stderr, "cplex_solver: end_objective: cannot add %d objective as constraint.\n", i);
exit(-1);
}
}
// Set the new objective value
reset_coeffs();
// Set previous objective coefficients to zero
for (int k = 0; k < objectives[previ]->nb_coeffs; k++) set_coeff(objectives[previ]->sindex[k], 0);
// Set next objective coefficients to their actual values
for (int k = 0; k < nexti_nb_coeffs; k++) set_coeff(objectives[nexti]->sindex[k], objectives[nexti]->coefficients[k]);
// Do set the next objective
status = CPXchgobj(env, lp, nb_coeffs, sindex, coefficients);
if ( status ) {
fprintf (stderr,"Cannot change objective value. Exiting...\n");
exit(-1);
}
// Output model to file (when requested)
if (verbosity >= VERBOSE) {
char buffer[1024];
sprintf(buffer, "cplexpb-%d.lp", i);
writelp(buffer);
}
} else
return OPTIMUM;
} else
return OPTIMUM;
} else if( mipstat == CPXMIP_TIME_LIM_INFEAS ||
mipstat == CPXMIP_TIME_LIM_FEAS) {
return _solutionCount > 0 ? SAT : UNKNOWN;
} else {
if (verbosity >= DEFAULT)
fprintf(stderr, "CPLEX solution status = %d\n", mipstat);
return ERROR;
}
}
return 0;
}
int main(int argc, char **argv) {
char ejes[100];
char labels[100];
char test[100];
archivoInput = argv[1];
randomness = argv[2];
porcentajeParticiones = atof(argv[3]);
algoritmo = argv[4];
epsilonClique = atof(argv[5]);
epsilonAgujero = atof(argv[6]);
numeroDeModelo = atoi(argv[7]);
RECORRIDO_ARBOL = atoi(argv[8]);
VARIABLE_CORTE = atoi(argv[9]);
semilla = atoi(argv[10]);
srand(semilla);
if(not freopen(archivoInput.c_str(), "r", stdin)){
cout << "No pude abrir archivo: " << archivoInput << endl;
return 1;
}
sprintf(ejes, "ejes.out");
sprintf(labels, "labels.out");
if(randomness == "notrandom") {
sprintf(test, "%s%s", argv[1], argv[2]);
}
else if (randomness == "random") {
sprintf(test, "%s%s", argv[1], argv[3]);
}
else{
cout << "Paramtros mal introducidos" << endl;
return 0;
}
read(randomness); // cada elemento de la particion conformado por un unico nodo
// Le paso por parametro el algoritmo a implementar: bb = branch and bound, cb = cut and branch
if(algoritmo != "bb" && algoritmo != "cb") {
cout << "Error introduciendo parametro de algoritmo a ser aplicado " << endl;
return 0;
}
// ==============================================================================================
// Genero el problema de cplex.
int status;
// Creo el entorno.
CPXENVptr env = CPXopenCPLEX(&status); // Puntero al entorno.
CPXLPptr lp; // Puntero al LP
if (env == NULL) {
cerr << "Error creando el entorno" << endl;
exit(1);
}
///Iniciio el reloj
CPXgettime(env, &inittime);
// Creo el LP.
lp = CPXcreateprob(env, &status, "instancia coloreo de grafo particionado");
if (lp == NULL) {
cerr << "Error creando el LP" << endl;
exit(1);
}
// Definimos las variables. En total, son P + N*P variables ( las W[j] y las X[i][j] )
int cantVariables = P + N*P;
double *ub, *lb, *objfun; // Cota superior, cota inferior, coeficiente de la funcion objetivo.
char *xctype, **colnames; // tipo de la variable , string con el nombre de la variable.
ub = new double[cantVariables];
lb = new double[cantVariables];
objfun = new double[cantVariables];
xctype = new char[cantVariables];
colnames = new char*[cantVariables];
for (int i = 0; i < cantVariables; i++) {
ub[i] = 1.0; // seteo upper y lower bounds de cada variable
lb[i] = 0.0;
if(i < P) { // agrego el costo en la funcion objetivo de cada variables
objfun[i] = 1; // busco minimizar Sum(W_j) para j=0..P (la cantidad de colores utilizados).
}
else {
objfun[i] = 0; // los X[i][j] no contribuyen a la funcion objetivo
}
xctype[i] = 'B'; // 'C' es continua, 'B' binaria, 'I' Entera.
colnames[i] = new char[10];
}
/* Defino el tipo de variable BoolVarMatrix, que sera utilizado en la resolucion
* recordar: X_v_j = 1 sii el color j es asignado al vertice v
* recordar: W_j = 1 si X_v_j = 1 para al menos un vertice v
*/
for(int j=0; j<P; j++) {
sprintf(colnames[j], "W_%d", j);
// cout << colnames[j] << endl;
}
for(int i=0; i<N; i++) {
for(int j=0; j<P; j++) {
sprintf(colnames[xijIndice(i,j)], "X_%d_%d", i, j);
// cout << colnames[xijIndice(i,j)] << endl;
}
}
// ========================== Agrego las columnas. =========================== //
if(algoritmo == "cb"){
// si quiero resolver la relajacion, agregar los cortes y despues resolver el MIP, no agrego xctype
status = CPXnewcols(env, lp, cantVariables, objfun, lb, ub, NULL, colnames);
}
else if (algoritmo == "bb"){
// si quiero hacer MIP, directamente, con brancha and bound, agrego xctype
status = CPXnewcols(env, lp, cantVariables, objfun, lb, ub, xctype, colnames);
}
else {
cout << "Error: parametro de algoritmo bb/cb mal introducido" << endl;
return 0;
}
if (status) {
cerr << "Problema agregando las variables CPXnewcols" << endl;
exit(1);
}
// Libero las estructuras.
for (int i = 0; i < cantVariables; i++) {
delete[] colnames[i];
}
delete[] ub;
delete[] lb;
delete[] objfun;
delete[] xctype;
delete[] colnames;
// CPLEX por defecto minimiza. Le cambiamos el sentido a la funcion objetivo si se quiere maximizar.
// CPXchgobjsen(env, lp, CPX_MAX);
// ================================================================================================ //
// ===================================== Restricciones ============================================ //
// i) Asigno exactamente un color a exactamente un vertice de cada particion ( P restricciones )
// ii) Dos vertices adyacentes no pueden tener el mismo color ( E restricciones )
// iii) Los W_j estan bien armados, en funcion de X_v_j ( 2*P restricciones )
// ccnt = numero nuevo de columnas en las restricciones.
// rcnt = cuantas restricciones se estan agregando.
// nzcnt = # de coeficientes != 0 a ser agregados a la matriz. Solo se pasan los valores que no son cero.
int ccnt = 0;
int rcnt;
if(numeroDeModelo == 0){
rcnt = P + (E*P)/2 + 2*P; // Cota maxima a la cantidad de restricciones
}
else{
rcnt = P + (E*P)/2 + N*P;
}
// (E/2 porque en la entrada se supone que en la entrada me pasan 2 veces cada eje)
int nzcnt = 0; // al ppio es cero (para cada valor q agrego, lo voy a incrementar en 1)
char sense[rcnt]; // Sentido de la desigualdad. 'G' es mayor o igual y 'E' para igualdad, 'L' menor o igual
double *rhs = new double[rcnt]; // Termino independiente de las restricciones.
int *matbeg = new int[rcnt]; //Posicion en la que comienza cada restriccion en matind y matval.
int *matind = new int[rcnt*cantVariables]; // Array con los indices de las variables con coeficientes != 0 en la desigualdad.
double *matval = new double[rcnt*cantVariables]; // Array que en la posicion i tiene coeficiente ( != 0) de la variable matind[i] en la restriccion.
// CPLEX va a leer hasta la cantidad nzcnt que le pasemos.
int cantRestricciones = 0; // r = numero de restriccion
// i) P restricciones - exactamente un color a cada vertice (una restriccion por cada particion)
for(int particion = 0; particion < P; particion++) {
matbeg[cantRestricciones] = nzcnt;
rhs[cantRestricciones] = 1;
sense[cantRestricciones] = 'E';
for(int e = 0; e < S[particion].size(); e++) {
for(int color = 0; color < P; color++) {
matind[nzcnt] = xijIndice(S[particion][e], color);
matval[nzcnt] = 1;
nzcnt++;
}
}
cantRestricciones++;
}
// ii) Cota superior de (E*P)/2 restricciones mas
// Una para cada par de vecinos i j, para cada color pero solo cuando i < j, y estan en distinta particion
for(int i = 0; i < N; i++) {
for(int j = i + 1; j < N; j++) {
if(M[i][j] == 1 and dameParticion(i) != dameParticion(j)){
for(int color = 0; color < P; color++) {
matbeg[cantRestricciones] = nzcnt;
rhs[cantRestricciones] = 1;
sense[cantRestricciones] = 'L';
matind[nzcnt] = xijIndice(i,color);
matval[nzcnt] = 1;
nzcnt++;
matind[nzcnt] = xijIndice(j,color);
matval[nzcnt] = 1;
nzcnt++;
cantRestricciones++;
}
}
}
}
if(numeroDeModelo == 0){
// iii) 2*P restricciones mas
// - P * wj + sigma xij <= 0
for(int k=0; k<P; k++) { // para cada color
matbeg[cantRestricciones] = nzcnt;
rhs[cantRestricciones] = 0;
sense[cantRestricciones] = 'L';
matind[nzcnt] = k;
matval[nzcnt] = -1 * P;
nzcnt++;
for(int i=0; i<N; i++) {
matind[nzcnt] = xijIndice(i,k);
matval[nzcnt] = 1;
nzcnt++;
}
cantRestricciones++;
}
// - wj + sigma xij >= 0
for(int k=0; k<P; k++) {
matbeg[cantRestricciones] = nzcnt;
rhs[cantRestricciones] = 0;
sense[cantRestricciones] = 'G';
matind[nzcnt] = k;
matval[nzcnt] = -1;
nzcnt++;
for(int i=0; i<N; i++) {
matind[nzcnt] = xijIndice(i,k);
matval[nzcnt] = 1;
nzcnt++;
}
cantRestricciones++;
}
}
else{
// iii) N*P restricciones mas
// -wj + xij <= 0
for(int color = 0; color < P; color++) {
for(int i = 0; i < N; i++) {
matbeg[cantRestricciones] = nzcnt;
rhs[cantRestricciones] = 0;
sense[cantRestricciones] = 'L';
matind[nzcnt] = color;
matval[nzcnt] = -1;
nzcnt++;
matind[nzcnt] = xijIndice(i, color);
matval[nzcnt] = 1;
nzcnt++;
cantRestricciones++;
}
}
}
//Actualizo rcnt.
rcnt = cantRestricciones;
// ===================================================================================================
// Agregamos las restricciones al lp.
status = CPXaddrows(env, lp, ccnt, rcnt, nzcnt, rhs, sense, matbeg, matind, matval, NULL, NULL);
if (status) {
cerr << "Problema agregando restricciones." << endl;
exit(1);
}
delete[] rhs;
delete[] matbeg;
delete[] matind;
delete[] matval;
// ============================================================================================== //
// ================================== Optimizamos el problema. ================================== //
// Seteo de algunos parametros.
// Para desactivar la salida poner CPX_OFF.
status = CPXsetintparam(env, CPX_PARAM_SCRIND, CPX_ON);
if (status) {
cerr << "Problema seteando SCRIND" << endl;
exit(1);
}
// Setea el tiempo limite de ejecucion.
status = CPXsetdblparam(env, CPX_PARAM_TILIM, TIEMPO_LIMITE); // setear limite de tiempo en 3600 !!!!!!!
if (status) {
cerr << "Problema seteando el tiempo limite" << endl;
exit(1);
}
// Escribimos el problema a un archivo .lp.
// status = CPXwriteprob(env, lp, "test.lp", NULL);
if (status) {
cerr << "Problema escribiendo modelo" << endl;
exit(1);
}
// Seteamos algunos parametros para resolver con branch and bound
CPXsetintparam(env, CPX_PARAM_MIPSEARCH, CPX_MIPSEARCH_TRADITIONAL);
// Para facilitar la comparación evitamos paralelismo:
CPXsetintparam(env, CPX_PARAM_THREADS, 1);
//Para que no se adicionen planos de corte:
CPXsetintparam(env,CPX_PARAM_EACHCUTLIM, 0);
CPXsetintparam(env, CPX_PARAM_FRACCUTS, -1);
CPXsetintparam(env, CPX_PARAM_LANDPCUTS, -1);
// Para que no haga preprocesamientos
CPXsetintparam(env, CPX_PARAM_PRESLVND, -1);
CPXsetintparam(env, CPX_PARAM_REPEATPRESOLVE, 0);
CPXsetintparam(env, CPX_PARAM_RELAXPREIND, 0);
CPXsetintparam(env, CPX_PARAM_REDUCE, 0);
// Recorrido del arbol
CPXsetintparam(env, CPX_PARAM_NODESEL, RECORRIDO_ARBOL);
// Seleccion de variable
CPXsetintparam(env, CPX_PARAM_VARSEL, VARIABLE_CORTE);
CPXgettime(env, &endtime);
tiempoPreparar = endtime - inittime;
inittime = endtime;
// =========================================================================================================
// resuelvo con cut and branch (con los cortes definidos por nosotros) o con branch and bound (y sin cortes)
// =========================================================================================================
if(algoritmo == "cb") {
// while (algo) ... resolver el lp, chequear si la restr inducida por la clique actual es violada. Seguir
//cout << "antes" << endl;
for(int ciclocb=0; ciclocb<CANT_CICLOS_CB; ciclocb++) {
status = CPXlpopt(env, lp);
//cout << "despues" << endl;
double objval;
status = CPXgetobjval(env, lp, &objval);
// Aca, deberia agregar los cortes requeridos, en funcion de "cliques" y "objval"
// mostrameValores(env, lp);
double *sol = new double[cantVariables];
CPXgetx(env, lp, sol, 0, cantVariables - 1);
//CPXwriteprob (env, lp, "antesDeClique.lp", "LP");
// BUSCAR Y AGREGAR CLIQUE
vector < vector<int> > agregados;
for(int color=0; color<P; color++) {
for(int i=0; i<CANT_RESTR_CLIQUES; i++) {
bool iteracionRandom = (i!=0);
vector<int> clique = dameClique(sol, color, iteracionRandom);
sort(clique.begin(), clique.end());
bool incluido = find(agregados.begin(), agregados.end(), clique) != agregados.end();
if (not incluido and not clique.empty()) {
agregados.push_back(clique);
agregarRestriccionClique(env, lp, clique);
cantidadCortesClique++;
// cout << "AGREGO RESTRICCION DE CLIQUE de random " << iteracionRandom << " y de color #"<< color << ": ";
// for(int j=0; j<clique.size(); j++) {
// cout << clique[j] << " ";
// }
// cout << endl;
}
}
}
// BUSCAR Y AGREGAR AGUJERO
agregados.clear();
for(int color=0; color<P; color++) {
for(int i=0; i<CANT_RESTR_AGUJEROS; i++) {
vector<int> agujero = dameAgujero(sol, color);
bool incluido = find(agregados.begin(), agregados.end(), agujero) != agregados.end();
if (not incluido and not agujero.empty()) {
agregados.push_back(agujero);
agregarRestriccionAgujero(env, lp, agujero);
cantidadCortesAgujero++;
// cout << "AGREGO RESTRICCION DE AGUJERO de color #"<< color << ": ";
// for(int j=0; j<agujero.size(); j++) {
// cout << agujero[j] << " ";
// }
// cout << endl;
}
}
}
delete [] sol;
}
// CPXwriteprob (env, lp, "lpCB.lp", "LP");
///Cuando salimos, pasamos a binaria y corremos un branch and bound
char *ctype = new char[cantVariables];
for (int i = 0; i < cantVariables; i++) {
ctype[i] = 'B';
}
// cout << "Antes cambiar tipo" << endl;
status = CPXcopyctype (env, lp, ctype);
// cout << "Despues cambiar tipo" << endl;
delete[] ctype;
CPXgettime(env, &endtime);
tiempoCutAndBranch = endtime - inittime;
inittime = endtime;
}
///Corremos el BB, ya sea porque esto es lo que queriamos originalemente, o porque terminamos con los planos de corte
// cout << "ANTES" << endl;
//CPXwriteprob (env, lp, "antesDeMip.lp", "LP");
CPXmipopt(env,lp);
// cout << "DESPUES" << endl;
CPXgettime(env, &endtime);
tiempoBranchAndBound = endtime - inittime;
// inittime = endtime;
status = CPXgettime(env, &endtime);
if (status) {
cerr << "Problema optimizando CPLEX" << endl;
exit(1);
}
// Chequeamos el estado de la solucion.
int solstat;
char statstring[510];
CPXCHARptr p;
solstat = CPXgetstat(env, lp);
p = CPXgetstatstring(env, solstat, statstring);
string statstr(statstring);
cout << endl << "Resultado de la optimizacion: " << statstring << endl;
if(solstat!=CPXMIP_OPTIMAL && solstat!=CPXMIP_OPTIMAL_TOL && solstat!=CPXMIP_NODE_LIM_FEAS && solstat!=CPXMIP_TIME_LIM_FEAS){
cout << "No hay solucion" << endl;
}
else{
double objval;
status = CPXgetobjval(env, lp, &objval);
if (status) {
cerr << "Problema obteniendo valor de mejor solucion." << endl;
exit(1);
}
cout << "Datos de la resolucion: " << "\t" << objval << "\t" << tiempoPreparar + tiempoCutAndBranch + tiempoBranchAndBound << endl;
cout << "Tiempo en preparar: " << "\t" << tiempoPreparar << endl;
cout << "Tiempo en CB: " << "\t" << tiempoCutAndBranch << endl;
cout << "Tiempo en BB: " << "\t" << tiempoBranchAndBound << endl;
// Tomamos los valores de todas las variables. Estan numeradas de 0 a n-1.
double *sol = new double[cantVariables];
status = CPXgetx(env, lp, sol, 0, cantVariables - 1);
if (status) {
cerr << "Problema obteniendo la solucion del LP." << endl;
exit(1);
}
impresionModelo(env, lp);
// Solo escribimos las variables distintas de cero (tolerancia, 1E-05).
//solfile << "Status de la solucion: " << statstr << endl;
// for(int j=0; j<P; j++) {
// if(sol[j] > TOL) {
// cout << "W_" << j << " = " << sol[j] << endl;
// }
// }
// for(int i=0; i<N; i++) {
// for(int j=0; j<P; j++) {
// if(sol[P + P*i + j] > TOL) {
// cout << "X_" << i << "_" << j << " = " << sol[P+P*i+j] << endl;
// }
// }
// }
//solfile.close();
// ==================== Devuelvo el grafo resultante coloreado, para graficar! ====================== //
// ofstream streamEjes, streamLabels;
//ofstream streamParticiones;
// Tomamos los valores de la solucion y los escribimos a un archivo.
// streamEjes.open(ejes);
// for(int v1=0; v1<N; v1++) {
// for(int v2=v1+1; v2<N; v2++) {
// if (M[v1][v2] == 1) {
// streamEjes << v1+1 << " " << v2+1 << endl;
// }
// }
// } streamEjes.close();
// cout << ejes << endl;
// streamLabels.open(labels);
// bool estaColoreado;
// for(int v=0; v<N; v++){
// estaColoreado = false;
// for(int j=0; j<P; j++){
// if (sol[P + P*v + j] == 1) {
// streamLabels << v+1 << " " << j+1 << endl;
// estaColoreado = true;
// }
// }
// if(not estaColoreado) {
// streamLabels << v+1 << " " << 0 << endl;
// }
// }
// streamLabels.close();
// delete [] sol;
}
return 0;
}
//==========================================================================
// This function solves the expected value problem
int
DDSIP_ExpValProb (void)
{
int status, j, mipstatus, nodes_1st = -1;
int wall_hrs, wall_mins,cpu_hrs, cpu_mins;
double objval, bobjval, time_start, time_end, wall_secs, cpu_secs, gap;
char fname[DDSIP_ln_fname];
double *mipx = (double *) DDSIP_Alloc (sizeof (double), (DDSIP_bb->firstvar + DDSIP_bb->secvar),
"mipx(ExpValProb)");
printf ("Solving expected value problem\n");
if (DDSIP_param->outlev)
fprintf (DDSIP_bb->moreoutfile, "Solving expected value problem...\n");
status = DDSIP_ChgProb (-1, 0);
if (status)
{
fprintf (stderr, "ERROR: Failed to change problem \n");
goto TERMINATE;
}
if (DDSIP_param->files > 1)
{
sprintf (fname, "%s/ev%s", DDSIP_outdir, DDSIP_param->coretype);
status = CPXwriteprob (DDSIP_env, DDSIP_lp, fname, NULL);
if (status)
{
fprintf (stderr, "ERROR: Failed to write problem\n");
goto TERMINATE;
}
}
// New cplex parameters
if (DDSIP_param->cpxnoeev)
{
status = DDSIP_SetCpxPara (DDSIP_param->cpxnoeev, DDSIP_param->cpxeevisdbl, DDSIP_param->cpxeevwhich, DDSIP_param->cpxeevwhat);
if (status)
{
fprintf (stderr, "ERROR: Failed to set CPLEX parameters (ExpValProb) \n");
goto TERMINATE;
}
}
time_start = DDSIP_GetCpuTime ();
mipstatus = CPXmipopt (DDSIP_env, DDSIP_lp);
// Reset cplex parameters
if (DDSIP_param->cpxnoeev)
{
status = DDSIP_SetCpxPara (DDSIP_param->cpxno, DDSIP_param->cpxisdbl, DDSIP_param->cpxwhich, DDSIP_param->cpxwhat);
if (status)
{
fprintf (stderr, "ERROR: Failed to reset CPLEX parameters (ExpValProb) \n");
goto TERMINATE;
}
}
if (DDSIP_Error (mipstatus))
{
fprintf (stderr, "ERROR: Failed to optimize EXP\n");
status = mipstatus;
goto TERMINATE;
}
// Error ? (blatant infeasible, scenario problem limit)
if (DDSIP_Infeasible (mipstatus))
{
status = 1;
goto TERMINATE;
}
// No solution found ? (integer infeasible, some limit (node, time))
mipstatus = CPXgetstat (DDSIP_env, DDSIP_lp);
if (DDSIP_NoSolution (mipstatus))
{
status = 1;
goto TERMINATE;
}
status = CPXgetx (DDSIP_env, DDSIP_lp, mipx, 0, DDSIP_bb->firstvar + DDSIP_bb->secvar - 1);
if (status)
{
fprintf (stderr, "ERROR: Failed to get solution \n");
goto TERMINATE;
}
// output of result
if (DDSIP_param->outlev)
{
status = CPXgetobjval (DDSIP_env, DDSIP_lp, &objval);
if (status)
{
fprintf (stderr, "ERROR*: Failed to get best objective value \n");
fprintf (DDSIP_outfile, "ERROR*: Failed to get best objective value \n");
if (DDSIP_param->outlev)
fprintf (DDSIP_bb->moreoutfile, "ERROR*: Failed to get best objective value \n");
goto TERMINATE;
}
if (mipstatus == CPXMIP_OPTIMAL)
{
bobjval = objval;
}
else
{
status = CPXgetbestobjval (DDSIP_env, DDSIP_lp, &bobjval);
if (status)
{
fprintf (stderr, "ERROR: Failed to get value of best remaining node\n");
fprintf (DDSIP_outfile, "ERROR: Failed to get value of best remaining node\n");
if (DDSIP_param->outlev)
fprintf (DDSIP_bb->moreoutfile, "ERROR: Failed to get value of best remaining node\n");
goto TERMINATE;
}
}
gap = 100.0*(objval-bobjval)/(fabs(objval)+1e-4);
nodes_1st = CPXgetnodecnt (DDSIP_env,DDSIP_lp);
time_end = DDSIP_GetCpuTime ();
time_start = time_end-time_start;
time (&DDSIP_bb->cur_time);
DDSIP_translate_time (difftime(DDSIP_bb->cur_time,DDSIP_bb->start_time),&wall_hrs,&wall_mins,&wall_secs);
DDSIP_translate_time (time_end,&cpu_hrs,&cpu_mins,&cpu_secs);
if (mipstatus == CPXMIP_OPTIMAL)
fprintf (DDSIP_bb->moreoutfile,
" exp. val. prob: Best=%-20.14g\tBound=%-20.14g (%9.4g%%) \t %3dh %02d:%02.0f / %3dh %02d:%05.2f (%6.2fs n: %4d)",
objval, bobjval, gap,
wall_hrs,wall_mins,wall_secs,cpu_hrs,cpu_mins,cpu_secs, time_start, nodes_1st);
else if (mipstatus == CPXMIP_OPTIMAL_TOL)
fprintf (DDSIP_bb->moreoutfile,
" exp. val. prob: Best=%-20.14g\tBound=%-20.14g (%9.4g%%) tol.\t %3dh %02d:%02.0f / %3dh %02d:%05.2f (%6.2fs n: %4d)",
objval, bobjval, gap,
wall_hrs,wall_mins,wall_secs,cpu_hrs,cpu_mins,cpu_secs, time_start, nodes_1st);
else if (mipstatus == CPXMIP_TIME_LIM_FEAS)
fprintf (DDSIP_bb->moreoutfile,
" exp. val. prob: Best=%-20.14g\tBound=%-20.14g (%9.4g%%) TIME\t %3dh %02d:%02.0f / %3dh %02d:%05.2f (%6.2fs n: %4d)",
objval, bobjval, gap,
wall_hrs,wall_mins,wall_secs,cpu_hrs,cpu_mins,cpu_secs, time_start, nodes_1st);
else
fprintf (DDSIP_bb->moreoutfile,
" exp. val. prob: Best=%-20.14g\tBound=%-20.14g (%9.4g%%) %-4d\t %3dh %02d:%02.0f / %3dh %02d:%05.2f (%6.2fs n: %4d)",
objval, bobjval, gap, mipstatus,
wall_hrs,wall_mins,wall_secs,cpu_hrs,cpu_mins,cpu_secs, time_start, nodes_1st);
}
// Returns sometimes rubbish, don't know why..
if (!DDSIP_bb->adv_sol)
DDSIP_bb->adv_sol = (double *) DDSIP_Alloc (sizeof (double), DDSIP_bb->firstvar, "DDSIP_bb->adv_sol(sipread)");
for (j = 0; j < DDSIP_bb->firstvar; j++)
{
// Numerical errors ?
if (DDSIP_Equal (mipx[DDSIP_bb->firstindex[j]], 0.0))
mipx[DDSIP_bb->firstindex[j]] = 0.0;
DDSIP_bb->adv_sol[j] = mipx[DDSIP_bb->firstindex[j]];
}
TERMINATE:
DDSIP_Free ((void **) &(mipx));
return status;
}
int
main (int argc,
char *argv[])
{
int status = 0;
/* Declare and allocate space for the variables and arrays where
we will store the optimization results, including the status,
objective value, and variable values */
int solstat;
double objval, relobj;
double *x = NULL;
MYCB info;
CPXENVptr env = NULL;
CPXLPptr lp = NULL;
CPXLPptr lpclone = NULL;
int j;
int cur_numcols;
/* Check the command line arguments */
if ( argc != 2 ) {
usage (argv[0]);
goto TERMINATE;
}
/* Initialize the CPLEX environment */
env = CPXopenCPLEX (&status);
/* If an error occurs, the status value indicates the reason for
failure. A call to CPXgeterrorstring will produce the text of
the error message. Note that CPXopenCPLEX produces no
output, so the only way to see the cause of the error is to use
CPXgeterrorstring. For other CPLEX routines, the errors will
be seen if the CPXPARAM_ScreenOutput parameter is set to CPX_ON */
if ( env == NULL ) {
char errmsg[CPXMESSAGEBUFSIZE];
fprintf (stderr, "Could not open CPLEX environment.\n");
CPXgeterrorstring (env, status, errmsg);
fprintf (stderr, "%s", errmsg);
goto TERMINATE;
}
/* Turn on output to the screen */
status = CPXsetintparam (env, CPXPARAM_ScreenOutput, CPX_ON);
if ( status ) {
fprintf (stderr,
"Failure to turn on screen indicator, error %d.\n",
status);
goto TERMINATE;
}
/* Turn on traditional search for use with control callbacks */
status = CPXsetintparam (env, CPXPARAM_MIP_Strategy_Search,
CPX_MIPSEARCH_TRADITIONAL);
if ( status ) goto TERMINATE;
/* Create the problem, using the filename as the problem name */
lp = CPXcreateprob (env, &status, argv[1]);
/* A returned pointer of NULL may mean that not enough memory
was available or there was some other problem. In the case of
failure, an error message will have been written to the error
channel from inside CPLEX. In this example, the setting of
the parameter CPXPARAM_ScreenOutput causes the error message to
appear on stdout. Note that most CPLEX routines return
an error code to indicate the reason for failure */
if ( lp == NULL ) {
fprintf (stderr, "Failed to create LP.\n");
goto TERMINATE;
}
/* Now read the file, and copy the data into the created lp */
status = CPXreadcopyprob (env, lp, argv[1], NULL);
if ( status ) {
fprintf (stderr,
"Failed to read and copy the problem data.\n");
goto TERMINATE;
}
/* We transfer a problem with semi-continuous or semi-integer
variables to a MIP problem by adding variables and
constraints. So in MIP callbacks, the size of the problem
is changed and this example won't work for such problems */
if ( CPXgetnumsemicont (env, lp) + CPXgetnumsemiint (env, lp) ) {
fprintf (stderr,
"Not for problems with semi-continuous or semi-integer variables.\n");
goto TERMINATE;
}
/* The size of the problem should be obtained by asking CPLEX what
the actual size is. cur_numcols store the current number
of columns */
cur_numcols = CPXgetnumcols (env, lp);
x = (double *) malloc (cur_numcols * sizeof (double));
if ( x == NULL ) {
fprintf (stderr, "Memory allocation failed.\n");
goto TERMINATE;
}
/* Solve relaxation of MIP */
/* Clone original model */
lpclone = CPXcloneprob (env, lp, &status);
if ( status ) {
fprintf (stderr, "Failed to clone problem.\n");
goto TERMINATE;
}
/* Relax */
status = CPXchgprobtype (env, lpclone, CPXPROB_LP);
if ( status ) {
fprintf (stderr, "Failed to relax problem.\n");
goto TERMINATE;
}
/* Solve LP relaxation of original model using "default"
LP solver */
status = CPXlpopt (env, lpclone);
if ( status ) {
fprintf (stderr, "Failed to solve relaxation.\n");
goto TERMINATE;
}
status = CPXsolution (env, lpclone, NULL, &relobj, x, NULL,
NULL, NULL);
if ( status ) {
fprintf (stderr, "Failed to extract solution.\n");
goto TERMINATE;
}
printf ("Solution status = %d", CPXgetstat(env,lpclone));
printf ("\nLP relaxation objective: %.4e\n\n", relobj);
/* Set up solve callback */
info.count = 0;
info.mip = lp;
info.relx = x;
status = CPXsetsolvecallbackfunc (env, &solvecallback,
(void *) &info);
if ( status ) {
fprintf (stderr, "Failed to set solve callback.\n");
goto TERMINATE;
}
/* Optimize the problem and obtain solution */
status = CPXmipopt (env, lp);
if ( status ) {
fprintf (stderr, "Failed to optimize MIP.\n");
goto TERMINATE;
}
solstat = CPXgetstat (env, lp);
status = CPXgetobjval (env, lp, &objval);
if ( status ) {
fprintf (stderr,"Failed to obtain objective value.\n");
goto TERMINATE;
}
printf ("Solution status %d.\n", solstat);
printf ("Objective value %.10g\n", objval);
status = CPXgetx (env, lp, x, 0, cur_numcols-1);
if ( status ) {
fprintf (stderr, "Failed to obtain solution.\n");
goto TERMINATE;
}
/* Write out the solution */
for (j = 0; j < cur_numcols; j++) {
if ( fabs (x[j]) > 1e-10 ) {
printf ( "Column %d: Value = %17.10g\n", j, x[j]);
}
}
TERMINATE:
/* Free the solution vector */
free_and_null ((char **) &x);
/* Free the problem as allocated by CPXcreateprob and
CPXreadcopyprob, if necessary */
if ( lp != NULL ) {
status = CPXfreeprob (env, &lp);
if ( status ) {
fprintf (stderr, "CPXfreeprob failed, error code %d.\n",
status);
}
}
/* Free the cloned lp as allocated by CPXcloneprob,
if necessary */
if ( lpclone != NULL ) {
status = CPXfreeprob (env, &lpclone);
if ( status ) {
fprintf (stderr, "CPXfreeprob failed, error code %d.\n",
status);
}
}
/* Free the CPLEX environment, if necessary */
if ( env != NULL ) {
status = CPXcloseCPLEX (&env);
/* Note that CPXcloseCPLEX produces no output, so the only
way to see the cause of the error is to use
CPXgeterrorstring. For other CPLEX routines, the errors
will be seen if the CPXPARAM_ScreenOutput parameter is set to
CPX_ON */
if ( status ) {
char errmsg[CPXMESSAGEBUFSIZE];
fprintf (stderr, "Could not close CPLEX environment.\n");
CPXgeterrorstring (env, status, errmsg);
fprintf (stderr, "%s", errmsg);
}
}
return (status);
} /* END main */
int
main (int argc,
char *argv[])
{
int status = 0;
/* Declare and allocate space for the variables and arrays where
we will store the optimization results, including the status,
objective value, and variable values */
int solstat;
double objval;
double *x = NULL;
CPXENVptr env = NULL;
CPXLPptr lp = NULL;
int j;
int cur_numcols;
int wantorig = 1;
int nameind = 1;
/* Check the command line arguments */
if ( argc != 2 ) {
if ( argc != 3 ||
argv[1][0] != '-' ||
argv[1][1] != 'r' ) {
usage (argv[0]);
goto TERMINATE;
}
wantorig = 0;
nameind = 2;
}
/* Initialize the CPLEX environment */
env = CPXopenCPLEX (&status);
/* If an error occurs, the status value indicates the reason for
failure. A call to CPXgeterrorstring will produce the text of
the error message. Note that CPXopenCPLEX produces no
output, so the only way to see the cause of the error is to use
CPXgeterrorstring. For other CPLEX routines, the errors will
be seen if the CPXPARAM_ScreenOutput parameter is set to CPX_ON */
if ( env == NULL ) {
char errmsg[CPXMESSAGEBUFSIZE];
fprintf (stderr, "Could not open CPLEX environment.\n");
CPXgeterrorstring (env, status, errmsg);
fprintf (stderr, "%s", errmsg);
goto TERMINATE;
}
/* Turn on output to the screen */
status = CPXsetintparam (env, CPXPARAM_ScreenOutput, CPX_ON);
if ( status != 0 ) {
fprintf (stderr,
"Failure to turn on screen indicator, error %d.\n",
status);
goto TERMINATE;
}
/* Create the problem, using the filename as the problem name */
lp = CPXcreateprob (env, &status, argv[nameind]);
/* A returned pointer of NULL may mean that not enough memory
was available or there was some other problem. In the case of
failure, an error message will have been written to the error
channel from inside CPLEX. In this example, the setting of
the parameter CPXPARAM_ScreenOutput causes the error message to
appear on stdout. Note that most CPLEX routines return
an error code to indicate the reason for failure */
if ( lp == NULL ) {
fprintf (stderr, "Failed to create LP.\n");
goto TERMINATE;
}
/* Now read the file, and copy the data into the created lp */
status = CPXreadcopyprob (env, lp, argv[nameind], NULL);
if ( status ) {
fprintf (stderr,
"Failed to read and copy the problem data.\n");
goto TERMINATE;
}
if ( CPXgetnumcols (env, lp) != CPXgetnumbin (env, lp) ) {
fprintf (stderr, "Problem contains non-binary variables, exiting\n");
goto TERMINATE;
}
/* Set parameters */
if ( wantorig ) {
/* Assure linear mappings between the presolved and original
models */
status = CPXsetintparam (env, CPXPARAM_Preprocessing_Linear, 0);
if ( status ) goto TERMINATE;
/* Let MIP callbacks work on the original model */
status = CPXsetintparam (env, CPXPARAM_MIP_Strategy_CallbackReducedLP,
CPX_OFF);
if ( status ) goto TERMINATE;
}
status = CPXsetdblparam (env, CPXPARAM_MIP_Tolerances_MIPGap,
(double) 1e-6);
if ( status ) goto TERMINATE;
/* Turn on traditional search for use with control callbacks */
status = CPXsetintparam (env, CPXPARAM_MIP_Strategy_Search,
CPX_MIPSEARCH_TRADITIONAL);
if ( status ) goto TERMINATE;
/* Set up to use MIP callback */
status = CPXsetheuristiccallbackfunc (env, rounddownheur, NULL);
if ( status ) goto TERMINATE;
/* Optimize the problem and obtain solution */
status = CPXmipopt (env, lp);
if ( status ) {
fprintf (stderr, "Failed to optimize MIP.\n");
goto TERMINATE;
}
solstat = CPXgetstat (env, lp);
printf ("Solution status %d.\n", solstat);
status = CPXgetobjval (env, lp, &objval);
if ( status ) {
fprintf (stderr, "Failed to obtain objective value.\n");
goto TERMINATE;
}
printf ("Objective value %.10g\n", objval);
cur_numcols = CPXgetnumcols (env, lp);
/* Allocate space for solution */
x = (double *) malloc (cur_numcols * sizeof (double));
if ( x == NULL ) {
fprintf (stderr, "No memory for solution values.\n");
goto TERMINATE;
}
status = CPXgetx (env, lp, x, 0, cur_numcols-1);
if ( status ) {
fprintf (stderr, "Failed to obtain solution.\n");
goto TERMINATE;
}
/* Write out the solution */
for (j = 0; j < cur_numcols; j++) {
if ( fabs (x[j]) > 1e-10 ) {
printf ( "Column %d: Value = %17.10g\n", j, x[j]);
}
}
TERMINATE:
/* Free the solution vector */
free_and_null ((char **) &x);
/* Free the problem as allocated by CPXcreateprob and
CPXreadcopyprob, if necessary */
if ( lp != NULL ) {
status = CPXfreeprob (env, &lp);
if ( status ) {
fprintf (stderr, "CPXfreeprob failed, error code %d.\n",
status);
}
}
/* Free the CPLEX environment, if necessary */
if ( env != NULL ) {
status = CPXcloseCPLEX (&env);
/* Note that CPXcloseCPLEX produces no output, so the only
way to see the cause of the error is to use
CPXgeterrorstring. For other CPLEX routines, the errors
will be seen if the CPXPARAM_ScreenOutput parameter is set to
CPX_ON */
if ( status ) {
char errmsg[CPXMESSAGEBUFSIZE];
fprintf (stderr, "Could not close CPLEX environment.\n");
CPXgeterrorstring (env, status, errmsg);
fprintf (stderr, "%s", errmsg);
}
}
return (status);
} /* END main */
int
main (void)
{
/* Declare pointers for the variables and arrays that will contain
the data which define the LP problem. The setproblemdata() routine
allocates space for the problem data. */
char *probname = NULL;
int numcols;
int numrows;
int objsen;
double *obj = NULL;
double *rhs = NULL;
char *sense = NULL;
int *matbeg = NULL;
int *matcnt = NULL;
int *matind = NULL;
double *matval = NULL;
double *lb = NULL;
double *ub = NULL;
char *ctype = NULL;
/* Declare and allocate space for the variables and arrays where we will
store the optimization results including the status, objective value,
variable values, and row slacks. */
int solstat;
double objval;
double x[NUMCOLS];
double slack[NUMROWS];
CPXENVptr env = NULL;
CPXLPptr lp = NULL;
int status;
int i, j;
int cur_numrows, cur_numcols;
/* Initialize the CPLEX environment */
env = CPXopenCPLEX (&status);
/* If an error occurs, the status value indicates the reason for
failure. A call to CPXgeterrorstring will produce the text of
the error message. Note that CPXopenCPLEX produces no output,
so the only way to see the cause of the error is to use
CPXgeterrorstring. For other CPLEX routines, the errors will
be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */
if ( env == NULL ) {
char errmsg[CPXMESSAGEBUFSIZE];
fprintf (stderr, "Could not open CPLEX environment.\n");
CPXgeterrorstring (env, status, errmsg);
fprintf (stderr, "%s", errmsg);
goto TERMINATE;
}
/* Turn on output to the screen */
status = CPXsetintparam (env, CPXPARAM_ScreenOutput, CPX_ON);
if ( status ) {
fprintf (stderr,
"Failure to turn on screen indicator, error %d.\n", status);
goto TERMINATE;
}
/* Fill in the data for the problem. */
status = setproblemdata (&probname, &numcols, &numrows, &objsen, &obj,
&rhs, &sense, &matbeg, &matcnt, &matind, &matval,
&lb, &ub, &ctype);
if ( status ) {
fprintf (stderr, "Failed to build problem data arrays.\n");
goto TERMINATE;
}
/* Create the problem. */
lp = CPXcreateprob (env, &status, probname);
/* A returned pointer of NULL may mean that not enough memory
was available or there was some other problem. In the case of
failure, an error message will have been written to the error
channel from inside CPLEX. In this example, the setting of
the parameter CPXPARAM_ScreenOutput causes the error message to
appear on stdout. */
if ( lp == NULL ) {
fprintf (stderr, "Failed to create LP.\n");
goto TERMINATE;
}
/* Now copy the problem data into the lp */
status = CPXcopylp (env, lp, numcols, numrows, objsen, obj, rhs,
sense, matbeg, matcnt, matind, matval,
lb, ub, NULL);
if ( status ) {
fprintf (stderr, "Failed to copy problem data.\n");
goto TERMINATE;
}
/* Now copy the ctype array */
status = CPXcopyctype (env, lp, ctype);
if ( status ) {
fprintf (stderr, "Failed to copy ctype\n");
goto TERMINATE;
}
/* Optimize the problem and obtain solution. */
status = CPXmipopt (env, lp);
if ( status ) {
fprintf (stderr, "Failed to optimize MIP.\n");
goto TERMINATE;
}
solstat = CPXgetstat (env, lp);
/* Write the output to the screen. */
printf ("\nSolution status = %d\n", solstat);
status = CPXgetobjval (env, lp, &objval);
if ( status ) {
fprintf (stderr,"No MIP objective value available. Exiting...\n");
goto TERMINATE;
}
printf ("Solution value = %f\n\n", objval);
/* The size of the problem should be obtained by asking CPLEX what
the actual size is, rather than using what was passed to CPXcopylp.
cur_numrows and cur_numcols store the current number of rows and
columns, respectively. */
cur_numrows = CPXgetnumrows (env, lp);
cur_numcols = CPXgetnumcols (env, lp);
status = CPXgetx (env, lp, x, 0, cur_numcols-1);
if ( status ) {
fprintf (stderr, "Failed to get optimal integer x.\n");
goto TERMINATE;
}
status = CPXgetslack (env, lp, slack, 0, cur_numrows-1);
if ( status ) {
fprintf (stderr, "Failed to get optimal slack values.\n");
goto TERMINATE;
}
for (i = 0; i < cur_numrows; i++) {
printf ("Row %d: Slack = %10f\n", i, slack[i]);
}
for (j = 0; j < cur_numcols; j++) {
printf ("Column %d: Value = %10f\n", j, x[j]);
}
/* Finally, write a copy of the problem to a file. */
status = CPXwriteprob (env, lp, "mipex1.lp", NULL);
if ( status ) {
fprintf (stderr, "Failed to write LP to disk.\n");
goto TERMINATE;
}
TERMINATE:
/* Free up the problem as allocated by CPXcreateprob, if necessary */
if ( lp != NULL ) {
status = CPXfreeprob (env, &lp);
if ( status ) {
fprintf (stderr, "CPXfreeprob failed, error code %d.\n", status);
}
}
/* Free up the CPLEX environment, if necessary */
if ( env != NULL ) {
status = CPXcloseCPLEX (&env);
/* Note that CPXcloseCPLEX produces no output,
so the only way to see the cause of the error is to use
CPXgeterrorstring. For other CPLEX routines, the errors will
be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */
if ( status ) {
char errmsg[CPXMESSAGEBUFSIZE];
fprintf (stderr, "Could not close CPLEX environment.\n");
CPXgeterrorstring (env, status, errmsg);
fprintf (stderr, "%s", errmsg);
}
}
/* Free up the problem data arrays, if necessary. */
free_and_null ((char **) &probname);
free_and_null ((char **) &obj);
free_and_null ((char **) &rhs);
free_and_null ((char **) &sense);
free_and_null ((char **) &matbeg);
free_and_null ((char **) &matcnt);
free_and_null ((char **) &matind);
free_and_null ((char **) &matval);
free_and_null ((char **) &lb);
free_and_null ((char **) &ub);
free_and_null ((char **) &ctype);
return (status);
} /* END main */
int
main (int argc, char *argv[])
{
int status = 0;
/* Declare and allocate space for the variables and arrays where
we will store the optimization results, including the status,
objective value, and variable values */
int solstat;
double objval;
double *x = NULL;
CPXENVptr env = NULL;
CPXLPptr lp = NULL;
int j;
int cur_numcols;
const char * datadir = argc <= 1 ? "../../../examples/data" : argv[1];
char *noswot = NULL;
noswot = (char *) malloc (strlen (datadir) + 1 + strlen("noswot.mps") + 1);
sprintf (noswot, "%s/noswot.mps", datadir);
/* Initialize the CPLEX environment */
env = CPXopenCPLEX (&status);
/* If an error occurs, the status value indicates the reason for
failure. A call to CPXgeterrorstring will produce the text of
the error message. Note that CPXopenCPLEX produces no
output, so the only way to see the cause of the error is to use
CPXgeterrorstring. For other CPLEX routines, the errors will
be seen if the CPXPARAM_ScreenOutput parameter is set to CPX_ON */
if ( env == NULL ) {
char errmsg[CPXMESSAGEBUFSIZE];
fprintf (stderr, "Could not open CPLEX environment.\n");
CPXgeterrorstring (env, status, errmsg);
fprintf (stderr, "%s", errmsg);
goto TERMINATE;
}
/* Turn on output to the screen */
status = CPXsetintparam (env, CPXPARAM_ScreenOutput, CPX_ON);
if ( status != 0 ) {
fprintf (stderr,
"Failure to turn on screen indicator, error %d.\n",
status);
goto TERMINATE;
}
CPXsetintparam (env, CPXPARAM_MIP_Interval, 1000);
/* Create the problem, using the filename as the problem name */
lp = CPXcreateprob (env, &status, "noswot");
/* A returned pointer of NULL may mean that not enough memory
was available or there was some other problem. In the case of
failure, an error message will have been written to the error
channel from inside CPLEX. In this example, the setting of
the parameter CPXPARAM_ScreenOutput causes the error message to
appear on stdout. Note that most CPLEX routines return
an error code to indicate the reason for failure */
if ( lp == NULL ) {
fprintf (stderr, "Failed to create LP.\n");
goto TERMINATE;
}
/* Now read the file, and copy the data into the created lp */
status = CPXreadcopyprob (env, lp, noswot, NULL);
if ( status ) {
fprintf (stderr,
"Failed to read and copy the problem data.\n");
goto TERMINATE;
}
/* Set parameters */
/* Assure linear mappings between the presolved and original
models */
status = CPXsetintparam (env, CPXPARAM_Preprocessing_Linear, 0);
if ( status ) goto TERMINATE;
/* Create user cuts for noswot problem */
status = addusercuts (env, lp);
if ( status ) goto TERMINATE;
/* Optimize the problem and obtain solution */
status = CPXmipopt (env, lp);
if ( status ) {
fprintf (stderr, "Failed to optimize MIP.\n");
goto TERMINATE;
}
solstat = CPXgetstat (env, lp);
printf ("Solution status %d.\n", solstat);
status = CPXgetobjval (env, lp, &objval);
if ( status ) {
fprintf (stderr,"Failed to obtain objective value.\n");
goto TERMINATE;
}
printf ("Objective value %.10g\n", objval);
cur_numcols = CPXgetnumcols (env, lp);
/* Allocate space for solution */
x = (double *) malloc (cur_numcols * sizeof (double));
if ( x == NULL ) {
fprintf (stderr, "No memory for solution values.\n");
goto TERMINATE;
}
status = CPXgetx (env, lp, x, 0, cur_numcols-1);
if ( status ) {
fprintf (stderr, "Failed to obtain solution.\n");
goto TERMINATE;
}
/* Write out the solution */
for (j = 0; j < cur_numcols; j++) {
if ( fabs (x[j]) > 1e-10 ) {
printf ("Column %d: Value = %17.10g\n", j, x[j]);
}
}
TERMINATE:
/* Free the filename */
free_and_null ((char **) &noswot);
/* Free the solution vector */
free_and_null ((char **) &x);
/* Free the problem as allocated by CPXcreateprob and
CPXreadcopyprob, if necessary */
if ( lp != NULL ) {
status = CPXfreeprob (env, &lp);
if ( status ) {
fprintf (stderr, "CPXfreeprob failed, error code %d.\n",
status);
}
}
/* Free the CPLEX environment, if necessary */
if ( env != NULL ) {
status = CPXcloseCPLEX (&env);
/* Note that CPXcloseCPLEX produces no output, so the only
way to see the cause of the error is to use
CPXgeterrorstring. For other CPLEX routines, the errors
will be seen if the CPXPARAM_ScreenOutput parameter is set to
CPX_ON */
if ( status ) {
char errmsg[CPXMESSAGEBUFSIZE];
fprintf (stderr, "Could not close CPLEX environment.\n");
CPXgeterrorstring (env, status, errmsg);
fprintf (stderr, "%s", errmsg);
}
}
return (status);
} /* END main */
int
main (void)
{
/* Declare variables and arrays where we will store the
optimization results including the status, objective value,
and variable values. */
int solstat;
double objval;
int colcnt = 0;
double *x = NULL;
CPXENVptr env = NULL;
CPXLPptr lp = NULL;
int status;
int m, p;
/* Initialize the CPLEX environment */
env = CPXopenCPLEX (&status);
/* If an error occurs, the status value indicates the reason for
failure. A call to CPXgeterrorstring will produce the text of
the error message. Note that CPXopenCPLEX produces no output,
so the only way to see the cause of the error is to use
CPXgeterrorstring. For other CPLEX routines, the errors will
be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */
if ( env == NULL ) {
char errmsg[CPXMESSAGEBUFSIZE];
fprintf (stderr, "Could not open CPLEX environment.\n");
CPXgeterrorstring (env, status, errmsg);
fprintf (stderr, "%s", errmsg);
goto TERMINATE;
}
/* Turn on output to the screen */
status = CPXsetintparam (env, CPXPARAM_ScreenOutput, CPX_ON);
if ( status ) {
fprintf (stderr,
"Failure to turn on screen indicator, error %d.\n", status);
goto TERMINATE;
}
/* Formulate and solve the problem */
lp = CPXcreateprob (env, &status, "food manufacturing");
/* A returned pointer of NULL may mean that not enough memory
was available or there was some other problem. In the case of
failure, an error message will have been written to the error
channel from inside CPLEX. In this example, the setting of
the parameter CPXPARAM_ScreenOutput causes the error message to
appear on stdout. */
if ( lp == NULL ) {
fprintf (stderr, "Failed to create LP.\n");
goto TERMINATE;
}
/* Build the model */
status = buildmodel (env, lp);
if ( status ) {
fprintf (stderr, "Failed to build model.\n");
goto TERMINATE;
}
/* Write a copy of the problem to a file. */
status = CPXwriteprob (env, lp, "foodmanu.lp", NULL);
if ( status ) {
fprintf (stderr, "Failed to write LP to disk.\n");
goto TERMINATE;
}
/* Optimize the problem and obtain solution. */
status = CPXmipopt (env, lp);
if ( status ) {
fprintf (stderr, "Failed to optimize MIP.\n");
goto TERMINATE;
}
solstat = CPXgetstat (env, lp);
/* Write solution status, objective and solution vector to the screen. */
printf ("\nSolution status = %d\n", solstat);
status = CPXgetobjval (env, lp, &objval);
if ( status ) {
fprintf (stderr,"No MIP objective value available. Exiting...\n");
goto TERMINATE;
}
printf ("Solution value (maximum profit) = %f\n\n", objval);
colcnt = NUMVARS*NUMMONTHS*NUMPRODUCTS;
x = (double *) malloc (colcnt * sizeof(double));
if ( x == NULL ) {
status = CPXERR_NO_MEMORY;
fprintf (stderr, "Could not allocate memory for solution.\n");
goto TERMINATE;
}
status = CPXgetx (env, lp, x, 0, colcnt - 1);
if ( status ) {
fprintf (stderr, "Failed to get optimal integer x.\n");
goto TERMINATE;
}
for (m = 0; m < NUMMONTHS; m++) {
printf ("Month %d \n", m);
printf (" . buy ");
for (p = 0; p < NUMPRODUCTS; p++)
printf ("%f\t", x[varindex(m, p, BUY)]);
printf ("\n");
printf (" . use ");
for (p = 0; p < NUMPRODUCTS; p++)
printf ("%f\t", x[varindex (m, p, USE)]);
printf ("\n");
printf (" . store ");
for (p = 0; p < NUMPRODUCTS; p++)
printf ("%f\t", x[varindex (m, p, STORE)]);
printf ("\n");
}
/* Free problem */
status = CPXfreeprob (env, &lp);
if ( status ) {
fprintf (stderr, "CPXfreeprob failed, error code %d.\n", status);
goto TERMINATE;
}
TERMINATE:
free_and_null ((char **) &x);
/* Free up the problem as allocated by CPXcreateprob, if necessary */
if ( lp != NULL ) {
status = CPXfreeprob (env, &lp);
if ( status ) {
fprintf (stderr, "CPXfreeprob failed, error code %d.\n", status);
}
}
/* Free up the CPLEX environment, if necessary */
if ( env != NULL ) {
status = CPXcloseCPLEX (&env);
/* Note that CPXcloseCPLEX produces no output,
so the only way to see the cause of the error is to use
CPXgeterrorstring. For other CPLEX routines, the errors will
be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */
if ( status ) {
char errmsg[CPXMESSAGEBUFSIZE];
fprintf (stderr, "Could not close CPLEX environment.\n");
CPXgeterrorstring (env, status, errmsg);
fprintf (stderr, "%s", errmsg);
}
}
return (status);
} /* END main */