Ce document, conçu pour les étudiants en Analyse numérique de l'Université, sert de guide pratique au logiciel de calcul formel Maple. Il vise à familiariser les utilisateurs avec les fonctionnalités essentielles de cet outil puissant.
Il couvre les notions suivantes :
- Les calculs de base et formels, ainsi que les types de nombres.
- La manipulation des fonctions mathématiques, leur analyse (limites, dérivées) et leur représentation graphique.
- Le calcul intégral, les équations différentielles et les développements en séries.
- Les structures de données fondamentales et l'algèbre linéaire.
- Les éléments de programmation avec Maple.
Introduction à Maple
Maple est un système de calcul formel et un langage symbolique. Cela signifie qu'il peut manipuler non seulement des nombres, mais aussi des symboles et des expressions mathématiques.
Premiers calculs dans Maple
Pour exécuter des calculs sous Maple, il faut respecter une syntaxe spécifique : chaque instruction se termine généralement par un point-virgule (;) ou deux points (:) et est validée par la touche Entrée.
18+20;
30-14;
82*5;
12/4;
2^100;
Si vous ne souhaitez pas afficher les calculs intermédiaires, vous pouvez remplacer le symbole ; par le symbole :.
8/5:
2;
Le symbole % est très utile car il rappelle le dernier résultat calculé, qu'il ait été affiché ou non.
4^5;
%/2;
De même, les symboles %% et %%% rappellent respectivement l'avant-dernier et l'avant-avant-dernier résultat exécuté.
Calculs formels avec Maple
Maple permet d'exécuter des calculs symboliques au moyen de commandes spécifiques sous forme de fonctions :
sqrt(512)/18; # pour calculer une racine carrée
solve(x^3 - 7*x + 6 = 0, x); # pour résoudre une équation
sum(1/k, k=1..n); # pour calculer une somme
Manipulation des nombres
Les nombres entiers
Soient a, b, n et k des entiers. Voici quelques commandes utiles :
donne la décomposition en facteurs premiers deifactor(a);a
teste la primalité deisprime(a);a
détermine le PGCD deigcd(a,b);aetb
détermine le PPCM deilcm(a,b);aetb
donne le quotient dans la division euclidienne deiquo(a,b);aetb
donne le reste dans la division euclidienne deirem(a,b);aetb
calcule la factorielle den!;n
calcule le coefficient binomial (n parmi k)binomial(n,k);
Les nombres rationnels
Maple gère les calculs avec des nombres rationnels, en conservant la forme exacte :
1/8 + 13/6;
Les nombres réels
Pour les nombres réels, Maple peut les manipuler sous forme exacte :
3 + 4*sqrt(5);
Si vous souhaitez obtenir une valeur approchée, vous utiliserez la commande evalf.
sqrt(2);
evalf(sqrt(2)); # 10 chiffres significatifs par défaut
evalf(sqrt(2), 20); # 20 chiffres significatifs
Fonctions mathématiques et expressions
Fonctions trigonométriques
Maple inclut les fonctions trigonométriques standards :
sin(x),cos(x),tan(x)arcsin(x),arccos(x),arctan(x)
Fonctions trigonométriques hyperboliques
Les fonctions trigonométriques hyperboliques sont également disponibles :
sinh(x),cosh(x),tanh(x)arcsinh(x),arccosh(x),arctanh(x)
Fonctions prédéfinies
Maple propose un large éventail de fonctions prédéfinies :
logarithme népérien deln(x);x
exponentielle deexp(x);x
racine carrée desqrt(x);x
partie entière defloor(x);x(plus grand entier inférieur ou égal àx)
entier immédiatement supérieur ou égal àceil(x);x
valeur absolue deabs(x);x
Définir de nouvelles fonctions
On peut définir de nouvelles fonctions et expressions de plusieurs manières :
- Sous forme d'une expression :
a := (x^2 + 1)/(x - 2);
f := x -> 3*tan(x) - 1;
Étude de fonctions mathématiques
Limites
La commande limit permet de calculer les limites de fonctions :
f := x -> sin(x)/x;
limit(f(x), x=0);
f := x -> x + exp(-x);
limit(f(x), x=infinity);
limit(tan(x), x=Pi/2);
limit(tan(x), x=Pi/2, left);
limit(tan(x), x=Pi/2, right);
Dérivées
Pour calculer les dérivées, utilisez la commande diff ou l'opérateur D :
g := x -> x^5 - 3*x + 7;
diff(g(x), x);
h := x -> 2*sin(x);
D(h); # première dérivée
diff(h(x), x$3); # dérivée troisième
(D@@3)(h); # autre syntaxe pour la dérivée troisième
Évaluation de fonctions
Pour évaluer une fonction ou une expression en un point spécifique :
f := x -> 2*arctan(x);
f(1);
u := (sin(x))^2;
eval(u, x=sqrt(2)/2);
Représentation graphique
La commande plot permet de visualiser les fonctions :
v := 2*x^2 + 3*x - 4;
plot(v, x=-5..5);
plot(v, x=-5..5, y=-10..10, discont=true);
Calcul intégral
Maple gère les calculs d'intégrales et de primitives :
int(sin(x) - x, x); # calcul de primitive
int(sin(x) - x, x=0..Pi); # calcul d'intégrale définie
evalf(int(1/(2*sqrt(x)), x=0..Pi)); # intégration numérique
Équations différentielles
Pour résoudre des équations différentielles, utilisez la commande dsolve :
deq := diff(y(x), x$2) - 5*diff(y(x), x) - 6*y(x) = 2*exp(x);
dsolve(deq, y(x)); # résolution d'une équation différentielle
Développement en séries
Maple peut calculer des développements en séries de fonctions :
taylor(exp(-x)*sin(2*x), x=0, 6); # développement en série de Taylor autour de 0 jusqu'au terme d'ordre 6
mtaylor(sin(x^2 + y^2), {x,y}, 8, [2,1]); # développement en série de Taylor multivariable par rapport à x et y, jusqu'à l'ordre 8, autour du point [2,1]
Structures de données élémentaires
Maple offre des moyens de construire diverses structures de données :
Les listes
Pour construire une liste, il suffit d'entourer une séquence d'éléments d'une paire de crochets ([]). Les listes sont des structures ordonnées ; Maple conserve exactement l'ordre dans lequel les éléments ont été placés.
liste1 := [0,2,3,-8,5];
liste2 := [seq(i, i=1..5)]; # une liste construite par la commande seq
liste1 + liste2; # concaténer la liste2 à la liste1
liste3 := [seq(i^2, i=1..10)];
liste3[8]; # extraire le 8ème élément de la liste3
Les ensembles
Pour construire un ensemble, il suffit d'entourer une séquence d'éléments d'une paire d'accolades ({}). Maple élimine automatiquement les répétitions entre les éléments d'un ensemble.
ensemble1 := {1,2,3,4};
ensemble2 := {a,b,c,d,1,3,5,3};
Maple effectue les opérations ensemblistes habituelles :
ensemble1 union ensemble2; # la réunion de deux ensembles
ensemble1 intersect ensemble2; # l'intersection de deux ensembles
ensemble1 minus ensemble2; # la différence de deux ensembles
L'algèbre linéaire
Pour manipuler les matrices (Matrix) et les vecteurs (Vector), il existe le package LinearAlgebra qui contient un grand nombre de fonctions pour les opérations sur ces structures.
with(LinearAlgebra);
v1 := Vector([1,5,8]);
v2 := Vector([2,-5,3]);
mat1 := Matrix([[1,2,4],[3,5,1],[1,0,-2]]);
mat2 := Matrix([[7,2,-4],[4,-3,-1],[1,2,-2]]);
Pour évaluer des expressions algébriques avec matrices et vecteurs :
+et-représentent l'addition et la soustraction.*représente le produit par un scalaire..représente le produit matriciel.^représente l'élévation d'une matrice à une puissance entière, qui peut être négative pour l'inverse.
v1 + v2;
v1 - v2;
3*v1 + 2*v2;
2*mat1 - 5*mat2;
mat1 . mat2;
mat1^2;
mat2^-1;
Determinant(mat1 - x*IdentityMatrix(3)); # calcule le déterminant
Sans faire appel à ce package, on peut utiliser la fonction evalm qui permet d'évaluer les expressions algébriques matricielles :
U := array([[1,2],[3,4]]);
V := array([[1,1],[2,-1]]);
evalm(U + 2*V);
evalm(U^2);
evalm(U^(-1));
evalm(sin(U));
evalm(U * V);
Programmation en Maple
Structures alternatives (conditions)
Les structures conditionnelles permettent d'exécuter des blocs de code différents selon qu'une condition est vraie ou fausse.
if condition then action else action fi;
Exemple :
x := 2;
y := -3;
if x > y then
print("Le minimum est y=", y)
else
print("Le minimum est x=", x)
fi;
Structures répétitives (boucles)
Maple supporte des boucles pour répéter des instructions.
- Si le nombre de répétitions est connu d'avance (boucle
for) :
for i from 1 to 15 do
print(i^2)
od;
while) :x := 3;
while x < 10 do
x := x + 2;
print(x);
od;
Procédures (fonctions personnalisées)
Une procédure est un ensemble d'instructions ordonnées, similaire à une fonction dans d'autres langages de programmation. Elle se construit selon la syntaxe :
proc(donnees)
local(variables locales);
action
end;
Les variables locales sont utilisées durant l'exécution de la procédure mais ne sont pas accessibles à l'extérieur de celle-ci. Les variables globales sont utilisées durant l'exécution de la procédure et sont accessibles à l'extérieur de celle-ci.
Exemple :
restart; # réinitialisation de la session Maple
fact := proc(n)
local i, p;
p := 1;
for i from 1 to n do
p := p*i;
od;
print("Factorielle n=", p)
end;
fact(10);
Dans l'exemple ci-dessus, si vous tapez p après l'exécution de fact(10), vous recevez la lettre p car elle est locale à la procédure.
Reprenons l'exemple précédent mais déclarons la variable p comme variable globale : il suffit d'ajouter l'instruction global p; dans la procédure.
Alors, si vous tapez p, vous recevez 3628800 (la factorielle de 10) car p est désormais globale.
Foire Aux Questions (FAQ) sur Maple
Comment afficher ou masquer les résultats d'un calcul dans Maple ?
Pour afficher le résultat d'un calcul, terminez votre instruction par un point-virgule (;). Pour exécuter un calcul sans en afficher le résultat (par exemple pour une étape intermédiaire), terminez l'instruction par deux points (:).
Comment obtenir une valeur numérique approchée d'une expression symbolique ?
Utilisez la commande evalf(). Par exemple, evalf(sqrt(2)); donnera une approximation numérique de la racine carrée de 2. Vous pouvez spécifier le nombre de chiffres significatifs en ajoutant un deuxième argument, comme dans evalf(sqrt(2), 20);.
Quelle est la différence fondamentale entre une liste et un ensemble dans Maple ?
Une liste (définie par []) est une collection ordonnée d'éléments qui peut contenir des doublons. L'ordre des éléments est conservé. Un ensemble (défini par {}) est une collection non ordonnée d'éléments uniques ; Maple élimine automatiquement les doublons et l'ordre des éléments n'est pas garanti.