Introduction à Scheme – Les bases (partie 2)

Bonjour à tous,

Cela fait assez longtemps que le premier article de cette série a été rédigé, le manque de temps ne m’ayant pas permis de continuer jusqu’à aujourd’hui. Nous allons donc aborder le code, après en avoir appris plus sur le langage Scheme. Notez que, comme je l’ai précisé dans le premier article, il est préférable d’avoir un minimum de connaissances en programmation pour aborder cet article.

Syntaxe et calculs :

Avant toute chose, vous devez vous familiariser avec la syntaxe de Scheme. Le type de donnée n’est pas à spécifier. En effet il est automatiquement fixé par le résultat du calcul, du test…

Pour délimiter vos instructions, il vous faut utiliser les parenthèses. L’opération que vous souhaitez effectuer précède les arguments : (<operation> <argument 1> <argument 2> …). C’est une notation préfixée. Faites attention car la syntaxe nécessite de la rigueur. Voici plusieurs exemples :

• (+ 2 2) <=> 2 + 2
• (- 1 2 3 4) <=> 1 – 2 – 3 – 4

Par ailleurs, vous pouvez effectuer des expressions composées. En fait, vous pouvez emboîter les expressions indéfiniment :

• (+ (- 3 10) 42) <=> 3 – 10 + 42
• (+ 5 4 (* 13 2)) <=> 5 + 4 + (13 * 2)
• (+ 1 (- 4 (* 5 9))) <=> 1 + (4 – 5*9)

Par ailleurs, comme dans tout langage de programmation, la virgule doit être remplacée par un point : 14,5 mais 14.5

Les constantes et les variables :

Maintenant que vous avez appris à réaliser des calculs avec Scheme, peut-être souhaitez vous qu’il retienne les résultats. Vous pouvez utiliser les variables globales, permanentes jusqu’à l’arrêt de Scheme. Pour définir une variable globale, rien de plus simple : (define <Nom de la var globale> <Valeur de la var globale>).

Voici un exemple :

(define kinchin 2.68545)
pi > 2.68545
(* 2 kinchin) > 5.3709

Voyons à présent comment mémoriser un calcul sans définir de liaison permanente. Pour ce faire, on utilise « let ». Voici la syntaxe de let : (let ((<Nom de la variable> <Valeur de la variable>)) (<Calcul>)). En guise d’exemple, calculons (x + 2)(x + 4) avec x = 3 :

(let ((x 3))
 (* (+ x 2) (+ x 4)))

On commence par assigner à « x » la valeur 3 puis on effectue le calcul (faites attention aux parenthèses). Ici, le résultat sera donc : 35.

Les fonctions :

Après avoir étudié la syntaxe de Scheme pour les calculs, étudions les fonctions. La syntaxe a respecter pour définir une fonction est la suivante : (define (<Nom de la fonction> <paramètre 1> <paramètre 2> …) (<Code de la fonction>)). Faites attention à ne pas vous emmêler avec toutes les parenthèses ! Par ailleurs, vous n’avez pas besoin d’instruction « retourner ». En effet, le résultat l’est automatiquement. Pour appeler votre fonction : (<Nom de la fonction> <paramètre 1> <paramètre 2> …). Et comme un exemple vaut mieux qu’un trop long discours, en voici un petit :

(define (moyenne x y)
  (/ (+ x y) 2)
)

Vous l’avez compris, cette fonction nommée « soustraction » retourne la moyenne de deux nombre X et Y. Oui, c’est peu utile, mais c’est un exemple ! Et pour appeler cette fonction :

(moyenne 20 15)
> 17 1/2 (17.5)

Maintenant que vous maîtrisez les fonctions, vous êtes capables d’écrire des fonctions récursives. Si vous ne savez pas ce que s’est, revoyez vos bases car elles vont nous servir dans les exemples de programme.

Les conditions :

Voyons maintenant comment effectuer des conditions. Il existe deux types de conditions. En premier lieu, voyons celle de type : « Si… Sinon… FinSi ». Voici la syntaxe de ce genre de condition en Scheme : (if (<Test>) (<Code si vrai>) (<Code si faux>)). Rien de bien exceptionnel, voici un petit exemple de condition :

(define (age x)
 (if (>= x 18)
  ”Majeur”
  ”Mineur”
 )
)

Vous avez donc sûrement comprit que cette petite condition vérifie si « x » est supérieur ou égal à 18. Si oui, on retourne « Mineur », sinon, on retourne « Majeur ».

Voyons maintenant le 2eme type de condition, à savoir : « Si… SinonSi… SinonSi… Sinon… FinSi ». Voici la syntaxe de celui-ci :

(cond ((<Test 1>) <Action 1>)
 [...]
 ((<Test n>) <Action n>)
(else action par defaut))

Grâce à cette manière, nous pouvons améliorer le premier exemple :

(define (age x)
 (cond ((>= x 18) ”Majeur”)
 ((>= x 14) ”Adolescent”)
 ((>= x 6) ”Enfant”)
 (else ”Bébé”)
))

Cette condition vérifie toujours l’âge mais de manière plus précise. Un individu quelconque de plus de 18 ans est qualifié de « Majeur », un jeune de plus de 14 ans est qualifié d’adolescent, et cetera.

Des exemples de programmes :

À partir de maintenant, vous êtes en mesure de comprendre de petits programmes écris en Scheme. Pour vous entrainer, voici quelques petits exemple. Bien sur, je vous recommande de ne pas afficher de suite les résultats !

Voici un premier programme :

(define (multiplication x y)
 (if (= y 1)
 x
 (+ x (multiplication x (- y 1)))
 )
)

Détail de ce petit programme :

show

(multiplication 3 2)
> 6

Un autre petit exemple, dans le même esprit que le premier :

(define (puissance x y)
  (if (= y 1)
   x
   (* x (puissance x (- y 1)))
  )
)

Si vous avez compris le premier programme, rien de difficile.

Détail de ce petit programme :

show

(puissance 4 5)
> 1024

Fonction affine :

Avant de lire cet exemple, je tiens à préciser que j’aurais aimé écrire les expressions Mathématiques en LaTeX par soucis de clarté, mais malheureusement, le plug-in le permettant a refusé de s’installer. Par conséquent, certaines expressions ne sont peut être pas très claire.

Voici donc un exemple plus sympathique que les deux premiers dans la mesure où il est assez utile. Si vous suivez en Mathématique, vous connaissez sûrement l’expression : f(u) – f(v) / u – v. Elle permet de calculer une fonction affine de forme ax + b. Si vous ne connaissez pas cette expression, voyez cet exemple d’application :

show

Voici donc le programme en question (ce programme utilise (display()), qui affiche du texte (équivaut à echo en php ou printf en C)). Le programme calcule les valeur de « a » et de « b » :

(define (fonction_affine u v fu fv)
 (display "a=")
 (display (/ (- fu fv)(- u v)))
 (display " b=")
 (display(- fu (* (/ (- fu fv)(- u v)) u)))
)

Rien de bien difficile, en somme.

Détail de ce programme :

show

(fonction_affine 1 -2 3 1)
> a=2/3 b=7/3

Conclusion :

Et voilà, c’est finis. Je sais, je pourrais vous faire un paquet d’autre exemples, mais après tout, vous avez maintenant assez de notions pour les faire vous même ! Si il y a une chose à retenir de ce long article, c’est de faire attention aux parenthèses (à la syntaxe en général, en fait).

Par ailleurs, je finirai bien par trouver le temps nécessaire à la rédaction d’une 3eme partie mais je ne sais absolument pas ce que je raconterai dedans. Ce sera donc la surprise totale !

Si vous avez une question, une remarque, ou autre, n’hésitez pas à me laisser un commentaire ou à m’envoyer un petit mail (par contre, pas la peine de me demander de coder à votre place). J’en profite aussi pour remercier Algorythm et son aide :-).