void CClp_freelp(CClp **lp)
{ /* FREES the LP loaded in CClp_loadlp (or CClp_create), but does
not free the data allocated by CClp_init. */
if ((*lp) != NULL && (*lp)->lp != NULL)
lpx_delete_prob((*lp)->lp), (*lp)->lp = NULL;
return;
}
LPX *lpx_read_freemps(const char *fname)
{ /* read problem data in free MPS format */
LPX *lp = lpx_create_prob();
if (glp_read_mps(lp, GLP_MPS_FILE, NULL, fname))
lpx_delete_prob(lp), lp = NULL;
return lp;
}
LPX *lpx_read_cpxlp(const char *fname)
{ /* read problem data in CPLEX LP format */
LPX *lp;
lp = lpx_create_prob();
if (glp_read_lp(lp, NULL, fname))
lpx_delete_prob(lp), lp = NULL;
return lp;
}
int GLPKClearSolver() {
if (GLPKModel != NULL) {
lpx_delete_prob(GLPKModel);
GLPKModel = NULL;
}
return SUCCESS;
}
void TankBlendOptimiser::clean()
{
if (lp)
lpx_delete_prob(lp);
lp = NULL;
if (tanks>0)
{
delete []ia;
delete []ja;
delete []ar;
delete []tankMax;
delete []tankLow;
delete []tankHigh;
delete []assayLow;
delete []assayHigh;
delete []tankLowPenalty;
delete []tankHighPenalty;
delete []assayLowPenalty;
delete []assayHighPenalty;
for (int i=0; i<assays; i++)
delete []assayConc[i];
delete []assayConc;
for (int i=0; i<assays; i++)
delete []assayRatioLow[i];
delete []assayRatioLow;
for (int i=0; i<assays; i++)
delete []assayRatioHigh[i];
delete []assayRatioHigh;
for (int i=0; i<assays; i++)
delete []assayRatioLowEnabled[i];
delete []assayRatioLowEnabled;
for (int i=0; i<assays; i++)
delete []assayRatioHighEnabled[i];
delete []assayRatioHighEnabled;
for (int i=0; i<assays; i++)
delete []assayRatioLowPenalty[i];
delete []assayRatioLowPenalty;
for (int i=0; i<assays; i++)
delete []assayRatioHighPenalty[i];
delete []assayRatioHighPenalty;
}
tanks = 0;
assays = 0;
maxConstraints = 0;
}
DWORD APIENTRY solve_mps(VOID *arg)
{ char *fname = arg;
LPX *lp;
lp = lpx_read_mps(fname);
if (lp == NULL)
{ print("Cannot read mps file `%s'", fname);
return 1;
}
lpx_simplex(lp);
lpx_delete_prob(lp);
return 0;
}
int main(void)
{ LPX *lp;
int ia[1+1000], ja[1+1000];
double ar[1+1000], Z, x1, x2, x3;
s1: lp = lpx_create_prob();
s2: lpx_set_prob_name(lp, "sample");
s3: lpx_set_obj_dir(lp, LPX_MAX);
s4: lpx_add_rows(lp, 3);
s5: lpx_set_row_name(lp, 1, "p");
s6: lpx_set_row_bnds(lp, 1, LPX_UP, 0.0, 100.0);
s7: lpx_set_row_name(lp, 2, "q");
s8: lpx_set_row_bnds(lp, 2, LPX_UP, 0.0, 600.0);
s9: lpx_set_row_name(lp, 3, "r");
s10: lpx_set_row_bnds(lp, 3, LPX_UP, 0.0, 300.0);
s11: lpx_add_cols(lp, 3);
s12: lpx_set_col_name(lp, 1, "x1");
s13: lpx_set_col_bnds(lp, 1, LPX_LO, 0.0, 0.0);
s14: lpx_set_obj_coef(lp, 1, 10.0);
s15: lpx_set_col_name(lp, 2, "x2");
s16: lpx_set_col_bnds(lp, 2, LPX_LO, 0.0, 0.0);
s17: lpx_set_obj_coef(lp, 2, 6.0);
s18: lpx_set_col_name(lp, 3, "x3");
s19: lpx_set_col_bnds(lp, 3, LPX_LO, 0.0, 0.0);
s20: lpx_set_obj_coef(lp, 3, 4.0);
s21: ia[1] = 1, ja[1] = 1, ar[1] = 1.0; /* a[1,1] = 1 */
s22: ia[2] = 1, ja[2] = 2, ar[2] = 1.0; /* a[1,2] = 1 */
s23: ia[3] = 1, ja[3] = 3, ar[3] = 1.0; /* a[1,3] = 1 */
s24: ia[4] = 2, ja[4] = 1, ar[4] = 10.0; /* a[2,1] = 10 */
s25: ia[5] = 3, ja[5] = 1, ar[5] = 2.0; /* a[3,1] = 2 */
s26: ia[6] = 2, ja[6] = 2, ar[6] = 4.0; /* a[2,2] = 4 */
s27: ia[7] = 3, ja[7] = 2, ar[7] = 2.0; /* a[3,2] = 2 */
s28: ia[8] = 2, ja[8] = 3, ar[8] = 5.0; /* a[2,3] = 5 */
s29: ia[9] = 3, ja[9] = 3, ar[9] = 6.0; /* a[3,3] = 6 */
s30: lpx_load_matrix(lp, 9, ia, ja, ar);
s31: lpx_simplex(lp);
s32: Z = lpx_get_obj_val(lp);
s33: x1 = lpx_get_col_prim(lp, 1);
s34: x2 = lpx_get_col_prim(lp, 2);
s35: x3 = lpx_get_col_prim(lp, 3);
s36: printf("\nZ = %g; x1 = %g; x2 = %g; x3 = %g\n", Z, x1, x2, x3);
s37: lpx_delete_prob(lp);
return 0;
}
int main(int argc, char *argv[])
{ LPX *lp;
MPL *mpl = NULL;
int ret;
double start;
/* parse command line parameters */
parse_cmdline(argc, argv);
/* remove all output files specified in the command line */
if (display != NULL) remove(display);
if (out_sol != NULL) remove(out_sol);
if (out_bnds != NULL) remove(out_bnds);
if (out_mps != NULL) remove(out_mps);
if (out_lpt != NULL) remove(out_lpt);
if (out_txt != NULL) remove(out_txt);
if (out_glp != NULL) remove(out_glp);
/* read problem from the input file */
if (in_file == NULL)
{ print("No input file specified; try %s --help", argv[0]);
exit(EXIT_FAILURE);
}
switch (format)
{ case 0:
lp = lpx_read_mps(in_file);
if (lp == NULL)
{ print("MPS file processing error");
exit(EXIT_FAILURE);
}
break;
case 1:
lp = lpx_read_lpt(in_file);
if (lp == NULL)
{ print("CPLEX LP file processing error");
exit(EXIT_FAILURE);
}
break;
case 2:
#if 0 /* 01/VIII-2004 */
lp = lpx_read_model(in_file, in_data, display);
if (lp == NULL)
{ print("Model processing error");
exit(EXIT_FAILURE);
}
#else
/* initialize the translator database */
mpl = mpl_initialize();
/* read model section and optional data section */
ret = mpl_read_model(mpl, in_file, in_data != NULL);
if (ret == 4)
err: { print("Model processing error");
exit(EXIT_FAILURE);
}
insist(ret == 1 || ret == 2);
/* read data section, if necessary */
if (in_data != NULL)
{ insist(ret == 1);
ret = mpl_read_data(mpl, in_data);
if (ret == 4) goto err;
insist(ret == 2);
}
/* generate model */
ret = mpl_generate(mpl, display);
if (ret == 4) goto err;
/* extract problem instance */
lp = lpx_extract_prob(mpl);
insist(lp != NULL);
#endif
if (lpx_get_num_rows(lp) == 0)
{ print("Problem has no rows");
exit(EXIT_FAILURE);
}
if (lpx_get_num_cols(lp) == 0)
{ print("Problem has no columns");
exit(EXIT_FAILURE);
}
break;
case 3:
lp = lpx_read_prob(in_file);
if (lp == NULL)
{ print("GNU LP file processing error");
exit(EXIT_FAILURE);
}
break;
default:
insist(format != format);
}
/* change problem name (if required) */
if (newname != NULL) lpx_set_prob_name(lp, newname);
/* change optimization direction (if required) */
if (dir != 0) lpx_set_obj_dir(lp, dir);
/* write problem in MPS format (if required) */
if (out_mps != NULL)
{ lpx_set_int_parm(lp, LPX_K_MPSORIG, orig);
ret = lpx_write_mps(lp, out_mps);
if (ret != 0)
{ print("Unable to write problem in MPS format");
exit(EXIT_FAILURE);
}
}
/* write problem in CPLEX LP format (if required) */
if (out_lpt != NULL)
{ lpx_set_int_parm(lp, LPX_K_LPTORIG, orig);
ret = lpx_write_lpt(lp, out_lpt);
if (ret != 0)
{ print("Unable to write problem in CPLEX LP format");
exit(EXIT_FAILURE);
}
}
/* write problem in plain text format (if required) */
if (out_txt != NULL)
{ lpx_set_int_parm(lp, LPX_K_LPTORIG, orig);
ret = lpx_print_prob(lp, out_txt);
if (ret != 0)
{ print("Unable to write problem in plain text format");
exit(EXIT_FAILURE);
}
}
/* write problem in GNU LP format (if required) */
if (out_glp != NULL)
{ ret = lpx_write_prob(lp, out_glp);
if (ret != 0)
{ print("Unable to write problem in GNU LP format");
exit(EXIT_FAILURE);
}
}
/* if only data check is required, skip computations */
if (check) goto skip;
/* scale the problem data (if required) */
if (scale && (!presol || method == 1)) lpx_scale_prob(lp);
/* build advanced initial basis (if required) */
if (method == 0 && basis && !presol) lpx_adv_basis(lp);
/* set some control parameters, which might be changed in the
command line */
lpx_set_int_parm(lp, LPX_K_PRICE, price);
if (!relax) lpx_set_real_parm(lp, LPX_K_RELAX, 0.0);
lpx_set_int_parm(lp, LPX_K_PRESOL, presol);
lpx_set_int_parm(lp, LPX_K_BRANCH, branch);
lpx_set_int_parm(lp, LPX_K_BTRACK, btrack);
lpx_set_real_parm(lp, LPX_K_TMLIM, (double)tmlim);
/* solve the problem */
start = utime();
switch (method)
{ case 0:
if (nomip || lpx_get_class(lp) == LPX_LP)
{ ret = lpx_simplex(lp);
if (presol && ret != LPX_E_OK && out_sol != NULL)
print("If you need actual output for non-optimal solu"
"tion, use --nopresol");
}
else
{ method = 2;
lpx_simplex(lp);
if (!intopt)
lpx_integer(lp);
else
lpx_intopt(lp);
}
break;
case 1:
if (nomip || lpx_get_class(lp) == LPX_LP)
lpx_interior(lp);
else
{ print("Interior point method is not able to solve MIP pr"
"oblem; use --simplex");
exit(EXIT_FAILURE);
}
break;
default:
insist(method != method);
}
/* display statistics */
print("Time used: %.1f secs", utime() - start);
print("Memory used: %.1fM (%d bytes)",
(double)lib_env_ptr()->mem_tpeak / (double)(1024 * 1024),
lib_env_ptr()->mem_tpeak);
#if 1 /* 01/VIII-2004 */
if (mpl != NULL && mpl_has_solve_stmt(mpl))
{ int n, j, round;
/* store the solution to the translator database */
n = lpx_get_num_cols(lp);
round = lpx_get_int_parm(lp, LPX_K_ROUND);
lpx_set_int_parm(lp, LPX_K_ROUND, 1);
switch (method)
{ case 0:
for (j = 1; j <= n; j++)
mpl_put_col_value(mpl, j, lpx_get_col_prim(lp, j));
break;
case 1:
for (j = 1; j <= n; j++)
mpl_put_col_value(mpl, j, lpx_ipt_col_prim(lp, j));
break;
case 2:
for (j = 1; j <= n; j++)
mpl_put_col_value(mpl, j, lpx_mip_col_val(lp, j));
break;
default:
insist(method != method);
}
lpx_set_int_parm(lp, LPX_K_ROUND, round);
/* perform postsolving */
ret = mpl_postsolve(mpl, display);
if (ret == 4)
{ print("Model postsolving error");
exit(EXIT_FAILURE);
}
insist(ret == 3);
}
#endif
/* write problem solution found by the solver (if required) */
if (out_sol != NULL)
{ switch (method)
{ case 0:
ret = lpx_print_sol(lp, out_sol);
break;
case 1:
ret = lpx_print_ips(lp, out_sol);
break;
case 2:
ret = lpx_print_mip(lp, out_sol);
break;
default:
insist(method != method);
}
if (ret != 0)
{ print("Unable to write problem solution");
exit(EXIT_FAILURE);
}
}
/* write sensitivity bounds information (if required) */
if (out_bnds != NULL)
{ if (method != 0)
{ print("Cannot write sensitivity bounds information for inte"
"rior-point or MIP solution");
exit(EXIT_FAILURE);
}
ret = lpx_print_sens_bnds(lp, out_bnds);
if (ret != 0)
{ print("Unable to write sensitivity bounds information");
exit(EXIT_FAILURE);
}
}
skip: /* delete the problem object */
lpx_delete_prob(lp);
#if 1 /* 01/VIII-2004 */
/* if the translator database exists, destroy it */
if (mpl != NULL) mpl_terminate(mpl);
#endif
/* check that no memory blocks are still allocated */
insist(lib_env_ptr()->mem_total == 0);
insist(lib_env_ptr()->mem_count == 0);
/* return to the control program */
return 0;
}
LPX *lpx_read_cpxlp(const char *fname)
{ /* read problem data in CPLEX LP format */
struct dsa _dsa, *dsa = &_dsa;
if (setjmp(dsa->jump)) goto fail;
dsa->lp = NULL;
dsa->fname = fname;
dsa->fp = NULL;
dsa->count = 0;
dsa->c = '\n';
dsa->token = T_EOF;
dsa->image[0] = '\0';
dsa->imlen = 0;
dsa->value = 0.0;
dsa->n_max = 100;
dsa->map = xcalloc(1+dsa->n_max, sizeof(int));
memset(&dsa->map[1], 0, dsa->n_max * sizeof(int));
dsa->ind = xcalloc(1+dsa->n_max, sizeof(int));
dsa->val = xcalloc(1+dsa->n_max, sizeof(double));
dsa->lb = xcalloc(1+dsa->n_max, sizeof(double));
dsa->ub = xcalloc(1+dsa->n_max, sizeof(double));
print("lpx_read_cpxlp: reading problem data from `%s'...",
dsa->fname);
dsa->fp = xfopen(dsa->fname, "r");
if (dsa->fp == NULL)
{ print("lpx_read_cpxlp: unable to open `%s' - %s", dsa->fname,
strerror(errno));
goto fail;
}
dsa->lp = lpx_create_prob();
lpx_create_index(dsa->lp);
#if 0
/* read very first character */
read_char(dsa);
#endif
/* scan very first token */
scan_token(dsa);
/* parse definition of the objective function */
if (!(dsa->token == T_MINIMIZE || dsa->token == T_MAXIMIZE))
fatal(dsa, "`minimize' or `maximize' keyword missing");
parse_objective(dsa);
/* parse constraints section */
if (dsa->token != T_SUBJECT_TO)
fatal(dsa, "constraints section missing");
parse_constraints(dsa);
/* parse optional bounds section */
if (dsa->token == T_BOUNDS) parse_bounds(dsa);
/* parse optional general, integer, and binary sections */
while (dsa->token == T_GENERAL ||
dsa->token == T_INTEGER ||
dsa->token == T_BINARY) parse_integer(dsa);
/* check for the keyword 'end' */
if (dsa->token == T_END)
scan_token(dsa);
else if (dsa->token == T_EOF)
print("%s:%d: warning: keyword `end' missing", dsa->fname,
dsa->count);
else
fatal(dsa, "symbol `%s' in wrong position", dsa->image);
/* nothing must follow the keyword 'end' (except comments) */
if (dsa->token != T_EOF)
fatal(dsa, "extra symbol(s) detected beyond `end'");
/* set bounds of variables */
{ int j, type;
double lb, ub;
for (j = lpx_get_num_cols(dsa->lp); j >= 1; j--)
{ lb = dsa->lb[j];
ub = dsa->ub[j];
if (lb == +DBL_MAX) lb = 0.0; /* default lb */
if (ub == -DBL_MAX) ub = +DBL_MAX; /* default ub */
if (lb == -DBL_MAX && ub == +DBL_MAX)
type = LPX_FR;
else if (ub == +DBL_MAX)
type = LPX_LO;
else if (lb == -DBL_MAX)
type = LPX_UP;
else if (lb != ub)
type = LPX_DB;
else
type = LPX_FX;
lpx_set_col_bnds(dsa->lp, j, type, lb, ub);
}
}
/* print some statistics */
{ int m = lpx_get_num_rows(dsa->lp);
int n = lpx_get_num_cols(dsa->lp);
int nnz = lpx_get_num_nz(dsa->lp);
print("lpx_read_cpxlp: %d row%s, %d column%s, %d non-zero%s",
m, m == 1 ? "" : "s", n, n == 1 ? "" : "s", nnz, nnz == 1 ?
"" : "s");
}
if (lpx_get_class(dsa->lp) == LPX_MIP)
{ int ni = lpx_get_num_int(dsa->lp);
int nb = lpx_get_num_bin(dsa->lp);
char s[50];
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_read_cpxlp: %d integer column%s, %s which %s binary"
, ni, ni == 1 ? "" : "s", s, nb == 1 ? "is" : "are");
}
print("lpx_read_cpxlp: %d lines were read", dsa->count);
xfclose(dsa->fp);
xfree(dsa->map);
xfree(dsa->ind);
xfree(dsa->val);
xfree(dsa->lb);
xfree(dsa->ub);
lpx_delete_index(dsa->lp);
lpx_order_matrix(dsa->lp);
return dsa->lp;
fail: if (dsa->lp != NULL) lpx_delete_prob(dsa->lp);
if (dsa->fp != NULL) xfclose(dsa->fp);
if (dsa->map != NULL) xfree(dsa->map);
if (dsa->ind != NULL) xfree(dsa->ind);
if (dsa->val != NULL) xfree(dsa->val);
if (dsa->lb != NULL) xfree(dsa->lb);
if (dsa->ub != NULL) xfree(dsa->ub);
return NULL;
}
int main(int argc, char *argv[])
{ LPX *lp;
MPL *mpl = NULL;
int ret;
ulong_t start;
/* parse command line parameters */
parse_cmdline(argc, argv);
/* set available memory limit */
if (memlim >= 0)
lib_mem_limit(ulmul(ulset(0, 1048576), ulset(0, memlim)));
/* remove all output files specified in the command line */
if (display != NULL) remove(display);
if (out_bas != NULL) remove(out_bas);
if (out_sol != NULL) remove(out_sol);
if (out_bnds != NULL) remove(out_bnds);
if (out_mps != NULL) remove(out_mps);
if (out_freemps != NULL) remove(out_freemps);
if (out_cpxlp != NULL) remove(out_cpxlp);
if (out_txt != NULL) remove(out_txt);
if (out_glp != NULL) remove(out_glp);
if (log_file != NULL) remove(log_file);
/* open hardcopy file, if necessary */
if (log_file != NULL)
{ if (lib_open_log(log_file))
{ print("Unable to create log file");
exit(EXIT_FAILURE);
}
}
/* read problem data from the input file */
if (in_file == NULL)
{ print("No input file specified; try %s --help", argv[0]);
exit(EXIT_FAILURE);
}
switch (format)
{ case 0:
lp = lpx_read_mps(in_file);
if (lp == NULL)
{ print("MPS file processing error");
exit(EXIT_FAILURE);
}
orig = 1;
break;
case 1:
lp = lpx_read_cpxlp(in_file);
if (lp == NULL)
{ print("CPLEX LP file processing error");
exit(EXIT_FAILURE);
}
break;
case 2:
/* initialize the translator database */
mpl = mpl_initialize();
/* read model section and optional data section */
ret = mpl_read_model(mpl, in_file, in_data != NULL);
if (ret == 4)
err: { print("Model processing error");
exit(EXIT_FAILURE);
}
xassert(ret == 1 || ret == 2);
/* read data section, if necessary */
if (in_data != NULL)
{ xassert(ret == 1);
ret = mpl_read_data(mpl, in_data);
if (ret == 4) goto err;
xassert(ret == 2);
}
/* generate model */
ret = mpl_generate(mpl, display);
if (ret == 4) goto err;
/* extract problem instance */
lp = lpx_extract_prob(mpl);
xassert(lp != NULL);
break;
case 3:
lp = lpx_read_prob(in_file);
if (lp == NULL)
{ print("GNU LP file processing error");
exit(EXIT_FAILURE);
}
break;
case 4:
lp = lpx_read_freemps(in_file);
if (lp == NULL)
{ print("MPS file processing error");
exit(EXIT_FAILURE);
}
break;
default:
xassert(format != format);
}
/* order rows and columns of the constraint matrix */
lpx_order_matrix(lp);
/* change problem name (if required) */
if (newname != NULL) lpx_set_prob_name(lp, newname);
/* change optimization direction (if required) */
if (dir != 0) lpx_set_obj_dir(lp, dir);
/* write problem in fixed MPS format (if required) */
if (out_mps != NULL)
{ lpx_set_int_parm(lp, LPX_K_MPSORIG, orig);
ret = lpx_write_mps(lp, out_mps);
if (ret != 0)
{ print("Unable to write problem in fixed MPS format");
exit(EXIT_FAILURE);
}
}
/* write problem in free MPS format (if required) */
if (out_freemps != NULL)
{ ret = lpx_write_freemps(lp, out_freemps);
if (ret != 0)
{ print("Unable to write problem in free MPS format");
exit(EXIT_FAILURE);
}
}
/* write problem in CPLEX LP format (if required) */
if (out_cpxlp != NULL)
{ ret = lpx_write_cpxlp(lp, out_cpxlp);
if (ret != 0)
{ print("Unable to write problem in CPLEX LP format");
exit(EXIT_FAILURE);
}
}
/* write problem in plain text format (if required) */
if (out_txt != NULL)
{ lpx_set_int_parm(lp, LPX_K_LPTORIG, orig);
ret = lpx_print_prob(lp, out_txt);
if (ret != 0)
{ print("Unable to write problem in plain text format");
exit(EXIT_FAILURE);
}
}
/* write problem in GNU LP format (if required) */
if (out_glp != NULL)
{ ret = lpx_write_prob(lp, out_glp);
if (ret != 0)
{ print("Unable to write problem in GNU LP format");
exit(EXIT_FAILURE);
}
}
/* if only data check is required, skip computations */
if (check) goto skip;
/* scale the problem data (if required) */
if (scale && (!presol || method == 1)) lpx_scale_prob(lp);
/* build initial LP basis */
if (method == 0 && !presol && in_bas == NULL)
{ switch (basis)
{ case 0:
lpx_std_basis(lp);
break;
case 1:
if (lpx_get_num_rows(lp) > 0 && lpx_get_num_cols(lp) > 0)
lpx_adv_basis(lp);
break;
case 2:
if (lpx_get_num_rows(lp) > 0 && lpx_get_num_cols(lp) > 0)
lpx_cpx_basis(lp);
break;
default:
xassert(basis != basis);
}
}
/* or read initial basis from input text file in MPS format */
if (in_bas != NULL)
{ if (method != 0)
{ print("Initial LP basis is useless for interior-point solve"
"r and therefore ignored");
goto nobs;
}
lpx_set_int_parm(lp, LPX_K_MPSORIG, orig);
ret = lpx_read_bas(lp, in_bas);
if (ret != 0)
{ print("Unable to read initial LP basis");
exit(EXIT_FAILURE);
}
if (presol)
{ presol = 0;
print("LP presolver disabled because initial LP basis has b"
"een provided");
}
nobs: ;
}
/* set some control parameters, which might be changed in the
command line */
lpx_set_int_parm(lp, LPX_K_BFTYPE, bf_type);
lpx_set_int_parm(lp, LPX_K_PRICE, price);
if (!relax) lpx_set_real_parm(lp, LPX_K_RELAX, 0.0);
lpx_set_int_parm(lp, LPX_K_PRESOL, presol);
lpx_set_int_parm(lp, LPX_K_BRANCH, branch);
lpx_set_int_parm(lp, LPX_K_BTRACK, btrack);
lpx_set_real_parm(lp, LPX_K_TMLIM, (double)tmlim);
lpx_set_int_parm(lp, LPX_K_BINARIZE, binarize);
lpx_set_int_parm(lp, LPX_K_USECUTS, use_cuts);
/* solve the problem */
start = xtime();
switch (method)
{ case 0:
if (nomip || lpx_get_class(lp) == LPX_LP)
{ ret = (!exact ? lpx_simplex(lp) : lpx_exact(lp));
if (xcheck)
{ if (!presol || ret == LPX_E_OK)
lpx_exact(lp);
else
print("If you need checking final basis for non-op"
"timal solution, use --nopresol");
}
if (presol && ret != LPX_E_OK && (out_bas != NULL ||
out_sol != NULL))
print("If you need actual output for non-optimal solu"
"tion, use --nopresol");
}
else
{ method = 2;
if (!intopt)
{ ret = (!exact ? lpx_simplex(lp) : lpx_exact(lp));
if (xcheck && (!presol || ret == LPX_E_OK))
lpx_exact(lp);
lpx_integer(lp);
}
else
lpx_intopt(lp);
}
break;
case 1:
if (nomip || lpx_get_class(lp) == LPX_LP)
lpx_interior(lp);
else
{ print("Interior-point method is not able to solve MIP pr"
"oblem; use --simplex");
exit(EXIT_FAILURE);
}
break;
default:
xassert(method != method);
}
/* display statistics */
print("Time used: %.1f secs", xdifftime(xtime(), start));
{ ulong_t tpeak;
char buf[50];
lib_mem_usage(NULL, NULL, NULL, &tpeak);
print("Memory used: %.1f Mb (%s bytes)",
(4294967296.0 * tpeak.hi + tpeak.lo) / 1048576.0,
ultoa(tpeak, buf, 10));
}
if (mpl != NULL && mpl_has_solve_stmt(mpl))
{ int n, j, round;
/* store the solution to the translator database */
n = lpx_get_num_cols(lp);
round = lpx_get_int_parm(lp, LPX_K_ROUND);
lpx_set_int_parm(lp, LPX_K_ROUND, 1);
switch (method)
{ case 0:
for (j = 1; j <= n; j++)
mpl_put_col_value(mpl, j, lpx_get_col_prim(lp, j));
break;
case 1:
for (j = 1; j <= n; j++)
mpl_put_col_value(mpl, j, lpx_ipt_col_prim(lp, j));
break;
case 2:
for (j = 1; j <= n; j++)
mpl_put_col_value(mpl, j, lpx_mip_col_val(lp, j));
break;
default:
xassert(method != method);
}
lpx_set_int_parm(lp, LPX_K_ROUND, round);
/* perform postsolving */
ret = mpl_postsolve(mpl);
if (ret == 4)
{ print("Model postsolving error");
exit(EXIT_FAILURE);
}
xassert(ret == 3);
}
/* write final LP basis (if required) */
if (out_bas != NULL)
{ lpx_set_int_parm(lp, LPX_K_MPSORIG, orig);
ret = lpx_write_bas(lp, out_bas);
if (ret != 0)
{ print("Unable to write final LP basis");
exit(EXIT_FAILURE);
}
}
/* write problem solution found by the solver (if required) */
if (out_sol != NULL)
{ switch (method)
{ case 0:
ret = lpx_print_sol(lp, out_sol);
break;
case 1:
ret = lpx_print_ips(lp, out_sol);
break;
case 2:
ret = lpx_print_mip(lp, out_sol);
break;
default:
xassert(method != method);
}
if (ret != 0)
{ print("Unable to write problem solution");
exit(EXIT_FAILURE);
}
}
/* write sensitivity bounds information (if required) */
if (out_bnds != NULL)
{ if (method != 0)
{ print("Cannot write sensitivity bounds information for inte"
"rior-point or MIP solution");
exit(EXIT_FAILURE);
}
ret = lpx_print_sens_bnds(lp, out_bnds);
if (ret != 0)
{ print("Unable to write sensitivity bounds information");
exit(EXIT_FAILURE);
}
}
skip: /* delete the problem object */
lpx_delete_prob(lp);
/* if the translator database exists, destroy it */
if (mpl != NULL) mpl_terminate(mpl);
xassert(gmp_pool_count() == 0);
gmp_free_mem();
/* close the hardcopy file */
if (log_file != NULL) lib_close_log();
/* check that no memory blocks are still allocated */
{ int count;
ulong_t total;
lib_mem_usage(&count, NULL, &total, NULL);
xassert(count == 0);
xassert(total.lo == 0 && total.hi == 0);
}
/* free the library environment */
lib_free_env();
/* return to the control program */
return 0;
}
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 lpx_write_pb(LPX *lp, const char *fname, int normalized,
int binarize)
{
FILE* fp;
int m,n,i,j,k,o,nonfree=0, obj_dir, dbl, *ndx, row_type, emptylhs=0;
double coeff, *val, bound, constant/*=0.0*/;
char* objconstname = "dummy_one";
char* emptylhsname = "dummy_zero";
/* Variables needed for possible binarization */
/*LPX* tlp;*/
IPP *ipp = NULL;
/*tlp=lp;*/
if(binarize) /* Transform integer variables to binary ones */
{
ipp = ipp_create_wksp();
ipp_load_orig(ipp, lp);
ipp_binarize(ipp);
lp = ipp_build_prob(ipp);
}
fp = fopen(fname, "w");
if(fp!= NULL)
{
xprintf(
"lpx_write_pb: writing problem in %sOPB format to `%s'...\n",
(normalized?"normalized ":""), fname);
m = glp_get_num_rows(lp);
n = glp_get_num_cols(lp);
for(i=1;i<=m;i++)
{
switch(glp_get_row_type(lp,i))
{
case GLP_LO:
case GLP_UP:
case GLP_FX:
{
nonfree += 1;
break;
}
case GLP_DB:
{
nonfree += 2;
break;
}
}
}
constant=glp_get_obj_coef(lp,0);
fprintf(fp,"* #variables = %d #constraints = %d\n",
n + (constant == 0?1:0), nonfree + (constant == 0?1:0));
/* Objective function */
obj_dir = glp_get_obj_dir(lp);
fprintf(fp,"min: ");
for(i=1;i<=n;i++)
{
coeff = glp_get_obj_coef(lp,i);
if(coeff != 0.0)
{
if(obj_dir == GLP_MAX)
coeff=-coeff;
if(normalized)
fprintf(fp, " %d x%d", (int)coeff, i);
else
fprintf(fp, " %d*%s", (int)coeff,
glp_get_col_name(lp,i));
}
}
if(constant)
{
if(normalized)
fprintf(fp, " %d x%d", (int)constant, n+1);
else
fprintf(fp, " %d*%s", (int)constant, objconstname);
}
fprintf(fp,";\n");
if(normalized && !binarize) /* Name substitution */
{
fprintf(fp,"* Variable name substitution:\n");
for(j=1;j<=n;j++)
{
fprintf(fp, "* x%d = %s\n", j, glp_get_col_name(lp,j));
}
if(constant)
fprintf(fp, "* x%d = %s\n", n+1, objconstname);
}
ndx = xcalloc(1+n, sizeof(int));
val = xcalloc(1+n, sizeof(double));
/* Constraints */
for(j=1;j<=m;j++)
{
row_type=glp_get_row_type(lp,j);
if(row_type!=GLP_FR)
{
if(row_type == GLP_DB)
{
dbl=2;
row_type = GLP_UP;
}
else
{
dbl=1;
}
k=glp_get_mat_row(lp, j, ndx, val);
for(o=1;o<=dbl;o++)
{
if(o==2)
{
row_type = GLP_LO;
}
if(k==0) /* Empty LHS */
{
emptylhs = 1;
if(normalized)
{
fprintf(fp, "0 x%d ", n+2);
}
else
{
fprintf(fp, "0*%s ", emptylhsname);
}
}
for(i=1;i<=k;i++)
{
if(val[i] != 0.0)
{
if(normalized)
{
fprintf(fp, "%d x%d ",
(row_type==GLP_UP)?(-(int)val[i]):((int)val[i]), ndx[i]);
}
else
{
fprintf(fp, "%d*%s ", (int)val[i],
glp_get_col_name(lp,ndx[i]));
}
}
}
switch(row_type)
{
case GLP_LO:
{
fprintf(fp, ">=");
bound = glp_get_row_lb(lp,j);
break;
}
case GLP_UP:
{
if(normalized)
{
fprintf(fp, ">=");
bound = -glp_get_row_ub(lp,j);
}
else
{
fprintf(fp, "<=");
bound = glp_get_row_ub(lp,j);
}
break;
}
case GLP_FX:
{
fprintf(fp, "=");
bound = glp_get_row_lb(lp,j);
break;
}
}
fprintf(fp," %d;\n",(int)bound);
}
}
}
xfree(ndx);
xfree(val);
if(constant)
{
xprintf(
"lpx_write_pb: adding constant objective function variable\n");
if(normalized)
fprintf(fp, "1 x%d = 1;\n", n+1);
else
fprintf(fp, "1*%s = 1;\n", objconstname);
}
if(emptylhs)
{
xprintf(
"lpx_write_pb: adding dummy variable for empty left-hand si"
"de constraint\n");
if(normalized)
fprintf(fp, "1 x%d = 0;\n", n+2);
else
fprintf(fp, "1*%s = 0;\n", emptylhsname);
}
}
else
{
xprintf("Problems opening file for writing: %s\n", fname);
return(1);
}
fflush(fp);
if (ferror(fp))
{ xprintf("lpx_write_pb: can't write to `%s' - %s\n", fname,
strerror(errno));
goto fail;
}
fclose(fp);
if(binarize)
{
/* delete the resultant problem object */
if (lp != NULL) lpx_delete_prob(lp);
/* delete MIP presolver workspace */
if (ipp != NULL) ipp_delete_wksp(ipp);
/*lp=tlp;*/
}
return 0;
fail: if (fp != NULL) fclose(fp);
return 1;
}
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;
}