Workshop 1

23 April 2011

Installing R

The latest version of an R installation binary (or source code) can be downloaded from one of the Comprehensive R Archive Network (or CRAN) mirrors. Having selected one of the (Australian) mirrors, follow one of the sets of instructions below (depending on your operating system).

Windows

MacOSX

Linux

Basic Syntax

The R environment and command line

A first look at R

Upon opening R, you are presented with the R Console along with the command prompt (>). R is a command driven application (as opposed to a 'point-and-click' application) and despite the steep learning curve, there are many very good reasons for this.

Commands that you type are evaluated once the Enter key has been pressed

Enter the following command at the command prompt (>);

This evaluates the command five plus one and returns the result (six).. The [1] before the 6 indicates that the object immediately to its right is the first element in the returned object. In this case there is only one object returned. However, when a large set of objects (e.g. numbers) are returned, each row will start with an index number thereby making it easier to count through the elements.

Important definitions

Expressions, Assignment and Arithmetic

Instead of evaluating a statement and printing the result directly to the console, the results of evaluations can be stored in an object via a process called 'Assignment'. Assignment assigns a name to an object and stores the result of an evaluation in that object. The contents of an object can be viewed (printed) by typing the name of the object at the command prompt and hitting Enter.

A single command (statement) can spread over multiple lines. If the Enter key is pressed before R considers the statement complete, the next line in the console will begin with the prompt + indicating that the statement is not complete.

When the contents of an object are numbers, standard arithmetic applies;

Objects can be concatenated (joined together) to create objects with multiple entries. Object concatenation is performed using the c() function.

Sessions and Workspaces

A number of objects have been created in the current session (a session encapsulates all the activity since the current instance of the R application was started). To review the names of all of the objects in the users current workspace (storage of user created objects);

From the above output, ignore the elements 'printVerbatim', 'Routput' and 'SweaveSyntaxHTML' - they are objects that are involved in the production of this web-page! Note, the [5] indicating that the second row of output starts with the fifth element of the output.

You can also refine the scope of the ls() function to search for object names that match a pattern;

The longer the session is running, the more objects will be created resulting in a very cluttered workspace. Unneeded objects can be removed using the rm() function;

Current working directory

The R working directory (location from which files/data are read and written) is by default, the location of the R executable (or execution path in Linux). The current working directory can be reviewed and changed (for the session) using the getwd() function and setwd() function respectively.

Quitting elegantly

To quit R, issue the following command; Note in Windows and MacOSX, the application can also be terminated using the standard Exiting protocols.

You will then be asked whether or not you wish to save the current workspace. If you do, enter 'Y' otherwise enter 'N'. Unless you have a very good reason to save the workspace, I would suggest that you do not. A workspace generated in a typical session will have numerous poorly named objects (objects created to temporarily store information whilst testing). Next time R starts, it could restore this workspace thereby starting with a cluttered workspace, but becoming a potential source of confusion if you inadvertently refer to an object stored during a previous session.

Getting help

There are numerous ways of seeking help on R syntax and functions (the following all ways of finding information about a function that calculates the mean of a vector).

• Providing the name of the function as an argument to the help(mean)function
  > help(mean)
• Typing the name of the function preceded by a '?'
  > ?mean
• To run the examples within the standard help files, use the example() function
  > example(mean)
• Some packages include demonstrations that showcase their features and use cases. The demo() function provides a user-friendly way to access these demonstrations. For example, to respectively get an overview of the basic graphical procedures in R and get a list of available demonstrations;
  > demo(graphics) #run the graphics demo
  > demo() #list all demos available on your system
  Note in the above example everything following the # (comment character) is ignored. This provides a way of including comments.
• If you don't know the exact name of the function, the apropos() function is useful as it returns the name of all objects from the current search list that match a specific pattern;

  > apropos("mea")

   [1] "colMeans"           "influence.measures" "kmeans"            

   [4] "mean"               "mean.data.frame"    "mean.Date"         

   [7] "mean.default"       "mean.difftime"      "mean.POSIXct"      

  [10] "mean.POSIXlt"       "rowMeans"           "weighted.mean"     

• If you have no idea what the function is called, the help.search() and help.start() functions search through the regular manuals and the local HTML manuals (via a web browser) respectively for specific terms;
  > help.search('mean') #search the local R manuals
  > help.start() #search the local HTML R manuals

Functions

As a wrapper for a collection of commands used together to perform a task, functions provide a convenient way of interacting with all of these commands in sequence. Most functions require one or more inputs (arguments), and while a particular function can have multiple arguments, not all are necessarily required (some could have default values).

Consider the seq() function, which generates a sequence of values (a vector) according to the values of the arguments. This function has the following definition;

• If the function is called without any arguments (e.g. seq()), it will return a single number 1. Using the default arguments for the function, it returns a vector starting at 1 (from=1), going up to 1 (to=1) and thus having a length of 1.
• We can alter this behavior by specifically providing values for the named arguments. The following generates a sequence of numbers from 2 to 10 incrementing by 1 (default);

> seq(from = 2, to = 10)

[1]  2  3  4  5  6  7  8  9 10

• The following generates a sequence of numbers from 2 to 10 incrementing by 2;

> seq(from = 2, to = 10, by = 2)

[1]  2  4  6  8 10

• Alternatively, instead of manipulating the increment space of the sequence, we could specify the desired length of the sequence;

> seq(from = 2, to = 10, length.out = 3)

[1]  2  6 10

• Named arguments need not include the full name of the parameter, so long as it is unambiguous which parameter is being referred to. For example, length.out could be shortened to just l since there are no other parameters of this function that start with 'l';

> seq(from = 2, to = 10, l = 4)

[1]  2.000000  4.666667  7.333333 10.000000

• Parameters can also be specified as unnamed arguments provided they are in the order specified in the function definition. For example to generate a sequence of numbers from 2 to 10 incrementing by 3;

> seq(2, 10, 2)

[1]  2  4  6  8 10

• Named and unnamed arguments can be mixed, just remember the above rules about parameter order and unambiguous names;

> seq(2, 10, l = 4)

[1]  2.000000  4.666667  7.333333 10.000000

Data Types

Vectors

Vectors are a collection of one or more entries (values) of the same type (class) and are the basic storage unit in R. Vectors are one-dimensional arrays (have a single dimension - length) and can be thought of as a single column of data. Each entry in a vector has a unique index (like a row number) to enable reference to particular entries in the vector.

The c() function

The c() function concatenates values together into a vector. To create a vector with the numbers 1, 4, 7, 21;

As an example, we could store the temperature recorded at 10 sites;

To create a vector with the words 'Fish', 'Rock', 'Tree', 'Git';

Regular or patterned sequences

We have already seen the use of the seq() function to create sequences of entries.

Sequences of repeated entries are supported with the rep() function;

The paste() function

To create a sequence of quadrat labels we could use the c() function as illustrated above,e.g.

A more elegant way of doing this is to use the paste() function;

This can be useful for naming vector elements. For example, we could use the names() function to name the elements of the temperature variable according to the quadrat labels.

Vector Classes

Factors

Factors are more than a vector of characters. Factors have additional properties that are utilized during statistical analyses and graphical procedures. To illustrate the difference, we will create a vector to represent a categorical variable indicating the level of shading applied to 10 quadrats. Firstly, we will create a character vector;

Now we convert this into a factor;

Notice the additional property (Levels) at the end of the output. Notice also that unless specified otherwise, the levels are ordered alphabetically. Whilst this does not impact on analyses, it does effect interpretations and graphical displays. If the alphabetical ordering does not reflect the natural order of the data, it is best to reorder the levels whilst defining the factor;

A more convenient way to create a balanced (equal number of replicates) factor is to use the gl() function. To create the shading factor from above;

Matrices

Matrices have two dimensions (length and width). The entries (which must be all of the same type - class) are in rows and columns.

We could arrange the vector of shading into two columns;

As another example, we could store the X,Y coordinates for five quadrats within a grid. We start by generating separate vectors to represent the X and Y coordinates and then we bind them together using the cbind() function;

We could even alter the row names;

Lists

Lists provide a way to group together multiple objects of different type. For example, whilst the contents of any single vector or matrix must all be of the one type (e.g. all numeric or all character) a list can contain a vector or numerics and a matrix or characters. Furthermore, the objects contained in a list do not need to be of the same lengths (c.f data frames). The output of most analyses are stored as lists.

As an example, we could group together the previously created isolated vectors and matrices into a single object that encapsulates the entire experiment;

Object Manipulation

Indexing

Indexing is the means by which data are filtered (subsetted) to include and exclude certain entries.

Vector indexing

Subsets of vectors are produced by appending an index vector (inclosed in square brackets []) to a vector name. There are four common forms of vector indexing used to extract a subset of vectors

• Vector of positive integers - a set of integers that indicate which elements of the vector should be included;

> TEMPERATURE[2]

  Q2 

30.6 

> TEMPERATURE[2:5]

  Q2   Q3   Q4   Q5 

30.6 31.0 36.3 39.9 

> TEMPERATURE[c(1, 5, 6, 9)]

  Q1   Q5   Q6   Q9 

36.1 39.9  6.5  9.7 

• Vector of negative integers - a set of integers that indicate which elements of the vector should be excluded;

> TEMPERATURE[-2]

  Q1   Q3   Q4   Q5   Q6   Q7   Q8   Q9  Q10 

36.1 31.0 36.3 39.9  6.5 11.2 12.8  9.7 15.9 

> TEMPERATURE[c(1, 5, 6, 9) * -1]

  Q2   Q3   Q4   Q7   Q8  Q10 

30.6 31.0 36.3 11.2 12.8 15.9 

• Vector of character strings (referencing names) - for vectors whose elements have been named, a vector of names can be used to select elements to include;

> TEMPERATURE["Q1"]

  Q1 

36.1 

> TEMPERATURE[c("Q1", "Q4")]

  Q1   Q4 

36.1 36.3 

• Vector of logical values - a vector of logical values (TRUE or FALSE) the same length as the vector being subsetted. Entries corresponding to a logical TRUE are included, FALSE are excluded;

> TEMPERATURE[TEMPERATURE < 15]

  Q6   Q7   Q8   Q9 

 6.5 11.2 12.8  9.7 

> TEMPERATURE[SHADE == "no"]

  Q1   Q2   Q3   Q4   Q5 

36.1 30.6 31.0 36.3 39.9 

> TEMPERATURE[TEMPERATURE < 34 & SHADE == "no"]

  Q2   Q3 

30.6 31.0 

> TEMPERATURE[TEMPERATURE < 10 | SHADE == "no"]

  Q1   Q2   Q3   Q4   Q5   Q6   Q9 

36.1 30.6 31.0 36.3 39.9  6.5  9.7 

Matrix indexing

Similar to vectors, matrices can be indexed using positive integers, negative integers, character strings and logical vectors. However, whereas vectors have a single dimension (length), matrices have two dimensions (length and width). Hence, indexing needs to reflect this. It is necessary to specify both the row and column number. Matrix indexing takes of the form of [row.indices, col.indices] where row.indices and col.indices respectively represent sequences of row and column indices. If a row or column index sequence is omitted, it is interpreted as the entire row or column respectively.

Sorting

The sort() function is used to sort vector entries in increasing order.

The order() function is used to get the position of each entry in a vector if it were sorted.

The rank() function is used to get the ranking of each entry in a vector if it were sorted.

Pivot tables

The apply() family of functions applies a function to the margins (1=row margins, 2=column margins) of a matrix.

Lets say we wanted to represent the abundance of three species of fish in three types

We could now calculate the column means (mean abundance of each species across habitats);

The tapply() function applies a function to a vector separately for each level of a factorial variable. For example, if we wanted to calculate the mean temperature for each level of the shade variable;

R Editors

Notepad++

RStudio

Emacs

Feature	Notepad ++	RStudio	Emacs
Platform	Win only	Win,Mac,Linux	Win,Mac,Linux
Syntax Highlighting	Yes	Yes	Yes
Bracket matching	Yes		Yes
Integrated Console	No	Yes	Yes
Auto-complete	Yes	Yes	Yes
Parameter prompting and integrated help	No	Yes	No
Code folding	Yes	No	Yes