Introduction to the R Language Introduction to the R Language

Control Structures
Roger Peng, Associate Professor
Johns Hopkins Bloomberg School of Public Health
Control Structures Control Structures
Control structures in R allow you to control the ow of execution of the program, depending on
runtime conditions. Common structures are
Most control structures are not used in interactive sessions, but rather when writing functions or
longer expresisons.
if, else: testing a condition
for: execute a loop a xed number of times
while: execute a loop while a condition is true
repeat: execute an innite loop
break: break the execution of a loop
next: skip an interation of a loop
return: exit a function

2/14
Control Structures: if Control Structures: if
if(<condition>) {
## do something
} else {
## do something else
}
if(<condition1>) {
## do something
} else if(<condition2>) {
## do something different
} else {
## do something different
}
3/14
if if
This is a valid if/else structure.
So is this one.
if(x > 3) {
y <- 10
} else {
y <- 0
}
y <- if(x > 3) {
10
} else {
0
}
4/14
if if
Of course, the else clause is not necessary.
if(<condition1>) {
}
if(<condition2>) {
}
5/14
for for
for loops take an interator variable and assign it successive values from a sequence or vector. For
loops are most commonly used for iterating over the elements of an object (list, vector, etc.)
This loop takes the i variable and in each iteration of the loop gives it values 1, 2, 3, ..., 10, and then
exits.
for(i in 1:10) {
print(i)
}
6/14
for for
These three loops have the same behavior.
x <- c("a", "b", "c", "d")
for(i in 1:4) {
print(x[i])
}
for(i in seq_along(x)) {
print(x[i])
}
for(letter in x) {
print(letter)
}
for(i in 1:4) print(x[i])
7/14
Nested for loops Nested for loops
for loops can be nested.
Be careful with nesting though. Nesting beyond 23 levels is often very difcult to read/understand.
x <- matrix(1:6, 2, 3)
for(i in seq_len(nrow(x))) {
for(j in seq_len(ncol(x))) {
print(x[i, j])
}
}
8/14
while while
While loops begin by testing a condition. If it is true, then they execute the loop body. Once the loop
body is executed, the condition is tested again, and so forth.
While loops can potentially result in innite loops if not written properly. Use with care!
count <- 0
while(count < 10) {
print(count)
count <- count + 1
}
9/14
while while
Sometimes there will be more than one condition in the test.
Conditions are always evaluated from left to right.
z <- 5
while(z >= 3 && z <= 10) {
print(z)
coin <- rbinom(1, 1, 0.5)
if(coin == 1) { ## random walk
z <- z + 1
} else {
z <- z - 1
}
}
10/14
repeat repeat
Repeat initiates an innite loop; these are not commonly used in statistical applications but they do
have their uses. The only way to exit a repeat loop is to call break.
x0 <- 1
tol <- 1e-8
repeat {
x1 <- computeEstimate()
if(abs(x1 - x0) < tol) {
break
} else {
x0 <- x1
}
}
11/14
repeat repeat
The loop in the previous slide is a bit dangerous because theres no guarantee it will stop. Better to
set a hard limit on the number of iterations (e.g. using a for loop) and then report whether
convergence was achieved or not.
12/14
next, return next, return
next is used to skip an iteration of a loop
return signals that a function should exit and return a given value
for(i in 1:100) {
if(i <= 20) {
## Skip the first 20 iterations
next
}
## Do something here
}
13/14
Control Structures Control Structures
Summary
Control structures like if, while, and for allow you to control the ow of an R program
Innite loops should generally be avoided, even if they are theoretically correct.
Control structures mentiond here are primarily useful for writing programs; for command-line
interactive work, the *apply functions are more useful.

14/14