}
#if 1 /* 28/V-2010 */
if (parm->alien)
{ /* use alien integer optimizer */
ret = _glp_intopt1(P, parm);
goto done;
}
#endif
if (!parm->presolve)
#if 0 /* 11/VII-2013 */
ret = solve_mip(P, parm);
#else
ret = solve_mip(P, parm, P, NULL);
#endif
else
ret = preprocess_and_solve_mip(P, parm);
done: /* return to the application program */
return ret;
}
/***********************************************************************
* NAME
*
* glp_init_iocp - initialize integer optimizer control parameters
*
* SYNOPSIS
*
* void glp_init_iocp(glp_iocp *parm);
*
* DESCRIPTION
*
int glp_intopt(glp_prob *P, const glp_iocp *parm)
{ /* solve MIP problem with the branch-and-bound method */
glp_iocp _parm;
int i, j, ret;
/* check problem object */
if (P == NULL || P->magic != GLP_PROB_MAGIC)
xerror("glp_intopt: P = %p; invalid problem object\n", P);
if (P->tree != NULL)
xerror("glp_intopt: operation not allowed\n");
/* check control parameters */
if (parm == NULL)
parm = &_parm, glp_init_iocp((glp_iocp *)parm);
if (!(parm->msg_lev == GLP_MSG_OFF ||
parm->msg_lev == GLP_MSG_ERR ||
parm->msg_lev == GLP_MSG_ON ||
parm->msg_lev == GLP_MSG_ALL ||
parm->msg_lev == GLP_MSG_DBG))
xerror("glp_intopt: msg_lev = %d; invalid parameter\n",
parm->msg_lev);
if (!(parm->br_tech == GLP_BR_FFV ||
parm->br_tech == GLP_BR_LFV ||
parm->br_tech == GLP_BR_MFV ||
parm->br_tech == GLP_BR_DTH ||
parm->br_tech == GLP_BR_PCH))
xerror("glp_intopt: br_tech = %d; invalid parameter\n",
parm->br_tech);
if (!(parm->bt_tech == GLP_BT_DFS ||
parm->bt_tech == GLP_BT_BFS ||
parm->bt_tech == GLP_BT_BLB ||
parm->bt_tech == GLP_BT_BPH))
xerror("glp_intopt: bt_tech = %d; invalid parameter\n",
parm->bt_tech);
if (!(0.0 < parm->tol_int && parm->tol_int < 1.0))
xerror("glp_intopt: tol_int = %g; invalid parameter\n",
parm->tol_int);
if (!(0.0 < parm->tol_obj && parm->tol_obj < 1.0))
xerror("glp_intopt: tol_obj = %g; invalid parameter\n",
parm->tol_obj);
if (parm->tm_lim < 0)
xerror("glp_intopt: tm_lim = %d; invalid parameter\n",
parm->tm_lim);
if (parm->out_frq < 0)
xerror("glp_intopt: out_frq = %d; invalid parameter\n",
parm->out_frq);
if (parm->out_dly < 0)
xerror("glp_intopt: out_dly = %d; invalid parameter\n",
parm->out_dly);
if (!(0 <= parm->cb_size && parm->cb_size <= 256))
xerror("glp_intopt: cb_size = %d; invalid parameter\n",
parm->cb_size);
if (!(parm->pp_tech == GLP_PP_NONE ||
parm->pp_tech == GLP_PP_ROOT ||
parm->pp_tech == GLP_PP_ALL))
xerror("glp_intopt: pp_tech = %d; invalid parameter\n",
parm->pp_tech);
if (parm->mip_gap < 0.0)
xerror("glp_intopt: mip_gap = %g; invalid parameter\n",
parm->mip_gap);
if (!(parm->mir_cuts == GLP_ON || parm->mir_cuts == GLP_OFF))
xerror("glp_intopt: mir_cuts = %d; invalid parameter\n",
parm->mir_cuts);
if (!(parm->gmi_cuts == GLP_ON || parm->gmi_cuts == GLP_OFF))
xerror("glp_intopt: gmi_cuts = %d; invalid parameter\n",
parm->gmi_cuts);
if (!(parm->cov_cuts == GLP_ON || parm->cov_cuts == GLP_OFF))
xerror("glp_intopt: cov_cuts = %d; invalid parameter\n",
parm->cov_cuts);
if (!(parm->clq_cuts == GLP_ON || parm->clq_cuts == GLP_OFF))
xerror("glp_intopt: clq_cuts = %d; invalid parameter\n",
parm->clq_cuts);
if (!(parm->presolve == GLP_ON || parm->presolve == GLP_OFF))
xerror("glp_intopt: presolve = %d; invalid parameter\n",
parm->presolve);
if (!(parm->binarize == GLP_ON || parm->binarize == GLP_OFF))
xerror("glp_intopt: binarize = %d; invalid parameter\n",
parm->binarize);
if (!(parm->fp_heur == GLP_ON || parm->fp_heur == GLP_OFF))
xerror("glp_intopt: fp_heur = %d; invalid parameter\n",
parm->fp_heur);
#if 1 /* 28/V-2010 */
if (!(parm->alien == GLP_ON || parm->alien == GLP_OFF))
xerror("glp_intopt: alien = %d; invalid parameter\n",
parm->alien);
#endif
/* integer solution is currently undefined */
P->mip_stat = GLP_UNDEF;
P->mip_obj = 0.0;
/* check bounds of double-bounded variables */
for (i = 1; i <= P->m; i++)
{ GLPROW *row = P->row[i];
if (row->type == GLP_DB && row->lb >= row->ub)
{ if (parm->msg_lev >= GLP_MSG_ERR)
xprintf("glp_intopt: row %d: lb = %g, ub = %g; incorrect"
" bounds\n", i, row->lb, row->ub);
ret = GLP_EBOUND;
goto done;
}
}
for (j = 1; j <= P->n; j++)
{ GLPCOL *col = P->col[j];
if (col->type == GLP_DB && col->lb >= col->ub)
{ if (parm->msg_lev >= GLP_MSG_ERR)
xprintf("glp_intopt: column %d: lb = %g, ub = %g; incorr"
"ect bounds\n", j, col->lb, col->ub);
ret = GLP_EBOUND;
goto done;
}
}
/* bounds of all integer variables must be integral */
for (j = 1; j <= P->n; j++)
{ GLPCOL *col = P->col[j];
if (col->kind != GLP_IV) continue;
if (col->type == GLP_LO || col->type == GLP_DB)
{ if (col->lb != floor(col->lb))
{ if (parm->msg_lev >= GLP_MSG_ERR)
xprintf("glp_intopt: integer column %d has non-intege"
"r lower bound %g\n", j, col->lb);
ret = GLP_EBOUND;
goto done;
}
}
if (col->type == GLP_UP || col->type == GLP_DB)
{ if (col->ub != floor(col->ub))
{ if (parm->msg_lev >= GLP_MSG_ERR)
xprintf("glp_intopt: integer column %d has non-intege"
"r upper bound %g\n", j, col->ub);
ret = GLP_EBOUND;
goto done;
}
}
if (col->type == GLP_FX)
{ if (col->lb != floor(col->lb))
{ if (parm->msg_lev >= GLP_MSG_ERR)
xprintf("glp_intopt: integer column %d has non-intege"
"r fixed value %g\n", j, col->lb);
ret = GLP_EBOUND;
goto done;
}
}
}
/* solve MIP problem */
if (parm->msg_lev >= GLP_MSG_ALL)
{ int ni = glp_get_num_int(P);
int nb = glp_get_num_bin(P);
char s[50];
xprintf("GLPK Integer Optimizer, v%s\n", glp_version());
xprintf("%d row%s, %d column%s, %d non-zero%s\n",
P->m, P->m == 1 ? "" : "s", P->n, P->n == 1 ? "" : "s",
P->nnz, P->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");
}
#if 1 /* 28/V-2010 */
if (parm->alien)
{ /* use alien integer optimizer */
ret = _glp_intopt1(P, parm);
goto done;
}
#endif
if (!parm->presolve)
ret = solve_mip(P, parm);
else
ret = preprocess_and_solve_mip(P, parm);
done: /* return to the application program */
return ret;
}
