Manipulation de Matrices

La donnée de base manipulée par MATLAB   est la matrice, d'où son nom MATrice LABoratory. Une matrice peut être rectangulaire, en forme de vecteur ou tout simplement constituée d'un seul élément. Les données constituant une matrice peuvent être des nombres réels ou des nombres complexes. L'utilisation d'une matrice ne demande aucune déclaration préalable.

Matrice  A
16    2    3   13
 5   11   10    8
 9    7    6   12
 4   14   15    1
Matrice  B
1    2    2     3
1    0    0     3
1    0    0     3
1    2    2     3
Dans la suite de ce document, nous utiliserons souvent deux matrices A et B qui s'afficheront en permanence sur l'écran.


Définir Une matrice

Une matrice est le plus souvent le résultat d'un calcul. Elle peut aussi être définie par une fonction particulière. Elle peut aussi être définie par une commande d'affectation simple:

>> A = [16  2   3  13; 5  11  10   8; 9  7 6  12; 4 14 15 1]


Si on ne termine pas la ligne de commande par le caractère de ponctuation ";" MATLAB  affiche le résultat de l'affectation dans la  fenêtre de commande :
A =
    16     2     3    13
     5    11    10     8
     9     7     6    12
     4    14    15     1

Cette matrice est maintenant mémorisée dans l'espace de travail MATLAB   et pourra être utilisée durant toute la séance de travail courante. L'instruction who donne la liste des variables mémorisées dans l'espace de travail MATLAB.L'instruction whos donne la liste des variables avec leur taille et leur classe(type)



OPÉRATIONS SUR LES MATRICES

Opérateurs arithmétiques

+    Addition
-    Soustraction
*    multiplication
/    Division
\    division à gauche
^    puissance
'    transposition ou complexe conjugué
.*    multiplication de matrice "point par point"
./    division de matrice "point par point"
.^    puissance de matrice "point par point"

Ajouter retrancher une constante:

>> X = A + 100
X =
   116   102   103   113
   105   111   110   108
   109   107   106   112
   104   114   115   101

Ajouter retrancher une matrice

>> X = A - A
X =
     0     0     0     0
     0     0     0     0
     0     0     0     0
     0     0     0     0

>>  B=[1 2 2 3;1 0 0 3;1 0 0 3;1 2 2 3]
  B=
     1     2     2     3
     1     0     0     3
     1     0     0     3
     1     2     2     3

>> y = A + B
y =
    17     4     5    16
     6    11    10    11
    10     7     6    15
     5    16    17     4

Multiplier diviser par une constante

>> X = A * 2
X =
    32     4     6    26
    10    22    20    16
    18    14    12    24
     8    28    30     2

>> X = A / 2
X =
    8.0000    1.0000    1.5000    6.5000
    2.5000    5.5000    5.0000    4.0000
    4.5000    3.5000    3.0000    6.0000
    2.0000    7.0000    7.5000    0.5000


Multiplication de matrice


>> A * B
ans =
    34    58    58   102
    34    26    26   102
    34    42    42   102
    34    10    10   102

C'est une vraie multiplication de matrice

Matrice puissance une constante

>> A ^ 2
ans =
   345   257   281   273
   257   313   305   281
   281   305   313   257
   273   281   257   345

matrice A à la puissance 2 ( A * A)

>> A ^ 3

ans =
       10426        9306        9386       10186
        9546       10026        9946        9786
        9866        9706        9626       10106
        9466       10266       10346        9226

matrice A à la puissance 3 ( A * A * A)


Matrice puissance une matrice


>> A ^ B
??? Error using ==>> ^
Matrix dimensions must agree.

On ne sait pas calculer une matrice carrée puissance une matrice carré


Multiplication élément par élément (mode tableau)


Chaque élément de A est multiplié par l'élément correspondant dans B.
On utilise l'opérateur .*
>> X = A .* B
X =
    16     4     6    39
     5     0     0    24
     9     0     0    36
     4    28    30     3


Division élément par élément (mode tableau)


Chaque élément de A est divisé par l'élément correspondant dans B.
On utilise l'opérateur ./

>> X = A ./ B
 Warning: Divide by zero
X =
   16.0000    1.0000    1.5000    4.3333
    5.0000       Inf       Inf    2.6667
    9.0000       Inf       Inf    4.0000
    4.0000    7.0000   7.5000     0.3333

Remarquer que la division par zéro a généré un simple warning. Le calcul global est terminé. Les division par zéro produisent inf


Puissance n élément par élément (mode tableau)


Chaque élément de A est élevé a la puissance n.
On utilise l'opérateur .^

>> A .^ 2

ans =

   256         4         9       169
    25       121       100        64
    81        49        36       144
    16       196       225         1


Puissance élément par élément (mode tableau)


Chaque élément de A est élevé a la puissance de l'élément correspondant dans B.
On utilise l'opérateur .^


>> X = A .^ B
X =
     16           4           9        2197
      5           1           1         512
      9           1           1        1728
      4         196         225           1


Opérateurs de comparaison

Ces opérateurs sont essentiellement utilisés avec les instruction if else, while ...

==    est égal à
~=    est différent de
>    supérieur à
<    inférieur à
>=    supérieur ou égal à
<=    inférieur ou égal à

Exemple:
if a == b
   faire quelque chose
else
   faire autre chose
end


Opérateur logiques

Ces opérateurs sont utilisés avec des grandeurs logiques. Une grandeur logique peut avoir deux valeurs: true ou false. Les grandeurs numériques peuvent aussi être manipulé comme logique: tout ce qui est différent de 0 est true, 0 = false

&    ET logique --> (a & b) est varie si a est vraie ET b est vraie
|    OU logique
~    NON logique
xor  OU exclusif

Exemple:
if a == b  & b > c
   faire quelque chose
else
   faire autre chose
end


Opérateurs logique de court-circuit


&&  similaire à & sauf que le 2ème opérande n'est évalué que si le premier est vrai
||  similaire à | sauf que le 2ème opérande n'est évalué que si le premier est vrai

Dans beaucoup de cas, ceci va éviter des message d'erreur. Par exemple, si la variable x n'existe pas et le programme rencontre:
if x > 0
  y = log(x);
end

Le programme va générer le message d'erreur  ??? Undefined function or variable 'x'
On peut éviter le message d'erreur comme suit:

if exist('x')   &&    x > 0
  y = log(x);
end

La variable x ne sera comparée à 0 que si elle existe



Opérateurs logiques bit par bits

Ce sont les opération logiques classique (NOT, AND, OR, XOR) sur les bits d'un nombre entier. Exemple:
a = 211 -->  11010011
b = 227 -->  11100011

bitand AND bit par bit bitand(a, b) --> 195 -->  11000011      11010011
  .  11100011
  --------------
     11000011
bitor OR bit par bit bitor(a,b) --> 243 -->  11110011      11010011
  .  11100011
  --------------
     11110011
bitxor XOR bit par bit bitxor(a,b)  --> 48  -->  110000      11010011
  .  11100011
  --------------
     00110000
bitcmp Complément = NOT
il faut préciser le type car les zéros de gauche deviennent des uns
 bitcmp(uint8(a)) --> 44 = 101100

      11010011
         ⇓
     00101100
bitcmp(uint16(a)) -> 65324 = 1111111100101100
  0000000011010011
         ⇓
 1111111100101100




Fonctions logiques prédéfinies


Voici une liste de fonction logiques prise comme telle dans la doc officielle

 Check existence of variable, function, folder, or class

isa

 Detect object of given MATLAB class or Java® class

isappdata

 Determine if object has specific application-defined data

iscell

Determine if input is cell array

iscellstr

Determine if input is cell array of strings

ischar

Determine if input is character array

iscom

Determine if input is Component Object Model (COM) object

isdir

Determine if input is folder

isempty

Determine if input is empty array

isequal

Determine if arrays are numerically equal

isequaln

Determine if arrays are numerically equal, treating NaNs as equal

isevent

Determine if input is Component Object Model (COM) object event

isfield

Determine if input is MATLAB structure array field

isfinite

Detect finite elements of array

isfloat

Determine if input is floating-point array

isglobal

Determine if input is global variable

ishandle

Detect valid graphics object handles

ishold

Determine if graphics hold state is on

isinf

Detect infinite elements of array

isinteger

Determine if input is integer array

isinterface

Determine if input is Component Object Model (COM) interface

isjava

Determine if input is Java object

iskeyword

Determine if input is MATLAB keyword

isletter

Detect elements that are alphabetic letters

islogical

Determine if input is logical array

ismac

Determine if running MATLAB for Macintosh OS X platform

ismember

Detect members of specific set

ismethod

Determine if input is object method

isnan

Detect elements of array that are not a number (NaN)

isnumeric

Determine if input is numeric array

isobject

Determine if input is MATLAB object

ispc

Determine if running MATLAB for PC (Windows®) platform

isprime

Detect prime elements of array

isprop

Determine if input is object property

isreal

Determine if all array elements are real numbers

isscalar

Determine if input is scalar

issorted

Determine if set elements are in sorted order

isspace

Detect space characters in array

issparse

Determine if input is sparse array

isstrprop

Determine if string is of specified category

isstruct

Determine if input is MATLAB structure array

sstudent

Determine if Student Version of MATLAB

isunix

Determine if running MATLAB for UNIX platform.

isvarname

Determine if input is valid variable name

isvector

Determine if input is vector



Les indices et l'opérateur : (deux points)

A(i,j) est l'élément situé à la ligne i et à la colonne j
>> A(2,3)
ans =    10

L'opérateur : est fondamental sous MATLAB , il permet de définir une suite d'éléments. En l'utilisant dans les indices, on peut accéder à une partie d'une matrice
 
>> 3 : 10
ans =      3     4     5     6     7     8     9    10

>> 0:0.5:3
ans =   0    0.5000    1.0000    1.5000    2.0000    2.5000    3.0000

>> 10:-2:4
ans =      10     8     6     4

>> A(3:4,2:3)
ans =
     7     6
    14    15

>> A(2,2:4)  (colonnes 2 à 4 de la 2ème ligne)
ans =     11    10     8

>> A(2,:)      (deuxième ligne)
ans =     5    11    10     8

>> A(:,4)       (quatrième colonne)
ans =
    13
     8
    12
     1

Si on essaye d'utiliser un élément en dehors de la matrice, il se produit une erreur :
>> A(10,1)
???  Index exceeds matrix dimensions.

D'un autre coté, si on définit un nouvel élément de la matrice en de hors de la taille initiale, la matrice est redimensionnée pour inclure le nouvel élément, les éléments non définis sont complétés par des zéros :

>> A(3,6) = 33
A =
    16     2     3    13     0     0
     5    11    10     8     0     0
     9     7     6    12     0    33
     4    14    15     1     0     0

Rien de plus facile que de retrouver notre matrice originale, voici deux façons de faire :

>> A = A(:,1:4)
A =
    16     2     3    13
     5    11    10     8
     9     7     6    12
     4    14    15     1

>> A(:,5:6)=[]
A =
    16     2     3    13
     5    11    10     8
     9     7     6    12
     4    14    15     1

On peut aussi accéder à plusieurs éléments non contigus

>> A([1 3],[2 4])   (ligne 1 et 3, colonnes 2 et 4)
ans =
     2    13
     7    12

En utilisant cette technique, on peut par exemple permuter deux colonnes d'une matrice: Sur toutes les lignes, prendre les colonnes 1, 3, 2 et 4 (je reconnais que ce n'est pas très évident)
 
>> A(:,[1 3 2 4])
ans =
    16     3     2    13
     5    10    11     8
     9     6     7    12
     4    15    14     1


On peut faire quasiment tout ce qu'on veut :

>> A(:,[1 1 2 2 3 3 4 4])
ans =
    16    16     2     2     3     3    13    13
     5     5    11    11    10    10     8     8
     9     9     7     7     6     6    12    12
     4     4    14    14    15    15     1     1

>> A([1 2 3 4 4 3 2 1],[1 1 2 2 3 3 4 4])
ans =
    16    16     2     2     3     3    13    13
     5     5    11    11    10    10     8     8
     9     9     7     7     6     6    12    12
     4     4    14    14    15    15     1     1
     4     4    14    14    15    15     1     1
     9     9     7     7     6     6    12    12
     5     5    11    11    10    10     8     8
    16    16     2     2     3     3    13    13

Il arrive qu'on désire fabriquer une matrice en répétant plusieurs fois la même ligne ou la même colonne :

>> X=1:4
X =      1     2     3     4

>> Y=X([1 1 1 1],:)
Y =
     1     2     3     4
     1     2     3     4
     1     2     3     4
     1     2     3     4


>> V=(2:2:8)'
V =
     2
     4
     6
     8

>>  U=V(:,[1 1 1 1])
U =
     2     2     2     2
     4     4     4     4
     6     6     6     6
     8     8     8     8

>> A(:,[3 3 3 3 3])
ans =
     3     3     3     3     3
    10    10    10    10    10
     6     6     6     6     6
    15    15    15    15    15

Même pour une matrice carrée, un élément peut être désigné par un seul indice. Les éléments sont numérotés comme si la matrice était constituée d'une seule colonne:

>> A(6)
ans =    11

>> X=[A(6) A(10) A(15)]
X =     11    10    12



Concaténation

X=[A A]
X =
    16     2     3    13    16     2     3    13
     5    11    10     8     5    11    10     8
     9     7     6    12     9     7     6    12
     4    14    15     1     4    14    15     1


>> X = [A; A]
X =
    16     2     3    13
     5    11    10     8
     9     7     6    12
     4    14    15     1
    16     2     3    13
     5    11    10     8
     9     7     6    12
     4    14    15     1


Transposition

Elle est obtenue à l'aide du caractère de ponctuation  '
>> B = A'
B =   
    16     5     9     4
     2    11     7    14
     3    10     6    15
    13     8    12     1


La fonction de sommation sum

La fonction sum calcule la somme colonne par colonne, mais dans le cas où la matrice se réduit à un vecteur ligne, elle calcule la somme de tous les éléments du vecteur :

>> X = sum(A)
X = 34    34    34    34


>> Y = sum(X)
Y =   136

Pour transformer un vecteur ligne en vecteur colonne et vice versa, il suffit de transposer
>> Z = X'
Z =
    34
    34
    34
    34

Pour calculer la somme lignes par lignes, il suffit de transposer avant d'utiliser la fonction sum  :

>> sum(A')
ans =    34    34    34    34

A remarquer que si on n'affecte le résultat à aucune variable, MATLAB  l'affecte à la variable ans qui est une variable tampon qui contient toujours le résultat de la dernière opération.


La fonction Diag:

Cette fonction retourne une colonne contenant la diagonale d'une matrice

>> V=diag(A)
V =
    16
    11
     6
     1

>> H=diag(A)'
H =     16    11     6     1


Les fonctions fliplr et flipud

Ces deux fonctions permettent de retourner une matrice de gauche à droite ou de droite à gauche

>> fliplr(H)
ans  =      1     6    11    16

>> flipud(V)
ans =
     1
     6
    11
    16

>> fliplr(A)
ans =
    13     3     2    16
     8    10    11     5
    12     6     7     9
     1    15    14     4

>> flipud(A)
ans =
     4    14    15     1
     9     7     6    12
     5    11    10     8
    16     2     3    13


Les fonctions ones et zeros:

Les fonctions zeros et ones permettent de générer des matrices remplie avec des zéros ou des uns.

>> X = zeros(3)
X =
     0     0     0
     0     0     0
     0     0     0

>> X = ones(4)
X =
     1     1     1     1
     1     1     1     1
     1     1     1     1
     1     1     1     1

>> X=zeros(3,5)
X =
     0     0     0     0     0
     0     0     0     0     0
     0     0     0     0     0


Les fonctions length et size

La fonction length retourne la longueur d'un vecteur (ligne ou colone) et la fonction size retourne la dimension d'une matrice

>> x=5:9
x =      5     6     7     8     9

>> l=length(x)
l =      5

>> Y=[x;x;x]
Y =
     5     6     7     8     9
     5     6     7     8     9
     5     6     7     8     9

>> k=size(Y)
k =      3     5

>> k(1)
ans =     3

>> k(2)
ans =      5


Les fonctions min et max

Les fonctions min et max retournent le plus petit et le plus grand élément d'un vecteur.

soit le vecteur:
x =  21.52     67.96     90.89     25.01     86.09      47.13       50.60

>> min(x)
ans =          21.52

>> max(x)
ans =          90.89


la fonction fix

La fonction fix retourne la partie entière d'un nombre

>> K = 123.456
>> fix(K)
ans =  123


La fonction reshape

La fonction reshape() permet de redimensionner une matrice.

>> a = [1 2 3 4; 5 6 7 8; 9 10 11 12]
a =
     1     2     3     4
     5     6     7     8
     9    10    11    12

>> b = reshape(a,2,6)
b =
     1     9     6     3    11     8
     5     2    10     7     4    12

>> reshape(a,1,[])
ans =
     1     5     9     2     6    10     3     7    11     4     8    12

>> reshape(a,4,[])
ans =
     1     6    11
     5    10     4
     9     3     8
     2     7    12

>> reshape(a,[],2)
ans =
     1     3
     5     7
     9    11
     2     4
     6     8
    10    12