Etapes de réalisation d’un programme sous KHAWARIZM                    Retour au sommaire

 

Familiarisation avec le langage algorithmique Z

Edition de l'algorithme

Vérification syntaxique

Exécution

Simulation

Trace

Traduction

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

 

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. Le langage Z n'offre pas des facilités pour de telles tâches.

 

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

 

 

  /**       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.

 

 

 Equivalent C 

 

  /** 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;

    }