[MUSIC] For-loops work well when we know the maximum number of necessary iterations before entering the loop. In a control statement, the expression is evaluated and then the loop index will receive the elements of the vector or the columns of the array one by one. Maximum number of times the for loop body will execute is fixed at this point. Why maximum? Because we can always quit early with the a break statement. What if we don't know the maximum number of times the loop needs to iterate? Consider this problem. How many positive integers do we need to add together to exceed 50? The only way to solve this with a for-loop is to guess a large enough number for the number of iterations and use a break statement to stop the loop when 50 is exceeded. You can do that. It's not that hard for this simple problem. But there's a better way. One with no guesswork at all, a while loop. Check this function out, we call it possum, for positive integer summation. It takes the limit that we want to exceed as an input argument. It both prints and returns both the number of positive integers we need to add together to exceed the input value and the sum of those integers. We start by setting both n and total to zero. Then we use the new while keyword followed by a condition. The meaning is simple. If the condition is true, we execute the body of the while loop. The body is the set of statements between the while line and the end keyword. Once we execute the body, we go back and check the condition again. If the condition is false, the while loop is done, otherwise it continues. The body in this example increments n by 1 and then adds the result to total. Once total exceeds limit, the while condition will be false, the loop terminates, and we print the result. The function then terminates and returns its output argument. If we run the function with the input 50, here's the result. The first line of the printout came from the fprintf inside the function. Then MATLAB caught the first output argument in its ands variable, and echoed the result. The second output argument was discarded. Well we've seen the while loop in action. Let's take a closer look at its form. Just like the for loop, the while loop has a control statement and a body. However, the control statement of a while loop is a condition like, for example, total less and than or equal to limit. Its value is either true or false. If it's true, we execute the body. Then, we check the condition again. If it's false, we quit. You might have noticed that the general form of the while loop is very similar to that of the if statement. In fact, syntactically, the only difference is the different keyword, while, instead of if. But semantically, they are very different. The if statement's a one-shot deal. If the condition's true, we execute the body and we're done. But the while loop keeps checking the condition and executing the body over and over and over until the condition becomes false. This is a very powerful and very flexible way of looping. Let's look at this example in MATLAB. Here's the possum function in the editor window right here. Let's run it. [SOUND] [SOUND] Okay let's check its answers. Let's look at the last example first. We can do that by checking the sum of 1 through 318 and then the sum of 1 through 319. Like this. [NOISE] Okay, 318 isn't large enough to get the sum above 51,000, but 319 is. And the sum to 319 is 51,040. Which agrees with the answers up here. So the answers are correct. You can check the other examples, too. You'll find they're all correct. This function works like a charm. But before we leave it, let's talk a little more about its form. We pointed out how similar a while loop is to an if statement. But notice how similar this particular while loop is to a for loop. Not only does it iterate, but like a for loop, on each iteration, our while loop increments in, right here. Which is a kind of loop index. And it starts out in initial value, here. And terminates when it reaches it's last value. I say kind of, because this so-called loop index you're in is not an integral part of the while loop control statement up here. In the way that an index of a for loop is. The index of the for loop is an integral part of the for loop control statement. The syntax requires it. And the for loop semantics is based on it too, because the number of iterations is completely determined by the list of values for the for loop index given in the control statement. And then the index is assigned a new value from that list on every iteration. In fact, as we showed earlier in this lesson, you can change the for loop index to whatever you want in the body of the loop and on the next iteration, it'll be changed right back to the next item of the list by the for loop control construct. The while loop on the contrary, doesn't provide a list of values for an index and it doesn't increment anything on any iteration. If we want to increment something, we've got to do it ourselves. Explicitly, with a statement in the body of the loop as we have here with this n equals n plus 1 statement. The index is not part of the while loop syntax at all or the while loop semantics. And to drive that point home, I'm going to show you a perfectly good while loop with no loop index at all. It's in a function called approxSquareroot. Right here. As its name suggests, this function computes an estimate of the square root of its input argument x here. There's just one statement in the body in this while loop. It computes the value of a variable called y. I'm going to remove this semicolon. You wouldn't ordinarily want to do that, but I want to see y's value change each time we iterate through this loop. Let's also go over here and change the format to long, like that. So we can see more decimals and ys printed out. Okay, let's calculate the square root of 2. There. Now, as you can see, it took only one, two, three iterations. And then it gave us back the answer. And that answer, 1.41, seems like it might be pretty close to the correct answer. Let's compare it with the built-in function. [SOUND] Yeah, that's close. Differs by two-millionths. If we test on a larger number, we'll see it takes a few more iterations. Let's try 200. Now, this time it took one, two, three, four, five, six iterations, instead of three. Let's see, how close it is this time? Oh, not as close, but still pretty good. That's three-thousandths. Well, let's look at the function itself, over here a little more carefully. Let's look at the condition here. First thing that happens is the absolute value of the difference between y square, and x is calculated. Y of course is supposed to be the square root of x, that's what we're trying to make it equal to. And if you square the square root of x, it should be equal to x. So the difference here, ideally, would be equal to zero. If it's bigger than zero, then we might want to do a little more work. So, what we do in fact is check to see, if it's bigger than a thousandth of x. If it's bigger than that, then we carry out the body of the loop again. And we check this again, and we keep doing that until the difference between the square of y and x is absolute value, no greater than a thousandth of x, and then the loop ends. We can talk about this combination of x and y, that gives us a better estimate of y, if in a current value of y. But I'm really more interested in this condition. The key thing to notice here is there is no loop index. I mean, where is a counter that counts up the number of times that we go through? Where is a list of values that it's set to? Where is an increment of n? There is no n. There is no loop index. It's absolutely unneeded, we don't care how many times we go through this loop. We just care that we go through it, while this number is bigger than this number. We stop, and that's no longer true, and declare that we've got a good approximation to the square root of x and we quit. And if we think we're quitting to soon to get an answer that's accurate enough. We can increase the accuracy by changing the one-thousandth of x threshold to something smaller say, make it one ten-millionth Of x. So, it took six iterations for one-thousandths of x. Now, we've increased the required accuracy by a factor of 10,000. Wonder how many more iterations it's going to take now? Better get comfortable. This could take awhile. Wait. One, two, three, four, five, six, seven iterations. Only one more iteration? Let's see, how accurate this one is, actually compared to the built-in function here? Three ten-millionths. We went from three-thousandths, and six iterations to three ten-millionths, and seven iterations. This thing is converging fast. By the way, if you're wondering why we aren't at one ten-millionth, since we have one ten-millionth here. Remember, that this wild loop condition is checking the accuracy of the square of y, while down here we're checking the accuracy of y. Well, let's put that semi colon back in, now that we've seen how this thing works. And let's see, how accurate we are on something we know the exact answer to. [INAUDIBLE] Like the square root of a million. Now, that's pretty accurate. Look at that. It should be 1000. Huh, ten to the minus eleven. Excellent. Let's see the built-in function try to beat that. Zero. You know, MATLAB, no body likes a show-off. Okay, our little function may not be quite as good at calculating square roots as the built-in function. It's a lot better than the built-in function that's showing you how y loops work, which is after all it's purpose. Let's get back to that by giving it another input. Let's try to minus 200. Okay, well, it's not doing anything here. Where's our prompt? Well, here's a hint of what's going on, look over here, you see the word Busy. This means that MATLAB is actually still working on our function. It hasn't croaked, it hasn't stopped, it's still going, it's in this wild loop, and it's going over and over. And it'll go forever because the condition in this wild loop, will never be false. This will always be greater than that. So we need to stop this thing. Do you remember what we said earlier, that you should do in a case like this, to stop MATLAB? You could click the little red button up here, or over here, depending on your operating system, and stop MATLAB entirely, and start all over again, but that's not necessary. Ctrl+C will stop this loop. Let's do that. I'll pop-up a keyboard viewer, so you can see what im doing. And I'll press the Ctrl key on your keyboard, it might be Ctrl on the key, or it might be Control, and here it's this little carrot, so I'm going to press that. There you can see I pressed that, and while I hold that down, I'll press the C key. Okay, and when we did that, everything's stopped, we got this red message, and we've got our prompt again. The red message is for once not a slap on the wrist by MATLAB. This message says that the user stopped it, while it was working. Maybe it's mad because we stopped it. But it tells us where it was, when it stopped. On line five of the function approx_sqrt, that's right here. That's the end statement of the loop, and that's where MATLAB typically stops, when you use Ctrl+C, while it's looping. Let's remove the semicolon here, and run it again, so we can see things happening. And you can see values of y streaming out on the screen. It's working hard, but let's go ahead, and stop it with Ctrl+C. Okay, our function clearly doesn't work [LAUGH] for this case. The algorithm works only for non-negative inputs. The square root of a negative number is a complex number, and we didn't do anything to produce a complex number in this short function. If you're familiar with complex numbers you know they have a real part and an imaginary part. MATLAB handles complex numbers with ease, which is a good thing, because they come up in some applications in engineering and physics. We're not going to deal with them except briefly in this course. First, let's see what the built-in square root function does with minus 200. You see the letter i at the end here? That means imaginary. The square root function is telling us that square root of minus 200 has a real part that's equal to 0, and an imaginary part that's equal to, well, all this. We can produce complex numbers, too. There are a couple of ways. Here's one. I just typed an i after the three. And I got a complex number that has a real part equal to 15 and an imaginary part equal to 3. Here's another way to do it. This time I put 15 plus 3 times i. MATLAB sets the variable i equal to the square root of minus 1. And you can use it to make an imaginary number. If you set i equal to say, 7 in the meantime, and then try this again. Well it uses the 7. If you want to get i back to meaning the square root of minus 1, clear it. Now let's just look at it. Now you see i is equal to the square root of minus 1 which is the imaginary 1. That's how you can produce complex numbers, and it wouldn't be hard to fix our function so that it would return the correct complex answer for a negative input. But we didn't do that and as a result, the condition in the while loop will never become false for a negative input. So MATLAB gets stuck in this loop. A loop that'll never end is called an infinite loop, and it's a feature only of while loops in MATLAB because that's the only place it can happen. A for-loop can never become an infinite loop because a loop will always quit when the loop index reaches the end of its list of values. And there's no way to set up and infinite list of values, accidentally or on purpose. But since while loops are susceptible to this problem, we have to be very careful how we set up the condition of a while loop, and how the variables in the condition are changed in the body of the while loop, so that eventually the condition will become false. While we're developing a program with one or more while loops, it's very common to make mistakes that cause one of those while loops to get stuck in an infinite loop. When MATLAB is seemingly not doing anything, always remember to check the bottom left corner for a busy message. If you see that, you know MATLAB is not dead. It's still working on your program. By the way, some very complex computations can run for a long time, even on today's fast computers. So whether you're using for-loops or while loops, MATLAB may still take a very long time to finish your function. In that case, you'll see the busy sign, and you'll know it's working. But if it's taking too long, you can always use Ctrl+C to stop the program, whether it's caught in an infinite loop or it's plowing through a calculation that you just don't want to wait for. [MUSIC] [SOUND] [APPLAUSE]