static int solve_lp(glp_prob *P, const glp_smcp *parm)
{ /* solve LP directly without using the preprocessor */
int ret;
if (!glp_bf_exists(P))
{ ret = glp_factorize(P);
if (ret == 0)
;
else if (ret == GLP_EBADB)
{ if (parm->msg_lev >= GLP_MSG_ERR)
xprintf("glp_simplex: initial basis is invalid\n");
}
else if (ret == GLP_ESING)
{ if (parm->msg_lev >= GLP_MSG_ERR)
xprintf("glp_simplex: initial basis is singular\n");
}
else if (ret == GLP_ECOND)
{ if (parm->msg_lev >= GLP_MSG_ERR)
xprintf(
"glp_simplex: initial basis is ill-conditioned\n");
}
else
xassert(ret != ret);
if (ret != 0) goto done;
}
if (parm->meth == GLP_PRIMAL)
ret = spx_primal(P, parm);
else if (parm->meth == GLP_DUALP)
{ ret = spx_dual(P, parm);
if (ret == GLP_EFAIL && P->valid)
ret = spx_primal(P, parm);
}
else if (parm->meth == GLP_DUAL)
ret = spx_dual(P, parm);
else
xassert(parm != parm);
done: return ret;
}
int glp_print_ranges(glp_prob *P, int len, const int list[],
int flags, const char *fname)
{ /* print sensitivity analysis report */
glp_file *fp = NULL;
GLPROW *row;
GLPCOL *col;
int m, n, pass, k, t, numb, type, stat, var1, var2, count, page,
ret;
double lb, ub, slack, coef, prim, dual, value1, value2, coef1,
coef2, obj1, obj2;
const char *name, *limit;
char buf[13+1];
/* sanity checks */
if (P == NULL || P->magic != GLP_PROB_MAGIC)
xerror("glp_print_ranges: P = %p; invalid problem object\n",
P);
m = P->m, n = P->n;
if (len < 0)
xerror("glp_print_ranges: len = %d; invalid list length\n",
len);
if (len > 0)
{ if (list == NULL)
xerror("glp_print_ranges: list = %p: invalid parameter\n",
list);
for (t = 1; t <= len; t++)
{ k = list[t];
if (!(1 <= k && k <= m+n))
xerror("glp_print_ranges: list[%d] = %d; row/column numb"
"er out of range\n", t, k);
}
}
if (flags != 0)
xerror("glp_print_ranges: flags = %d; invalid parameter\n",
flags);
if (fname == NULL)
xerror("glp_print_ranges: fname = %p; invalid parameter\n",
fname);
if (glp_get_status(P) != GLP_OPT)
{ xprintf("glp_print_ranges: optimal basic solution required\n");
ret = 1;
goto done;
}
if (!glp_bf_exists(P))
{ xprintf("glp_print_ranges: basis factorization required\n");
ret = 2;
goto done;
}
/* start reporting */
xprintf("Write sensitivity analysis report to '%s'...\n", fname);
fp = glp_open(fname, "w");
if (fp == NULL)
{ xprintf("Unable to create '%s' - %s\n", fname, get_err_msg());
ret = 3;
goto done;
}
page = count = 0;
for (pass = 1; pass <= 2; pass++)
for (t = 1; t <= (len == 0 ? m+n : len); t++)
{ if (t == 1) count = 0;
k = (len == 0 ? t : list[t]);
if (pass == 1 && k > m || pass == 2 && k <= m)
continue;
if (count == 0)
{ xfprintf(fp, "GLPK %-4s - SENSITIVITY ANALYSIS REPORT%73sPa"
"ge%4d\n", glp_version(), "", ++page);
xfprintf(fp, "\n");
xfprintf(fp, "%-12s%s\n", "Problem:",
P->name == NULL ? "" : P->name);
xfprintf(fp, "%-12s%s%s%.10g (%s)\n", "Objective:",
P->obj == NULL ? "" : P->obj,
P->obj == NULL ? "" : " = ", P->obj_val,
P->dir == GLP_MIN ? "MINimum" :
P->dir == GLP_MAX ? "MAXimum" : "???");
xfprintf(fp, "\n");
xfprintf(fp, "%6s %-12s %2s %13s %13s %13s %13s %13s %13s "
"%s\n", "No.", pass == 1 ? "Row name" : "Column name",
"St", "Activity", pass == 1 ? "Slack" : "Obj coef",
"Lower bound", "Activity", "Obj coef", "Obj value at",
"Limiting");
xfprintf(fp, "%6s %-12s %2s %13s %13s %13s %13s %13s %13s "
"%s\n", "", "", "", "", "Marginal", "Upper bound",
"range", "range", "break point", "variable");
xfprintf(fp, "------ ------------ -- ------------- --------"
"----- ------------- ------------- ------------- ------"
"------- ------------\n");
}
if (pass == 1)
{ numb = k;
xassert(1 <= numb && numb <= m);
row = P->row[numb];
name = row->name;
type = row->type;
lb = glp_get_row_lb(P, numb);
ub = glp_get_row_ub(P, numb);
coef = 0.0;
stat = row->stat;
prim = row->prim;
if (type == GLP_FR)
slack = - prim;
else if (type == GLP_LO)
slack = lb - prim;
else if (type == GLP_UP || type == GLP_DB || type == GLP_FX)
slack = ub - prim;
dual = row->dual;
}
else
{ numb = k - m;
xassert(1 <= numb && numb <= n);
col = P->col[numb];
name = col->name;
lb = glp_get_col_lb(P, numb);
ub = glp_get_col_ub(P, numb);
coef = col->coef;
stat = col->stat;
prim = col->prim;
slack = 0.0;
dual = col->dual;
}
if (stat != GLP_BS)
{ glp_analyze_bound(P, k, &value1, &var1, &value2, &var2);
if (stat == GLP_NF)
coef1 = coef2 = coef;
else if (stat == GLP_NS)
coef1 = -DBL_MAX, coef2 = +DBL_MAX;
else if (stat == GLP_NL && P->dir == GLP_MIN ||
stat == GLP_NU && P->dir == GLP_MAX)
coef1 = coef - dual, coef2 = +DBL_MAX;
else
coef1 = -DBL_MAX, coef2 = coef - dual;
if (value1 == -DBL_MAX)
{ if (dual < -1e-9)
obj1 = +DBL_MAX;
else if (dual > +1e-9)
obj1 = -DBL_MAX;
else
obj1 = P->obj_val;
}
else
obj1 = P->obj_val + dual * (value1 - prim);
if (value2 == +DBL_MAX)
{ if (dual < -1e-9)
obj2 = -DBL_MAX;
else if (dual > +1e-9)
obj2 = +DBL_MAX;
else
obj2 = P->obj_val;
}
else
obj2 = P->obj_val + dual * (value2 - prim);
}
else
{ glp_analyze_coef(P, k, &coef1, &var1, &value1, &coef2,
&var2, &value2);
if (coef1 == -DBL_MAX)
{ if (prim < -1e-9)
obj1 = +DBL_MAX;
else if (prim > +1e-9)
obj1 = -DBL_MAX;
else
obj1 = P->obj_val;
}
else
obj1 = P->obj_val + (coef1 - coef) * prim;
if (coef2 == +DBL_MAX)
{ if (prim < -1e-9)
obj2 = -DBL_MAX;
else if (prim > +1e-9)
obj2 = +DBL_MAX;
else
obj2 = P->obj_val;
}
else
obj2 = P->obj_val + (coef2 - coef) * prim;
}
/*** first line ***/
/* row/column number */
xfprintf(fp, "%6d", numb);
/* row/column name */
xfprintf(fp, " %-12.12s", name == NULL ? "" : name);
if (name != NULL && strlen(name) > 12)
xfprintf(fp, "%s\n%6s %12s", name+12, "", "");
/* row/column status */
xfprintf(fp, " %2s",
stat == GLP_BS ? "BS" : stat == GLP_NL ? "NL" :
stat == GLP_NU ? "NU" : stat == GLP_NF ? "NF" :
stat == GLP_NS ? "NS" : "??");
/* row/column activity */
xfprintf(fp, " %s", format(buf, prim));
/* row slack, column objective coefficient */
xfprintf(fp, " %s", format(buf, k <= m ? slack : coef));
/* row/column lower bound */
xfprintf(fp, " %s", format(buf, lb));
/* row/column activity range */
xfprintf(fp, " %s", format(buf, value1));
/* row/column objective coefficient range */
xfprintf(fp, " %s", format(buf, coef1));
/* objective value at break point */
xfprintf(fp, " %s", format(buf, obj1));
/* limiting variable name */
if (var1 != 0)
{ if (var1 <= m)
limit = glp_get_row_name(P, var1);
else
limit = glp_get_col_name(P, var1 - m);
if (limit != NULL)
xfprintf(fp, " %s", limit);
}
xfprintf(fp, "\n");
/*** second line ***/
xfprintf(fp, "%6s %-12s %2s %13s", "", "", "", "");
/* row/column reduced cost */
xfprintf(fp, " %s", format(buf, dual));
/* row/column upper bound */
xfprintf(fp, " %s", format(buf, ub));
/* row/column activity range */
xfprintf(fp, " %s", format(buf, value2));
/* row/column objective coefficient range */
xfprintf(fp, " %s", format(buf, coef2));
/* objective value at break point */
xfprintf(fp, " %s", format(buf, obj2));
/* limiting variable name */
if (var2 != 0)
{ if (var2 <= m)
limit = glp_get_row_name(P, var2);
else
limit = glp_get_col_name(P, var2 - m);
if (limit != NULL)
xfprintf(fp, " %s", limit);
}
xfprintf(fp, "\n");
xfprintf(fp, "\n");
/* print 10 items per page */
count = (count + 1) % 10;
}
xfprintf(fp, "End of report\n");
#if 0 /* FIXME */
xfflush(fp);
#endif
if (glp_ioerr(fp))
{ xprintf("Write error on '%s' - %s\n", fname, get_err_msg());
ret = 4;
goto done;
}
ret = 0;
done:
if (fp != NULL) glp_close(fp);
return ret;
}
int lpx_is_b_avail(glp_prob *lp)
{ /* check if LP basis is available */
return glp_bf_exists(lp);
}
int lpx_print_sens_bnds(LPX *lp, const char *fname)
{ /* write bounds sensitivity information */
if (glp_get_status(lp) == GLP_OPT && !glp_bf_exists(lp))
glp_factorize(lp);
return glp_print_ranges(lp, 0, NULL, 0, fname);
}
static PyObject* LPX_write(LPXObject *self, PyObject *args, PyObject *keywds)
{
static char* kwlist[] = {"mps", "freemps", "prob", "sol", "sens_bnds",
"ips", "mip", NULL};
char* fnames[] = {NULL,NULL,NULL,NULL,NULL,NULL,NULL};
char* fname;
const char* err_msg = "writer for '%s' failed to write to '%s'";
int rv;
rv = PyArg_ParseTupleAndKeywords(args, keywds, "|sssssss", kwlist,
fnames,fnames+1,fnames+2,fnames+3, fnames+4,fnames+5,fnames+6);
if (!rv)
return NULL;
fname = fnames[0];
if (fname != NULL) {
rv = glp_write_mps(LP, GLP_MPS_DECK, NULL, fname);
if (rv != 0) {
PyErr_Format(PyExc_RuntimeError, err_msg, kwlist[0], fname);
return NULL;
}
}
fname = fnames[1];
if (fname != NULL) {
rv = glp_write_mps(LP, GLP_MPS_FILE, NULL, fname);
if (rv != 0) {
PyErr_Format(PyExc_RuntimeError, err_msg, kwlist[1], fname);
return NULL;
}
}
fname = fnames[2];
if (fname != NULL) {
rv = glp_write_lp(LP, NULL, fname);
if (rv != 0) {
PyErr_Format(PyExc_RuntimeError, err_msg, kwlist[2], fname);
return NULL;
}
}
fname = fnames[3];
if (fname != NULL) {
rv = glp_print_sol(LP, fname);
if (rv != 0) {
PyErr_Format(PyExc_RuntimeError, err_msg, kwlist[3], fname);
return NULL;
}
}
fname = fnames[4];
if (fname != NULL) {
if (glp_get_status(LP) == GLP_OPT && !glp_bf_exists(LP))
glp_factorize(LP);
rv = glp_print_ranges(LP, 0, NULL, 0, fname);
if (rv != 0) {
PyErr_Format(PyExc_RuntimeError, err_msg, kwlist[4], fname);
return NULL;
}
}
fname = fnames[5];
if (fname != NULL) {
rv = glp_print_ipt(LP, fname);
if (rv != 0) {
PyErr_Format(PyExc_RuntimeError, err_msg, kwlist[5], fname);
return NULL;
}
}
fname = fnames[6];
if (fname != NULL) {
glp_print_mip(LP, fname);
if (rv != 0) {
PyErr_Format(PyExc_RuntimeError, err_msg, kwlist[6], fname);
return NULL;
}
}
Py_RETURN_NONE;
}
