Memento du logiciel Maxima - UHA

Memento du logiciel Maxima
Table des matières
A Préliminaires
1
B Affectation
1
C Constantes et fonctions usuelles
1
D Vecteurs (ou listes de réels)
2
E Matrices
2
F Polynômes
3
G Applications
3
H Dérivées
4
I
Dérivées partielles
4
J Primitive et intégrale
4
K Tracé de fonctions
4
L Tracé d’un nuage de points
5
M Equations différentielles du premier ordre
M.1 Equation homogène . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
M.2 Equation non homogène . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
M.3 Equation différentielles quelconques du premier ordre . . . . . . . . . . . . . . . . . .
5
5
6
6
N Equations différentielles du second ordre
7
O Calcul différentiel
7
P Equations de récurrence
8
Q Régression linéaire simple
8
A
Préliminaires
1) Pour les versions ne comportant pas une ligne d’entrée au bas de l’écran, la validation d’une
ligne s’effectue en appuyant sur la touche Retour Chariot (et non pas la touche Entrée du pavé
numérique)
2) L’exponentiation ab s’obtient
- sur un PC par aˆb ou par a ∗ ∗b
- sur un Mac uniquement par a ∗ ∗b
1
3) La variable ’%’ représente le dernier résultat obtenu. Les résulta précédents s’obtiennent en utilisant les variables ’%on’ où n est le numéro du résultat.
4) Dans tout ce qui suit, les exemples sont donnés tels qu’ils doivent être entrés, et non tels qu’ils
apparaissent à l’écran une fois entrés.
5) Pour obtenir une valeur numérique d’une application f (par exemple f (2)) il est nécessaire de
passer en mode N umrique par Basculer l0af f ichage numrique.
6) On peut télécharger le logiciel Maxima à partir du site
http://michel.gosse.free.fr/,
sur le quel on trouvera également de la documentation.
Autres sources : http://declic.softonic.fr/comparer/geogebra,multiplication,maxima
http://maxima.sourceforge.net/
B
Affectation
Constante : a : 5
Polynôme : p : (x − 1) ∗ (x + 3)
Application : f (x) := xˆ4 ∗ sin(x), g(x, y) := [x ∗ sin(x), exp(x ∗ y)]
La commande kill supprime une affectation
C
Constantes et fonctions usuelles
Constantes
%e, %pi, %i, true, f alse
Application
exp, log (logarithme népérien), cos, sin, sqrt (racine carrée), abs (valeur absolue) ,floor (parie
entière), ceiling (plus petit entier supérieur ou égal), gamma (gamma(n)=(n-1) !)
Combinatoire
factorial(n) (=gamma(n+1)), binomial(n,p) (=Cnp )
Opérateurs logiques : and, or, not
D
Vecteurs (ou listes de réels)
A) Déclaration d’un vecteur : a : [2, −1, 5], considéré selon le contexte comme une matrice
3 × 1 ou une matrice 1 × 3.
Exemples
1) Si b : [5, −3, 1], a.b donne le produit scalaire de a et b dont la valeur est 18.
2) Si M : matrix([−1, 2, −5], [3, 1, −4], [−2, 0, 6]), M.a donne la matrice colonne matrix([−29], [−15]),
et a.M donne la matrice ligne matrix([−15, 3, 24]) qui apparaît à l’écran sous la forme [−15 3 24]
3) transpose(a) donne la matrice colonne matrix([2], [−1], [5])
4) matrix(a) transforme a en la matrice ligne matrix([2, −1, 5]) qui apparaît à l’écran sous la
forme [2 −1 5]
B) Création de liste : si f est une application, la liste f (a), ..., f (b), où a < b sont des entiers,
s’obtient par
makelist(f (i), i, a, b) (ou par Algbre −→ Gnrer une liste)
P
Somme : si f est une application, la somme bi=a f (i), où a < b sont des entiers, se calcule par
sum(f (i), i, a, b).
2
C) Opération sur les listes
Commande apply : appliquée à une liste b (entrée directe ou Algbre −→ Appliquer une liste)
1) apply(” + ”, b) donne la somme de cette liste ; apply(” ∗ ”, b) donne le produit des éléments de
la liste
2) apply(max, b) (resp. apply(min, b)) donne le plus grand (resp. le plus petit) élément de la liste
Commande map : appliquée à une liste b (entrée directe ou Algbre −→ Appliquer une liste)
map(f, b) donne la liste obtenue en appliquant à chaque élément de b l’application f
E
Matrices
Trois façons d’entre une matrice :
1) De façon interactive : m : entermatrix(p, q), où p est le nombre de lignes et q le nombre de
colonnes
2) a) Sur un PC : Algbre −→ Entrer une matrice : entrer les coefficients, puis valider ; si l’on
veut appeler m la matrice que l’on vient de créer, entrer m : %
b) Sur un Mac : Algbre −→ Entrer une matrice : entrer les coefficients, le nom de la matrice,
puis valider
3) m : matrix([a, b, c], [d, e, f ]) ([a, b, c] est la première ligne de m)
Matrices particulières
zeromatrix(m, n) : matrice m × n nulle
ident(n) : matrice identité d’ordre n
diag_matrix(a1 , ..., an ) retourne la matrice diagonale d’éléments diagonaux a1 , ..., an
Extraction
Si m = (mi,j ) est une matrice :
- m[i, j] renvoie l’élément mi,j
- m[i] renvoie la ie ligne
- col(m, j) renvoie la j e colonne
Opérations unaires
- Inverse : invert(M ) (équivaut à mˆˆ − 1) (Algbre −→ Inverser une matrice)
- Déterminant : determinant(M ) (Algbre −→ Dterminant)
- Rang : rank(M )
- Transposée : transpose(M ) (Algbre −→ T ransposer une matrice)
- Transposée de la matrice des cofacteurs de M : adjoint − M (Algbre −→ M atrice asssocie)
- Trace 1) tracematrix(M ) après avoir entré load(f uncts) 2) mattrace(M ) après avoir entré load(nchrpl)
- Décomposition de Cholesky d’une matrice positive : cholesky(M )
- Polynôme caractéristique de la matrice M en x : charpoly(M, x) ((Algbre −→ P olynme caractristique)
- Valeurs propres : eigenvalues(M ) = eivals(M ) (Algbre −→ V aleurs propres)
- Vecteurs propres : eigenvectors(M ) = eivects(M ) (Algbre −→ V ecteurs propres)
- Matrice triangulaire supérieure obtenue par élimination de Gauss : triangularize(M )
Opérations binaires
+, −, ∗, /, exp,ˆ : opération élément par élément
. (point usuel) : produit
ˆˆ : puissance
3
F
Polynômes
Entrée d’un polynôme : p : 2 ∗ xˆ2 − 3 ∗ x + 4 (les expressions p(x) ou p(2) n’ont aucun sens)
Opération binaires sur deux polynômes p et q
- p + q, p − q, p ∗ q, gcd(p, q)
Composition
Si p : xˆ3 − 3 ∗ x et q : y − 2
subst(q, x, p) donne le polynôme composé p ◦ q en la variable y (=y 3 − 6 ∗ y 2 + 9 ∗ y − 2)
Division euclidienne
divide(x2 + x + 1, x − 2) donne [x + 3, 7] (dans l’ordre quotient et reste)
Factorisation
Si p est un polynôme, f actor(p) donne sa factorisation dans R et gf actor(p) donne sa factorisation
dans C
Développement
Si p : (2 ∗ x − 3) ∗ (5 ∗ x + 7), expand(p) donne 10x2 − x − 21
Racine
- Les racines réelles d’un polynôme p s’obtiennent par realroots(p)
- Les racines réelles ou complexes d’un polynôme p s’obtiennent par allroots(p)
G
Applications
1) Application à valeur dans R : f (x) := x ∗ cos(x)
2) Application à valeur vectorielle : g(x, y) := [exp(−4 ∗ x ∗ y), x ∗ sin(y)]
3) Application à valeur matricielle : h(x, y) := matrix([y∗exp(−2∗x), xˆ2∗y], [sin(x∗y), x∗log(y)])
Substitution de variables : si a et b n’ont pas d’affectation g(a, b) donne à l’écran [%e4ab , asin(b)]
Substitution de valeurs numériques :
µ
¶
4%e4
16
- si l’affichage numérique n’est pas activé, h(2, 4) donne la matrice
sin(8) 2log(4)
µ
¶
0.073262555554937
16
- si l’affichage numérique est activé, h(2, 4) donne la matrice
0.98935824662338 2.772588722239781
Composition : la composition de deux applications f et g de R dans R s’obtient par f (g(x)).
Résolution d’équation
1) si f est une application continue de R dans R, et si a < b et c sont des réels tels que f (a) − c et
f (b) − c sont de signes opposés, une solution de l’équation f (x) = c comprise entre a et b est donnée
par f ind_root(f (x) = c, x, a, b).
2) si f et g sont des applications, solve(f (x) = g(x)) donne des solutions de l’équation f (x) = g(x) ;
solve(f (x)) résout implicitement l’équation f (x) = 0.
H
Dérivées
Entrer l’application : g(x) := xˆ4 ∗ sin(x)
Dérivée : diff(g(x), x) (=g 0 (x))
Dérivée ne : diff(g(x), x, n) (= g (n) (x))
Evaluation en une valeur réelle : at(diff(g(x), x, n), x = 2) donne la valeur g (n) (2))
Il peut être plus pratique de poser h(x) :=diff(g(x), x, n), puis d’entrer at(h(x), x = 2)
4
I
Dérivées partielles
Entrée de l’application : g(x, y, z) := xˆ4 ∗ sin(y) ∗ exp(−2 ∗ z)
∂g
(x, y, z) s’obtient par diff(g(x, y, z), x)
∂x
∂ 2g
(x, y, z) s’obtient par diff(g(x, y, z), x, 2)
∂x2
∂ 2g
∂2g
(x, y, z) =
(x, y) s’obtient par diff(g(x), x, 1, y, 1) ou diff(g(x), y, 1, x, 1)
∂x∂y
∂y∂x
∂ 6g
(x, y, z) s’obtient par diff(g(x), x, 2, y, 1, z, 3)
∂x2 ∂y∂z 3
∂6g
(x, y, z), h(−1, 2, 4) s’obtient par
Si par exemple h(x, y, z) :=
∂x2 ∂y∂z 3
at(h(x, y, z), [x = −1, y = 2, z = 4])])
-
J
Primitive et intégrale
Si f (x) := 2 ∗ xˆ3 − x + 5
integrate(f (x), x) donne la primitive 21 x4 − 12 x2 + 5x
R1
integrate(f (x), x, 0, 1) donne l’intégrale 0 (2x3 − x + 5)dx = 5
K
Tracé de fonctions
Tracer du graphe d’une application f entre les bornes a et b
Première méthode
On entre la commande plot2d(f, [x, a, b]), qui trace le graphe de f dans le format par défaut
gnuplot. Cette commande équivaut à la commande plot2d(f, [x, a, b], [plot_f ormat, gnuplot]).
La précision des bornes a et b est obligatoire.
Si l’on veut faire afficher le graphe dans la fenêtre courante, on utilise la commande
wxplot2d(f, [x, a, b]).
Si l’on veut tracer le graphe selon le format openmath, on entre plot2d(f, [x, a, b], [plot_f ormat, openmath]).
Si l’on veut limiter le domaine de variation de y à l’intervalle [c, d] et imposer la largeur et la
couleur du trait, on utilise la commande plot2d(f, [x, a, b], [y, c, d], [style, [lines, l, co]]), où l détermine
la largeur du trait et co sa couleur.
La commande plot2d([f, g], [x, a, b]) trace le graphe de deux applications f et g. Si l’on veut imposer
la largeur et la couleur des deux graphes, on utilise la commande plot2d([f, g], [x, a, b], [style, [lines, lf , cof ], [lines, lg
Ces commandes s’étendent à un nombre quelconque d’applications.
Correspondance entre valeurs de co et couleur :
0 : bleu marine 1 : bleu clair 2 : rouge 3 : mauve 4 : vert 5 : brun 6 : vert clair
Deuxième méthode
- cliquer sur Courbe 2D dans la barre inférieure (ou latérale)
- entrer f (ou laisser % si l’on vient juste d’entrer f (x))
- choisir les bornes d’intégration
- modifier éventuellement la graduation
- choisir le format de sortie : 1) le format par défaut est gnuplot 2) en ligne : affiche le graphe
dans la fenêtre courante 3) gnuplot : affiche le graphe dans une fenêtre séparée 4) openmath : affiche
5
le graphe dans une fenêtre séparée ; format commode pour sauvegarder le graphe sous le format
PostScript
N.B. : sur un MAC on ne peut utiliser la sortie gnuplot que si le logiciel X11 est actif ; il se trouve
dans le dossier Utilitaires d’Applications.
L
Tracé d’un nuage de points
Si u et w sont des vecteurs de même longueur (ne pas nommer les vecteurs x)
plot2d([discrete, u, w], [x, a, b], [style, points])
trace le nuage de points (u, w), chaque point étant représenté par un disque bleu.
La commande plot2d([discrete, u, w], [x, a, b], [style, [points, t, co, f ]]) permet en plus de préciser la
taille (t), la couleur (co) et la forme (f ) de la figure représentant chaque point.
Correspondance entre valeur de f et forme :
1 : • 2 : ◦ 3 : + 4 : × 5 : ∗ 6 : ¥ 7 : ¤ 8 : N 9 : 4 10 : H 11 : O 12 : ¨ 13 :
♦
M
Equations différentielles du premier ordre
On commence par la résolution, sur un exemple, d’une équation différentielle du type :
g 0 (x) = ag(x) + P (x), où a est un réel et P un polynôme.
M.1
Equation homogène
Résolution de l’équation homogène : h0 (x) = 4h(x), de solution h(x) = ceax
Première méthode
Il faut donner un nom à l’équation,par exemple eq, puis poser
eq :’diff(h(x), x) = 4 ∗ h(x).
La résolution de l’équation s’obtient par
desolve([eq], [h(x)])
Si l’on impose une condition à initiale, nécessairement en 0 pour cette méthode, il faut procéder
comme suit. Si par exemple on exige que h(0) = −5 :
eq :’diff(h(x), x) = 4 ∗ h(x)
atvalue(h(x), x = 0, −5)
desolve([eq], [h(x)]),
pour obtenir à l’écran h(x) = −5%e4x .
Deuxième méthode
Si l’on préfère écrire l’équation précédente sous la forme y 0 = 4y, on entrera
equa :’diff(y, x) = 4 ∗ y
qui se résout par
ode2(equa, y, x)
Si l’on impose une condition à initiale, par exemple y(1) = −2, il est préférable de procéder comme
suit :
equa :’diff(y, x) = 4 ∗ y
g(x) := ode2(equa, y, x)
ic1(g(x), x = 1, y = −2),
pour obtenir à l’écran y = −2%e2x−2 (si l’affichage numérique n’est pas activé).
6
M.2
Equation non homogène
Résolution de l’équation homogène : h0 (x) = 4h(x) − 3x + 7 Première méthode
Il faut donner un nom à l’équation,par exemple eq, puis poser
eq :’diff(h(x), x) = 4 ∗ h(x) − 3 ∗ x + 7
desolve([eq], [h(x)]),
4x )
pour obtenir h(x) = (16h(0)+25)%e
+ 3x
− 25
.
16
4
16
Si l’on impose une condition initiale, nécessairement en 0 pour cette méthode, il faut procéder
comme suit :
eq :’diff(h(x), x) = 4 ∗ h(x) − 3 ∗ x + 7
atvalue(h(x), x = 0, 1)
desolve([eq], [h(x)]),
4x
pour obtenir à l’écran h(x) = 41%e
+ 3x
− 25
.
16
4
16
Deuxième méthode
Si l’on préfère écrire l’équation précédente sous la forme y 0 = 4y − 3x + 7, on entrera
equa :’diff(y, x) = 4 ∗ y − 3 ∗ x + 7
qui se résout par
ode2(equa, y, x). ³
´
−4x
7%e−4x
L’écran affiche y = 3(4x+1)%e
−
+
%c
%e4x ;
16
4
4x
après avoir cliqué sur l’un quelconque des boutons ”Simplifier” on obtient l’expression y = 16%c%e 16+12x−25 .
Si l’on impose une condition initiale, par exemple y(1) = −2, il est préférable de procéder comme
suit :
equa :’diff(y, x) = 4 ∗ y − 3 ∗ x + 7
g(x) := ode2(equa, y, x)
ic1(g(x), x = 1, y = −2),
−4
4x
4 x+25%e4 )
pour obtenir à l’écran y = − %e (19%e −12%e
.
16
M.3
Equation différentielles quelconques du premier ordre
Le cas général se traite même manière analogue. Nous l’illustrons par l’équation :
g 0 (x) = xg(x) + x2 exp(− 12 x2 ).
On utilisera la deuxième méthode qui permet d’imposer une valeur en tout point de R.
Entrer l’équation : equa :’diff(y, x) = x ∗ y + xˆ2 ∗ exp((1/2) ∗ xˆ2),
poser g(x) := ode2(equa, y, x),
3
x2
visualiser la solution générale en entrant g(x) qui affiche y = ( x3 + %c)%e 2
imposer la condition initiale g(1) = −1 par
ic1(g(x), x = 1, y = −1)
qui affiche
x2
1
x2
(x3 − 1)%e 2 + 2 − 3%e 2
√
.
y=
3 %e
7
N
Equations différentielles du second ordre
Résolution de l’équation g 00 (x) = 2g 0 (x) − cos(x)
Première méthode
equa :’diff(g(x), x, 2) = 2∗’diff(g(x), x, 1) − cos(x)
desolve([equa], [g(x)])
Si l’on souhaite imposer des conditions initiales, nécessairement en 0, on procède comme suit :
equa :’diff(g(x), x, 2) = 2∗ ’diff(g(x), x, 2) − cos(x)
atvalue(g(x), x = 0, 1)
atvalue(’diff(g(x), x), x = 0, 2)
2 sin(x) cos(x) 4e2x
desolve([equa], [g(x)]) (=
+
+
)
5
5
5
Deuxième méthode
equa :’diff(y, x, 2) = 2∗’diff(y, x, 1) − cos(x)
ode2(equa, y, x)
Si l’on impose des condition initiale, par exemple y(1) = −2 et y(0) = −3, il est préférable de
procéder comme suit :
equa :’diff(y, x, 2) = 2∗’diff(y, x, 1) − cos(x)
g(x) := ode2(equa, y, x)
bc2(g(x), x = 1, y = −2, x = 2, y = −3).
O
Calcul différentiel
Matrice jacobienne : jacobian([f (x, y), g(x, y)],
Ã[x, 2y])
!
∂ f
∂2f
(x,
y)
(x,
y)
2
∂x
∂x∂y
Matrice hessienne : hessian(f (x, y), [x, y]) (=
)
∂2f
∂2f
(x,
y)
(x, y)
∂x∂y
∂y 2
Exemple : si k(x, y) := xˆ2
µ ∗ sin(y), et si l’on pose¶ g(x, y) := hessian(k(x, y), [x, y])
2 sin(y) 2x cos(y)
- g(x, y) donne la matrice
2x cos(y) −x2 sin(y)
µ 2
¶
√
√2
2
2
- at(g(x, y), [x = 1, y = %pi/4]) donne à l’écran la matrice
√2
√2
2
2
µ
¶
2 sin(2) 2 cos(2)
- at(g(x, y), [x = 1, y = 2]) donne à l’écran la matrice
si l’affichage numé2 cos(2) − sin(2)
rique n’est pas activé
h
i
2
2
2
2
∂ k
∂ k
∂ k
- si l’on veut obtenir la valeur numérique ∆(1, 2) = ∂x
(1, 2) , on pourra
2 (1, 2) ∂y 2 (1, 2) −
∂x∂y
poser
d(x, y) := determinant(g(x, y)), activer l’affichage numérique, et obtenir la valeur souhaitée par
at(d(x, y), [x = 1, y = 2]).
P
Equations de récurrence
a) L’équation f (n + 1) = af (n) + g(n), où g est par exemple un polynôme, se résout de la façon
suivante :
eq : f (n + 1) = a ∗ f (n) + g(n)
f uncsolve(eq, f (n))
b) L’équation f (n + 2) = af (n + 1) + bf (n) + g(n), où g est une application de N dans R, se résout
de façon analogue :
eq : f (n + 2) = a ∗ f (n + 1) + b ∗ f (n) + g(n)
8
f uncsolve(eq, f (n))
N.B. : M axima recherche d’abord une solution constante. Dans le cas d’une équation sans second
membre f (n + 2) = af (n + 1) + bf (n) le résultat sera toujours 0.
Q
Régression linéaire simple
Si u et w sont des données de même longueur n, pour obtenir la droite de régression de u en w
il est nécessaire d’entrer les données sous forme d’un matrice 2 × n dont la première colonne est le
vecteur u et la seconde le vecteur w. On peut
- soit créer directement la matrice (qu’on appelle m)
- soit, si u et w sont des vecteurs, créer la matrice n × 2 ayant u pour première ligne et w pour
seconde ligne par m : matrix(u, w), puis obtenir la matrice souhaitée, de dimension 2 × n, par
m : transpose(m).
Il faut charger le module stat par load(stats). La commande simple_linear_regression(m) renvoie
quelques résultats des calculs relatifs à la régression, en premier lieu l’équation de la droite de
régression de w en u sous la forme y = ax + b.
La résultat suivant, appelé correlation, est le coefficient de corrélation linéaire entre u et w (noté
r(u, w) ou ρ(u, v)). Ce coefficient peut se calculer de la façon suivante : cov(m) renvoie une matrice
2 × 2, qu’on appellera co, qui est la matrice de variance-covariance du couple (u, w), i.e. co[1, 1] est la
variance de u, co[2, 2] est la variance de w et co[1, 2] = co[2, 1] est la covariance cov(u, w) du couple
(u, w). Le coefficient de corrélation linéaire entre u et w s’obtient alors par co[1, 2]/sqrt(co[1, 1] ∗
co[2, 2]).
Parmi les autres résultats :
n
- v_estimation se calcule par
cov(u, w)(1 − r2 ), où r = r(u, w)
n
−
2
p
- statistic se calcule par r/ (1 − r2 )/(n − 2).
9