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 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;
}
