Séance 1
Premiers pas en Oz

L'objectif de cette séance est de se familiariser avec

Pour cela, vous écrirez de petits programmes et les ferez fonctionner avec l'environnement de développement du système Mozart.

Préalable

Démarrez l' interface de Mozart.

Consultez ce lien pour utiliser au mieux les commandes d'édition et de compilation.

Exercices

Voici quelques exercices pour vous familiariser à l'environnement et au langage.

  1. Editer et compiler. Tapez le programme suivant.

       {Browse 1}
       {Browse 2}
       {Browse 3}
       {Browse 4}
    
    Ce programme appelle quatre fois la procédure Browse. Cette procédure affiche la valeur qui est donnée en argument.

  2. Expressions arithmétiques. Nous pouvons utiliser la procédure Browse pour évaluer des expressions arithmétiques. Par exemple:

       {Browse (1+5)*(9-2)}
    
    Calculez

    Attention: l'opérateur de négation se note ``~''.

  3. Variables. L'instruction declare permet de créer une variable et de lui assigner une valeur. Comme dans l'exercice précédent, la valeur peut être donnée par une expression. Par exemple:

       declare
       X=(6+5)*(9-7)
    
    On peut alors utiliser l'identificateur de la variable comme synonyme de la valeur. Par exemple:
       {Browse X}
       {Browse X+5}
    
    Réeffectuez les calculs de l'exercice précédent, en utilisant des variables là où vous le jugez utile.

  4. Déclarations multiples. Considérez le programme suivant:

       declare
       X=42
       Z=~3
       {Browse X}     % (1)
       {Browse Z}
       
       declare
       Y=X+5
       {Browse Y}     % (2)
       
       declare
       X=1234567890
       {Browse X}     % (3)
    
    Ce qui se trouve après le signe % est ignoré par le compilateur. Cela permet de commenter le programme.

  5. Expressions booléennes. Outre les expressions arithmétiques, Oz propose des expressions booléennes. Les deux valeurs possibles de telles expressions sont true et false. Ainsi, la comparaison de deux valeurs entières renvoie un booléen.

       {Browse 3 == 7}     % egaux
       {Browse 3 \= 7}     % differents
       {Browse 3 < 7}      % plus petit
       {Browse 3 =< 7}     % plus petit ou egal
       {Browse 3 > 7}      % plus grand
       {Browse 3 >= 7}     % plus grand ou egal
    
    Faites quelques tests et observez les valeurs booléennes renvoyées.

  6. Fonctions et expressions. Nous pouvons aussi utiliser des appels de fonctions dans les expressions arithmétiques et booléennes. Voici un exemple:

       {Browse {Max 3 7}}
       {Browse {Not 3==7}}
    
    La fonction Max prend deux arguments et renvoie le maximum de ceux-ci. La fonction Not prend un argument booléen et renvoie sa négation. Notez que les arguments des fonctions sont aussi des expressions arithmétiques ou booléennes.

  7. Portée lexicale et environnement. Pour rappel, la portée d'une déclaration est la zone d'un programme où un identificateur est défini et correspond à cette déclaration. L'environnement à un moment donné de l'exécution est l'ensemble des identificateurs définis et leur variable correspondante en mémoire.

  8. L'abstraction procédurale. Dans cet exercice, vous allez explorer les possibilités des fonctions, afin d'en améliorer votre compréhension. Considérez le programme suivant.

       declare
       X=3
    
       {Browse X+2}     % (1)
       {Browse X*2}     % (2)
    

Exercices supplémentaires

  1. Le fichier seance1.oz contient des exemples de code Oz. Compilez et exécutez quelques-uns de ces exemples.

  2. Calculez l'expressions suivante en utilisant des variables de manière adéquate (Indication: pensez à 27 = 2*2*2*2*2*2*2).

    27 * 3 + 242 - 2100 * 5

  3. La fonction Sqrt renvoie la racine carrée du nombre réel passé en argument. Utilisez-la pour construire une fonction Distance qui calcule la distance entre deux points d'un plan. Cette fonction prend quatre nombres réels en arguments.

       local
          X1=3.   Y1=2.
          X2=2.5  Y2=0.
       in
          {Browse {Distance X1 Y1 X2 Y2}}
       end
    

  4. Construisez une fonction Egal qui prend deux arguments et renvoie true s'ils sont égaux, false sinon.

Exercice individuel (échance: le 8 octobre 2004)

Voici un petit exercice qui ne vous prendra que quelques minutes ! Il vous permet de tester si vous maîtrisez les bases de la syntaxe du langage Oz. C'est un premier pas vers la bonne compréhension du cours.

Remplissez le formulaire avec vos réponses, ensuite sélectionnez votre tuteur dans la liste. Un e-mail est composé automatiquement, il vous suffit de l'envoyer.

  1. Ecrivez deux fonctions MonMax1 et MonMax2, qui prennent chacune deux arguments et renvoient le maximum de ceux-ci. MonMax1 ne peut pas utiliser la fonction Max définie par Oz et utilisée dans l'exercice 6 ci-dessus.

    MonMax2, à l'inverse, doit utiliser la fonction Max.

  2. Analysez le comportement des trois morceaux de code suivants. Certains provoquent des erreurs, d'autres pas. Tâchez d'expliquer.

       declare
       X=1 Y=2
       Y={MonMax1 X Y}
       {Browse Y}
    
       declare
       X=2 Y=1
       Y={MonMax1 X Y}
       {Browse Y}
    
       declare
       X=2 Y=1
       {Browse Y=={MonMax1 X Y}}
    

  3. Ecrivez une fonction MonMax3, qui prend un seul argument et renvoie le maximum entre cet argument et la variable X.

    Expliquez le comportement des deux bouts de programme suivants.

       declare
       X=1 Y=2
       {Browse {MonMax3 Y}}
    
       declare
       X=1 Y=2
       {Browse {MonMax3 X}}
    

Sélectionnez maintenant le nom de votre tuteur dans la liste :

Isabelle Dony et Raphaël Collet - 1 octobre 2004