Premiers pas avec le langage MATLAB

Matrices et tableaux d’indexation

MATLAB permet plusieurs méthodes pour indexer (accéder) aux éléments de matrices et de tableaux :

  • Indexation en indice - où vous spécifiez la position des éléments que vous voulez dans chaque dimension de la matrice séparément.
  • Indexation linéaire - où la matrice est traitée comme un vecteur, quelles que soient ses dimensions. Cela signifie que vous spécifiez chaque position dans la matrice avec un seul numéro.
  • Indexation logique - où vous utilisez une matrice logique (et une matrice de valeurs “true” et “false”) avec les mêmes dimensions que la matrice que vous essayez d’indexer en tant que masque pour spécifier la valeur à renvoyer.

Ces trois méthodes sont maintenant expliquées plus en détail en utilisant la matrice 3 par 3 suivante “M” comme exemple :

>> M = magic(3)

ans = 

       8    1    6
       3    5    7
       4    9    2

Indexation par indice

La méthode la plus simple pour accéder à un élément consiste à spécifier son index ligne-colonne. Par exemple, en accédant à l’élément de la deuxième ligne et de la troisième colonne :

>> M(2, 3)

ans =

      7

Le nombre d’indices fournis correspond exactement au nombre de dimensions de “M” (deux dans cet exemple).

Notez que l’ordre des indices est le même que la convention mathématique : l’index de ligne est le premier. De plus, les indices MATLAB commencent par 1 et pas par 0 comme la plupart des langages de programmation.

Vous pouvez indexer plusieurs éléments à la fois en passant un vecteur pour chaque coordonnée au lieu d’un seul nombre. Par exemple, pour obtenir la deuxième ligne entière, nous pouvons spécifier que nous voulons les première, deuxième et troisième colonnes :

>> M(2, [1,2,3])

ans =

       3    5    7

Dans MATLAB, le vecteur [1,2,3] est plus facilement créé à l’aide de l’opérateur deux-points, c’est-à-dire 1: 3. Vous pouvez également l’utiliser pour l’indexation. Pour sélectionner une ligne (ou une colonne) entière, MATLAB fournit un raccourci en vous permettant simplement de spécifier :. Par exemple, le code suivant renverra également la deuxième ligne entière

>> M(2, :)

ans =

       3    5    7

MATLAB fournit également un raccourci pour spécifier le dernier élément d’une dimension sous la forme du mot-clé end. Le mot-clé end fonctionnera exactement comme s’il s’agissait du numéro du dernier élément de cette dimension. Donc, si vous voulez toutes les colonnes de la colonne “2” à la dernière colonne, vous pouvez écrire ce qui suit :

>> M(2, 2:end)

ans =

       5    7

L’indexation en indice peut être restrictive car elle ne permet pas d’extraire des valeurs uniques de différentes colonnes et lignes ; il extraira la combinaison de toutes les lignes et colonnes.

>> M([2,3], [1,3])
ans =

       3    7
       4    2

Par exemple, l’indexation en indice ne peut pas extraire uniquement les éléments M(2,1) ou M(3,3). Pour ce faire, il faut considérer l’indexation linéaire.

Indexation linéaire

MATLAB vous permet de traiter les tableaux à n dimensions comme des tableaux à une dimension lorsque vous indexez en utilisant une seule dimension. Vous pouvez accéder directement au premier élément :

>> M(1)

ans = 

       8

Notez que les tableaux sont stockés dans [column-major order][1] dans MATLAB, ce qui signifie que vous accédez aux éléments en descendant d’abord les colonnes. Donc ‘M(2)’ est le deuxième élément de la première colonne qui est ‘3’ et ‘M(4)’ sera le premier élément de la deuxième colonne, c’est-à-dire

>> M(4)

ans = 

        1

Il existe des fonctions intégrées dans MATLAB pour convertir les indices d’indices en indices linéaires, et vice versa : [sub2ind][3] et [ind2sub][4] respectivement. Vous pouvez convertir manuellement les indices (r,c) en un index linéaire en

idx = r + (c-1)*size(M,1)

Pour comprendre cela, si nous sommes dans la première colonne alors l’index linéaire sera simplement l’index de ligne. La formule ci-dessus est vraie pour cela car pour c == 1, (c-1) == 0. Dans les colonnes suivantes, l’index linéaire est le numéro de ligne plus toutes les lignes des colonnes précédentes.

Notez que le mot clé end s’applique toujours et fait maintenant référence au tout dernier élément du tableau, c’est-à-dire M(end) == M(end, end) == 2.

Vous pouvez également indexer plusieurs éléments à l’aide de l’indexation linéaire. Notez que si vous faites cela, la matrice renvoyée aura la même forme que la matrice des vecteurs d’index.

M(2:4) renvoie un vecteur ligne car 2:4 représente le vecteur ligne [2,3,4] :

>> M(2:4)

ans =

        3    4    1

Comme autre exemple, M([1,2;3,4]) renvoie une matrice 2 par 2 car [1,2;3,4] est également une matrice 2 par 2. Voir le code ci-dessous pour vous en convaincre :

>> M([1,2;3,4])

ans =

       8        3
       4        1

Notez que l’indexation avec : seul renverra toujours un vecteur colonne :

>> M(:)

ans = 

        8
        3
        4
        1
        5
        9
        6
        7
        2

Cet exemple illustre également l’ordre dans lequel MATLAB renvoie les éléments lors de l’utilisation de l’indexation linéaire.

Indexation logique

La troisième méthode d’indexation consiste à utiliser une matrice logique, c’est-à-dire une matrice contenant uniquement des valeurs “true” ou “false”, comme masque pour filtrer les éléments dont vous ne voulez pas. Par exemple, si nous voulons trouver tous les éléments de ‘M’ supérieurs à ‘5’, nous pouvons utiliser la matrice logique

>> M > 5

ans =

    1    0    1
    0    0    1
    0    1    0

pour indexer ‘M’ et renvoyer uniquement les valeurs supérieures à ‘5’ comme suit :

>> M(M > 5)

ans =

        8
        9
        6
        7

Si vous vouliez que ces nombres restent en place (c’est-à-dire qu’ils conservent la forme de la matrice), vous pouvez attribuer au compliment logique

>> M(~(M > 5)) = NaN

ans = 

    8      NaN    6
    NaN    NaN    7
    NaN    9      Nan

Nous pouvons réduire les blocs de code compliqués contenant des instructions if et for en utilisant l’indexation logique.

Prenez le non vectorisé (déjà raccourci à une seule boucle en utilisant l’indexation linéaire):

for elem = 1:numel(M)
  if M(elem) > 5
    M(elem) = M(elem) - 2;
  end
end

Cela peut être raccourci au code suivant en utilisant l’indexation logique :

idx = M > 5;
M(idx) = M(idx) - 2;

Ou encore plus court :

M(M > 5) = M(M > 5) - 2;

En savoir plus sur l’indexation

Matrices de dimension supérieure

Toutes les méthodes mentionnées ci-dessus se généralisent en n-dimensions. Si nous utilisons la matrice tridimensionnelle M3 = rand(3,3,3) comme exemple, vous pouvez accéder à toutes les lignes et colonnes de la deuxième tranche de la troisième dimension en écrivant

>> M(:,:,2)

Vous pouvez accéder au premier élément de la deuxième tranche en utilisant l’indexation linéaire. L’indexation linéaire ne passera qu’à la deuxième tranche après toutes les lignes et toutes les colonnes de la première tranche. Ainsi, l’indice linéaire de cet élément est

>> M(size(M,1)*size(M,2)+1)

En fait, dans MATLAB, chaque matrice est à n dimensions : il se trouve que la taille de la plupart des autres n dimensions est de un. Donc, si a = 2 alors a(1) == 2 (comme on pouvait s’y attendre), mais aussi a(1, 1) == 2, tout comme a(1, 1, 1) == 2, a(1, 1, 1, ..., 1) == 2 et ainsi de suite. Ces dimensions “supplémentaires” (de taille “1”) sont appelées dimensions singleton. La commande squeeze les supprimera, et on peut utiliser permute pour échanger l’ordre des dimensions (et introduire des dimensions singleton si nécessaire).

Une matrice à n dimensions peut également être indexée à l’aide de m indices (où m<=n). La règle est que les m-1 premiers indices se comportent normalement, tandis que le dernier (m’ième) indice référence les dimensions restantes (n-m+1), tout comme un index linéaire référencerait une dimension (n-m+1) déployer. Voici un exemple:

>> M = reshape(1:24,[2,3,4]);
>> M(1,1)
ans =
     1
>> M(1,10)
ans =
    19
>> M(:,:)
ans =
     1     3     5     7     9    11    13    15    17    19    21    23
     2     4     6     8    10    12    14    16    18    20    22    24

Renvoi de plages d’éléments

Avec l’indexation en indice, si vous spécifiez plusieurs éléments dans plusieurs dimensions, MATLAB renvoie chaque paire de coordonnées possible. Par exemple, si vous essayez M([1,2],[1,3]), MATLAB renverra M(1,1) et M(2,3) mais il renverra également M(1,3)' et 'M(2,1)'. Cela peut sembler peu intuitif lorsque vous recherchez les éléments d'une liste de paires de coordonnées, mais considérez l'exemple d'une matrice plus grande,A = rand(20)(notez queAest maintenant20-by-20), où vous voulez obtenir le quadrant supérieur droit. Dans ce cas, au lieu d'avoir à spécifier chaque paire de coordonnées dans ce quadrant (et dans ce cas, il s'agirait de100paires), vous spécifiez simplement les10lignes et les10colonnes que vous voulez doncA(1 : 10, 11:fin)`. Découper une matrice comme celle-ci est beaucoup plus courant que d’exiger une liste de paires de coordonnées.

Si vous souhaitez obtenir une liste de paires de coordonnées, la solution la plus simple consiste à convertir en indexation linéaire. Considérez le problème où vous avez un vecteur d’indices de colonne que vous souhaitez renvoyer, où chaque ligne du vecteur contient le numéro de colonne que vous souhaitez renvoyer pour la ligne corresponding de la matrice. Par exemple

colIdx = [3;2;1]

Donc, dans ce cas, vous voulez en fait récupérer les éléments à (1,3), (2,2) et (3,1). Donc, en utilisant l’indexation linéaire :

>> colIdx = [3;2;1];
>> rowIdx = 1:length(colIdx);
>> idx = sub2ind(size(M), rowIdx, colIdx);
>> M(idx)

ans = 

        6    5    4

Renvoyer un élément plusieurs fois

Avec l’indexation en indice et linéaire, vous pouvez également renvoyer un élément plusieurs fois en répétant son index afin

>> M([1,1,1,2,2,2])

ans = 

        8    8    8    3    3    3

Vous pouvez l’utiliser pour dupliquer des lignes et des colonnes entières, par exemple pour répéter la première ligne et la dernière colonne

>> M([1, 1:end], [1:end, end])

ans = 

        8    1    6    6 
        8    1    6    6
        3    5    7    7
        4    9    2    2

Pour plus d’informations, voir [ici][2].

[1] : https://en.wikipedia.org/wiki/Row-major_order [2] : http://www.mathworks.com/company/newsletters/articles/matrix-indexing-in-matlab.html [3] : http://www.mathworks.com/help/matlab/ref/sub2ind.html [4] : http://www.mathworks.com/help/matlab/ref/ind2sub.html

Fonctions anonymes et poignées de fonction

Bases

Les fonctions anonymes sont un outil puissant du langage MATLAB. Ce sont des fonctions qui existent localement, c’est-à-dire : dans l’espace de travail courant. Cependant, ils n’existent pas sur le chemin MATLAB comme le ferait une fonction régulière, par ex. dans un fichier m. C’est pourquoi ils sont appelés anonymes, bien qu’ils puissent avoir un nom comme une variable dans l’espace de travail.

L’opérateur @

Utilisez l’opérateur @ pour créer des fonctions anonymes et des descripteurs de fonction. Par exemple, pour créer un handle vers la fonction sin (sinus) et l’utiliser comme f :

>> f = @sin
f = 
    @sin

Maintenant, f est un handle de la fonction sin. Tout comme (dans la vraie vie) une poignée de porte est une façon d’utiliser une porte, une poignée de fonction est une façon d’utiliser une fonction. Pour utiliser f, les arguments lui sont passés comme s’il s’agissait de la fonction sin :

>> f(pi/2)
ans =
     1

f accepte tous les arguments d’entrée que la fonction sin accepte. Si sin était une fonction qui n’accepte aucun argument d’entrée (ce qui n’est pas le cas, mais d’autres le font, par exemple la fonction peaks), f() serait utilisé pour l’appeler sans argument d’entrée.

Fonctions anonymes personnalisées

Fonctions anonymes d’une variable

Il n’est évidemment pas utile de créer un handle vers une fonction existante, comme sin dans l’exemple ci-dessus. C’est un peu redondant dans cet exemple. Cependant, il est utile de créer des fonctions anonymes qui font des choses personnalisées qui devraient autrement être répétées plusieurs fois ou créer une fonction distincte pour. À titre d’exemple de fonction anonyme personnalisée qui accepte une variable en entrée, additionnez le sinus et le cosinus au carré d’un signal :

>> f = @(x) sin(x)+cos(x).^2
f = 
    @(x)sin(x)+cos(x).^2

Maintenant, f accepte un argument d’entrée appelé x. Ceci a été spécifié en utilisant des parenthèses (...) directement après l’opérateur @. f est maintenant une fonction anonyme de x : f(x). Il est utilisé en passant une valeur de x à f :

>> f(pi)
ans =
    1.0000

Un vecteur de valeurs ou une variable peuvent également être passés à f, tant qu’ils sont utilisés de manière valide dans f :

>> f(1:3) % pass a vector to f
ans =
    1.1334    1.0825    1.1212
>> n = 5:7;
>> f(n) % pass n to f
ans =
   -0.8785    0.6425    1.2254

Fonctions anonymes de plusieurs variables

De la même manière, des fonctions anonymes peuvent être créées pour accepter plus d’une variable. Un exemple de fonction anonyme qui accepte trois variables :

>> f = @(x,y,z) x.^2 + y.^2 - z.^2
f = 
    @(x,y,z)x.^2+y.^2-z.^2
>> f(2,3,4)
ans =
    -3

Paramétrage des fonctions anonymes

Les variables de l’espace de travail peuvent être utilisées dans la définition des fonctions anonymes. C’est ce qu’on appelle le paramétrage. Par exemple, pour utiliser une constante c = 2 dans une fonction anonyme :

>> c = 2;
>> f = @(x) c*x
f = 
    @(x)c*x
>> f(3)
ans =
     6

f(3) a utilisé la variable c comme paramètre pour multiplier avec le x fourni. Notez que si la valeur de c est définie sur quelque chose de différent à ce stade, alors f(3) est appelé, le résultat ne serait pas différent. La valeur de c est la valeur au moment de la création de la fonction anonyme :

>> c = 2;
>> f = @(x) c*x;
>> f(3)
ans =
     6
>> c = 3;
>> f(3)
ans =
     6

Les arguments d’entrée d’une fonction anonyme ne font pas référence aux variables de l’espace de travail

Notez que l’utilisation du nom des variables dans l’espace de travail comme l’un des arguments d’entrée d’une fonction anonyme (c’est-à-dire l’utilisation de @(...)) n’utilisera pas les valeurs de ces variables. Au lieu de cela, elles sont traitées comme des variables différentes dans le cadre de la fonction anonyme, c’est-à-dire : la fonction anonyme a son espace de travail privé où les variables d’entrée ne font jamais référence aux variables de l’espace de travail principal. L’espace de travail principal et l’espace de travail de la fonction anonyme ne connaissent pas le contenu de l’autre. Un exemple pour illustrer cela :

>> x = 3 % x in main workspace
x =
     3
>> f = @(x) x+1; % here x refers to a private x variable
>> f(5)
ans =
     6
>> x
x =
     3

La valeur de x de l’espace de travail principal n’est pas utilisée dans f. De plus, dans l’espace de travail principal, “x” n’a pas été modifié. Dans le cadre de f, les noms de variables entre parenthèses après l’opérateur @ sont indépendants des principales variables de l’espace de travail.

Les fonctions anonymes sont stockées dans des variables

Une fonction anonyme (ou, plus précisément, le handle de fonction pointant vers une fonction anonyme) est stockée comme n’importe quelle autre valeur dans l’espace de travail courant : dans une variable (comme nous l’avons fait ci-dessus), dans un tableau de cellules ({@(x) x.^2,@(x)x+1}), ou même dans une propriété (comme h.ButtonDownFcn pour les graphiques interactifs). Cela signifie que la fonction anonyme peut être traitée comme n’importe quelle autre valeur. Lorsqu’il est stocké dans une variable, il a un nom dans l’espace de travail actuel et peut être modifié et effacé tout comme les variables contenant des nombres.

En d’autres termes : un descripteur de fonction (que ce soit sous la forme @sin ou pour une fonction anonyme) est simplement une valeur qui peut être stockée dans une variable, tout comme une matrice numérique peut l’être.

Utilisation avancée

Passer des poignées de fonction à d’autres fonctions

Étant donné que les descripteurs de fonction sont traités comme des variables, ils peuvent être passés à des fonctions qui acceptent des descripteurs de fonction comme arguments d’entrée.

Un exemple : une fonction est créée dans un fichier m qui accepte un descripteur de fonction et un nombre scalaire. Il appelle ensuite le handle de fonction en lui passant ‘3’, puis ajoute le nombre scalaire au résultat. Le résultat est renvoyé.

Contenu de funHandleDemo.m :

function y = funHandleDemo(fun,x)
y = fun(3);
y = y + x;

Enregistrez-le quelque part sur le chemin, par ex. dans le dossier actuel de MATLAB. Désormais, funHandleDemo peut être utilisé comme suit, par exemple :

>> f = @(x) x^2; % an anonymous function
>> y = funHandleDemo(f,10) % pass f and a scalar to funHandleDemo
y =
    19

Le handle d’une autre fonction existante peut être passé à funHandleDemo :

>> y = funHandleDemo(@sin,-5)
y =
   -4.8589

Remarquez comment @sin était un moyen rapide d’accéder à la fonction sin sans d’abord la stocker dans une variable en utilisant f = @sin.

Utiliser bsxfun, cellfun et des fonctions similaires avec des fonctions anonymes

MATLAB possède des fonctions intégrées qui acceptent des fonctions anonymes en entrée. C’est un moyen d’effectuer de nombreux calculs avec un nombre minimal de lignes de code. Par exemple bsxfun, qui effectue des opérations binaires élément par élément, c’est-à-dire : il applique une fonction sur deux vecteurs ou matrices de manière élément par élément. Normalement, cela nécessiterait l’utilisation de boucles for, ce qui nécessite souvent une préallocation pour la vitesse. En utilisant bsxfun, ce processus est accéléré. L’exemple suivant illustre cela en utilisant tic et toc, deux fonctions qui peuvent être utilisées pour chronométrer la durée du code. Il calcule la différence de chaque élément de la matrice à partir de la moyenne de la colonne de la matrice.

A = rand(50); % 50-by-50 matrix of random values between 0 and 1

% method 1: slow and lots of lines of code
tic
meanA = mean(A); % mean of every matrix column: a row vector
% pre-allocate result for speed, remove this for even worse performance
result = zeros(size(A));
for j = 1:size(A,1)
    result(j,:) = A(j,:) - meanA;
end
toc
clear result % make sure method 2 creates its own result

% method 2: fast and only one line of code
tic
result = bsxfun(@minus,A,mean(A));
toc

L’exécution de l’exemple ci-dessus génère deux sorties :

Elapsed time is 0.015153 seconds.
Elapsed time is 0.007884 seconds.

Ces lignes proviennent des fonctions toc, qui impriment le temps écoulé depuis le dernier appel à la fonction tic.

L’appel bsxfun applique la fonction dans le premier argument d’entrée aux deux autres arguments d’entrée. @moins est un long nom pour la même opération que le ferait le signe moins. Une fonction ou un handle anonyme différent (@) de toute autre fonction aurait pu être spécifié, tant qu’il accepte A et mean(A) comme entrées pour générer un résultat significatif.

Surtout pour de grandes quantités de données dans de grandes matrices, bsxfun peut accélérer considérablement les choses. Cela rend également le code plus propre, bien qu’il puisse être plus difficile à interpréter pour les personnes qui ne connaissent pas MATLAB ou bsxfun. (Notez que dans MATLAB R2016a et versions ultérieures, de nombreuses opérations qui utilisaient auparavant “bsxfun” n’en ont plus besoin ; “A-mean(A)” fonctionne directement et peut, dans certains cas, être encore plus rapide.)

Matrices et tableaux

Dans MATLAB, le type de données le plus basique est le tableau numérique. Il peut s’agir d’un scalaire, d’un vecteur 1-D, d’une matrice 2-D ou d’un tableau multidimensionnel N-D.

% a 1-by-1 scalar value
x = 1;

Pour créer un vecteur ligne, saisissez les éléments entre parenthèses, séparés par des espaces ou des virgules :

% a 1-by-4 row vector
v = [1, 2, 3, 4];
v = [1 2 3 4];

Pour créer un vecteur colonne, séparez les éléments par des points-virgules :

% a 4-by-1 column vector
v = [1; 2; 3; 4];

Pour créer une matrice, nous saisissons les lignes comme précédemment séparées par des points-virgules :

% a 2 row-by-4 column matrix
M = [1 2 3 4; 5 6 7 8];

% a 4 row-by-2 column matrix
M = [1 2; ...
     4 5; ...
     6 7; ...
     8 9];

Notez que vous ne pouvez pas créer une matrice avec une taille de ligne/colonne inégale. Toutes les lignes doivent avoir la même longueur et toutes les colonnes doivent avoir la même longueur :

% an unequal row / column matrix
M = [1 2 3 ; 4 5 6 7]; % This is not valid and will return an error

% another unequal row / column matrix
M = [1 2 3; ...
     4   5; ...
     6 7 8; ...
     9   10];     % This is not valid and will return an error

Pour transposer un vecteur ou une matrice, on utilise l’opérateur .', ou l’opérateur ' pour prendre son conjugué hermitien, qui est le conjugué complexe de sa transposée. Pour les matrices réelles, ces deux sont les mêmes :

% create a row vector and transpose it into a column vector
v = [1 2 3 4].';              % v is equal to [1; 2; 3; 4];

% create a 2-by-4 matrix and transpose it to get a 4-by-2 matrix
M = [1 2 3 4; 5 6 7 8].';     % M is equal to [1 5; 2 6; 3 7; 4 8]

% transpose a vector or matrix stored as a variable
A = [1 2; 3 4];
B = A.';                      % B is equal to [1 3; 2 4]

Pour les tableaux de plus de deux dimensions, il n’y a pas de syntaxe de langage directe pour les entrer littéralement. Au lieu de cela, nous devons utiliser des fonctions pour les construire (telles que ones, zeros, rand) ou en manipulant d’autres tableaux (en utilisant des fonctions telles que cat, reshape, permute). Quelques exemples:

% a 5-by-2-by-4-by-3 array (4-dimensions)
arr = ones(5, 2, 4, 3);

% a 2-by-3-by-2 array (3-dimensions)
arr = cat(3, [1 2 3; 4 5 6], [7 8 9; 0 1 2]);

% a 5-by-4-by-3-by-2 (4-dimensions)
arr = reshape(1:120, [5 4 3 2]);

Tableaux de cellules

Les éléments d’une même classe peuvent souvent être concaténés dans des tableaux (à quelques rares exceptions près, par exemple les poignées de fonction). Les scalaires numériques, par défaut de classe double, peuvent être stockés dans une matrice.

>> A = [1, -2, 3.14, 4/5, 5^6; pi, inf, 7/0, nan, log(0)]
A =
   1.0e+04 *
    0.0001   -0.0002    0.0003    0.0001    1.5625
    0.0003       Inf       Inf       NaN      -Inf

Les caractères, qui sont de la classe char dans MATLAB, peuvent également être stockés dans un tableau en utilisant une syntaxe similaire. Un tel tableau est similaire à une chaîne dans de nombreux autres langages de programmation.

>> s = ['MATLAB ','is ','fun']
s =
MATLAB is fun

Notez que bien que les deux utilisent des crochets [ et ], les classes de résultats sont différentes. Par conséquent, les opérations pouvant être effectuées sur eux sont également différentes.

>> whos
  Name      Size            Bytes  Class     Attributes

  A         2x5                80  double              
  s         1x13               26  char                

En fait, le tableau s n’est pas un tableau des chaînes 'MATLAB ','is ' et 'fun', c’est juste une chaîne - un tableau de 13 caractères. Vous obtiendriez les mêmes résultats s’il était défini par l’un des éléments suivants :

>> s = ['MAT','LAB ','is f','u','n'];
>> s = ['M','A','T','L','A','B,' ','i','s',' ','f','u','n'];

Un vecteur MATLAB standard ne vous permet pas de stocker un mélange de variables de différentes classes ou quelques chaînes différentes. C’est là que le tableau cell est utile. Il s’agit d’un tableau de cellules pouvant chacune contenir un objet MATLAB, dont la classe peut être différente dans chaque cellule si nécessaire. Utilisez des accolades { et } autour des éléments à stocker dans un tableau de cellules.

>> C = {A; s}
C = 
    [2x5 double]
    'MATLAB is fun'
>> whos C
  Name      Size            Bytes  Class    Attributes

  C         2x1               330  cell 

Les objets MATLAB standard de toutes les classes peuvent être stockés ensemble dans un tableau de cellules. Notez que les tableaux de cellules nécessitent plus de mémoire pour stocker leur contenu.

L’accès au contenu d’une cellule se fait à l’aide des accolades { et }.

>> C{1}
ans =
   1.0e+04 *
    0.0001   -0.0002    0.0003    0.0001    1.5625
    0.0003       Inf       Inf       NaN      -Inf

Notez que C(1) est différent de C{1}. Alors que ce dernier renvoie le contenu de la cellule (et a la classe double in out example), le premier renvoie un tableau de cellules qui est un sous-tableau de C. De même, si D était un tableau de 10 par 5 cellules, alors D(4:8,1:3) renverrait un sous-tableau de D dont la taille est de 5 par 3 et dont la classe est cell . Et la syntaxe C{1:2} n’a pas un seul objet renvoyé, mais elle renvoie 2 objets différents (similaire à une fonction MATLAB avec plusieurs valeurs de retour) :

>> [x,y] = C{1:2}
x =
                         1                        -2                      3.14                       0.8                     15625
          3.14159265358979                       Inf                       Inf                       NaN                      -Inf
y =
MATLAB is fun

Bonjour le monde

Ouvrez un nouveau document vierge dans l’éditeur MATLAB (dans les versions récentes de MATLAB, faites-le en sélectionnant l’onglet Accueil de la bande d’outils et en cliquant sur Nouveau script). Le raccourci clavier par défaut pour créer un nouveau script est Ctrl-n.

Alternativement, taper edit myscriptname.m ouvrira le fichier myscriptname.m pour modification, ou proposera de créer le fichier s’il n’existe pas sur le chemin MATLAB.

Dans l’éditeur, tapez ce qui suit :

disp('Hello, World!');

Sélectionnez l’onglet Éditeur de la barre d’outils, puis cliquez sur Enregistrer sous. Enregistrez le document dans un fichier du répertoire courant appelé helloworld.m. L’enregistrement d’un fichier sans titre fera apparaître une boîte de dialogue pour nommer le fichier.

Dans la fenêtre de commande MATLAB, saisissez ce qui suit :

>> helloworld

Vous devriez voir la réponse suivante dans la fenêtre de commande MATLAB :

Hello, World!

Nous voyons que dans la fenêtre de commande, nous pouvons taper les noms des fonctions ou des fichiers de script que nous avons écrits, ou qui sont livrés avec MATLAB, pour les exécuter.

Ici, nous avons exécuté le script ‘helloworld’. Notez que la saisie de l’extension (.m) n’est pas nécessaire. Les instructions contenues dans le fichier de script sont exécutées par MATLAB, en imprimant ici “Hello, World!” en utilisant la fonction disp.

Les fichiers de script peuvent être écrits de cette manière pour enregistrer une série de commandes pour une (ré)utilisation ultérieure.

S’aider soi-même

MATLAB est livré avec de nombreux scripts et fonctions intégrés qui vont de la simple multiplication aux boîtes à outils de reconnaissance d’images. Afin d’obtenir des informations sur une fonction que vous souhaitez utiliser, tapez : help nom_fonction dans la ligne de commande. Prenons la fonction help comme exemple.

Des informations sur son utilisation peuvent être obtenues en tapant :

>> aide aide

dans la fenêtre de commande. Cela renverra des informations sur l’utilisation de la fonction help. Si les informations que vous recherchez ne sont toujours pas claires, vous pouvez essayer la page de documentation de la fonction. Tapez simplement :

>> aide doc

dans la fenêtre de commande. Cela ouvrira la documentation navigable sur la page de la fonction “help” fournissant toutes les informations dont vous avez besoin pour comprendre le fonctionnement de “l’aide”.

Cette procédure fonctionne pour toutes les fonctions et tous les symboles intégrés.

Lorsque vous développez vos propres fonctions, vous pouvez leur donner leur propre section d’aide en ajoutant des commentaires en haut du fichier de la fonction ou juste après la déclaration de la fonction.

Exemple pour une fonction simple multiplyby2 enregistrée dans le fichier multiplyby2.m

function [prod]=multiplyby2(num)
% function MULTIPLYBY2 accepts a numeric matrix NUM and returns output PROD 
% such that all numbers are multiplied by 2

    prod=num*2;
end

ou

% function MULTIPLYBY2 accepts a numeric matrix NUM and returns output PROD 
% such that all numbers are multiplied by 2

function [prod]=multiplyby2(num)
    prod=num*2;
end

Ceci est très utile lorsque vous récupérez votre code des semaines/mois/années après l’avoir écrit.

Les fonctions help et doc fournissent de nombreuses informations, apprendre à utiliser ces fonctionnalités vous aidera à progresser rapidement et à utiliser MATLAB efficacement.

Scripts et fonctions

Le code MATLAB peut être enregistré dans des fichiers m pour être réutilisé. Les fichiers m ont l’extension .m qui est automatiquement associée à MATLAB. Un fichier m peut contenir soit un script, soit des fonctions.

Scripts

Les scripts sont simplement des fichiers de programme qui exécutent une série de commandes MATLAB dans un ordre prédéfini.

Les scripts n’acceptent pas d’entrée et ne renvoient pas non plus de sortie. Fonctionnellement, les scripts équivalent à taper des commandes directement dans la fenêtre de commande MATLAB et à pouvoir les rejouer.

Un exemple de script :

length = 10;
width = 3;
area = length * width;

Ce script définira length, width et area dans l’espace de travail actuel avec les valeurs 10, 3 et 30 respectivement.

Comme indiqué précédemment, le script ci-dessus est fonctionnellement équivalent à taper les mêmes commandes directement dans la fenêtre de commande.

>> length = 10;
>> width = 3;
>> area = length * width;

Les fonctions

Les fonctions, comparées aux scripts, sont beaucoup plus flexibles et extensibles. Contrairement aux scripts, les fonctions peuvent accepter une entrée et renvoyer une sortie à l’appelant. Une fonction a son propre espace de travail, cela signifie que les opérations internes des fonctions ne changeront pas les variables de l’appelant.

Toutes les fonctions sont définies avec le même format d’en-tête :

function [output] = myFunctionName(input)

Le mot-clé function commence chaque en-tête de fonction. La liste des sorties suit. La liste des sorties peut également être une liste de variables séparées par des virgules à renvoyer.

function [a, b, c] = myFunctionName(input)

Vient ensuite le nom de la fonction qui sera utilisée pour l’appel. Il s’agit généralement du même nom que le nom du fichier. Par exemple, nous enregistrerions cette fonction sous myFunctionName.m.

Après le nom de la fonction se trouve la liste des entrées. Comme les sorties, cela peut également être une liste séparée par des virgules.

function [a, b, c] = myFunctionName(x, y, z)

Nous pouvons réécrire l’exemple de script précédent en tant que fonction réutilisable comme suit :

function [area] = calcRecArea(length, width)
   area = length * width;
end

Nous pouvons appeler des fonctions à partir d’autres fonctions, ou même à partir de fichiers de script. Voici un exemple de notre fonction ci-dessus utilisée dans un fichier de script.

l = 100;
w = 20;
a = calcRecArea(l, w);

Comme précédemment, nous créons l, w et a dans l’espace de travail avec les valeurs de 100, 20 et 2000 respectivement.

Lecture d’entrée et écriture de sortie

Comme tous les langages de programmation, Matlab est conçu pour lire et écrire dans une grande variété de formats. La bibliothèque native prend en charge un grand nombre de formats Texte, Image, Vidéo, Audio, Données avec plus de formats inclus dans chaque mise à jour de version - [vérifiez ici][1] pour voir la liste complète des formats de fichiers pris en charge et quelle fonction utiliser pour importer leur.

Avant d’essayer de charger votre fichier, vous devez vous demander ce que vous voulez que les données deviennent et comment vous vous attendez à ce que l’ordinateur organise les données pour vous. Supposons que vous ayez un fichier txt/csv au format suivant :

Fruit,TotalUnits,UnitsLeftAfterSale,SellingPricePerUnit
Apples,200,67,$0.14
Bananas,300,172,$0.11
Pineapple,50,12,$1.74

Nous pouvons voir que la première colonne est au format Strings, tandis que la deuxième, la troisième sont Numeric, la dernière colonne est au format Currency. Disons que nous voulons trouver combien de revenus nous avons réalisés aujourd’hui en utilisant Matlab et que nous voulons d’abord charger ce fichier txt/csv. Après avoir vérifié le lien, nous pouvons voir que les fichiers txt de type chaîne et numérique sont gérés par textscan. Alors on pourrait essayer :

fileID = fopen('dir/test.txt'); %Load file from dir
C = textscan(fileID,'%s %f %f %s','Delimiter',',','HeaderLines',1); %Parse in the txt/csv

%s suggère que l’élément est de type String, %f suggère que l’élément est de type Float et que le fichier est délimité par “,”. L’option HeaderLines demande à Matlab de sauter les N premières lignes tandis que le 1 immédiatement après signifie sauter la première ligne (la ligne d’en-tête).

Maintenant, C est les données que nous avons chargées sous la forme d’un tableau de cellules de 4 cellules, chacune contenant la colonne de données dans le fichier txt/csv.

Donc, nous voulons d’abord calculer combien de fruits nous avons vendus aujourd’hui en soustrayant la troisième colonne de la deuxième colonne, cela peut être fait par :

sold = C{2} - C{3}; %C{2} gives the elements inside the second cell (or the second column)

Maintenant, nous voulons multiplier ce vecteur par le prix par unité, nous devons donc d’abord convertir cette colonne de chaînes en une colonne de nombres, puis la convertir en une matrice numérique à l’aide de cell2mat de Matlab. La première chose que nous devons faire est de enlevez le signe “$”, il y a plusieurs façons de le faire. Le moyen le plus direct consiste à utiliser une simple regex :

D = cellfun(@(x)(str2num(regexprep(x, '\$',''))), C{4}, 'UniformOutput', false);%cellfun allows us to avoid looping through each element in the cell.

Ou vous pouvez utiliser une boucle :

for t=1:size(C{4},1)
   D{t} = str2num(regexprep(C{4}{t}, '\$',''));
end

E = cell2mat(D)% converts the cell array into a Matrix

La fonction str2num transforme la chaîne qui avait des signes “$” dépouillés en types numériques et cell2mat transforme la cellule d’éléments numériques en une matrice de nombres

Nous pouvons maintenant multiplier les unités vendues par le coût unitaire :

revenue = sold .* E; %element-wise product is denoted by .* in Matlab

totalrevenue = sum(revenue);

[1] : https://uk.mathworks.com/help/matlab/import_export/supported-file-formats.html

Types de données

Il existe [16 types de données fondamentaux] [1], ou classes, dans MATLAB. Chacune de ces classes se présente sous la forme d’une matrice ou d’un tableau. À l’exception des poignées de fonction, cette matrice ou ce tableau a une taille minimale de 0 par 0 et peut devenir un tableau à n dimensions de n’importe quelle taille. Un handle de fonction est toujours scalaire (1 par 1).

Le moment important dans MATLAB est que vous n’avez pas besoin d’utiliser de déclaration de type ou d’instructions de dimension par défaut. Lorsque vous définissez une nouvelle variable, MATLAB la crée automatiquement et alloue l’espace mémoire approprié.

Exemple:

a = 123;
b = [1 2 3];
c = '123';

>> whos
  Name      Size            Bytes  Class     Attributes

  a         1x1                 8  double              
  b         1x3                24  double              
  c         1x3                 6  char    

Si la variable existe déjà, MATLAB remplace les données d’origine par de nouvelles et alloue un nouvel espace de stockage si nécessaire.

Types de données fondamentaux

Les types de données fondamentaux sont : numeric, logical, char, cell, struct, table et function_handle.

[Types de données numériques][2] :

  • [Nombres à virgule flottante][3] (par défaut)

MATLAB représente les nombres à virgule flottante au format double précision ou simple précision. La valeur par défaut est la double précision, mais vous pouvez rendre n’importe quel nombre simple précision avec une simple fonction de conversion :

   a = 1.23;
   b = single(a);

   >> whos
     Name      Size            Bytes  Class     Attributes
   
     a         1x1                 8  double              
     b         1x1                 4  single     
  • [Entiers][4]

MATLAB a quatre classes d’entiers signés et quatre classes d’entiers non signés. Les types signés vous permettent de travailler aussi bien avec des entiers négatifs qu’avec des nombres positifs, mais ne peuvent pas représenter une plage de nombres aussi large que les types non signés car un bit est utilisé pour désigner un signe positif ou négatif pour le nombre. Les types non signés vous donnent une plage de nombres plus large, mais ces nombres ne peuvent être que nuls ou positifs.

MATLAB prend en charge le stockage sur 1, 2, 4 et 8 octets pour les données entières. Vous pouvez économiser de la mémoire et du temps d’exécution pour vos programmes si vous utilisez le plus petit type entier qui accepte vos données. Par exemple, vous n’avez pas besoin d’un entier 32 bits pour stocker la valeur 100.

   a = int32(100);
   b = int8(100);

   >> whos
     Name      Size            Bytes  Class    Attributes

     a         1x1                 4  int32              
     b         1x1                 1  int8               

Pour stocker des données sous forme d’entier, vous devez convertir de double au type d’entier souhaité. Si le nombre converti en entier a une partie fractionnaire, MATLAB arrondit à l’entier le plus proche. Si la partie fractionnaire est exactement “0,5”, alors parmi les deux entiers également proches, MATLAB choisit celui pour lequel la valeur absolue est la plus grande.

   a  = int16(456);
  • [char][5]

Les tableaux de caractères fournissent un stockage pour les données textuelles dans MATLAB. Conformément à la terminologie de programmation traditionnelle, un tableau (séquence) de caractères est défini comme une chaîne. Il n’y a pas de type de chaîne explicite dans les versions commerciales de MATLAB.

  • logique : les valeurs logiques de 1 ou 0, représentent respectivement vrai et faux. À utiliser pour les conditions relationnelles et l’indexation de tableaux. Parce que c’est juste VRAI ou FAUX, il a une taille de 1 octet.

     a = logical(1);
    
  • structure. Un tableau de structure est un type de données qui regroupe des variables de différents types de données à l’aide de conteneurs de données appelés champs. Chaque champ peut contenir n’importe quel type de données. Accéder aux données d’une structure à l’aide de la notation par points sous la forme structName.fieldName.

     field1 = 'first';
     field2 = 'second';
     value1 = [1 2 3 4 5];
     value2 = 'sometext';
     s = struct(field1,value1,field2,value2);
    
    In order to access value1, each of the following syntax are equivalent 
    
     s.first or s.(field1) or s.('first')
    We can explicitly access a field we know will exist with the first method, or either pass a string or create a string to access the field in the second example.  The third example is demostrating that the dot parenthases notation takes a string, which is the same one stored in the field1 variable.
    
  • les variables de table peuvent être de tailles et de types de données différents, mais toutes les variables doivent avoir le même nombre de lignes.

     Age = [15 25 54]';
     Height = [176 190 165]';
     Name = {'Mike', 'Pete', 'Steeve'}';
     T = table(Name,Age, Height);
    
  • cellule. C’est un type de données MATLAB très utile: le tableau de cellules est un tableau dont chaque élément peut être de type et de taille de données différents. C’est un instrument très puissant pour manipuler les données comme vous le souhaitez.

     a = { [1 2 3], 56, 'art'};
    

    or

     a = cell(3);
    
  • [function handles][6] stocke un pointeur vers une fonction (par exemple, vers une fonction anonyme). Il vous permet de passer une fonction à une autre fonction ou d’appeler des fonctions locales depuis l’extérieur de la fonction principale.

Il existe de nombreux instruments pour travailler avec chaque type de données et également des [fonctions de conversion de type de données][7] (str2double, table2cell).

Types de données supplémentaires

Il existe plusieurs types de données supplémentaires qui sont utiles dans certains cas spécifiques. Elles sont:

  • Date et heure : tableaux pour représenter les dates, l’heure et la durée. datetime('now') returns 21-Jul-2016 16:30:16.

  • Tableaux catégoriels : c’est un type de données pour stocker des données avec des valeurs provenant d’un ensemble de catégories discrètes. Utile pour stocker des données non numériques (mémoire efficace). Peut être utilisé dans un tableau pour sélectionner des groupes de lignes.

     a = categorical({'a' 'b' 'c'});
    
  • Les conteneurs de cartes sont une structure de données qui a la capacité unique d’indexer non seulement à travers les valeurs numériques scalaires mais le vecteur de caractères. Les indices dans les éléments d’une carte sont appelés clés. Ces clés, ainsi que les valeurs de données qui leur sont associées, sont stockées dans la carte.

  • Les [séries temporelles][8] sont des vecteurs de données échantillonnés dans le temps, dans l’ordre, souvent à intervalles réguliers. Il est utile de stocker les données liées aux pas de temps et il existe de nombreuses méthodes utiles pour travailler.

[1] : http://www.mathworks.com/help/matlab/matlab_prog/fundamental-matlab-classes.html [2] : http://www.mathworks.com/help/matlab/numeric-types.html [3] : http://www.mathworks.com/help/matlab/matlab_prog/floating-point-numbers.html [4] : http://www.mathworks.com/help/matlab/matlab_prog/integers.html [5] : http://www.mathworks.com/help/matlab/characters-and-strings.html [6] : http://www.mathworks.com/help/matlab/matlab_prog/creating-a-function-handle.html [7] : http://www.mathworks.com/help/matlab/data-type-conversion.html [8] : http://www.mathworks.com/help/matlab/ref/timeseries-class.html