Langage Scilab

Matrices et vecteurs en Scilab

Dans Scilab, le type de données de base est la matrice, qui est définie par :

  • le nombre de lignes,
  • le nombre de colonnes, 
  • le type de données.

Le type de données peut être réel, entier, booléen, chaîne et polynomial. Lorsque deux matrices ont le même nombre delignes et de colonnes, on dit que les deux matrices ont la même forme (shape).

Dans Scilab, les vecteurs sont un cas particulier de matrices, où le nombre de lignes (ou le nombre de colonnes) est égal à 1. Les variables scalaires simples n’existent pas dans Scilab : une variable scalaire est une matrice avec 1 ligne et 1 colonne.

Il est juste de dire que Scilab a été conçu principalement pour des matrices de variables réelles. Cela permet d’effectuer des opérations d’algèbre linéaire avec un langage de haut niveau.

Par conception, Scilab a été créé pour pouvoir effectuer des opérations matricielles le plus rapidement possible. Le bloc de construction de cette fonctionnalité est que les matrices Scilab sont stockées dans une structure de données interne qui peut être gérée au niveau de l’interpréteur. La plupart des opérations d’algèbre linéaire de base, telles que l’addition, la soustraction, la transposition ou le produit scalaire, sont effectuées par un code source compilé et optimisé. Ces opérationssont effectuées avec les opérateurs communs "+", "-", "*" et le guillemet simple "", de sorte que, au niveau de Scilab, le code source est à la fois simple et rapide.

Avec ces opérateurs de haut niveau, la plupart des algorithmes matriciels n’ont pas besoin d’utiliser des boucles. En fait, un script Scilab qui effectue les mêmes opérations avec des boucles est généralement de 10 à 100 fois plus lent. Afin d’obtenir une implémentation rapide d’un algorithme donné, le développeur Scilab doit toujours utiliser des opérations de haut niveau, de sorte que chaque instruction traite une matrice (ou un vecteur) au lieu d’un scalaire. 

Des tâches plus complexes d’algèbre linéaire, comme la résolution de systèmes d’équations linéaires Ax = b, diverses décompositions (par exemple Gauss partiel PA= LU), des calculs de valeurs propres / vecteurs propres, sont également effectuées par des codes source compilés et optimisés. Ces opérations sont effectuées par des opérateurs communs comme le slash "/" ou backslash "ou avec des fonctions comme spec, qui calcule les valeurs propres et les vecteurs propres. 

1. Créer une matrice de valeurs réelles 

Il existe une syntaxe simple et efficace pour créer une matrice avec des valeurs données. Voici la liste des symboles utiliséspour définir une matrice :

  • les crochets "[" et "]" marquent le début et la fin de la matrice,
  • les virgules "," séparent les valeurs dans différentes colonnes,
  • points-virgules " ;" séparent les valeurs des différentes lignes.

La syntaxe suivante peut être utilisée pour définir une matrice, où les espaces sont facultatifs (mais rendent la ligne plusfacile à lire) et "..." indique des valeurs intermédiaires : 

A = [a11, a12, ..., a1n; a21, a22, ..., a2n; ...; an1, an2, ..., ann]

Dans l’exemple suivant, nous créons une matrice 2 × 3 de valeurs réelles. 

-->A = [1 , 2 , 3 ; 4 , 5 , 6]
A=
    1. 2. 3.
    4. 5. 6.

Une syntaxe plus simple est disponible, qui ne nécessite pas d’utiliser les virgules et les points-virgules. Lors de la création d’une matrice, l’espace vide sépare les colonnes tandis que la nouvelle ligne sépare les lignes, comme dans la syntaxe suivante : 

A = [a11 a12 ... a1n
a21 a22 ... a2n
...
an1 an2 ... ann]

Cela permet d’alléger considérablement la gestion des matrices, comme dans l'exemple suivant. 

-->A = [1 2 3
-->4 5 6]
A=
    1.2.  3.
    4. 5.  6.

Plusieurs commandes Scilab permettent de créer des matrices à partir d’une taille donnée, c’est-à-dire à partir d’unnombre donné de lignes et de colonnes. Ces fonctions sont présentées dans la figure 1. Les plus utilisées sont les eye, zeros etones. Ces commandes prennent deux arguments d’entrée, le nombre de lignes et de colonnes de la matrice à générer. 

Figure 1 – Fonctions pour créer des matrices

--> eye(4,4)
 ans  =

   1.   0.   0.   0.
   0.   1.   0.   0.
   0.   0.   1.   0.
   0.   0.   0.   1.
--> linspace(0,1,6)
 ans  =

   0.   0.2   0.4   0.6   0.8   1.
--> ones(2,3)
 ans  =

   1.   1.   1.
   1.   1.   1.
--> zeros(2,3)
 ans  =

   0.   0.   0.
   0.   0.   0.

--> testmatrix('magi',3)
 ans  =

   8.   1.   6.
   3.   5.   7.
   4.   9.   2.
--> grand(2, 3, "bin", 1, 0.3)
 ans  =

   1.   0.   0.
   0.   0.   0.
--> rand(3,4)
 ans  =

   0.6653811   0.685731    0.5608486   0.1985144
   0.6283918   0.8782165   0.6623569   0.5442573
   0.8497452   0.068374    0.7263507   0.2320748

2. La matrice vide [] 

Une matrice vide peut être créée en utilisant des crochets vides, comme ci-dessous, où nous créons une matrice 0 × 0. 

--> M=[]
 M  =
    []

Cette syntaxe permet de supprimer le contenu d’une matrice, de sorte que la mémoire associée soit libérée. 

--> M=ones(3,3)
--> M=[]
 M  =
    []

3. operation sur les matrices 

Les fonctions de la figure 2 permettent d’interroger ou de mettre à jour une matrice. La fonction size renvoie les deux arguments de sortie nr et nc, qui sont les nombre de lignes et le nombre de colonnes. 

Figure 2 – Fonctions qui interrogent ou modifient des matrices. 

--> A=[1 4 5;3 7 9]
 A  =

   1.   4.   5.
   3.   7.   9.
--> [n,m]=size(A)
 m  =

   3.

 n  =

   2.
--> matrix(A,1,6)
 ans  =

   1.   3.   4.   7.   5.   9.
--> matrix(A,3,2)
 ans  =

   1.   7.
   3.   5.
   4.   9.
--> resize_matrix(A, -1, 5)  //  utiliser -1 pour garder la taille de la ligne ou colonnes
 ans  =

   1.   4.   5.   0.   0.
   3.   7.   9.   0.   0.
--> resize_matrix(A, 4, -1)
 ans  =

   1.   4.   5.
   3.   7.   9.
   0.   0.   0.
   0.   0.   0.
--> resize_matrix(A, 6, 6) 
 ans  =

   1.   4.   5.   0.   0.   0.
   3.   7.   9.   0.   0.   0.
   0.   0.   0.   0.   0.   0.
   0.   0.   0.   0.   0.   0.
   0.   0.   0.   0.   0.   0.
   0.   0.   0.   0.   0.   0.

La fonction size a une valeur pratique importante lorsque nous concevons une fonction, car le traitement que nous devons effectuer sur une matrice donnée peut dépendre de sa forme. Par exemple, pour calculer la norme d’une matrice donnée, différents algorithmes peuvent être utilisés selon que la matrice est un vecteur colonne de taille nr × 1 et nr> 0, un vecteur ligne de taille 1 × nc et nc> 0, ou une matrice générale de taille nr × nc et nr, nc> 1.

La fonction size a aussi la syntaxe suivante nr = size(A,sel) qui permet d’obtenir uniquement le nombre de lignes ou le nombre de colonnes et où sel peut avoir les valeurs suivantes :

  • sel = 1 ou sel = "r", retourne le nombre de lignes,
  • sel = 2 ou sel = "c", renvoie le nombre de colonnes.
  • sel = "*", renvoie le nombre total d’éléments, c’est-à-dire le nombre de colonnes multiplié par le nombre de lignes.
--> A=ones(5,3)
 A  =
   1.   1.   1.
   1.   1.   1.
   1.   1.   1.
   1.   1.   1.
   1.   1.   1.
--> size(A,1)
 ans  =
   5.
   
--> size(A,2)
 ans  =
   3.

--> size(A,'*')
 ans  =
   15.

4. Accéder aux éléments d’une matrice 

Il existe plusieurs méthodes pour accéder aux éléments d’une matrice A :

  • la matrice entière, avec la syntaxe A,
  • élément par élément avec la syntaxe A (i, j),
  • une plage de valeurs d’index avec l’opérateur " :" deux-points.

Un élément d’une matrice peut être accédé directement avec la syntaxe A(i, j), à condition que i et soient des valeurs d’index valides.
Nous soulignons que, par défaut, le premier indice d’une matrice est 1. Cela contraste avec d’autres langages, tels que le langage C par exemple, où le premier indice est 0. 

Par exemple, supposons que A est une matrice nr x nc, où nr est le nombre de lignes et nc est le nombre de colonnes. Par conséquent, la valeur A(i, j)  n’a de sens que si les valeurs d’indice i et j satisfont 1≤ i ≤ nr et 1 ≤ j ≤ nc.  Si les valeurs d’index ne sont pas valides, une erreur est générée 

a. L’opérateur " :"

Avec un vecteur de valeurs indexées, nous pouvons accéder aux éléments d’une matrice dans un interval donné, comme avec la syntaxe simplifiée suivante A(i : j, k : l)  i, j, k, l sont des valeurs d’index de début et de fin.  La syntaxe complète est A(i : s : j, k : t : l), où s et t sont les étapes.

Par exemple, supposons que A est une matrice 4 × 5, et que nous voulons accéder aux éléments ai,j pour i = 1, 2 et j = 3,4. Avec le langage Scilab, cela peut être fait en une seule instruction , en utilisant la syntaxe A(1 : 2, 3 : 4), comme indiqué dans l’exemple suivant : 

--> A=testmatrix('magi',5)
 A  =

   17.   24.   1.    8.    15.
   23.   5.    7.    14.   16.
   4.    6.    13.   20.   22.
   10.   12.   19.   21.   3.
   11.   18.   25.   2.    9.
--> A(1:2,3:4)
 ans  =

   1.   8.
   7.   14.

Il existe de nombreuses variantes de cette syntaxe, et la figure 3 présente certaines des combinaisons possibles. 

 

Figure 3 – Accès à une matrice avec l’opérateur " :" 

b.  L’opérateur dollar "$" 

Habituellement, nous utilisons des indices pour faire référence à partir du début d’une matrice. Par opposition, l’opérateur dollar "$" permet de référencer des éléments à partir de la fin de la matrice. L’opérateur "$" signifie "l’index correspondant à la dernière" ligne ou colonne, selon le contexte. Cette syntaxe est associée à une algèbre, de sorte que l’index $-i correspond à l’index l-i, où l est le nombre de lignes ou de colonnes correspondantes. Les différentes utilisations de l’opérateur dollar sontprésentées dans la figure 4.

Figure 4 – Accès à une matrice avec l’opérateur dollar "$" 

Dans l’exemple suivant, nous considérons une matrice 3 × 3 et nous accédons à l’élément A (2,1) = A (nr-1, nc-2) = A ($ -1, $ - 2) parce que nr = 3 et nc = 3. 

--> A=testmatrix('magi',3)
 A  =

   8.   1.   6.
   3.   5.   7.
   4.   9.   2.

--> A($-1,$-2)
 ans  =

   3.

L’opérateur dollar "$" permet d’ajouter des éléments dynamiquement à la fin des matrices. 

--> A=testmatrix('magi',3)
 A  =

   8.   1.   6.
   3.   5.   7.
   4.   9.   2.
--> A($+1,:)=[7 12 30]
 A  =

   8.   1.    6.
   3.   5.    7.
   4.   9.    2.
   7.   12.   30.

5. Opérations élémentaires 

Si un point "." Est écrit devant un opérateur, il est associé à un opérateur élémentaire, c’est-à-dire que l’opération est effectuée élément par élément.
Par exemple, 

  • Avec l’opérateur de multiplication habituel "*", le contenu de la matrice C = A * B est
  • Avec l’opérateur de multiplication élémentaire ". *", Le contenu de la matrice C = A. * B est

Figure 5 – Opérateurs matriciels et opérateurs élémentaires. 

Partager ce cours avec tes amis :
Rédigé par Mostafa Sedoki
Computer science teacher and the founder of the e-learning platform "developpement-informatique.com", my mission is to provide high-quality courses for free to all computer science students and teachers

Cours Similaires :