Notes de cours maple. Alain JEAN-MARIE. *. Annie HOFSTETTER. †. Juin 2002.
*LIRMM Montpellier. †INRA LAMETA Montpellier ...
Notes de cours maple Alain JEAN-MARIE Annie HOFSTETTERy Juin 2002
y
LIRMM Montpellier INRA LAMETA Montpellier
Table des matières 1 Introduction
1.1 Dé nition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.2 Accès sur le campus . . . . . . . . . . . . . . . . . . . . . . . . 1.3 Accès à l'aide . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2 Prise en main 2.1 2.2 2.3 2.4
3 4 5 6
Notation . . . . . . La feuille de calcul Conventions . . . . Opérateurs . . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
Ce que peut faire Maple Ce que Maple ne peut pas faire Problème de l'évaluation des symboles Structures de données 6.1 6.2 6.3 6.4 6.5 6.6
Les ensembles . . . . . . . . . . . . . . . Les listes . . . . . . . . . . . . . . . . . . Les tables . . . . . . . . . . . . . . . . . Les "table-array" . . . . . . . . . . . . . Les matrices . . . . . . . . . . . . . . . . Passage entre les structures de données .
. . . .
. . . . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
Manipulations simples . . . . . . . . . . . . Coe cients des polynômes . . . . . . . . . . Intégration . . . . . . . . . . . . . . . . . . Factorisation et décomposition de fractions Développements . . . . . . . . . . . . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
8 Algèbre linéaire 8.1 8.2 8.3 8.4 8.5 8.6 8.7
. . . .
. . . . . .
7 Manipulations sur les fonctions 7.1 7.2 7.3 7.4 7.5
. . . .
Matrices . . . . . . . . . . . . . . Résolution de systèmes linéaires . Vecteurs propres . . . . . . . . . Systèmes d'équations généraux . Equations diérentielles . . . . . Développements en série . . . . . Système d'équations . . . . . . . 1
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
3
3 3 3
4
4 4 4 5
5 6 7 9
9 9 10 11 13 14
15
15 16 17 19 20
22
22 24 25 27 30 31 34
9 Graphiques 10 Programmation
36 39
10.1 Tests et conditions . . . . . . . . . . . . . . . . . . . . . . . . . 39 10.2 Boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 10.3 Procédures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
11 Fichiers, entrées/sorties, sauvegardes
11.1 Sauvegarde des instructions . . . . . . . . . . . . 11.2 Utilisation des procédures dans un chier externe 11.3 Communication . . . . . . . . . . . . . . . . . . . 11.3.1 Fichier texte . . . . . . . . . . . . . . . . 11.3.2 Sélection . . . . . . . . . . . . . . . . . . . 11.3.3 Feuille de calcul . . . . . . . . . . . . . . 11.3.4 Format HTML . . . . . . . . . . . . . . . 11.3.5 Graphiques . . . . . . . . . . . . . . . . . 11.3.6 Postscript . . . . . . . . . . . . . . . . . . 11.4 Fonctions d'édition de la feuille de calcul . . . . .
2
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
43
43 43 45 45 45 45 45 46 46 46
1 Introduction 1.1 Dé nition
maple7 est un logiciel de calcul formel ou symbolique comme Mathematica,
Axiom ; tandis que des langages tels que Pascal, C, C++, Java, Matlab, sont destinés à manipuler des nombres.
1.2 Accès sur le campus
L'acquisition a été faite pour utiliser 6 licences simultanées au maximum. C'est le gestionnaire de licence qui empêche le 7e appel au programme. A termes, l'installation sous la forme de licences ottantes devrait permettre aux utilisateurs de lancer l'application depuis n'importe quelle plateforme (pc ou tx, depuis windows ou unix). Sur les pc avec un système d'exploitation windows*, ce type d'accès nécessite d'installer l'application cliente sur les postes de travail. Ensuite l'accès se fait par Démarrer > Programmes > Maple7 > Maple7 Dans le cas d'utilisation sous unix, l'accès pourrait se faire depuis une session telnet soit depuis un pc soit depuis un terminal. L'interface graphique se présente sous la forme d'une fenêtre avec un menu, des barres d'outils et un espace de travail. La fenêtre principale est l'espace de travail où le signe ">" représente le prompt c'est à dire que maple est prêt à travailler et attend qu'une instruction soit entrée à ce niveau a n de l'exécuter. L'interface laisse la possibilité d'avoir plusieurs feuilles de travail ouvertes dans la même application. La navigation se fait alors de page en page.
1.3 Accès à l'aide
Documentation : Les livres pédagogiques sont sans doute nombreux. Des supports de cours existent sur le net (Mourrain & Papegay inria, Salvy). Aide en ligne : Le menu help introduction assure une navigation de rubrique en rubrique. L'accès direct peut se faire à partir de la ligne de commande : >? solve accès à la fenêtre d'aide relative à la commande solve > ? sol accès à la liste des commandes dont le nom commence par sol >
?solve
3
2 Prise en main 2.1 Notation
Une instruction est saisie au clavier derrière le prompt ">". Le point virgule représente la n de l'instruction. > f : = x^2 + x + 1 ; # commentaire L'expression x^2 + x + 1 est une formule avec le symbole x , un symbole non évalué, une variable libre. : = symbolise l'aectation. f représente le nom de la variable qui devient ici une fonction de x. # est un commentaire. Le point virgule à la n d'une instruction demande son exécution et l'a chage du résultat > f: = x^2 + x + 1 : tandis que les deux points à la place du point virgule n'a chent pas le résultat. Ce qui peut être utile en cas de résultat intermédiaire, bien qu'il y ait une aectation par derrière. Une formule longue ou une indentation est appliquée grâce à shift return qui permet de poursuivre une ligne sans demander la n de l'instruction par une validation avec return. Il n'y a donc pas de message d'invitation à donner une suite à l'instruction. On peut ainsi mettre plusieurs instructions sur une même ligne. > a : = 2 : b : = 3 ; n'a che que la variable b et son aectation. > a : = 'a' ; b : = unassign('b') ; ces deux commandes permettent de remettre à zéro l'initialisation.
2.2 La feuille de calcul
Nous avons vu qu'une feuille est une interface entre l'utilisateur et le moteur de Maple (dénommé server 1 sur le nom de la feuille), qui reçoit des instructions et les exécute séquentiellement. Attention toutefois, car l'ordre d'exécution n'est pas forcément l'ordre visuel. De plus, cela signi e qu'il n'y a rien en mémoire dans une feuille Maple : charger la feuille ne su t pas à refaire les instructions. Pour réexécuter les instructions : Menu Edit > Execute > Worksheet
2.3 Conventions
Pour les noms de variables, toutes les lettres sont autorisées. La casse a de l'importance. 4
Les chires sont autorisés à condition que le nom ne commence pas par un chire. De même, le caractères surligné "_" est utilisable.
2.4 Opérateurs
Les opérateurs arithmétiques : + * - / ^ Les opérateurs logiques : < >= and or not >
f := x^2 + x + 1 ;
>
xx=2 ; yy:=3 ; # égalité et affectation
>
u:=1/(x-1)*(x+2) ;
>
u:=1/(x-1)/(x+2) ;
f := x2 + x + 1
xx := 2 yy := 3 Notons au passage la notation des deux lignes d'instructions suivantes.
+2 u := xx ; 1
u := (x ; 1)1(x + 2)
3 Ce que peut faire Maple Maple sait faire des manipulations algébriques sur les formules composées
de variables, de symboles. > f: = x + 2 ; Maple n'a pas besoin de savoir ce qu'est x, on suppose que x supporte l'addition, etc. Il sait faire des dérivées, intégrales, factorisations ou résoudre des systèmes d'équations. Il sait faire des manipulations numériques, calculer des nombres, faire des graphiques. Il fait du calcul arbitraire sur les nombres entiers, rationnels, les polynômes. Maple essaie de faire du calcul exact autant que possible. >
f:= a*x+b : solve(f,x) ;
>
(3/2)^100;
; ab
515377520732011331036461129765621272702107522001 1267650600228229401496703205376 5
>
1.5^100;
>
r:=(3/2)^100 : evalf(r) ;
:4065611775 1018 :4065611775 1018
4 Ce que Maple ne peut pas faire Pour des raisons théoriques, on ne peut pas tester l'égalité à zéro. Si
une expression est trop compliquée (sin, lg) alors il n'est pas possible d'a rmer si elle vaut 0 ou non. Par contre si cette expression est un polynôme, alors c'est possible ; le polynôme nul vaut 0 tout le temps. Notons que si la formule utilise des sin, log, etc., on peut aboutir à des formules qui ne se simpli eront jamais. Maple ne simpli e pas spontanément les expressions. On le lui demande par l'appel de la fonction simplify(). >
f := (x+1)^2 - 2*x - x^2 - 1 ;
>
f:= simplify(f) ;
f := (x + 1)2 ; 2 x ; x2 ; 1 f := 0
Maple fait de son mieux pour résoudre des équations ou factoriser des
formules. S'il ne trouve pas de solution (pour solve par exemple), il renvoie un résultat vide. Dans le cas d'un polynôme de degré supérieur ou égal à 5, il n'existe pas de formule de calcul des racines. L'expression retournée de type RootOf(...) est toutefois exploitable par Maple. >
solve(f);
Si la taille du symbole est trop grande ou si l'algoritme est trop long, alors
c'est un échec. Il existe un bouton stop permettant d'interrompre un calcul trop long. Parfois ce bouton ne su t pas et il faut tuer l'application. Penser à sauvegarder son travail ! ! Il peut y avoir un problème de précision numérique classique. La valeur par défaut du nombre de chires signi catifs est Digits: =10. Il faut donc faire attention aux manipulations de formules et autres inversions de matrices ! >
>
v:=(log(640320^3+744)/Pi)^2;
2
v := ln(262537412640768744) 2
Digits := 20 ; evalf(v) ;
6
Digits := 20 162:99999999999999999 >
Digits := 40 ; evalf(v) ;
Digits := 40 163:0000000000000000000000000000232167780
5 Problème de l'évaluation des symboles Maple évalue les formules le plus loin possible, c'est à dire tant qu'il peut remplacer les symboles qui ont une valeur. >
f:=x^2 ;
>
x:=y ;
>
f ;
>
g:=x^2 ;
>
x:=12 ;
>
f; # f n'a pas changé
>
g; # g non plus !
f := x2 x := y y2 g := y2 x := 12 144
y2
Il faut donc faire attention à l'ordre d'aectation des symboles : le résultat semble le même, bien qu'en mémoire ce soit diérent ! >
a:=val ; b:=a ; c:=b ; a; b; c;
a := val b := val c := val val val val
>
val:=10 ; a; b; c;
val := 10 10 10
7
10 >
val:=c ;
>
b:='b' ; a; b; c; val ;
val := 10
b := b 10
b
10 10 >
val:=20 ; a; b; c; val ;
val := 20 20
b
20 20 >
z:=t ; t:=z^2 ; # récursif !
z := t
Error, recursive assignment >
t:=10 ; z:=t ; t:=z^2 ;
l'initialisation est une solution !
t := 10 z := 10 t := 100
Pour éviter ces problèmes d'évaluation, il vaut mieux ne jamais donner de valeurs numériques aux variables et utiliser la fonction de substitution. >
f:=x^2+x+1 ;
>
subs(x=3,f) ;
>
f ;
f := x2 + x + 1 13
f n'a pas changé de nature !
x2 + x + 1
Il est possible d'eectuer plusieurs substitutions avec de nombreuses variables en même temps. 8
>
f:=x^2 + 3*a*x +1 ;
>
subs({x=3,a=2},f) ;
>
subs({x=a^2,a=2},f) ;
f := x2 + 3 a x + 1
28 Attention aux substitutions récursives...
a4 + 6 a2 + 1
Il faut procéder en deux temps : >
subs(a=2,subs(x=a^2,f)) ;
41
Information utile : > anames() permet de savoir quelles sont les variables utilisées, y compris celles du système parfois nombreuses ! >
anames() :
6 Structures de données 6.1 Les ensembles
Un ensemble de symboles est toujours évalué si les valeurs sont assignées. Un ensemble n'est pas ordonné ; Maple peut donc à tout moment changer l'ordre des éléments. >
A:={a,b,x^2+1} ;
>
B:={A,C} ;
A := fa; b; x2 + 1g
B := fC; fa; b; x2 + 1gg
On peut appliquer les opérations classiques sur les ensembles. >
A union B ;
>
A intersect B ;
fa; b; C; x2 + 1; fa; b; x2 + 1gg fg
6.2 Les listes
Une liste est un ensemble ordonné dont les éléments sont numérotés à partir de 1. >
l:=[a,b,d];
l := [a; b; d] 9
>
l[1] ; # 1er élément de la liste
>
a:=[10,11] ; # un élément peut être une liste également
a
a := [10; 11]
>
l;
>
l[1][2] ; #le 2nd membre du 1er élément de l
>
l[4] ; # le 4ème élément n'existe pas
[[10; 11]; b; d] 11
Error, invalid subscript selector
Ajout d'un élément à une liste >
l:= [op(l),e5] ;
l := [[10; 11]; b; d; e5 ] Concaténation de deux listes, par exemple une liste avec elle-même : dans une liste on peut avoir 2 fois le même élément, contrairement aux ensembles. >
l:= [op(l),op(l)] ;
l := [[10; 11]; b; d; e5 ; [10; 11]; b; d; e5 ] Une façon de fabriquer une "liste" est d'utiliser la fonction seq (séquence) qui produit une suite que l'on peut mettre dans une liste. >
st:=seq(n*n,n=1..10) ; # création de la séquence d'éléments
>
l:=[st] ; # affectation à une liste
st := 1; 4; 9; 16; 25; 36; 49; 64; 81; 100 La séquence est constituée des carrés des nombres allant de 1 à 10.
l := [1; 4; 9; 16; 25; 36; 49; 64; 81; 100]
6.3 Les tables
Les tables sont des objets généraux qui assurent la correspondance entre deux valeurs (tableau indicé). >
t[1]:=3;
>
t[12]:=8 ;
>
op(t) ;
t1 := 3 L'instruction précédente vient de créer implicitement le tableau t et d'assigner la valeur 3 dans le 3e élément de ce tableau. t12 := 8 table([1 = 3; 12 = 8]) 10
>
t[6] ;
>
t[1/2]:=7 ;
t6 t1 2 := 7 =
>
t[(a,b,c)]:=x ; # table d'une suite
t[10 11]
:= x Une table représente un espace de stockage ou encore une manière d'associer une valeur à une famille d'objets. C'est un tableau associatif où à un indice correspond une valeur. ;
; b; c
La fonction op() permet d'obtenir une représentation de ce qu'il y a à l'intérieur d'un tableau, mais elle n'est pas très pratique. La fonction indices retourne la liste des valeurs des indices et non pas le contenu. >
tbl[[a,b,c]]:=x ; tbl[1/2]:=7 ; indices(tbl) ;
tbl [ ] := x tbl 1 2 := 7 [[a; b; c]]; [ 21 ] La fonction entries permet d'obtenir la liste des valeurs contenues dans le tableau. a; b; c =
>
entries(tbl) ;
>
tab[1,3]:=y ;
[x]; [7] Les deux instructions suivantes sont diérentes. La première fait référence à un élément d'un tableau à 2 dimensions. Tandis que la seconde représente le 3ème élément de l'objet tab[1] qui est un tableau à une dimension. tab 1 3 := y ;
>
tab[1][3]:=y ;
tab 13 := y Le tableau est une structure puissante mais elle n'est pas forcément la plus e cace.
6.4 Les "table-array"
Il s'agit d'une table avec des indices numériques dans un certain intervalle, que l'on appelle "array" sous Maple. L'instruction suivante dé nit un array dont les indices vont de 1 à 10. >
a:=array(1..10) ;
a := array(1::10; []) 11
>
a[3] ;
>
a[13] ; # en dehors de l'intervalle
a3
Error, 1st index, 13, larger than upper array bound 10 >
a[0] ; # l'intervalle commence à 1
Error, 1st index, 0, smaller than lower array bound 1 >
b:=array(0..2,[x,y,z]) ;
b := array(0::2; [ (0) = x (1) = y (2) = z
]) Si la liste est trop courte, tous les éléments ne sont pas initialisés. Si la liste est trop longue, Maple refuse de le faire. >
b:=array(0..2,[x,y]);
b := array(0::2; [ (0) = x (1) = y (2) = b2 ])
>
b:=array(0..2,[x,y,z,t]);
Error, (in index/fill) a list with 4 entries cannot be used to initialize the range 0 .. 2
Par exemple nous proposons de déclarer un tableau puis de le remplir de zéros. >
n:= 10 ; # taille du tableau
>
b:=array(1..n,[0$n]);# $ est l'opérateur de répétition
n := 10
b := [0; 0; 0; 0; 0; 0; 0; 0; 0; 0]
Dans l'exemple suivant, la boucle qui remplit le tableau est cachée à l'intérieur de la fonction de création du tableau. On obtient la liste des valeurs i répétées pour la valeur d'une variable allant de 1 à n (n=10). >
c:=array(1..n,[i$i=1..n]) ;
c := [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
Tableaux à plusieurs dimensions : >
d2:=array(1..3,1..4) ;
12
d2 := array(1::3; 1::4; []) >
d2[0,0] ; # en dehors des bornes
Error, 1st index, 0, smaller than lower array bound 1 >
d2[1,3]:=3 ;
>
d2[2] ; # le tableau est à deux dimensions
d2 1 3 := 3 ;
Error, array defined with 2 indices, used with 1 indices >
b2:=array(1..3,1..4,[0$12]) ; # non autorisé
Error, (in index/fill) a list with 12 entries cannot be used to initialize the range 1 .. 3
Cet exemple nécessite une liste de 3 éléments, chacun étant une liste de 4 autres éléments. >
b2:=array(1..3,1..4,[[0$4]$3]);
2 3 0 0 0 0 b2 := 64 0 0 0 0 75 0 0 0 0
>
b2:=array(1..4,1..3,[[0$3]$4]);
2 3 0 0 0 6 7 b2 := 664 00 00 00 775 0 0 0
6.5 Les matrices
Il existe peu de diérence entre les structures array et matrice. Dans une matrice les indices sont toujours dé nis à partir de 1. La matrice est un objet algébrique ce qui nécessite de charger la bibliothèque spéci que aux traitements d'algébre linéaire. >
with(linalg) : # ":" est moins bavard que ";"
>
M := matrix(4,4,[0$16]);
2 3 0 0 0 0 6 7 M := 664 00 00 00 00 775 0 0 0 0
>
p:=charpoly(M,Z) ; # renvoie le déterminant (M-ZI)
p := Z 4 13
6.6 Passage entre les structures de données
Lorsqu'il est possible, le passage d'une structure de données à une autre se fait grâce à l'instruction convert. >
convert(M,array) ;
2 3 0 0 0 0 66 0 0 0 0 77 64 0 0 0 0 75 0 0 0 0
>
whattype(M) ;
symbol
>
whattype(op(M)) ; # renvoie le type de M
>
type(M,matrix) ;
>
type(M,array) ; # une matrice est un array
array true
true Convert calcule un objet de type array à partir de la matrice M. L'objet M ne change pas de type. M peut recevoir le résultat de la conversion (ce qui est rare), mais cela détruira le contenu antérieur de M.
> matrix(m,n,[]) ;
est équivalent à : > array(1..m,1..n,[]) ; On peut fabriquer une array monodimensionnelle ou bidimensionnelle. Ces objets ne sont pas des matrices. >
array(1..3,[a,aa,aaa]) ;
[a; aa ; aaa ]
>
b:=array(1..2,1..3,[[0$3] $2]) ;
"
b := 00 00 00 >
>
convert(b,matrix) ;
"
0 0 0 0 0 0
#
#
convert(b,list) ; # impossible
Error, (in convert/list) can't convert array of dimension > 1
14
>
b:=matrix(3,3,[i$i=1..9]) ;
2 3 1 2 3 b := 64 4 5 6 75 7 8 9
>
convert(b,listlist) ; # liste de listes
>
convert(tbl,list) ;
>
convert(tbl,array) ; # impossible
[[1; 2; 3]; [4; 5; 6]; [7; 8; 9]] [x; 7]
Error, (in index/FillInitVals) unevaluated array index in assignment
Il faut veiller à ne pas perdre le contenu d'un tableau ou les autres données telles que les symboles importants ! >
c:=x ; # le contenu de c est perdu !
c := x
7 Manipulations sur les fonctions 7.1 Manipulations simples f est une fonction de x. >
f:=x^2 + a*x +1 ;
>
df:= diff(f,x) ;
>
dfa:=diff(f,a) ;
> >
f := x2 + a x + 1 df := 2 x + a dfa := x
dfg:=diff(f,g) ;# f ne dépend pas de g
dfg := 0
>
df2:=diff(f,x,x) ;
>
df2:=diff(f,x$2) ; # x$2 vaut x,x
>
res:=diff(f,x,a)-diff(f,a,x) ;
>
f4:=f**4 ;
df2 := 2 df2 := 2 res := 0
f4 := (x2 + a x + 1)4
15
>
f4:=expand(f4) ; # pas de hiérarchisation des puissances
f4 := 1 + 4 a3 x3 + 4 x6 + 12 x5 a + 12 x4 a2 + x8 + 6 x4 + 12 x3 a + 6 a2 x2 + 4 a x + 6 x6 a2 + 4 x5 a3 + a4 x4 + 4 x7 a + 4 x2 >
sort(f4,x) ; # puissances décroissantes par défaut
x8 + 4 a x7 + 4 x6 + 6 a2 x6 + 12 a x5 + 4 a3 x5 + 12 a2 x4 + a4 x4 + 6 x4 + 4 a3 x3 + 12 a x3 + 6 a2 x2 + 4 x2 + 4 a x + 1 >
sort(f4,[x,a],plex) ; # tri en x et a, puiss. lexicographiques
x8 + 4 x7 a + 6 x6 a2 + 4 x6 + 4 x5 a3 + 12 x5 a + x4 a4 + 12 x4 a2 + 6 x4 + 4 x3 a3 + 12 x3 a + 6 x2 a2 + 4 x2 + 4 x a + 1 >
collect(f4,x) ; # rassemble les coeff par puissances de x
x8 + 4 x7 a + (6 a2 + 4) x6 + (12 a + 4 a3) x5 + (a4 + 12 a2 + 6) x4 + (12 a + 4 a3) x3 + (6 a2 + 4) x2 + 4 x a + 1 >
collect(f4,x,sort) ;
x8 + 4 x7 a + (6 a2 + 4) x6 + (4 a3 + 12 a) x5 + (a4 + 12 a2 + 6) x4 + (4 a3 + 12 a) x3 + (6 a2 + 4) x2 + 4 x a + 1 >
collect(f4,[x,a]) ;
x8 + 4 x7 a + (6 a2 + 4) x6 + (4 a3 + 12 a) x5 + (a4 + 12 a2 + 6) x4 + (4 a3 + 12 a) x3 + (6 a2 + 4) x2 + 4 x a + 1
7.2 Coe cients des polynômes >
coeff(f4,x,6) ;
>
coeffs(f4,x) ; # liste de tous les coeffs
>
coeffs(expand((x^2+1)^3),x) ; # non ordonné incomplet
>
degree(expand((x^2+1)^3),x) ;
6 a2 + 4
1; 4 a; 6 a2 + 4; a4 + 12 a2 + 6; 6 a2 + 4; 1; 12 a + 4 a3; 12 a + 4 a3 ; 4 a
> >
> >
1; 1; 3; 3 6
seq(coeff(x^6+3*x^4+3*x^2+1,x,i),i=0..degree(x^6+3*x^4+3*x^2+1,x)) ; # ordonné et complet
1; 0; 3; 0; 3; 0; 1
[seq(coeff(x^6+3*x^4+3*x^2+1,x,i),i=0..degree(x^6+3*x^4+3*x^2+1,x))] ; # liste
[1; 0; 3; 0; 3; 0; 1] 16
7.3 Intégration >
int(f4,x) ; # polynôme résultant de l'intégration
1 x9 + 1 x8 a + 6 x7 a2 + 4 x7 + 2 x6 a3 + 2 x6 a + 1 x5 a4 + 12 x5 a2 + 6 x5 + x4 a3 + 3 x4 a 9 2 7 7 3 5 5 5 4 + 2 x3 a2 + 3 x3 + 2 x2 a + x >
int(f4,x=1..y) ;
1 y 9 ; 10 + 1 a (y 8 ; 1) + 1 (6 a2 + 4) (y 7 ; 1) + 1 (4 a3 + 12 a) (y 6 ; 1) 9 9 2 7 6 1 1 + 5 (a4 + 12 a2 + 6) (y 5 ; 1) + 4 (4 a3 + 12 a) (y 4 ; 1) + 13 (6 a2 + 4) (y 3 ; 1) + 2 a (y 2 ; 1) + y >
ig:=int(f4,x=1..y) ;
10 1 1 1 1 ig := y 9 ; + a (y 8 ; 1) + (6 a2 + 4) (y 7 ; 1) + (4 a3 + 12 a) (y 6 ; 1) 9 9 2 7 6 1 1 4 2 5 3 4 + (a + 12 a + 6) (y ; 1) + (4 a + 12 a) (y ; 1) + 1 (6 a2 + 4) (y 3 ; 1) 5 4 3 2 + 2 a (y ; 1) + y >
simplify(ig) ; # formule magique
1 4 5 12 2 5 3 4 4 2 3 2 5 3 1 4 6 ; 15 2 a+y + 5 a y + 5 a y +a y + 3ay + 2a y + 2ay ; 3 a ; 5 a + 2ay 2 ; 1328 + 1 a y 8 + 6 a2 y 7 + 23 a3 y 6 + 91 y 9 + 56 y 5 + 43 y 3 + 74 y 7 ; 184 a 35 315 2 7 > >
expand(ig) ; # expand préférée à simplify pour les produits (id dans ce cas)
2 y 5 + a3 y 4 + 3 a y 4 + 2 a2 y 3 + 2 a y 2 ; 5 a3 ; 1 a4 + 2 a y 6 a ; 152 a + y + 15 a4 y5 + 12 5 3 5 2 1328 1 8 6 2 7 + 23 a3 y 6 + 91 y 9 + 56 y 5 + 43 y 3 + 74 y 7 ; 184 35 a ; 315 + 2 a y + 7 a y >
int(1/f4,x) ;
17
1 2x+ a 2 3 (4 ; a ) (x2 + x a + 1)3
0 0 2 x + a )11 p 4 arctanh( BB CC B 2x+ a ;4 + a2 C C p ; 3B BB @(4 ; a2) (x2 + x a + 1) (4 ; a2) ;4 + a2 ACC B CC 10 B1 2x+a + B CC 3 B 4 ; a2 BB2 (4 ; a2) (x2 + x a + 1)2 CC B@ CA
+
4 ; a2
>
int(sqrt(1/f4),x) ; # Maple réussit souvent !
p p (;2 ;4 + a2 x ; ;4 + a2 a + 4 arctanh( p2 x + a 2 ) x2 + 4 arctanh( p2 x + a 2 ) x a ;4 + a ;4 + a . + 4 arctanh( p2 x + a 2 ))(x2 + x a + 1)(1 (x8 + 4 x7 a + 6 x6 a2 + 4 x6 + 4 x5 a3 ;4 + a + 12 x5 a + x4 a4 + 12 x4 a2 + 6 x4 + 4 x3 a3 + 12 x3 a + 6 x2 a2 + 4 x2 + 4 x a + 1)) . (1 2) (;4 + a2 )(3 2) =
=
>
int(1/f^(1/3),x) ; # Maple essaie quand même !
Z
1
dx (x2 + x a + 1)(1 3) =
Il existe une diérence entre évaluation numérique et évaluation formelle >
int(1/f4,x=1..2) ;
Z2 . 1 (x8 + 4 x7 a + 6 x6 a2 + 4 x6 + 4 x5 a3 + 12 x5 a + x4 a4 + 12 x4 a2 + 6 x4 + 4 x3 a3 1 + 12 x3 a + 6 x2 a2 + 4 x2 + 4 x a + 1)dx >
int(1/f4,x);
1 2x+ a 2 3 (4 ; a ) (x2 + x a + 1)3
0 0 11 2 x + a p 4 arctanh( BB C BB 2 )C 2x+ a ; 4 + a p 3 ; BB @(4 ; a2) (x2 + x a + 1) (4 ; a2) ;4 + a2 CACCC CC 10 B 2x+a BB1 + CC 3 B 4 ; a2 BB2 (4 ; a2) (x2 + x a + 1)2 CC B@ CA
+
4 ; a2 18
>
fa:=subs(a=3,f4) ; # évacue le pb du paramètre a
>
v:=int(1/fa,x=1..2) ; # résultat avec partie réelle
>
evalc(v) ; # évaluation/simplification d'un nombre complexe
>
evalf(v) ;
fa := x8 + 12 x7 + 58 x6 + 144 x5 + 195 x4 + 144 x3 + 58 x2 + 12 x + 1
10946 + 8 p5
factor(f4) ;
>
h:=diff(1/f4,x) ;
(x2 + x a + 1)4
19
h := ;(8 x7 + 28 x6 a + 36 x5 a2 + 24 x5 + .20 x4 a3 + 60 x4 a + 4 x3 a4 + 48 x3 a2 + 24 x3 + 12 x2 a3 + 36 x2 a + 12 x a2 + 8 x + 4 a) (x8 + 4 x7 a + 6 x6 a2 + 4 x6 + 4 x5 a3 + 12 x5 a + x4 a4 + 12 x4 a2 + 6 x4 + 4 x3 a3 + 12 x3 a + 6 x2 a2 + 4 x2 + 4 x a + 1)2 >
h:=factor(h);
>
numer(h) ;
>
denom(h) ;
h := ;4 (x2 +2 xx+a +a 1)5
;8 x ; 4 a
(x2 + x a + 1)5 Il n'y a pas de règles quant à l'écriture : Maple limite l'expression ; ne pas toujours faire con ance à Maple, ne pas s'attendre à ce que le dénominateur soit toujours positif par exemple.
7.5 Développements >
ty:=taylor(h,x=1,8) : # à tester sur son poste...
>
simplify(ty) ;
renvoie le développement de Taylor de h au voisinage de 1 à l'ordre 8. 2 ;4 (2 +1 a)4 + 4 (28 ++ 5a)a5 (x ; 1) ; 60 (21++aa)5 (x ; 1)2 + 20 6 +(216+a a+)67 a (x ; 1)3; 21 a + 14 a2 (x ; 1)4 + 12 ;24 + 49 a + 112 a2 + 42 a3 (x ; 1)5; 20 1 + (2 + a)6 (2 + a)7 2 3 3 33 a4 + 36 a2 28 ;19 ; 4 a(2++54a)a7 + 30 a (x ; 1)6 + 40 ;25 ; 64 a +(296+a a+ )8 (x ; 1)7 + O((x ; 1)8) >
convert(ty,polynom) : id sans "O" à tester
>
qw:= subs(a=-2,h) ;
>
simplify(qw) ;
Parfois Maple donne un développement à un ordre inférieur à cause de ses calculs intermédiaires. La solution est de demander un développement à un ordre supérieur.
>
factor(qw) ;
2x;2 qw := ;4 2 (x ; 2 x + 1)5
;8 (x ; 1) (x21; 2 x + 1)4 20
;8 (x ;1 1)9
>
taylor(qw,x=1) ; # par défaut ordre 6
on obtient une erreur mais Maple propose la fonction series Error, does not have a taylor expansion, try series() >
series(qw,x=1) ;
>
series(u,x=1) ;
;8 (x ; 1);9
1 (x ; 1);1 ; 1 + 1 (x ; 1) ; 1 (x ; 1)2 + 1 (x ; 1)3 ; 1 (x ; 1)4 + 1 (x ; 1)5+ 3 9 27 81 243 729 2187 O((x ; 1)6) Quelques compléments sur les développements de Taylor, limité, de Laurent (extensions de dérivées limites). >
u2 := u*(exp(x-1)-1) ;
u2 := >
subs(x=1,u2) ;
e( ;1) ; 1 (x ; 1) (x + 2) x
Error, numeric exception: division by zero >
limit(u2,x=1) ;
>
limit(u2,x=1.0) ;
>
subs(x=1.0,u2) ;
1 3
:3333333333
Float(1) e0 ; Float(1) Remarquons que l'écriture des paramètres est inversée entre subs et limit. :
Maple fait le développement limité pour calculer la singularité. Par ailleurs, il existe un paradoxe. En eet on demande le développement limité. Puis on remplace le paramètre a. Le retour ne se fait pas forcément car les calculs intermédiaires le bloquent peut-être. >
pty:=convert(ty,polynom) : # à tester
>
ptz:=subs(x-1=z,pty) :
>
st:=seq(coeff(ptz,z,1),i=0..degree(ptz,z));
21
st := %1; %1; %1; %1; %1; %1; %1; %1 %1 := ;8 (2 +1 a)5 + (2 +20a)4
>
map(factor,st);
Error, (in factor) wrong number of arguments
On observe que les coe cients ne sont pas dé nis si a=0. Maple trouve les formules génériques sans hypothèses particulières.
8 Algèbre linéaire 8.1 Matrices
Initialisation d'une matrice avec une fonction où le coe i,j est i^j : >
M:=matrix(3,3,(i,j)->x[i]^j) ;
2 2 x1 3 3 x x 1 1 M := 64 x2 x22 x23 75 x3 x32 x33
Il faut songer à charger le package linalg ! >
with(linalg) :
>
det(M) ;
>
factor(det(M)) ;
x1 x22 x33 ; x1 x23 x32 ; x2 x12 x33 + x2 x13 x32 + x3 x12 x23 ; x3 x13 x22
;x3 x2 x1 (;x2 + x1) (;x1 + x3) (x3 ; x2)
multiply(M,M) ;
2 2 2 3 3 2 2 3 2 4 2 3 3 3 64 xx12 x+1 +x1x2x32++xx213 xx33 xx112+x2x+1 xx224 ++xx213 xx332 xx12 x+13x+1 xx225 ++xx213 xx333 x3 x1 + x32 x2 + x34 x3 x12 + x32 x22 + x35 x13 x3 + x23 x32 + x36 evalm(M &* M) ; # équivalent à multiply(M,M) 2 2 2 3 3 2 2 3 2 4 2 3 3 3 64 xx12 x+1 +x1x2x32++xx213 xx33 xx112+x2x+1 xx224 ++xx213 xx332 xx12 x+13x+1 xx225 ++xx213 xx333 >
>
x3 x1 + x32 x2 + x34 x3 x12 + x32 x22 + x35 x13 x3 + x23 x32 + x36
> evalm permet d'évaluer la matrice avec des opérations sur les matrices. L'opérateur &* est la multiplication de matrices. >
evalm(M**2) ;
22
3 75 3 75
2 2 2 3 x + x1 x2 + x13 x3 x1 3 + x1 2 x2 2 + x1 3 x3 2 x14 + x12 x23 + x13 x33 1 64 x2 x1 + x23 + x23 x3 x12 x2 + x24 + x23 x32 x2 x13 + x25 + x23 x33 75 2 4 2 2 2 5 3 3 2 6 x3 x1 + x3 x2 + x3
>
x3 x1 + x3 x2 + x3
Minv:=evalm(M^(-1)) ;
x1 x3 + x2 x3 + x3
2 x3 x2 x1 x3 x1 x2 %1 x3 66 ; %3 x1 %2 x2 6 x3 + x2 x3 + x1 x1 + x2 Minv := 66 %3 x ; %2 x ; %1 x 1 2 3 64 1 1 1 ; %3 x %2 x2 %1 x3 1 2 %1 := ;x3 x1 + x2 x1 + x3 ; x2 x3 %2 := ;x2 x3 + x3 x1 + x2 2 ; x2 x1 %3 := ;x2 x3 + x3 x1 + x2 x1 ; x1 2
>
3 77 77 77 5
simplify(%) ; # % dernier résultat %% avant dernier
2 x3 x2 x1 x3 x1 x2 3 ; %1 x3 7 66 %3 x1 %2 x2 66 x3 + x2 ; x3 + x1 ; x1 + x2 777 66 %3 x1 %2 x2 %1 x3 77 5 4 1 1 1 ; %3 x %2 x2 %1 x3 1 %1 := ;x3 x1 + x2 x1 + x3 2 ; x2 x3 %2 := ;x2 x3 + x3 x1 + x2 2 ; x2 x1 %3 := ;x2 x3 + x3 x1 + x2 x1 ; x12
Dans l'exemple qui suit, la fonction map applique la fonction factor à tous les éléments de la matrice. >
map(factor,Minv) ;
>
evalm(M &* Minv) : # à tester
>
map(factor,evalm(M &* Minv)) ;
2 x2 x3 x3 x1 x2 x1 66 ; (;x2 + x1) (;x1 + x3) x1 (;x2 + x1) (x3 ; x2) x2 (;x1 + x3) (x3 ; x2) x3 66 x +x x +x x +x 66 (;x2 + x1)3 (;x21 + x3) x1 ; (;x2 + x13) (x31; x2) x2 ; (;x1 + x31) (x32; x2) x3 64 1 ; (;x + x ) (1;x + x ) x (;x + x )1(x ; x ) x (;x1 + x3 ) (x3 ; x2 ) x3 2 1 1 3 1 2 1 3 2 2
Les vecteurs sont des matrices !
2 3 1 0 0 64 0 1 0 75 0 0 1 23
3 77 77 77 75
>
b:=matrix(3,1,[1,2,0]) ;
2 3 1 b := 64 2 75 0
>
>
>
evalm(M &* b) ;
2 3 x + 2 x12 1 64 x2 + 2 x22 75 x3 + 2 x32
transpose(b) ;
h
1 2 0
i
val:=evalm(transpose(b) &* M &* b) ;
h
val := x1 + 2 x2 + 2 x12 + 4 x22
>
val[1,1] ; # scalaire
>
val[1] ;
i
x1 + 2 x2 + 2 x12 + 4 x22
Error, array defined with 2 indices, used with 1 indices
8.2 Résolution de systèmes linéaires >
xs:=linsolve(M,b);
2 x (;2 x x 2 + x 2 x + 2 x 3 ; x 3) 3 1 2 3 1 2 66 ; 3 66 ;2 x x 2 + xx2xx12%1 1 3 2 3 + 2 x13 ; x2 3 xs := 66 x2 x1 %1 66 2 2 4 ; 2 x1 ; 2 x1 x3 ; x2 + x2 x3
3 77 77 77 77 5
x1 %1 x2 %1 := ;x3 x1 2 + x2 x12 ; x2 x3 2 + x1 x3 2 + x2 2 x3 ; x2 2 x1 Ce sont les solutions de Mx=b en x : la même chose que x=M(-1)b, ce qui n'est pas faux ! >
xs2:=evalm(M^(-1) &* b);
24
>
2 3 x2 x3 ; 2 x1 x3 66 %2 x1 %1 x2 7 66 x2 + x3 2 (x1 + x3) 777 xs2 := 66 ; 7 + %1 x2 77 64 %2 x1 5 1 ; 2 %2 x1 %1 x2 %1 := ;x1 x3 + x2 x1 ; x2 2 + x2 x3 %2 := x2 x3 ; x2 x1 ; x1 x3 + x12 map(simplify,evalm(xs-xs2)); # pour voir que 2 3 64 00 75
c'est identique
0 Calcule aussi x mais c'est plus long, d'autant plus long que les symboles restent dans la matrice ! Le calcul symbolique a ses limites : il est exact mais prend du temps.
8.3 Vecteurs propres >
z:='z' : cp:=charpoly(M,z) ;
cp := z 3 ; z 2 x3 3 ; x2 2 z 2 + z x22 x33 ; z x2 3 x3 2 ; x1 z 2 + x1 z x3 3 + x1 x2 2 z ; x1 x2 2 x3 3 + x1 x2 3 x3 2 ; x2 x1 2 z + x2 x1 2 x3 3 ; x2 x13 x32 ; x3 x1 2 x2 3 ; x3 x1 3 z + x3 x1 3 x2 2 >
factor(cp) ;
z3 ; z2 x33 ; x22 z2 + z x22 x33 ; z x23 x32 ; x1 z2 + x1 z x33 + x1 x22 z ; x1 x22 x33 + x1 x23 x32 ; x2 x12 z + x2 x12 x33 ; x2 x13 x32 ; x3 x12 x23 ; x3 x13 z + x3 x13 x22 >
M2:=subs({x[1]=0,x[2]=1,x[3]=t},op(M)) ;
2 3 0 0 0 M2 := 64 1 1 1 75 t t2 t3
eigenvals(M2) ; # valeurs propres
p p 0; 1 + 1 t3 + 1 1 ; 2 t3 + t6 + 4 t2 ; 1 + 1 t3 ; 1 1 ; 2 t3 + t6 + 4 t2 2 2 2 2 2 2 >
>
1 1 1 1 1 1 3 3 [ 2 + 2 t + 2 %1; 1; f 0; 1; ; 2 + 2 t + 2 %1 g]; [ 21 + 12 t3 ; 21 %1; 1; f 0; 1; ; 21 + 12 t3 ; 21 %1 g]; [0; 1; f ; t +t 1 ; 1; ; t +1 1 g] eigenvects(M2) ; # vecteurs propres
p
%1 := 1 ; 2 t3 + t6 + 4 t2 Renvoie une séquence avec la valeur propre, la dimension de l'espace et l'ensemble des vecteurs propre, soit autant de descripteurs qu'il y a de valeurs propres. 25
>
eigenvects(diag(1,1,2)) ;
[1; 2; f[1; 0; 0]; [0; 1; 0]g]; [2; 1; f[0; 0; 1]g] Par exemple, pour chercher si le système est stable, on cherche si les valeurs propres sont inférieures à 1 en valeur absolue. >
linsolve(M2,b) ; # pas de message = pas de solution
>
evalm(inverse(M2) &* b);
Error, (in inverse) singular matrix
Renvoie une erreur car il n'y a pas de solution à ce système : il n'existe pas de x tel que M2x=b, mais M2 est singulière. >
zoro:=matrix(3,1,[0,0,0]) ;
2 3 0 zoro := 64 0 75 0
>
linsolve(M2,zoro) ;
2 3 t 11 t 64 ; t 11 (t + 1) 75
t 11 Ce résultat peut paraître étrange mais il est correct ! Il existe une in nité de solutions proportionnelles à un vecteur que Maple a choisi de noter d'une certaine façon.
Le problème est de trouver x tel que M2x=0 et la somme des x = 1 pour i dimensions du vecteur. i
>
res:=linsolve(M2,zoro) ;
2 3 t 11 t res := 64 ; t 11 (t + 1) 75 t 11
>
total:=sum(res[i,1],i=1..3);
>
simplify(total);
>
total:=res[1,1]+2*res[2,1]+3*res[3,1];
t t t total := ; 11 + t 11 ; 11 t+1 t+1
0 On ne peut pas trouver de solution telle que x1 + 2x2 + 3x3 = 1 car toute solution est telle que x1 + 2x2 + 3x3 = 0. On essaie donc de trouver x avec M2x=0 et x1 + 2x2 + 3x3 = 1. t t 3t total := ; 11 + 2 t 11 ; 11 t+1 t+1
26
>
solu:=evalm(res/total);
2 t 11 t 66 ; %1 (t + 1) 6 t 11 solu := 666 %1 64 ; %1 (tt11+ 1)
3 77 77 77 75
%1 := ; tt+111t + 2 t 11 ; 3t +t 111 avec x tel que x1 + 2x2 + 3x3 = 1 soit 1 tel que 1 + 2 2 + 3 3 = 1. x
x
s
>
map(simplify,solu) ;
>
map(factor,solu) ;
2 t 66 ; t ; 1 66 t + 1 66 t ; 1 64 1 ;t ; 1
2 t 66 ; t ; 1 66 t + 1 66 t ; 1 64 1 ;t ; 1
x
x
s
s
3 77 77 77 75 3 77 77 77 75
Quelques manipulations sur les matrices : >
coldim(b) ;
>
rowdim(b) ;
1 3
8.4 Systèmes d'équations généraux >
p:=product(z-i,i=1..4) ;
p := (z ; 1) (z ; 2) (z ; 3) (z ; 4)
seq et sum sont des fonctions permettant d'obtenir en une seule ligne des résultats parfois compliqués. >
solve(p,z) ; # sous entendu p=0
>
solve(p=1,z) ;
1; 2; 3; 4
27
5 ; 1 q5 + 4 p2; 5 + 1 q5 + 4 p2; 5 ; 1 q5 ; 4 p2; 5 + 1 q5 ; 4 p2 2 2 2 2 2 2 2 2 >
solve(p=-10,z) ;
>
sol:=[solve(p=-10,z)] ;
1 + I; 1 ; I; 4 + I; 4 ; I Renvoie des nombres imaginaires. sol := [1 + I; 1 ; I; 4 + I; 4 ; I ]
>
sol[2] ;
>
p:=product(z-i,i=1..5) ;
1;I
p := (z ; 1) (z ; 2) (z ; 3) (z ; 4) (z ; 5)
>
sol:=[solve(p=-10,z)] ;
sol := [RootOf(%1; index = 1); RootOf(%1; index = 2); RootOf(%1; index = 3); RootOf(%1; index = 4); RootOf(%1; index = 5)] %1 := Z 5 ; 15 Z 4 + 85 Z 3 ; 225 Z 2 + 274 Z ; 110 Maple n'ayant pas réussi, on peut lui demander de faire la résolution avec des ottants. >
fsolve(p=-10,z) ;
:7449115882443210833027883655874290900097
Maple a trouvé une racine qui est réelle. On lui demande alors de savoir où sont toutes les racines. >
Digits:=10 : fsolve(p=-10,z,complex) ;
:7449115882; 2:349739682 ; :9370699874 I; 2:349739682 + :9370699874 I; 4:777804524 ; :4980352577 I; 4:777804524 + :4980352577 I
Il renvoie des valeurs complexes mais numériques que l'ont peut véri er graphiquement. >
plot(p+10,z=0..2); # cf. Figure 1
>
fsolve(p=sin(z)) ;
1:038994656 On trouve une solution mais la question est de savoir s'il existe une autre racine, soit par la réalisation de graphes, soit en s'aidant de l'analyse mathématique, soit en trouvant (ou excluant) des intervalles contenant les racines. Soit une fonction d'utilité que l'on cherche à maximiser. >
ut:=-(x+2*y+2)^4-(3*x+y-2)^2 ;
>
maximize(ut,x,y) ;
ut := ;(x + 2 y + 2)4 ; (3 x + y ; 2)2
28
Figure 1: Plot z
0.2 0.4 0.6 0.8
z 1
1.2 1.4 1.6 1.8
2
0 –20 –40 –60 –80 –100
0 >
maximize(ut,location) ;
0; f[fy = ;58 ; x = 56 g; 0]g Maple écrit les équations du 1er ordre et les résoud. Faisons le étape par étape. >
gr:=grad(ut,[x,y]) ; # calcul du gradient
>
sys:={gr[1]=0,gr[2]=0} ;
>
so:=solve(sys) ;
gr := ;4 (x + 2 y + 2)3 ; 18 x ; 6 y + 12; ;8 (x + 2 y + 2)3 ; 6 x ; 2 y + 4 sys := f;8 (x + 2 y + 2)3 ; 6 x ; 2 y + 4 = 0; ;4 (x + 2 y + 2)3 ; 18 x ; 6 y + 12 = 0g Il s'agit d'un système d'équations de deux éléments : on prend le 1er élément de gradient=0 et le second de gradient=0.
29
so := fy = ;8 ; x = 6 g 5 5
>
so[1] ;
>
subs(so[1],ut) ;
y = ;58
2 ;(x ; 65 )4 ; (3 x ; 18 5)
On peut récupérer la valeur du 2nd élément de la première solution, mais selon les cas ce n'est pas toujours dans le même ordre. >
a:=op(2,so[1]) ;
a := ;58
Pour illustrer le propos de la con ance limitée à accorder à Maple quant aux résultats, il su t de faire l'exercice avec la fonction d'utilité suivante : >
ut:=-(x^2+2*y+2)^4-(3*x+y-2)^2
;
ut := ;(x2 + 2 y + 2)4 ; (3 x + y ; 2)2
8.5 Equations diérentielles
dsolve concerne équations diérentielles ordinaires. pdesolve (ou pdsolve) est utilisé pour les dérivées partielles. >
ode1:=diff(y(x),x) ;
ode1 := ode1 reçoit ensuite toute l'équation. >
y(x)
ode1:=diff(y(x),x)=k*y(x)*(1-y(x)) ;
ode1 := >
@ @x
@ @x
y(x) = k y(x) (1 ; y(x))
dsolve(ode1,{y(x)}) ;
1 y(x) = ( ; 1 + e ) C1 Cette solution est générique, C1 étant la constante d'intégration. kx
Pour avoir une solution particulière, il faut mentionner que y(0) a une certaine valeur et extraire la constante de l'équation. Le premier membre de la fonction dsolve représente le système d'équations à résoudre et le second concerne les fonctions recherchées. >
dsolve({ode1,y(0)=y0},{y(x)}) ;
y(x) =
1
1;
e(; ) (;1 + C1 ) k x
C1
30
>
dsolve({ode1,y(0)=0},{y(x)}) ;
y(x) = 0
8.6 Développements en série
Si l'on veut obtenir la série de y(x) à l'ordre 6 : >
dsolve(ode1,{y(x)},type=series) ;
y(x) = y(0) + k y(0) (1 ; y(0)) x + (; 3 k2 y(0)2 + k2 y(0)3 + 1 k2 y(0)) x2 + ( 2 2 1 k y(0) ( 3 k2 y(0)2 ; k2 y(0)3 ; 1 k2 y(0)) ; 1 k3 y(0)2 (1 ; y(0))2 3 2 2 3 1 3 1 2 2 2 3 2 + 3 k (; 2 k y(0) + k y(0) + 2 k y(0)) (1 ; y(0)))x3+ 25 k4 y(0)3 ; 5 k4 y(0)4 ; 5 k4 y(0)2 + k4 y(0)5 + 1 k4 y(0)) x4+ ( 12 2 8 24 3 13 31 1 k5 y(0) ; k5 y(0)6) x5+ ( 2 k5 y(0)3 ; 4 k5 y(0)4 ; 120 k5 y(0)2 + 3 k5 y(0)5 + 120 O(x6) >
Order:=10 ; # à l'odre 10 ! avec majuscule
Order := 10
>
dsolve(ode1,{y(x)},type=series) :# à tester
>
dsolve({ode1,y(0)=1/2},{y(x)},type=series) ;
1 k3 x3 + 1 k5 x5 ; 17 k7 x7 + 31 k9 x9 + O(x10 ) y(x) = 21 + 14 k x ; 48 480 80640 1451520 > >
ode2:=diff(y(x),x,x)-k*y(x)*(1-y(x)): dsolve({ode2,y(0)=1/2},{y(x)},type=series) ;
1 k D(y )(0)2 x4 ; 1 k2 D(y )(0) x5 ; 1 k3 x6 + y(x) = 21 + D(y )(0) x + 18 k x2 ; 12 80 1920 1 k2 D(y )(0)3 x7 + 11 k3 D(y )(0)2 x8 + 1 k4 D(y )(0) x9 + O(x10) 252 13440 17280 >
D(y)(0) ; # dérivée de y évaluée en 0
D(y )(0) Récupération de la partie polynomiale du développement limité : >
solu:=dsolve({ode2,y(0)=1/2,D(y)(0)=1},{y(x)},type=series) ;
solu := y(x) = 1 + x + 1 k x2 ; 1 k x4 ; 1 k2 x5 ; 1 k3 x6 + 1 k2 x7 + 11 k3 x8 + 2 8 12 80 1920 252 13440 1 k4 x9 + O(x10 ) 17280 >
toto:=subs(solu,y(x)) ;
31
toto := 1 + x + 1 k x2 ; 1 k x4 ; 1 k2 x5 ; 1 k3 x6 + 1 k2 x7 + 11 k3 x8 + 1 k4 2 8 12 80 1920 252 13440 17280 x9 + O(x10) >
toto:=convert(toto,polynom) ;
toto := 1 + x + 1 k x2 ; 1 k x4 ; 1 k2 x5 ; 1 k3 x6 + 1 k2 x7 + 11 k3 x8 2 8 12 80 1920 252 13440 1 + 17280 k4 x9 >
subs(x=4,toto) ;
9 ; 58 k + 16448 k2 + 5408 k3 + 2048 k4 2 3 315 105 135 Ces deux méthodes -solution générique et développement limité- sont des méthodes formelles. Passons maintenant à la méthode numérique : > >
k:=0.1 ; lo:=dsolve({ode1,y(0)=1/2},{y(x)},type=numeric) ;
k := :1
lo := proc(rkf45 x ) : : : end proc Le résultat de cet appel est une procédure. >
lo(1) ;
>
lo(2) ;
>
lo(0) ;
>
Digits:=20 ;
[x = 1:; y(x) = :524979187477936592] [x = 2:; y(x) = :549833997184993926] [x = 0:; y(x) = :50000000000000] Digits := 20
>
lo(1.0) ;
>
lo1:=subs(k=2,lo) ; # ne marche pas
[x = 1:0; y(x) = :524979195325058768] lo1 := lo
>
k:=0.1 ; lo(1.0) ; # marche... mais...
>
logode:=subs(k=0.1,ode1) ;
k := :1 [x = 1:0; y(x) = :524979195325058768] logode :=
@ @x
y(x) = :1 y(x) (1 ; y(x)) 32
>
; > > >
lo:=dsolve({subs(k=0.1,ode1),y(0)=1/2},{y(x)},type=numeric)
lo := proc(rkf45 x ) : : : end proc with(plots) : # bibliothèque des fonctions graphiques évoluées curvs:=seq(dsolve({logode,y(0)=i/10}, {y(x)},type=numeric),i=1..9) ;
curvs := proc(rkf45 x ) : : : end proc; proc(rkf45 x ) : : : end proc; proc(rkf45 x ) : : : end proc; proc(rkf45 x ) : : : end proc; proc(rkf45 x ) : : : end proc; proc(rkf45 x ) : : : end proc; proc(rkf45 x ) : : : end proc; proc(rkf45 x ) : : : end proc; proc(rkf45 x ) : : : end proc > odeplot n'accepte pas une liste de courbes, il faut extraire la 1ière : >
odeplot(curvs[1],x=0..100) ; # cf. Figure 2
Figure 2: Plot 1 seule courbe
1
0.8
y
0.6
0.4
0.2 0
20
40
60 x
33
80
100
> >
listgr:=[seq(odeplot(curvs[i],x=0..100),i=1..9)]: display (listgr) ; # cf. Figure 3
Figure 3: Plot plusieurs courbes
1
0.8
y
0.6
0.4
0.2 0
20
40
60 x
8.7 Système d'équations Méthode formelle : > >
t:='t' : a:='a' : b:='b' : c:='c' : eq1:=diff(x(t),t)=a*x(t)+b*y(t) ;
eq1 := >
x(t) = a x(t) + b y(t)
eq2:=diff(y(t),t)=c*x(t)+d*y(t) ;
eq2 := >
@ @t
@ @t
y(t) = c x(t) + d y(t)
dsolve({eq1,eq2},{x(t),y(t)}) ;
34
80
100
fy(t) = ; 12 C1 %3 a ; C1 %3 d ; C1 %3 %1 +b C2 %2 a ; C2 %2 d + C2 %2 %1 ; x(t) = C1 %3 + C2 %2g p %1 := a2 ; 2 a d + d2 + 4 c b %2 := e(1 2( + ;%1) ) %3 := e((1 2 +1 2 +1 2 %1) ) =
a
=
>
a
d
t
=
d
=
t
dsolve({eq1,eq2,x(0)=1,y(0)=0},{x(t),y(t)}) ;
8 0 p p < 1 1 1 ( a ; d + %1) %3 a ( a ; d + %1) %3 d ; 1 (a ; d + p%1) %3 @ p p y( t ) = ; ; : 2 2 2 2 %1 %1 1 1 (a ; d ; p%1) %2 d p . p p ; 12 (a ; d ;p %1) %2 a + 2 ; 12 (a ; d ; %1) %2A b; %1 %1 9 p p = 1 ( a ; d + %1) %3 ( a ; d ; %1) %2 1 p p x(t) = 2 ;2 ; %1 %1 %1 := a2 ; 2 a d +p d2 + 4 c b %2 := e(1 2( + ; %1) )p %3 := e((1 2 +1 2 +1 2 %1) ) Méthode série : =
=
>
a
a
t
d
=
d
=
t
Order:=4; dsolve({eq1,eq2},{x(t),y(t)}, type=series) ;
Order := 4 fx(t) = x(0) + (a x(0) + b y(0)) t + ( 12 a2 x(0) + 12 a b y(0) + 21 b c x(0) + 12 b d y(0)) t2 + ( 1 a3 x(0) + 1 a2 b y(0) + 1 a b c x(0) + 1 a b d y(0) + 1 c b2 y(0) + 1 b d c x(0) 6 6 3 6 6 6 1 + 6 b d2 y(0))t3 + O(t4 ); y(t) = y(0) + (c x(0) + d y(0)) t+ ( 12 c a x(0) + 21 c b y(0) + 12 d c x(0) + 12 d2 y(0)) t2 + ( 16 c a2 x(0) + 61 c a b y(0) + 16 b c2 x(0) + 13 c b d y(0) + 61 d c a x(0) + 16 d2 c x(0) + 16 d3 y(0))t3 + O(t4 )g Equations non linéaires : >
eq3:=diff(x(t),t)=x(t)^2+2*y(t) ;
eq3 := >
@ @t
x(t) = x(t)2 + 2 y(t)
eq4:=diff(y(t),t)=x(t)*y(t) ;
eq4 :=
@ @t
y(t) = x(t) y(t) 35
dsolve({eq3,eq4},{x(t),y(t)}) ;
>
[fx(t) = ;2
t + C2
1
1
2 ; C1 + t2 + 2 t C2 + C2 2 g; fy(t) = 2 ( x(t)) ; 2 x(t) g] @
@t
eq5:=diff(y(t),t)=x(t)*y(t)^2 ;
>
eq5 :=
@ @t
y(t) = x(t) y(t)2
dsolve({eq3,eq5},{x(t),y(t)}) ;
>
2( !) Z Z RootOf(;e Z a 2 ; 4 C1 + 4 Ei(1; ; Z )) 4 x(t) = RootOf ; d a + t + C2 ; 4 + RootOf(;e Z a 2 ; 4 C1 + 4 Ei(1; ; Z )) a 2 3 1 1 fy(t) = 2 ( x(t)) ; 2 x(t)2g5 @
@t
En rajoutant des conditions initiales et la liste des procédures, on obtient : > >
ff:=dsolve({eq3,eq5,x(0)=1,y(0)=1},{x(t),y(t)}, type=numeric,output=listprocedure) ;
:= [t = (proc(t) : : : end proc); x(t) = (proc(t) : : : end proc ); y(t) = (proc(t) : : : end proc)] >
fx:=subs(ff,x(t)) ;
>
fy:=subs(ff,y(t)) ;
> >
fx := proc(t) : : : end proc fy := proc(t) : : : end proc
fx(0.0) ; fy(0.0) ; fx(1.0) ; fy(1.0) ;
1: 1:
Error, (in fx) cannot evaluate the solution further right of .43053336, probably a singularity Error, (in fy) cannot evaluate the solution further right of .43053336 >
odeplot(ff,t=0..0.5) ; # cf. Figure 4
Warning, cannot compute solution further right of .43053336275796050028
Le graphique apparaît dans la feuille de calcul, pour le faire apparaître dans une fenêtre, il faut passer par la commande interface (sur unix mettre plotdevice=X11). Tous les graphiques sont mis dans une fenêtre à part, chaque graphique étant dans sa propre fenêtre.
9 Graphiques >
f:=-(x+2*y+1)^4-(x+3*y-3)^2 ;
36
Figure 4: Plot t
12 10 8 x 6 4 2 0
0.1
0.2
0.3
0.4
t
f := ;(x + 2 y + 1)4 ; (x + 3 y ; 3)2 >
plot3d(f,x=-2..2,y=-2..2,axes=boxed) ; # cf. Figure 5
>
?plot[options] : # accès aux options
>
gradplot(f,x=-2..2,y=-2..2,grid=[10,10],arrows=SLIM) ;
Dans une fenêtre graphique le menu contextuel du bouton droit de la souris est utilisable. Par exemple, une option des styles patches et contours fait apparaître les lignes de niveaux. La commande suivante permet de dessiner le gradient de la fonction. > animate propose de superposer les graphiques sous la forme d'une animation. gradplot(;(x + 2 y + 1)4 ; (x + 3 y ; 3)2; x = ;2::2; y = ;2::2; grid = [10; 10]; arrows = SLIM ) >
implicitplot(f=-10,x=-2..2,y=-2..2,grid=[50,50]) ;
37
Figure 5: Plot 3d
0 –500 –1000 –1500 –2000 –2
–2 –1
–1 y
0
0 1
1 2
x
2
implicitplot(;(x + 2 y + 1)4 ; (x + 3 y ; 3)2 = ;10; x = ;2::2; y = ;2::2; grid = [50; 50]) Par défaut la précision de lissage est donnée par le paramètre grid=[25,25]. Il faut veiller à choisir les bonnes dimensions du graphique. >
f:=x*x+cos(x)-x*y^3 ;
>
plot(f,x=-1..1,y=-10..10) ; # utiliser plot3d
f := x2 + cos(x) ; x y3
Plotting error, empty plot
38
10 Programmation
10.1 Tests et conditions > > > > >
> > > > > > >
> > > > > > >
if a=1 then a*a else a-1 fi ; if a=1 then b:=a*a elif a=2 then b:=a else b:= a-1 fi ; if a=1 then a*a else if b=1 then b:=0 fi fi ;
a;1
b := a ; 1
10.2 Boucles > > > >
>
> > > >
s:='s' : n:=10 ; s:=0 ; for i from 1 to n do s:= s+ i*i od:
n := 10 s := 0
s; s:='s' : # récursif for i from 1 to n do s:= s+ i*i od ;
385
s := s + 4
Error, too many levels of recursion
Construction d'une récurrence : > > >
for i from 1 to n do v[i]:=v[i-1]+ i*i od ;
v1 := v0 + 1 39
v2 := v0 + 5 v3 := v0 + 14 v4 := v0 + 30 v5 := v0 + 55 v6 := v0 + 91 v7 := v0 + 140 v8 := v0 + 204 v9 := v0 + 285 v10 := v0 + 385 >
op(v) ;
table([1 = v0 + 1; 2 = v0 + 5; 3 = v0 + 14; 4 = v0 + 30; 5 = v0 + 55; 6 = v0 + 91; 7 = v0 + 140; 8 = v0 + 204; 9 = v0 + 285; 10 = v0 + 385 ]) >
sum(j*j,j=1..N) ;
1 (N + 1)3 ; 1 (N + 1)2 + 1 N + 1 3 2 6 6
>
factor(sum(j*j,j=1..N)) ;
1 N (N + 1) (2 N + 1) 6 La boucle descendante présentera un incrément négatif. Une boucle s'incrémente tant que c'est inférieur à la borne (ou supérieur si c'est une boucle descendante). > > >
>
for i from 1 to 9 by 2 do v[i]:=v[i-1]+i^3; od ;
v1 := v0 + 1 v3 := v0 + 32 v5 := v0 + 155 v7 := v0 + 434 v9 := v0 + 933
for i in [4, 7, 12] do toto[i]:=i*i od ;
toto 4 := 16 toto 7 := 49 toto 12 := 144
a:='a' : b:='b' : # réinitialisation l:=[a,b,c] ;# quelle que soit la liste, ensemble, etc. > for i in l do l2:=[op(l2),i*i] od ; # initialisation d'une liste vide > >
l := [a; b; c] 40
l2 := [] l2 := [a2] l2 := [a2 ; b2] l2 := [a2; b2; c2] >
[seq(l[i]^2,i=1..nops(l))] ;
[a2; b2; c2] La fonction nops correspond au nombre d'éléments de la liste. > > >
for i in l do l2:=[op(l2),i^2] # concaténation par ajout à l'existant od ;
Boucle tant que : > > > >
s:=1 ; while s > > > > >
# la fonction carre calcule le carre d'un nb carre:=proc(x) local x2; # variable locale x2:=x*x; RETURN(x2); # par défaut retourne le dernier résultat end;
carre := proc(x) local x2 ; x2 := x2 ; RETURN(x2 ) end proc
>
carre(3) ;
>
carre(3,4) ; # prend le 1er argument
>
carre(truc) ;
> > > > > > >
9 9
truc 2
racine:=proc(x) if (x>=0) then RETURN(sqrt(x)) ; else RETURN(Impossible !) ; fi; end ;
racine := proc(x) if 0 x then RETURN(sqrt(x)) else RETURN(Impossible!) end if
end proc >
racine(4) ;
>
racine(-3) ;
>
racine(sophie) ; # ne sait pas évaluer sophie
2 Impossible!
Error, (in racine) cannot evaluate boolean: -sophie
> > > > > > > >
sqrt(-3) ;
p I 3
racine:=proc(x::numeric) # paramètre de type connu par maple if (x>=0) then RETURN(sqrt(x)) else RETURN("Impossible!") fi; end ;
42
racine := proc(x: : numeric ) if 0 x then RETURN(sqrt(x)) else RETURN( Impossible! ) end if
end proc >
racine(ab) ;
Error, invalid input: racine expects its 1st argument, x, to be of type numeric, but received ab >
racine(carre(4,6)) ; # prend le 1er argument
4
11 Fichiers, entrées/sorties, sauvegardes 11.1 Sauvegarde des instructions
La sauvegarde d'une session correspond à la sauvegarde des instructions. La feuille de calcul Maple est sauvegardée avec les instructions et leurs résultats. La fonction save permet de sauvegarder des instructions telles on les taperait en tant qu'instructions Maple. Le chier est éditable dans un éditeur (Notepad, Emacs) et chargeable dans Maple par le menu File> Open. > > >
M:=matrix(2,2,[0$4]) : save M,"C:toto.dat" ;
read "c:toto.dat" ; # rapelle et exécute les instructions
"
M := 00 00 toto.dat contient les informations suivantes :
#
M : = array(1.. 2, 1 .. 2,[(1, 1)=0,(1, 2)=0,(2, 1)=0,(2, 2)=0]);
11.2 Utilisation des procédures dans un chier externe
Le chier ascii peut contenir la procédure maxvp qui recherche le maximum des valeurs propres d'une matrice.
43
maxvp : =proc(M: : matrix) local ev, mx ; ev : = eigenvals(M) ; mx : = max(ev) ; RETURN(ev,mx); end; >
read "C:toto.dat" :
>
debug(maxvp) ; #mode debugage d'une procédure
>
restart ; # remise à zéro
>
save carre, "carre.txt" ;
Le principe est de mettre les procédures dans un chier. Le restart réinitialise et se débarasse du contexte précédent. On peut sauvegarder une procédure comme tout autre objet dans un chier, sans mise en forme. carre : = proc (x, y) local x2, y2; x2: =x^2; y2 : = y^3; RETURN(x2,"et",y2) end proc; Un chier de commandes peut contenir de nombreuses instructions :
44
# mon chier de commandes progmp.txt with(linalg); # proc carre carre: =proc(x,y) local x2,y2; x2: =x*x; y2: =y*y*y; RETURN(x2,"et",y2) end; # proc calcul... maxvp: =proc(M: : matrix) local ev, mx, vabs ; ev : = eigenvals(M) ; vabs : = seq(abs(vabs[i]),i=1..nops(vabs)); mx : = max(ev) ; RETURN(mx); end;
11.3 Communication 11.3.1 Fichier texte
Menu File> Save as Text Ensuite on peut copier depuis un éditeur puis coller dans Maple as Maple Text
11.3.2 Sélection
Menu Exporter pose le problème de tout exporter : il faut faire le ménage ensuite.
11.3.3 Feuille de calcul
L'exportation au format TeX de la feuille de calcul produit un chier TeX autonome très utile pour retravailler le texte. Il est nécessaire d'avoir récupéré le package maple2e.
11.3.4 Format HTML
Il est possible de fabriquer du HTML standard avec des chiers GIF intégrés. A l'avenir, mathML permettra de représenter des formules. 45
11.3.5 Graphiques
Il est préférable de passer par le menu contextuel car le menu Export ne s'applique pas toujours à l'ensemble souhaité. >
interface(plotdevice=inline) ; # retour à la feuille
Les exportations de graphiques peuvent se faire aux diérents formats reconnus (GIF, JPG, EPS, WMF).
11.3.6 Postscript
Pour exporter la feuille en postscript, Maple ne le fait pas tout seul, il faut passer par l'impression dans un chier à l'aide d'un driver d'imprimante Postscript (rappelons que lorsqu'on imprime, on peut imprimer sur une feuille ou dans un chier ! ), puis éditer avec un éditeur de chiers postscript, tel que GhostView et sélectionner les pages intéressantes. Entre collaborateurs, la communication peut se faire à l'aide de chiers postscript.
11.4 Fonctions d'édition de la feuille de calcul Nous mentionnons ici les principales fonctionnalités.
Menu > Insert > Execution Group > Before ou After permet de créer un groupe de commandes. Le système présente une barre de modi cation avec validation par exemple. Les fenêtres d'aide ont été faites avec des instructions et des commentaires. Menu > Insert > Section ou Subsection. Le bloc peut être indenté ou outdenté par Menu > Format. Les blocs d'exécution peuvent être fusionnés ou cassés par Menu > Edit > Split ou Join.
46
Index :,4 : =, 4 ;,4 >, 3 ?,3 #, 4 $, 12 &*, 22
exp, 21 expand, 16 exporter, 45 factor, 19 chiers, 43 for, 39 formats, 46 fsolve, 28
aide, 3 anames, 9 array, 11
gif, 45 html, 45
boucle, 39, 41
if, 39 implicitplot, 37 indices, 11 int, 17 intersect, 9
charpoly, 13, 25 coe, 16 coes, 16 coldim, 27 collect, 16 convert, 14
limit, 21 linalg, 13, 22 linsolve, 24 liste, 9, 41 listlist, 15 listprocedure, 36
debug, 44 degree, 16 denom, 20 det, 22 diag, 26 di, 15 Digits, 6 display, 34 dsolve, 30
map, 23 maple2e, 45 matrice, 13 maximize, 28 multiply, 22
édition, 46 eigenvals, 25 eigenvects, 25 ensemble, 9 entries, 11 evalc, 19 evalf, 6 evalm, 22
nops, 41 numer, 20 odeplot, 36 op, 10, 11 opérateurs arithmétiques, 5 opérateurs logiques, 5 order, 35 47
Order, 31 pdesolve, 30 pdsolve, 30 plot, 28 plot3d, 37 plots, 33 postscript, 46 procedure, 41 product, 27 prompt, 3 read, 43 restart, 44 return, 42 rowdim, 27 sauvegarde, 43, 45 save, 43 seq, 10 series, 21 simplify, 6 solve, 6 sort, 16 sqrt, 18 subs, 8 sum, 26, 40 table, 10 tableau indicé, 10 taylor, 20 test, 39 transpose, 24 type, 14 type numeric, 42 unassign, 4 union, 9 variable locale, 42 whattype, 14 while, 41 with, 13, 33 48
Liste des gures 1 2 3 4 5
Plot z . . . . . . . . . Plot 1 seule courbe . . Plot plusieurs courbes Plot t . . . . . . . . . Plot 3d . . . . . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
29 33 34 37 38
Références [1] C. Gomez. Notes de cours Maple. Institut National de la Recherche en Informatique et Automatique, 2001. [2] Y. Mourrain, B. Papegay. Notes de cours Maple. Institut National de la Recherche en Informatique et Automatique, 2001. [3] Waterloo. Maple 7. Waterloo Maple, 2002.
49
