Exemple #1
0
void __stubprintf (char *file, int line, const char *func,
                   char *format, ...) {
   va_list args;
   xfflush (NULL);
   xprintf ("%s: %s[%d] %s: ", execname, file, line, func);
   va_start (args, format);
   xvprintf (format, args);
   va_end (args);
   xfflush (NULL);
}
Exemple #2
0
void veprintf (char *format, va_list args) {
   assert (execname != NULL);
   assert (format != NULL);
   xfflush (NULL);
   if (strstr (format, "%:") == format) {
      xfprintf (stderr, "%s: ", get_execname ());
      format += 2;
   }
   xvfprintf (stderr, format, args);
   xfflush (NULL);
}
Exemple #3
0
void __debugprintf (char flag, char *file, int line, const char *func,
                    char *format, ...) {
   va_list args;
   if (! is_debugflag (flag)) return;
   xfflush (NULL);
   va_start (args, format);
   xfprintf (stderr, "DEBUGF(%c): %s[%d] %s():\n",
             flag, file, line, func);
   xvfprintf (stderr, format, args);
   va_end (args);
   xfflush (NULL);
}
int glp_write_mip(glp_prob *mip, const char *fname)
{   glp_file *fp;
    int i, j, ret = 0;
    xprintf("Writing MIP solution to '%s'...\n", fname);
    fp = glp_open(fname, "w");
    if (fp == NULL)
    {   xprintf("Unable to create '%s' - %s\n", fname, get_err_msg());
        ret = 1;
        goto done;
    }
    /* number of rows, number of columns */
    xfprintf(fp, "%d %d\n", mip->m, mip->n);
    /* solution status, objective value */
    xfprintf(fp, "%d %.*g\n", mip->mip_stat, DBL_DIG, mip->mip_obj);
    /* rows (auxiliary variables) */
    for (i = 1; i <= mip->m; i++)
        xfprintf(fp, "%.*g\n", DBL_DIG, mip->row[i]->mipx);
    /* columns (structural variables) */
    for (j = 1; j <= mip->n; j++)
        xfprintf(fp, "%.*g\n", DBL_DIG, mip->col[j]->mipx);
#if 0 /* FIXME */
    xfflush(fp);
#endif
    if (glp_ioerr(fp))
    {   xprintf("Write error on '%s' - %s\n", fname, get_err_msg());
        ret = 1;
        goto done;
    }
    xprintf("%d lines were written\n", 2 + mip->m + mip->n);
done:
    if (fp != NULL) glp_close(fp);
    return ret;
}
Exemple #5
0
int glp_write_graph(glp_graph *G, const char *fname)
{     XFILE *fp;
      glp_vertex *v;
      glp_arc *a;
      int i, count, ret;
      xprintf("Writing graph to `%s'...\n", fname);
      fp = xfopen(fname, "w"), count = 0;
      if (fp == NULL)
      {  xprintf("Unable to create `%s' - %s\n", fname, xerrmsg());
         ret = 1;
         goto done;
      }
      xfprintf(fp, "%d %d\n", G->nv, G->na), count++;
      for (i = 1; i <= G->nv; i++)
      {  v = G->v[i];
         for (a = v->out; a != NULL; a = a->t_next)
            xfprintf(fp, "%d %d\n", a->tail->i, a->head->i), count++;
      }
      xfflush(fp);
      if (xferror(fp))
      {  xprintf("Write error on `%s' - %s\n", fname, xerrmsg());
         ret = 1;
         goto done;
      }
      xprintf("%d lines were written\n", count);
      ret = 0;
done: if (fp != NULL) xfclose(fp);
      return ret;
}
Exemple #6
0
int xfclose(xFILE *fp) {
  extern void free(void *);     /* FIXME */

  xfflush(fp);
  fp->flag = 0;
  if (fp->base != fp->buf)
    free(fp->base);
  return fp->vtable.close(fp->vtable.cookie);
}
Exemple #7
0
void flush_output(MPL *mpl)
{     xassert(mpl->out_fp != NULL);
      if (mpl->out_fp != (void *)stdout)
      {  xfflush(mpl->out_fp);
         if (xferror(mpl->out_fp))
            error(mpl, "write error on %s - %s", mpl->out_file,
               xerrmsg());
      }
      return;
}
Exemple #8
0
static pic_value
pic_port_flush(pic_state *pic)
{
  struct pic_port *port = pic_stdout(pic);

  pic_get_args(pic, "|p", &port);

  assert_port_profile(port, PIC_PORT_OUT, PIC_PORT_OPEN, "flush-output-port");

  xfflush(port->file);
  return pic_none_value();
}
Exemple #9
0
int glp_write_maxflow(glp_graph *G, int s, int t, int a_cap,
      const char *fname)
{     XFILE *fp;
      glp_vertex *v;
      glp_arc *a;
      int i, count = 0, ret;
      double cap;
      if (!(1 <= s && s <= G->nv))
         xerror("glp_write_maxflow: s = %d; source node number out of r"
            "ange\n", s);
      if (!(1 <= t && t <= G->nv))
         xerror("glp_write_maxflow: t = %d: sink node number out of ran"
            "ge\n", t);
      if (a_cap >= 0 && a_cap > G->a_size - (int)sizeof(double))
         xerror("glp_write_mincost: a_cap = %d; invalid offset\n",
            a_cap);
      xprintf("Writing maximum flow problem data to `%s'...\n",
         fname);
      fp = xfopen(fname, "w");
      if (fp == NULL)
      {  xprintf("Unable to create `%s' - %s\n", fname, xerrmsg());
         ret = 1;
         goto done;
      }
      xfprintf(fp, "c %s\n",
         G->name == NULL ? "unknown" : G->name), count++;
      xfprintf(fp, "p max %d %d\n", G->nv, G->na), count++;
      xfprintf(fp, "n %d s\n", s), count++;
      xfprintf(fp, "n %d t\n", t), count++;
      for (i = 1; i <= G->nv; i++)
      {  v = G->v[i];
         for (a = v->out; a != NULL; a = a->t_next)
         {  if (a_cap >= 0)
               memcpy(&cap, (char *)a->data + a_cap, sizeof(double));
            else
               cap = DBL_MAX;
            xfprintf(fp, "a %d %d %.*g\n",
               a->tail->i, a->head->i, DBL_DIG, cap), count++;
         }
      }
      xfprintf(fp, "c eof\n"), count++;
      xfflush(fp);
      if (xferror(fp))
      {  xprintf("Write error on `%s' - %s\n", fname, xerrmsg());
         ret = 1;
         goto done;
      }
      xprintf("%d lines were written\n", count);
      ret = 0;
done: if (fp != NULL) xfclose(fp);
      return ret;
}
Exemple #10
0
long xfseek(xFILE *fp, long offset, int whence) {
  long s;

  xfflush(fp);

  fp->ptr = fp->base;
  fp->cnt = 0;

  if ((s = fp->vtable.seek(fp->vtable.cookie, offset, whence)) != 0)
    return s;
  fp->flag &= ~X_EOF;
  return 0;
}
Exemple #11
0
char *xgets(char *s) {
  int c;
  char *buf;

  xfflush(NULL);

  buf = s;
  while ((c = xgetchar()) != EOF && c != '\n') {
    *buf++ = c;
  }
  *buf = '\0';

  return (c == EOF && buf == s) ? NULL : s;
}
Exemple #12
0
struct pic_port *
pic_open_input_string(pic_state *pic, const char *str)
{
  struct pic_port *port;

  port = (struct pic_port *)pic_obj_alloc(pic, sizeof(struct pic_port *), PIC_TT_PORT);
  port->file = xmopen();
  port->flags = PIC_PORT_IN | PIC_PORT_TEXT;
  port->status = PIC_PORT_OPEN;

  xfputs(str, port->file);
  xfflush(port->file);
  xrewind(port->file);

  return port;
}
Exemple #13
0
char *xfgets(char *s, int size, xFILE *stream) {
  int c;
  char *buf;

  xfflush(NULL);

  if (size == 0) {
    return NULL;
  }
  buf = s;
  while (--size > 0 && (c = xgetc(stream)) != EOF) {
    if ((*buf++ = c) == '\n')
      break;
  }
  *buf = '\0';

  return (c == EOF && buf == s) ? NULL : s;
}
Exemple #14
0
struct pic_string *
pic_get_output_string(pic_state *pic, struct pic_port *port)
{
  size_t size;
  char *buf;

  /* get endpos */
  xfflush(port->file);
  size = (size_t)xftell(port->file);
  xrewind(port->file);

  /* copy to buf */
  buf = (char *)pic_alloc(pic, size + 1);
  buf[size] = 0;
  xfread(buf, size, 1, port->file);

  return pic_make_str(pic, buf, size);
}
Exemple #15
0
static pic_value
pic_port_open_input_blob(pic_state *pic)
{
  struct pic_port *port;
  struct pic_blob *blob;

  pic_get_args(pic, "b", &blob);

  port = (struct pic_port *)pic_obj_alloc(pic, sizeof(struct pic_port *), PIC_TT_PORT);
  port->file = xmopen();
  port->flags = PIC_PORT_IN | PIC_PORT_BINARY;
  port->status = PIC_PORT_OPEN;

  xfwrite(blob->data, 1, blob->len, port->file);
  xfflush(port->file);
  xrewind(port->file);

  return pic_obj_value(port);
}
int glp_write_sol(glp_prob *lp, const char *fname)
{   glp_file *fp;
    int i, j, ret = 0;
    xprintf("Writing basic solution to '%s'...\n", fname);
    fp = glp_open(fname, "w");
    if (fp == NULL)
    {   xprintf("Unable to create '%s' - %s\n", fname, get_err_msg());
        ret = 1;
        goto done;
    }
    /* number of rows, number of columns */
    xfprintf(fp, "%d %d\n", lp->m, lp->n);
    /* primal status, dual status, objective value */
    xfprintf(fp, "%d %d %.*g\n", lp->pbs_stat, lp->dbs_stat, DBL_DIG,
             lp->obj_val);
    /* rows (auxiliary variables) */
    for (i = 1; i <= lp->m; i++)
    {   GLPROW *row = lp->row[i];
        /* status, primal value, dual value */
        xfprintf(fp, "%d %.*g %.*g\n", row->stat, DBL_DIG, row->prim,
                 DBL_DIG, row->dual);
    }
    /* columns (structural variables) */
    for (j = 1; j <= lp->n; j++)
    {   GLPCOL *col = lp->col[j];
        /* status, primal value, dual value */
        xfprintf(fp, "%d %.*g %.*g\n", col->stat, DBL_DIG, col->prim,
                 DBL_DIG, col->dual);
    }
#if 0 /* FIXME */
    xfflush(fp);
#endif
    if (glp_ioerr(fp))
    {   xprintf("Write error on '%s' - %s\n", fname, get_err_msg());
        ret = 1;
        goto done;
    }
    xprintf("%d lines were written\n", 2 + lp->m + lp->n);
done:
    if (fp != NULL) glp_close(fp);
    return ret;
}
Exemple #17
0
int xfflush(xFILE *f) {
  int retval;
  int i;

  retval = 0;
  if (f == NULL) {
    /* flush all output streams */
    for (i = 0; i < XOPEN_MAX; i++) {
      if ((x_iob[i].flag & X_WRITE) && (xfflush(&x_iob[i]) == -1))
        retval = -1;
    }
  } else {
    if ((f->flag & X_WRITE) == 0)
      return -1;
    x_flushbuf(EOF, f);
    if (f->flag & X_ERR)
      retval = -1;
  }
  return retval;
}
Exemple #18
0
static pic_value
pic_port_get_output_bytevector(pic_state *pic)
{
  struct pic_port *port = pic_stdout(pic);
  pic_blob *blob;
  size_t size;

  pic_get_args(pic, "|p", &port);

  assert_port_profile(port, PIC_PORT_OUT | PIC_PORT_BINARY, PIC_PORT_OPEN, "get-output-bytevector");

  /* get endpos */
  xfflush(port->file);
  size = (size_t)xftell(port->file);
  xrewind(port->file);

  /* copy to buf */
  blob = pic_make_blob(pic, size);
  xfread(blob->data, 1, size, port->file);

  return pic_obj_value(blob);
}
Exemple #19
0
int glp_write_ipt(glp_prob *lp, const char *fname)
{   XFILE *fp;
    int i, j, ret = 0;
    xprintf("Writing interior-point solution to `%s'...\n", fname);
    fp = xfopen(fname, "w");
    if (fp == NULL)
    {   xprintf("Unable to create `%s' - %s\n", fname, xerrmsg());
        ret = 1;
        goto done;
    }
    /* number of rows, number of columns */
    xfprintf(fp, "%d %d\n", lp->m, lp->n);
    /* solution status, objective value */
    xfprintf(fp, "%d %.*g\n", lp->ipt_stat, DBL_DIG, lp->ipt_obj);
    /* rows (auxiliary variables) */
    for (i = 1; i <= lp->m; i++)
    {   GLPROW *row = lp->row[i];
        /* primal value, dual value */
        xfprintf(fp, "%.*g %.*g\n", DBL_DIG, row->pval, DBL_DIG,
                 row->dval);
    }
    /* columns (structural variables) */
    for (j = 1; j <= lp->n; j++)
    {   GLPCOL *col = lp->col[j];
        /* primal value, dual value */
        xfprintf(fp, "%.*g %.*g\n", DBL_DIG, col->pval, DBL_DIG,
                 col->dval);
    }
    xfflush(fp);
    if (xferror(fp))
    {   xprintf("Write error on `%s' - %s\n", fname, xerrmsg());
        ret = 1;
        goto done;
    }
    xprintf("%d lines were written\n", 2 + lp->m + lp->n);
done:
    if (fp != NULL) xfclose(fp);
    return ret;
}
Exemple #20
0
int glp_write_lp(glp_prob *P, const glp_cpxcp *parm, const char *fname)
{     /* write problem data in CPLEX LP format */
      glp_cpxcp _parm;
      struct csa _csa, *csa = &_csa;
      glp_file *fp;
      GLPROW *row;
      GLPCOL *col;
      GLPAIJ *aij;
      int i, j, len, flag, count, ret;
      char line[1000+1], term[500+1], name[255+1];
      xprintf("Writing problem data to '%s'...\n", fname);
      if (parm == NULL)
         glp_init_cpxcp(&_parm), parm = &_parm;
      /* check control parameters */
      check_parm("glp_write_lp", parm);
      /* initialize common storage area */
      csa->P = P;
      csa->parm = parm;
      /* create output CPLEX LP file */
      fp = glp_open(fname, "w"), count = 0;
      if (fp == NULL)
      {  xprintf("Unable to create '%s' - %s\n", fname, get_err_msg());
         ret = 1;
         goto done;
      }
      /* write problem name */
      xfprintf(fp, "\\* Problem: %s *\\\n",
         P->name == NULL ? "Unknown" : P->name), count++;
      xfprintf(fp, "\n"), count++;
      /* the problem should contain at least one row and one column */
      if (!(P->m > 0 && P->n > 0))
      {  xprintf("Warning: problem has no rows/columns\n");
         xfprintf(fp, "\\* WARNING: PROBLEM HAS NO ROWS/COLUMNS *\\\n"),
            count++;
         xfprintf(fp, "\n"), count++;
         goto skip;
      }
      /* write the objective function definition */
      if (P->dir == GLP_MIN)
         xfprintf(fp, "Minimize\n"), count++;
      else if (P->dir == GLP_MAX)
         xfprintf(fp, "Maximize\n"), count++;
      else
         xassert(P != P);
      row_name(csa, 0, name);
      sprintf(line, " %s:", name);
      len = 0;
      for (j = 1; j <= P->n; j++)
      {  col = P->col[j];
         if (col->coef != 0.0 || col->ptr == NULL)
         {  len++;
            col_name(csa, j, name);
            if (col->coef == 0.0)
               sprintf(term, " + 0 %s", name); /* empty column */
            else if (col->coef == +1.0)
               sprintf(term, " + %s", name);
            else if (col->coef == -1.0)
               sprintf(term, " - %s", name);
            else if (col->coef > 0.0)
               sprintf(term, " + %.*g %s", DBL_DIG, +col->coef, name);
            else
               sprintf(term, " - %.*g %s", DBL_DIG, -col->coef, name);
            if (strlen(line) + strlen(term) > 72)
               xfprintf(fp, "%s\n", line), line[0] = '\0', count++;
            strcat(line, term);
         }
      }
      if (len == 0)
      {  /* empty objective */
         sprintf(term, " 0 %s", col_name(csa, 1, name));
         strcat(line, term);
      }
      xfprintf(fp, "%s\n", line), count++;
      if (P->c0 != 0.0)
         xfprintf(fp, "\\* constant term = %.*g *\\\n", DBL_DIG, P->c0),
            count++;
      xfprintf(fp, "\n"), count++;
      /* write the constraints section */
      xfprintf(fp, "Subject To\n"), count++;
      for (i = 1; i <= P->m; i++)
      {  row = P->row[i];
         if (row->type == GLP_FR) continue; /* skip free row */
         row_name(csa, i, name);
         sprintf(line, " %s:", name);
         /* linear form */
         for (aij = row->ptr; aij != NULL; aij = aij->r_next)
         {  col_name(csa, aij->col->j, name);
            if (aij->val == +1.0)
               sprintf(term, " + %s", name);
            else if (aij->val == -1.0)
               sprintf(term, " - %s", name);
            else if (aij->val > 0.0)
               sprintf(term, " + %.*g %s", DBL_DIG, +aij->val, name);
            else
               sprintf(term, " - %.*g %s", DBL_DIG, -aij->val, name);
            if (strlen(line) + strlen(term) > 72)
               xfprintf(fp, "%s\n", line), line[0] = '\0', count++;
            strcat(line, term);
         }
         if (row->type == GLP_DB)
         {  /* double-bounded (ranged) constraint */
            sprintf(term, " - ~r_%d", i);
            if (strlen(line) + strlen(term) > 72)
               xfprintf(fp, "%s\n", line), line[0] = '\0', count++;
            strcat(line, term);
         }
         else if (row->ptr == NULL)
         {  /* empty constraint */
            sprintf(term, " 0 %s", col_name(csa, 1, name));
            strcat(line, term);
         }
         /* right hand-side */
         if (row->type == GLP_LO)
            sprintf(term, " >= %.*g", DBL_DIG, row->lb);
         else if (row->type == GLP_UP)
            sprintf(term, " <= %.*g", DBL_DIG, row->ub);
         else if (row->type == GLP_DB || row->type == GLP_FX)
            sprintf(term, " = %.*g", DBL_DIG, row->lb);
         else
            xassert(row != row);
         if (strlen(line) + strlen(term) > 72)
            xfprintf(fp, "%s\n", line), line[0] = '\0', count++;
         strcat(line, term);
         xfprintf(fp, "%s\n", line), count++;
      }
      xfprintf(fp, "\n"), count++;
      /* write the bounds section */
      flag = 0;
      for (i = 1; i <= P->m; i++)
      {  row = P->row[i];
         if (row->type != GLP_DB) continue;
         if (!flag)
            xfprintf(fp, "Bounds\n"), flag = 1, count++;
         xfprintf(fp, " 0 <= ~r_%d <= %.*g\n",
            i, DBL_DIG, row->ub - row->lb), count++;
      }
      for (j = 1; j <= P->n; j++)
      {  col = P->col[j];
         if (col->type == GLP_LO && col->lb == 0.0) continue;
         if (!flag)
            xfprintf(fp, "Bounds\n"), flag = 1, count++;
         col_name(csa, j, name);
         if (col->type == GLP_FR)
            xfprintf(fp, " %s free\n", name), count++;
         else if (col->type == GLP_LO)
            xfprintf(fp, " %s >= %.*g\n",
               name, DBL_DIG, col->lb), count++;
         else if (col->type == GLP_UP)
            xfprintf(fp, " -Inf <= %s <= %.*g\n",
               name, DBL_DIG, col->ub), count++;
         else if (col->type == GLP_DB)
            xfprintf(fp, " %.*g <= %s <= %.*g\n",
               DBL_DIG, col->lb, name, DBL_DIG, col->ub), count++;
         else if (col->type == GLP_FX)
            xfprintf(fp, " %s = %.*g\n",
               name, DBL_DIG, col->lb), count++;
         else
            xassert(col != col);
      }
      if (flag) xfprintf(fp, "\n"), count++;
      /* write the integer section */
      flag = 0;
      for (j = 1; j <= P->n; j++)
      {  col = P->col[j];
         if (col->kind == GLP_CV) continue;
         xassert(col->kind == GLP_IV);
         if (!flag)
            xfprintf(fp, "Generals\n"), flag = 1, count++;
         xfprintf(fp, " %s\n", col_name(csa, j, name)), count++;
      }
      if (flag) xfprintf(fp, "\n"), count++;
skip: /* write the end keyword */
      xfprintf(fp, "End\n"), count++;
#if 0 /* FIXME */
      xfflush(fp);
#endif
      if (glp_ioerr(fp))
      {  xprintf("Write error on '%s' - %s\n", fname, get_err_msg());
         ret = 1;
         goto done;
      }
      /* problem data has been successfully written */
      xprintf("%d lines were written\n", count);
      ret = 0;
done: if (fp != NULL) glp_close(fp);
      return ret;
}
Exemple #21
0
int glp_write_mincost(glp_graph *G, int v_rhs, int a_low, int a_cap,
      int a_cost, const char *fname)
{     XFILE *fp;
      glp_vertex *v;
      glp_arc *a;
      int i, count = 0, ret;
      double rhs, low, cap, cost;
      if (v_rhs >= 0 && v_rhs > G->v_size - (int)sizeof(double))
         xerror("glp_write_mincost: v_rhs = %d; invalid offset\n",
            v_rhs);
      if (a_low >= 0 && a_low > G->a_size - (int)sizeof(double))
         xerror("glp_write_mincost: a_low = %d; invalid offset\n",
            a_low);
      if (a_cap >= 0 && a_cap > G->a_size - (int)sizeof(double))
         xerror("glp_write_mincost: a_cap = %d; invalid offset\n",
            a_cap);
      if (a_cost >= 0 && a_cost > G->a_size - (int)sizeof(double))
         xerror("glp_write_mincost: a_cost = %d; invalid offset\n",
            a_cost);
      xprintf("Writing min-cost flow problem data to `%s'...\n",
         fname);
      fp = xfopen(fname, "w");
      if (fp == NULL)
      {  xprintf("Unable to create `%s' - %s\n", fname, xerrmsg());
         ret = 1;
         goto done;
      }
      xfprintf(fp, "c %s\n",
         G->name == NULL ? "unknown" : G->name), count++;
      xfprintf(fp, "p min %d %d\n", G->nv, G->na), count++;
      if (v_rhs >= 0)
      {  for (i = 1; i <= G->nv; i++)
         {  v = G->v[i];
            memcpy(&rhs, (char *)v->data + v_rhs, sizeof(double));
            if (rhs != 0.0)
               xfprintf(fp, "n %d %.*g\n", i, DBL_DIG, rhs), count++;
         }
      }
      for (i = 1; i <= G->nv; i++)
      {  v = G->v[i];
         for (a = v->out; a != NULL; a = a->t_next)
         {  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 = DBL_MAX;
            if (a_cost >= 0)
               memcpy(&cost, (char *)a->data + a_cost, sizeof(double));
            else
               cost = 0.0;
            xfprintf(fp, "a %d %d %.*g %.*g %.*g\n",
               a->tail->i, a->head->i, DBL_DIG, low, DBL_DIG, cap,
               DBL_DIG, cost), count++;
         }
      }
      xfprintf(fp, "c eof\n"), count++;
      xfflush(fp);
      if (xferror(fp))
      {  xprintf("Write error on `%s' - %s\n", fname, xerrmsg());
         ret = 1;
         goto done;
      }
      xprintf("%d lines were written\n", count);
      ret = 0;
done: if (fp != NULL) xfclose(fp);
      return ret;
}
Exemple #22
0
int dict_data_zip( const char *inFilename, const char *outFilename,
		   const char *preFilter, const char *postFilter )
{
   char          inBuffer[IN_BUFFER_SIZE];
   char          outBuffer[OUT_BUFFER_SIZE];
   int           count;
   unsigned long inputCRC = crc32( 0L, Z_NULL, 0 );
   z_stream      zStream;
   FILE          *outStr;
   FILE          *inStr;
   int           len;
   struct stat   st;
   char          *header;
   int           headerLength;
   int           dataLength;
   int           extraLength;
   int           chunkLength;
#if HEADER_CRC
   int           headerCRC;
#endif
   unsigned long chunks;
   unsigned long chunk = 0;
   unsigned long total = 0;
   int           i;
   char          tail[8];
   char          *pt, *origFilename;

   
   /* Open files */
   if (!(inStr = fopen( inFilename, "r" )))
      err_fatal_errno( __func__,
		       "Cannot open \"%s\" for read\n", inFilename );
   if (!(outStr = fopen( outFilename, "w" )))
      err_fatal_errno( __func__,
		       "Cannot open \"%s\"for write\n", outFilename );

   origFilename = xmalloc( strlen( inFilename ) + 1 );
   if ((pt = strrchr( inFilename, '/' )))
      strcpy( origFilename, pt + 1 );
   else
      strcpy( origFilename, inFilename );

   /* Initialize compression engine */
   zStream.zalloc    = NULL;
   zStream.zfree     = NULL;
   zStream.opaque    = NULL;
   zStream.next_in   = NULL;
   zStream.avail_in  = 0;
   zStream.next_out  = NULL;
   zStream.avail_out = 0;
   if (deflateInit2( &zStream,
		     Z_BEST_COMPRESSION,
		     Z_DEFLATED,
		     -15,	/* Suppress zlib header */
		     Z_BEST_COMPRESSION,
		     Z_DEFAULT_STRATEGY ) != Z_OK)
      err_internal( __func__,
		    "Cannot initialize deflation engine: %s\n", zStream.msg );

   /* Write initial header information */
   chunkLength = (preFilter ? PREFILTER_IN_BUFFER_SIZE : IN_BUFFER_SIZE );
   fstat( fileno( inStr ), &st );
   chunks = st.st_size / chunkLength;
   if (st.st_size % chunkLength) ++chunks;
   PRINTF(DBG_VERBOSE,("%lu chunks * %u per chunk = %lu (filesize = %lu)\n",
			chunks, chunkLength, chunks * chunkLength,
			(unsigned long) st.st_size ));
   dataLength   = chunks * 2;
   extraLength  = 10 + dataLength;
   headerLength = GZ_FEXTRA_START
		  + extraLength		/* FEXTRA */
		  + strlen( origFilename ) + 1	/* FNAME  */
		  + (HEADER_CRC ? 2 : 0);	/* FHCRC  */
   PRINTF(DBG_VERBOSE,("(data = %d, extra = %d, header = %d)\n",
		       dataLength, extraLength, headerLength ));
   header = xmalloc( headerLength );
   for (i = 0; i < headerLength; i++) header[i] = 0;
   header[GZ_ID1]        = GZ_MAGIC1;
   header[GZ_ID2]        = GZ_MAGIC2;
   header[GZ_CM]         = Z_DEFLATED;
   header[GZ_FLG]        = GZ_FEXTRA | GZ_FNAME;
#if HEADER_CRC
   header[GZ_FLG]        |= GZ_FHCRC;
#endif
   header[GZ_MTIME+3]    = (st.st_mtime & 0xff000000) >> 24;
   header[GZ_MTIME+2]    = (st.st_mtime & 0x00ff0000) >> 16;
   header[GZ_MTIME+1]    = (st.st_mtime & 0x0000ff00) >>  8;
   header[GZ_MTIME+0]    = (st.st_mtime & 0x000000ff) >>  0;
   header[GZ_XFL]        = GZ_MAX;
   header[GZ_OS]         = GZ_OS_UNIX;
   header[GZ_XLEN+1]     = (extraLength & 0xff00) >> 8;
   header[GZ_XLEN+0]     = (extraLength & 0x00ff) >> 0;
   header[GZ_SI1]        = GZ_RND_S1;
   header[GZ_SI2]        = GZ_RND_S2;
   header[GZ_SUBLEN+1]   = ((extraLength - 4) & 0xff00) >> 8;
   header[GZ_SUBLEN+0]   = ((extraLength - 4) & 0x00ff) >> 0;
   header[GZ_VERSION+1]  = 0;
   header[GZ_VERSION+0]  = 1;
   header[GZ_CHUNKLEN+1] = (chunkLength & 0xff00) >> 8;
   header[GZ_CHUNKLEN+0] = (chunkLength & 0x00ff) >> 0;
   header[GZ_CHUNKCNT+1] = (chunks & 0xff00) >> 8;
   header[GZ_CHUNKCNT+0] = (chunks & 0x00ff) >> 0;
   strcpy( &header[GZ_FEXTRA_START + extraLength], origFilename );
   xfwrite( header, 1, headerLength, outStr );
    
   /* Read, compress, write */
   while (!feof( inStr )) {
      if ((count = fread( inBuffer, 1, chunkLength, inStr ))) {
	 dict_data_filter( inBuffer, &count, IN_BUFFER_SIZE, preFilter );

	 inputCRC = crc32( inputCRC, (const Bytef *) inBuffer, count );
	 zStream.next_in   = (Bytef *) inBuffer;
	 zStream.avail_in  = count;
	 zStream.next_out  = (Bytef *) outBuffer;
	 zStream.avail_out = OUT_BUFFER_SIZE;
	 if (deflate( &zStream, Z_FULL_FLUSH ) != Z_OK)
	    err_fatal( __func__, "deflate: %s\n", zStream.msg );
	 assert( zStream.avail_in == 0 );
	 len = OUT_BUFFER_SIZE - zStream.avail_out;
	 assert( len <= 0xffff );

	 dict_data_filter( outBuffer, &len, OUT_BUFFER_SIZE, postFilter );
	 
	 assert( len <= 0xffff );
	 header[GZ_RNDDATA + chunk*2 + 1] = (len & 0xff00) >>  8;
	 header[GZ_RNDDATA + chunk*2 + 0] = (len & 0x00ff) >>  0;
	 xfwrite( outBuffer, 1, len, outStr );

	 ++chunk;
	 total += count;
	 if (dbg_test( DBG_VERBOSE )) {
	    printf( "chunk %5lu: %lu of %lu total\r",
		    chunk, total, (unsigned long) st.st_size );
	    xfflush( stdout );
	 }
      }
   }
int lpx_print_prob(LPX *lp, const char *fname)
{     XFILE *fp;
      int m, n, mip, i, j, len, t, type, *ndx;
      double coef, lb, ub, *val;
      char *str, name[255+1];
      xprintf("lpx_write_prob: writing problem data to `%s'...\n",
         fname);
      fp = xfopen(fname, "w");
      if (fp == NULL)
      {  xprintf("lpx_write_prob: unable to create `%s' - %s\n",
            fname, strerror(errno));
         goto fail;
      }
      m = lpx_get_num_rows(lp);
      n = lpx_get_num_cols(lp);
      mip = (lpx_get_class(lp) == LPX_MIP);
      str = (void *)lpx_get_prob_name(lp);
      xfprintf(fp, "Problem:    %s\n", str == NULL ? "(unnamed)" : str);
      xfprintf(fp, "Class:      %s\n", !mip ? "LP" : "MIP");
      xfprintf(fp, "Rows:       %d\n", m);
      if (!mip)
         xfprintf(fp, "Columns:    %d\n", n);
      else
         xfprintf(fp, "Columns:    %d (%d integer, %d binary)\n",
            n, lpx_get_num_int(lp), lpx_get_num_bin(lp));
      xfprintf(fp, "Non-zeros:  %d\n", lpx_get_num_nz(lp));
      xfprintf(fp, "\n");
      xfprintf(fp, "*** OBJECTIVE FUNCTION ***\n");
      xfprintf(fp, "\n");
      switch (lpx_get_obj_dir(lp))
      {  case LPX_MIN:
            xfprintf(fp, "Minimize:");
            break;
         case LPX_MAX:
            xfprintf(fp, "Maximize:");
            break;
         default:
            xassert(lp != lp);
      }
      str = (void *)lpx_get_obj_name(lp);
      xfprintf(fp, " %s\n", str == NULL ? "(unnamed)" : str);
      coef = lpx_get_obj_coef(lp, 0);
      if (coef != 0.0)
         xfprintf(fp, "%*.*g %s\n", DBL_DIG+7, DBL_DIG, coef,
            "(constant term)");
      for (i = 1; i <= m; i++)
#if 0
      {  coef = lpx_get_row_coef(lp, i);
#else
      {  coef = 0.0;
#endif
         if (coef != 0.0)
            xfprintf(fp, "%*.*g %s\n", DBL_DIG+7, DBL_DIG, coef,
               row_name(lp, i, name));
      }
      for (j = 1; j <= n; j++)
      {  coef = lpx_get_obj_coef(lp, j);
         if (coef != 0.0)
            xfprintf(fp, "%*.*g %s\n", DBL_DIG+7, DBL_DIG, coef,
               col_name(lp, j, name));
      }
      xfprintf(fp, "\n");
      xfprintf(fp, "*** ROWS (CONSTRAINTS) ***\n");
      ndx = xcalloc(1+n, sizeof(int));
      val = xcalloc(1+n, sizeof(double));
      for (i = 1; i <= m; i++)
      {  xfprintf(fp, "\n");
         xfprintf(fp, "Row %d: %s", i, row_name(lp, i, name));
         lpx_get_row_bnds(lp, i, &type, &lb, &ub);
         switch (type)
         {  case LPX_FR:
               xfprintf(fp, " free");
               break;
            case LPX_LO:
               xfprintf(fp, " >= %.*g", DBL_DIG, lb);
               break;
            case LPX_UP:
               xfprintf(fp, " <= %.*g", DBL_DIG, ub);
               break;
            case LPX_DB:
               xfprintf(fp, " >= %.*g <= %.*g", DBL_DIG, lb, DBL_DIG,
                  ub);
               break;
            case LPX_FX:
               xfprintf(fp, " = %.*g", DBL_DIG, lb);
               break;
            default:
               xassert(type != type);
         }
         xfprintf(fp, "\n");
#if 0
         coef = lpx_get_row_coef(lp, i);
#else
         coef = 0.0;
#endif
         if (coef != 0.0)
            xfprintf(fp, "%*.*g %s\n", DBL_DIG+7, DBL_DIG, coef,
               "(objective)");
         len = lpx_get_mat_row(lp, i, ndx, val);
         for (t = 1; t <= len; t++)
            xfprintf(fp, "%*.*g %s\n", DBL_DIG+7, DBL_DIG, val[t],
               col_name(lp, ndx[t], name));
      }
      xfree(ndx);
      xfree(val);
      xfprintf(fp, "\n");
      xfprintf(fp, "*** COLUMNS (VARIABLES) ***\n");
      ndx = xcalloc(1+m, sizeof(int));
      val = xcalloc(1+m, sizeof(double));
      for (j = 1; j <= n; j++)
      {  xfprintf(fp, "\n");
         xfprintf(fp, "Col %d: %s", j, col_name(lp, j, name));
         if (mip)
         {  switch (lpx_get_col_kind(lp, j))
            {  case LPX_CV:
                  break;
               case LPX_IV:
                  xfprintf(fp, " integer");
                  break;
               default:
                  xassert(lp != lp);
            }
         }
         lpx_get_col_bnds(lp, j, &type, &lb, &ub);
         switch (type)
         {  case LPX_FR:
               xfprintf(fp, " free");
               break;
            case LPX_LO:
               xfprintf(fp, " >= %.*g", DBL_DIG, lb);
               break;
            case LPX_UP:
               xfprintf(fp, " <= %.*g", DBL_DIG, ub);
               break;
            case LPX_DB:
               xfprintf(fp, " >= %.*g <= %.*g", DBL_DIG, lb, DBL_DIG,
                  ub);
               break;
            case LPX_FX:
               xfprintf(fp, " = %.*g", DBL_DIG, lb);
               break;
            default:
               xassert(type != type);
         }
         xfprintf(fp, "\n");
         coef = lpx_get_obj_coef(lp, j);
         if (coef != 0.0)
            xfprintf(fp, "%*.*g %s\n", DBL_DIG+7, DBL_DIG, coef,
               "(objective)");
         len = lpx_get_mat_col(lp, j, ndx, val);
         for (t = 1; t <= len; t++)
            xfprintf(fp, "%*.*g %s\n", DBL_DIG+7, DBL_DIG, val[t],
               row_name(lp, ndx[t], name));
      }
      xfree(ndx);
      xfree(val);
      xfprintf(fp, "\n");
      xfprintf(fp, "End of output\n");
      xfflush(fp);
      if (xferror(fp))
      {  xprintf("lpx_write_prob: write error on `%s' - %s\n", fname,
            strerror(errno));
         goto fail;
      }
      xfclose(fp);
      return 0;
fail: if (fp != NULL) xfclose(fp);
      return 1;
}

#undef row_name
#undef col_name

/*----------------------------------------------------------------------
-- lpx_print_sol - write LP problem solution in printable format.
--
-- *Synopsis*
--
-- #include "glplpx.h"
-- int lpx_print_sol(LPX *lp, char *fname);
--
-- *Description*
--
-- The routine lpx_print_sol writes the current basic solution of an LP
-- problem, which is specified by the pointer lp, to a text file, whose
-- name is the character string fname, in printable format.
--
-- Information reported by the routine lpx_print_sol is intended mainly
-- for visual analysis.
--
-- *Returns*
--
-- If the operation was successful, the routine returns zero. Otherwise
-- the routine prints an error message and returns non-zero. */

int lpx_print_sol(LPX *lp, const char *fname)
{     XFILE *fp;
      int what, round;
      xprintf(
         "lpx_print_sol: writing LP problem solution to `%s'...\n",
         fname);
      fp = xfopen(fname, "w");
      if (fp == NULL)
      {  xprintf("lpx_print_sol: can't create `%s' - %s\n", fname,
            strerror(errno));
         goto fail;
      }
      /* problem name */
      {  const char *name;
         name = lpx_get_prob_name(lp);
         if (name == NULL) name = "";
         xfprintf(fp, "%-12s%s\n", "Problem:", name);
      }
      /* number of rows (auxiliary variables) */
      {  int nr;
         nr = lpx_get_num_rows(lp);
         xfprintf(fp, "%-12s%d\n", "Rows:", nr);
      }
      /* number of columns (structural variables) */
      {  int nc;
         nc = lpx_get_num_cols(lp);
         xfprintf(fp, "%-12s%d\n", "Columns:", nc);
      }
      /* number of non-zeros (constraint coefficients) */
      {  int nz;
         nz = lpx_get_num_nz(lp);
         xfprintf(fp, "%-12s%d\n", "Non-zeros:", nz);
      }
      /* solution status */
      {  int status;
         status = lpx_get_status(lp);
         xfprintf(fp, "%-12s%s\n", "Status:",
            status == LPX_OPT    ? "OPTIMAL" :
            status == LPX_FEAS   ? "FEASIBLE" :
            status == LPX_INFEAS ? "INFEASIBLE (INTERMEDIATE)" :
            status == LPX_NOFEAS ? "INFEASIBLE (FINAL)" :
            status == LPX_UNBND  ? "UNBOUNDED" :
            status == LPX_UNDEF  ? "UNDEFINED" : "???");
      }
      /* objective function */
      {  char *name;
         int dir;
         double obj;
         name = (void *)lpx_get_obj_name(lp);
         dir = lpx_get_obj_dir(lp);
         obj = lpx_get_obj_val(lp);
         xfprintf(fp, "%-12s%s%s%.10g %s\n", "Objective:",
            name == NULL ? "" : name,
            name == NULL ? "" : " = ", obj,
            dir == LPX_MIN ? "(MINimum)" :
            dir == LPX_MAX ? "(MAXimum)" : "(" "???" ")");
      }
      /* main sheet */
      for (what = 1; what <= 2; what++)
      {  int mn, ij;
         xfprintf(fp, "\n");
         xfprintf(fp, "   No. %-12s St   Activity     Lower bound   Upp"
            "er bound    Marginal\n",
            what == 1 ? "  Row name" : "Column name");
         xfprintf(fp, "------ ------------ -- ------------- -----------"
            "-- ------------- -------------\n");
         mn = (what == 1 ? lpx_get_num_rows(lp) : lpx_get_num_cols(lp));
         for (ij = 1; ij <= mn; ij++)
         {  const char *name;
            int typx, tagx;
            double lb, ub, vx, dx;
            if (what == 1)
            {  name = lpx_get_row_name(lp, ij);
               if (name == NULL) name = "";
               lpx_get_row_bnds(lp, ij, &typx, &lb, &ub);
               round = lpx_get_int_parm(lp, LPX_K_ROUND);
               lpx_set_int_parm(lp, LPX_K_ROUND, 1);
               lpx_get_row_info(lp, ij, &tagx, &vx, &dx);
               lpx_set_int_parm(lp, LPX_K_ROUND, round);
            }
            else
            {  name = lpx_get_col_name(lp, ij);
               if (name == NULL) name = "";
               lpx_get_col_bnds(lp, ij, &typx, &lb, &ub);
               round = lpx_get_int_parm(lp, LPX_K_ROUND);
               lpx_set_int_parm(lp, LPX_K_ROUND, 1);
               lpx_get_col_info(lp, ij, &tagx, &vx, &dx);
               lpx_set_int_parm(lp, LPX_K_ROUND, round);
            }
            /* row/column ordinal number */
            xfprintf(fp, "%6d ", ij);
            /* row column/name */
            if (strlen(name) <= 12)
               xfprintf(fp, "%-12s ", name);
            else
               xfprintf(fp, "%s\n%20s", name, "");
            /* row/column status */
            xfprintf(fp, "%s ",
               tagx == LPX_BS ? "B " :
               tagx == LPX_NL ? "NL" :
               tagx == LPX_NU ? "NU" :
               tagx == LPX_NF ? "NF" :
               tagx == LPX_NS ? "NS" : "??");
            /* row/column primal activity */
            xfprintf(fp, "%13.6g ", vx);
            /* row/column lower bound */
            if (typx == LPX_LO || typx == LPX_DB || typx == LPX_FX)
               xfprintf(fp, "%13.6g ", lb);
            else
               xfprintf(fp, "%13s ", "");
            /* row/column upper bound */
            if (typx == LPX_UP || typx == LPX_DB)
               xfprintf(fp, "%13.6g ", ub);
            else if (typx == LPX_FX)
               xfprintf(fp, "%13s ", "=");
            else
               xfprintf(fp, "%13s ", "");
            /* row/column dual activity */
            if (tagx != LPX_BS)
            {  if (dx == 0.0)
                  xfprintf(fp, "%13s", "< eps");
               else
                  xfprintf(fp, "%13.6g", dx);
            }
            /* end of line */
            xfprintf(fp, "\n");
         }
      }
      xfprintf(fp, "\n");
#if 1
      if (lpx_get_prim_stat(lp) != LPX_P_UNDEF &&
          lpx_get_dual_stat(lp) != LPX_D_UNDEF)
      {  int m = lpx_get_num_rows(lp);
         LPXKKT kkt;
         xfprintf(fp, "Karush-Kuhn-Tucker optimality conditions:\n\n");
         lpx_check_kkt(lp, 1, &kkt);
         xfprintf(fp, "KKT.PE: max.abs.err. = %.2e on row %d\n",
            kkt.pe_ae_max, kkt.pe_ae_row);
         xfprintf(fp, "        max.rel.err. = %.2e on row %d\n",
            kkt.pe_re_max, kkt.pe_re_row);
         switch (kkt.pe_quality)
         {  case 'H':
               xfprintf(fp, "        High quality\n");
               break;
            case 'M':
               xfprintf(fp, "        Medium quality\n");
               break;
            case 'L':
               xfprintf(fp, "        Low quality\n");
               break;
            default:
               xfprintf(fp, "        PRIMAL SOLUTION IS WRONG\n");
               break;
         }
         xfprintf(fp, "\n");
         xfprintf(fp, "KKT.PB: max.abs.err. = %.2e on %s %d\n",
            kkt.pb_ae_max, kkt.pb_ae_ind <= m ? "row" : "column",
            kkt.pb_ae_ind <= m ? kkt.pb_ae_ind : kkt.pb_ae_ind - m);
         xfprintf(fp, "        max.rel.err. = %.2e on %s %d\n",
            kkt.pb_re_max, kkt.pb_re_ind <= m ? "row" : "column",
            kkt.pb_re_ind <= m ? kkt.pb_re_ind : kkt.pb_re_ind - m);
         switch (kkt.pb_quality)
         {  case 'H':
               xfprintf(fp, "        High quality\n");
               break;
            case 'M':
               xfprintf(fp, "        Medium quality\n");
               break;
            case 'L':
               xfprintf(fp, "        Low quality\n");
               break;
            default:
               xfprintf(fp, "        PRIMAL SOLUTION IS INFEASIBLE\n");
               break;
         }
         xfprintf(fp, "\n");
         xfprintf(fp, "KKT.DE: max.abs.err. = %.2e on column %d\n",
            kkt.de_ae_max, kkt.de_ae_col);
         xfprintf(fp, "        max.rel.err. = %.2e on column %d\n",
            kkt.de_re_max, kkt.de_re_col);
         switch (kkt.de_quality)
         {  case 'H':
               xfprintf(fp, "        High quality\n");
               break;
            case 'M':
               xfprintf(fp, "        Medium quality\n");
               break;
            case 'L':
               xfprintf(fp, "        Low quality\n");
               break;
            default:
               xfprintf(fp, "        DUAL SOLUTION IS WRONG\n");
               break;
         }
         xfprintf(fp, "\n");
         xfprintf(fp, "KKT.DB: max.abs.err. = %.2e on %s %d\n",
            kkt.db_ae_max, kkt.db_ae_ind <= m ? "row" : "column",
            kkt.db_ae_ind <= m ? kkt.db_ae_ind : kkt.db_ae_ind - m);
         xfprintf(fp, "        max.rel.err. = %.2e on %s %d\n",
            kkt.db_re_max, kkt.db_re_ind <= m ? "row" : "column",
            kkt.db_re_ind <= m ? kkt.db_re_ind : kkt.db_re_ind - m);
         switch (kkt.db_quality)
         {  case 'H':
               xfprintf(fp, "        High quality\n");
               break;
            case 'M':
               xfprintf(fp, "        Medium quality\n");
               break;
            case 'L':
               xfprintf(fp, "        Low quality\n");
               break;
            default:
               xfprintf(fp, "        DUAL SOLUTION IS INFEASIBLE\n");
               break;
         }
         xfprintf(fp, "\n");
      }
#endif
#if 1
      if (lpx_get_status(lp) == LPX_UNBND)
      {  int m = lpx_get_num_rows(lp);
         int k = lpx_get_ray_info(lp);
         xfprintf(fp, "Unbounded ray: %s %d\n",
            k <= m ? "row" : "column", k <= m ? k : k - m);
         xfprintf(fp, "\n");
      }
#endif
      xfprintf(fp, "End of output\n");
      xfflush(fp);
      if (xferror(fp))
      {  xprintf("lpx_print_sol: can't write to `%s' - %s\n", fname,
            strerror(errno));
         goto fail;
      }
      xfclose(fp);
      return 0;
fail: if (fp != NULL) xfclose(fp);
      return 1;
}
int lpx_print_mip(LPX *lp, const char *fname)
{     XFILE *fp;
      int what, round;
#if 0
      if (lpx_get_class(lp) != LPX_MIP)
         fault("lpx_print_mip: error -- not a MIP problem");
#endif
      xprintf(
         "lpx_print_mip: writing MIP problem solution to `%s'...\n",
         fname);
      fp = xfopen(fname, "w");
      if (fp == NULL)
      {  xprintf("lpx_print_mip: can't create `%s' - %s\n", fname,
            strerror(errno));
         goto fail;
      }
      /* problem name */
      {  const char *name;
         name = lpx_get_prob_name(lp);
         if (name == NULL) name = "";
         xfprintf(fp, "%-12s%s\n", "Problem:", name);
      }
      /* number of rows (auxiliary variables) */
      {  int nr;
         nr = lpx_get_num_rows(lp);
         xfprintf(fp, "%-12s%d\n", "Rows:", nr);
      }
      /* number of columns (structural variables) */
      {  int nc, nc_int, nc_bin;
         nc = lpx_get_num_cols(lp);
         nc_int = lpx_get_num_int(lp);
         nc_bin = lpx_get_num_bin(lp);
         xfprintf(fp, "%-12s%d (%d integer, %d binary)\n", "Columns:",
            nc, nc_int, nc_bin);
      }
      /* number of non-zeros (constraint coefficients) */
      {  int nz;
         nz = lpx_get_num_nz(lp);
         xfprintf(fp, "%-12s%d\n", "Non-zeros:", nz);
      }
      /* solution status */
      {  int status;
         status = lpx_mip_status(lp);
         xfprintf(fp, "%-12s%s\n", "Status:",
            status == LPX_I_UNDEF  ? "INTEGER UNDEFINED" :
            status == LPX_I_OPT    ? "INTEGER OPTIMAL" :
            status == LPX_I_FEAS   ? "INTEGER NON-OPTIMAL" :
            status == LPX_I_NOFEAS ? "INTEGER EMPTY" : "???");
      }
      /* objective function */
      {  char *name;
         int dir;
         double mip_obj;
         name = (void *)lpx_get_obj_name(lp);
         dir = lpx_get_obj_dir(lp);
         mip_obj = lpx_mip_obj_val(lp);
         xfprintf(fp, "%-12s%s%s%.10g %s\n", "Objective:",
            name == NULL ? "" : name,
            name == NULL ? "" : " = ", mip_obj,
            dir == LPX_MIN ? "(MINimum)" :
            dir == LPX_MAX ? "(MAXimum)" : "(" "???" ")");
      }
      /* main sheet */
      for (what = 1; what <= 2; what++)
      {  int mn, ij;
         xfprintf(fp, "\n");
         xfprintf(fp, "   No. %-12s      Activity     Lower bound   Upp"
            "er bound\n",
            what == 1 ? "  Row name" : "Column name");
         xfprintf(fp, "------ ------------    ------------- -----------"
            "-- -------------\n");
         mn = (what == 1 ? lpx_get_num_rows(lp) : lpx_get_num_cols(lp));
         for (ij = 1; ij <= mn; ij++)
         {  const char *name;
            int kind, typx;
            double lb, ub, vx;
            if (what == 1)
            {  name = lpx_get_row_name(lp, ij);
               if (name == NULL) name = "";
               kind = LPX_CV;
               lpx_get_row_bnds(lp, ij, &typx, &lb, &ub);
               round = lpx_get_int_parm(lp, LPX_K_ROUND);
               lpx_set_int_parm(lp, LPX_K_ROUND, 1);
               vx = lpx_mip_row_val(lp, ij);
               lpx_set_int_parm(lp, LPX_K_ROUND, round);
            }
            else
            {  name = lpx_get_col_name(lp, ij);
               if (name == NULL) name = "";
               kind = lpx_get_col_kind(lp, ij);
               lpx_get_col_bnds(lp, ij, &typx, &lb, &ub);
               round = lpx_get_int_parm(lp, LPX_K_ROUND);
               lpx_set_int_parm(lp, LPX_K_ROUND, 1);
               vx = lpx_mip_col_val(lp, ij);
               lpx_set_int_parm(lp, LPX_K_ROUND, round);
            }
            /* row/column ordinal number */
            xfprintf(fp, "%6d ", ij);
            /* row column/name */
            if (strlen(name) <= 12)
               xfprintf(fp, "%-12s ", name);
            else
               xfprintf(fp, "%s\n%20s", name, "");
            /* row/column kind */
            xfprintf(fp, "%s  ",
               kind == LPX_CV ? " " : kind == LPX_IV ? "*" : "?");
            /* row/column primal activity */
            xfprintf(fp, "%13.6g", vx);
            /* row/column lower and upper bounds */
            switch (typx)
            {  case LPX_FR:
                  break;
               case LPX_LO:
                  xfprintf(fp, " %13.6g", lb);
                  break;
               case LPX_UP:
                  xfprintf(fp, " %13s %13.6g", "", ub);
                  break;
               case LPX_DB:
                  xfprintf(fp, " %13.6g %13.6g", lb, ub);
                  break;
               case LPX_FX:
                  xfprintf(fp, " %13.6g %13s", lb, "=");
                  break;
               default:
                  xassert(typx != typx);
            }
            /* end of line */
            xfprintf(fp, "\n");
         }
      }
      xfprintf(fp, "\n");
#if 1
      if (lpx_mip_status(lp) != LPX_I_UNDEF)
      {  int m = lpx_get_num_rows(lp);
         LPXKKT kkt;
         xfprintf(fp, "Integer feasibility conditions:\n\n");
         lpx_check_int(lp, &kkt);
         xfprintf(fp, "INT.PE: max.abs.err. = %.2e on row %d\n",
            kkt.pe_ae_max, kkt.pe_ae_row);
         xfprintf(fp, "        max.rel.err. = %.2e on row %d\n",
            kkt.pe_re_max, kkt.pe_re_row);
         switch (kkt.pe_quality)
         {  case 'H':
               xfprintf(fp, "        High quality\n");
               break;
            case 'M':
               xfprintf(fp, "        Medium quality\n");
               break;
            case 'L':
               xfprintf(fp, "        Low quality\n");
               break;
            default:
               xfprintf(fp, "        SOLUTION IS WRONG\n");
               break;
         }
         xfprintf(fp, "\n");
         xfprintf(fp, "INT.PB: max.abs.err. = %.2e on %s %d\n",
            kkt.pb_ae_max, kkt.pb_ae_ind <= m ? "row" : "column",
            kkt.pb_ae_ind <= m ? kkt.pb_ae_ind : kkt.pb_ae_ind - m);
         xfprintf(fp, "        max.rel.err. = %.2e on %s %d\n",
            kkt.pb_re_max, kkt.pb_re_ind <= m ? "row" : "column",
            kkt.pb_re_ind <= m ? kkt.pb_re_ind : kkt.pb_re_ind - m);
         switch (kkt.pb_quality)
         {  case 'H':
               xfprintf(fp, "        High quality\n");
               break;
            case 'M':
               xfprintf(fp, "        Medium quality\n");
               break;
            case 'L':
               xfprintf(fp, "        Low quality\n");
               break;
            default:
               xfprintf(fp, "        SOLUTION IS INFEASIBLE\n");
               break;
         }
         xfprintf(fp, "\n");
      }
#endif
      xfprintf(fp, "End of output\n");
      xfflush(fp);
      if (xferror(fp))
      {  xprintf("lpx_print_mip: can't write to `%s' - %s\n", fname,
            strerror(errno));
         goto fail;
      }
      xfclose(fp);
      return 0;
fail: if (fp != NULL) xfclose(fp);
      return 1;
}
int lpx_print_ips(LPX *lp, const char *fname)
{     XFILE *fp;
      int what, round;
      xprintf("lpx_print_ips: writing LP problem solution to `%s'...\n",
         fname);
      fp = xfopen(fname, "w");
      if (fp == NULL)
      {  xprintf("lpx_print_ips: can't create `%s' - %s\n", fname,
            strerror(errno));
         goto fail;
      }
      /* problem name */
      {  const char *name;
         name = lpx_get_prob_name(lp);
         if (name == NULL) name = "";
         xfprintf(fp, "%-12s%s\n", "Problem:", name);
      }
      /* number of rows (auxiliary variables) */
      {  int nr;
         nr = lpx_get_num_rows(lp);
         xfprintf(fp, "%-12s%d\n", "Rows:", nr);
      }
      /* number of columns (structural variables) */
      {  int nc;
         nc = lpx_get_num_cols(lp);
         xfprintf(fp, "%-12s%d\n", "Columns:", nc);
      }
      /* number of non-zeros (constraint coefficients) */
      {  int nz;
         nz = lpx_get_num_nz(lp);
         xfprintf(fp, "%-12s%d\n", "Non-zeros:", nz);
      }
      /* solution status */
      {  int status;
         status = lpx_ipt_status(lp);
         xfprintf(fp, "%-12s%s\n", "Status:",
            status == LPX_T_UNDEF  ? "INTERIOR UNDEFINED" :
            status == LPX_T_OPT    ? "INTERIOR OPTIMAL" : "???");
      }
      /* objective function */
      {  char *name;
         int dir;
         double obj;
         name = (void *)lpx_get_obj_name(lp);
         dir = lpx_get_obj_dir(lp);
         obj = lpx_ipt_obj_val(lp);
         xfprintf(fp, "%-12s%s%s%.10g %s\n", "Objective:",
            name == NULL ? "" : name,
            name == NULL ? "" : " = ", obj,
            dir == LPX_MIN ? "(MINimum)" :
            dir == LPX_MAX ? "(MAXimum)" : "(" "???" ")");
      }
      /* main sheet */
      for (what = 1; what <= 2; what++)
      {  int mn, ij;
         xfprintf(fp, "\n");
         xfprintf(fp, "   No. %-12s      Activity     Lower bound   Upp"
            "er bound    Marginal\n",
            what == 1 ? "  Row name" : "Column name");
         xfprintf(fp, "------ ------------    ------------- -----------"
            "-- ------------- -------------\n");
         mn = (what == 1 ? lpx_get_num_rows(lp) : lpx_get_num_cols(lp));
         for (ij = 1; ij <= mn; ij++)
         {  const char *name;
            int typx /*, tagx */;
            double lb, ub, vx, dx;
            if (what == 1)
            {  name = lpx_get_row_name(lp, ij);
               if (name == NULL) name = "";
               lpx_get_row_bnds(lp, ij, &typx, &lb, &ub);
               round = lpx_get_int_parm(lp, LPX_K_ROUND);
               lpx_set_int_parm(lp, LPX_K_ROUND, 1);
               vx = lpx_ipt_row_prim(lp, ij);
               dx = lpx_ipt_row_dual(lp, ij);
               lpx_set_int_parm(lp, LPX_K_ROUND, round);
            }
            else
            {  name = lpx_get_col_name(lp, ij);
               if (name == NULL) name = "";
               lpx_get_col_bnds(lp, ij, &typx, &lb, &ub);
               round = lpx_get_int_parm(lp, LPX_K_ROUND);
               lpx_set_int_parm(lp, LPX_K_ROUND, 1);
               vx = lpx_ipt_col_prim(lp, ij);
               dx = lpx_ipt_col_dual(lp, ij);
               lpx_set_int_parm(lp, LPX_K_ROUND, round);
            }
            /* row/column ordinal number */
            xfprintf(fp, "%6d ", ij);
            /* row column/name */
            if (strlen(name) <= 12)
               xfprintf(fp, "%-12s ", name);
            else
               xfprintf(fp, "%s\n%20s", name, "");
            /* two positions are currently not used */
            xfprintf(fp, "   ");
            /* row/column primal activity */
            xfprintf(fp, "%13.6g ", vx);
            /* row/column lower bound */
            if (typx == LPX_LO || typx == LPX_DB || typx == LPX_FX)
               xfprintf(fp, "%13.6g ", lb);
            else
               xfprintf(fp, "%13s ", "");
            /* row/column upper bound */
            if (typx == LPX_UP || typx == LPX_DB)
               xfprintf(fp, "%13.6g ", ub);
            else if (typx == LPX_FX)
               xfprintf(fp, "%13s ", "=");
            else
               xfprintf(fp, "%13s ", "");
            /* row/column dual activity */
            xfprintf(fp, "%13.6g", dx);
            /* end of line */
            xfprintf(fp, "\n");
         }
      }
      xfprintf(fp, "\n");
      xfprintf(fp, "End of output\n");
      xfflush(fp);
      if (xferror(fp))
      {  xprintf("lpx_print_ips: can't write to `%s' - %s\n", fname,
            strerror(errno));
         goto fail;
      }
      xfclose(fp);
      return 0;
fail: if (fp != NULL) xfclose(fp);
      return 1;
}
int glp_print_mip(glp_prob *P, const char *fname)
{   /* write MIP solution in printable format */
    glp_file *fp;
    GLPROW *row;
    GLPCOL *col;
    int i, j, t, ae_ind, re_ind, ret;
    double ae_max, re_max;
    xprintf("Writing MIP solution to '%s'...\n", fname);
    fp = glp_open(fname, "w");
    if (fp == NULL)
    {   xprintf("Unable to create '%s' - %s\n", fname, get_err_msg());
        ret = 1;
        goto done;
    }
    xfprintf(fp, "%-12s%s\n", "Problem:",
             P->name == NULL ? "" : P->name);
    xfprintf(fp, "%-12s%d\n", "Rows:", P->m);
    xfprintf(fp, "%-12s%d (%d integer, %d binary)\n", "Columns:",
             P->n, glp_get_num_int(P), glp_get_num_bin(P));
    xfprintf(fp, "%-12s%d\n", "Non-zeros:", P->nnz);
    t = glp_mip_status(P);
    xfprintf(fp, "%-12s%s\n", "Status:",
             t == GLP_OPT    ? "INTEGER OPTIMAL" :
             t == GLP_FEAS   ? "INTEGER NON-OPTIMAL" :
             t == GLP_NOFEAS ? "INTEGER EMPTY" :
             t == GLP_UNDEF  ? "INTEGER UNDEFINED" : "???");
    xfprintf(fp, "%-12s%s%s%.10g (%s)\n", "Objective:",
             P->obj == NULL ? "" : P->obj,
             P->obj == NULL ? "" : " = ", P->mip_obj,
             P->dir == GLP_MIN ? "MINimum" :
             P->dir == GLP_MAX ? "MAXimum" : "???");
    xfprintf(fp, "\n");
    xfprintf(fp, "   No.   Row name        Activity     Lower bound  "
             " Upper bound\n");
    xfprintf(fp, "------ ------------    ------------- ------------- "
             "-------------\n");
    for (i = 1; i <= P->m; i++)
    {   row = P->row[i];
        xfprintf(fp, "%6d ", i);
        if (row->name == NULL || strlen(row->name) <= 12)
            xfprintf(fp, "%-12s ", row->name == NULL ? "" : row->name);
        else
            xfprintf(fp, "%s\n%20s", row->name, "");
        xfprintf(fp, "%3s", "");
        xfprintf(fp, "%13.6g ",
                 fabs(row->mipx) <= 1e-9 ? 0.0 : row->mipx);
        if (row->type == GLP_LO || row->type == GLP_DB ||
                row->type == GLP_FX)
            xfprintf(fp, "%13.6g ", row->lb);
        else
            xfprintf(fp, "%13s ", "");
        if (row->type == GLP_UP || row->type == GLP_DB)
            xfprintf(fp, "%13.6g ", row->ub);
        else
            xfprintf(fp, "%13s ", row->type == GLP_FX ? "=" : "");
        xfprintf(fp, "\n");
    }
    xfprintf(fp, "\n");
    xfprintf(fp, "   No. Column name       Activity     Lower bound  "
             " Upper bound\n");
    xfprintf(fp, "------ ------------    ------------- ------------- "
             "-------------\n");
    for (j = 1; j <= P->n; j++)
    {   col = P->col[j];
        xfprintf(fp, "%6d ", j);
        if (col->name == NULL || strlen(col->name) <= 12)
            xfprintf(fp, "%-12s ", col->name == NULL ? "" : col->name);
        else
            xfprintf(fp, "%s\n%20s", col->name, "");
        xfprintf(fp, "%s  ",
                 col->kind == GLP_CV ? " " :
                 col->kind == GLP_IV ? "*" : "?");
        xfprintf(fp, "%13.6g ",
                 fabs(col->mipx) <= 1e-9 ? 0.0 : col->mipx);
        if (col->type == GLP_LO || col->type == GLP_DB ||
                col->type == GLP_FX)
            xfprintf(fp, "%13.6g ", col->lb);
        else
            xfprintf(fp, "%13s ", "");
        if (col->type == GLP_UP || col->type == GLP_DB)
            xfprintf(fp, "%13.6g ", col->ub);
        else
            xfprintf(fp, "%13s ", col->type == GLP_FX ? "=" : "");
        xfprintf(fp, "\n");
    }
    xfprintf(fp, "\n");
    xfprintf(fp, "Integer feasibility conditions:\n");
    xfprintf(fp, "\n");
    glp_check_kkt(P, GLP_MIP, GLP_KKT_PE, &ae_max, &ae_ind, &re_max,
                  &re_ind);
    xfprintf(fp, "KKT.PE: max.abs.err = %.2e on row %d\n",
             ae_max, ae_ind);
    xfprintf(fp, "        max.rel.err = %.2e on row %d\n",
             re_max, re_ind);
    xfprintf(fp, "%8s%s\n", "",
             re_max <= 1e-9 ? "High quality" :
             re_max <= 1e-6 ? "Medium quality" :
             re_max <= 1e-3 ? "Low quality" : "SOLUTION IS WRONG");
    xfprintf(fp, "\n");
    glp_check_kkt(P, GLP_MIP, GLP_KKT_PB, &ae_max, &ae_ind, &re_max,
                  &re_ind);
    xfprintf(fp, "KKT.PB: max.abs.err = %.2e on %s %d\n",
             ae_max, ae_ind <= P->m ? "row" : "column",
             ae_ind <= P->m ? ae_ind : ae_ind - P->m);
    xfprintf(fp, "        max.rel.err = %.2e on %s %d\n",
             re_max, re_ind <= P->m ? "row" : "column",
             re_ind <= P->m ? re_ind : re_ind - P->m);
    xfprintf(fp, "%8s%s\n", "",
             re_max <= 1e-9 ? "High quality" :
             re_max <= 1e-6 ? "Medium quality" :
             re_max <= 1e-3 ? "Low quality" : "SOLUTION IS INFEASIBLE");
    xfprintf(fp, "\n");
    xfprintf(fp, "End of output\n");
#if 0 /* FIXME */
    xfflush(fp);
#endif
    if (glp_ioerr(fp))
    {   xprintf("Write error on '%s' - %s\n", fname, get_err_msg());
        ret = 1;
        goto done;
    }
    ret = 0;
done:
    if (fp != NULL) glp_close(fp);
    return ret;
}
int glp_print_ipt(glp_prob *P, const char *fname)
{   /* write interior-point solution in printable format */
    glp_file *fp;
    GLPROW *row;
    GLPCOL *col;
    int i, j, t, ae_ind, re_ind, ret;
    double ae_max, re_max;
    xprintf("Writing interior-point solution to '%s'...\n", fname);
    fp = glp_open(fname, "w");
    if (fp == NULL)
    {   xprintf("Unable to create '%s' - %s\n", fname, get_err_msg());
        ret = 1;
        goto done;
    }
    xfprintf(fp, "%-12s%s\n", "Problem:",
             P->name == NULL ? "" : P->name);
    xfprintf(fp, "%-12s%d\n", "Rows:", P->m);
    xfprintf(fp, "%-12s%d\n", "Columns:", P->n);
    xfprintf(fp, "%-12s%d\n", "Non-zeros:", P->nnz);
    t = glp_ipt_status(P);
    xfprintf(fp, "%-12s%s\n", "Status:",
             t == GLP_OPT    ? "OPTIMAL" :
             t == GLP_UNDEF  ? "UNDEFINED" :
             t == GLP_INFEAS ? "INFEASIBLE (INTERMEDIATE)" :
             t == GLP_NOFEAS ? "INFEASIBLE (FINAL)" : "???");
    xfprintf(fp, "%-12s%s%s%.10g (%s)\n", "Objective:",
             P->obj == NULL ? "" : P->obj,
             P->obj == NULL ? "" : " = ", P->ipt_obj,
             P->dir == GLP_MIN ? "MINimum" :
             P->dir == GLP_MAX ? "MAXimum" : "???");
    xfprintf(fp, "\n");
    xfprintf(fp, "   No.   Row name        Activity     Lower bound  "
             " Upper bound    Marginal\n");
    xfprintf(fp, "------ ------------    ------------- ------------- "
             "------------- -------------\n");
    for (i = 1; i <= P->m; i++)
    {   row = P->row[i];
        xfprintf(fp, "%6d ", i);
        if (row->name == NULL || strlen(row->name) <= 12)
            xfprintf(fp, "%-12s ", row->name == NULL ? "" : row->name);
        else
            xfprintf(fp, "%s\n%20s", row->name, "");
        xfprintf(fp, "%3s", "");
        xfprintf(fp, "%13.6g ",
                 fabs(row->pval) <= 1e-9 ? 0.0 : row->pval);
        if (row->type == GLP_LO || row->type == GLP_DB ||
                row->type == GLP_FX)
            xfprintf(fp, "%13.6g ", row->lb);
        else
            xfprintf(fp, "%13s ", "");
        if (row->type == GLP_UP || row->type == GLP_DB)
            xfprintf(fp, "%13.6g ", row->ub);
        else
            xfprintf(fp, "%13s ", row->type == GLP_FX ? "=" : "");
        if (fabs(row->dval) <= 1e-9)
            xfprintf(fp, "%13s", "< eps");
        else
            xfprintf(fp, "%13.6g ", row->dval);
        xfprintf(fp, "\n");
    }
    xfprintf(fp, "\n");
    xfprintf(fp, "   No. Column name       Activity     Lower bound  "
             " Upper bound    Marginal\n");
    xfprintf(fp, "------ ------------    ------------- ------------- "
             "------------- -------------\n");
    for (j = 1; j <= P->n; j++)
    {   col = P->col[j];
        xfprintf(fp, "%6d ", j);
        if (col->name == NULL || strlen(col->name) <= 12)
            xfprintf(fp, "%-12s ", col->name == NULL ? "" : col->name);
        else
            xfprintf(fp, "%s\n%20s", col->name, "");
        xfprintf(fp, "%3s", "");
        xfprintf(fp, "%13.6g ",
                 fabs(col->pval) <= 1e-9 ? 0.0 : col->pval);
        if (col->type == GLP_LO || col->type == GLP_DB ||
                col->type == GLP_FX)
            xfprintf(fp, "%13.6g ", col->lb);
        else
            xfprintf(fp, "%13s ", "");
        if (col->type == GLP_UP || col->type == GLP_DB)
            xfprintf(fp, "%13.6g ", col->ub);
        else
            xfprintf(fp, "%13s ", col->type == GLP_FX ? "=" : "");
        if (fabs(col->dval) <= 1e-9)
            xfprintf(fp, "%13s", "< eps");
        else
            xfprintf(fp, "%13.6g ", col->dval);
        xfprintf(fp, "\n");
    }
    xfprintf(fp, "\n");
    xfprintf(fp, "Karush-Kuhn-Tucker optimality conditions:\n");
    xfprintf(fp, "\n");
    glp_check_kkt(P, GLP_IPT, GLP_KKT_PE, &ae_max, &ae_ind, &re_max,
                  &re_ind);
    xfprintf(fp, "KKT.PE: max.abs.err = %.2e on row %d\n",
             ae_max, ae_ind);
    xfprintf(fp, "        max.rel.err = %.2e on row %d\n",
             re_max, re_ind);
    xfprintf(fp, "%8s%s\n", "",
             re_max <= 1e-9 ? "High quality" :
             re_max <= 1e-6 ? "Medium quality" :
             re_max <= 1e-3 ? "Low quality" : "PRIMAL SOLUTION IS WRONG");
    xfprintf(fp, "\n");
    glp_check_kkt(P, GLP_IPT, GLP_KKT_PB, &ae_max, &ae_ind, &re_max,
                  &re_ind);
    xfprintf(fp, "KKT.PB: max.abs.err = %.2e on %s %d\n",
             ae_max, ae_ind <= P->m ? "row" : "column",
             ae_ind <= P->m ? ae_ind : ae_ind - P->m);
    xfprintf(fp, "        max.rel.err = %.2e on %s %d\n",
             re_max, re_ind <= P->m ? "row" : "column",
             re_ind <= P->m ? re_ind : re_ind - P->m);
    xfprintf(fp, "%8s%s\n", "",
             re_max <= 1e-9 ? "High quality" :
             re_max <= 1e-6 ? "Medium quality" :
             re_max <= 1e-3 ? "Low quality" : "PRIMAL SOLUTION IS INFEASIBL"
             "E");
    xfprintf(fp, "\n");
    glp_check_kkt(P, GLP_IPT, GLP_KKT_DE, &ae_max, &ae_ind, &re_max,
                  &re_ind);
    xfprintf(fp, "KKT.DE: max.abs.err = %.2e on column %d\n",
             ae_max, ae_ind == 0 ? 0 : ae_ind - P->m);
    xfprintf(fp, "        max.rel.err = %.2e on column %d\n",
             re_max, re_ind == 0 ? 0 : re_ind - P->m);
    xfprintf(fp, "%8s%s\n", "",
             re_max <= 1e-9 ? "High quality" :
             re_max <= 1e-6 ? "Medium quality" :
             re_max <= 1e-3 ? "Low quality" : "DUAL SOLUTION IS WRONG");
    xfprintf(fp, "\n");
    glp_check_kkt(P, GLP_IPT, GLP_KKT_DB, &ae_max, &ae_ind, &re_max,
                  &re_ind);
    xfprintf(fp, "KKT.DB: max.abs.err = %.2e on %s %d\n",
             ae_max, ae_ind <= P->m ? "row" : "column",
             ae_ind <= P->m ? ae_ind : ae_ind - P->m);
    xfprintf(fp, "        max.rel.err = %.2e on %s %d\n",
             re_max, re_ind <= P->m ? "row" : "column",
             re_ind <= P->m ? re_ind : re_ind - P->m);
    xfprintf(fp, "%8s%s\n", "",
             re_max <= 1e-9 ? "High quality" :
             re_max <= 1e-6 ? "Medium quality" :
             re_max <= 1e-3 ? "Low quality" : "DUAL SOLUTION IS INFEASIBLE")
    ;
    xfprintf(fp, "\n");
    xfprintf(fp, "End of output\n");
#if 0 /* FIXME */
    xfflush(fp);
#endif
    if (glp_ioerr(fp))
    {   xprintf("Write error on '%s' - %s\n", fname, get_err_msg());
        ret = 1;
        goto done;
    }
    ret = 0;
done:
    if (fp != NULL) glp_close(fp);
    return ret;
}
int glp_print_ranges(glp_prob *P, int len, const int list[],
                     int flags, const char *fname)
{   /* print sensitivity analysis report */
    glp_file *fp = NULL;
    GLPROW *row;
    GLPCOL *col;
    int m, n, pass, k, t, numb, type, stat, var1, var2, count, page,
        ret;
    double lb, ub, slack, coef, prim, dual, value1, value2, coef1,
           coef2, obj1, obj2;
    const char *name, *limit;
    char buf[13+1];
    /* sanity checks */
    if (P == NULL || P->magic != GLP_PROB_MAGIC)
        xerror("glp_print_ranges: P = %p; invalid problem object\n",
               P);
    m = P->m, n = P->n;
    if (len < 0)
        xerror("glp_print_ranges: len = %d; invalid list length\n",
               len);
    if (len > 0)
    {   if (list == NULL)
            xerror("glp_print_ranges: list = %p: invalid parameter\n",
                   list);
        for (t = 1; t <= len; t++)
        {   k = list[t];
            if (!(1 <= k && k <= m+n))
                xerror("glp_print_ranges: list[%d] = %d; row/column numb"
                       "er out of range\n", t, k);
        }
    }
    if (flags != 0)
        xerror("glp_print_ranges: flags = %d; invalid parameter\n",
               flags);
    if (fname == NULL)
        xerror("glp_print_ranges: fname = %p; invalid parameter\n",
               fname);
    if (glp_get_status(P) != GLP_OPT)
    {   xprintf("glp_print_ranges: optimal basic solution required\n");
        ret = 1;
        goto done;
    }
    if (!glp_bf_exists(P))
    {   xprintf("glp_print_ranges: basis factorization required\n");
        ret = 2;
        goto done;
    }
    /* start reporting */
    xprintf("Write sensitivity analysis report to '%s'...\n", fname);
    fp = glp_open(fname, "w");
    if (fp == NULL)
    {   xprintf("Unable to create '%s' - %s\n", fname, get_err_msg());
        ret = 3;
        goto done;
    }
    page = count = 0;
    for (pass = 1; pass <= 2; pass++)
        for (t = 1; t <= (len == 0 ? m+n : len); t++)
        {   if (t == 1) count = 0;
            k = (len == 0 ? t : list[t]);
            if (pass == 1 && k > m || pass == 2 && k <= m)
                continue;
            if (count == 0)
            {   xfprintf(fp, "GLPK %-4s - SENSITIVITY ANALYSIS REPORT%73sPa"
                         "ge%4d\n", glp_version(), "", ++page);
                xfprintf(fp, "\n");
                xfprintf(fp, "%-12s%s\n", "Problem:",
                         P->name == NULL ? "" : P->name);
                xfprintf(fp, "%-12s%s%s%.10g (%s)\n", "Objective:",
                         P->obj == NULL ? "" : P->obj,
                         P->obj == NULL ? "" : " = ", P->obj_val,
                         P->dir == GLP_MIN ? "MINimum" :
                         P->dir == GLP_MAX ? "MAXimum" : "???");
                xfprintf(fp, "\n");
                xfprintf(fp, "%6s %-12s %2s %13s %13s %13s  %13s %13s %13s "
                         "%s\n", "No.", pass == 1 ? "Row name" : "Column name",
                         "St", "Activity", pass == 1 ? "Slack" : "Obj coef",
                         "Lower bound", "Activity", "Obj coef", "Obj value at",
                         "Limiting");
                xfprintf(fp, "%6s %-12s %2s %13s %13s %13s  %13s %13s %13s "
                         "%s\n", "", "", "", "", "Marginal", "Upper bound",
                         "range", "range", "break point", "variable");
                xfprintf(fp, "------ ------------ -- ------------- --------"
                         "----- -------------  ------------- ------------- ------"
                         "------- ------------\n");
            }
            if (pass == 1)
            {   numb = k;
                xassert(1 <= numb && numb <= m);
                row = P->row[numb];
                name = row->name;
                type = row->type;
                lb = glp_get_row_lb(P, numb);
                ub = glp_get_row_ub(P, numb);
                coef = 0.0;
                stat = row->stat;
                prim = row->prim;
                if (type == GLP_FR)
                    slack = - prim;
                else if (type == GLP_LO)
                    slack = lb - prim;
                else if (type == GLP_UP || type == GLP_DB || type == GLP_FX)
                    slack = ub - prim;
                dual = row->dual;
            }
            else
            {   numb = k - m;
                xassert(1 <= numb && numb <= n);
                col = P->col[numb];
                name = col->name;
                lb = glp_get_col_lb(P, numb);
                ub = glp_get_col_ub(P, numb);
                coef = col->coef;
                stat = col->stat;
                prim = col->prim;
                slack = 0.0;
                dual = col->dual;
            }
            if (stat != GLP_BS)
            {   glp_analyze_bound(P, k, &value1, &var1, &value2, &var2);
                if (stat == GLP_NF)
                    coef1 = coef2 = coef;
                else if (stat == GLP_NS)
                    coef1 = -DBL_MAX, coef2 = +DBL_MAX;
                else if (stat == GLP_NL && P->dir == GLP_MIN ||
                         stat == GLP_NU && P->dir == GLP_MAX)
                    coef1 = coef - dual, coef2 = +DBL_MAX;
                else
                    coef1 = -DBL_MAX, coef2 = coef - dual;
                if (value1 == -DBL_MAX)
                {   if (dual < -1e-9)
                        obj1 = +DBL_MAX;
                    else if (dual > +1e-9)
                        obj1 = -DBL_MAX;
                    else
                        obj1 = P->obj_val;
                }
                else
                    obj1 = P->obj_val + dual * (value1 - prim);
                if (value2 == +DBL_MAX)
                {   if (dual < -1e-9)
                        obj2 = -DBL_MAX;
                    else if (dual > +1e-9)
                        obj2 = +DBL_MAX;
                    else
                        obj2 = P->obj_val;
                }
                else
                    obj2 = P->obj_val + dual * (value2 - prim);
            }
            else
            {   glp_analyze_coef(P, k, &coef1, &var1, &value1, &coef2,
                                 &var2, &value2);
                if (coef1 == -DBL_MAX)
                {   if (prim < -1e-9)
                        obj1 = +DBL_MAX;
                    else if (prim > +1e-9)
                        obj1 = -DBL_MAX;
                    else
                        obj1 = P->obj_val;
                }
                else
                    obj1 = P->obj_val + (coef1 - coef) * prim;
                if (coef2 == +DBL_MAX)
                {   if (prim < -1e-9)
                        obj2 = -DBL_MAX;
                    else if (prim > +1e-9)
                        obj2 = +DBL_MAX;
                    else
                        obj2 = P->obj_val;
                }
                else
                    obj2 = P->obj_val + (coef2 - coef) * prim;
            }
            /*** first line ***/
            /* row/column number */
            xfprintf(fp, "%6d", numb);
            /* row/column name */
            xfprintf(fp, " %-12.12s", name == NULL ? "" : name);
            if (name != NULL && strlen(name) > 12)
                xfprintf(fp, "%s\n%6s %12s", name+12, "", "");
            /* row/column status */
            xfprintf(fp, " %2s",
                     stat == GLP_BS ? "BS" : stat == GLP_NL ? "NL" :
                     stat == GLP_NU ? "NU" : stat == GLP_NF ? "NF" :
                     stat == GLP_NS ? "NS" : "??");
            /* row/column activity */
            xfprintf(fp, " %s", format(buf, prim));
            /* row slack, column objective coefficient */
            xfprintf(fp, " %s", format(buf, k <= m ? slack : coef));
            /* row/column lower bound */
            xfprintf(fp, " %s", format(buf, lb));
            /* row/column activity range */
            xfprintf(fp, "  %s", format(buf, value1));
            /* row/column objective coefficient range */
            xfprintf(fp, " %s", format(buf, coef1));
            /* objective value at break point */
            xfprintf(fp, " %s", format(buf, obj1));
            /* limiting variable name */
            if (var1 != 0)
            {   if (var1 <= m)
                    limit = glp_get_row_name(P, var1);
                else
                    limit = glp_get_col_name(P, var1 - m);
                if (limit != NULL)
                    xfprintf(fp, " %s", limit);
            }
            xfprintf(fp, "\n");
            /*** second line ***/
            xfprintf(fp, "%6s %-12s %2s %13s", "", "", "", "");
            /* row/column reduced cost */
            xfprintf(fp, " %s", format(buf, dual));
            /* row/column upper bound */
            xfprintf(fp, " %s", format(buf, ub));
            /* row/column activity range */
            xfprintf(fp, "  %s", format(buf, value2));
            /* row/column objective coefficient range */
            xfprintf(fp, " %s", format(buf, coef2));
            /* objective value at break point */
            xfprintf(fp, " %s", format(buf, obj2));
            /* limiting variable name */
            if (var2 != 0)
            {   if (var2 <= m)
                    limit = glp_get_row_name(P, var2);
                else
                    limit = glp_get_col_name(P, var2 - m);
                if (limit != NULL)
                    xfprintf(fp, " %s", limit);
            }
            xfprintf(fp, "\n");
            xfprintf(fp, "\n");
            /* print 10 items per page */
            count = (count + 1) % 10;
        }
    xfprintf(fp, "End of report\n");
#if 0 /* FIXME */
    xfflush(fp);
#endif
    if (glp_ioerr(fp))
    {   xprintf("Write error on '%s' - %s\n", fname, get_err_msg());
        ret = 4;
        goto done;
    }
    ret = 0;
done:
    if (fp != NULL) glp_close(fp);
    return ret;
}