As R is a statistical programming language it also provides the standard programming constructs such as loops, if statements, and the ability to write functions.
A function needs to have a name, probably at least one argument (although it doesn’t have to), and a body of code that does something. At the end it usually should (although doesn’t have to) return an object out of the function. The general syntax for writing your own function is
name.of.function <- function(arg1, arg2, arg3=2, ...) {
# function code to do some useful stuff
return(something) # return value
}name.of.function: is the function’s
name. This can be any valid variable name, but you should avoid using
names that are used elsewhere in R, such as mean,
function, plot, etc.arg1, arg2,
arg3: these are the arguments of the function. You
can write a function with any number of arguments, or none at all. These
can be any R object: numbers, strings, arrays, data frames, of
even pointers to other functions; anything that is needed for the
name.of.function function to run. Some arguments have
default values specified, such as arg3 in our example.
Arguments without a default must have a value supplied for the function
to run. You do not need to provide a value for those arguments with a
default as they are considered as optional, and when omitted the
function will simply use the default value in its definition.... argument: The …, or
ellipsis, element in the function definition allows for other
unspecified optional arguments to be passed into the function, which are
usually passed onto to another function. This technique is often in
plotting, but has uses in many other places.{} brackets is run every time the function is called.
This code might be very long or very short. Ideally functions are short
and do just one thing – problems are rarely too small to benefit from
some abstraction. Sometimes a large function is unavoidable, but usually
these can be in turn constructed from a bunch of small functions. More
on that below.For example, we can write a function to compute the sum of squares of two numbers as
sum.of.squares <- function(x,y) {
return(x^2 + y^2)
}and we can then evaluate
sum.of.squares(3,4)## [1] 25Now, it’s not necessarily the case that you must use
return() at the end of your function. If we don’t
explicitly return something, then R will
automatically return the results of evaluating the last statement inside
the function. The reason you return an object (aside from
making your code more readable) is if you’ve saved the value of your
statements into an object inside the function. Variables created inside
a function only exist within that function, and won’t appear outside in
your workspace. See how it works in the following two examples:
fun1 <- function(x) {
3 * x - 1
}
fun1(5)## [1] 14fun2 <- function(x) {
y <- 3 * x - 1
}
fun2(5)In the first function, I just evaluate the statement
3*x-1 without saving it anywhere inside the function. So
when I run fun1(5), the result comes popping out of the
function. However, when I call fun2(5), nothing happens.
That’s because the object y that I saved my result into
doesn’t exist outside the function and I haven’t used
return(y) to pass the value of y outside the
function. If I try to use y outside of the function, I will
encounter errors because it only exists within the local
environment of the function. I can return the value of
y using the return(y) at the end of the
function fun2, but I can’t return the object itself; it’s
stuck inside the function.
Conceptually, a loop is a way to repeat a sequence of instructions
under certain conditions. They allow you to automate parts of your code
that are in need of repetition. Typically, there are two types of loops.
Loops which execute for a prescribed number of times, as controlled by a
counter or an index, incremented at each iteration cycle are represented
as for loops in R. Loops that are based on the
testing of a logical condition at each iteration in the loop are
while or repeat loops.
In R a for {#for} loop takes the following
general form
for (variable in sequence) {
## code to repeat goes here
}where variable is a name given to the iteration variable
and which takes each possible value in the vector sequence
at each pass through the loop. Here is a quick trivial example, printing
the square root of the integers one to ten:
for (x in 1:10) {
print(sqrt(x))
}## [1] 1
## [1] 1.414214
## [1] 1.732051
## [1] 2
## [1] 2.236068
## [1] 2.44949
## [1] 2.645751
## [1] 2.828427
## [1] 3
## [1] 3.162278As with the example above, there is often no need to explicity write
for loops to repeat calculations in R code as most
built-in functions and arithmetic can be evaluated for vector arguments
anyway (and usually more efficiently). For the example above, simply
evaluating sqrt(1:10) would give the answer we need for
rather less typing
sqrt(1:10)## [1] 1.000000 1.414214 1.732051 2.000000 2.236068 2.449490 2.645751 2.828427
## [9] 3.000000 3.162278A break statement is used inside a loop
(for, while) to stop the iterations and jump
to the code outside of the loop. In a nested looping situation, where
there is a loop inside another loop, this statement exits from the
innermost loop that is being evaluated.
x <- 1:5
for (val in x) {
if (val == 3){
break
}
print(val)
}## [1] 1
## [1] 2Conversely, a next statement is useful when we want to
skip the rest of the code in current iteration of a loop without
terminating it. On encountering next, R skips any
further evaluation and starts next iteration of the loop.
x <- 1:5
for (val in x) {
if (val == 3){
next
}
print(val)
}## [1] 1
## [1] 2
## [1] 4
## [1] 5R Help: for
We saw above how to use a for loop to apply the same
code to a collection of objects described by the sequence
over which we are looping. However, we can achieve the same results by
writing a function to perform the code within the body of the loop, and
then applying that function to every element of sequence. Handily,
R has a family of functions, the ‘apply’ family, which do
exactly that. We will use the following two members of apply function
family:
sapply - applies a function to every element of a
vector and returns a vector formed from the resultsapply - applies a function to the either the rows or
the columns of a matrix (or data frame)Each of these has an argument FUN which takes a function
to apply to each element of the object. So, to replicate the simple
example above using apply, we would write
sapply(1:10, FUN=sqrt)## [1] 1.000000 1.414214 1.732051 2.000000 2.236068 2.449490 2.645751 2.828427
## [9] 3.000000 3.162278Unlike a loop, sapply automatically returns its results
as a vector (or whatever form is most natural) without us having to
write code for that. Therefore, if we combine this technique with the
ability to write our own functions then we have a very flexible way of
re-writing a standard loop in a vectorised way. In general, using an
apply-type function is to be preferred to a
for loop particularly when we want to keep the results of
the calculations from each iteration. However, for loops
are still useful and more natural in certain cases (where we do not want
the output values, or where each iteration has a dependency on the
calculations at the previous step).
The apply function can be used to evaluate the same
function for either every row or every column of a given matrix (or data
frame). To apply the function over rows we supply the argument
MARGIN=1, and to apply to each column we set
MARGIN=2. We must also provide the function we wish to
apply in the FUN argument.
For example, to calculate the means of each column in the
mtCars data set, we could write
data(mtcars)
apply(mtcars, MARGIN=2, FUN=mean)## mpg cyl disp hp drat wt qsec
## 20.090625 6.187500 230.721875 146.687500 3.596563 3.217250 17.848750
## vs am gear carb
## 0.437500 0.406250 3.687500 2.812500Thus apply is very useful for quickly computing
summaries and calculations across entire data sets.
A standard programming construct is the if statement,
which are used to tell R that we want to make a choice based on
the results of a test.
if(test){
## do this code if TRUE
} else{
## do this code if FALSE
}If the test is TRUE, then the code inside
the if statement (i.e., the lines in the curly braces
underneath it) is executed. If the test is
FALSE, the body of the else is executed instead. Only one
or the other is ever executed:
x <- -5
if(x > 0){
print("Non-negative number")
} else {
print("Negative number")
}## [1] "Negative number"We can chain a sequence of if and else
statements together to consider a sequence of alternative test
conditions:
x <- 0
if (x < 0) {
print("Negative number")
} else if (x > 0) {
print("Positive number")
} else {
print("Zero")
}## [1] "Zero"