Quelle defaults_pga.c Sprache: C

/****************************************************************************
**
*A  defaults_pga.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 "constants.h"
#include "pq_functions.h"
#define SINGLE_STAGE 5

/* set up algorithm and print defaults for p-group generation calculation */

void defaults_pga(int option,
                  int *k,
                  struct pga_vars *flag,
                  struct pga_vars *pga,
                  struct pcp_vars *pcp)
{
   int default_algorithm;
   int default_output;
   int default_perm_info;
   int default_group_info;
   int default_orbit_info;
   int default_automorphism_info;

   set_defaults(flag);

   if (option == SINGLE_STAGE)
      read_step_size(pga, pcp);
   flag->step_size = pga->step_size;

   query_solubility(flag);

   read_value(
       TRUE, "Do you want default algorithm? ", &default_algorithm, INT_MIN);
   if (!default_algorithm) {
      read_subgroup_rank(k);
      if (flag->soluble)
         query_space_efficiency(flag);
      query_terminal(flag);
      query_exponent_law(flag);
      query_metabelian_law(flag);
   } else {
      *k = 0;
   }

   read_value(TRUE, "Do you want default output? ", &default_output, INT_MIN);
   if (default_output)
      return;

   read_value(TRUE,
              "Do you want default permutation group output? ",
              &default_perm_info,
              INT_MIN);
   if (!default_perm_info) {
      query_degree_aut_information(flag);
      query_perm_information(flag);
   }

   read_value(TRUE,
              "Do you want default orbit information? ",
              &default_orbit_info,
              INT_MIN);
   if (!default_orbit_info)
      query_orbit_information(flag);

   read_value(TRUE,
              "Do you want default group information? ",
              &default_group_info,
              INT_MIN);
   if (!default_group_info)
      query_group_information(pcp->p, flag);

   read_value(TRUE,
              "Do you want default automorphism group information? ",
              &default_automorphism_info,
              INT_MIN);
   if (!default_automorphism_info)
      query_aut_group_information(flag);

   read_value(TRUE,
              "Do you want algorithm trace information? ",
              &flag->trace,
              INT_MIN);
}

/* set printing and algorithm defaults up in flag structure for storage */

void set_defaults(struct pga_vars *flag)
{
   flag->print_extensions = FALSE;
   flag->print_automorphism_matrix = FALSE;

   flag->print_degree = FALSE;
   flag->print_permutation = FALSE;

   flag->print_subgroup = FALSE;
   flag->print_reduced_cover = FALSE;
   flag->print_group = FALSE;
   flag->print_nuclear_rank = FALSE;
   flag->print_multiplicator_rank = FALSE;

   flag->print_orbit_summary = FALSE;
   flag->print_orbits = FALSE;
   flag->print_orbit_arrays = FALSE;

   flag->print_commutator_matrix = FALSE;
   flag->print_automorphisms = FALSE;
   flag->print_automorphism_order = FALSE;
   flag->print_stabiliser_array = FALSE;

   flag->trace = FALSE;

   flag->space_efficient = FALSE;
   flag->soluble = TRUE;
   flag->terminal = FALSE;
   flag->metabelian = FALSE;
   flag->exponent_law = 0;
}

/* copy printing and algorithm defaults from flag structure to pga */

void copy_flags(struct pga_vars *flag, struct pga_vars *pga)
{
   pga->print_extensions = flag->print_extensions;
   pga->print_automorphism_matrix = flag->print_automorphism_matrix;

   pga->print_degree = flag->print_degree;
   pga->print_permutation = flag->print_permutation;

   pga->print_subgroup = flag->print_subgroup;
   pga->print_reduced_cover = flag->print_reduced_cover;
   pga->print_group = flag->print_group;
   pga->print_nuclear_rank = flag->print_nuclear_rank;
   pga->print_multiplicator_rank = flag->print_multiplicator_rank;

   pga->print_orbits = flag->print_orbits;
   pga->print_orbit_summary = flag->print_orbit_summary;
   pga->print_orbit_arrays = flag->print_orbit_arrays;

   pga->print_commutator_matrix = flag->print_commutator_matrix;
   pga->print_automorphisms = flag->print_automorphisms;
   pga->print_automorphism_order = flag->print_automorphism_order;
   pga->print_stabiliser_array = flag->print_stabiliser_array;

   pga->trace = flag->trace;

   pga->space_efficient = flag->space_efficient;
   pga->soluble = flag->soluble;
   pga->terminal = flag->terminal;
   pga->exponent_law = flag->exponent_law;
   pga->metabelian = flag->metabelian;

   pga->step_size = flag->step_size;
}

/* use space efficient option? */

void query_space_efficiency(struct pga_vars *pga)
{
   read_value(
       TRUE, "Space efficient computation? ", &pga->space_efficient, INT_MIN);
}

/* orbit information to be printed */

void query_orbit_information(struct pga_vars *pga)
{
   read_value(TRUE,
              "Summary of orbit information? ",
              &pga->print_orbit_summary,
              INT_MIN);

   read_value(
       TRUE, "Complete listing of orbits? ", &pga->print_orbits, INT_MIN);

   pga->print_orbit_arrays = FALSE;
}

/* group information to be printed */

void query_group_information(int p, struct pga_vars *pga)
{
   read_value(TRUE,
              "Print standard matrix of allowable subgroup? ",
              &pga->print_subgroup,
              INT_MIN);

   read_value(TRUE,
              "Presentation of reduced p-covering groups? ",
              &pga->print_reduced_cover,
              INT_MIN);

   read_value(TRUE,
              "Presentation of immediate descendants? ",
              &pga->print_group,
              INT_MIN);

   read_value(TRUE,
              "Print nuclear rank of descendants? ",
              &pga->print_nuclear_rank,
              INT_MIN);

   read_value(TRUE,
              "Print p-multiplicator rank of descendants? ",
              &pga->print_multiplicator_rank,
              INT_MIN);
}

/* automorphism group information to be printed */

void query_aut_group_information(struct pga_vars *pga)
{
   read_value(TRUE,
              "Print commutator matrix? ",
              &pga->print_commutator_matrix,
              INT_MIN);

   read_value(TRUE,
              "Automorphism group description of descendants? ",
              &pga->print_automorphisms,
              INT_MIN);

#ifdef HAVE_GMP
   read_value(TRUE,
              "Automorphism group order of descendants? ",
              &pga->print_automorphism_order,
              INT_MIN);
#else
   /* HACK: still ask the question, to prevent the GAP interface from
      getting "confused" (it blindly fires input at us, without checking
      what the prompt is). */
   int fake;
   read_value(TRUE,
              "PLACEHOLDER QUESTION (GMP disabled), input any integer? ",
              &fake,
              INT_MIN);
#endif

   pga->print_stabiliser_array = FALSE;
}

/* degree and extended automorphism information to be printed */

void query_degree_aut_information(struct pga_vars *pga)
{
   read_value(TRUE,
              "Print degree of permutation group? ",
              &pga->print_degree,
              INT_MIN);

   read_value(
       TRUE, "Print extended automorphisms? ", &pga->print_extensions, INT_MIN);
}

/* other permutation group information to be printed */

void query_perm_information(struct pga_vars *pga)
{
   read_value(TRUE,
              "Print automorphism matrices? ",
              &pga->print_automorphism_matrix,
              INT_MIN);

   read_value(TRUE, "Print permutations? ", &pga->print_permutation, INT_MIN);
}

/* read step size */

void read_step_size(struct pga_vars *pga, struct pcp_vars *pcp)
{
   Logical reading = TRUE;

   while (reading) {
      read_value(TRUE, "Input step size: ", &pga->step_size, 1);
      reading = (pga->step_size <= 0);
      if (isatty(0))
         reading = (reading || (pga->step_size > pcp->newgen));
      if (reading)
         printf("Error: step sizes range from 1 to %d only\n", pcp->newgen);
      /*
        if (reading = (pga->step_size <= 0 || pga->step_size > pcp->newgen))
        printf ("Error: step sizes range from 1 to %d only\n", pcp->newgen);
        */
   }
}

/* read class bound */

void read_class_bound(int *class_bound, struct pcp_vars *pcp)
{
   read_value(TRUE, "Input class bound on descendants: ", class_bound, pcp->cc);
}

/* read order bound */

void read_order_bound(int *order_bound, struct pcp_vars *pcp)
{
   register int *y = y_address;

   int least_order = y[pcp->clend + pcp->cc - 1] + 1;
   read_value(
       TRUE, "Input order bound on descendants: ", order_bound, least_order);
}

/* read rank of initial-segment subgroup */

void read_subgroup_rank(int *k)
{
   read_value(TRUE, "Rank of the initial segment subgroup? ", k, 0);
   *k = MAX(0, *k - 1);
}

/* supply a PAG-generating sequence for automorphism group? */

void query_solubility(struct pga_vars *pga)
{
   read_value(TRUE,
              "PAG-generating sequence for automorphism group? ",
              &pga->soluble,
              INT_MIN);
}

/* completely process all (capable and terminal) descendants? */

void query_terminal(struct pga_vars *pga)
{
   read_value(TRUE,
              "Completely process terminal descendants? ",
              &pga->terminal,
              INT_MIN);
}

/* set exponent law for all descendants to satisfy */

void query_exponent_law(struct pga_vars *pga)
{
   read_value(
       TRUE, "Input exponent law (0 if none): ", &pga->exponent_law, INT_MIN);
}

/* enforce metabelian law on all descendants */

void query_metabelian_law(struct pga_vars *pga)
{
   read_value(TRUE, "Enforce metabelian law? ", &pga->metabelian, INT_MIN);
}

quality94%

¤ 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.