A review of the language |
471 |
will work. So will
> 3 + 2 + 5
[1] 10
The + sign at the end of the first line indicates that the statement isn’t complete. But
>3 + 2 [1] 5
>+ 5 [1] 5
obviously doesn’t work, because 3 + 2 is interpreted as a complete statement. Sometimes you need to process code nonsequentially. You may want to execute
code conditionally or repeat one or more statements multiple times. This section describes three control-flow functions that are particularly useful in writing functions: for(), if(), and ifelse().
FOR LOOPS
The for() function allows you to execute a statement repeatedly. The syntax is
for(var in seq){ statements
}
where var is a variable name and seq is an expression that evaluates to a vector. If there is only one statement, the curly braces are optional:
>for(i in 1:5) print(1:i) [1] 1 [1] 1 2
[1] 1 2 3 [1] 1 2 3 4
[1] 1 2 3 4 5
>for(i in 5:1)print(1:i) [1] 1 2 3 4 5 [1] 1 2 3 4 [1] 1 2 3 [1] 1 2 [1] 1
Note that var continues to exist after the function exits. Here, i equals 1.
IF() AND ELSE
The if() function allows you to execute statements conditionally. The syntax for the if() construct is
if(condition){ statements
} else { statements
}
472 |
CHAPTER 20 Advanced programming |
The condition should be a one-element logical vector (TRUE or FALSE) and can’t be missing (NA). The else portion is optional. If there is only one statement, the curly braces are also optional.
As an example, consider the following code fragment:
if(interactive()){ plot(x, y)
} else { png("myplot.png") plot(x, y) dev.off()
}
If the code is being run interactively, the interactive() function returns TRUE and a plot is sent to the screen. Otherwise, the plot is saved to disk. You’ll use the if() function extensively in chapter 21.
IFELSE()
The ifelse() function is a vectorized version of if(). Vectorization allows a function to process objects without explicit looping. The format of ifelse() is
ifelse(test, yes, no)
where test is an object that has been coerced to logical mode, yes returns values for true elements of test, and no returns values for false elements of test.
Let’s say that you have a vector of p-values that you have extracted from a statistical analysis that involved six statistical tests, and you want to flag the tests that are significant at the p < .05 level. This can be accomplished with the following code:
>pvalues <- c(.0867, .0018, .0054, .1572, .0183, .5386)
>results <- ifelse(pvalues <.05, "Significant", "Not Significant")
>results
[1] "Not Significant" "Significant" "Significant"
[4] "Not Significant" "Significant" "Not Significant"
The ifelse() function loops through the vector pvalues and returns a character vector containing the value "Significant" or "Not Significant" depending on whether the corresponding element of pvalues is greater than .05.
The same result can be accomplished with explicit loops using
pvalues <- c(.0867, .0018, .0054, .1572, .0183, .5386) results <- vector(mode="character", length=length(pvalues)) for(i in 1:length(pvalues)){
if (pvalues[i] < .05) results[i] <- "Significant" else results[i] <- "Not Significant"
}
The vectorized version is faster and more efficient.
There are other control structures, including while(), repeat(), and switch(), but the ones presented here are the most commonly used. Now that you have data structures and control structures, we can talk about creating functions.
474 |
CHAPTER 20 Advanced programming |
Parameters are passed by value, not by reference. Consider this function statement:
result <- lm(height ~ weight, data=women)
The dataset women isn’t accessed directly. A copy is made and passed to the function. If the women dataset was very large, RAM could be used up quickly. This can become an issue when you’re dealing with big data problems, and you may need to use special techniques (see appendix G).
OBJECT SCOPE
The scope of the objects in R (how names are resolved to produce contents) is a complex topic. In the typical case,
■Objects created outside of any function are global (can be resolved within any function). Objects created within a function are local (available only within the function).
■Local objects are discarded at the end of function execution. Only objects passed back via the return() function (or assigned using an operator like <<-) are accessible after the function finishes executing.
■Global objects can be accessed (read) from within a function but not altered (again, unless the <<- operator is used).
■Objects passed to a function through parameters aren’t altered by the function. Copies of the objects are passed, not the objects themselves.
Here is a simple example:
>x <- 2
>y <- 3
>z <- 4
>f <- function(w){ z <- 2
x <- w*y*z
return(x)
}
>f(x) [1] 12
>x [1] 2
>y [1] 3
>z [1] 4
In this example, a copy of x is passed to the function f(), but the original isn’t altered. The value of y is obtained from the environment. Even though z exists in the environment, the value set in the function is used and doesn’t alter the value in the environment.
To understand scoping rules better, we need to discuss environments.