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;
}
int CSolver:: Optimize(int Algorthim) {
m_cbData.bMip = false;
CPXsetlpcallbackfunc(m_env, lpcallback, &m_cbData);
switch(Algorthim) {
case SIMPLEX:
m_status = CPXprimopt(m_env,m_lp);
break;
case DUAL_SIMPLEX:
m_status = CPXdualopt(m_env,m_lp);
break;
case BARRIER:
m_status = CPXbaropt(m_env,m_lp);
break;
default:
Message("Undefined Algorthim specified in call to Optimize -- will use simplex!");
m_status = CPXoptimize(m_env,m_lp);
};
char buff[100];
if (m_status) {
CPXgeterrorstring(m_env, m_status, m_error );
sprintf(buff,"Error: %d",m_status);
Message( buff );
Message( m_error );
return -1;
}
CPXsetlpcallbackfunc(m_env,NULL, NULL);
CreateSolArrays();
// get solution and place into arrays
m_status = CPXsolution(m_env, m_lp, &m_lpstat, &m_obj, m_x,
m_pi, m_slack, m_dj);
if (m_status) {
CPXgeterrorstring(m_env, m_status, m_error );
Message("Getting solution IP_FAILED.");
Message( m_error );
return -1;
}
// save the basis to arrays
m_status = CPXgetbase(m_env, m_lp, m_pCstat, m_pRstat);
if ( m_status ) {
CPXgeterrorstring(m_env, m_status, m_error);
Message("Getting basis failed!");
Message(m_error);
return -1;
}
return m_status;
}
void SolverInterfaceCpx::solve()
{
if (useBarrier_)
{
CPXbaropt(cpx_->getEnvironmentPtr(), cpx_->getLpPtr(OsiCpxSolverInterface::FREECACHED_RESULTS));
//int lpstat = CPXgetstat(cpx_->getEnvironmentPtr(), cpx_->getLpPtr(OsiCpxSolverInterface::KEEPCACHED_ALL));
//printf("CPLEX barrier status %d\n", lpstat);
}
else
SolverInterfaceOsi::solve();
}
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;
int *qmatbeg = NULL;
int *qmatcnt = NULL;
int *qmatind = NULL;
double *qmatval = NULL;
int *qconrow = NULL;
int *qconcol = NULL;
double *qconval = NULL;
/* Declare and allocate space for the variables and arrays where we
will store the optimization results including the status, objective
value, variable values, dual values, row slacks and variable
reduced costs. */
int solstat;
double objval;
double x[NUMCOLS];
double slack[NUMROWS];
CPXENVptr env = NULL;
CPXLPptr lp = NULL;
int status;
int j;
int 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, &qmatbeg, &qmatcnt,
&qmatind, &qmatval, &qconrow, &qconcol, &qconval);
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 problem.\n");
goto TERMINATE;
}
/* Now copy the LP part of 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 quadratic objective. */
status = CPXcopyquad (env, lp, qmatbeg, qmatcnt, qmatind, qmatval);
if ( status ) {
fprintf (stderr, "Failed to copy quadratic matrix.\n");
goto TERMINATE;
}
/* Now add the quadratic constraint. */
status = CPXaddqconstr (env, lp, 0, NUMQCONNZ, 1.0, 'L',
NULL, NULL, qconrow, qconcol, qconval, NULL);
if ( status ) {
fprintf (stderr, "Failed to copy quadratic constraint.\n");
goto TERMINATE;
}
/* Optimize the problem and obtain solution. */
status = CPXbaropt (env, lp);
if ( status ) {
fprintf (stderr, "Failed to optimize QCP.\n");
goto TERMINATE;
}
status = CPXsolution (env, lp, &solstat, &objval, x, NULL, slack, NULL);
if ( status ) {
fprintf (stderr, "Failed to obtain solution.\n");
goto TERMINATE;
}
/* Write the output to the screen. */
printf ("\nSolution status = %d\n", solstat);
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_numcols stores the current number of columns. */
cur_numcols = CPXgetnumcols (env, lp);
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, "qcpex1.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 **) &qmatbeg);
free_and_null ((char **) &qmatcnt);
free_and_null ((char **) &qmatind);
free_and_null ((char **) &qmatval);
free_and_null ((char **) &qconrow);
free_and_null ((char **) &qconcol);
free_and_null ((char **) &qconval);
return (status);
} /* END main */
int
main (void)
{
int status, solstat;
CPXENVptr env;
CPXLPptr lp;
int i;
double x[NUMCOLS];
double cpi[NUMCOLS];
double rpi[NUMROWS];
double qpi[NUMQS];
double slack[NUMROWS], qslack[NUMQS];
double kktsum[NUMCOLS];
/* ********************************************************************** *
* *
* S E T U P P R O B L E M *
* *
* ********************************************************************** */
/* Create CPLEX environment and enable screen output.
*/
env = CPXopenCPLEX (&status);
if ( status != 0 )
goto TERMINATE;
status = CPXsetintparam (env, CPXPARAM_ScreenOutput, CPX_ON);
if ( status != 0 )
goto TERMINATE;
/* Create the problem object and populate it.
*/
lp = CPXcreateprob (env, &status, "qcpdual");
if ( status != 0 )
goto TERMINATE;
status = CPXnewcols (env, lp, NUMCOLS, obj, lb, ub, NULL, cname);
if ( status != 0 )
goto TERMINATE;
status = CPXaddrows (env, lp, 0, NUMROWS, NUMNZS, rhs, sense,
rmatbeg, rmatind, rmatval, NULL, rname);
if ( status != 0 )
goto TERMINATE;
for (i = 0; i < NUMQS; ++i) {
int const linend = (i == NUMQS - 1) ? NUMLINNZ : linbeg[i + 1];
int const quadend = (i == NUMQS - 1) ? NUMQUADNZ : quadbeg[i + 1];
status = CPXaddqconstr (env, lp, linend - linbeg[i],
quadend - quadbeg[i], qrhs[i], qsense[i],
&linind[linbeg[i]], &linval[linbeg[i]],
&quadrow[quadbeg[i]], &quadcol[quadbeg[i]],
&quadval[quadbeg[i]], qname[i]);
if ( status != 0 )
goto TERMINATE;
}
/* ********************************************************************** *
* *
* O P T I M I Z E P R O B L E M *
* *
* ********************************************************************** */
status = CPXsetdblparam (env, CPXPARAM_Barrier_QCPConvergeTol, 1e-10);
if ( status != 0 )
goto TERMINATE;
/* Solve the problem.
*/
status = CPXbaropt (env, lp);
if ( status != 0 )
goto TERMINATE;
solstat = CPXgetstat (env, lp);
if ( solstat != CPX_STAT_OPTIMAL ) {
fprintf (stderr, "No optimal solution found!\n");
goto TERMINATE;
}
/* ********************************************************************** *
* *
* Q U E R Y S O L U T I O N *
* *
* ********************************************************************** */
/* Optimal solution and slacks for linear and quadratic constraints. */
status = CPXgetx (env, lp, x, 0, NUMCOLS - 1);
if ( status != 0 )
goto TERMINATE;
status = CPXgetslack (env, lp, slack, 0, NUMROWS - 1);
if ( status != 0 )
goto TERMINATE;
status = CPXgetqconstrslack (env, lp, qslack, 0, NUMQS - 1);
if ( status != 0 )
goto TERMINATE;
/* Dual multipliers for linear constraints and bound constraints. */
status = CPXgetdj (env, lp, cpi, 0, NUMCOLS - 1);
if ( status != 0 )
goto TERMINATE;
status = CPXgetpi (env, lp, rpi, 0, NUMROWS - 1);
if ( status != 0 )
goto TERMINATE;
status = getqconstrmultipliers (env, lp, x, qpi, ZEROTOL);
if ( status != 0 )
goto TERMINATE;
/* ********************************************************************** *
* *
* C H E C K K K T C O N D I T I O N S *
* *
* Here we verify that the optimal solution computed by CPLEX (and *
* the qpi[] values computed above) satisfy the KKT conditions. *
* *
* ********************************************************************** */
/* Primal feasibility: This example is about duals so we skip this test. */
/* Dual feasibility: We must verify
* - for <= constraints (linear or quadratic) the dual
* multiplier is non-positive.
* - for >= constraints (linear or quadratic) the dual
* multiplier is non-negative.
*/
for (i = 0; i < NUMROWS; ++i) {
switch (sense[i]) {
case 'E': /* nothing */ break;
case 'R': /* nothing */ break;
case 'L':
if ( rpi[i] > ZEROTOL ) {
fprintf (stderr,
"Dual feasibility test failed for <= row %d: %f\n",
i, rpi[i]);
status = -1;
goto TERMINATE;
}
break;
case 'G':
if ( rpi[i] < -ZEROTOL ) {
fprintf (stderr,
"Dual feasibility test failed for >= row %d: %f\n",
i, rpi[i]);
status = -1;
goto TERMINATE;
}
break;
}
}
for (i = 0; i < NUMQS; ++i) {
switch (qsense[i]) {
case 'E': /* nothing */ break;
case 'L':
if ( qpi[i] > ZEROTOL ) {
fprintf (stderr,
"Dual feasibility test failed for <= quad %d: %f\n",
i, qpi[i]);
status = -1;
goto TERMINATE;
}
break;
case 'G':
if ( qpi[i] < -ZEROTOL ) {
fprintf (stderr,
"Dual feasibility test failed for >= quad %d: %f\n",
i, qpi[i]);
status = -1;
goto TERMINATE;
}
break;
}
}
/* Complementary slackness.
* For any constraint the product of primal slack and dual multiplier
* must be 0.
*/
for (i = 0; i < NUMROWS; ++i) {
if ( sense[i] != 'E' && fabs (slack[i] * rpi[i]) > ZEROTOL ) {
fprintf (stderr,
"Complementary slackness test failed for row %d: %f\n",
i, fabs (slack[i] * rpi[i]));
status = -1;
goto TERMINATE;
}
}
for (i = 0; i < NUMQS; ++i) {
if ( qsense[i] != 'E' && fabs (qslack[i] * qpi[i]) > ZEROTOL ) {
fprintf (stderr,
"Complementary slackness test failed for quad %d: %f\n",
i, fabs (qslack[i] * qpi[i]));
status = -1;
goto TERMINATE;
}
}
for (i = 0; i < NUMCOLS; ++i) {
if ( ub[i] < CPX_INFBOUND ) {
double const slk = ub[i] - x[i];
double const dual = cpi[i] < -ZEROTOL ? cpi[i] : 0.0;
if ( fabs (slk * dual) > ZEROTOL ) {
fprintf (stderr,
"Complementary slackness test failed for ub %d: %f\n",
i, fabs (slk * dual));
status = -1;
goto TERMINATE;
}
}
if ( lb[i] > -CPX_INFBOUND ) {
double const slk = x[i] - lb[i];
double const dual = cpi[i] > ZEROTOL ? cpi[i] : 0.0;
if ( fabs (slk * dual) > ZEROTOL ) {
printf ("lb=%f, x=%f, cpi=%f\n", lb[i], x[i], cpi[i]);
fprintf (stderr,
"Complementary slackness test failed for lb %d: %f\n",
i, fabs (slk * dual));
status = -1;
goto TERMINATE;
}
}
}
/* Stationarity.
* The difference between objective function and gradient at optimal
* solution multiplied by dual multipliers must be 0, i.e., for the
* optimal solution x
* 0 == c
* - sum(r in rows) r'(x)*rpi[r]
* - sum(q in quads) q'(x)*qpi[q]
* - sum(c in cols) b'(x)*cpi[c]
* where r' and q' are the derivatives of a row or quadratic constraint,
* x is the optimal solution and rpi[r] and qpi[q] are the dual
* multipliers for row r and quadratic constraint q.
* b' is the derivative of a bound constraint and cpi[c] the dual bound
* multiplier for column c.
*/
/* Objective function. */
for (i = 0; i < NUMCOLS; ++i)
kktsum[i] = obj[i];
/* Linear constraints.
* The derivative of a linear constraint ax - b (<)= 0 is just a.
*/
for (i = 0; i < NUMROWS; ++i) {
int const end = (i == NUMROWS - 1) ? NUMNZS : rmatbeg[i + 1];
int k;
for (k = rmatbeg[i]; k < end; ++k)
kktsum[rmatind[k]] -= rpi[i] * rmatval[k];
}
/* Quadratic constraints.
* The derivative of a constraint xQx + ax - b <= 0 is
* Qx + Q'x + a.
*/
for (i = 0; i < NUMQS; ++i) {
int j;
int k;
for (j = linbeg[i]; j < linbeg[i] + linnzcnt[i]; ++j)
kktsum[linind[j]] -= qpi[i] * linval[j];
for (k = quadbeg[i]; k < quadbeg[i] + quadnzcnt[i]; ++k) {
kktsum[quadrow[k]] -= qpi[i] * x[quadcol[k]] * quadval[k];
kktsum[quadcol[k]] -= qpi[i] * x[quadrow[k]] * quadval[k];
}
}
/* Bounds.
* The derivative for lower bounds is -1 and that for upper bounds
* is 1.
* CPLEX already returns dj with the appropriate sign so there is
* no need to distinguish between different bound types here.
*/
for (i = 0; i < NUMCOLS; ++i) {
kktsum[i] -= cpi[i];
}
for (i = 0; i < NUMCOLS; ++i) {
if ( fabs (kktsum[i]) > ZEROTOL ) {
fprintf (stderr, "Stationarity test failed at index %d: %f\n",
i, kktsum[i]);
status = -1;
goto TERMINATE;
}
}
/* KKT conditions satisfied. Dump out the optimal solutions and
* the dual values.
*/
printf ("Optimal solution satisfies KKT conditions.\n");
printf (" x[] =");
for (i = 0; i < NUMCOLS; ++i)
printf (" %7.3f", x[i]);
printf ("\n");
printf ("cpi[] =");
for (i = 0; i < NUMCOLS; ++i)
printf (" %7.3f", cpi[i]);
printf ("\n");
printf ("rpi[] =");
for (i = 0; i < NUMROWS; ++i)
printf (" %7.3f", rpi[i]);
printf ("\n");
printf ("qpi[] =");
for (i = 0; i < NUMQS; ++i)
printf (" %7.3f", qpi[i]);
printf ("\n");
TERMINATE:
/* ********************************************************************** *
* *
* C L E A N U P *
* *
* ********************************************************************** */
status = CPXfreeprob (env, &lp);
if ( status != 0 ) {
fprintf (stderr, "WARNING: Failed to free problem: %d\n", status);
}
status = CPXcloseCPLEX (&env);
if ( status != 0 ) {
fprintf (stderr, "WARNING: Failed to close CPLEX: %d\n", status);
}
return status;
}
