int glpk (int sense, int n, int m, double *c, int nz, int *rn, int *cn,
double *a, double *b, char *ctype, int *freeLB, double *lb,
int *freeUB, double *ub, int *vartype, int isMIP, int lpsolver,
int save_pb, char *save_filename, char *filetype,
double *xmin, double *fmin, double *status,
double *lambda, double *redcosts, double *time, double *mem)
{
int typx = 0;
int method;
clock_t t_start = clock();
//Redirect standard output
if (glpIntParam[0] > 1) glp_term_hook (glpk_print_hook, NULL);
else glp_term_hook (NULL, NULL);
//-- Create an empty LP/MILP object
LPX *lp = lpx_create_prob ();
//-- Set the sense of optimization
if (sense == 1)
glp_set_obj_dir (lp, GLP_MIN);
else
glp_set_obj_dir (lp, GLP_MAX);
//-- Define the number of unknowns and their domains.
glp_add_cols (lp, n);
for (int i = 0; i < n; i++)
{
//-- Define type of the structural variables
if (! freeLB[i] && ! freeUB[i]) {
if ( lb[i] == ub[i] )
glp_set_col_bnds (lp, i+1, GLP_FX, lb[i], ub[i]);
else
glp_set_col_bnds (lp, i+1, GLP_DB, lb[i], ub[i]);
}
else
{
if (! freeLB[i] && freeUB[i])
glp_set_col_bnds (lp, i+1, GLP_LO, lb[i], ub[i]);
else
{
if (freeLB[i] && ! freeUB[i])
glp_set_col_bnds (lp, i+1, GLP_UP, lb[i], ub[i]);
else
glp_set_col_bnds (lp, i+1, GLP_FR, lb[i], ub[i]);
}
}
// -- Set the objective coefficient of the corresponding
// -- structural variable. No constant term is assumed.
glp_set_obj_coef(lp,i+1,c[i]);
if (isMIP)
glp_set_col_kind (lp, i+1, vartype[i]);
}
glp_add_rows (lp, m);
for (int i = 0; i < m; i++)
{
/* If the i-th row has no lower bound (types F,U), the
corrispondent parameter will be ignored.
If the i-th row has no upper bound (types F,L), the corrispondent
parameter will be ignored.
If the i-th row is of S type, the i-th LB is used, but
the i-th UB is ignored.
*/
switch (ctype[i])
{
case 'F': typx = GLP_FR; break;
// upper bound
case 'U': typx = GLP_UP; break;
// lower bound
case 'L': typx = GLP_LO; break;
// fixed constraint
case 'S': typx = GLP_FX; break;
// double-bounded variable
case 'D': typx = GLP_DB; break;
}
if ( typx == GLP_DB && -b[i] < b[i]) {
glp_set_row_bnds (lp, i+1, typx, -b[i], b[i]);
}
else if(typx == GLP_DB && -b[i] == b[i]) {
glp_set_row_bnds (lp, i+1, GLP_FX, b[i], b[i]);
}
else {
// this should be glp_set_row_bnds (lp, i+1, typx, -b[i], b[i]);
glp_set_row_bnds (lp, i+1, typx, b[i], b[i]);
}
}
// Load constraint matrix A
glp_load_matrix (lp, nz, rn, cn, a);
// Save problem
if (save_pb) {
if (!strcmp(filetype,"cplex")){
if (glp_write_lp (lp, NULL, save_filename) != 0) {
mexErrMsgTxt("glpk: unable to write the problem");
longjmp (mark, -1);
}
}else{
if (!strcmp(filetype,"fixedmps")){
if (glp_write_mps (lp, GLP_MPS_DECK, NULL, save_filename) != 0) {
mexErrMsgTxt("glpk: unable to write the problem");
longjmp (mark, -1);
}
}else{
if (!strcmp(filetype,"freemps")){
if (glp_write_mps (lp, GLP_MPS_FILE, NULL, save_filename) != 0) {
mexErrMsgTxt("glpk: unable to write the problem");
longjmp (mark, -1);
}
}else{// plain text
if (lpx_print_prob (lp, save_filename) != 0) {
mexErrMsgTxt("glpk: unable to write the problem");
longjmp (mark, -1);
}
}
}
}
}
//-- scale the problem data (if required)
if (! glpIntParam[16] || lpsolver != 1) {
switch ( glpIntParam[1] ) {
case ( 0 ): glp_scale_prob( lp, GLP_SF_SKIP ); break;
case ( 1 ): glp_scale_prob( lp, GLP_SF_GM ); break;
case ( 2 ): glp_scale_prob( lp, GLP_SF_EQ ); break;
case ( 3 ): glp_scale_prob( lp, GLP_SF_AUTO ); break;
case ( 4 ): glp_scale_prob( lp, GLP_SF_2N ); break;
default :
mexErrMsgTxt("glpk: unrecognized scaling option");
longjmp (mark, -1);
}
}
else {
/* do nothing? or unscale?
glp_unscale_prob( lp );
*/
}
//-- build advanced initial basis (if required)
if (lpsolver == 1 && ! glpIntParam[16])
glp_adv_basis (lp, 0);
glp_smcp sParam;
glp_init_smcp(&sParam);
//-- set control parameters for simplex/exact method
if (lpsolver == 1 || lpsolver == 3){
//remap of control parameters for simplex method
sParam.msg_lev=glpIntParam[0]; // message level
// simplex method: primal/dual
switch ( glpIntParam[2] ) {
case 0: sParam.meth=GLP_PRIMAL; break;
case 1: sParam.meth=GLP_DUAL; break;
case 2: sParam.meth=GLP_DUALP; break;
default:
mexErrMsgTxt("glpk: unrecognized primal/dual method");
longjmp (mark, -1);
}
// pricing technique
if (glpIntParam[3]==0) sParam.pricing=GLP_PT_STD;
else sParam.pricing=GLP_PT_PSE;
// ratio test
if (glpIntParam[20]==0) sParam.r_test = GLP_RT_STD;
else sParam.r_test=GLP_RT_HAR;
//tollerances
sParam.tol_bnd=glpRealParam[1]; // primal feasible tollerance
sParam.tol_dj=glpRealParam[2]; // dual feasible tollerance
sParam.tol_piv=glpRealParam[3]; // pivot tollerance
sParam.obj_ll=glpRealParam[4]; // lower limit
sParam.obj_ul=glpRealParam[5]; // upper limit
// iteration limit
if (glpIntParam[5]==-1) sParam.it_lim=INT_MAX;
else sParam.it_lim=glpIntParam[5];
// time limit
if (glpRealParam[6]==-1) sParam.tm_lim=INT_MAX;
else sParam.tm_lim=(int) glpRealParam[6];
sParam.out_frq=glpIntParam[7]; // output frequency
sParam.out_dly=(int) glpRealParam[7]; // output delay
// presolver
if (glpIntParam[16]) sParam.presolve=GLP_ON;
else sParam.presolve=GLP_OFF;
}else{
for(int i = 0; i < NIntP; i++) {
// skip assinging ratio test or
if ( i == 18 || i == 20) continue;
lpx_set_int_parm (lp, IParam[i], glpIntParam[i]);
}
for (int i = 0; i < NRealP; i++) {
lpx_set_real_parm (lp, RParam[i], glpRealParam[i]);
}
}
//set MIP params if MIP....
glp_iocp iParam;
glp_init_iocp(&iParam);
if ( isMIP ){
method = 'I';
switch (glpIntParam[0]) { //message level
case 0: iParam.msg_lev = GLP_MSG_OFF; break;
case 1: iParam.msg_lev = GLP_MSG_ERR; break;
case 2: iParam.msg_lev = GLP_MSG_ON; break;
case 3: iParam.msg_lev = GLP_MSG_ALL; break;
default: mexErrMsgTxt("glpk: msg_lev bad param");
}
switch (glpIntParam[14]) { //branching param
case 0: iParam.br_tech = GLP_BR_FFV; break;
case 1: iParam.br_tech = GLP_BR_LFV; break;
case 2: iParam.br_tech = GLP_BR_MFV; break;
case 3: iParam.br_tech = GLP_BR_DTH; break;
default: mexErrMsgTxt("glpk: branch bad param");
}
switch (glpIntParam[15]) { //backtracking heuristic
case 0: iParam.bt_tech = GLP_BT_DFS; break;
case 1: iParam.bt_tech = GLP_BT_BFS; break;
case 2: iParam.bt_tech = GLP_BT_BLB; break;
case 3: iParam.bt_tech = GLP_BT_BPH; break;
default: mexErrMsgTxt("glpk: backtrack bad param");
}
if ( glpRealParam[8] > 0.0 && glpRealParam[8] < 1.0 )
iParam.tol_int = glpRealParam[8]; // absolute tolorence
else
mexErrMsgTxt("glpk: tolint must be between 0 and 1");
iParam.tol_obj = glpRealParam[9]; // relative tolarence
iParam.mip_gap = glpRealParam[10]; // realative gap tolerance
// set time limit for mip
if ( glpRealParam[6] < 0.0 || glpRealParam[6] > 1e6 )
iParam.tm_lim = INT_MAX;
else
iParam.tm_lim = (int)(1000.0 * glpRealParam[6] );
// Choose Cutsets for mip
// shut all cuts off, then start over....
iParam.gmi_cuts = GLP_OFF;
iParam.mir_cuts = GLP_OFF;
iParam.cov_cuts = GLP_OFF;
iParam.clq_cuts = GLP_OFF;
switch( glpIntParam[17] ) {
case 0: break;
case 1: iParam.gmi_cuts = GLP_ON; break;
case 2: iParam.mir_cuts = GLP_ON; break;
case 3: iParam.cov_cuts = GLP_ON; break;
case 4: iParam.clq_cuts = GLP_ON; break;
case 5: iParam.clq_cuts = GLP_ON;
iParam.gmi_cuts = GLP_ON;
iParam.mir_cuts = GLP_ON;
iParam.cov_cuts = GLP_ON;
iParam.clq_cuts = GLP_ON; break;
default: mexErrMsgTxt("glpk: cutset bad param");
}
switch( glpIntParam[18] ) { // pre-processing for mip
case 0: iParam.pp_tech = GLP_PP_NONE; break;
case 1: iParam.pp_tech = GLP_PP_ROOT; break;
case 2: iParam.pp_tech = GLP_PP_ALL; break;
default: mexErrMsgTxt("glpk: pprocess bad param");
}
if (glpIntParam[16]) iParam.presolve=GLP_ON;
else iParam.presolve=GLP_OFF;
if (glpIntParam[19]) iParam.binarize = GLP_ON;
else iParam.binarize = GLP_OFF;
}
else {
/* Choose simplex method ('S')
or interior point method ('T')
or Exact method ('E')
to solve the problem */
switch (lpsolver) {
case 1: method = 'S'; break;
case 2: method = 'T'; break;
case 3: method = 'E'; break;
default:
mexErrMsgTxt("glpk: lpsolver != lpsolver");
longjmp (mark, -1);
}
}
// now run the problem...
int errnum = 0;
switch (method) {
case 'I':
errnum = glp_intopt( lp, &iParam );
errnum += 200; //this is to avoid ambiguity in the return codes.
break;
case 'S':
errnum = glp_simplex(lp, &sParam);
errnum += 100; //this is to avoid ambiguity in the return codes.
break;
case 'T':
errnum = glp_interior(lp, NULL );
errnum += 300; //this is to avoid ambiguity in the return codes.
break;
case 'E':
errnum = glp_exact(lp, &sParam);
errnum += 100; //this is to avoid ambiguity in the return codes.
break;
default: /*xassert (method != method); */
mexErrMsgTxt("glpk: method != method");
longjmp (mark, -1);
}
if (errnum==100 || errnum==200 || errnum==300 || errnum==106 || errnum==107 || errnum==108 || errnum==109 || errnum==209 || errnum==214 || errnum==308) {
// Get status and object value
if (isMIP) {
*status = glp_mip_status (lp);
*fmin = glp_mip_obj_val (lp);
}
else {
if (lpsolver == 1 || lpsolver == 3) {
*status = glp_get_status (lp);
*fmin = glp_get_obj_val (lp);
}
else {
*status = glp_ipt_status (lp);
*fmin = glp_ipt_obj_val (lp);
}
}
// Get optimal solution (if exists)
if (isMIP) {
for (int i = 0; i < n; i++)
xmin[i] = glp_mip_col_val (lp, i+1);
}
else {
/* Primal values */
for (int i = 0; i < n; i++) {
if (lpsolver == 1 || lpsolver == 3)
xmin[i] = glp_get_col_prim (lp, i+1);
else
xmin[i] = glp_ipt_col_prim (lp, i+1);
}
/* Dual values */
for (int i = 0; i < m; i++) {
if (lpsolver == 1 || lpsolver == 3)
lambda[i] = glp_get_row_dual (lp, i+1);
else
lambda[i] = glp_ipt_row_dual (lp, i+1);
}
/* Reduced costs */
for (int i = 0; i < glp_get_num_cols (lp); i++) {
if (lpsolver == 1 || lpsolver == 3)
redcosts[i] = glp_get_col_dual (lp, i+1);
else
redcosts[i] = glp_ipt_col_dual (lp, i+1);
}
}
*time = (clock () - t_start) / CLOCKS_PER_SEC;
size_t tpeak;
glp_mem_usage(NULL, NULL, NULL, &tpeak);
*mem=((double) tpeak) / (1024);
lpx_delete_prob(lp);
return 0;
}
else {
// printf("errnum is %d\n", errnum);
}
lpx_delete_prob(lp);
/* this shouldn't be nessiary with glp_deleted_prob, but try it
if we have weird behavior again... */
glp_free_env();
*status = errnum;
return errnum;
}
int ios_driver(glp_tree *T)
{ int p, curr_p, p_stat, d_stat, ret;
#if 1 /* carry out to glp_tree */
int pred_p = 0;
/* if the current subproblem has been just created due to
branching, pred_p is the reference number of its parent
subproblem, otherwise pred_p is zero */
#endif
glp_long ttt = T->tm_beg;
#if 0
((glp_iocp *)T->parm)->msg_lev = GLP_MSG_DBG;
#endif
/* on entry to the B&B driver it is assumed that the active list
contains the only active (i.e. root) subproblem, which is the
original MIP problem to be solved */
loop: /* main loop starts here */
/* at this point the current subproblem does not exist */
xassert(T->curr == NULL);
/* if the active list is empty, the search is finished */
if (T->head == NULL)
{ if (T->parm->msg_lev >= GLP_MSG_DBG)
xprintf("Active list is empty!\n");
xassert(dmp_in_use(T->pool).lo == 0);
ret = 0;
goto done;
}
/* select some active subproblem to continue the search */
xassert(T->next_p == 0);
/* let the application program select subproblem */
if (T->parm->cb_func != NULL)
{ xassert(T->reason == 0);
T->reason = GLP_ISELECT;
T->parm->cb_func(T, T->parm->cb_info);
T->reason = 0;
if (T->stop)
{ ret = GLP_ESTOP;
goto done;
}
}
if (T->next_p != 0)
{ /* the application program has selected something */
;
}
else if (T->a_cnt == 1)
{ /* the only active subproblem exists, so select it */
xassert(T->head->next == NULL);
T->next_p = T->head->p;
}
else if (T->child != 0)
{ /* select one of branching childs suggested by the branching
heuristic */
T->next_p = T->child;
}
else
{ /* select active subproblem as specified by the backtracking
technique option */
T->next_p = ios_choose_node(T);
}
/* the active subproblem just selected becomes current */
ios_revive_node(T, T->next_p);
T->next_p = T->child = 0;
/* invalidate pred_p, if it is not the reference number of the
parent of the current subproblem */
if (T->curr->up != NULL && T->curr->up->p != pred_p) pred_p = 0;
/* determine the reference number of the current subproblem */
p = T->curr->p;
if (T->parm->msg_lev >= GLP_MSG_DBG)
{ xprintf("-----------------------------------------------------"
"-------------------\n");
xprintf("Processing node %d at level %d\n", p, T->curr->level);
}
/* if it is the root subproblem, initialize cut generators */
if (p == 1)
{ if (T->parm->gmi_cuts == GLP_ON)
{ if (T->parm->msg_lev >= GLP_MSG_ALL)
xprintf("Gomory's cuts enabled\n");
}
if (T->parm->mir_cuts == GLP_ON)
{ if (T->parm->msg_lev >= GLP_MSG_ALL)
xprintf("MIR cuts enabled\n");
xassert(T->mir_gen == NULL);
T->mir_gen = ios_mir_init(T);
}
if (T->parm->cov_cuts == GLP_ON)
{ if (T->parm->msg_lev >= GLP_MSG_ALL)
xprintf("Cover cuts enabled\n");
}
if (T->parm->clq_cuts == GLP_ON)
{ xassert(T->clq_gen == NULL);
if (T->parm->msg_lev >= GLP_MSG_ALL)
xprintf("Clique cuts enabled\n");
T->clq_gen = ios_clq_init(T);
}
}
more: /* minor loop starts here */
/* at this point the current subproblem needs either to be solved
for the first time or re-optimized due to reformulation */
/* display current progress of the search */
if (T->parm->msg_lev >= GLP_MSG_DBG ||
T->parm->msg_lev >= GLP_MSG_ON &&
(double)(T->parm->out_frq - 1) <=
1000.0 * xdifftime(xtime(), T->tm_lag))
show_progress(T, 0);
if (T->parm->msg_lev >= GLP_MSG_ALL &&
xdifftime(xtime(), ttt) >= 60.0)
#if 0 /* 16/II-2012 */
{ glp_long total;
glp_mem_usage(NULL, NULL, &total, NULL);
xprintf("Time used: %.1f secs. Memory used: %.1f Mb.\n",
xdifftime(xtime(), T->tm_beg), xltod(total) / 1048576.0);
ttt = xtime();
}
#else
{ size_t total;
glp_mem_usage(NULL, NULL, &total, NULL);
xprintf("Time used: %.1f secs. Memory used: %.1f Mb.\n",
xdifftime(xtime(), T->tm_beg), (double)total / 1048576.0);
ttt = xtime();
}
#endif
/* check the mip gap */
if (T->parm->mip_gap > 0.0 &&
ios_relative_gap(T) <= T->parm->mip_gap)
{ if (T->parm->msg_lev >= GLP_MSG_DBG)
xprintf("Relative gap tolerance reached; search terminated "
"\n");
ret = GLP_EMIPGAP;
goto done;
}
/* 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))
{ if (T->parm->msg_lev >= GLP_MSG_DBG)
xprintf("Time limit exhausted; search terminated\n");
ret = GLP_ETMLIM;
goto done;
}
/* let the application program preprocess the subproblem */
if (T->parm->cb_func != NULL)
{ xassert(T->reason == 0);
T->reason = GLP_IPREPRO;
T->parm->cb_func(T, T->parm->cb_info);
T->reason = 0;
if (T->stop)
{ ret = GLP_ESTOP;
goto done;
}
}
/* perform basic preprocessing */
if (T->parm->pp_tech == GLP_PP_NONE)
;
else if (T->parm->pp_tech == GLP_PP_ROOT)
{ if (T->curr->level == 0)
{ if (ios_preprocess_node(T, 100))
goto fath;
}
}
else if (T->parm->pp_tech == GLP_PP_ALL)
{ if (ios_preprocess_node(T, T->curr->level == 0 ? 100 : 10))
goto fath;
}
else
xassert(T != T);
/* preprocessing may improve the global bound */
if (!is_branch_hopeful(T, p))
{ xprintf("*** not tested yet ***\n");
goto fath;
}
/* solve LP relaxation of the current subproblem */
if (T->parm->msg_lev >= GLP_MSG_DBG)
xprintf("Solving LP relaxation...\n");
ret = ios_solve_node(T);
if (!(ret == 0 || ret == GLP_EOBJLL || ret == GLP_EOBJUL))
{ if (T->parm->msg_lev >= GLP_MSG_ERR)
xprintf("ios_driver: unable to solve current LP relaxation;"
" glp_simplex returned %d\n", ret);
ret = GLP_EFAIL;
goto done;
}
/* analyze status of the basic solution to LP relaxation found */
p_stat = T->mip->pbs_stat;
d_stat = T->mip->dbs_stat;
if (p_stat == GLP_FEAS && d_stat == GLP_FEAS)
{ /* LP relaxation has optimal solution */
if (T->parm->msg_lev >= GLP_MSG_DBG)
xprintf("Found optimal solution to LP relaxation\n");
}
else if (d_stat == GLP_NOFEAS)
{ /* LP relaxation has no dual feasible solution */
/* since the current subproblem cannot have a larger feasible
region than its parent, there is something wrong */
if (T->parm->msg_lev >= GLP_MSG_ERR)
xprintf("ios_driver: current LP relaxation has no dual feas"
"ible solution\n");
ret = GLP_EFAIL;
goto done;
}
else if (p_stat == GLP_INFEAS && d_stat == GLP_FEAS)
{ /* LP relaxation has no primal solution which is better than
the incumbent objective value */
xassert(T->mip->mip_stat == GLP_FEAS);
if (T->parm->msg_lev >= GLP_MSG_DBG)
xprintf("LP relaxation has no solution better than incumben"
"t objective value\n");
/* prune the branch */
goto fath;
}
else if (p_stat == GLP_NOFEAS)
{ /* LP relaxation has no primal feasible solution */
if (T->parm->msg_lev >= GLP_MSG_DBG)
xprintf("LP relaxation has no feasible solution\n");
/* prune the branch */
goto fath;
}
else
{ /* other cases cannot appear */
xassert(T->mip != T->mip);
}
/* at this point basic solution to LP relaxation of the current
subproblem is optimal */
xassert(p_stat == GLP_FEAS && d_stat == GLP_FEAS);
xassert(T->curr != NULL);
T->curr->lp_obj = T->mip->obj_val;
/* thus, it defines a local bound to integer optimal solution of
the current subproblem */
{ double bound = T->mip->obj_val;
/* some local bound to the current subproblem could be already
set before, so we should only improve it */
bound = ios_round_bound(T, bound);
if (T->mip->dir == GLP_MIN)
{ if (T->curr->bound < bound)
T->curr->bound = bound;
}
else if (T->mip->dir == GLP_MAX)
{ if (T->curr->bound > bound)
T->curr->bound = bound;
}
else
xassert(T->mip != T->mip);
if (T->parm->msg_lev >= GLP_MSG_DBG)
xprintf("Local bound is %.9e\n", bound);
}
/* if the local bound indicates that integer optimal solution of
the current subproblem cannot be better than the global bound,
prune the branch */
if (!is_branch_hopeful(T, p))
{ if (T->parm->msg_lev >= GLP_MSG_DBG)
xprintf("Current branch is hopeless and can be pruned\n");
goto fath;
}
/* let the application program generate additional rows ("lazy"
constraints) */
xassert(T->reopt == 0);
xassert(T->reinv == 0);
if (T->parm->cb_func != NULL)
{ xassert(T->reason == 0);
T->reason = GLP_IROWGEN;
T->parm->cb_func(T, T->parm->cb_info);
T->reason = 0;
if (T->stop)
{ ret = GLP_ESTOP;
goto done;
}
if (T->reopt)
{ /* some rows were added; re-optimization is needed */
T->reopt = T->reinv = 0;
goto more;
}
if (T->reinv)
{ /* no rows were added, however, some inactive rows were
removed */
T->reinv = 0;
xassert(glp_factorize(T->mip) == 0);
}
}
/* check if the basic solution is integer feasible */
check_integrality(T);
/* if the basic solution satisfies to all integrality conditions,
it is a new, better integer feasible solution */
if (T->curr->ii_cnt == 0)
{ if (T->parm->msg_lev >= GLP_MSG_DBG)
xprintf("New integer feasible solution found\n");
if (T->parm->msg_lev >= GLP_MSG_ALL)
display_cut_info(T);
record_solution(T);
if (T->parm->msg_lev >= GLP_MSG_ON)
show_progress(T, 1);
/* make the application program happy */
if (T->parm->cb_func != NULL)
{ xassert(T->reason == 0);
T->reason = GLP_IBINGO;
T->parm->cb_func(T, T->parm->cb_info);
T->reason = 0;
if (T->stop)
{ ret = GLP_ESTOP;
goto done;
}
}
/* since the current subproblem has been fathomed, prune its
branch */
goto fath;
}
/* at this point basic solution to LP relaxation of the current
subproblem is optimal, but integer infeasible */
/* try to fix some non-basic structural variables of integer kind
on their current bounds due to reduced costs */
if (T->mip->mip_stat == GLP_FEAS)
fix_by_red_cost(T);
/* let the application program try to find some solution to the
original MIP with a primal heuristic */
if (T->parm->cb_func != NULL)
{ xassert(T->reason == 0);
T->reason = GLP_IHEUR;
T->parm->cb_func(T, T->parm->cb_info);
T->reason = 0;
if (T->stop)
{ ret = GLP_ESTOP;
goto done;
}
/* check if the current branch became hopeless */
if (!is_branch_hopeful(T, p))
{ if (T->parm->msg_lev >= GLP_MSG_DBG)
xprintf("Current branch became hopeless and can be prune"
"d\n");
goto fath;
}
}
/* try to find solution with the feasibility pump heuristic */
if (T->parm->fp_heur)
{ xassert(T->reason == 0);
T->reason = GLP_IHEUR;
ios_feas_pump(T);
T->reason = 0;
/* check if the current branch became hopeless */
if (!is_branch_hopeful(T, p))
{ if (T->parm->msg_lev >= GLP_MSG_DBG)
xprintf("Current branch became hopeless and can be prune"
"d\n");
goto fath;
}
}
/* it's time to generate cutting planes */
xassert(T->local != NULL);
xassert(T->local->size == 0);
/* let the application program generate some cuts; note that it
can add cuts either to the local cut pool or directly to the
current subproblem */
if (T->parm->cb_func != NULL)
{ xassert(T->reason == 0);
T->reason = GLP_ICUTGEN;
T->parm->cb_func(T, T->parm->cb_info);
T->reason = 0;
if (T->stop)
{ ret = GLP_ESTOP;
goto done;
}
}
/* try to generate generic cuts with built-in generators
(as suggested by Matteo Fischetti et al. the built-in cuts
are not generated at each branching node; an intense attempt
of generating new cuts is only made at the root node, and then
a moderate effort is spent after each backtracking step) */
if (T->curr->level == 0 || pred_p == 0)
{ xassert(T->reason == 0);
T->reason = GLP_ICUTGEN;
generate_cuts(T);
T->reason = 0;
}
/* if the local cut pool is not empty, select useful cuts and add
them to the current subproblem */
if (T->local->size > 0)
{ xassert(T->reason == 0);
T->reason = GLP_ICUTGEN;
ios_process_cuts(T);
T->reason = 0;
}
/* clear the local cut pool */
ios_clear_pool(T, T->local);
/* perform re-optimization, if necessary */
if (T->reopt)
{ T->reopt = 0;
T->curr->changed++;
goto more;
}
/* no cuts were generated; remove inactive cuts */
remove_cuts(T);
if (T->parm->msg_lev >= GLP_MSG_ALL && T->curr->level == 0)
display_cut_info(T);
/* update history information used on pseudocost branching */
if (T->pcost != NULL) ios_pcost_update(T);
/* it's time to perform branching */
xassert(T->br_var == 0);
xassert(T->br_sel == 0);
/* let the application program choose variable to branch on */
if (T->parm->cb_func != NULL)
{ xassert(T->reason == 0);
xassert(T->br_var == 0);
xassert(T->br_sel == 0);
T->reason = GLP_IBRANCH;
T->parm->cb_func(T, T->parm->cb_info);
T->reason = 0;
if (T->stop)
{ ret = GLP_ESTOP;
goto done;
}
}
/* if nothing has been chosen, choose some variable as specified
by the branching technique option */
if (T->br_var == 0)
T->br_var = ios_choose_var(T, &T->br_sel);
/* perform actual branching */
curr_p = T->curr->p;
ret = branch_on(T, T->br_var, T->br_sel);
T->br_var = T->br_sel = 0;
if (ret == 0)
{ /* both branches have been created */
pred_p = curr_p;
goto loop;
}
else if (ret == 1)
{ /* one branch is hopeless and has been pruned, so now the
current subproblem is other branch */
/* the current subproblem should be considered as a new one,
since one bound of the branching variable was changed */
T->curr->solved = T->curr->changed = 0;
goto more;
}
else if (ret == 2)
{ /* both branches are hopeless and have been pruned; new
subproblem selection is needed to continue the search */
goto fath;
}
else
xassert(ret != ret);
fath: /* the current subproblem has been fathomed */
if (T->parm->msg_lev >= GLP_MSG_DBG)
xprintf("Node %d fathomed\n", p);
/* freeze the current subproblem */
ios_freeze_node(T);
/* and prune the corresponding branch of the tree */
ios_delete_node(T, p);
/* if a new integer feasible solution has just been found, other
branches may become hopeless and therefore must be pruned */
if (T->mip->mip_stat == GLP_FEAS) cleanup_the_tree(T);
/* new subproblem selection is needed due to backtracking */
pred_p = 0;
goto loop;
done: /* display progress of the search on exit from the solver */
if (T->parm->msg_lev >= GLP_MSG_ON)
show_progress(T, 0);
if (T->mir_gen != NULL)
ios_mir_term(T->mir_gen), T->mir_gen = NULL;
if (T->clq_gen != NULL)
ios_clq_term(T->clq_gen), T->clq_gen = NULL;
/* return to the calling program */
return ret;
}
