static int is_binary(LPX *lp, int j) { /* this routine checks if variable x[j] is binary */ return lpx_get_col_kind(lp, j) == LPX_IV && lpx_get_col_type(lp, j) == LPX_DB && lpx_get_col_lb(lp, j) == 0.0 && lpx_get_col_ub(lp, j) == 1.0; }
static void show_status(LPX *prob, int prob_m, int prob_nz) { int n, j, count; double x, tol_int; /* determine the number of structural variables of integer kind whose current values are still fractional */ n = lpx_get_num_cols(prob); tol_int = lpx_get_real_parm(prob, LPX_K_TOLINT); count = 0; for (j = 1; j <= n; j++) { if (lpx_get_col_kind(prob, j) != LPX_IV) continue; x = lpx_get_col_prim(prob, j); if (fabs(x - floor(x + 0.5)) <= tol_int) continue; count++; } print("&%6d: obj = %17.9e frac = %5d cuts = %5d (%d)", lpx_get_int_parm(prob, LPX_K_ITCNT), lpx_get_obj_val(prob), count, lpx_get_num_rows(prob) - prob_m, lpx_get_num_nz(prob) - prob_nz); return; }
int lpx_write_cpxlp(LPX *lp, const char *fname) { /* write problem data in CPLEX LP format */ FILE *fp; int nrows, ncols, i, j, t, len, typx, flag, kind, *ind; double lb, ub, temp, *val; char line[1023+1], term[1023+1], rname[255+1], cname[255+1]; print("lpx_write_cpxlp: writing problem data to `%s'...", fname); /* open the output text file */ fp = xfopen(fname, "w"); if (fp == NULL) { print("lpx_write_cpxlp: unable to create `%s' - %s", fname, strerror(errno)); goto fail; } /* determine the number of rows and columns */ nrows = lpx_get_num_rows(lp); ncols = lpx_get_num_cols(lp); /* the problem should contain at least one row and one column */ if (!(nrows > 0 && ncols > 0)) fault("lpx_write_cpxlp: problem has no rows/columns"); /* write problem name */ { const char *name = lpx_get_prob_name(lp); if (name == NULL) name = "Unknown"; fprintf(fp, "\\* Problem: %s *\\\n", name); fprintf(fp, "\n"); } /* allocate working arrays */ ind = xcalloc(1+ncols, sizeof(int)); val = xcalloc(1+ncols, sizeof(double)); /* write the objective function definition and the constraints section */ for (i = 0; i <= nrows; i++) { if (i == 0) { switch (lpx_get_obj_dir(lp)) { case LPX_MIN: fprintf(fp, "Minimize\n"); break; case LPX_MAX: fprintf(fp, "Maximize\n"); break; default: xassert(lp != lp); } } else if (i == 1) { temp = lpx_get_obj_coef(lp, 0); if (temp != 0.0) fprintf(fp, "\\* constant term = %.*g *\\\n", DBL_DIG, temp); fprintf(fp, "\n"); fprintf(fp, "Subject To\n"); } row_name(lp, i, rname); if (i == 0) { len = 0; for (j = 1; j <= ncols; j++) { temp = lpx_get_obj_coef(lp, j); if (temp != 0.0) len++, ind[len] = j, val[len] = temp; } } else { lpx_get_row_bnds(lp, i, &typx, &lb, &ub); if (typx == LPX_FR) continue; len = lpx_get_mat_row(lp, i, ind, val); } flag = 0; more: if (!flag) sprintf(line, " %s:", rname); else sprintf(line, " %*s ", strlen(rname), ""); for (t = 1; t <= len; t++) { col_name(lp, ind[t], cname); if (val[t] == +1.0) sprintf(term, " + %s", cname); else if (val[t] == -1.0) sprintf(term, " - %s", cname); else if (val[t] > 0.0) sprintf(term, " + %.*g %s", DBL_DIG, +val[t], cname); else if (val[t] < 0.0) sprintf(term, " - %.*g %s", DBL_DIG, -val[t], cname); else xassert(lp != lp); if (strlen(line) + strlen(term) > 72) fprintf(fp, "%s\n", line), line[0] = '\0'; strcat(line, term); } if (len == 0) { /* empty row */ sprintf(term, " 0 %s", col_name(lp, 1, cname)); strcat(line, term); } if (i > 0) { switch (typx) { case LPX_LO: case LPX_DB: sprintf(term, " >= %.*g", DBL_DIG, lb); break; case LPX_UP: sprintf(term, " <= %.*g", DBL_DIG, ub); break; case LPX_FX: sprintf(term, " = %.*g", DBL_DIG, lb); break; default: xassert(typx != typx); } if (strlen(line) + strlen(term) > 72) fprintf(fp, "%s\n", line), line[0] = '\0'; strcat(line, term); } fprintf(fp, "%s\n", line); if (i > 0 && typx == LPX_DB) { /* double-bounded row needs a copy for its upper bound */ flag = 1; typx = LPX_UP; goto more; } } /* free working arrays */ xfree(ind); xfree(val); /* write the bounds section */ flag = 0; for (j = 1; j <= ncols; j++) { col_name(lp, j, cname); lpx_get_col_bnds(lp, j, &typx, &lb, &ub); if (typx == LPX_LO && lb == 0.0) continue; if (!flag) { fprintf(fp, "\n"); fprintf(fp, "Bounds\n"); flag = 1; } switch (typx) { case LPX_FR: fprintf(fp, " %s free\n", cname); break; case LPX_LO: fprintf(fp, " %s >= %.*g\n", cname, DBL_DIG, lb); break; case LPX_UP: fprintf(fp, " %s <= %.*g\n", cname, DBL_DIG, ub); break; case LPX_DB: fprintf(fp, " %.*g <= %s <= %.*g\n", DBL_DIG, lb, cname, DBL_DIG, ub); break; case LPX_FX: fprintf(fp, " %s = %.*g\n", cname, DBL_DIG, lb); break; default: xassert(typx != typx); } } /* write the general section */ if (lpx_get_class(lp) == LPX_MIP) { flag = 0; for (j = 1; j <= ncols; j++) { kind = lpx_get_col_kind(lp, j); if (kind == LPX_CV) continue; xassert(kind == LPX_IV); if (!flag) { fprintf(fp, "\n"); fprintf(fp, "Generals\n"); flag = 1; } fprintf(fp, " %s\n", col_name(lp, j, cname)); } } /* write the end keyword */ fprintf(fp, "\n"); fprintf(fp, "End\n"); /* close the output text file */ fflush(fp); if (ferror(fp)) { print("lpx_write_cpxlp: write error on `%s' - %s", fname, strerror(errno)); goto fail; } xfclose(fp); /* return to the calling program */ return 0; fail: /* the operation failed */ if (fp != NULL) xfclose(fp); return 1; }
int lpx_print_prob(LPX *lp, const char *fname) { XFILE *fp; int m, n, mip, i, j, len, t, type, *ndx; double coef, lb, ub, *val; char *str, name[255+1]; xprintf("lpx_write_prob: writing problem data to `%s'...\n", fname); fp = xfopen(fname, "w"); if (fp == NULL) { xprintf("lpx_write_prob: unable to create `%s' - %s\n", fname, strerror(errno)); goto fail; } m = lpx_get_num_rows(lp); n = lpx_get_num_cols(lp); mip = (lpx_get_class(lp) == LPX_MIP); str = (void *)lpx_get_prob_name(lp); xfprintf(fp, "Problem: %s\n", str == NULL ? "(unnamed)" : str); xfprintf(fp, "Class: %s\n", !mip ? "LP" : "MIP"); xfprintf(fp, "Rows: %d\n", m); if (!mip) xfprintf(fp, "Columns: %d\n", n); else xfprintf(fp, "Columns: %d (%d integer, %d binary)\n", n, lpx_get_num_int(lp), lpx_get_num_bin(lp)); xfprintf(fp, "Non-zeros: %d\n", lpx_get_num_nz(lp)); xfprintf(fp, "\n"); xfprintf(fp, "*** OBJECTIVE FUNCTION ***\n"); xfprintf(fp, "\n"); switch (lpx_get_obj_dir(lp)) { case LPX_MIN: xfprintf(fp, "Minimize:"); break; case LPX_MAX: xfprintf(fp, "Maximize:"); break; default: xassert(lp != lp); } str = (void *)lpx_get_obj_name(lp); xfprintf(fp, " %s\n", str == NULL ? "(unnamed)" : str); coef = lpx_get_obj_coef(lp, 0); if (coef != 0.0) xfprintf(fp, "%*.*g %s\n", DBL_DIG+7, DBL_DIG, coef, "(constant term)"); for (i = 1; i <= m; i++) #if 0 { coef = lpx_get_row_coef(lp, i); #else { coef = 0.0; #endif if (coef != 0.0) xfprintf(fp, "%*.*g %s\n", DBL_DIG+7, DBL_DIG, coef, row_name(lp, i, name)); } for (j = 1; j <= n; j++) { coef = lpx_get_obj_coef(lp, j); if (coef != 0.0) xfprintf(fp, "%*.*g %s\n", DBL_DIG+7, DBL_DIG, coef, col_name(lp, j, name)); } xfprintf(fp, "\n"); xfprintf(fp, "*** ROWS (CONSTRAINTS) ***\n"); ndx = xcalloc(1+n, sizeof(int)); val = xcalloc(1+n, sizeof(double)); for (i = 1; i <= m; i++) { xfprintf(fp, "\n"); xfprintf(fp, "Row %d: %s", i, row_name(lp, i, name)); lpx_get_row_bnds(lp, i, &type, &lb, &ub); switch (type) { case LPX_FR: xfprintf(fp, " free"); break; case LPX_LO: xfprintf(fp, " >= %.*g", DBL_DIG, lb); break; case LPX_UP: xfprintf(fp, " <= %.*g", DBL_DIG, ub); break; case LPX_DB: xfprintf(fp, " >= %.*g <= %.*g", DBL_DIG, lb, DBL_DIG, ub); break; case LPX_FX: xfprintf(fp, " = %.*g", DBL_DIG, lb); break; default: xassert(type != type); } xfprintf(fp, "\n"); #if 0 coef = lpx_get_row_coef(lp, i); #else coef = 0.0; #endif if (coef != 0.0) xfprintf(fp, "%*.*g %s\n", DBL_DIG+7, DBL_DIG, coef, "(objective)"); len = lpx_get_mat_row(lp, i, ndx, val); for (t = 1; t <= len; t++) xfprintf(fp, "%*.*g %s\n", DBL_DIG+7, DBL_DIG, val[t], col_name(lp, ndx[t], name)); } xfree(ndx); xfree(val); xfprintf(fp, "\n"); xfprintf(fp, "*** COLUMNS (VARIABLES) ***\n"); ndx = xcalloc(1+m, sizeof(int)); val = xcalloc(1+m, sizeof(double)); for (j = 1; j <= n; j++) { xfprintf(fp, "\n"); xfprintf(fp, "Col %d: %s", j, col_name(lp, j, name)); if (mip) { switch (lpx_get_col_kind(lp, j)) { case LPX_CV: break; case LPX_IV: xfprintf(fp, " integer"); break; default: xassert(lp != lp); } } lpx_get_col_bnds(lp, j, &type, &lb, &ub); switch (type) { case LPX_FR: xfprintf(fp, " free"); break; case LPX_LO: xfprintf(fp, " >= %.*g", DBL_DIG, lb); break; case LPX_UP: xfprintf(fp, " <= %.*g", DBL_DIG, ub); break; case LPX_DB: xfprintf(fp, " >= %.*g <= %.*g", DBL_DIG, lb, DBL_DIG, ub); break; case LPX_FX: xfprintf(fp, " = %.*g", DBL_DIG, lb); break; default: xassert(type != type); } xfprintf(fp, "\n"); coef = lpx_get_obj_coef(lp, j); if (coef != 0.0) xfprintf(fp, "%*.*g %s\n", DBL_DIG+7, DBL_DIG, coef, "(objective)"); len = lpx_get_mat_col(lp, j, ndx, val); for (t = 1; t <= len; t++) xfprintf(fp, "%*.*g %s\n", DBL_DIG+7, DBL_DIG, val[t], row_name(lp, ndx[t], name)); } xfree(ndx); xfree(val); xfprintf(fp, "\n"); xfprintf(fp, "End of output\n"); xfflush(fp); if (xferror(fp)) { xprintf("lpx_write_prob: write error on `%s' - %s\n", fname, strerror(errno)); goto fail; } xfclose(fp); return 0; fail: if (fp != NULL) xfclose(fp); return 1; } #undef row_name #undef col_name /*---------------------------------------------------------------------- -- lpx_print_sol - write LP problem solution in printable format. -- -- *Synopsis* -- -- #include "glplpx.h" -- int lpx_print_sol(LPX *lp, char *fname); -- -- *Description* -- -- The routine lpx_print_sol writes the current basic solution of an LP -- problem, which is specified by the pointer lp, to a text file, whose -- name is the character string fname, in printable format. -- -- Information reported by the routine lpx_print_sol is intended mainly -- for visual analysis. -- -- *Returns* -- -- If the operation was successful, the routine returns zero. Otherwise -- the routine prints an error message and returns non-zero. */ int lpx_print_sol(LPX *lp, const char *fname) { XFILE *fp; int what, round; xprintf( "lpx_print_sol: writing LP problem solution to `%s'...\n", fname); fp = xfopen(fname, "w"); if (fp == NULL) { xprintf("lpx_print_sol: can't create `%s' - %s\n", fname, strerror(errno)); goto fail; } /* problem name */ { const char *name; name = lpx_get_prob_name(lp); if (name == NULL) name = ""; xfprintf(fp, "%-12s%s\n", "Problem:", name); } /* number of rows (auxiliary variables) */ { int nr; nr = lpx_get_num_rows(lp); xfprintf(fp, "%-12s%d\n", "Rows:", nr); } /* number of columns (structural variables) */ { int nc; nc = lpx_get_num_cols(lp); xfprintf(fp, "%-12s%d\n", "Columns:", nc); } /* number of non-zeros (constraint coefficients) */ { int nz; nz = lpx_get_num_nz(lp); xfprintf(fp, "%-12s%d\n", "Non-zeros:", nz); } /* solution status */ { int status; status = lpx_get_status(lp); xfprintf(fp, "%-12s%s\n", "Status:", status == LPX_OPT ? "OPTIMAL" : status == LPX_FEAS ? "FEASIBLE" : status == LPX_INFEAS ? "INFEASIBLE (INTERMEDIATE)" : status == LPX_NOFEAS ? "INFEASIBLE (FINAL)" : status == LPX_UNBND ? "UNBOUNDED" : status == LPX_UNDEF ? "UNDEFINED" : "???"); } /* objective function */ { char *name; int dir; double obj; name = (void *)lpx_get_obj_name(lp); dir = lpx_get_obj_dir(lp); obj = lpx_get_obj_val(lp); xfprintf(fp, "%-12s%s%s%.10g %s\n", "Objective:", name == NULL ? "" : name, name == NULL ? "" : " = ", obj, dir == LPX_MIN ? "(MINimum)" : dir == LPX_MAX ? "(MAXimum)" : "(" "???" ")"); } /* main sheet */ for (what = 1; what <= 2; what++) { int mn, ij; xfprintf(fp, "\n"); xfprintf(fp, " No. %-12s St Activity Lower bound Upp" "er bound Marginal\n", what == 1 ? " Row name" : "Column name"); xfprintf(fp, "------ ------------ -- ------------- -----------" "-- ------------- -------------\n"); mn = (what == 1 ? lpx_get_num_rows(lp) : lpx_get_num_cols(lp)); for (ij = 1; ij <= mn; ij++) { const char *name; int typx, tagx; double lb, ub, vx, dx; if (what == 1) { name = lpx_get_row_name(lp, ij); if (name == NULL) name = ""; lpx_get_row_bnds(lp, ij, &typx, &lb, &ub); round = lpx_get_int_parm(lp, LPX_K_ROUND); lpx_set_int_parm(lp, LPX_K_ROUND, 1); lpx_get_row_info(lp, ij, &tagx, &vx, &dx); lpx_set_int_parm(lp, LPX_K_ROUND, round); } else { name = lpx_get_col_name(lp, ij); if (name == NULL) name = ""; lpx_get_col_bnds(lp, ij, &typx, &lb, &ub); round = lpx_get_int_parm(lp, LPX_K_ROUND); lpx_set_int_parm(lp, LPX_K_ROUND, 1); lpx_get_col_info(lp, ij, &tagx, &vx, &dx); lpx_set_int_parm(lp, LPX_K_ROUND, round); } /* row/column ordinal number */ xfprintf(fp, "%6d ", ij); /* row column/name */ if (strlen(name) <= 12) xfprintf(fp, "%-12s ", name); else xfprintf(fp, "%s\n%20s", name, ""); /* row/column status */ xfprintf(fp, "%s ", tagx == LPX_BS ? "B " : tagx == LPX_NL ? "NL" : tagx == LPX_NU ? "NU" : tagx == LPX_NF ? "NF" : tagx == LPX_NS ? "NS" : "??"); /* row/column primal activity */ xfprintf(fp, "%13.6g ", vx); /* row/column lower bound */ if (typx == LPX_LO || typx == LPX_DB || typx == LPX_FX) xfprintf(fp, "%13.6g ", lb); else xfprintf(fp, "%13s ", ""); /* row/column upper bound */ if (typx == LPX_UP || typx == LPX_DB) xfprintf(fp, "%13.6g ", ub); else if (typx == LPX_FX) xfprintf(fp, "%13s ", "="); else xfprintf(fp, "%13s ", ""); /* row/column dual activity */ if (tagx != LPX_BS) { if (dx == 0.0) xfprintf(fp, "%13s", "< eps"); else xfprintf(fp, "%13.6g", dx); } /* end of line */ xfprintf(fp, "\n"); } } xfprintf(fp, "\n"); #if 1 if (lpx_get_prim_stat(lp) != LPX_P_UNDEF && lpx_get_dual_stat(lp) != LPX_D_UNDEF) { int m = lpx_get_num_rows(lp); LPXKKT kkt; xfprintf(fp, "Karush-Kuhn-Tucker optimality conditions:\n\n"); lpx_check_kkt(lp, 1, &kkt); xfprintf(fp, "KKT.PE: max.abs.err. = %.2e on row %d\n", kkt.pe_ae_max, kkt.pe_ae_row); xfprintf(fp, " max.rel.err. = %.2e on row %d\n", kkt.pe_re_max, kkt.pe_re_row); switch (kkt.pe_quality) { case 'H': xfprintf(fp, " High quality\n"); break; case 'M': xfprintf(fp, " Medium quality\n"); break; case 'L': xfprintf(fp, " Low quality\n"); break; default: xfprintf(fp, " PRIMAL SOLUTION IS WRONG\n"); break; } xfprintf(fp, "\n"); xfprintf(fp, "KKT.PB: max.abs.err. = %.2e on %s %d\n", kkt.pb_ae_max, kkt.pb_ae_ind <= m ? "row" : "column", kkt.pb_ae_ind <= m ? kkt.pb_ae_ind : kkt.pb_ae_ind - m); xfprintf(fp, " max.rel.err. = %.2e on %s %d\n", kkt.pb_re_max, kkt.pb_re_ind <= m ? "row" : "column", kkt.pb_re_ind <= m ? kkt.pb_re_ind : kkt.pb_re_ind - m); switch (kkt.pb_quality) { case 'H': xfprintf(fp, " High quality\n"); break; case 'M': xfprintf(fp, " Medium quality\n"); break; case 'L': xfprintf(fp, " Low quality\n"); break; default: xfprintf(fp, " PRIMAL SOLUTION IS INFEASIBLE\n"); break; } xfprintf(fp, "\n"); xfprintf(fp, "KKT.DE: max.abs.err. = %.2e on column %d\n", kkt.de_ae_max, kkt.de_ae_col); xfprintf(fp, " max.rel.err. = %.2e on column %d\n", kkt.de_re_max, kkt.de_re_col); switch (kkt.de_quality) { case 'H': xfprintf(fp, " High quality\n"); break; case 'M': xfprintf(fp, " Medium quality\n"); break; case 'L': xfprintf(fp, " Low quality\n"); break; default: xfprintf(fp, " DUAL SOLUTION IS WRONG\n"); break; } xfprintf(fp, "\n"); xfprintf(fp, "KKT.DB: max.abs.err. = %.2e on %s %d\n", kkt.db_ae_max, kkt.db_ae_ind <= m ? "row" : "column", kkt.db_ae_ind <= m ? kkt.db_ae_ind : kkt.db_ae_ind - m); xfprintf(fp, " max.rel.err. = %.2e on %s %d\n", kkt.db_re_max, kkt.db_re_ind <= m ? "row" : "column", kkt.db_re_ind <= m ? kkt.db_re_ind : kkt.db_re_ind - m); switch (kkt.db_quality) { case 'H': xfprintf(fp, " High quality\n"); break; case 'M': xfprintf(fp, " Medium quality\n"); break; case 'L': xfprintf(fp, " Low quality\n"); break; default: xfprintf(fp, " DUAL SOLUTION IS INFEASIBLE\n"); break; } xfprintf(fp, "\n"); } #endif #if 1 if (lpx_get_status(lp) == LPX_UNBND) { int m = lpx_get_num_rows(lp); int k = lpx_get_ray_info(lp); xfprintf(fp, "Unbounded ray: %s %d\n", k <= m ? "row" : "column", k <= m ? k : k - m); xfprintf(fp, "\n"); } #endif xfprintf(fp, "End of output\n"); xfflush(fp); if (xferror(fp)) { xprintf("lpx_print_sol: can't write to `%s' - %s\n", fname, strerror(errno)); goto fail; } xfclose(fp); return 0; fail: if (fp != NULL) xfclose(fp); return 1; }
int lpx_print_mip(LPX *lp, const char *fname) { XFILE *fp; int what, round; #if 0 if (lpx_get_class(lp) != LPX_MIP) fault("lpx_print_mip: error -- not a MIP problem"); #endif xprintf( "lpx_print_mip: writing MIP problem solution to `%s'...\n", fname); fp = xfopen(fname, "w"); if (fp == NULL) { xprintf("lpx_print_mip: can't create `%s' - %s\n", fname, strerror(errno)); goto fail; } /* problem name */ { const char *name; name = lpx_get_prob_name(lp); if (name == NULL) name = ""; xfprintf(fp, "%-12s%s\n", "Problem:", name); } /* number of rows (auxiliary variables) */ { int nr; nr = lpx_get_num_rows(lp); xfprintf(fp, "%-12s%d\n", "Rows:", nr); } /* number of columns (structural variables) */ { int nc, nc_int, nc_bin; nc = lpx_get_num_cols(lp); nc_int = lpx_get_num_int(lp); nc_bin = lpx_get_num_bin(lp); xfprintf(fp, "%-12s%d (%d integer, %d binary)\n", "Columns:", nc, nc_int, nc_bin); } /* number of non-zeros (constraint coefficients) */ { int nz; nz = lpx_get_num_nz(lp); xfprintf(fp, "%-12s%d\n", "Non-zeros:", nz); } /* solution status */ { int status; status = lpx_mip_status(lp); xfprintf(fp, "%-12s%s\n", "Status:", status == LPX_I_UNDEF ? "INTEGER UNDEFINED" : status == LPX_I_OPT ? "INTEGER OPTIMAL" : status == LPX_I_FEAS ? "INTEGER NON-OPTIMAL" : status == LPX_I_NOFEAS ? "INTEGER EMPTY" : "???"); } /* objective function */ { char *name; int dir; double mip_obj; name = (void *)lpx_get_obj_name(lp); dir = lpx_get_obj_dir(lp); mip_obj = lpx_mip_obj_val(lp); xfprintf(fp, "%-12s%s%s%.10g %s\n", "Objective:", name == NULL ? "" : name, name == NULL ? "" : " = ", mip_obj, dir == LPX_MIN ? "(MINimum)" : dir == LPX_MAX ? "(MAXimum)" : "(" "???" ")"); } /* main sheet */ for (what = 1; what <= 2; what++) { int mn, ij; xfprintf(fp, "\n"); xfprintf(fp, " No. %-12s Activity Lower bound Upp" "er bound\n", what == 1 ? " Row name" : "Column name"); xfprintf(fp, "------ ------------ ------------- -----------" "-- -------------\n"); mn = (what == 1 ? lpx_get_num_rows(lp) : lpx_get_num_cols(lp)); for (ij = 1; ij <= mn; ij++) { const char *name; int kind, typx; double lb, ub, vx; if (what == 1) { name = lpx_get_row_name(lp, ij); if (name == NULL) name = ""; kind = LPX_CV; lpx_get_row_bnds(lp, ij, &typx, &lb, &ub); round = lpx_get_int_parm(lp, LPX_K_ROUND); lpx_set_int_parm(lp, LPX_K_ROUND, 1); vx = lpx_mip_row_val(lp, ij); lpx_set_int_parm(lp, LPX_K_ROUND, round); } else { name = lpx_get_col_name(lp, ij); if (name == NULL) name = ""; kind = lpx_get_col_kind(lp, ij); lpx_get_col_bnds(lp, ij, &typx, &lb, &ub); round = lpx_get_int_parm(lp, LPX_K_ROUND); lpx_set_int_parm(lp, LPX_K_ROUND, 1); vx = lpx_mip_col_val(lp, ij); lpx_set_int_parm(lp, LPX_K_ROUND, round); } /* row/column ordinal number */ xfprintf(fp, "%6d ", ij); /* row column/name */ if (strlen(name) <= 12) xfprintf(fp, "%-12s ", name); else xfprintf(fp, "%s\n%20s", name, ""); /* row/column kind */ xfprintf(fp, "%s ", kind == LPX_CV ? " " : kind == LPX_IV ? "*" : "?"); /* row/column primal activity */ xfprintf(fp, "%13.6g", vx); /* row/column lower and upper bounds */ switch (typx) { case LPX_FR: break; case LPX_LO: xfprintf(fp, " %13.6g", lb); break; case LPX_UP: xfprintf(fp, " %13s %13.6g", "", ub); break; case LPX_DB: xfprintf(fp, " %13.6g %13.6g", lb, ub); break; case LPX_FX: xfprintf(fp, " %13.6g %13s", lb, "="); break; default: xassert(typx != typx); } /* end of line */ xfprintf(fp, "\n"); } } xfprintf(fp, "\n"); #if 1 if (lpx_mip_status(lp) != LPX_I_UNDEF) { int m = lpx_get_num_rows(lp); LPXKKT kkt; xfprintf(fp, "Integer feasibility conditions:\n\n"); lpx_check_int(lp, &kkt); xfprintf(fp, "INT.PE: max.abs.err. = %.2e on row %d\n", kkt.pe_ae_max, kkt.pe_ae_row); xfprintf(fp, " max.rel.err. = %.2e on row %d\n", kkt.pe_re_max, kkt.pe_re_row); switch (kkt.pe_quality) { case 'H': xfprintf(fp, " High quality\n"); break; case 'M': xfprintf(fp, " Medium quality\n"); break; case 'L': xfprintf(fp, " Low quality\n"); break; default: xfprintf(fp, " SOLUTION IS WRONG\n"); break; } xfprintf(fp, "\n"); xfprintf(fp, "INT.PB: max.abs.err. = %.2e on %s %d\n", kkt.pb_ae_max, kkt.pb_ae_ind <= m ? "row" : "column", kkt.pb_ae_ind <= m ? kkt.pb_ae_ind : kkt.pb_ae_ind - m); xfprintf(fp, " max.rel.err. = %.2e on %s %d\n", kkt.pb_re_max, kkt.pb_re_ind <= m ? "row" : "column", kkt.pb_re_ind <= m ? kkt.pb_re_ind : kkt.pb_re_ind - m); switch (kkt.pb_quality) { case 'H': xfprintf(fp, " High quality\n"); break; case 'M': xfprintf(fp, " Medium quality\n"); break; case 'L': xfprintf(fp, " Low quality\n"); break; default: xfprintf(fp, " SOLUTION IS INFEASIBLE\n"); break; } xfprintf(fp, "\n"); } #endif xfprintf(fp, "End of output\n"); xfflush(fp); if (xferror(fp)) { xprintf("lpx_print_mip: can't write to `%s' - %s\n", fname, strerror(errno)); goto fail; } xfclose(fp); return 0; fail: if (fp != NULL) xfclose(fp); return 1; }
int lpx_integer(LPX *mip) { int m = lpx_get_num_rows(mip); int n = lpx_get_num_cols(mip); MIPTREE *tree; LPX *lp; int ret, i, j, stat, type, len, *ind; double lb, ub, coef, *val; #if 0 /* the problem must be of MIP class */ if (lpx_get_class(mip) != LPX_MIP) { print("lpx_integer: problem is not of MIP class"); ret = LPX_E_FAULT; goto done; } #endif /* an optimal solution of LP relaxation must be known */ if (lpx_get_status(mip) != LPX_OPT) { print("lpx_integer: optimal solution of LP relaxation required" ); ret = LPX_E_FAULT; goto done; } /* bounds of all integer variables must be integral */ for (j = 1; j <= n; j++) { if (lpx_get_col_kind(mip, j) != LPX_IV) continue; type = lpx_get_col_type(mip, j); if (type == LPX_LO || type == LPX_DB || type == LPX_FX) { lb = lpx_get_col_lb(mip, j); if (lb != floor(lb)) { print("lpx_integer: integer column %d has non-integer lo" "wer bound or fixed value %g", j, lb); ret = LPX_E_FAULT; goto done; } } if (type == LPX_UP || type == LPX_DB) { ub = lpx_get_col_ub(mip, j); if (ub != floor(ub)) { print("lpx_integer: integer column %d has non-integer up" "per bound %g", j, ub); ret = LPX_E_FAULT; goto done; } } } /* it seems all is ok */ if (lpx_get_int_parm(mip, LPX_K_MSGLEV) >= 2) print("Integer optimization begins..."); /* create the branch-and-bound tree */ tree = mip_create_tree(m, n, lpx_get_obj_dir(mip)); /* set up column kinds */ for (j = 1; j <= n; j++) tree->int_col[j] = (lpx_get_col_kind(mip, j) == LPX_IV); /* access the LP relaxation template */ lp = tree->lp; /* set up the objective function */ tree->int_obj = 1; for (j = 0; j <= tree->n; j++) { coef = lpx_get_obj_coef(mip, j); lpx_set_obj_coef(lp, j, coef); if (coef != 0.0 && !(tree->int_col[j] && coef == floor(coef))) tree->int_obj = 0; } if (lpx_get_int_parm(mip, LPX_K_MSGLEV) >= 2 && tree->int_obj) print("Objective function is integral"); /* set up the constraint matrix */ ind = xcalloc(1+n, sizeof(int)); val = xcalloc(1+n, sizeof(double)); for (i = 1; i <= m; i++) { len = lpx_get_mat_row(mip, i, ind, val); lpx_set_mat_row(lp, i, len, ind, val); } xfree(ind); xfree(val); /* set up scaling matrices */ for (i = 1; i <= m; i++) lpx_set_rii(lp, i, lpx_get_rii(mip, i)); for (j = 1; j <= n; j++) lpx_set_sjj(lp, j, lpx_get_sjj(mip, j)); /* revive the root subproblem */ mip_revive_node(tree, 1); /* set up row attributes for the root subproblem */ for (i = 1; i <= m; i++) { type = lpx_get_row_type(mip, i); lb = lpx_get_row_lb(mip, i); ub = lpx_get_row_ub(mip, i); stat = lpx_get_row_stat(mip, i); lpx_set_row_bnds(lp, i, type, lb, ub); lpx_set_row_stat(lp, i, stat); } /* set up column attributes for the root subproblem */ for (j = 1; j <= n; j++) { type = lpx_get_col_type(mip, j); lb = lpx_get_col_lb(mip, j); ub = lpx_get_col_ub(mip, j); stat = lpx_get_col_stat(mip, j); lpx_set_col_bnds(lp, j, type, lb, ub); lpx_set_col_stat(lp, j, stat); } /* freeze the root subproblem */ mip_freeze_node(tree); /* inherit some control parameters and statistics */ tree->msg_lev = lpx_get_int_parm(mip, LPX_K_MSGLEV); if (tree->msg_lev > 2) tree->msg_lev = 2; tree->branch = lpx_get_int_parm(mip, LPX_K_BRANCH); tree->btrack = lpx_get_int_parm(mip, LPX_K_BTRACK); tree->tol_int = lpx_get_real_parm(mip, LPX_K_TOLINT); tree->tol_obj = lpx_get_real_parm(mip, LPX_K_TOLOBJ); tree->tm_lim = lpx_get_real_parm(mip, LPX_K_TMLIM); lpx_set_int_parm(lp, LPX_K_BFTYPE, lpx_get_int_parm(mip, LPX_K_BFTYPE)); lpx_set_int_parm(lp, LPX_K_PRICE, lpx_get_int_parm(mip, LPX_K_PRICE)); lpx_set_real_parm(lp, LPX_K_RELAX, lpx_get_real_parm(mip, LPX_K_RELAX)); lpx_set_real_parm(lp, LPX_K_TOLBND, lpx_get_real_parm(mip, LPX_K_TOLBND)); lpx_set_real_parm(lp, LPX_K_TOLDJ, lpx_get_real_parm(mip, LPX_K_TOLDJ)); lpx_set_real_parm(lp, LPX_K_TOLPIV, lpx_get_real_parm(mip, LPX_K_TOLPIV)); lpx_set_int_parm(lp, LPX_K_ITLIM, lpx_get_int_parm(mip, LPX_K_ITLIM)); lpx_set_int_parm(lp, LPX_K_ITCNT, lpx_get_int_parm(mip, LPX_K_ITCNT)); /* reset the status of MIP solution */ lpx_put_mip_soln(mip, LPX_I_UNDEF, NULL, NULL); /* try solving the problem */ ret = mip_driver(tree); /* if an integer feasible solution has been found, copy it to the MIP problem object */ if (tree->found) lpx_put_mip_soln(mip, LPX_I_FEAS, &tree->mipx[0], &tree->mipx[m]); /* copy back statistics about spent resources */ lpx_set_real_parm(mip, LPX_K_TMLIM, tree->tm_lim); lpx_set_int_parm(mip, LPX_K_ITLIM, lpx_get_int_parm(lp, LPX_K_ITLIM)); lpx_set_int_parm(mip, LPX_K_ITCNT, lpx_get_int_parm(lp, LPX_K_ITCNT)); /* analyze exit code reported by the mip driver */ switch (ret) { case MIP_E_OK: if (tree->found) { if (lpx_get_int_parm(mip, LPX_K_MSGLEV) >= 3) print("INTEGER OPTIMAL SOLUTION FOUND"); lpx_put_mip_soln(mip, LPX_I_OPT, NULL, NULL); } else { if (lpx_get_int_parm(mip, LPX_K_MSGLEV) >= 3) print("PROBLEM HAS NO INTEGER FEASIBLE SOLUTION"); lpx_put_mip_soln(mip, LPX_I_NOFEAS, NULL, NULL); } ret = LPX_E_OK; break; case MIP_E_ITLIM: if (lpx_get_int_parm(mip, LPX_K_MSGLEV) >= 3) print("ITERATIONS LIMIT EXCEEDED; SEARCH TERMINATED"); ret = LPX_E_ITLIM; break; case MIP_E_TMLIM: if (lpx_get_int_parm(mip, LPX_K_MSGLEV) >= 3) print("TIME LIMIT EXCEEDED; SEARCH TERMINATED"); ret = LPX_E_TMLIM; break; case MIP_E_ERROR: if (lpx_get_int_parm(mip, LPX_K_MSGLEV) >= 1) print("lpx_integer: cannot solve current LP relaxation"); ret = LPX_E_SING; break; default: xassert(ret != ret); } /* delete the branch-and-bound tree */ mip_delete_tree(tree); done: /* return to the application program */ return ret; }
void ipp_load_orig(IPP *ipp, LPX *orig) { IPPROW **row; IPPCOL *col; int i, j, k, type, len, *ind; double lb, ub, *val; /* save some information about the original problem */ ipp->orig_m = lpx_get_num_rows(orig); ipp->orig_n = lpx_get_num_cols(orig); ipp->orig_nnz = lpx_get_num_nz(orig); ipp->orig_dir = lpx_get_obj_dir(orig); /* allocate working arrays */ row = xcalloc(1+ipp->orig_m, sizeof(IPPROW *)); ind = xcalloc(1+ipp->orig_m, sizeof(int)); val = xcalloc(1+ipp->orig_m, sizeof(double)); /* copy rows of the original problem into the workspace */ for (i = 1; i <= ipp->orig_m; i++) { type = lpx_get_row_type(orig, i); if (type == LPX_FR || type == LPX_UP) lb = -DBL_MAX; else lb = lpx_get_row_lb(orig, i); if (type == LPX_FR || type == LPX_LO) ub = +DBL_MAX; else ub = lpx_get_row_ub(orig, i); row[i] = ipp_add_row(ipp, lb, ub); } /* copy columns of the original problem into the workspace; each column created in the workspace is assigned a reference number which is its ordinal number in the original problem */ for (j = 1; j <= ipp->orig_n; j++) { type = lpx_get_col_type(orig, j); if (type == LPX_FR || type == LPX_UP) lb = -DBL_MAX; else lb = lpx_get_col_lb(orig, j); if (type == LPX_FR || type == LPX_LO) ub = +DBL_MAX; else ub = lpx_get_col_ub(orig, j); col = ipp_add_col(ipp, lpx_get_col_kind(orig, j) == LPX_IV, lb, ub, lpx_get_obj_coef(orig, j)); len = lpx_get_mat_col(orig, j, ind, val); for (k = 1; k <= len; k++) ipp_add_aij(ipp, row[ind[k]], col, val[k]); } /* copy the constant term of the original objective function */ ipp->c0 = lpx_get_obj_coef(orig, 0); /* if the original problem is maximization, change the sign of the objective function, because the transformed problem to be processed by the presolver must be minimization */ if (ipp->orig_dir == LPX_MAX) { for (col = ipp->col_ptr; col != NULL; col = col->next) col->c = - col->c; ipp->c0 = - ipp->c0; } /* free working arrays */ xfree(row); xfree(ind); xfree(val); return; }
int lpx_gomory_cut(LPX *lp, int len, int ind[], double val[], double work[]) { int m = lpx_get_num_rows(lp); int n = lpx_get_num_cols(lp); int k, t, stat; double lb, ub, *alfa, beta, alfa_j, f0, fj, *a, b, a_j; /* on entry the specified row of the simplex table has the form: y = alfa[1]*xN[1] + ... + alfa[n]*xN[n]; convert this row to the form: y + alfa'[1]*xN'[1] + ... + alfa'[n]*xN'[n] = beta, where all new (stroked) non-basic variables are non-negative (this is not needed for y, because it has integer bounds and only fractional part of beta is used); note that beta is the value of y in the current basic solution */ alfa = val; beta = 0.0; for (t = 1; t <= len; t++) { /* get index of some non-basic variable x[k] = xN[j] */ k = ind[t]; if (!(1 <= k && k <= m+n)) fault("lpx_gomory_cut: ind[%d] = %d; variable number out of" " range", t, k); /* get the original influence coefficient alfa[j] */ alfa_j = alfa[t]; /* obtain status and bounds of x[k] = xN[j] */ if (k <= m) { stat = lpx_get_row_stat(lp, k); lb = lpx_get_row_lb(lp, k); ub = lpx_get_row_ub(lp, k); } else { stat = lpx_get_col_stat(lp, k-m); lb = lpx_get_col_lb(lp, k-m); ub = lpx_get_col_ub(lp, k-m); } /* perform conversion */ if (stat == LPX_BS) fault("lpx_gomory_cut: ind[%d] = %d; variable must be non-b" "asic", t, k); switch (stat) { case LPX_NL: /* xN[j] is on its lower bound */ /* substitute xN[j] = lb[k] + xN'[j] */ alfa[t] = - alfa_j; beta += alfa_j * lb; break; case LPX_NU: /* xN[j] is on its upper bound */ /* substitute xN[j] = ub[k] - xN'[j] */ alfa[t] = + alfa_j; beta += alfa_j * ub; break; case LPX_NF: /* xN[j] is free non-basic variable */ return -1; case LPX_NS: /* xN[j] is fixed non-basic variable */ /* substitute xN[j] = lb[k] */ alfa[t] = 0.0; beta += alfa_j * lb; break; default: insist(stat != stat); } } /* now the converted row of the simplex table has the form: y + alfa'[1]*xN'[1] + ... + alfa'[n]*xN'[n] = beta, where all xN'[j] >= 0; generate Gomory's mixed integer cut in the form of inequality: a'[1]*xN'[1] + ... + a'[n]*xN'[n] >= b' */ a = val; /* f0 is fractional part of beta, where beta is the value of the variable y in the current basic solution; if f0 is close to zero or to one, i.e. if y is near to a closest integer point, the corresponding cutting plane may be unreliable */ f0 = beta - floor(beta); if (!(0.00001 <= f0 && f0 <= 0.99999)) return -2; for (t = 1; t <= len; t++) { alfa_j = alfa[t]; if (alfa_j == 0.0) { a[t] = 0.0; continue; } k = ind[t]; insist(1 <= k && k <= m+n); if (k > m && lpx_get_col_kind(lp, k-m) == LPX_IV) { /* xN[j] is integer */ fj = alfa_j - floor(alfa_j); if (fj <= f0) a[t] = fj; else a[t] = (f0 / (1.0 - f0)) * (1.0 - fj); } else { /* xN[j] is continuous */ if (alfa_j > 0.0) a[t] = alfa_j; else a[t] = - (f0 / (1.0 - f0)) * alfa_j; } } b = f0; /* now the generated cutting plane has the form of an inequality: a'[1]*xN'[1] + ... + a'[n]*xN'[n] >= b'; convert this inequality back to the form expressed through the original non-basic variables: a[1]*xN[1] + ... + a[n]*xN[n] >= b */ for (t = 1; t <= len; t++) { a_j = a[t]; if (a_j == 0.0) continue; k = ind[t]; /* x[k] = xN[j] */ /* obtain status and bounds of x[k] = xN[j] */ if (k <= m) { stat = lpx_get_row_stat(lp, k); lb = lpx_get_row_lb(lp, k); ub = lpx_get_row_ub(lp, k); } else { stat = lpx_get_col_stat(lp, k-m); lb = lpx_get_col_lb(lp, k-m); ub = lpx_get_col_ub(lp, k-m); } /* perform conversion */ switch (stat) { case LPX_NL: /* xN[j] is on its lower bound */ /* substitute xN'[j] = xN[j] - lb[k] */ val[t] = + a_j; b += a_j * lb; break; case LPX_NU: /* xN[j] is on its upper bound */ /* substitute xN'[j] = ub[k] - xN[j] */ val[t] = - a_j; b -= a_j * ub; break; default: insist(stat != stat); } } /* substitute auxiliary (non-basic) variables to the generated inequality constraint a[1]*xN[1] + ... + a[n]*xN[n] >= b using the equality constraints of the specified LP problem object in order to express the generated constraint through structural variables only */ len = lpx_reduce_form(lp, len, ind, val, work); /* store the right-hand side */ ind[0] = 0, val[0] = b; /* return to the calling program */ return len; }
double lpx_eval_degrad(LPX *lp, int len, int ind[], double val[], int type, double rhs) { int m = lpx_get_num_rows(lp); int n = lpx_get_num_cols(lp); int dir = lpx_get_obj_dir(lp); int q, k; double y, delta; if (lpx_get_dual_stat(lp) != LPX_D_FEAS) fault("lpx_eval_degrad: LP basis is not dual feasible"); if (!(0 <= len && len <= n)) fault("lpx_eval_degrad: len = %d; invalid row length", len); if (!(type == LPX_LO || type == LPX_UP)) fault("lpx_eval_degrad: type = %d; invalid row type", type); /* compute value of the row auxiliary variable */ y = lpx_eval_row(lp, len, ind, val); /* the inequalitiy constraint is assumed to be violated */ if (!(type == LPX_LO && y < rhs || type == LPX_UP && y > rhs)) fault("lpx_eval_degrad: y = %g, rhs = %g; constraint is not vi" "olated", y, rhs); /* transform the row in order to express y through only non-basic variables: y = alfa[1] * xN[1] + ... + alfa[n] * xN[n] */ len = lpx_transform_row(lp, len, ind, val); /* in the adjacent basis y would become non-basic, so in case of '>=' it increases and in case of '<=' it decreases; determine which non-basic variable x[q], 1 <= q <= m+n, should leave the basis to keep dual feasibility */ q = lpx_dual_ratio_test(lp, len, ind, val, type == LPX_LO ? +1 : -1, 1e-7); /* q = 0 means no adjacent dual feasible basis exist */ if (q == 0) return dir == LPX_MIN ? +DBL_MAX : -DBL_MAX; /* find the entry corresponding to x[q] in the list */ for (k = 1; k <= len; k++) if (ind[k] == q) break; insist(k <= len); /* dy = alfa[q] * dx[q], so dx[q] = dy / alfa[q], where dy is a change in y, dx[q] is a change in x[q] */ delta = (rhs - y) / val[k]; #if 0 /* Tomlin noticed that if the variable x[q] is of integer kind, its change cannot be less than one in the magnitude */ if (q > m && lpx_get_col_kind(lp, q-m) == LPX_IV) { /* x[q] is structural integer variable */ if (fabs(delta - floor(delta + 0.5)) > 1e-3) { if (delta > 0.0) delta = ceil(delta); /* +3.14 -> +4 */ else delta = floor(delta); /* -3.14 -> -4 */ } } #endif /* dz = lambda[q] * dx[q], where dz is a change in the objective function, lambda[q] is a reduced cost of x[q] */ if (q <= m) delta *= lpx_get_row_dual(lp, q); else delta *= lpx_get_col_dual(lp, q-m); /* delta must be >= 0 (in case of minimization) or <= 0 (in case of minimization); however, due to round-off errors and finite tolerance used to choose x[q], this condition can be slightly violated */ switch (dir) { case LPX_MIN: if (delta < 0.0) delta = 0.0; break; case LPX_MAX: if (delta > 0.0) delta = 0.0; break; default: insist(dir != dir); } return delta; }
static void gen_gomory_cut(LPX *prob, int maxlen) { int m = lpx_get_num_rows(prob); int n = lpx_get_num_cols(prob); int i, j, k, len, cut_j, *ind; double x, d, r, temp, cut_d, cut_r, *val, *work; insist(lpx_get_status(prob) == LPX_OPT); /* allocate working arrays */ ind = ucalloc(1+n, sizeof(int)); val = ucalloc(1+n, sizeof(double)); work = ucalloc(1+m+n, sizeof(double)); /* nothing is chosen so far */ cut_j = 0; cut_d = 0.0; cut_r = 0.0; /* look through all structural variables */ for (j = 1; j <= n; j++) { /* if the variable is continuous, skip it */ if (lpx_get_col_kind(prob, j) != LPX_IV) continue; /* if the variable is non-basic, skip it */ if (lpx_get_col_stat(prob, j) != LPX_BS) continue; /* if the variable is fixed, skip it */ if (lpx_get_col_type(prob, j) == LPX_FX) continue; /* obtain current primal value of the variable */ x = lpx_get_col_prim(prob, j); /* if the value is close enough to nearest integer, skip the variable */ if (fabs(x - floor(x + 0.5)) < 1e-4) continue; /* compute the row of the simplex table corresponding to the variable */ len = lpx_eval_tab_row(prob, m+j, ind, val); len = lpx_remove_tiny(len, ind, NULL, val, 1e-10); /* generate Gomory's mixed integer cut: a[1]*x[1] + ... + a[n]*x[n] >= b */ len = lpx_gomory_cut(prob, len, ind, val, work); if (len < 0) continue; insist(0 <= len && len <= n); len = lpx_remove_tiny(len, ind, NULL, val, 1e-10); if (fabs(val[0]) < 1e-10) val[0] = 0.0; /* if the cut is too long, skip it */ if (len > maxlen) continue; /* if the cut contains coefficients with too large magnitude, do not use it to prevent numeric instability */ for (k = 0; k <= len; k++) /* including rhs */ if (fabs(val[k]) > 1e+6) break; if (k <= len) continue; /* at the current point the cut inequality is violated, i.e. the residual b - (a[1]*x[1] + ... + a[n]*x[n]) > 0; note that for Gomory's cut the residual is less than 1.0 */ /* in order not to depend on the magnitude of coefficients we use scaled residual: r = [b - (a[1]*x[1] + ... + a[n]*x[n])] / max(1, |a[j]|) */ temp = 1.0; for (k = 1; k <= len; k++) if (temp < fabs(val[k])) temp = fabs(val[k]); r = (val[0] - lpx_eval_row(prob, len, ind, val)) / temp; if (r < 1e-5) continue; /* estimate degradation (worsening) of the objective function by one dual simplex step if the cut row would be introduced in the problem */ d = lpx_eval_degrad(prob, len, ind, val, LPX_LO, val[0]); /* ignore the sign of degradation */ d = fabs(d); /* which cut should be used? there are two basic cases: 1) if the degradation is non-zero, we are interested in a cut providing maximal degradation; 2) if the degradation is zero (i.e. a non-basic variable which would enter the basis in the adjacent vertex has zero reduced cost), we are interested in a cut providing maximal scaled residual; in both cases it is desired that the cut length (the number of inequality coefficients) is possibly short */ /* if both degradation and scaled residual are small, skip the cut */ if (d < 0.001 && r < 0.001) continue; /* if there is no cut chosen, choose this cut */ else if (cut_j == 0) ; /* if this cut provides stronger degradation and has shorter length, choose it */ else if (cut_d != 0.0 && cut_d < d) ; /* if this cut provides larger scaled residual and has shorter length, choose it */ else if (cut_d == 0.0 && cut_r < r) ; /* otherwise skip the cut */ else continue; /* save attributes of the cut choosen */ cut_j = j, cut_r = r, cut_d = d; } /* if a cut has been chosen, include it to the problem */ if (cut_j != 0) { j = cut_j; /* compute the row of the simplex table */ len = lpx_eval_tab_row(prob, m+j, ind, val); len = lpx_remove_tiny(len, ind, NULL, val, 1e-10); /* generate the cut */ len = lpx_gomory_cut(prob, len, ind, val, work); insist(0 <= len && len <= n); len = lpx_remove_tiny(len, ind, NULL, val, 1e-10); if (fabs(val[0]) < 1e-10) val[0] = 0.0; /* include the corresponding row in the problem */ i = lpx_add_rows(prob, 1); lpx_set_row_bnds(prob, i, LPX_LO, val[0], 0.0); lpx_set_mat_row(prob, i, len, ind, val); } /* free working arrays */ ufree(ind); ufree(val); ufree(work); return; }
int lpx_intopt(LPX *_mip) { IPP *ipp = NULL; LPX *orig = _mip, *prob = NULL; int orig_m, orig_n, i, j, ret, i_stat; /* the problem must be of MIP class */ if (lpx_get_class(orig) != LPX_MIP) { print("lpx_intopt: problem is not of MIP class"); ret = LPX_E_FAULT; goto done; } /* the problem must have at least one row and one column */ orig_m = lpx_get_num_rows(orig); orig_n = lpx_get_num_cols(orig); if (!(orig_m > 0 && orig_n > 0)) { print("lpx_intopt: problem has no rows/columns"); ret = LPX_E_FAULT; goto done; } /* check that each double-bounded row and column has bounds */ for (i = 1; i <= orig_m; i++) { if (lpx_get_row_type(orig, i) == LPX_DB) { if (lpx_get_row_lb(orig, i) >= lpx_get_row_ub(orig, i)) { print("lpx_intopt: row %d has incorrect bounds", i); ret = LPX_E_FAULT; goto done; } } } for (j = 1; j <= orig_n; j++) { if (lpx_get_col_type(orig, j) == LPX_DB) { if (lpx_get_col_lb(orig, j) >= lpx_get_col_ub(orig, j)) { print("lpx_intopt: column %d has incorrect bounds", j); ret = LPX_E_FAULT; goto done; } } } /* bounds of all integer variables must be integral */ for (j = 1; j <= orig_n; j++) { int type; double lb, ub; if (lpx_get_col_kind(orig, j) != LPX_IV) continue; type = lpx_get_col_type(orig, j); if (type == LPX_LO || type == LPX_DB || type == LPX_FX) { lb = lpx_get_col_lb(orig, j); if (lb != floor(lb)) { print("lpx_intopt: integer column %d has non-integer low" "er bound or fixed value %g", j, lb); ret = LPX_E_FAULT; goto done; } } if (type == LPX_UP || type == LPX_DB) { ub = lpx_get_col_ub(orig, j); if (ub != floor(ub)) { print("lpx_intopt: integer column %d has non-integer upp" "er bound %g", j, ub); ret = LPX_E_FAULT; goto done; } } } /* reset the status of MIP solution */ lpx_put_mip_soln(orig, LPX_I_UNDEF, NULL, NULL); /* create MIP presolver workspace */ ipp = ipp_create_wksp(); /* load the original problem into the presolver workspace */ ipp_load_orig(ipp, orig); /* perform basic MIP presolve analysis */ switch (ipp_basic_tech(ipp)) { case 0: /* no infeasibility is detected */ break; case 1: nopfs: /* primal infeasibility is detected */ print("PROBLEM HAS NO PRIMAL FEASIBLE SOLUTION"); ret = LPX_E_NOPFS; goto done; case 2: /* dual infeasibility is detected */ nodfs: print("LP RELAXATION HAS NO DUAL FEASIBLE SOLUTION"); ret = LPX_E_NODFS; goto done; default: insist(ipp != ipp); } /* reduce column bounds */ switch (ipp_reduce_bnds(ipp)) { case 0: break; case 1: goto nopfs; default: insist(ipp != ipp); } /* perform basic MIP presolve analysis */ switch (ipp_basic_tech(ipp)) { case 0: break; case 1: goto nopfs; case 2: goto nodfs; default: insist(ipp != ipp); } /* replace general integer variables by sum of binary variables, if required */ if (lpx_get_int_parm(orig, LPX_K_BINARIZE)) ipp_binarize(ipp); /* perform coefficient reduction */ ipp_reduction(ipp); /* if the resultant problem is empty, it has an empty solution, which is optimal */ if (ipp->row_ptr == NULL || ipp->col_ptr == NULL) { insist(ipp->row_ptr == NULL); insist(ipp->col_ptr == NULL); print("Objective value = %.10g", ipp->orig_dir == LPX_MIN ? +ipp->c0 : -ipp->c0); print("INTEGER OPTIMAL SOLUTION FOUND BY MIP PRESOLVER"); /* allocate recovered solution segment */ ipp->col_stat = ucalloc(1+ipp->ncols, sizeof(int)); ipp->col_mipx = ucalloc(1+ipp->ncols, sizeof(double)); for (j = 1; j <= ipp->ncols; j++) ipp->col_stat[j] = 0; /* perform MIP postsolve processing */ ipp_postsolve(ipp); /* unload recovered MIP solution and store it in the original problem object */ ipp_unload_sol(ipp, orig, LPX_I_OPT); ret = LPX_E_OK; goto done; } /* build resultant MIP problem object */ prob = ipp_build_prob(ipp); /* display some statistics */ { int m = lpx_get_num_rows(prob); int n = lpx_get_num_cols(prob); int nnz = lpx_get_num_nz(prob); int ni = lpx_get_num_int(prob); int nb = lpx_get_num_bin(prob); char s[50]; print("lpx_intopt: presolved MIP has %d row%s, %d column%s, %d" " non-zero%s", m, m == 1 ? "" : "s", n, n == 1 ? "" : "s", nnz, 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); print("lpx_intopt: %d integer column%s, %s which %s binary", ni, ni == 1 ? "" : "s", s, nb == 1 ? "is" : "are"); } /* inherit some control parameters and statistics */ lpx_set_int_parm(prob, LPX_K_PRICE, lpx_get_int_parm(orig, LPX_K_PRICE)); lpx_set_real_parm(prob, LPX_K_RELAX, lpx_get_real_parm(orig, LPX_K_RELAX)); lpx_set_real_parm(prob, LPX_K_TOLBND, lpx_get_real_parm(orig, LPX_K_TOLBND)); lpx_set_real_parm(prob, LPX_K_TOLDJ, lpx_get_real_parm(orig, LPX_K_TOLDJ)); lpx_set_real_parm(prob, LPX_K_TOLPIV, lpx_get_real_parm(orig, LPX_K_TOLPIV)); lpx_set_int_parm(prob, LPX_K_ITLIM, lpx_get_int_parm(orig, LPX_K_ITLIM)); lpx_set_int_parm(prob, LPX_K_ITCNT, lpx_get_int_parm(orig, LPX_K_ITCNT)); lpx_set_real_parm(prob, LPX_K_TMLIM, lpx_get_real_parm(orig, LPX_K_TMLIM)); lpx_set_int_parm(prob, LPX_K_BRANCH, lpx_get_int_parm(orig, LPX_K_BRANCH)); lpx_set_int_parm(prob, LPX_K_BTRACK, lpx_get_int_parm(orig, LPX_K_BTRACK)); lpx_set_real_parm(prob, LPX_K_TOLINT, lpx_get_real_parm(orig, LPX_K_TOLINT)); lpx_set_real_parm(prob, LPX_K_TOLOBJ, lpx_get_real_parm(orig, LPX_K_TOLOBJ)); /* build an advanced initial basis */ lpx_adv_basis(prob); /* solve LP relaxation */ print("Solving LP relaxation..."); switch (lpx_simplex(prob)) { case LPX_E_OK: break; case LPX_E_ITLIM: ret = LPX_E_ITLIM; goto done; case LPX_E_TMLIM: ret = LPX_E_TMLIM; goto done; default: print("lpx_intopt: cannot solve LP relaxation"); ret = LPX_E_SING; goto done; } /* analyze status of the basic solution */ switch (lpx_get_status(prob)) { case LPX_OPT: break; case LPX_NOFEAS: ret = LPX_E_NOPFS; goto done; case LPX_UNBND: ret = LPX_E_NODFS; goto done; default: insist(prob != prob); } /* generate cutting planes, if necessary */ if (lpx_get_int_parm(orig, LPX_K_USECUTS)) { ret = generate_cuts(prob); if (ret != LPX_E_OK) goto done; } /* call the branch-and-bound solver */ ret = lpx_integer(prob); /* determine status of MIP solution */ i_stat = lpx_mip_status(prob); if (i_stat == LPX_I_OPT || i_stat == LPX_I_FEAS) { /* load MIP solution of the resultant problem into presolver workspace */ ipp_load_sol(ipp, prob); /* perform MIP postsolve processing */ ipp_postsolve(ipp); /* unload recovered MIP solution and store it in the original problem object */ ipp_unload_sol(ipp, orig, i_stat); } else { /* just set the status of MIP solution */ lpx_put_mip_soln(orig, i_stat, NULL, NULL); } done: /* copy back statistics about spent resources */ if (prob != NULL) { lpx_set_int_parm(orig, LPX_K_ITLIM, lpx_get_int_parm(prob, LPX_K_ITLIM)); lpx_set_int_parm(orig, LPX_K_ITCNT, lpx_get_int_parm(prob, LPX_K_ITCNT)); lpx_set_real_parm(orig, LPX_K_TMLIM, lpx_get_real_parm(prob, LPX_K_TMLIM)); } /* delete the resultant problem object */ if (prob != NULL) lpx_delete_prob(prob); /* delete MIP presolver workspace */ if (ipp != NULL) ipp_delete_wksp(ipp); return ret; }