Algèbre linéaire

Tout traitement mathématique est vu par Scilab comme une manipulation de matrices. Pour l'algèbre linéaire, les fonctionnalités sont donc particulièrement développées. Dans une utilisation un peu avancée, on aura intérêt à tirer parti de la structure de matrice creuse (sparse) que nous n'aborderons pas.

Il est important de garder à l'esprit que tous les calculs numériques dépendent de la représentation des nombres réels en machine, et que donc les résultats «exacts» n'existent pas. La détection de singularités dépend d'une précision prédéfinie et n'est donc pas infaillible.

rank([1,1;1,1])
rank([1.00000000000001,1;1,1])
rank([1.000000000000001,1;1,1])
inv([1,1;1,1])
A=[1,2,3;4,5,6;7,8,9]
det(A)
det(A')
rank(A)
inv(A)     // le calcul est effectue
inv(A')    // message d'erreur
A*inv(A)   // ce n'est pas l'identite

Si A et B sont deux matrices, alors A\B retourne une matrice X telle que A*X=B, et B/A une matrice X telle que X*A=B pourvu que les dimensions de A et B soient compatibles. Si A n'est pas une matrice carrée inversible, ces commandes retourneront un résultat, qu'il y ait une infinité de solutions ou qu'il y en ait aucune.

A=[1,2,3;4,5,6;7,8,9]
b=[1;1;1]
x=A\b       // le systeme a une infinite de solutions
A*x
b=[1,1,1]
x=b/A       // le systeme a une infinite de solutions  
x*A        
b=[1;1;2]
x=A\b       // le systeme n'a pas de solution
A*x
b=[1,1,2]
x=b/A       // le systeme n'a pas de solution 
x*A

Si A est carrée et régulière x=A\b est unique et équivalent mathématiquement à x=inv(A)*b mais plus rapide.

b=[1:500]';
A=diag(b);
timer(); A\b ; timer()
timer(); inv(A)*b ; timer()

Pour résoudre un système linéaire quand on craint une singularité, il vaut mieux utiliser linsolve, qui détecte les impossibilités et peut retourner une base du noyau de la matrice en cas de solutions multiples. Attention, linsolve(A,b) résout A*x=-b.

A=[1,2,3;4,5,6;7,8,9]
b=[1;1;1]
[x,k]=linsolve(A,b)
A*x
A*k
b=[1;1;2]
[x,k]=linsolve(A,b)  // erreur

La commande [D,U]=bdiag(A) retourne (en théorie) une matrice diagonale D et une matrice inversible U telles que U*D*inv(U)=A.

A=diag([1,2,3]); P=rand(3,3); A=P*A*inv(P)
spec(A)
[D,U]=bdiag(A)       // matrice diagonalisable
inv(U)*A*U
U*D*inv(U)-A
A=[1,0,0;0,1,1;0,0,1]; P=rand(3,3); A=P*A*inv(P)
spec(A)
[D,U]=bdiag(A)       // matrice non diagonalisable
inv(U)*A*U
U*D*inv(U)-A
[X,diagevals]=spec(A)

La décomposition LU d'une matrice, c'est-à-dire la décomposition en produit d'une matrice triangulaire inférieure L et d'une matrice triangulaire supérieure U, à des permutations près, s'obtient grâce à la commande lu.

A= [ 1, 2, 3; 4, 5, 6 ; 7, 8, 9  ]
[L,U,E]=lu(A)
E*A-L*U
det(U)
det(A)

Opérations matricielles
A'	transposée (conjuguée) de A
rank	rang
lu	décomposition LU
inv	inverse
expm	exponentielle matricielle
det	déterminant
trace	trace
poly(A,"x")	polynôme caractéristique de A
spec	valeurs propres de A
bdiag	diagonalisation
svd	décomposition en valeurs singulières
A\b	solution de A*x = b
b/A	solution de x*A = b
linsolve(A,b)	solution de A*x = -b