MATLAB Language
Für Schleifen

Bemerkungen

% 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

Schleife 1 bis n

Der einfachste Fall ist das Vorbereiten einer Aufgabe für eine festgelegte Anzahl von Malen. Angenommen, wir möchten die Zahlen zwischen 1 und n anzeigen, können wir schreiben:

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

Die Schleife führt die inneren Anweisungen (alles) zwischen dem for und dem end n mal aus (in diesem Beispiel 5):

1
2
3
4
5

Hier ist ein anderes Beispiel:

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

Dieses Mal verwenden wir sowohl n als auch k in der Schleife, um eine "verschachtelte" Anzeige zu erstellen:

 5     4     3     2     1

 4     3     2     1

 3     2     1

 2     1

 1

Über Elemente des Vektors iterieren

Die rechte Seite der Zuweisung in einer for Schleife kann ein beliebiger Zeilenvektor sein. Die linke Seite der Zuweisung kann ein beliebiger gültiger Variablenname sein. Die for Schleife weist der Variablen bei jedem Lauf ein anderes Element dieses Vektors zu.

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

Die Ausgabe würde angezeigt

4
3
5
1
2

(Die 1:n Version ist ein normaler Fall, da in Matlab 1:n nur die Syntax für die Konstruktion eines Zeilenvektors von [1, 2, ..., n] .)

Daher sind die beiden folgenden Codeblöcke identisch:

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

und

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

Und das Folgende ist auch identisch:

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

und

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

Jeder Zeilenvektor reicht aus. Sie müssen keine Zahlen sein.

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

wird ausgegeben

a
b
c
d
e

Iteriere über Spalten der Matrix

Wenn die rechte Seite der Zuweisung eine Matrix ist, werden der Variablen in jeder Iteration nachfolgende Spalten dieser Matrix zugewiesen.

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

(Die Zeilenvektorversion ist ein normaler Fall, da in Matlab ein Zeilenvektor nur eine Matrix ist, deren Spalten die Größe 1 haben.)

Die Ausgabe würde angezeigt

1
4
2
5
3
6

dh jede Spalte der angezeigten iterierten Matrix wird bei jedem Aufruf der display gedruckt.

Schleife über Indizes

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

Die einfachsten Dinge, die mit for Schleifen erledigt werden, können durch vektorisierte Operationen schneller und einfacher erledigt werden. Zum Beispiel kann die obige Schleife durch my_vector = my_vector + 1 .

Verschachtelte Loops

Schleifen können verschachtelt werden, um eine iterierte Task innerhalb einer anderen iterierten Task vorzuführen. Betrachten Sie die folgenden Schleifen:

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

Wir verwenden 2 Iteratoren, um alle Elementkombinationen von abc und 1:m anzuzeigen. abc ergibt:

a1
a2
a3
b1
b2
b3
c1
c2
c3

Wir können auch verschachtelte Schleifen verwenden, um zwischen jeweils zu erledigenden Aufgaben und einmal in mehreren Durchläufen zu erledigenden Aufgaben zu kombinieren:

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

Hier wollen wir alle Fibonacci-Serien berechnen, aber jedes Mal nur das n te Element anzeigen, also erhalten wir

   3
   13
   55
   233
   987
   4181
   17711
   75025
   317811
   1346269

Eine andere Möglichkeit ist, den ersten (äußeren) Iterator innerhalb der inneren Schleife zu verwenden. Hier ist ein anderes Beispiel:

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

Diesmal verwenden wir die verschachtelte Schleife, um die Ausgabe zu formatieren, und bremsen die Linie nur, wenn eine neue Lücke ( j ) zwischen den Elementen eingeführt wurde. Wir durchlaufen die Lückenbreite in der äußeren Schleife und verwenden sie innerhalb der inneren Schleife, um den Vektor zu durchlaufen:

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 

Hinweis: Seltsame gleiche verschachtelte Gegenschleifen.

Dies wird in anderen Programmierumgebungen nicht angezeigt. Ich bin vor einigen Jahren darauf gestoßen und konnte nicht verstehen, warum es passiert ist, aber nachdem ich einige Zeit mit MATLAB zusammengearbeitet hatte, konnte ich es herausfinden. Sehen Sie sich den Code-Ausschnitt unten an:

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

Sie würden nicht erwarten, dass dies richtig funktioniert, aber es liefert folgende Ausgabe:

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,

Der Grund ist, dass der x Zähler wie alles andere in MATLAB auch eine Matrix ist - ein Vektor, um genau zu sein. Somit ist x nur ein Verweis auf ein "Array" (eine zusammenhängende, aufeinanderfolgende Speicherstruktur), auf das in jeder nachfolgenden Schleife (verschachtelt oder nicht) entsprechend verwiesen wird. Die Tatsache, dass die verschachtelte Schleife denselben Bezeichner verwendet, hat keinen Einfluss darauf, wie auf Werte aus diesem Array verwiesen wird. Das einzige Problem ist, dass das äußere x in der verschachtelten Schleife durch das verschachtelte (lokale) x ausgeblendet wird und daher nicht referenziert werden kann. Die Funktionalität der geschachtelten Schleifenstruktur bleibt jedoch erhalten.