fp20_lpdata.c

Go to the documentation of this file.

/****************************************************************************/
/*                                                                          */
/*  This file is part of QSopt_ex.                                          */
/*                                                                          */
/*  (c) Copyright 2006 by David Applegate, William Cook, Sanjeeb Dash,      */
/*  and Daniel Espinoza                                                     */
/*                                                                          */
/*  Sanjeeb Dash ownership of copyright in QSopt_ex is derived from his     */
/*  copyright in QSopt.                                                     */
/*                                                                          */
/*  This code may be used under the terms of the GNU General Public License */
/*  (Version 2.1 or later) as published by the Free Software Foundation.    */
/*                                                                          */
/*  Alternatively, use is granted for research purposes only.               */
/*                                                                          */
/*  It is your choice of which of these two licenses you are operating      */
/*  under.                                                                  */
/*                                                                          */
/*  We make no guarantees about the correctness or usefulness of this code. */
/*                                                                          */
/****************************************************************************/

/* RCS_INFO = "$RCSfile: fp20_lpdata.c,v $ $Revision: 1.2 $ $Date: 2003/11/05 16:49:52 $"; */
/****************************************************************************/
/*                                                                          */
/*               Routines for Manipulating and Writing LPdata               */
/*                                                                          */
/*  EXPORTED FUNCTIONS                                                      */
/*                                                                          */
/*    int ILLlpdata_buildrows (fp20_ILLlpdata *lp, int **rowbeg, int **rowcnt,     */
/*            int **rowind, double **rowval, int include_logicals)          */
/*      - include_logicals:  if nonzero, then logical variables will be     */
/*          included in the row data                                        */
/*                                                                          */
/*                                                                          */
/*    All _init routines initialize fields of allocated structure to        */
/*    appropiate default values                                             */
/*    The _free routines free structures contained in pareameter structure  */
/*    but not the parameter itself.                                         */
/*    The _alloc routines check whether given parameter is NULL; they either*/
/*    print an error message or fill structure with default values or the   */
/*    given paremeter values.                                               */
/*                                                                          */
/*    void fp20_ILLlpdata_init (fp20_ILLlpdata *lp)                                   */
/*    void fp20_ILLlpdata_free (fp20_ILLlpdata *lp)                                   */
/*                                                                          */
/*    void fp20_ILLlp_basis_init (fp20_ILLlp_basis *B)                                */
/*    void fp20_ILLlp_basis_free (fp20_ILLlp_basis *B)                                */
/*    int fp20_ILLlp_basis_alloc (fp20_ILLlp_basis *B, int nstruct, int nrows)        */
/*                                                                          */
/*    void fp20_ILLlp_cache_init (fp20_ILLlp_cache *C)                                */
/*    void fp20_ILLlp_cache_free (fp20_ILLlp_cache *C)                                */
/*    int fp20_ILLlp_cache_alloc (fp20_ILLlp_cache *C, int nstruct, int nrows)        */
/*                                                                          */
/*    void fp20_ILLlp_sinfo_init (fp20_ILLlp_sinfo *sinfo)                            */
/*    void fp20_ILLlp_sinfo_free (fp20_ILLlp_sinfo *sinfo)                            */
/*                                                                          */
/*    int fp20_ILLlp_rows_init(fp20_ILLlp_rows *lprows, fp20_ILLlpdata *lp,                */
/*                                           int include_logicals)          */
/*                                                                          */
/****************************************************************************/

#include "qs_config.h"
#include "fp20_iqsutil.h"
#include "fp20_lpdata.h"
#include "fp20_qstruct.h"
#include "fp20_qsopt.h"
#include "fp20_lp.h"
#include "fp20_mps.h"
#include "fp20_rawlp.h"
#ifdef USEDMALLOC
#include "dmalloc.h"
#endif

//static int TRACE = 0;

EGfp20_t fp20_PARAM_IBASIS_RPIVOT;
EGfp20_t fp20_PARAM_IBASIS_RTRIANG;
EGfp20_t fp20_PARAM_MIN_DNORM;
EGfp20_t fp20_PFEAS_TOLER;
EGfp20_t fp20_BD_TOLER;
EGfp20_t fp20_DFEAS_TOLER;
EGfp20_t fp20_PIVOT_TOLER;
EGfp20_t fp20_SZERO_TOLER;
EGfp20_t fp20_PIVZ_TOLER;
EGfp20_t fp20_OBJBND_TOLER;
EGfp20_t fp20_DBNDPIV_TOLER;
EGfp20_t fp20_DBNDPIV_RATIO;
EGfp20_t fp20_ALTPIV_TOLER;
//EGfp20_t DJZERO_TOLER;
EGfp20_t fp20_PROGRESS_ZERO;        /*   1e-7 */
EGfp20_t fp20_PROGRESS_THRESH;      /*   1e-5 */
EGfp20_t fp20_CB_EPS;
EGfp20_t fp20_CB_INF_RATIO;
EGfp20_t fp20_CB_PRI_RLIMIT;
EGfp20_t fp20_ILL_MAXDOUBLE;
EGfp20_t fp20_ILL_MINDOUBLE;

/* ========================================================================= */
int fp20___QSEX_SETUP = 0;
/* ========================================================================= */
void fp20_ILLstart ( void)
{
  if (fp20___QSEX_SETUP)
    return;
  fp20_EGlpNumInitVar (fp20_PARAM_IBASIS_RPIVOT);
  fp20_EGlpNumInitVar (fp20_PARAM_IBASIS_RTRIANG);
  fp20_EGlpNumInitVar (fp20_PARAM_MIN_DNORM);
  fp20_EGlpNumInitVar (fp20_PFEAS_TOLER);
  fp20_EGlpNumInitVar (fp20_BD_TOLER);
  fp20_EGlpNumInitVar (fp20_DFEAS_TOLER);
  fp20_EGlpNumInitVar (fp20_PIVOT_TOLER);
  fp20_EGlpNumInitVar (fp20_SZERO_TOLER);
  fp20_EGlpNumInitVar (fp20_PIVZ_TOLER);
  fp20_EGlpNumInitVar (fp20_OBJBND_TOLER);
  fp20_EGlpNumInitVar (fp20_DBNDPIV_TOLER);
  fp20_EGlpNumInitVar (fp20_DBNDPIV_RATIO);
  fp20_EGlpNumInitVar (fp20_ALTPIV_TOLER);
  //fp20_EGlpNumInitVar (DJZERO_TOLER);
  fp20_EGlpNumInitVar (fp20_PROGRESS_ZERO); /*            1e-7 */
  fp20_EGlpNumInitVar (fp20_PROGRESS_THRESH); /*          1e-5 */
  fp20_EGlpNumInitVar (fp20_CB_PRI_RLIMIT);
  fp20_EGlpNumInitVar (fp20_CB_INF_RATIO);
  fp20_EGlpNumInitVar (fp20_CB_EPS);
  fp20_EGlpNumInitVar (fp20_ILL_MAXDOUBLE);
  fp20_EGlpNumInitVar (fp20_ILL_MINDOUBLE);
  /* parameters that do depend on the tolerance to zero */
  fp20_EGlpNumSet (fp20_PARAM_MIN_DNORM, 4.5036e-9);
  fp20_EGlpNumMultTo (fp20_PARAM_MIN_DNORM, fp20_epsLpNum);
  fp20_EGlpNumSet (fp20_PFEAS_TOLER, 4.5036e9);
  fp20_EGlpNumMultTo (fp20_PFEAS_TOLER, fp20_epsLpNum);
  fp20_EGlpNumSet (fp20_BD_TOLER, 4.5036e8);
  fp20_EGlpNumMultTo (fp20_BD_TOLER, fp20_epsLpNum);
  fp20_EGlpNumSet (fp20_DFEAS_TOLER, 4.5036e9);
  fp20_EGlpNumMultTo (fp20_DFEAS_TOLER, fp20_epsLpNum);
  fp20_EGlpNumSet (fp20_PIVOT_TOLER, 4.5036e5);
  fp20_EGlpNumMultTo (fp20_PIVOT_TOLER, fp20_epsLpNum);
  fp20_EGlpNumSet (fp20_SZERO_TOLER, 4.5036);
  fp20_EGlpNumMultTo (fp20_SZERO_TOLER, fp20_epsLpNum);
  fp20_EGlpNumSet (fp20_PIVZ_TOLER, 4.5036e3);
  fp20_EGlpNumMultTo (fp20_PIVZ_TOLER, fp20_epsLpNum);
  fp20_EGlpNumSet (fp20_OBJBND_TOLER, 4.5036e13);
  fp20_EGlpNumMultTo (fp20_OBJBND_TOLER, fp20_epsLpNum);
  fp20_EGlpNumSet (fp20_ALTPIV_TOLER, 4.5036e7);
  fp20_EGlpNumMultTo (fp20_ALTPIV_TOLER, fp20_epsLpNum);
  fp20_EGlpNumSet (fp20_PROGRESS_ZERO, 4.5036e8);
  fp20_EGlpNumMultTo (fp20_PROGRESS_ZERO, fp20_epsLpNum);
  fp20_EGlpNumSet (fp20_PROGRESS_THRESH, 4.5036e10);
  fp20_EGlpNumMultTo (fp20_PROGRESS_THRESH, fp20_epsLpNum);
#if VERBOSE_LEVEL <= DEBUG
  MESSAGE (VERBOSE_LEVEL, "Setting fp20_PARAM_MIN_DNORM to %lg", fp20_EGlpNumToLf (fp20_PARAM_MIN_DNORM));
  MESSAGE (VERBOSE_LEVEL, "Setting fp20_PFEAS_TOLER to %lg", fp20_EGlpNumToLf (fp20_PFEAS_TOLER));
  MESSAGE (VERBOSE_LEVEL, "Setting fp20_BD_TOLER to %lg", fp20_EGlpNumToLf (fp20_BD_TOLER));
  MESSAGE (VERBOSE_LEVEL, "Setting fp20_DFEAS_TOLER to %lg", fp20_EGlpNumToLf (fp20_DFEAS_TOLER));
  MESSAGE (VERBOSE_LEVEL, "Setting fp20_PIVOT_TOLER to %lg", fp20_EGlpNumToLf (fp20_PIVOT_TOLER));
  MESSAGE (VERBOSE_LEVEL, "Setting fp20_SZERO_TOLER to %lg", fp20_EGlpNumToLf (fp20_SZERO_TOLER));
  MESSAGE (VERBOSE_LEVEL, "Setting fp20_PIVZ_TOLER to %lg", fp20_EGlpNumToLf (fp20_PIVZ_TOLER));
  MESSAGE (VERBOSE_LEVEL, "Setting fp20_OBJBND_TOLER to %lg", fp20_EGlpNumToLf (fp20_OBJBND_TOLER));
  MESSAGE (VERBOSE_LEVEL, "Setting fp20_ALTPIV_TOLER to %lg", fp20_EGlpNumToLf (fp20_ALTPIV_TOLER));
  MESSAGE (VERBOSE_LEVEL, "Setting fp20_PROGRESS_ZERO to %lg", fp20_EGlpNumToLf (fp20_PROGRESS_ZERO));
  MESSAGE (VERBOSE_LEVEL, "Setting fp20_PROGRESS_THRESH to %lg", fp20_EGlpNumToLf (fp20_PROGRESS_THRESH));
#endif
  /* parameters that do not depend on the tolerance to zero */
  fp20_EGlpNumSet (fp20_ILL_MAXDOUBLE, 1e150);
  fp20_EGlpNumSet (fp20_ILL_MINDOUBLE, -1e150);
  fp20_EGlpNumSet (fp20_PARAM_IBASIS_RPIVOT, 0.98);
  fp20_EGlpNumSet (fp20_PARAM_IBASIS_RTRIANG, 0.01);
  fp20_EGlpNumSet (fp20_DBNDPIV_TOLER, 1e-3);
  fp20_EGlpNumSet (fp20_DBNDPIV_RATIO, 1e-2);
  //fp20_EGlpNumSet (DJZERO_TOLER, 1e-8);
  fp20_EGlpNumSet (fp20_CB_EPS, 0.001);
  fp20_EGlpNumSet (fp20_CB_INF_RATIO, 10.0);
  fp20_EGlpNumSet (fp20_CB_PRI_RLIMIT, 0.25);
  fp20___QSEX_SETUP = 1;
}

/* ========================================================================= */
void fp20_ILLchange_precision (
  void)
{
  fp20_EGlpNumClearVar (fp20_PFEAS_TOLER);
  fp20_EGlpNumClearVar (fp20_BD_TOLER);
  fp20_EGlpNumClearVar (fp20_DFEAS_TOLER);
  fp20_EGlpNumClearVar (fp20_PIVOT_TOLER);
  fp20_EGlpNumClearVar (fp20_SZERO_TOLER);
  fp20_EGlpNumClearVar (fp20_PIVZ_TOLER);
  fp20_EGlpNumClearVar (fp20_OBJBND_TOLER);
  fp20_EGlpNumClearVar (fp20_ALTPIV_TOLER);
  fp20_EGlpNumClearVar (fp20_PARAM_MIN_DNORM);
  fp20_EGlpNumClearVar (fp20_PROGRESS_ZERO);
  fp20_EGlpNumClearVar (fp20_PROGRESS_THRESH);
  fp20_EGlpNumInitVar (fp20_PROGRESS_ZERO);
  fp20_EGlpNumInitVar (fp20_PROGRESS_THRESH);
  fp20_EGlpNumInitVar (fp20_PFEAS_TOLER);
  fp20_EGlpNumInitVar (fp20_BD_TOLER);
  fp20_EGlpNumInitVar (fp20_DFEAS_TOLER);
  fp20_EGlpNumInitVar (fp20_PIVOT_TOLER);
  fp20_EGlpNumInitVar (fp20_SZERO_TOLER);
  fp20_EGlpNumInitVar (fp20_PIVZ_TOLER);
  fp20_EGlpNumInitVar (fp20_OBJBND_TOLER);
  fp20_EGlpNumInitVar (fp20_ALTPIV_TOLER);
  fp20_EGlpNumInitVar (fp20_PARAM_MIN_DNORM);
  /* parameters that do depend on the tolerance to zero */
  fp20_EGlpNumSet (fp20_PARAM_MIN_DNORM, 4.5036e-9);
  fp20_EGlpNumMultTo (fp20_PARAM_MIN_DNORM, fp20_epsLpNum);
  fp20_EGlpNumSet (fp20_PFEAS_TOLER, 4.5036e9);
  fp20_EGlpNumMultTo (fp20_PFEAS_TOLER, fp20_epsLpNum);
  fp20_EGlpNumSet (fp20_BD_TOLER, 4.5036e8);
  fp20_EGlpNumMultTo (fp20_BD_TOLER, fp20_epsLpNum);
  fp20_EGlpNumSet (fp20_DFEAS_TOLER, 4.5036e9);
  fp20_EGlpNumMultTo (fp20_DFEAS_TOLER, fp20_epsLpNum);
  fp20_EGlpNumSet (fp20_PIVOT_TOLER, 4.5036e5);
  fp20_EGlpNumMultTo (fp20_PIVOT_TOLER, fp20_epsLpNum);
  fp20_EGlpNumSet (fp20_SZERO_TOLER, 4.5036);
  fp20_EGlpNumMultTo (fp20_SZERO_TOLER, fp20_epsLpNum);
  fp20_EGlpNumSet (fp20_PIVZ_TOLER, 4.5036e3);
  fp20_EGlpNumMultTo (fp20_PIVZ_TOLER, fp20_epsLpNum);
  fp20_EGlpNumSet (fp20_OBJBND_TOLER, 4.5036e13);
  fp20_EGlpNumMultTo (fp20_OBJBND_TOLER, fp20_epsLpNum);
  fp20_EGlpNumSet (fp20_ALTPIV_TOLER, 4.5036e7);
  fp20_EGlpNumMultTo (fp20_ALTPIV_TOLER, fp20_epsLpNum);
  fp20_EGlpNumSet (fp20_PROGRESS_ZERO, 4.5036e8);
  fp20_EGlpNumMultTo (fp20_PROGRESS_ZERO, fp20_epsLpNum);
  fp20_EGlpNumSet (fp20_PROGRESS_THRESH, 4.5036e10);
  fp20_EGlpNumMultTo (fp20_PROGRESS_THRESH, fp20_epsLpNum);
}

/* ========================================================================= */
void fp20_ILLend ( void)
{
  if (!fp20___QSEX_SETUP)
    return;
  fp20_EGlpNumClearVar (fp20_PARAM_IBASIS_RPIVOT);
  fp20_EGlpNumClearVar (fp20_PARAM_IBASIS_RTRIANG);
  fp20_EGlpNumClearVar (fp20_PARAM_MIN_DNORM);
  fp20_EGlpNumClearVar (fp20_PFEAS_TOLER);
  fp20_EGlpNumClearVar (fp20_BD_TOLER);
  fp20_EGlpNumClearVar (fp20_DFEAS_TOLER);
  fp20_EGlpNumClearVar (fp20_PIVOT_TOLER);
  fp20_EGlpNumClearVar (fp20_SZERO_TOLER);
  fp20_EGlpNumClearVar (fp20_PIVZ_TOLER);
  fp20_EGlpNumClearVar (fp20_OBJBND_TOLER);
  fp20_EGlpNumClearVar (fp20_DBNDPIV_TOLER);
  fp20_EGlpNumClearVar (fp20_DBNDPIV_RATIO);
  fp20_EGlpNumClearVar (fp20_ALTPIV_TOLER);
  //fp20_EGlpNumClearVar (DJZERO_TOLER);
  fp20_EGlpNumClearVar (fp20_PROGRESS_ZERO);  /*            1e-7 */
  fp20_EGlpNumClearVar (fp20_PROGRESS_THRESH);  /*          1e-5 */
  fp20_EGlpNumClearVar (fp20_CB_EPS);
  fp20_EGlpNumClearVar (fp20_CB_INF_RATIO);
  fp20_EGlpNumClearVar (fp20_CB_PRI_RLIMIT);
  fp20_EGlpNumClearVar (fp20_ILL_MAXDOUBLE);
  fp20_EGlpNumClearVar (fp20_ILL_MINDOUBLE);
  fp20___QSEX_SETUP = 0;
}

fp20_QSdata *fp20_ILLread (
  fp20_qsline_reader * file,
  const char *fp20_fname,
  int isMps)
{
  int rval = 0;
  fp20_QSdata *p = 0;
  fp20_ILLlpdata *lp;
  fp20_rawlpdata rawlp;

  ILL_FAILfalse (file != NULL, NULL);
  ILL_FAILfalse (fp20_fname != NULL, NULL);

  p = fp20_QScreate_prob (fp20_fname, QS_MIN);
  ILL_CHECKnull (p, NULL);
  ILL_IFFREE (p->qslp->probname, char);

  lp = p->qslp;

  fp20_ILLinit_rawlpdata (&rawlp, file->error_collector);
  fp20_ILLlpdata_init (lp);

  if (isMps != 0)
  {
    rval = fp20_ILLread_mps (file, fp20_fname, &rawlp);
  }
  else
  {
    rval = fp20_ILLread_lp (file, fp20_fname, &rawlp);
  }
  CHECKRVALG (rval, CLEANUP);

  rval = fp20_ILLrawlpdata_to_lpdata (&rawlp, lp);
  CHECKRVALG (rval, CLEANUP);

CLEANUP:
  fp20_ILLfree_rawlpdata (&rawlp);
  if (rval != 0)
  {
    fp20_QSfree_prob (p);
    p = 0;
  }
  return p;
}

void fp20_ILLlpdata_init (
  fp20_ILLlpdata * lp)
{
  if (lp)
  {
    lp->nrows = 0;
    lp->ncols = 0;
    lp->nstruct = 0;
    lp->nzcount = 0;
    lp->rowsize = 0;
    lp->colsize = 0;
    lp->structsize = 0;
    lp->objsense = fp20_ILL_MIN;
    lp->sense = 0;
    lp->obj = 0;
    lp->rhs = 0;
    lp->rangeval = 0;
    lp->lower = 0;
    lp->upper = 0;

    fp20_ILLmatrix_init (&lp->A);
    fp20_ILLmatrix_init (&lp->sos);
    lp->rA = 0;
    lp->is_sos_mem = NULL;
    lp->refrowname = NULL;
    lp->refind = -1;

    lp->colnames = 0;
    ILLsymboltab_init (&lp->coltab);
    lp->rownames = 0;
    ILLsymboltab_init (&lp->rowtab);
    lp->objname = 0;

    lp->probname = 0;
    lp->intmarker = 0;
    lp->structmap = 0;
    lp->rowmap = 0;
    lp->basis = 0;
    /*lp->presolve   = 0; */
    lp->sinfo = 0;

    ILLstring_reporter_init (&lp->reporter, ILL_fprintf, stdout);
  }
}

void fp20_ILLlpdata_free (
  fp20_ILLlpdata * lp)
{
  int i;

  if (lp)
  {
    ILL_IFFREE (lp->sense, char);

    fp20_EGlpNumFreeArray (lp->obj);
    fp20_EGlpNumFreeArray (lp->rhs);
    fp20_EGlpNumFreeArray (lp->rangeval);
    fp20_EGlpNumFreeArray (lp->lower);
    fp20_EGlpNumFreeArray (lp->upper);
    fp20_ILLmatrix_free (&lp->A);
    if (lp->rA)
    {
      fp20_ILLlp_rows_clear (lp->rA);
      ILL_IFFREE (lp->rA, fp20_ILLlp_rows);
    }
    ILL_IFFREE (lp->is_sos_mem, int);
    ILL_IFFREE (lp->refrowname, char);

    fp20_ILLmatrix_free (&lp->sos);
    if (lp->colnames)
    {
      for (i = 0; i < lp->nstruct; i++)
      {
        ILL_IFFREE (lp->colnames[i], char);
      }
      ILL_IFFREE (lp->colnames, char *);
    }
    ILLsymboltab_free (&lp->coltab);
    if (lp->rownames)
    {
      for (i = 0; i < lp->nrows; i++)
      {
        ILL_IFFREE (lp->rownames[i], char);
      }
      ILL_IFFREE (lp->rownames, char *);
    }
    ILLsymboltab_free (&lp->rowtab);
    ILL_IFFREE (lp->objname, char);
    ILL_IFFREE (lp->probname, char);
    ILL_IFFREE (lp->intmarker, char);
    ILL_IFFREE (lp->structmap, int);
    ILL_IFFREE (lp->rowmap, int);

    if (lp->sinfo)
    {
      fp20_ILLlp_sinfo_free (lp->sinfo);
      ILL_IFFREE (lp->sinfo, fp20_ILLlp_sinfo);
    }
    fp20_ILLlpdata_init (lp);
  }
}

void fp20_ILLlp_basis_init (
  fp20_ILLlp_basis * B)
{
  if (B)
  {
    B->cstat = 0;
    B->rstat = 0;
    B->rownorms = 0;
    B->colnorms = 0;
    B->nstruct = 0;
    B->nrows = 0;
  }
}

void fp20_ILLlp_basis_free (
  fp20_ILLlp_basis * B)
{
  if (B)
  {
    ILL_IFFREE (B->cstat, char);
    ILL_IFFREE (B->rstat, char);

    fp20_EGlpNumFreeArray (B->rownorms);
    fp20_EGlpNumFreeArray (B->colnorms);
    B->nstruct = 0;
    B->nrows = 0;
  }
}

int fp20_ILLlp_basis_alloc (
  fp20_ILLlp_basis * B,
  int nstruct,
  int nrows)
{
  int rval = 0;

  ILL_FAILtrue (B == NULL, "fp20_ILLlp_basis_alloc called without a basis");

  B->nstruct = nstruct;
  B->nrows = nrows;

  if (nstruct > 0)
  {
    ILL_SAFE_MALLOC (B->cstat, nstruct, char);
  }

  if (nrows > 0)
  {
    ILL_SAFE_MALLOC (B->rstat, nrows, char);
  }

CLEANUP:

  if (rval)
  {
    fp20_ILLlp_basis_free (B);
  }

  EG_RETURN (rval);
}

void fp20_ILLlp_cache_init (
  fp20_ILLlp_cache * C)
{
  if (C)
  {
    C->x = 0;
    C->rc = 0;
    C->pi = 0;
    C->slack = 0;
    C->nstruct = 0;
    C->nrows = 0;
    C->status = 0;
    fp20_EGlpNumZero (C->val);
  }
}

void fp20_ILLlp_cache_free (
  fp20_ILLlp_cache * C)
{
  if (C)
  {
    fp20_EGlpNumFreeArray (C->x);
    fp20_EGlpNumFreeArray (C->rc);
    fp20_EGlpNumFreeArray (C->pi);
    fp20_EGlpNumFreeArray (C->slack);
    C->nstruct = 0;
    C->nrows = 0;
    C->status = 0;
  }
}

int fp20_ILLlp_cache_alloc (
  fp20_ILLlp_cache * C,
  int nstruct,
  int nrows)
{
  int rval = 0;

  ILL_FAILtrue (C == NULL, "fp20_ILLlp_cache_alloc called without a cache");

  C->nstruct = nstruct;
  C->nrows = nrows;

  if (nstruct > 0)
  {
    C->x = fp20_EGlpNumAllocArray (nstruct);
    C->rc = fp20_EGlpNumAllocArray (nstruct);
  }

  if (nrows > 0)
  {
    C->pi = fp20_EGlpNumAllocArray (nrows);
    C->slack = fp20_EGlpNumAllocArray (nrows);
  }

CLEANUP:

  if (rval)
  {
    fp20_ILLlp_cache_free (C);
  }

  EG_RETURN (rval);
}


int fp20_ILLlp_rows_init (
  fp20_ILLlp_rows * lprows,
  fp20_ILLlpdata * lp,
  int include_logicals)
{
  int rval = 0;
  int i, k, st;
  int *beg, *cnt, *ind;
  EGfp20_t *val;
  fp20_ILLmatrix *A;
  char *hit = 0;
  int *inv_structmap = 0;

  /* If logicals are not included, then the columns are ordered as in */
  /* lp->structmap.  Otherwise, the columns are ordered as in the     */
  /* matrix structure.                                                */

  if (lprows != NULL)
  {
    lprows->rowbeg = 0;
    lprows->rowcnt = 0;
    lprows->rowind = 0;
    lprows->rowval = 0;
  }

  ILL_FAILfalse ((lp != NULL) && (lprows != NULL),
                 "called with a NULL pointer");

  A = &lp->A;

  if (lp->nrows > 0)
  {
    if (include_logicals == 0)
    {
      ILL_FAILtrue (lp->rowmap == NULL, "Programming error.");
      ILL_SAFE_MALLOC (hit, lp->ncols, char);

      for (i = 0; i < lp->ncols; i++)
      {
        hit[i] = 0;
      }
      for (i = 0; i < lp->nrows; i++)
      {
        hit[lp->rowmap[i]] = 1;
      }

      ILL_SAFE_MALLOC (inv_structmap, lp->ncols, int);

      for (i = 0; i < lp->nstruct; i++)
      {
        inv_structmap[lp->structmap[i]] = i;
      }
    }

    ILL_SAFE_MALLOC (lprows->rowbeg, lp->nrows, int);
    ILL_SAFE_MALLOC (lprows->rowcnt, lp->nrows, int);

    if (((include_logicals != 0) && lp->nzcount > 0) ||
        ((include_logicals == 0) && lp->nzcount > lp->nrows))
    {
      if (include_logicals != 0)
      {
        ILL_SAFE_MALLOC (lprows->rowind, lp->nzcount, int);

        lprows->rowval = fp20_EGlpNumAllocArray (lp->nzcount);
      }
      else
      {
        ILL_SAFE_MALLOC (lprows->rowind, lp->nzcount - lp->nrows, int);

        lprows->rowval = fp20_EGlpNumAllocArray (lp->nzcount - lp->nrows);
      }
    }

    beg = lprows->rowbeg;
    cnt = lprows->rowcnt;
    ind = lprows->rowind;
    val = lprows->rowval;

    for (i = 0; i < lp->nrows; i++)
    {
      cnt[i] = 0;
    }

    for (i = 0; i < lp->ncols; i++)
    {
      if ((include_logicals != 0) || hit[i] == 0)
      {
        k = A->matbeg[i];
        st = k + A->matcnt[i];
        for (; k < st; k++)
        {
          cnt[A->matind[k]]++;
        }
      }
    }

    for (i = 0, k = 0; i < lp->nrows; i++)
    {
      beg[i] = k;
      k += cnt[i];
    }

    for (i = 0; i < lp->ncols; i++)
    {
      if ((include_logicals != 0) || hit[i] == 0)
      {
        k = A->matbeg[i];
        st = k + A->matcnt[i];
        for (; k < st; k++)
        {
          if (include_logicals != 0)
          {
            ind[beg[A->matind[k]]] = i;
          }
          else
          {
            ind[beg[A->matind[k]]] = inv_structmap[i];
          }
          fp20_EGlpNumCopy (val[beg[A->matind[k]]], A->matval[k]);
          beg[A->matind[k]]++;
        }
      }
    }

    for (i = 0, k = 0; i < lp->nrows; i++)
    {
      beg[i] = k;
      k += cnt[i];
    }
  }
CLEANUP:

  if (rval)
  {
    fp20_ILLlp_rows_clear (lprows);
  }
  ILL_IFFREE (hit, char);
  ILL_IFFREE (inv_structmap, int);

  EG_RETURN (rval);
}

void fp20_ILLlp_rows_clear (
  fp20_ILLlp_rows * lprows)
{
  if (lprows != NULL)
  {
    ILL_IFFREE (lprows->rowbeg, int);
    ILL_IFFREE (lprows->rowcnt, int);
    ILL_IFFREE (lprows->rowind, int);

    fp20_EGlpNumFreeArray (lprows->rowval);
  }
}

static int fp20_wr_line (
  fp20_ILLlpdata * lp,
  const char *format,
  va_list argptr)
{
  char buffer[ILL_namebufsize];
  int rval = 0;

  rval = vsprintf (buffer, format, argptr);
  if (rval > 0)
  {
                /* Bico -- OPTERON DEBUGGING 051005  */
                /* Replaced ILLstring_report by the explicit call to */
                /* fprintf.                                          */
                /*rval = fprintf (lp->reporter.dest, buffer);
                if (rval < 0) rval = 1;
                else          rval = 0;
                */
    /* daespino -- BACK to ILLstring_report to support compresed files 090909
     * */
    rval = ILLstring_report(buffer, &lp->reporter);
  }
  return rval;
}

int fp20_ILLprint_report (
  fp20_ILLlpdata * lp,
  const char *format,
  ...)
{
  va_list marker;
  int rval = 0;

  va_start (marker, format);    /* ANSI style */
  rval = fp20_wr_line (lp, format, marker);
  va_end (marker);              /* Reset variable arguments.      */
  return rval;
}

---