int CClp_opt(CClp *lp, int method)
{ /* CALLS designated LP solution method. */
int stat, ret;
if (MSGLEV >= 1)
{ int m = lpx_get_num_rows(lp->lp);
int n = lpx_get_num_cols(lp->lp);
int nz = lpx_get_num_nz(lp->lp);
print("CClp_opt: %-11s m = %d; n = %d; nz = %d",
method == CClp_METHOD_DUAL ? "(dual)" : "(primal)",
m, n, nz);
}
lpx_set_int_parm(lp->lp, LPX_K_DUAL, method == CClp_METHOD_DUAL);
switch (MSGLEV)
{ case 0:
lpx_set_int_parm(lp->lp, LPX_K_MSGLEV, 0);
lpx_set_int_parm(lp->lp, LPX_K_OUTFRQ, 1000000);
lpx_set_real_parm(lp->lp, LPX_K_OUTDLY, 1e6);
break;
case 1:
lpx_set_int_parm(lp->lp, LPX_K_MSGLEV, 2);
lpx_set_int_parm(lp->lp, LPX_K_OUTFRQ, 200);
lpx_set_real_parm(lp->lp, LPX_K_OUTDLY, 5.0);
break;
case 2:
lpx_set_int_parm(lp->lp, LPX_K_MSGLEV, 3);
lpx_set_int_parm(lp->lp, LPX_K_OUTFRQ, 200);
lpx_set_real_parm(lp->lp, LPX_K_OUTDLY, 0.0);
break;
default:
insist(MSGLEV != MSGLEV);
}
ret = lpx_simplex(lp->lp);
if (ret == LPX_E_FAULT)
{ if (MSGLEV >= 1) print("CClp_opt: restarting from advanced bas"
"is...");
lpx_adv_basis(lp->lp);
ret = lpx_simplex(lp->lp);
}
if (ret != LPX_E_OK)
{ print("CClp_opt: lpx_simplex failed; return code = %d", ret);
ret = 1;
goto done;
}
stat = lpx_get_status(lp->lp);
if (stat == LPX_OPT)
ret = 0;
else if (stat == LPX_NOFEAS)
ret = 2;
else
{ print("CClp_opt: optimization status = %d", stat);
ret = 1;
}
done: return ret;
}
static void show_status(LPX *prob, int prob_m, int prob_nz)
{ int n, j, count;
double x, tol_int;
/* determine the number of structural variables of integer kind
whose current values are still fractional */
n = lpx_get_num_cols(prob);
tol_int = lpx_get_real_parm(prob, LPX_K_TOLINT);
count = 0;
for (j = 1; j <= n; j++)
{ if (lpx_get_col_kind(prob, j) != LPX_IV) continue;
x = lpx_get_col_prim(prob, j);
if (fabs(x - floor(x + 0.5)) <= tol_int) continue;
count++;
}
print("&%6d: obj = %17.9e frac = %5d cuts = %5d (%d)",
lpx_get_int_parm(prob, LPX_K_ITCNT),
lpx_get_obj_val(prob), count,
lpx_get_num_rows(prob) - prob_m,
lpx_get_num_nz(prob) - prob_nz);
return;
}
LPX *lpp_build_prob(LPP *lpp)
{ LPX *prob;
LPPROW *row;
LPPCOL *col;
struct load_info info;
int i, j, typx;
/* count number of rows and columns in the resultant problem */
lpp->m = lpp->n = 0;
for (row = lpp->row_ptr; row != NULL; row = row->next) lpp->m++;
for (col = lpp->col_ptr; col != NULL; col = col->next) lpp->n++;
/* allocate two arrays to save reference numbers assigned to rows
and columns of the resultant problem */
lpp->row_ref = ucalloc(1+lpp->m, sizeof(int));
lpp->col_ref = ucalloc(1+lpp->n, sizeof(int));
/* create LP problem object */
prob = lpx_create_prob();
/* the resultant problem should have the same optimization sense
as the original problem */
lpx_set_obj_dir(prob, lpp->orig_dir);
/* set the constant term of the objective function */
lpx_set_obj_c0(prob,
lpp->orig_dir == LPX_MIN ? + lpp->c0 : - lpp->c0);
/* create rows of the resultant problem */
insist(lpp->m > 0);
lpx_add_rows(prob, lpp->m);
for (i = 1, row = lpp->row_ptr; i <= lpp->m; i++, row = row->next)
{ insist(row != NULL);
lpp->row_ref[i] = row->i;
row->i = i;
if (row->lb == -DBL_MAX && row->ub == +DBL_MAX)
typx = LPX_FR;
else if (row->ub == +DBL_MAX)
typx = LPX_LO;
else if (row->lb == -DBL_MAX)
typx = LPX_UP;
else if (row->lb != row->ub)
typx = LPX_DB;
else
typx = LPX_FX;
lpx_set_row_bnds(prob, i, typx, row->lb, row->ub);
}
insist(row == NULL);
/* create columns of the resultant problem */
insist(lpp->n > 0);
lpx_add_cols(prob, lpp->n);
for (j = 1, col = lpp->col_ptr; j <= lpp->n; j++, col = col->next)
{ insist(col != NULL);
lpp->col_ref[j] = col->j;
col->j = j;
if (col->lb == -DBL_MAX && col->ub == +DBL_MAX)
typx = LPX_FR;
else if (col->ub == +DBL_MAX)
typx = LPX_LO;
else if (col->lb == -DBL_MAX)
typx = LPX_UP;
else if (col->lb != col->ub)
typx = LPX_DB;
else
typx = LPX_FX;
lpx_set_col_bnds(prob, j, typx, col->lb, col->ub);
lpx_set_col_coef(prob, j,
lpp->orig_dir == LPX_MIN ? + col->c : - col->c);
}
insist(col == NULL);
/* create the constraint matrix of the resultant problem */
info.lpp = lpp;
info.row = NULL;
info.aij = NULL;
lpx_load_mat(prob, &info, next_aij);
/* count number of non-zeros in the resultant problem */
lpp->nnz = lpx_get_num_nz(prob);
/* internal data structures that represnts the resultant problem
are no longer needed, so free them */
dmp_delete_pool(lpp->row_pool), lpp->row_pool = NULL;
dmp_delete_pool(lpp->col_pool), lpp->col_pool = NULL;
dmp_delete_pool(lpp->aij_pool), lpp->aij_pool = NULL;
lpp->row_ptr = NULL, lpp->col_ptr = NULL;
lpp->row_que = NULL, lpp->col_que = NULL;
/* return a pointer to the built LP problem object */
return prob;
}
void lpp_load_orig(LPP *lpp, LPX *orig)
{ LPPROW *row;
LPPCOL *col, **map;
int i, j, t, len, typx, *ndx;
double lb, ub, temp, *c, *val;
/* save some information about the original problem */
lpp->orig_m = lpx_get_num_rows(orig);
lpp->orig_n = lpx_get_num_cols(orig);
lpp->orig_nnz = lpx_get_num_nz(orig);
lpp->orig_dir = lpx_get_obj_dir(orig);
/* allocate working arrays */
c = ucalloc(1+lpp->orig_n, sizeof(double));
ndx = ucalloc(1+lpp->orig_n, sizeof(int));
val = ucalloc(1+lpp->orig_n, sizeof(double));
/* auxiliary variables (i.e. rows) in the original problem may
have non-zero objective coefficients; so, we substitute these
auxiliary variables into the objective function in order that
it depends only on structural variables (i.e. columns); the
resultant vector of objective coefficients is accumulated in
the working array c */
for (j = 1; j <= lpp->orig_n; j++)
c[j] = lpx_get_col_coef(orig, j);
for (i = 1; i <= lpp->orig_m; i++)
{ /* obtain an objective coefficient at i-th row */
temp = lpx_get_row_coef(orig, i);
/* substitute i-th row into the objective function */
if (temp != 0.0)
{ len = lpx_get_mat_row(orig, i, ndx, val);
for (t = 1; t <= len; t++) c[ndx[t]] += val[t] * temp;
}
}
/* copy rows of the original problem into the workspace; each
row created in the workspace is assigned a reference number,
which is its ordinal number in the original problem */
for (i = 1; i <= lpp->orig_m; i++)
{ lpx_get_row_bnds(orig, i, &typx, &lb, &ub);
if (typx == LPX_FR || typx == LPX_UP) lb = -DBL_MAX;
if (typx == LPX_FR || typx == LPX_LO) ub = +DBL_MAX;
if (typx == LPX_FX) ub = lb;
lpp_add_row(lpp, lb, ub);
}
/* copy columns of the original problem into the workspace; each
column created in the workspace is assigned a reference number,
which its ordinal number in the original problem */
for (j = 1; j <= lpp->orig_n; j++)
{ lpx_get_col_bnds(orig, j, &typx, &lb, &ub);
if (typx == LPX_FR || typx == LPX_UP) lb = -DBL_MAX;
if (typx == LPX_FR || typx == LPX_LO) ub = +DBL_MAX;
if (typx == LPX_FX) ub = lb;
lpp_add_col(lpp, lb, ub, c[j]);
}
/* copy the constant term of the original objective function */
lpp->c0 = lpx_get_obj_c0(orig);
/* if the original problem is maximization, change the sign of
the objective function, because the transformed problem to be
processed by the presolver must be minimization */
if (lpp->orig_dir == LPX_MAX)
{ for (col = lpp->col_ptr; col != NULL; col = col->next)
col->c = - col->c;
lpp->c0 = - lpp->c0;
}
/* build an auxiliary array to map column ordinal numbers to the
corresponding pointers */
insist(sizeof(LPPCOL *) <= sizeof(double));
map = (LPPCOL **)c;
for (col = lpp->col_ptr; col != NULL; col = col->next)
map[col->j] = col;
/* copy the original constraint matrix into the workspace */
for (row = lpp->row_ptr; row != NULL; row = row->next)
#if 1
{ len = lpx_get_mat_row(orig, row->i, ndx, val);
for (t = 1; t <= len; t++)
lpp_add_aij(lpp, row, map[ndx[t]], val[t]);
}
#else /* 27/XI-2003 (the problem persists) */
{ double big, eps;
len = lpx_get_mat_row(orig, row->i, ndx, val);
big = 0.0;
for (t = 1; t <= len; t++)
if (big < fabs(val[t])) big = fabs(val[t]);
eps = 1e-10 * big;
for (t = 1; t <= len; t++)
{ if (fabs(val[t]) < eps) continue;
lpp_add_aij(lpp, row, map[ndx[t]], val[t]);
}
}
#endif
/* free working arrays */
ufree(c);
ufree(ndx);
ufree(val);
return;
}
LPX *lpx_read_cpxlp(const char *fname)
{ /* read problem data in CPLEX LP format */
struct dsa _dsa, *dsa = &_dsa;
if (setjmp(dsa->jump)) goto fail;
dsa->lp = NULL;
dsa->fname = fname;
dsa->fp = NULL;
dsa->count = 0;
dsa->c = '\n';
dsa->token = T_EOF;
dsa->image[0] = '\0';
dsa->imlen = 0;
dsa->value = 0.0;
dsa->n_max = 100;
dsa->map = xcalloc(1+dsa->n_max, sizeof(int));
memset(&dsa->map[1], 0, dsa->n_max * sizeof(int));
dsa->ind = xcalloc(1+dsa->n_max, sizeof(int));
dsa->val = xcalloc(1+dsa->n_max, sizeof(double));
dsa->lb = xcalloc(1+dsa->n_max, sizeof(double));
dsa->ub = xcalloc(1+dsa->n_max, sizeof(double));
print("lpx_read_cpxlp: reading problem data from `%s'...",
dsa->fname);
dsa->fp = xfopen(dsa->fname, "r");
if (dsa->fp == NULL)
{ print("lpx_read_cpxlp: unable to open `%s' - %s", dsa->fname,
strerror(errno));
goto fail;
}
dsa->lp = lpx_create_prob();
lpx_create_index(dsa->lp);
#if 0
/* read very first character */
read_char(dsa);
#endif
/* scan very first token */
scan_token(dsa);
/* parse definition of the objective function */
if (!(dsa->token == T_MINIMIZE || dsa->token == T_MAXIMIZE))
fatal(dsa, "`minimize' or `maximize' keyword missing");
parse_objective(dsa);
/* parse constraints section */
if (dsa->token != T_SUBJECT_TO)
fatal(dsa, "constraints section missing");
parse_constraints(dsa);
/* parse optional bounds section */
if (dsa->token == T_BOUNDS) parse_bounds(dsa);
/* parse optional general, integer, and binary sections */
while (dsa->token == T_GENERAL ||
dsa->token == T_INTEGER ||
dsa->token == T_BINARY) parse_integer(dsa);
/* check for the keyword 'end' */
if (dsa->token == T_END)
scan_token(dsa);
else if (dsa->token == T_EOF)
print("%s:%d: warning: keyword `end' missing", dsa->fname,
dsa->count);
else
fatal(dsa, "symbol `%s' in wrong position", dsa->image);
/* nothing must follow the keyword 'end' (except comments) */
if (dsa->token != T_EOF)
fatal(dsa, "extra symbol(s) detected beyond `end'");
/* set bounds of variables */
{ int j, type;
double lb, ub;
for (j = lpx_get_num_cols(dsa->lp); j >= 1; j--)
{ lb = dsa->lb[j];
ub = dsa->ub[j];
if (lb == +DBL_MAX) lb = 0.0; /* default lb */
if (ub == -DBL_MAX) ub = +DBL_MAX; /* default ub */
if (lb == -DBL_MAX && ub == +DBL_MAX)
type = LPX_FR;
else if (ub == +DBL_MAX)
type = LPX_LO;
else if (lb == -DBL_MAX)
type = LPX_UP;
else if (lb != ub)
type = LPX_DB;
else
type = LPX_FX;
lpx_set_col_bnds(dsa->lp, j, type, lb, ub);
}
}
/* print some statistics */
{ int m = lpx_get_num_rows(dsa->lp);
int n = lpx_get_num_cols(dsa->lp);
int nnz = lpx_get_num_nz(dsa->lp);
print("lpx_read_cpxlp: %d row%s, %d column%s, %d non-zero%s",
m, m == 1 ? "" : "s", n, n == 1 ? "" : "s", nnz, nnz == 1 ?
"" : "s");
}
if (lpx_get_class(dsa->lp) == LPX_MIP)
{ int ni = lpx_get_num_int(dsa->lp);
int nb = lpx_get_num_bin(dsa->lp);
char s[50];
if (nb == 0)
strcpy(s, "none of");
else if (ni == 1 && nb == 1)
strcpy(s, "");
else if (nb == 1)
strcpy(s, "one of");
else if (nb == ni)
strcpy(s, "all of");
else
sprintf(s, "%d of", nb);
print("lpx_read_cpxlp: %d integer column%s, %s which %s binary"
, ni, ni == 1 ? "" : "s", s, nb == 1 ? "is" : "are");
}
print("lpx_read_cpxlp: %d lines were read", dsa->count);
xfclose(dsa->fp);
xfree(dsa->map);
xfree(dsa->ind);
xfree(dsa->val);
xfree(dsa->lb);
xfree(dsa->ub);
lpx_delete_index(dsa->lp);
lpx_order_matrix(dsa->lp);
return dsa->lp;
fail: if (dsa->lp != NULL) lpx_delete_prob(dsa->lp);
if (dsa->fp != NULL) xfclose(dsa->fp);
if (dsa->map != NULL) xfree(dsa->map);
if (dsa->ind != NULL) xfree(dsa->ind);
if (dsa->val != NULL) xfree(dsa->val);
if (dsa->lb != NULL) xfree(dsa->lb);
if (dsa->ub != NULL) xfree(dsa->ub);
return NULL;
}
int lpx_print_prob(LPX *lp, const char *fname)
{ XFILE *fp;
int m, n, mip, i, j, len, t, type, *ndx;
double coef, lb, ub, *val;
char *str, name[255+1];
xprintf("lpx_write_prob: writing problem data to `%s'...\n",
fname);
fp = xfopen(fname, "w");
if (fp == NULL)
{ xprintf("lpx_write_prob: unable to create `%s' - %s\n",
fname, strerror(errno));
goto fail;
}
m = lpx_get_num_rows(lp);
n = lpx_get_num_cols(lp);
mip = (lpx_get_class(lp) == LPX_MIP);
str = (void *)lpx_get_prob_name(lp);
xfprintf(fp, "Problem: %s\n", str == NULL ? "(unnamed)" : str);
xfprintf(fp, "Class: %s\n", !mip ? "LP" : "MIP");
xfprintf(fp, "Rows: %d\n", m);
if (!mip)
xfprintf(fp, "Columns: %d\n", n);
else
xfprintf(fp, "Columns: %d (%d integer, %d binary)\n",
n, lpx_get_num_int(lp), lpx_get_num_bin(lp));
xfprintf(fp, "Non-zeros: %d\n", lpx_get_num_nz(lp));
xfprintf(fp, "\n");
xfprintf(fp, "*** OBJECTIVE FUNCTION ***\n");
xfprintf(fp, "\n");
switch (lpx_get_obj_dir(lp))
{ case LPX_MIN:
xfprintf(fp, "Minimize:");
break;
case LPX_MAX:
xfprintf(fp, "Maximize:");
break;
default:
xassert(lp != lp);
}
str = (void *)lpx_get_obj_name(lp);
xfprintf(fp, " %s\n", str == NULL ? "(unnamed)" : str);
coef = lpx_get_obj_coef(lp, 0);
if (coef != 0.0)
xfprintf(fp, "%*.*g %s\n", DBL_DIG+7, DBL_DIG, coef,
"(constant term)");
for (i = 1; i <= m; i++)
#if 0
{ coef = lpx_get_row_coef(lp, i);
#else
{ coef = 0.0;
#endif
if (coef != 0.0)
xfprintf(fp, "%*.*g %s\n", DBL_DIG+7, DBL_DIG, coef,
row_name(lp, i, name));
}
for (j = 1; j <= n; j++)
{ coef = lpx_get_obj_coef(lp, j);
if (coef != 0.0)
xfprintf(fp, "%*.*g %s\n", DBL_DIG+7, DBL_DIG, coef,
col_name(lp, j, name));
}
xfprintf(fp, "\n");
xfprintf(fp, "*** ROWS (CONSTRAINTS) ***\n");
ndx = xcalloc(1+n, sizeof(int));
val = xcalloc(1+n, sizeof(double));
for (i = 1; i <= m; i++)
{ xfprintf(fp, "\n");
xfprintf(fp, "Row %d: %s", i, row_name(lp, i, name));
lpx_get_row_bnds(lp, i, &type, &lb, &ub);
switch (type)
{ case LPX_FR:
xfprintf(fp, " free");
break;
case LPX_LO:
xfprintf(fp, " >= %.*g", DBL_DIG, lb);
break;
case LPX_UP:
xfprintf(fp, " <= %.*g", DBL_DIG, ub);
break;
case LPX_DB:
xfprintf(fp, " >= %.*g <= %.*g", DBL_DIG, lb, DBL_DIG,
ub);
break;
case LPX_FX:
xfprintf(fp, " = %.*g", DBL_DIG, lb);
break;
default:
xassert(type != type);
}
xfprintf(fp, "\n");
#if 0
coef = lpx_get_row_coef(lp, i);
#else
coef = 0.0;
#endif
if (coef != 0.0)
xfprintf(fp, "%*.*g %s\n", DBL_DIG+7, DBL_DIG, coef,
"(objective)");
len = lpx_get_mat_row(lp, i, ndx, val);
for (t = 1; t <= len; t++)
xfprintf(fp, "%*.*g %s\n", DBL_DIG+7, DBL_DIG, val[t],
col_name(lp, ndx[t], name));
}
xfree(ndx);
xfree(val);
xfprintf(fp, "\n");
xfprintf(fp, "*** COLUMNS (VARIABLES) ***\n");
ndx = xcalloc(1+m, sizeof(int));
val = xcalloc(1+m, sizeof(double));
for (j = 1; j <= n; j++)
{ xfprintf(fp, "\n");
xfprintf(fp, "Col %d: %s", j, col_name(lp, j, name));
if (mip)
{ switch (lpx_get_col_kind(lp, j))
{ case LPX_CV:
break;
case LPX_IV:
xfprintf(fp, " integer");
break;
default:
xassert(lp != lp);
}
}
lpx_get_col_bnds(lp, j, &type, &lb, &ub);
switch (type)
{ case LPX_FR:
xfprintf(fp, " free");
break;
case LPX_LO:
xfprintf(fp, " >= %.*g", DBL_DIG, lb);
break;
case LPX_UP:
xfprintf(fp, " <= %.*g", DBL_DIG, ub);
break;
case LPX_DB:
xfprintf(fp, " >= %.*g <= %.*g", DBL_DIG, lb, DBL_DIG,
ub);
break;
case LPX_FX:
xfprintf(fp, " = %.*g", DBL_DIG, lb);
break;
default:
xassert(type != type);
}
xfprintf(fp, "\n");
coef = lpx_get_obj_coef(lp, j);
if (coef != 0.0)
xfprintf(fp, "%*.*g %s\n", DBL_DIG+7, DBL_DIG, coef,
"(objective)");
len = lpx_get_mat_col(lp, j, ndx, val);
for (t = 1; t <= len; t++)
xfprintf(fp, "%*.*g %s\n", DBL_DIG+7, DBL_DIG, val[t],
row_name(lp, ndx[t], name));
}
xfree(ndx);
xfree(val);
xfprintf(fp, "\n");
xfprintf(fp, "End of output\n");
xfflush(fp);
if (xferror(fp))
{ xprintf("lpx_write_prob: write error on `%s' - %s\n", fname,
strerror(errno));
goto fail;
}
xfclose(fp);
return 0;
fail: if (fp != NULL) xfclose(fp);
return 1;
}
#undef row_name
#undef col_name
/*----------------------------------------------------------------------
-- lpx_print_sol - write LP problem solution in printable format.
--
-- *Synopsis*
--
-- #include "glplpx.h"
-- int lpx_print_sol(LPX *lp, char *fname);
--
-- *Description*
--
-- The routine lpx_print_sol writes the current basic solution of an LP
-- problem, which is specified by the pointer lp, to a text file, whose
-- name is the character string fname, in printable format.
--
-- Information reported by the routine lpx_print_sol is intended mainly
-- for visual analysis.
--
-- *Returns*
--
-- If the operation was successful, the routine returns zero. Otherwise
-- the routine prints an error message and returns non-zero. */
int lpx_print_sol(LPX *lp, const char *fname)
{ XFILE *fp;
int what, round;
xprintf(
"lpx_print_sol: writing LP problem solution to `%s'...\n",
fname);
fp = xfopen(fname, "w");
if (fp == NULL)
{ xprintf("lpx_print_sol: can't create `%s' - %s\n", fname,
strerror(errno));
goto fail;
}
/* problem name */
{ const char *name;
name = lpx_get_prob_name(lp);
if (name == NULL) name = "";
xfprintf(fp, "%-12s%s\n", "Problem:", name);
}
/* number of rows (auxiliary variables) */
{ int nr;
nr = lpx_get_num_rows(lp);
xfprintf(fp, "%-12s%d\n", "Rows:", nr);
}
/* number of columns (structural variables) */
{ int nc;
nc = lpx_get_num_cols(lp);
xfprintf(fp, "%-12s%d\n", "Columns:", nc);
}
/* number of non-zeros (constraint coefficients) */
{ int nz;
nz = lpx_get_num_nz(lp);
xfprintf(fp, "%-12s%d\n", "Non-zeros:", nz);
}
/* solution status */
{ int status;
status = lpx_get_status(lp);
xfprintf(fp, "%-12s%s\n", "Status:",
status == LPX_OPT ? "OPTIMAL" :
status == LPX_FEAS ? "FEASIBLE" :
status == LPX_INFEAS ? "INFEASIBLE (INTERMEDIATE)" :
status == LPX_NOFEAS ? "INFEASIBLE (FINAL)" :
status == LPX_UNBND ? "UNBOUNDED" :
status == LPX_UNDEF ? "UNDEFINED" : "???");
}
/* objective function */
{ char *name;
int dir;
double obj;
name = (void *)lpx_get_obj_name(lp);
dir = lpx_get_obj_dir(lp);
obj = lpx_get_obj_val(lp);
xfprintf(fp, "%-12s%s%s%.10g %s\n", "Objective:",
name == NULL ? "" : name,
name == NULL ? "" : " = ", obj,
dir == LPX_MIN ? "(MINimum)" :
dir == LPX_MAX ? "(MAXimum)" : "(" "???" ")");
}
/* main sheet */
for (what = 1; what <= 2; what++)
{ int mn, ij;
xfprintf(fp, "\n");
xfprintf(fp, " No. %-12s St Activity Lower bound Upp"
"er bound Marginal\n",
what == 1 ? " Row name" : "Column name");
xfprintf(fp, "------ ------------ -- ------------- -----------"
"-- ------------- -------------\n");
mn = (what == 1 ? lpx_get_num_rows(lp) : lpx_get_num_cols(lp));
for (ij = 1; ij <= mn; ij++)
{ const char *name;
int typx, tagx;
double lb, ub, vx, dx;
if (what == 1)
{ name = lpx_get_row_name(lp, ij);
if (name == NULL) name = "";
lpx_get_row_bnds(lp, ij, &typx, &lb, &ub);
round = lpx_get_int_parm(lp, LPX_K_ROUND);
lpx_set_int_parm(lp, LPX_K_ROUND, 1);
lpx_get_row_info(lp, ij, &tagx, &vx, &dx);
lpx_set_int_parm(lp, LPX_K_ROUND, round);
}
else
{ name = lpx_get_col_name(lp, ij);
if (name == NULL) name = "";
lpx_get_col_bnds(lp, ij, &typx, &lb, &ub);
round = lpx_get_int_parm(lp, LPX_K_ROUND);
lpx_set_int_parm(lp, LPX_K_ROUND, 1);
lpx_get_col_info(lp, ij, &tagx, &vx, &dx);
lpx_set_int_parm(lp, LPX_K_ROUND, round);
}
/* row/column ordinal number */
xfprintf(fp, "%6d ", ij);
/* row column/name */
if (strlen(name) <= 12)
xfprintf(fp, "%-12s ", name);
else
xfprintf(fp, "%s\n%20s", name, "");
/* row/column status */
xfprintf(fp, "%s ",
tagx == LPX_BS ? "B " :
tagx == LPX_NL ? "NL" :
tagx == LPX_NU ? "NU" :
tagx == LPX_NF ? "NF" :
tagx == LPX_NS ? "NS" : "??");
/* row/column primal activity */
xfprintf(fp, "%13.6g ", vx);
/* row/column lower bound */
if (typx == LPX_LO || typx == LPX_DB || typx == LPX_FX)
xfprintf(fp, "%13.6g ", lb);
else
xfprintf(fp, "%13s ", "");
/* row/column upper bound */
if (typx == LPX_UP || typx == LPX_DB)
xfprintf(fp, "%13.6g ", ub);
else if (typx == LPX_FX)
xfprintf(fp, "%13s ", "=");
else
xfprintf(fp, "%13s ", "");
/* row/column dual activity */
if (tagx != LPX_BS)
{ if (dx == 0.0)
xfprintf(fp, "%13s", "< eps");
else
xfprintf(fp, "%13.6g", dx);
}
/* end of line */
xfprintf(fp, "\n");
}
}
xfprintf(fp, "\n");
#if 1
if (lpx_get_prim_stat(lp) != LPX_P_UNDEF &&
lpx_get_dual_stat(lp) != LPX_D_UNDEF)
{ int m = lpx_get_num_rows(lp);
LPXKKT kkt;
xfprintf(fp, "Karush-Kuhn-Tucker optimality conditions:\n\n");
lpx_check_kkt(lp, 1, &kkt);
xfprintf(fp, "KKT.PE: max.abs.err. = %.2e on row %d\n",
kkt.pe_ae_max, kkt.pe_ae_row);
xfprintf(fp, " max.rel.err. = %.2e on row %d\n",
kkt.pe_re_max, kkt.pe_re_row);
switch (kkt.pe_quality)
{ case 'H':
xfprintf(fp, " High quality\n");
break;
case 'M':
xfprintf(fp, " Medium quality\n");
break;
case 'L':
xfprintf(fp, " Low quality\n");
break;
default:
xfprintf(fp, " PRIMAL SOLUTION IS WRONG\n");
break;
}
xfprintf(fp, "\n");
xfprintf(fp, "KKT.PB: max.abs.err. = %.2e on %s %d\n",
kkt.pb_ae_max, kkt.pb_ae_ind <= m ? "row" : "column",
kkt.pb_ae_ind <= m ? kkt.pb_ae_ind : kkt.pb_ae_ind - m);
xfprintf(fp, " max.rel.err. = %.2e on %s %d\n",
kkt.pb_re_max, kkt.pb_re_ind <= m ? "row" : "column",
kkt.pb_re_ind <= m ? kkt.pb_re_ind : kkt.pb_re_ind - m);
switch (kkt.pb_quality)
{ case 'H':
xfprintf(fp, " High quality\n");
break;
case 'M':
xfprintf(fp, " Medium quality\n");
break;
case 'L':
xfprintf(fp, " Low quality\n");
break;
default:
xfprintf(fp, " PRIMAL SOLUTION IS INFEASIBLE\n");
break;
}
xfprintf(fp, "\n");
xfprintf(fp, "KKT.DE: max.abs.err. = %.2e on column %d\n",
kkt.de_ae_max, kkt.de_ae_col);
xfprintf(fp, " max.rel.err. = %.2e on column %d\n",
kkt.de_re_max, kkt.de_re_col);
switch (kkt.de_quality)
{ case 'H':
xfprintf(fp, " High quality\n");
break;
case 'M':
xfprintf(fp, " Medium quality\n");
break;
case 'L':
xfprintf(fp, " Low quality\n");
break;
default:
xfprintf(fp, " DUAL SOLUTION IS WRONG\n");
break;
}
xfprintf(fp, "\n");
xfprintf(fp, "KKT.DB: max.abs.err. = %.2e on %s %d\n",
kkt.db_ae_max, kkt.db_ae_ind <= m ? "row" : "column",
kkt.db_ae_ind <= m ? kkt.db_ae_ind : kkt.db_ae_ind - m);
xfprintf(fp, " max.rel.err. = %.2e on %s %d\n",
kkt.db_re_max, kkt.db_re_ind <= m ? "row" : "column",
kkt.db_re_ind <= m ? kkt.db_re_ind : kkt.db_re_ind - m);
switch (kkt.db_quality)
{ case 'H':
xfprintf(fp, " High quality\n");
break;
case 'M':
xfprintf(fp, " Medium quality\n");
break;
case 'L':
xfprintf(fp, " Low quality\n");
break;
default:
xfprintf(fp, " DUAL SOLUTION IS INFEASIBLE\n");
break;
}
xfprintf(fp, "\n");
}
#endif
#if 1
if (lpx_get_status(lp) == LPX_UNBND)
{ int m = lpx_get_num_rows(lp);
int k = lpx_get_ray_info(lp);
xfprintf(fp, "Unbounded ray: %s %d\n",
k <= m ? "row" : "column", k <= m ? k : k - m);
xfprintf(fp, "\n");
}
#endif
xfprintf(fp, "End of output\n");
xfflush(fp);
if (xferror(fp))
{ xprintf("lpx_print_sol: can't write to `%s' - %s\n", fname,
strerror(errno));
goto fail;
}
xfclose(fp);
return 0;
fail: if (fp != NULL) xfclose(fp);
return 1;
}
int lpx_print_mip(LPX *lp, const char *fname)
{ XFILE *fp;
int what, round;
#if 0
if (lpx_get_class(lp) != LPX_MIP)
fault("lpx_print_mip: error -- not a MIP problem");
#endif
xprintf(
"lpx_print_mip: writing MIP problem solution to `%s'...\n",
fname);
fp = xfopen(fname, "w");
if (fp == NULL)
{ xprintf("lpx_print_mip: can't create `%s' - %s\n", fname,
strerror(errno));
goto fail;
}
/* problem name */
{ const char *name;
name = lpx_get_prob_name(lp);
if (name == NULL) name = "";
xfprintf(fp, "%-12s%s\n", "Problem:", name);
}
/* number of rows (auxiliary variables) */
{ int nr;
nr = lpx_get_num_rows(lp);
xfprintf(fp, "%-12s%d\n", "Rows:", nr);
}
/* number of columns (structural variables) */
{ int nc, nc_int, nc_bin;
nc = lpx_get_num_cols(lp);
nc_int = lpx_get_num_int(lp);
nc_bin = lpx_get_num_bin(lp);
xfprintf(fp, "%-12s%d (%d integer, %d binary)\n", "Columns:",
nc, nc_int, nc_bin);
}
/* number of non-zeros (constraint coefficients) */
{ int nz;
nz = lpx_get_num_nz(lp);
xfprintf(fp, "%-12s%d\n", "Non-zeros:", nz);
}
/* solution status */
{ int status;
status = lpx_mip_status(lp);
xfprintf(fp, "%-12s%s\n", "Status:",
status == LPX_I_UNDEF ? "INTEGER UNDEFINED" :
status == LPX_I_OPT ? "INTEGER OPTIMAL" :
status == LPX_I_FEAS ? "INTEGER NON-OPTIMAL" :
status == LPX_I_NOFEAS ? "INTEGER EMPTY" : "???");
}
/* objective function */
{ char *name;
int dir;
double mip_obj;
name = (void *)lpx_get_obj_name(lp);
dir = lpx_get_obj_dir(lp);
mip_obj = lpx_mip_obj_val(lp);
xfprintf(fp, "%-12s%s%s%.10g %s\n", "Objective:",
name == NULL ? "" : name,
name == NULL ? "" : " = ", mip_obj,
dir == LPX_MIN ? "(MINimum)" :
dir == LPX_MAX ? "(MAXimum)" : "(" "???" ")");
}
/* main sheet */
for (what = 1; what <= 2; what++)
{ int mn, ij;
xfprintf(fp, "\n");
xfprintf(fp, " No. %-12s Activity Lower bound Upp"
"er bound\n",
what == 1 ? " Row name" : "Column name");
xfprintf(fp, "------ ------------ ------------- -----------"
"-- -------------\n");
mn = (what == 1 ? lpx_get_num_rows(lp) : lpx_get_num_cols(lp));
for (ij = 1; ij <= mn; ij++)
{ const char *name;
int kind, typx;
double lb, ub, vx;
if (what == 1)
{ name = lpx_get_row_name(lp, ij);
if (name == NULL) name = "";
kind = LPX_CV;
lpx_get_row_bnds(lp, ij, &typx, &lb, &ub);
round = lpx_get_int_parm(lp, LPX_K_ROUND);
lpx_set_int_parm(lp, LPX_K_ROUND, 1);
vx = lpx_mip_row_val(lp, ij);
lpx_set_int_parm(lp, LPX_K_ROUND, round);
}
else
{ name = lpx_get_col_name(lp, ij);
if (name == NULL) name = "";
kind = lpx_get_col_kind(lp, ij);
lpx_get_col_bnds(lp, ij, &typx, &lb, &ub);
round = lpx_get_int_parm(lp, LPX_K_ROUND);
lpx_set_int_parm(lp, LPX_K_ROUND, 1);
vx = lpx_mip_col_val(lp, ij);
lpx_set_int_parm(lp, LPX_K_ROUND, round);
}
/* row/column ordinal number */
xfprintf(fp, "%6d ", ij);
/* row column/name */
if (strlen(name) <= 12)
xfprintf(fp, "%-12s ", name);
else
xfprintf(fp, "%s\n%20s", name, "");
/* row/column kind */
xfprintf(fp, "%s ",
kind == LPX_CV ? " " : kind == LPX_IV ? "*" : "?");
/* row/column primal activity */
xfprintf(fp, "%13.6g", vx);
/* row/column lower and upper bounds */
switch (typx)
{ case LPX_FR:
break;
case LPX_LO:
xfprintf(fp, " %13.6g", lb);
break;
case LPX_UP:
xfprintf(fp, " %13s %13.6g", "", ub);
break;
case LPX_DB:
xfprintf(fp, " %13.6g %13.6g", lb, ub);
break;
case LPX_FX:
xfprintf(fp, " %13.6g %13s", lb, "=");
break;
default:
xassert(typx != typx);
}
/* end of line */
xfprintf(fp, "\n");
}
}
xfprintf(fp, "\n");
#if 1
if (lpx_mip_status(lp) != LPX_I_UNDEF)
{ int m = lpx_get_num_rows(lp);
LPXKKT kkt;
xfprintf(fp, "Integer feasibility conditions:\n\n");
lpx_check_int(lp, &kkt);
xfprintf(fp, "INT.PE: max.abs.err. = %.2e on row %d\n",
kkt.pe_ae_max, kkt.pe_ae_row);
xfprintf(fp, " max.rel.err. = %.2e on row %d\n",
kkt.pe_re_max, kkt.pe_re_row);
switch (kkt.pe_quality)
{ case 'H':
xfprintf(fp, " High quality\n");
break;
case 'M':
xfprintf(fp, " Medium quality\n");
break;
case 'L':
xfprintf(fp, " Low quality\n");
break;
default:
xfprintf(fp, " SOLUTION IS WRONG\n");
break;
}
xfprintf(fp, "\n");
xfprintf(fp, "INT.PB: max.abs.err. = %.2e on %s %d\n",
kkt.pb_ae_max, kkt.pb_ae_ind <= m ? "row" : "column",
kkt.pb_ae_ind <= m ? kkt.pb_ae_ind : kkt.pb_ae_ind - m);
xfprintf(fp, " max.rel.err. = %.2e on %s %d\n",
kkt.pb_re_max, kkt.pb_re_ind <= m ? "row" : "column",
kkt.pb_re_ind <= m ? kkt.pb_re_ind : kkt.pb_re_ind - m);
switch (kkt.pb_quality)
{ case 'H':
xfprintf(fp, " High quality\n");
break;
case 'M':
xfprintf(fp, " Medium quality\n");
break;
case 'L':
xfprintf(fp, " Low quality\n");
break;
default:
xfprintf(fp, " SOLUTION IS INFEASIBLE\n");
break;
}
xfprintf(fp, "\n");
}
#endif
xfprintf(fp, "End of output\n");
xfflush(fp);
if (xferror(fp))
{ xprintf("lpx_print_mip: can't write to `%s' - %s\n", fname,
strerror(errno));
goto fail;
}
xfclose(fp);
return 0;
fail: if (fp != NULL) xfclose(fp);
return 1;
}
int lpx_print_ips(LPX *lp, const char *fname)
{ XFILE *fp;
int what, round;
xprintf("lpx_print_ips: writing LP problem solution to `%s'...\n",
fname);
fp = xfopen(fname, "w");
if (fp == NULL)
{ xprintf("lpx_print_ips: can't create `%s' - %s\n", fname,
strerror(errno));
goto fail;
}
/* problem name */
{ const char *name;
name = lpx_get_prob_name(lp);
if (name == NULL) name = "";
xfprintf(fp, "%-12s%s\n", "Problem:", name);
}
/* number of rows (auxiliary variables) */
{ int nr;
nr = lpx_get_num_rows(lp);
xfprintf(fp, "%-12s%d\n", "Rows:", nr);
}
/* number of columns (structural variables) */
{ int nc;
nc = lpx_get_num_cols(lp);
xfprintf(fp, "%-12s%d\n", "Columns:", nc);
}
/* number of non-zeros (constraint coefficients) */
{ int nz;
nz = lpx_get_num_nz(lp);
xfprintf(fp, "%-12s%d\n", "Non-zeros:", nz);
}
/* solution status */
{ int status;
status = lpx_ipt_status(lp);
xfprintf(fp, "%-12s%s\n", "Status:",
status == LPX_T_UNDEF ? "INTERIOR UNDEFINED" :
status == LPX_T_OPT ? "INTERIOR OPTIMAL" : "???");
}
/* objective function */
{ char *name;
int dir;
double obj;
name = (void *)lpx_get_obj_name(lp);
dir = lpx_get_obj_dir(lp);
obj = lpx_ipt_obj_val(lp);
xfprintf(fp, "%-12s%s%s%.10g %s\n", "Objective:",
name == NULL ? "" : name,
name == NULL ? "" : " = ", obj,
dir == LPX_MIN ? "(MINimum)" :
dir == LPX_MAX ? "(MAXimum)" : "(" "???" ")");
}
/* main sheet */
for (what = 1; what <= 2; what++)
{ int mn, ij;
xfprintf(fp, "\n");
xfprintf(fp, " No. %-12s Activity Lower bound Upp"
"er bound Marginal\n",
what == 1 ? " Row name" : "Column name");
xfprintf(fp, "------ ------------ ------------- -----------"
"-- ------------- -------------\n");
mn = (what == 1 ? lpx_get_num_rows(lp) : lpx_get_num_cols(lp));
for (ij = 1; ij <= mn; ij++)
{ const char *name;
int typx /*, tagx */;
double lb, ub, vx, dx;
if (what == 1)
{ name = lpx_get_row_name(lp, ij);
if (name == NULL) name = "";
lpx_get_row_bnds(lp, ij, &typx, &lb, &ub);
round = lpx_get_int_parm(lp, LPX_K_ROUND);
lpx_set_int_parm(lp, LPX_K_ROUND, 1);
vx = lpx_ipt_row_prim(lp, ij);
dx = lpx_ipt_row_dual(lp, ij);
lpx_set_int_parm(lp, LPX_K_ROUND, round);
}
else
{ name = lpx_get_col_name(lp, ij);
if (name == NULL) name = "";
lpx_get_col_bnds(lp, ij, &typx, &lb, &ub);
round = lpx_get_int_parm(lp, LPX_K_ROUND);
lpx_set_int_parm(lp, LPX_K_ROUND, 1);
vx = lpx_ipt_col_prim(lp, ij);
dx = lpx_ipt_col_dual(lp, ij);
lpx_set_int_parm(lp, LPX_K_ROUND, round);
}
/* row/column ordinal number */
xfprintf(fp, "%6d ", ij);
/* row column/name */
if (strlen(name) <= 12)
xfprintf(fp, "%-12s ", name);
else
xfprintf(fp, "%s\n%20s", name, "");
/* two positions are currently not used */
xfprintf(fp, " ");
/* row/column primal activity */
xfprintf(fp, "%13.6g ", vx);
/* row/column lower bound */
if (typx == LPX_LO || typx == LPX_DB || typx == LPX_FX)
xfprintf(fp, "%13.6g ", lb);
else
xfprintf(fp, "%13s ", "");
/* row/column upper bound */
if (typx == LPX_UP || typx == LPX_DB)
xfprintf(fp, "%13.6g ", ub);
else if (typx == LPX_FX)
xfprintf(fp, "%13s ", "=");
else
xfprintf(fp, "%13s ", "");
/* row/column dual activity */
xfprintf(fp, "%13.6g", dx);
/* end of line */
xfprintf(fp, "\n");
}
}
xfprintf(fp, "\n");
xfprintf(fp, "End of output\n");
xfflush(fp);
if (xferror(fp))
{ xprintf("lpx_print_ips: can't write to `%s' - %s\n", fname,
strerror(errno));
goto fail;
}
xfclose(fp);
return 0;
fail: if (fp != NULL) xfclose(fp);
return 1;
}
int CClp_nnonzeros(CClp *lp)
{ /* RETURNS the number of nonzeros in the LP. */
return lpx_get_num_nz(lp->lp);
}
int CClp_limited_dualopt(CClp *lp, int iterationlim, int *status,
double *objupperlim)
{ /* CALLS the dual simplex method with a limit on the number of
pivots.
- upperbound it is used to cutoff the dual simplex method (when
the objective value reaches upperbound); it can be NULL;
- status returns the status of the optimization (it can be
NULL). */
int stat, ret;
insist(iterationlim == iterationlim);
insist(objupperlim == objupperlim);
if (MSGLEV >= 1)
{ int m = lpx_get_num_rows(lp->lp);
int n = lpx_get_num_cols(lp->lp);
int nz = lpx_get_num_nz(lp->lp);
print("CClp_limited_dualopt: m = %d; n = %d; nz = %d", m, n,
nz);
}
lpx_set_int_parm(lp->lp, LPX_K_DUAL, 1);
switch (MSGLEV)
{ case 0:
lpx_set_int_parm(lp->lp, LPX_K_MSGLEV, 0);
lpx_set_int_parm(lp->lp, LPX_K_OUTFRQ, 1000000);
lpx_set_real_parm(lp->lp, LPX_K_OUTDLY, 1e6);
break;
case 1:
lpx_set_int_parm(lp->lp, LPX_K_MSGLEV, 2);
lpx_set_int_parm(lp->lp, LPX_K_OUTFRQ, 200);
lpx_set_real_parm(lp->lp, LPX_K_OUTDLY, 5.0);
break;
case 2:
lpx_set_int_parm(lp->lp, LPX_K_MSGLEV, 3);
lpx_set_int_parm(lp->lp, LPX_K_OUTFRQ, 200);
lpx_set_real_parm(lp->lp, LPX_K_OUTDLY, 0.0);
break;
default:
insist(MSGLEV != MSGLEV);
}
ret = lpx_simplex(lp->lp);
if (ret == LPX_E_FAULT)
{ if (MSGLEV >= 1) print("CClp_limited_dualopt: restarting from "
"advanced basis...");
lpx_adv_basis(lp->lp);
ret = lpx_simplex(lp->lp);
}
if (ret != LPX_E_OK)
{ print("CClp_limited_dualopt: lpx_simplex failed; return code ="
" %d", ret);
if (status) *status = CClp_FAILURE;
ret = 1;
goto done;
}
stat = lpx_get_status(lp->lp);
if (stat == LPX_OPT)
{ if (status) *status = CClp_SUCCESS;
ret = 0;
}
else if (stat == LPX_NOFEAS)
{ if (status) *status = CClp_INFEASIBLE;
ret = 0;
}
else
{ print("CClp_limited_dualopt: optimization status = %d", stat);
if (status) *status = CClp_FAILURE;
ret = 1;
}
done: return ret;
}
int lpx_interior(LPX *_lp)
{ /* easy-to-use driver to the interior-point method */
struct dsa _dsa, *dsa = &_dsa;
int ret, status;
double *row_pval, *row_dval, *col_pval, *col_dval;
/* initialize working area */
dsa->lp = _lp;
dsa->orig_m = lpx_get_num_rows(dsa->lp);
dsa->orig_n = lpx_get_num_cols(dsa->lp);
dsa->ref = NULL;
dsa->m = 0;
dsa->n = 0;
dsa->size = 0;
dsa->ne = 0;
dsa->ia = NULL;
dsa->ja = NULL;
dsa->ar = NULL;
dsa->b = NULL;
dsa->c = NULL;
dsa->x = NULL;
dsa->y = NULL;
dsa->z = NULL;
/* check if the problem is empty */
if (!(dsa->orig_m > 0 && dsa->orig_n > 0))
{ print("lpx_interior: problem has no rows and/or columns");
ret = LPX_E_FAULT;
goto done;
}
/* issue warning about dense columns */
if (dsa->orig_m >= 200)
{ int j, len, ndc = 0;
for (j = 1; j <= dsa->orig_n; j++)
{ len = lpx_get_mat_col(dsa->lp, j, NULL, NULL);
if ((double)len > 0.30 * (double)dsa->orig_m) ndc++;
}
if (ndc == 1)
print("lpx_interior: WARNING: PROBLEM HAS ONE DENSE COLUMN")
;
else if (ndc > 0)
print("lpx_interior: WARNING: PROBLEM HAS %d DENSE COLUMNS",
ndc);
}
/* determine dimension of transformed LP */
print("lpx_interior: original LP problem has %d rows and %d colum"
"ns", dsa->orig_m, dsa->orig_n);
calc_mn(dsa);
print("lpx_interior: transformed LP problem has %d rows and %d co"
"lumns", dsa->m, dsa->n);
/* transform original LP to standard formulation */
dsa->ref = ucalloc(1+dsa->orig_m+dsa->orig_n, sizeof(int));
dsa->size = lpx_get_num_nz(dsa->lp);
if (dsa->size < dsa->m) dsa->size = dsa->m;
if (dsa->size < dsa->n) dsa->size = dsa->n;
dsa->ne = 0;
dsa->ia = ucalloc(1+dsa->size, sizeof(int));
dsa->ja = ucalloc(1+dsa->size, sizeof(int));
dsa->ar = ucalloc(1+dsa->size, sizeof(double));
dsa->b = ucalloc(1+dsa->m, sizeof(double));
dsa->c = ucalloc(1+dsa->n, sizeof(double));
transform(dsa);
/* solve the transformed LP problem */
{ int *A_ptr = ucalloc(1+dsa->m+1, sizeof(int));
int *A_ind = ucalloc(1+dsa->ne, sizeof(int));
double *A_val = ucalloc(1+dsa->ne, sizeof(double));
int i, k, pos, len;
/* determine row lengths */
for (i = 1; i <= dsa->m; i++)
A_ptr[i] = 0;
for (k = 1; k <= dsa->ne; k++)
A_ptr[dsa->ia[k]]++;
/* set up row pointers */
pos = 1;
for (i = 1; i <= dsa->m; i++)
len = A_ptr[i], pos += len, A_ptr[i] = pos;
A_ptr[dsa->m+1] = pos;
insist(pos - 1 == dsa->ne);
/* build the matrix */
for (k = 1; k <= dsa->ne; k++)
{ pos = --A_ptr[dsa->ia[k]];
A_ind[pos] = dsa->ja[k];
A_val[pos] = dsa->ar[k];
}
ufree(dsa->ia), dsa->ia = NULL;
ufree(dsa->ja), dsa->ja = NULL;
ufree(dsa->ar), dsa->ar = NULL;
dsa->x = ucalloc(1+dsa->n, sizeof(double));
dsa->y = ucalloc(1+dsa->m, sizeof(double));
dsa->z = ucalloc(1+dsa->n, sizeof(double));
ret = ipm_main(dsa->m, dsa->n, A_ptr, A_ind, A_val, dsa->b,
dsa->c, dsa->x, dsa->y, dsa->z);
ufree(A_ptr);
ufree(A_ind);
ufree(A_val);
ufree(dsa->b), dsa->b = NULL;
ufree(dsa->c), dsa->c = NULL;
}
/* analyze return code reported by the solver */
switch (ret)
{
case 0:
/* optimal solution found */
ret = LPX_E_OK;
break;
case 1:
/* problem has no feasible (primal or dual) solution */
ret = LPX_E_NOFEAS;
break;
case 2:
/* no convergence */
ret = LPX_E_NOCONV;
break;
case 3:
/* iterations limit exceeded */
ret = LPX_E_ITLIM;
break;
case 4:
/* numerical instability on solving Newtonian system */
ret = LPX_E_INSTAB;
break;
default:
insist(ret != ret);
}
/* recover solution of original LP */
row_pval = ucalloc(1+dsa->orig_m, sizeof(double));
row_dval = ucalloc(1+dsa->orig_m, sizeof(double));
col_pval = ucalloc(1+dsa->orig_n, sizeof(double));
col_dval = ucalloc(1+dsa->orig_n, sizeof(double));
restore(dsa, row_pval, row_dval, col_pval, col_dval);
ufree(dsa->ref), dsa->ref = NULL;
ufree(dsa->x), dsa->x = NULL;
ufree(dsa->y), dsa->y = NULL;
ufree(dsa->z), dsa->z = NULL;
/* store solution components into the problem object */
status = (ret == LPX_E_OK ? LPX_T_OPT : LPX_T_UNDEF);
lpx_put_ipt_soln(dsa->lp, status, row_pval, row_dval, col_pval,
col_dval);
ufree(row_pval);
ufree(row_dval);
ufree(col_pval);
ufree(col_dval);
done: /* return to the calling program */
return ret;
}
void ipp_load_orig(IPP *ipp, LPX *orig)
{ IPPROW **row;
IPPCOL *col;
int i, j, k, type, len, *ind;
double lb, ub, *val;
/* save some information about the original problem */
ipp->orig_m = lpx_get_num_rows(orig);
ipp->orig_n = lpx_get_num_cols(orig);
ipp->orig_nnz = lpx_get_num_nz(orig);
ipp->orig_dir = lpx_get_obj_dir(orig);
/* allocate working arrays */
row = xcalloc(1+ipp->orig_m, sizeof(IPPROW *));
ind = xcalloc(1+ipp->orig_m, sizeof(int));
val = xcalloc(1+ipp->orig_m, sizeof(double));
/* copy rows of the original problem into the workspace */
for (i = 1; i <= ipp->orig_m; i++)
{ type = lpx_get_row_type(orig, i);
if (type == LPX_FR || type == LPX_UP)
lb = -DBL_MAX;
else
lb = lpx_get_row_lb(orig, i);
if (type == LPX_FR || type == LPX_LO)
ub = +DBL_MAX;
else
ub = lpx_get_row_ub(orig, i);
row[i] = ipp_add_row(ipp, lb, ub);
}
/* copy columns of the original problem into the workspace; each
column created in the workspace is assigned a reference number
which is its ordinal number in the original problem */
for (j = 1; j <= ipp->orig_n; j++)
{ type = lpx_get_col_type(orig, j);
if (type == LPX_FR || type == LPX_UP)
lb = -DBL_MAX;
else
lb = lpx_get_col_lb(orig, j);
if (type == LPX_FR || type == LPX_LO)
ub = +DBL_MAX;
else
ub = lpx_get_col_ub(orig, j);
col = ipp_add_col(ipp, lpx_get_col_kind(orig, j) == LPX_IV,
lb, ub, lpx_get_obj_coef(orig, j));
len = lpx_get_mat_col(orig, j, ind, val);
for (k = 1; k <= len; k++)
ipp_add_aij(ipp, row[ind[k]], col, val[k]);
}
/* copy the constant term of the original objective function */
ipp->c0 = lpx_get_obj_coef(orig, 0);
/* if the original problem is maximization, change the sign of
the objective function, because the transformed problem to be
processed by the presolver must be minimization */
if (ipp->orig_dir == LPX_MAX)
{ for (col = ipp->col_ptr; col != NULL; col = col->next)
col->c = - col->c;
ipp->c0 = - ipp->c0;
}
/* free working arrays */
xfree(row);
xfree(ind);
xfree(val);
return;
}
int lpx_intopt(LPX *_mip)
{ IPP *ipp = NULL;
LPX *orig = _mip, *prob = NULL;
int orig_m, orig_n, i, j, ret, i_stat;
/* the problem must be of MIP class */
if (lpx_get_class(orig) != LPX_MIP)
{ print("lpx_intopt: problem is not of MIP class");
ret = LPX_E_FAULT;
goto done;
}
/* the problem must have at least one row and one column */
orig_m = lpx_get_num_rows(orig);
orig_n = lpx_get_num_cols(orig);
if (!(orig_m > 0 && orig_n > 0))
{ print("lpx_intopt: problem has no rows/columns");
ret = LPX_E_FAULT;
goto done;
}
/* check that each double-bounded row and column has bounds */
for (i = 1; i <= orig_m; i++)
{ if (lpx_get_row_type(orig, i) == LPX_DB)
{ if (lpx_get_row_lb(orig, i) >= lpx_get_row_ub(orig, i))
{ print("lpx_intopt: row %d has incorrect bounds", i);
ret = LPX_E_FAULT;
goto done;
}
}
}
for (j = 1; j <= orig_n; j++)
{ if (lpx_get_col_type(orig, j) == LPX_DB)
{ if (lpx_get_col_lb(orig, j) >= lpx_get_col_ub(orig, j))
{ print("lpx_intopt: column %d has incorrect bounds", j);
ret = LPX_E_FAULT;
goto done;
}
}
}
/* bounds of all integer variables must be integral */
for (j = 1; j <= orig_n; j++)
{ int type;
double lb, ub;
if (lpx_get_col_kind(orig, j) != LPX_IV) continue;
type = lpx_get_col_type(orig, j);
if (type == LPX_LO || type == LPX_DB || type == LPX_FX)
{ lb = lpx_get_col_lb(orig, j);
if (lb != floor(lb))
{ print("lpx_intopt: integer column %d has non-integer low"
"er bound or fixed value %g", j, lb);
ret = LPX_E_FAULT;
goto done;
}
}
if (type == LPX_UP || type == LPX_DB)
{ ub = lpx_get_col_ub(orig, j);
if (ub != floor(ub))
{ print("lpx_intopt: integer column %d has non-integer upp"
"er bound %g", j, ub);
ret = LPX_E_FAULT;
goto done;
}
}
}
/* reset the status of MIP solution */
lpx_put_mip_soln(orig, LPX_I_UNDEF, NULL, NULL);
/* create MIP presolver workspace */
ipp = ipp_create_wksp();
/* load the original problem into the presolver workspace */
ipp_load_orig(ipp, orig);
/* perform basic MIP presolve analysis */
switch (ipp_basic_tech(ipp))
{ case 0:
/* no infeasibility is detected */
break;
case 1:
nopfs: /* primal infeasibility is detected */
print("PROBLEM HAS NO PRIMAL FEASIBLE SOLUTION");
ret = LPX_E_NOPFS;
goto done;
case 2:
/* dual infeasibility is detected */
nodfs: print("LP RELAXATION HAS NO DUAL FEASIBLE SOLUTION");
ret = LPX_E_NODFS;
goto done;
default:
insist(ipp != ipp);
}
/* reduce column bounds */
switch (ipp_reduce_bnds(ipp))
{ case 0: break;
case 1: goto nopfs;
default: insist(ipp != ipp);
}
/* perform basic MIP presolve analysis */
switch (ipp_basic_tech(ipp))
{ case 0: break;
case 1: goto nopfs;
case 2: goto nodfs;
default: insist(ipp != ipp);
}
/* replace general integer variables by sum of binary variables,
if required */
if (lpx_get_int_parm(orig, LPX_K_BINARIZE))
ipp_binarize(ipp);
/* perform coefficient reduction */
ipp_reduction(ipp);
/* if the resultant problem is empty, it has an empty solution,
which is optimal */
if (ipp->row_ptr == NULL || ipp->col_ptr == NULL)
{ insist(ipp->row_ptr == NULL);
insist(ipp->col_ptr == NULL);
print("Objective value = %.10g",
ipp->orig_dir == LPX_MIN ? +ipp->c0 : -ipp->c0);
print("INTEGER OPTIMAL SOLUTION FOUND BY MIP PRESOLVER");
/* allocate recovered solution segment */
ipp->col_stat = ucalloc(1+ipp->ncols, sizeof(int));
ipp->col_mipx = ucalloc(1+ipp->ncols, sizeof(double));
for (j = 1; j <= ipp->ncols; j++) ipp->col_stat[j] = 0;
/* perform MIP postsolve processing */
ipp_postsolve(ipp);
/* unload recovered MIP solution and store it in the original
problem object */
ipp_unload_sol(ipp, orig, LPX_I_OPT);
ret = LPX_E_OK;
goto done;
}
/* build resultant MIP problem object */
prob = ipp_build_prob(ipp);
/* display some statistics */
{ int m = lpx_get_num_rows(prob);
int n = lpx_get_num_cols(prob);
int nnz = lpx_get_num_nz(prob);
int ni = lpx_get_num_int(prob);
int nb = lpx_get_num_bin(prob);
char s[50];
print("lpx_intopt: presolved MIP has %d row%s, %d column%s, %d"
" non-zero%s", m, m == 1 ? "" : "s", n, n == 1 ? "" : "s",
nnz, nnz == 1 ? "" : "s");
if (nb == 0)
strcpy(s, "none of");
else if (ni == 1 && nb == 1)
strcpy(s, "");
else if (nb == 1)
strcpy(s, "one of");
else if (nb == ni)
strcpy(s, "all of");
else
sprintf(s, "%d of", nb);
print("lpx_intopt: %d integer column%s, %s which %s binary",
ni, ni == 1 ? "" : "s", s, nb == 1 ? "is" : "are");
}
/* inherit some control parameters and statistics */
lpx_set_int_parm(prob, LPX_K_PRICE, lpx_get_int_parm(orig,
LPX_K_PRICE));
lpx_set_real_parm(prob, LPX_K_RELAX, lpx_get_real_parm(orig,
LPX_K_RELAX));
lpx_set_real_parm(prob, LPX_K_TOLBND, lpx_get_real_parm(orig,
LPX_K_TOLBND));
lpx_set_real_parm(prob, LPX_K_TOLDJ, lpx_get_real_parm(orig,
LPX_K_TOLDJ));
lpx_set_real_parm(prob, LPX_K_TOLPIV, lpx_get_real_parm(orig,
LPX_K_TOLPIV));
lpx_set_int_parm(prob, LPX_K_ITLIM, lpx_get_int_parm(orig,
LPX_K_ITLIM));
lpx_set_int_parm(prob, LPX_K_ITCNT, lpx_get_int_parm(orig,
LPX_K_ITCNT));
lpx_set_real_parm(prob, LPX_K_TMLIM, lpx_get_real_parm(orig,
LPX_K_TMLIM));
lpx_set_int_parm(prob, LPX_K_BRANCH, lpx_get_int_parm(orig,
LPX_K_BRANCH));
lpx_set_int_parm(prob, LPX_K_BTRACK, lpx_get_int_parm(orig,
LPX_K_BTRACK));
lpx_set_real_parm(prob, LPX_K_TOLINT, lpx_get_real_parm(orig,
LPX_K_TOLINT));
lpx_set_real_parm(prob, LPX_K_TOLOBJ, lpx_get_real_parm(orig,
LPX_K_TOLOBJ));
/* build an advanced initial basis */
lpx_adv_basis(prob);
/* solve LP relaxation */
print("Solving LP relaxation...");
switch (lpx_simplex(prob))
{ case LPX_E_OK:
break;
case LPX_E_ITLIM:
ret = LPX_E_ITLIM;
goto done;
case LPX_E_TMLIM:
ret = LPX_E_TMLIM;
goto done;
default:
print("lpx_intopt: cannot solve LP relaxation");
ret = LPX_E_SING;
goto done;
}
/* analyze status of the basic solution */
switch (lpx_get_status(prob))
{ case LPX_OPT:
break;
case LPX_NOFEAS:
ret = LPX_E_NOPFS;
goto done;
case LPX_UNBND:
ret = LPX_E_NODFS;
goto done;
default:
insist(prob != prob);
}
/* generate cutting planes, if necessary */
if (lpx_get_int_parm(orig, LPX_K_USECUTS))
{ ret = generate_cuts(prob);
if (ret != LPX_E_OK) goto done;
}
/* call the branch-and-bound solver */
ret = lpx_integer(prob);
/* determine status of MIP solution */
i_stat = lpx_mip_status(prob);
if (i_stat == LPX_I_OPT || i_stat == LPX_I_FEAS)
{ /* load MIP solution of the resultant problem into presolver
workspace */
ipp_load_sol(ipp, prob);
/* perform MIP postsolve processing */
ipp_postsolve(ipp);
/* unload recovered MIP solution and store it in the original
problem object */
ipp_unload_sol(ipp, orig, i_stat);
}
else
{ /* just set the status of MIP solution */
lpx_put_mip_soln(orig, i_stat, NULL, NULL);
}
done: /* copy back statistics about spent resources */
if (prob != NULL)
{ lpx_set_int_parm(orig, LPX_K_ITLIM, lpx_get_int_parm(prob,
LPX_K_ITLIM));
lpx_set_int_parm(orig, LPX_K_ITCNT, lpx_get_int_parm(prob,
LPX_K_ITCNT));
lpx_set_real_parm(orig, LPX_K_TMLIM, lpx_get_real_parm(prob,
LPX_K_TMLIM));
}
/* delete the resultant problem object */
if (prob != NULL) lpx_delete_prob(prob);
/* delete MIP presolver workspace */
if (ipp != NULL) ipp_delete_wksp(ipp);
return ret;
}
static int generate_cuts(LPX *prob)
{ int prob_m, prob_n, prob_nz, msg_lev, dual, nrows, it_cnt, ret;
double out_dly, tm_lim, tm_lag = 0.0, tm_beg = utime();
print("Generating cutting planes...");
/* determine the number of rows, columns, and non-zeros on entry
to the routine */
prob_m = lpx_get_num_rows(prob);
prob_n = lpx_get_num_cols(prob);
prob_nz = lpx_get_num_nz(prob);
/* save some control parameters */
msg_lev = lpx_get_int_parm(prob, LPX_K_MSGLEV);
dual = lpx_get_int_parm(prob, LPX_K_DUAL);
out_dly = lpx_get_real_parm(prob, LPX_K_OUTDLY);
tm_lim = lpx_get_real_parm(prob, LPX_K_TMLIM);
/* and set their new values needed for re-optimization */
lpx_set_int_parm(prob, LPX_K_MSGLEV, 1);
lpx_set_int_parm(prob, LPX_K_DUAL, 1);
lpx_set_real_parm(prob, LPX_K_OUTDLY, 10.0);
lpx_set_real_parm(prob, LPX_K_TMLIM, -1.0);
loop: /* main loop starts here */
/* display current status of the problem */
if (utime() - tm_lag >= 5.0 - 0.001)
show_status(prob, prob_m, prob_nz), tm_lag = utime();
/* check if the patience has been exhausted */
if (tm_lim >= 0.0 && tm_lim <= utime() - tm_beg)
{ ret = LPX_E_TMLIM;
goto done;
}
/* not more than 500 cut inequalities are allowed */
if (lpx_get_num_rows(prob) - prob_m >= 500)
{ ret = LPX_E_OK;
goto done;
}
/* not more than 50,000 cut coefficients are allowed */
if (lpx_get_num_nz(prob) - prob_nz >= 50000)
{ ret = LPX_E_OK;
goto done;
}
/* try to generate Gomory's mixed integer cut */
nrows = lpx_get_num_rows(prob);
gen_gomory_cut(prob, prob_n);
if (nrows == lpx_get_num_rows(prob))
{ /* nothing has been generated */
ret = LPX_E_OK;
goto done;
}
/* re-optimize current LP relaxation using dual simplex */
it_cnt = lpx_get_int_parm(prob, LPX_K_ITCNT);
switch (lpx_simplex(prob))
{ case LPX_E_OK:
break;
case LPX_E_ITLIM:
ret = LPX_E_ITLIM;
goto done;
default:
ret = LPX_E_SING;
goto done;
}
if (it_cnt == lpx_get_int_parm(prob, LPX_K_ITCNT))
{ ret = LPX_E_OK;
goto done;
}
/* analyze status of the basic solution */
switch (lpx_get_status(prob))
{ case LPX_OPT:
break;
case LPX_NOFEAS:
ret = LPX_E_NOPFS;
goto done;
default:
insist(prob != prob);
}
/* continue generating cutting planes */
goto loop;
done: /* display final status of the problem */
show_status(prob, prob_m, prob_nz);
switch (ret)
{ case LPX_E_OK:
break;
case LPX_E_NOPFS:
print("PROBLEM HAS NO INTEGER FEASIBLE SOLUTION");
break;
case LPX_E_ITLIM:
print("ITERATIONS LIMIT EXCEEDED; SEARCH TERMINATED");
break;
case LPX_E_TMLIM:
print("TIME LIMIT EXCEEDED; SEARCH TERMINATED");
break;
case LPX_E_SING:
print("lpx_intopt: cannot re-optimize LP relaxation");
break;
default:
insist(ret != ret);
}
/* decrease the time limit by spent amount of the time */
if (tm_lim >= 0.0)
{ tm_lim -= (utime() - tm_beg);
if (tm_lim < 0.0) tm_lim = 0.0;
}
/* restore some control parameters and update statistics */
lpx_set_int_parm(prob, LPX_K_MSGLEV, msg_lev);
lpx_set_int_parm(prob, LPX_K_DUAL, dual);
lpx_set_real_parm(prob, LPX_K_OUTDLY, out_dly);
lpx_set_real_parm(prob, LPX_K_TMLIM, tm_lim);
return ret;
}
int lpx_print_sens_bnds(LPX *lp, char *fname)
{ FILE *fp = NULL;
int what, round;
print("lpx_print_sens_bnds: writing LP problem solution bounds to"
" `%s'...", fname);
#if 1
/* added by mao */
/* this routine needs factorization of the current basis matrix
which, however, does not exist if the basic solution was
obtained by the lp presolver; therefore we should warm up the
basis to be sure that the factorization is valid (note that if
the factorization exists, lpx_warm_up does nothing) */
lpx_warm_up(lp);
#endif
#if 0 /* 21/XII-2003 by mao */
if (lp->b_stat == LPX_B_UNDEF)
#else
if (!lpx_is_b_avail(lp))
#endif
{ print("lpx_print_sens_bnds: basis information not available (m"
"ay be a presolve issue)");
goto fail;
}
fp = ufopen(fname, "w");
if (fp == NULL)
{ print("lpx_print_sens_bnds: can't create `%s' - %s", fname,
strerror(errno));
goto fail;
}
/* problem name */
{ char *name;
name = lpx_get_prob_name(lp);
if (name == NULL) name = "";
fprintf(fp, "%-12s%s\n", "Problem:", name);
}
/* number of rows (auxiliary variables) */
{ int nr;
nr = lpx_get_num_rows(lp);
fprintf(fp, "%-12s%d\n", "Rows:", nr);
}
/* number of columns (structural variables) */
{ int nc;
nc = lpx_get_num_cols(lp);
fprintf(fp, "%-12s%d\n", "Columns:", nc);
}
/* number of non-zeros (constraint coefficients) */
{ int nz;
nz = lpx_get_num_nz(lp);
fprintf(fp, "%-12s%d\n", "Non-zeros:", nz);
}
/* solution status */
{ int status;
status = lpx_get_status(lp);
fprintf(fp, "%-12s%s\n", "Status:",
status == LPX_OPT ? "OPTIMAL" :
status == LPX_FEAS ? "FEASIBLE" :
status == LPX_INFEAS ? "INFEASIBLE (INTERMEDIATE)" :
status == LPX_NOFEAS ? "INFEASIBLE (FINAL)" :
status == LPX_UNBND ? "UNBOUNDED" :
status == LPX_UNDEF ? "UNDEFINED" : "???");
}
/* explanation/warning */
{ fprintf(fp, "\nExplanation: This file presents amounts by whi"
"ch objective coefficients,\n");
fprintf(fp, "constraint bounds, and variable bounds may be cha"
"nged in the original problem\n");
fprintf(fp, "while the optimal basis remains the same. Note t"
"hat the optimal solution\n");
fprintf(fp, "and objective value may change even though the ba"
"sis remains the same.\n");
fprintf(fp, "These bounds assume that all parameters remain fi"
"xed except the one in\n");
fprintf(fp, "question. If more than one parameter is changed,"
" it is possible for the\n");
fprintf(fp, "optimal basis to change even though each paramete"
"r stays within its bounds.\n");
fprintf(fp, "For more details, consult a text on linear progra"
"mming.\n");
}
/* Sensitivity ranges if solution was optimal */
{ int status;
status = lpx_get_status(lp);
if (status == LPX_OPT)
{ int i,j,k,m,n;
int dir;
double max_inc, max_dec;
int *index;
double *val;
fprintf(fp, "\nObjective Coefficient Analysis\n");
fprintf(fp, " No. Column name St Value Max incr"
"ease Max decrease\n");
fprintf(fp, "------ ------------ -- ------------- ---------"
"---- ------------- \n");
n = lpx_get_num_cols(lp);
m = lpx_get_num_rows(lp);
dir = lpx_get_obj_dir(lp);
/* allocate memory for index and val arrays */
index = ucalloc(1+n+m, sizeof(int));
val = ucalloc(1+n+m, sizeof(double));
for (j = 1; j <= n; j++)
{ char *name;
int typx, tagx;
double lb, ub, vx, dx;
name = lpx_get_col_name(lp, j);
if (name == NULL) name = "";
lpx_get_col_bnds(lp, j, &typx, &lb, &ub);
#if 0 /* 21/XII-2003 by mao */
round = lp->round, lp->round = 1;
lpx_get_col_info(lp, j, &tagx, &vx, &dx);
lp->round = round;
#else
round = lpx_get_int_parm(lp, LPX_K_ROUND);
lpx_set_int_parm(lp, LPX_K_ROUND, 1);
lpx_get_col_info(lp, j, &tagx, &vx, &dx);
lpx_set_int_parm(lp, LPX_K_ROUND, round);
#endif
/* row/column ordinal number */
fprintf(fp, "%6d ", j);
/* row column/name */
if (strlen(name) <= 12)
fprintf(fp, "%-12s ", name);
else
fprintf(fp, "%s\n%20s", name, "");
/* row/column status */
fprintf(fp, "%s ",
tagx == LPX_BS ? "B " :
tagx == LPX_NL ? "NL" :
tagx == LPX_NU ? "NU" :
tagx == LPX_NF ? "NF" :
tagx == LPX_NS ? "NS" : "??");
/* objective coefficient */
fprintf(fp, "%13.6g ", lpx_get_obj_coef(lp, j));
if (tagx == LPX_NL)
{ if (dir==LPX_MIN)
{ /* reduced cost must be positive */
max_inc = DBL_MAX; /* really represents infinity */
max_dec = dx;
}
else
{ /* reduced cost must be negative */
max_inc = -dx;
max_dec = DBL_MAX; /* means infinity */
}
}
if (tagx == LPX_NU)
{ if (dir==LPX_MIN)
{ /* reduced cost must be negative */
max_inc = -dx;
max_dec = DBL_MAX;
}
else
{ max_inc = DBL_MAX;
max_dec = dx;
}
}
if (tagx == LPX_NF)
{ /* can't change nonbasic free variables' cost */
max_inc = 0.0;
max_dec = 0.0;
}
if (tagx == LPX_NS)
{ /* doesn't matter what happens to the cost */
max_inc = DBL_MAX;
max_dec = DBL_MAX;
}
if (tagx == LPX_BS)
{ int len;
/* We need to see how this objective coefficient
affects reduced costs of other variables */
len = lpx_eval_tab_row(lp, m+j, index, val);
max_inc = DBL_MAX;
max_dec = DBL_MAX;
for (i = 1; i <= len; i++)
{ /*int stat;*/
int tagx2;
double vx2, dx2;
double delta;
if (index[i]>m)
lpx_get_col_info(lp, index[i]-m, &tagx2, &vx2,
&dx2);
else
lpx_get_row_info(lp, index[i], &tagx2, &vx2,
&dx2);
if (tagx2 == LPX_NL)
{ if (val[i] != 0.0)
{ delta = dx2 / val[i];
if (delta < 0 && -delta < max_inc)
max_inc = -delta;
else if (delta >0 && delta < max_dec)
max_dec = delta;
}
}
if (tagx2 == LPX_NU)
{ if (val[i] != 0.0)
{ delta = dx2 / val[i];
if (delta < 0 && -delta < max_inc)
max_inc = -delta;
else if (delta > 0 && delta < max_dec)
max_dec = delta;
}
}
if (tagx2 == LPX_NF)
{ if (val[i] != 0.0)
{ max_inc = 0.0;
max_dec = 0.0;
}
}
}
}
if (max_inc == -0.0) max_inc = 0.0;
if (max_dec == -0.0) max_dec = 0.0;
if (max_inc == DBL_MAX)
fprintf(fp, "%13s ", "infinity");
else if (max_inc < 1.0e-12 && max_inc > 0)
fprintf(fp, "%13s ", "< eps");
else
fprintf(fp, "%13.6g ", max_inc);
if (max_dec == DBL_MAX)
fprintf(fp, "%13s ", "infinity");
else if (max_dec < 1.0e-12 && max_dec > 0)
fprintf(fp, "%13s ", "< eps");
else
fprintf(fp, "%13.6g ", max_dec);
fprintf(fp, "\n");
}
for (what = 1; what <= 2; what++)
{ int ij, mn;
fprintf(fp, "\n");
fprintf(fp, "%s Analysis\n",
what==1? "Constraint Bounds":"Variable Bounds");
fprintf(fp, " No. %12s St Value Max increase "
" Max decrease\n",
what==1 ? " Row name":"Column name");
fprintf(fp, "------ ------------ -- ------------- ------"
"------- ------------- \n");
mn = what==1 ? m : n;
for (ij = 1; ij <= mn; ij++)
{ char *name;
int typx, tagx;
double lb, ub, vx, dx;
if (what==1)
name = lpx_get_row_name(lp, ij);
else
name = lpx_get_col_name(lp, ij);
if (name == NULL) name = "";
#if 0 /* 21/XII-2003 by mao */
if (what==1)
{ lpx_get_row_bnds(lp, ij, &typx, &lb, &ub);
round = lp->round, lp->round = 1;
lpx_get_row_info(lp, ij, &tagx, &vx, &dx);
lp->round = round;
}
else
{ lpx_get_col_bnds(lp, ij, &typx, &lb, &ub);
round = lp->round, lp->round = 1;
lpx_get_col_info(lp, ij, &tagx, &vx, &dx);
lp->round = round;
}
#else
round = lpx_get_int_parm(lp, LPX_K_ROUND);
lpx_set_int_parm(lp, LPX_K_ROUND, 1);
if (what==1)
{ lpx_get_row_bnds(lp, ij, &typx, &lb, &ub);
lpx_get_row_info(lp, ij, &tagx, &vx, &dx);
}
else
{ lpx_get_col_bnds(lp, ij, &typx, &lb, &ub);
lpx_get_col_info(lp, ij, &tagx, &vx, &dx);
}
lpx_set_int_parm(lp, LPX_K_ROUND, round);
#endif
/* row/column ordinal number */
fprintf(fp, "%6d ", ij);
/* row column/name */
if (strlen(name) <= 12)
fprintf(fp, "%-12s ", name);
else
fprintf(fp, "%s\n%20s", name, "");
/* row/column status */
fprintf(fp, "%s ",
tagx == LPX_BS ? "B " :
tagx == LPX_NL ? "NL" :
tagx == LPX_NU ? "NU" :
tagx == LPX_NF ? "NF" :
tagx == LPX_NS ? "NS" : "??");
fprintf(fp, "\n");
/* first check lower bound */
if (typx == LPX_LO || typx == LPX_DB ||
typx == LPX_FX)
{ int at_lower;
at_lower = 0;
if (tagx == LPX_BS || tagx == LPX_NU)
{ max_inc = vx - lb;
max_dec = DBL_MAX;
}
if (tagx == LPX_NS)
{ max_inc = 0.0;
max_dec = 0.0;
if (dir == LPX_MIN && dx > 0) at_lower = 1;
if (dir == LPX_MAX && dx < 0) at_lower = 1;
}
if (tagx == LPX_NL || at_lower == 1)
{ int len;
/* we have to see how it affects basic
variables */
len = lpx_eval_tab_col(lp, what==1?ij:ij+m,
index, val);
k = lpx_prim_ratio_test(lp, len, index, val, 1,
10e-7);
max_inc = DBL_MAX;
if (k != 0)
{ /*int stat;*/
int tagx2, typx2;
double vx2, dx2, lb2, ub2;
/*double delta;*/
double alpha;
int l;
for (l = 1; l <= len; l++)
if (index[l] == k) alpha = val[l];
if (k>m)
{ lpx_get_col_info(lp, k-m, &tagx2, &vx2,
&dx2);
lpx_get_col_bnds(lp, k-m, &typx2, &lb2,
&ub2);
}
else
{ lpx_get_row_info(lp, k, &tagx2, &vx2,
&dx2);
lpx_get_row_bnds(lp, k, &typx2, &lb2,
&ub2);
}
/* Check which direction;
remember this is upper bound */
if (alpha > 0)
max_inc = (ub2 - vx2)/ alpha;
else
max_inc = (lb2 - vx2)/ alpha;
}
/* now check lower bound */
k = lpx_prim_ratio_test(lp, len, index, val, -1,
10e-7);
max_dec = DBL_MAX;
if (k != 0)
{ /*int stat;*/
int tagx2, typx2;
double vx2, dx2, lb2, ub2;
/*double delta;*/
double alpha;
int l;
for (l = 1; l <= len; l++)
if (index[l] == k) alpha = val[l];
if (k>m)
{ lpx_get_col_info(lp, k-m, &tagx2, &vx2,
&dx2);
lpx_get_col_bnds(lp, k-m, &typx2, &lb2,
&ub2);
}
else
{ lpx_get_row_info(lp, k, &tagx2, &vx2,
&dx2);
lpx_get_row_bnds(lp, k, &typx2, &lb2,
&ub2);
}
/* Check which direction;
remember this is lower bound */
if (alpha > 0)
max_dec = (vx2 - lb2)/ alpha;
else
max_dec = (vx2 - ub2)/ alpha;
}
}
/* bound */
if (typx == LPX_DB || typx == LPX_FX)
{ if (max_inc > ub - lb)
max_inc = ub - lb;
}
fprintf(fp, " LOWER %13.6g ", lb);
if (max_inc == -0.0) max_inc = 0.0;
if (max_dec == -0.0) max_dec = 0.0;
if (max_inc == DBL_MAX)
fprintf(fp, "%13s ", "infinity");
else if (max_inc < 1.0e-12 && max_inc > 0)
fprintf(fp, "%13s ", "< eps");
else
fprintf(fp, "%13.6g ", max_inc);
if (max_dec == DBL_MAX)
fprintf(fp, "%13s ", "infinity");
else if (max_dec < 1.0e-12 && max_dec > 0)
fprintf(fp, "%13s ", "< eps");
else
fprintf(fp, "%13.6g ", max_dec);
fprintf(fp, "\n");
}
/* now check upper bound */
if (typx == LPX_UP || typx == LPX_DB ||
typx == LPX_FX)
{ int at_upper;
at_upper = 0;
if (tagx == LPX_BS || tagx == LPX_NL)
{ max_inc = DBL_MAX;
max_dec = ub - vx;
}
if (tagx == LPX_NS)
{ max_inc = 0.0;
max_dec = 0.0;
if (dir == LPX_MIN && dx < 0) at_upper = 1;
if (dir == LPX_MAX && dx > 0) at_upper = 1;
}
if (tagx == LPX_NU || at_upper == 1)
{ int len;
/* we have to see how it affects basic
variables */
len = lpx_eval_tab_col(lp, what==1?ij:ij+m,
index, val);
k = lpx_prim_ratio_test(lp, len, index, val, 1,
10e-7);
max_inc = DBL_MAX;
if (k != 0)
{ /*int stat;*/
int tagx2, typx2;
double vx2, dx2, lb2, ub2;
/*double delta;*/
double alpha;
int l;
for (l = 1; l <= len; l++)
if (index[l] == k) alpha = val[l];
if (k>m)
{ lpx_get_col_info(lp, k-m, &tagx2, &vx2,
&dx2);
lpx_get_col_bnds(lp, k-m, &typx2, &lb2,
&ub2);
}
else
{ lpx_get_row_info(lp, k, &tagx2, &vx2,
&dx2);
lpx_get_row_bnds(lp, k, &typx2, &lb2,
&ub2);
}
/* Check which direction;
remember this is upper bound */
if (alpha > 0)
max_inc = (ub2 - vx2)/ alpha;
else
max_inc = (lb2 - vx2)/ alpha;
}
/* now check lower bound */
k = lpx_prim_ratio_test(lp, len, index, val, -1,
10e-7);
max_dec = DBL_MAX;
if (k != 0)
{ /*int stat;*/
int tagx2, typx2;
double vx2, dx2, lb2, ub2;
/*double delta;*/
double alpha;
int l;
for (l = 1; l <= len; l++)
if (index[l] == k) alpha = val[l];
if (k>m)
{ lpx_get_col_info(lp, k-m, &tagx2, &vx2,
&dx2);
lpx_get_col_bnds(lp, k-m, &typx2, &lb2,
&ub2);
}
else
{ lpx_get_row_info(lp, k, &tagx2, &vx2,
&dx2);
lpx_get_row_bnds(lp, k, &typx2, &lb2,
&ub2);
}
/* Check which direction;
remember this is lower bound */
if (alpha > 0)
max_dec = (vx2 - lb2)/ alpha;
else
max_dec = (vx2 - ub2)/ alpha;
}
}
if (typx == LPX_DB || typx == LPX_FX)
{ if (max_dec > ub - lb)
max_dec = ub - lb;
}
/* bound */
fprintf(fp, " UPPER %13.6g ", ub);
if (max_inc == -0.0) max_inc = 0.0;
if (max_dec == -0.0) max_dec = 0.0;
if (max_inc == DBL_MAX)
fprintf(fp, "%13s ", "infinity");
else if (max_inc < 1.0e-12 && max_inc > 0)
fprintf(fp, "%13s ", "< eps");
else
fprintf(fp, "%13.6g ", max_inc);
if (max_dec == DBL_MAX)
fprintf(fp, "%13s ", "infinity");
else if (max_dec < 1.0e-12 && max_dec > 0)
fprintf(fp, "%13s ", "< eps");
else
fprintf(fp, "%13.6g ", max_dec);
fprintf(fp, "\n");
}
}
}
/* free the memory we used */
ufree(index);
ufree(val);
}
else fprintf(fp, "No range information since solution is not o"
"ptimal.\n");
}
fprintf(fp, "\n");
fprintf(fp, "End of output\n");
fflush(fp);
if (ferror(fp))
{ print("lpx_print_sens_bnds: can't write to `%s' - %s", fname,
strerror(errno));
goto fail;
}
ufclose(fp);
return 0;
fail: if (fp != NULL) ufclose(fp);
return 1;
}
