Buy this book at Amazon.com

This HTML version of the book is provided as a convenience, but some math equations are not translated correctly. The PDF version is more reliable.

Chapter 4  Loops

4.1  Updating variables

In Exercise 3, you might have been tempted to write something like

a = a - 0.05*a + 0.03*b
b = b + 0.05*a - 0.03*b

But that would be wrong, so very wrong. Why? The problem is that the first line changes the value of a, so when the second line runs, it gets the old value of b and the new value of a. As a result, the change in a is not always the same as the change in b, which violates the principle of Conversation of Cars!

One solution is to use temporary variables anew and bnew:

anew = a - 0.05*a + 0.03*b
bnew = b + 0.05*a - 0.03*b
a = anew
b = bnew

This has the effect of updating the variables “simultaneously;” that is, it reads both old values before writing either new value.

The following is an alternative solution that has the added advantage of simplifying the computation:

atob = 0.05*a - 0.03*b
a = a - atob
b = b + atob

It is easy to look at this code and confirm that it obeys Conversation of Cars. Even if the value of atob is wrong, at least the total number of cars is right. And that brings us to the Seventh Theorem of Debugging:

The best way to avoid a bug is to make it impossible.

In this case, removing redundancy also eliminates the opportunity for a bug.

4.2  Kinds of error

There are four kinds of error:

Syntax error:

You have written a MATLAB command that cannot execute because it violates one of the rules of syntax. For example, you can’t have two operands in a row without an operator, so pi r^2 contains a syntax error. When MATLAB finds a syntax error, it prints an error message and stops running your program.

Runtime error:

Your program starts running, but something goes wrong along the way. For example, if you try to access a variable that doesn’t exist, that’s a runtime error. When MATLAB detects the problem, it prints an error message and stops.

Logical error:

Your program runs without generating any error messages, but it doesn’t do the right thing. The problem in the previous section, where we changed the value of a before reading the old value, is a logical error.

Numerical error:

Most computations in MATLAB are only approximately right. Most of the time the errors are small enough that we don’t care, but in some cases the roundoff errors are a problem.

Syntax errors are usually the easiest. Sometimes the error messages are confusing, but MATLAB can usually tell you where the error is, at least roughly.

Runtime errors are harder because, as I mentioned before, MATLAB can tell you where it detected the problem, but not what caused it.

Logical errors are hard because MATLAB can’t help at all. Only you know what the program is supposed to do, so only you can check it. From MATLAB’s point of view, there’s nothing wrong with the program; the bug is in your head!

Numerical errors can be tricky because it’s not clear whether the problem is your fault. For most simple computations, MATLAB produces the floating-point value that is closest to the exact solution, which means that the first 15 significant digits should be correct. But some computations are ill-conditioned, which means that even if your program is correct, the roundoff errors accumulate and the number of correct digits can be smaller. Sometimes MATLAB can warn you that this is happening, but not always! Precision (the number of digits in the answer) does not imply accuracy (the number of digits that are right).

4.3  Absolute and relative error

There are two ways of thinking about numerical errors, called absolute and relative.

Absolute error:

It is just the difference between the correct value and the approximation. We usually write the magnitude of the error, ignoring its sign, because it doesn’t matter whether the approximation is too high or too low.

Relative error:

It is the error expressed as a fraction (or percentage) of the exact value.

For example, we might want to estimate 9! using the formula √18 π ( 9 / e)⁹. The exact answer is 9 · 8 · 7 · 6 · 5 · 4 · 3 · 2 · 1 = 362,880. The approximation is 359,536.87. The absolute error is 3,343.13.

At first glance, that sounds like a lot—we’re off by three thousand—but it is worth taking into account the size of the thing we are estimating. For example, $3000 matters a lot if we are talking about my annual salary, but not at all if we are talking about the national debt.

A natural way to handle this problem is to use relative error. In this case, we would divide the error by 362,880, yielding .00921, which is just less than 1%. For many purposes, being off by 1% is good enough.

4.4  for loops

A loop is a part of a program that executes repeatedly; a for loop is the kind of loop that uses the for statement.

The simplest use of a for loop is to execute one or more lines a fixed number of times. For example, in the last chapter we wrote a script named car_update that simulates one week in the life of a rental car company. To simulate an entire year, we have to run it 52 times:

for i=1:52
    car_update
end

The first line looks like an assignment statement, and it is like an assignment statement, except that it runs more than once. The first time it runs, it creates the variable i and assigns it the value 1. The second time, i gets the value 2, and so on, up to 52.

The colon operator, :, specifies a range of integers. In the spirit of unit testing, you can create a range at the prompt:

>> 1:5
ans =  1     2     3     4     5

The variable you use in the for statement is called the loop variable. It is a common convention to use the names i, j, and k as loop variables.

The statements inside the loop are called the body. By convention, they are indented to show that they are inside the loop, but the indentation does not actually affect the execution of the program. The end of the loop is officially marked by the end statement.

To see the loop in action you can run a loop that displays the loop variable:

>> for i=1:5
    i
end

i = 1
i = 2
i = 3
i = 4
i = 5

As this example shows, you can run a for loop from the command line, but it’s much more common to put it in a script.

4.5  plotting

plot is a versatile function for plotting points and lines on a two-dimensional graph. Unfortunately, it is so versatile that it can be hard to use (and hard to read the documentation!). We will start simple and work our way up.

To plot a single point, type

>> plot(1, 2)

A Figure Window should appear with a graph and a single, blue dot at x position 1 and y position 2. To make the dot more visible, you can specify a different shape:

>> plot(1, 2, 'o')

The letter in single quotes is a string that specifies how the point should be plotted. You can also specify the color:

>> plot(1, 2, 'ro')

r stands for red; the other colors include green, blue, cyan, magenta, yellow, and black. Other shapes include +, *, x, s (for square), d (for diamond), and ^ (for a triangle).

When you use plot this way, it can only plot one point at a time. If you run plot again, it clears the figure before making the new plot. The hold command lets you override that behavior. hold on tells MATLAB not to clear the figure when it makes a new plot; hold off returns to the default behavior.

Try this:

>> hold on
>> plot(1, 1, 'o')
>> plot(2, 2, 'o')
>> hold off

You should see a figure with three circles. MATLAB scales the plot automatically so that the axes run from the lowest value in the plot to the highest. So in this example the points are plotted in the corners.

4.6  Sequences

In mathematics a sequence is a set of numbers that corresponds to the positive integers. The numbers in the sequence are called elements. In math notation, the elements are denoted with subscripts, so the first element of the series A is A₁, followed by A₂, and so on.

for loops are a natural way to compute the elements of a sequence. As an example, in a geometric sequence, each element is a constant multiple of the previous element. As a more specific example, let’s look at the sequence with A₁ = 1 and the ratio A_i+1 = A_i/2, for all i. In other words, each element is half as big as the one before it.

The following loop computes the first 10 elements of A:

a = 1
for i=2:10
    a = a/2
end

Each time through the loop, we find the next value of a by dividing the previous value by 2. Notice that the loop range starts at 2 because the initial value of a corresponds to A₁, so the first time through the loop we are computing A₂.

Each time through the loop, we replace the previous element with the next, so at the end, a contains the 10th element. The other elements are displayed on the screen, but they are not saved in a variable. Later, we will see how to save all of the elements of a sequence in a vector.

This loop computes the sequence recurrently, which means that each element depends on the previous one. For this sequence it is also possible to compute the ith element directly, as a function of i, without using the previous element. In math notation, A_i = A₁ rⁱ⁻¹.

4.7  Series

In mathematics, a series is the sum of the elements of a sequence. It’s a terrible name, because in common English, “sequence” and “series” mean pretty much the same thing, but in math, a sequence is a set of numbers, and a series is an expression (a sum) that has a single value. In math notation, a series is often written using the summation symbol ∑.

For example, the sum of the first 10 elements of A is

A for loop is a natural way to compute the value of this series:

A1 = 1;
total = 0;
for i=1:10
    a = A1 * 0.5^(i-1);
    total = total + a;
end
ans = total

A1 is the first element of the sequence, so each time through the loop a is the ith element.

The way we are using total is sometimes called an accumulator; that is, a variable that accumulates a result a little bit at a time. Before the loop we initialize it to 0. Each time through the loop we add in the ith element. At the end of the loop total contains the sum of the elements. Since that’s the value we were looking for, we assign it to ans.

4.8  Generalization

As written, the previous example always adds up the first 10 elements of the sequence, but we might be curious to know what happens to total as we increase the number of terms in the series. If you have studied geometric series, you might know that this series converges on 2; that is, as the number of terms goes to infinity, the sum approaches 2 asymptotically.

To see if that’s true for our program, we could replace the constant, 10, with a variable named n:

A1 = 1;
total = 0;
for i=1:n
    a = A1 * 0.5^(i-1);
    total = total + a;
end
ans = total

The code above can now compute any number of terms, with the precondition that you have to set n before you execute the code. Put the code in a file named series.m, then run the script with different values of n as shown in the following:

>> n=10; series

total = 1.99804687500000

>> n=20; series

total = 1.99999809265137

>> n=30; series

total = 1.99999999813735

>> n=40; series

total = 1.99999999999818

It sure looks like it’s converging on 2.

Replacing a constant with a variable is called generalization. Instead of computing a fixed, specific number of terms, the new script is more general; it can compute any number of terms.

This is an important idea we will come back to when we talk about functions.

4.9  Glossary

absolute error:

The difference between an approximation and an exact answer.

relative error:

The difference between an approximation and an exact answer, expressed as a fraction or percentage of the exact answer.

loop:

A part of a program that runs repeatedly.

loop variable:

A variable, defined in a for statement, that gets assigned a different value each time through the loop.

range:

The set of values assigned to the loop variable, often specified with the colon operator; for example 1:5.

body:

The statements inside the for loop that are run repeatedly.

sequence:

In mathematics, a set of numbers that correspond to the positive integers.

element:

A member of the set of numbers in a sequence.

recurrently:

A way of computing the next element of a sequence based on previous elements.

directly:

A way of computing an element in a sequence without using previous elements.

series:

The sum of the elements in a sequence.

accumulator:

A variable that is used to accumulate a result a little bit at a time.

generalization:

A way to make a program more versatile, for example by replacing a specific value with a variable that can have any value.

4.10  Exercises

Are you using one of our books in a class?

Think Bayes

Think Python 2e

Think Stats 2e

Think Complexity