Introduction au logiciel Maxima/Calculs élémentaires

Un livre de Wikilivres.
Sauter à la navigation Sauter à la recherche


2. Calculs élémentaires

Opérateurs et fonctions classiques[modifier | modifier le wikicode]

Maxima utilise les opérateurs et fonctions classiques.

Le séparateur décimal est le point.

Les fractions d'entiers sont manipulées de manière symbolique. Pour avoir un résultat numérique, on peut soit indiquer un entier sous forme de nombre décimal, soit utiliser la fonction float() ou bfloat() (pour les grands flottants, big floating points). La fonction factor() permet de factoriser les entiers.

(%i1) 1+1
(%o1) 2

(%i2) 1/3
(%o2) 1
      —
      3

(%i3) 1/3.0
(%o3) 0.3333333333333333

(%i4) float(1/3)
(%o4) 0.3333333333333333

(%i5) factor(10)
(%o5) 2²5²

On a donc :

  • + (addition), - (soustraction), * (produit), / (division), ^ ou ** (élévation à une puissance),
  • divide(a, b) fait la division euclidienne des polynômes a et b ; quotient(a, b) indique le résultat entier de la division euclidienne, et remainder(a, b) ou mod(a, b) donnent le reste entier de a/b,
  • sqrt() (racine carrée), nthroot(x, n) (racine n-ième de x)
  • cos(), sin(), tan() pour les fonctions trigonométriques de base, acos(), asin(), atan() pour leurs réciproques, cot() pour la cotangente ;
  • les fonctions trigonométriques hyperboliques cosh(), sinh(), tanh(), acosh(), asinh(), atanh()
  • log() pour le logarithme népérien (ln),
  • exp() pour la fonction exponentielle,
  • floor() pour l'arrondi à l'entier inférieur, round() pour l’arrondi au plus proche (0,5 → 0 et 0,5 + 10-16 → 1), ceiling() pour l'arrondi au supérieur, entier() ou fix() pour la partie entière, abs() pour la valeur absolue,
  • erf() pour la fonction d'erreur de Gauss,
  • random() pour avoir un nombre aléatoire ; si le paramètre est un entier positif, le nombre est un entier positif strictement inférieur ; si c'est un flottant positif, le nombre est un réel positif strictement inférieur ; par exemple random(6)+1 pour simuler un dé à six faces, random(1.0) pour avoir un nombre décimal entre 0 et 1,
  • la factorielle de n peut s'obtenir par n! ou bien par gamma(n+1) ;
(%i1) float(erf(2))
(%o1) 0.9953222650189527

Les puissances de 10 se notent avec la lettre « e » en minuscule ou en capitale : 5,2·103 s'écrit 5.2e3 ou 5.2E3, 5,2·10-3 s'écrit 5.2e-3 ou 5.2E-3. On peut aussi utiliser le « d » minuscule ou capital. La lettre « b » en minuscule ou capitale s'utilise pour un nombre à double précision.

Constantes particulières[modifier | modifier le wikicode]

On peut utiliser les constantes habituelles des mathématiques :

  • %e : nombre d'Euler e = 2,71828… ;
  • %pi : π = 3,14… ;
  • %phi : nombre d'or  ;
  • %i : l'imaginaire  ;
  • inf : infini réel positif ∞ ;
  • minf : infini réel négatif -∞ ;
  • infinity : infini complexe ;
  • und : résultat indéfini (undefined).

Par exemple :

(%i1) sin(%pi/4);
(%o1) 1/√2

(%i2) %e^(%i*%pi/2)
(%o2) %i

Variables[modifier | modifier le wikicode]

On peut définir des variables simplement sous la forme NomVariable:valeur. NomVariable est une chaîne de caractères commençant par une lettre ; Maxima est sensible à la casse, c'est-à-dire que les variables « a » et « A » sont deux variables différentes.

La commande values donne la liste des variables définies par l'utilisateur. La commande kill(all) supprime toutes ces variables-là.

La variable %in contient le résultat de la n-ième entrée (input). La variable %on contient le résultat du n-ième résultat (output). La variable % contient le dernier résultat, et la variable _ (tiret de soulignement) contient la dernière expression entrée.

On peut également avoir accès au n-ième précédent résultat avec %th(n). Ainsi, %th(1) donne le dernier résultat, %th(2) donne l'avant-dernier…

Complexes[modifier | modifier le wikicode]

Les nombres complexes sont entrés sous la forme a + b*%i.

z:1 + 2*%i

Les commandes realpart(z) et imagpart(z) donnent respectivement la partie réelle et la partie imaginaire du nombre complexe. La conjugaison complexe z s'obtient par conjugate(z).

Le module d'un nombre complexe s'obtient avec la commande cabs(z) ; la commande abs() fonctionne aussi, mais cabs() prend en compte un certain nombre de propriétés des fonctions complexes. L'argument complexe de z = a + bi s'obtient par carg(z).

Les commandes rectform(z) et polarform(z) donnent respectivement les formes cartésienne et polaire du nombre.

Booléens[modifier | modifier le wikicode]

Lorsque l’on assigne une valeur booléenne, on utilise true pour « vrai » et false pour « faux ».

L’opérateur ou est noté or, et est noté and, non est noté not.

Un booléen peut être obtenu en comparant deux grandeurs. La comparaison se fait avec la fonction is() :

(%i1) a:1 ; b:2 ;
(%o1) 1
(%o2) 2

(%i3) is(a#b)
(%o3) true

(%i4) is(a>b)
(%o4) false

(%i5) is(equal(a, b))
(%o5) false

(%i6) compare(a, b)
(%o6) <

Les opérateurs de comparaison sont les suivants :

  • a = b ou equal(a, b) : égalité ;
  • a # b ou notequal(a, b) : non-égalité ;
  • <, > : inégalités strictes ;
  • <=, >= : inégalités larges.

La commande compare() indique l'opérateur qui s'applique pour que l'expression soit vraie.

La commande emptyp() renvoie le booléen vrai si l'expression entre parenthèses est la liste vide (vecteur vide, matrice vide) ou bien l'ensemble vide. L'expression matrixp(A) est vraie si A est une matrice.

Polynômes et fractions rationnelles[modifier | modifier le wikicode]

Les polynômes et fractions rationnelles sont écrits de manière « intuitive ». La commande factor() fait leur factorisation :

%i1 factor((x^2-1)/(x^2 + x -6));
%o1 (x - 1) (x + 1)
    ———————————————
    (x - 2) (x + 3)

À l'inverse, la commande ratexpand() fait le développement d'une expression (la commande expand() fonctionne aussi mais est moins efficace dans le cas des polynômes et fonctions rationnelles). La commande ratsimp() simplifie une fraction rationnelle :

%i1 ratsimp((x^2-1)/(x+1))
%o1 x - 1

Les commandes trigsimp() et trigexpand() simplifient et développent les polynômes de fonctions trigonométriques.

%i1 trigexpand(sin(2*x))
%o1 2 cos(x) sin(x)

Les commandes hipow(a, x) et lopow(a, x) donnent les degrés respectivement les plus élevés et les plus faibles de l'expression a en x.

La commande horner() donne la forme du polynôme ou de la fraction rationnelle selon la méthode de horner.

La commande ratdiff(a, x) effectue la dérivation en x du polynôme ou de la fonction rationnelle a. Pour avoir la valeur numérique de la fonction polynôme ou fraction rationnelle a, pour x = n, on utilise subst(n, x, a)

%i1 f:(x^2-1)/(x^2 + x -6)
%o1 x² - 1
    ——————————
    x² + x - 6

%i2 subst(3, x, f);
%o2 4
    —
    3

calcule bien ƒ(3).

Fonctions spécifiques aux polynômes[modifier | modifier le wikicode]

Concernant spécifiquement les polynômes : coeff(a, x, n) donne le coefficient du terme de degré n pour le polynôme a en x.

%i1 a:3*x^3 + 2*x^2 - x + 6
%o1 3x³ + 2x² - x + 6

%i2 coeff(a, x, 2)
%o2 2

La commande divide(a, b) fait la division euclidienne des polynômes a et b. La commende quotient(a, b) indique le résultat entier de la division euclidienne, et remainder(a, b) donne le reste.

La commande gcd(a, b) donne le PGCD des polynômes a et b.

Fonctions spécifiques aux fractions rationnelles[modifier | modifier le wikicode]

Concernant spécifiquement les fractions rationnelles : les commandes denom() et ratdenom() donnent le dénominateur, et num(), ratnum() et ratnumer() donnent le numérateur.

Matrices[modifier | modifier le wikicode]

Pour créer une matrice, on utilise :

matrix(ligne1, ligne2, …, lignem)

ligne1, ligne2, …, lignem sont m vecteurs ligne de même dimension n ; on obtient ainsi une matrice m × n.

  • diagmatrix(n, x) crée une matrice diagonale dont les éléments valent tous x ;
  • ematrix(m, n, x, i, j) crée une matrice m × n dont toutes les valeurs valent 0 sauf le coefficient (i, j) qui vaut x ;
  • entermatrix(m, n) permet de créer une matrice m × n de manière interactive ;
  • ident(n) crée la matrice identité (ou unité) de dimension n × n ;
  • setelmx(x, i, j, M) : remplace l'élément (i, j) de la matrice M par la valeur x, et renvoie la matrice modifiée ;
  • zeromatrix(m, n) : crée la matrice nulle de dimension m × n.

Les opérateurs habituels effectuent les opérations élément par élément. C'est le cas des addition + et soustraction -, mais aussi de la division /, de la fonction exponentielle exp() et des opérateurs de multiplication * et de puissance ^.

La multiplication de matrices (dite « non commutative ») se fait avec l'opérateur  .  (espace-point-espace), et l'élévation à la puissance matricielle se fait avec l'opérateur ^^.

(%i1) M : matrix([a, b], [c, d]);
      ⎡a b⎤
(%o1) ⎢   ⎥
      ⎣c d⎦
(%i2) M*M
      ⎡a² b²⎤
(%o2) ⎢     ⎥
      ⎣c² d²⎦
(%i3) M . M
      ⎡bc+a² bd+ab⎤
(%o3) ⎢           ⎥
      ⎣cd+ac d²+bc⎦
(%i4) M^3
      ⎡a³ b³⎤
(%o4) ⎢     ⎥
      ⎣c³ d³⎦
(%i5) M^^3
      ⎡c(bd+ab)+a(bc+a²) d(bd+ab)+b(bc+a²)⎤
(%o5) ⎢                                   ⎥
      ⎣c(d²+bc)+a(cd+ac) d(d²+bc)+b(cd+ac)⎦
(%i6) M^^-1
      ⎡  d      b  ⎤
      ⎢————— -—————⎥
(%o6) ⎢ad-bc  ad-bc⎥
      ⎢   c     a  ⎥
      ⎢-————— —————⎥
      ⎣ ad-bc ad-bc⎦
(%i7) diagmatrix(2, 1)
      ⎡1 0⎤
(%o7) ⎢   ⎥
      ⎣0 1⎦

L'expression 6 calcule la matrice inverse.

Voici quelques fonctions classiques :

  • adjoint(M) : matrice adjointe (transconjuguée) de M ;
  • charpoly(M, x) ou ncharpoly(M, x) : calcule le polynôme caractéristique de la matrice M avec l'inconnue x, c'est-à-dire determinant(M - diagmatrix(length(M), x)) ;
  • col(M, i) : renvoie la i-ème colonne de M, sous la forme d'une matrice colonne ;
  • determinant(M) : calcule le déterminant de M ;
  • echelon(M) effectue le pivot de Gauss sur M et renvoie une matrice diagonale supérieure, le premier élément non-nul de chaque ligne étant normalisé à 1 ; voir aussi triangularize() ;
  • gramschmidt(M) fait une orthogonalisation selon l'algorithme de Gram-Schmidt ;
  • invert(M) : calcule la matrice inverse en utilisant la factorisation LU (comme M^^-1) ;
  • invert_by_adjoint(M) : calcule la matrice inverse en utilisant la méthode des cofacteurs ;
  • length(M) : indique la plus petite dimension de M ;
  • matrixp(a) : indique si l'expression a est une matrice ou non ; la valeur retournée est un booléen true (c'est une matrice) ou false (ce n'en est pas une) ;
  • mattrace(M) : trace de la matrice ;
  • minor(M, i, j) : donne la sous-matrice de M obtenue en enlevant la ligne i et la colonne j ;
  • newdet(M) : calcule le déterminant d'une matrice polynomiale par la méthode de Johnson-Gentleman, et exprime le résultat sous la forme de l'expression rationnelle canonique (CRE, canonical rational expression) ;
  • rank(M) : donne le rang de la matrice ;
  • row(M, i) : retourne la i-ème ligne de la matrice, sous la forme d'une matrice ligne ;
  • similaritytransform(M) ou simtran(M) : détermine une matrice semblable ;
  • submatrix(i1, i2, …, im, M, j1, j2, …, jn) : retourne la sous-matrice obtenue en supprimant les lignes i1, i2, …, im et les colonnes j1, j2, …, jn ;
  • transpose(M) : transpose la matrice M ;
  • triangularize(M) : détermine une matrice triangulaire supérieure en appliquant le pivot de Gauss-Jordan, mais sans normalisation ; voir aussi echelon() ;

L'extension eigen (chargée par la commande load(eigen)$) donne accès aux fonctions suivantes :

  • eigenvalues(M) ou eivals(M) calcule les valeurs propres, en utilisant la fonction solve(), et renvoie deux listes : la première avec les valeurs propres et la seconde avec les multiplicités des valeurs propres ;
  • eigenvectors(M) ou eivects(M) calcule les valeurs propres (première liste) et les vecteurs propres (seconde liste) ;
  • innerproduct(X, Y) ou inprod(X, Y) : fait le produit scalaire conjugate(X) . Y ;

Notez que l'extension eigen est chargée automatiquement si l'on utilise les fonctions eigenvalues/eivals() et eigenvector/eivects().

Chaînes de caractères[modifier | modifier le wikicode]

Une chaîne de caractère est un expression comprise entre des guillemets doubles ". Si l'on veut faire figurer un guillemet « " » dans la chaîne, on utilise \". Si l'on veut utiliser une barre de fraction inversée « \ », on la redouble \\.

Les commandes concat(a, b) et sconcat(a, b) font la concaténation des chaînes a et b. La commande string(a) transforme l'expression a en une chaîne de caractères.

Notes[modifier | modifier le wikicode]


Interface et premiers exemples < >