Loops in R

In this guide, we're going to dive into the concept of loops and their implementation in the R programming language. 

What exactly is a loop? A loop is a fundamental programming construct that allows for the repeated execution of a code block. Each cycle through the loop is known as an iteration. Through iterations, a loop efficiently manages repetitive tasks, minimizing the need for redundant code.

In R, there are primarily two kinds of loops: for loops and while loops.

Let's explore their functionality and how to leverage them for effective programming.

For Loop

The for loop in R iterates over a block of code a set number of times, making it ideal for when you know in advance how many times you need to repeat an action.

1. for (variable in sequence) {
2. # Executable Code
3. }

During each iteration, the loop variable takes the next value in the sequence, and the code within the curly braces {} executes. Once the loop exhausts the sequence, it concludes.

Consider this practical example:

Let's say you want to print numbers from 1 to 5:

1. for (i in 1:5) {
2. print(i)
3. }

In this R for loop, the counter "i" sequentially assumes values from 1 to 5. In each iteration, the print(i) function outputs the current value of "i". The loop runs five times, printing the numbers 1 through 5 in order.

1
2
3
4
5

While Loop

The while loop performs a set of instructions as long as a specified condition remains true, making it more flexible than the for loop, especially when the number of iterations is not predetermined.

1. while (condition) {
2. # Executable Code
3. }

The code to be repeated is enclosed in curly braces and can consist of multiple statements.

For instance, here's how you can print numbers from 1 to 5 using a while loop:

1. i <- 1
2. while (i <= 5) {
3. print(i)
4. i <- i + 1
5. }

In this R code snippet, the variable "i" starts at 1. The while loop keeps running as long as i is less than or equal to 5, printing i's value during each cycle. The variable i is incremented after each iteration, and the loop terminates once i exceeds 5.

1
2
3
4
5

Differing from the for loop, the while loop can execute both definite and indefinite cycles.

What differentiates determined and undetermined loops? Determined loops perform a set number of iterations, following a predefined sequence or range. In contrast, undetermined loops, such as while loops, continue until a specified condition is no longer met. With undetermined loops, the total number of iterations is not known beforehand, posing a risk of infinite looping.

The Infinite Loop Hazard

A while loop might not have a preset number of iterations, continuing as long as its condition is met. This can potentially lead to an infinite loop if the condition never becomes false.

An infinite loop example: this code will run indefinitely since the condition (i>0) remains perpetually true. The variable "i" starts at 1 and increases with each iteration, always staying positive.

1. i <- 1
2. while (i >0) {
3. print(i)
4. i <- i + 1
5. }

To mitigate infinite loop risks, it's prudent to implement a forced exit condition.

For instance, you can set the loop to terminate after 1000 iterations with an error message, as shown in the following code:

1. i <- 1
2. while (i >0) {
3. print(i)
4. i <- i + 1
5. # Forced exit condition after a thousand iterations
6. if (i>1000) {
7. print("error: infinite loop")
8. break
9. }
10. }

Controlling Loops with break and next

The break and next statements offer additional control by allowing for the premature termination of loops.

Using the break Statement

This statement halts the loop immediately, proceeding to the next line of code after the loop. For example, in the following snippet, the loop ends after 1000 iterations:

1. i <- 1
2. while (i >0) {
3. print(i)
4. i <- i + 1
5. if (i>1000) {
6. print("error: infinite loop")
7. break
8. }
9. }

Understanding the 'next' Statement

The 'next' statement plays a crucial role in controlling the flow of loops. It prematurely terminates the current iteration, moving directly to the subsequent one.

Importantly, 'next' does not end the loop itself. It only skips the remainder of the current iteration. For example, consider the following loop that prints numbers from 1 to 5, skipping the number 4.

1. i <- 1
2. while (i <= 5) {
3. if (i == 4) { next }
4. print(i)
5. i <- i + 1
6. }
7. }

In this scenario, the loop skips printing the number 4 as the 'next' statement halts the fourth iteration before it can output the current value of 'i'.

1
2
3
5

The 'next' statement is particularly useful for bypassing the remainder of a loop's iteration when certain conditions are met, efficiently moving to the next cycle.