Quelle read_word.c Sprache: C

/****************************************************************************
**
*A  read_word.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 "constants.h"
#include "pq_functions.h"
#include "pretty_filterfns.h"
#include "word_types.h"

static void setup_relation(int disp,
                           int length,
                           int type,
                           Logical commutator,
                           int *t,
                           struct pcp_vars *pcp);
static int check_for_commutator(char *s);
static int check_for_symbol(char *s);
static int string_to_integer(char *s, int *integer);

/* display the appropriate input message */
static void display_message(int type)
{
   switch (type) {
   case LHS:
      printf("Input left-hand side of relation:\n");
      break;

   case RHS:
      printf("Input right-hand side of relation:\n");
      break;

   case WORD:
      printf("Input the word for collection:\n");
      printf("(use generators x1,x2,... and terminate with a semicolon)\n");
      break;

   case VALUE_A:
      printf("Input the value of a:\n");
      printf("(use generators x1,x2,... and terminate with a semicolon)\n");
      break;

   case VALUE_B:
      printf("Input the value of b:\n");
      break;

   case FIRST_ENTRY:
      printf("Input the first component of commutator:\n");
      break;

   case NEXT_ENTRY:
      printf("Input the next component of commutator:\n");
      break;
   case ACTION:
      break;
   }
}

/* set up array of generators x1, x2, .., xlastg and their
   inverses to represent the pcp generators of the group;
   this permits words to be input using the pretty format */

void setup_symbols(struct pcp_vars *pcp)
{
   int i, j, k, m;
   int log, digit;

   /* space for this array may have been previously allocated */
   /* 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);
   }

   paired_gens = pcp->lastg;
   num_gens = 2 * paired_gens;
   user_gen_name = anu_valloc(word, num_gens + 1);
   inv_of = anu_valloc(gen_type, num_gens + 1);
   pairnumber = anu_valloc(int, num_gens + 1);

   /* memory leak September 1996 */
   user_gen_name[0].first = num_gens;

   for (i = 1; i <= paired_gens; i++) {
      j = i;
      word_init(user_gen_name + 2 * i - 1);
      word_init(user_gen_name + 2 * i);
      word_put_last(user_gen_name + 2 * i - 1, 'x');
      word_put_last(user_gen_name + 2 * i, 'x');
      /* extract the digits of the number, i, from left to right */
      log = log10((double)j);
      for (k = log; k >= 0; --k) {
         m = int_power(10, k);
         digit = j / m;
         word_put_last(user_gen_name + 2 * i - 1, digit + '0');
         word_put_last(user_gen_name + 2 * i, digit + '0');
         j %= m;
      }
      word_put_last(user_gen_name + 2 * i, '^');
      word_put_last(user_gen_name + 2 * i, '-');
      word_put_last(user_gen_name + 2 * i, '1');
      inv_of[2 * i - 1] = 2 * i;
      inv_of[2 * i] = 2 * i - 1;
      pairnumber[2 * i] = pairnumber[2 * i - 1] = i;
   }
}

/* read in a word using the basic format;
   type determines the message printed out;
   store the word with address ptr which has value lused + 1 + disp;
   y[ptr] is the length of the word (includes exponent);

   if the word is one side of a relation, and it is a commutator,
   then y[ptr] is the negative of the length, as this allows
   collect_relations to recognise that this word is a commutator;

   y[ptr + 1] is the exponent;

   y[ptr + 2] .. y[ptr + length] are generators (either defining or pcp)
   or their inverses */

void read_word(FILE *file, int disp, int type, struct pcp_vars *pcp)
{
   Logical finish = FALSE;
   Logical commutator = FALSE;
   char s[MAXWORD];
   int t[MAXWORD];
   int integer, temp;
   int length = 0;
   int nmr_items;

   display_message(type);

   while (!finish && (nmr_items = fscanf(file, "%s", s)) != EOF) {

      verify_read(nmr_items, 1);

      while (s[0] == COMMENT) {
         read_line();
         nmr_items = fscanf(file, "%s", s);
         verify_read(nmr_items, 1);
      }

      /* check for end of relation marker */
      if (check_for_symbol(s))
         finish = TRUE;

      /* check for commutator symbol */
      if (!commutator)
         commutator = check_for_commutator(s);

      /* convert string to integer */
      integer = 0;
      temp = string_to_integer(s, &integer);

      if (integer == 0 && !(commutator || finish || *s == ',')) {
         printf("Error in input data -- %s\n", s);
         if (!isatty(0))
            exit(FAILURE);
      }

      if (integer != 0) {
         if ((length == 0 && temp == 0) || temp != 0) {
            t[length] = temp;
            ++length;
         }
      }
   }

   setup_relation(disp, length, type, commutator, t, pcp);
}

/* read word using pretty format */

void pretty_read_word(FILE *file, int disp, int type, struct pcp_vars *pcp)
{
   register int *y = y_address;

   int ptr = pcp->lused + 1 + disp;
   word w1, w2, w3;
   gen_type g;
   int i, exp;
   int length;

   if (file == stdin)
      display_message(type);

   word_init(&w1);
   word_init(&w2);
   word_init(&w3);
   read_next_word(&w1, file);
   find_char(';', file);
   word2prog_word(&w1, &w2);
   word_factor(&w2, &w3, &exp);

   y[ptr] = length = 0;
   y[ptr + 1] = exp;
   while (word_delget_first(&w3, &g))
      if (g != 0)
         y[ptr + 1 + (++length)] =
             (g <= inv(g)) ? pairnumber[g] : -pairnumber[g];
   word_clear(&w1);
   word_clear(&w2);
   word_clear(&w3);

   if (length != 0)
      y[ptr] = ++length;

   if (file != stdin)
      return;

   printf("The input word is ");
   for (i = 1; i <= length; ++i)
      printf("%d ", y[ptr + i]);
   printf("\n");
}

/* process the input word and set it up as an entry in y */

static void setup_relation(int disp,
                           int length,
                           int type,
                           Logical commutator,
                           int *t,
                           struct pcp_vars *pcp)
{
   register int *y = y_address;

   register int i;
   int u[MAXWORD];
   register int total;
   register int ptr;
   Logical commutator_relation;

   /* currently, only a commutator which is one side of a
      relation is not expanded -- this may be changed later */
   commutator_relation = (commutator && (type == LHS || type == RHS));

   /* is the word trivial? */
   if (t[0] == 0 || length == 1) {
      length = 1;
      ptr = pcp->lused + 1 + disp;
      y[ptr + 1] = 0;
   } else {
      /* set up relation */
      for (i = 1; i < MAXWORD; ++i)
         u[i] = 0;
      u[0] = t[1];

      if (length >= MAXWORD) {
         text(18, 0, 0, 0, 0);
         exit(FAILURE);
      }

      if (commutator_relation || !commutator)
         for (i = 1; i < length - 1; ++i)
            u[i] = t[i + 1];
      else {
         for (i = 2; i < length; ++i)
            expand_commutator(u, t[i]);
      }

      /* check how much space is required to store the word in y */
      total = 2;
      while (u[total] != 0)
         ++total;

      /* the length of the relation is total */
      if (total >= MAXWORD) {
         text(18, 0, 0, 0, 0);
         exit(FAILURE);
      }

      /* is there enough room in array y to store the word? */
      if (is_space_exhausted(total, pcp))
         return;

      ptr = pcp->lused + 1 + disp;

      /* copy expanded word and set up as relation stored in y */
      y[ptr + 1] = t[0];
      length = 0;
      while (u[length] != 0) {
         y[ptr + 2 + length] = u[length];
         ++length;
      }
      ++length;
   }

   /* set up the length */
   if (commutator_relation)
      y[ptr] = -length;
   else
      y[ptr] = length;

   PRINT("The input word is ");
   PRINT("%d ", y[ptr + 1]);
   if (commutator_relation)
      PRINT("[ ");
   for (i = 2; i <= length; ++i)
      PRINT("%d ", y[ptr + i]);
   if (commutator_relation)
      PRINT("]");
   PRINT("\n");
}

/* check whether relation is a commutator */

static int check_for_commutator(char *s)
{
   int not_found = 0;
   register int length = strlen(s);

   while (length > 0 && (not_found = (s[length - 1] != LHS_COMMUTATOR &&
                                      s[length - 1] != RHS_COMMUTATOR)))
      --length;

   return !not_found;
}

/* check for occurrence of END_OF_WORD in word */

static int check_for_symbol(char *s)
{
   int not_found = 0;
   register int length = strlen(s);

   while (length > 0 && (not_found = (s[length - 1] != END_OF_WORD)))
      --length;

   return !not_found;
}

/* convert string s to integer */

static int string_to_integer(char *s, int *integer)
{
   int i, n, sign;

   for (i = 0; isspace(s[i]); i++) /* skip white space */
      ;
   sign = (s[i] == '-') ? -1 : 1;
   if (s[i] == '+' || s[i] == '-') /* skip sign */
      i++;
   for (n = 0; s[i] != '\0'; i++) {
      if (isdigit(s[i])) {
         *integer = 1;
         n = 10 * n + (s[i] - '0');
      }
   }

   return sign * n;
}

quality92%

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