Etapes de réalisation d’un programme sous KHAWARIZM

 

Familiarisation avec le langage algorithmique Z

Edition de l'algorithme

Vérification syntaxique

Exécution

Simulation

Trace

Passage vers un langage de programmation

Programmation PASCAL ou C

Exemple d'un Z-algorithme

Equivalent PASCAL

Equivalent C

 

 

 

 

Familiarisation avec le langage algorithmique Z

 

Apprendre le langage algorithmique utilisé. Utiliser l'aide en ligne.

 

Edition de l'algorithme

 

Ecrire un algorithme ou corriger un algorithme existant.

 

Vérification syntaxique

 

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 )

 

Exécution

 

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.

 

Simulation

 

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.

 

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 en PASCAL ou en C.Pour cela, vous devez aller à l'éditeur, ouvrir deux fenêtres que vous organisez en "Tuile" par exemple. 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.

 

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à.

 

Programmation PASCAL ou C

 

   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.

 

Exemple d'un Z-algorithme

 

{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

 

Equivalent PASCAL

 

   PROGRAM S11;

 

   { Implémentation de la liste }

   TYPE

     Typeelem = INTEGER;

     Pointeur = ^Maillon;

     Maillon = RECORD

       VAL : Typeelem;

       Suiv : Pointeur

     END;

 

   { Implémentation des listes linéaires chaînées }

   PROCEDURE Allouer ( VAR P : Pointeur ) ;

     BEGIN  NEW(P)  END;

 

   PROCEDURE Liberer ( P : Pointeur ) ;

     BEGIN  DISPOSE(P)  END;

 

   PROCEDURE Aff_val(P : Pointeur; VAL : Typeelem );

     BEGIN P^.VAL := VAL  END;

 

   FUNCTION Valeur (P : Pointeur) : Typeelem;

     BEGIN   Valeur := P^.VAL  END;

 

   FUNCTION Suivant( P : Pointeur) : Pointeur;

     BEGIN  Suivant := P^.Suiv END;

 

   PROCEDURE Aff_adr( P, Q : Pointeur ) ;

     BEGIN P^.Suiv := Q    END;

 

   {-------   CREER_LISTE   ---------------------}

   TYPE T = ARRAY[1..10] OF INTEGER;

  

PROCEDURE Creer_liste( V:T; N : BYTE; VAR L : Pointeur);

     VAR

       I : BYTE;

       Q, P : Pointeur;

     BEGIN

       FOR I:= 1 TO N DO

         BEGIN

           Allouer(Q);

           Aff_val(Q, V[I]);

           IF  I<>1 THEN Aff_adr(P, Q) ELSE L := Q;

           P := Q

         END;

      END;

 

   {----------------------------------------------------}

   FUNCTION Rech( L: Pointeur; VAL : INTEGER) : BOOLEAN;

     BEGIN

       IF L = NIL

       THEN Rech := FALSE

       ELSE IF Valeur(L) = VAL

            THEN Rech := TRUE

            ELSE Rech := Rech( Suivant(L), VAL)

     END;

 

   FUNCTION Tous ( L1, L2 : Pointeur ) : BOOLEAN;

     BEGIN

       IF L1 = NIL

       THEN Tous := TRUE

       ELSE

         IF NOT Rech(L2, Valeur(L1) )

         THEN Tous := FALSE

         ELSE

           Tous :=  Tous(Suivant(L1), L2)

     END;

 

   {Variables globales}

   VAR

     L1, L2 : Pointeur;

   CONST

     V1 : T = (2,5, 9, 8, 7, 0, 0, 0, 0, 0);

     V2 : T = (2,15, 19, 18, 7, 2, 5, 8,9, 0);

 

   {Programme principal}

   BEGIN

     Creer_liste( V1, 6, L1);

     Creer_liste (V2, 10, L2);

     WRITELN( Tous(L1, L2) );

   END.

 

 

 Equivalent C 

 

  #include <alloc.h>

  #include "stdio.h"

 

  /* Maillon*/

  struct Maillon

    {

      int  Val ;

      struct Maillon *Suiv ;

    }  ;

 

/* Opérations du modèle */

  struct Maillon *Allouer ( )

    {

      return  (  (struct Maillon *) malloc( sizeof(struct Maillon))   );

    }

 

  void Aff_val(struct Maillon *P, int V)

    { P->Val =V; }

 

  void Aff_adr( struct Maillon *P,  struct Maillon *Q)

     {  P->Suiv = Q; }

 

  struct Maillon *Suivant(  struct Maillon *P)

    { return( P->Suiv );  }

 

  int Valeur( struct Maillon *P)

    { return( P->Val) ; }

 

  //-------   CREER_LISTE   ---------------------

  typedef int  T [9]  ;

  void Creer_liste( T V, int N , struct Maillon **L )

    {

      int I;

      struct Maillon *Q, *P;

      for (I=0; I<N; I++)

             {

               Q = Allouer();

               Aff_val(Q, V[I]);

               if (I != 0)  Aff_adr(P, Q) ; else *L = Q;

               P = Q ;

             }

       Aff_adr(P,NULL);

    }

  //----------------------------------------------------

  typedef int Boolean;

  #define FALSE 0

  #define TRUE 1

 

 

 

 

  Boolean Rech( struct Maillon *L, int Val )

    {

       if (L == NULL)

             return ( FALSE );

       else if (Valeur(L) == Val)

                 return (TRUE )  ;

                else return( Rech( Suivant(L), Val) )  ;

     }

 

  Boolean Tous ( struct Maillon *L1, struct Maillon *L2  )

     {

       if ( L1 == NULL)

            return( TRUE ) ;

       else

             if ( ! Rech(L2, Valeur(L1) ) )

              return ( FALSE );

             else

               return ( Tous(Suivant(L1), L2) );

     }

  // Variables globales

     struct Maillon *L1, *L2;

     T V1;

     T V2;

 

  // Programme principal

  main()

   {

     V1[0]= 2;      V1[1]= 5;     V1[2]= 9;

     V1[3]= 8;      V1[4]= 7;     V1[5]= 0;

 

     V2[0]= 2;      V2[1]= 15;     V2[2]= 19;

     V2[3]= 18;     V2[4]= 7;      V2[5]= 0;

     V2[6]= 5;      V2[7]= 8;      V2[8]= 9;

 

     Creer_liste( V1, 6, &L1);

     Creer_liste (V2, 9, &L2);

     printf( "Résultat : %d",Tous(L1, L2) );

   }