/* write a MPS file to output */ long __declspec(dllexport) WINAPI _write_mps(lprec *lp, char *filename) { long ret; if (lp != NULL) { freebuferror(); ret = write_mps(lp, filename); } return(ret); }
int glp_write_mps(glp_prob *lp, int fmt, const void *parm, const char *fname) { /* write problem data in MPS format */ int ret; if (!(fmt == GLP_MPS_DECK || fmt == GLP_MPS_FILE)) xerror("glp_write_mps: fmt = %d; invalid parameter\n", fmt); if (parm != NULL) xerror("glp_write_mps: parm = %p; invalid parameter\n", parm); switch (fmt) { case GLP_MPS_DECK: ret = write_mps(lp, fname); break; case GLP_MPS_FILE: ret = write_freemps(lp, fname); break; default: xassert(fmt != fmt); } return ret; }
int MtxLP::writeMPS(string filename){ return write_mps(filename.data()); }
int repricing(lp_prob *p) { LPdata *lp_data = p->lp_data; node_times *comp_times = &p->comp_times; int iterd, termcode; int num_errors = 0; our_col_set *new_cols = NULL; int dual_feas, new_vars, cuts, no_more_cuts_count; int cut_term = 0; check_ub(p); p->iter_num = 0; /*------------------------------------------------------------------------*\ * The main loop -- continue solving relaxations until TDF \*------------------------------------------------------------------------*/ while (TRUE){ p->iter_num++; PRINT(p->par.verbosity, 2, ("\n\n**** Starting iteration %i ****\n\n", p->iter_num)); termcode = dual_simplex(lp_data, &iterd); /* Get relevant data */ get_dj_pi(lp_data); get_slacks(lp_data); /* display the current solution */ if (p->mip->obj_sense == SYM_MAXIMIZE){ PRINT(p->par.verbosity, 2, ("The LP value is: %.3f [%i,%i]\n\n", -lp_data->objval + p->mip->obj_offset, termcode, iterd)); }else{ PRINT(p->par.verbosity, 2, ("The LP value is: %.3f [%i,%i]\n\n", lp_data->objval+ p->mip->obj_offset, termcode, iterd)); } comp_times->lp += used_time(&p->tt); switch (termcode){ case LP_D_ITLIM: /* impossible, since itlim is set to infinity */ case LP_D_INFEASIBLE: /* this is impossible (?) as of now */ case LP_ABANDONED: printf("######## Unexpected termcode: %i \n", termcode); if (p->par.try_to_recover_from_error && (++num_errors == 1)){ /* Try to resolve it from scratch */ printf("######## Trying to recover by resolving from scratch...\n", termcode); continue; }else{ char name[50] = ""; printf("######## Recovery failed. %s%s", "LP solver is having numerical difficulties :(.\n", "######## Dumping current LP to MPS file and exiting.\n\n"); sprintf(name, "matrix.%i.%i.mps", p->bc_index, p->iter_num); write_mps(lp_data, name); return(ERROR__NUMERICAL_INSTABILITY); } case LP_D_UNBOUNDED: /* the primal problem is infeasible */ case LP_D_OBJLIM: case LP_OPTIMAL: if (termcode == LP_D_UNBOUNDED){ PRINT(p->par.verbosity, 1, ("Feasibility lost -- ")); }else if ((p->has_ub && lp_data->objval > p->ub - p->par.granularity) || termcode == LP_D_OBJLIM){ PRINT(p->par.verbosity, 1, ("Terminating due to high cost -- ")); }else{ /* optimal and not too high cost */ break; } comp_times->lp += used_time(&p->tt); if (fathom(p, (termcode != LP_D_UNBOUNDED))){ comp_times->communication += used_time(&p->tt); return(FUNCTION_TERMINATED_NORMALLY); }else{ comp_times->communication += used_time(&p->tt); continue; } } /* If come to here, the termcode must have been OPTIMAL and the * cost cannot be too high. */ /* is_feasible_u() fills up lp_data->x, too!! */ if (is_feasible_u(p, FALSE) == IP_FEASIBLE){ if (p->par.verbosity > 2){ printf ("Now displaying the feasible solution ...\n"); display_lp_solution_u(p, DISP_FEAS_SOLUTION); } cuts = -1; }else{ /*------------------------------------------------------------------*\ * send the current solution to the cut generator, and also to the * cut pool if this is the 1st or cut_pool_check_freq-th iteration. \*------------------------------------------------------------------*/ no_more_cuts_count = 0; if (p->cut_pool && ((p->iter_num-1) % p->par.cut_pool_check_freq == 0) ){ no_more_cuts_count += send_lp_solution_u(p, p->cut_pool); } if (p->cut_gen){ no_more_cuts_count += send_lp_solution_u(p, p->cut_gen); } if (p->par.verbosity > 4){ printf ("Now displaying the relaxed solution ...\n"); display_lp_solution_u(p, DISP_RELAXED_SOLUTION); } comp_times->lp += used_time(&p->tt); tighten_bounds(p); comp_times->fixing += used_time(&p->tt); cuts = 0; if (p->cut_gen || p->cut_pool){ cuts = check_row_effectiveness(p); } /*------------------------------------------------------------------*\ * receive the cuts from the cut generator and the cut pool \*------------------------------------------------------------------*/ if ((cut_term = receive_cuts(p, TRUE, no_more_cuts_count)) >= 0){ cuts += cut_term; }else{ return(ERROR__USER); } } comp_times->lp += used_time(&p->tt); if (cuts < 0){ /* i.e. feasible solution is found */ if (fathom(p, TRUE)){ comp_times->communication += used_time(&p->tt); return(FUNCTION_TERMINATED_NORMALLY); }else{ comp_times->communication += used_time(&p->tt); check_ub(p); continue; } } if (cuts == 0){ PRINT(p->par.verbosity, 2, ("\nIn iteration %i ... no cuts were added.\n", p->iter_num)); }else{ /* Go back to top */ PRINT(p->par.verbosity, 2, ("\nIn iteration %i ... %i violated cuts were added.\n", p->iter_num, cuts)); continue; } comp_times->lp += used_time(&p->tt); /* So no cuts were found. Price out everything */ new_cols = price_all_vars(p); new_vars = new_cols->num_vars + new_cols->rel_ub + new_cols->rel_lb; dual_feas = new_cols->dual_feas; free_col_set(&new_cols); comp_times->pricing += used_time(&p->tt); if (dual_feas != NOT_TDF) break; /* Don't have total dual feasibility. The non-dual-feasible vars * have already been added. Go back and resolve. */ PRINT(p->par.verbosity, 2, ("%i variables added in price-out.\n", new_vars)); } /* Now we know that we have TDF, just send back the node */ comp_times->lp += used_time(&p->tt); send_node_desc(p, REPRICED_NODE); comp_times->communication += used_time(&p->tt); return(FUNCTION_TERMINATED_NORMALLY); }
int fathom_branch(lp_prob *p) { LPdata *lp_data = p->lp_data; node_times *comp_times = &p->comp_times; char first_in_loop = TRUE; int iterd, termcode, i; int cuts, no_more_cuts_count; int num_errors = 0; int cut_term = 0; check_ub(p); p->iter_num = p->node_iter_num = 0; /*------------------------------------------------------------------------*\ * The main loop -- continue solving relaxations until no new cuts * are found \*------------------------------------------------------------------------*/ while (TRUE){ if (p->par.branch_on_cuts && p->slack_cut_num > 0){ switch (p->par.discard_slack_cuts){ case DISCARD_SLACKS_WHEN_STARTING_NEW_NODE: if (p->iter_num != 0) break; case DISCARD_SLACKS_BEFORE_NEW_ITERATION: free_cuts(p->slack_cuts, p->slack_cut_num); p->slack_cut_num = 0; break; } } p->iter_num++; p->node_iter_num++; PRINT(p->par.verbosity, 2, ("\n\n**** Starting iteration %i ****\n\n", p->iter_num)); termcode = dual_simplex(lp_data, &iterd); /* Get relevant data */ get_dj_pi(lp_data); get_slacks(lp_data); get_x(lp_data); /* display the current solution */ if (p->mip->obj_sense == SYM_MAXIMIZE){ PRINT(p->par.verbosity, 2, ("The LP value is: %.3f [%i,%i]\n\n", -lp_data->objval + p->mip->obj_offset, termcode, iterd)); }else{ PRINT(p->par.verbosity, 2, ("The LP value is: %.3f [%i,%i]\n\n", lp_data->objval+ p->mip->obj_offset, termcode, iterd)); } switch (termcode){ case LP_D_ITLIM: /* impossible, since itlim is set to infinity */ case LP_D_INFEASIBLE: /* this is impossible (?) as of now */ case LP_ABANDONED: printf("######## Unexpected termcode: %i \n", termcode); if (p->par.try_to_recover_from_error && (++num_errors == 1)){ /* Try to resolve it from scratch */ printf("######## Trying to recover by resolving from scratch...\n", termcode); continue; }else{ char name[50] = ""; printf("######## Recovery failed. %s%s", "LP solver is having numerical difficulties :(.\n", "######## Dumping current LP to MPS file and exiting.\n\n"); sprintf(name, "matrix.%i.%i.mps", p->bc_index, p->iter_num); write_mps(lp_data, name); return(ERROR__NUMERICAL_INSTABILITY); } case LP_D_UNBOUNDED: /* the primal problem is infeasible */ case LP_D_OBJLIM: case LP_OPTIMAL: if (num_errors == 1){ printf("######## Recovery succeeded! Continuing with node...\n\n"); num_errors = 0; } if (termcode == LP_D_UNBOUNDED){ PRINT(p->par.verbosity, 1, ("Feasibility lost -- ")); #if 0 char name[50] = ""; sprintf(name, "matrix.%i.%i.mps", p->bc_index, p->iter_num); write_mps(lp_data, name); #endif }else if ((p->has_ub && lp_data->objval > p->ub - p->par.granularity) || termcode == LP_D_OBJLIM){ PRINT(p->par.verbosity, 1, ("Terminating due to high cost -- ")); }else{ /* optimal and not too high cost */ break; } comp_times->lp += used_time(&p->tt); if (fathom(p, (termcode != LP_D_UNBOUNDED))){ comp_times->communication += used_time(&p->tt); return(FUNCTION_TERMINATED_NORMALLY); }else{ first_in_loop = FALSE; comp_times->communication += used_time(&p->tt); continue; } } /* If come to here, the termcode must have been OPTIMAL and the * cost cannot be too high. */ /* is_feasible_u() fills up lp_data->x, too!! */ if (is_feasible_u(p, FALSE) == IP_FEASIBLE){ cuts = -1; }else{ /*------------------------------------------------------------------*\ * send the current solution to the cut generator, and also to the * cut pool if we are either * - at the beginning of a chain (but not in the root in the * first phase) * - or this is the cut_pool_check_freq-th iteration. \*------------------------------------------------------------------*/ cuts = 0; no_more_cuts_count = 0; if (p->cut_pool && ((first_in_loop && (p->bc_level>0 || p->phase==1)) || (p->iter_num % p->par.cut_pool_check_freq == 0)) ){ no_more_cuts_count += send_lp_solution_u(p, p->cut_pool); } if (p->cut_gen){ no_more_cuts_count += send_lp_solution_u(p, p->cut_gen); } if (p->par.verbosity > 4){ printf ("Now displaying the relaxed solution ...\n"); display_lp_solution_u(p, DISP_RELAXED_SOLUTION); } comp_times->lp += used_time(&p->tt); tighten_bounds(p); comp_times->fixing += used_time(&p->tt); if (!first_in_loop){ cuts = check_row_effectiveness(p); } /*------------------------------------------------------------------*\ * receive the cuts from the cut generator and the cut pool \*------------------------------------------------------------------*/ if ((cut_term = receive_cuts(p, first_in_loop, no_more_cuts_count)) >=0 ){ cuts += cut_term; }else{ return(ERROR__USER); } } comp_times->lp += used_time(&p->tt); if (cuts < 0){ /* i.e. feasible solution is found */ if (fathom(p, TRUE)){ return(FUNCTION_TERMINATED_NORMALLY); }else{ first_in_loop = FALSE; check_ub(p); continue; } } PRINT(p->par.verbosity, 2, ("\nIn iteration %i, before calling branch()\n", p->iter_num)); if (cuts == 0){ PRINT(p->par.verbosity, 2, ("... no cuts were added.\n")); if (p->par.verbosity > 4){ printf("Now displaying final relaxed solution...\n\n"); display_lp_solution_u(p, DISP_FINAL_RELAXED_SOLUTION); } }else{ PRINT(p->par.verbosity, 2, ("... %i violated cuts were added\n", cuts)); } comp_times->lp += used_time(&p->tt); switch (cuts = branch(p, cuts)){ case NEW_NODE: #ifndef ROOT_NODEONLY if (p->par.verbosity > 0){ printf("*************************************************\n"); printf("* Now processing NODE %i LEVEL %i\n", p->bc_index, p->bc_level); printf("*************************************************\n\n"); p->node_iter_num = 0; } break; #endif case FATHOMED_NODE: comp_times->strong_branching += used_time(&p->tt); return(FUNCTION_TERMINATED_NORMALLY); case ERROR__NO_BRANCHING_CANDIDATE: /* Something went wrong */ return(ERROR__NO_BRANCHING_CANDIDATE); default: /* the return value is the number of cuts added */ if (p->par.verbosity > 2){ printf("Continue with this node."); if (cuts > 0) printf(" %i cuts added alltogether in iteration %i", cuts, p->iter_num); printf("\n\n"); } break; } comp_times->strong_branching += used_time(&p->tt); check_ub(p); first_in_loop = FALSE; } comp_times->lp += used_time(&p->tt); return(FUNCTION_TERMINATED_NORMALLY); }