float128_editor.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: float128_editor.c,v $ $Revision: 1.2 $ $Date: 2003/11/05 16:49:52 $"; */

#include "qs_config.h"
#include "float128_qsopt.h"
#include "float128_lpdata.h"
#include "float128_qstruct.h"
#include "float128_qsopt.h"
#include "float128_editor.h"
#include "float128_readline.h"
#include "float128_rawlp.h"
#include "stddefs.h"            /* for MAX */
#include "float128_read_lp.h"
#include "float128_lp.h"
#include "float128_lib.h"
#ifdef USEDMALLOC
#include "dmalloc.h"
#endif

static int TRACE = 0;

#define float128_ILL_BREAK_BODY_IF(rval) if (rval != 0) goto CLEANUP
#define float128_ILL_BREAK_BODY goto CLEANUP

static int float128_transpose ( float128_rawlpdata * lp);
static int float128_pull_info_from_p ( float128_QSdata * p, float128_rawlpdata * lp);
static void float128_add_row ( float128_QSdata * p, float128_rawlpdata * lp, float128_ILLread_lp_state * state);

/* static int new_row(float128_QSdata *p, float128_rawlpdata *lp, float128_ILLread_lp_state *state); */
static void float128_del_row ( float128_QSdata * p, float128_rawlpdata * lp, float128_ILLread_lp_state * state);

static void float128_add_col ( float128_QSdata * p, float128_rawlpdata * lp, float128_ILLread_lp_state * state);
static void float128_del_col ( float128_QSdata * p, float128_rawlpdata * lp, float128_ILLread_lp_state * state);

#define float128_NONE -1
#define float128_QS_EXIT 0
#define float128_ROW 1
#define float128_COL 2
#define float128_PLP 3
#define float128_PRTX 4
#define float128_SOLVE 5
#define float128_PMPS 6
#define float128_HELP 7
#define float128_DEL 8
#define float128_NEW 9
#define float128_ADD 10
#define float128_PRIMAL 11
#define float128_DUAL 12
#define float128_NCOMMAND 13
static const char *float128_commands[float128_NCOMMAND + 1];
static char float128_hasSubCmd[float128_NCOMMAND + 1];

void float128_ILLeditor_init (
  void)
{
  float128_commands[float128_QS_EXIT] = "float128_QS_EXIT";
  float128_commands[float128_ROW] = "float128_ROW";
  float128_commands[float128_COL] = "float128_COL";
  float128_commands[float128_PLP] = "LP";
  float128_commands[float128_PMPS] = "MPS";
  float128_commands[float128_SOLVE] = "float128_SOLVE";
  float128_commands[float128_PRTX] = "PRT";
  float128_commands[float128_HELP] = "float128_HELP";
  float128_commands[float128_ADD] = "float128_ADD";
  float128_commands[float128_DEL] = "float128_DEL";
  float128_commands[float128_NEW] = "float128_NEW";
  float128_commands[float128_PRIMAL] = "float128_PRIMAL";
  float128_commands[float128_DUAL] = "float128_DUAL";
  float128_commands[float128_NCOMMAND] = NULL;

  float128_hasSubCmd[float128_QS_EXIT] = 0;
  float128_hasSubCmd[float128_ROW] = 1;
  float128_hasSubCmd[float128_COL] = 1;
  float128_hasSubCmd[float128_PLP] = 0;
  float128_hasSubCmd[float128_PMPS] = 0;
  float128_hasSubCmd[float128_SOLVE] = 1;
  float128_hasSubCmd[float128_PRTX] = 0;
  float128_hasSubCmd[float128_HELP] = 0;
  float128_hasSubCmd[float128_ADD] = 1;
  float128_hasSubCmd[float128_DEL] = 1;
  float128_hasSubCmd[float128_NEW] = 1;
  float128_hasSubCmd[float128_PRIMAL] = 1;
  float128_hasSubCmd[float128_DUAL] = 1;
  float128_hasSubCmd[float128_NCOMMAND] = 0;
}

static void float128_ILLeditor_help_cmd (
  int cmd,
  int subcmd);

static void float128_ILLeditor_help (
  void)
{
  float128_ILLeditor_help_cmd (float128_ROW, float128_ADD);
  /* float128_ILLeditor_help_cmd(float128_ROW, float128_NEW);  */
  float128_ILLeditor_help_cmd (float128_ROW, float128_DEL);
  float128_ILLeditor_help_cmd (float128_COL, float128_ADD);
  float128_ILLeditor_help_cmd (float128_COL, float128_DEL);
  float128_ILLeditor_help_cmd (float128_SOLVE, float128_NONE);
  float128_ILLeditor_help_cmd (float128_PRTX, float128_NONE);
  float128_ILLeditor_help_cmd (float128_PLP, float128_NONE);
  float128_ILLeditor_help_cmd (float128_PMPS, float128_NONE);
  float128_ILLeditor_help_cmd (float128_QS_EXIT, float128_NONE);
  float128_ILLeditor_help_cmd (float128_HELP, float128_NONE);
}

static void float128_ILLeditor_help_cmd (
  int cmd,
  int subcmd)
{
  if (cmd == float128_ROW && subcmd == float128_ADD)
    fprintf (stdout, "%s float128_ADD:\t%s.\n",
             float128_commands[float128_ROW], "add a row; enter in LP format");
  if (cmd == float128_COL && subcmd == float128_ADD)
    fprintf (stdout, "%s float128_ADD:\t%s.\n",
             float128_commands[float128_COL], "add a col; enter in LP format");
  /* if (cmd == float128_ROW && subcmd == float128_NEW) 
   * fprintf(stdout, "%s float128_NEW:\t%s.\n", 
   * float128_commands[float128_ROW], "new row; enter rowname: sense rhs");  
   */
  if (cmd == float128_ROW && subcmd == float128_DEL)
    fprintf (stdout, "%s float128_DEL:\t%s.\n",
             float128_commands[float128_ROW], "delete a row; give rowname");
  if (cmd == float128_COL && subcmd == float128_DEL)
    fprintf (stdout, "%s float128_DEL:\t%s.\n",
             float128_commands[float128_COL], "delete a col; give colname");
  if (cmd == float128_SOLVE)
    fprintf (stdout, "%s:\t%s.\n", float128_commands[float128_SOLVE], "solve problem");
  if (cmd == float128_PRTX)
    fprintf (stdout, "%s:\t%s.\n",
             float128_commands[float128_PRTX], "print variable values for optimal solution");
  if (cmd == float128_PLP)
    fprintf (stdout, "%s [file]:\t%s.\n",
             float128_commands[float128_PLP], "print problem in LP format to file or stdout");
  if (cmd == float128_PMPS)
    fprintf (stdout, "%s [file]:\t%s.\n",
             float128_commands[float128_PMPS], "print problem in MPS format to file or stdout");
  if (cmd == float128_QS_EXIT)
    fprintf (stdout, "%s:\t%s.\n", float128_commands[float128_QS_EXIT], "float128_QS_EXIT");
  if (cmd == float128_HELP)
    fprintf (stdout, "%s:\t%s.\n", float128_commands[float128_HELP], "print this help");
}

static void float128_getCmd (
  float128_ILLread_lp_state * state,
  int *cmd,
  int *subcmd)
{
  const char *cmd_str, *subcmd_str;
  int tmp;

  *cmd = float128_ILLutil_index (float128_commands, state->field);
  *subcmd = -1;
  if (float128_hasSubCmd[*cmd] && (float128_ILLread_lp_state_next_field_on_line (state) == 0))
  {
    *subcmd = float128_ILLutil_index (float128_commands, state->field);
    if ((*subcmd == float128_ROW) || (*subcmd == float128_COL) || (*subcmd == float128_SOLVE))
    {
      float128_ILL_SWAP (*subcmd, *cmd, tmp);
    }
  }
  cmd_str = (*cmd >= 0) ? float128_commands[*cmd] : "???";
  subcmd_str = (*subcmd >= 0) ? float128_commands[*subcmd] : "???";
  ILL_IFTRACE ("cmd = %s, subcmd = %s\n", cmd_str, subcmd_str);
}

void float128_ILLeditor (
  float128_QSdata * p)
{
  float128_rawlpdata raw, *lp = &raw;
  int cmd, subcmd, tval, rval = 0;
  float128_ILLread_lp_state lpstate, *state = &lpstate;
  float128_qsline_reader *reader;

  ILL_IFTRACE ("float128_ILLeditor\n");

  reader = float128_ILLline_reader_new ((float128_qsread_line_fct) fgets, stdin);
  rval = float128_ILLread_lp_state_init (state, reader, "STDIN", 1);
  rval = rval || float128_pull_info_from_p (p, lp);
  float128_ILL_BREAK_BODY_IF (rval);

  while (float128_ILLread_lp_state_next_field (state) == 0)
  {
    float128_getCmd (state, &cmd, &subcmd);
    switch (cmd)
    {
    case float128_QS_EXIT:
      float128_ILL_BREAK_BODY;

    case float128_ROW:
      {
        switch (subcmd)
        {
        case float128_ADD:
          float128_add_row (p, lp, state);
          break;
          /* case float128_NEW: rval = new_row(p, lp, state); break; */
        case float128_DEL:
          float128_del_row (p, lp, state);
          break;
        default:
          float128_ILLeditor_help ();
          break;
        }
        break;
      }
    case float128_COL:
      {
        switch (subcmd)
        {
        case float128_ADD:
          float128_add_col (p, lp, state);
          break;
        case float128_DEL:
          float128_del_col (p, lp, state);
          break;
        default:
          float128_ILLeditor_help ();
          break;
        }
        break;
      }

    case float128_SOLVE:
      {
        if (subcmd == float128_PRIMAL)
        {
          (void) float128_ILLeditor_solve (p, PRIMAL_SIMPLEX);
        }
        else if (subcmd == float128_DUAL)
        {
          (void) float128_ILLeditor_solve (p, DUAL_SIMPLEX);
        }
        else
        {
          float128_ILLeditor_help ();
        }
        break;
      }

    case float128_PRTX:
      {
        EGioFile_t*lout = EGioOpenFILE(stdout);
        if ((rval = float128_ILLlib_print_x (lout, p->lp, 0, 0, 1)))
        {
          fprintf (stdout, "The problem may not be feasible.\n");
        }
        EGioClose(lout);
        break;
      }

    case float128_PLP:
    case float128_PMPS:
      {
        if (float128_ILLread_lp_state_next_field_on_line (state) == 0)
        {
          if (cmd == float128_PMPS)
          {
            tval = float128_QSwrite_prob (p, state->field, "MPS");
          }
          else
          {
            tval = float128_QSwrite_prob (p, state->field, "LP");
          }
          if (tval)
          {
            fprintf (stdout, "Could not write problem to \"%s\".\n",
                     state->field);
          }
          else
          {
            fprintf (stdout, "Saved to \"%s\".\n", state->field);
          }
        }
        else
        {
          if (cmd == float128_PMPS)
          {
            (void) float128_QSwrite_prob_file (p, stdout, "MPS");
          }
          else
          {
            (void) float128_QSwrite_prob_file (p, stdout, "LP");
          }
        }
        break;
      }

    case float128_NONE:
      fprintf (stdout, "Unknown command: %s\n", state->field);
    default:
      float128_ILLeditor_help ();
      break;
    }
    fflush (stdout);
    float128_ILLread_lp_state_next_line (state);
  }
CLEANUP:
  float128_ILLline_reader_free (reader);
  float128_ILLfree_rawlpdata (lp);
}

int float128_ILLeditor_solve (
  float128_QSdata * p,
  int salgo)
{
  int rval = 0;
  int status = 0;
  float128 val;

  float128_EGlpNumInitVar (val);

  if (salgo == PRIMAL_SIMPLEX)
  {
    rval = float128_QSopt_primal (p, &status);
  }
  else
  {
    rval = float128_QSopt_dual (p, &status);
  }
  float128_ILL_BREAK_BODY_IF (rval);
  rval = float128_QSget_objval (p, &val);
  if (p->simplex_display)
    if (rval == 0)
    {
      fprintf (stdout, "LP Value: %.6f, status %d\n", float128_EGlpNumToLf (val),
               status);
      fflush (stdout);
    }
CLEANUP:
  float128_EGlpNumClearVar (val);
  ILL_RESULT (rval, "float128_ILLeditor_solve");
}


static int float128_pull_info_from_p (
  float128_QSdata * p,
  float128_rawlpdata * lp)
{
  int i, rval = 0;
  float128_ILLlpdata *qslp = p->lp->O;
  int nrows, ncols;

  float128_ILLinit_rawlpdata (lp, NULL);
  rval = ILLsymboltab_create (&lp->rowtab, 100) ||
    ILLsymboltab_create (&lp->coltab, 100);
  float128_ILL_BREAK_BODY_IF (rval);

  nrows = qslp->nrows;
  ncols = qslp->nstruct;
  /* add rows to lp */
  float128_ILLraw_add_row (lp, qslp->objname, 'N', float128_zeroLpNum);
  for (i = 0; i < nrows; i++)
  {
    ILL_FAILfalse (qslp->rownames[i] != NULL, "should have no NULL names");
    float128_ILLraw_add_row (lp, qslp->rownames[i], qslp->sense[i], qslp->rhs[i]);
  }

  /* add cols to coltab and lp */
  for (i = 0; i < ncols; i++)
  {
    ILL_FAILfalse (qslp->colnames[i] != NULL, "should have no NULL names");
    float128_ILLraw_add_col (lp, qslp->colnames[i],
                    (qslp->intmarker) ? qslp->intmarker[i] : 0);
  }
CLEANUP:
  ILL_RETURN (rval, "float128_pull_info_from_p");
}

static int float128_transpose (
  float128_rawlpdata * lp)
{
  int rval = 0;
  int tmp;
  ILLsymboltab tmptab;

  tmp = QSMAX (lp->nrows, lp->ncols);
  if (tmp >= lp->sensesize)
  {
    lp->sensesize *= 1.3;
    lp->sensesize += 1000;
    if (lp->sensesize < tmp + 1)
      lp->sensesize = tmp + 1;
    lp->rowsense = EGrealloc (lp->rowsense, sizeof (char) * lp->sensesize);
    //rval = ILLutil_reallocrus_scale ((void **) &lp->rowsense,
    //                                 &lp->sensesize, tmp + 1,
    //                                 1.3, sizeof (char));
    //ILL_CLEANUP_IF (rval);
  }
  if (tmp >= lp->rhssize)
  {
    lp->rhssize *= 1.3;
    lp->rhssize += 1000;
    if (lp->rhssize < tmp + 1)
      lp->rhssize = tmp + 1;
    float128_EGlpNumReallocArray (&(lp->rhs), lp->rhssize);
    //lp->rhs = EGrealloc(lp->rhs, sizeof(double)*lp->rhssize);
    //rval = ILLutil_reallocrus_scale ((void **) &lp->rhs,
    //                                 &lp->sensesize, tmp + 1,
    //                                 1.3, sizeof (double));
    //ILL_CLEANUP_IF (rval);
  }
  float128_ILL_SWAP (lp->nrows, lp->ncols, tmp);
  float128_ILL_SWAP (lp->rowtab, lp->coltab, tmptab);
  ILL_RETURN (rval, "float128_transpose");
}

static char *float128_get_row_col_name (
  float128_QSdata * p,
  float128_rawlpdata * lp,
  float128_ILLread_lp_state * state,
  int doRow)
{
  int rval = 0;
  int ind;
  char *rname, *thename = NULL;
  char buf[ILL_namebufsize];
  ILLsymboltab *tab = (doRow) ? &lp->rowtab : &lp->coltab;
  int id = (doRow) ? lp->nrows : lp->ncols;

  id--;                         /* in float128_rawlpdata obj counts as a row */

  rval = float128_ILLread_constraint_name (state, &rname);
  float128_ILL_BREAK_BODY_IF (rval);

  if (rname == NULL)
  {
    float128_ILLlib_findName (p->qslp, doRow /* forRow */ , rname, id, buf);
    float128_ILL_UTIL_STR (thename, buf);
  }
  else
  {
    float128_ILL_UTIL_STR (thename, rname);
  }
  if (ILLsymboltab_lookup (tab, thename, &ind) == 0)
  {
    rval = float128_ILLlp_error (state, "\"%s\" already exists.", thename);
  }
CLEANUP:
  if (rval != 0)
  {
    ILL_IFFREE (thename, char);
  }
  return thename;
}

static int float128_fill_matrix (
  float128_rawlpdata * lp,
  float128_ILLread_lp_state * state,
  float128_ILLmatrix * m,
  float128 * obj,
  int n)
{
  int i, cnt, rval = 0;
  float128_colptr *cp;
  float128 val;
  int newCol = (obj != NULL);

  float128_EGlpNumInitVar (val);

  /* rely on fact that objective has rowindex 0 */

  m->matrows = lp->nrows;
  m->matcols = 1;
  m->matval = float128_EGlpNumAllocArray (lp->ncols);
  ILL_SAFE_MALLOC (m->matind, lp->ncols, int);
  ILL_SAFE_MALLOC (m->matbeg, 1, int);
  ILL_SAFE_MALLOC (m->matcnt, 1, int);

  m->matsize = lp->ncols;
  m->matbeg[0] = 0;
  m->matcnt[0] = 0;
  for (i = 0; i < lp->ncols; i++)
  {
    cnt = 0;
    float128_EGlpNumZero (val);
    for (cp = lp->cols[i]; cp != NULL; cp = cp->next)
    {
      ILL_FAILfalse (cp->this_val == n, "n should be the only row around");
      if (float128_EGlpNumIsNeqqZero (cp->coef))
      {
        float128_EGlpNumAddTo (val, cp->coef);
        cnt++;
      }
    }
    if (cnt > 1)
    {
      float128_ILLlp_warn (state, "Multiple coefficients for \"%s\".",
                  float128_ILLraw_colname (lp, i));
    }
    if (float128_EGlpNumIsNeqqZero (val))
    {
      if ((i - newCol) >= 0)
      {
        float128_EGlpNumCopy (m->matval[m->matcnt[0]], val);
        m->matind[m->matcnt[0]] = i - newCol;
        m->matcnt[0]++;
      }
      else
      {
        float128_EGlpNumCopy (obj[0], val);
      }
    }
  }
  if (m->matcnt[0] == 0)
  {
    rval = float128_ILLlp_error (state, "There are no non zero coefficients.");
  }
CLEANUP:
  float128_EGlpNumClearVar (val);
  ILL_RESULT (rval, "float128_fill_matrix");
}

static void float128_add_row (
  float128_QSdata * p,
  float128_rawlpdata * lp,
  float128_ILLread_lp_state * state)
{
  int rval = 0;
  int n;
  char *name;
  float128_ILLmatrix m;
  char sense[1];

  float128_ILLmatrix_init (&m);
  n = lp->nrows;
  name = float128_get_row_col_name (p, lp, state, 1 /*doRow */ );

  if (name == NULL)
  {
    rval = 1;
  }
  else
  {
    rval = float128_ILLread_one_constraint (state, name, lp, 0);

    /* adds row name to lp->rowtab the checks constraint expression  */
    if (rval != 0)
    {
      /* failed because of error in expression => 
       * must remove name from symbol table */
      fprintf (stdout, "Incorrect expression.\n");
    }
    else
    {
      ILL_FAILfalse (lp->nrows == (n + 1), "Should have one row");
      ILL_IFTRACE ("ADDING row %s.\n", name);

      sense[0] = lp->rowsense[n];

      rval = float128_fill_matrix (lp, state, &m, NULL, n);
      float128_ILL_BREAK_BODY_IF (rval);

      float128_QSadd_rows (p, 1, m.matcnt, m.matbeg, m.matind, m.matval,
                  &(lp->rhs[n]), sense, (const char **) &name);
    }
  }
CLEANUP:
  float128_ILLmatrix_free (&m);
  if (name != NULL)
  {
    if (rval != 0)
      ILLsymboltab_delete (&lp->rowtab, name);
    ILL_IFFREE (name, char);
  }
  if (rval != 0)
  {
    lp->nrows = n;
  }
  float128_ILLraw_clear_matrix (lp);
}

static void float128_add_col (
  float128_QSdata * p,
  float128_rawlpdata * lp,
  float128_ILLread_lp_state * state)
{
  int rval = 0;
  int n;
  char *name[1];
  int transposed = 1;
  float128_ILLmatrix matrix, *m = &matrix;
  float128 obj[1], lower[1], upper[2];

  float128_EGlpNumInitVar (*obj);
  float128_EGlpNumInitVar (*lower);
  float128_EGlpNumInitVar (upper[0]);
  float128_EGlpNumInitVar (upper[1]);

  n = lp->ncols;
  float128_ILLmatrix_init (m);
  name[0] = float128_get_row_col_name (p, lp, state, 0 /*doRow */ );
  rval = (name[0] == NULL);
  float128_ILL_BREAK_BODY_IF (rval);

  transposed = !float128_transpose (lp);
  rval = float128_ILLread_one_constraint (state, name[0], lp, 0);

  /* adds row name to lp->rowtab the checks constraint expression  */
  if (rval != 0)
  {
    /* failed because of error in expression => 
     * must remove name from symbol table */
    fprintf (stdout, "Incorrect expression.\n");
  }
  else
  {
    ILL_FAILfalse (lp->nrows == (n + 1), "Should have one row");

    rval = float128_fill_matrix (lp, state, m, obj, n);
    float128_ILL_BREAK_BODY_IF (rval);

    fprintf (stdout, "lower ");
    rval = float128_ILLread_lp_state_next_line (state) ||
      float128_ILLread_lp_state_value (state, &(lower[0]));
    float128_ILL_BREAK_BODY_IF (rval);

    fprintf (stdout, "upper ");
    rval = float128_ILLread_lp_state_next_line (state) ||
      float128_ILLread_lp_state_value (state, &(upper[0]));
    float128_ILL_BREAK_BODY_IF (rval);

    ILL_IFTRACE ("ADDING col %s.\n", name[0]);

    float128_QSadd_cols (p, 1, m->matcnt, m->matbeg, m->matind, m->matval,
                obj, lower, upper, (const char **) name);

  }
CLEANUP:
  float128_ILLmatrix_free (m);
  if (name[0] != NULL)
  {
    if (rval != 0)
      ILLsymboltab_delete (&lp->rowtab, name[0]);
    ILL_IFFREE (name[0], char);
  }
  if (rval != 0)
  {
    lp->nrows = n;
  }
  float128_ILLraw_clear_matrix (lp);
  if (transposed)
    float128_transpose (lp);
  ILL_IFFREE (name[0], char);

  float128_EGlpNumClearVar (*obj);
  float128_EGlpNumClearVar (*lower);
  float128_EGlpNumClearVar (upper[0]);
  float128_EGlpNumClearVar (upper[1]);
}

#if 0
#ifndef JAVA_PORT
static void new_row (
  float128_QSdata * p,
  float128_rawlpdata * lp,
  float128_ILLread_lp_state * state)
{
  int rval = 0;
  char *rowname = NULL, *rname = NULL;
  char sense;
  double d;
  int ind, hit;

  rval = float128_ILLread_constraint_name (state, &rname);
  if (rname == NULL)
  {
    rval = 1;
    float128_ILLeditor_help_cmd (float128_ROW, float128_NEW);
  }
  float128_ILL_BREAK_BODY_IF (rval);

  ILLsymboltab_lookup (&lp->rowtab, rname, &ind);
  if (ind != ILL_SYM_NOINDEX)
  {
    rval = float128_ILLlp_error (state, "\"%s\" is already defined.\n", rname);
    float128_ILL_BREAK_BODY_IF (rval);
  }
  float128_ILL_UTIL_STR (rowname, rname);

  rval = float128_ILLread_lp_state_sense (state);
  sense = state->sense_val;
  float128_ILL_BREAK_BODY_IF (rval);

  rval = float128_ILLread_lp_state_value (state, &d);
  float128_ILL_BREAK_BODY_IF (rval);

  rval = float128_QSnew_row (p, d, sense, rowname);
  if (rval != 0)
  {
    fprintf (stderr, "could not add row\n");
  }
  else
  {
    ILLsymboltab_register (&lp->rowtab, rname, &ind, &hit);
  }
CLEANUP:
  ILL_IFFREE (rowname, char);
}
#endif
#endif

static int float128_del_row_or_col (
  float128_QSdata * p,
  float128_rawlpdata * lp,
  float128_ILLread_lp_state * state,
  int isRow)
{
  int i[1], rval = 0;
  char **names = (isRow) ? p->qslp->rownames : p->qslp->colnames;
  int nnames = (isRow) ? p->qslp->nrows : p->qslp->nstruct;
  ILLsymboltab *tab = (isRow) ? &lp->rowtab : &lp->coltab;

  rval = float128_ILLread_lp_state_next_field_on_line (state);
  float128_ILL_BREAK_BODY_IF (rval);

  i[0] = float128_ILLutil_array_index (names, nnames, state->field);
  if (i[0] >= 0)
  {
    rval = (isRow) ? float128_QSdelete_rows (p, 1, i) : float128_QSdelete_cols (p, 1, i);
    if (rval == 0)
    {
      ILLsymboltab_delete (tab, state->field);
    }
  }
  else
  {
    rval = float128_ILLlp_error (state, "\"%s\" is not defined.\n", state->field);
  }

CLEANUP:
  ILL_RESULT (rval, "float128_del_row_or_col");
}

static void float128_del_row (
  float128_QSdata * p,
  float128_rawlpdata * lp,
  float128_ILLread_lp_state * state)
{
  int rval = float128_del_row_or_col (p, lp, state, 1);

  if (rval == 0)
  {
    lp->nrows--;
  }
}

static void float128_del_col (
  float128_QSdata * p,
  float128_rawlpdata * lp,
  float128_ILLread_lp_state * state)
{
  int rval = float128_del_row_or_col (p, lp, state, 0);

  if (rval == 0)
  {
    lp->ncols--;
  }
}

---