As well being a statistical computing environment, R is also a programming language. The topic of R programming is beyond the scope of this book. However, this chapter gives a brief introduction to basic programming and writing your own functions.

When programming, use a script file so that you can edit your code easily. Remember to add plenty of comments with the hash symbol (#), so that your script can be understood by others or by yourself at a later date.

Creating New Functions

Throughout this book, you will have used many of R’s built-in functions, but it is also possible to create your own. Creating your own function allows you to neatly bundle together a group of commands that perform a specific task that you want to use repeatedly.

To create a new function, the script takes the following general form:

functionname<-function(arg1name,arg2name, ..., argNname) {
 
     command(s)
      
     return(outputvalue)
}

All of the indentation and additional blank lines are optional, but they help to show the hierarchy of the program and are considered good programming practice.

The first line determines the name of the function and the names of the input arguments. You can include as many arguments as required, or none at all. Optionally, you can assign default values to the arguments:

functionname<-function(arg1name=value1,arg2name=value2, ...,argNname=valueN) {
 
     command(s)
      
     return(outputvalue)
}

This first line of the script ends with an opening curly bracket. After this is where the main content of the function begins. Generally, this is a set of commands that manipulate the input arguments in some way, or perform calculations from them, in order to create an output. The commands can make use of existing functions, including any that you have written yourself. Note that any objects that you create within a function exist only inside the function and are not saved to the workspace.

The return function determines the output of the function, which is either displayed in the console or assigned to an object whenever the function is used. It can either be a literal value such as a number or character string, or a it can be a vector, data frame or any other type of object.

Instead of using the return function in the final command, you can use the print function, which always displays the output in the console window even if the output is assigned to an object. Alternatively, you may want to create a function that produces a plot instead of giving an output value. In this case, the final command would be plot or another plotting function.

Finally, the script ends with a closing curly bracket.

Once you have written your function and run the script, the function is saved to the workspace as an object and is available to use for as long as the current workspace is loaded. You can use it just like a built-in function:

>functionname(value1,value2, ..., valueN)

Conditional Statements

Consider the cube.root function created in Example B-1. If you try to input a negative number, you get the result shown here.

> cube.root(-5)

It would be nice if the function could return an error message to explain to the user what went wrong. In order to do this, the function would need to behave differently depending on whether the user inputs a positive number or a negative number. This is what a conditional statement allows you to do.

A conditional statement allows you to perform a command or set of commands only under certain circumstances (called the condition). Conditional statements add flexibility to your functions, as they allow the function to behave in different ways depending on the input.

There are a few types of conditional statement that allow you to do slightly different things. Before looking at these, you need to understand conditions and how they are constructed in R.

> 6>8

[1] FALSE

> vector1<-c(4,2,1,6)
> 2 %in% vector1

[1] TRUE

> object1<-4
> object1<5

[1] TRUE

> 3<5 & 7<5

[1] FALSE

> 3<5 & 7>5

[1] TRUE

> 3<5 | 7<5

[1] TRUE

> 3<5 | 7>5

[1] TRUE

> !3<5

[1] FALSE

> !(3<5 & 7<5)

[1] TRUE

if (condition)command

if (condition) {
 
     commands to be performed if condition is true
 
}

> cube.root(5)

[1] 1.709976

> cube.root(-5)

[1] NaN
Warning message:
In cube.root(-5) : Cannot calculate cube root of negative number

if (condition)command1elsecommand2

if (condition) {
 
     commands to be performed if condition is true
 
} else {
 
     commands to be performed if condition is false
 
}

if (condition1) command1 else if (condition2) command2 else command3

> switch(input, option1=command1, option2=command2, option3=command3, command4)

> switch(input, value1, value2, value3, value4)

times.table<-function(x) {
 
     result<-x*1                                   # Calculate result for x*1
     text<-paste(x, "times 1 equals", result)      # Create character string
                                                   # giving the result
     print(text)                                   # Print the result
 
     # Repeat for numbers 2 to 10:
     Result<-x*2
     text<-paste(x, "times 2 equals", result)
     print(text)
 
     result<-x*3
     text<-paste(x, "times 3 equals", result)
     print(text)
 
     # Continues to x*10
 
}

for (i in startvalue:endvalue) command

for i in c(5,7,8,2,11) command

for (i instartvalue:endvalue) {
 
     commands to be repeated
 
}

while (condition)command

while (condition) {
 
     commands to be repeated
 
}

i<-1
while (i<10) {
 
     print(i)
     i<-i+1
 
}

b<-2
while (b<3) {
     print(b)
     a<-4
}