Leçons de niveau 14

Introduction à Maple/Fonctions

Une page de Wikiversité.
Sauter à la navigation Sauter à la recherche
Début de la boite de navigation du chapitre
Fonctions
Icône de la faculté
Chapitre no 3
Leçon : Introduction à Maple
Chap. préc. :Expressions en ligne de commande
Chap. suiv. :Polynômes
fin de la boite de navigation du chapitre
Icon falscher Titel.svg
En raison de limitations techniques, la typographie souhaitable du titre, « Introduction à Maple : Fonctions
Introduction à Maple/Fonctions
 », n'a pu être restituée correctement ci-dessus.

Introduction[modifier | modifier le wikicode]

Puisque Maple va nous servir à résoudre des problèmes, il serait pratique d'y retrouver les objets mathématiques usuels. En particulier, il est facile de définir des fonctions d'une ou plusieurs variables, réelles ou complexes comme nous allons le voir dans ce chapitre. Nous pourrons alors effectuer un certain nombre d'opérations sur ces fonctions, les représenter graphiquement, etc.

Fonctions de base[modifier | modifier le wikicode]

Maple dispose d'un certain nombre de fonctions « de base », en particulier :

  • les fonctions trigonométriques et hyperboliques : cos, sin, tan, cosh, sinh, tanh ;
  • les fonctions inverses associées : Arccos, Arcsin, Arctan, Arccosh, Arcsinh, Arctanh ;
  • les « parties entières » : floor, ceil (respectivement inférieure et supérieure) ;
  • la valeur absolue : abs ;
  • exponentielle et logarithme : exp, log (Attention : log désigne le logarithme népérien) ;
  • etc.

On peut utiliser ces fonctions telles quelles, même dans une autre fonction si cela s'avère nécessaire. On peut former, dans Maple, des fonctions de toutes sortes :

  • des fonctions à variables numériques qui renvoient un nombre ;
  • des fonctions qui prennent des fonctions et renvoient un nombre (appelées fonctionnelles) ;
  • des fonctions qui prennent des fonctions et renvoient des fonctions ;
  • des fonctions qui prennent un nombre (ou une fonction, un texte, une matrice…) et renvoient une image (ou une liste, un texte, une matrice…) ;
  • etc.

Définir une fonction[modifier | modifier le wikicode]

Voici comment définir une fonction mathématique dans Maple :

nom_de_la_fonction := (variable1, variable2, …) -> contenu ;

Remarquez le symbole « -> » qui tente d'imiter la flèche utilisée généralement en mathématiques. Quelques exemples d'illustration :

f := x -> x^3 ;
g := (x,y) -> x + y ;
h := (a, b, c, d) -> a * b + c * d ;

Exercice rapide : que doit-on écrire pour définir une fonction f qui à x associe xx ?

Opérations simples sur les fonctions[modifier | modifier le wikicode]

Puisque Maple manipule des symboles, nous pouvons effectuer les opérations sur les fonctions comme sur des nombres, à quelques exceptions près. Soit f et g deux fonctions quelconques, alors les opérations suivantes donnent des fonctions valides :

f + g ;
f - g ;
f * g ;
f / g ; (tant que g ne s'annule pas !)
f ^ g ;

Maple sait également évaluer une fonction en un point (à condition qu’il appartienne à son ensemble de définition).

f:=x->x^2+1;
evalf(f(2));

Pour calculer la limite d'une fonction, on procède de la manière suivante :

limit((exp(x)-1)/x,x=0);

Dérivation, équations différentielles simples[modifier | modifier le wikicode]

Maple peut calculer la dérivée (ou les dérivées partielles) d'une fonction, avec l'instruction diff, qui s'utilise ainsi :

diff(nom_de_la_fonction, variable); (dérivée de la fonction par rapport à variable)

Par exemple, si je cherche la dérivée de la fonction qui à x associe  :

f := x -> x^2 ;
diff(f(x), x) ;

ce qui affiche 2x. On peut, de même, calculer des dérivées partielles :

f := (x,y) -> sin(2*x + y) ;
diff(f(x,y), x); (dérivée partielle par rapport à x) 
diff(f(x,y), y); (dérivée partielle par rapport à y)

ce qui affiche respectivement 2cos(2x + y) et cos(2x + y).

Panneau d’avertissement diff(f(x,y), x) est une fonction. Par exemple, diff(f(x,y), x)(3,4) renvoie 2cos(10).

Nous pouvons désormais chercher à résoudre des équations différentielles (simples, pour commencer) : il suffit d'écrire une telle équation, faisant intervenir une fonction et ses dérivées, puis nous demandons à Maple la ou les solutions à l'aide de la fonction dsolve. Par exemple :

equadiff := ( diff( diff( f(x), x ), x) + f(x) = 0 ); (c'est-à-dire f'' + f = 0)
dsolve ( equadiff, f(x) ); (on cherche la fonction ''f'' qui résout equadiff)

Maple réfléchit quelques temps et affiche quelque chose de la forme suivante :

''_C1''cos(''x'') + ''_C2''sin(''x'')

Explication : notre équation différentielle admet, dans l'absolu, une infinité de solutions. Il y a donc deux constantes, au doux nom de _C1 et _C2, que l’on peut fixer en imposant des conditions initiales au problème.

Panneau d’avertissement Remarquez que la solution donnée par Maple est complexe : ce sera toujours le cas par défaut. À vous, donc, de faire le tri…

Pour fixer des conditions initiales, il faut utiliser un troisième argument dans dsolve :

dsolve({equadiff, f(0)=4, D(f)(0) = 6}, f(x))

Les conditions initiales et l'équation sont entre deux accolades, pour des raisons qui seront clarifiés dans un prochain chapitre. Si on exécute l’expression ci-dessus, Maple affiche :

6sin(''x'') + 4cos(''x'')

qui est l'unique solution de notre problème avec les conditions initiales. Maple ne peut pas toujours résoudre les équations différentielles de manière exacte. Il existe cependant des méthodes permettant de contourner le problème, par exemple en résolvant numériquement de telles équations, mais cela dépasse le cadre de cette leçon d'introduction.

Exercice rapide : qu'affiche Maple lorsqu'on tape les instructions suivantes ?

equa := ( diff(f(t), t) + f(t) = 5 ) ;
dsolve (equa, f(t));

Intégration[modifier | modifier le wikicode]

Maple peut également intégrer des fonctions. Soit une fonction f, nous cherchons l'intégrale de f c'est-à-dire :

Il nous suffit pour cela d'écrire :

int( f(t) , t = a..b )

Par exemple : Pour f := x -> x^2, on a int( f(x) , x = 0..1 ); qui retourne 1/3. Maple connaît certaines intégrales impropres, il est donc légitime dans certains cas de pousser les bornes d'intégration à l'infini :

f := x -> sin(x)/x ;
int( f(x) , x = 0..infinity );

Enfin, dans certains cas, on ne peut (ou ne veut) pas calculer une expression de l'intégrale et nous ne nous intéressons qu’à une valeur approchée : on utilisera alors l’expression Int (avec une majuscule et qui s'utilise exactement comme int) qui retourne une version "inerte" du calcul à faire, ce qui permet d'afficher l’expression sans pour autant l'exécuter. Si l’on y adjoint en plus la fonction evalf() qui évalue numériquement de ce qui est entre parenthèse, on obtient evalf(Int(...)) qui est une approximation de l'intégrale.

Exercice rapide : que doit-on écrire pour obtenir une primitive de ln ?

Représentation graphique[modifier | modifier le wikicode]

Maintenant que nous avons les fonctions, dessinons-les ! Il suffit pour cela d’utiliser une nouvelle instruction : plot (qui signifie « tracer »). Elle s'emploie ainsi :

plot( fonction(variable) , variable = debut..fin );

Par exemple, pour représenter la fonction qui à x associe sur l'intervalle [-1, 4π], on écrit :

f := x -> x^2 ;
plot( f(x) , x = -1..4*Pi );

On peut représenter, simultanément, plusieurs fonctions. Par exemple :

f := x -> sqrt(x) ;
g := x -> x ;
h := x -> x^2 ;

plot([f(x), g(x), h(x)], x=0..5);

Par défaut, le graphe de chaque fonction est d'une couleur différente (rouge, bleu, vert, jaune, violet…). Cela est contrôlable mais ne nous intéresse pas dans le cadre de cette leçon. Il est également possible de représenter une fonction en coordonnées polaires ou paramétriques — mais cela est secondaire.

Comme évoqué plus haut, on peut définir une fonction qui, à un nombre, associe un graphique. Par exemple :

dessin := n -> plot( t->t^n, t=0..5);

Cette fonction retourne le graphe de la fonction tⁿ sur l'intervalle [0, 5]. Ce genre d'astuces est intéressant pour créer, entre autres, des animations.

Panneau d’avertissement L'instruction plot ne permet que de tracer des fonctions de R dans R… pour représenter des fonctions à valeurs complexes (ou autres) il faut d'autres instructions, dont certaines seront évoquées dans un prochain chapitre.

Recherche de zéros & d'extrema[modifier | modifier le wikicode]

On peut utiliser l'instruction solve vue au chapitre précédent pour rechercher les zéros ou les extrema (locaux) d'une fonction d'une pour plusieurs variables. Pour cela, on cherche les points où la fonction s'annule (zéro), ou bien les points où sa (ses) dérivée(s) s'annule(nt) (extrema locaux). Respectivement :

solve(f(x) = 0, x); (zéros de f)
solve( diff(f(x),x) = 0, x); (zéros de ''f’'', c'est-à-dire extrema locaux potentiels de ''f'')

Lorsqu’il y a plusieurs solutions, elles sont données entre crochets.

Panneau d’avertissement L'instruction solve peut échouer ! Maple ne trouve pas toujours de solutions…

Représenter graphiquement la fonction permet généralement de s'assurer de la validité des résultats fournis par Maple.

Exercice rapide : comment trouver les extrema de la fonction qui à x et y associe x² + y² - 2xy - 2(x + y) ?

Résumé[modifier | modifier le wikicode]

Nous avons vu comment réaliser les opérations suivantes :

  • définir une fonction mathématique ;
  • utiliser les fonctions de base et combiner des fonctions ;
  • dériver (avec diff) une fonction ;
  • intégrer (avec int) une fonction ;
  • intégrer de manière approchée (avec evalf(Int)) une fonction ;
  • représenter une ou plusieurs fonctions (avec plot) ;
  • rechercher les zéros et extrema d'une fonction.

Dans le prochain chapitre, nous nous attacherons aux polynômes et aux opérations que l’on peut exécuter sur eux.