MATLAB LanguageDémarrer avec MATLAB Language


Versions

Version Libération Date de sortie
1.0 1984-01-01
2 1986-01-01
3 1987-01-01
3.5 1990-01-01
4 1992-01-01
4.2c 1994-01-01
5.0 Volume 8 1996-12-01
5.1 Volume 9 1997-05-01
5.1.1 R9.1 1997-05-02
5.2 R10 1998-03-01
5.2.1 R10.1 1998-03-02
5.3 R11 1999-01-01
5.3.1 R11.1 1999-11-01
6,0 R12 2000-11-01
6.1 R12.1 2001-06-01
6,5 R13 2002-06-01
6.5.1 R13SP2 2003-01-01
6.5.2 R13SP2 2003-01-02
7 R14 2006-06-01
7.0.4 R14SP1 2004-10-01
7.1 R14SP3 2005-08-01
7.2 R2006a 2006-03-01
7.3 R2006b 2006-09-01
7.4 R2007a 2007-03-01
7.5 R2007b 2007-09-01
7.6 R2008a 2008-03-01
7.7 R2008b 2008-09-01
7.8 R2009a 2009-03-01
7,9 R2009b 2009-09-01
7.10 R2010a 2010-03-01
7.11 R2010b 2010-09-01
7.12 R2011a 2011-03-01
7.13 R2011b 2011-09-01
7.14 R2012a 2012-03-01
8.0 R2012b 2012-09-01
8.1 R2013a 2013-03-01
8.2 R2013b 2013-09-01
8.3 R2014a 2014-03-01
8.4 R2014b 2014-09-01
8.5 R2015a 2015-03-01
8.6 R2015b 2015-09-01
9.0 R2016a 2016-03-01
9.1 R2016b 2016-09-14
9.2 R2017a 2017-03-08

Voir aussi: Historique des versions de MATLAB sur Wikipedia .

Fonctions anonymes et poignées de fonction

Les bases

Les fonctions anonymes sont un outil puissant du langage MATLAB. Ce sont des fonctions qui existent localement, à savoir: dans l'espace de travail actuel. Cependant, ils n'existent pas sur le chemin MATLAB comme le ferait une fonction normale, par exemple 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 fonctions. 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 vers la fonction sin . Tout comme (dans la vraie vie) une poignée de porte est un moyen d'utiliser une porte, une poignée de fonction est un moyen d'utiliser une fonction. Pour utiliser f , les arguments lui sont transmis comme s'il s'agissait de la fonction sin :

>> f(pi/2)
ans =
     1
 

f accepte tous les arguments en entrée que la fonction sin accepte. Si sin était une fonction qui accepte des arguments d'entrée nuls (ce qui n'est pas le cas, mais que 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 pour 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 effectuent des tâches personnalisées qui, autrement, devraient être répétées plusieurs fois ou créer une fonction distincte pour. Comme exemple d'une fonction anonyme personnalisée qui accepte une variable en entrée, additionnez le carré sinus et le cosinus d'un signal:

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

Maintenant, f accepte un argument appelé x . Cela a été spécifié en utilisant des parenthèses (...) directement après l'opérateur @ . f maintenant est 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 peut également être transmis à f , du moment 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 plus d'une variable

De la même manière, des fonctions anonymes peuvent être créées pour accepter plusieurs variables. 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. Ceci s'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) 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 à des variables d'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, ils sont traités comme des variables différentes dans la portée de la fonction anonyme, à savoir: 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 ceci:

>> 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 dans l'espace de travail principal n'est pas utilisée dans f . En outre, dans l'espace de travail principal, x n'a pas été modifié. Dans le cadre de f , les noms de variable entre parenthèses après l'opérateur @ sont indépendants des variables principales 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 sur une fonction anonyme) est stockée comme toute autre valeur dans l'espace de travail actuel: 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 toute autre valeur. Lorsque vous le stockez dans une variable, il porte un nom dans l’espace de travail actuel et peut être modifié et effacé comme les variables contenant des numéros.

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

Utilisation avancée

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

Les descripteurs de fonctions étant traités comme des variables, ils peuvent être transmis à des fonctions qui acceptent les descripteurs de fonctions en tant qu'arguments d'entrée.

Un exemple: Une fonction est créée dans un fichier m qui accepte un handle de fonction et un nombre scalaire. Il appelle ensuite le handle de fonction en lui passant 3 , puis ajoute le numéro 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 exemple dans le dossier actuel de MATLAB. Maintenant, 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 transmis à funHandleDemo :

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

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

Utilisation de fonctions bsxfun , cellfun et similaires avec des fonctions anonymes

MATLAB a des fonctions intégrées qui acceptent les 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 qu'il applique une fonction sur deux vecteurs ou matrices d'une manière élément par élément. Normalement, cela nécessiterait l'utilisation de for -loops, qui nécessite souvent une préallocation pour la vitesse. En utilisant bsxfun ce processus est accéléré. L'exemple suivant illustre ceci 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 matrice par rapport à la moyenne de la colonne de 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 se traduit par 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. @minus est un nom long pour la même opération que ferait le signe moins. Une fonction ou un descripteur anonyme ( @ ) différent de toute autre fonction aurait pu être spécifié, à condition qu'il accepte A et mean(A) comme entrées pour générer un résultat significatif.

Surtout pour les grandes quantités de données dans les grandes matrices, bsxfun peut accélérer les choses. Cela rend aussi 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.)

Réseaux de cellules

Les éléments de la même classe peuvent souvent être concaténés en tableaux (à quelques rares exceptions près, par exemple les descripteurs de fonctions). 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 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' , il ne s'agit que d'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 de plusieurs chaînes différentes. C'est là que le tableau de cell est utile. Il s'agit d'un tableau de cellules pouvant contenir chacun 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 d'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 le dernier retourne le contenu de la cellule (et a par exemple la classe double in out), le premier retourne 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 la cell . Et la syntaxe C{1:2} n'a pas un seul objet retourné, mais il 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
 

Types de données

Il existe 16 types de données fondamentaux , ou classes, dans MATLAB. Chacune de ces classes est sous la forme d'une matrice ou d'un tableau. À l'exception des descripteurs de fonctions, 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).

Un moment important dans MATLAB est que vous n'avez pas besoin d'utiliser une déclaration de type ou des instructions de dimension par défaut. Lorsque vous définissez une nouvelle variable, MATLAB la crée automatiquement et alloue un 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 une nouvelle 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 :

  • Nombre à virgule flottante ( par défaut )

    MATLAB représente des 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 créer n'importe quelle précision simple avec une fonction de conversion simple:

    a = 1.23;
    b = single(a);
    
    >> whos
      Name      Size            Bytes  Class     Attributes
    
      a         1x1                 8  double              
      b         1x1                 4  single     
     
  • Entiers

    MATLAB a quatre classes d'entiers signés et quatre non signés. Les types signés vous permettent de travailler avec des entiers négatifs aussi bien que 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 plus grande gamme de nombres, mais ces nombres ne peuvent être que zéro ou positifs.

    MATLAB prend en charge le stockage à 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 d'entier adapté à 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 la forme d'un nombre entier, vous devez convertir du type double au type 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 égale à 0.5 , MATLAB choisit, à partir des deux entiers également voisins, celui pour lequel la valeur absolue est la plus grande.

    a  = int16(456);
     
  • char

    Les tableaux de caractères fournissent un stockage pour les données de texte 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 true et false. Utilisez pour les conditions relationnelles et l'indexation de tableau. Parce qu'il 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 dans une structure en utilisant la notation par points de la forme structName.fieldName.

    field1 = 'first';
    field2 = 'second';
    value1 = [1 2 3 4 5];
    value2 = 'sometext';
    s = struct(field1,value1,field2,value2);
     

    Pour accéder à value1, chacune des syntaxes suivantes est équivalente

    s.first or s.(field1) or s.('first')
     

    Nous pouvons explicitement accéder à un champ dont nous savons qu’il existera avec la première méthode, ou bien passer une chaîne ou créer une chaîne pour accéder au champ dans le deuxième exemple. Le troisième exemple montre que la notation par points est une chaîne, qui est la même que celle stockée dans la variable field1.

  • 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 avoir un type et une 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'};
     

    ou

    a = cell(3);
     
  • la fonction gère stocke un pointeur sur une fonction (par exemple, une fonction anonyme). Cela vous permet de passer une fonction à une autre fonction ou d'appeler des fonctions locales en dehors de la fonction principale.

Il y a beaucoup d'instruments à str2double avec chaque type de données et également des fonctions de conversion de type de données intégrées ( str2double , table2cell ).

Types de données supplémentaires

Plusieurs types de données supplémentaires sont utiles dans certains cas spécifiques. Elles sont:

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

  • Tableaux catégoriels: il s'agit d'un type de données permettant de 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 par le biais de toutes les valeurs numériques scalaires, mais également par le biais du 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 chronologiques 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 connectées avec des horodatages et de nombreuses méthodes utiles à utiliser.

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 barre d'outils et en cliquant sur Nouveau script). Le raccourci clavier par défaut pour créer un nouveau script est Ctrl-n .

Alternativement, en tapant edit myscriptname.m ouvrira le fichier myscriptname.m pour le modifier, 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 Editeur de la barre d'outils, puis cliquez sur Enregistrer sous. Enregistrez le document dans un fichier du répertoire en cours 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, tapez 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 lancé le script "helloworld". Notez que taper l'extension ( .m ) est inutile. Les instructions contenues dans le fichier de script sont exécutées par MATLAB, 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.

Vous aider

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. Pour obtenir des informations sur une fonction que vous souhaitez utiliser, tapez: help functionname dans la ligne de commande. Prenons la fonction d' help comme exemple.

L'information sur la façon de l'utiliser peut être obtenue en tapant:

>> help help

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

>> doc help

dans la fenêtre de commande. Cela ouvrira la documentation navigable sur la page d' help aux fonctions fournissant toutes les informations dont vous avez besoin pour comprendre comment fonctionne 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 laisser leur propre section d'aide en ajoutant des commentaires en haut du fichier de fonction ou juste après la déclaration de 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 prenez votre code semaines / mois / années après l'avoir écrit.

La fonction d' help et de doc fournit de nombreuses informations, apprendre à utiliser ces fonctionnalités vous aidera à progresser rapidement et à utiliser efficacement MATLAB.

Matrices d'indexation et tableaux

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

  • Indexation des indices - où vous spécifiez séparément la position des éléments que vous souhaitez dans chaque dimension de la matrice.
  • 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 dimensions identiques de 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 à l' aide de la matrice 3 par 3 suivant M comme exemple:

>> M = magic(3)

ans = 

       8    1    6
       3    5    7
       4    9    2
 

Indexation des indices

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

>> M(2, 3)

ans =

      7
 

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

Notez que l'ordre des indices est identique à la convention mathématique: l'index de ligne est le premier. De plus, les indices MATLAB commencent par 1 et non 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éé en utilisant l'opérateur deux-points, c'est-à-dire 1:3 . Vous pouvez également l'utiliser pour l'indexation. Pour sélectionner toute une ligne (ou colonne), Matlab fournit un raccourci en vous permettant de spécifier simplement : . 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 utiliser ce qui suit:

>> M(2, 2:end)

ans =

       5    7
 

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

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

       3    7
       4    2
 

Par exemple, l'indexation des indices ne peut extraire que les éléments M(2,1) ou M(3,3) . Pour ce faire, il faut envisager 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 en ordre majeur dans MATLAB, ce qui signifie que vous accédez aux éléments en commençant par 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 en indice en indices linéaires, et inversement: sub2ind et ind2sub 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, l'index linéaire sera simplement l'indice 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, à savoir 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 retournée aura la même forme que la matrice des vecteurs d'index.

M(2:4) renvoie un vecteur de ligne car 2:4 représente le vecteur de 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 convaincre:

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

ans =

       8        3
       4        1
 

Notez que l'indexation avec : alone renverra toujours un vecteur de colonne:

>> M(:)

ans = 

        8
        3
        4
        1
        5
        9
        6
        7
        2
 

Cet exemple illustre également l'ordre dans lequel MATLAB renvoie des é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 false valeurs true ou false , comme masque pour filtrer les éléments que 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 numéros restent en place (c.-à-d. Gardez la forme de la matrice), vous pouvez attribuer au complément logique

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

ans = 

    8      NaN    6
    NaN    NaN    7
    NaN    9      Nan
 

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

Prenez le non vectorisé (déjà raccourci en 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 à l'aide de l'indexation logique:

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

Ou même plus court:

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

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 se déplacera que sur la deuxième tranche après toutes les lignes et toutes les colonnes de la première tranche. Donc, l’index linéaire pour cet élément est

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

En fait, dans MATLAB, chaque matrice est une dimension n: il se trouve que la taille de la plupart des autres dimensions n est une. Donc, si a = 2 alors a(1) == 2 (comme on peut s’attendre), mais aussi a(1, 1) == 2 , comme le fait 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 cotes singleton . La commande squeeze les supprimera, et on pourra 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 d'un m indices (où m <= n). La règle est que les premiers indices m-1 se comportent normalement, tandis que le dernier indice (m'th) référence les dimensions restantes (n-m + 1), tout comme un index linéaire ferait référence à une dimension (n-m + 1). tableau. 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
 

Retour des plages d'éléments

Avec l'indexation des indices, 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 retournera é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) (note A maintenant 20 - par 20 ), où vous voulez obtenir la quadrant supérieur droit. Dans ce cas, au lieu d'avoir à spécifier chaque paire de coordonnées dans ce quadrant (et ce serait 100 paires), il vous suffit de spécifier les 10 lignes et les 10 colonnes que vous souhaitez. A(1:10, 11:end) . Trancher une matrice comme celle-ci est beaucoup plus courant que de demander 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'index de colonne que vous souhaitez retourner, où chaque ligne du vecteur contient le numéro de colonne que vous souhaitez renvoyer pour la ligne correspondante de la matrice. Par exemple

colIdx = [3;2;1]
 

Donc, dans ce cas, vous voulez récupérer les éléments en (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 linéaire et en indice, vous pouvez également renvoyer plusieurs fois un élément en répétant son index

>> 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 .

Matrices et tableaux

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

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

Pour créer un vecteur de ligne, entrez les éléments entre crochets, 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 de 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 entrons 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, nous utilisons le .' -operator, ou le ' opérateur de prendre son conjugué hermitien, qui est le conjugué complexe de sa transposée. Pour les vraies matrices, 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 des ones , des zeros , des 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]);
 

Lecture d'entrée et écriture

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. Cochez ici pour voir la liste complète des formats de fichiers pris en charge et leur fonction.

Avant d'essayer de charger votre fichier, vous devez vous demander ce que vous voulez que les données deviennent et comment vous attendez que l'ordinateur organise les données pour vous. Supposons que vous avez 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 dans le format de chaînes, tandis que la deuxième, troisième, est numérique, la dernière colonne est sous la forme de devise. Disons que nous voulons trouver combien de revenus nous avons fait aujourd'hui en utilisant Matlab et que nous voulons d'abord charger dans ce fichier txt / csv. Après avoir vérifié le lien, nous pouvons voir que les types de fichiers txt String et Numeric sont gérés par textscan . Nous pourrions donc 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 un type String, %f suggère que l'élément est un type Float et que le fichier est délimité par ",". L'option HeaderLines demande à Matlab d'ignorer les N premières lignes tandis que le 1 immédiatement après signifie de sauter la première ligne (la ligne d'en-tête).

Maintenant, C est la donnée que nous avons chargée et qui se présente sous la forme d'un tableau de 4 cellules, chacune contenant la colonne de données du 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é, donc nous devons 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. du signe "$", il y a plusieurs façons de le faire. La manière la plus directe consiste à utiliser une simple expression régulière:

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 a les signes "$" en types numériques et cell2mat transforme la cellule des éléments numériques en une matrice de nombres

Maintenant, nous pouvons multiplier les unités vendues par le coût par unité:

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

totalrevenue = sum(revenue);
 

Scripts et fonctions

Le code MATLAB peut être enregistré dans les fichiers m pour être réutilisé. Les fichiers m ont l'extension .m qui est automatiquement associée à MATLAB. Un fichier m peut contenir un script ou 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 les entrées et les scripts ne renvoient pas 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 la length , la width et la area dans l'espace de travail actuel avec la valeur 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, par rapport aux scripts, sont beaucoup plus flexibles et extensibles. Contrairement aux scripts, les fonctions peuvent accepter les entrées et les renvoyer à l'appelant. Une fonction a son propre espace de travail, cela signifie que les opérations internes des fonctions ne modifieront 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)
 

Suivant est le nom de la fonction qui sera utilisée pour l'appel. C'est généralement le même nom que le nom de fichier. Par exemple, nous enregistrerions cette fonction sous le nom myFunctionName.m .

Le nom de la fonction suit la liste des entrées. Comme les sorties, il peut également s'agir d'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 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.