Quelle setup.h Sprache: C

/****************************************************************************
**
*A  setup.h                     ANUPQ source                   Eamonn O'Brien
**
*Y  Copyright 1995-2001,  Lehrstuhl D fuer Mathematik,  RWTH Aachen,  Germany
*Y  Copyright 1995-2001,  School of Mathematical Sciences, ANU,     Australia
**
*/

/* in general pointers have the following format:
   if non-negative then they have that value; otherwise -pointer
   points to the base address of an exponent-generator string;
   these strings are made up of a header block consisting of a
   pointer and length followed by exponent-generator pair(s)
   stored in array y in the following format

   pointer   length   exp-gen   exp-gen    exp-gen   ...

   By default, the program has the following limits:
   the maximum no of pc generators is 2^16 - 1 = 65535;
   the maximum no of defining generators is 2^9 - 1 = 511;
   the maximum class is 2^6 - 1 = 63;
   the maximum exponent is 2^15 - 1;

   The program can be compiled in two modes; in fixed mode
   the above limits are enforced; in runtime mode, these are
   also the default; however, the limit on the number of defining
   generators and the class can be altered by the user via
   on-line options "-d" and "-c"; if such selections are made,
   the maximum number of pc generators is consequently altered;
   a user must decide the limit on *each* of the number of
   defining generators and the class;

   The default limits are set in the header files:
   storage_fixed.h (for the fixed version)
   runtime.h       (for the runtime version).

   If you wish to compile the runtime mode version, then set
   the RUN_TIME compiler flag in the Makefile.

   for i positive --
   y[pcp->dgen + i] is a pointer for defining generator i
   y[pcp->dgen + i] = j (positive) if defining generator i is not redundant
   and is assigned generator number j in pcp;
   y[pcp->dgen + i] = 0 if defining generator i is currently trivial;
   y[pcp->dgen + i] = -ptr if defining generator i is redundant
   where ptr is the base address for its value relative to y[0];

   for i negative --
   y[pcp->dgen + i] is a pointer for inverse of defining generator i;
   y[pcp->dgen + i] = 1 if inverse of defining generator i not needed;
   y[pcp->dgen + i] = 0 if inverse is needed and is currently trivial;
   y[pcp->dgen + i] = -ptr if inverse of defining generator is needed
   where ptr is the base address for its value relative to y[0];

   y[pcp->dgen + pcp->ndgen + i] contains the maximum number of
   occurrences of defining generator i in the structure of a
   pcp-generator or 0;

   y[pcp->relp + 2 * i - 1] is a pointer to lhs of defining relation i;
   y[pcp->relp + 2 * i] is a pointer to rhs of defining relation i;
   y[pcp->relp + 2 * i(-1)] = 0 if this side of relation is trivial,
   else y[pcp->relp + 2 * i(-1)] = ptr where ptr is the base address
   of this side of relation;

   a base address, ba say, of a value of a redundant defining
   generator, inverse of a defining generator, side of a defining
   relation, power or commutator table entry is such that
   y[ba] is the start of a header block of length 2;
   y[ba] contains a pointer, ptr say, which is the y-index of the
   cell referring to this value (that is, y[ptr] = -ba);
   y[ba + 1] contains the length of the following string
   (the string starting in y[ba + 2] and ending in y[ba + 1 + y[ba + 1]);

   when a string is no longer needed, y[ba] is set to 0 and y[ptr] is
   changed to point to its new value; when only 1 word is to be taken
   off of a string there is not a sufficient gap left to form a new
   2 word header block and this is overcome by forming a 1 word header
   block containing the value -1 (this is only needed for subroutine
   compact);

   allocation of storage in the array y is made in both directions;

   the following data is stored at the front of y
   1) y[pcp->clend + i] i = 0 .. MAXCLASS
   2) y[pcp->dgen + i]  i = -pcp->ndgen .. pcp->ndgen .. 2 * pcp->ndgen
   3) y[pcp->relp + i]  i = 1 .. 2 * pcp->ndrel
   4) the group defining relations (with only a 1 word header block
      containing the total length of the following exponent and side
      of a group defining relation);
   5) garbage collectable space (y[pcp->gspace] to y[pcp->lused])
      after initialisation the data 1) to 4) is stable in size;
      the garbage collectable space comprises strings of data with
      each string preceded by a header block; temporary storage is
      available in y[pcp->lused + 1] to y[pcp->subgrp] to do collections,
      assemble strings, etc;

   the following data is stored at the back of y
   1) subgroup information (y[pcp->subgrp + i])
   2) word information (y[pcp->words + i])
   3) structure information (y[structure + i])
   4) pointers to powers (y[pcp->ppower + i])
   5) pointers to pointers to commutators (y[pcp->ppcomm + i])
   6) pointers to commutators; to find the value of the commutator
      (b,a) say one looks up y[y[pcp->ppcomm + b] + a];

   the storage allocated for the data (3) to (6) changes at the
   beginning of each class (in subroutine setup), destroying the
   data (1) and (2);

   most storage allocation is checked via calls to is_space_exhausted */

quality84%

¤ Dauer der Verarbeitung: 0.16 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.