## 7.5 For Loops

Suppose `N`

is a variable of type `int`

, `y`

is a one-dimensional
array of type `real[]`

, and `mu`

and `sigma`

are variables of type
`real`

. Furthermore, suppose that `n`

has not been defined as a
variable. Then the following is a well-formed for-loop statement.

```
for (n in 1:N) {
y[n] ~ normal(mu, sigma);
}
```

The loop variable is `n`

, the loop bounds are the values in the
range `1:N`

, and the body is the statement following the
loop bounds.

### Loop Variable Typing and Scope

The type of the loop variable is `int`

. Unlike in C++ and similarly
to R, this variable must not be declared explicitly.

The bounds in a for loop must be integers. Unlike in R, the loop is
always interpreted as an upward counting loop. The range `L:H`

will cause the loop to execute the loop with the loop variable taking
on all integer values greater than or equal to `L`

and less than
or equal to `H`

. For example, the loop `for (n in 2:5)`

will cause the body of the for loop to be executed with `n`

equal
to 2, 3, 4, and 5, in order. The variable and bound `for (n in 5:2)`

will not execute anything because there are no integers
greater than or equal to 5 and less than or equal to 2.

The scope of the loop variable is limited to the body of the loop.

### Order Sensitivity and Repeated Variables

Unlike in BUGS, Stan allows variables to be reassigned. For
example, the variable `theta`

in the following program is
reassigned in each iteration of the loop.

```
for (n in 1:N) {
theta = inv_logit(alpha + x[n] * beta);
y[n] ~ bernoulli(theta);
}
```

Such reassignment is not permitted in BUGS. In BUGS, for loops are
declarative, defining plates in directed graphical model notation,
which can be thought of as repeated substructures in the graphical
model. Therefore, it is illegal in BUGS or JAGS to have a for loop
that repeatedly reassigns a value to a variable.^{9}

In Stan, assignments are executed in the order they are encountered. As a consequence, the following Stan program has a very different interpretation than the previous one.

```
for (n in 1:N) {
y[n] ~ bernoulli(theta);
theta = inv_logit(alpha + x[n] * beta);
}
```

In this program, `theta`

is assigned after it is used in the
probability statement. This presupposes it was defined before the
first loop iteration (otherwise behavior is undefined), and then each
loop uses the assignment from the previous iteration.

Stan loops may be used to accumulate values. Thus it is possible to sum the values of an array directly using code such as the following.

```
total = 0.0;
for (n in 1:N)
total = total + x[n];
```

After the for loop is executed, the variable `total`

will hold
the sum of the elements in the array `x`

. This example was
purely pedagogical; it is easier and more efficient to write

`total = sum(x);`

A variable inside (or outside) a loop may even be reassigned multiple times, as in the following legal code.

```
for (n in 1:100) {
y += y * epsilon;
epsilon = 0.5 * epsilon;
y += y * epsilon;
}
```

A programming idiom in BUGS code simulates a local variable by replacing

`theta`

in the above example with`theta[n]`

, effectively creating`N`

different variables,`theta[1]`

, …,`theta[N]`

. Of course, this is not a hack if the value of`theta[n]`

is required for all`n`

.↩