Introduction au logiciel Maxima/Interface et premiers exemples
1. Interface utilisateur et premiers exemples
Interface
modifierMaxima est un langage interprété, en ligne de commande : on tape une expression (suite de commandes et de paramètres), on valide avec la touche [Entrée]
, et on obtient son résultat.
Attention :
- il peut y avoir une différence de comportement entre la touche
[Entrée]
du pavé numérique et la touche[Entrée]
située à côté des touches alphabétiques.
L'invite de commande est de la forme %in
où n est le numéro de la commande (« i » pour input). Le résultat est indiqué sur la ligne d'après, précédé de %on
(« o » pour output).
Si l'on ne veut pas que le résultat s'affiche, on termine la ligne par un signe dollar $
.
Si l'on ne veut pas qu'une expression soit évaluée, on met une apostrophe '
devant. Par exemple, diff(x, t, 2);
renvoie 0
(on dérive deux fois par rapport à t une expression ne contenant pas t), tandis que 'diff(x, t, 2);
renvoie d2x/dt2 (expression non évaluée, laissée telle quelle).
Premiers exemples
modifierCalculs simples
modifier(%i1) 1+1;
(%o1) 2
(%i2) %+2;
(%o2) 4
(%i3) sin(%pi/4)
(%o3) 1
———
√2
(%i4) float(sqrt(3));
(%o4) 1.732050807568877
(%i5) f(x) := sin(x)/x;
(%o5) sin(x)
f(x) := ——————
x
(%i6) a:2
(%o6) 2
(%i7) f(a);
(%o7) sin(2)
——————
2
(%i8) float(%)
(%o8) 0.4546487134128409
(%i9) (81*y^4)^(1/4);
(%o9) 3|y|
Dans les expressions n°2 et 8, le pour-cent %
désigne le dernier résultat obtenu.
Dans l'expression n°3, la commande float()
transforme la valeur symbolique √3 en nombre décimal approché (réel à virgule flottante). De même, dans l'expression n°8, il transforme l'expression symbolique sin(2)/2 en valeur décimale approchée.
Dans l'expression n°5, on définit la fonction ƒ. Dans l'expression n°6, on définit la variable a et on lui attribue la valeur de 2. L'expression n°7 calcule ƒ(a).
Tracés graphiques
modifier(%i1) plot2d(x^2, [x, -1, 1]);
(%o1) […]
(%i2) f(x,y):= sin(x) + cos(y);
(%o2) f(x,y):= sin(x) + cos(y)
(%i3) plot3d(f(x, y), [x, -2*%pi, 2*%pi], [y, -2*%pi, 2*%pi]);
(%o3) […]
L'expression n°1 trace la fonction y = x² pour x variant de -1 à 1.
L'expression n°3 trace la fonction ƒ(x, y), chacune des variables variant entre -2π et 2π.
Calculs formels
modifier(%i1) expand((x+y)^3);
(%o1) y³ + 3xy² + 3x²y + x³
(%i2) factor(x^2 - y^2);
(%o2) -(y-x)(y+x)
(%i3) a:(x^2 - 2)/(2*x^3 + 3*x + 2);
(%o3) x²-2
————————
2x³+3x+2
(%i4) subst(2, x, a);
(%o4) 1
——
12
(%i5) diff(a, x);
(%o5) ⎧ 2x (x²-2)(6x²+3)⎫
⎪———————— - —————————————⎪
⎩2x³+3x+2 (2x³+3x+2)² ⎭
(%i6) integrate(sin(x), x);
(%o6) -cos(x)
(%i7) integrate(sin(t), t, 0, x);
"Is x positive, negative or zero?" positive;
(%o7) 1-cos(x)
Les expressions n°1 et 2 montrent le développement et la factorisation d'une expression.
L'expression n°3 définit une fonction rationnelle et la met dans la variable a.
L'expression n°4 calcule a(2) : elle consiste à substituer 2 à « x » dans l'expression de a.
L'expression n°6 donne la primitive de sin(x). L'expression n°7 consiste à intégrer sin(t) entre 0 et x. Maxima demande si x est positif, négatif ou nul. Les réponses peuvent être positive
, negative
, zero
, ou bien les abréviations pos
, neg
ou 0
.
Résolution d'équations linéaires et polynomiales
modifier(%i1) solve(x^2 + 2*x - 10 = 0, x)
(%o1) [x=-sqrt(11)-1,x=sqrt(11)-1]
(%i2) linsolve([3*x + 4*y = 7, 2*x + 2*y = 13], [x, y]);
(%o2) [x=19,y=-25/2]
(%i3) algsys([3*x^2 + 4*y = 7, 2*x + 2*y = 13], [x, y]);
(%o3) [[x=-(sqrt(53)*%i-2)/3, y=(2*sqrt(53)*%i+35)/6], [x=(sqrt(53)*%i+2)/3, y=-(2*sqrt(53)*%i-35)/6]]
L'expression n°1 cherche les valeurs de x qui sont solution de
- x2 + 2x - 10 = 0.
Notons que si le second membre est nul, on peut l'omettre : on aurait pu écrire solve(x^2 + 2*x - 10, x)
.
L'expression n°2 cherche les couples de valeurs (x, y) qui sont la solution du système linéaire
S'il s'agit d'un système polynomial, on utilise algsys()
, avec la même syntaxe (expression n°3).
La fonction eliminate()
permet d'éliminer une inconnue. Par exemple :
(%i4) eliminate([3*x + 4*y = 7, 2*x + 2*y = 13], [x]);
(%o4) [-2*y-25]
nous indique que si l'on élimine la variable x du système n°2, on obtient l'équation . Cela permet de contourner des défaut du solveur. Par exemple, la version 5.43.0 de Maxima n'est pas capable de résoudre directement le système :
c'est-à-dire d'exprimer x et y' en fonction de X et de Y. En effet :
(%i1) Eq1:X = x*(1+(1-x)^2*y^2/(1-x^2*y^2))$
(%i2) Eq2:Y = y*(1-x)^2/(1-x^2*y^2)$
(%i3) solve([Eq1, Eq2], [x, y]);
(%o3) [[x=1,y=-1],[x=1,y=1]]
Les solutions trouvées correspondent à des situations de type 0/0. On peut contourner le problème avec
(%i4) Eqint1:eliminate([Eq2, Eq1], [x])$
(%i5) soluy:solve(Eqint1, y);
(%o5) [y=-(sqrt(Y^4+(-2*X^2+4*X+2)*Y^2+X^4-4*X^3+6*X^2-4*X+1)-Y^2+X^2-2*X+1)/(2*Y),y=
(sqrt(Y^4+(-2*X^2+4*X+2)*Y^2+X^4-4*X^3+6*X^2-4*X+1)+Y^2-X^2+2*X-1)/(2*Y),y=1,y=-1,y=0]
(%i6) Eqint2:eliminate([Eq2, Eq1], [y])$
(%i7) solux:solve(Eqint2, x);
(%o7) [x=-(sqrt(Y^4+(-2*X^2+4*X+2)*Y^2+X^4-4*X^3+6*X^2-4*X+1)+Y^2-X^2+2*X+1)/(2*X-4),x=
(sqrt(Y^4+(-2*X^2+4*X+2)*Y^2+X^4-4*X^3+6*X^2-4*X+1)-Y^2+X^2-2*X-1)/(2*X-4),x=1,x=0]
tout le programme: ctrlC+ctrlV:
Eq1:X = x*(1+(1-x)^2*y^2/(1-x^2*y^2))$
Eq2:Y = y*(1-x)^2/(1-x^2*y^2)$
Eqint1:eliminate([Eq2, Eq1], [x])$
Eqint2:eliminate([Eq2, Eq1], [y])$
solux:solve(Eqint2, x);
e:'diff(x, t, 2) + 2*x + 1= 0;
ode2(e, x, t);
mais il faut ensuite trier les paires de solution…
Résolution d'équations différentielles ordinaires
modifier(%i1) e:'diff(x, t, 2) + 2*x + 1= 0;
(%o1) (d²x/dt²) + 2x + 1 = 0
(%i2) ode2(e, x, t);
(%o2) x = %k1*sin(sqrt(2)*t) + %k2*cos(sqrt(2)*t) - 1/2
Dans l'expression n°1, nous définissons une équation différentielle ordinaire (EDO) d'ordre 2. Notez l'apostrophe qui interdit à Maxima d'effectuer la dérivation : l'expression « x » ne contenant pas de « t », l'évaluation de diff(x, t, 2)
donnerait 0. L'apostrophe au début de 'diff(x, t, 2)
permet de garder l'expression intacte et donc de travaille avec (d²x/dt²).
L'expression n°2 résout cette EDO. Les paramètres %k1
et %k2
désignent des constantes arbitraires k1 et k2. Une constante d'intégration serait notée %c
.
Donc ici, Maxima nous indique que les solutions de l'EDO sont les fonctions de la forme .
Optimisation
modifierPour l'optimisation linéaire par la méthode du simplex, on peut utiliser la commande minimize_lp
du module « simplex » :
(%i1) load("simplex")$;
(%i2) minimize_lp(x + y, [x + 2*y >= 2, x >= 0, y >= 0]);
(%o2) [1,[y=1,x=0]]
Ici, nous cherchons le minimum dex + y avec pour contraintes x + 2y ≥ 2, x ≥ 0 et y ≥ 0. La valeur minimale est 1 et est obtenue pour le couple de valeurs (x = 0 ; y = 1).
On peut utiliser la méthode de quasi-Newton, en particulier la méthode de Broyden-Fletcher-Goldfard-Shanno à mémoire limitée (L-BFGS) :
(%i1) load("lbfgs")$;
(%i2) lbfgs(x^2+2, '[x], '[5], 1e-3, [0, 0]);
*************************************************
N= 1 NUMBER OF CORRECTIONS=25
INITIAL VALUES
F= 2.700000000000000D+01 GNORM= 1.000000000000000D+01
*************************************************
I NFN FUNC GNORM STEPLENGTH
1 2 1.800000000000000D+01 8.000000000000000D+00 1.000000000000000D-01
2 3 2.000000000000000D+00 0.000000000000000D+00 1.000000000000000D+00
THE MINIMIZATION TERMINATED WITHOUT DETECTING ERRORS.
IFLAG = 0
(%o2) [x=0.0]
Ici, nous cherchons la valeur de x donnant le minimum de y = x2 + 2, en partant d'une valeur initiale de x valant x0 = 5, et avec un pas de 10-3. Le dernier paramètre [0, 0]
détermine le rapport de calcul généré.
La dernière ligne du rapport nous indique qu'il a fallu 2 itérations (I), donc trois évaluations de la fonction (NFN), et que la valeur minimale est 2 (FUNC). Cette valeur est atteinte pour x = 0.
Vecteurs
modifier(%i1) i:[1, 0, 0]; j:[0, 1, 0]; k:[0, 0, 1];
(%o1) [1,0,0]
(%o2) [0,1,0]
(%o3) [0,0,1]
(%i4) i . j;
(%o4) 0
(%i5) load("vect")$
(%i6) i~j;
(%o6) -[0,1,0]~[1,0,0]
(%i7) express(%);
(%o7) [0,0,1]
Dans l'expression n°1, nous définissons les vecteurs (i, j, k) de la base canonique de ℝ3. Dans l'expression n°4, nous calculons le produit scalaire. Pour éviter la confusion avec le point décimal, nous mettons un espace avant et après.
Dans l'expression n°5, nous chargeons un module complémentaire appelé « vect ». Ce module fournit entre autres le produit vectoriel (cross product), par l'opérateur ~
(tilde). Il faut utiliser la commande express()
pour que le calcul soit effectué (expression n°7).
(%i1) a:[3, 2, 1];
(%o1) [3,2,1]
(%i2) a[1];
(%o2) 3
(%i3) sqrt(a . a);
(%o3) sqrt(14)
(%i4) load("eigen")$;
(%i5) uvect(a);
(%o5) [3/sqrt(14), 2/sqrt(14), 1/sqrt(14)]
Ici, nous définission un vecteur a. L'expression n°2 extrait la première composante du vecteur. En n°3, nous calculons la norme d'un vecteur a. Puis, nous chargeons l'extension « eigen » ; cela nous fournit la commande unitvector()
(abrégée en uvect()
), qui calcule le vecteur unitaire colinéaire à a.
(%i1) A:[[1, 0, 0], [0, 1, 0], [0, 0, 1]];
(%o1) [[1,0,0],[0,1,0],[0,0,1]]
(%i2) A[1]
(%o2) [1, 0, 0]
(%i3) A[1][1]
(%o3) 1
Ici, nous définissons un vecteur de vecteurs. La première composante de A est le vecteur i, et la première composante de la première composante est le nombre 1.
Matrices
modifier(%i1) A:matrix([3, 2, 1]);
(%o1) [3 2 1]
(%i2) transpose(A);
(%o2) ⎡3⎤
⎢2⎥
⎣1⎦
(%i3) 5*A . transpose(A);
(%o3) 70
(%i4) B:transpose(A) . A;
(%o4) ⎡9 6 3⎤
⎢6 4 2⎥
⎣3 2 1⎦
(%i5) B*B;
(%o5) ⎡81 36 9⎤
⎢36 16 4⎥
⎣ 9 4 1⎦
(%i6) I:matrix([1, 0, 0], [0, 1, 0], [0, 0, 1]);
(%o6) ⎡1 0 0⎤
⎢0 1 0⎥
⎣0 0 1⎦
Nous définissons ici la matrice A de ℝ3. Nous en prenons la transposée. Dans l'expression n°3, nous calculons le produit matriciel de A par sa transposée, que nous multiplions par 5. Dans l'expression n°4, nous calculons le produit matriciel de la transposée de A par A.
Dans l'expression 5, nous effectuons une multiplication terme-à-terme.
Dans l'expression n°6, nous définissons la matrice unité de ℝ3×ℝ3.