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) |
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 tableT{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 tableT{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 doubleT.Nom(1)
renverra la valeur 'Allais' sous le type du contenant, ici avec le type cellT.Nom{1}
renverra la valeur 'Allais' sous le type du contenu, ici avec le type char (notez la différence avecT{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 |