int glp_intfeas1(glp_prob *P, int use_bound, int obj_bound)
{ /* solve integer feasibility problem */
NPP *npp = NULL;
glp_prob *mip = NULL;
int *obj_ind = NULL;
double *obj_val = NULL;
int obj_row = 0;
int i, j, k, obj_len, temp, ret;
/* check the problem object */
if (P == NULL || P->magic != GLP_PROB_MAGIC)
xerror("glp_intfeas1: P = %p; invalid problem object\n",
P);
if (P->tree != NULL)
xerror("glp_intfeas1: operation not allowed\n");
/* integer solution is currently undefined */
P->mip_stat = GLP_UNDEF;
P->mip_obj = 0.0;
/* check columns (variables) */
for (j = 1; j <= P->n; j++)
{ GLPCOL *col = P->col[j];
#if 0 /* currently binarization is not yet implemented */
if (!(col->kind == GLP_IV || col->type == GLP_FX))
{ xprintf("glp_intfeas1: column %d: non-integer non-fixed var"
"iable not allowed\n", j);
#else
if (!((col->kind == GLP_IV && col->lb == 0.0 && col->ub == 1.0)
|| col->type == GLP_FX))
{ xprintf("glp_intfeas1: column %d: non-binary non-fixed vari"
"able not allowed\n", j);
#endif
ret = GLP_EDATA;
goto done;
}
temp = (int)col->lb;
if ((double)temp != col->lb)
{ if (col->type == GLP_FX)
xprintf("glp_intfeas1: column %d: fixed value %g is non-"
"integer or out of range\n", j, col->lb);
else
xprintf("glp_intfeas1: column %d: lower bound %g is non-"
"integer or out of range\n", j, col->lb);
ret = GLP_EDATA;
goto done;
}
temp = (int)col->ub;
if ((double)temp != col->ub)
{ xprintf("glp_intfeas1: column %d: upper bound %g is non-int"
"eger or out of range\n", j, col->ub);
ret = GLP_EDATA;
goto done;
}
if (col->type == GLP_DB && col->lb > col->ub)
{ xprintf("glp_intfeas1: column %d: lower bound %g is greater"
" than upper bound %g\n", j, col->lb, col->ub);
ret = GLP_EBOUND;
goto done;
}
}
/* check rows (constraints) */
for (i = 1; i <= P->m; i++)
{ GLPROW *row = P->row[i];
GLPAIJ *aij;
for (aij = row->ptr; aij != NULL; aij = aij->r_next)
{ temp = (int)aij->val;
if ((double)temp != aij->val)
{ xprintf("glp_intfeas1: row = %d, column %d: constraint c"
"oefficient %g is non-integer or out of range\n",
i, aij->col->j, aij->val);
ret = GLP_EDATA;
goto done;
}
}
temp = (int)row->lb;
if ((double)temp != row->lb)
{ if (row->type == GLP_FX)
xprintf("glp_intfeas1: row = %d: fixed value %g is non-i"
"nteger or out of range\n", i, row->lb);
else
xprintf("glp_intfeas1: row = %d: lower bound %g is non-i"
"nteger or out of range\n", i, row->lb);
ret = GLP_EDATA;
goto done;
}
temp = (int)row->ub;
if ((double)temp != row->ub)
{ xprintf("glp_intfeas1: row = %d: upper bound %g is non-inte"
"ger or out of range\n", i, row->ub);
ret = GLP_EDATA;
goto done;
}
if (row->type == GLP_DB && row->lb > row->ub)
{ xprintf("glp_intfeas1: row %d: lower bound %g is greater th"
"an upper bound %g\n", i, row->lb, row->ub);
ret = GLP_EBOUND;
goto done;
}
}
/* check the objective function */
temp = (int)P->c0;
if ((double)temp != P->c0)
{ xprintf("glp_intfeas1: objective constant term %g is non-integ"
"er or out of range\n", P->c0);
ret = GLP_EDATA;
goto done;
}
for (j = 1; j <= P->n; j++)
{ temp = (int)P->col[j]->coef;
if ((double)temp != P->col[j]->coef)
{ xprintf("glp_intfeas1: column %d: objective coefficient is "
"non-integer or out of range\n", j, P->col[j]->coef);
ret = GLP_EDATA;
goto done;
}
}
/* save the objective function and set it to zero */
obj_ind = xcalloc(1+P->n, sizeof(int));
obj_val = xcalloc(1+P->n, sizeof(double));
obj_len = 0;
obj_ind[0] = 0;
obj_val[0] = P->c0;
P->c0 = 0.0;
for (j = 1; j <= P->n; j++)
{ if (P->col[j]->coef != 0.0)
{ obj_len++;
obj_ind[obj_len] = j;
obj_val[obj_len] = P->col[j]->coef;
P->col[j]->coef = 0.0;
}
}
/* add inequality to bound the objective function, if required */
if (!use_bound)
xprintf("Will search for ANY feasible solution\n");
else
{ xprintf("Will search only for solution not worse than %d\n",
obj_bound);
obj_row = glp_add_rows(P, 1);
glp_set_mat_row(P, obj_row, obj_len, obj_ind, obj_val);
if (P->dir == GLP_MIN)
glp_set_row_bnds(P, obj_row,
GLP_UP, 0.0, (double)obj_bound - obj_val[0]);
else if (P->dir == GLP_MAX)
glp_set_row_bnds(P, obj_row,
GLP_LO, (double)obj_bound - obj_val[0], 0.0);
else
xassert(P != P);
}
/* create preprocessor workspace */
xprintf("Translating to CNF-SAT...\n");
xprintf("Original problem has %d row%s, %d column%s, and %d non-z"
"ero%s\n", P->m, P->m == 1 ? "" : "s", P->n, P->n == 1 ? "" :
"s", P->nnz, P->nnz == 1 ? "" : "s");
npp = npp_create_wksp();
/* load the original problem into the preprocessor workspace */
npp_load_prob(npp, P, GLP_OFF, GLP_MIP, GLP_OFF);
/* perform translation to SAT-CNF problem instance */
ret = npp_sat_encode_prob(npp);
if (ret == 0)
;
else if (ret == GLP_ENOPFS)
xprintf("PROBLEM HAS NO INTEGER FEASIBLE SOLUTION\n");
else if (ret == GLP_ERANGE)
xprintf("glp_intfeas1: translation to SAT-CNF failed because o"
"f integer overflow\n");
else
xassert(ret != ret);
if (ret != 0)
goto done;
/* build SAT-CNF problem instance and try to solve it */
mip = glp_create_prob();
npp_build_prob(npp, mip);
ret = glp_minisat1(mip);
/* only integer feasible solution can be postprocessed */
if (!(mip->mip_stat == GLP_OPT || mip->mip_stat == GLP_FEAS))
{ P->mip_stat = mip->mip_stat;
goto done;
}
/* postprocess the solution found */
npp_postprocess(npp, mip);
/* the transformed problem is no longer needed */
glp_delete_prob(mip), mip = NULL;
/* store solution to the original problem object */
npp_unload_sol(npp, P);
/* change the solution status to 'integer feasible' */
P->mip_stat = GLP_FEAS;
/* check integer feasibility */
for (i = 1; i <= P->m; i++)
{ GLPROW *row;
GLPAIJ *aij;
double sum;
row = P->row[i];
sum = 0.0;
for (aij = row->ptr; aij != NULL; aij = aij->r_next)
sum += aij->val * aij->col->mipx;
xassert(sum == row->mipx);
if (row->type == GLP_LO || row->type == GLP_DB ||
row->type == GLP_FX)
xassert(sum >= row->lb);
if (row->type == GLP_UP || row->type == GLP_DB ||
row->type == GLP_FX)
xassert(sum <= row->ub);
}
/* compute value of the original objective function */
P->mip_obj = obj_val[0];
for (k = 1; k <= obj_len; k++)
P->mip_obj += obj_val[k] * P->col[obj_ind[k]]->mipx;
xprintf("Objective value = %17.9e\n", P->mip_obj);
done: /* delete the transformed problem, if it exists */
if (mip != NULL)
glp_delete_prob(mip);
/* delete the preprocessor workspace, if it exists */
if (npp != NULL)
npp_delete_wksp(npp);
/* remove inequality used to bound the objective function */
if (obj_row > 0)
{ int ind[1+1];
ind[1] = obj_row;
glp_del_rows(P, 1, ind);
}
/* restore the original objective function */
if (obj_ind != NULL)
{ P->c0 = obj_val[0];
for (k = 1; k <= obj_len; k++)
P->col[obj_ind[k]]->coef = obj_val[k];
xfree(obj_ind);
xfree(obj_val);
}
return ret;
}
static int preprocess_and_solve_mip(glp_prob *P, const glp_iocp *parm)
{ /* solve MIP using the preprocessor */
ENV *env = get_env_ptr();
int term_out = env->term_out;
NPP *npp;
glp_prob *mip = NULL;
glp_bfcp bfcp;
glp_smcp smcp;
int ret;
if (parm->msg_lev >= GLP_MSG_ALL)
xprintf("Preprocessing...\n");
/* create preprocessor workspace */
npp = npp_create_wksp();
/* load original problem into the preprocessor workspace */
npp_load_prob(npp, P, GLP_OFF, GLP_MIP, GLP_OFF);
/* process MIP prior to applying the branch-and-bound method */
if (!term_out || parm->msg_lev < GLP_MSG_ALL)
env->term_out = GLP_OFF;
else
env->term_out = GLP_ON;
ret = npp_integer(npp, parm);
env->term_out = term_out;
if (ret == 0)
;
else if (ret == GLP_ENOPFS)
{ if (parm->msg_lev >= GLP_MSG_ALL)
xprintf("PROBLEM HAS NO PRIMAL FEASIBLE SOLUTION\n");
}
else if (ret == GLP_ENODFS)
{ if (parm->msg_lev >= GLP_MSG_ALL)
xprintf("LP RELAXATION HAS NO DUAL FEASIBLE SOLUTION\n");
}
else
xassert(ret != ret);
if (ret != 0) goto done;
/* build transformed MIP */
mip = glp_create_prob();
npp_build_prob(npp, mip);
/* if the transformed MIP is empty, it has empty solution, which
is optimal */
if (mip->m == 0 && mip->n == 0)
{ mip->mip_stat = GLP_OPT;
mip->mip_obj = mip->c0;
if (parm->msg_lev >= GLP_MSG_ALL)
{ xprintf("Objective value = %17.9e\n", mip->mip_obj);
xprintf("INTEGER OPTIMAL SOLUTION FOUND BY MIP PREPROCESSOR"
"\n");
}
goto post;
}
/* display some statistics */
if (parm->msg_lev >= GLP_MSG_ALL)
{ int ni = glp_get_num_int(mip);
int nb = glp_get_num_bin(mip);
char s[50];
xprintf("%d row%s, %d column%s, %d non-zero%s\n",
mip->m, mip->m == 1 ? "" : "s", mip->n, mip->n == 1 ? "" :
"s", mip->nnz, mip->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);
xprintf("%d integer variable%s, %s which %s binary\n",
ni, ni == 1 ? "" : "s", s, nb == 1 ? "is" : "are");
}
/* inherit basis factorization control parameters */
glp_get_bfcp(P, &bfcp);
glp_set_bfcp(mip, &bfcp);
/* scale the transformed problem */
if (!term_out || parm->msg_lev < GLP_MSG_ALL)
env->term_out = GLP_OFF;
else
env->term_out = GLP_ON;
glp_scale_prob(mip,
GLP_SF_GM | GLP_SF_EQ | GLP_SF_2N | GLP_SF_SKIP);
env->term_out = term_out;
/* build advanced initial basis */
if (!term_out || parm->msg_lev < GLP_MSG_ALL)
env->term_out = GLP_OFF;
else
env->term_out = GLP_ON;
glp_adv_basis(mip, 0);
env->term_out = term_out;
/* solve initial LP relaxation */
if (parm->msg_lev >= GLP_MSG_ALL)
xprintf("Solving LP relaxation...\n");
glp_init_smcp(&smcp);
smcp.msg_lev = parm->msg_lev;
mip->it_cnt = P->it_cnt;
ret = glp_simplex(mip, &smcp);
P->it_cnt = mip->it_cnt;
if (ret != 0)
{ if (parm->msg_lev >= GLP_MSG_ERR)
xprintf("glp_intopt: cannot solve LP relaxation\n");
ret = GLP_EFAIL;
goto done;
}
/* check status of the basic solution */
ret = glp_get_status(mip);
if (ret == GLP_OPT)
ret = 0;
else if (ret == GLP_NOFEAS)
ret = GLP_ENOPFS;
else if (ret == GLP_UNBND)
ret = GLP_ENODFS;
else
xassert(ret != ret);
if (ret != 0) goto done;
/* solve the transformed MIP */
mip->it_cnt = P->it_cnt;
#if 0 /* 11/VII-2013 */
ret = solve_mip(mip, parm);
#else
if (parm->use_sol)
{ mip->mip_stat = P->mip_stat;
mip->mip_obj = P->mip_obj;
}
ret = solve_mip(mip, parm, P, npp);
#endif
P->it_cnt = mip->it_cnt;
/* only integer feasible solution can be postprocessed */
if (!(mip->mip_stat == GLP_OPT || mip->mip_stat == GLP_FEAS))
{ P->mip_stat = mip->mip_stat;
goto done;
}
/* postprocess solution from the transformed MIP */
post: npp_postprocess(npp, mip);
/* the transformed MIP is no longer needed */
glp_delete_prob(mip), mip = NULL;
/* store solution to the original problem */
npp_unload_sol(npp, P);
done: /* delete the transformed MIP, if it exists */
if (mip != NULL) glp_delete_prob(mip);
/* delete preprocessor workspace */
npp_delete_wksp(npp);
return ret;
}
static int preprocess_and_solve_lp(glp_prob *P, const glp_smcp *parm)
{ /* solve LP using the preprocessor */
NPP *npp;
glp_prob *lp = NULL;
glp_bfcp bfcp;
int ret;
if (parm->msg_lev >= GLP_MSG_ALL)
xprintf("Preprocessing...\n");
/* create preprocessor workspace */
npp = npp_create_wksp();
/* load original problem into the preprocessor workspace */
npp_load_prob(npp, P, GLP_OFF, GLP_SOL, GLP_OFF);
/* process LP prior to applying primal/dual simplex method */
ret = npp_simplex(npp, parm);
if (ret == 0)
;
else if (ret == GLP_ENOPFS)
{ if (parm->msg_lev >= GLP_MSG_ALL)
xprintf("PROBLEM HAS NO PRIMAL FEASIBLE SOLUTION\n");
}
else if (ret == GLP_ENODFS)
{ if (parm->msg_lev >= GLP_MSG_ALL)
xprintf("PROBLEM HAS NO DUAL FEASIBLE SOLUTION\n");
}
else
xassert(ret != ret);
if (ret != 0) goto done;
/* build transformed LP */
lp = glp_create_prob();
npp_build_prob(npp, lp);
/* if the transformed LP is empty, it has empty solution, which
is optimal */
if (lp->m == 0 && lp->n == 0)
{ lp->pbs_stat = lp->dbs_stat = GLP_FEAS;
lp->obj_val = lp->c0;
if (parm->msg_lev >= GLP_MSG_ON && parm->out_dly == 0)
{ xprintf("~%6d: obj = %17.9e infeas = %10.3e\n", P->it_cnt,
lp->obj_val, 0.0);
}
if (parm->msg_lev >= GLP_MSG_ALL)
xprintf("OPTIMAL SOLUTION FOUND BY LP PREPROCESSOR\n");
goto post;
}
if (parm->msg_lev >= GLP_MSG_ALL)
{ xprintf("%d row%s, %d column%s, %d non-zero%s\n",
lp->m, lp->m == 1 ? "" : "s", lp->n, lp->n == 1 ? "" : "s",
lp->nnz, lp->nnz == 1 ? "" : "s");
}
/* inherit basis factorization control parameters */
glp_get_bfcp(P, &bfcp);
glp_set_bfcp(lp, &bfcp);
/* scale the transformed problem */
{ ENV *env = get_env_ptr();
int term_out = env->term_out;
if (!term_out || parm->msg_lev < GLP_MSG_ALL)
env->term_out = GLP_OFF;
else
env->term_out = GLP_ON;
glp_scale_prob(lp, GLP_SF_AUTO);
env->term_out = term_out;
}
/* build advanced initial basis */
{ ENV *env = get_env_ptr();
int term_out = env->term_out;
if (!term_out || parm->msg_lev < GLP_MSG_ALL)
env->term_out = GLP_OFF;
else
env->term_out = GLP_ON;
glp_adv_basis(lp, 0);
env->term_out = term_out;
}
/* solve the transformed LP */
lp->it_cnt = P->it_cnt;
ret = solve_lp(lp, parm);
P->it_cnt = lp->it_cnt;
/* only optimal solution can be postprocessed */
if (!(ret == 0 && lp->pbs_stat == GLP_FEAS && lp->dbs_stat ==
GLP_FEAS))
{ if (parm->msg_lev >= GLP_MSG_ERR)
xprintf("glp_simplex: unable to recover undefined or non-op"
"timal solution\n");
if (ret == 0)
{ if (lp->pbs_stat == GLP_NOFEAS)
ret = GLP_ENOPFS;
else if (lp->dbs_stat == GLP_NOFEAS)
ret = GLP_ENODFS;
else
xassert(lp != lp);
}
goto done;
}
post: /* postprocess solution from the transformed LP */
npp_postprocess(npp, lp);
/* the transformed LP is no longer needed */
glp_delete_prob(lp), lp = NULL;
/* store solution to the original problem */
npp_unload_sol(npp, P);
/* the original LP has been successfully solved */
ret = 0;
done: /* delete the transformed LP, if it exists */
if (lp != NULL) glp_delete_prob(lp);
/* delete preprocessor workspace */
npp_delete_wksp(npp);
return ret;
}
