static int branch_on(glp_tree *T, int j, int next)
{ glp_prob *mip = T->mip;
IOSNPD *node;
int m = mip->m;
int n = mip->n;
int type, dn_type, up_type, dn_bad, up_bad, p, ret, clone[1+2];
double lb, ub, beta, new_ub, new_lb, dn_lp, up_lp, dn_bnd, up_bnd;
/* determine bounds and value of x[j] in optimal solution to LP
relaxation of the current subproblem */
xassert(1 <= j && j <= n);
type = mip->col[j]->type;
lb = mip->col[j]->lb;
ub = mip->col[j]->ub;
beta = mip->col[j]->prim;
/* determine new bounds of x[j] for down- and up-branches */
new_ub = floor(beta);
new_lb = ceil(beta);
switch (type)
{ case GLP_FR:
dn_type = GLP_UP;
up_type = GLP_LO;
break;
case GLP_LO:
xassert(lb <= new_ub);
dn_type = (lb == new_ub ? GLP_FX : GLP_DB);
xassert(lb + 1.0 <= new_lb);
up_type = GLP_LO;
break;
case GLP_UP:
xassert(new_ub <= ub - 1.0);
dn_type = GLP_UP;
xassert(new_lb <= ub);
up_type = (new_lb == ub ? GLP_FX : GLP_DB);
break;
case GLP_DB:
xassert(lb <= new_ub && new_ub <= ub - 1.0);
dn_type = (lb == new_ub ? GLP_FX : GLP_DB);
xassert(lb + 1.0 <= new_lb && new_lb <= ub);
up_type = (new_lb == ub ? GLP_FX : GLP_DB);
break;
default:
xassert(type != type);
}
/* compute local bounds to LP relaxation for both branches */
ios_eval_degrad(T, j, &dn_lp, &up_lp);
/* and improve them by rounding */
dn_bnd = ios_round_bound(T, dn_lp);
up_bnd = ios_round_bound(T, up_lp);
/* check local bounds for down- and up-branches */
dn_bad = !ios_is_hopeful(T, dn_bnd);
up_bad = !ios_is_hopeful(T, up_bnd);
if (dn_bad && up_bad)
{ if (T->parm->msg_lev >= GLP_MSG_DBG)
xprintf("Both down- and up-branches are hopeless\n");
ret = 2;
goto done;
}
else if (up_bad)
{ if (T->parm->msg_lev >= GLP_MSG_DBG)
xprintf("Up-branch is hopeless\n");
glp_set_col_bnds(mip, j, dn_type, lb, new_ub);
T->curr->lp_obj = dn_lp;
if (mip->dir == GLP_MIN)
{ if (T->curr->bound < dn_bnd)
T->curr->bound = dn_bnd;
}
else if (mip->dir == GLP_MAX)
{ if (T->curr->bound > dn_bnd)
T->curr->bound = dn_bnd;
}
else
xassert(mip != mip);
ret = 1;
goto done;
}
else if (dn_bad)
{ if (T->parm->msg_lev >= GLP_MSG_DBG)
xprintf("Down-branch is hopeless\n");
glp_set_col_bnds(mip, j, up_type, new_lb, ub);
T->curr->lp_obj = up_lp;
if (mip->dir == GLP_MIN)
{ if (T->curr->bound < up_bnd)
T->curr->bound = up_bnd;
}
else if (mip->dir == GLP_MAX)
{ if (T->curr->bound > up_bnd)
T->curr->bound = up_bnd;
}
else
xassert(mip != mip);
ret = 1;
goto done;
}
/* both down- and up-branches seem to be hopeful */
if (T->parm->msg_lev >= GLP_MSG_DBG)
xprintf("Branching on column %d, primal value is %.9e\n",
j, beta);
/* determine the reference number of the current subproblem */
xassert(T->curr != NULL);
p = T->curr->p;
T->curr->br_var = j;
T->curr->br_val = beta;
/* freeze the current subproblem */
ios_freeze_node(T);
/* create two clones of the current subproblem; the first clone
begins the down-branch, the second one begins the up-branch */
ios_clone_node(T, p, 2, clone);
if (T->parm->msg_lev >= GLP_MSG_DBG)
xprintf("Node %d begins down branch, node %d begins up branch "
"\n", clone[1], clone[2]);
/* set new upper bound of j-th column in the down-branch */
node = T->slot[clone[1]].node;
xassert(node != NULL);
xassert(node->up != NULL);
xassert(node->b_ptr == NULL);
node->b_ptr = dmp_get_atom(T->pool, sizeof(IOSBND));
node->b_ptr->k = m + j;
node->b_ptr->type = (unsigned char)dn_type;
node->b_ptr->lb = lb;
node->b_ptr->ub = new_ub;
node->b_ptr->next = NULL;
node->lp_obj = dn_lp;
if (mip->dir == GLP_MIN)
{ if (node->bound < dn_bnd)
node->bound = dn_bnd;
}
else if (mip->dir == GLP_MAX)
{ if (node->bound > dn_bnd)
node->bound = dn_bnd;
}
else
xassert(mip != mip);
/* set new lower bound of j-th column in the up-branch */
node = T->slot[clone[2]].node;
xassert(node != NULL);
xassert(node->up != NULL);
xassert(node->b_ptr == NULL);
node->b_ptr = dmp_get_atom(T->pool, sizeof(IOSBND));
node->b_ptr->k = m + j;
node->b_ptr->type = (unsigned char)up_type;
node->b_ptr->lb = new_lb;
node->b_ptr->ub = ub;
node->b_ptr->next = NULL;
node->lp_obj = up_lp;
if (mip->dir == GLP_MIN)
{ if (node->bound < up_bnd)
node->bound = up_bnd;
}
else if (mip->dir == GLP_MAX)
{ if (node->bound > up_bnd)
node->bound = up_bnd;
}
else
xassert(mip != mip);
/* suggest the subproblem to be solved next */
xassert(T->child == 0);
if (next == GLP_NO_BRNCH)
T->child = 0;
else if (next == GLP_DN_BRNCH)
T->child = clone[1];
else if (next == GLP_UP_BRNCH)
T->child = clone[2];
else
xassert(next != next);
ret = 0;
done: return ret;
}
void ios_feas_pump(glp_tree *T)
{ glp_prob *P = T->mip;
int n = P->n;
glp_prob *lp = NULL;
struct VAR *var = NULL;
RNG *rand = NULL;
GLPCOL *col;
glp_smcp parm;
int j, k, new_x, nfail, npass, nv, ret, stalling;
double dist, tol;
xassert(glp_get_status(P) == GLP_OPT);
/* this heuristic is applied only once on the root level */
if (!(T->curr->level == 0 && T->curr->solved == 1)) goto done;
/* determine number of binary variables */
nv = 0;
for (j = 1; j <= n; j++)
{ col = P->col[j];
/* if x[j] is continuous, skip it */
if (col->kind == GLP_CV) continue;
/* if x[j] is fixed, skip it */
if (col->type == GLP_FX) continue;
/* x[j] is non-fixed integer */
xassert(col->kind == GLP_IV);
if (col->type == GLP_DB && col->lb == 0.0 && col->ub == 1.0)
{ /* x[j] is binary */
nv++;
}
else
{ /* x[j] is general integer */
if (T->parm->msg_lev >= GLP_MSG_ALL)
xprintf("FPUMP heuristic cannot be applied due to genera"
"l integer variables\n");
goto done;
}
}
/* there must be at least one binary variable */
if (nv == 0) goto done;
if (T->parm->msg_lev >= GLP_MSG_ALL)
xprintf("Applying FPUMP heuristic...\n");
/* build the list of binary variables */
var = xcalloc(1+nv, sizeof(struct VAR));
k = 0;
for (j = 1; j <= n; j++)
{ col = P->col[j];
if (col->kind == GLP_IV && col->type == GLP_DB)
var[++k].j = j;
}
xassert(k == nv);
/* create working problem object */
lp = glp_create_prob();
more: /* copy the original problem object to keep it intact */
glp_copy_prob(lp, P, GLP_OFF);
/* we are interested to find an integer feasible solution, which
is better than the best known one */
if (P->mip_stat == GLP_FEAS)
{ int *ind;
double *val, bnd;
/* add a row and make it identical to the objective row */
glp_add_rows(lp, 1);
ind = xcalloc(1+n, sizeof(int));
val = xcalloc(1+n, sizeof(double));
for (j = 1; j <= n; j++)
{ ind[j] = j;
val[j] = P->col[j]->coef;
}
glp_set_mat_row(lp, lp->m, n, ind, val);
xfree(ind);
xfree(val);
/* introduce upper (minimization) or lower (maximization)
bound to the original objective function; note that this
additional constraint is not violated at the optimal point
to LP relaxation */
#if 0 /* modified by xypron <*****@*****.**> */
if (P->dir == GLP_MIN)
{ bnd = P->mip_obj - 0.10 * (1.0 + fabs(P->mip_obj));
if (bnd < P->obj_val) bnd = P->obj_val;
glp_set_row_bnds(lp, lp->m, GLP_UP, 0.0, bnd - P->c0);
}
else if (P->dir == GLP_MAX)
{ bnd = P->mip_obj + 0.10 * (1.0 + fabs(P->mip_obj));
if (bnd > P->obj_val) bnd = P->obj_val;
glp_set_row_bnds(lp, lp->m, GLP_LO, bnd - P->c0, 0.0);
}
else
xassert(P != P);
#else
bnd = 0.1 * P->obj_val + 0.9 * P->mip_obj;
/* xprintf("bnd = %f\n", bnd); */
if (P->dir == GLP_MIN)
glp_set_row_bnds(lp, lp->m, GLP_UP, 0.0, bnd - P->c0);
else if (P->dir == GLP_MAX)
glp_set_row_bnds(lp, lp->m, GLP_LO, bnd - P->c0, 0.0);
else
xassert(P != P);
#endif
}
/* reset pass count */
npass = 0;
/* invalidate the rounded point */
for (k = 1; k <= nv; k++)
var[k].x = -1;
pass: /* next pass starts here */
npass++;
if (T->parm->msg_lev >= GLP_MSG_ALL)
xprintf("Pass %d\n", npass);
/* initialize minimal distance between the basic point and the
rounded one obtained during this pass */
dist = DBL_MAX;
/* reset failure count (the number of succeeded iterations failed
to improve the distance) */
nfail = 0;
/* if it is not the first pass, perturb the last rounded point
rather than construct it from the basic solution */
if (npass > 1)
{ double rho, temp;
if (rand == NULL)
rand = rng_create_rand();
for (k = 1; k <= nv; k++)
{ j = var[k].j;
col = lp->col[j];
rho = rng_uniform(rand, -0.3, 0.7);
if (rho < 0.0) rho = 0.0;
temp = fabs((double)var[k].x - col->prim);
if (temp + rho > 0.5) var[k].x = 1 - var[k].x;
}
goto skip;
}
loop: /* innermost loop begins here */
/* round basic solution (which is assumed primal feasible) */
stalling = 1;
for (k = 1; k <= nv; k++)
{ col = lp->col[var[k].j];
if (col->prim < 0.5)
{ /* rounded value is 0 */
new_x = 0;
}
else
{ /* rounded value is 1 */
new_x = 1;
}
if (var[k].x != new_x)
{ stalling = 0;
var[k].x = new_x;
}
}
/* if the rounded point has not changed (stalling), choose and
flip some its entries heuristically */
if (stalling)
{ /* compute d[j] = |x[j] - round(x[j])| */
for (k = 1; k <= nv; k++)
{ col = lp->col[var[k].j];
var[k].d = fabs(col->prim - (double)var[k].x);
}
/* sort the list of binary variables by descending d[j] */
qsort(&var[1], nv, sizeof(struct VAR), fcmp);
/* choose and flip some rounded components */
for (k = 1; k <= nv; k++)
{ if (k >= 5 && var[k].d < 0.35 || k >= 10) break;
var[k].x = 1 - var[k].x;
}
}
skip: /* check if the time limit has been exhausted */
if (T->parm->tm_lim < INT_MAX &&
(double)(T->parm->tm_lim - 1) <=
1000.0 * xdifftime(xtime(), T->tm_beg)) goto done;
/* build the objective, which is the distance between the current
(basic) point and the rounded one */
lp->dir = GLP_MIN;
lp->c0 = 0.0;
for (j = 1; j <= n; j++)
lp->col[j]->coef = 0.0;
for (k = 1; k <= nv; k++)
{ j = var[k].j;
if (var[k].x == 0)
lp->col[j]->coef = +1.0;
else
{ lp->col[j]->coef = -1.0;
lp->c0 += 1.0;
}
}
/* minimize the distance with the simplex method */
glp_init_smcp(&parm);
if (T->parm->msg_lev <= GLP_MSG_ERR)
parm.msg_lev = T->parm->msg_lev;
else if (T->parm->msg_lev <= GLP_MSG_ALL)
{ parm.msg_lev = GLP_MSG_ON;
parm.out_dly = 10000;
}
ret = glp_simplex(lp, &parm);
if (ret != 0)
{ if (T->parm->msg_lev >= GLP_MSG_ERR)
xprintf("Warning: glp_simplex returned %d\n", ret);
goto done;
}
ret = glp_get_status(lp);
if (ret != GLP_OPT)
{ if (T->parm->msg_lev >= GLP_MSG_ERR)
xprintf("Warning: glp_get_status returned %d\n", ret);
goto done;
}
if (T->parm->msg_lev >= GLP_MSG_DBG)
xprintf("delta = %g\n", lp->obj_val);
/* check if the basic solution is integer feasible; note that it
may be so even if the minimial distance is positive */
tol = 0.3 * T->parm->tol_int;
for (k = 1; k <= nv; k++)
{ col = lp->col[var[k].j];
if (tol < col->prim && col->prim < 1.0 - tol) break;
}
if (k > nv)
{ /* okay; the basic solution seems to be integer feasible */
double *x = xcalloc(1+n, sizeof(double));
for (j = 1; j <= n; j++)
{ x[j] = lp->col[j]->prim;
if (P->col[j]->kind == GLP_IV) x[j] = floor(x[j] + 0.5);
}
#if 1 /* modified by xypron <*****@*****.**> */
/* reset direction and right-hand side of objective */
lp->c0 = P->c0;
lp->dir = P->dir;
/* fix integer variables */
for (k = 1; k <= nv; k++)
#if 0 /* 18/VI-2013; fixed by mao
* this bug causes numerical instability, because column statuses
* are not changed appropriately */
{ lp->col[var[k].j]->lb = x[var[k].j];
lp->col[var[k].j]->ub = x[var[k].j];
lp->col[var[k].j]->type = GLP_FX;
}
#else
glp_set_col_bnds(lp, var[k].j, GLP_FX, x[var[k].j], 0.);
#endif
/* copy original objective function */
for (j = 1; j <= n; j++)
lp->col[j]->coef = P->col[j]->coef;
/* solve original LP and copy result */
ret = glp_simplex(lp, &parm);
if (ret != 0)
{ if (T->parm->msg_lev >= GLP_MSG_ERR)
xprintf("Warning: glp_simplex returned %d\n", ret);
goto done;
}
ret = glp_get_status(lp);
if (ret != GLP_OPT)
{ if (T->parm->msg_lev >= GLP_MSG_ERR)
xprintf("Warning: glp_get_status returned %d\n", ret);
goto done;
}
for (j = 1; j <= n; j++)
if (P->col[j]->kind != GLP_IV) x[j] = lp->col[j]->prim;
#endif
ret = glp_ios_heur_sol(T, x);
xfree(x);
if (ret == 0)
{ /* the integer solution is accepted */
if (ios_is_hopeful(T, T->curr->bound))
{ /* it is reasonable to apply the heuristic once again */
goto more;
}
else
{ /* the best known integer feasible solution just found
is close to optimal solution to LP relaxation */
goto done;
}
}
}
static int is_branch_hopeful(glp_tree *T, int p)
{ xassert(1 <= p && p <= T->nslots);
xassert(T->slot[p].node != NULL);
return ios_is_hopeful(T, T->slot[p].node->bound);
}
