« Introduction à Maple/Procédures » : différence entre les versions

Une page de Wikiversité, la communauté pédagogique libre.
Contenu supprimé Contenu ajouté
Sharayanan (discussion | contributions)
m corr. nav chap/bdp
Aucun résumé des modifications
Ligne 1 : Ligne 1 :
{{Chapitre
{{Chapitre
|titre=Procédures
| titre = Procédures
| idfaculté = informatique
|titre_leçon=Introduction à Maple
| leçon = [[Introduction à Maple]]
|idfaculté=informatique
| numero = 6
|leçon=[[Introduction à Maple]]
| précédent = [[Introduction à Maple/Listes, tableaux, matrices|Listes, tableaux, matrices]]
|numero=6
| suivant = [[../Bibliothèques de fonctions|Bibliothèques de fonctions]]
|précédent=[[Introduction à Maple/Listes, tableaux, matrices|Listes, tableaux, matrices]]
| niveau = 13
|suivant=[[../Bibliothèques de fonctions|Bibliothèques de fonctions]]
|niveau=13
}}
}}


Ligne 144 : Ligne 143 :
Lorsqu'on ne sait pas, ''a priori'', combien de fois nous souhaitons répéter les instructions, il est quand même possible de s'en sortir. Il faut cependant savoir quand arrêter, sans quoi le programme restera bloqué, exécutant les mêmes instructions ''ad vitam æternam''. On fixe donc une condition, par exemple « <code>x < 5</code> ». Tant que cette condition est vérifiée, la boucle s'exécute.
Lorsqu'on ne sait pas, ''a priori'', combien de fois nous souhaitons répéter les instructions, il est quand même possible de s'en sortir. Il faut cependant savoir quand arrêter, sans quoi le programme restera bloqué, exécutant les mêmes instructions ''ad vitam æternam''. On fixe donc une condition, par exemple « <code>x < 5</code> ». Tant que cette condition est vérifiée, la boucle s'exécute.


{{Attention
{{Attention|Avec_fond=oui|Il faut que, '''dans la boucle''', une instruction modifie ''x'' : si ce n'est pas le cas, la condition peut être toujours vraie, et le programme boucle pour toujours.}}
| Avec_fond = oui
| Il faut que, '''dans la boucle''', une instruction modifie ''x'' : si ce n'est pas le cas, la condition peut être toujours vraie, et le programme boucle pour toujours.
}}


On utilise, pour de telles boucles indéterminées, la structure <code>do while … od</code>, de la manière suivante :
On utilise, pour de telles boucles indéterminées, la structure <code>do while … od</code>, de la manière suivante :
Ligne 203 : Ligne 205 :


{{Bas de page
{{Bas de page
|idfaculté=informatique
| idfaculté = informatique
|leçon=[[Introduction à Maple]]
| leçon = [[Introduction à Maple]]
|précédent=[[Introduction à Maple/Listes, tableaux, matrices|Listes, tableaux, matrices]]
| précédent = [[Introduction à Maple/Listes, tableaux, matrices|Listes, tableaux, matrices]]
|suivant=[[../Bibliothèques de fonctions|Bibliothèques de fonctions]]
| suivant = [[../Bibliothèques de fonctions|Bibliothèques de fonctions]]
}}
}}


[[Catégorie:{{BASEPAGENAME}}]]
[[Catégorie:Introduction à Maple]]

Version du 10 juillet 2008 à 13:59

Début de la boite de navigation du chapitre
Procédures
Icône de la faculté
Chapitre no {{{numéro}}}
Leçon : Introduction à Maple
Chap. préc. :Listes, tableaux, matrices
Chap. suiv. :Bibliothèques de fonctions
fin de la boite de navigation du chapitre
En raison de limitations techniques, la typographie souhaitable du titre, « Introduction à Maple : Procédures
Introduction à Maple/Procédures
 », n'a pu être restituée correctement ci-dessus.

Introduction

Toutes les opérations que nous avons réalisé jusqu'ici concernaient des opérations élémentaires (pas nécessairement simples). Pour exécuter trente fois ces opérations, nous pourrions les écrire trente fois à la suite. Cela est toutefois assez pénible et improductif : Maple dispose de quelques capacités de programmation, que nous abordons dans ce chapitre.

Les procédures (proc)

Utiliser les procédures

Une « procédure » est une opération (potentiellement très longue est complexe), repérée par son nom. Par exemple : MoudreCafe. On peut demander à Maple d'exécuter cette opération, sans avoir à se soucier de son contenu précis. Une procédure peut également nécessiter une ou plusieurs informations de départ (les arguments) pour se faire : la température T, le volume V du café dans notre exemple.

Pour l'utiliser, on pourra écrire :

MoudreCafe(T, V) ;

Enfin, une procédure peut se comporter comme une fonction : elle peut retourner une (ou plusieurs) valeur(s) lorsqu'elle est appelée. La différence tient surtout au fait qu'une procédure permet de faire beaucoup plus de choses qu'une fonction. En contrepartie, il ne faut pas espérer dériver, tracer… une procédure.

Définir une procédure

Une procédure Maple se découpe en trois parties : l'entête, le corps et le retour.

  • L'entête (MaProcedure := proc(a, b, c)) fournit les informations utiles pour utiliser la procédure : son nom (MaProcedure) et ses arguments (ici, a, b et c).
  • Le corps (x := a + b + c) indique au logiciel les actions à réaliser.
  • Enfin, la fin de la procédure retourne éventuellement un résultat (RETURN(x)). Une procédure Maple se termine toujours par end.

Voici l'exemple complet :

MaProcedure := proc(a, b, c)
x := a + b + c ;
RETURN(x) ;
end;

Cette procédure prend trois arguments et retourne la somme des trois. Par exemple :

MaProcedure(1,2,3); retourne 6 ;
MaProcedure(x,x,x); retourne 3x.

Les variables

On peut utiliser des variables dans les procédures Maple (elles sont dites « locales »). Pour cela, il n'est en pratique rien besoin de faire. Pour plus de clarté cependant, on prendra l'habitude de les préciser en début de code, avec le mot-clé local. Exemple :

MaProcedure := proc(a, b, c)
local x ;

On peut également utiliser des variables accessibles depuis l'extérieur des procédures (dites « globales »), bien que cela soit moins courant. On utilise alors le mot-clé global.

Les conditions (if… then… else)

Nous voudrions pouvoir exécuter une certaine opération si un nombre x est positif, et une autre opération s'il est négatif. Comment faire ? La réponse : utiliser des conditions. Voici la syntaxe Maple qui convient :

if condition then
code si condition vraie
fi;

La condition doit être une expression booléenne (vraie ou fausse), par exemple :

  • x > 3
  • (x > 3) and (x < 1)
  • x = 12

Si on essaie d'utiliser une expression ouverte (par exemple, x + 3) Maple retourne une erreur. Notre code s'exécute ici uniquement si la condition est vraie. Si elle est fausse, rien n'est fait. Un petit raffinement :

if condition then
code si condition vraie
else
code si condition fausse
fi;
Panneau d’avertissement En anglais, if… then… else… signifie littéralement si… alors… sinon….

Exemple :

Majeur := proc(age)
if age >= 18 then
RETURN("oui");
else
RETURN("non")
fi ;
end ;

Ce programme répond de la manière suivante :

Majeur(32); réponse : oui
Majeur(24); réponse : oui
Majeur(18); réponse : oui
Majeur(17); réponse : non

Les boucles

Boucles déterminées (for)

Il est parfois nécessaire de répéter des instructions un nombre déterminé de fois. On peut pour cela utiliser l'instruction for, de la manière suivante :

for variable from debut to fin do
code à répéter
od;

Écrire le code ci-dessus revient exactement à écrire la chose suivante:

variable = début ;
code à répéter
variable = début + 1 ;
code à répéter
variable = début +2 ;
code à répéter
variable = fin ;
code à répéter

Utiliser for permet donc de condenser les choses. Voici un exemple clarifiant les choses :

x := NULL ;
for i from 1 to 10 do
x := x, i ;
od ;
RETURN([x]);

Étudions ce code ligne par ligne :

  • on crée une liste vide, nommée x
  • on ajoute « 1 » à la liste ;
  • on ajoute « 2 » à la liste ;
  • on ajoute « 10 » à la liste ;
  • on retourne la liste.

Remarquez que i prend toutes les valeurs entre 1 et 10. Le programme ci-dessus retourne donc [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]. Exercice rapide : adapter le code précédent pour afficher la liste des 1000 premiers entiers non nuls.

L'instruction for ne peut être utilisée que lorsqu'on connait a priori le nombre de répétitions.

Remarque : on peut avoir besoin que l'indice aille de 2 en 2, ou de 3 en 3. Il suffit de rajouter cette option dans la déclaration de la boucle : for k from 1 to 1 by 2 do en remplaçant 2 par le pas souhaité.

Boucles indéterminées (do while)

Lorsqu'on ne sait pas, a priori, combien de fois nous souhaitons répéter les instructions, il est quand même possible de s'en sortir. Il faut cependant savoir quand arrêter, sans quoi le programme restera bloqué, exécutant les mêmes instructions ad vitam æternam. On fixe donc une condition, par exemple « x < 5 ». Tant que cette condition est vérifiée, la boucle s'exécute.

Panneau d’avertissement Il faut que, dans la boucle, une instruction modifie x : si ce n'est pas le cas, la condition peut être toujours vraie, et le programme boucle pour toujours.

On utilise, pour de telles boucles indéterminées, la structure do while … od, de la manière suivante :

do while (condition)
code à répéter
code qui modifie l'état de la condition
od;

Voici un exemple d'utilisation :

x := 5 ;
do while (x > 2)
y := x + 12 ;
x := x - 1 ;
od ;

Remarquez que, dans ce cas précis, on aurait pu faire exactement la même chose avec for… Utiliser while dans ce cas n'est vraiment pas utile, mais c'est un exemple.

L'utilisation de do while … od est souvent évitable. On peut également l'utiliser pour optimiser un peu le code, mais dans la majorité des cas simples, il est rarement nécessaire ou utile.

Exercice rapide : reprendre l'exemple de la section précédente avec un do while au lieu du for.

Programmation récursive

Une procédure Maple peut tout à fait s'appeler elle-même, pour résoudre des problèmes de manière récursive. En particulier, les algorithmes de tri les plus efficaces utilisent cette méthode. Pour illustrer cela, nous allons écrire un algorithme qui calcule la (très classique) factorielle d'un entier n.

Partons des constats suivants :

  • lorsque n est strictement positif ;

Pour calculer la factorielle de n, nous calculons la factorielle de n-1. Pour celle-ci, il nous faut (n-2)! etc. Voici le code associé :

factorielle := proc(n)
if n = 0 then
RETURN(1) ;
else
RETURN(n * factorielle(n-1) ) ;
fi ;
end ;

Lorsqu'on exécute factorielle(6), Maple affiche le bon résultat : 720.

Quelques exemples

Résumé

Au cours de ce chapitre, nous avons appris à réaliser les opérations suivantes :

  • définir une procédure avec proc ;
  • définir des variables avec local ;
  • poser des conditions, avec if … then … else … fi ;
  • former des boucles avec for ou while ;
  • réaliser des procédures récursives.

Ces points sont au cœur de l'utilisation pratique de Maple : en effet, les capacités de calcul sont bien souvent employées dans de telles procédures. Dans le chapitre prochain, nous verrons comment étendre les capacités de Maple, en prenant en compte les bibliothèques de fonctions.