void interactive_pga(Logical group_present, FILE *StartFile, int group_nmr, int ***auts, struct pga_vars *pga, struct pcp_vars *pcp) { struct pga_vars flag; int option; Logical soluble_group = TRUE; FILE *OutputFile = 0; FILE *LINK_input = 0; char *StartName = 0; int t; int **perms = 0; int index; int **S = 0; int k; int K; int label; int *a = 0, *b = 0; char *c = 0; int *orbit_length = 0; int nmr_of_exponents; int *subset = 0; int alpha; int upper_step; int rep; int i; list_interactive_pga_menu(); do { option = read_option(MAX_INTERACTIVE_OPTION); switch (option) { case -1: list_interactive_pga_menu(); break; case SUPPLY_AUTS: auts = read_auts(PGA, &pga->m, &nmr_of_exponents, pcp); #ifdef HAVE_GMP autgp_order(pga, pcp); #endif pga->soluble = TRUE; start_group(&StartFile, auts, pga, pcp); break; case EXTEND_AUTS: extend_automorphisms(auts, pga->m, pcp); print_auts(pga->m, pcp->lastg, auts, pcp); break; case RESTORE_GP: StartName = GetString("Enter input file name: "); StartFile = OpenFileInput(StartName); if (StartFile != NULL) { read_value(TRUE, "Which group? ", &group_nmr, 0); auts = restore_group(TRUE, StartFile, group_nmr, pga, pcp); RESET(StartFile); } break; case DISPLAY_GP: print_presentation(FALSE, pcp); print_structure(1, pcp->lastg, pcp); print_pcp_relations(pcp); break; case SINGLE_STAGE: t = runTime(); if (group_present && pga->m == 0) start_group(&StartFile, auts, pga, pcp); assert(OutputFile); construct(1, &flag, SINGLE_STAGE, OutputFile, StartFile, 0, ALL, group_nmr, pga, pcp); t = runTime() - t; printf("Time for intermediate stage is %.2f seconds\n", t * CLK_SCALE); break; case DEGREE: read_step_size(pga, pcp); read_subgroup_rank(&k); query_exponent_law(pga); enforce_laws(pga, pga, pcp); extend_automorphisms(auts, pga->m, pcp); step_range(k, &pga->s, &upper_step, auts, pga, pcp); if (pga->s > upper_step) printf("Desired step size is invalid for current group\n"); else { if (pga->s < upper_step) { printf("The permitted relative step sizes range from %d to %d\n", pga->s, upper_step); read_value( TRUE, "Input the chosen relative step size: ", &pga->s, 0); } store_definition_sets(pga->r, pga->s, pga->s, pga); get_definition_sets(pga); pga->print_degree = TRUE; compute_degree(pga); pga->print_degree = FALSE; } break; case PERMUTATIONS: if (pga->Degree != 0) { t = runTime(); query_solubility(pga); pga->trace = FALSE; if (pga->soluble) query_space_efficiency(pga); else pga->space_efficient = FALSE; query_perm_information(pga); strip_identities(auts, pga, pcp); soluble_group = (pga->soluble || pga->Degree == 1 || pga->nmr_of_perms == 0); if (!soluble_group) { #if defined(GAP_LINK) StartGapFile(pga); #else #if defined(GAP_LINK_VIA_FILE) start_GAP_file(&LINK_input, auts, pga, pcp); #endif #endif } perms = permute_subgroups(LINK_input, &a, &b, &c, auts, pga, pcp); #if defined(GAP_LINK_VIA_FILE) if (!soluble_group) CloseFile(LINK_input); #endif t = runTime() - t; printf("Time to compute permutations is %.2f seconds\n", t * CLK_SCALE); } else printf("You must first select option %d\n", DEGREE); break; case ORBITS: orbit_option(option, perms, &a, &b, &c, &orbit_length, pga); break; case STABILISERS: case STABILISER: assert(perms); stabiliser_option( option, auts, perms, a, b, c, orbit_length, pga, pcp); /* free_space (pga->soluble, perms, orbit_length, a, b, c, pga); */ break; case MATRIX_TO_LABEL: S = allocate_matrix(pga->s, pga->q, 0, FALSE); subset = allocate_vector(pga->s, 0, FALSE); printf("Input the %d x %d subgroup matrix:\n", pga->s, pga->q); read_matrix(S, pga->s, pga->q); K = echelonise_matrix(S, pga->s, pga->q, pga->p, subset, pga); printf("The standard matrix is:\n"); print_matrix(S, pga->s, pga->q); printf("The label is %d\n", subgroup_to_label(S, K, subset, pga)); free_vector(subset, 0); break; case LABEL_TO_MATRIX: read_value(TRUE, "Input allowable subgroup label: ", &label, 1); S = label_to_subgroup(&index, &subset, label, pga); printf("The corresponding standard matrix is\n"); print_matrix(S, pga->s, pga->q); break; case IMAGE: t = runTime(); /* invert_automorphisms (auts, pga, pcp); print_auts (pga->m, pcp->lastg, auts, pcp); */ printf("Input the subgroup label and automorphism number: "); read_value(TRUE, "", &label, 1); read_value(FALSE, "", &alpha, 1); printf("Image is %d\n", find_image(label, auts[alpha], pga, pcp)); t = runTime() - t; printf("Computation time in seconds is %.2f\n", t * CLK_SCALE); break; case SUBGROUP_RANK: read_subgroup_rank(&k); printf("Closure of initial segment subgroup has rank %d\n", close_subgroup(k, auts, pga, pcp)); break; case ORBIT_REP: printf("Input label for subgroup: "); read_value(TRUE, "", &label, 1); rep = abs(a[label]); for (i = 1; i <= pga->nmr_orbits && pga->rep[i] != rep; ++i) ; printf("Subgroup with label %d has representative %d and is in orbit " "%d\n", label, rep, i); break; case COMPACT_DESCRIPTION: Compact_Description = TRUE; read_value(TRUE, "Lower bound for order (0 for all groups generated)? ", &Compact_Order, 0); break; case AUT_CLASSES: t = runTime(); permute_elements(); t = runTime() - t; printf("Time to compute orbits is %.2f seconds\n", t * CLK_SCALE); break; /* printf ("Input label: "); scanf ("%d", &l); process_complete_orbit (a, l, pga, pcp); break; case TEMP: printf ("Input label: "); scanf ("%d", &l); printf ("Input label: "); scanf ("%d", &u); for (i = l; i <= u; ++i) { x = IsValidAllowableSubgroup (i, pga); printf ("%d is %d\n", i, x); } StartName = GetString ("Enter output file name: "); OutputFile = OpenFileOutput (StartName); part_setup_reps (pga->rep, pga->nmr_orbits, orbit_length, perms, a, b, c, auts, OutputFile, OutputFile, pga, pcp); list_word (pga, pcp); read_value (TRUE, "Input the rank of the subgroup: ", &pga->q, 1); strip_identities (auts, pga, pcp); break; */ case EXIT: case MAX_INTERACTIVE_OPTION: printf("Exiting from interactive p-group generation menu\n"); break; } /* switch */ } while (option != 0 && option != MAX_INTERACTIVE_OPTION); #if defined(GAP_LINK) if (!soluble_group) QuitGap(); #endif }
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; }