<- c(3, 1, 4)
vec
<- vec + 1
vec2 vec2
[1] 4 2 5
In the previous chapter you got introduced to your first iterative construct: for
loops. You use this type of loop when you know how many times a given computation needs to be repeated. But what about those situations in which you have to repeat a process without necessarily knowing how many times this repetition will take place? This is where we need a more general type of loop, namely, the while loop.
Let’s begin with the same toy example discussed in the previous chapter. Say you have a vector vec <- c(3, 1, 4)
, and suppose you want to obtain a new vector vec2
that adds 1 to every element in vec
. You know that this can easily be achieved using vectorized code:
<- c(3, 1, 4)
vec
<- vec + 1
vec2 vec2
[1] 4 2 5
Again, in order to explain the concept of a while
loop, I am going to ask you to pretend that R does not have vectorized code.
What would you need to do in order to add 1 to the elements in vec
? As we mentioned in the preceding chapter, you would need to do something like this:
# new vector to be updated
<- rep(0, 3)
vec2
# repetitive steps
1] <- vec[1] + 1
vec2[2] <- vec[2] + 1
vec2[3] <- vec[3] + 1 vec2[
That is, take the first element in vec
and add 1, then take the second element in vec
and add 1, and finally the third element in vec
and add 1. Basically, you are performing the same type of operation several times: selecting an element in vec
and adding 1 to it. But there’s a lot of (unnecessary) repetition.
We’ve seen how to write a for
loop to take care of the addition computation. Alternatively, we can also approach this problem from a slightly different perspective by considering a stopping condition to decide when to terminate the repetitive process of adding 1 to the elements in vec
.
What stopping condition can we use? Well, one example may involve: “let’s keep selecting a single element in vec
and adding 1 to it, until we exhaust all elements in vec
”. In other words, let’s keep iterating until we reach the last element in vec
.
As usual, the first step involves identifying the common structure of the repetitive steps. We can make the repetitive code a bit more general by referring to each position as pos
:
<- vec[pos] + 1 vec2[pos]
Once we have the correct abstraction for the code that needs to be repetead, then we can encapsulate it with a while
loop. Let me first show you an example and then we’ll examine it in detail:
# input vector
<- c(3, 1, 4)
vec
# initialize output vector
<- rep(0, 3)
vec2
# declare auxiliary iterator
<- 1
pos
# while loop
while (pos <= length(vec)) {
<- vec[pos] + 1
vec2[pos] <- pos + 1 # update iterator
pos }
The first thing that I should mention is that writing an R while
loop is a bit more complex than writing a for
loop. The complexity has to do with some of the things that R does not automatically take care of in a while
loop.
One main difference between a for
loop and a while
loop is that in the latter we must explicit declare the auxiliary iterator and give it an initial value: pos <- 1
.
Next we have the while
statement. This statement is technically a function, but I prefer to think of it, and call it, a statement (like the if
and the for
statements). What you pass inside parenthesis of the while
declaration is a condition. This is basically any piece of code that R will evaluate and coerce it into a logical condition that is TRUE
or FALSE
. The while
loop iterates as long as the condition is TRUE
. If the condition becomes FALSE
then the loop is terminated.
The code of the repetitive steps consists of an R expression { ... }
. This is where we indicate what to do at each step. Often, an important piece of code that we need to include here involves increasing the value of the auxiliary iterator: pos <- pos + 1
. In this particular example, if we don’t increase the iterator pos
, the loop would iterate forever.
Note that the condition is the stopping condition, which in turn depends on the auxiliary iterator: pos <= length(vec)
. You can think of this condition as: “let’s keep iterating until we reach the last element in vec
”.
Now that you’ve seen a first example of a while
loop, I can give you a generic template for this kind of iterative construct:
<- initial
iterator
while (condition) {
do_something<- iterator + 1
iterator }
What’s going on?
you need to declare the auxiliary iterator with some initial value
you declare the while
statement by giving a condition inside parenthesis
the condition must be a piece of code that gets evaluated into a single logical value: TRUE
or FALSE
the condition is used as the stopping condition: if the condition is TRUE
the loop keeps iterating; when the condition becomes FALSE
the loop is terminated
we use an R compound expression { ... }
to embrace the code that will be repeated at each iteration
inside the loop, you typically need to increase the value of the iterator
; even if the condition
does not depend on the iterator
, it’s a good idea to keep track of the number of iterations in the loop
Let’s see a more interesting example.
Say we generate a vector with 10 different integer numbers between 1 and 100, arranged in increasing order. To make things more interesting, we are going to generate these numbers in a random way using the sample.int()
function that allows us to get a random sample of size = 10
integers, sampling without replacement (replace = FALSE
):
set.seed(234) # for replication purposes
# vector of 10 random integers between 1 and 100
= sample.int(n = 100, size = 10, replace = FALSE)
random_numbers = sort(random_numbers)
random_numbers random_numbers
[1] 1 18 31 34 46 56 68 92 97 98
What are we going to do with these random_numbers
? We are going to compute a cumulative sum until its value becomes greater than 100. And we are going to consider these two questions:
What is the value of the cumulative sum?
How many numbers were added to reach the sum’s value?
My recommendation is to always start with baby steps. Simply put, start writing code for a couple of concrete steps so that you understand what kind of computations will be repeated, and what things they have in common:
# initialize output sum
= 0
total_sum
# accumulate numbers
= total_sum + random_numbers[1]
total_sum = total_sum + random_numbers[2]
total_sum = total_sum + random_numbers[3]
total_sum # ... keep adding numbers as long as total_sum <= 100
There are three important aspects to keep in mind:
we need an object to store the cumulative sum: total_sum
we need an iterator to move through the elements of random_numebrs
and of course we need to determine a stopping-condition: total_sum <= 100
Here’s the code:
# initialize object of cumulative sum
= 0
total_sum
# declare iterator
= 0
pos
# repetitive steps
while (total_sum <= 100) {
= pos + 1
pos = total_sum + random_numbers[pos]
total_sum
}
# what is the value of the cumulative sum?
total_sum
[1] 130
# how many iterations were necessary?
pos
[1] 5
Observe that in this example, we declared pos = 0
. Then, at each iteration, we increase its value pos = pos + 1
, and then we added random_numbers[pos]
to the previous total_sum
value, effectively updating the cumulative sum.
For comparison purposes, consider this other while
loop. It looks extremely similar to the preceding loop but there is an important difference.
# initialize object of cumulative sum
= 0
total_sum
# declare iterator
= 1
pos
# repetitive steps
while (total_sum <= 100) {
= total_sum + random_numbers[pos]
total_sum = pos + 1
pos
}
# what is the value of the cumulative sum?
total_sum
[1] 130
# how many iterations were necessary?
pos
[1] 6
Can you see the difference between these two while
loops?
In this second loop, the iterator is declared as pos = 1
, and its value is increased after updating the cumulative sum. While total_sum
has the correct value, pos
does not indicate anymore the right number of iterations.
I wanted to show you this second example to make a point: in a while
loop you not only need to declare the iterator before entering the loop, but you also need to carefully think what initial value you’ll use, as well as when to increase its value inside the loop. Some times the very first thing to do in each iteration is to increase the value of the iterator; some times that’s the last thing to do. It all depends on the specific way you are approaching a given iterative task.
Sometimes we need to skip a certain iteration if a given condition is met, this can be done with the next
statement. The following code chunk contains an abstract template that uses next
:
<- initial
iterator
while (condition) {
do_somethingif (skip_condition) {
next
}<- iterator + 1
iterator }
As a less abstract example, let’s bring back the while loop of the cumulative sum of random numbers, but this time say we want to skip any numbers between 30 and 39. This means we need an if-else
statement to check whether a given element of random_numbers
is between 30 and 39. If yes, we should skip that element and go to the next
iteration. Here is how to do it:
= 0
total_sum = 0
pos
while (total_sum <= 100) {
= pos + 1
pos if (random_numbers[pos] %in% 30:39) {
next
}= total_sum + random_numbers[pos]
total_sum
}
total_sum
[1] 121
pos
[1] 6
In addition to skipping certain iterations, sometimes we need to stop a loop from iterating if a given condition is met. This can be done with the break
statement, which is shown below in an abstract code template:
while (condition) {
expr1
expr2if (stop_condition) {
break
}
expr3
expr4 }
Let’s go back to the cumulative sum example. Say we want to stop iterating if numbers are greater than or equal to 40. Like we did previously, we need again an if-else
statement to check whether a given element of random_numbers
is greater than or equal to 40. If yes, we stop the loop from iterating by using the break
statement as follows:
= 0
total_sum = 0
pos
while (total_sum <= 100) {
= pos + 1
pos if (random_numbers[pos] >= 40) {
break
}= total_sum + random_numbers[pos]
total_sum
}
total_sum
[1] 84
pos
[1] 5