int glp_asnprob_lp(glp_prob *P, int form, glp_graph *G, int names,
int v_set, int a_cost)
{ glp_vertex *v;
glp_arc *a;
int i, j, ret, ind[1+2];
double cost, val[1+2];
if (!(form == GLP_ASN_MIN || form == GLP_ASN_MAX ||
form == GLP_ASN_MMP))
xerror("glp_asnprob_lp: form = %d; invalid parameter\n",
form);
if (!(names == GLP_ON || names == GLP_OFF))
xerror("glp_asnprob_lp: names = %d; invalid parameter\n",
names);
if (v_set >= 0 && v_set > G->v_size - (int)sizeof(int))
xerror("glp_asnprob_lp: v_set = %d; invalid offset\n",
v_set);
if (a_cost >= 0 && a_cost > G->a_size - (int)sizeof(double))
xerror("glp_asnprob_lp: a_cost = %d; invalid offset\n",
a_cost);
ret = glp_check_asnprob(G, v_set);
if (ret != 0) goto done;
glp_erase_prob(P);
if (names) glp_set_prob_name(P, G->name);
glp_set_obj_dir(P, form == GLP_ASN_MIN ? GLP_MIN : GLP_MAX);
if (G->nv > 0) glp_add_rows(P, G->nv);
for (i = 1; i <= G->nv; i++)
{ v = G->v[i];
if (names) glp_set_row_name(P, i, v->name);
glp_set_row_bnds(P, i, form == GLP_ASN_MMP ? GLP_UP : GLP_FX,
1.0, 1.0);
}
if (G->na > 0) glp_add_cols(P, G->na);
for (i = 1, j = 0; i <= G->nv; i++)
{ v = G->v[i];
for (a = v->out; a != NULL; a = a->t_next)
{ j++;
if (names)
{ char name[50+1];
sprintf(name, "x[%d,%d]", a->tail->i, a->head->i);
xassert(strlen(name) < sizeof(name));
glp_set_col_name(P, j, name);
}
ind[1] = a->tail->i, val[1] = +1.0;
ind[2] = a->head->i, val[2] = +1.0;
glp_set_mat_col(P, j, 2, ind, val);
glp_set_col_bnds(P, j, GLP_DB, 0.0, 1.0);
if (a_cost >= 0)
memcpy(&cost, (char *)a->data + a_cost, sizeof(double));
else
cost = 1.0;
glp_set_obj_coef(P, j, cost);
}
}
xassert(j == G->na);
done:
return ret;
}
int CMyProblem::ConstructLP(const char* model_file)
{
//надо проверить чего-нибудь
glp_erase_prob(lp);
glp_tran *tran;
int ret;
tran = glp_mpl_alloc_wksp();
try{
ret = glp_mpl_read_model(tran, model_file, 1);
if (ret != 0)
{
cerr << "Error on translating model\n";
throw MyException();
}
string data_file = name;
data_file+=".dat";
WriteMathProg(data_file.c_str());
ret = glp_mpl_read_data(tran, data_file.c_str());
if (ret != 0)
{
cerr << "Error on translating data\n";
throw MyException();
}
ret = glp_mpl_generate(tran, NULL);
if (ret != 0)
{
cerr << "Error on generating model\n";
throw MyException();
}
glp_mpl_build_prob(tran, lp);
glp_set_prob_name(lp, name.c_str());
//вот тут я разрушаю транслятор, что делать с postsolve непонятно, но пока оно не надо
glp_mpl_free_wksp(tran);
}
catch(MyException){
glp_mpl_free_wksp(tran);
glp_erase_prob(lp);
return ret;
}
return 0;
}
static PyObject* LPX_Erase(LPXObject *self) {
#if GLPK_VERSION(4, 29)
glp_erase_prob(LP);
#else
// Approximate the functionality by deleting and reassigning the
// underlying pointer. The Python code shouldn't actually know the
// difference.
if (LP) glp_delete_prob(LP);
self->lp = glp_create_prob();
#endif
Py_RETURN_NONE;
}
void glp_copy_prob(glp_prob *dest, glp_prob *prob, int names)
{ glp_tree *tree = dest->tree;
glp_bfcp bfcp;
int i, j, len, *ind;
double *val;
if (tree != NULL && tree->reason != 0)
xerror("glp_copy_prob: operation not allowed\n");
if (dest == prob)
xerror("glp_copy_prob: copying problem object to itself not al"
"lowed\n");
if (!(names == GLP_ON || names == GLP_OFF))
xerror("glp_copy_prob: names = %d; invalid parameter\n",
names);
glp_erase_prob(dest);
if (names && prob->name != NULL)
glp_set_prob_name(dest, prob->name);
if (names && prob->obj != NULL)
glp_set_obj_name(dest, prob->obj);
dest->dir = prob->dir;
dest->c0 = prob->c0;
if (prob->m > 0)
glp_add_rows(dest, prob->m);
if (prob->n > 0)
glp_add_cols(dest, prob->n);
glp_get_bfcp(prob, &bfcp);
glp_set_bfcp(dest, &bfcp);
dest->pbs_stat = prob->pbs_stat;
dest->dbs_stat = prob->dbs_stat;
dest->obj_val = prob->obj_val;
dest->some = prob->some;
dest->ipt_stat = prob->ipt_stat;
dest->ipt_obj = prob->ipt_obj;
dest->mip_stat = prob->mip_stat;
dest->mip_obj = prob->mip_obj;
for (i = 1; i <= prob->m; i++)
{ GLPROW *to = dest->row[i];
GLPROW *from = prob->row[i];
if (names && from->name != NULL)
glp_set_row_name(dest, i, from->name);
to->type = from->type;
to->lb = from->lb;
to->ub = from->ub;
to->rii = from->rii;
to->stat = from->stat;
to->prim = from->prim;
to->dual = from->dual;
to->pval = from->pval;
to->dval = from->dval;
to->mipx = from->mipx;
}
ind = xcalloc(1+prob->m, sizeof(int));
val = xcalloc(1+prob->m, sizeof(double));
for (j = 1; j <= prob->n; j++)
{ GLPCOL *to = dest->col[j];
GLPCOL *from = prob->col[j];
if (names && from->name != NULL)
glp_set_col_name(dest, j, from->name);
to->kind = from->kind;
to->type = from->type;
to->lb = from->lb;
to->ub = from->ub;
to->coef = from->coef;
len = glp_get_mat_col(prob, j, ind, val);
glp_set_mat_col(dest, j, len, ind, val);
to->sjj = from->sjj;
to->stat = from->stat;
to->prim = from->prim;
to->dual = from->dual;
to->pval = from->pval;
to->dval = from->dval;
to->mipx = from->mipx;
}
xfree(ind);
xfree(val);
return;
}
void glp_maxflow_lp(glp_prob *lp, glp_graph *G, int names, int s,
int t, int a_cap)
{ glp_vertex *v;
glp_arc *a;
int i, j, type, ind[1+2];
double cap, val[1+2];
if (!(names == GLP_ON || names == GLP_OFF))
xerror("glp_maxflow_lp: names = %d; invalid parameter\n",
names);
if (!(1 <= s && s <= G->nv))
xerror("glp_maxflow_lp: s = %d; source node number out of rang"
"e\n", s);
if (!(1 <= t && t <= G->nv))
xerror("glp_maxflow_lp: t = %d: sink node number out of range "
"\n", t);
if (s == t)
xerror("glp_maxflow_lp: s = t = %d; source and sink nodes must"
" be distinct\n", s);
if (a_cap >= 0 && a_cap > G->a_size - (int)sizeof(double))
xerror("glp_maxflow_lp: a_cap = %d; invalid offset\n", a_cap);
glp_erase_prob(lp);
if (names) glp_set_prob_name(lp, G->name);
glp_set_obj_dir(lp, GLP_MAX);
glp_add_rows(lp, G->nv);
for (i = 1; i <= G->nv; i++)
{ v = G->v[i];
if (names) glp_set_row_name(lp, i, v->name);
if (i == s)
type = GLP_LO;
else if (i == t)
type = GLP_UP;
else
type = GLP_FX;
glp_set_row_bnds(lp, i, type, 0.0, 0.0);
}
if (G->na > 0) glp_add_cols(lp, G->na);
for (i = 1, j = 0; i <= G->nv; i++)
{ v = G->v[i];
for (a = v->out; a != NULL; a = a->t_next)
{ j++;
if (names)
{ char name[50+1];
sprintf(name, "x[%d,%d]", a->tail->i, a->head->i);
xassert(strlen(name) < sizeof(name));
glp_set_col_name(lp, j, name);
}
if (a->tail->i != a->head->i)
{ ind[1] = a->tail->i, val[1] = +1.0;
ind[2] = a->head->i, val[2] = -1.0;
glp_set_mat_col(lp, j, 2, ind, val);
}
if (a_cap >= 0)
memcpy(&cap, (char *)a->data + a_cap, sizeof(double));
else
cap = 1.0;
if (cap == DBL_MAX)
type = GLP_LO;
else if (cap != 0.0)
type = GLP_DB;
else
type = GLP_FX;
glp_set_col_bnds(lp, j, type, 0.0, cap);
if (a->tail->i == s)
glp_set_obj_coef(lp, j, +1.0);
else if (a->head->i == s)
glp_set_obj_coef(lp, j, -1.0);
}
}
xassert(j == G->na);
return;
}
void glp_mincost_lp(glp_prob *lp, glp_graph *G, int names, int v_rhs,
int a_low, int a_cap, int a_cost)
{ glp_vertex *v;
glp_arc *a;
int i, j, type, ind[1+2];
double rhs, low, cap, cost, val[1+2];
if (!(names == GLP_ON || names == GLP_OFF))
xerror("glp_mincost_lp: names = %d; invalid parameter\n",
names);
if (v_rhs >= 0 && v_rhs > G->v_size - (int)sizeof(double))
xerror("glp_mincost_lp: v_rhs = %d; invalid offset\n", v_rhs);
if (a_low >= 0 && a_low > G->a_size - (int)sizeof(double))
xerror("glp_mincost_lp: a_low = %d; invalid offset\n", a_low);
if (a_cap >= 0 && a_cap > G->a_size - (int)sizeof(double))
xerror("glp_mincost_lp: a_cap = %d; invalid offset\n", a_cap);
if (a_cost >= 0 && a_cost > G->a_size - (int)sizeof(double))
xerror("glp_mincost_lp: a_cost = %d; invalid offset\n", a_cost)
;
glp_erase_prob(lp);
if (names) glp_set_prob_name(lp, G->name);
if (G->nv > 0) glp_add_rows(lp, G->nv);
for (i = 1; i <= G->nv; i++)
{ v = G->v[i];
if (names) glp_set_row_name(lp, i, v->name);
if (v_rhs >= 0)
memcpy(&rhs, (char *)v->data + v_rhs, sizeof(double));
else
rhs = 0.0;
glp_set_row_bnds(lp, i, GLP_FX, rhs, rhs);
}
if (G->na > 0) glp_add_cols(lp, G->na);
for (i = 1, j = 0; i <= G->nv; i++)
{ v = G->v[i];
for (a = v->out; a != NULL; a = a->t_next)
{ j++;
if (names)
{ char name[50+1];
sprintf(name, "x[%d,%d]", a->tail->i, a->head->i);
xassert(strlen(name) < sizeof(name));
glp_set_col_name(lp, j, name);
}
if (a->tail->i != a->head->i)
{ ind[1] = a->tail->i, val[1] = +1.0;
ind[2] = a->head->i, val[2] = -1.0;
glp_set_mat_col(lp, j, 2, ind, val);
}
if (a_low >= 0)
memcpy(&low, (char *)a->data + a_low, sizeof(double));
else
low = 0.0;
if (a_cap >= 0)
memcpy(&cap, (char *)a->data + a_cap, sizeof(double));
else
cap = 1.0;
if (cap == DBL_MAX)
type = GLP_LO;
else if (low != cap)
type = GLP_DB;
else
type = GLP_FX;
glp_set_col_bnds(lp, j, type, low, cap);
if (a_cost >= 0)
memcpy(&cost, (char *)a->data + a_cost, sizeof(double));
else
cost = 0.0;
glp_set_obj_coef(lp, j, cost);
}
}
xassert(j == G->na);
return;
}
void npp_build_prob(NPP *npp, glp_prob *prob)
{ /* build resultant (preprocessed) problem */
NPPROW *row;
NPPCOL *col;
NPPAIJ *aij;
int i, j, type, len, *ind;
double dir, *val;
glp_erase_prob(prob);
glp_set_prob_name(prob, npp->name);
glp_set_obj_name(prob, npp->obj);
glp_set_obj_dir(prob, npp->orig_dir);
if (npp->orig_dir == GLP_MIN)
dir = +1.0;
else if (npp->orig_dir == GLP_MAX)
dir = -1.0;
else
xassert(npp != npp);
glp_set_obj_coef(prob, 0, dir * npp->c0);
/* build rows */
for (row = npp->r_head; row != NULL; row = row->next)
{ row->temp = i = glp_add_rows(prob, 1);
glp_set_row_name(prob, i, row->name);
if (row->lb == -DBL_MAX && row->ub == +DBL_MAX)
type = GLP_FR;
else if (row->ub == +DBL_MAX)
type = GLP_LO;
else if (row->lb == -DBL_MAX)
type = GLP_UP;
else if (row->lb != row->ub)
type = GLP_DB;
else
type = GLP_FX;
glp_set_row_bnds(prob, i, type, row->lb, row->ub);
}
/* build columns and the constraint matrix */
ind = xcalloc(1+prob->m, sizeof(int));
val = xcalloc(1+prob->m, sizeof(double));
for (col = npp->c_head; col != NULL; col = col->next)
{ j = glp_add_cols(prob, 1);
glp_set_col_name(prob, j, col->name);
#if 0
glp_set_col_kind(prob, j, col->kind);
#else
glp_set_col_kind(prob, j, col->is_int ? GLP_IV : GLP_CV);
#endif
if (col->lb == -DBL_MAX && col->ub == +DBL_MAX)
type = GLP_FR;
else if (col->ub == +DBL_MAX)
type = GLP_LO;
else if (col->lb == -DBL_MAX)
type = GLP_UP;
else if (col->lb != col->ub)
type = GLP_DB;
else
type = GLP_FX;
glp_set_col_bnds(prob, j, type, col->lb, col->ub);
glp_set_obj_coef(prob, j, dir * col->coef);
len = 0;
for (aij = col->ptr; aij != NULL; aij = aij->c_next)
{ len++;
ind[len] = aij->row->temp;
val[len] = aij->val;
}
glp_set_mat_col(prob, j, len, ind, val);
}
xfree(ind);
xfree(val);
/* resultant problem has been built */
npp->m = prob->m;
npp->n = prob->n;
npp->nnz = prob->nnz;
npp->row_ref = xcalloc(1+npp->m, sizeof(int));
npp->col_ref = xcalloc(1+npp->n, sizeof(int));
for (row = npp->r_head, i = 0; row != NULL; row = row->next)
npp->row_ref[++i] = row->i;
for (col = npp->c_head, j = 0; col != NULL; col = col->next)
npp->col_ref[++j] = col->j;
/* transformed problem segment is no longer needed */
dmp_delete_pool(npp->pool), npp->pool = NULL;
npp->name = npp->obj = NULL;
npp->c0 = 0.0;
npp->r_head = npp->r_tail = NULL;
npp->c_head = npp->c_tail = NULL;
return;
}
void glp_mpl_build_prob(glp_tran *tran, glp_prob *prob)
{ /* build LP/MIP problem instance from the model */
int m, n, i, j, t, kind, type, len, *ind;
double lb, ub, *val;
if (tran->phase != 3)
xerror("glp_mpl_build_prob: invalid call sequence\n");
/* erase the problem object */
glp_erase_prob(prob);
/* set problem name */
glp_set_prob_name(prob, mpl_get_prob_name(tran));
/* build rows (constraints) */
m = mpl_get_num_rows(tran);
if (m > 0)
glp_add_rows(prob, m);
for (i = 1; i <= m; i++)
{ /* set row name */
glp_set_row_name(prob, i, mpl_get_row_name(tran, i));
/* set row bounds */
type = mpl_get_row_bnds(tran, i, &lb, &ub);
switch (type)
{ case MPL_FR: type = GLP_FR; break;
case MPL_LO: type = GLP_LO; break;
case MPL_UP: type = GLP_UP; break;
case MPL_DB: type = GLP_DB; break;
case MPL_FX: type = GLP_FX; break;
default: xassert(type != type);
}
if (type == GLP_DB && fabs(lb - ub) < 1e-9 * (1.0 + fabs(lb)))
{ type = GLP_FX;
if (fabs(lb) <= fabs(ub)) ub = lb; else lb = ub;
}
glp_set_row_bnds(prob, i, type, lb, ub);
/* warn about non-zero constant term */
if (mpl_get_row_c0(tran, i) != 0.0)
xprintf("glp_mpl_build_prob: row %s; constant term %.12g ig"
"nored\n",
mpl_get_row_name(tran, i), mpl_get_row_c0(tran, i));
}
/* build columns (variables) */
n = mpl_get_num_cols(tran);
if (n > 0)
glp_add_cols(prob, n);
for (j = 1; j <= n; j++)
{ /* set column name */
glp_set_col_name(prob, j, mpl_get_col_name(tran, j));
/* set column kind */
kind = mpl_get_col_kind(tran, j);
switch (kind)
{ case MPL_NUM:
break;
case MPL_INT:
case MPL_BIN:
glp_set_col_kind(prob, j, GLP_IV);
break;
default:
xassert(kind != kind);
}
/* set column bounds */
type = mpl_get_col_bnds(tran, j, &lb, &ub);
switch (type)
{ case MPL_FR: type = GLP_FR; break;
case MPL_LO: type = GLP_LO; break;
case MPL_UP: type = GLP_UP; break;
case MPL_DB: type = GLP_DB; break;
case MPL_FX: type = GLP_FX; break;
default: xassert(type != type);
}
if (kind == MPL_BIN)
{ if (type == GLP_FR || type == GLP_UP || lb < 0.0) lb = 0.0;
if (type == GLP_FR || type == GLP_LO || ub > 1.0) ub = 1.0;
type = GLP_DB;
}
if (type == GLP_DB && fabs(lb - ub) < 1e-9 * (1.0 + fabs(lb)))
{ type = GLP_FX;
if (fabs(lb) <= fabs(ub)) ub = lb; else lb = ub;
}
glp_set_col_bnds(prob, j, type, lb, ub);
}
/* load the constraint matrix */
ind = xcalloc(1+n, sizeof(int));
val = xcalloc(1+n, sizeof(double));
for (i = 1; i <= m; i++)
{ len = mpl_get_mat_row(tran, i, ind, val);
glp_set_mat_row(prob, i, len, ind, val);
}
/* build objective function (the first objective is used) */
for (i = 1; i <= m; i++)
{ kind = mpl_get_row_kind(tran, i);
if (kind == MPL_MIN || kind == MPL_MAX)
{ /* set objective name */
glp_set_obj_name(prob, mpl_get_row_name(tran, i));
/* set optimization direction */
glp_set_obj_dir(prob, kind == MPL_MIN ? GLP_MIN : GLP_MAX);
/* set constant term */
glp_set_obj_coef(prob, 0, mpl_get_row_c0(tran, i));
/* set objective coefficients */
len = mpl_get_mat_row(tran, i, ind, val);
for (t = 1; t <= len; t++)
glp_set_obj_coef(prob, ind[t], val[t]);
break;
}
}
/* free working arrays */
xfree(ind);
xfree(val);
return;
}
int glp_read_prob(glp_prob *P, int flags, const char *fname)
{ DMX _csa, *csa = &_csa;
int mip, m, n, nnz, ne, i, j, k, type, kind, ret, *ln = NULL,
*ia = NULL, *ja = NULL;
double lb, ub, temp, *ar = NULL;
char *rf = NULL, *cf = NULL;
if (P == NULL || P->magic != GLP_PROB_MAGIC)
xerror("glp_read_prob: P = %p; invalid problem object\n",
P);
if (flags != 0)
xerror("glp_read_prob: flags = %d; invalid parameter\n",
flags);
if (fname == NULL)
xerror("glp_read_prob: fname = %d; invalid parameter\n",
fname);
glp_erase_prob(P);
if (setjmp(csa->jump))
{ ret = 1;
goto done;
}
csa->fname = fname;
csa->fp = NULL;
csa->count = 0;
csa->c = '\n';
csa->field[0] = '\0';
csa->empty = csa->nonint = 0;
xprintf("Reading problem data from '%s'...\n", fname);
csa->fp = glp_open(fname, "r");
if (csa->fp == NULL)
{ xprintf("Unable to open '%s' - %s\n", fname, get_err_msg());
longjmp(csa->jump, 1);
}
/* read problem line */
read_designator(csa);
if (strcmp(csa->field, "p") != 0)
error(csa, "problem line missing or invalid");
read_field(csa);
if (strcmp(csa->field, "lp") == 0)
mip = 0;
else if (strcmp(csa->field, "mip") == 0)
mip = 1;
else
error(csa, "wrong problem designator; 'lp' or 'mip' expected");
read_field(csa);
if (strcmp(csa->field, "min") == 0)
glp_set_obj_dir(P, GLP_MIN);
else if (strcmp(csa->field, "max") == 0)
glp_set_obj_dir(P, GLP_MAX);
else
error(csa, "objective sense missing or invalid");
read_field(csa);
if (!(str2int(csa->field, &m) == 0 && m >= 0))
error(csa, "number of rows missing or invalid");
read_field(csa);
if (!(str2int(csa->field, &n) == 0 && n >= 0))
error(csa, "number of columns missing or invalid");
read_field(csa);
if (!(str2int(csa->field, &nnz) == 0 && nnz >= 0))
error(csa, "number of constraint coefficients missing or inval"
"id");
if (m > 0)
{ glp_add_rows(P, m);
for (i = 1; i <= m; i++)
glp_set_row_bnds(P, i, GLP_FX, 0.0, 0.0);
}
if (n > 0)
{ glp_add_cols(P, n);
for (j = 1; j <= n; j++)
{ if (!mip)
glp_set_col_bnds(P, j, GLP_LO, 0.0, 0.0);
else
glp_set_col_kind(P, j, GLP_BV);
}
}
end_of_line(csa);
/* allocate working arrays */
rf = xcalloc(1+m, sizeof(char));
memset(rf, 0, 1+m);
cf = xcalloc(1+n, sizeof(char));
memset(cf, 0, 1+n);
ln = xcalloc(1+nnz, sizeof(int));
ia = xcalloc(1+nnz, sizeof(int));
ja = xcalloc(1+nnz, sizeof(int));
ar = xcalloc(1+nnz, sizeof(double));
/* read descriptor lines */
ne = 0;
for (;;)
{ read_designator(csa);
if (strcmp(csa->field, "i") == 0)
{ /* row descriptor */
read_field(csa);
if (str2int(csa->field, &i) != 0)
error(csa, "row number missing or invalid");
if (!(1 <= i && i <= m))
error(csa, "row number out of range");
read_field(csa);
if (strcmp(csa->field, "f") == 0)
type = GLP_FR;
else if (strcmp(csa->field, "l") == 0)
type = GLP_LO;
else if (strcmp(csa->field, "u") == 0)
type = GLP_UP;
else if (strcmp(csa->field, "d") == 0)
type = GLP_DB;
else if (strcmp(csa->field, "s") == 0)
type = GLP_FX;
else
error(csa, "row type missing or invalid");
if (type == GLP_LO || type == GLP_DB || type == GLP_FX)
{ read_field(csa);
if (str2num(csa->field, &lb) != 0)
error(csa, "row lower bound/fixed value missing or in"
"valid");
}
else
lb = 0.0;
if (type == GLP_UP || type == GLP_DB)
{ read_field(csa);
if (str2num(csa->field, &ub) != 0)
error(csa, "row upper bound missing or invalid");
}
else
ub = 0.0;
if (rf[i] & 0x01)
error(csa, "duplicate row descriptor");
glp_set_row_bnds(P, i, type, lb, ub), rf[i] |= 0x01;
}
else if (strcmp(csa->field, "j") == 0)
{ /* column descriptor */
read_field(csa);
if (str2int(csa->field, &j) != 0)
error(csa, "column number missing or invalid");
if (!(1 <= j && j <= n))
error(csa, "column number out of range");
if (!mip)
kind = GLP_CV;
else
{ read_field(csa);
if (strcmp(csa->field, "c") == 0)
kind = GLP_CV;
else if (strcmp(csa->field, "i") == 0)
kind = GLP_IV;
else if (strcmp(csa->field, "b") == 0)
{ kind = GLP_IV;
type = GLP_DB, lb = 0.0, ub = 1.0;
goto skip;
}
else
error(csa, "column kind missing or invalid");
}
read_field(csa);
if (strcmp(csa->field, "f") == 0)
type = GLP_FR;
else if (strcmp(csa->field, "l") == 0)
type = GLP_LO;
else if (strcmp(csa->field, "u") == 0)
type = GLP_UP;
else if (strcmp(csa->field, "d") == 0)
type = GLP_DB;
else if (strcmp(csa->field, "s") == 0)
type = GLP_FX;
else
error(csa, "column type missing or invalid");
if (type == GLP_LO || type == GLP_DB || type == GLP_FX)
{ read_field(csa);
if (str2num(csa->field, &lb) != 0)
error(csa, "column lower bound/fixed value missing or"
" invalid");
}
else
lb = 0.0;
if (type == GLP_UP || type == GLP_DB)
{ read_field(csa);
if (str2num(csa->field, &ub) != 0)
error(csa, "column upper bound missing or invalid");
}
else
ub = 0.0;
skip: if (cf[j] & 0x01)
error(csa, "duplicate column descriptor");
glp_set_col_kind(P, j, kind);
glp_set_col_bnds(P, j, type, lb, ub), cf[j] |= 0x01;
}
else if (strcmp(csa->field, "a") == 0)
{ /* coefficient descriptor */
read_field(csa);
if (str2int(csa->field, &i) != 0)
error(csa, "row number missing or invalid");
if (!(0 <= i && i <= m))
error(csa, "row number out of range");
read_field(csa);
if (str2int(csa->field, &j) != 0)
error(csa, "column number missing or invalid");
if (!((i == 0 ? 0 : 1) <= j && j <= n))
error(csa, "column number out of range");
read_field(csa);
if (i == 0)
{ if (str2num(csa->field, &temp) != 0)
error(csa, "objective %s missing or invalid",
j == 0 ? "constant term" : "coefficient");
if (cf[j] & 0x10)
error(csa, "duplicate objective %s",
j == 0 ? "constant term" : "coefficient");
glp_set_obj_coef(P, j, temp), cf[j] |= 0x10;
}
else
{ if (str2num(csa->field, &temp) != 0)
error(csa, "constraint coefficient missing or invalid"
);
if (ne == nnz)
error(csa, "too many constraint coefficient descripto"
"rs");
ln[++ne] = csa->count;
ia[ne] = i, ja[ne] = j, ar[ne] = temp;
}
}
else if (strcmp(csa->field, "n") == 0)
{ /* symbolic name descriptor */
read_field(csa);
if (strcmp(csa->field, "p") == 0)
{ /* problem name */
read_field(csa);
if (P->name != NULL)
error(csa, "duplicate problem name");
glp_set_prob_name(P, csa->field);
}
else if (strcmp(csa->field, "z") == 0)
{ /* objective name */
read_field(csa);
if (P->obj != NULL)
error(csa, "duplicate objective name");
glp_set_obj_name(P, csa->field);
}
else if (strcmp(csa->field, "i") == 0)
{ /* row name */
read_field(csa);
if (str2int(csa->field, &i) != 0)
error(csa, "row number missing or invalid");
if (!(1 <= i && i <= m))
error(csa, "row number out of range");
read_field(csa);
if (P->row[i]->name != NULL)
error(csa, "duplicate row name");
glp_set_row_name(P, i, csa->field);
}
else if (strcmp(csa->field, "j") == 0)
{ /* column name */
read_field(csa);
if (str2int(csa->field, &j) != 0)
error(csa, "column number missing or invalid");
if (!(1 <= j && j <= n))
error(csa, "column number out of range");
read_field(csa);
if (P->col[j]->name != NULL)
error(csa, "duplicate column name");
glp_set_col_name(P, j, csa->field);
}
else
error(csa, "object designator missing or invalid");
}
else if (strcmp(csa->field, "e") == 0)
break;
else
error(csa, "line designator missing or invalid");
end_of_line(csa);
}
if (ne < nnz)
error(csa, "too few constraint coefficient descriptors");
xassert(ne == nnz);
k = glp_check_dup(m, n, ne, ia, ja);
xassert(0 <= k && k <= nnz);
if (k > 0)
{ csa->count = ln[k];
error(csa, "duplicate constraint coefficient");
}
glp_load_matrix(P, ne, ia, ja, ar);
/* print some statistics */
if (P->name != NULL)
xprintf("Problem: %s\n", P->name);
if (P->obj != NULL)
xprintf("Objective: %s\n", P->obj);
xprintf("%d row%s, %d column%s, %d non-zero%s\n",
m, m == 1 ? "" : "s", n, n == 1 ? "" : "s", nnz, nnz == 1 ?
"" : "s");
if (glp_get_num_int(P) > 0)
{ int ni = glp_get_num_int(P);
int nb = glp_get_num_bin(P);
if (ni == 1)
{ if (nb == 0)
xprintf("One variable is integer\n");
else
xprintf("One variable is binary\n");
}
else
{ xprintf("%d integer variables, ", ni);
if (nb == 0)
xprintf("none");
else if (nb == 1)
xprintf("one");
else if (nb == ni)
xprintf("all");
else
xprintf("%d", nb);
xprintf(" of which %s binary\n", nb == 1 ? "is" : "are");
}
}
xprintf("%d lines were read\n", csa->count);
/* problem data has been successfully read */
glp_sort_matrix(P);
ret = 0;
done: if (csa->fp != NULL) glp_close(csa->fp);
if (rf != NULL) xfree(rf);
if (cf != NULL) xfree(cf);
if (ln != NULL) xfree(ln);
if (ia != NULL) xfree(ia);
if (ja != NULL) xfree(ja);
if (ar != NULL) xfree(ar);
if (ret) glp_erase_prob(P);
return ret;
}
int glp_read_lp(glp_prob *P, const glp_cpxcp *parm, const char *fname)
{ /* read problem data in CPLEX LP format */
glp_cpxcp _parm;
struct csa _csa, *csa = &_csa;
int ret;
xprintf("Reading problem data from '%s'...\n", fname);
if (parm == NULL)
glp_init_cpxcp(&_parm), parm = &_parm;
/* check control parameters */
check_parm("glp_read_lp", parm);
/* initialize common storage area */
csa->P = P;
csa->parm = parm;
csa->fname = fname;
csa->fp = NULL;
if (setjmp(csa->jump))
{ ret = 1;
goto done;
}
csa->count = 0;
csa->c = '\n';
csa->token = T_EOF;
csa->image[0] = '\0';
csa->imlen = 0;
csa->value = 0.0;
csa->n_max = 100;
csa->ind = xcalloc(1+csa->n_max, sizeof(int));
csa->val = xcalloc(1+csa->n_max, sizeof(double));
csa->flag = xcalloc(1+csa->n_max, sizeof(char));
memset(&csa->flag[1], 0, csa->n_max * sizeof(char));
csa->lb = xcalloc(1+csa->n_max, sizeof(double));
csa->ub = xcalloc(1+csa->n_max, sizeof(double));
#if 1 /* 27/VII-2013 */
csa->lb_warn = csa->ub_warn = 0;
#endif
/* erase problem object */
glp_erase_prob(P);
glp_create_index(P);
/* open input CPLEX LP file */
csa->fp = glp_open(fname, "r");
if (csa->fp == NULL)
{ xprintf("Unable to open '%s' - %s\n", fname, get_err_msg());
ret = 1;
goto done;
}
/* scan very first token */
scan_token(csa);
/* parse definition of the objective function */
if (!(csa->token == T_MINIMIZE || csa->token == T_MAXIMIZE))
error(csa, "'minimize' or 'maximize' keyword missing\n");
parse_objective(csa);
/* parse constraints section */
if (csa->token != T_SUBJECT_TO)
error(csa, "constraints section missing\n");
parse_constraints(csa);
/* parse optional bounds section */
if (csa->token == T_BOUNDS) parse_bounds(csa);
/* parse optional general, integer, and binary sections */
while (csa->token == T_GENERAL ||
csa->token == T_INTEGER ||
csa->token == T_BINARY) parse_integer(csa);
/* check for the keyword 'end' */
if (csa->token == T_END)
scan_token(csa);
else if (csa->token == T_EOF)
warning(csa, "keyword 'end' missing\n");
else
error(csa, "symbol '%s' in wrong position\n", csa->image);
/* nothing must follow the keyword 'end' (except comments) */
if (csa->token != T_EOF)
error(csa, "extra symbol(s) detected beyond 'end'\n");
/* set bounds of variables */
{ int j, type;
double lb, ub;
for (j = 1; j <= P->n; j++)
{ lb = csa->lb[j];
ub = csa->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 = GLP_FR;
else if (ub == +DBL_MAX)
type = GLP_LO;
else if (lb == -DBL_MAX)
type = GLP_UP;
else if (lb != ub)
type = GLP_DB;
else
type = GLP_FX;
glp_set_col_bnds(csa->P, j, type, lb, ub);
}
}
/* print some statistics */
xprintf("%d row%s, %d column%s, %d non-zero%s\n",
P->m, P->m == 1 ? "" : "s", P->n, P->n == 1 ? "" : "s",
P->nnz, P->nnz == 1 ? "" : "s");
if (glp_get_num_int(P) > 0)
{ int ni = glp_get_num_int(P);
int nb = glp_get_num_bin(P);
if (ni == 1)
{ if (nb == 0)
xprintf("One variable is integer\n");
else
xprintf("One variable is binary\n");
}
else
{ xprintf("%d integer variables, ", ni);
if (nb == 0)
xprintf("none");
else if (nb == 1)
xprintf("one");
else if (nb == ni)
xprintf("all");
else
xprintf("%d", nb);
xprintf(" of which %s binary\n", nb == 1 ? "is" : "are");
}
}
xprintf("%d lines were read\n", csa->count);
/* problem data has been successfully read */
glp_delete_index(P);
glp_sort_matrix(P);
ret = 0;
done: if (csa->fp != NULL) glp_close(csa->fp);
xfree(csa->ind);
xfree(csa->val);
xfree(csa->flag);
xfree(csa->lb);
xfree(csa->ub);
if (ret != 0) glp_erase_prob(P);
return ret;
}
