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

m
Robot : Remplacement de texte automatisé (-\n(==={0,3})(?: *)([^\n=]+)(?: *)\1(?: *)\n +\n\1 \2 \1\n)
m (Robot : Remplacement de texte automatisé (-(\*)(.*)\n{2,}(\*) +\1\2\n\3))
m (Robot : Remplacement de texte automatisé (-\n(==={0,3})(?: *)([^\n=]+)(?: *)\1(?: *)\n +\n\1 \2 \1\n))
 
}}
 
== 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 et 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.
Cette procédure inutile, ne retourne que la valeur 1 car c’est lors de la première itération de la boucle <code>for</code>, c'est-à-dire quand <code>i</code> possède la valeur 1, que le programme va retourner <code>i</code> et s'interrompre. Aucune autre itération ne sera effectuée, quelle que soit la valeur de <code>x</code> (pourvu tout de même qu'elle soit supérieure ou égale à 1).
 
=== Les variables ===
 
On peut utiliser des variables dans les procédures Maple (elles sont dites « locales », ce sont par exemple les variables muettes des <code>for</code>). Il n’est pas nécessaire de les indiquer mais c’est fortement conseillé de le faire en début de code pour plus de clarté en utilisant 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 10 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>while do</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''.
''Remarque : on peut cependant améliorer l'efficacité de la récursivité en demandant à Maple de se souvenir des valeurs précédemment calculées en ajoutant <code>option remember</code> dans l'entête de la procédure.''
 
== Quelques exemples ==
 
== Résumé ==
 
Au cours de ce chapitre, nous avons appris à réaliser les opérations suivantes :
140 590

modifications