Fonctions de génération aléatoire
Fonctions sur chaînes de caractères
> Un Z-algorithme est un ensemble de modules parallèles dont le premier est principal et les autres sont soient des actions composées soient des fonctions .
> La communication entre les modules se fait via les paramètres et/ou les variables globales.
> Les objets globaux sont définis dans le module principal.
> Le langage permet tout type de paramètres : scalaires, structures, file, vecteur, ..., et mêmes les types complexes.
> Le langage Z admet les modules récursifs.
> Le langage permet l'allocation dynamique de tableaux et de structures.
> Le langage permet l'affectation globale de tout type.
> Quatre types standards (scalaires) sont autorisés : ENTIER, BOOLEEN, CARACTERE, CHAINE.
> Certaines fonctions usuelles sont prédéfinies : MOD, MIN, MAX et EXP .
> Le langage est l'ensemble des algorithmes abstraits, écrits à base de modèles ou machines abstraites.
> On définit ainsi des machines abstraites sur
- les structures ou objets composés
- les vecteurs
- les listes mono directionnelles
- les listes bidirectionnelles
- les piles
- les files d'attente
- les arbres de recherche binaire
- les arbres de recherche m-aire
- les fichiers
> Le langage permet les types composés du genre PILE de FILES de LISTES ... dont la dernière est de type scalaire ou structure simple.
> Le langage peut être étendu avec d'autres machines abstraites dans les futures versions.
> Le langage est doté des opérations de haut niveau permettant de construire des listes, des arbres, des files, ... à partir d'un ensemble de valeurs ( expressions entières )
> Le langage offre deux fonctions très utiles permettant de générer aléatoirement des chaînes de caractères (ALEACHAINE ) et des entiers (ALEANOMBRE ).
> Le langage offre également deux fonctions pour la manipulation des chaînes de caractères (LONGCHAINE et CARACT ).
> Le langage permet la lecture et l'écriture de scalaires, de vecteurs de n'importe quelle dimension et des structures simples ou complexes.
> Le format d'écriture est libre.
SOIENT
Objets locaux et globaux
Annonce des modules
DEBUT
Instructions
FIN
Module 1
Module 2
...
Modules n
Chaque module est soit une action composée soit une fonction.
La boucle TANTQUE
TANTQUE Exp[ : ]
Instructions
FINTANTQUE
La boucle POUR
POUR V : = Exp1, Exp2 [,Exp3] [ : ]
Instructions
FINPOUR
Exp3 désigne l'incrément du pas. Par défaut, sa valeur est 1.
La conditionnelle
SI Exp [ : ]
Instructions
FINSI
L'alternative
SI Exp [ : ]
Instructions
SINON
Instructions
FINSI
Affectation
V := Exp
Affecte la valeur d'une expression à une variable.
Lecture
LIRE ( V1, V2, .... )
Introduit des données dans les variables V1, V2,...
Ecriture
ECRIRE ( Exp1, Exp2, ... )
Restitue les expressions Exp1, Exp2,....
(Expressions entières ou chaînes de caractères)
Quatre types standards sont autorisés : ENTIER, CARACTERE, CHAINE, BOOLEEN.
Définition des scalaires
[SOIT/SOIENT] <li> Sep Type
<Li> : Liste d'identificateurs séparés par des virgules.
Sep dans { :, UN, UNE, DES }
Type est un type standard.
Exemples
A, B, Trouv : BOOLEENS ;
X, Y, Z DES BOOLEENS ;
A : ENTIERS ;
X, Y, Z DES CHAINES ;
On définit des variables de type "Pointeur" pour la manipulation des structures de données.
[SOIT/SOIENT] <li> Sep
POINTEUR VERS [sep] [ DE Typec DE Typec DE ....] [ DE Types]
<Li> : Liste d'identificateurs séparés par des virgules.
Sep dans { :, UN, UNE, DES }
Typec dans { vecteur, pile, liste, file, pile, arb, listebi, arm }
Types est un scalaire ou une structure simple.
Remarque
On peut s'en passer de ce type. En effet, les déclarations
"Soit L une liste" et
"soit L un pointeur vers une liste" sont équivalentes.
Exemples
P1 : POINTEUR VERS LISTE DE PILE;
P2, P2 DES POINTEURS VERS DES ARB;
Comme dans les langages de programmation.
Expressions arithmétiques : + , - , / , *
Expressions logiques : ET, OU, NON
Expressions sur chaînes de caractères : +
Expressions relationnelles : <, <=, >, >=, =, <> (ou #)
Constantes logiques : VRAI, FAUX
Constante pointeur : NIL
Exemples
B+C / F
NON Trouv
(X # 5) ET NON TROUV
F(X) <> 5
P = Nil
Les commentaires peuvent être insérés dans tout endroit oŚ on peut avoir un blanc.
Les commentaires sont entre { et } ou entre /* et */.
Elles permettent de remplir une structure de données (ou initialiser une machine) à partir d'un ensemble d'expressions.
INIT_VECT ( T, [Exp1, Exp2, ....] )
INIT_STRUCT ( S, [Exp1, Exp2, ....] )
CREER_LISTE ( L, [Exp1, Exp2, ....] )
CREER_LISTEBI ( LB, [Exp1, Exp2, ....] )
CREER_ARB ( A, [Exp1, Exp2, ....] )
CREER_ARM ( M, [Exp1, Exp2, ....] )
CREER_FILE ( F, [Exp1, Exp2, ....] )
CREER_PILE ( P, [Exp1, Exp2, ....] )
Exp1, Exp2, .... sont des expressions scalaires ou des structures simples.
Exemple
CREER_LISTE ( L, [12, 34, I, I+J, 45] )
Crée la liste linéaire chaînée L avec les valeurs entre crochets dans l'ordre indiqué.
MOD (A, B)
Reste de la division entière de A par B.
MAX(A, B)
Maximum entre A et B.
MIN(A, B)
Minimum entre A et B.
EXP(A, B)
A exposant B
Fonctions de génération aléatoire
ALEACHAINE ( N )
Fournit une chaîne aléatoire de N caractères parmi les caractères alphabétiques majuscule et minuscule.
ALEAENTIER ( N )
Fournit un nombre aléatoire entre 0 et N
Fonctions sur chaînes de caractères
LONGCHAINE ( C )
Donne la longueur de la chaîne C
CARACT(C, I)
Fournit le I-ième caractère de la chaîne C
Définition d'une action composée
ACTION Nom ( P1, P2, ...Pn )
Objets locaux et paramètres
DEBUT
Instructions
FIN
Les paramètres sont appelés par "référence", ce qui implique que les paramètres d'entrée ne sont pas protégés par l'action.
Une action composée doit être annoncée dans le module principal.
L'appel à une action se fait par
APPEL nom de l'action (paramètres réels)
FONCTION Nom ( P1, P2, ...Pn ) : type
Objets locaux et paramètres
DEBUT
Instructions
FIN
Les paramètres sont appelés par "référence", ce qui implique que les paramètres d'entrée ne sont pas protégés par l'action.
Une fonction utilisateur doit être annoncée dans le module principal en précisant son type.
Il doit y exister dans le corps d'une fonction une affectation du genre
Nom := Expression.
SOIENT
L1, L2 DES LISTES;
Rech, Tous : FONCTION(BOOLEEN);
DEBUT
CREER_LISTE(L1, [2, 5, 9, 8, 3, 6 ]);
CREER_LISTE(L2, [12, 5, 19, 8, 3, 6, 2,9]);
ECRIRE( Tous(L1, L2) )
FIN
/* Recherche de la valeur Val dans la liste L */
FONCTION Rech ( L, Val ) : BOOLEEN
SOIENT
L UNE LISTE;
Val UN ENTIER;
DEBUT
SI L = NIL : Rech := FAUX
SINON
SI VALEUR(L) = Val
Rech := VRAI
SINON
Rech := Rech(SUIVANT(L), Val )
FSI
FSI
FIN
/* Détermine si tous les éléments de L1 sont dans L2 */
FONCTION Tous ( L1, L2 ) : BOOLEEN
SOIENT
L1, L2 DES LISTES;
DEBUT
SI L1 = NIL
Tous := VRAI
SINON
SI NON Rech(L2, VALEUR(L1) )
Tous := FAUX
SINON
Tous := Tous(SUIVANT(L1), L2)
FSI
FSI
FIN