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;
CPXDIM j;
CPXDIM 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 = CPXXopenCPLEX (&status);
/* If an error occurs, the status value indicates the reason for
failure. A call to CPXXgeterrorstring will produce the text of
the error message. Note that CPXXopenCPLEX produces no
output, so the only way to see the cause of the error is to use
CPXXgeterrorstring. 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");
CPXXgeterrorstring (env, status, errmsg);
fprintf (stderr, "%s", errmsg);
goto TERMINATE;
}
/* Turn on output to the screen */
status = CPXXsetintparam (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 = CPXXcreateprob (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 = CPXXreadcopyprob (env, lp, argv[nameind], NULL);
if ( status ) {
fprintf (stderr,
"Failed to read and copy the problem data.\n");
goto TERMINATE;
}
/* Set up to use MIP callbacks */
status = CPXXsetnodecallbackfunc (env, userselectnode, NULL) ||
CPXXsetbranchcallbackfunc (env, usersetbranch, NULL) ||
CPXXsetsolvecallbackfunc (env, usersolve, NULL);
if ( wantorig ) {
/* Assure linear mappings between the presolved and original
models */
status = CPXXsetintparam (env, CPXPARAM_Preprocessing_Linear, 0);
if ( status ) goto TERMINATE;
/* Let MIP callbacks work on the original model */
status = CPXXsetintparam (env, CPXPARAM_MIP_Strategy_CallbackReducedLP,
CPX_OFF);
if ( status ) goto TERMINATE;
}
/* Set MIP log interval to 1 */
status = CPXXsetcntparam (env, CPXPARAM_MIP_Interval, 1);
if ( status ) goto TERMINATE;
/* Turn on traditional search for use with control callbacks */
status = CPXXsetintparam (env, CPXPARAM_MIP_Strategy_Search,
CPX_MIPSEARCH_TRADITIONAL);
if ( status ) goto TERMINATE;
/* Optimize the problem and obtain solution */
status = CPXXmipopt (env, lp);
if ( status ) {
fprintf (stderr, "Failed to optimize MIP.\n");
goto TERMINATE;
}
solstat = CPXXgetstat (env, lp);
printf ("Solution status %d.\n", solstat);
status = CPXXgetobjval (env, lp, &objval);
if ( status ) {
fprintf (stderr,"Failed to obtain objective value.\n");
goto TERMINATE;
}
printf ("Objective value %.10g\n", objval);
cur_numcols = CPXXgetnumcols (env, lp);
/* Allocate space for solution */
x = malloc (cur_numcols * sizeof (*x));
if ( x == NULL ) {
fprintf (stderr, "No memory for solution values.\n");
goto TERMINATE;
}
status = CPXXgetx (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 CPXXcreateprob and
CPXXreadcopyprob, if necessary */
if ( lp != NULL ) {
status = CPXXfreeprob (env, &lp);
if ( status ) {
fprintf (stderr, "CPXXfreeprob failed, error code %d.\n",
status);
}
}
/* Free the CPLEX environment, if necessary */
if ( env != NULL ) {
status = CPXXcloseCPLEX (&env);
/* Note that CPXXcloseCPLEX produces no output, so the only
way to see the cause of the error is to use
CPXXgeterrorstring. 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");
CPXXgeterrorstring (env, status, errmsg);
fprintf (stderr, "%s", errmsg);
}
}
return (status);
} /* END main */
int
main (int argc, char *argv[])
{
int status = 0;
int solstat;
/* 17 city problem */
const char* filename = "../../../examples/data/atsp.dat";
/* ATSP instance */
double **arc_cost = NULL;
CPXDIM num_nodes;
/* data required to print the optimal ATSP tour */
double objval;
CPXDIM num_x_cols;
double *x = NULL;
CPXDIM i, j;
CPXDIM *succ = NULL;
/* Cplex environment and master ILP */
CPXENVptr env = NULL;
CPXLPptr lp = NULL;
/* Decide when Benders' cuts are going to be separated:
0: only when a integer solution if found
(i.e., wherefrom == CPX_CALLBACK_MIP_CUT_FEAS )
1: even to cut-off fractional solutions,
at the end of the cplex cut-loop
(i.e., wherefrom == CPX_CALLBACK_MIP_CUT_LAST ||
wherefrom == CPX_CALLBACK_MIP_CUT_FEAS ) */
int separate_fractional_solutions;
/* Cut callback data structure */
USER_CBHANDLE user_cbhandle;
user_cbhandle.env = NULL;
user_cbhandle.lp = NULL;
user_cbhandle.x = NULL;
user_cbhandle.indices = NULL;
user_cbhandle.ray = NULL;
user_cbhandle.cutval = NULL;
user_cbhandle.cutind = NULL;
/* Check the command line arguments */
if ( argc != 2 && argc != 3) {
usage (argv[0]);
goto TERMINATE;
}
if ( (argv[1][0] != '1' && argv[1][0] != '0') ||
argv[1][1] != '\0' ) {
usage (argv[0]);
goto TERMINATE;
}
separate_fractional_solutions = ( argv[1][0] == '0' ? 0 : 1 );
printf ("Benders' cuts separated to cut off: ");
if ( separate_fractional_solutions ) {
printf ("Integer and fractional infeasible solutions.\n");
}
else {
printf ("Only integer infeasible solutions.\n");
}
fflush (stdout);
if ( argc == 3 ) filename = argv[2];
/* Read the ATSP instance */
status = read_ATSP (filename, &arc_cost, &num_nodes);
if ( status ) {
fprintf (stderr, "Error in read_ATSP, status = %d\n", status);
goto TERMINATE;
}
/* Init the CPLEX environment */
env = CPXXopenCPLEX (&status);
if ( env == NULL ) {
fprintf (stderr, "Failure in CPXXopenCPLEX, status = %d.\n", status);
goto TERMINATE;
}
/* Turn on output to the screen */
status = CPXXsetintparam (env, CPXPARAM_ScreenOutput, CPX_ON);
if ( status ) {
fprintf (stderr, "Failed to turn on screen indicator, status = %d.\n",
status);
goto TERMINATE;
}
/* Set MIP log interval to 1 */
status = CPXXsetcntparam (env, CPXPARAM_MIP_Interval, 1);
if ( status ) {
fprintf (stderr,
"Failed to set CPXPARAM_MIP_Interval, status = %d.\n", status);
goto TERMINATE;
}
/* Create the master ILP */
lp = CPXXcreateprob (env, &status, "master_ILP.lp");
if ( lp == NULL ) {
fprintf (stderr, "Failure in CPXXcreateprob, status = %d.\n", status);
goto TERMINATE;
}
status = create_master_ILP (env, lp, arc_cost, num_nodes);
if ( status ) {
fprintf (stderr,
"Failed to create the master ILP.\n");
goto TERMINATE;
}
/* Init the cut callback data structure */
status = init_user_cbhandle (&user_cbhandle, num_nodes,
separate_fractional_solutions);
if ( status ) {
fprintf (stderr,
"Failed to init the cut callback data structure, status = %d.\n",
status);
goto TERMINATE;
}
/* Set up environment parameters to use the function benders_callback
as cut callback function */
status = set_benders_callback (env, &user_cbhandle);
if ( status ) {
fprintf (stderr,
"Failure in function set_benders_callback: status = %d.\n",
status);
goto TERMINATE;
}
/* Optimize the problem and obtain solution status */
status = CPXXmipopt (env, lp);
if ( status ) {
fprintf (stderr, "Failed to optimize MIP, status = %d.\n", status);
goto TERMINATE;
}
solstat = CPXXgetstat (env, lp);
printf ("\nSolution status: %d\n", solstat);
/* Write out the objective value */
if ( CPXXgetobjval (env, lp, &objval) ) {
printf ("Failed to obtain objective value.\n");
}
else {
printf ("Objective value: %17.10e\n", objval);
}
if ( solstat == CPXMIP_OPTIMAL ) {
/* Write out the optimal tour */
num_x_cols = CPXXgetnumcols (env, lp);
x = malloc (num_x_cols * sizeof(*x));
if ( x == NULL ) {
fprintf (stderr, "No memory for x array.\n");
status = -1;
goto TERMINATE;
}
status = CPXXgetx (env, lp, x, 0, num_x_cols-1);
if ( status ) {
fprintf (stderr, "Failed to obtain solution, status = %d.\n", status);
goto TERMINATE;
}
succ = malloc (num_nodes * sizeof(*succ));
if ( succ == NULL ) {
fprintf (stderr, "No memory for succ array.\n");
status = -1;
goto TERMINATE;
}
for (j = 0; j < num_nodes; ++j)
succ[j] = -1;
for (i = 0; i < num_nodes; ++i) {
for (j = 0; j < num_nodes; ++j) {
if ( fabs (x[i * num_nodes + j]) > 1e-03 )
succ[i] = j;
}
}
printf ("Optimal tour:\n");
i = 0;
while ( succ[i] != 0 ) {
printf ("%d, ", i);
i = succ[i];
}
printf ("%d\n", i);
}
else {
printf ("Solution status is not CPX_STAT_OPTIMAL\n");
}
TERMINATE:
/* Free the allocated memory if necessary */
free_and_null ((char **) &x);
free_and_null ((char **) &succ);
if ( arc_cost != NULL ) {
for (i = 0; i < num_nodes; ++i) {
free_and_null ((char **) &(arc_cost[i]));
}
}
free_and_null ((char **) &arc_cost);
status = free_user_cbhandle (&user_cbhandle);
if ( status ) {
fprintf (stderr, "free_user_cbhandle failed, status = %d.\n",
status);
}
if ( lp != NULL ) {
int local_status = CPXXfreeprob (env, &lp);
if ( local_status ) {
fprintf (stderr, "CPXXfreeprob failed, error code %d.\n",
local_status);
status = local_status;
}
}
/* Free the CPLEX environment, if necessary */
if ( env != NULL ) {
int local_status = CPXXcloseCPLEX (&env);
if ( local_status ) {
fprintf (stderr,
"Could not close CPLEX environment, status = %d.\n",
local_status);
status = local_status;
}
}
return status;
} /* END main */
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 = CPXXopenCPLEX (&status);
/* If an error occurs, the status value indicates the reason for
failure. A call to CPXXgeterrorstring will produce the text of
the error message. Note that CPXXopenCPLEX produces no output,
so the only way to see the cause of the error is to use
CPXXgeterrorstring. 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");
CPXXgeterrorstring (env, status, errmsg);
fprintf (stderr, "%s", errmsg);
goto TERMINATE;
}
/* Turn on output to the screen */
status = CPXXsetintparam (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 = CPXXcreateprob (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 = CPXXreadcopyprob (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 = CPXXgettime (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 = CPXXsetinfocallbackfunc (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 = CPXXsetcntparam (env, CPXPARAM_MIP_Limits_Nodes, 5000);
if ( status ) goto TERMINATE;
status = CPXXgettime (env, &myloginfo.timestart);
if ( status ) {
fprintf (stderr, "Failed to query time.\n");
goto TERMINATE;
}
status = CPXXgetdettime (env, &myloginfo.dettimestart);
if ( status ) {
fprintf (stderr, "Failed to query deterministic time.\n");
goto TERMINATE;
}
myloginfo.numcols = CPXXgetnumcols (env, lp);
myloginfo.lastincumbent = CPXXgetobjsen (env, lp) * 1e+35;
myloginfo.lastlog = -10000;
status = CPXXsetinfocallbackfunc (env, logcallback, &myloginfo);
if ( status ) {
fprintf (stderr, "Failed to set logging callback function.\n");
goto TERMINATE;
}
/* Turn off CPLEX logging */
status = CPXXsetintparam (env, CPXPARAM_MIP_Display, 0);
if ( status ) goto TERMINATE;
}
else if ( useterminate) {
status = CPXXsetterminate (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 = CPXXmipopt (env, lp);
if ( status ) {
fprintf (stderr, "Failed to optimize MIP.\n");
goto TERMINATE;
}
solstat = CPXXgetstat (env, lp);
printf ("Solution status %d.\n", solstat);
TERMINATE:
/* Free up the problem as allocated by CPXXcreateprob, if necessary */
if ( lp != NULL ) {
int xstatus = CPXXfreeprob (env, &lp);
if ( xstatus ) {
fprintf (stderr, "CPXXfreeprob failed, error code %d.\n", xstatus);
status = xstatus;
}
}
/* Free up the CPLEX environment, if necessary */
if ( env != NULL ) {
int xstatus = CPXXcloseCPLEX (&env);
/* Note that CPXXcloseCPLEX produces no output,
so the only way to see the cause of the error is to use
CPXXgeterrorstring. 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");
CPXXgeterrorstring (env, status, errmsg);
fprintf (stderr, "%s", errmsg);
status = xstatus;
}
}
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 */
CPXENVptr env = NULL;
CPXLPptr lp = NULL;
CUTINFO usercutinfo;
CUTINFO lazyconinfo;
const char * datadir = argc <= 1 ? "../../../examples/data" : argv[1];
char *noswot = NULL;
usercutinfo.x = NULL;
usercutinfo.beg = NULL;
usercutinfo.ind = NULL;
usercutinfo.val = NULL;
usercutinfo.rhs = NULL;
lazyconinfo.x = NULL;
lazyconinfo.beg = NULL;
lazyconinfo.ind = NULL;
lazyconinfo.val = NULL;
lazyconinfo.rhs = NULL;
noswot = (char *) malloc (strlen (datadir) + 1 + strlen("noswot.mps") + 1);
sprintf (noswot, "%s/noswot.mps", datadir);
/* Initialize the CPLEX environment */
env = CPXXopenCPLEX (&status);
/* If an error occurs, the status value indicates the reason for
failure. A call to CPXXgeterrorstring will produce the text of
the error message. Note that CPXXopenCPLEX produces no
output, so the only way to see the cause of the error is to use
CPXXgeterrorstring. 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");
CPXXgeterrorstring (env, status, errmsg);
fprintf (stderr, "%s", errmsg);
goto TERMINATE;
}
/* Turn on output to the screen */
status = CPXXsetintparam (env, CPXPARAM_ScreenOutput, CPX_ON);
if ( status != 0 ) {
fprintf (stderr,
"Failure to turn on screen indicator, error %d.\n",
status);
goto TERMINATE;
}
CPXXsetcntparam (env, CPXPARAM_MIP_Interval, 1000);
/* The problem will be solved several times, so turn off advanced start */
status = CPXXsetintparam (env, CPXPARAM_Advance, CPX_OFF);
if ( status ) goto TERMINATE;
/* Create the problem, using the filename as the problem name */
lp = CPXXcreateprob (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 = CPXXreadcopyprob (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 = CPXXsetintparam (env, CPXPARAM_Preprocessing_Linear, 0);
if ( status ) goto TERMINATE;
/* Turn on traditional search for use with control callbacks */
status = CPXXsetintparam (env, CPXPARAM_MIP_Strategy_Search, CPX_MIPSEARCH_TRADITIONAL);
if ( status ) goto TERMINATE;
/* Let MIP callbacks work on the original model */
status = CPXXsetintparam (env, CPXPARAM_MIP_Strategy_CallbackReducedLP, CPX_OFF);
if ( status ) goto TERMINATE;
/* Create user cuts for noswot problem */
status = makeusercuts (env, lp, &usercutinfo);
if ( status ) goto TERMINATE;
/* Set up to use MIP usercut callback */
status = CPXXsetusercutcallbackfunc (env, mycutcallback, &usercutinfo);
if ( status ) goto TERMINATE;
status = myoptimize (env, lp, -41.0);
if ( status ) goto TERMINATE;
/*=======================================================================*/
/* Create a lazy constraint to alter the optimum */
status = makelazyconstraint (env, lp, &lazyconinfo);
if ( status ) goto TERMINATE;
/* Set up to use MIP lazyconstraint callback. The callback funtion
* registered is the same, but the data will be different. */
status = CPXXsetlazyconstraintcallbackfunc (env, mycutcallback, &lazyconinfo);
if ( status ) goto TERMINATE;
status = myoptimize (env, lp, -39.0);
if ( status ) goto TERMINATE;
/*=======================================================================*/
/* Now solve the problem without usercut callback */
status = CPXXsetusercutcallbackfunc (env, NULL, NULL);
if ( status ) goto TERMINATE;
status = myoptimize (env, lp, -39.0);
if ( status ) goto TERMINATE;
/*=======================================================================*/
TERMINATE:
/* Free the filename */
free_and_null ((char **) &noswot);
/* Free the allocated vectors */
free_and_null ((char **) &usercutinfo.x);
free_and_null ((char **) &usercutinfo.beg);
free_and_null ((char **) &usercutinfo.ind);
free_and_null ((char **) &usercutinfo.val);
free_and_null ((char **) &usercutinfo.rhs);
free_and_null ((char **) &lazyconinfo.x);
free_and_null ((char **) &lazyconinfo.beg);
free_and_null ((char **) &lazyconinfo.ind);
free_and_null ((char **) &lazyconinfo.val);
free_and_null ((char **) &lazyconinfo.rhs);
/* Free the problem as allocated by CPXXcreateprob and
CPXXreadcopyprob, if necessary */
if ( lp != NULL ) {
status = CPXXfreeprob (env, &lp);
if ( status ) {
fprintf (stderr, "CPXXfreeprob failed, error code %d.\n",
status);
}
}
/* Free the CPLEX environment, if necessary */
if ( env != NULL ) {
status = CPXXcloseCPLEX (&env);
/* Note that CPXXcloseCPLEX produces no output, so the only
way to see the cause of the error is to use
CPXXgeterrorstring. 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");
CPXXgeterrorstring (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;
CPXDIM j;
CPXDIM 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 = CPXXopenCPLEX (&status);
/* If an error occurs, the status value indicates the reason for
failure. A call to CPXXgeterrorstring will produce the text of
the error message. Note that CPXXopenCPLEX produces no
output, so the only way to see the cause of the error is to use
CPXXgeterrorstring. 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");
CPXXgeterrorstring (env, status, errmsg);
fprintf (stderr, "%s", errmsg);
goto TERMINATE;
}
/* Turn on output to the screen */
status = CPXXsetintparam (env, CPXPARAM_ScreenOutput, CPX_ON);
if ( status != 0 ) {
fprintf (stderr,
"Failure to turn on screen indicator, error %d.\n",
status);
goto TERMINATE;
}
CPXXsetcntparam (env, CPXPARAM_MIP_Interval, 1000);
/* Create the problem, using the filename as the problem name */
lp = CPXXcreateprob (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 = CPXXreadcopyprob (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 = CPXXsetintparam (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 = CPXXmipopt (env, lp);
if ( status ) {
fprintf (stderr, "Failed to optimize MIP.\n");
goto TERMINATE;
}
solstat = CPXXgetstat (env, lp);
printf ("Solution status %d.\n", solstat);
status = CPXXgetobjval (env, lp, &objval);
if ( status ) {
fprintf (stderr,"Failed to obtain objective value.\n");
goto TERMINATE;
}
printf ("Objective value %.10g\n", objval);
cur_numcols = CPXXgetnumcols (env, lp);
/* Allocate space for solution */
x = malloc (cur_numcols * sizeof (*x));
if ( x == NULL ) {
fprintf (stderr, "No memory for solution values.\n");
goto TERMINATE;
}
status = CPXXgetx (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 CPXXcreateprob and
CPXXreadcopyprob, if necessary */
if ( lp != NULL ) {
status = CPXXfreeprob (env, &lp);
if ( status ) {
fprintf (stderr, "CPXXfreeprob failed, error code %d.\n",
status);
}
}
/* Free the CPLEX environment, if necessary */
if ( env != NULL ) {
status = CPXXcloseCPLEX (&env);
/* Note that CPXXcloseCPLEX produces no output, so the only
way to see the cause of the error is to use
CPXXgeterrorstring. 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");
CPXXgeterrorstring (env, status, errmsg);
fprintf (stderr, "%s", errmsg);
}
}
return (status);
} /* END main */
