Manipulations élémentaires des tableaux sous MatLab

Sommaire

I. Stockage des tableaux

MatLab stocke les vecteurs, les matrices, et plus généralement les tableaux, quelles que soient leurs dimensions, sous forme de vecteurs colonnes.
Par exemple, la matrice suivante:

(2 7 4)
(5 8 3)

est stockée dans un vecteur colonne obtenu en mettant bout à bout ses colonnes:

(2)
(5)
(7)
(8)
(4)
(3)

II. L'indexation linéaire

Cette manière de stocker sous MatLab, implique en particulier qu'on peut accéder aux éléments d'un tableau par un seul indice (variant de 1 au nombre total des éléments du tableau), c'est ce qu'on appelle l'indexation linéaire.

II.1. Accéder à un élément d'un tableau en utilisant l'indexation linéaire

Pour les matrices, nous venons de voir que le vecteur colonne qui leur correspondait était simplement les colonnes de la matrice mises bout à bout. Cependant, il est plus difficile de voir ce qui se passe lorsqu'on manipule des tableaux à plus de 2 dimensions.
Considérons donc le cas particulier d'un tableau T à trois dimensions, de taille 4x2x3. Ce tableau contient 24 éléments. En les numérotant donc de 1 à 24 et en considérant (pour plus de clarté) qu'un tableau à 3 dimensions est un ensemble de pages (dernière dimension) contenant chacune des matrices (deux premières dimensions), voici comment ils sont organisés:



Ces éléments sont donc organisés dans le vecteur colonne qui correspond au tableau en incrémentant le premier indice du tableau, puis le second, puis le troisième (et les suivants si on travaillait avec plus de 3 dimensions).
Plus précisément, voici comment on peut afficher les éléments de T dans leur ordre de stockage. Tout d'abord, affectons une valeur à T:

T=rand(4,2,3);

Dans le vecteur colonne qui lui correspond, les éléments sont donnés dans leur ordre de stockage par:

for p=1:3
    for n=1:2
        for m=1:4
            disp(T(m,n,p));
        end
    end
end

Dit d'une autre manière, partant du vecteur colonne correspondant au stockage d'un tableau, celui-ci est "rangé" dans le tableau en le découpant suivant la dernière dimension, puis la précédente et ainsi de suite. Le découpage est donc fait de cette manière:



Finalement, pour notre exemple, on peut accéder au 11ème élément du tableau T de deux manières:

T(3,1,2)

ou

T(11)

Il suffit de taper les quelques lignes suivantes pour voir que les éléments apparaissent dans le même ordre qu'avec les 3 boucles imbriquées précédentes:

for q=1:24
    disp(T(q));
end

II.2. Passer d'une indexation à l'autre

Suivant les cas, l'une ou l'autre des indexations peu être plus pratique. Il existe des fonctions MatLab qui simplifient la manipulation de ces indexations:

• sub2ind permet de passer de l'indexation linéaire à l'indexation multiple.
• ind2sub permet de passer de l'indexation multiple à l'indexation linéaire.

Une aide sur l'utilisation de ces fonctions est disponible depuis la fenêtre MatLab en tapant help sub2ind ou help ind2sub. Pour accéder à une aide plus détaillée, tapez doc sub2ind ou doc ind2sub.

Plutôt que d'expliquer l'utilisation de ces fonctions dans le cas général d'un tableau N dimensions, nous prendrons pour les explications un cas particulier.

II.2.1. La fonction ind2sub

Pour connaître l'indexation multiple correspondant aux indices 3, 8, 17, 23 d'un tableau de taille 4x2x3 il suffit de faire:

v=[3;8;17;23];
[m n p]=ind2sub([4 2 3],v);

• Le premier argument de la fonction ind2sub est la taille du tableau pour laquelle on veut effectuer la conversion "indexation linéaire -> indexation multiple"
• Le second argument v de la fonction ind2sub est le vecteur des indices qu'on veut convertir.
• Le membre de gauche [m n p] recevra les vecteurs correspondants à l'indexation multiple.

Plus précisément, pour tout tableau T de taille 4x2x3 nous aurons:

T(m(1),n(1),p(1))=T(v(1))=T(3)
T(m(2),n(2),p(2))=T(v(2))=T(8)
T(m(3),n(3),p(3))=T(v(3))=T(17)
T(m(4),n(4),p(4))=T(v(4))=T(23)

Vous pouvez alors tester ces quelques lignes:

T=rand(4,2,3);
v=[3;8;17;23];
[m n p]=ind2sub([4 2 3],v);
for q=1:4
    disp([T(m(q),n(q),p(q)), T(v(q))]);
end

pour voir que nous avons bien obtenu le résultat escompté.

II.2.2. La fonction sub2ind

Supposons qu'on veuille convertir en indexation linéaire les multi-indices (2,2,1), (1,2,3), (4,1,2), (3,1,3) d'un tableau de taille 4x2x3, il suffit alors de faire:

m=[2;1;4;3];
n=[2;2;1;1];
p=[1;3;2;3];
v=sub2ind([4 2 3],m,n,p);

• Le premier argument de la fonction sub2ind est la taille du tableau pour laquelle on veut effectuer la conversion "indexation multiple -> indexation linéaire"
• Les arguments suivants sont les colonnes m, n, p, contenant respectivement les indices de la première dimension, les indices de la seconde dimension, les indices de la troisième dimension.
• Le membre de gauche v recevra le vecteur correspondant à l'indexation linéaire.

Plus précisément, pour tout tableau T de taille 4x2x3 nous aurons:

T(v(1))=T(m(1),n(1),p(1))=T(2,1,1)
T(v(2))=T(m(2),n(2),p(2))=T(1,2,3)
T(v(3))=T(m(3),n(3),p(3))=T(4,1,2)
T(v(4))=T(m(4),n(4),p(4))=T(3,1,3)

Vous pouvez alors tester ces quelques lignes:

T=rand(4,2,3);
m=[2;1;4;3];
n=[2;2;1;1];
p=[1;3;2;3];
v=sub2ind([4 2 3],m,n,p);
for q=1:4
    disp([T(v(q)), T(m(q),n(q),p(q))]);
end

pour voir que nous avons bien obtenu le résultat escompté.

III. La fonction reshape

Prenant en considération le stockage d'un tableau sous MatLab, on comprend aisément que la taille d'un tableau n'est pas importante et qu'il suffit d'une petite fonction pour donner à un tableau la forme qu'on veut (pourvu que le nombre d'éléments ne change pas). La fonction MatLab qui permet de redimensionner un tableau est reshape.
Comme pour les autres fonctions, une aide concernant cette fonction est accessible depuis la fenêtre MatLab en tapant help reshape ou bien doc reshape pour une aide encore plus détaillée.

Pour comprendre l'action de l'instruction reshape, il suffit de savoir qu'en redimensionnant un tableau T en un tableau M, les éléments de T sont pris dans l'ordre croissant de leur indexation linéaire et sont "placés" dans M avec le même ordre.

Prenons de nouveau l'exemple du tableau T précédent (T est de taille 4x2x3). Comme il a déjà été dit, le nombre d'éléments de ce tableau est 24. On voit que c'est aussi le nombre d'éléments d'une matrice M de taille 6x4. Voici ce qui se passe donc lorsqu'on tape le code suivant:

M=reshape(T,[6 4]);

On remarquera qu'on peut facilement obtenir le tableau initial T à l'aide de M en le redimensionnant comme il le faut:

TT=reshape(M,[4 2 3]);

Le tableau TT est alors identique au tableau T initial.