Introduction au logiciel Maxima/Interface et premiers exemples

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 [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 d²x/dt² (expression non évaluée, laissée telle quelle).

Premiers exemples

Calculs simples

(%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

(%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

(%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.

\int _{0}^{x}\sin(t)\mathrm {d} t=1-\cos(x)

Résolution d'équations linéaires et polynomiales

(%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

x² + 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

{\begin{cases}3x+4y&=&7\\2x+2y&=&13\end{cases}}

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 $-2y-25=0$ . 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 :

{\begin{cases}\mathrm {X} =x\left(1+{\frac {(1-x)^{2}y^{2}}{(1-x)^{2}}}\right)\\\mathrm {Y} =y{\frac {(1-x)^{2}}{(1-x)^{2}}}\end{cases}}

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 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 k₁ et k₂. Une constante d'intégration serait notée %c.

Donc ici, Maxima nous indique que les solutions de l'EDO ${\frac {\mathrm {d} ^{2}x}{\mathrm {d} t^{2}}}+2x+1=0$ sont les fonctions de la forme $x=k_{1}\cdot \sin({\sqrt {2}}t)+k_{2}\cdot \cos({\sqrt {2}}t)-{\frac {1}{2}}$ .

Optimisation

Pour 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 = x² + 2, en partant d'une valeur initiale de x valant x₀ = 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

(%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 ℝ³. 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

(%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 ℝ³. 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 ℝ³×ℝ³.

Notes et références

Sommaire < ↑ > Calculs élémentaires