while Loops, break and continueخولەکانی while، break و continue

A for loop is the right tool when you know the number of turns: ten marks, five terms of a series. Very often you do not know it in advance. Keep asking until the user types a negative number. Keep doubling until the amount passes 1000. Keep halving until the answer is accurate enough. For jobs like these MATLAB has the While loop: it repeats a block of code as long as a condition is true and stops the first time the condition is false.

خولی for ئامرازی گونجاوە کاتێک ژمارەی جارەکان دەزانیت: دە نمرە، پێنج بڕگەی زنجیرەیەک. بەڵام زۆر جار ئەو ژمارەیە پێشوەختە نازانیت. بپرسە تا بەکارهێنەر (User) ژمارەیەکی سالب (Negative number) دەنووسێت. دوو هێندە بکە تا بڕەکە لە ⁦1000⁩ تێدەپەڕێت. نیوە بکە تا وەڵامەکە بەس وردە. بۆ کاری لەم جۆرە MATLAB خولی whileـی هەیە: بلۆکێک کۆد دووبارە دەکاتەوە مادام مەرجەکە ڕاست بێت و یەکەم جار کە مەرجەکە هەڵە بوو، دەوەستێت.

Repetition is the same idea in every language (see the building blocks of algorithms); this lesson teaches MATLAB's form, break and continue. Every program here also runs in GNU Octave (free) and in the free version of MATLAB Online. A first example with new numbers: a lab sample starts with 3 cells and the number doubles every hour. After how many hours are there more than 1000 cells?

دووبارەکردنەوە لە هەموو زمانێکدا هەمان بیرۆکەیە (بڕوانە بەردە بناغەکانی ئەلگۆریزمەکان)؛ ئەم وانەیە شێوەی MATLAB و break و continue فێر دەکات. هەموو بەرنامەکانی ئەم وانەیە لە ⁦GNU Octave⁩ (بەخۆڕایی) و وەشانی بەخۆڕایی ⁦MATLAB Online⁩ـیش کار دەکەن. یەکەم نموونە بە ژمارەی نوێ: نموونەیەکی تاقیگە بە 3 خانە دەست پێدەکات و ژمارەکەی هەموو کاتژمێرێک دوو هێندە دەبێت. دوای چەند کاتژمێر زیاتر لە ⁦1000⁩ خانە هەیە؟

The form is short: the keyword while, a condition, the statements to repeat, and end.

شێوەکەی کورتە: وشەی کلیلەیی (Keyword) while، مەرجێک، ڕستەکانی (Statement) ناو خولەکە کە دووبارە دەبنەوە و end.

Two consequences. First, if the condition is false the very first time, the body runs zero times — with amount = 2000; in the example above, hours stays 0. Second, the condition follows the same truth rule as if: it is true only when it is not empty and every element is nonzero. A vector condition such as while v > 0 therefore means while all elements are positive; write all(…) or any(…) to say what you mean (see when the condition is an array). Join conditions with && and || (logical operators).

دوو ئەنجام. یەکەم، ئەگەر مەرجەکە لە یەکەم جاردا هەڵە بێت، جەستەکە سفر جار جێبەجێ دەبێت — بە amount = 2000; لە نموونەکەی سەرەوەدا، hours بە 0 دەمێنێتەوە. دووەم، مەرجەکە پەیڕەوی هەمان یاسای ڕاستیی if دەکات: تەنها کاتێک ڕاستە کە بەتاڵ نەبێت و هەموو توخمەکانی (Element) ناسفر بن. بۆیە مەرجێکی ئاڕاستەبڕ وەک while v > 0 واتە مادام هەموو توخمەکان موجەبن؛ all(…) یان any(…) بنووسە بۆ ئەوەی مەبەستەکەت ڕوون بێت (بڕوانە کاتێک مەرج ڕیزەکێکە). مەرجەکان بە && و || پێکەوە ببەستە (کارپێکەرە لۆجیکییەکان).

A while loop that works always has three parts. Two of them are easy to see; the third is the one people forget.

خولێکی while کە بە دروستی کار دەکات هەمیشە سێ بەشی هەیە. دووانیان بە ئاسانی دەبینرێن؛ سێیەمیان ئەوەیە کە خەڵک لە بیری دەکەن.

The change must also go in the right direction. amount = amount/2; changes the amount, but it moves it away from 1000, so the condition stays true for ever. When you write a while loop, point at the line that will one day make the condition false. If you cannot find that line, the loop has a bug.

گۆڕانەکە دەبێت بە ئاڕاستەی دروستیش بڕوات. amount = amount/2; بڕەکە دەگۆڕێت، بەڵام لە ⁦1000⁩ دووری دەخاتەوە، بۆیە مەرجەکە بۆ هەمیشە ڕاست دەمێنێتەوە. کاتێک خولێکی while دەنووسیت، ئاماژە بەو دێڕە بکە کە ڕۆژێک مەرجەکە هەڵە دەکات. ئەگەر نەتتوانی ئەو دێڕە بدۆزیتەوە، خولەکە باگی تێدایە.

This program comes from the course's lab sheet (re-typed; the bug is kept on purpose). It should add ten terms of a series with alternating signs: J flips between 1 and −1, and pow takes the odd powers 1, 3, 5, … Read it and look for the three parts of the loop.

ئەم بەرنامەیە لە پەڕەی تاقیگەی کۆرسەکەوە هاتووە (دووبارە نووسراوەتەوە؛ باگەکە بە مەبەست هێڵراوەتەوە). دەبێت دە بڕگەی زنجیرەیەک بە هێمای گۆڕاو کۆ بکاتەوە: J لە نێوان 1 و $-1$دا دەگۆڕێت و pow توانە تاکەکانی 1، 3، 5، … وەردەگرێت. بیخوێنەرەوە و بەدوای سێ بەشەکەی خولەکەدا بگەڕێ.

counter starts at 1 and nothing inside the loop changes it, so counter <= 10 is true at every test. The loop is an Infinite loop: MATLAB keeps working, never reaches disp(y), and the >> prompt does not come back. The value of y even settles near 0.2499 after a few turns, which makes the bug sneaky — the number is right, but the program never stops to show it.

counter بە 1 دەست پێدەکات و هیچ شتێک لەناو خولەکەدا نایگۆڕێت، بۆیە counter <= 10 لە هەموو تاقیکردنەوەیەکدا ڕاستە. خولەکە خولێکی بێکۆتایە: MATLAB بەردەوام کار دەکات، هەرگیز ناگاتە disp(y) و >> ناگەڕێتەوە. نرخی y تەنانەت دوای چەند جارێک لە نزیک ⁦0.2499⁩ جێگیر دەبێت، ئەمەش باگەکە فێڵاوی دەکات — ژمارەکە دروستە، بەڵام بەرنامەکە هەرگیز ناوەستێت بۆ ئەوەی پیشانی بدات.

When a program seems stuck, click in the Command Window and press Ctrl+C (hold Ctrl, press C). MathWorks' page on while gives exactly this advice for a loop that never ends on its own. MATLAB stops the program, prints a short message about the interruption, and the >> prompt returns. The same keyboard shortcut works in Octave and in MATLAB Online. On a Mac it is also Ctrl+C, not Cmd+C.

کاتێک بەرنامەیەک وا دیارە گیری خواردووە، لە ⁦Command Window⁩ کلیک بکە و ⁦Ctrl+C⁩ دابگرە (Ctrl ڕابگرە و C دابگرە). پەڕەی MathWorks دەربارەی while ڕێک ئەم ئامۆژگارییە بۆ خولێک دەدات کە خۆی هەرگیز کۆتایی نایەت. MATLAB بەرنامەکە دەوەستێنێت، پەیامێکی کورت دەربارەی پچڕاندنەکە چاپ دەکات و >> دەگەڕێتەوە. هەمان کورتەڕێی کیبۆرد (Keyboard shortcut) لە Octave و ⁦MATLAB Online⁩ـیشدا کار دەکات. لەسەر Macـیش ⁦Ctrl+C⁩ـە، نەک ⁦Cmd+C⁩.

With the change in place the loop runs exactly ten times and adds

بە بوونی گۆڕانەکە خولەکە ڕێک دە جار جێبەجێ دەبێت و ئەمە کۆ دەکاتەوە

Notice that this loop has a fixed number of turns (ten), so a for loop is the more natural choice: for k = 0:9 changes k by itself and cannot forget its change. While loops are for the cases where the number of turns is unknown — the next screens show them.

سەرنج بدە کە ئەم خولە ژمارەیەکی جێگیری جاری هەیە (دە)، بۆیە خولی for (for loop) هەڵبژاردنێکی سروشتیترە: for k = 0:9 خۆی k دەگۆڕێت و ناتوانێت گۆڕانەکەی لە بیر بکات. خولەکانی while بۆ ئەو حاڵەتانەن کە ژمارەی جارەکان نەزانراوە — شاشەکانی داهاتوو پیشانیان دەدەن.

Lab program 4 has the same missing counter = counter + 1;. With the fix it adds ten factorials with alternating signs, 1!, 5!, 9!, …, 37! (seq grows by 4 each turn):

بەرنامەی 4ـی تاقیگە هەمان counter = counter + 1;ـی ونبووی هەیە. بە چاککردنەکە دە فاکتۆریێل بە هێمای گۆڕاو کۆ دەکاتەوە، ⁦1!⁩، ⁦5!⁩، ⁦9!⁩، …، ⁦37!⁩ (seq هەموو جارێک 4 زیاد دەکات):

The exact answer is a whole number with 44 digits: $-13\,763\,744\,407\,917\,567\,980\,912\,064\,812\,596\,549\,260\,002\,039$. MATLAB cannot hold it. A double stores every whole number exactly only up to $2^{53}\approx 9.007\times 10^{15}$; MathWorks' page on factorial says the result is exact for $n \le 21$ and above that is right only in its first 15 digits. So MATLAB's −1.3764e+43 is a rounded answer: correct in its leading digits, wrong in the last ones. Read more in round-off, factorial and what computers cannot do exactly.

وەڵامە وردەکە ژمارەیەکی تەواوە (Integer) بە ⁦44⁩ تاکژمارە (Digit): $-13\,763\,744\,407\,917\,567\,980\,912\,064\,812\,596\,549\,260\,002\,039$. MATLAB ناتوانێت هەڵیبگرێت. double هەموو ژمارەیەکی تەواو تەنها تا $2^{53}\approx 9.007\times 10^{15}$ بە وردی هەڵدەگرێت؛ پەڕەی MathWorks دەربارەی factorial دەڵێت ئەنجامەکە بۆ $n \le 21$ وردە و لەوە زیاتر تەنها لە ⁦15⁩ تاکژمارەی یەکەمیدا دروستە. بۆیە ⁦−1.3764e+43⁩ـی MATLAB وەڵامێکی نزیککراوەیە: لە تاکژمارە سەرەتاییەکانیدا دروستە، لە کۆتاییەکانیدا هەڵەیە. زیاتر بخوێنەرەوە لە هەڵەی نزیککردنەوە، فاکتۆریێل و ئەوەی کۆمپیوتەر ناتوانێت بە وردی بیکات.

Lab program 3 reads a number, prints its factorial, and reads again — until the user types a negative number. The negative number is not data; it is a signal that means stop. Programmers call such a value a Sentinel value. Nobody knows in advance how many numbers will come, so this is a job for while.

بەرنامەی 3ـی تاقیگە ژمارەیەک دەخوێنێتەوە، فاکتۆریێلەکەی چاپ دەکات و دووبارە دەخوێنێتەوە — تا بەکارهێنەر ژمارەیەکی سالب دەنووسێت. ژمارە سالبەکە دراوە (Data) نییە؛ نیشانەیەکە بە واتای بوەستە. بەرنامەنووسان بەم جۆرە نرخە دەڵێن نرخی پاسەوان. کەس پێشوەختە نازانێت چەند ژمارە دێت، بۆیە ئەمە کاری whileـە.

The program works, but its output is noisy, and the original sheet also wrote while(x>=0); with a semicolon after the condition — MATLAB accepts that empty statement, but it only confuses the reader. A tidier version prints one clear line per number with fprintf (printing with fprintf):

بەرنامەکە کار دەکات، بەڵام دەرخستەکەی (Output) قەرەباڵغە و پەڕە ڕەسەنەکە while(x>=0);ـیشی نووسیوە بە خاڵبۆرێک دوای مەرجەکە — MATLAB ئەو ڕستە بەتاڵە وەردەگرێت، بەڵام تەنها خوێنەر سەرگەردان دەکات. وەشانێکی ڕێکتر بۆ هەر ژمارەیەک یەک دێڕی ڕوون بە fprintf چاپ دەکات (چاپکردن بە fprintf):

The strength of while is a question whose answer is how many times? Hana's new page has 10,000 followers and grows by 25 % a month. Soran's page has 60,000 and gains 5,000 a month. After how many months does Hana catch up? Count the turns, and print the situation before and after the loop so you can check it:

هێزی while لە پرسیارێکدایە کە وەڵامەکەی چەند جار؟ـە. پەڕە نوێیەکەی هانا ⁦10,000⁩ شوێنکەوتووی هەیە و مانگانە ⁦25 %⁩ گەورە دەبێت. پەڕەکەی سۆران ⁦60,000⁩ـی هەیە و مانگانە ⁦5,000⁩ زیاد دەکات. دوای چەند مانگ هانا دەگاتە سۆران؟ جارەکان بژمێرە و دۆخەکە پێش و دوای خولەکە چاپ بکە بۆ ئەوەی بتوانیت بیپشکنیت:

Two more loops of the same kind (the guide shows the factorial one with 100; here with new numbers). The first finds the smallest n whose factorial is above 5000 — prod(1:n) multiplies $1\cdot 2\cdots n$. The second prints a running total until it passes 20:

دوو خولی تر لە هەمان جۆر (ڕێبەرەکە نموونەی فاکتۆریێل بە ⁦100⁩ پیشان دەدات؛ لێرە بە ژمارەی نوێ). یەکەمیان بچووکترین n دەدۆزێتەوە کە فاکتۆریێلەکەی لە ⁦5000⁩ زیاترە — prod(1:n) $1\cdot 2\cdots n$ لێک دەدات. دووەمیان کۆیەکی ڕۆیشتوو چاپ دەکات تا لە ⁦20⁩ تێدەپەڕێت:

The guide also walks an index i along a vector with while and stops in time. Here is the idea with new data: find the first element above 50.

ڕێبەرەکە بە while ئیندێکسێک i بە درێژایی ئاڕاستەبڕێک دەجوڵێنێت و لە کاتی خۆیدا دەوەستێت. ئەمە بیرۆکەکەیە بە دراوەی نوێ: یەکەم توخم بدۆزەرەوە کە لە ⁦50⁩ زیاترە.

This is the short-circuit evaluation of && at work. With v = [12 47 33] the loop stops with i = 4, which is past the end — so check i <= length(v) before you use v(i) after the loop. The one-line MATLAB way is find(v > 50, 1) (comparing a whole vector).

ئەمە هەڵسەنگاندنە کورتبڕەکەی (Short-circuit evaluation) &&ـە لە کاردا. بە v = [12 47 33] خولەکە بە ⁦i = 4⁩ دەوەستێت کە لە کۆتایی تێپەڕیوە — بۆیە پێش ئەوەی دوای خولەکە v(i) بەکار بهێنیت، i <= length(v) بپشکنە. ڕێگای یەک دێڕیی MATLAB find(v > 50, 1)ـە (بەراوردکردنی ئاڕاستەبڕێکی تەواو).

The guide's first example on its second while page uses the same index walk to fill a vector. It makes x values from 0 to 2 in steps of h, a vector y of zeros with the same size (y = 0*x), sets y(1) = 1, and then computes every new element from the one before it, y(i+1) = y(i) + h*(…), until i reaches the last position, max(size(x)) — the same number as length(x). At the end it draws plot(x, y, 'go'). Here is the pattern with a short new rule: each new value lies halfway between the old value and x(i).

یەکەم نموونەی پەڕەی دووەمی whileـی ڕێبەرەکە هەمان ڕۆیشتنی ئیندێکس بەکار دەهێنێت بۆ پڕکردنەوەی ئاڕاستەبڕێک. نرخەکانی x لە 0 تا 2 بە هەنگاوی h دروست دەکات، ئاڕاستەبڕێکی y لە سفر بە هەمان قەبارە (y = 0*x)، y(1) = 1 دادەنێت و پاشان هەر توخمێکی نوێ لە توخمەکەی پێشوویەوە هەژمار دەکات، y(i+1) = y(i) + h*(…)، تا i دەگاتە دوایین شوێن، max(size(x)) — هەمان ژمارەی length(x). لە کۆتاییدا plot(x, y, 'go') دەکێشێت. ئەمە هەمان شێوازە بە یاسایەکی نوێی کورت: هەر نرخێکی نوێ لە نیوەڕێی نێوان نرخە کۆنەکە و x(i)ـدایە.

A rule that builds each value from the previous one is how computers follow anything that changes step by step — a balance month by month, or (in a numerical-analysis course) the solution of an equation of change. The loop is a while here because the guide wrote it so; since the number of turns is known (length(x) - 1), for i = 1:length(x)-1 does the same job.

یاسایەک کە هەر نرخێک لە نرخەکەی پێشوویەوە دروست دەکات، ڕێگای کۆمپیوتەرە بۆ بەدواداچوونی هەر شتێک کە هەنگاو بە هەنگاو دەگۆڕێت — بڕی پارەی هەژمارێکی بانک مانگ بە مانگ، یان (لە کۆرسێکی شیکاریی ژمارەییدا) چارەسەری هاوکێشەیەکی (Equation) گۆڕان. لێرەدا خولەکە whileـە چونکە ڕێبەرەکە وای نووسیوە؛ بەڵام ژمارەی جارەکان زانراوە (length(x) - 1)، بۆیە for i = 1:length(x)-1 هەمان کار دەکات.

Sometimes the reason to stop appears in the middle of the body. The Break statement ends the loop immediately: the rest of the body is skipped, no more turns happen, and MATLAB continues with the first statement after the loop's end. break works in for and while loops alike — MathWorks' page puts it simply: the statements after break in the loop do not run.

هەندێک جار هۆکاری وەستان لە ناوەڕاستی جەستەکەدا دەردەکەوێت. ڕستەی break (break statement) یەکسەر خولەکە کۆتایی پێ دەهێنێت: باقیی جەستەکە باز دەدرێت، هیچ جارێکی تر ڕوو نادات و MATLAB بە یەکەم ڕستە دوای endـی خولەکە بەردەوام دەبێت. break لە خولەکانی for و whileـدا وەک یەک کار دەکات — پەڕەی MathWorks بە سادەیی دەڵێت: ڕستەکانی دوای break لە خولەکەدا جێبەجێ نابن.

A lab program reads the marks of four subjects and stops at the first mark below 50. Then it prints the average. Here it is as it was typed in the lab (re-typed from a photo):

بەرنامەیەکی تاقیگە نمرەی چوار وانە دەخوێنێتەوە و لە یەکەم نمرەی خوار ⁦50⁩دا دەوەستێت. پاشان ناوەند چاپ دەکات. ئەمە وەک ئەوەیە کە لە تاقیگەدا نووسراوە (لە وێنەیەکەوە دووبارە نووسراوەتەوە):

Marks 70 and 85 were added, then 40 triggered break. The program still divides by 4, so it reports 38.75 for a student whose two counted marks average 77.5. The three mistakes:

نمرەکانی ⁦70⁩ و ⁦85⁩ کۆ کرانەوە، پاشان ⁦40⁩ breakـی چالاک کرد. بەرنامەکە هێشتا دابەشی 4 دەکات، بۆیە ⁦38.75⁩ ڕادەگەیەنێت بۆ قوتابییەک کە ناوەندی دوو نمرە ژمێردراوەکەی ⁦77.5⁩ـە. سێ هەڵەکە:

MATLAB has no do...while loop, which runs its body first and tests afterwards. MathWorks' page on while shows the usual replacement: a loop whose condition is always true, with an if … break at the point where you can decide. It is ideal for checking input (validation):

MATLAB خولی do...whileـی (do...while loop) نییە کە یەکەم جار جەستەکەی جێبەجێ دەکات و پاشان تاقی دەکاتەوە. پەڕەی MathWorks دەربارەی while جێگرەوە باوەکە پیشان دەدات: خولێک کە مەرجەکەی هەمیشە trueـە و if … breakـێک لەو شوێنەی دەتوانیت بڕیار بدەیت. بۆ پشکنینی نێوخستە (پشتڕاستکردنەوە (Validation)) زۆر گونجاوە:

In a nested loop, break ends only the loop it is written in. The outer loop carries on with its next turn:

لە خولێکی ناوەکیدا (Nested loop) break تەنها ئەو خولە کۆتایی پێ دەهێنێت کە تێیدا نووسراوە. خولە دەرەکییەکە بە جاری داهاتووی بەردەوام دەبێت:

break belongs inside a loop. Written outside any loop it is an error in a MATLAB file. To leave a function early you use return instead (leaving early with return).

break شوێنی لەناو خولێکە. ئەگەر لە دەرەوەی هەموو خولێک بنووسرێت، لە فایلێکی MATLABـدا هەڵەیە. بۆ زوو جێهێشتنی کردارێک لە جیاتی ئەوە return بەکار دەهێنیت (زوو دەرچوون بە return).

The Continue statement is the gentle cousin of break: it skips the rest of the current turn and goes straight to the next one; the loop itself goes on. Here −1 marks an absent student, and the absent ones are skipped:

ڕستەی continue (continue statement) ئامۆزای نەرمی breakـە: باقیی جاری ئێستا باز دەدات و ڕاستەوخۆ دەچێت بۆ جاری داهاتوو؛ خودی خولەکە بەردەوام دەبێت. لێرەدا $-1$ نیشانەی قوتابیی ئامادەنەبووە و ئامادەنەبووەکان باز دەدرێن:

MATLAB can also do this job without a loop: mean(marks(marks >= 0)) keeps only the marks that pass the test (comparing a whole vector). Use continue when the body is long and you want to drop the unwanted cases early.

MATLAB دەتوانێت ئەم کارە بەبێ خولیش بکات: mean(marks(marks >= 0)) تەنها ئەو نمرانە دەهێڵێتەوە کە لە تاقیکردنەوەکە دەردەچن (بەراوردکردنی ئاڕاستەبڕێکی تەواو). continue بەکار بهێنە کاتێک جەستەکە درێژە و دەتەوێت حاڵەتە نەویستراوەکان زوو لاببەیت.

A useful rule: if you can write the number of turns before the loop starts, use for — it changes its variable by itself, so it cannot become infinite by accident. If the loop must stop when something happens, use while and check its three parts.

یاسایەکی بەسوود: ئەگەر دەتوانیت ژمارەی جارەکان پێش دەستپێکردنی خولەکە بنووسیت، for بەکار بهێنە — خۆی گۆڕاوەکەی دەگۆڕێت، بۆیە بە هەڵە نابێتە خولی بێکۆتا. ئەگەر خولەکە دەبێت کاتێک شتێک ڕوو دەدات بوەستێت، while بەکار بهێنە و سێ بەشەکەی بپشکنە.

If you know Python: its while loop works the same way, including endless loops stopped with Ctrl+C and break/continue — see infinite loops in Python and break.

ئەگەر Python دەزانیت: لەوێدا خولی while بە هەمان شێوە کار دەکات، بە خولە بێکۆتاکانەوە کە بە ⁦Ctrl+C⁩ دەوەستێنرێن و break/continue — بڕوانە خولە بێکۆتاکان لە Pythonـدا و break.