6.108
Loops and Iteration in R

Prequisites

This lesson presumes that you are familiar with the contents of:

• 6.104 – Quick Guide to R For Programmers

Introduction

This lesson provides an explanation of loops in R. Loops are often necessary in R to process data, but where they are required in other programming languages, R programmers can often avoid them by using vector operations or the apply() family of functions. Nevertheless, there are times when they are essential, so R programmers must know how to work with loops.

In computer programming, loops are program control structures that allow the repetition of a sequence of instructions a certain number of times or until a specific condition is met.

There are different types of loops, and R supports the most common ones:

for loop: executes a block of code a specific number of times based on a range of values or a list

while loop: executes a block of code repeatedly as long as a certain condition is true

do-while/repeat loop: executes a block of code at least once and then repeatedly as long as a certain condition is true

Loops can also be nested, which means that one loop can be contained within another loop. This allows for more complex iterations and more efficient programming.

We generally distinguish between “counting loops” that iterate some number of times versus “iterating loops” that iterate over the elements of a vector or list.

Counting Loop: for

The counting loop is actually more like an iterator in R, although it can be set up to mimic the behavior of a typical loop in C/C++, Java, etc., that loops from a low value to a high value. See the examples below.

n = 5
for (i in 1:n) {
  print(i)
}

## [1] 1
## [1] 2
## [1] 3
## [1] 4
## [1] 5

In the example above, i is the loop variable and it takes on the values in the vector 1:5, i.e., 1, 2, 3, 4, 5

To count down, it would be 5:1 or n:1 in the above code example.

Like other languages, R uses curly braces to enclose the body of the loop, i.e., the statements that are executed repeatedly, once for each value of i. Of course, the loop counter can be any properly named variable.

The example below accesses a vector using positional access, e.g., v[1] accesses the first element. Note that vector, data frames, lists, and arrays are indexed starting at 1 and not 0 as in C-based languages.

v = rnorm(5)      # vector of five random numbers
for (i in 1:length(v)) 
{
  v[i] = v[i] ^ 2
}

print(v)

## [1] 0.00342597 0.21315501 0.77381792 1.22558029 0.13509337

While you can use loops you actually do not need them. If you apply a mathematical operation to a vector, R automatically applies them to each element, but loops might be more natural in the beginning.

# note that you actually do not need loops in R
# this also squares each element in the vector v
v = v ^ 2

As already stated, looping in R is actually iteration over a set: a set of numbers as above or a set of any kind of primitive object, e.g., strings. Note that in the code below, k takes on each value in the vector over which the loop iterates.

s = c("one","two","three","four")

for (k in s) {
  print(k)
}

## [1] "one"
## [1] "two"
## [1] "three"
## [1] "four"

We could have written this using a non-iterator approach as well, which is more like what you’d do in C. Note that length returns the number of elements in a vector, i.e., its “length”.

s = c("one","two","three","four")

for (j in 1:length(s)) {
  print(s[j])
}

## [1] "one"
## [1] "two"
## [1] "three"
## [1] "four"

Iteration Continuation

Continuation of the loop to the next iteration and forgoing processing the remainder of the current iteration is done with next in R, similar to continue in C-based languages such as Java.

In the example below we are already reaching ahead to the if statement. The code fragment echoes only odd number. Of course, you could have done this differently by just iterating over the even numbers from one to twenty, but that would not have allowed us to share this example for using next.

for (i in 1:10) {
  if (!i %% 2) {
    next
  }
  print(i)
}

## [1] 1
## [1] 3
## [1] 5
## [1] 7
## [1] 9

But, just to show you how to iterate over just odd number, we can use the seq() function which generates a sequence of numbers in steps. No if and no break needed – much simpler.

for (i in seq(1, 10, 2)) {
  print(i)
}

## [1] 1
## [1] 3
## [1] 5
## [1] 7
## [1] 9

Or, more explicitly by specifying the parameters by name.

for (i in seq(from = 1, to = 10, by = 2)) {
  print(i)
}

## [1] 1
## [1] 3
## [1] 5
## [1] 7
## [1] 9

To stop the execution of the rest of a loop and to move immediately to the next statement after the loop is done with break in R which is identical to C, C++, Java, etc. In the code below we will find the position of the first occurrence of some number; x is the number we are looking for in v and p is the found position.

v = c(1, 3, 5, 7, 1, 9, 4)
x = 9
p = 0

for (i in 1:length(v)) {
  if (v[i] == x) {
    p = i
    break
  }
}

print(p)

## [1] 6

To be clear, there is a quicker and more efficient way to do this using the which function. This function does not exist is other languages and it shows the power of R. Also, using which is much faster. Incidentally, the code below finds all occurrences of x in v. Note, once again, the use of a vector variable to refer to all elements.

v = c(1, 3, 5, 7, 1, 9, 4)
x = 9

p = which(v == x)

print(p)

## [1] 6

Conditional Loops: while and repeat

Like many other languages, R supports top and bottom tested loops. In the example below we repeatedly ask for a number from the user and only exit the loop if the number is 42. Of course, the example really should be done with a bottom tested loop.

response <- as.integer(readline(prompt="Enter a number: "))

while (response != 42) {   
  print("Sorry, not correct");
  response <- as.integer(readline(prompt="Enter a number: "));
}

In the above example, we are using two new functions. readline is used to read input from the console, while as.integer coerces (or casts in C/C++ terminology) the input to an integer.

The code is above is not very efficient or elegant as it has the code for the user prompt twice. It is really better to ask first and then check the condition: we need a bottom-tested loop.

Let’s look at the same example, but with a repeat loop that runs until a condition is reached and the loop is explicitly exited with break. So, if you want to run the code at least once, use repeat; if the code is run zero or more times, use while. The repeat loop is identical to the do or do while loop found in many other programming languages.

repeat {   
  response <- as.integer(readline(prompt="Enter a number: "));
  if (response == 42) {
    break
  }
  print("Sorry, not correct");
}

There is no equivalent in R for the use of an infinite for loop as in C and C++, e.g., for(;;){ // do something indefinitely } that runs until a condition is reached and then uses break to exit the loop. The repeat loop construct is used instead. There is no testing of a condition in the repeat loop, so there’s no equivalent to the C-like construct do … while.

Conclusion

As you saw, R is not a difficult language to learn as it is similar to other languages and for most language constructs that you are familiar with, there is an equivalent. But it is important that you go beyond this tutorial and learn the “R way” of programming using vectorized operations.

---

Files & Resources

All Files for Lesson 6.108

---

References

No references.

Errata

None collected yet. Let us know.