Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma


products/sources/formale Sprachen/C/Firefox/dom/webidl/ (Browser von der Mozilla Stiftung Version 136.0.1^©) Datei vom 10.2.2025 mit Größe 521 B

Quelle trmetab.c Sprache: unbekannt

/****************************************************************************
**
**    trmetab.c                       NQ                       Werner Nickel
**                                         nickel@mathematik.tu-darmstadt.de
*/

#include "nq.h"
#include "engel.h"
#include "glimt.h"

static int NrWords = 0;
static int TrMetAb = 0;

static void Error(word v, word w) {
printf("Overflow in collector computing [ ");
printWord(v, 'a');
printWord(w, 'a');
printf(" ]\n");
}

static void eval8Power(word u) {
word  uu;
int   needed;

/*    printf( "eval8Power() called with : " );
    printWord( u, 'A' );
    putchar( '\n' );
*/
uu = Exponentiate(u, 8);
needed = addRow(ExpVecWord(uu));

if (needed) {
  printf("# (");
  printWord(u, 'A');
  printf(")^8\n");
}
free(uu);
}

static void evalTrMetAbRel(word *ul) {
word    u, uu, vv;
long    i, needed;

/*      printf( "evalTrMetAbRel() called with : " );
        for( i = 0; i < 6; i++ ) {
            printWord( ul[i], 'A' ); printf( "    " );
        }
        putchar( '\n' );
*/
NrWords++;
/* Calculate [ [ ul[0], ul[1] ], ul[2] ] */
if ((u = Commutator(ul[0], ul[1])) == (word)0) {
  Error(ul[0], ul[1]);
  return;
}
if ((uu = Commutator(u, ul[2])) == (word)0) {
  Error(u, ul[2]);
  return;
}
free(u);
/* Calculate [ [ ul[3], ul[4] ], ul[5] ] */
if ((u = Commutator(ul[3], ul[4])) == (word)0) {
  Error(ul[3], ul[4]);
  return;
}
if ((vv = Commutator(u, ul[5])) == (word)0) {
  Error(u, ul[5]);
  return;
}
free(u);

u = Commutator(uu, vv);
free(uu);
free(vv);

needed = addRow(ExpVecWord(u));
if (needed) {
  printf("# [ [");
  for (i = 0; i < 3; i++) {
   printWord(ul[i], 'A');
   if (i != 2) printf(",");
  }
  printf("], [");
  for (i = 3; i < 6; i++) {
   printWord(ul[i], 'A');
   if (i != 5) printf(",");
  }
  printf("] ]\n");
}

free(u);
}

static void buildTuple(word *ul, long i, gen g, long wt, long which) {
long    save_wt;
word    u;

if (wt == 0 && which == 5 && i > 0) {
  eval8Power(ul[5]);
}

if (wt == 0 && which == 0 && i > 0) {
  evalTrMetAbRel(ul);
  return;
}

if (i > 0 && which > 0) buildTuple(ul, 0, 1, wt, which - 1);

if (g > NrPcGens) return;

save_wt = wt;
u = ul[ which ];
while (!EarlyStop && g <= NrPcGens && Wt(g) <= wt) {
  u[i].g   = g;
  u[i].e   = (expo)0;
  u[i + 1].g = EOW;
  while (!EarlyStop && Wt(g) <= wt) {
   u[i].e++;
   if (Exponent[g] > (expo)0 && Exponent[g] == u[i].e) break;
   wt -= Wt(g);
   buildTuple(ul, i + 1, g + 1, wt, which);
   /* now build the same word with negative exponent */
   if (!EarlyStop && !SemigroupOnly && Exponent[g] == (expo)0) {
    u[i].g *= -1;
    buildTuple(ul, i + 1, g + 1, wt, which);
    u[i].g *= -1;
   }
  }
  wt = save_wt;
  g++;
}
u[i].g = EOW;
u[i].e = (expo)0;
if (EarlyStop || SemigroupOnly || !SemigroupFirst) return;

while (!EarlyStop && g <= NrPcGens && Wt(g) <= wt) {
  u[i].g   = -g;
  u[i].e   = (expo)0;
  u[i + 1].g = EOW;
  while (!EarlyStop && Wt(g) <= wt) {
   u[i].e++;
   if (Exponent[g] > (expo)0 && Exponent[g] == u[i].e) break;
   wt -= Wt(g);
   buildTuple(ul, i + 1, g + 1, wt, which);
   if (EarlyStop) return;
   /* now build the same word with negative exponent */
   if (!EarlyStop && !SemigroupOnly && Exponent[g] == (expo)0) {
    u[i].g *= -1;
    buildTuple(ul, i + 1, g + 1, wt, which);
    u[i].g *= -1;
   }
  }
  wt = save_wt;
  g++;
}
u[i].g = EOW;
u[i].e = (expo)0;
}

void EvalTrMetAb(void) {

word u, ul[6];
int i, c;

if (!TrMetAb) return;

for (i = 0; i < 6; i++)
  ul[i] = (word)Allocate((NrPcGens + NrCenGens + 1) * sizeof(gpower));

u = ul[0];
for (i = 1; i <= NrCenGens; i++) {
  u[0].g = i;
  u[0].e = (expo)1;
  u[1].g = EOW;
  u[1].e = (expo)0;
  eval8Power(u);
}

for (c = 2; !EarlyStop && c <= Class + 1; c++) {
  for (i = 0; i < 6; i++) {
   ul[i][0].g = EOW;
   ul[i][0].e = (expo)0;
  }
  NrWords = 0;
  if (Verbose)
   printf("# Checking tuples of words of weight %d\n", c);
  buildTuple(ul, 0, 1, c, 5);
  if (Verbose) printf("# Checked %d words.\n", NrWords);
}

for (i = 0; i < 6; i++)
  free(ul[i]);
}

void InitTrMetAb(int t) {
TrMetAb = t;
}

quality99%