Construire des matrices

Tout calcul, programmation ou tracé graphique peut se faire à partir de matrices rectangulaires. En Scilab, tout est matrice : les scalaires sont des matrices $1\times 1$ , les éléments de $\mathbb{R}^n$ sont des vecteurs colonnes, c'est-à-dire des matrices $n\times 1$ et les vecteurs lignes sont des matrices $1\times n$ .

On peut saisir manuellement des (petites) matrices. Les coefficients d'une même ligne sont séparés par des blancs ou des virgules (préférable). Les lignes sont séparées par des points-virgules. La transposée est notée par une apostrophe. Elle permet en particulier de changer un vecteur ligne en un vecteur colonne.

x=[1,2,3]
x'
A=[1,2,3;4,5,6;7,8,9]
A'

On a souvent besoin de connaître les dimensions d'une matrice (par exemple pour vérifier si un vecteur est une ligne ou une colonne). On utilise pour cela la fonction size. Les options "r" ou "c" désignent les lignes (rows) ou les colonnes (columns).

La fonction size
`size(A)`	nombre de lignes et de colonnes
`size(A,"r")`ou `size(A,1)`	nombre de lignes
`size(A,"c")`ou `size(A,2)`	nombre de colonnes
`size(A,"*")`	nombre total d'éléments

help size
A=[1,2,3;4,5,6]
size(A)
size(A')
size(A,1)
size(A,"c")
size(A,"*")

Les commandes d'itération permettent de construire des vecteurs de nombres séparés par des pas positifs ou négatifs. La syntaxe de base, [deb:pas:fin], retourne un vecteur ligne de valeurs allant de deb à fin par valeurs séparées par des multiples de pas. Les crochets sont facultatifs. Par défaut, pas vaut . Selon que fin-deb est ou non un multiple entier de pas, le vecteur se terminera ou non par fin.

Si l'on souhaite un vecteur commençant par deb et se terminant par fin avec n coordonnées régulièrement espacées, il est préférable d'utiliser linspace(deb,fin,n).

v=0:10
v=0.10       
v=[0:10]
v=[0;10]
v=[0,10]             // attention aux confusions
v=[0:0.1:1]
size(v)
v=[0:0.1:0.99]
size(v)
v=[0:0.15:1]
v=[1:-0.15:0]
v=linspace(0,1,10)
v=linspace(0,1,11)
v=linspace(0,1)      // attention, n=100 par defaut
v=logspace(1,2,11)   // puissances de 10
v-10^(linspace(1,2,11))

L'élément de la i-ième ligne, j-ième colonne de la matrice A est A(i,j). Si v et w sont deux vecteurs d'entiers, A(v,w) désigne la sous-matrice extraite de A en conservant les éléments dont l'indice de ligne est dans v et l'indice de colonne dans w. A(v,:) (respectivement : A(:,w)) désigne la sous-matrice formée des lignes (resp. : des colonnes) indicées par les coordonnées de v (resp. : w). Les coordonnées sont numérotées à partir de . Le dernier indice peut être désigné par $.

A=[1,2,3;4,5,6]
A(2,2)
A(:,2)
A(:,[1,3])
A(1,$)
A($,2)

On peut modifier un élément, une ligne, une colonne, pourvu que le résultat reste une matrice. Pour supprimer des éléments, on les affecte à la matrice vide : []

A=[1,2,3;4,5,6]
A(1,3)=30
A(:,[1,3])=[10,20]       // erreur
A(:,[1,3])=[10,30;40,60]
A(:,[1,3])=0             
A(:,2)=[]

Il suffit d'un indice pour repérer les éléments d'un vecteur ligne ou colonne.

v=[1:6]
v(3)
v(4)=40
v([2:4])=[]
w=[1:6]'
w([2,4,6])=0

Faire appel à un élément dont un des indices dépasse le nombre de lignes ou de colonnes de la matrice provoque un message d'erreur. Cependant on peut étendre une matrice en affectant de nouvelles coordonnées, au-delà de sa taille. Les coordonnées intermédiaires sont nulles par défaut.

A=[1,2,3;4,5,6]
A(0,0)          // erreur
A(3,2)          // erreur
A(3,2)=1        
v=[1:6]
v(8)            // erreur
v(8) = 1

Vecteurs
`x:y`	nombres de `x` à `y` par pas de 1
`x:p:y`	nombres de `x` à `y` par pas de `p`
`linspace(x,y)`	nombres entre `x` et `y`
`linspace(x,y,n)`	`n` nombres entre `x` et `y`
`v(i)`	`i`-ième coordonnée de `v`
`v($)`	dernière coordonnée de `v`
`v(i1:i2)`	coordonnées `i1` à `i2` de `v`
`v(i1:i2)=[]`	supprimer les coordonnées `i1` à `i2` de `v`

Matrices
`A(i,j)`	coefficient d'ordre `i,j` de `A`
`A(i1:i2,:)`	lignes `i1` à `i2` de `A`
`A($,:)`	dernière ligne de `A`
`A(i1:i2,:)=[]`	supprimer les lignes `i1` à `i2` de `A`
`A(:,j1:j2)`	colonnes `j1` à `j2` de `A`
`A(:,$)`	dernière colonne de `A`
`A(:,j1:j2)=[]`	supprimer les colonnes `j1` à `j2` de `A`
`diag(A)`	coefficients diagonaux de `A`

Si A, B, C, D sont 4 matrices, les commandes [A,B], [A;B], [A,B;C,D] retourneront des matrices construites par blocs, pourvu que les dimensions coïncident. En particulier, si v et w sont deux vecteurs lignes, [v,w] les concaténera, tandis que [v;w] les empilera (s'ils sont de même longueur).

A=[1,2,3;4,5,6]
M=[A,A]
M=[A;A]
M=[A,A']                 // erreur
M=[A,[10;20];[7,8,9],30]  
M=[A,[10,20];[7,8,9],30] // erreur

Des fonctions prédéfinies permettent de construire certaines matrices particulières.

Matrices particulières
`zeros(m,n)`	matrice nulle de taille `m,n`
`ones(m,n)`	matrice de taille `m,n` dont les coefficients valent 1
`eye(m,n)`	matrice identité de taille min(`m,n`), complétée par des zéros
`rand(m,n)`	matrice de taille `m,n` à coefficients aléatoires uniformes sur
`diag(v)`	matrice diagonale dont la diagonale est le vecteur `v`
`diag(v,k)`	matrice dont la -ième diagonale est le vecteur `v`
`diag(A)`	extrait la diagonale de la matrice `A`
`diag(A,k)`	extrait la -ième diagonale de la matrice `A`
`triu(A)`	annule les coefficients au-dessous de la diagonale
`tril(A)`	annule les coefficients au-dessus de la diagonale
`toeplitz`	matrices à diagonales constantes

d=[1:6]
D=diag(d)
diag(d,1)
A=[1,2,3;4,5,6]
d=diag(A)
B=[A,zeros(2,3);rand(2,2),ones(2,4)]
diag(B,1)
diag(B,-1)
diag(B,0)
help toeplitz
M=toeplitz([1:4],[1:5])
triu(M)
tril(M)

Les commandes zeros, ones, eye, rand retournent des matrices dont la taille peut être spécifiée soit par un nombre de lignes et de colonnes, soit par une autre matrice. Si un seul nombre est donné comme argument, ce nombre est compris comme une matrice de taille $1\times 1$ .

A=ones(5,5)      // 5 lignes et 5 colonnes
rand(A)          // idem
eye(A)           // idem 
eye(5)           // 1 ligne et 1 colonne
ones(5)          // idem
rand(size(A))    // 1 ligne et 2 colonnes

On dispose de deux moyens pour réordonner des coefficients en une nouvelle matrice. La commande A(:) concatène toutes les colonnes de A en un seul vecteur colonne (on peut jouer avec la transposée pour concaténer les vecteurs lignes). La fonction matrix crée une matrice de dimensions spécifiées, pourvu qu'elles soient compatibles avec l'entrée. On peut même créer avec matrix des tableaux à plus de deux entrées (hypermatrices), ce qui ne sert que rarement.

v=[1:6]
help matrix
A=matrix(v,2,2)    // erreur
A=matrix(v,3,3)    // erreur
A=matrix(v,2,3)
A=matrix(v,3,2)'
w=A(:)
A=A'; w=A(:)'
H=matrix([1:24],[2,3,4])

Un peu d'algèbre permet souvent de construire des matrices particulières à peu de frais, en utilisant le produit, noté *, et la transposée. Le produit de Kronecker, kron ou .*., peut également être utile.

A=ones(4,1)*[1:5]
A=[1:4]'*ones(1,5)
B=[1,2;3,4]
kron(B,B)
kron(B,eye(B))
kron(eye(B),B)
kron(B,ones(2,3))
kron(ones(2,3),B)

Un générateur de nombres pseudo-aléatoires plus performant que rand est fourni par la commande grand. Dans sa syntaxe, il faut indiquer les dimensions du tableau, la loi de distribution et les paramètres nécessaires :

grand(2,2,'bin',100,0.5)
grand(1,10,'uin',-100,100)
help grand