MATLAB Language
छोरों के लिए

टिप्पणियों

% 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

लूप 1 से एन

सबसे सरल मामला एक निश्चित ज्ञात संख्या के लिए किसी कार्य को पूर्ववर्ती करना है। कहें कि हम 1 से n के बीच की संख्याओं को प्रदर्शित करना चाहते हैं, हम लिख सकते हैं:

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

लूप आंतरिक विवरण (यों) को निष्पादित करेगा, इसके for और end बीच सब कुछ, n समय के लिए (इस उदाहरण में 5):

1
2
3
4
5

यहाँ एक और उदाहरण है:

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

इस बार हम " n नेस्ट" डिस्प्ले बनाने के लिए n और k दोनों को लूप में उपयोग करते हैं:

 5     4     3     2     1

 4     3     2     1

 3     2     1

 2     1

 1

वेक्टर के तत्वों पर Iterate

दाएँ हाथ के एक में काम के पक्ष for पाश किसी भी पंक्ति वेक्टर हो सकता है। असाइनमेंट का बायाँ भाग किसी भी मान्य चर नाम का हो सकता है। प्रत्येक रन के for लूप के for इस वेक्टर का एक अलग तत्व प्रदान करता है।

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

आउटपुट प्रदर्शित करेगा

4
3
5
1
2

( 1:n संस्करण इसका एक सामान्य मामला है, क्योंकि Matlab 1:n में [1, 2, ..., n] पंक्ति वेक्टर के निर्माण के लिए सिर्फ वाक्यविन्यास है।)

इसलिए, कोड के दो निम्नलिखित ब्लॉक समान हैं:

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

तथा

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

और निम्नलिखित समान हैं:

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

तथा

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

कोई भी रो वेक्टर करेगा। उन्हें नंबर नहीं होना चाहिए।

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

उत्पादन होगा

a
b
c
d
e

मैट्रिक्स के कॉलम पर फेरबदल करें

यदि असाइनमेंट का दाहिना हाथ एक मैट्रिक्स है, तो प्रत्येक पुनरावृत्ति में चर को इस मैट्रिक्स के बाद के कॉलम सौंपे जाते हैं।

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

(पंक्ति वेक्टर संस्करण इसका एक सामान्य मामला है, क्योंकि मतलब में एक पंक्ति वेक्टर सिर्फ एक मैट्रिक्स है जिसके कॉलम आकार में हैं)

आउटपुट प्रदर्शित करेगा

1
4
2
5
3
6

अर्थात् प्रदर्शित मैट्रिक्स के प्रत्येक स्तंभ, प्रत्येक कॉल display प्रत्येक कॉल पर मुद्रित display ।

अनुक्रमित पर लूप

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

अधिकांश साधारण चीजें साथ किया for छोरों तेज और आसान vectorized आपरेशन द्वारा किया जा सकता। उदाहरण के लिए, उपरोक्त लूप को my_vector = my_vector + 1 द्वारा प्रतिस्थापित किया जा सकता है।

स्थिर फंदा

लूप्स को किसी अन्य पुनरावृत्त कार्य के भीतर पुनरावृत्त कार्य के लिए, नेस्टेड किया जा सकता है। निम्नलिखित छोरों पर विचार करें:

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

हम 2 पुनरावृत्तियों का उपयोग abc और 1:m से तत्वों के सभी संयोजनों को प्रदर्शित करने के लिए करते हैं:

a1
a2
a3
b1
b2
b3
c1
c2
c3

हम प्रत्येक बार किए जाने वाले कार्यों के बीच संयोजन के लिए नेस्टेड लूप का उपयोग भी कर सकते हैं, और कई पुनरावृत्तियों में एक बार किए जाने वाले कार्य:

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

यहां हम सभी फाइबोनैचि श्रृंखला की गणना करना चाहते हैं, लेकिन हर बार केवल n वें तत्व को प्रदर्शित करने के लिए, इसलिए हम प्राप्त करते हैं

   3
   13
   55
   233
   987
   4181
   17711
   75025
   317811
   1346269

एक और चीज जो हम कर सकते हैं वह है कि आंतरिक लूप के भीतर पहले (बाहरी) पुनरावृत्त का उपयोग करना। यहाँ एक और उदाहरण है:

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

इस बार हम आउटपुट को प्रारूपित करने के लिए नेस्टेड लूप का उपयोग करते हैं, और लाइन को ब्रेक तभी करते हैं जब तत्वों के बीच एक नया अंतर ( j ) पेश किया गया था। हम बाहरी लूप में अंतराल चौड़ाई के माध्यम से लूप करते हैं और वेक्टर के माध्यम से पुनरावृति करने के लिए आंतरिक लूप के भीतर इसका उपयोग करते हैं:

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 

सूचना: एक ही काउंटर नेस्टेड छोरों।

यह कुछ ऐसा नहीं है जिसे आप अन्य प्रोग्रामिंग वातावरण में देखेंगे। मैं कुछ साल पहले इसके पार आया था और मुझे समझ नहीं आया कि ऐसा क्यों हो रहा है, लेकिन कुछ समय तक MATLAB के साथ काम करने के बाद मुझे यह पता चला। नीचे दिए गए कोड स्निपेट को देखें:

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

आप इसे ठीक से काम करने की उम्मीद नहीं करेंगे, लेकिन यह निम्न आउटपुट का उत्पादन करता है:

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,

कारण यह है कि, MATLAB में सब कुछ के साथ के रूप में, x काउंटर भी एक मैट्रिक्स है - सटीक होने के लिए एक वेक्टर। जैसे, x केवल एक 'व्यूह' (एक सुसंगत, लगातार स्मृति संरचना) का संदर्भ है जो कि प्रत्येक परिणामी लूप (नेस्टेड या नहीं) के साथ संदर्भित विनियोगात्मक है। तथ्य यह है कि नेस्टेड लूप एक ही पहचानकर्ता का उपयोग करता है, इससे कोई फर्क नहीं पड़ता कि उस सरणी से मान कैसे संदर्भित किए जाते हैं। एकमात्र समस्या यह है कि नेस्टेड लूप के भीतर बाहरी x नेस्टेड (स्थानीय) x द्वारा छिपा हुआ है और इसलिए इसे संदर्भित नहीं किया जा सकता है। हालाँकि, नेस्टेड लूप संरचना की कार्यक्षमता बरकरार है।