void ios_proxy_heur(glp_tree *T)
{ glp_prob *prob;
int j, status;
double *xstar, zstar;
/* this heuristic is applied only once on the root level */
if (!(T->curr->level == 0 && T->curr->solved == 1))
goto done;
prob = glp_create_prob();
glp_copy_prob(prob, T->mip, 0);
xstar = xcalloc(1+prob->n, sizeof(double));
for (j = 1; j <= prob->n; j++)
xstar[j] = 0.0;
if (T->mip->mip_stat != GLP_FEAS)
status = proxy(prob, &zstar, xstar, NULL, 0.0,
T->parm->ps_tm_lim, 1);
else
{ double *xinit = xcalloc(1+prob->n, sizeof(double));
for (j = 1; j <= prob->n; j++)
xinit[j] = T->mip->col[j]->mipx;
status = proxy(prob, &zstar, xstar, xinit, 0.0,
T->parm->ps_tm_lim, 1);
xfree(xinit);
}
if (status == 0)
glp_ios_heur_sol(T, xstar);
xfree(xstar);
glp_delete_prob(prob);
done: return;
}
void CMyProblem::_copy(const CMyProblem &src)
{
name = src.name;
n=src.n;
p=src.p;
r=src.r;
w=src.w;
original_index=src.original_index;
glp_copy_prob(lp,src.lp,GLP_ON);
/*for (int i=0;i<n;i++)
{
r[i]=src.r[i];
w[i]=src.w[i];
}*/
}
/* Different cases :
* - if the created node is root, then father is NULL, the problem version in the node is the one gave as parameter.
* - else we copy the problem, and had the constraint "x_{y} = valy"
*/
void create_node(node* n, glp_prob* prob, node* father, int y, double valy)
{
n->father = father;
n->leftSon = NULL;
n->rightSon = NULL;
n->check = 0;
int i = 0;
int ind[] = {0,y};
double val[] = {0,1};
if (n-> father == NULL)
{
n->prob = prob;
}
else
{
n->prob = glp_create_prob();
glp_copy_prob(n->prob, n->father->prob, GLP_ON);
i = glp_add_rows(n->prob, 1);
glp_set_mat_row(n->prob, i, 1, ind, val);
glp_set_row_bnds(n->prob, i, GLP_FX, valy, valy);
}
glp_smcp parm;
glp_init_smcp(&parm);
parm.msg_lev = GLP_MSG_OFF;
glp_iocp parmip;
glp_init_iocp(&parmip);
parmip.msg_lev = GLP_MSG_OFF;
glp_write_lp(prob, NULL, "ULS.lp");
n->solveFlag = glp_simplex(n->prob, &parm); glp_intopt(n->prob, &parmip);
n->z = glp_mip_obj_val(n->prob);
n->x = (double *) malloc (glp_get_num_cols(n->prob) * sizeof(double));
for (i = 0; i < glp_get_num_cols(n->prob); ++i) n->x[i] = glp_mip_col_val(n->prob, i+1);
}
/* Create from the base problem, an other problem which forces stocks to be 0.
* The cronstruted solution stay feasible for the first problem.
*/
node* construction (glp_prob * prob)
{
node* res = (node *) malloc (sizeof(node));
glp_prob * constProb = glp_create_prob(); glp_copy_prob(constProb, prob, GLP_ON);
int i = glp_add_rows(constProb, 1);
int k = glp_add_rows(constProb, 1);
int nbj = glp_get_num_cols(prob)/3 -1;
int ind[nbj+2];
double val[nbj+2];
int indk[nbj+2];
double valk[nbj+2];
int j;
ind[0] = 0; val[0] = 1;
ind[1] = 1; val[1] = 1;
indk[1] = 2 ; valk[1] = 1;
for (j = 1; j <= nbj; ++j)
{
ind[j] = j * 3 +2;
indk[j] = j *3 + 3;
val[j] = 1;
valk[j] = 1;
}
glp_set_mat_row(constProb, i, nbj, ind, val);
glp_set_row_bnds(constProb, i, GLP_FX, 0, 0);
glp_set_mat_row(constProb, k, nbj, indk, valk);
glp_set_row_bnds(constProb, k, GLP_FX, nbj, nbj);
create_node(res, constProb, NULL, 0, 0);
return res;
}
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 double eval_degrad(glp_prob *P, int j, double bnd)
{ /* compute degradation of the objective on fixing x[j] at given
value with a limited number of dual simplex iterations */
/* this routine fixes column x[j] at specified value bnd,
solves resulting LP, and returns a lower bound to degradation
of the objective, degrad >= 0 */
glp_prob *lp;
glp_smcp parm;
int ret;
double degrad;
/* the current basis must be optimal */
xassert(glp_get_status(P) == GLP_OPT);
/* create a copy of P */
lp = glp_create_prob();
glp_copy_prob(lp, P, 0);
/* fix column x[j] at specified value */
glp_set_col_bnds(lp, j, GLP_FX, bnd, bnd);
/* try to solve resulting LP */
glp_init_smcp(&parm);
parm.msg_lev = GLP_MSG_OFF;
parm.meth = GLP_DUAL;
parm.it_lim = 30;
parm.out_dly = 1000;
parm.meth = GLP_DUAL;
ret = glp_simplex(lp, &parm);
if (ret == 0 || ret == GLP_EITLIM)
{ if (glp_get_prim_stat(lp) == GLP_NOFEAS)
{ /* resulting LP has no primal feasible solution */
degrad = DBL_MAX;
}
else if (glp_get_dual_stat(lp) == GLP_FEAS)
{ /* resulting basis is optimal or at least dual feasible,
so we have the correct lower bound to degradation */
if (P->dir == GLP_MIN)
degrad = lp->obj_val - P->obj_val;
else if (P->dir == GLP_MAX)
degrad = P->obj_val - lp->obj_val;
else
xassert(P != P);
/* degradation cannot be negative by definition */
/* note that the lower bound to degradation may be close
to zero even if its exact value is zero due to round-off
errors on computing the objective value */
if (degrad < 1e-6 * (1.0 + 0.001 * fabs(P->obj_val)))
degrad = 0.0;
}
else
{ /* the final basis reported by the simplex solver is dual
infeasible, so we cannot determine a non-trivial lower
bound to degradation */
degrad = 0.0;
}
}
else
{ /* the simplex solver failed */
degrad = 0.0;
}
/* delete the copy of P */
glp_delete_prob(lp);
return degrad;
}