The R Language

1
Dr. Smruti R. Sarangi and Ms. Hameedah Sultan
Computer Science and Engineering
IIT Delhi
2 Overview of R

 Language for statistical computing and data analysis

 Freely available under GPL v2
 Extensive library support
 Programming paradigms
 procedural
 functional
 object-oriented
 General matrix computation (similar to Matlab)
3 Running R

 Command Line
 Just type R
 The R command prompt comes up
> .....
 With a GUI
 R Studio
 R Commander
4 Outline

 Variables and Vectors

 Factors
 Arrays and Matrices
 Data Frames
 Functions and Conditionals
 Graphical Procedures
5 Normal Variables

 We can use <- as the assignment operator in R

 > x <- 4
(set x to 4)
 For printing the value of x
 >x
[1] 4
 OR, > print(x)
[1] 4
6 A Numeric Vector

 Simplest data structure

 Numeric vector
 > v <- c(1,2,3)
 <- is the assignment operator
 c is the list concatenation operator
 To print the value, v
 Type : > v
 Output: [1] 1 2 3
7 A vector is a full fledged variable

 Let us do the following:

 > 1/v
[1] 1.0000000 0.5000000 0.3333333
 >v+2
[1] 3 4 5
 We can treat a vector as a regular variable
 For example, we can have:
 > v1 <- v / 2
> v1
[1] 0.5 1.0 1.5
8 Creating a vector with vectors

 > v <- c (1,2,3)

>v
[1] 1 2 3
> vnew <- c (v,0,v)
> vnew
[1] 1 2 3 0 1 2 3
The c operator concatenates all the vectors
9 Functions on Vectors and Complex
Numbers
 If v is a vector
 Here, are a few of the functions that take vectors as
inputs:
mean(v), max(v), sqrt(v), length(v), sum(v), prod(v),
sort (v) (in ascending order)
 > x <- 1 + 1i
> y <- 1i
>x*y
[1] -1+1i
10 Generating Vectors

 Suppose we want a vector of the form:

(1,2,3,... 100)
 We do not have to generate it manually.
 We can use the following commands:
> v <- 1:100
OR
> v <- seq(1,100)
 seq takes an additional argument, which is the difference
between consecutive numbers:
 seq (1,100,10) gives (1,11,21,31 ... , 91)
 rep (2,5) generates a vector (2, 2, 2, 2, 2)
11 Boolean Variables and Vectors
 R recognizes the constants: TRUE, FALSE
 TRUE corresponds to 1
 FALSE corresponds to 0
 We can define a vector of the form:
 v <- c (TRUE, FALSE, TRUE)
 We can also define a logical vector
 Can be created with logical operators: <, <=, >=,
==, !=, & and I
> v <- 1:9 > 5
> v
[1] FALSE FALSE FALSE FALSE FALSE TRUE
TRUE TRUE TRUE
12 String Vectors

 Similarly, we can have a vector of strings

 > vec <- c (“f1”, “f2”, “f3”)
> vec
[1] "f1" "f2" "f3“
 The paste function can be used to create a vector of
strings
paste(1:3, 3:5,sep="*")
[1] "1*3" "2*4" "3*5"

It takes two vectors of the same length, and an optional

argument, sep. The ith element of the result string,
contains the ith elements of both the arguments,
separated by the string specified by sep.
13 Outline

 Variables and Vectors

 Factors
 Arrays and Matrices
 Data Frames
 Functions and Conditionals
 Graphical Procedures
14 Factors
Factor Definition: A vector used to specify
a grouping (classification) of objects
in other vectors.

 Consider the following problem:

 We have a vector of the type of the Nationality of
students, and a vector of their marks in a given
subject.
 AIM: Find the average scores per nationality.
15 Graphical View of the Problem

Indian 6

Chinese 8
Indian
Indian 7
Chinese
Chinese 9
Russian
Indian 8
Factor
Russian 10

Nationality Marks
 # character starts
16 Code a comment

> nationalities <- c ("Indian", "Chinese", "Indian", "Chinese",

"Indian", "Russian") # create a factor
> marks <- c (6, 8, 7, 9, 8, 10)

> fac <- factor(nationalities)

> fac
[1] Indian Chinese Indian Chinese Indian Russian
Levels: Chinese Indian Russian

 The levels of a factor indicate the categories

17 Code - II

 Now let us apply the factor to the marks

vector
> results <- tapply (marks, fac, mean)

Works on each compute the mean

factor
element of the list in each category

List of marks
18 Time for the results
> results
Chinese Indian Russian
8.5 7.0 10.0

 Let us now apply the sum function

> tapply (marks, fac, sum)
Chinese Indian Russian
17 21 10
19 levels and table
> levels (fac)
[1] "Chinese" "Indian" "Russian"
> table (fac)
fac
Chinese Indian Russian
2 3 1

 Let us assume that the factor is fac.

 fac is
[1] Indian Chinese Indian Chinese Indian Russian
Levels: Chinese Indian Russian
 levels returns a vector containing all the
unique labels
 table returns a special kind of array that
20 Outline

 Variables and Vectors

 Factors
 Arrays and Matrices
 Data Frames
 Functions and Conditionals
 Graphical Procedures
21 Arrays and Matrices

 Generic array function

 Creates an array. Takes two arguments:
 data_vector  vector of values
 dimension_vector
 Example:
> array (1:10, c(2,5))
[,1 [,2] [,3] [,4] [,5]
[1,] 1 3 5 7 9
[2,] 2 4 6 8 10
The numbers are laid out in column major order.
Count from 1, Not 0
22 Other ways to make arrays

 Take a vector, and assign it dimensions

 > v <- c (1,2,3,4)
> dim(v) <- c(2,2)
>v
[,1] [,2]
[1,] 1 3
[2,] 2 4
23 Arrays are Created in Column Major
Order > v <- 1:8
> dim(v) <- c(2,2,2)
>v
,,1

[,1] [,2] Start from the last index

[1,] 1 3
[2,] 2 4

,,2 Array elements are accessed

by specifying their index
[,1] [,2] (within square brackets)
[1,] 5 7
[2,] 6 8

> v[2,1,2]
[1] 6
24 The matrix command

 A matrix is a 2-D array

 There is a fast method of creating a matrix
 Use the matrix (data, dim1, dim2) command
 Example:
> matrix(1:4, 2, 2)
[,1] [,2]
[1,] 1 3
[2,] 2 4
25 cbind and rbind

mat1 mat2 mat1 mat2

cbind

mat1
mat1 mat2

mat2
rbind
26 Problem: set the diagonal elements of
a matrix to 0
> mat <- matrix(1:16,4,4)
> mat
[,1] [,2] [,3] [,4]
[1,] 1 5 9 13
[2,] 2 6 10 14
[3,] 3 7 11 15
[4,] 4 8 12 16
> indices <- cbind (1:4, 1:4)
> mat[indices] <- 0
> mat
[,1] [,2] [,3] [,4]
[1,] 0 5 9 13
[2,] 2 0 10 14
[3,] 3 7 0 15
[4,] 4 8 12 0
27 Recycling Rule
> cbind (1:4, 1:8)
[,1] [,2]
[1,] 1 1
[2,] 2 2
[3,] 3 3
[4,] 4 4
[5,] 1 5
[6,] 2 6
[7,] 3 7
[8,] 4 8

 The smaller structure is replicated to match the

length of the longer structure
 Note that the size of the longer structure has to
be a multiple of the size of the smaller structure.
 Matrix Operations
28

 A * B is a normal element-by-element product

 A %*% B is a matrix product
 Equation solution:
 solve (A, b) (for equations of the form Ax = b)
 solve (A) returns the inverse of the matrix
> A <- matrix (1:4, 2, 2)
> b <- 5:6 Solve an equation of the
> solve (A,b) form: Ax = b
[1] -1 2

> solve(A) %*% b

[,1] A-1 * b = x
[1,] -1
[2,] 2
29 Additional Features
 nrow (mat)  Number of rows in the matrix
 ncol (mat)  Number of columns in the matrix

Feature Function
Eigen Values eigen
Singular Value Decomposition svd
Least Squares Fitting lsfit
QR decomposition qr
30 Outline

 Variables and Vectors

 Factors
 Arrays and Matrices
 Data Frames
 Functions and Conditionals
 Graphical Procedures
31 Lists and Data Frames

 A list is a heterogeneous data structure

 It can contain data belonging to all kinds of types
 Example:
 > lst <- list (“one”, 1, TRUE)
 Elements can be lists, arrays, factors, and normal variables
 The components are always numbered
 They are accessed as follows: lst[[1]], lst[[2]], lst[[3]]
 [[ ... ]] is the operator for accessing an element in a list
32 Named Components

 Lists can also have named components

 lst <- list(name=“Sofia”, age=29, marks=33.7)
 The three components are: lst$name, lst$age, lst$marks
 We can also use
 lst [[“name”]], lst[[“age”]], lst [[“marks”]]
33 Data Frames columns

rows Data Frame

 It is a table in R

> entries <- c(“cars”, “trucks”, “bikes”)

> price <- c (8, 10, 5)
> num <- c (1, 2, 3)
> df <- data.frame(entries, price, num)

> df
entries price num
1 cars 8 1
2 trucks 10 2
3 bikes 5 3
34 Accessing an Element

 Can be accessed as a regular array, or as a list

> df[1,2]
Row names, i.e. [1] 8
character values > df[2,]
entries price num
2 trucks 10 2
> df$price
[1] 8 10 5

 Summary shows a summary of each variable in the data frame

Feature Function
> summary(df) Show first 6 rows of head(df)
entries price num df
bikes :1 Min. : 5.000 Min. :1.0
cars :1 1st Qu.: 6.500 1st Qu.:1.5 List objects ls()
trucks:1 Median : 8.000 Median :2.0
Remove variables x rm(x,y)
Mean : 7.667 Mean :2.0
3rd Qu.: 9.000 3rd Qu.:2.5
& y from data frame
35 Operations on Data Frames

 A data frame can be sorted on the values of a variable,

filtered using values of a variable, and grouped by a variable.

 Eg. Filter rows where entries = “cars”

> df[df$entries == "cars",]
entries price num
1 cars 8 1

 Group by entries
> aggregate(df,by = list(entries), mean)
Group.1 entries price num
1 bikes NA 5 3
2 cars NA 8 1
3 trucks NA 10 2
36 Reading Data from Files

 Reads in a data frame from a file

 Steps:
 Store the data frame in a file
 Read it in
 > df <- read.table (“<filename>”)

 Access the data frame

37 Outline

 Variables and Vectors

 Factors
 Arrays and Matrices
 Data Frames
 Functions and Conditionals
 Graphical Procedures
38 Grouping, Loops, Conditional
Execution
 R does have support for regular if statements,
while loops, and other conditionals
 if statement
 if (condition) statement 1 else statement 2. Use {}
for creating grouped statements
 The condition should evaluate to a single variable
(not a vector)
 Example:
> x <- 3
> if (x > 0) x <- x+ 3 else x <- x + 6
> x
[1] 6
39 For loop
 for (var in expr1) {
....
....
}
Example: > for (v in 1:10) print (v)
[1] 1
[1] 2
[1] 3
[1] 4
[1] 5
[1] 6
[1] 7
[1] 8
[1] 9
[1] 10
40 While loop
> while (x[i] < 10) {
+ print (x[i])
+ i <- i + 1
+ }
[1] 1
[1] 2
[1] 3
[1] 4
[1] 5
[1] 6
[1] 7
[1] 8
[1] 9

Use the break statement to exit

a loop
41 Writing one’s own functions

> cube <- function (x) {

+ x * x * x
+ }
> cube(4)
[1] 64

 A function takes a list of arguments within ( ... )

 To return a value, just print the expression
(without assignment statements)
 Function calling convention  similar to C
42 Applying a Function

> lapply (1:2,cube)

[[1]]
[1] 1

[[2]]
[1] 8

 Apply the cube function to a vector

 Applies the function to each and every argument
 sapply returns a list

> sapply (1:3, cube)

[1] 1 8 27
43 Named arguments
> fun <- function (x=4, y=3) { x - y }
> fun()
[1] 1
> fun (4,3)
[1] 1
> fun (y=4, x=3)
[1] -1

 Possible to specify default values in the function

declaration
 If a variable is not specified, the default value is used
 We can also specify the values of the variables by the
name of the argument (last line)
44 Scoping in R
> deposit <- function (amt) balance + amt
> withdraw <- function (amt) balance - amt
> balance <- withdraw(10)
> balance <- deposit (20)
> balance
[1] 110

 Scope of variables in R
 Function arguments (valid only inside the function)
 Local variables (valid only inside the function)
 Global variables (balance)
45 Functional Programming: Closures
> exponent <- function (n) {
+ power <- function (x) {
+ x ** n
+ }
+ }
> square <- exponent(2)
> square(4)
[1] 16

 A function with pre-specified data is called a closure

 exponent returns a function power (with n = 2)
 source http://adv-r.had.co.nz/Functional-programming.html

46 Example: Numerical Integration

> composite <- function(f, a, b, n = 10,
rule) {

area <- 0
+ points <- seq(a, b, length = n + 1)
+
+ area <- 0
+ for (i in seq_len(n)) { Function for
+ area <- area + rule(f, points[i], numerical
points[i + 1]) integration
+ }
+
+ area
+ }
> midpoint <- function(f, a, b) {
+ (b - a) * f((a + b) / 2) Midpoint rule
function passed + }
as an argument > composite(sin, 0, pi, n = 1000, rule =
𝜋
midpoint)
∫ sin ( 𝑥 ) 𝑑𝑥
[1] 2.00000 0
47 Outline

 Variables and Vectors

 Factors
 Arrays and Matrices
 Data Frames
 Functions and Conditionals
 Graphical Procedures
48 Plotting a Function

 A basic 2D plot:
Plot type
vec1 <-cube(seq(1,100,10)) (overplotted)
vec2 <-cube(seq(5,100,10))
plot(vec1, type="o", col="blue“, ylim=c(0,3e5))
title(main=“Plot of Cubes", col.main="red")

 To add a line to the same plot:

lines(vec2, type=“o", lty = 2, pch = 22, col=“red“)
Line type: Marker type:
dashed square

 To add a legend:
legend(1, max(vec1), c(“vec1",“vec2"), cex=0.8, col=c("blue","red"),
pch=21:22, lty=1:2)
49 Plotting: Linear Regression
library("MASS")
data(cats) # load data
plot(cats$Bwt, cats$Hwt) # scatter plot of cats body weight vs heart rate
M <- lm(formula = cats$Hwt ~ cats$Bwt, data=cats) # fit a linear model
regmodel <- predict(M) # predict values using this model
plot(cats$Bwt, cats$Hwt, pch = 16, cex = 1.3, col = "blue", main = "Heart
rate plotted against body weight of cats", xlab = "Body weight", ylab =
"Heart rate") # scatter plot
abline(M) # plot the regression line
50 Creating 3-D plots

 Packages plot3D, ggplot2 contain useful 3D

plotting options
 plot3d, scatter3d, surf3d, persp3d are some
of the commonly used plots.
 plot3d is from package rgl.
 It allows creating interactive 3D plots that can be
rotated using the mouse.
plot3d(x, y, z, col="red", size=3)
51 Creating 3-D plots: surf3D

 Surf3d (package: plot3D) allows us to create

surface plots like the one shown below:
#source: http://blog.revolutionanalytics.com/2014/02/3d-
plots-in-r.html
library ('ggplot2')
library(plot3D)
par(mar = c(2, 2, 2, 2))
par(mfrow = c(1, 1))
R <- 3; r <- 2
x <- seq(0, 2*pi,length.out=50)
y <- seq(0, pi,length.out=50)
M <- mesh(x, y)
alpha <- M$x; beta <- M$y
surf3D(x = (R + r*cos(alpha)) * cos(beta),
y = (R + r*cos(alpha)) * sin(beta),
z = r * sin(alpha),
colkey=FALSE,
bty="b2",
main="Half of a Torus")
52 Creating 3-D plots: persp3d

 persp3d(package: plot3D) allows us to create

surface plots like the one shown below:

xdim <- 16
newmap <- array(0,dim=c(xdim,xdim))
newmap <- rnorm(256,1,.2)
jet.colors <- colorRampPalette( c("yellow", "red") )
pal <- jet.colors(100)
col.ind <- cut(newmap,100) # colour indices of each point
persp3d(seq(1:xdim),seq(1:xdim),newmap,shade=TRUE,
type="wire", col=pal[col.ind],xlab="",ylab="",zlab="",
cex.axis=1.5,xtics="",aspect=2,zlim=c(0,5))
53