The following tutorial provides a basic introduction to using R in a Unix environment.
 Invoking/interrupting/quitting
 Getting help
 Mathematical calculations
 Storing/manipulating data using vectors and matrices
 Managing the workspace image
 Importing/exporting data
 Functions
 Distributions
 Graphics
Invoking/interrupting/quitting
Before you begin this tutorial...
If you are not familiar with working in a Unix environment, please take the following Unix tutorial.
Invoking R
You start R by typing "R" at the Unix prompt on a machine that has R installed on it. R is installed on the following undergrad machines: bacon, agnesi, blanch, fenchel, fitch, maddison, magnus, merrill and rees. To obtain a Unix prompt, you must login to one of these machines by typing "rlogin maddison". For those students with a graduate account, R is available on the following graduate machines: pythagoras and beta.
Once you have started R, you must also decide if you want the commands that you type to be saved. Here are your choices:
 Type all of your commands directly into the R window. The disadvantage is that your commands are not saved. Also, when you write a command, R doesn't allow you to go back and correct a typo so you will have to retype your command.
 Use a text editor (emacs, for example), write your commands in it and copypaste them into your R window.

Using
the
script
command,
you
can
create
a
file,
say
Rsession1,
that
is
an
exact
copy
of
every
keystroke
that
you
perform
in
a
Unix
window
as
well
as
everything
that
is
echoed
onto
the
screen
after
you
invoke
the
command.
For
instance,
at
the
Unix
prompt,
type:
$ script 'Rsession1' $ R
to produce the script. Rsession1, that will copy everything in your R session. To stop the script from copying, simply quit R and at the Unix prompt, type:$ exit

If
you
are
running
an
intensive
program,
you
can
run
it
using
BATCH
mode.
Type:
help(BATCH)
in R for more information.
Interrupting R
To interrupt an R command, use the CtrlC key combination to stop execution of the command. This will return you to the R prompt.
Quitting R
To quit R, type:
> q() > Save workspace image? [y/n/c]: y
When you quit R, you will be asked whether you want to save the workspace image. Refer to managing the workspace image for a more detailed description of the workspace image. Note that in
If you answer "y", all of the objects you have created are saved and are available the next time you start R. If you answer "n", all objects are removed. Answering "c" cancels quitting and you are returned to an R prompt.
Caution: it is not advisable to rely on saving the workspace image so that all objects are saved and ready for your next R session. For instance, you may overwrite a particular object and then can't remember how that object was obtained. In general, it is recommend that you use a text editor, like that discussed above, or at the very least save all of your R commands using the script command, to save all of the R commands that were used during your R session. In this case, all objects can then be easily input into future R sessions.
Getting help
How to get help on a particular R command
You can type either of
> help(log) > ?log
to get help on the log command.
How to obtain a list of the help files for all R commands
Type:
> help.start()
to start a help window using Netscape. This is also a way to list all of the R commands.
Other ways of getting help in R
You may also find additional information in R manuals or FAQ's. These can be accessed from the internet using the following links:
Note that if you do not know the command in R that you want help on, the above methods of searching the R help files for relevant information concerning a particular subject are (most of the time) not useful. Some other ways of searching for help on a particular subject are:
Search for the particular subject in R using the Google newsgroups. Note that the keyword, R, is not particularly helpful when specified in Google because it is generic. Because Splus and R are quite similar in most cases, searching Google using Splus instead of R will most likely yield some information.
Above all, if you know know something about R, ask someone who might know!
Mathematical calculations
You can use R for many mathematical calculations. Note that the use of brackets in the typical way is recommended, if not needed, for large mathematical expressions.
Addition/subtraction
> 5 + 5 > 10  2
Multiplication/division
> 10*10 > 25/5
Power multiplication
> 3 ^ 2 > 2 ^ (2)
Note that
> 100 ^ (1/2)
is equivalent to
> sqrt(100)
Logarithms
> # Compute a natural logarithm > log(10) > # Compute a logarithm with base 10 > log10(1000) > # Compute a logarithm with base 2 > log2(8) > # Compute a logarithm with base 4 > log(16,base=4)
Exponentials
> exp(1)
Trigonometric Functions
Type:
> help(sin)
to see a list of all functions. Note that angles are specified in radians so if you want sin of 90 degrees, type:
> sin(pi/2)
The value NA
NA is the value R uses for a missing or undefined value. For instance, type:
> sqrt(3)
Storing/manipulating data using vectors and matrices
Creating vectors and extraction of its elements
> x < c(1,3,5,7,8,9) > x [1] 1 3 5 7 8 9 > y < 1:20 > y [1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 > z < seq(1,2,0.1) > z [1] 1.0 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 2.0 > x[3] [1] 5 > x[1:3] [1] 1 3 5 > x[2] [1] 1 5 7 8 9
Mathematical operations on vectors
One of the quirks/strengths of R is it's use of vectorized operations. Create two vectors x and y, having the same length, and see what happens when you do each of the following operations
> x + y > x  y > x / y #division element by element > x * y #multiplication element by element > sqrt(y) > x^3 > x^y > log(x) > cos(x)
Creating matrices and extraction of its elements
> X < cbind(x,1:6) # You can also use rbind to combine rows > X x [1,] 1 1 [2,] 3 2 [3,] 5 3 [4,] 7 4 [5,] 8 5 [6,] 9 6 > Y < matrix(0,2,3) > Y [,1] [,2] [,3] [1,] 0 0 0 [2,] 0 0 0 > Y < matrix(x,2,3) > Y [,1] [,2] [,3] [1,] 1 5 8 [2,] 3 7 9 Y[1,2] # extract element on the first row and the second column [1] 5 > Y[1,] # extract the first row [1] 1 5 8 > Y[,1] # extract the first column [1] 1 3 > Y[2,c(1,3)] # extract elements (1,3) of the second row [1] 3 9
Mathematical operations on matrices
To multiply two matrices A and B together, type:
> A %*% B
To find the transpose of a matrix, type:
> t(A)
To find the inverse of a matrix, type:
> solve(A)
Comparing objects
Suppose you create a vector, x, in the following way:
> x < c(1,3,2,4,5,6)
Now create a new vector.
> i < x<0
This returns a vector of logical values
[1,] (T,F,F,T,F,F)
The first element of x is less than 0, so the first element of i is T. The second element of x is greater than 0, so the second element of i is F, etc. Other comparison operators are >,<=, >=, == The logical operators are &(and) (or) !(not)
> i < x==3  x==6 > i [1] F T F F F T > i < x<6 & x>3 > i [1] F F F F T F
Obtaining a subset of an object
Suppose you want to extract a subset of a vector based on its values. For instance, if you want to extract just those elements of x that are less than 0, type
> i < x<0 > x[i]
This returns the vector
[1,] 1,4
A short cut is
> x[x<0] > x[x<6 & x>3]
Say you have two vectors that give the weight and height of 7 people
> weight < c(110,120,115,136,205,156,175) > height < c(64, 67, 62, 60, 77, 70, 66)
To extract the weight of all people whose height is greater than 65,
> weight[height>65]
To extract the weight of all people whose height is equal to 60,
> weight[height==65]
To extract the weight of all people whose height is not equal to 60,
> weight[height!=65]
Managing the workspace image
The workspace image includes all of the R objects that you have created in the current, and possibly other, R sessions. An R object is any vector, matrix, list, etc. that you have assigned a specific name. For instance, suppose you typed:
> x < 1
Then x is now an object that is in the workspace image.
Listing objects from your workspace image
To view the objects in the workspace image, type:
> ls()
Removing objects from your workspace image
To remove an object, x, from the workspace image, type:
> rm(x)
To remove all objects from the workspace image, type:
> rm(list=ls())
Importing/exporting data
The following information will provide a basic introduction to importing and exporting data into and out of R.
Importing data from an external ascii file
Several functions can be used to read data from an external ascii file (text file) into R and store it into an R object. However, if data is stored in some other type of format (e.g. an Excel spreadsheet), you may want to use the application in which the data is stored in (e.g. Excel) to export the data to a text file.
The function, scan, will read data into a vector or list from a console or ascii file. To see how this is done, first create a file, "file1.txt", in the directory in which you run R. In Unix, this just means that "file1.txt" must be in the same directory in which you invoked R.
For instance, suppose the text file, "file1.txt", contains the following information on the weight of ten subjects.
195 143 210 105 177 154 123 233 118 166
To scan the data in "file1.txt" to the vector, x, type:
> x<scan("file1.txt") > x
Type
> help(scan)
for more information on the available options.
The function, read.table, will read an ascii file (text file) in table format and create a data frame from it. Table format means that the lines in the file correspond to cases and the columns in the file correspond to variables. A header may (or may not) be included in the file indicating the name of the variable in each column. A data frame is used with most R modeling software and is similar in nature to matrices and lists.
We can read the data from the file, "file1.txt" into a data frame, x, using the function, read.table. To see how this is done, first create a file, "file1.txt", in the directory in which you run R. For instance, suppose the text file, "file1.txt", contains the following information on the weight and age of ten subjects.
wt age 195 44 143 32 210 56 105 24 177 37 154 32 123 54 233 28 118 30 166 47
To scan the data in "file1.txt" to the vector, x, type:
> x < read.table("file1.txt",header=TRUE) > x
Type
> help(read.table)
for more information on the available options.
Importing data from a text file on a webpage
It is likely that instead of having an ascii file saved in the directory in which you are using R, the file to be imported may exist on a webpage. Using any of the commands for importing data given previously (i.e. scan, read.table), the file can also be imported by specifying the URL as the filename. To import this dataset to R using the URL as the filename, just type:
> x < read.table("http://www.math.uwaterloo.ca/~dbabinea/webpage/R.tut/R.tut.unix/file1",header=TRUE)
Exporting data
Several functions can be used to write an R object to an external ascii file (text file).
The function, write, writes out a matrix or vector in a specified number of columns. To see how this is done to the matrix, x, first put the matrix, x, into R by typing:
> x1 < 1:10 > x2 < 11:20 > x3 < 21:30 > x < cbind(x1,x2,x3)
To write the matrix, x, so that each column appears as a line in the text file, type:
> write(x,file="file1.txt",ncolumns=10)
Alternatively, if you want each row in the matrix, x, to appear as a line in the text file, type:
> write(t(x),file="file2.txt",ncolumns=3)
Using either of these commands will save the text files in the directory in which you run R. Type
> help(write)
for more information on the available options.
The function, write.table, will write a data frame (after converting it to a data frame if it isn't already one) to an external ascii file (text file). Entries in each line(row) are separated by the value of 'sep;. The default value for 'sep' is a space. This is done to the object, x2, by typing:
> x1 < 1:10 > x2 < 11:20 > x3 < 21:30 > x < cbind(x1,x2,x3) > x2 < data.frame(x) > write.table(x2,"file3.txt",quote=FALSE)
In this case, the object is written to a file, file3.txt, which should now be in the directory in which you run R.
Type
> help(write.table)
for more information on the available options. Note that the function, write.table, can be slow for data frames that have hundreds of columns. The function, write.matrix, in the package, 'MASS', is a more efficient way of dealing with this problem if the object being exported can be represented as a numeric matrix.
Functions
R functions are used to provide users with programmed procedures for a number of statistical and nonstatistical procedures. Many functions are available in R. All basic functions are part of the BASE package. However, other functions are part of other packages that must be loaded. If you need to write your own function, this is also possible.
R functions that are available through addon packages
Functions that are part of the BASE package are available upon invoking R. Some R functions may not be available when you first invoke R and are available by specifying different addon packages. If you don't know if a function is part of the BASE package or not, simply type:
> help(function.name)
If help is not given, check the spelling OR you have found a function that is not a part of the BASE package. Refer to the listing of packages given on the R homepage to see a listing of the different addon packages that are available. Click on any package to see a listing of the functions that are a part of that package. For more detailed information, refer to the Section 5 of the FAQ under the R Homepage Documentation.
Suppose you want to use the function, survreg. This function is available in the package, survival. To load the package in Unix, type
> library(survival)
You will now be able to use the function, survreg.
You can find out which functions a package provides by typing
> library(help=survival)
or
> help(package=survival)
How to write your own functions
Here is a simple example of how to create your own function.
standardize<function(x) { # Inputs: a vector x # Outputs: the standardized version of x # m<mean(x) std<sqrt(var(x)) result<(x  m)/std return(result) }
The function takes one argument, a vector x, and returns a vector. The lines beginning with # are comments. The last line tells the function to return the value result, i.e. the original vector x, transformed by subtracting its mean, and then dividing by its standard deviation. To invoke the function on a vector x, type
> xstand < standardize(x)
To see the commands which make up the function, just type
> standardize
Note that there are no brackets used. If you want to create a function which returns several outputs, here is a simple example.
sqacu<function(x) { # Inputs: a vector x # Outputs: the square of x and the cube of x # res1<x^2 res2<x^3 return(list("square"=res1,"cube"=res2)) }
Now, if you type
>sqacu(2) $square: [1] 4 $cube: [1] 8 >sqacu(2)$square [1] 4
Iteration
When writing your own function, avoid iteration if you can; take advantage of R vectorized math and functions such as apply. It successively applies the function of your choice to each row (or column) of a matrix. Let's create a simple matrix and use apply to find the mean of each row/column.
> x < matrix(1:12,3,4) > apply(x,2,mean) #returns the mean of each column. > apply(x,1,mean) #returns the mean of each row
Sometimes,
iteration
can
not
be
avoided.
The
R
commands, for or while ,
are
useful
in
this
situation.
Here
is
an
example
of
using for inside
a
function
jsum<function(x) { jsum < 0 for(i in 1:length(x)) { jsum < jsum + x[i] } return(jsum) }
Note that R has its own function that performs this task, called sum. It will work much faster than this one, especially on large vectors.
Distributions
Data from different distributions can be easily calculated or simulated using R. The functions are named such that the first letter states what it calculates or simulates (d=density function, p=distribution function, q=quantile, r=random generation) and the last part of the function's name specifies the distribution (beta=beta, chisq = chisquared, exp=exponential, f=f, gamma=gamma, logis=logistic, norm=normal, t=student t, unif = uniform, weibull=weibull, binom=binomial, nbinom=negative binomial, pois=poisson). For instance, the function, qnorm, returns the quantiles of the normal distribution.
Calculating the probability density function
To calculate the value of the p.d.f. for a N(2,25) using the quantile, x, type:
> dnorm(x,mean=2,sd=5)
Calculating the cumulative density function
To calculate the value of the c.d.f. for a N(2,25) using the quantile, x, type:
> pnorm(x,mean=2,sd=5)
Determining a quantile
To calculate the quantile associated with a N(2,25) using the probability, x, type:
> qnorm(x,mean=2,sd=5)
Generating a random value from a distribution
To generate 10 random values from a N(2,25), type:
> rnorm(10,mean=2,sd=5)
Graphics
Opening a graphics window
To open/close a graphics device :
> X11() # open a graphics device in R > dev.off() # close a graphic device in R
Note that you do not need to open a graphics device to use a plotting function. An X11() graphics device is opened automatically when a plotting function is called.
Common types of graphs
There are several high level plot functions that can be used to plot graphs. For instance, a histogram can be made by typing:
> x < rnorm(1000) > hist(x)
To plot two R objects against one another (called a scatterplot), type:
> x < 1:10 > y < seq(from=1,to=20,by=2) > plot(x,y)
Plotting functions, like hist or plot, have many features that can be changed to accomodate the type of plot that you want. For instance, suppose you wanted a line plot instead of a scatter plot with the xaxis labelled as "X Values". Type:
> plot(x,y,type="l",xlab="X Values")
See the individual help files for more information.
You may also want to add other plots to an existing plot (i.e. overlay a plot).

To
add
a
straight
line
with
yintercept,
5,
and
slope,
1,
to
the
above
plot,
type:
> plot(x,y,type="l",xlab="X Values") > abline(5,1)

To
add
a
line
plot
to
the
above
plot,
type:
> plot(x,y,type="l",xlab="X Values") > x1<1:10 > y1<rep(c(5,15),5) > lines(x1,y1)

To
add
points
to
the
above
plot,
type:
> plot(x,y,type="l",xlab="X Values") > x1<1:10 > y1<rep(c(5,15),5) > points(x1,y1)
Note that when using the functions, lines or points, any graphical features on the original plot (i.e. title, axis labels, axis ranges) can not be changed without rerunning the original plot. This forces the values specified for the x and y coordinates in the functions, lines or points, to lie within the range of the original plot.
Changing graphical features
Graphical plots, like 'hist' or 'plot', have many additional graphical features that aren't given specifically in the help files. For instance, type:
> help(plot)
to give the following help file.
plot package:base R Documentation
Generic XY Plotting
Description:
Generic function for plotting of R objects. For more details
about the graphical parameter arguments, see `par'.
Usage:
plot(x, y, xlim=range(x), ylim=range(y), type="p",
main, xlab, ylab, ...)
Arguments:
x: the coordinates of points in the plot. Alternatively, a
single plotting structure, function or any R object with a
`plot' method can be provided.
y: the y coordinates of points in the plot, optional if `x' is
an appropriate structure.
xlim, ylim: the ranges to be encompassed by the x and y axes.
type: what type of plot should be drawn. Possible types are
* `"p"' for points,
* `"l"' for lines,
* `"b"' for both,
* `"c"' for the lines part alone of `"b"',
* `"o"' for both ``overplotted'',
* `"h"' for ``histogram'' like (or ``highdensity'')
vertical lines,
* `"s"' for stair steps,
* `"S"' for other steps, see Details below,
* `"n"' for no plotting.
All other `type's give a warning or an error; using, e.g.,
`type = "punkte"' being equivalent to `type = "p"' for S
compatibility.
main: an overall title for the plot.
xlab: a title for the x axis.
ylab: a title for the y axis.
...: graphical parameters can be given as arguments to `plot'.
.
.
.
etc.
The blue highlighted area indicates that there are other graphical parameters that can be given as arguments. To see these, type:
> help(par)
There are two ways to set the graphical parameters given by 'par'.

To
set
graphical
parmaeters
that
apply
to
all
plots,
set
the
features
using
arguments
to
'par'.
The
only
arguments
that
can
be
set
this
way
are:
* `"ask"' * `"fig"', `"fin"' * `"mai"', `"mar"', `"mex"' * `"mfrow"', `"mfcol"', `"mfg"' * `"new"' * `"oma"', `"omd"', `"omi"' * `"pin"', `"plt"', `"ps"', `"pty"' * `"usr"' * `"xlog"', `"ylog"'
Here is an example. A common parameter that you may want to set is to graph several plots on one page. Suppose you wanted 6 plots on one page, with 2 plots per line (a total of 3 lines), and the plots are placed on the graph by filling each row in order. The you would type:
> par(mfrow=c(3,2)) > plot(1:10) > title("Plot 1") > plot(10:100) > title("Plot 2") > plot(5:7) > title("Plot 3") > plot(50:75) > title("Plot 4") > plot(22:33) > title("Plot 5") > plot(1000:10000) > title("Plot 6")
If you wanted to have 6 plots on one page, like above, but instead place the graphs by filling each column in order, then you would use> par(mfcol=c(3,2))
To place each of the 6 plots in locations that don't follow an ordering given by 'mfrow' or 'mfcol', first set the number of plots on each page using 'mfrow' or 'mfcol' and then use 'par(mfg=c(a,b))' preceding each individual plotting function to specify the position that you want the plot graphed. 
To
set
graphical
parameters
that
apply
to
specific
high
level
plots,
set
the
features
within
the
plotting
function
itself.
For
instance,
suppose
you
wanted
to
change
the
plotting
symbol
in
a
scatterplot
to
be
the
character
's'.
Then
you
would
type:
> plot(1:10,pch="s")
Note that the graphical parameters that are set using 'par' (described in the previous point) can not be set using this method.
Saving/printing graphs
Simple methods for saving/printing graphs in R are given below. For more detailed information about saving/printing in R, refer to Section 5.2 in the R tip sheet.

Generate
a
plot
using
any
of
the
plotting
functions
in
R.
For
instance,
type
> plot(1:10)

To
save
this
plot
to
a
postscript
file
called,
graph1.ps,
type
> dev.print(postscript,file="graph1.ps")
The file, graph1.ps, is saved in the directory in which R is invoked. Other graphics devices (i.e. x11, jpeg, etc.) can be specified. Type
> help(Devices)
for a list of the available devices. When the graph is saved to an appropriate file, it can then be printed.