Autres types de variables, spécifiques à MATLAB

Jusqu'ici, nous avons vu que nous pouvions stocker une valeur dans une variable. Par extension, nous verrons par la suite que l'on peut stocker un tableau de valeurs numériques dans une matrice, et les manipuler par des opérations terme à terme par exemple.

Les tableaux (array en anglais) permettent de stocker un ensemble de valeurs, à condition qu'elles soient toutes homogènes en type. Cela signifie que l'on peut avoir un tableau de doubles, où toutes les valeurs seront de type double, par exemple ; ou un tableau de nombres complexes, où toutes les valeurs seront de type complexe.

Il existe des types de variables plus complexes, que MATLAB a introduit au fil du temps, pour permettre la gestion d'un ensemble de données pouvant être hétérogènes, ou constitué d'éléments de types autres que numériques.

cell : type parfait pour gérer des tableaux de données hétérogènes

Fondamental

Une variable cell (cellule) est un tableau où chaque cellule peut être d'un type spécifique. On peut donc stocker dans une même variable un ensemble de données hétérogènes en type.

Les accolades {} permettent de créer des cell :

1
2
3
4
5
6
7
8
9
10
11
12
13
>> dateDuJour = {'mardi',2,'02/10/2018',[2,10,2018]}
  
dateDuJour =
  
   1×4 cell array
  
   {'mardi'} {[2]} {'02/10/2018'} {1×3 double}
  
>> dateDuJour{4}
  
ans =
  
   2 10 2018

Les cell sont aussi très souvent utilisées pour créer des tableaux de chaînes de caractères où chaque cellule peut avoir une taille spécifique (ce qui ne serait pas possible avec un simple tableau de chaînes de caractères). Par exemple :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
>> langages = {'Ada';'C';'Java';'Matlab';'Fortran';'Python';'Ruby'}
  
langages =
  
    'Ada'
    'C'
    'Java'
    'Matlab'
    'Fortran'
    'Python'
    'Ruby'
  
>> langages{4}
  
ans =
  
Matlab

struct : type parfait pour créer des variables structurées

Fondamental

Une variable de type struct est un tableau structuré. Ce type de donnée permet de regrouper des données dans des contenants que l'on appelle des champs (fields en anglais). Chaque champ peut être de n'importe quel type.

Syntaxe

La fonction struct permet de définir un élément de structure en précisant ses champs et ses valeurs :

1
nomDeLaStructure = struct('nomDuChamp1',valeur1,'nomDuChamp2',valeur2, ... )

Exemple

1
2
3
4
5
6
7
8
9
>> cetacea = struct('NomCommun','Rorcqual commun','Longueur',20,'Poids',55e3)
  
cetacea =
  
  struct with fields:
  
    NomCommun: 'Rorcqual commun'
     Longueur: 20
        Poids: 55000

On peut aisément étendre cette syntaxe pour créer un tableau de structure :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
>> cetacea(2) = struct('NomCommun','Orque','Longueur',7.55,'Poids',5.8e3);
>> cetacea(3) = struct('NomCommun','Grand dauphin','Longueur',3,'Poids',400);
>> cetacea(4) = struct('NomCommun','Cachalot','Longueur',14.5,'Poids',35e3);
  
>> cetacea(3).NomCommun
  
ans =
  
    'Grand dauphin'
  
>> cetacea(1).Poids
  
ans =
  
    55000

L'exemple précédent montre que l'on peut utiliser la notation objet (dot notation) de la forme nomDeLaStructure.nomDuChamp pour accéder facilement à un champ particulier de la structure. L'opérateur . peut aussi être utilisé pour créer les champs par cette syntaxe issue de l'approche objet :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
>> langages(1).nom = 'C' ;
>> langages(1).version = 4.8 ;
>> langages(2).nom = 'Matlab' ;
>> langages(2).version = 2019 ;
>> langages
  
langages =
  
1x2 struct array with fields:
    nom
    version
  
>> langages(2)
  
ans =
  
    nom: 'Matlab'
    version: 2019
  

table : le type parfait pour des données hétérogènes tabulées

Un nouveau type de données vient d'être introduit dans le langage MATLAB : il s'agit des table.

Fondamental

Ce type de variable table permet de regrouper plusieurs variables de types différents dans un container unique, et de les visualiser aisément sous forme de données tabulées.

Syntaxe

La fonction table permet de définir une nouvelle variable de type table, en précisant le contenu de chacune de ses colonnes :

1
nomDeLaTable = table(valeursColonne1, valeursColonne2, ...)

Exemple

Par exemple, si l'on crée différentes variables pour stocker des informations :

1
2
3
4
5
6
>> Prenom={'Maurice';'Émile';'Henry';'Henri';'Paul'};
>> Nom={'Allais';'Clapeyron';'Le Chatelier';'Poincaré';'Lévy'};
>> DateNaissance=[1911;1799;1850;1854;1886];
>> DateDeces=[2010;1864;1936;1912;1971];
>> Specialites={'économiste et physicien';'physicien (thermodynamique)';'chimiste';'mathématicien et physicien';'mathématicien (probabilités)'};
>> Prix={'Prix Nobel d''économie en 1988';'';'médaille Davy en 1916';'médaille d''or de la Royal Astronomical Society en 1900';''};

On peut alors créer une table T, regroupant toutes ces variables dans un tableau :

1
>> T=table(Prenom,Nom,DateNaissance,DateDeces,Specialites,Prix)
Exemple d'une variable de type table

Comme il est montré dans l'exemple précédent, il est obligatoire que le nombre d'éléments dans chacune des variables soit identique.

L'accès à un élément de la table peut se faire de différentes manières :

  • T(1,3) renverra la valeur 1911 sous le type table

  • T{1,3} renverra la valeur 1911 sous le type du contenu, ici avec le type double.

De la même manière,

  • T(1,2) renverra la valeur 'Allais' sous le type table

  • T{1,2} renverra la valeur 'Allais' sous le type du contenu, ici avec le type cell.

Exemple

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
>> T(1,2)
  
ans =
  
   table
  
       Nom
     ________
  
     'Allais'
  
>> T{1,2}
  
ans =
  
   1×1 cell array
     {'Allais'}

Une autre manière d'accéder à un élément d'une table est la notation objet (dot notation) par champ :

  • T.DateNaissance(1) renverra la valeur 1911 sous le type du contenu, ici avec le type double

  • T.Nom(1) renverra la valeur 'Allais' sous le type du contenant, ici avec le type cell

  • T.Nom{1} renverra la valeur 'Allais' sous le type du contenu, ici avec le type char (notez la différence avec T{1,2} !).

1
2
3
4
5
>> T.Nom{1}
  
ans =
  
   'Allais'

Selon le même principe, l'ensemble des éléments d'une variable (ou colonne de la table) peut être récupéré de plusieurs manières :

  • noms = T(:,2)

  • ou noms = T{:,2}

  • ou noms = T.Nom

Exemple

1
2
3
4
5
6
7
8
9
10
11
>> noms = T.Nom
    
noms =
    
  5×1 cell array
  
    {'Allais'      }
    {'Clapeyron'   }
    {'Le Chatelier'}
    {'Poincaré'    }
    {'Lévy'        }

Plusieurs variables peuvent être extraites simultanément.

M = T(:,{'Prenom','Nom','DateNaissance'}) va créer une nouvelle table avec les trois premières colonnes de la table T.

M1=T{:,{'Prenom','Nom'}} va créer une matrice du type associé au contenu. Il est donc nécessaire que les variables extraites soient de même type.

On peut ajouter une nouvelle variable (colonne du tableau) à la table, soit avec une instruction de type indexation :

T{:,7} = [99;65;86;58;85]; le nom de la septième colonne prend par défaut la valeur Var7

soit par une notation objet, en spécifiant le nom de la colonne :

T.AgeDeces = [99;65;86;58;85]; le nom de la colonne est donc AgeDeces

Exemple

1
>> T.AgeDeces=T.DateDeces-T.DateNaissance
Exemple d'une variable de type table : ajout d'une colonne