SSL central_auts.c Sprache: C

/****************************************************************************
**
*A  central_auts.c              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
**
*/

#include "pq_defs.h"
#include "pcp_vars.h"
#include "pga_vars.h"
#include "pq_functions.h"

/* determine which of the central outer automorphisms of the immediate
   descendant are required for iteration purposes; set up those
   which are necessary in the array central, which is returned */

int ***central_automorphisms(struct pga_vars *pga, struct pcp_vars *pcp)
{
   register int *y = y_address;

   int ***central = 0;
   int **commutator; /* result of commutator calculations */
   char **redundant; /* automorphisms which are not required */
   Logical found;
   register int gamma = 0;
   register int i, j, k;
   register int u, v;

   /* number of generators of last class in group */
   int x = y[pcp->clend + pcp->cc - 1] - y[pcp->clend + pcp->cc - 2];
   register int nmr_columns;

   /* dummy variable -- not used in this routine but
      required for echelonise_matrix call */
   /*
     int *subset;
     subset = allocate_vector (x, 0, 0);
     echelonise_matrix (commutator, x, nmr_columns, pcp->p, subset, pga);
     free_vector (subset, 0);
     */

   /* maximum number of central outer automorphisms */
   nmr_columns = pga->nmr_centrals = pga->ndgen * pga->s;

   commutator = commutator_matrix(pga, pcp);
   if (pga->print_commutator_matrix) {
      printf("The commutator matrix is \n");
      print_matrix(commutator, x, nmr_columns);
   }

   reduce_matrix(commutator, x, nmr_columns, pcp->p, pga);

   redundant = allocate_char_matrix(pga->ndgen, pga->s, 0, TRUE);
   for (i = 0; i < x; ++i) {
      found = FALSE;
      j = 0;
      while (j < nmr_columns && !(found = (commutator[i][j] == 1)))
         ++j;
      if (found) {
         u = j / pga->s;
         v = j % pga->s;
         redundant[u][v] = TRUE;
         --pga->nmr_centrals;
      }
   }

   /* set up, in the array central, all necessary automorphisms of the form
      u --> u * (pcp->ccbeg + v)
      k --> k
      where both u and k are defining generators, k distinct from u,
      and v runs from 0 to pga->s - 1 */

   if (pga->nmr_centrals != 0) {
      central = allocate_array(pga->nmr_centrals, pga->ndgen, pcp->lastg, TRUE);

      for (u = 0; u < pga->ndgen; ++u) {
         for (v = 0; v < pga->s; ++v) {
            if (redundant[u][v] == FALSE) {
               ++gamma;
               for (k = 0; k < pga->ndgen; ++k) {
                  central[gamma][k + 1][k + 1] = 1;
                  if (k == u)
                     central[gamma][k + 1][pcp->ccbeg + v] = 1;
               }
            }
         }
      }
   }

   free_matrix(commutator, x, 0);
   free_char_matrix(redundant, pga->ndgen);

   return central;
}

/* for each of the x generators of highest class - 1, look up
   its commutator with each of the pga->ndgen defining generators;
   set up the exponents of the pga->s new generators which occur
   in the commutator as part of a row of an
   x by pga->ndgen * pga->s matrix, commutator, which is returned */

int **commutator_matrix(struct pga_vars *pga, struct pcp_vars *pcp)
{
   register int *y = y_address;

   /* first and last generator of last class of parent */
   int first = y[pcp->clend + pcp->cc - 2] + 1;
   int last = y[pcp->clend + pcp->cc - 1];

   int x = last - first + 1;
   int **commutator;
   int *result;
   int pointer, value, entry, length;
   int offset;
   int u, v;
   register int i, j, k;
#include "access.h"

#ifdef CARANTI
   commutator = allocate_matrix(x, pga->ndgen * pga->s, 0, TRUE);
   return commutator;
#else
   commutator = allocate_matrix(x, pga->ndgen * pga->s, 0, FALSE);
#endif

   for (i = first; i <= last; ++i) {

      offset = 0;

      for (j = 1; j <= pga->ndgen; ++j) {

         /* store the result of [i, j] */
         result = allocate_vector(pga->s, 0, 1);

         if (i != j) {

            if (i < j) {
               u = i;
               v = j;
            } else {
               u = j;
               v = i;
            }

            /* look up the value of [v, u] */
            pointer = y[pcp->ppcomm + v];
            entry = y[pointer + u];
            if (entry > 0)
               result[entry - pcp->ccbeg] = 1;
            else if (entry < 0) {
               length = y[-entry + 1];
               for (k = 1; k <= length; ++k) {
                  value = y[-entry + 1 + k];
                  result[FIELD2(value) - pcp->ccbeg] = FIELD1(value);
               }
            }

            /* since, we want the value of [i, j], we may now
               need to invert [v, u] */
            if (j == v) {
               for (k = 0; k < pga->s; ++k)
                  if (result[k] != 0)
                     result[k] = (pga->p - result[k]) % pga->p;
            }
         }

         /* now copy the result to commutator */
         for (k = 0; k < pga->s; ++k)
            commutator[i - first][k + offset] = result[k];
         offset += pga->s;

         free_vector(result, 0);
      }
   }

   return commutator;
}

quality86%

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