int glp_get_status(glp_prob *lp)
{ int status;
status = glp_get_prim_stat(lp);
switch (status)
{ case GLP_FEAS:
switch (glp_get_dual_stat(lp))
{ case GLP_FEAS:
status = GLP_OPT;
break;
case GLP_NOFEAS:
status = GLP_UNBND;
break;
case GLP_UNDEF:
case GLP_INFEAS:
status = status;
break;
default:
xassert(lp != lp);
}
break;
case GLP_UNDEF:
case GLP_INFEAS:
case GLP_NOFEAS:
status = status;
break;
default:
xassert(lp != lp);
}
return status;
}
static KKTObject* LPX_kkt(LPXObject *self, PyObject *args) {
// Cannot get for undefined primal or dual.
if (glp_get_prim_stat(LP)==GLP_UNDEF ||
glp_get_dual_stat(LP)==GLP_UNDEF) {
PyErr_SetString(PyExc_RuntimeError, "cannot get KKT when primal or dual "
"basic solution undefined");
return NULL;
}
// Check the Python arguments.
int scaling = 0;
PyObject *arg = NULL;
if (!PyArg_ParseTuple(args, "|O", &arg)) return NULL;
scaling = ((arg==NULL) ? 0 : PyObject_IsTrue(arg));
if (scaling == -1) return NULL;
// OK, all done with those checks. Now get the KKT condition.
KKTObject *kkt = KKT_New();
if (!kkt) return NULL;
lpx_check_kkt(LP, scaling, &(kkt->kkt));
return kkt;
}
int lpx_get_prim_stat(glp_prob *lp)
{ /* retrieve status of primal basic solution */
return glp_get_prim_stat(lp) - GLP_UNDEF + LPX_P_UNDEF;
}
static double eval_degrad(glp_prob *P, int j, double bnd)
{ /* compute degradation of the objective on fixing x[j] at given
value with a limited number of dual simplex iterations */
/* this routine fixes column x[j] at specified value bnd,
solves resulting LP, and returns a lower bound to degradation
of the objective, degrad >= 0 */
glp_prob *lp;
glp_smcp parm;
int ret;
double degrad;
/* the current basis must be optimal */
xassert(glp_get_status(P) == GLP_OPT);
/* create a copy of P */
lp = glp_create_prob();
glp_copy_prob(lp, P, 0);
/* fix column x[j] at specified value */
glp_set_col_bnds(lp, j, GLP_FX, bnd, bnd);
/* try to solve resulting LP */
glp_init_smcp(&parm);
parm.msg_lev = GLP_MSG_OFF;
parm.meth = GLP_DUAL;
parm.it_lim = 30;
parm.out_dly = 1000;
parm.meth = GLP_DUAL;
ret = glp_simplex(lp, &parm);
if (ret == 0 || ret == GLP_EITLIM)
{ if (glp_get_prim_stat(lp) == GLP_NOFEAS)
{ /* resulting LP has no primal feasible solution */
degrad = DBL_MAX;
}
else if (glp_get_dual_stat(lp) == GLP_FEAS)
{ /* resulting basis is optimal or at least dual feasible,
so we have the correct lower bound to degradation */
if (P->dir == GLP_MIN)
degrad = lp->obj_val - P->obj_val;
else if (P->dir == GLP_MAX)
degrad = P->obj_val - lp->obj_val;
else
xassert(P != P);
/* degradation cannot be negative by definition */
/* note that the lower bound to degradation may be close
to zero even if its exact value is zero due to round-off
errors on computing the objective value */
if (degrad < 1e-6 * (1.0 + 0.001 * fabs(P->obj_val)))
degrad = 0.0;
}
else
{ /* the final basis reported by the simplex solver is dual
infeasible, so we cannot determine a non-trivial lower
bound to degradation */
degrad = 0.0;
}
}
else
{ /* the simplex solver failed */
degrad = 0.0;
}
/* delete the copy of P */
glp_delete_prob(lp);
return degrad;
}
