1. Interface utilisateur et premiers exemples
Interface.
Maxima 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 codice_1, et on obtient son résultat.
Attention :
L'invite de commande est de la forme codice_4 où "n" est le numéro de la commande (« i » pour '). Le résultat est indiqué sur la ligne d'après, précédé de codice_5 (« o » pour ').
Si l'on ne veut pas que le résultat s'affiche, on termine la ligne par un signe dollar codice_6.
Si l'on ne veut pas qu'une expression soit évaluée, on met une apostrophe codice_7 devant. Par exemple, codice_8 renvoie codice_9 (on dérive deux fois par rapport à "t" une expression ne contenant pas "t"), tandis que codice_10 renvoie d2"x"/d"t"2 (expression non évaluée, laissée telle quelle).
Premiers exemples.
Calculs simples.
(%i1) 1+1;
(%o1) 2
(%i2) %+2;
(%o2) 4
(%o3) 1
 √2
(%i4) float(sqrt(3));
(%o4) 1.732050807568877
(%i5) f(x) := sin(x)/x;
 f(x) := ——————
 x
(%i6) a:2
(%o6) 2
(%i7) f(a);
 2
(%o8) 0.4546487134128409
(%i9) (81*y^4)^(1/4);
(%o9) 3|y|
Dans les expressions n°2 et 8, le pour-cent codice_11 désigne le dernier résultat obtenu.
Dans l'expression n°3, la commande codice_12 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.
(%i1) plot2d(x^2, [x, -1, 1]);
(%o1) […]
(%i2) 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.
(%i1) expand((x+y)^3);
(%o1) y³ + 3xy² + 3x²y + x³
(%i2) factor(x^2 - y^2);
(%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);
(%i7) integrate(sin(t), t, 0, x);
"Is x positive, negative or zero?" positive;
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 codice_13, codice_14, codice_15, ou bien les abréviations codice_16, codice_17 ou codice_9.
Résolution d'équations linéaires et polynomiales.
(%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
Notons que si le second membre est nul, on peut l'omettre : on aurait pu écrire codice_19.
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 codice_20, avec la même syntaxe (expression n°3).
La fonction codice_21 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 formula_3. 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.
(%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 codice_22 donnerait 0. L'apostrophe au début de codice_23 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 codice_24 et codice_25 désignent des constantes arbitraires "k"1 et "k"2. Une constante d'intégration serait notée codice_26.
Donc ici, Maxima nous indique que les solutions de l'EDO formula_5 sont les fonctions de la forme formula_6.
Optimisation.
Pour l'optimisation linéaire par la méthode du simplex, on peut utiliser la commande codice_27 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 de"x" + "y" avec pour contraintes "x" + 2"y" ≥ 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" = "x"2 + 2, en partant d'une valeur initiale de "x" valant "x"0 = 5, et avec un pas de 10-3. Le dernier paramètre codice_28 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.
(%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 "()", par l'opérateur codice_29 (tilde). Il faut utiliser la commande codice_30 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);
(%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 codice_31 (abrégée en codice_32), 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.
(%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.
Notes et références.
"Sommaire" < ↑ > Calculs élémentaires