bool glpk_wrapper::is_constraint_used(int index) {
if (solver_type == SIMPLEX || solver_type == EXACT) {
return glp_get_row_stat(lp, index + 1) == GLP_BS;
} else {
return true;
}
}
int glp_eval_tab_row(glp_prob *lp, int k, int ind[], double val[])
{ int m = lp->m;
int n = lp->n;
int i, t, len, lll, *iii;
double alfa, *rho, *vvv;
if (!(m == 0 || lp->valid))
xerror("glp_eval_tab_row: basis factorization does not exist\n"
);
if (!(1 <= k && k <= m+n))
xerror("glp_eval_tab_row: k = %d; variable number out of range"
, k);
/* determine xB[i] which corresponds to x[k] */
if (k <= m)
i = glp_get_row_bind(lp, k);
else
i = glp_get_col_bind(lp, k-m);
if (i == 0)
xerror("glp_eval_tab_row: k = %d; variable must be basic", k);
xassert(1 <= i && i <= m);
/* allocate working arrays */
rho = xcalloc(1+m, sizeof(double));
iii = xcalloc(1+m, sizeof(int));
vvv = xcalloc(1+m, sizeof(double));
/* compute i-th row of the inverse; see (8) */
for (t = 1; t <= m; t++) rho[t] = 0.0;
rho[i] = 1.0;
glp_btran(lp, rho);
/* compute i-th row of the simplex table */
len = 0;
for (k = 1; k <= m+n; k++)
{ if (k <= m)
{ /* x[k] is auxiliary variable, so N[k] is a unity column */
if (glp_get_row_stat(lp, k) == GLP_BS) continue;
/* compute alfa[i,j]; see (9) */
alfa = - rho[k];
}
else
{ /* x[k] is structural variable, so N[k] is a column of the
original constraint matrix A with negative sign */
if (glp_get_col_stat(lp, k-m) == GLP_BS) continue;
/* compute alfa[i,j]; see (9) */
lll = glp_get_mat_col(lp, k-m, iii, vvv);
alfa = 0.0;
for (t = 1; t <= lll; t++) alfa += rho[iii[t]] * vvv[t];
}
/* store alfa[i,j] */
if (alfa != 0.0) len++, ind[len] = k, val[len] = alfa;
}
xassert(len <= n);
/* free working arrays */
xfree(rho);
xfree(iii);
xfree(vvv);
/* return to the calling program */
return len;
}
int glp_eval_tab_col(glp_prob *lp, int k, int ind[], double val[])
{ int m = lp->m;
int n = lp->n;
int t, len, stat;
double *col;
if (!(m == 0 || lp->valid))
xerror("glp_eval_tab_col: basis factorization does not exist\n"
);
if (!(1 <= k && k <= m+n))
xerror("glp_eval_tab_col: k = %d; variable number out of range"
, k);
if (k <= m)
stat = glp_get_row_stat(lp, k);
else
stat = glp_get_col_stat(lp, k-m);
if (stat == GLP_BS)
xerror("glp_eval_tab_col: k = %d; variable must be non-basic",
k);
/* obtain column N[k] with negative sign */
col = xcalloc(1+m, sizeof(double));
for (t = 1; t <= m; t++) col[t] = 0.0;
if (k <= m)
{ /* x[k] is auxiliary variable, so N[k] is a unity column */
col[k] = -1.0;
}
else
{ /* x[k] is structural variable, so N[k] is a column of the
original constraint matrix A with negative sign */
len = glp_get_mat_col(lp, k-m, ind, val);
for (t = 1; t <= len; t++) col[ind[t]] = val[t];
}
/* compute column of the simplex table, which corresponds to the
specified non-basic variable x[k] */
glp_ftran(lp, col);
len = 0;
for (t = 1; t <= m; t++)
{ if (col[t] != 0.0)
{ len++;
ind[len] = glp_get_bhead(lp, t);
val[len] = col[t];
}
}
xfree(col);
/* return to the calling program */
return len;
}
double glpk_wrapper::get_row_value(int i) {
double cstr_value = 0;
if (solver_type == SIMPLEX || solver_type == EXACT) {
int cstr_status = glp_get_row_stat(lp, i);
if (cstr_status == GLP_BS) { // basic variable;
cstr_status = glp_get_row_prim(lp, i); // or glp_get_row_dual
} else if (cstr_status == GLP_NL || cstr_status == GLP_NS) { // non-basic variable on its lower bound, non-basic fixed variable.
cstr_value = glp_get_row_lb(lp, i);
} else if (cstr_status == GLP_NU) { // non-basic variable on its upper bound
cstr_value = glp_get_row_ub(lp, i);
}
// TODO(dzufferey): should we do something for GLP_NF — non-basic free (unbounded) variable;
} else {
cstr_value = glp_ipt_row_prim(lp, i); // or glp_ipt_row_dual
}
return cstr_value;
}
int glp_mpl_postsolve(glp_tran *tran, glp_prob *prob, int sol)
{ /* postsolve the model */
int i, j, m, n, stat, ret;
double prim, dual;
if (!(tran->phase == 3 && !tran->flag_p))
xerror("glp_mpl_postsolve: invalid call sequence\n");
if (!(sol == GLP_SOL || sol == GLP_IPT || sol == GLP_MIP))
xerror("glp_mpl_postsolve: sol = %d; invalid parameter\n",
sol);
m = mpl_get_num_rows(tran);
n = mpl_get_num_cols(tran);
if (!(m == glp_get_num_rows(prob) &&
n == glp_get_num_cols(prob)))
xerror("glp_mpl_postsolve: wrong problem object\n");
if (!mpl_has_solve_stmt(tran))
{ ret = 0;
goto done;
}
for (i = 1; i <= m; i++)
{ if (sol == GLP_SOL)
{ stat = glp_get_row_stat(prob, i);
prim = glp_get_row_prim(prob, i);
dual = glp_get_row_dual(prob, i);
}
else if (sol == GLP_IPT)
{ stat = 0;
prim = glp_ipt_row_prim(prob, i);
dual = glp_ipt_row_dual(prob, i);
}
else if (sol == GLP_MIP)
{ stat = 0;
prim = glp_mip_row_val(prob, i);
dual = 0.0;
}
else
xassert(sol != sol);
if (fabs(prim) < 1e-9) prim = 0.0;
if (fabs(dual) < 1e-9) dual = 0.0;
mpl_put_row_soln(tran, i, stat, prim, dual);
}
for (j = 1; j <= n; j++)
{ if (sol == GLP_SOL)
{ stat = glp_get_col_stat(prob, j);
prim = glp_get_col_prim(prob, j);
dual = glp_get_col_dual(prob, j);
}
else if (sol == GLP_IPT)
{ stat = 0;
prim = glp_ipt_col_prim(prob, j);
dual = glp_ipt_col_dual(prob, j);
}
else if (sol == GLP_MIP)
{ stat = 0;
prim = glp_mip_col_val(prob, j);
dual = 0.0;
}
else
xassert(sol != sol);
if (fabs(prim) < 1e-9) prim = 0.0;
if (fabs(dual) < 1e-9) dual = 0.0;
mpl_put_col_soln(tran, j, stat, prim, dual);
}
ret = mpl_postsolve(tran);
if (ret == 3)
ret = 0;
else if (ret == 4)
ret = 1;
done: return ret;
}
int lpx_get_row_stat(LPX *lp, int i)
{ /* retrieve row status (basic solution) */
return glp_get_row_stat(lp, i) - GLP_BS + LPX_BS;
}
static int branch_drtom(glp_tree *T, int *_next)
{ glp_prob *mip = T->mip;
int m = mip->m;
int n = mip->n;
char *non_int = T->non_int;
int j, jj, k, t, next, kase, len, stat, *ind;
double x, dk, alfa, delta_j, delta_k, delta_z, dz_dn, dz_up,
dd_dn, dd_up, degrad, *val;
/* basic solution of LP relaxation must be optimal */
xassert(glp_get_status(mip) == GLP_OPT);
/* allocate working arrays */
ind = xcalloc(1+n, sizeof(int));
val = xcalloc(1+n, sizeof(double));
/* nothing has been chosen so far */
jj = 0, degrad = -1.0;
/* walk through the list of columns (structural variables) */
for (j = 1; j <= n; j++)
{ /* if j-th column is not marked as fractional, skip it */
if (!non_int[j]) continue;
/* obtain (fractional) value of j-th column in basic solution
of LP relaxation */
x = glp_get_col_prim(mip, j);
/* since the value of j-th column is fractional, the column is
basic; compute corresponding row of the simplex table */
len = glp_eval_tab_row(mip, m+j, ind, val);
/* the following fragment computes a change in the objective
function: delta Z = new Z - old Z, where old Z is the
objective value in the current optimal basis, and new Z is
the objective value in the adjacent basis, for two cases:
1) if new upper bound ub' = floor(x[j]) is introduced for
j-th column (down branch);
2) if new lower bound lb' = ceil(x[j]) is introduced for
j-th column (up branch);
since in both cases the solution remaining dual feasible
becomes primal infeasible, one implicit simplex iteration
is performed to determine the change delta Z;
it is obvious that new Z, which is never better than old Z,
is a lower (minimization) or upper (maximization) bound of
the objective function for down- and up-branches. */
for (kase = -1; kase <= +1; kase += 2)
{ /* if kase < 0, the new upper bound of x[j] is introduced;
in this case x[j] should decrease in order to leave the
basis and go to its new upper bound */
/* if kase > 0, the new lower bound of x[j] is introduced;
in this case x[j] should increase in order to leave the
basis and go to its new lower bound */
/* apply the dual ratio test in order to determine which
auxiliary or structural variable should enter the basis
to keep dual feasibility */
k = glp_dual_rtest(mip, len, ind, val, kase, 1e-9);
if (k != 0) k = ind[k];
/* if no non-basic variable has been chosen, LP relaxation
of corresponding branch being primal infeasible and dual
unbounded has no primal feasible solution; in this case
the change delta Z is formally set to infinity */
if (k == 0)
{ delta_z =
(T->mip->dir == GLP_MIN ? +DBL_MAX : -DBL_MAX);
goto skip;
}
/* row of the simplex table that corresponds to non-basic
variable x[k] choosen by the dual ratio test is:
x[j] = ... + alfa * x[k] + ...
where alfa is the influence coefficient (an element of
the simplex table row) */
/* determine the coefficient alfa */
for (t = 1; t <= len; t++) if (ind[t] == k) break;
xassert(1 <= t && t <= len);
alfa = val[t];
/* since in the adjacent basis the variable x[j] becomes
non-basic, knowing its value in the current basis we can
determine its change delta x[j] = new x[j] - old x[j] */
delta_j = (kase < 0 ? floor(x) : ceil(x)) - x;
/* and knowing the coefficient alfa we can determine the
corresponding change delta x[k] = new x[k] - old x[k],
where old x[k] is a value of x[k] in the current basis,
and new x[k] is a value of x[k] in the adjacent basis */
delta_k = delta_j / alfa;
/* Tomlin noticed that if the variable x[k] is of integer
kind, its change cannot be less (eventually) than one in
the magnitude */
if (k > m && glp_get_col_kind(mip, k-m) != GLP_CV)
{ /* x[k] is structural integer variable */
if (fabs(delta_k - floor(delta_k + 0.5)) > 1e-3)
{ if (delta_k > 0.0)
delta_k = ceil(delta_k); /* +3.14 -> +4 */
else
delta_k = floor(delta_k); /* -3.14 -> -4 */
}
}
/* now determine the status and reduced cost of x[k] in the
current basis */
if (k <= m)
{ stat = glp_get_row_stat(mip, k);
dk = glp_get_row_dual(mip, k);
}
else
{ stat = glp_get_col_stat(mip, k-m);
dk = glp_get_col_dual(mip, k-m);
}
/* if the current basis is dual degenerate, some reduced
costs which are close to zero may have wrong sign due to
round-off errors, so correct the sign of d[k] */
switch (T->mip->dir)
{ case GLP_MIN:
if (stat == GLP_NL && dk < 0.0 ||
stat == GLP_NU && dk > 0.0 ||
stat == GLP_NF) dk = 0.0;
break;
case GLP_MAX:
if (stat == GLP_NL && dk > 0.0 ||
stat == GLP_NU && dk < 0.0 ||
stat == GLP_NF) dk = 0.0;
break;
default:
xassert(T != T);
}
/* now knowing the change of x[k] and its reduced cost d[k]
we can compute the corresponding change in the objective
function delta Z = new Z - old Z = d[k] * delta x[k];
note that due to Tomlin's modification new Z can be even
worse than in the adjacent basis */
delta_z = dk * delta_k;
skip: /* new Z is never better than old Z, therefore the change
delta Z is always non-negative (in case of minimization)
or non-positive (in case of maximization) */
switch (T->mip->dir)
{ case GLP_MIN: xassert(delta_z >= 0.0); break;
case GLP_MAX: xassert(delta_z <= 0.0); break;
default: xassert(T != T);
}
/* save the change in the objective fnction for down- and
up-branches, respectively */
if (kase < 0) dz_dn = delta_z; else dz_up = delta_z;
}
/* thus, in down-branch no integer feasible solution can be
better than Z + dz_dn, and in up-branch no integer feasible
solution can be better than Z + dz_up, where Z is value of
the objective function in the current basis */
/* following the heuristic by Driebeck and Tomlin we choose a
column (i.e. structural variable) which provides largest
degradation of the objective function in some of branches;
besides, we select the branch with smaller degradation to
be solved next and keep other branch with larger degradation
in the active list hoping to minimize the number of further
backtrackings */
if (degrad < fabs(dz_dn) || degrad < fabs(dz_up))
{ jj = j;
if (fabs(dz_dn) < fabs(dz_up))
{ /* select down branch to be solved next */
next = GLP_DN_BRNCH;
degrad = fabs(dz_up);
}
else
{ /* select up branch to be solved next */
next = GLP_UP_BRNCH;
degrad = fabs(dz_dn);
}
/* save the objective changes for printing */
dd_dn = dz_dn, dd_up = dz_up;
/* if down- or up-branch has no feasible solution, we does
not need to consider other candidates (in principle, the
corresponding branch could be pruned right now) */
if (degrad == DBL_MAX) break;
}
}
/* free working arrays */
xfree(ind);
xfree(val);
/* something must be chosen */
xassert(1 <= jj && jj <= n);
#if 1 /* 02/XI-2009 */
if (degrad < 1e-6 * (1.0 + 0.001 * fabs(mip->obj_val)))
{ jj = branch_mostf(T, &next);
goto done;
}
#endif
if (T->parm->msg_lev >= GLP_MSG_DBG)
{ xprintf("branch_drtom: column %d chosen to branch on\n", jj);
if (fabs(dd_dn) == DBL_MAX)
xprintf("branch_drtom: down-branch is infeasible\n");
else
xprintf("branch_drtom: down-branch bound is %.9e\n",
lpx_get_obj_val(mip) + dd_dn);
if (fabs(dd_up) == DBL_MAX)
xprintf("branch_drtom: up-branch is infeasible\n");
else
xprintf("branch_drtom: up-branch bound is %.9e\n",
lpx_get_obj_val(mip) + dd_up);
}
done: *_next = next;
return jj;
}
int ios_preprocess_node(glp_tree *tree, int max_pass)
{ glp_prob *mip = tree->mip;
int m = mip->m;
int n = mip->n;
int i, j, nrs, *num, ret = 0;
double *L, *U, *l, *u;
/* the current subproblem must exist */
xassert(tree->curr != NULL);
/* determine original row bounds */
L = xcalloc(1+m, sizeof(double));
U = xcalloc(1+m, sizeof(double));
switch (mip->mip_stat)
{ case GLP_UNDEF:
L[0] = -DBL_MAX, U[0] = +DBL_MAX;
break;
case GLP_FEAS:
switch (mip->dir)
{ case GLP_MIN:
L[0] = -DBL_MAX, U[0] = mip->mip_obj - mip->c0;
break;
case GLP_MAX:
L[0] = mip->mip_obj - mip->c0, U[0] = +DBL_MAX;
break;
default:
xassert(mip != mip);
}
break;
default:
xassert(mip != mip);
}
for (i = 1; i <= m; i++)
{ L[i] = glp_get_row_lb(mip, i);
U[i] = glp_get_row_ub(mip, i);
}
/* determine original column bounds */
l = xcalloc(1+n, sizeof(double));
u = xcalloc(1+n, sizeof(double));
for (j = 1; j <= n; j++)
{ l[j] = glp_get_col_lb(mip, j);
u[j] = glp_get_col_ub(mip, j);
}
/* build the initial list of rows to be analyzed */
nrs = m + 1;
num = xcalloc(1+nrs, sizeof(int));
for (i = 1; i <= nrs; i++) num[i] = i - 1;
/* perform basic preprocessing */
if (basic_preprocessing(mip , L, U, l, u, nrs, num, max_pass))
{ ret = 1;
goto done;
}
/* set new actual (relaxed) row bounds */
for (i = 1; i <= m; i++)
{ /* consider only non-active rows to keep dual feasibility */
if (glp_get_row_stat(mip, i) == GLP_BS)
{ if (L[i] == -DBL_MAX && U[i] == +DBL_MAX)
glp_set_row_bnds(mip, i, GLP_FR, 0.0, 0.0);
else if (U[i] == +DBL_MAX)
glp_set_row_bnds(mip, i, GLP_LO, L[i], 0.0);
else if (L[i] == -DBL_MAX)
glp_set_row_bnds(mip, i, GLP_UP, 0.0, U[i]);
}
}
/* set new actual (tightened) column bounds */
for (j = 1; j <= n; j++)
{ int type;
if (l[j] == -DBL_MAX && u[j] == +DBL_MAX)
type = GLP_FR;
else if (u[j] == +DBL_MAX)
type = GLP_LO;
else if (l[j] == -DBL_MAX)
type = GLP_UP;
else if (l[j] != u[j])
type = GLP_DB;
else
type = GLP_FX;
glp_set_col_bnds(mip, j, type, l[j], u[j]);
}
done: /* free working arrays and return */
xfree(L);
xfree(U);
xfree(l);
xfree(u);
xfree(num);
return ret;
}