Différences entre les versions de « Introduction à Maple/Procédures »

m
Robot : Changement de type cosmétique
m (Robot : Changement de type cosmétique)
}}
 
== 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 (<code>proc</code>) ==
 
=== 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 : <code>MoudreCafe</code>. 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.
 
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.
:<code>MaProcedure(x,x,x);</code> retourne <code>3x</code>.
 
=== 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é <code>local</code>. Exemple :
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é <code>global</code>.
 
== Les conditions (<code>if… then… else</code>) ==
 
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 :
:<code>Majeur(17);</code> réponse : <code>non</code>
 
== Les boucles ==
=== Boucles déterminées (<code>for</code>) ===
Il est parfois nécessaire de répéter des instructions un nombre ''déterminé'' de fois. On peut pour cela utiliser l'instruction <code>for</code>, de la manière suivante :
 
''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 : <code>for k from 1 to 1 by 2 do</code> en remplaçant 2 par le pas souhaité.''
 
=== Boucles indéterminées (<code>do while</code>) ===
 
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.
Exercice rapide : reprendre l'exemple de la section précédente avec un <code>do while</code> au lieu du <code>for</code>.
 
== 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''.
Lorsqu'on exécute <code>factorielle(6)</code>, Maple affiche le bon résultat : <code>720</code>.
 
== Quelques exemples ==
 
== Résumé ==
 
Au cours de ce chapitre, nous avons appris à réaliser les opérations suivantes :
140 590

modifications