void restore_automorphisms(FILE *ifp, int **head, int **list, struct pcp_vars *pcp) { int new_index = 0; int offset; register int alpha; int nmr_saved; int list_length; int retain; int nmr_items; nmr_items = fread(&nmr_saved, sizeof(int), 1, ifp); verify_read(nmr_items, 1); nmr_items = fread(&list_length, sizeof(int), 1, ifp); verify_read(nmr_items, 1); *head = allocate_vector(nmr_saved * pcp->m + 1, 0, FALSE); (*head)[0] = nmr_saved; *list = allocate_vector(list_length + 1, 0, FALSE); (*list)[0] = list_length; retain = MIN(pcp->lastg, nmr_saved); for (alpha = 1; alpha <= pcp->m; ++alpha) { offset = (alpha - 1) * retain; restore_auts(ifp, offset, nmr_saved, retain, &new_index, *head, *list); } (*head)[0] = retain; printf("Automorphisms read from file\n"); }
int restore_auts(FILE *ifp, int offset, int nmr_saved, int retain, int *new_index, int *head, int *list) { int alpha_length; /* length of the automorphism description */ int i, add; int nmr_items; nmr_items = fread(head + offset + 1, sizeof(int), nmr_saved, ifp); verify_read(nmr_items, nmr_saved); add = *new_index - head[offset + 1]; for (i = 1; i <= nmr_saved; ++i) head[offset + i] += add; nmr_items = fread(&alpha_length, sizeof(int), 1, ifp); verify_read(nmr_items, 1); nmr_items = fread(list + *new_index + 1, sizeof(int), alpha_length, ifp); verify_read(nmr_items, alpha_length); *new_index = head[offset + retain] + list[head[offset + retain] + 1] + 1; return alpha_length; }
void read_value (Logical newline, char *string, int *value, int lower_bound) { char response[MAXWORD]; Logical error; Logical reading = TRUE; int nmr_items; while (reading) { printf ("%s", string); nmr_items = scanf ("%s", response); verify_read (nmr_items, 1); /* read past any comments */ while (response[0] == COMMENT) { read_line (); nmr_items = scanf ("%s", response); verify_read (nmr_items, 1); } if (!isatty (0)) printf ("%s ", response); if (!isatty (0) && newline) printf ("\n"); *value = string_to_int (response, &error); if (error) printf ("Error in input -- must be integer only\n"); else if ((reading = (*value < lower_bound))) printf ("Error: supplied value must be at least %d\n", lower_bound); } }
char* GetString (char *string) { int nmr_items; char *s = (char *) malloc (MAXIDENT * sizeof (char)); printf ("%s", string); nmr_items = scanf ("%s", s); verify_read (nmr_items, 1); while (s[0] == COMMENT) { read_line (); nmr_items = scanf ("%s", s); verify_read (nmr_items, 1); } if (!isatty (0)) printf ("%s\n", s); return s; }
void save_auts(FILE *ofp, int *head, int *list, struct pcp_vars *pcp) { register int alpha; register int offset; register int required_offset; register int prev = 0; register int m = pcp->m; register int required_ptr, stored_ptr; int required_length, stored_length; register int original, diff; register int j; int list_length; int retain; int nmr_items; int *copy_head; /* the action on more than lastg generators may be stored in list; if this is the case, establish how many entries from the array list must be stored in order to retain the description of the automorphisms on lastg generators */ original = head[0]; if (head[0] > pcp->lastg) { copy_head = allocate_vector(pcp->lastg * m + 1, 0, FALSE); list_length = 0; retain = pcp->lastg; diff = 0; for (alpha = 1; alpha <= m; ++alpha) { offset = (alpha - 1) * original; required_offset = (alpha - 1) * retain; for (j = 1; j <= retain; ++j) copy_head[required_offset + j] = head[offset + j] - diff; required_ptr = head[offset + retain]; stored_ptr = head[offset + original]; stored_length = stored_ptr + list[stored_ptr + 1] + 1 - prev; required_length = required_ptr + list[required_ptr + 1] + 1 - prev; diff += stored_length - required_length; list_length += required_length; prev += stored_length; } } else { copy_head = head; retain = head[0]; list_length = list[0]; } prev = 0; nmr_items = fwrite(&retain, sizeof(int), 1, ofp); verify_read(nmr_items, 1); nmr_items = fwrite(&list_length, sizeof(int), 1, ofp); verify_read(nmr_items, 1); for (alpha = 1; alpha <= m; ++alpha) { offset = (alpha - 1) * original; required_offset = (alpha - 1) * retain; nmr_items = fwrite(copy_head + required_offset + 1, sizeof(int), retain, ofp); verify_read(nmr_items, retain); required_ptr = head[offset + retain]; stored_ptr = head[offset + original]; stored_length = stored_ptr + list[stored_ptr + 1] + 1 - prev; required_length = required_ptr + list[required_ptr + 1] + 1 - prev; nmr_items = fwrite(&required_length, sizeof(int), 1, ofp); verify_read(nmr_items, 1); nmr_items = fwrite(list + prev + 1, sizeof(int), required_length, ofp); verify_read(nmr_items, required_length); prev += stored_length; } if (original != retain) free_vector(copy_head, 0); RESET(ofp); }
void isom_options (int format, struct pcp_vars *pcp) { register int *y = y_address; FILE *Status; FILE *FileName; FILE *Subgroup; 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; char *name; 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: 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); }