Université Paris xii - Val de Marne, 2008–2009 Module Libre

Université Paris xii - Val de Marne,
Module Libre Sciences L2/S3,
2008–2009
Mathématiques expérimentales
TP n◦ 0
Pour commencer : à l’aide de la souris, amener la flèche sur la case “Démarrer”.
1. Premier contact
Le mode d’intéraction de base avec Maple est le suvant : on écrit une instruction, Maple l’évalue et
renvoie le résultat. Pour signifier qu’il attend une instruction, Maple affiche le signe d’appel > .
Chaque commande doit se terminer par ; (résultat affiché) ou par : (résultat non affiché). Le signe %
représente le dernier résultat, %% l’avant-dernier et %%% l’antépénultième.
Exercice 1. Essayer :
> 2+4; 1/sqrt(2);
> % * %%;
Exercice 2. Essayer : > 2/x^2*y^3;
Exercice 3. Essayer : > 5^1/3;
Comment obtient-on
2
x2 y 3
?
Comment obtient-on 51/3 ?
Certaines fonctions mathématiques peuvent être utilisées : exp, sin, cos, sqrt,... (faire ?inifcns
pour en avoir la liste).
Exercice 4. Essayer : > I^2; cos(Pi); exp(I*Pi); sqrt(2);
Exercice 5. A partir de l’aide en ligne comprendre ce que produit la fonction igcd.
Calculer 7500 et 1000! puis leur pgcd.
Exercice 6. Sauvegarder la feuille de travail, fermer la session puis la restaurer.
1153(358 + 540 )
exactement, puis avec 5 chiffres significatifs, et finalement avec 5
295 − 736
chiffres après la virgule. On utilisera la fonction evalf.
Exercice 7. Calculer
La commande restart réinitialise la session : elle efface la mémoire de Maple et permet de se retrouver
comme au début d’une session.
2. Affectation, Évaluation
L’affectation := est une opération qui permet de nommer des expressions. Pour assigner une valeur à
un nom on utilise :
nom := expression ;
ce qui affecte à nom la valeur résultant de l’évaluation totale de expression. L’assignation se visualise
comme la création d’une flèche qui pointe vers la valeur. L’évaluation totale consiste à suivre toutes les
flèches. Par contre, un évaluation partielle de niveau n :
eval(expression, n);
consiste à ne suivre que les n premières flèches. (si l’argument n est omis, l’évaluation est totale).
Exercice 8. Essayer :
> restart;
> r:=s; s:=t; t:=2; q:=r;
> eval(r); eval(r,1); eval(r,2); eval(r,3);
> eval(s); eval(s,1); eval(s,2);
> eval(q); eval(q,1); eval(q,2);
Commenter les résultats.
Toute expression Maple syntaxiquement correcte retourne une valeur. Les nombres et les noms sans
valeur affectée sont auto-évaluables.
Exercice 9. Essayer : > 1; u;
Mécanisme de “l’évaluation totale” : une fois qu’une valeur est assignée à une variable (c’est-àdire à un nom), elle prend cette valeur partout. L’évaluation totale est donc lancée à chaque fois qu’une
variable apparaı̂t. (Il y a des exceptions à cette règle.)
Exercice 10. Essayer :
> sin(Pi); ’sin(Pi)’; %;
Quel est le rôle des apostrophes ?
Les expressions fonctionnelles de la forme
nom (arg1 , arg2 , . . . , argn )
sont évaluées de la manière suivante : tous les arguments sont évalués de gauche à droite, ensuite nom
appliqué aux arguments évalués est évalué.
Exercice 11. Essayer :
> cos(1+1);
> x:=1; cos(x+1);
> f(y,y+x,y+1);
Exercice 12. Trouver où se trouve une exception à cette règle d’évaluation des expressions fonctionnelles
dans l’exercice 8.
3. Types de données
Maple reconnaı̂t 97 types et sous-types de base. La fonction whattype donne le type de données d’une
expression. On en présente ici quelques uns.
3.1. Les constantes. Ce sont des objets dont on ne peut modifier la valeur. Les exemples importants
sont
• Les entiers (type integer), les rationnels (type rationnal), les flottants (type float)
• le nombre π (Pi), les boléens : false, true.
Exercice 13. Essayer :
> 2; 1/3; 0.2; Float(2,-1);
> whattype(2); whattype(1/3); whattype(0.2);
3.2. Les noms. Un nom (type name), qui représentent une variable, est généralement une chaı̂ne de
caractères, éventuellement suivi d’un numéro entre crochet (c’est alors un nom indexé).
Exercice 14. Essayer : > x[1]; x[2]; x[k];
Pour former un nom on ne peut pas utiliser les mots-clés (faire ?keywords pour les connaı̂tre). Maple
fait la différence entre majuscules et minuscules. Si l’on veut utiliser n’importe quel caractère pour former
un nom on utilise des accents graves :
Exercice 15. Essayer : > ‘n’importe quoi‘ := ‘quelque chose‘;
On peut utiliser l’opérateur de concaténation . (le point)
Exercice 16. Essayer : > ‘n’importe quoi‘.Deux;
3.3. Suite d’expressions (sequence ou expression sequence). C’est une famille finie et ordonnée
d’objets séparés par des virgules. La virgule , est l’opérateur de construction de suites.
Exercice 17. Essayer : > S:=a,b; S,c;
On ne peut pas former de suite de suites.
L’opérateur de sélection permet de prendre un élément ou des éléments consécutifs d’une suite :
Exercice 18. Essayer : > S:=a,b,c,c; S[2]; S[2..4];
3.4. Listes. Une liste (type list) est une suite d’expressions entre crochets. La liste vide est [ ]. La
différence avec les suites est que l’on peut former des listes de listes (et des suites de listes).
Exercice 19. Essayer : [S]; %,d; [%];
La fonction seq. Elle permet de construire des suites d’expressions. Trois exemples :
Exercice 20. Essayer :
> seq(f(i), i=1..5);
> seq(i^3, i=1..10);
Exercice 21. Construire une suite de la forme c1, c2, . . . , c15 en utilisant seq. Transformer cette suite en
liste.
Exercice 22. En utilisant la commande sum (cf. l’aide en ligne), calculer
n
X
(−1)k k 2
puis
k=1
n
X
(−1)pk k 2
k=1
où n et p sont des entiers positifs.
3.5. Autres types de données. Opérateurs : +, *,/,ˆ, Procédures,. . .
La fonction Float
3.6. Les fonctions op, nops et subsop.
• La fonction op permet d’extraire les opérandes (les composantes) d’une expression :
op(i,expr) extrait l’opérande numéro i de expr
op(i..j,expr) extrait la suite formée des opérandes de i à j
op(expr) renvoie la suite de toutes les opérandes.
• nops(expr) donne le nombre d’opérandes.
• subsop(i=operande, expr) permet de substituer operande à l’opérande numéro i de expr.
Exercice 23. Essayer : > e:=a+b*c^2+d;
> op(e);
> op(1,e); op(1..2,e);
> nops(e); subsop(2=x,e);
Exercice 24. Essayer : > L:=[a,b,c]; op(L); Comment remplacer le deuxième elément de L par x ?
4. Les itérations
4.1. Boucle do. Deux syntaxes sont possibles :
•
¯
¯
¯
¯
¯
¯
¯ for nom ¯ from expr1 ¯ by expr2 ¯ to expr3 ¯ while cond ¯ do suite d0 instructions od;
où toutes les expressions entre | peuvent être omises. La suite d0 instructions est répétée pour
chaque valeur distincte de nom tant que cette valeur est plus petite que la valeur de expr3 et
que la condition cond est vraie. La variable nom est initialement affectée de la valeur de expr1
et est incrémentée de la valeur de expr2 à chaque boucle.
Exercice 25. Essayer : > Somme:=0 :
od;
•
for i from 1 to 5 while i<5 do Somme:=Somme+i;
¯
¯
¯
¯ for nom in expr ¯ while cond ¯ do suite d0 instructions od;
nom prend successivement pour valeurs la suite des opérandes de expr.
Exercice 26. Essayer : > Somme:=0 :
od; et expliquer les résultats.
for i in [a,b,c,d,e] while i<>d do Somme:=Somme+i;
Exercice 27. Calculer la valeur minimale de n telle que
n
X
1
> 1, 7.
k!
k=1
4.2. La fonction seq. cf. section 3.
4.3. la fonction map. La commande map applique une fonction à chacun des opérandes d’une expression.
L’utilisation la plus fréquente est map(f ,L) où L est une liste, qui renvoit une liste constituée des résultats
de l’application de f à chacun des éléments de L.
Exercice 28. Essayer :
> map(sqrt,[1,2,9,z]);
> map(f,[seq(i,i=1..10)]);
5. Les tests
La syntaxe général d’un test est la suivante :
if condition1 then suite d0 instructions1
elif condition2 then suite d0 instructions2
elif condition3 then suite d0 instructions3
..
.
else conditionn then suite d0 instructionsn
fi;
Toutes les lignes, sauf la première sont optionnelles. La première suite d’instructions telle que la
condition associée soit vérifiée est exécutée, les autres ne le sont pas.
6. les procédures
Maple utilise le nom “procédure” pour dénommer ce qui correspond généralement à des “fonctions”
dans la terminologie d’un langage comme C par exemple. Nous emploierons les deux termes indifféremment.
6.1. Opérateur flèche. Le moyen le plus simple de définir une procédure qui calcule une expression
algébrique est d’utiliser la notation flèche. Par exemple la fonction qui à (x, y) associe x2 + y 2 peut être
définie par l’instruction (x,y)->x^2+y^2. On peut donner un nom à cette expression et l’utiliser de
façon naturelle :
Exercice 29. Essayer :
> ((x,y)->x^2+y^2)(2,3);
> f:=(x,y)->x^2+y^2;
> f(2,3);
6.2. La commande unapply. On regardera dans l’aide en ligne ce que produit la commande unapply.
Exercice 30. Définir une procédure correspondant à l’application
f : x 7→
20
X
(−1)k
k=0
k!
x2k+1 .
Calculer f (0), f (1),. . . ,f (20) puis la somme de ces termes. Tracer le graphe de f restreinte à l’intervalle [0, 2]
(cf. plot).
6.3. Définition d’une procédure. Il est possible de définir en Maple ses propres commandes, c’est-àdire de définir des procédures. La syntaxe générale d’une procédure est la suivante :
nom de la procédure := proc(x1::type1, x2::type2,...)
local y1, y2,...; global z1, z2,...;
options op1, op2,...;
corps de la procédure (suite d’instructions)
end;
6.4. La commande trace. On regardera dans l’aide en ligne ce que produit la commande trace.
Exercice 31. Définir une procédure somme qui prenne en entrées deux valeurs var1 et var2 et qui calcule
la somme des carrés des entiers compris entre ces deux valeurs.
Essayer :
> somme(1,4);
puis
> trace(somme);
> somme(1,4);
Que fait la commande trace.
6.5. Procédure récursive. Ainsi est qualifiée une procédure qui apparaı̂t dans sa propre définition.
Exercice 32. Essayer : > F:=n-> if n<2 then 1; else F(n-1)*n; fi;
Que produit la procédure F ?
Exercice 33. Ecrire une fonction U, définie récursivement, qui renvoie la valeur de un où (un )n∈N est la
suite de Fibonacci définie par
u0 = 0, u1 = 1,
un = un−1 + un−2
∀n ≥ 2.
Exercice 34.
• Ecrire une procédure H qui donne la valeur de la somme partielle de la série harmonique :
n
X
1
.
Hn =
i
i=1
• Pour quelles valeurs de n le rationnel Hn est-il entier ?
• Essayer de comprendre pourquoi en observant la décomposition en facteurs premiers du numérateur
et du dénominateur (cf. fonction ifactor).
• Obtenir ainsi une conjecture. . . à démontrer par récurrence sur n.