MATLAB Language
Pour les boucles

Remarques

% Prints once: [3, 1]
my_vector = [1; 2; 3];
for i = my_vector
    display(size(i))
end

% Prints 1, 2, 3, 4, 5
for i = 1:5
    display(i)
    i = 5; % Fail at trying to terminate the loop
end

% Loops forever
for i = 1:1e50
end

% Crashes immediately
for i = [1:1e50]
end

Boucle 1 à n

Le cas le plus simple consiste simplement à préparer une tâche pour un nombre de fois déterminé. Disons que nous voulons afficher les nombres entre 1 et n, nous pouvons écrire:

n = 5;
for k = 1:n
    display(k)
end

La boucle exécutera les instructions internes, tout entre le for et le end , pour n fois (5 dans cet exemple):

1
2
3
4
5

Voici un autre exemple:

n = 5;
for k = 1:n
    disp(n-k+1:-1:1) % DISP uses more "clean" way to print on the screen
end

Cette fois, nous utilisons à la fois le n et le k dans la boucle pour créer un affichage "imbriqué":

 5     4     3     2     1

 4     3     2     1

 3     2     1

 2     1

 1

Itérer sur des éléments de vecteur

Le côté droit de l'affectation dans une boucle for peut être un vecteur de ligne. Le côté gauche de l'affectation peut être n'importe quel nom de variable valide. La boucle for assigne un élément différent de ce vecteur à la variable à chaque exécution.

other_row_vector = [4, 3, 5, 1, 2];
for any_name = other_row_vector
    display(any_name)
end

La sortie afficherait

4
3
5
1
2

(La version 1:n est un cas normal, car dans Matlab 1:n est juste la syntaxe pour construire un vecteur de ligne de [1, 2, ..., n] .)

Par conséquent, les deux blocs de code suivants sont identiques:

A = [1 2 3 4 5];
for x = A
  disp(x);
end

et

for x = 1:5
  disp(x);
end

Et ce qui suit sont identiques:

A = [1 3 5 7 9];
for x = A
  disp(x);
end

et

for x = 1:2:9
  disp(x);
end

Tout vecteur de ligne fera l'affaire. Ils n'ont pas besoin d'être des chiffres.

my_characters = 'abcde';
for my_char = my_characters
    disp(my_char)
end

va sortir

a
b
c
d
e

Itérer sur des colonnes de matrice

Si la partie droite de l'affectation est une matrice, la colonne se voit attribuer dans chaque itération les colonnes suivantes de cette matrice.

some_matrix = [1, 2, 3; 4, 5, 6]; % 2 by 3 matrix
for some_column = some_matrix
    display(some_column)
end

(La version vectorielle de ligne est un cas normal car, dans Matlab, un vecteur de ligne est simplement une matrice dont les colonnes sont de taille 1.)

La sortie afficherait

1
4
2
5
3
6

c'est-à-dire chaque colonne de la matrice itérée affichée, chaque colonne imprimée à chaque appel d' display .

Boucle sur les index

my_vector = [0, 2, 1, 3, 9];
for i = 1:numel(my_vector)
    my_vector(i) = my_vector(i) + 1;
end

Les opérations les plus simples réalisées avec for boucles peuvent être effectuées plus rapidement et plus facilement grâce aux opérations vectorisées. Par exemple, la boucle ci-dessus peut être remplacée par my_vector = my_vector + 1 .

Boucles imbriquées

Les boucles peuvent être imbriquées pour préformer une tâche itérée dans une autre tâche itérée. Considérons les boucles suivantes:

ch = 'abc';
m = 3;
for c = ch
    for k = 1:m
        disp([c num2str(k)]) % NUM2STR converts the number stored in k to a charachter,
                             % so it can be concataneted with the letter in c
    end
end

nous utilisons 2 itérateurs pour afficher toutes les combinaisons d'éléments abc et 1:m , ce qui donne:

a1
a2
a3
b1
b2
b3
c1
c2
c3

Nous pouvons également utiliser des boucles imbriquées pour combiner des tâches à effectuer à chaque fois et des tâches à effectuer une fois dans plusieurs itérations:

N = 10;
n = 3;
a1 = 0; % the first element in Fibonacci series
a2 = 1; % the secound element in Fibonacci series
for j = 1:N
    for k = 1:n
        an = a1 + a2; % compute the next element in Fibonacci series
        a1 = a2;      % save the previous element for the next iteration
        a2 = an;      % save ht new element for the next iteration
    end
    disp(an) % display every n'th element
end

Nous voulons ici pour calculer toutes les séries de Fibonacci , mais pour afficher uniquement le n ième élément à chaque fois, donc nous obtenons

   3
   13
   55
   233
   987
   4181
   17711
   75025
   317811
   1346269

Une autre chose que nous pouvons faire est d'utiliser le premier itérateur (externe) dans la boucle interne. Voici un autre exemple:

N = 12;
gap = [1 2 3 4 6];
for j = gap
    for k = 1:j:N
        fprintf('%d ',k) % FPRINTF prints the number k proceeding to the next the line
    end
    fprintf('\n')        % go to the next line
end

Cette fois, nous utilisons la boucle imbriquée pour formater la sortie et freiner la ligne uniquement lorsqu'un nouvel espace ( j ) entre les éléments a été introduit. Nous parcourons la largeur de l'intervalle dans la boucle externe et l'utilisons dans la boucle interne pour parcourir le vecteur:

1 2 3 4 5 6 7 8 9 10 11 12 
1 3 5 7 9 11 
1 4 7 10 
1 5 9 
1 7 

Remarque: Bizarrement, les mêmes boucles imbriquées.

Ce n'est pas quelque chose que vous verrez dans d'autres environnements de programmation. Je l'ai rencontré il y a quelques années et je ne comprenais pas pourquoi cela se passait, mais après avoir travaillé avec MATLAB pendant un certain temps, j'ai pu le comprendre. Regardez l'extrait de code ci-dessous:

for x = 1:10
    for x = 1:10
        fprintf('%d,', x);
    end
    fprintf('\n');
end

vous ne vous attendriez pas à ce que cela fonctionne correctement, mais en produisant la sortie suivante:

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

La raison en est que, comme avec tout le reste dans MATLAB, le compteur x est également une matrice - un vecteur pour être précis. En tant que tel, x n'est qu'une référence à un «tableau» (une structure de mémoire consécutive cohérente) qui est correctement référencé avec chaque boucle conséquente (imbriquée ou non). Le fait que la boucle imbriquée utilise le même identifiant ne fait aucune différence sur la façon dont les valeurs de ce tableau sont référencées. Le seul problème est que, dans la boucle imbriquée, le x externe est masqué par le x imbriqué (local) et ne peut donc pas être référencé. Cependant, la fonctionnalité de la structure de boucle imbriquée reste intacte.