R Intro

To HomePage

Introduction to R

History of S and R

Predecessors of R are S (sometimes called Old S), New S, and S-Plus.
S was created by John Chambers in 1975 while working at Bell Labs. It was inspired by the computer language Scheme, but the syntax of S is most similar to C.
In 1980, the first version of S was distributed outside of Bell Labs.
By 1988, many changes had been made to S. In that year, the book entitled The New S Language was published by Becker, Chambers, and Wilks, that described these changes.
S-Plus was a commercial implementation of S, that was first produced by a Seattle startup company in 1988. This startup company was Statistical Sciences, Inc., and was started by Douglas Martin of the University of Washington.
R is a public domain version of S, first developed by Ross Ihaka and Robert Gentleman at the University of Auckland, New Zealand, in 1997. The name R was partly chosen for the first names of the developers, and was partly as a play on S.
R is very good for interactive analysis and also as a programming language for customizing and extending statistical procedures. R is not as good as SAS for producing well layed out reports that present results of a statistical analyses.

Installing R

Download R from

cran.us.r-project.org/bin/windows/base/

or from one of the sites on

http://cran.r-project.org/mirrors.html
Double click on the installation file R-2.15.2-win32.exe to install R.
The R software will be installed in the new folder c:\Program Files\R.
The actual R program is located at c:\Program Files\R\R-2.15.2\bin\i386\RGui.exe for 32-bit and in c:\Program Files\R\R-2.15.2\bin\x64\RGui.exe for 64-bit.

Invoking R

To invoke the R software, select Start >> All Programs >> R >> R 2.13.0 (or the current version). This will bring up a multiple document interface (MDI) window titled RGui with a child window titled R Console.
To run R commands, simply type them in the R Console Window.
Additional windows may be displayed in the RGui Window, for example graphics.
In this tutorial, the > symbol at the beginning of a line is the R prompt, which should not be typed.
R can also be run from the R Editor, which is invoked by File >> New Script.
Within the R Editor, select the lines of the script to be executed, then right click >> Run line or selection to execute these lines.

Some Useful R Commands

To obtain help on a specific R command, enter help and the command for which you need help in parentheses. For example:
```
> help(hist)
```
A browser window will open with the requested information.
Sometimes you will want to read data from a file or send output, such as graphs, to an output file. Although a full path name can be used to specify the input or output file, it is often useful to specify the current working directory so that a relative path can be used. To set and get the current working directory:
```
> setwd("c:/csc423/s-files")
> getwd( )
[1] c:/csc423/s-files
```
To exit or quit from R:
```
> q( )
```

Vectors and Atomic Elements

The simplest R data structure is the vector, which consists an arbitrary number of primitive atomic elements.
An atomic element is an object that does not contain other objects (such as a list).

The datatype of a primitive object is its mode. Here is a table of the most common modes of atomic elements:

Mode	Meaning	Examples
numeric	Floating Point Numbers	3.1416, -34.0, 5.97e24
character	Character Strings	"elephant", "abc\n", "345"
logical	True or False	TRUE, FALSE, T, F
complex	Complex Numbers	3.43+6.92, 1+0i, 0+1i

Although atomic objects of more than one mode can be used when creating a vector, the elements will be coerced into the least restrictive mode, so that the resulting vector contains elements that are all of the same mode.
Here is a list of the atomic modes, from most restrictive to least restrictive:
Use the c operator to combine atomic elements into a vector. The assignment operator = assigns the vector determined by the expression on the right hand side to the variable x on the left hand side. Some examples:
```
> values = c(33, 5, 429, 37)
> animals = c("dog", "cat", "mouse")
> flags = c(TRUE, FALSE, TRUE, TRUE, FALSE)
```
To display the value of a variable or expression, type the variable or expression at the R command prompt. The value will be shown in the R Command Window:
```
> values
[1]  33   5 429  37
> animals
[1] "dog"  "cat"  "mouse"
> flags
[1]  TRUE FALSE  TRUE  TRUE FALSE
```

Any R object has two attributes mode and length. Use the mode and length functions to obtain the values of these attributes:

> mode(values)
[1] "numeric"
> mode(animals)
[1] "character"
> mode(flags)
[1] "logical"
> length(values)
[1] 4
> length(animals)
[1] 3
> length(flags)
[1] 5

Repetition and Sequences

Use the rep function to repeat a value in a vector:
```
> r = rep(45, 5)
> r
[1]  45  45  45  45  45
```

m:n creates a sequence from m to n, inclusive:

> s = 1:6
> s
[1]  1  2  3  4  5  6
> r = 9:6
[1]  9  8  7  6

Use the seq function to create a more general sequence:

> q = seq(from=3, to=5.5, by=0.5)
> q
[1]  3.0  3.5  4.0  4.5  5.0  5.5
> p = seq(from=900, to=600, by=-100)
[1]  900  800  700  600

Matrices

A matrix is a two-dimensional array of atomic elements. An n×m matrix is a matrix with n rows and m columns.

Use the matrix command to format a vector into rows and columns. This example creates an array with 3 rows and 4 columns. This requires a vector of length 12.

> v = c(4, 2, 5, 9, 4, 7, -1, 6, 0, 3, 2, 7)
> m = matrix(v, 3, 4, byrow=TRUE)
> m
     [,1] [,2] [,3] [,4]
[1,]    4    2    5    9
[2,]    4    7   -1    6
[3,]    0    3    2    7

Here is a table of matrix operators that will be useful in CSC 423:

Operation Operator or Function

Matrix Addition +

Scalar Multiplication *

Matrix Multiplication %*%

Transpose t

Identity diag(nrow=n)

Inverse solve

Operation	Operator or Function
Matrix Addition	+
Scalar Multiplication	*
Matrix Multiplication	%*%
Transpose	t
Identity	diag(nrow=n)
Inverse	solve

Subsetting Vectors and Matrices

The subset operator is [ ].
There are three ways to select a subset of a vector:
1. Use a vector of positive indices
```
> a = c("apple", "orange", "pear", "grape")
> u = c(1, 4)
> a[u]
[1]  "apple" "grape"
```
  The values with indices 1 and 4 are selected from a.
2. Use a vector of positive indices
```
> a = c("apple", "orange", "pear", "grape", "watermelon")
> v = c(-2, -4, -5)
> a[v]
[1]  "apple" "pear"
```
  The values with indices 2, 4, and 5 are omitted from a.
3. Use a vector of boolean values
```
> a = c("apple", "orange", "pear", "grape", "watermelon")
> w = c(F, T, F, T, T)
> a[w]
[1]  "orange"  "grape"  "watermelon"
```
  Only the values corresponding to TRUE, which have indices 2, 4, and 5 are selected.
The subset operator for a matrix takes two inputs:
```
m[5:10, -4]
```
Rows 5 through 10 are selected and column 4 is omitted from the matrix m.

Lists and Data Frames

To create an R data structure with named components, create a list like this:

> scores = list(name=c("Jason", "Ginger", Mary), 
+ midterm=c(89, 93, 90))
> scores
$name
[1]  "Jason"  "Ginger"  "Mary"

$midterm
[1] 89 93 90

> scores$name
[1]  "Jason"  "Ginger"  "Mary"
> scores$midterm
[1] 89 93 90

An alternative to a list is a data frame, which looks more like a conventional dataset:
```
  name   midterm
1 Jason  89
2 Ginger 93
3 Mary   90 
```

To create the preceding data frame:

> scores = data.frame(name=c(Jason, Ginger, Mary), midterm=c(89, 93, 90))

File Input

To read values, either from the keyboard, or from an input file, use the scan function:

> # Enter a blank line to terminate input from keyboard:
> x = scan() 
1: 4 2 5 4 6
6:
Read 5 items.
> x
[1] 4 2 5 4 6
> setwd("c:\r-input")
> getwd()
[1] c:\r-input
> # Default mode of input is numeric:
> x = scan("input.txt")  
> x
[1] 45 65 45  4
> # Set input mode to character:
> y = scan("states.txt", what="character") 
> y
[1] "Illinois"  "Indiana"   "Iowa"  "Nebraska"

To load data from a file in table format, use the read.table function. The current working directory contains the file scores.txt with these contents:
```
 name   midterm
Jason  89
Ginger 93
Mary   90
```
These statements read the table data from a file and load them into a data frame:
```
> scores = read.table("scores.txt", header=TRUE)
> scores
name midterm
Jason 89
Ginger 93
Mary 90
> scores$name
[1] "Jason"  "Ginger"  "Mary" 
> scores$midterm
[i] 89 93 90
```
If header=TRUE is missing, the variable names can still be read from the first row if (1) row numbers are included, and (2) the number of names is one less than the number of fields in the rest of the rows. If the input file looks like this
```
  name   midterm
1 Jason  89
2 Ginger 93
3 Mary   90
```
Read the file like this:
```
> scores = read.table("scores.txt")
```

Running R Statements from a Script

To run R statements from a script file:
```
> source("script.r")
```
Caution: entering an expression in a script file will not automatically display the value of the expression. Use the print function to display the value. For example:
```
> print(mean(x))
```
An alternative to print is the cat command. Using print includes the vector index at the beginning of each output line and quote marks for character data. Using cat suppresses vector indices and quote marks for character data. Also, new line characters (\n) must be explicitly included with cat.

For example:

> cat("The mean of the vector x is ", mean(x), ".\n")

The mean of the vector  3.54.

Redirecting Graphics Output to Disk

To start sending R output to a file instead of the screen:
```
> sink("output.txt")
```
When finished sending output to the file, type
```
> sink( )
```
to resume sending output to the screen.

Redirecting Graphics Output to Disk

To redirect graphics output from the terminal window to a disk file, use one of these R commands:

> pdf("mygraph.pdf")        # Create PDF file.
> png("mygraph.png")        # Create PNG file.
> jpeg("mygraph.jpg")       # Create JPEG file.
> bmp("mygraph.bmp")        # Create BMP file.
> postscript("mygraph.ps")  # Create Postscript file.