void pyglpk_kkt_check(glp_prob *lp, int scaling, pyglpk_kkt_t *kkt)
{
#if GLPK_VERSION(4, 49)
int m = glp_get_num_rows(lp);
/* check primal equality constraints */
glp_check_kkt(lp, GLP_SOL, GLP_KKT_PE,
&(kkt->pe_ae_max), &(kkt->pe_ae_row),
&(kkt->pe_re_max), &(kkt->pe_re_row));
kkt->pe_quality = quality(kkt->pe_re_max);
/* check primal bound constraints */
glp_check_kkt(lp, GLP_SOL, GLP_KKT_PB,
&(kkt->pb_ae_max), &(kkt->pb_ae_ind),
&(kkt->pb_re_max), &(kkt->pb_re_ind));
kkt->pb_quality = quality(kkt->pb_re_max);
/* check dual equality constraints */
glp_check_kkt(lp, GLP_SOL, GLP_KKT_DE,
&(kkt->de_ae_max), &(kkt->de_ae_col),
&(kkt->de_re_max), &(kkt->de_re_col));
kkt->de_ae_col = kkt->de_ae_col == 0 ? 0 : kkt->de_ae_col - m;
kkt->de_re_col = kkt->de_re_col == 0 ? 0 : kkt->de_re_col - m;
kkt->de_quality = quality(kkt->de_re_max);
/* check dual bound constraints */
glp_check_kkt(lp, GLP_SOL, GLP_KKT_DB,
&(kkt->db_ae_max), &(kkt->db_ae_ind),
&(kkt->db_re_max), &(kkt->db_re_ind));
kkt->db_quality = quality(kkt->db_re_max);
#else
lpx_check_kkt(lp, scaling, kkt);
#endif
}
static PyObject* LPX_getray(LPXObject *self, void *closure) {
int ray = lpx_get_ray_info(LP), numrows;
if (ray==0) Py_RETURN_NONE;
numrows = glp_get_num_rows(LP);
ray--;
if (ray < numrows) return PySequence_GetItem(self->rows, ray);
return PySequence_GetItem(self->cols, ray - numrows);
}
void glp_unscale_prob(glp_prob *lp)
{ int m = glp_get_num_rows(lp);
int n = glp_get_num_cols(lp);
int i, j;
for (i = 1; i <= m; i++) glp_set_rii(lp, i, 1.0);
for (j = 1; j <= n; j++) glp_set_sjj(lp, j, 1.0);
return;
}
void glpk_wrapper::get_error_bounds(double * errors) {
int n = domain.size();
int * nbr_non_zero = new int[n];
for (int i = 0; i < n; i++) {
errors[i] = INFINITY;
nbr_non_zero[i] = 0;
}
// get the error on the KKT condition
int sol;
if (solver_type == SIMPLEX || solver_type == EXACT) {
sol = GLP_SOL;
} else {
sol = GLP_IPT;
}
double ae_max; // largest absolute error
int ae_ind; // number of row (PE), column (DE), or variable (PB, DB) with the largest absolute error
double re_max; // largest relative error
int re_ind; // number of row (PE), column (DE), or variable (PB, DB) with the largest relative error
// GLP_KKT_PE — check primal equality constraints
glp_check_kkt(lp, sol, GLP_KKT_PE, &ae_max, &ae_ind, &re_max, &re_ind);
// a sparse vector for the coeffs in the row
int row_size = 1;
int * row_idx = new int[n + 1];
double * row_coeff = new double[n + 1];
// PE
// gives the distance between the auxiliary var and A * strucutral variable
int m = glp_get_num_rows(lp);
for (int i = 1; i <= m ; ++i) {
// get the coeffs for that constraint
row_size = glp_get_mat_row(lp, i, row_idx, row_coeff);
for (int j = 1; j <= row_size; j++) {
int v = row_idx[j] - 1; // GLPK indexing
nbr_non_zero[v] += 1;
int c = row_coeff[j];
// relative error
errors[v] = std::min(errors[v], get_row_value(i) * re_max / c);
// absolute error
errors[v] = std::min(errors[v], ae_max / c);
}
}
// variables that don't matter
for (int i = 0; i < n; i++) {
if (nbr_non_zero[i] == 0) {
errors[i] = 0;
}
DREAL_LOG_INFO << "glpk_wrapper::get_error_bounds: error for " << domain.get_name(i) << " is " << errors[i];
}
delete[] nbr_non_zero;
delete[] row_idx;
delete[] row_coeff;
}
int GLPKAddConstraint(LinEquation* InEquation) {
if (InEquation->QuadCoeff.size() > 0) {
FErrorFile() << "GLPK solver cannot accept quadratic constraints." << endl;
FlushErrorFile();
return FAIL;
}
if (GLPKModel == NULL) {
FErrorFile() << "Could not add constraint because GLPK object does not exist." << endl;
FlushErrorFile();
return FAIL;
}
int NumRows = glp_get_num_rows(GLPKModel);
if (InEquation->Index >= NumRows) {
glp_add_rows(GLPKModel, 1);
}
if (InEquation->EqualityType == EQUAL) {
glp_set_row_bnds(GLPKModel, InEquation->Index+1, GLP_FX, InEquation->RightHandSide, InEquation->RightHandSide);
} else if (InEquation->EqualityType == GREATER) {
glp_set_row_bnds(GLPKModel, InEquation->Index+1, GLP_LO, InEquation->RightHandSide, InEquation->RightHandSide);
} else if (InEquation->EqualityType == LESS) {
glp_set_row_bnds(GLPKModel, InEquation->Index+1, GLP_UP, InEquation->RightHandSide, InEquation->RightHandSide);
} else {
FErrorFile() << "Could not add constraint because the constraint type was not recognized." << endl;
FlushErrorFile();
return FAIL;
}
int NumColumns = glp_get_num_cols(GLPKModel);
int* Indecies = new int[int(InEquation->Variables.size())+1];
double* Coeff = new double[int(InEquation->Variables.size())+1];
for (int i=0; i < int(InEquation->Variables.size()); i++) {
if (InEquation->Variables[i]->Index < NumColumns) {
if (InEquation->Variables[i]->Exclude) {
Coeff[i+1] = 0;
} else {
Coeff[i+1] = InEquation->Coefficient[i];
}
Indecies[i+1] = InEquation->Variables[i]->Index+1;
} else {
FErrorFile() << "Variable index found in constraint is out of the range found in GLPK problem" << endl;
FlushErrorFile();
return FAIL;
}
}
glp_set_mat_row(GLPKModel, InEquation->Index+1, int(InEquation->Variables.size()), Indecies, Coeff);
delete [] Indecies;
delete [] Coeff;
return SUCCESS;
}
int main(int argc, char *argv[])
{
leEstradas();
glp_prob *lp = montarModeloInicial();
while(1){
glp_intopt(lp, NULL); // acha solucao com restricao de integralidade
printf("Solucao Otima: %.3f\n", glp_mip_obj_val(lp));
printf("X1: %.3f\n", glp_mip_col_val(lp, 1));
printf("X2: %.3f\n", glp_mip_col_val(lp, 2));
printf("X3: %.3f\n", glp_mip_col_val(lp, 3));
int arestaEscolhida[1234];
for(int est = 1; est) {
arestaEscolhida[est] = glp_mip_col_val(lp, est);
}
int verticesAlcancados[123];
for( ) ; // para contar se todos os vertices foram alcancados
// se tiverem sido, de um break e mostre a resposta;
encontraVerticesAlcancaveis(arestaEscolhida, verticesAlcancados);
glp_add_row(lp, 1);
int indCol[123];
double val[123];
int nCoef = 0;
for (int e = 1; e <= nArestas; ++e) {
Estrada estrada = estradas[e];
int nextremosAlcancados = verticesAlcancados[estrada.ori] +
verticesAlcancados[estrada.dest];
if (nextremosAlcancados == 1) {
indCol[nCoef + 1] = e;
val[nCoef + 1] = 1.0;
}
}
glp_set_mat_row(lp, glp_get_num_rows(lp), nCoef, indCol, val);
glp_set_row_bnds(lp, glp_get_num_rows(lp), GLP_LO, 2.0, 2.0);
system("PAUSE");
return EXIT_SUCCESS;
}
PyObject *LPX_GetMatrix(LPXObject *self)
{
int row, numrows, listi, i, nnz, rownz;
PyObject *retval;
numrows = glp_get_num_rows(LP);
nnz = glp_get_num_nz(LP);
retval = PyList_New(nnz);
if (nnz == 0 || retval == NULL)
return retval;
// We don't really need this much memory, but, eh...
int *ind = (int*)calloc(nnz, sizeof(int));
double *val = (double*)calloc(nnz, sizeof(double));
listi = 0;
for (row=1; row<=numrows; ++row) {
rownz = glp_get_mat_row(LP, row, ind-1, val-1);
if (rownz == 0)
continue;
for (i = 0; i < rownz; ++i) {
PyList_SET_ITEM(retval, listi++, Py_BuildValue("iid", row - 1, ind[i] - 1, val[i]));
}
/*
* Continue to downscale these vectors, freeing memory in C even
* as we use more memory in Python.
*/
nnz -= rownz;
if (nnz) {
ind = (int*)realloc(ind, nnz*sizeof(int));
val = (double*)realloc(val, nnz*sizeof(double));
}
}
free(ind);
free(val);
if (PyList_Sort(retval)) {
Py_DECREF(retval);
return NULL;
}
return retval;
}
vector<int> LinearProblem::ElasticFilter() const {
LinearProblem tmp(*this);
int realCols = glp_get_num_cols(tmp.lp_);
for (int i = realCols; i > 0; --i) { // set old coefs to zero
glp_set_obj_coef(tmp.lp_, i, 0);
}
int elasticCols = glp_get_num_rows(tmp.lp_);
glp_add_cols(tmp.lp_, elasticCols);
for (int i = 1; i <= elasticCols; ++i) {
int indices[MAX_VARS];
double values[MAX_VARS];
int nonZeros = glp_get_mat_row(tmp.lp_, i, indices, values);
indices[nonZeros + 1] = realCols + i;
values[nonZeros + 1] = 1.0;
glp_set_mat_row(tmp.lp_, i, nonZeros + 1, indices, values);
glp_set_obj_coef(tmp.lp_, realCols + i, 1);
glp_set_col_bnds(tmp.lp_, realCols + i, GLP_UP, 0.0, 0.0);
}
vector<int> suspects;
glp_std_basis(tmp.lp_);
int status = tmp.Solve();
while ((status != GLP_INFEAS) && (status != GLP_NOFEAS)) {
for (int i = 1; i <= elasticCols; ++i) {
if (glp_get_col_prim(tmp.lp_, realCols + i) < 0) {
suspects.push_back(i);
glp_set_col_bnds(tmp.lp_, realCols + i, GLP_FX, 0.0, 0.0);
}
}
status = tmp.Solve();
}
return suspects;
}
int glp_mpl_postsolve(glp_tran *tran, glp_prob *prob, int sol)
{ /* postsolve the model */
int j, m, n, ret;
double x;
if (!(tran->phase == 3 && !tran->flag_p))
xerror("glp_mpl_postsolve: invalid call sequence\n");
if (!(sol == GLP_SOL || sol == GLP_IPT || sol == GLP_MIP))
xerror("glp_mpl_postsolve: sol = %d; invalid parameter\n",
sol);
m = mpl_get_num_rows(tran);
n = mpl_get_num_cols(tran);
if (!(m == glp_get_num_rows(prob) &&
n == glp_get_num_cols(prob)))
xerror("glp_mpl_postsolve: wrong problem object\n");
if (!mpl_has_solve_stmt(tran))
{ ret = 0;
goto done;
}
for (j = 1; j <= n; j++)
{ if (sol == GLP_SOL)
x = glp_get_col_prim(prob, j);
else if (sol == GLP_IPT)
x = glp_ipt_col_prim(prob, j);
else if (sol == GLP_MIP)
x = glp_mip_col_val(prob, j);
else
xassert(sol != sol);
if (fabs(x) < 1e-9) x = 0.0;
mpl_put_col_value(tran, j, x);
}
ret = mpl_postsolve(tran);
if (ret == 3)
ret = 0;
else if (ret == 4)
ret = 1;
done: return ret;
}
int c_glp_get_num_rows (glp_prob *lp){
return glp_get_num_rows (lp);
}
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);
}
int glp_mpl_postsolve(glp_tran *tran, glp_prob *prob, int sol)
{ /* postsolve the model */
int i, j, m, n, stat, ret;
double prim, dual;
if (!(tran->phase == 3 && !tran->flag_p))
xerror("glp_mpl_postsolve: invalid call sequence\n");
if (!(sol == GLP_SOL || sol == GLP_IPT || sol == GLP_MIP))
xerror("glp_mpl_postsolve: sol = %d; invalid parameter\n",
sol);
m = mpl_get_num_rows(tran);
n = mpl_get_num_cols(tran);
if (!(m == glp_get_num_rows(prob) &&
n == glp_get_num_cols(prob)))
xerror("glp_mpl_postsolve: wrong problem object\n");
if (!mpl_has_solve_stmt(tran))
{ ret = 0;
goto done;
}
for (i = 1; i <= m; i++)
{ if (sol == GLP_SOL)
{ stat = glp_get_row_stat(prob, i);
prim = glp_get_row_prim(prob, i);
dual = glp_get_row_dual(prob, i);
}
else if (sol == GLP_IPT)
{ stat = 0;
prim = glp_ipt_row_prim(prob, i);
dual = glp_ipt_row_dual(prob, i);
}
else if (sol == GLP_MIP)
{ stat = 0;
prim = glp_mip_row_val(prob, i);
dual = 0.0;
}
else
xassert(sol != sol);
if (fabs(prim) < 1e-9) prim = 0.0;
if (fabs(dual) < 1e-9) dual = 0.0;
mpl_put_row_soln(tran, i, stat, prim, dual);
}
for (j = 1; j <= n; j++)
{ if (sol == GLP_SOL)
{ stat = glp_get_col_stat(prob, j);
prim = glp_get_col_prim(prob, j);
dual = glp_get_col_dual(prob, j);
}
else if (sol == GLP_IPT)
{ stat = 0;
prim = glp_ipt_col_prim(prob, j);
dual = glp_ipt_col_dual(prob, j);
}
else if (sol == GLP_MIP)
{ stat = 0;
prim = glp_mip_col_val(prob, j);
dual = 0.0;
}
else
xassert(sol != sol);
if (fabs(prim) < 1e-9) prim = 0.0;
if (fabs(dual) < 1e-9) dual = 0.0;
mpl_put_col_soln(tran, j, stat, prim, dual);
}
ret = mpl_postsolve(tran);
if (ret == 3)
ret = 0;
else if (ret == 4)
ret = 1;
done: return ret;
}
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;
}
static PyObject* LPX_Str(LPXObject *self) {
// Returns a string representation of this object.
return PyString_FromFormat
("<%s %d-by-%d at %p>", self->ob_type->tp_name,
glp_get_num_rows(LP), glp_get_num_cols(LP), self);
}
int lpx_get_num_rows(LPX *lp)
{ /* retrieve number of rows */
return glp_get_num_rows(lp);
}
// 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");
}
