R Programming Tutorial for Beginners - -TIB Academy

Introduction To Programming In R
2nd & 3rd Floor, 5/3 BEML Layout,
Varathur Road, Thubarahalli,
Kundalahalli Gate, Bangalore 66
Landmark – Behind Kundalahalli Gate bus stop,
Opposite to SKR Convention Mall,
Next to AXIS Bank.
Introduction T o Programming In R

1 Workshop overview and materials
2 Data types
Extracting and replacing object elements
4 Applying functions to list elements
3
5
Writing functions
Control flow
6
7
The S3 object class system
Things that may surprise you
9 Additional resources
8
10 Loops (supplimental)
Last updated November 20, 2013 2 /
71Introduction T o Programming In R

W orkshop overview and materials
2 Data types
3
5
Writing functions
Control flow
6
7
8
3 /

This is an intermediate/advanced R course
Appropriate for those with basic knowledge of R
Learning objectives:
Index data objects by position, name or logical condition
Understand looping and branching
Write your own simple functions
Debug functions
Understand and use the S3 object system

Throughout this workshop we will return to a running example that involves
calculating descriptive statistics for every column of a data.frame. We will
often use the built-in iris data set. You can load the iris data by evaluating
d a t a ( i r i s ) at the R prompt.
Our main example today consists of writing a statistical summary function
that calculates the min, mean, median, max, sd, and n for all numeric
columns in a data.frame, the correlations among these variables, and the
counts and proportions for all categorical columns. Typically I will describe a
topic and give some generic examples, then ask you to use the technique to
start building the summary.

Lab computer users:
USERNAME dataclass
PASSWORD dataclass
Download materials from
h t t p : / / p r o j e c t s . i q . h ar v a r d . e d u / r t c / r - prog
Scroll to the bottom of the page and download the
r-programming.zip file
Move it to your desktop and extract

Data types
2 Data types
3
5
Writing functions
Control flow
6
7
8

Data types
Values can be combined into vectors using the c ( ) function
> num.var <- c (1, 2, 3, 4) # numeric vector
> char. var <- c ( "1", "2", "3", "4") # character vector
> log. var <- c (TRUE, TRUE, FALSE, TRUE) # logica l vector
> char.var2 <- c(num.var, char. var) # numbers coverted to character
>
Vectors have a class which determines how functions treat them
> class(num.var)
[1] "numeric"
> mean(num.var) # take the mean of a numeric vector
[1] 2.5
> class(cha r. v ar)
[1] " character"
> mean(char. var) # cannot average characters
[1] NA
> class(char. var2)
[1] " character"

Data types
Vectors can be converted from one class to another
> class(char. var2)
[1] " character"
> num.var2 <- as.numeric(char. var2) # convert to numeric
> class(num.var2)
[1] "numeric"
> mean( as.numeric( c h a r . var2)) # now we can calcul a t e the mean
[1] 2.5
> as.numeric( c ( "a", "b", "c") ) # cannot convert l e t t e r s to numeric
[1] NA NA NA
In addition to class, you can examine the length()
and s t r ( ) ucture of vectors
> l s ( ) # l i s t objects in our workspace
[1] " char. var" "char.var2" " log. var" "num.var" "num.var2"
> length(char. var) # how many elements in char. var?
[1] 4
> s t r (num.var2) # what i s the structure of num.var2?
num [1:8] 1 2 3 4 1 2 3 4

Data types
Factors are stored as numbers, but have character labels. Factors are useful
for
Modeling (automatically contrast coded)
Sorting/presenting values in arbitrary order
Most of the time we can treat factors as though they were character vectors

Data types
A data.frame is a list of vectors, each of the same length
A list is a collection of objects each of which can be almost anything
> DF <- data.frame(x=1: 5, y = l e t t e r s [ 1: 5] )
> DF # d a t a . frame with two columns and 5 rows
x y
1 1 a
2 2 b
3 3 c
4 4 d
5 5 e
>
> # DF <- data.frame(x=1:10, y=1:7) # i l l e g a l becase lengths d i f f e r
> L <- l i s t ( x=1: 5, y=1: 3, z = DF)
> L # l i s t s a r e much more f l e x i b l e !
$x
[1] 1 2 3 4 5
$y
[1] 1 2 3
$z
x y
1 1 a Last updated November 20, 2013 11 /

Data types
Key points:
vector classes include numeric, logical, character, and factors
vectors can be combined into lists or data.frames
a data.frame can almost always be thought of as a list of vectors of
equal length
a list is a collection of objects, each of which can by of almost any type
Functions introduced in this section:
c combine elements
as.numeric convert an object (e.g., a character verctor) to numeric
data.frame combine oject into a data.frame
ls list the objects in the workspace
class get the class of an object
str get the structure of an object
length get the number of elements in an object
mean calculate the mean of a vector

Data types
Create a new vector called "test" containing five numbers of your choice
[ c ( ) , <- ]
Create a second vector called "students" containing five common names
of your choice [ c ( ) , <- ]
Determine the class of "students" and "test" [ c l a s s ( ) or s t r ( ) ]
Create a data frame containing two columns, "students" and "tests" as
defined above [ data.frame ]
Convert "test" to character class, and confirm that you were successful [
as.numeric(), <-, s t r ( ) ]

Data types
Create a new vector called "test" containing five numbers of your choice
t e s t <- c ( 1, 2, 3, 4, 5)
a Create a second vector called "students" containing five common
names of your choice
students <- c ( "Mary", "Joan", "Steve", "Alex", "Suzy")
Determine the class of "students" and "test"
c l a s s ( s t ude nt s )
c l a s s ( t e s t )
Create a data frame containing two columns, "students" and "tests" as
defined above
testScores <- data.frame( s t u de n t s , t e s t s )
Convert "test" to character class, and confirm that you were successful
t e s t <- as.charact e r ( t e s t )
c l a s s ( t e s t )

2 Data types
3
5
Writing functions
Control flow
6
7
8

Parts of vectors, matricies, data.frames, and lists can be extracted or replaced
based on position or name
> ## indexing vectors by position
> x <- 101: 110 # Creat a vector of integer s from 101 to 110
> x[c( 4, 5) ] # extract the fourth and f i f t h values of x
[1] 104 105
> x[4] <- 1 # change the 4th value to 1
> x # p r i n t x
[1] 101 102 103 1 105 106 107 108 109 110
>
> ## indexing vectors by name
> names(x) <- l e t t e r s [ 1: 10] # give x names
> p r i n t (x) #print x
a b c d e f g h i j
101 102 103 1 105 106 107 108 109 110
> x[c( "a", " f " ) ] # extract the values of a and f from x
a f
101 106

Elements can also be selected or replaced based on logical (TRUE/FALSE)
vectors.
> x > 106 # shows which elements of x a r e > 106
a b c d e f g h i j
FALSE FALSE FALSE FALSE FALSE FALSE TRUE TRUE TRUE TRUE
> x[x > 106] # s e l e c t s elements of x where x > 106
g h i j
107 108 109 110
Additional operators useful for logical indexing:
= = equal to
!= not equal to
> greater than
< less than
> = greater than or equal to
< = less than or equal to
%in% is included in
& and
| or
> x[x > 106 & x <= 108]
g h

Extraction on matrices operate in two dimensions: first dimension refers to
rows, second dimension refers to columns
> ## indexing matricies
> # create a matrix
> (M <- cbind(x = 1: 5, y = -1: -5, z = c (6, 3, 4, 2, 8) ) )
x y
z [ 1 , ] 1 -1
6
[ 2 , ] 2 -2 3
[ 3 , ] 3 -3 4
[ 4 , ] 4 -4 2
[ 5 , ] 5 -5 8
> M[1: 3, ] #extract rows 1 through 3 , a l l columns
x y z
[ 1 , ] 1 -1 6
[ 2 , ] 2 -2 3
[ 3 , ] 3 -3 4
> M[c(5, 3, 1) , 2: 3] # rows 5 , 3 and 1 , columns 2 and 3
y z
[ 1 , ] -5 8
[ 2 , ] -3 4
[ 3 , ] -1 6
> M[M[, 1] %in% 4: 2, 2] # second column where f i r s t column <=4 & >= 2
[1] -2 -3 -4 Last updated November 20, 2013 18 /

Lists can be indexed in the same way as vectors, with the following extension:
> # Lists can be indexed with single br a c k e t s , similar to vector indexing
> L[c(1, 2) ] # the f i r s t two elements of L
$x
[1] 1 2 3 4 5
$y
[1] 1 2 3
> L[1] # a l i s t with one element
$x
[1] 1 2 3 4 5
> ## double brackets s e l e c t the content of a single selected element
> ## effectiv e l y taking i t out of the l i s t .
> L[[1] ] # a vector
[1] 1 2 3 4 5

A data.frame can be indexed in the same ways as a matrix, and also the same
ways as a list:
> DF[c(3, 1, 2) , c (1, 2) ] # rows 3 , 1 , and 2 , columns 1 and 2
x y
3 3 c
1 1 a
2 2 b
> DF[[1] ] # column 1 as a vector
[1] 1 2 3 4 5
There is a subtle but important difference between [ , n] and [ n] when
indexing data.frames: the first form returns a vector, the second returns a
data.frame with one column.
> s t r (DF[1] ) # a data.frame with one column
’data.frame’: 5 ob s . of 1 variable :
$ x: i n t 1 2 3 4 5
> s t r (DF[ , 1] ) # a vector
i n t [1:5] 1 2 3 4 5

Key points:
elements of objects can be extracted or replaced using the [ operator
objects can be indexed by position, name, or logical (TRUE/FALSE)
vectors
vectors and lists have only one dimension, and hence only one index is
used
matricies and data.frames have two dimensions, and extraction methods
for these objects use two indices
[ extraction operator, used to extract/replace object elements
names get the names of an object, usually a vector, list, or data.frame
print print an object

Select just the Sepal.Length and Species columns from the iris data set
(built-in, will be available in your workspace automatically) and save the
result to a new data.frame named iris.2
Calculate the mean of the Sepal.Length column in iris.2
BONUS (optional): Calculate the mean of Sepal.Length, but only for
the setosa species
BONUS (optional): Calculate the number of sepal lengths that are more
than one standard deviation below the average sepal length

Select just the Sepal.Length and Species columns from the iris data set
(built-in, will be available in your workspace automatically) and save the
result to a new data.frame named iris.2
data( i r i s )
i r i s 2 <- i r i s [ c ( "Sepal.Length", "Species") ]
s t r ( i r i s 2 )
Calculate the mean of the Sepal.Length column in iris.2
mean( i r i s 2 [ , "Sepal.Length"] )
3[@3] BONUS (optional): Calculate the mean of Sepal.Length, but only for
the setosa species
mean( i r i s 2 [ i r i s 2 [ [ "Species"] ] == "setosa", "Sepal.Length"] )
## s hor t c ut :
with( i r i s 2 , {
p r i n t ( mean(Sepal.Length[Species == "setosa"] ) )
})
4[@4] BONUS (optional): Calculate the number of sepal lengths that are
more than one standard deviation below the average sepal length
m.mi nus . s d <- mean( i r i s 2 [ [ "Sepal.Length"] ] ) - sd( i r i s 2 [ [ "Sepal.Length"] ] )
length( i r i s 2 [ i r i s 2 [ [ "Sepal.Length"] ] < m.minus.sd, "Sepal.Length"] )

Applying functions to list elements
2 Data types
3
5
Writing functions
Control flow
6
7
8

The apply function is used to apply a function to the rows or columns of a
matrix
> M <- matrix( 1: 20, ncol=4)
> apply(M, 2, mean) ## average across the rows
[1] 3 8 13 18
> apply(M, 2, sum) ## sum the columns
[1] 15 40 65 90

It is often useful to apply a function to each element of a vector, list, or
data.frame; use the sapply function for this
> sapply(DF, class ) # get the class of each column in the DF data.frame
x y
" integer" " factor "
> sapply(L, length) # get the length of each element in the L l i s t
x y z
5 3 2
> sapply(DF, i s . n umeric) # check each column of DF to see i f i t i s numeric
x y
TRUE FALSE

The sapply function can be used in combination with indexing to extract
elements that meet certain criteria
Recall that we can index using logical vectors:
> DF[, c (TRUE, FALSE) ] # s e l e c t the f i r s t column of DF, but not the second
[1] 1 2 3 4 5
> ## r e c a l l t h a t we can index using logica l vectors :
> DF[, c(TRUE, FALSE) ] # s e l e c t the f i r s t column of DF, but not the second
[1] 1 2 3 4 5
sapply() can be used to generate the logical vector
> (DF.which.num <- sapply(DF, is. numeric))# check which columns of DF a r e numer
x y
TRUE FALSE
> DF[DF.which.num] # s e l e c t the numeric columns
x
1 1
2 2
3 3
4 4
5 5 Last updated November 20, 2013 27 /

Key points:
R has convenient methods for applying functions to matricies, lists, and
data.frames
other apply-style functions exist, e.g., lapply, tapply, and mapply (see
documentation of these functions for details
matrix create a matrix (vector with two dimensions)
apply apply a function to the rows or columns of a matrix
sapply apply a function to the elements of a list
is.numeric returns TRUE or FALSE, depending on the type of object

W riting functions
2 Data types
3
5
Writing functions
Control flow
6
7
8

W riting functions
A function is a collection of commands that takes input(s) and returns
output.
If you have a specific analysis or transformation you want to do on
different data, use a function
Functions are defined using the function() function
Functions can be defined with any number of named arguments
Arguments can be of any type (e.g., vectors, data.frames, lists . . . )

W riting functions
The return value of a function can be:
The last object stored in the body of the function
Objects explicitly returned with the return() function
Other function output can come from:
Calls to print() , message() or cat() in function body
Error messages
Assignment inside the body of a function takes place in a local
environment
Example:
> f <- function( ) { # define function f
+ p r i n t ( " s e t t i n g x to 1") # p r i n t a t e xt s t r i n g
+ x <- 1} # s e t x to 1
>
> y <- f ( ) # assign y the value returned by f
[1] " s e t t i n g x to 1"
>
> y # p r i n t y
[1] 1
> x # x in the global i s not 1!
a b c d e f g h i j
101 102 103 1 105 106 107 108 109 110

W riting functions
Goal: write a function that returns the square of it’sargument
> square <- function (x) { # define function named "square" with argument x
+ return(x*x) # multiple the x argument by i t s e l f
+ } # end the function defini t io n
>
> # check to see t h a t the function works
> square(x = 2) # square the value 2
[1] 4
> square( 10) # square the value 10
[1] 100
> square( 1: 5) # square integer s 1 through 5
[1] 1 4 9 16 25

W riting functions
Stepping througth functions and setting breakpoints
Use traceback() to see what went wrong after the fact

W riting functions
Key points:
writing new functions is easy!
most functions will have a return value, but functions can also print
things, write things to file etc.
functions can be stepped through to facilitate debugging
Functions introduced in this section
function defines a new function
return used inside a function definition to set the return value
browser sets a break point
debug turns on the debugging flag of a function so you can step
through it
undebug turns off the debugging flag
traceback shows the error stack (call after an error to see what went
wrong)

W riting functions
Write a function that takes a data.frame as an argument and returns the
mean of each numeric column in the data frame. Test your function
using the iris data.
Modify your function so that it returns a list, the first element if which is
the means of the numeric variables, the second of which is the counts of
the levels of each categorical variable.

W riting functions
Write a function that takes a data.frame as an argument and returns the
mean of each numeric column in the data frame. Test your function
using the iris data.
statsum <- function( d f ) {
c l a s s e s <- sapply( d f , c l a s s )
means <- sappl y ( df [ c l a s s e s == "numeric"] , mean)
return (means)}
statsum( i r i s )
Modify your function so that it returns a list, the first element if which is
the means of the numeric variables, the second of which is the counts of
the levels of each categorical variable.
statsum <- f unc t i on( d f ) {
c l a s s e s <- s apply( d f , c l a s s )
means <- sapply( df [ c l a s s e s == "numeric"] , mean)
counts <- sapply( df [ c l a s s e s == " f a c t o r " ] , t a bl e )
r e t ur n ( l i s t (means, counts))}
statsum( i r i s )

Control flow
2 Data types
3
5
Writing functions
Control flow
6
7
8

Control flow
Basic idea: if some condition is true, do one thing. If false, do
something else
Carried out in R using i f ( ) and e l s e ( ) statements, which can be
nested if necessary
Especially useful for checking function arguments and performing
different operations depending on function input

Control flow
Goal: write a function that tells us if a number is positive or negative
> ## use branching to return d i f f e r e n t resul t depending on the sign of the inpu
> isPosit i ve <- function(x) { # define function " isPosit i ve "
+ i f (x > 0) { # i f x i s greater than zero, then
+ c a t( x , " i s positi ve n" ) } # say so!
+ else { # otherwise
+ c a t( x , " i s negative n" )} # say x i s negative
+ } # end function definit i o n
>
> ## t e s t the i s P o s i t i v e ( ) function
> isPosit i ve ( 10)
10 i s positi v e
> isPosit i ve ( -1)
-1 i s negative
> isPosit i ve ( 0)
0 i s negative
Need to do something different if x equals zero!

Control flow
Add a condition to handle x = 0
> ## add condition to handle the case t h a t x i s zero
> i s P o s i t i ve <- function(x) { # define function " isPosit i ve "
+ i f (x > 0) { # i f x i s greater than zero, then
+ else i f (x == 0) { # otherwise i f x i s zero
+ c a t( x , " i s zero n" )} # say so!
+ else { #otherwise
+ } # end function defini t i on
>
Test the new function
> isPosit i ve ( 0) # t e s t the i s P o s i t i v e ( ) function
0 i s zero
> isPosit i ve ( "a") #oops, t h a t will not work! a i s
positi ve
We fixed the problem when x = 0, but now we need to make sure x is
numeric of length one (unless we agree with R that a is positive!)

Control flow
Do something reasonable if x is not numeric
> ## add condition to handle the case t h a t x i s zero
> i s P o s i t i ve <- function(x) { # define function " isPosit i ve "
+ i f ( ! is.numeric(x) | length(x) > 1) {
+ c a t( "x must be a numeric vector of length one! n" )}
+ else i f (x > 0) { # i f x i s greater than zero, then
+ else i f (x == 0) { # otherwise i f x i s z e ro
+ c a t( x , " i s zero n" )} # say so!
+ else { #otherwise
+ } # end function defini t i on
>
> isPosit i ve ( "a") # t e s t the i s P o s i t i v e ( ) function on character
x must be a numeric vector of length one!

Control flow
Key points:
code can be conditionally executed
conditions can be nested
conditional execution is often used for argument checking, among other
things
Functions1 introduced in this section
cat Concatenates and prints R objects
if execute code only if condition is met
else used with if; code to execute if condition is not met
1Technically i f and else are not functions, but this need not concern us at the moment

Control flow
Add argument checking code to return an error if the argument to your
function is not a data.frame
Insert a break point with browser() and step through your function

Control flow
Add argument checking code to return an error if the argument to your
function is not a data.frame
i f ( c l a s s ( d f ) != "data.frame") stop( "df must be a data.frame!")
counts <- sapply( df [ c l a s s e s == " f a c t o r " ] , tabl e )
r e t ur n ( l i s t (means, counts))}
statsum( 1: 10)
statsum( i r i s )
Insert a break point with browser() and step through your function
browser( )
r e t ur n ( l i s t (means, counts))
}
statsum( i r i s )

2 Data types
3
5
Writing functions
Control flow
6
7
8

R has two major object systems:
Relatively informal "S3" classes
Stricter, more formal "S4" classes
We will cover only the S3 system, not the S4 system
Basic idea: functions have different methods for different types of objects

The class of an object can be retrieved and modified using the c l a s s ( )
function:
> x <- 1: 10
> class(x)
[1] " integer"
> class(x) <- "foo"
> class(x)
[1] "foo"
Objects are not limited to a single class, and can have many classes:
> class(x) <- c ( "A", "B")
> class(x)
[1] "A" "B"

Functions can have many methods, allowing us to have (e.g.) one plot()
function that does different things depending on what is being plotted()
Methods can only be defined for generic functions: plot, print, summary,
mean, and several others are already generic
> # see what methods have been defined for the mean function
> methods(mean)
[1] mean.Date mean.default mean.difftim e mean.POSIXct
[5] mean.POSIXlt
> # which functions have methods for d a t a . f rames?
> methods(class=" d a t a . f rame") [ 1: 9]
[1] " aggregate. data. fra me" "anyDuplicated.data.frame"
[3] " as. data.frame.data .frame" " a s . l i s t . d a t a . f r a m e "
[5]
" a s . m a t r i x . d a t a . f r a me"
[7] "cbind.data.frame"
[9] " [. data. frame"
"by.data.frame"
"[<-.data.frame"

To create a new method for a function that is already generic all you have to
do is name your function function.class
> # create a mean() method for objects of class " foo" :
> mean.foo <- function(x) { # mean method for "foo" class
+ i f ( i s . n u meric( x ) ) {
+ c a t( "The average i s " , mean.defaul t ( x ) )
+ return( i n v i s i b l e ( mean.default( x ) ) ) #use mean.default for numeric
+ } el s e
+ c a t( "x i s not numeric n" ) } # otherwise say x not numeric
>
> x <- 1: 10
> mean(x)
[1] 5.5
> class (x) <- "foo"
> mean(x)
The average i s 5.5>
> x <- as. character (x)
> class (x) <- "foo"
> mean(x)
x i s not nume r i c

S3 generics are most often used for print, summary, and plot methods, but
sometimes you may want to create a new generic function
> # create a generic disp() function
> disp <- function( x , . . . ) {
+ UseMethod( "disp")
+ }
>
> # create a disp method for class "mat r i x "
> disp.matrix <- function(x) {
+ p r i n t ( round( x , digits= 2) )
+ }
>
> # t e s t i t out
> disp( matrix( runif ( 10) , ncol=2) )
[ , 1 ] [ , 2 ]
[ 1 , ] 0.78 0.21
[ 2 , ] 0.85 0.45
[ 3 , ] 0.31 0.34
[ 4 , ] 0.47 0.80
[ 5 , ] 0.51 0.66

Key points:
there are several class systems in R, of which S3 is the oldest and
simplest
objects have class and functions have corresponding methods
the class of an object can be set by simple assignment
S3 generic functions all contain UseMethod("x") in the body, where x
is the name of the function
new methods for existing generic functions can be written simply by
defining a new function with a special naming scheme: the name of the
function followed by dot followed by the name of the class
Functions introduced in this section
plot creates a graphical display, the type of which depends on the
class of the object being plotted
methods lists the methods defined for a function or class
UseMethod the body of a generic function
invisible returns an object but does not print it

Modify your function so that it also returns the standard deviations of
the numeric variables
Modify your function so that it returns a list of class "statsum"
Write a print method for the statsum class

Modify your function so that it also returns the standard deviations of
the numeric variables
sds <- sapply( df [ c l a s s e s == "numeric"] , mean)
counts <- sapply( df [ c l a s s e s == " f a c t o r " ] , tabl e )
r e t ur n ( l i s t ( cbind(means , s d s ) , counts))}
statsum( i r i s )
Modify your function so that it returns a list of class "statsum"
sds <- sapply( df [ c l a s s e s == "numeric"] , mean)
R <- l i s t ( cbind(means, s d s ) , counts)
c l a s s (R) <- c ( "statsum", c l a s s (R))
r e t ur n (R)}
s t r ( statsum( i r i s ) )
3 [@3] Write a print method for the statsum class
pr i nt . s t a t s um <- function( x) {
p r i n t ( x [ [ 1] ] ,
c a t ( "Numeric va r i able de s c r i pt i ve s t a t i s t i c s : n " )
71

2 Data types
3
5
Writing functions
Control flow
6
7
8

There are an unfortunately large number of surprises in R programming
Some of these "gotcha’s" are common problems in other languages,
many are unique to R
We will only cover a few –for a more comprehensive discussion please
see http://www.burns-s t a t .com/pages/Tutor/R_inferno.pdf

Floating point arithmetic is not exact:
> . 1 == . 3 / 3
[1] FALSE
Solution: use a l l . e q u a l ( ):
> a l l . e q u a l ( . 1 , . 3/ 3)
[1] TRUE

R does not exclude missing values by default –a single missing value in a
vector means that many thing are unknown:
> x <- c (1: 10, NA, 12: 20)
> c (mean( x ) , sd(x) , median( x ) , min( x ) , sd( x ) )
[1] NA NA NA NA NA
NA is not equal to anything, not even NA
> NA == NA
[1] NA
Solutions: use na.rm = TRUE option when calculating, and is.na to test for
missing

Automatic type conversion happens a lot which is often useful, but makes it
easy to miss mistakes
> # combining values coereces them to the most general type
> (x <- c (TRUE, FALSE, 1, 2, "a", "b") )
[1] "TRUE" "FALSE" "1" "2" "a" "b"
> s t r (x)
chr [1:6] "TRUE" "FALSE" "1" "2" "a" "b"
>
> # comparisons convert arguments to most general type
> 1 > "a"
[1] FALSE
Maybe this is what you expect. . . I would like to at least get a warning!

Functions you might expect to work similarly don’t always:
> mean( 1, 2, 3, 4, 5)*5
[1] 5
> sum( 1, 2, 3, 4, 5)
[1] 15
Why are these different?!?
> args(mean)
function ( x , . . . )
NULL
> args(sum)
function ( . . . , na.rm = FALSE)
NULL
Ouch. That is not nice at all!

Factors sometimes behave as numbers, and sometimes as characters, which
can be confusing!
> (x <- f a c t or( c ( 5, 5, 6, 6) , levels = c (6, 5) ) )
[1] 5 5 6 6
Levels: 6 5
>
> s t r (x)
Factor w/ 2 levels " 6" , " 5" : 2 2 1 1
>
> as. character (x)
[1] "5" "5" "6" "6"
> # here i s where people sometimes get l o s t . . .
> as.numeric(x)
[1] 2 2 1 1
> # you probably want
> as.numeric( as. charact e r ( x ) )
[1] 5 5 6 6

Additional resources
2 Data types
3
5
Writing functions
Control flow
6
7
8

S3 system overview:
https://github.com/ hadley/devtools/wiki/S3
S4 system overview:
https://github.com/ hadley/devtools/wiki/S4
R documentation: h t t p : / / c r a n . r - project.org/manuals.html
Collection of R tutorials:
h t t p : / / c r a n . r - projec t . o r g / o t h e r - docs.html
R for Programmers (by Norman Matloff, UC–Davis)
h t t p : / / h e a t h e r . c s . u c d avis.edu/~matloff/R/RProg.pdf
Calling C and Fortran from R (by Charles Geyer, UMinn)
http://www.stat.umn.e d u/ ~c ha rlie /rc/
State of the Art in Parallel Computing with R (Schmidberger et al.)
http://www.jstatso|.o rg/v31/i01/paper
Institute for Quantitative Social Science: http://iq. ha r var d .e d u
Research technology consulting:
h t t p : / / p r o j e c t s . i q . harvard.edu/rtc

Help Us Make This Workshop Better!
Please take a moment to fill out a very short feedback form
These workshops exist for you –tell us what you need!
h t t p : / / t i n y u r l . c o m / RprogrammingFeedback

Loops (supplimental)
2 Data types
3
5
Writing functions
Control flow
6
7
8

A loop is a collection of commands that are run over and over again.
A for loop runs the code a fixed number of times, or on a fixed set of
objects.
A while loop runs the code until a condition is met.
If you’re typing the same commands over and over again, you might
want to use a loop!

For each value in a vector, print the number and its square
> # For-loop example
> for (num i n seq( -5, 5) ) {# for each number in [ - 5 , 5]
+ c a t(num, "squared i s " , num^2, " n" ) # p r i n t the number
+ }
-5 squared i s 25
-4 squared i s 16
-3 squared i s 9
-2 squared i s 4
-1 squared i s 1
0 squared i s 0
1 squared i s 1
2 squared i s 4
3 squared i s 9
4 squared i s 16
5 squared i s 25

Goal: simulate rolling two dice until we roll two sixes
> ## While-loop example: r o l l i n g dice
> set. seed ( 15) # allows repoducible sample() resu l t s
> dice <- seq( 1, 6) # s e t dice = [1 2 3 4 5 6]
> r o l l <- 0 # s e t r o l l = 0
> while ( r o l l < 12) {
+ r o l l <- sample( d i c e , 1) + sample( d i c e , 1) # calculate sum of two r o l l s
+ c a t( "We rolled a " , r o l l , " n" ) # p r i n t the r e s u l t
+ } # end the loop
We rolled a 6
We rolled a 10
We rolled a 9
We rolled a 7
We rolled a 10
We rolled a 5
We rolled a 9
We rolled a 12
Last updated November 20, 2013

Often you will want to store the results from a loop. You can create an object
to hold the results generated in the loop and fill in the values using indexing
> ## save calculat i o ns done in a loop
> Result <- l i s t ( ) # create an object to store the r e s u l t s
> for ( i in 1: 5) {# for each i in [ 1 , 5]
+ R e s u l t [ [ i ] ] <- 1: i ## a s s i gn the sequence 1 to i to Result
+ }
> Result # pr i n t Result
[ [ 1 ] ]
[1] 1
[ [ 2 ] ]
[1] 1 2
[ [ 3 ] ]
[1] 1 2 3
[ [ 4 ] ]
[1] 1 2 3 4
[ [ 5 ] ]
[1] 1 2 3 4 5

Most operations in R are vectorized –This makes loops unnecessary in many
cases
Use vector arithmatic instead of loops:
> x <- c ( ) # create vector x
> for ( i in 1: 5) x [ i ] <- i + i # double a vector using a loop
> p r i n t (x) # p r i n t the r e s u l t
[1] 2 4 6 8 10
>
> 1: 5 + 1: 5 #double a vector without a loop
[1] 2 4 6 8 10
> 1: 5 + 5 # shorter vectors are recycled
[1] 6 7 8 9 10
Use paste instead of loops:
> ## Earlier we said
> ## for (num in seq( -5, 5)) {# for each number in [ - 5 , 5]
>
>
## cat(num, "squared i s " , num^2, " n " ) # p r i n t the number
## }
> ## a bette r way:
> paste( 1: 5, "squared = " , ( 1: 5)^ 2)
[1] "1 squared = 1" "2 squared = 4" "3 squared =
9"[4] "4 squared = 16" "5 squared = 25"

use a loop to get the c l a s s ( ) of each column in the iris data set
use the results from step 1 to select the numeric columns
use a loop to calculate the mean of each numeric column in the iris data

use a loop to get the c l a s s ( ) of each column in the iris data set
> classes <- c ( )
> for (name in names( i r i s ) ) {
+
+ }
>
classes[name] <- class(ir is[ [n am e]] )
> classes
Sepal.Length Sepal.Width Petal.Length
Petal.Width
Species
" factor""numeric" "numeric" "numeric" "numeric"
use the results from step 1 to select the numeric columns
> iris.num <- i r i s [ , names(classes)[classes== "numeric"] ]
> head(ir is. nu m, 2)
Sepal.Length Sepal.Width Petal.Length Petal.Width
1
2
5.1
4.9
3.5
3.0
1.4
1.4
0.2
0.2
use a loop to calculate the mean of each numeric column in the iris data
> iris. m e ans <- c ( )
> for (var in names(iris. num) ) {
+ iris. means [[ var ]] <- mean( i r i s [ [ v a r ] ] )
+ }
Last updated November 20, 2013 /

Training in Bangalore
Second Floor and Third Floor,
5/3 BEML Layout,
Varathur Road, Thubarahalli,
Kundalahalli Gate, Bangalore 66
Landmark – Behind Kundalahalli Gate bus stop,
Opposite to SKR Convention Mall,
Next to AXIS Bank.

R Programming Tutorial for Beginners - -TIB Academy

More Related Content

What's hot

Similar to R Programming Tutorial for Beginners - -TIB Academy

More from rajkamaltibacademy

Recently uploaded

R Programming Tutorial for Beginners - -TIB Academy