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;
}
int main(void)
{ glp_prob *P;
P = glp_create_prob();
glp_read_mps(P, GLP_MPS_DECK, NULL, "25fv47.mps");
glp_adv_basis(P, 0);
glp_simplex(P, NULL);
glp_print_sol(P, "25fv47.txt");
glp_delete_prob(P);
return 0;
}
int main(void)
{ glp_prob *P;
glp_smcp parm;
P = glp_create_prob();
glp_read_mps(P, GLP_MPS_DECK, NULL, "25fv47.mps");
glp_init_smcp(&parm);
parm.meth = GLP_DUAL;
glp_simplex(P, &parm);
glp_print_sol(P, "25fv47.txt");
glp_delete_prob(P);
return 0;
}
static void
solve(char* file_name) {
ppl_Constraint_System_t ppl_cs;
#ifndef NDEBUG
ppl_Constraint_System_t ppl_cs_copy;
#endif
ppl_Generator_t optimum_location;
ppl_Linear_Expression_t ppl_le;
int dimension, row, num_rows, column, nz, i, j, type;
int* coefficient_index;
double lb, ub;
double* coefficient_value;
mpq_t rational_lb, rational_ub;
mpq_t* rational_coefficient;
mpq_t* objective;
ppl_Linear_Expression_t ppl_objective_le;
ppl_Coefficient_t optimum_n;
ppl_Coefficient_t optimum_d;
mpq_t optimum;
mpz_t den_lcm;
int optimum_found;
glp_mpscp glpk_mpscp;
glpk_lp = glp_create_prob();
glp_init_mpscp(&glpk_mpscp);
if (verbosity == 0) {
/* FIXME: find a way to suppress output from glp_read_mps. */
}
#ifdef PPL_LPSOL_SUPPORTS_TIMINGS
if (print_timings)
start_clock();
#endif /* defined(PPL_LPSOL_SUPPORTS_TIMINGS) */
if (glp_read_mps(glpk_lp, GLP_MPS_FILE, &glpk_mpscp, file_name) != 0)
fatal("cannot read MPS file `%s'", file_name);
#ifdef PPL_LPSOL_SUPPORTS_TIMINGS
if (print_timings) {
fprintf(stderr, "Time to read the input file: ");
print_clock(stderr);
fprintf(stderr, " s\n");
start_clock();
}
#endif /* defined(PPL_LPSOL_SUPPORTS_TIMINGS) */
glpk_lp_num_int = glp_get_num_int(glpk_lp);
if (glpk_lp_num_int > 0 && !no_mip && !use_simplex)
fatal("the enumeration solving method can not handle MIP problems");
dimension = glp_get_num_cols(glpk_lp);
/* Read variables constrained to be integer. */
if (glpk_lp_num_int > 0 && !no_mip && use_simplex) {
if (verbosity >= 4)
fprintf(output_file, "Integer variables:\n");
integer_variables = (ppl_dimension_type*)
malloc((glpk_lp_num_int + 1)*sizeof(ppl_dimension_type));
for (i = 0, j = 0; i < dimension; ++i) {
int col_kind = glp_get_col_kind(glpk_lp, i+1);
if (col_kind == GLP_IV || col_kind == GLP_BV) {
integer_variables[j] = i;
if (verbosity >= 4) {
ppl_io_fprint_variable(output_file, i);
fprintf(output_file, " ");
}
++j;
}
}
}
coefficient_index = (int*) malloc((dimension+1)*sizeof(int));
coefficient_value = (double*) malloc((dimension+1)*sizeof(double));
rational_coefficient = (mpq_t*) malloc((dimension+1)*sizeof(mpq_t));
ppl_new_Constraint_System(&ppl_cs);
mpq_init(rational_lb);
mpq_init(rational_ub);
for (i = 1; i <= dimension; ++i)
mpq_init(rational_coefficient[i]);
mpz_init(den_lcm);
if (verbosity >= 4)
fprintf(output_file, "\nConstraints:\n");
/* Set up the row (ordinary) constraints. */
num_rows = glp_get_num_rows(glpk_lp);
for (row = 1; row <= num_rows; ++row) {
/* Initialize the least common multiple computation. */
mpz_set_si(den_lcm, 1);
/* Set `nz' to the number of non-zero coefficients. */
nz = glp_get_mat_row(glpk_lp, row, coefficient_index, coefficient_value);
for (i = 1; i <= nz; ++i) {
set_mpq_t_from_double(rational_coefficient[i], coefficient_value[i]);
/* Update den_lcm. */
mpz_lcm(den_lcm, den_lcm, mpq_denref(rational_coefficient[i]));
}
lb = glp_get_row_lb(glpk_lp, row);
ub = glp_get_row_ub(glpk_lp, row);
set_mpq_t_from_double(rational_lb, lb);
set_mpq_t_from_double(rational_ub, ub);
mpz_lcm(den_lcm, den_lcm, mpq_denref(rational_lb));
mpz_lcm(den_lcm, den_lcm, mpq_denref(rational_ub));
ppl_new_Linear_Expression_with_dimension(&ppl_le, dimension);
for (i = 1; i <= nz; ++i) {
mpz_mul(tmp_z, den_lcm, mpq_numref(rational_coefficient[i]));
mpz_divexact(tmp_z, tmp_z, mpq_denref(rational_coefficient[i]));
ppl_assign_Coefficient_from_mpz_t(ppl_coeff, tmp_z);
ppl_Linear_Expression_add_to_coefficient(ppl_le, coefficient_index[i]-1,
ppl_coeff);
}
type = glp_get_row_type(glpk_lp, row);
add_constraints(ppl_le, type, rational_lb, rational_ub, den_lcm, ppl_cs);
ppl_delete_Linear_Expression(ppl_le);
}
free(coefficient_value);
for (i = 1; i <= dimension; ++i)
mpq_clear(rational_coefficient[i]);
free(rational_coefficient);
free(coefficient_index);
#ifndef NDEBUG
ppl_new_Constraint_System_from_Constraint_System(&ppl_cs_copy, ppl_cs);
#endif
/*
FIXME: here we could build the polyhedron and minimize it before
adding the variable bounds.
*/
/* Set up the columns constraints, i.e., variable bounds. */
for (column = 1; column <= dimension; ++column) {
lb = glp_get_col_lb(glpk_lp, column);
ub = glp_get_col_ub(glpk_lp, column);
set_mpq_t_from_double(rational_lb, lb);
set_mpq_t_from_double(rational_ub, ub);
/* Initialize the least common multiple computation. */
mpz_set_si(den_lcm, 1);
mpz_lcm(den_lcm, den_lcm, mpq_denref(rational_lb));
mpz_lcm(den_lcm, den_lcm, mpq_denref(rational_ub));
ppl_new_Linear_Expression_with_dimension(&ppl_le, dimension);
ppl_assign_Coefficient_from_mpz_t(ppl_coeff, den_lcm);
ppl_Linear_Expression_add_to_coefficient(ppl_le, column-1, ppl_coeff);
type = glp_get_col_type(glpk_lp, column);
add_constraints(ppl_le, type, rational_lb, rational_ub, den_lcm, ppl_cs);
ppl_delete_Linear_Expression(ppl_le);
}
mpq_clear(rational_ub);
mpq_clear(rational_lb);
/* Deal with the objective function. */
objective = (mpq_t*) malloc((dimension+1)*sizeof(mpq_t));
/* Initialize the least common multiple computation. */
mpz_set_si(den_lcm, 1);
mpq_init(objective[0]);
set_mpq_t_from_double(objective[0], glp_get_obj_coef(glpk_lp, 0));
for (i = 1; i <= dimension; ++i) {
mpq_init(objective[i]);
set_mpq_t_from_double(objective[i], glp_get_obj_coef(glpk_lp, i));
/* Update den_lcm. */
mpz_lcm(den_lcm, den_lcm, mpq_denref(objective[i]));
}
/* Set the ppl_objective_le to be the objective function. */
ppl_new_Linear_Expression_with_dimension(&ppl_objective_le, dimension);
/* Set value for objective function's inhomogeneous term. */
mpz_mul(tmp_z, den_lcm, mpq_numref(objective[0]));
mpz_divexact(tmp_z, tmp_z, mpq_denref(objective[0]));
ppl_assign_Coefficient_from_mpz_t(ppl_coeff, tmp_z);
ppl_Linear_Expression_add_to_inhomogeneous(ppl_objective_le, ppl_coeff);
/* Set values for objective function's variable coefficients. */
for (i = 1; i <= dimension; ++i) {
mpz_mul(tmp_z, den_lcm, mpq_numref(objective[i]));
mpz_divexact(tmp_z, tmp_z, mpq_denref(objective[i]));
ppl_assign_Coefficient_from_mpz_t(ppl_coeff, tmp_z);
ppl_Linear_Expression_add_to_coefficient(ppl_objective_le, i-1, ppl_coeff);
}
if (verbosity >= 4) {
fprintf(output_file, "Objective function:\n");
if (mpz_cmp_si(den_lcm, 1) != 0)
fprintf(output_file, "(");
ppl_io_fprint_Linear_Expression(output_file, ppl_objective_le);
}
for (i = 0; i <= dimension; ++i)
mpq_clear(objective[i]);
free(objective);
if (verbosity >= 4) {
if (mpz_cmp_si(den_lcm, 1) != 0) {
fprintf(output_file, ")/");
mpz_out_str(output_file, 10, den_lcm);
}
fprintf(output_file, "\n%s\n",
(maximize ? "Maximizing." : "Minimizing."));
}
ppl_new_Coefficient(&optimum_n);
ppl_new_Coefficient(&optimum_d);
ppl_new_Generator_zero_dim_point(&optimum_location);
optimum_found = use_simplex
? solve_with_simplex(ppl_cs,
ppl_objective_le,
optimum_n,
optimum_d,
optimum_location)
: solve_with_generators(ppl_cs,
ppl_objective_le,
optimum_n,
optimum_d,
optimum_location);
ppl_delete_Linear_Expression(ppl_objective_le);
if (glpk_lp_num_int > 0)
free(integer_variables);
if (optimum_found) {
mpq_init(optimum);
ppl_Coefficient_to_mpz_t(optimum_n, tmp_z);
mpq_set_num(optimum, tmp_z);
ppl_Coefficient_to_mpz_t(optimum_d, tmp_z);
mpz_mul(tmp_z, tmp_z, den_lcm);
mpq_set_den(optimum, tmp_z);
if (verbosity == 1)
fprintf(output_file, "Optimized problem.\n");
if (verbosity >= 2)
fprintf(output_file, "Optimum value: %.10g\n", mpq_get_d(optimum));
if (verbosity >= 3) {
fprintf(output_file, "Optimum location:\n");
ppl_Generator_divisor(optimum_location, ppl_coeff);
ppl_Coefficient_to_mpz_t(ppl_coeff, tmp_z);
for (i = 0; i < dimension; ++i) {
mpz_set(mpq_denref(tmp1_q), tmp_z);
ppl_Generator_coefficient(optimum_location, i, ppl_coeff);
ppl_Coefficient_to_mpz_t(ppl_coeff, mpq_numref(tmp1_q));
ppl_io_fprint_variable(output_file, i);
fprintf(output_file, " = %.10g\n", mpq_get_d(tmp1_q));
}
}
#ifndef NDEBUG
{
ppl_Polyhedron_t ph;
unsigned int relation;
ppl_new_C_Polyhedron_recycle_Constraint_System(&ph, ppl_cs_copy);
ppl_delete_Constraint_System(ppl_cs_copy);
relation = ppl_Polyhedron_relation_with_Generator(ph, optimum_location);
ppl_delete_Polyhedron(ph);
assert(relation == PPL_POLY_GEN_RELATION_SUBSUMES);
}
#endif
maybe_check_results(PPL_MIP_PROBLEM_STATUS_OPTIMIZED,
mpq_get_d(optimum));
mpq_clear(optimum);
}
ppl_delete_Constraint_System(ppl_cs);
ppl_delete_Coefficient(optimum_d);
ppl_delete_Coefficient(optimum_n);
ppl_delete_Generator(optimum_location);
glp_delete_prob(glpk_lp);
}
static int LPX_init(LPXObject *self, PyObject *args, PyObject *kwds) {
char *mps_n=NULL, *freemps_n=NULL, *cpxlp_n=NULL;
PyObject *model_obj=NULL;
static char *kwlist[] = {"gmp","mps","freemps","cpxlp",NULL};
if (!PyArg_ParseTupleAndKeywords
(args, kwds, "|Osss", kwlist,
&model_obj, &mps_n, &freemps_n, &cpxlp_n)) {
return -1;
}
int numargs = (mps_n?1:0)+(freemps_n?1:0)+(cpxlp_n?1:0)+(model_obj?1:0);
if (numargs>1) {
PyErr_SetString(PyExc_TypeError, "cannot specify multiple data sources");
return -1;
}
if (numargs==0) {
// No arguments. Create an empty problem.
self->lp = glp_create_prob();
} else {
// Some of these are pretty straightforward data reading routines.
if (mps_n) {
#if GLPK_VERSION(4, 29)
self->lp = glp_create_prob();
int failure = glp_read_mps(self->lp, GLP_MPS_DECK, NULL, mps_n);
if (failure) {
PyErr_SetString(PyExc_RuntimeError, "MPS reader failed");
return -1;
}
#else
self->lp = lpx_read_mps(mps_n);
#endif
} else if (freemps_n) {
#if GLPK_VERSION(4, 29)
self->lp = glp_create_prob();
int failure = glp_read_mps(self->lp, GLP_MPS_FILE, NULL, mps_n);
if (failure) {
PyErr_SetString(PyExc_RuntimeError, "Free MPS reader failed");
return -1;
}
#else
self->lp = lpx_read_freemps(freemps_n);
#endif
} else if (cpxlp_n) {
#if GLPK_VERSION(4, 29)
self->lp = glp_create_prob();
int failure = glp_read_lp(self->lp, NULL, mps_n);
if (failure) {
PyErr_SetString(PyExc_RuntimeError, "CPLEX LP reader failed");
return -1;
}
#else
self->lp = lpx_read_cpxlp(cpxlp_n);
#endif
} else if (model_obj) {
// This one can take a few possible values.
char *model[] = {NULL,NULL,NULL};
if (PyString_Check(model_obj)) {
// Single string object.
model[0] = PyString_AsString(model_obj);
if (!model[0]) return -1;
} else if (PyTuple_Check(model_obj)) {
// Possibly module arguments.
int i,size = PyTuple_Size(model_obj);
if (size < -1) { return -1; }
if (size > 3) {
PyErr_SetString(PyExc_ValueError, "model tuple must have length<=3");
return -1; }
for (i=0; i<size; ++i) {
PyObject *so = PyTuple_GET_ITEM(model_obj,i);
if (so==Py_None) continue;
model[i] = PyString_AsString(so);
if (model[i]==NULL) { return -1; }
}
} else {
PyErr_SetString(PyExc_TypeError, "model arg must be string or tuple");
return -1;
}
// Now, pass in that information.
if (!model[0]) return -1;
self->lp = lpx_read_model(model[0], model[1], model[2]);
}
}
// Any of the methods above may have failed, so the LP would be null.
if (LP == NULL) {
PyErr_SetString(numargs?PyExc_RuntimeError:PyExc_MemoryError,
"could not create problem");
return -1;
}
// Create those rows and cols and things.
self->cols = (PyObject*)BarCol_New(self, 0);
self->rows = (PyObject*)BarCol_New(self, 1);
self->obj = (PyObject*)Obj_New(self);
#ifdef USEPARAMS
self->params = (PyObject*)Params_New(self);
#endif
return 0;
}
int glp_main(int argc, const char *argv[])
{ /* stand-alone LP/MIP solver */
struct csa _csa, *csa = &_csa;
int ret;
xlong_t start;
/* perform initialization */
csa->prob = glp_create_prob();
glp_get_bfcp(csa->prob, &csa->bfcp);
glp_init_smcp(&csa->smcp);
csa->smcp.presolve = GLP_ON;
glp_init_iocp(&csa->iocp);
csa->iocp.presolve = GLP_ON;
csa->tran = NULL;
csa->graph = NULL;
csa->format = FMT_MPS_FILE;
csa->in_file = NULL;
csa->ndf = 0;
csa->out_dpy = NULL;
csa->solution = SOL_BASIC;
csa->in_res = NULL;
csa->dir = 0;
csa->scale = 1;
csa->out_sol = NULL;
csa->out_res = NULL;
csa->out_bnds = NULL;
csa->check = 0;
csa->new_name = NULL;
csa->out_mps = NULL;
csa->out_freemps = NULL;
csa->out_cpxlp = NULL;
csa->out_pb = NULL;
csa->out_npb = NULL;
csa->log_file = NULL;
csa->crash = USE_ADV_BASIS;
csa->exact = 0;
csa->xcheck = 0;
csa->nomip = 0;
/* parse command-line parameters */
ret = parse_cmdline(csa, argc, argv);
if (ret < 0)
{ ret = EXIT_SUCCESS;
goto done;
}
if (ret > 0)
{ ret = EXIT_FAILURE;
goto done;
}
/*--------------------------------------------------------------*/
/* remove all output files specified in the command line */
if (csa->out_dpy != NULL) remove(csa->out_dpy);
if (csa->out_sol != NULL) remove(csa->out_sol);
if (csa->out_res != NULL) remove(csa->out_res);
if (csa->out_bnds != NULL) remove(csa->out_bnds);
if (csa->out_mps != NULL) remove(csa->out_mps);
if (csa->out_freemps != NULL) remove(csa->out_freemps);
if (csa->out_cpxlp != NULL) remove(csa->out_cpxlp);
if (csa->out_pb != NULL) remove(csa->out_pb);
if (csa->out_npb != NULL) remove(csa->out_npb);
if (csa->log_file != NULL) remove(csa->log_file);
/*--------------------------------------------------------------*/
/* open log file, if required */
if (csa->log_file != NULL)
{ if (lib_open_log(csa->log_file))
{ xprintf("Unable to create log file\n");
ret = EXIT_FAILURE;
goto done;
}
}
/*--------------------------------------------------------------*/
/* read problem data from the input file */
if (csa->in_file == NULL)
{ xprintf("No input problem file specified; try %s --help\n",
argv[0]);
ret = EXIT_FAILURE;
goto done;
}
if (csa->format == FMT_MPS_DECK)
{ ret = glp_read_mps(csa->prob, GLP_MPS_DECK, NULL,
csa->in_file);
if (ret != 0)
err1: { xprintf("MPS file processing error\n");
ret = EXIT_FAILURE;
goto done;
}
}
else if (csa->format == FMT_MPS_FILE)
{ ret = glp_read_mps(csa->prob, GLP_MPS_FILE, NULL,
csa->in_file);
if (ret != 0) goto err1;
}
else if (csa->format == FMT_CPLEX_LP)
{ ret = glp_read_lp(csa->prob, NULL, csa->in_file);
if (ret != 0)
{ xprintf("CPLEX LP file processing error\n");
ret = EXIT_FAILURE;
goto done;
}
}
else if (csa->format == FMT_MATHPROG)
{ int k;
/* allocate the translator workspace */
csa->tran = glp_mpl_alloc_wksp();
/* read model section and optional data section */
if (glp_mpl_read_model(csa->tran, csa->in_file, csa->ndf > 0))
err2: { xprintf("MathProg model processing error\n");
ret = EXIT_FAILURE;
goto done;
}
/* read optional data section(s), if necessary */
for (k = 1; k <= csa->ndf; k++)
{ if (glp_mpl_read_data(csa->tran, csa->in_data[k]))
goto err2;
}
/* generate the model */
if (glp_mpl_generate(csa->tran, csa->out_dpy)) goto err2;
/* build the problem instance from the model */
glp_mpl_build_prob(csa->tran, csa->prob);
}
else if (csa->format == FMT_MIN_COST)
{ csa->graph = glp_create_graph(sizeof(v_data), sizeof(a_data));
ret = glp_read_mincost(csa->graph, offsetof(v_data, rhs),
offsetof(a_data, low), offsetof(a_data, cap),
offsetof(a_data, cost), csa->in_file);
if (ret != 0)
{ xprintf("DIMACS file processing error\n");
ret = EXIT_FAILURE;
goto done;
}
glp_mincost_lp(csa->prob, csa->graph, GLP_ON,
offsetof(v_data, rhs), offsetof(a_data, low),
offsetof(a_data, cap), offsetof(a_data, cost));
glp_set_prob_name(csa->prob, csa->in_file);
}
else if (csa->format == FMT_MAX_FLOW)
{ int s, t;
csa->graph = glp_create_graph(sizeof(v_data), sizeof(a_data));
ret = glp_read_maxflow(csa->graph, &s, &t,
offsetof(a_data, cap), csa->in_file);
if (ret != 0)
{ xprintf("DIMACS file processing error\n");
ret = EXIT_FAILURE;
goto done;
}
glp_maxflow_lp(csa->prob, csa->graph, GLP_ON, s, t,
offsetof(a_data, cap));
glp_set_prob_name(csa->prob, csa->in_file);
}
else
xassert(csa != csa);
/*--------------------------------------------------------------*/
/* change problem name, if required */
if (csa->new_name != NULL)
glp_set_prob_name(csa->prob, csa->new_name);
/* change optimization direction, if required */
if (csa->dir != 0)
glp_set_obj_dir(csa->prob, csa->dir);
/* order rows and columns of the constraint matrix */
lpx_order_matrix(csa->prob);
/*--------------------------------------------------------------*/
/* write problem data in fixed MPS format, if required */
if (csa->out_mps != NULL)
{ ret = glp_write_mps(csa->prob, GLP_MPS_DECK, NULL,
csa->out_mps);
if (ret != 0)
{ xprintf("Unable to write problem in fixed MPS format\n");
ret = EXIT_FAILURE;
goto done;
}
}
/* write problem data in free MPS format, if required */
if (csa->out_freemps != NULL)
{ ret = glp_write_mps(csa->prob, GLP_MPS_FILE, NULL,
csa->out_freemps);
if (ret != 0)
{ xprintf("Unable to write problem in free MPS format\n");
ret = EXIT_FAILURE;
goto done;
}
}
/* write problem data in CPLEX LP format, if required */
if (csa->out_cpxlp != NULL)
{ ret = glp_write_lp(csa->prob, NULL, csa->out_cpxlp);
if (ret != 0)
{ xprintf("Unable to write problem in CPLEX LP format\n");
ret = EXIT_FAILURE;
goto done;
}
}
/* write problem data in OPB format, if required */
if (csa->out_pb != NULL)
{ ret = lpx_write_pb(csa->prob, csa->out_pb, 0, 0);
if (ret != 0)
{ xprintf("Unable to write problem in OPB format\n");
ret = EXIT_FAILURE;
goto done;
}
}
/* write problem data in normalized OPB format, if required */
if (csa->out_npb != NULL)
{ ret = lpx_write_pb(csa->prob, csa->out_npb, 1, 1);
if (ret != 0)
{ xprintf(
"Unable to write problem in normalized OPB format\n");
ret = EXIT_FAILURE;
goto done;
}
}
/*--------------------------------------------------------------*/
/* if only problem data check is required, skip computations */
if (csa->check)
{ ret = EXIT_SUCCESS;
goto done;
}
/*--------------------------------------------------------------*/
/* determine the solution type */
if (!csa->nomip &&
glp_get_num_int(csa->prob) + glp_get_num_bin(csa->prob) > 0)
{ if (csa->solution == SOL_INTERIOR)
{ xprintf("Interior-point method is not able to solve MIP pro"
"blem; use --simplex\n");
ret = EXIT_FAILURE;
goto done;
}
csa->solution = SOL_INTEGER;
}
/*--------------------------------------------------------------*/
/* if solution is provided, read it and skip computations */
if (csa->in_res != NULL)
{ if (csa->solution == SOL_BASIC)
ret = glp_read_sol(csa->prob, csa->in_res);
else if (csa->solution == SOL_INTERIOR)
ret = glp_read_ipt(csa->prob, csa->in_res);
else if (csa->solution == SOL_INTEGER)
ret = glp_read_mip(csa->prob, csa->in_res);
else
xassert(csa != csa);
if (ret != 0)
{ xprintf("Unable to read problem solution\n");
ret = EXIT_FAILURE;
goto done;
}
goto skip;
}
/*--------------------------------------------------------------*/
/* scale the problem data, if required */
if (csa->scale)
{ if (csa->solution == SOL_BASIC && !csa->smcp.presolve ||
csa->solution == SOL_INTERIOR ||
csa->solution == SOL_INTEGER && !csa->iocp.presolve)
glp_scale_prob(csa->prob, GLP_SF_AUTO);
}
/* construct starting LP basis */
if (csa->solution == SOL_BASIC && !csa->smcp.presolve ||
csa->solution == SOL_INTEGER && !csa->iocp.presolve)
{ if (csa->crash == USE_STD_BASIS)
glp_std_basis(csa->prob);
else if (csa->crash == USE_ADV_BASIS)
glp_adv_basis(csa->prob, 0);
else if (csa->crash == USE_CPX_BASIS)
glp_cpx_basis(csa->prob);
else
xassert(csa != csa);
}
/*--------------------------------------------------------------*/
/* solve the problem */
start = xtime();
if (csa->solution == SOL_BASIC)
{ if (!csa->exact)
{ glp_set_bfcp(csa->prob, &csa->bfcp);
glp_simplex(csa->prob, &csa->smcp);
if (csa->xcheck)
{ if (csa->smcp.presolve &&
glp_get_status(csa->prob) != GLP_OPT)
xprintf("If you need to check final basis for non-opt"
"imal solution, use --nopresol\n");
else
glp_exact(csa->prob, &csa->smcp);
}
if (csa->out_sol != NULL || csa->out_res != NULL)
{ if (csa->smcp.presolve &&
glp_get_status(csa->prob) != GLP_OPT)
xprintf("If you need actual output for non-optimal solut"
"ion, use --nopresol\n");
}
}
else
glp_exact(csa->prob, &csa->smcp);
}
else if (csa->solution == SOL_INTERIOR)
glp_interior(csa->prob, NULL);
else if (csa->solution == SOL_INTEGER)
{ if (!csa->iocp.presolve)
{ glp_set_bfcp(csa->prob, &csa->bfcp);
glp_simplex(csa->prob, &csa->smcp);
}
glp_intopt(csa->prob, &csa->iocp);
}
else
xassert(csa != csa);
/*--------------------------------------------------------------*/
/* display statistics */
xprintf("Time used: %.1f secs\n", xdifftime(xtime(), start));
{ xlong_t tpeak;
char buf[50];
lib_mem_usage(NULL, NULL, NULL, &tpeak);
xprintf("Memory used: %.1f Mb (%s bytes)\n",
xltod(tpeak) / 1048576.0, xltoa(tpeak, buf));
}
/*--------------------------------------------------------------*/
skip: /* postsolve the model, if necessary */
if (csa->tran != NULL)
{ if (csa->solution == SOL_BASIC)
ret = glp_mpl_postsolve(csa->tran, csa->prob, GLP_SOL);
else if (csa->solution == SOL_INTERIOR)
ret = glp_mpl_postsolve(csa->tran, csa->prob, GLP_IPT);
else if (csa->solution == SOL_INTEGER)
ret = glp_mpl_postsolve(csa->tran, csa->prob, GLP_MIP);
else
xassert(csa != csa);
if (ret != 0)
{ xprintf("Model postsolving error\n");
ret = EXIT_FAILURE;
goto done;
}
}
/*--------------------------------------------------------------*/
/* write problem solution in printable format, if required */
if (csa->out_sol != NULL)
{ if (csa->solution == SOL_BASIC)
ret = lpx_print_sol(csa->prob, csa->out_sol);
else if (csa->solution == SOL_INTERIOR)
ret = lpx_print_ips(csa->prob, csa->out_sol);
else if (csa->solution == SOL_INTEGER)
ret = lpx_print_mip(csa->prob, csa->out_sol);
else
xassert(csa != csa);
if (ret != 0)
{ xprintf("Unable to write problem solution\n");
ret = EXIT_FAILURE;
goto done;
}
}
/* write problem solution in printable format, if required */
if (csa->out_res != NULL)
{ if (csa->solution == SOL_BASIC)
ret = glp_write_sol(csa->prob, csa->out_res);
else if (csa->solution == SOL_INTERIOR)
ret = glp_write_ipt(csa->prob, csa->out_res);
else if (csa->solution == SOL_INTEGER)
ret = glp_write_mip(csa->prob, csa->out_res);
else
xassert(csa != csa);
if (ret != 0)
{ xprintf("Unable to write problem solution\n");
ret = EXIT_FAILURE;
goto done;
}
}
/* write sensitivity bounds information, if required */
if (csa->out_bnds != NULL)
{ if (csa->solution == SOL_BASIC)
{ ret = lpx_print_sens_bnds(csa->prob, csa->out_bnds);
if (ret != 0)
{ xprintf("Unable to write sensitivity bounds information "
"\n");
ret = EXIT_FAILURE;
goto done;
}
}
else
xprintf("Cannot write sensitivity bounds information for in"
"terior-point or MIP solution\n");
}
/*--------------------------------------------------------------*/
/* all seems to be ok */
ret = EXIT_SUCCESS;
/*--------------------------------------------------------------*/
done: /* delete the LP/MIP problem object */
if (csa->prob != NULL)
glp_delete_prob(csa->prob);
/* free the translator workspace, if necessary */
if (csa->tran != NULL)
glp_mpl_free_wksp(csa->tran);
/* delete the network problem object, if necessary */
if (csa->graph != NULL)
glp_delete_graph(csa->graph);
xassert(gmp_pool_count() == 0);
gmp_free_mem();
/* close log file, if necessary */
if (csa->log_file != NULL) lib_close_log();
/* check that no memory blocks are still allocated */
{ int count;
xlong_t total;
lib_mem_usage(&count, NULL, &total, NULL);
if (count != 0)
xerror("Error: %d memory block(s) were lost\n", count);
xassert(count == 0);
xassert(total.lo == 0 && total.hi == 0);
}
/* free the library environment */
lib_free_env();
/* return to the control program */
return ret;
}
// read in all necessary elements for retrieving the LP/MILP
void Rglpk_read_file (char **file, int *type,
int *lp_direction_of_optimization,
int *lp_n_constraints, int *lp_n_objective_vars,
int *lp_n_values_in_constraint_matrix,
int *lp_n_integer_vars, int *lp_n_binary_vars,
char **lp_prob_name,
char **lp_obj_name,
int *lp_verbosity) {
int status;
extern glp_prob *lp;
glp_tran *tran;
const char *str;
// Turn on/off Terminal Output
if (*lp_verbosity==1)
glp_term_out(GLP_ON);
else
glp_term_out(GLP_OFF);
// create problem object
if (lp)
glp_delete_prob(lp);
lp = glp_create_prob();
// read file -> gets stored as an GLPK problem object 'lp'
// which file type do we have?
switch (*type){
case 1:
// Fixed (ancient) MPS Format, param argument currently NULL
status = glp_read_mps(lp, GLP_MPS_DECK, NULL, *file);
break;
case 2:
// Free (modern) MPS format, param argument currently NULL
status = glp_read_mps(lp, GLP_MPS_FILE, NULL, *file);
break;
case 3:
// CPLEX LP Format
status = glp_read_lp(lp, NULL, *file);
break;
case 4:
// MATHPROG Format (based on lpx_read_model function)
tran = glp_mpl_alloc_wksp();
status = glp_mpl_read_model(tran, *file, 0);
if (!status) {
status = glp_mpl_generate(tran, NULL);
if (!status) {
glp_mpl_build_prob(tran, lp);
}
}
glp_mpl_free_wksp(tran);
break;
}
// if file read successfully glp_read_* returns zero
if ( status != 0 ) {
glp_delete_prob(lp);
lp = NULL;
error("Reading file %s failed", *file);
}
// retrieve problem name
str = glp_get_prob_name(lp);
if (str){
*lp_prob_name = (char *) str;
}
// retrieve name of objective function
str = glp_get_obj_name(lp);
if (str){
*lp_obj_name = (char *) str;
}
// retrieve optimization direction flag
*lp_direction_of_optimization = glp_get_obj_dir(lp);
// retrieve number of constraints
*lp_n_constraints = glp_get_num_rows(lp);
// retrieve number of objective variables
*lp_n_objective_vars = glp_get_num_cols(lp);
// retrieve number of non-zero elements in constraint matrix
*lp_n_values_in_constraint_matrix = glp_get_num_nz(lp);
// retrieve number of integer variables
*lp_n_integer_vars = glp_get_num_int(lp);
// retrieve number of binary variables
*lp_n_binary_vars = glp_get_num_bin(lp);
}
// retrieve all missing values of LP/MILP
void Rglpk_retrieve_MP_from_file (char **file, int *type,
int *lp_n_constraints,
int *lp_n_objective_vars,
double *lp_objective_coefficients,
int *lp_constraint_matrix_i,
int *lp_constraint_matrix_j,
double *lp_constraint_matrix_values,
int *lp_direction_of_constraints,
double *lp_right_hand_side,
double *lp_left_hand_side,
int *lp_objective_var_is_integer,
int *lp_objective_var_is_binary,
int *lp_bounds_type,
double *lp_bounds_lower,
double *lp_bounds_upper,
int *lp_ignore_first_row,
int *lp_verbosity,
char **lp_constraint_names,
char **lp_objective_vars_names
) {
extern glp_prob *lp;
glp_tran *tran;
const char *str;
int i, j, lp_column_kind, tmp;
int ind_offset, status;
// Turn on/off Terminal Output
if (*lp_verbosity==1)
glp_term_out(GLP_ON);
else
glp_term_out(GLP_OFF);
// create problem object
if (lp)
glp_delete_prob(lp);
lp = glp_create_prob();
// read file -> gets stored as an GLPK problem object 'lp'
// which file type do we have?
switch (*type){
case 1:
// Fixed (ancient) MPS Format, param argument currently NULL
status = glp_read_mps(lp, GLP_MPS_DECK, NULL, *file);
break;
case 2:
// Free (modern) MPS format, param argument currently NULL
status = glp_read_mps(lp, GLP_MPS_FILE, NULL, *file);
break;
case 3:
// CPLEX LP Format
status = glp_read_lp(lp, NULL, *file);
break;
case 4:
// MATHPROG Format (based on lpx_read_model function)
tran = glp_mpl_alloc_wksp();
status = glp_mpl_read_model(tran, *file, 0);
if (!status) {
status = glp_mpl_generate(tran, NULL);
if (!status) {
glp_mpl_build_prob(tran, lp);
}
}
glp_mpl_free_wksp(tran);
break;
}
// if file read successfully glp_read_* returns zero
if ( status != 0 ) {
glp_delete_prob(lp);
lp = NULL;
error("Reading file %c failed.", *file);
}
if(*lp_verbosity==1)
Rprintf("Retrieve column specific data ...\n");
if(glp_get_num_cols(lp) != *lp_n_objective_vars) {
glp_delete_prob(lp);
lp = NULL;
error("The number of columns is not as specified");
}
// retrieve column specific data (values, bounds and type)
for (i = 0; i < *lp_n_objective_vars; i++) {
lp_objective_coefficients[i] = glp_get_obj_coef(lp, i+1);
// Note that str must not be freed befor we have returned
// from the .C call in R!
str = glp_get_col_name(lp, i+1);
if (str){
lp_objective_vars_names[i] = (char *) str;
}
lp_bounds_type[i] = glp_get_col_type(lp, i+1);
lp_bounds_lower[i] = glp_get_col_lb (lp, i+1);
lp_bounds_upper[i] = glp_get_col_ub (lp, i+1);
lp_column_kind = glp_get_col_kind(lp, i+1);
// set to TRUE if objective variable is integer or binary
switch (lp_column_kind){
case GLP_IV:
lp_objective_var_is_integer[i] = 1;
break;
case GLP_BV:
lp_objective_var_is_binary[i] = 1;
break;
}
}
ind_offset = 0;
if(*lp_verbosity==1)
Rprintf("Retrieve row specific data ...\n");
if(glp_get_num_rows(lp) != *lp_n_constraints) {
glp_delete_prob(lp);
lp = NULL;
error("The number of rows is not as specified");
}
// retrieve row specific data (right hand side, direction of constraints)
for (i = *lp_ignore_first_row; i < *lp_n_constraints; i++) {
lp_direction_of_constraints[i] = glp_get_row_type(lp, i+1);
str = glp_get_row_name(lp, i + 1);
if (str) {
lp_constraint_names[i] = (char *) str;
}
// the right hand side. Note we don't allow for double bounded or
// free auxiliary variables
if( lp_direction_of_constraints[i] == GLP_LO )
lp_right_hand_side[i] = glp_get_row_lb(lp, i+1);
if( lp_direction_of_constraints[i] == GLP_UP )
lp_right_hand_side[i] = glp_get_row_ub(lp, i+1);
if( lp_direction_of_constraints[i] == GLP_FX )
lp_right_hand_side[i] = glp_get_row_lb(lp, i+1);
if( lp_direction_of_constraints[i] == GLP_DB ){
lp_right_hand_side[i] = glp_get_row_ub(lp, i+1);
lp_left_hand_side[i] = glp_get_row_lb(lp, i+1);
}
tmp = glp_get_mat_row(lp, i+1, &lp_constraint_matrix_j[ind_offset-1],
&lp_constraint_matrix_values[ind_offset-1]);
if (tmp > 0)
for (j = 0; j < tmp; j++)
lp_constraint_matrix_i[ind_offset+j] = i+1;
ind_offset += tmp;
}
if(*lp_verbosity==1)
Rprintf("Done.\n");
}