/*************************************** * * * Copyright (c) 1998 Jean-Eric Pin * * All rights reserved. * * * * TAB = 2 spaces * * * ***************************************/ /*------------------------------------------------------------------- * Sortie.c Jean-Eric Pin 07/12/96 *------------------------------------------------------------------- */ #include <stdlib.h> #include <stdio.h> #include "Globales.h" #include "Main.h" #include "Initialisation.h" #include "DclassesIteratif.h" #include "Inverses.h" #include "Reduction.h" #include "Syntactique.h" #include "Zero.h" #include "Sortie.h" extern unsigned long Periode, Seuil, CalculsEffectues; extern unsigned short NbEtats, NbLettres, NbChiffresNbElements, LongueurMax, TypeCalcul, TypeSemigroupe, PossedeUnZero, PossedeUnNeutre; extern unsigned long NbElements, NbIdempotents, nZero, DernierMot; extern element *Generateurs, *TableDesValeurs; extern info *Table; extern info2 *Table2; extern unsigned long *TableIdempotents; /* La table des idempotents */ extern Sortie_ SortieElement; extern char **Messages; extern infoSommet **Graphe; /* Le graphe syntactique */ extern ListeNumero *Inverses, *InversesFaibles; /**************************************************** * * Sortie du semianneau. OK * ****************************************************/ void SortieSemiAnneauZst(void) { printf("%s%ld, %ld}\n", Messages[M_Semiring], Seuil, Periode); /* Le semianneau est Z_{s, t} */ } /**************************************************** * * Sortie des generateurs. OK * ****************************************************/ void SortieGenerateurs(void) { lettre a; printf("%s\n", Messages[M_Generators]); /* Generateurs : \n */ for (a = 0; a < NbLettres; a++) { printf("%c |", a + 97); SortieElement(Generateurs[a]); } printf("\n"); } /**************************************************** * * Sortie d'un mot non vide. OK * ****************************************************/ void SortieMotNonVide(unsigned long n) { if (n != IDENTITE) { SortieMotNonVide(Table[n].Prefixe); printf("%1c",Table[n].Finale + 97); } } /**************************************************** * * Sortie du mot vide. OK * ****************************************************/ void SortieMotVide(void) { printf("1"); } /**************************************************** * * Sortie d'un mot. OK * ****************************************************/ void SortieMot(unsigned long n) { (n == IDENTITE) ? SortieMotVide() : SortieMotNonVide(n); } /**************************************************** * * Sortie formatee d'un mot. OK * ****************************************************/ void SortieMotFormate(unsigned long n, unsigned short Longueur) { if (n == IDENTITE) printf("%*c1", LongueurMax,' '); else { printf("%*c", 1 + LongueurMax - Longueur,' '); SortieMotNonVide(n); } } /**************************************************** * * Sortie. OK * ****************************************************/ void SortieListeElements(void) { unsigned long n = IDENTITE; unsigned short Longueur = 0; printf(" %*c | ", LongueurMax + NbChiffresNbElements + 3, ' '); SortieElement(TableDesValeurs[IDENTITE]); switch (TypeSemigroupe) { case ParTransitions : case ParTransitionsPartielles : printf("%.*s\n", LongueurMax + NbChiffresNbElements + 8 + 3 * NbEtats, "----------------------------------------------------------------------------------------------------------------------------------"); break; case MatricesBooleennes: printf("%.*s\n", LongueurMax + NbChiffresNbElements + 8 + (3 * NbEtats + 1) * NbEtats, "-----------------------------------------------------------------------------------------------------------------------------"); break; case MatricesMaxPlus: case MatricesMinPlus: case MatricesMaxPlusTropicales : case MatricesMinPlusTropicales : case MatricesMaxPlusProjectives :case MatricesEntieres: printf("%.*s\n", LongueurMax + NbChiffresNbElements + 8 + (4 * NbEtats + 1) * NbEtats, "-----------------------------------------------------------------------------------------------------------------------------"); break; default: break; } if (PossedeUnNeutre) { if (CalculsEffectues & CALCUL_D_CLASSES) printf("*%c%*c1 %*c1 | ", (Table2[IDENTITE].Statut & EST_D_MINIMAL) ? 'M' : ' ', NbChiffresNbElements, ' ', LongueurMax, ' '); else printf("*%*c1 %*c1 | ", NbChiffresNbElements, ' ', LongueurMax, ' '); SortieElement(TableDesValeurs[IDENTITE]); for (n = IDENTITE; n != DernierMot; ) { n = Table[n].Suivant; Longueur = Table[n].Longueur; if (Table[n].Statut & IDEMPOTENT) printf("*"); else if (Table[n].Statut & DANS_UN_GROUPE) printf("G"); else if (Table[n].Statut & REGULIER) printf("R"); else printf(" "); if (CalculsEffectues & CALCUL_D_CLASSES) printf("%c", (Table2[n].Statut & EST_D_MINIMAL) ? 'M' : ' '); printf(" %*ld ", NbChiffresNbElements, n); SortieMotFormate(n, Longueur); printf(" | "); SortieElement(TableDesValeurs[n]); } } else for (n = IDENTITE; n != DernierMot; ) { n = Table[n].Suivant; Longueur = Table[n].Longueur; if (Table[n].Statut & IDEMPOTENT) printf("*"); else if (Table[n].Statut & DANS_UN_GROUPE) printf("G"); else if (Table[n].Statut & REGULIER) printf("R"); else printf(" "); if (CalculsEffectues & CALCUL_D_CLASSES) printf("%c", (Table2[n].Statut & EST_D_MINIMAL) ? 'M' : ' '); printf(" %*ld ", NbChiffresNbElements, n - 1); SortieMotFormate(n, Longueur); printf(" | "); SortieElement(TableDesValeurs[n]); } printf("\n"); } /**************************************************** * * Sortie de la liste des idempotents. OK * ****************************************************/ void SortieListeIdempotents(void) { unsigned long i; printf("E(S) = {"); for (i = 0; i < NbIdempotents; i++) { SortieMot(TableIdempotents[i]); printf(", "); } printf("\b\b}\n"); } /**************************************************** * * Sortie de K(S). OK * ****************************************************/ void SortieKS(void) { unsigned long u; printf("K(S) = {"); for (u = IDENTITE; u <= NbElements; u++) if (Table[u].Statut & EST_DANS_KS) { SortieMot(u); printf(", "); } printf("\b\b}\n"); } /**************************************************** * * Sortie de l'ideal minimal. OK * ****************************************************/ void SortieIdealMinimal(void) { unsigned long u; CalculDclasses(); printf("I = {"); for (u = IDENTITE; u <= NbElements; u++) if (Table2[u].Statut & EST_D_MINIMAL) { SortieMot(u); printf(", "); } printf("\b\b}\n"); } /**************************************************** * * Sortie des relations. OK * ****************************************************/ void SortieRelations(void) { lettre a; unsigned long n, u; if (!(CalculsEffectues & CALCUL_ZERO)) TesteZero(); printf("%s\n", Messages[M_Relations]); /* \nRelations : \n */ for (n = IDENTITE; n != 0; n = Table[n].Suivant) { if (n == nZero) { SortieMot(n); printf(" = 0\n"); } else for (a = 0; a < NbLettres; a++) { u = Table[n].Produits[a].D; if ((Table[Table[n].Suffixe].Produits[a].D & EST_REDUIT) && (!(u & EST_REDUIT))) { SortieMot(n); printf("%c = ", a + 97); if (u == nZero) printf("0"); else SortieMot(u); printf("\n"); } } } printf("\n"); } /**************************************************** * * Sortie des puissances omega. OK * ****************************************************/ void SortieOmega(void) { unsigned long n; for (n = IDENTITE; n <= NbElements; n++) { printf("("); SortieMot(n); printf(")^ = "); SortieMot(Table2[n].xOmega); printf("\n"); } } /**************************************************** * * Sortie du semigroupe local. OK * ****************************************************/ void SortieMonoideLocal(unsigned long e) { unsigned long n; printf("Local submonoid generated by e = \n"); SortieMot(e); printf("eSe = {"); for (n = IDENTITE; n <= NbElements; n++) { if ((~(Table[n].Statut) & (EST_DANS_IDEAL_DROIT | EST_DANS_IDEAL_GAUCHE)) == 0) /* Les 2 bits a 1 */ { SortieMot(n); printf(", "); } } printf("\b\b}\n"); } /**************************************************** * * Sortie Ideal droit. OK * ****************************************************/ void SortieIdealDroit(unsigned long u) { unsigned long n; printf("Right ideal generated by u = \n"); SortieMot(u); printf("uS^1 = {"); for (n = IDENTITE; n <= NbElements; n++) { if ((~Table[n].Statut & EST_DANS_IDEAL_DROIT) == 0) /* bit a 1 */ { SortieMot(n); printf(", "); } } printf("\b\b}\n"); } /**************************************************** * * Sortie Ideal gauche. OK * ****************************************************/ void SortieIdealGauche(unsigned long u) { unsigned long n; printf("Left ideal generated by u = \n"); SortieMot(u); printf("S^1u = {"); for (n = IDENTITE; n <= NbElements; n++) { if ((~Table[n].Statut & EST_DANS_IDEAL_GAUCHE) == 0) /* bit a 1 */ { SortieMot(n); printf(", "); } } printf("\b\b}\n"); } /**************************************************** * * Sortie du zero. OK * ****************************************************/ void SortieZero(void) { printf("\n"); if (PossedeUnZero) { SortieMot(nZero); printf(" = 0\n"); } else printf("%s\n", Messages[M_No_zero]); /* Pas de zero */ } /*************************************************************************** * * SortieSyntactique. Sortie du preordre syntactique. * ***************************************************************************/ void SortieSyntactique(void) { char compteur, c; unsigned long u, v; CalculSyntactique(); CalculSqueletteSyntactique(); printf("%s\n", Messages[M_SyntacticOrder]); /* Preordre syntactique de P: */ for (u = IDENTITE + !PossedeUnNeutre; u <= NbElements; u++) { compteur = 0; for (v = u + 1; v <= NbElements; v++) { c = Graphe[u][v].Label; if ((c & TRANSITIF) == 0) { c &= CHAR_TROIS; switch (c) { case CHAR_UN: SortieMot(v); printf(" < "); compteur++; SortieMot(u); printf(", "); break; case CHAR_DEUX: SortieMot(u); printf(" < "); compteur++; SortieMot(v); printf(", "); break; case CHAR_TROIS: SortieMot(u); printf(" = "); compteur++; SortieMot(v); printf(", "); break; } } } if (compteur != 0) printf("\n"); } } /*************************************************************************** * * SortieTableInverses. * ***************************************************************************/ void SortieTable(ListeNumero *Tableau, short Message) { unsigned long s; printf("%s\n", Messages[Message]); /* Inverses faibles */ for (s = IDENTITE + !PossedeUnNeutre; s <= NbElements; s++) SortieListe(s, Tableau[s]); } /*************************************************************************** * * SortieInverses. * ***************************************************************************/ void SortieInverses(void) { SortieTable(Inverses, M_Computation_Inverses); SortieTable(InversesFaibles, M_Computation_WeakInverses); } /*************************************************************************** * * SortieListe. Affiche la liste des inverses faibles de u. * ***************************************************************************/ void SortieListe(unsigned long s, ListeNumero Liste) { unsigned long compteur = 0; SortieMot(s); printf(" --> {"); while (Liste != NULL) { compteur++; SortieMot(Liste->t); printf(", "); Liste = Liste->suivant; } if (compteur != 0) printf("\b\b"); printf("}\n"); }