Etapes de réalisation d’un programme sous KHAWARIZM
Familiarisation avec le langage algorithmique Z
Apprendre le langage algorithmique utilisé. Utiliser l'aide en ligne.
Ecrire un algorithme ou corriger un algorithme existant.
Lancer le module Arranger.
Répéter tant qu'il y a des erreurs
. Corriger les erreurs
. Relancer le module Arranger
A ce stade, votre algorithme est bien écrit et il a été indenté pour vous.( Vous pouvez changer les modes de présentation de votre algorithme ( voir "Options" du menu )
Lancer l'exécution de votre algorithme
Les fenêtres montrent alors
- les données lues par votre algorithme (Bouton Données)
- les écritures émises par votre algorithme (Bouton Résultats)
Ou bien votre algorithme donne les résultats attendus ou pas. Dans ce dernier cas, lancer la simulation pour essayer de déterminer les erreurs de logique.
Lancer la simulation de votre algorithme. Il s'agit d'une exécution avec une trace.
Les fenêtres montrent alors
- les données lues par votre algorithme (Bouton Données)
- les écritures émises par votre algorithme (Bouton Résultats)
- tous les changements effectués sur les objets utilisés (Bouton Simulation)
Vous avez ainsi la trace complète de votre algorithme que vous pouvez imprimer et l'analyser pour détecter les erreurs.
Si vous désirez voir de plus près les différents pas de votre algorithme, demander une trace.
Redemander la simulation avec trace. Vous pouvez alors suivre pas à pas l'évolution de votre algorithme, sortir de la boucle courante ou même du module courant.
Afin d'éviter d'avoir une trace complète qui peut être longue il est possible de limiter la longueur des boucles utilisées dans votre algorithme. Vous pouvez changer les modes de simulation (voir "Options" du menu).
Passage vers un langage de programmation
Une fois que votre algorithme "tourne", il est possible de le traduire automatiquement en PASCAL ou en C. Il suffit de cliquer sur le bouton "Vers Pascal" ou "Vers C". Deux fenêtres organisées en "Tuile" apparaissent. L'une contient votre algorithme et l'autre le résultat de votre traduction. Utiliser alors l'aide concernant le passage vers PASCAL ou C pour faciliter la compréhension de la traduction.
Dans cette aide, vous trouverez
- les équivalents Z vers PASCAL et Z vers C.
- toutes les implémentations des machines Z.
La tâche de Khawarizm s'arrête à ce niveau là.
Utiliser le compilateur PASCAL ou C, pour finaliser définitivement votre programme. En particuliers, vous devez rajouter tous les modules de saisie des données et de restitution des résultats. Le langage Z n'offre pas des facilités pour de telles tâches.
{Inclusion d'une liste linéaire chaînée dans une autre ?}
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 d'une valeur dans une liste linéaire chaînée}
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
{Inclusion d'une liste dans une autre}
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
/** C o n v e r s i o n Z vers PASCAL (Standard) **/
PROGRAM Mon_programme;
{/// Implémentation \\\: LISTE DE ENTIERS }
{ Listes linéaires chaînées }
TYPE
Typeelem_LI = INTEGER;
Pointeur_LI = ^Maillon_LI; { type du champ 'Adresse' }
Maillon_LI = RECORD
Val : Typeelem_LI;
Suiv : Pointeur_LI
END;
PROCEDURE Allouer_LI ( VAR P : Pointeur_LI ) ;
BEGIN NEW(P) END;
PROCEDURE Liberer_LI ( P : Pointeur_LI ) ;
BEGIN DISPOSE(P) END;
PROCEDURE Aff_val_LI(P : Pointeur_LI; Val : Typeelem_LI );
BEGIN P^.Val := Val END;
FUNCTION Valeur_LI (P : Pointeur_LI) : Typeelem_LI;
BEGIN Valeur_LI := P^.Val END;
FUNCTION Suivant_LI( P : Pointeur_LI) : Pointeur_LI;
BEGIN Suivant_LI := P^.Suiv END;
PROCEDURE Aff_adr_LI( P, Q : Pointeur_LI ) ;
BEGIN P^.Suiv := Q END;
{ Macro opérations }
{ Création d'une liste }
PROCEDURE CREER_LISTE_LI ( VAR L : Pointeur_LI ; Tab : Typetab_V6I ; N: INTEGER) ;
VAR
I : INTEGER;
P, Q : Pointeur_LI ;
BEGIN
L:=NIL;
FOR I := 1 TO N DO
BEGIN
ALLOUER_LI( Q ) ;
AFF_VAL_LI (Q, Tab[I]);
AFF_ADR_LI (Q, NIL);
IF L = NIL
THEN L := Q
ELSE AFF_ADR_LI (P, Q);
P := Q
END;
END;
TYPE
Typeelem_V6I = INTEGER ;
Typetab_V6I = ARRAY[1..6] of Typeelem_V6I ;
TYPE
Typeelem_V8I = INTEGER ;
Typetab_V8I = ARRAY[1..8] of Typeelem_V8I ;
{Partie déclaration de variables }
VAR
L1 : Pointeur_LI;
L2 : Pointeur_LI;
T_L1 : Typetab_V6I ;
T_L2 : Typetab_V8I ;
{ Prototypes des procédures et/ou fonctions }
FUNCTION Rech (VAR L : Pointeur_LI ; VAR Val : INTEGER) : BOOLEAN; FORWARD;
FUNCTION Tous (VAR L1 : Pointeur_LI ; VAR L2 : Pointeur_LI) : BOOLEAN; FORWARD;
{ Recherche d'une valeur dans une liste linéaire chaînée }
FUNCTION Rech (VAR L : Pointeur_LI ; VAR Val : INTEGER) : BOOLEAN;
{Partie déclaration de variables }
VAR
Rech2 : BOOLEAN ;
Px1 : Pointeur_LI;
BEGIN
IF L = NIL THEN BEGIN
Rech2 := FALSE END
ELSE
BEGIN
IF VALEUR_LI(L ) = Val THEN BEGIN
Rech2 := TRUE END
ELSE
BEGIN
Px1 := SUIVANT_LI(L ) ;
Rech2 := Rech2 (Px1, Val )
END
END
;Rech := Rech2 ;
END;
{ Inclusion d'une liste dans une autre }
FUNCTION Tous (VAR L1 : Pointeur_LI ; VAR L2 : Pointeur_LI) : BOOLEAN;
{Partie déclaration de variables }
VAR
Tous2 : BOOLEAN ;
Px1 : Pointeur_LI;
Px2 : Pointeur_LI;
BEGIN
IF L1 = NIL THEN BEGIN
Tous2 := TRUE END
ELSE
BEGIN
Px1 := VALEUR_LI(L1 ) ;
IF NOT Rech ( L2 ,Px1) THEN BEGIN
Tous2 := FALSE END
ELSE
BEGIN
Px2 := SUIVANT_LI(L1 ) ;
Tous2 := Tous2 (Px2, L2 )
END
END
;Tous := Tous2 ;
END;
{Corps du programme principal }
BEGIN
T_L1 [ 1 ] := 2 ;
T_L1 [ 2 ] := 5 ;
T_L1 [ 3 ] := 9 ;
T_L1 [ 4 ] := 8 ;
T_L1 [ 5 ] := 3 ;
T_L1 [ 6 ] := 6 ;
NEW(L1);
CREER_LISTE_LI ( L1 , T_L1 , 6 ) ;
T_L2 [ 1 ] := 12 ;
T_L2 [ 2 ] := 5 ;
T_L2 [ 3 ] := 19 ;
T_L2 [ 4 ] := 8 ;
T_L2 [ 5 ] := 3 ;
T_L2 [ 6 ] := 6 ;
T_L2 [ 7 ] := 2 ;
T_L2 [ 8 ] := 9 ;
NEW(L2);
CREER_LISTE_LI ( L2 , T_L2 , 8 ) ;
WRITE ( Tous(L1,L2) )
END.
/** C o n v e r s i o n Z vers C (Standard) **/
#include <stdio.h>
#include <stdlib.h>
typedef int bool ;
#define True 1
#define False 0
/** Implémentation **\: LISTE DE ENTIERS**/
/** Listes linéaires chaînées **/
typedef int Typeelem_Li ;
typedef struct Maillon_Li * Pointeur_Li ;
struct Maillon_Li
{
Typeelem_Li Val ;
Pointeur_Li Suiv ;
} ;
Pointeur_Li Allouer_Li (Pointeur_Li *P)
{
*P = (struct Maillon_Li *) malloc( sizeof( struct Maillon_Li)) ;
}
void Aff_val_Li(Pointeur_Li P, Typeelem_Li V)
{
P->Val = V ;
}
void Aff_adr_Li( Pointeur_Li P, Pointeur_Li Q)
{
P->Suiv = Q ;
}
Pointeur_Li Suivant_Li( Pointeur_Li P)
{ return( P->Suiv ) ; }
Typeelem_Li Valeur_Li( Pointeur_Li P)
{ return( P->Val) ; }
void Liberer_Li ( Pointeur_Li P)
{ free (P);}
/** Prototypes des fonctions **/
bool Rech (Pointeur_Li *L , int *Val) ;
bool Tous (Pointeur_Li *L1 , Pointeur_Li *L2) ;
/** Macro opérations **/
/** Création d'une liste **/
void Creer_liste_Li ( Pointeur_Li *L, Typetab_V6i Tab, int N)
{
int I ;
Pointeur_Li P, Q ;
*L =NULL;
for( I=1;I<=N;++I)
{
Allouer_Li( &Q ) ;
Aff_val_Li (Q, Tab[I-1]);
Aff_adr_Li (Q, NULL);
if (*L == NULL)
*L = Q ;
else Aff_adr_Li (P, Q);
P = Q ;
}
}
/** Pour les variables temporaires **/
typedef int Typeelem_V6i;
typedef Typeelem_V6i Typetab_V6i[6];
/** Pour les variables temporaires **/
typedef int Typeelem_V8i;
typedef Typeelem_V8i Typetab_V8i[8];
/** Partie déclaration de variables **/
Pointeur_Li L1;
Pointeur_Li L2;
Typetab_V6i T_L1;
Typetab_V8i T_L2;
/* Recherche d'une valeur dans une liste linéaire chaînée */
bool Rech (Pointeur_Li *L , int *Val)
{
/** Partie déclaration de variables **/
bool Rech2 ;
Pointeur_Li Px1;
/** Corps du module **/
if( *L == NULL) {
Rech2 = False; }
else
{
if( Valeur_Li(*L ) == *Val) {
Rech2 = True; }
else
{
Px1 = Suivant_Li(*L ) ;
Rech2 = Rech2 ( &Px1, & *Val );
}
}
return Rech2 ;
}
/* Inclusion d'une liste dans une autre */
bool Tous (Pointeur_Li *L1 , Pointeur_Li *L2)
{
/** Partie déclaration de variables **/
bool Tous2 ;
Pointeur_Li Px1;
Pointeur_Li Px2;
/** Corps du module **/
if( *L1 == NULL) {
Tous2 = True; }
else
{
Px1 = Valeur_Li(*L1 ) ;
if( ! Rech ( & *L2 , &Px1)) {
Tous2 = False; }
else
{
Px2 = Suivant_Li(*L1 ) ;
Tous2 = Tous2 ( &Px2, & *L2 );
}
}
return Tous2 ;
}
int main(int argc, char *argv[])
{
T_L1 [ 0 ] = 2 ;
T_L1 [ 1 ] = 5 ;
T_L1 [ 2 ] = 9 ;
T_L1 [ 3 ] = 8 ;
T_L1 [ 4 ] = 3 ;
T_L1 [ 5 ] = 6 ;
L1 = malloc(sizeof(Typestr_Li));
Creer_liste_Li (&L1 , T_L1 , 6 ) ;
T_L2 [ 0 ] = 12 ;
T_L2 [ 1 ] = 5 ;
T_L2 [ 2 ] = 19 ;
T_L2 [ 3 ] = 8 ;
T_L2 [ 4 ] = 3 ;
T_L2 [ 5 ] = 6 ;
T_L2 [ 6 ] = 2 ;
T_L2 [ 7 ] = 9 ;
L2 = malloc(sizeof(Typestr_Li));
Creer_liste_Li (&L2 , T_L2 , 8 ) ;
printf ( " %d ", Tous(&L1,&L2) );
system("PAUSE");
return 0;
}