Quelle control.c Sprache: C

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

        control.c
        Colin Ramsay (cram@itee.uq.edu.au)
2 Mar 01

        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)

This is Level 1 of ACE; i.e., an `easy to use' wrapper round the core
enumerator.  Note that we choose to always free & then reallocate space for
the data structures.  This is simple, but may be inefficient on a long
series of runs.  It would be more efficient to keep track of how much
memory is currently allocated (for each structure), and only free/malloc
if the new structure is *bigger*!

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

#include "al1.h"

/******************************************************************
        This is all the stuff declared in al1.h
******************************************************************/

int    workspace, workmult, *costable, tabsiz;
int   *currrep, repsiz, repsp;
Logic  asis;
char  *grpname;
Wlist *rellst;
int    trellen, ndgen, *gencol, *colgen;
Logic *geninv, galpha;
char   algen[28];
int    genal[27];
char  *subgrpname;
Wlist *genlst;
int    tgenlen;

/******************************************************************
        These are the Level 0 parameters `aliased' in Level 1.
******************************************************************/

int rfactor1, cfactor1;
int pdsiz1, dedsiz1;
int maxrow1, ffactor1, nrinsgp1;

/******************************************************************
        void al1_freered(Wlist *w)

Freely reduce all the words in a word list.  Can reduce words to
zero length; we leave these in, since they'll be removed (&
deallocated) by _remempt() later.  We keep it simple, and make
multiple passes through the word until there are no changes.
******************************************************************/

void al1_freered(Wlist *w)
  {
  Wlelt *p;
  Logic done;
  int i,j;

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

  for (p = w->first; p != NULL; p = p->next)
    {
    do
      {
      done = TRUE;

      for (i = 1; i <= p->len-1; i++)
        {
        if (p->word[i] == -p->word[i+1])
          {
          for (j = i; j <= p->len-2; j++)
            { p->word[j] = p->word[j+2]; }
          p->len -= 2;

          done = FALSE;
          break;
          }
        }
      }
    while (!done);
    }
  }

/******************************************************************
        void al1_cycred(Wlist *w)

Cyclically reduce all the words in a word list.  Since this is run
*after* _freered(), it can't introduce any 0-length words (think
about it!).
******************************************************************/

void al1_cycred(Wlist *w)
  {
  Wlelt *p;
  Logic done;
  int j;

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

  for (p = w->first; p != NULL; p = p->next)
    {
    do
      {
      done = TRUE;

      if ((p->len >= 2) && (p->word[1] == -p->word[p->len]))
        {
        for (j = 1; j <= p->len-2; j++)
          { p->word[j] = p->word[j+1]; }
        p->len -= 2;

        done = FALSE;
        }
      }
    while (!done);
    }
  }

/******************************************************************
void al1_remempt(Wlist *w)

Removes & deallocates zero-length or null words from the list.  We
KISS, and do a `copy', dropping any empty words.

Note: we make no attempt to remove duplicate words!
******************************************************************/

void al1_remempt(Wlist *w)
  {
  Wlelt *newf, *newl, *old, *tmp;
  int length;

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

  newf = newl = NULL;
  length = 0;

  for (old = w->first; old != NULL; )
    {
    tmp = old;
    old = old->next;

    if (tmp->word == NULL || tmp->len == 0) /* blow away */
      {
      if (tmp->word != NULL)
        { free(tmp->word); }
      free(tmp);
      }
    else     /* move to `new' list */
      {
      if (newf == NULL)
        {
        newf = newl = tmp;
        tmp->next = NULL;
        }
      else
        {
        newl->next = tmp;
        newl = tmp;
        tmp->next = NULL;
        }

      length++;
      }
    }

  w->first = newf;
  w->last  = newl;
  w->len   = length;
  }

/******************************************************************
        void al1_sort(Wlist *w)

Sort word list into nondecreasing length order, using a stable (as
regards words of the same length) insertion sort.  Note that the
list may contain duplicates, but is guaranteed *not* to contain any
empty words.  We trace through the original list, stripping
elements off the front & inserting them in the new list in their
correct place.  Note the speculative check to see if we can tag the
next element on at the end of the new list, instead of having to
traverse the list looking for its proper place; this means that
already sorted (or partially sorted) lists process fast.
******************************************************************/

void al1_sort(Wlist *w)
  {
  Wlelt *newf, *newl;
  Wlelt *old, *tmp;
  Wlelt *curr, *currp;

  if (w == NULL || w->len < 2)
    { return; }

  /* The list contains >1 word!  We move the first word to the new list,
  remove it from the old list & make the new list `correct'. */

  newf = newl = w->first;
  old = w->first->next;
  newl->next = NULL;

  while (old != NULL)
    {
    tmp = old;
    old = old->next;

    if (tmp->len >= newl->len)  /* tag onto the end */
      {
      newl->next = tmp;
      tmp->next = NULL;
      newl = tmp;
      }
    else if (tmp->len < newf->len) /* tag onto the front */
      {
      tmp->next = newf;
      newf = tmp;
      }
    else
      {
      /* At this point we have to scan the new list looking for tmp's
      position; this *cannot* be the first or last, because of the
      preceding checks.  Further the new list must have at least two
      elements in it by now (think about it!). */

      currp = newf;
      curr = newf->next;

      while (tmp->len >= curr->len)
        {
        currp = curr;
        curr = curr->next;
        }

      tmp->next = curr;
      currp->next = tmp;
      }
    }

  w->first = newf;
  w->last  = newl;
  }

/******************************************************************
Logic al1_chkinvol(void)

First stage of involution checking / column allocation.  Builds up
the initial version of the geninv[] array, based on the relator
list and the asis flag.  If asis is false, any xx/x^2 (or whatever)
sets x to an involution.  If asis is true, only a relator flagged
as an invol does the trick.
******************************************************************/

Logic al1_chkinvol(void)
  {
  int i;
  Wlelt *p;

  if (geninv != NULL)
    { free(geninv); }
  if ((geninv = (int *)malloc((ndgen+1)*sizeof(Logic))) == NULL)
    { return(FALSE); }

  geninv[0] = FALSE;   /* P.P.P. */
  for (i = 1; i <= ndgen; i++)
    { geninv[i] = FALSE; }

  if (rellst != NULL && rellst->len > 0)
    {
    for (p = rellst->first; p != NULL; p = p->next)
      {
      if (p->len == 2 && p->word[1] == p->word[2])
        {
        if (asis)
          {
          if (p->invol)
            { geninv[abs(p->word[1])] = TRUE; }
          }
        else
          { geninv[abs(p->word[1])] = TRUE; }
        }
      }
    }

  return(TRUE);
  }

/******************************************************************
Logic al1_cols(void)

At this stage, geninv contains a list of the generators we would
*like* to treat as involutions, based on the presentation & the
asis flag.  We now allocate the generators to columns, honouring
geninv & the order of entry, as far as we can.  We *must* ensure
that the first two columns are either a generator & its inverse,
or two involutions.  Once all this has been done, geninv & the
columns are *fixed* for the entire run.  The invcol & gencol/colgen
arrays are created here; note the offsetting of the data in gencol,
to cope with -ve generator nos (inverses)!
******************************************************************/

Logic al1_cols(void)
  {
  int i,j;

  /* First, we dispose of the anomalous case of one generator */

  if (ndgen == 1)
    {
    geninv[1] = FALSE;
    ncol = 2;

    if (invcol != NULL)
      { free(invcol); }
    if (gencol != NULL)
      { free(gencol); }
    if (colgen != NULL)
      { free(colgen); }
    if ( (invcol = (int *)malloc(3*sizeof(int))) == NULL ||
         (gencol = (int *)malloc(3*sizeof(int))) == NULL ||
         (colgen = (int *)malloc(3*sizeof(int))) == NULL )
      { return(FALSE); }

    invcol[0] = 0;    /* P.P.P. */
    invcol[1] = 2;    /* col 2 is inv of col 1 */
    invcol[2] = 1;    /* col 1 is inv of col 2 */

    gencol[0] = 2;    /* -gen #1 is col #2 */
    gencol[1] = 0;    /* P.P.P. */
    gencol[2] = 1;    /* +gen #1 is col #1 */

    colgen[0] = 0;    /* P.P.P. */
    colgen[1] = +1;    /* col 1 is + gen 1 */
    colgen[2] = -1;    /* col 2 is - gen 1 */

    return(TRUE);
    }

  /* As ndgen > 1, we can honour geninv.  Allocate the required space,
  since we now know that ncol will be 2*ndgen - #involns. */

  ncol = 2*ndgen;
  for (i = 1; i <= ndgen; i++)
    {
    if (geninv[i])
      { ncol--; }
    }

  if (invcol != NULL)
    { free(invcol); }
  if (gencol != NULL)
    { free(gencol); }
  if (colgen != NULL)
    { free(colgen); }
  if ( (invcol = (int *)malloc((ncol+1)*sizeof(int))) == NULL ||
       (gencol = (int *)malloc((2*ndgen+1)*sizeof(int))) == NULL ||
       (colgen = (int *)malloc((ncol+1)*sizeof(int))) == NULL )
    { return(FALSE); }

  invcol[0] = 0;    /* P.P.P. ... */
  gencol[ndgen] = 0;
  colgen[0] = 0;

  /* We can honour the generator ordering if the first generator is not an
  involution, or if both the first two are. */

  if (!geninv[1] || (geninv[1] && geninv[2]))
    {
    j = 0;
    for (i = 1; i <= ndgen; i++)
      {
      if (geninv[i])    /* involution, 1 col */
        {
        j++;
        invcol[j] = j;
        gencol[ndgen+i] = j;
        gencol[ndgen-i] = j;
        colgen[j] = +i;
        }
      else     /* noninvolution, 2 cols */
        {
        j++;
        invcol[j] = j+1;
        gencol[ndgen+i] = j;
        colgen[j] = +i;
        j++;
        invcol[j] = j-1;
        gencol[ndgen-i] = j;
        colgen[j] = -i;
        }
      }

    return(TRUE);
    }

  /* We have to shuffle the columns.  At this point, generator #1 is an
  involution & #2 is not (think about it); we'll swap gen'rs 1 & 2, and
  then honour the order. */

  invcol[1] = 2;
  invcol[2] = 1;
  invcol[3] = 3;

  gencol[ndgen+1] = 3;
  gencol[ndgen-1] = 3;
  gencol[ndgen+2] = 1;
  gencol[ndgen-2] = 2;

  colgen[1] = +2;
  colgen[2] = -2;
  colgen[3] = +1;

  j = 3;
  for (i = 3; i <= ndgen; i++)   /* any more gen'rs? */
    {
    if (geninv[i])    /* involution, 1 col */
      {
      j++;
      invcol[j] = j;
      gencol[ndgen+i] = j;
      gencol[ndgen-i] = j;
      colgen[j] = +i;
      }
    else     /* noninvolution, 2 cols */
      {
      j++;
      invcol[j] = j+1;
      gencol[ndgen+i] = j;
      colgen[j] = +i;
      j++;
      invcol[j] = j-1;
      gencol[ndgen-i] = j;
      colgen[j] = -i;
      }
    }

  return(TRUE);
  }

/******************************************************************
void al1_getlen(void)

Compute the total length of the relators and the generators.
******************************************************************/

void al1_getlen(void)
  {
  Wlelt *p;

  trellen = 0;
  if (rellst != NULL && rellst->len > 0)
    {
    for (p = rellst->first; p != NULL; p = p->next)
      { trellen += p->len; }
    }

  tgenlen = 0;
  if (genlst != NULL && genlst->len > 0)
    {
    for (p = genlst->first; p != NULL; p = p->next)
      { tgenlen += p->len; }
    }
  }

/******************************************************************
void al1_baseexp(Wlelt *e)

Compute exponent of word *e.  btry is current attempt at base
length.  This counts up, so get exp correct (i.e., as large as
possible).  Originally used internally to save storage space (but
not time); now used for edps & print-out.  Note that geninv is now
frozen & any involutary X's changed to x's, so we do not need to
worry about these when trying to find the max possible exponent.
******************************************************************/

void al1_baseexp(Wlelt *e)
  {
  int i, j, btry;

  for (btry = 1; btry <= e->len/2; btry++)
    {
    if (e->len % btry == 0)
      {               /* possible base length */
      e->exp = e->len / btry;

      for (i = 1; i <= btry; i++)
        {                  /* for each gen in possible base */
        for (j = i + btry; j <= e->len; j += btry)
          {                     /* for each poss copy */
          if (e->word[i] != e->word[j])
            { goto eLoop; }    /* mismatch, this e->exp failed */
          }
        }

      return;                  /* this e->exp is the exponent */
      }

    eLoop:
      ;                       /* try next potential exponent */
    }

  e->exp = 1;                  /* nontrivial exponent not found */
  }

/******************************************************************
void al1_getexp(void)

Compute exponents of all words in both lists.
******************************************************************/

void al1_getexp(void)
  {
  Wlelt *p;

  if (rellst != NULL && rellst->len > 0)
    {
    for (p = rellst->first; p != NULL; p = p->next)
      { al1_baseexp(p); }
    }

  if (genlst != NULL && genlst->len > 0)
    {
    for (p = genlst->first; p != NULL; p = p->next)
      { al1_baseexp(p); }
    }
  }

/******************************************************************
void al1_xtox(void)

Change any involutary X to x.
******************************************************************/

void al1_xtox(void)
  {
  Wlelt *p;
  int i;

  if (rellst != NULL && rellst->len > 0)
    {
    for (p = rellst->first; p != NULL; p = p->next)
      {
      if (p->word != NULL && p->len > 0)
        {
        for (i = 1; i <= p->len; i++)
          {
          if (p->word[i] < 0 && geninv[-p->word[i]])
            { p->word[i] = -p->word[i]; }
          }
        }
      }
    }

  if (genlst != NULL && genlst->len > 0)
    {
    for (p = genlst->first; p != NULL; p = p->next)
      {
      if (p->word != NULL && p->len > 0)
        {
        for (i = 1; i <= p->len; i++)
          {
          if (p->word[i] < 0 && geninv[-p->word[i]])
            { p->word[i] = -p->word[i]; }
          }
        }
      }
    }
  }

/******************************************************************
Logic al1_setrel(void)

Setup the relators for the enumerator.  Note how we double up the
relators, so we can do `cyclic' scans efficiently.  If ndrel=0, we
could skip this & leave the last setup present, but we choose to
tidy up.
******************************************************************/

Logic al1_setrel(void)
  {
  Wlelt *p;
  int i, j, first, second;

  if (relind != NULL)
    { free(relind); }
  if ((relind = (int *)malloc((ndrel+1)*sizeof(int))) == NULL)
    { return(FALSE); }
  relind[0] = -1;    /* P.P.P. */

  if (relexp != NULL)
    { free(relexp); }
  if ((relexp = (int *)malloc((ndrel+1)*sizeof(int))) == NULL)
    { return(FALSE); }
  relexp[0] = 0;    /* P.P.P. */

  if (rellen != NULL)
    { free(rellen); }
  if ((rellen = (int *)malloc((ndrel+1)*sizeof(int))) == NULL)
    { return(FALSE); }
  rellen[0] = 0;    /* P.P.P. */

  if (relators != NULL)
    { free(relators); }
  if ((relators = (int *)malloc(2*trellen*sizeof(int))) == NULL)
    { return(FALSE); }

  if (rellst != NULL && rellst->len > 0)
    {
    second = 0;
    i = 1;

    for (p = rellst->first; p != NULL; p = p->next)
      {
      rellen[i] = p->len;
      relexp[i] = p->exp;
      first = second;
      second = first + p->len;
      relind[i] = first;
      for (j = 1; j <= p->len; j++)
        { relators[first++] = relators[second++] = p->word[j]; }
      i++;
      }
    }

  return(TRUE);
  }

/******************************************************************
Logic al1_setgen(void)

Build the generator array.  Again, if nsgpg=0 we could skip this.
******************************************************************/

Logic al1_setgen(void)
  {
  Wlelt *p;
  int i, j, first;

  if (subgindex != NULL)
    { free(subgindex); }
  if ((subgindex = (int *)malloc((nsgpg+1)*sizeof(int))) == NULL)
    { return(FALSE); }
  subgindex[0] = -1;    /* P.P.P. */

  if (subglength != NULL)
    { free(subglength); }
  if ((subglength = (int *)malloc((nsgpg+1)*sizeof(int))) == NULL)
    { return(FALSE); }
  subglength[0] = 0;    /* P.P.P. */

  if (subggen != NULL)
    { free(subggen); }
  if ((subggen = (int *)malloc(tgenlen*sizeof(int))) == NULL)
    { return(FALSE); }

  if (genlst != NULL && genlst->len > 0)
    {
    first = 0;
    i = 1;

    for (p = genlst->first; p != NULL; p = p->next)
      {
      subglength[i] = p->len;
      subgindex[i] = first;
      for (j = 1; j <= p->len; j++)
        { subggen[first++] = p->word[j]; }
      i++;
      }
    }

  return(TRUE);
  }

/******************************************************************
Logic al1_bldedp(void)

Build the edp data structure by scanning through the appropriate
portion of relators[] array for each relator.  Note that *if* x is
to be treated as an involution, then relators of the form xx are
*not* included, since they yield nothing.  However, relators of the
form xx *must* be included if x/X has more than 1 column allocated
in the table (ie, it is *not* treated as an involution).  At this
stage, relators[] is still in the form of +/- gen'r nos.  Note that
generators with single cols are being treated as involutions, and
any X's have been changed to x's, so we do not need to worry about
picking up inverses of 1-column generators.

Remark: if defn:1 is active there are no involns, so *all* the
relators will be included.
******************************************************************/

Logic al1_bldedp(void)
  {
  int start, col, gen, rel;
  int b,e,i;

  if (edpbeg != NULL)
    { free(edpbeg); }
  if (edpend != NULL)
    { free(edpend); }
  if (edp != NULL)
    { free(edp); }

  if ( (edpbeg = (int *)malloc((ncol + 1)*sizeof(int))) == NULL ||
       (edpend = (int *)malloc((ncol + 1)*sizeof(int))) == NULL ||
       (edp = (int *)malloc(2*trellen*sizeof(int))) == NULL )
    { return(FALSE); }
  edpbeg[0] = edpend[0] = -1;   /* P.P.P. */

  start = 0;
  for (col = 1; col <= ncol; col++)
    {
    edpbeg[col] = start;  /* index of first edp, this col */
    gen = colgen[col];

    for (rel = 1; rel <= ndrel; rel++)
      {
      /* b points to the beginning & e to the end of the base of (the first
      copy of) relator rel. */

      b = relind[rel];
      e = b-1 + rellen[rel]/relexp[rel];

      for (i = b; i <= e; i++)
        {
        if (relators[i] == gen)
          {
          if (!(b == e && relexp[rel] == 2 && invcol[col] == col))
            {
            edp[start++] = i;
            edp[start++] = rellen[rel];
            }
          }
        }
      }

    if (start == edpbeg[col])  /* none found! */
      { edpbeg[col] = edpend[col] = -1; }
    else
      { edpend[col] = start - 2; } /* index of last edp, this col */
    }

  return(TRUE);
  }

/******************************************************************
void al1_transl(void)

Translate the relators & generators from arrays in terms of
generators & inverses to arrays in terms of their associated column
numbers in the coset table.
******************************************************************/

void al1_transl(void)
  {
  int i;

  for (i = 0; i < 2*trellen; i++)
    { relators[i] = gencol[ndgen+relators[i]]; }

  for (i = 0; i < tgenlen; i++)
    { subggen[i] = gencol[ndgen+subggen[i]]; }
  }

/******************************************************************
int al1_start(int mode)

        This is a wrapper for the enumerator (ie, al0_enum()).  The mode
parameter indicates what we want to do; for the moment it is the
same as al0_enum()'s mode parameter, and is used to determine how
much `set-up' we have to do.  (The order in which this setting-up
is done is *important*, since there are dependencies between the
various components.)  The style parameter for the call will be
built from the values of rfactor1/cfactor1.  Several other of the
Level 0 parameters are `aliased', to enable us to set them
`conveniently'.  The return value is either a Level 1 error (ie, <=
-8192), or is that returned by _enum() (ie, > -8192).

-8192 disallowed mode
-8193 memory problem
-8194 table too small

Note: this routine (& all of Level 1) is written to be as general-
purpose as possible.  In particular, it is *not* assumed that it
will be driven by the Level 2 interactive interface.  So some of
the code may seem unnecessary, or needlessly complicated.

Warning: this wrapper routine prevents some of the more obvious
`errors' that may occur when continuing/redoing enumerations.
However, it cannot pick up all such errors; either be very careful,
or use the Level 2 interactive interface.  It is the caller's
responsibility to ensure that call sequences are valid!

Warning: this routine may invalidate the current table, without
explicitly noting this fact.  You *must* check the return value,
and only `believe' the table if this is >= -259 (ie, if the
enumerator is called and if it does something ok)!
******************************************************************/

int al1_start(int mode)
  {
  int i, style;

  if (mode < 0 || mode > 2)
    { return(-8192); }

  /* If the mode is start or redo, then we have a (possibly) new or
  (possibly) expanded (ie, *additional* relators/generators) presentation;
  we have to do all the setup associated with the relator and generator
  lists.  If the mode is continue, we simply fall through. */

  if (mode == 0 || mode == 2)
    {
    /* If asis if false, then we freely/cyclically reduce the relators and
    freely reduce the generators.  (This may introduce (additional) empty
    and/or duplicate words.)  We then remove any empty words, irrespective
    of the value of asis; duplicates are not (currently) removed.  If asis
    is false, we sort both lists.  We *always* (re)set ndrel & nsgpg, since
    it is not incumbent on a caller of _start() to set (& reset) these
    correctly, and the length of the lists may have changed anyway!

    Note: we do *not* do any Tietze transformations, thus we are not free
    to do, for example, xx --> 1 if x is an involution. */

    if (!asis)
      {
      al1_freered(rellst);
      al1_freered(genlst);
      al1_cycred(rellst);
      }

    al1_remempt(rellst);
    al1_remempt(genlst);

    if (!asis)
      {
      al1_sort(rellst);
      al1_sort(genlst);
      }

    if (rellst == NULL)
      { ndrel = 0; }
    else
      { ndrel = rellst->len; }
    if (genlst == NULL)
      { nsgpg = 0; }
    else
      { nsgpg = genlst->len; }
    }

  /* If we're in start mode, we need to build a list of which generators
  are to be *treated* as involutions & do a column allocation (possibly
  changing this list).  These are *fixed* over a run (incl any redos), even
  if later relators / values of asis would have changed it! */

  if (mode == 0)
    {
    if (!al1_chkinvol())
      { return(-8193); }
    if (!al1_cols())
      { return(-8193); }
    }

  /* If we're in start mode, then we have to build the empty table.
  Although coset numbers are limited to 2G, the workspace can exceed the
  32-bit limit; hence the messing around with floating-point to find the
  max number of cosets given the number of columns.  Note the extra
  rounding down by 1 (for safety), and that coset #0 dne.  Note the error
  if there's not enough memory for at least 2 rows. */

  if (mode == 0)
    {
    tabsiz =
      (int)(((double)workspace*(double)workmult)/(double)ncol) -1 -1;
    if (tabsiz < 2)
      { return(-8194); }

    if (colptr != NULL)
      { free(colptr); }
    if ((colptr = (int **)malloc((ncol + 1)*sizeof(int *))) == NULL)
      {
      tabsiz = 0;
      maxrow = 1;
      return(-8193);
      }

    /* We now chop up our block of memory into (tabsiz+1)-sized chunks, one
    for each column of the table.  Whether or not this is the best way to
    do things in moot (cf, caching).  Recall that coset #0 is unused, and
    note the (IP27/R10000) 64-bit addressing kludge! */

    colptr[0] = NULL;
    for (i = 1; i <= ncol; i++)
      { colptr[i] = costable + (long)(i-1)*(long)(tabsiz+1); }
    col1ptr = colptr[1];
    col2ptr = colptr[2];
    }

  /* In start/redo mode, we now have to (re)build the data structures
  associated with the relators & generators. */

  if (mode == 0 || mode == 2)
    {
    /* The values in geninv have now been decided, and will be frozen for
    this run.  We now go through the relators/generators and change X to x
    if x is to be *treated* as an involution. */

    al1_xtox();

    /* Calculate the total length of the relators & generators, and their
    correct exponents. */

    al1_getlen();
    al1_getexp();

    /* Build the doubled-up list of relators. */

    if (!al1_setrel())
      { return(-8193); }

    /* Build the list of generators. */

    if (!al1_setgen())
      { return(-8193); }

    /* Build the edp's. */

    if (!al1_bldedp())
      { return(-8193); }

    /* Change relator/generator lists to column-based form. */

    al1_transl();
    }

  /* Having now done all the mode-specific setup, we embark on setting-up
  those Level 0 parameters which are aliased at Level 1 (ie, those which
  are not set *directly* by the user).  We *assume* that the caller hasn't
  done anything stupid, and try to honour the parameters requested.  This
  may be automatic, involve changing the enumerator's state on the fly,
  cause an error return, or be silently ignored ... */

  /* Pd's are not preserved between calls, but we may need to honour a new
  value of pdsiz.  Values <=0 translate to the default of 256 and >0 is
  honoured.  It is up to the caller to ensure that pdsiz1 is a power of 2 &
  is >=2. We don't bother malloc'ing if we already have enough memory.
  Note that pdsiz is initialised to 0, so we are guaranteed to allocate
  list space the first time through. */

  toppd = botpd = 0;

  if (pdsiz1 <= 0)
    { pdsiz1 = 256; }

  if (pdsiz1 < pdsiz)
    { pdsiz = pdsiz1; }
  else if (pdsiz1 == pdsiz)
    { ; }
  else
    {
    if (pdqrow != NULL)
      { free(pdqrow); }
    if (pdqcol != NULL)
      { free(pdqcol); }
    if ( (pdqcol = (int *)malloc(pdsiz1*sizeof(int))) == NULL ||
         (pdqrow = (int *)malloc(pdsiz1*sizeof(int))) == NULL )
      {
      pdsiz = 0;
      return(-8193);
      }

    pdsiz = pdsiz1;
    }

  /* A fill factor request of <= 0 picks up the default, anything else
  is honoured.  Levels 1/2 use ffactor1, which is always integral, so we
  need to convert to float; in general, we can convert (int)<->(float)
  without any problems, since ffactor1 is a `small' integer. */

  if (ffactor1 <= 0)
    {
    ffactor1 = 0;
    ffactor = (float)((int)((5*(ncol + 2))/4));
    }
  else
    { ffactor = (float)ffactor1; }

  /* Deductions *may* be preserved betweens calls; we need to be careful to
  preserve them if we're in continue mode, but we are free to empty the
  stack in start/redo mode (if we choose).  We honour size increases using
  realloc (which acts like malloc if the existing pointer is null); this
  preserves the stack, in the absence of allocation errors.  We honour size
  reductions simply by changing dedsiz, but we take care to note if we have
  to discard any deductions.  dedsiz <=0 means the `smallish' default of
  1000, and >0 is honoured.  Comments similar to those for pdsiz1 apply. */

  if (dedsiz1 <= 0)
    { dedsiz1 = 1000; }

  if (dedsiz1 < dedsiz)
    {
    if (topded >= dedsiz1)  /* We've lost some deductions */
      {
      topded = dedsiz1-1;
      disded = TRUE;
      }
    dedsiz = dedsiz1;
    }
  else if (dedsiz1 == dedsiz)
    { ; }
  else
    {
    if ( (dedrow = (int *)realloc(dedrow, dedsiz1*sizeof(int))) == NULL ||
         (dedcol = (int *)realloc(dedcol, dedsiz1*sizeof(int))) == NULL )
      {
      if (topded >= 0)
        { disded = TRUE; }
      topded = -1;
      dedsiz = 0;
      return(-8193);
      }

    dedsiz = dedsiz1;
    }

  /* If nrinsgp1 <0 or nrinsgp >ndrel, then the default is to use all the
  relators.  Otherwise the request is honoured. */

  if (nrinsgp1 < 0 || nrinsgp1 > ndrel)
    {
    nrinsgp1 = -1;
    nrinsgp = ndrel;
    }
  else
    { nrinsgp = nrinsgp1; }

  /* If maxrow1 <= 1, or >= the number of rows allowed by the allocated
  memory, then maxrow defaults to the allocated memory size; else if it's
  >= the current value of maxrow, then the request is honoured.  Otherwise,
  the request is honoured in start mode, and is honoured in redo &
  continue modes *provided* that it is at least as large as nextdf; it not,
  it's (re)set to nextdf-1 (here, maxrow >= 2, so we're OK as regards
  always allowing at least 2 rows in the table).  Note that maxrow1 is
  initialised to 0 & nextdf to 2, so we're ok the first time through. */

  if (maxrow1 <= 1 || maxrow1 >= tabsiz)
    {
    maxrow1 = 0;
    maxrow = tabsiz;
    }
  else if (maxrow1 >= maxrow)
    { maxrow = maxrow1; }
  else
    {
    /* Note: 1 < maxrow1 < tabsiz and maxrow1 < maxrow */
    if (mode == 0)    /* start mode */
      { maxrow = maxrow1; }
    else     /* redo/continue modes */
      {
      if (maxrow1 >= nextdf)
        { maxrow = maxrow1; }
      else
        /* Note: 2 <= maxrow1 < nextdf <= maxrow+1 <= tabsiz+1 */
        { maxrow = nextdf-1; }   /* (re)set to CT size */
      }
    }

  /* Pick up the required style & set the blocking factors. */

  if (rfactor1 < 0)
    {
    if (cfactor1 < 0)    /* R/C-style */
      {
      rfactor = -rfactor1;
      cfactor = -cfactor1;
      style   = 0;
      }
    else if (cfactor1 == 0)   /* R*-style */
      {
      rfactor = -rfactor1;
      cfactor = 0;
      style   = 1;
      }
    else     /* Cr-style */
      {
      rfactor = -rfactor1;
      cfactor = cfactor1;
      style   = 2;
      }
    }
  else if (rfactor1 == 0)
    {
    if (cfactor1 < 0)    /* C*-style */
      {
      /* C* is not yet implemented.  For the moment, just use C-style. */

      rfactor = 0;
      cfactor = -cfactor1;
      style   = 5;    /* ! */
      }
    else if (cfactor1 == 0)   /* R/C-style (defaulted) */
      {
      /* R/C-style with defaulted parameters, which try to `balance' the
      R- & C-style activity.  We set C-style to 1000 definitions, and
      assume that 1 in 2 of the positions in a relator yield a definition,
      hence the 2000 (ie, 2x1000).  Note the care to prevent rfactor=0, as
      we're doing integer divisions.  If there are no relators, we'll
      simply fill the columns of each row, hence the 1000/ncol. */

      if (ndrel == 0)
        { rfactor = 1 + 1000/ncol; }
      else
        { rfactor = 1 + 2000/(1 + trellen); }
      cfactor = 1000;
      style   = 0;    /* Nota bene! */
      }
    else     /* C-style */
      {
      rfactor = 0;
      cfactor = cfactor1;
      style   = 5;
      }
    }
  else
    {
    if (cfactor1 < 0)    /* Rc-style */
      {
      rfactor = rfactor1;
      cfactor = -cfactor1;
      style   = 6;
      }
    else if (cfactor1 == 0)   /* R-style */
      {
      rfactor = rfactor1;
      cfactor = 0;
      style   = 7;
      }
    else     /* CR-style */
      {
      rfactor = rfactor1;
      cfactor = cfactor1;
      style   = 8;
      }
    }

  /* And away we go ... */

  if (msgctrl)    /* normal message control */
    { al1_prtdetails(1); }

  /* Warning: DTT code */
  /*
  fprintf(fop, "DTT: mode = %d & style = %d\n", mode, style);
  */

  i = al0_enum(mode,style);

  return i;
  }

quality92%

¤ Dauer der Verarbeitung: 0.6 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.