Quelle isom_options.c Sprache: C

/****************************************************************************
**
*A  isom_options.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 "constants.h"
#include "pq_defs.h"
#include "pretty_filterfns.h"
#include "standard.h"
#include "menus.h"
#include "pcp_vars.h"
#include "pga_vars.h"
#include "pq_functions.h"
#include "word_types.h"

#if defined(GROUP)
#if defined(STANDARD_PCP)

static Logical setup_start_info(Logical identity_map,
                                Logical status,
                                FILE *file,
                                int format,
                                struct pga_vars *pga,
                                struct pcp_vars *pcp);
static Logical compare_sequences(int *s, int *t, int length);

static char FileBuffer[1024];

static void copy_file(const char *from, const char *to)
{
   FILE *in;
   FILE *out;
   int n;

   in = fopen(from, "r");
   if (in == NULL) {
      perror(from);
      exit(FAILURE);
   }
   out = fopen(to, "w");
   if (out == NULL) {
      perror(to);
      exit(FAILURE);
   }
   do {
      n = fread(FileBuffer, 1, 1024, in);
      if (0 < n)
         fwrite(FileBuffer, 1, n, out);
      if (ferror(in)) {
         perror(from);
         exit(FAILURE);
      }
      if (ferror(out)) {
         perror(to);
         exit(FAILURE);
      }
   } while (!feof(in));
   fclose(in);
   fclose(out);
}

static void append_file(const char *from, const char *to)
{
   FILE *in;
   FILE *out;
   int n;

   in = fopen(from, "r");
   if (in == NULL) {
      perror(from);
      exit(FAILURE);
   }
   out = fopen(to, "a");
   if (out == NULL) {
      perror(to);
      exit(FAILURE);
   }
   do {
      n = fread(FileBuffer, 1, 1024, in);
      if (0 < n)
         fwrite(FileBuffer, 1, n, out);
      if (ferror(in)) {
         perror(from);
         exit(FAILURE);
      }
      if (ferror(out)) {
         perror(to);
         exit(FAILURE);
      }
   } while (!feof(in));
   fclose(in);
   fclose(out);
}

#define ISOM_OPTION 8
#define MAXOPTION 9 /* maximum number of menu options */

void list_isom_menu(void);

/* control routine for computing standard presentation */

void isom_options(int format, struct pcp_vars *pcp)
{
   register int *y = y_address;

   FILE *Status = 0;
   FILE *FileName = 0;
   FILE *Subgroup = 0;

   struct pga_vars pga;

   Logical user_supplied = FALSE;
   Logical group_present = FALSE;
   Logical identity_map;
   Logical finished;
   Logical valid;
   Logical equal;

   int output = DEFAULT_STANDARD_PRINT;
   int start_class, final_class;
   int option;
   int t;
   int status;
   int complete;
   int iteration;
   int *seq1;
   int *seq2;
   int len1, len2;
   int nmr_items;
   int ***auts;
   int x_dim, y_dim;
   FILE *GAP_library = 0;
   char *name = 0;
   int nmr_of_exponents;

   StandardPresentation = TRUE;
   pga.nmr_soluble = 0;

   list_isom_menu();

   do {
      option = read_option(MAXOPTION);
      switch (option) {

      case -1:
         list_isom_menu();
         break;

      case START_INFO:
         t = runTime();
         group_present = setup_start_info(FALSE, 0, stdin, format, &pga, pcp);
         handle_error(group_present);
         user_supplied = TRUE;
         t = runTime() - t;
         /* it is possible that the p-quotient is trivial */
         if (pcp->cc == 0) {
            group_present = FALSE;
            break;
         }
         printf("Class %d %d-quotient and its %d-covering group computed in "
                "%.2f seconds\n",
                pcp->cc - 1,
                pcp->p,
                pcp->p,
                t * CLK_SCALE);
         break;

      case CONSTRUCT:
         if (!user_supplied) {
            name = GetString("Enter input file name for group information: ");
            FileName = OpenFile(name, "r");
            if (FileName == NULL)
               break;
         }

         name = GetString("Enter output file name for group information: ");

         read_value(
             TRUE, "Standardise presentation to what class? ", &final_class, 0);
         if (user_supplied && final_class < pcp->cc) {
            printf("Value supplied for end class must be at least %d\n",
                   pcp->cc);
         }

         /* read in data from file and set up group to end of start_class
            and compute its p-covering group */

         if (!user_supplied) {
            group_present =
                setup_start_info(FALSE, 0, FileName, FILE_INPUT, &pga, pcp);
            handle_error(group_present);
            if (final_class < pcp->cc) {
               CloseFile(FileName);
               printf("Value supplied for end class must be at least %d\n",
                      pcp->cc);
            }
         }

         if (pcp->cc == 0) {
            printf("%d-quotient is trivial\n", pcp->p);
            break;
         }

         complete = (pcp->newgen == 0) ? TERMINAL : CAPABLE;
         iteration = 0;

         for (start_class = pcp->cc;
              start_class <= final_class && complete != TERMINAL;
              ++start_class) {

            t = runTime();

            identity_map = FALSE;
            Subgroup = OpenFile("ISOM_Subgroup", "w");

            do {
               ++iteration;
               set_defaults(&pga);
               /*
                 pga.space_efficient = TRUE;
                 */

               /* either prompt for information or read it from file */
               if (user_supplied) {
                  auts = read_auts(STANDARDISE, &pga.m, &nmr_of_exponents, pcp);
                  pga.fixed = 0;
                  query_solubility(&pga);
                  user_supplied = FALSE;
#ifdef HAVE_GMP
                  autgp_order(&pga, pcp);
#endif
               } else {
                  auts = read_auts_from_file(FileName, &pga.m, pcp);
                  nmr_items = fscanf(FileName, "%d", &pga.fixed);
                  verify_read(nmr_items, 1);
                  nmr_items = fscanf(FileName, "%d", &pga.soluble);
                  verify_read(nmr_items, 1);

#ifdef HAVE_GMP
                  fscanf(FileName, "\n");
                  mpz_init(&pga.aut_order);
                  mpz_inp_str(&pga.aut_order, FileName, 10);
#endif
                  CloseFile(FileName);
               }
               x_dim = pga.m;
               y_dim = pcp->lastg;

               /* construct standard presentation relative to smallest
                  permissible characteristic subgroup in p-multiplicator */

               standard_presentation(&identity_map, output, auts, &pga, pcp);

               free_array(auts, x_dim, y_dim, 1);

               /* was the characteristic subgroup chosen in this iteration
                  the whole of the p-multiplicator? */

               Status = OpenFile("ISOM_Status", "r");
               fscanf(Status, "%d", &status);
               fscanf(Status, "%d", &complete);
               CloseFile(Status);

               /* have we finished the construction? */
               finished =
                   (status == END_OF_CLASS &&
                    (start_class == final_class || complete == TERMINAL));

               /* organise to write modified presentation + automorphisms
                  to file ISOM_PP */

               if (!identity_map || finished) {
                  copy_file("ISOM_present", "ISOM_PP");
                  append_file("ISOM_NextClass", "ISOM_PP");
               } else
                  copy_file("ISOM_NextClass", "ISOM_PP");

               if (finished)
                  break;

               /* if necessary, set up new presentation + other information */
               FileName = OpenFile("ISOM_PP", "r");
               group_present = setup_start_info(
                   identity_map, status, FileName, FILE_INPUT, &pga, pcp);

               handle_error(group_present);

               /* if appropriate, factor subgroup from p-multiplicator */
               if (status != END_OF_CLASS)
                  factor_subgroup(pcp);

               /* reinitialise pga structure */
               initialise_pga(&pga, pcp);
               pga.m = 0;
               pga.ndgen = y[pcp->clend + 1];
               set_values(&pga, pcp);

            } while (status != END_OF_CLASS && complete != TERMINAL);

            CloseFile(Subgroup);

            /* the group may have completed only when relations are enforced;
               this is an attempt to determine this case */
            if (pga.nuclear_rank != 0 && pcp->complete)
               break;

            t = runTime() - t;
            printf("Computing standard presentation for class %d took %.2f "
                   "seconds\n",
                   start_class,
                   t * CLK_SCALE);
         }

         /* we currently may have presentation for p-covering group;
            or is the starting group terminal? if so, we may want to
            use last_class to revert to group presentation */

         if (!user_supplied && iteration == 0 && !pcp->complete)
            last_class(pcp);

         /* is the group terminal? */
         if (complete == TERMINAL)
            printf("The largest %d-quotient of the group has class %d\n",
                   pcp->p,
                   pcp->cc);

         if (iteration == 0)
            break;

         /* rename file ISOM_PP containing iteration info to nominated file */
         rename("ISOM_PP", name);

         break;

      case PRINT_PCP:
         if (group_present)
            print_presentation(TRUE, pcp);
         break;

      case SAVE_PRES:
         name = GetString("Enter output file name: ");
         FileName = OpenFileOutput(name);
         if (group_present && FileName != NULL) {
            save_pcp(FileName, pcp);
            CloseFile(FileName);
            printf("Presentation written to file\n");
         }
         break;

      case COMPARE:
         valid = get_description(
             "Enter file name storing first presentation: ", &len1, &seq1, pcp);
         if (!valid)
            break;
         valid =
             get_description("Enter file name storing second presentation: ",
                             &len2,
                             &seq2,
                             pcp);

         if (!valid)
            break;
         equal = (len1 == len2) ? compare_sequences(seq1, seq2, len1) : FALSE;

         printf("Identical presentations? %s\n",
                equal == TRUE ? "True" : "False");
         free_vector(seq1, 1);
         free_vector(seq2, 1);
         break;

      case STANDARD_PRINT_LEVEL:
         read_value(
             TRUE, "Input print level for construction (0-2): ", &output, 0);
         /* allow user to supply same max print level as for
            p-quotient calculations */
         if (output == MAX_STANDARD_PRINT + 1)
            --output;
         if (output > MAX_STANDARD_PRINT) {
            printf("Print level must lie between %d and %d\n",
                   MIN_STANDARD_PRINT,
                   MAX_STANDARD_PRINT);
            output = DEFAULT_STANDARD_PRINT;
         }
         break;

      case PQ_MENU:
         options(ISOM_MENU, format, pcp);
         break;

      case ISOM_OPTION:
         assert(name);
         FileName = OpenFile(name, "r");
         group_present =
             setup_start_info(FALSE, 0, FileName, FILE_INPUT, &pga, pcp);
         pcp->multiplicator_rank = pcp->lastg - y[pcp->clend + pcp->cc - 1];
         last_class(pcp);
         auts = read_auts_from_file(FileName, &pga.m, pcp);
         nmr_items = fscanf(FileName, "%d", &pga.fixed);
         verify_read(nmr_items, 1);
         nmr_items = fscanf(FileName, "%d", &pga.soluble);
         verify_read(nmr_items, 1);

         printf("Images of user-supplied generators are listed last below\n");
         print_map(pcp);
#ifdef HAVE_GMP
         fscanf(FileName, "\n");
         mpz_init(&pga.aut_order);
         mpz_inp_str(&pga.aut_order, FileName, 10);
#endif
         CloseFile(FileName);
         GAP_library = OpenFile("GAP_library", "a+");
         write_GAP_library(GAP_library, pcp);
         pga.nmr_centrals = pga.m;
         pga.nmr_stabilisers = 0;

         GAP_auts(GAP_library, auts, auts, &pga, pcp);
         CloseFile(GAP_library);
         printf("Presentation listing images of user-supplied generators "
                "written to GAP_library\n");
         break;

      case EXIT:
      case MAXOPTION:
         unlink("ISOM_present");
         unlink("ISOM_Subgroup");
         unlink("ISOM_cover_file");
         unlink("ISOM_group_file");
         unlink("ISOM_XX");
         unlink("ISOM_NextClass");
         unlink("ISOM_Status");
         printf("Exiting from ANU p-Quotient Program\n");
         break;

      } /* switch */
   } while (option != 0 && option != MAXOPTION);
}

/* list available menu options */

void list_isom_menu(void)
{
   printf("\nStandard Presentation Menu\n");
   printf("-----------------------------\n");
   printf("%d. Supply start information\n", START_INFO);
   printf("%d. Compute standard presentation to supplied class\n", CONSTRUCT);
   printf("%d. Save presentation to file\n", SAVE_PRES);
   printf("%d. Display presentation\n", PRINT_PCP);
   printf("%d. Set print level for construction\n", STANDARD_PRINT_LEVEL);
   printf("%d. Compare two presentations stored in files\n", COMPARE);
   printf("%d. Call basic menu for p-Quotient program\n", PQ_MENU);
   printf("%d. Compute the isomorphism\n", ISOM_OPTION);
   printf("%d. Exit from program\n", MAXOPTION);
}

/* set up the group to the desired class and its p-covering group;
   identity_map indicates whether standard automorphism applied
   was the identity; status indicates whether we are end of class;
   the presentation is read from file using indicated format */

static Logical setup_start_info(Logical identity_map,
                                Logical status,
                                FILE *file,
                                int format,
                                struct pga_vars *pga,
                                struct pcp_vars *pcp)
{
   register int *y = y_address;

   FILE *FileName;
   FILE *presentation_file;
   Logical group_present = FALSE;
   int exit_value;
   int *list, *head;
   int i;

#if defined(TIME)
   int t;
   t = runTime();
#endif

   if (!identity_map) {

      /* we must recompute the presentation since generators and
         relations have been altered by applying the standard map */

      /* memory leak September 1996 */
      if (user_gen_name != NULL) {
         num_gens = user_gen_name[0].first;

         for (i = 1; i <= num_gens; ++i) {
            free_vector(user_gen_name[i].g, 0);
         }
         free(user_gen_name);
         user_gen_name = NULL;
         free_vector(inv_of, 0);
         free_vector(pairnumber, 0);
      }

      exit_value = pquotient(0, 0, file, format, pcp);
      if (exit_value == SUCCESS)
         group_present = TRUE;

#if defined(TIME)
      printf("Time to recompute pcp is %.2f\n", (runTime() - t) * CLK_SCALE);
#endif

   } else {
      /* generators and relations of presentation have not changed --
         we can restore presentation for either full p-covering group
         or class c + 1 quotient */
      if (status == END_OF_CLASS)
         presentation_file = OpenFile("ISOM_group_file", "r");
      else
         presentation_file = OpenFile("ISOM_cover_file", "r");

      restore_pcp(presentation_file, pcp);
      CloseFile(presentation_file);
      group_present = TRUE;
   }

#if defined(DEBUG)
   pcp->diagn = TRUE;
   printf("The modified presentation is \n");
   print_presentation(TRUE, pcp);
   pcp->diagn = FALSE;
#endif

   if (!group_present || pcp->cc == 0)
      return group_present;

   /* do we need to compute the full p-covering group? */

   if (!identity_map || status == END_OF_CLASS) {
      pcp->multiplicator = TRUE;
      next_class(FALSE, &head, &list, pcp);

      pga->exponent_law = pcp->extra_relations;
      pga->metabelian = pcp->metabelian;
      enforce_laws(pga, pga, pcp);

      pcp->multiplicator = FALSE;
      FileName = OpenFile("ISOM_cover_file", "w");
      save_pcp(FileName, pcp);
      CloseFile(FileName);
   }

   initialise_pga(pga, pcp);
   pga->m = 0;
   pga->ndgen = y[pcp->clend + 1];
   set_values(pga, pcp);

   return group_present;
}

/* factor subgroup whose generators are listed in Subgroup file
   from p-multiplicator to give reduced p-multiplicator */

void factor_subgroup(struct pcp_vars *pcp)
{
   register int *y = y_address;

   FILE *Subgroup;
   int flag;
   int cp;
   int i;

   Subgroup = fopen("ISOM_Subgroup", "r");

   if (Subgroup == (FILE *)NULL)
      return;

   while (!feof(Subgroup)) {

      if (fscanf(Subgroup, "%d", &flag) == -1)
         continue;

      /* should we eliminate (in order to renumber the generators)? */
      if (flag == ELIMINATE)
         eliminate(FALSE, pcp);

      if (fscanf(Subgroup, "%d", &flag) == -1)
         continue;

      setup_symbols(pcp);
      cp = pcp->lused;
      setup_word_to_collect(Subgroup, PRETTY, WORD, cp, pcp);

      for (i = 1; i <= pcp->lastg; ++i)
         y[cp + pcp->lastg + i] = 0;

      echelon(pcp);
   }
   CloseFile(Subgroup);
}

void handle_error(Logical group_present)
{
   if (group_present == FALSE) {
      printf("Error in Standard Presentation Program\n");
      exit(FAILURE);
   }
}

/* compare two sequences, s and t, of length length */

static Logical compare_sequences(int *s, int *t, int length)
{
   /* TODO: Replace this by memcmp? */
   register int i;
   Logical equal = TRUE;

   for (i = 1; i <= length && (equal = (s[i] == t[i])); ++i)
      ;

   return equal;
}

/* read group from file and set up its compact description
   as sequence seq of length len */

int get_description(char *string, int *len, int **seq, struct pcp_vars *pcp)
{
   char *name;
   FILE *file;

   name = GetString(string);
   file = OpenFile(name, "r");
   if (file == NULL) {
      if (isatty(0))
         return FALSE;
      else
         exit(FAILURE);
   }

   restore_pcp(file, pcp);
   CloseFile(file);

   /* length of sequence */
   *len = choose(pcp->lastg + 1, 3);

   /* sequence of exponents */
   *seq = compact_description(FALSE, pcp);

   return TRUE;
}

#endif
#endif

quality89%

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