# Introduction au logiciel Maxima/Calculs élémentaires

2. Calculs élémentaires

## Opérateurs et fonctions classiques

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.
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) ;
Les puissances de 10 se notent avec la lettre « e » en minuscule ou en capitale : 5,2·10$^3$ 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

On peut utiliser les constantes habituelles des mathématiques :
* %e : nombre d'Euler e = 2,71828… ;
* %pi : π = 3,14… ;
* %phi : nombre d'or $\displaystyle \varphi ={\frac {1+{\sqrt {5}}}{2}}=1,618\ldots$ ;
* %i : l'imaginaire $\displaystyle i={\sqrt {-1}}$ ;
* inf : infini réel positif ∞ ;
* minf : infini réel négatif -∞ ;
* infinity : infini complexe ;
* und : résultat indéfini (undefined).
Par exemple :

## Variables

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

Les nombres complexes sont entrés sous la forme a + b*%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

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 :
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

Les polynômes et fractions rationnelles sont écrits de manière « intuitive ». La commande factor fait leur factorisation :
À 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 :
Les commandes trigsimp et trigexpand simplifient et développent les polynômes de fonctions trigonométriques.
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)
calcule bien ƒ(3).

### Fonctions spécifiques aux polynômes

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

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

Pour créer une matrice, on utilise :
    matrix(ligne1, ligne2, …, lignem)
où 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 ^^.
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 i$_1$, i$_2$, …, i$_m$ et les colonnes j$_1$, j$_2$, …, j$_n$ ;
* 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

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

Interface et premiers exemples < ↑ > …