Outils pour l’Algèbre

## 4 Outils pour l’Algèbre

### 4.1 Arithmétique des entiers

Les opérations sur les entiers figurent dans le menu `Cmds->Entier`. Les calculs modulo p se font en utilisant `% p`. Une fois défini un entier modulo p, disons `a:=3%5`, tous les calculs seront efffectués dans ℤ/pℤ : `a*2` renvoie `1%5` (6 modulo 5), `1/a` renvoie `2%5`, … Pour calculer efficacement les puissances modulo p, on peut utiliser ce qui précède, ou la fonction `powermod` ou `powmod`.

    a:=3%5
    a+12
    a^4
    powermod(3,4,5)

Nombres entiers
`a%p` | a modulo p
`powmod(a,n,p)` | an modulo p
`irem` | reste de la division euclidienne
`iquo` | quotient de la division euclidienne
`iquorem` | quotient et reste
`ifactor` | décomposition en facteurs premiers
`ifactors` | liste des facteurs premiers
`idivis` | liste des diviseurs
`gcd` | plus grand diviseur commun
`lcm` | plus petit multiple commun
`iegcd` | identité de Bezout
`iabcuv` | renvoie [u,v] tels que au+bv=c
`is_prime` | l’entier est-il premier
`nextprime` | prochain entier premier
`previousprime` | entier premier précédent

### 4.2 Polynômes et fractions rationnelles

Les fonctions de traitement des polynômes sont dans le menu `Cmds->Polyn\^omes`.

On utilise `normal` ou `expand` pour développer, ou plus généralement mettre une fraction sous forme irréductible, et `factor` pour factoriser. Le résultat dépend du corps de nombres dans lequel on se place. Par défaut il s’agit des rationnels si les coefficients sont exacts ou des réels sinon. Pour les complexes (exacts ou approchées), il faut activer l’option `Complexe` à partir du bouton rappelant la configuration `Config:...`. On peut aussi déclarer les coefficients comme des entiers modulo p pour travailler dans ℤ/pℤ (commande `%`) ou dans un corps fini (défini par la commande `GF`). Exécutez les commandes suivantes avant et après avoir activé l’option `Complexe`.

    P:=x^4-1
    factor(P)
    gcd(P,x^3-1)
    divis(P)
    propfrac(x^4/P)
    partfrac(4/P)
    Q:=(x^4+1)%3
    factor(Q)
    G:=GF(2,8,['a','G'])
    factor(G(a^3)*x^2+1)
    genpoly(5,3,x)
    genpoly(2,3,x)
    genpoly(2*y+5,3,x)

Polynômes
`normal` | forme normale (développée et réduite)
`expand` | forme développée
`ptayl` | forme de Taylor
`peval` ou `horner` | évaluation en un point par l’algorithme de Horner
`genpoly` | polynôme défini par sa valeur en un point
`canonical_form` | trinôme sous forme canonique
`coeff` | (liste des) coefficient(s)
`poly2symb` | de l’expression algébrique à la forme symbolique
`symb2poly` | de la forme symbolique à l’expression algébrique
`pcoeff` | polynôme décrit par ses racines
`degree` | degré
`lcoeff` | coefficient du terme de plus haut degré
`valuation` | degré du monôme de plus bas degré
`tcoeff` | coefficient du terme de plus bas degré
`factor` | décomposition en facteurs premiers
`factors` | liste des facteurs premiers
`divis` | liste des diviseurs
`collect` | factorisation sur les entiers
`froot` | racines avec leurs multiplicités
`proot` | valeurs approchées des racines
`sturmab` | nombre de racines dans un intervalle
`getNum` | numérateur d’une fraction rationnelle
`getDenom` | dénominateur d’une fraction rationnelle
`propfrac` | isole partie entière et fraction propre
`partfrac` | décomposition en éléments simples
`quo` | quotient de la division euclidienne
`rem` | reste de la division euclidienne
`gcd` | plus grand diviseur commun
`lcm` | plus petit multiple commun
`egcd` | identité de Bezout
`divpc` | division suivant les puissances croissantes
`randpoly` | polynôme aléatoire
`cyclotomic` | polynômes cyclotomiques
`lagrange` | polynômes de Lagrange
`hermite` | polynômes de Hermite
`laguerre` | polynômes de Laguerre
`tchebyshev1` | polynômes de Tchebyshev
`tchebyshev2` | polynômes de Tchebyshev

### 4.3 Trigonométrie

Le menu `Cmds->R\'eel->Transcendental` contient les fonctions circulaires et hyperboliques ainsi que leurs inverses. Pour linéariser et développer on utilise `tlin` et `texpand`. Beaucoup d’autres réécritures sont accessibles à partir des menus

- `Expression->Trigo` : transformations en tan(x/2) (halftan), transformation des tangentes en sinus et cosinus (tan2sincos), …
- `Expression->Trigo exp` : transformation des fonctions trigonométriques en exponentielles par les formules d’Euler (trig2exp), transformation des exponentielles en fonctions trigonométriques (exp2trig), transformation des exponentielles en puissances (exp2pow)...,
- `Expression->Trigo inv` : transformation des fonctions inverses

    exp2pow(exp(3*ln(x)))
    exp2trig(exp(i*x))
    trig2exp(cos(x))
    E:=sin(x)^4+sin(x)^3
    El:=tlin(E)
    texpand(El)
    tsimplify(E)
    tsimplify(El)
    tsimplify(E-El)
    halftan(E)
    trig2exp(El)
    Et:=trigtan(E)
    tan2sincos(Et)
    tan2sincos2(Et)
    tan2cossin2(Et)

Trigonométrie
`tlin` | linéariser
`tcollect` | linéariser et regrouper
`texpand` | forme polynomiale
`trig2exp` | trigonométrique vers exponentielle
`exp2trig` | exponentielle vers trigonométrique
`hyp2exp` | hyperbolique vers exponentielle

### 4.4 Vecteurs et matrices

Un vecteur est une liste de nombres, une matrice est la liste de ses vecteurs lignes. Le produit matriciel est noté comme le produit ordinaire `*`. Les vecteurs sont a priori des vecteurs lignes, mais le produit à droite par un vecteur ligne est effectué comme si c’était une colonne. En particulier, si `v` et `w` sont deux vecteurs de même taille, `v*w` retourne leur produit scalaire.

    A:=[[1,2,3],[4,5,6],[7,8,9]]
    v:=[1,1,1]
    v*v
    A*v
    v*A
    B:=[[1,1,1],[2,2,2]]
    A*B
    B*A
    A*tran(B)

A partir d’une fonction qui à deux indices (j,k) associe un réel a(j,k), on peut constituer une matrice avec `makemat` ou `matrix`. Pour `makemat` les indices commencent à 0, pour `matrix` il commencent à 1.

    makemat((j,k)->j+2*k,3,2)
    matrix(3,2,(j,k)->j+2*k)

On peut aussi créer des matrices par blocs avec la commande `blockmatrix`.

    A:=makemat((j,k)->j+2*k,3,2)
    B:=idn(3)
    blockmatrix(1,2,[A,B])
    blockmatrix(2,2,[A,B,B,A])

On accède à un élément d’une matrice grâce à deux indices séparés par une virgule et mis entre crochets. Le premier indice est l’indice de la ligne et le deuxième celui de la colonne. Les indices commencent à 0. Par exemple, si `A:=[[0,2],[1,3],[2,4]]` alors `A[2,1]` renvoie `4`. Pour extraire un bloc de la matrice, on utilise des intervalles comme indices : `A[1..2,0..1]` renvoie le bloc constitué des lignes 1 à 2 et des colonnes 0 à 1.

Notez que les matrices de Xcas sont recopiées entièrement à chaque modification d’un coefficient. Ceci est pénalisant si on modifie successivement dans un programme beaucoup de coefficients d’une même (grande) matrice.

Vecteurs et matrices
`v*w` | produit scalaire
`cross(v,w)` | produit vectoriel
`A*B` | produit matriciel
`A.*B` | produit terme à terme
`1/A` | inverse
`tran` | transposée
`rank` | rang
`det` | déterminant
`ker` | base du noyau
`image` | base de l’image
`idn` | matrice identité
`ranm` | matrice à coefficients aléatoires

### 4.5 Systèmes linéaires

La fonction `linsolve` résout une liste d’équations linéaires, avec la même syntaxe que solve. On peut aussi utiliser `simult` pour résoudre plusieurs systèmes d’équations linéaires qui ne diffèrent que par leur second membre, en mettant comme premier argument la matrice du système et comme second argument la matrice dont la (ou les) colonnes sont le (ou les) second membre(s) des systèmes, ou bien `rref` d’argument une matrice obtenue en bordant la matrice du système avec lesecond membre (border(A,tran(b)) si b est une matrice colonne). Quand le système est impossible, `linsolve` retourne la liste vide, `simult` retourne un message d’erreur, `rref` retourne une matrice dont une des lignes est nulle, sauf le dernier coefficient. Quand le système est indéterminé, `linsolve` retourne la solution fonction de certaines variables, `simult` retourne seulement une solution, `rref` retourne une matrice dont une ou plusieurs lignes sont nulles. L’exemple ci-dessous concerne le système

⎧ ⎪ ⎨ ⎪ ⎩ |
x | + | y | + | az | = | 1
x | + | a y | + | z | = | 1
ax | + | y | + | z | = | −2

Il a une solution unique pour a≠ 1 et a≠ −2, il est impossible pour a=1 et il est indéterminé pour a=−2.

    linsolve([x+y+a*z=1,x+a*y+z=1,x+a*y+z=-2],[x,y,z])
    a:=1
    linsolve([x+y+a*z=1,x+a*y+z=1,x+a*y+z=-2],[x,y,z])
    a:=-2
    linsolve([x+y+a*z=1,x+a*y+z=1,x+a*y+z=-2],[x,y,z])
    purge(a)
    A:=[[1,1,a],[1,a,1],[a,1,1]]
    solve(det(A),a)
    A1:=subst(A,a=1)
    rank(A1)
    image(A1)
    ker(A1)
    A2:=subst(A,a=-2)
    rank(A2)
    image(A2)
    ker(A2)
    b:= [1,1,-2]
    B:=tran(b)
    simult(A,B)
    simult(A1,B)
    simult(A2,B)
    M:=blockmatrix(1,2,[A,B])
    rref(M)
    rref(border(A,b))
    rref(border(A1,b))
    rref(border(A2,b))

Systèmes linéaires
`linsolve` | résolution d’un système
`simult` | résolution simultanée de plusieurs systèmes
`rref` | réduction de Gauss-Jordan
`rank` | rang
`det` | déterminant du système

### 4.6 Réduction des matrices

La fonction `jordan` prend en entrée une matrice A et retourne en sortie une matrice de passage P et une forme réduite de Jordan J telles que P−1A P=J. Soit A est diagonalisable auquel cas J est diagonale et contient les valeurs propres de A sur la diagonale, soit A n’est pas diagonalisable et J comporte des "1" ou des "0" au-dessus de la diagonale. Pour les matrices exactes et symboliques, seules les valeurs propres calculables par `solve` sont accessibles. Pour des matrices de nombres approchés, un algorithme numérique est utilisé, et il risque d’échouer en cas de valeurs propres multiples ou très proches. La matrice A de l’exemple qui suit a pour valeurs propres doubles 1 et 2. Elle est diagonalisable pour a=0, non diagonalisable pour a≠ 0.

    A:=[[1,1,-1,0],[0,1,0,a],[0,-1,2,0],[1,0,1,2]
    factor(poly2symb(simplify(pcar(A))))
    jordan(A)
    eigenvals(A)
    eigenvects(A)
    jordan(subs(A,a=0))
    eigenvects(subs(A,a=1))
    jordan(evalf(subs(A,a=0)))
    jordan(evalf(subs(A,a=1)))

Certaines fonctions, définies par des séries entières, s’étendent aux matrices dès lors que l’on sait calculer leur forme de Jordan. La plus utile est l’exponentielle.

    A:=[[0,1,0],[0,0,1],[-2,1,2]]
    jordan(A)
    exp(A)
    ln(A)
    sin(A)

Réduction des matrices
`jordan` | diagonalisation ou réduction de Jordan
`pcar` | coefficients du polynôme caractéristique
`pmin` | coefficients du polynôme minimal
`eigenvals` | valeurs propres
`eigenvects` | vecteurs propres