﻿ ]>

## for Loop

The structure of a `for` loop:

```for counter = first : increment : last
statements  % body of for loop
end```

The form of a `for` loop is interpreted as follows:

The variable `counter` is often called the counter variable. This variable will take on each successive value of the vector created in the first line of the loop. The current value of `counter` can be used inside of the body of the `for` loop. Any valid variable name can be used for the counter variable. Common choices are: `n`, `k`, and `j`.

The code `first:increment:last` is like the vectors we have created using the colon (`:`) operator in earlier lessons.

Even though the `for` loop condition has a different form than that found in the `while` loop, it is still evaluated as a boolean expression. The condition of the `for` loop compares the current value of the counter variable, `n`, with the value of `last`. If the value of the counter variable is less than or equal to the value in `last`, the body of the loop will execute.

The control flow diagram of a `for` loop looks like:

The `for` loop is equivalent to the following `while` loop:

```counter = first;
while counter <= last
statements  % body of the loop
counter = counter + incr;
end```

We can leave out the `increment` part of the condition. If we leave it out, Matlab uses an increment of 1. In other words, `first : last` is equivalent to `first : 1 : last` (just as it was when we used the colon operator to create and manipulate matrices). We can rewrite our program to sum the odd integers from 1 to 1,000,001 so it uses a `for` loop in the following way:

```sum = 0;
last = 10^6 + 1;   % 1,000,001
for num = 1 : 2 : last
sum = sum + num;
end
disp(sum)```

This results in code that is more compact (but still readable). The `for` statement is useful for constructing the matrices required to solve complex linear systems. The index (or counter) of the `for` statement can be used as the index of a vector or matrix. In the following code fragment, we first create a 10 x 10 matrix of zeros and then put the numbers 0 to 9 along the diagonal:

```zmat = zeros(10, 10);
for k = 1 : 10
zmat(k, k) = k-1;
end
disp(zmat)```

This code works as follows:

1. Create the matrix `zmat`, with ten columns and ten rows, containing all zeros.
2. Set `k` to 1.
3. If `k` is less than or equal 10, execute the body.
1. assign the value `k-1` to the element at position `k,k` in the matrix `zmat`.
2. Increment the value of `k` by the increment amount (1 in this example).
3. Repeat this step.
4. Else, continue to the next step.
5. Display the values in `zmat`.

It is sometimes better to use a more general form when specifying the range of values to iterate over in the first line of a `for` loop. For example, in place of the 10 in the first line of the loop in the previous example, we could have used `length(zmat)`. Recall that, for a matrix, the `length` function returns the larger of the number of rows and number of columns (since `zmat` is a square matrix, the number of rows is the same as the number of columns). By doing this, we make it easier to modify our program to handle square matrices of other sizes, for example, we can now put the values 0 to 19 along the diagonal of a 20 x 20 matrix just by changing the values in the zeros function:

```zmat = zeros(20, 20);
for k = 1 : length(zmat)
zmat(k, k) = k-1;
end
disp(zmat)```

We can make our program even more general (and easier to modify to handle square matrices of other sizes) by using a variable to hold the number of elements in a row (or column):

```N = 20;              % N = # of rows (also # of columns)
zmat = zeros(N, N);  % so zmat is a N x N matrix
for k = 1 : N
zmat(k, k) = k-1;
end
disp(zmat)```

Using variables instead of numbers in our code is what makes programming solutions to problems better than simply solving the individual problem. A general solution can be used for an entire classes of problems. Once we write and debug the code for a type of problem instead of just a specific instance of a problem, we can execute our code for any new instances of that type of problem.