Working with Vectors and Matrices in R

This session is intended to introduce some of the features in R for dealing with vectors and matrices. We will be using these features throughout the semester, so learn this stuff well.

Vectors

R handles vector objects quite easily and intuitively.

x<-c(1,3,2,10,5)    #create a vector x with 5 components

x

y<-1:5              #create a vector of consecutive integers

y

y+2                 #scalar addition

2*y                 #scalar multiplication

y^2                 #raise each component to the second power

2^y                 #raise 2 to the first through fifth power

y                   #y itself has not been unchanged

y<-y*2

y                   #it is now changed

More examples of vector arithmetic:

x<-c(1,3,2,10,5); y<-1:5 #two or more statements are separated by semicolons

x;y

x+y

x*y

x/y

x^y

sum(x)            #sum of elements in x

cumsum(x)         #cumulative sum vector

diff(x)           # first difference

diff(x,2)         #second difference

max(x)            #maximum

min(x)            #minimum

Sorting can be done using sort() command:

x

sort(x)                # increasing order

sort(x, decreasing=T)  # decreasing order

Component extraction is a very important part of vector calculation.

x

length(x)           # number of elements in x

x[3]                # the third element of x

x[3:5]              # the third to fifth element of x, inclusive

x[-2]               # all except the second element

x[x>3]              # list of elements in x greater than 3

Logical vectors can be handy:

x>3

as.numeric(x>3)     # as.numeric() function coerces logical components to numeric

sum(x>3)            # number of elements in x greater than 3

(1:length(x))[x<=2] # indices of x whose components are less than or equal to 2

z<-as.logical(c(1,0,0,1)) # numeric to logical vector conversion

z

Character vector:

colors<-c("green", "blue", "orange", "yellow", "red")

colors

Individual components can be named and referenced by their names.

names(x)            # check if any names are attached to x

names(x)<-colors    # assign the names using the character vector colors

names(x)

x

x["green"]          # component reference by its name

names(x)<-NULL      # names can be removed by assigning NULL

x

seq() and rep() provide convenient ways to a construct vectors with a certain pattern.

seq(10)

seq(0,1,length=10)

seq(0,1,by=0.1)

rep(1,3)

c(rep(1,3),rep(2,2),rep(-1,4))

rep("Small",3)

c(rep("Small",3),rep("Medium",4))

rep(c("Low","High"),3)

Matrices

A matrix refers to a numeric array of rows and columns. One of the easiest ways to create a matrix is to combine vectors of equal length using cbind(), meaning "column bind":

x

y

m1<-cbind(x,y);m1

t(m1)                # transpose of m1

m1<-t(cbind(x,y))    # Or you can combine them and assign in one step

m1

dim(m1)              # 2 by 5 matrix

m1<-rbind(x,y)       # rbind() is for row bind and equivalent to t(cbind()).

m1

Of course you can directly list the elements and specify the matrix:

m2<-matrix(c(1,3,2,5,-1,2,2,3,9),nrow=3);m2

Note that the elements are used to fill the first column, then the second column and so on. To fill row-wise, we specify byrow=T option:

m2<-matrix(c(1,3,2,5,-1,2,2,3,9),ncol=3,byrow=T);m2

Extracting the components of a matrix involves one or two indices.

m2

m2[2,3]            #element of m2 at the second row, third column

m2[2,]             #second row

m2[,3]             #third column

m2[-1,]            #submatrix of m2 without the first row

m2[,-1]            #ditto, sans the first column

m2[-1,-1]          #submatrix of m2 with the first row and column removed

Matrix computation is usually done component-wise.

m1<-matrix(1:4, ncol=2); m2<-matrix(c(10,20,30,40),ncol=2)

m1; m2

2*m1                # scalar multiplication

m1+m2               # matrix addition

m1*m2               # component-wise multiplication

Note that m1*m2 is NOT the usual matrix multiplication. To do the matrix multiplication, you should use %*% operator instead.

m1 %*% m2

solve(m1)            #inverse matrix of m1

solve(m1)%*%m1       #check if it is the inverse

diag(3)              #diag() is used to construct a k by k identity matrix

diag(c(2,3,3))       #or other diagonal matrices

Rank of a matrix. There is no rank command, as in some packages.

However, you can get the rank of a matrix using the qr factorization

qr(m1)$rank   # Returns the matrix rank.

det(m1); det(m2)  #Calculate the determinant of a matrix using det()

eigen(m2) #Eigenvalues and eigenvectors of a matrix is handled by eigen() function:

Matrix Factorization

m <- matrix(c(5,1,1,3),2,2)  # Create a matrix known to be symmetrical and positive definite

m

cm <- chol(m)   # Compute the choleski factorization of m.

cm

Check the choleski factorization of m, i.e,. cm'%*%cm=m and cm%*%cm=m

t(cm) %*% cm  #-- = 'm'

crossprod(cm)  #-- = 'm'

The Singular Value Decomposition of a rectangular matrix X is computed by

X = U D V',

where U and V are orthogonal, V' means V transposed, and D is a diagonal matrix with the singular values D[i,i].

Equivalently, D = U' X V. Note that this is useful for diagonalizing a matrix.

hilbert <- function(n) { i <- 1:n; 1 / outer(i - 1, i, "+") } # Create a Hilbert matrix for fun.

X <- hilbert(9)[,1:6]

s <- svd(X)

s

Check the factorization

D <- diag(s$d)

s$u %*% D %*% t(s$v) #  X = U D V'

t(s$u) %*% X %*% s$v #  D = U' X V

D