2.2 Quelques matrices et vecteurs types

Il existe des fonctions pour construire des matrices et vecteurs types, dont voici une première liste (il y en a bien d'autres dont nous parlerons ultérieurement ou que vous découvrirez avec le Help) :

• Pour obtenir une matrice identité de dimension (4,4) :

  -->I=eye(4,4)
   I  =
   
  !   1.    0.    0.    0. !
  !   0.    1.    0.    0. !
  !   0.    0.    1.    0. !
  !   0.    0.    0.    1. !
  

  Les arguments de la fonction eye(n,m)   sont le nombre de lignes n et le nombre de colonnes m de la matrice (Rmq : si n < m (resp. n > m) on obtient la matrice de la surjection (resp. injection) canonique de $\mathbb{K}^m$ vers $\mathbb{K}^n$.)

• Pour obtenir une matrice diagonale, dont les éléments diagonaux sont les composantes d'un vecteur  :

  -->B=diag(b)
   B  =
   
  !   2.    0.     0.     0.   !
  !   0.    10.    0.     0.   !
  !   0.    0.     44.    0.   !
  !   0.    0.     0.     190. !
  

  (Rmq : cet exemple illustre le fait que Scilab distingue minuscule et majuscule, taper b pour vous rendre compte que ce vecteur existe toujours dans l'environnement). Appliquée sur une matrice la fonction diag permet d'en extraire sa diagonale principale sous la forme d'un vecteur colonne :

  -->b=diag(B)
   b  =
   
  !   2.   !
  !   10.  !
  !   44.  !
  !   190. !
  

  Cette fonction admet aussi un deuxième argument optionnel (cf exercices).

• Les fonctions zeros et ones permettent respectivement de créer des matrices nulles et des matrices << de 1 >>. Comme pour la fonction eye leurs arguments sont le nombre de lignes puis de colonnes désirées.     Exemple :

  -->C = ones(3,4)
   C  =
   
  !   1.    1.    1.    1. !
  !   1.    1.    1.    1. !
  !   1.    1.    1.    1. !
  

  Mais on peut aussi utiliser comme argument le nom d'une matrice déjà définie dans l'environnement et tout se passe comme si l'on avait donné les deux dimensions de cette matrice :

  -->O = zeros(C)
   O  =
   
  !   0.    0.    0.    0. !
  !   0.    0.    0.    0. !
  !   0.    0.    0.    0. !
  

• Les fonctions triu et tril permettent elles d'extraire respectivement la partie triangulaire supérieure (u comme upper) et inférieure (l comme lower) d'une matrice, exemple   :

  -->U = triu(C)
   U  =
   
  !   1.    1.    1.    1. !
  !   0.    1.    1.    1. !
  !   0.    0.    1.    1. !
  

• La fonction rand (dont nous reparlerons)  

  permet de créer des matrices remplies de nombres pseudo-aléatoires (suivants une loi uniforme sur [0,1[ mais il est possible d'obtenir une loi normale et aussi de choisir le germe de la suite) :

  -->M = rand(2, 6)
   M  =
   
  !   0.2113249    0.0002211    0.6653811    0.8497452    0.8782165    0.5608486 !
  !   0.7560439    0.3303271    0.6283918    0.6857310    0.0683740    0.6623569 !
  

• Pour rentrer un vecteur (ligne) x à n composantes régulièrement réparties entre x₁ et x_n (c-à-d telles $x_{i+1} - x_i = \frac{x_n - x_1}{n-1}$ , n << piquets >> donc n-1 intervalles...), on utilise la fonction linspace  :

  -->x = linspace(0,1,11)
   x  =
   
  !   0.    0.1    0.2    0.3    0.4    0.5    0.6    0.7    0.8    0.9    1. !
  

• Une instruction analogue permet, partant d'une valeur initiale pour la première composante, d'imposer << l'incrément >> entre deux composantes, et de former ainsi les autres composantes du vecteur jusqu'à ne pas dépasser une certaine limite :

  -->y = 0:0.3:1
   y  =
   
  !   0.    0.3    0.6    0.9 !
  

  La syntaxe est donc : y = valeur_initiale:incrément:limite_a_ne_pas_dépasser. Lorsque l'on travaille avec des entiers, il n'y pas de problème (sauf entiers très grands...) à fixer la limite de sorte qu'elle corresponde à la dernière composante :

  -->i = 0:2:12
   i  =
   
  !   0.    2.    4.    6.    8.    10.    12. !
  

  Pour les réels (approché par des nombres flottants) c'est beaucoup moins évident du fait :

  (i)

  que l'incrément peut ne pas << tomber juste >> en binaire (par exemple $(0.2)_{10} = (0.00110011\dots)_2$) et il y a donc un arrondi dans la représentation machine,

  (ii)

  et des erreurs d'arrondi numérique qui s'accumulent au fur et à mesure du calcul des composantes.

  Par exemple :

  -->xx = 0:0.05:0.60
   ans  =
   
  ! 0.   0.05   0.1   0.15   0.2   0.25   0.3   0.35   0.4   0.45   0.5   0.55 !
  

  Rmq : selon l'unité d'arithmétique flottante de l'ordinateur vous pouvez obtenir un résultat différent (c-à-d avec 0.6 comme composante supplémentaire). Souvent l'incrément est égal à 1 et on peut alors l'omettre :

  -->ind = 1:5
   ind  =
   
  !   1.    2.    3.    4.    5. !
  

  Finalement, si l'incrément est positif (resp. négatif) et que limite < valeur_initiale (resp. limite > valeur_initiale) alors on obtient un vecteur sans composantes (!) qui est un objet Scilab appelée matrice vide (cf section quelques primitives matricielles supplémentaires)   :

  -->i=3:-1:4
   i  =
   
       []
   
  -->i=1:0
   i  =
   
       []