Vecteurs et Matrices en Scilab
Dans Scilab, le type de données fondamental est la matrice. Tout est matrice : un scalaire est une matrice 1×1, un vecteur est une matrice à une seule ligne ou colonne. Cette conception permet d'effectuer des opérations d'algèbre linéaire complexes avec une syntaxe concise et des performances élevées.
Définition — Matrice ScilabUne matrice Scilab est définie par trois caractéristiques :
- Nombre de lignes (
nr) - Nombre de colonnes (
nc) - Type de données : réel, entier, booléen, chaîne ou polynomial
nr et nc ont la même forme (shape).| Type | Taille | Exemple |
|---|---|---|
| Scalaire | 1 × 1 | x = 5 |
| Vecteur ligne | 1 × nc | v = [1, 2, 3] |
| Vecteur colonne | nr × 1 | v = [1; 2; 3] |
| Matrice | nr × nc | A = [1 2; 3 4] |
| Matrice vide | 0 × 0 | M = [] |
Performances — Opérations vectorisées Un script Scilab utilisant des boucles pour traiter des matrices est généralement 10 à 100 fois plus lent qu'un script équivalent utilisant les opérateurs matriciels de haut niveau. Toujours privilégier les opérations sur matrices entières plutôt que les traitements élément par élément via des boucles.
1. Créer une matrice
Syntaxe de création
// Symboles utilisés
// [ ] — délimitent la matrice
// , — sépare les colonnes (ou espace)
// ; — sépare les lignes (ou saut de ligne)
// Syntaxe avec virgules et points-virgules
A = [a11, a12, a13 ; a21, a22, a23]
// Syntaxe allégée — espaces et sauts de ligne
A = [a11 a12 a13
a21 a22 a23]Exemple n°1 — Créer une matrice 2×3
// Avec virgules et points-virgules
A = [1, 2, 3 ; 4, 5, 6]
// Syntaxe allégée — identique
A = [1 2 3
4 5 6] Sortie
A = 1. 2. 3. 4. 5. 6.
Fonctions de création spécialisées
Figure 1 — Fonctions pour créer des matrices
| Fonction | Description | Exemple |
|---|---|---|
zeros(nr, nc) | Matrice de zéros | zeros(2, 3) |
ones(nr, nc) | Matrice de uns | ones(2, 3) |
eye(nr, nc) | Matrice identité (1 sur la diagonale) | eye(4, 4) |
rand(nr, nc) | Matrice aléatoire uniforme [0, 1] | rand(3, 4) |
linspace(a, b, n) | Vecteur de n valeurs régulièrement espacées entre a et b | linspace(0, 1, 6) |
testmatrix('magi', n) | Carré magique n×n | testmatrix('magi', 3) |
grand(nr, nc, ...) | Matrice aléatoire selon une loi (binomiale, normale…) | grand(2, 3, "bin", 1, 0.3) |
Exemple n°2 — Fonctions de création
// Matrice identité 4×4
eye(4, 4)
// 6 valeurs régulièrement espacées entre 0 et 1
linspace(0, 1, 6)
// Matrice de uns 2×3
ones(2, 3)
// Matrice de zéros 2×3
zeros(2, 3)
// Carré magique 3×3
testmatrix('magi', 3)
// Matrice aléatoire 3×4
rand(3, 4) Sortie
eye(4,4) =
1. 0. 0. 0.
0. 1. 0. 0.
0. 0. 1. 0.
0. 0. 0. 1.
linspace(0,1,6) =
0. 0.2 0.4 0.6 0.8 1.
ones(2,3) =
1. 1. 1.
1. 1. 1.
zeros(2,3) =
0. 0. 0.
0. 0. 0.
testmatrix('magi',3) =
8. 1. 6.
3. 5. 7.
4. 9. 2.2. La matrice vide []
La matrice vide [] (taille 0×0) permet de libérer la mémoire associée à une variable ou de tester si une matrice est vide.
Exemple n°3 — Création et vidage d'une matrice
// Créer une matrice vide
M = []
// Créer une matrice 3×3, puis la vider
M = ones(3, 3)
disp(size(M)) // [3, 3]
M = [] // libère la mémoire
disp(M) // []
disp(M == []) // %t — test si vide Sortie
M = []
Astuce — Supprimer une ligne ou colonne Affecter
[]à une ligne ou colonne permet de la supprimer dynamiquement :A = [1 2 3 ; 4 5 6 ; 7 8 9]
A(2, :) = [] // supprime la 2ème ligne
// A = [1 2 3 ; 7 8 9]
A(:, 1) = [] // supprime la 1ère colonne
// A = [2 3 ; 8 9]3. Opérations sur les matrices
Figure 2 — Fonctions qui interrogent ou modifient des matrices
| Fonction | Description | Exemple |
|---|---|---|
size(A) | Retourne [nr, nc] — nombre de lignes et colonnes | [n, m] = size(A) |
size(A, 1) ou size(A,'r') | Nombre de lignes uniquement | size(A, 1) |
size(A, 2) ou size(A,'c') | Nombre de colonnes uniquement | size(A, 2) |
size(A, '*') | Nombre total d'éléments (nr × nc) | size(A, '*') |
matrix(A, nr, nc) | Redimensionne A en nr×nc (par colonnes) | matrix(A, 1, 6) |
resize_matrix(A, nr, nc) | Redimensionne en ajoutant des zéros ou en tronquant | resize_matrix(A, 4, -1) |
Exemple n°4 — size(), matrix() et resize_matrix()
A = [1 4 5 ; 3 7 9] // matrice 2×3
// Taille
[n, m] = size(A)
disp("Lignes : " + string(n) + " Colonnes : " + string(m))
// Sélecteurs individuels
disp("nr = " + string(size(A, 1))) // 2
disp("nc = " + string(size(A, 2))) // 3
disp("total = " + string(size(A,'*'))) // 6
// Redimensionner en vecteur ligne (lecture par colonnes)
matrix(A, 1, 6)
// Redimensionner en 3×2
matrix(A, 3, 2)
// Ajouter des colonnes remplies de zéros
resize_matrix(A, -1, 5) // garde 2 lignes, passe à 5 colonnes
// Ajouter des lignes remplies de zéros
resize_matrix(A, 4, -1) // passe à 4 lignes, garde 3 colonnes Sortie
Lignes : 2 Colonnes : 3 nr = 2 nc = 3 total = 6 matrix(A,1,6) = 1. 3. 4. 7. 5. 9. matrix(A,3,2) = 1. 7. 3. 5. 4. 9. resize_matrix(A,-1,5) = 1. 4. 5. 0. 0. 3. 7. 9. 0. 0. resize_matrix(A,4,-1) = 1. 4. 5. 3. 7. 9. 0. 0. 0. 0. 0. 0.
Remarque —
-1 dans resize_matrix Passer -1 comme valeur de ligne ou colonne dans resize_matrix signifie "conserver la taille actuelle" dans cette dimension.4. Accéder aux éléments d'une matrice
Définition — Indexation en Scilab En Scilab, les indices commencent à 1 (contrairement à C ou Python qui commencent à 0). Pour une matrice A de taille nr×nc, l'élément A(i, j) est valide si 1 ≤ i ≤ nr et 1 ≤ j ≤ nc. Tout indice hors de ces bornes provoque une erreur.
Exemple n°5 — Accès élémentaire
A = [1 4 5 ; 3 7 9 ; 2 8 6]
disp(A(1, 1)) // 1ère ligne, 1ère colonne → 1
disp(A(2, 3)) // 2ème ligne, 3ème colonne → 9
disp(A(3, 2)) // 3ème ligne, 2ème colonne → 8
// Ligne entière
disp(A(2, :)) // [3, 7, 9]
// Colonne entière
disp(A(:, 1)) // [1; 3; 2] Sortie
1 9 8 3. 7. 9. 1. 3. 2.
a. L'opérateur : (deux-points)
L'opérateur : permet d'accéder à une plage de lignes et colonnes en une seule instruction.
A(i:j, k:l) // lignes i à j, colonnes k à l
A(i:s:j, k:t:l) // avec pas s et t
A(:, k) // toutes les lignes, colonne k
A(i, :) // ligne i, toutes les colonnes
A(:, :) // matrice entière
Figure 3 — Accès à une matrice avec l'opérateur ":"
Exemple n°6 — Slicing avec l'opérateur :
A = testmatrix('magi', 5) // carré magique 5×5
// Sous-matrice : lignes 1-2, colonnes 3-4
disp(A(1:2, 3:4))
// Toute la 3ème colonne
disp(A(:, 3))
// Toute la 2ème ligne
disp(A(2, :))
// Lignes impaires (pas = 2)
disp(A(1:2:5, :))
// Sous-matrice centrale
disp(A(2:4, 2:4)) Sortie
A(1:2,3:4) =
1. 8.
7. 14.
A(:,3) = [1. 7. 13. 19. 25.]ᵀ
A(2,:) = [23. 5. 7. 14. 16.]
A(1:2:5,:) = (lignes 1, 3, 5)
17. 24. 1. 8. 15.
4. 6. 13. 20. 22.
11. 18. 25. 2. 9.b. L'opérateur dollar $
L'opérateur $ représente le dernier indice d'une ligne ou d'une colonne selon le contexte. Il permet de référencer des éléments à partir de la fin de la matrice.
Figure 4 — Accès à une matrice avec l'opérateur dollar "$"
Exemple n°7 — Opérateur $
A = testmatrix('magi', 3)
// A =
// 8. 1. 6.
// 3. 5. 7.
// 4. 9. 2.
// Dernier élément
disp(A($, $)) // A(3,3) = 2
// Avant-dernier élément de la 1ère ligne
disp(A(1, $-1)) // A(1,2) = 1
// 2ème ligne depuis la fin, 1ère depuis le début
disp(A($-1, $-2)) // A(2,1) = 3
// Dernière ligne entière
disp(A($, :)) // [4. 9. 2.]
// Ajouter une ligne à la fin avec $+1
A($+1, :) = [7 12 30]
disp(A) Sortie
2 1 3 4. 9. 2. A après ajout : 8. 1. 6. 3. 5. 7. 4. 9. 2. 7. 12. 30.
Astuce —
$ pour les derniers éléments L'opérateur $évite de connaître la taille exacte de la matrice. Très utile dans les fonctions génériques :// Dernière colonne — quelle que soit la taille de A
derniere_col = A(:, $)
// 3 dernières lignes
trois_dern = A($-2:$, :)
// Inverser l'ordre des colonnes
A_inverse = A(:, $:-1:1)5. Opérations élémentaires (point-opérateur)
En Scilab, placer un point . devant un opérateur le transforme en opérateur élémentaire : l'opération est alors effectuée élément par élément (et non matriciellement).
Figure 5 — Opérateurs matriciels et opérateurs élémentaires
| Opération | Matricielle | Élémentaire | Description élémentaire |
|---|---|---|---|
| Multiplication | A * B | A .* B | C(i,j) = A(i,j) × B(i,j) |
| Division | A / B | A ./ B | C(i,j) = A(i,j) / B(i,j) |
| Puissance | A ^ n | A .^ n | C(i,j) = A(i,j)ⁿ |
| Addition | A + B | A + B | Identique (toujours élémentaire) |
| Transposée | A' | A.' | .' = transposée sans conjugaison complexe |
Exemple n°8 — Différence entre * et .*
A = [1 2 ; 3 4]
B = [5 6 ; 7 8]
// Produit matriciel C = A × B
C_mat = A * B
disp("A * B =")
disp(C_mat)
// Produit élémentaire — chaque élément multiplié par son homologue
C_elem = A .* B
disp("A .* B =")
disp(C_elem)
// Puissance élémentaire — carré de chaque élément
disp("A .^ 2 =")
disp(A .^ 2)
// Division élémentaire
disp("A ./ B =")
disp(A ./ B) Sortie
A * B = 19. 22. 43. 50. A .* B = 5. 12. 21. 32. A .^ 2 = 1. 4. 9. 16. A ./ B = 0.2 0.333... 0.428... 0.5
Attention —
* vs .* A * B est le produit matriciel : il nécessite que le nombre de colonnes de A égale le nombre de lignes de B. A .* B est le produit élément par élément : A et B doivent avoir exactement la même taille:A = [1 2 3] // 1×3
B = [4 5 6] // 1×3
A * B // ❌ Erreur — incompatible pour produit matriciel
A .* B // ✅ [4. 10. 18.] — produit élémentaire
Discussion (0)
Soyez le premier à laisser un commentaire !
Laisser un commentaire
Votre commentaire sera visible après modération.