ace-5.3/src/util1.c

/**************************************************************************

        util1.c
        Colin Ramsay (cram@itee.uq.edu.au)
        22 Dec 00

        ADVANCED COSET ENUMERATOR, Version 3.001

        Copyright 2000
        Centre for Discrete Mathematics and Computing,
        Department of Mathematics and
          Department of Computer Science & Electrical Engineering,
        The University of Queensland, QLD 4072.
	(http://staff.itee.uq.edu.au/havas)

These are the utilities for Level 1 of ACE.

**************************************************************************/

#include "al1.h"

#include <ctype.h>

	/******************************************************************
        void al1_init(void)

        One-off initialisation of the Level 1 stuff, and all lower levels.
	Note that there is no need to initialise, for example, genal[].
	******************************************************************/

void al1_init(void)
  {
  al0_init();

  workspace = DEFWORK;
  workmult  = 1;
  costable  = NULL;
  tabsiz    = 0;

  currrep = NULL;
  repsiz  = repsp = 0;

  asis = FALSE;

  grpname = NULL;
  rellst  = NULL;
  trellen = 0;

  ndgen    = 0;
  geninv   = NULL;
  gencol   = colgen   = NULL;
  galpha   = FALSE;
  algen[0] = algen[1] = '\0';		/* &algen[1] is printable string */

  subgrpname = NULL;
  genlst     = NULL;
  tgenlen    = 0;

  rfactor1 = cfactor1 = 0;
  pdsiz1   = dedsiz1  = 0;
  maxrow1  = ffactor1 = 0;
  nrinsgp1 = -1;
  }

        /******************************************************************
        void al1_dump(Logic allofit)

        Dump out the internals of Level 1 of ACE, working through al1.h
        more or less in order.
        ******************************************************************/

void al1_dump(Logic allofit)
  {
  int i;
  Wlelt *p;

  fprintf(fop, "  #---- %s: Level 1 Dump ----\n", ACE_VER);

	/* workspace, workmult, costable, tabsiz; */
  fprintf(fop, "workspace=%d workmult=%d", workspace, workmult);
  if (costable == NULL)
    { fprintf(fop, " costable=NULL"); }
  else
    { fprintf(fop, " costable=non-NULL"); }
  fprintf(fop, " tabsiz=%d\n", tabsiz);

	/* currrep, repsiz, repsp; */
  if (currrep == NULL)
    { fprintf(fop, "currrep=NULL"); }
  else
    { fprintf(fop, "currrep=non-NULL"); }
  fprintf(fop, " repsiz=%d repsp=%d\n", repsiz, repsp);

	/* LLL, asis */
  fprintf(fop, "LLL=%d, asis=%d\n", LLL, asis);

	/* group: name, generators, geninv */
  if (grpname == NULL)
    { fprintf(fop, "grpname=NULL\n"); }
  else
    { fprintf(fop, "grpname=%s\n", grpname); }

  if (ndgen == 0)
    { fprintf(fop, "ndgen=%d\n", ndgen); }
  else if (galpha)
    {
    fprintf(fop, "ndgen=%d galpha=%d algen[]=", ndgen, galpha);
    for (i = 1; i <= ndgen; i++)
      { fprintf(fop, "%c", algen[i]); }
    fprintf(fop, "\n");

    if (allofit)
      {
      fprintf(fop, "  genal[]=");
      for (i = 1; i <= 26; i++)
        { fprintf(fop, "%d ", genal[i]); }
      fprintf(fop, "\n");
      }
    }
  else
    { fprintf(fop, "ndgen=%d galpha=%d\n", ndgen, galpha); }

  if (geninv == NULL)
    { fprintf(fop, "geninv=NULL\n"); }
  else
    {
    fprintf(fop, "geninv[]=");
    for (i = 1; i <= ndgen; i++)
      { fprintf(fop, "%d ", geninv[i]); }
    fprintf(fop, "\n");
    }

	/* gencol, colgen */
  if (gencol == NULL)
    { fprintf(fop, "gencol=NULL\n"); }
  else
    {
    fprintf(fop, "gencol[]=");
    for (i = -ndgen; i <= -1; i++)
      { fprintf(fop, "%d ", gencol[ndgen+i]); }
    fprintf(fop, "x ");
    for (i = 1; i <= ndgen; i++)
      { fprintf(fop, "%d ", gencol[ndgen+i]); }
    fprintf(fop, "\n");
    }
  if (colgen == NULL)
    { fprintf(fop, "colgen=NULL\n"); }
  else
    {
    fprintf(fop, "colgen[]=");
    for (i = 1; i <= ncol; i++)
      { fprintf(fop, "%d ", colgen[i]); }
    fprintf(fop, "\n");
    }

	/* group relators + trellen */
  if (rellst == NULL)
    { fprintf(fop, "rellst=NULL trellen=%d\n", trellen); }
  else if (rellst->len == 0)
    { fprintf(fop, "rellst->len=0 trellen=%d\n", trellen); }
  else
    {
    fprintf(fop, "rellst->len=%d trellen=%d\n", rellst->len, trellen);
    if (allofit)
      {
      fprintf(fop, "  len    exp    inv    word\n");
      for (p = rellst->first;  ; p = p->next)
        {
        fprintf(fop, "  %3d    %3d    %3d    ", p->len, p->exp, p->invol);
        for (i = 1; i <= p->len; i++)
          { fprintf(fop, "%d ", p->word[i]); }
        fprintf(fop, "\n");

        if (p == rellst->last)
          { break; }
        }
      }
    }

	/* subgroup: name */
  if (subgrpname == NULL)
    { fprintf(fop, "subgrpname=NULL\n"); }
  else
    { fprintf(fop, "subgrpname=%s\n", subgrpname); }

	/* subgroup generators + tgenlen */
  if (genlst == NULL)
    { fprintf(fop, "genlst=NULL tgenlen=%d\n", tgenlen); }
  else if (genlst->len == 0)
    { fprintf(fop, "genlst->len=0 tgenlen=%d\n", tgenlen); }
  else
    {
    fprintf(fop, "genlst->len=%d tgenlen=%d\n", genlst->len, tgenlen);
    if (allofit)
      {
      fprintf(fop, "  len    exp    inv    word\n");
      for (p = genlst->first;  ; p = p->next)
        {
        fprintf(fop, "  %3d    %3d    %3d    ", p->len, p->exp, p->invol);
        for (i = 1; i <= p->len; i++)
          { fprintf(fop, "%d ", p->word[i]); }
        fprintf(fop, "\n");

        if (p == genlst->last)
          { break; }
        }
      }
    }

	/* rfactor1, cfactor1 */
  fprintf(fop, "rfactor1=%d cfactor1=%d\n", rfactor1, cfactor1);

	/* pdsiz1, dedsiz1 */
  fprintf(fop, "pdsiz1=%d dedsiz1=%d\n", pdsiz1, dedsiz1);

	/* maxrow1, ffactor1, nrinsgp1 */
  fprintf(fop, "maxrow1=%d ffactor1=%d nrinsgp1=%d\n",
                maxrow1,   ffactor1,   nrinsgp1);

  fprintf(fop, "  #---------------------------------\n");
  }

	/******************************************************************
	void al1_prtdetails(int bits)

	This prints out details of the Level 0 & 1 settings, in a form
	suitable for reading in by applications using the core enumerator
	plus its wrapper (eg, ACE Level 2).  If bits is 0, then enum, rel,
	subg & gen are printed.  If 1 then *all* of the presentation and
	the enumerator control settings (this allows the run to be
	duplicated at a later date).  If bits is 2-5, then only enum, rel,
	subg & gen, respectively, are printed.  This routine is really
	intended for the ACE Level 2 interface, where some items cannot be
	examined by invoking them with an empty argument.  However it is
	put here (at Level 1), since it is a useful utility for any
	application.

	If messaging in on, this routine (with bits 1) is called by
	al1_start() after all the setup & just before the call to
	al0_enum().  So it shows what the parameters actually were.  They
	may not match what you thought they were, since the Level 1 wrapper
	(which interfaces between applications (ie, ACE's Level 2
	interactive interface) and the Level 0 enumerator) trys to prevent
	errors, and may occasionally ignore or change something.  If you
	call this after changing parameters, but before calling _start(),
	the values do *not* reflect the new values.  If you want to see
	what the Level 2 parameters are (as opposed to the current Level 0
	parameters), use the `empty argument' form of the commands, or the
	"sr;" Level 2 command (which invokes this function with bits
	false.

	To *exactly* duplicate a run, you may need to duplicate the entire
	sequence of commands since ACE was started, the execution
	environment, and use the same executable; but that's a project for
	some rainy Sunday afternoon sometime in the future.  However do
	note that the allocation of generators to columns may have upset
	your intended handling of involutions and/or the ordering of the
	generators; do a (full) Level 0/1 dump to check this, if you care!
	In particular, the value of asis is the *current* value, which may
	not match that when the call to _start() which allocated columns &
	determined which generators will be involutions was made.
	******************************************************************/

void al1_prtdetails(int bits)
  {
  if (bits < 2)
    { fprintf(fop, "  #--- %s: Run Parameters ---\n", ACE_VER); }

  if (bits == 0 || bits == 1 || bits == 2)
    {
    if (grpname != NULL)
      { fprintf(fop, "Group Name: %s;\n", grpname); }
    else
      { fprintf(fop, "Group Name:  ;\n"); }
    }

  if (bits == 1)
    {
    if (ndgen > 0)
      {
      fprintf(fop, "Group Generators: ");
      if (!galpha)
        { fprintf(fop, "%d", ndgen); }
      else
        { fprintf(fop, "%s", &algen[1]); }
      fprintf(fop, ";\n");
      }
    }

  if (bits == 0 || bits == 1 || bits == 3)
    {
    if (rellst != NULL)
      {
      fprintf(fop, "Group Relators: ");
      al1_prtwl(rellst, 16);
      fprintf(fop, ";\n");
      }
    else
      { fprintf(fop, "Group Relators: ;\n"); }
    }

  if (bits == 0 || bits == 1 || bits == 4)
    {
    if (subgrpname != NULL)
      { fprintf(fop, "Subgroup Name: %s;\n", subgrpname); }
    else
      { fprintf(fop, "Subgroup Name: ;\n"); }
    }

  if (bits == 0 || bits == 1 || bits == 5)
    {
    if (genlst != NULL)
      {
      fprintf(fop, "Subgroup Generators: ");
      al1_prtwl(genlst, 21);
      fprintf(fop, ";\n");
      }
    else
      { fprintf(fop, "Subgroup Generators: ;\n"); }
    }

  if (bits == 1)
    {
    switch (workmult)
      {
      case 1:
        fprintf(fop, "Wo:%d;", workspace);
        break;
      case KILO:
        fprintf(fop, "Wo:%dK;", workspace);
        break;
      case MEGA:
        fprintf(fop, "Wo:%dM;", workspace);
        break;
      case GIGA:
        fprintf(fop, "Wo:%dG;", workspace);
        break;
      }
    fprintf(fop, " Max:%d;", maxrow);
    if (msgctrl)
      {
      if (msghol)
        { fprintf(fop, " Mess:-%d;", msgincr); }
      else
        { fprintf(fop, " Mess:%d;", msgincr); }
      }
    else
      { fprintf(fop, " Mess:0;"); }
    fprintf(fop, " Ti:%d; Ho:%d; Loop:%d;\n", tlimit, hlimit, llimit);

    if (asis)
      { fprintf(fop, "As:1;"); }
    else
      { fprintf(fop, "As:0;"); }
    if (pcomp)
      { fprintf(fop, " Path:1;"); }
    else
      { fprintf(fop, " Path:0;"); }
    if (rfill)
      { fprintf(fop, " Row:1;"); }
    else
      { fprintf(fop, " Row:0;"); }
    if (mendel)
      { fprintf(fop, " Mend:1;"); }
    else
      { fprintf(fop, " Mend:0;"); }
    fprintf(fop, " No:%d; Look:%d; Com:%d;\n", nrinsgp, lahead, comppc);

    /* Note that we printout using the aliases, since we want to know (or,
    at least, be able to deduce) what style was used.  Note that, although
    ffactor is a float, the Level 1 (& Level 2) interfaces use ffactor1,
    which is an int.  So we need to convert for printout, to maintain the
    ability to read the output back in. */

    fprintf(fop, "C:%d; R:%d; Fi:%d;", cfactor1, rfactor1, (int)ffactor);
    fprintf(fop, " PMod:%d; PSiz:%d; DMod:%d;", pdefn, pdsiz, dedmode);
    fprintf(fop, " DSiz:%d;\n", dedsiz);
    }

  if (bits < 2)
    { fprintf(fop, "  #---------------------------------\n"); }
  }

	/******************************************************************
        void al1_rslt(int rslt)

        Pretty-print the result of a run of al1_start().  If there were no
	problems at Level 1, this will just be the result of the call to
	al0_enum(), printed via al0_rslt().
	******************************************************************/

void al1_rslt(int rslt)
  {
  if (rslt > -8192)
    { al0_rslt(rslt); }
  else
    {
    switch(rslt)
      {
      case -8194:  fprintf(fop, "TABLE TOO SMALL\n");           break;
      case -8193:  fprintf(fop, "MEMORY PROBLEM\n");            break;
      case -8192:  fprintf(fop, "INVALID MODE\n");              break;
         default:  fprintf(fop, "UNKNOWN ERROR (%d)\n", rslt);  break;
      }
    }
  }

/**************************************************************************
These are the utilities for the simple list manipulation package used to
handle the group's relators & the subgroup's generators.  Note that it is
up to the caller to catch any errors (flagged by the return values).
**************************************************************************/

	/******************************************************************
        Wlist *al1_newwl(void)

        Creates a new (empty) word list.  Returns NULL on failure.
	******************************************************************/

Wlist *al1_newwl(void)
  {
  Wlist *p = (Wlist *)malloc(sizeof(Wlist));

  if (p != NULL)
    {
    p->len   = 0;
    p->first = p->last = NULL;
    }

  return(p);
  }

	/******************************************************************
        Wlelt *al1_newelt(void)

        Creates a new (empty) word-list element.  Returns NULL on failure.
	******************************************************************/

Wlelt *al1_newelt(void)
  {
  Wlelt *p = (Wlelt *)malloc(sizeof(Wlelt));

  if (p != NULL)
    {
    p->word  = NULL;
    p->len   = p->exp = 0;
    p->invol = FALSE;
    p->next  = NULL;
    }

  return(p);
  }

	/******************************************************************
        void al1_addwl(Wlist *l, Wlelt *w)

        Adds a word (if it's non-null & non-empty) to a word list. l must
	be non-null, but may be empty.
	******************************************************************/

void al1_addwl(Wlist *l, Wlelt *w)
  {
  if (w == NULL || w->len == 0)		/* ignore null/empty words */
    { return; }

  if (l->len == 0)
    { l->first = w; }			/* add word to start of list */
  else
    { l->last->next = w; }		/* add word to end of list */

  l->last = w;
  l->len++;
  }

	/******************************************************************
	void al1_concatwl(Wlist *l, Wlist *m);

	Concatenate m's list to l's, and delete m's header node.  Note that
	l is guaranteed non-null, but may be empty.  m may be null, empty,
	or contain data.
	******************************************************************/

void al1_concatwl(Wlist *l, Wlist *m)
  {
  if (m == NULL)
    { return; }
  else if (m->len == 0)
    {
    free(m);
    return;
    }

  /* If we get here, m contains data */

  if (l->len == 0)		/* l is empty */
    {
    l->len   = m->len;
    l->first = m->first;
    l->last  = m->last;
    }
  else				/* l is non-empty */
    {
    l->len       += m->len;
    l->last->next = m->first;
    l->last       = m->last;
    }

  free(m);
  }

	/******************************************************************
	void al1_emptywl(Wlist *l)

	Delete the list of words in l, leaving l as an empty list.  Does
	*not* delete the storage for l.
	******************************************************************/

void al1_emptywl(Wlist *l)
  {
  Wlelt *p, *q;

  if (l == NULL || l->len == 0)
    { return; }

  for (p = l->first; p != NULL; )
    {
    q = p->next;

    if (p->word != NULL)
      { free(p->word); }
    free(p);

    p = q;
    }

  l->len   = 0;
  l->first = l->last = NULL;
  }

	/******************************************************************
	void al1_prtwl(Wlist *l, int n)

	Attempt to pretty-print a list of group relators or subgroup
        generators within the allowed (i.e., LLL) number of columns.  n is
        the current output column.  (Not quite sure how this would cope
        with a really nasty presentation!)  Note that this prints out words
        in exp form.  If no enumeration has yet been run, exp is at its
        default of 1, so a printout will not be `exponentiated'.  Note that
	relators of the form xx are *always* printed out in the form (x)^2
	*if* they were entered thus; in all other cases they are printed as
	xx.  This is to preserve the ability to specify whether or not a
	generator should be treated as an involution when asis is true.

	Warning: if the list contains any empty words superfluous commas
	may be introduced, rendering the list `invalid' to the Level 2
	input parser!  If _start() has been called in start/redo mode, then
	the relator & generator lists are guaranteed to be free of empty
	word (although they may contain duplicates).
	******************************************************************/

void al1_prtwl(Wlist *l, int n)
  {
  Wlelt *e;
  int elen, eexp;
  int i, len;
  char c;

  if (l == NULL || l->len == 0)
    { return; }

  for (e = l->first; e != NULL; e = e->next)
    {
    elen = e->len;			/* Alias e->len & e->exp ... */
    eexp = e->exp;

    if (elen == 2 && e->word[1] == e->word[2])
      {					/* ... adjust them if involn */
      if (e->invol)
        { eexp = 2; }
      else
        { eexp = 1; }
      }

    len = elen/eexp;

    if (!galpha)
      {						/* numeric generators */
      if (eexp == 1)
        {
        n += 2 + len*2;				/* +2 for \ , *2 for \ n */
        if (n > LLL)
          {
          fprintf(fop, "\n  ");
          n = 2+2 + len*2;
          }
        }
      else
        {
        n += 2+4 + len*2; 			/* 4 for ()^e */
        if (n > LLL)
          {
          fprintf(fop, "\n  ");
          n = 4+4 + len*2;
          }
        fprintf(fop, "(");
        }

      for (i = 1; i <= len; i++)
        { fprintf(fop, "%d ", e->word[i]); }

      if (eexp != 1)
        { fprintf(fop, ")^%d", eexp); }
      if (e->next != NULL && len != 0)		/* len = 0 not poss? */
        { fprintf(fop, ", "); }
      }
    else
      {              				/* alphabetic generators */
      if (eexp == 1)
        {
        n += 2 + len;
        if (n > LLL)
          {
          fprintf(fop, "\n  ");
          n = 2+1 + len;
          }
        }
      else
        {
        n += 2+4 + len;          		/* 4 for ()^x */
        if (n > LLL)
          {
          fprintf(fop, "\n  ");
          n = 3+4 + len;
          }
        fprintf(fop, "(");
        }

      for (i = 1; i <= len; i++)
        {
        c = (e->word[i] > 0) ? algen[e->word[i]]
                                 : toupper(algen[-e->word[i]]);
        fprintf(fop, "%c", c);
        }

      if (eexp != 1)
        { fprintf(fop, ")^%d", eexp); }
      if (e->next != NULL && len !=0)
        { fprintf(fop, ", "); }
      }
    }
  }

/**************************************************************************
These are the utilities for handling coset representatives.
**************************************************************************/

	/******************************************************************
	Logic al1_addrep(int col)

	Add #col to the current rep've, possibly extending its storage.
	Fails if we can't allocate memory.
	******************************************************************/

Logic al1_addrep(int col)
  {
  if (currrep == NULL)
    {
    repsp = 8;
    if ((currrep = (int*)malloc(repsp*sizeof(int))) == NULL)
      {
      repsiz = repsp = 0;
      return(FALSE);
      }
    }
  else if (repsiz == repsp)	/* current entries are 0..repsiz-1 */
    {
    repsp *= 2;
    if ((currrep = (int*)realloc(currrep, repsp*sizeof(int))) == NULL)
      {
      repsiz = repsp = 0;
      return(FALSE);
      }
    }

  currrep[repsiz++] = col;
  return(TRUE);
  }

	/******************************************************************
	Logic al1_bldrep(int cos)

	Traces back through the table, building up a rep've of #cos in
	currrep.  The rep've is in terms of column numbers, and is
	guaranteed to be the `canonic' rep've (ie, first in `length + col
	order' order) in terms of the *current* table.  The table may or
	may not be compact/standard.  If the table is compact & standard,
	then the rep've is guaranteed to be `really' canonic, independant
	of the details of the enumeration.  Fails if _addrep() fails.

	The order of the columns is *not* constrained in any way (apart
	from the col 1/2 stuff), so we have to be careful to pick up the
	1st col (ie, scol) in order (*after* they have been inverted) if
	more than one entry in a row is minimal.

	Note that our ability to backtrace is predicated on the fact that
	the first definition of a coset is always in terms of a lower-
	numbered coset, and during coinc processing we keep the lower-
	numbered coset & move data from the higher to the lower.  So each
	coset's row, apart from #1, *must* contain a lower-numbered entry.
	In this routine we *assume* that this property of the table has not
	been compromised in any way; if it has, then the behaviour is
	undefined.
	******************************************************************/

Logic al1_bldrep(int cos)
  {
  int low, slow, col, scol, i;

  repsiz = 0;
  if (cos <= 1 || cos >= nextdf || COL1(cos) < 0)
    { return(TRUE); }

  low = slow = cos;
  while (low > 1)
    {
    scol = 0;
    for (col = 1; col <= ncol; col++)
      {
      if ((i = CT(low,col)) > 0)
        {
        if (i < slow)				/* Lower row number found */
          {
          slow = i;
          scol = col;
          }
        else if (i == slow && scol != 0)	/* Same row & slow < low */
          {					/* ... earlier column? */
          if (invcol[col] < invcol[scol])
            { scol = col; }
          }
        }
      }

    /* Add it (increases repsiz); note the column inversion!  Failure sets
    repsiz to 0 */

    if (!al1_addrep(invcol[scol]))
      { return(FALSE); }

    low = slow;
    }

  /* Reverse representative (note: inversion already done) */

  for (i = 1; i <= repsiz/2; i++)
    {
    col  = currrep[i-1];
    scol = currrep[repsiz-i];

    currrep[i-1]      = scol;
    currrep[repsiz-i] = col;
    }

  return(TRUE);
  }

	/******************************************************************
	int al1_trrep(int cos)

	Traces currrep, starting at #cos.  Returns 0 on redundant cosets,
	on empty slot, or if there's no rep've.
	******************************************************************/

int al1_trrep(int cos)
  {
  int i;

  if (repsiz == 0)
    { return(0); }

  for (i = 0; i < repsiz; i++)
    {
    if ((COL1(cos) < 0) || ((cos = CT(cos,currrep[i])) == 0))
      { return(0); }
    }

  return(cos);
  }

	/******************************************************************
	int al1_ordrep(void)

	Traces currrep repeatedly until we arrive back at #1, or an empty
	slot.  The number of times round the loop is the order; return 0 if
	the tracing doesn't complete or the rep is empty.  Note that
	termination is guaranteed, since the table is finite!
	******************************************************************/

int al1_ordrep(void)
  {
  int i,j;

  if (repsiz == 0)
    { return(0); }

  for (i = j = 1;  ; j++)
    {
    if ((i = al1_trrep(i)) == 1)
      { return(j); }
    else if (i == 0)
      { return(0); }
    }

  return(0);		/* Can't get here; prevent compiler whinging */
  }

	/******************************************************************
	void al1_prtct(int f, int l, int s, Logic c, Logic or)

	This is a general-purpose coset table printer.  It prints rows from
	f[irst] to l[ast] inclusive, in steps of s.  On a bad value, we try
	to do the `right' thing.  If c[oinc] is true then the print-out
	includes coincident rows, else not; we skip the appropriate number
	of rows whatever the c flag is.  If or is true then the order and
	a representative are printed.  The rep've is found via a backtrace
	of the table; if the table is in standard form, this rep will be
	minimal & the `first' in `order' (length + *column* order).  Note
	that the table may or may not have been compacted and/or
	standardised.

	Warnings/Notes:
	i) If you print entries >999999, then the neatly aligned columns
	will be lost, although the entries *will* be spaced.
	ii) _bldrep() can fail.  Most probably due to a lack of memory, but
	also if the table is `corrupt' or it is called `inappropriately'.
	In this situation we should perhaps alert the user, but we choose
	simply to print `?'s instead!
	******************************************************************/

void al1_prtct(int f, int l, int s, Logic c, Logic or)
  {
  int i, j, row;

  if (f < 1)
    { f = 1; }
  if (l > nextdf-1)
    { l = nextdf-1; }
  if (s < 1)
    { s = 1; }

  fprintf(fop, " coset |");		/* above coset number */
  if (!galpha)
    {
    for (i = 1; i <= ncol; i++)
      { fprintf(fop, " %6d", colgen[i]); }
    }
  else
    {
    for (i = 1; i <= ncol; i++)
      { fprintf(fop, "      %c", (colgen[i] > 0)
                        ? algen[colgen[i]] : toupper(algen[-colgen[i]])); }
    }
  if (or)
    { fprintf(fop,"   order   rep've"); }
  fprintf(fop, "\n");

  fprintf(fop, "-------+");
  for (i = 1; i <= ncol; i++)
    { fprintf(fop, "-------"); }
  if (or)
    { fprintf(fop,"-----------------"); }
  fprintf(fop, "\n");

  row = f;
  if (!c)
    {
    while (row < nextdf && COL1(row) < 0)
      { row++; }
    }
  while (row <= l)
    {
    fprintf(fop, "%6d |", row);
    for (i = 1; i <= ncol; i++)
      { fprintf(fop, " %6d", CT(row,i)); }
    if (or && row != 1)
      {
      if (COL1(row) < 0)
        { fprintf(fop, "       -   -"); }
      else
        {
        if (al1_bldrep(row))
          {
          fprintf(fop, " %7d   ", al1_ordrep());
          for (i = 0; i < repsiz; i++)
            {
            j = colgen[currrep[i]];		/* generator number */
            if (!galpha)
              { fprintf(fop, "%d ", j); }
            else
              { fprintf(fop, "%c",
                             (j > 0) ? algen[j] : toupper(algen[-j])); }
            }
          }
        else
          { fprintf(fop, "       ?   ?"); }
        }
      }
    fprintf(fop, "\n");

    /* If we're printing *all* rows, we can just incr row by s.  If not, we
    have to jump over non-redundant rows. */

    if (c)
      { row += s; }
    else
      {
      for (i = 1; i <= s; i++)
        {
        row++;
        while (row < nextdf && COL1(row) < 0)
          { row++; }
        if (row == nextdf)
          { break; }
        }
      }
    }
  }