####################################################
####################################################
##
## TOPICS covered in this file:
##
## matrices ("matrices" is the plural of matrix)
##
## - a matrix is a vector with a "dim" attribute whose
## value is a numeric vector of length 2. The first value
## in the dim attribute is the # of rows, the 2nd value is
## the # of columns in the matrix. The underlying vector
## can be of any type, e.g. numeric, character or logical
##
## - create a matrix with the matrix function
##
## - create a matrix by assigning a value to the dim attribute of a vector
##
## - functions: dim rownames colnames nrow ncol
##
## - mode(SOME_MATRIX) is the mode of the underlying vector
##
## - class(SOME_MATRIX) is "matrix" "array"
##
## - is(SOME_OBJECT, "SOME_CLASS") returns TRUE if the specified class is
## one of the values in the vector that is returned by class(SOME_OBJECT)
##
## - using two vectors between the [brackets], i.e. somematrix[ ROW_VECTOR , COL_VECTOR ]
##
## - using ONE vector between the [brackets], i.e. somematrix[ SOME_VECTOR ]
## retrives data from the underlying vector
##
## - data from 2 or more rows and 2 or more cols is returned as a matrix
##
## - data from a single row or single column is returned as a vector
##
## - you can use the matrix as a vector, e.g. mean(some_matrix)
##
## - specifying row and column names with dimnames argument to matrix function
##
## - rownames and colnames functions
##
## - changing the dimensions of a matrix
##
## - convert a matrix to a vector using functions: as.vector, as.numeric, as.character, as.logical
##
## - change a matrix back to a vector by setting the dim attribute to NULL
## e.g. attr(someMatrix, "dim") <- NULL
##
## - built in vectors LETTERS ("A" "B" "C" ... "Z") and leters ("a" "b" "c" ... "z")
##
## - using the byrow=TRUE option when creating a matrix
##
## - functions: as.numeric, as.logical, as.character
##
## - is.numeric, is.logical, is.character is.matrix is.list
##
## - every matrix is an array, but not every array is a matrix
##
## an array can have 2 OR MORE dimensions
##
## a matrix is by definition a 2 dimensional array
##
## That is why you get the following results
##
## > class ( SOME_ARRAY_OF_3_OR_MORE_DIMENSIONS )
## [1] "array"
##
## > class ( SOME_MATRIX )
## [1] "matrix" "array"
##
##
## - Some examples of how to use a 3 dimensional array
##
####################################################
####################################################
rm(list=ls())
####################################################
####################################################
##
## Matrices ("matrices" is the plural of matrix)
##
####################################################
####################################################30 28. matrices
30.1 DEFINITION: matrix
#-------------------------------
# DEFINITION: matrix
#-------------------------------
# A matrix is a VECTOR (e.g. numeric, logical or character) that is organized
# into rows and columns.
#
# The vector has a "dim" attribute that contains the #of rows and #of columns
# (more on this later)
#
# Since a matrix IS a vector - all of the data must be of the same mode,
# i.e. all numeric, all character or all logical
#
# see examples and usage below ...30.2 FIRST WAY TO CREATE A MATRIX
#--------------------------------
# FIRST WAY TO CREATE A MATRIX
#--------------------------------
# You can use the matrix() function to create a matrix from a vector.
# The general form of this function is:
# matrix(data = NA, nrow = 1, ncol = 1, byrow = FALSE, dimnames = NULL)
#
# The data argument is a vector that contains the data. nrow and ncol are the
# number of rows and number of columns for the matrix.
#
# View the help page by typing:
#
# ?matrix # see the documentation for the matrix function
# EXAMPLE: a matrix with 3 rows and 4 columns:
nums <- matrix( c(10,20,30,40,50,60,70,80,90,100,110,120) , nrow = 3, ncol=4)
nums [,1] [,2] [,3] [,4]
[1,] 10 40 70 100
[2,] 20 50 80 110
[3,] 30 60 90 120# ASIDE BASED ON A QUESTION FROM A STUDENT
# (this is covered in more detail below)
#
# YOU CAN FILL IN THE DATA OF A MATRIX "row by row" or "column by column"
# THIS IS CONTROLLED BY THE byrow ARGUMENT TO THE matrix FUNCTION.
# BY DEFAULT, byrow=FALSE, AND THE DATA IS FILLED IN THE MATRIX
# "column by column". TO HAVE THE DATA BE FILLED IN "row by row" SIMPLY
# SET byrow=TRUE WHEN YOU CALL THE matrix FUNCTION.
numsFilledInByRow <- matrix( c(10,20,30,40,50,60,70,80,90,100,110,120) , nrow = 3, ncol=4, byrow = TRUE)
numsFilledInByRow [,1] [,2] [,3] [,4]
[1,] 10 20 30 40
[2,] 50 60 70 80
[3,] 90 100 110 12030.3 dim( SOME_MATRIX ) ncol( SOME_MATRIX ) nrow( SOME_MATRIX )
#-------------------------------------------------.
# dim( SOME_MATRIX )
# returns a vector, c(# of rows,# of columns)
# shorthand for attr(SOME_MATRIX, "dim")
#
# nrow( SOME_MATRIX )
# returns # of rows
# shorthand for dim(SOME_MATRIX)[1]
#
# ncol( SOME_MATRIX )
# returns # of columns
# shorthand for dim(SOME_MATRIX)[2]
#-------------------------------------------------.
# The "dim" attribute is a numeric vector that contains
# - the number of rows in the first position
# - the number of columns in the 2nd position
# ("dim" stands for the English word "dimensions")
# Let's start over with a matrix whose values are filled in column by column
nums <- matrix( c(10,20,30,40,50,60,70,80,90,100,110,120) , nrow = 3, ncol=4)
nums [,1] [,2] [,3] [,4]
[1,] 10 40 70 100
[2,] 20 50 80 110
[3,] 30 60 90 120attributes(nums) # show the list of all attributes$dim
[1] 3 4attr(nums, "dim") # just get the dim attribute[1] 3 4dim(nums) # same thing - a shorthand for attr(nums,"dim")[1] 3 4mode(dim(nums)) # "numeric"[1] "numeric"length(dim(nums)) # 2[1] 2nrow(nums) # shorthand for dim(nums)[1][1] 3dim(nums)[1] # nrow(nums) is same thing[1] 3attr(nums,"dim")[1] # also same thing[1] 3attr(nums,"year") = 2021
nums [,1] [,2] [,3] [,4]
[1,] 10 40 70 100
[2,] 20 50 80 110
[3,] 30 60 90 120
attr(,"year")
[1] 2021attributes(nums)$dim
[1] 3 4
$year
[1] 2021ncol(nums) # shorthand for dim(nums)[2][1] 4dim(nums)[2] # ncol(nums) is same thing[1] 4attr(nums,"dim")[2] # also same thing[1] 430.4 mode( SOME_OBJECT) vs class( SOME_OBJECT )
#----------------------------------------------------------------------------.
# mode( SOME_OBJECT ) vs class( SOME_OBJECT )
#
# mode( SOME_OBJECT )
# mode returns the underlying basic type of the data
# - i.e. "numeric" or "logical" or "character" or "list"
# Every object has just ONE mode
#
# class( SOME_OBJECT )
# For "regular" vectors and lists, class returns the
# same value as mode returns.
# For more complex "derived" types, such as matrices, dataframes, factors, etc.
# class returns the name(s) of the derived type(s).
# For example:
# class( SOME_DATAFRAME ) is "data.frame"
# class( SOME_MATRIX ) is "matrix" "array" (since a matrix is also an array)
#
# (see more info below)
#----------------------------------------------------------------------------.
nums [,1] [,2] [,3] [,4]
[1,] 10 40 70 100
[2,] 20 50 80 110
[3,] 30 60 90 120
attr(,"year")
[1] 2021attr(nums,"year") = NULL # get rid of the "year" attribute
nums [,1] [,2] [,3] [,4]
[1,] 10 40 70 100
[2,] 20 50 80 110
[3,] 30 60 90 120# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# mode( SOME_OBJECT )
#
# mode returns the underlying basic type of the data
# - i.e. "numeric", "logical", "character" or "list"
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
mode(nums) # numeric , i.e. a numeric vector[1] "numeric"# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# class (SOME_OBJECT)
#
# For "standard plain old" vectors and lists, class(SOME_OBJECT) returns
# the same value as mode(SOME_OBJECT)
#
# For more complex "derived" types, such as matrix
# class returns the name of the derived type(s).
# Since a "matrix" is also a type of "array" the class function
# for matrices returns "matrix" "array"
#
# Note - in older versions of R, class(SOME_MATRIX) used to return just "matrix".
# This changed in R 4.0 to "matrix" "array". There may still be documentation and
# tutorials online that refer to the older functionality.
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
class(nums) # "matrix" "array"[1] "matrix" "array" attr(nums,"dim") = NULL # remove dim attribute
# dim(nums) = NULL # this does the same thing ...
nums [1] 10 20 30 40 50 60 70 80 90 100 110 120class(nums) # "numeric" - it's not a matrix anymore.[1] "numeric"30.5 is( SOME_OBJECT , “SOME_TYPE” )
#--------------------------------------------------.
# is( SOME_OBJECT , "SOME_TYPE" )
#
# This function returns TRUE if "SOME_TYPE" is in the vector that is
# returned by class(SOME_OBJECT). Basically it's the same as
#
# "SOME_TYPE" %in% class(SOME_OBJECT)
#
# NOTE - The inherits and isa functions are similar to the is function.
# For R beginners I recommend you use the "is" function.
# The name is easier to remember than "inherits" and the "isa"
# function has some peculiarities that "is" doesn't.
#--------------------------------------------------.
mat <- matrix( c(10,20,30,40,50,60,70,80,90,100,110,120) , nrow = 3, ncol=4)
mat [,1] [,2] [,3] [,4]
[1,] 10 40 70 100
[2,] 20 50 80 110
[3,] 30 60 90 120class(mat)[1] "matrix" "array" is(mat, "array") # TRUE[1] TRUEis(mat, "matrix") # TRUE[1] TRUEis(mat, "data.frame") # FALSE[1] FALSE#--------------------------------
# SECOND WAY TO CREATE A MATRIX
#--------------------------------
rm(list=ls()) # start over
# Since a matrix is just a vector with a dim attribute (see above) we
# can "create" a matrix by explicitly adding the dim attribute to a vector.
nums <- c(10,20,30,40,50,60,70,80,90,100,110,120) # start with a regular vector
nums [1] 10 20 30 40 50 60 70 80 90 100 110 120mode(nums) # "numeric"[1] "numeric"class(nums) # "numeric"[1] "numeric"dim(nums) <- c(3,4) # add a dim attribute i.e. 3 rows, 4 columns, same as: attr(nums,"dim") <- c(3,4)
nums # we now have a matrix [,1] [,2] [,3] [,4]
[1,] 10 40 70 100
[2,] 20 50 80 110
[3,] 30 60 90 120mode(nums) # "numeric"[1] "numeric"class(nums) # "matrix" "array"[1] "matrix" "array" # Remember ...
attributes(nums) # show the list of all attributes (for right now this only contains dim)$dim
[1] 3 4attr(nums, "dim") # just get the dim attribute[1] 3 4dim(nums) # a shorthand for attr(nums,"dim")[1] 3 430.6 matrix vs dataframe
#----------------------------------------------------------------------------
# NOTE: YOU MAY IGNORE THIS FOR NOW.
#
# We will cover dataframes later, but for those who already know about
# dataframes from other classes, this migh clarify some things for you.
#----------------------------------------------------------------------------
# matrix VS dataframe
#
# - A MATRIX is a vector
# o The vector has a dim attribute whose value is a
# numeric vector with the number of rows and number of columns
#
#
# - A DATAFRAME is a list
# o The list contains several vectors of the same length.
# (the vectors are shown as columns when the dataframe is displayed)
#
# o A dataframe has the following attributes:
# 1. "class" is an attribute whose value is "data.frame"
# 1. "names" is an attribute whose value is a character vector of column names
# 2. "row.names" is an attribute whose value is a character vector of row names
#----------------------------------------------------------------------------30.7 someMatrix [ ROWS_VECTOR , COLS_VECTOR ]
#---------------------------------------------
#
# someMatrix [ ROWS_VECTOR , COLS_VECTOR ]
#
# (returns the info in the ROWS and COLS
# similar to how a dataframe works)
#
#---------------------------------------------
rm(list=ls())
nums <- matrix( c(10,20,30,40,50,60,70,80,90,100,110,120) , nrow = 3, ncol=4)
nums [,1] [,2] [,3] [,4]
[1,] 10 40 70 100
[2,] 20 50 80 110
[3,] 30 60 90 120# In [brackets], specify the [ ROWS , COLUMNS ] that you want.
# This is very similar to the way dataframes are accessed.
nums[c(1,2,3), c(2,4)] # rows: 1,2,3 columns: 2,4 [,1] [,2]
[1,] 40 100
[2,] 50 110
[3,] 60 120nums[c(1,3), c(2,4)] # rows 1,3 columns: 2,4 [,1] [,2]
[1,] 40 100
[2,] 60 120nums[ , c(2,4)] # all rows, columns: 2,4 [,1] [,2]
[1,] 40 100
[2,] 50 110
[3,] 60 120nums[ c(2,3) , ] # rows 2,3 columns: ALL [,1] [,2] [,3] [,4]
[1,] 20 50 80 110
[2,] 30 60 90 12030.8 drop=TRUE vs drop=FALSE
#-------------------------------------------------------------------
# Sometimes the data is returned AS A MATRIX.
#
# - If the data comes from at least two rows and at least two columns
# then the data is returned as a MATRIX.
#
#
# Sometimes the data is returned AS A VECTOR.
#
# - If the data comes from only one row or one column,
# then the data is returned as a VECTOR and not as a matrix.
#
#
# How to override this behavior - someMatrix[ ROWS , COLS , drop=TRUE ]
#
# - If you specify drop=TRUE as a third arguemnt between the [single-brackets]
# Then the data will ALWAYS be returned as a matrix EVEN IF the
# data is all from one row or one column
#------------------------------------------------------------------
# The following only retrieves the data from the 2nd column.
# The data doesn't have a rectangular structure so it is
# returned as a VECTOR and not as a matrix.
nums[ , 2 ] # 2nd column as a vector - since all the data being returned is in one column.[1] 40 50 60class(nums[ , 2 ]) # numeric (only one column - this is NOT a matrix)[1] "numeric"nums[ , 2, drop=FALSE ] # same data as a matrix [,1]
[1,] 40
[2,] 50
[3,] 60# Similarly ... we're limiting the rows, but still only one column
nums[ c(1,2) , 2 ] # all data from a single column - result is vector (not a matrix)[1] 40 50class(nums[ c(1,2), 2 ]) # numeric (only one column - this is NOT a matrix)[1] "numeric"nums[ c(1,2) , 2, drop=FALSE ] # same data as a matrix [,1]
[1,] 40
[2,] 50# At least two rows and at least two cols - returned info IS a MATRIX
nums[ c(1,2), c(2,4)] # matrix (2 or more rows and 2 or more cols - this IS a matrix) [,1] [,2]
[1,] 40 100
[2,] 50 110class(nums[ c(1,2), c(2,4)]) # matrix (2 or more rows and 2 or more cols - this IS a matrix)[1] "matrix" "array" # At least two rows and at least two cols - returned info IS a MATRIX
nums[c(1,3) , ] # matrix (2 or more rows and 2 or more cols - this IS a matrix) [,1] [,2] [,3] [,4]
[1,] 10 40 70 100
[2,] 30 60 90 120class(nums[c(1,3) , ]) # matrix (2 or more rows and 2 or more cols - this IS a matrix)[1] "matrix" "array" nums[3 , ] # numeric (only one row - result is NOT a matrix)[1] 30 60 90 120class(nums[ 3 , ]) # numeric (only one row - result is NOT a matrix)[1] "numeric"nums[3 , c(1,2)] # numeric (only one row - result is NOT a matrix)[1] 30 60class(nums[3 , c(1,2)]) # numeric (only one row - result is NOT a matrix)[1] "numeric"30.9 You can use a matrix like a vector.
#----------------------------------------------------------
# Use a matrix like a vector.
#
# Remember since "under the covers" a matrix IS a vector.
# you can do anything with a matrix that you can do with a vector.
#
# - access individual values using one vector in the [brackets]
#
# - pass the matrix to functions like mean, sum, length, round, etc
#----------------------------------------------------------
# If you use just ONE vector between the [square brackets] and
# you don't include a comma between the brackets, you will wind up
# retrieving the data as if you were retrieving it from the underlying
# vector.
#
# The following retrieves JUST A SINGLE VALUE - i.e. the 2nd value
# from the vector. It does NOT retrieve the 2nd row or the 2nd
# column but the 2nd value!
nums [,1] [,2] [,3] [,4]
[1,] 10 40 70 100
[2,] 20 50 80 110
[3,] 30 60 90 120nums [ 2 ] # 20 - i.e. the 2nd item in the underlying vector![1] 20# BE CAREFUL! - adding a comma before or after the 2 changes the meaning.
nums [ , 2 ] # all ROWs , 2nd column of data[1] 40 50 60nums [ , 2 , drop=FALSE] [,1]
[1,] 40
[2,] 50
[3,] 60# ... and the following will return the 2nd row (as we already saw above):
nums [ 2 , ] # 2nd ROW , all COLUMNS[1] 20 50 80 110# since the following only specifies one vector between the
# [square brackets] it retrieves the 2nd and 4th items from the VECTOR:
nums [ c(2, 4) ] # 20 40 - position 2 and position 4 in underlying vector[1] 20 40# Be careful ...
nums [ 2 , 4 ] # 110 - i.e. ROW 2 , COL 4 (because there are two vectors in the brackets)[1] 11030.10 4 different types of indexing still works with rows and cols of matrices
############################################################################.
# You can use any of the 4 types of indexing that we learned about to
# specify which rows and columns you want. Specifically these are:
#
# - positive index numbers
# - negative index numbers
# - TRUE/FALSE values
# - a vector of row/column names (if there are row/column names)
############################################################################.
#--------------------------------
# Using negative position numbers
#--------------------------------
nums [,1] [,2] [,3] [,4]
[1,] 10 40 70 100
[2,] 20 50 80 110
[3,] 30 60 90 120nums[,-2] # get all except for 2nd column [,1] [,2] [,3]
[1,] 10 70 100
[2,] 20 80 110
[3,] 30 90 120nums[ , c(-2,-3)] # get all except for 2nd and 3rd columns [,1] [,2]
[1,] 10 100
[2,] 20 110
[3,] 30 120nums[c(1,3), c(-2,-3)] # get rows 1,3 and all columns except for 2nd and 3rd [,1] [,2]
[1,] 10 100
[2,] 30 120# The following only has one vector in the brackets
# so we will access the data as a VECTOR
# This returns all values except the 3rd value from the underlying vector.
nums[-3] # one vector in [brackets] - access nums as a VECTOR [1] 10 20 40 50 60 70 80 90 100 110 120# This returns all values except the 2nd and 3rd from the underlying vector
nums [-c(2,3)] # one vector in brackets - access data as if it were a vector [1] 10 40 50 60 70 80 90 100 110 120nums[-(3:10)] # all values except the 3rd through 10th from the vector[1] 10 20 110 120#---------------------------------------------------------------------
# using logical vectors
#---------------------------------------------------------------------
# specify two vectors in the brackets, i.e. [ROWS,COLS]
nums[ , c(TRUE,FALSE,FALSE,TRUE)] # get the 1st and 4th columns [,1] [,2]
[1,] 10 100
[2,] 20 110
[3,] 30 120nums[c(TRUE,TRUE,FALSE) , ] # get the first two rows [,1] [,2] [,3] [,4]
[1,] 10 40 70 100
[2,] 20 50 80 110# specify one vector in the brackets to get info from the underlying vector
nums [c(TRUE, FALSE)] # get every other value from the underlying vector [1] 10 30 50 70 90 110nums[c(TRUE,FALSE), c(TRUE, FALSE)] # rows: every other cols: every other [,1] [,2]
[1,] 10 70
[2,] 30 9030.11 rownames and colnames
#--------------------------------------------------
# rownames and colnames - i.e. using names for rows and columns
# - matrix function dimnames argument
# - rownames function
# - colnames function
#--------------------------------------------------
# use matrix function to setup a matrix with row and column names
# dimnames argument takes a list
# - 1st entry in the list is character vector with ROW names
# - 2nd entry in the list is character vector with COLUMN names
nums <- matrix(c(10,20,30,40,50,60,70,80,90,100,110,120),
nrow = 3,
ncol=4,
dimnames=list(
c("row1", "row2","row3"), # ROW NAMES
c("first","second","third","fourth") # COL NAMES
))
nums first second third fourth
row1 10 40 70 100
row2 20 50 80 110
row3 30 60 90 120# QUESTION
# x is a positive number
# Create a vector "row1" "row2" "row3" .... "rowx"
x=9
paste0("row", 1:x)[1] "row1" "row2" "row3" "row4" "row5" "row6" "row7" "row8" "row9"# QUESTION
# r is the number of rows you want
# c is the number of columns you want
# create a matrix that has the followign structure
#
# "col1" "col2" .... "col-c"
# "row1"
# "row2"
# .
#.
# .
# "row-r"
#
# the values of the matrix should be 10,20,30, etc
r = 4
c = 7
answer <- matrix( 1:(r*c) * 10 , # another way: seq(10, r*c*10, by=10)
nrow = r,
ncol = c,
dimnames=list(
paste0("row", 1:r), # ROW NAMES
paste0("col", 1:c) # COL NAMES
))
answer col1 col2 col3 col4 col5 col6 col7
row1 10 50 90 130 170 210 250
row2 20 60 100 140 180 220 260
row3 30 70 110 150 190 230 270
row4 40 80 120 160 200 240 280# see the documentation for the matrix function by typing:
#
# ?matrix
attributes(nums) # "dim" (a vector) and "dimnames" (a list of 2 vectors)$dim
[1] 3 4
$dimnames
$dimnames[[1]]
[1] "row1" "row2" "row3"
$dimnames[[2]]
[1] "first" "second" "third" "fourth"str(attributes(nums))List of 2
$ dim : int [1:2] 3 4
$ dimnames:List of 2
..$ : chr [1:3] "row1" "row2" "row3"
..$ : chr [1:4] "first" "second" "third" "fourth"#--------------------------------------------
# access the rownames / colnames
#--------------------------------------------
rownames(nums) # the vector of row names[1] "row1" "row2" "row3"attributes(nums)$dimnames[[1]] # same thing[1] "row1" "row2" "row3"colnames(nums) # the vector of column names[1] "first" "second" "third" "fourth"attributes(nums)$dimnames[[2]] # same thing[1] "first" "second" "third" "fourth"# change the rownames / colnames
rownames(nums)[c(1,3)] <- c("apple","pear")
nums first second third fourth
apple 10 40 70 100
row2 20 50 80 110
pear 30 60 90 120rownames(nums)[2] <- "peach"
nums first second third fourth
apple 10 40 70 100
peach 20 50 80 110
pear 30 60 90 120rownames(nums) <- c("a","b","c")
nums first second third fourth
a 10 40 70 100
b 20 50 80 110
c 30 60 90 120nums[ c("a","c") , ] # get the 1st and 3rd rows first second third fourth
a 10 40 70 100
c 30 60 90 120nums[ , c("first", "fourth")] # get the 1st and 4th columns first fourth
a 10 100
b 20 110
c 30 120nums[ c("a", "c"), c("first", "fourth")] # get the 1st and 3rd rows from the 1st and 4th columns first fourth
a 10 100
c 30 120nums[c(1,3), c(1,4)] first fourth
a 10 100
c 30 120#----------------------------------------------------------
# Combining the different ways to access rows and columns
#----------------------------------------------------------
# EXAMPLES
# logical vector and negative position numbers
nums [ c(TRUE, FALSE, TRUE), c(-2,-3) ] # rows: 1,3 columns: all except for 2nd and 3rd first fourth
a 10 100
c 30 120# vector of names and vector of positions
nums [ c("a","c"), c(1,4) ] # rows 1,3 columns 1,4 first fourth
a 10 100
c 30 12030.12 Changing the dimensions of a matrix
#-------------------------------------------
#
# Changing the dimensions of a matrix
#
#-------------------------------------------
# You can change the dimensions of a matrix too:
nums <- matrix(c(10,20,30,40,50,60,70,80,90,100,110,120), nrow = 3, ncol=4)
nums [,1] [,2] [,3] [,4]
[1,] 10 40 70 100
[2,] 20 50 80 110
[3,] 30 60 90 120dim(nums) <- c(4,3) # change to 4 rows and 3 columns
nums [,1] [,2] [,3]
[1,] 10 50 90
[2,] 20 60 100
[3,] 30 70 110
[4,] 40 80 120dim(nums) <- c(2,6) # change to 2 rows and 6 columns
nums [,1] [,2] [,3] [,4] [,5] [,6]
[1,] 10 30 50 70 90 110
[2,] 20 40 60 80 100 12030.13 matrices can be based on any mode of vector: including “character”, “logical” and “numeric”
#------------------------------------------------------------------------------
#
# A matrix can be based on any type (i.e. mode) of underlying vector:
# including "character", "logical" and "numeric"
#
# As with all vectors - all values in the vector must be the
# same mode (ie. "character", "logical" or "numeric")
#
#------------------------------------------------------------------------------
# Character, logical and numeric matrices
#
# Just like you can have numeric matrices you can also have character
# and logical matrices:
# A matrix with character data
students <- matrix(c("joe","sam","sue","bill","anne","heather","mike","alice","chana"),
nrow=3,
ncol=3,
dimnames = list(
1:3, # row names
c("group1", "group2", "group3") # column names
))
students group1 group2 group3
1 "joe" "bill" "mike"
2 "sam" "anne" "alice"
3 "sue" "heather" "chana"as.vector(students) # get the underlying character vector[1] "joe" "sam" "sue" "bill" "anne" "heather" "mike"
[8] "alice" "chana" as.character(students) # same thing[1] "joe" "sam" "sue" "bill" "anne" "heather" "mike"
[8] "alice" "chana" students # students didn't change group1 group2 group3
1 "joe" "bill" "mike"
2 "sam" "anne" "alice"
3 "sue" "heather" "chana"# A matrix with logical data
yesNo <- c(TRUE, TRUE, TRUE, FALSE, FALSE, TRUE)
yesNo[1] TRUE TRUE TRUE FALSE FALSE TRUEdim(yesNo) <- c(3, 2)
yesNo [,1] [,2]
[1,] TRUE FALSE
[2,] TRUE FALSE
[3,] TRUE TRUEdim(yesNo)[1] 3 2nrow(yesNo) # same as: dim(yesNo)[1] [1] 3ncol(yesNo) # same as: dim(yesNo)[2][1] 2# SOME OTHER EXAMPLES:
letters # built in vector of lowercase letters "a" "b" "c" ... etc ... "z" [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s"
[20] "t" "u" "v" "w" "x" "y" "z"LETTERS # built in vector of UPPERCASE letters "A" "B" "C" ... etc ... "Z" [1] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J" "K" "L" "M" "N" "O" "P" "Q" "R" "S"
[20] "T" "U" "V" "W" "X" "Y" "Z"class(LETTERS)[1] "character"class(letters)[1] "character"stuff <- letters[1:20] # assign the first 24 lowercase letters to stuff
mode (stuff) # "character"[1] "character"stuff # "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s" "t" [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s"
[20] "t"dim(stuff) <- c(4,5) # add dimensions
stuff [,1] [,2] [,3] [,4] [,5]
[1,] "a" "e" "i" "m" "q"
[2,] "b" "f" "j" "n" "r"
[3,] "c" "g" "k" "o" "s"
[4,] "d" "h" "l" "p" "t" # Get 2nd and 3rd rows, 5th column
stuff [ c(2,3), 5] # "r" "s"[1] "r" "s"30.14 Convert a matrix to a vector
#-----------------------------------------------------------------------------------
# Convert a matrix to a vector
#
# A few ways:
#
# - remove the dim attribute in any of the following ways (they are all equivalent)
# (this also automatically removes the dimnames attribute if it exists)
#
# o dim(SOME_MATRIX) = NULL
#
# o attr(SOME_MATRIX, "dim") = NULL
#
# o attributes(SOME_MATRIX)$dim = NULL
#
# - use one of the as.xxxxx functions
# (this will remove ALL attributes, including the dim attribute)
#
# o SOME_MATRIX = as.vector(SOME_MATRIX)
#
# o you can similarly use as.numeric, as.logical or as.character to convert
# to a numeric, logical or character vector
#-----------------------------------------------------------------------------------
# View the underlying vector with the as.vector function for any
# vector (or the as.numeric, as.character or as.logical for those types of vectors).
nums <- matrix(c(10,20,30,40,50,60,70,80,90,100,110,120), nrow = 3, ncol=4)
nums [,1] [,2] [,3] [,4]
[1,] 10 40 70 100
[2,] 20 50 80 110
[3,] 30 60 90 120as.numeric(nums) # a numeric vector [1] 10 20 30 40 50 60 70 80 90 100 110 120as.vector(nums) # same - return the underlying vector [1] 10 20 30 40 50 60 70 80 90 100 110 120nums # nums didn't change [,1] [,2] [,3] [,4]
[1,] 10 40 70 100
[2,] 20 50 80 110
[3,] 30 60 90 120# TO change the variable to a vector you would have to assign the new value
# back to the same variable. For example:
nums = as.vector(nums)
nums # 10 20 30 40 50 60 70 80 90 100 110 120 [1] 10 20 30 40 50 60 70 80 90 100 110 120# Set the dimensions of a matrix to NULL
#
# TO remove the dimensions from a matrix, You can also set the value of the
# dim attribute to NULL. The variable will cease to be a matrix and will
# be treated as a regular vector. For exmample:
nums <- matrix(c(10,20,30,40,50,60,70,80,90,100,110,120), nrow = 3, ncol=4)
nums [,1] [,2] [,3] [,4]
[1,] 10 40 70 100
[2,] 20 50 80 110
[3,] 30 60 90 120dim(nums)[1] 3 4dim(nums) <- NULL # remove the dimensions
nums # nums is no longer a matrix [1] 10 20 30 40 50 60 70 80 90 100 110 12030.15 byrow=TRUE
############################
#
# byrow=TRUE
#
###########################
# When you create a matrix the values can be filled in either "by row" or "by
# column" For example, in the following code, the first values in the original
# vector (i.e. 10,20,30) are used to fill in the first column of the matrix.
# Then the following values (i.e. 30,40,50) are used to fill in the 2nd column,
# etc. This is knowns a "filling in the values by column":
originalValues <- c(10,20,30,40,50,60,70,80,90,100,110,120)
originalValues [1] 10 20 30 40 50 60 70 80 90 100 110 120numsA <- matrix(originalValues, nrow = 3, ncol=4)
numsA [,1] [,2] [,3] [,4]
[1,] 10 40 70 100
[2,] 20 50 80 110
[3,] 30 60 90 120# The byrow argument to the matrix function can be used to change this behavior.
# By default the byrow argument is set to FALSE. Therefore the data is filled
# in "by column" as shown above. However by setting byrow=TRUE, the values
# would be filled into the matrix "by row" as shown below:
originalValues <- c(10,20,30,40,50,60,70,80,90,100,110,120)
originalValues [1] 10 20 30 40 50 60 70 80 90 100 110 120numsB <- matrix(originalValues, nrow = 3, ncol=4, byrow=TRUE)
numsB [,1] [,2] [,3] [,4]
[1,] 10 20 30 40
[2,] 50 60 70 80
[3,] 90 100 110 120numsB[2] # using byrow=TRUE rearranges the values in the underlying vector[1] 50# Note that if you convert the matrix back to a vector (as shown earlier in this
# document) then if the data was filled in by column (i.e. byrow=FALSE) then the
# new vector will be in the exact same order as the original data. As shown here
# with the matrix numsA from above:
dim(numsA) <- NULL
numsA # 10 20 30 40 50 60 70 80 90 100 110 120 [1] 10 20 30 40 50 60 70 80 90 100 110 120# However, if the matrix was filled in by row (by setting byrow=TRUE) then the
# arrangement in the underlying vector is changed to the order that would be
# used to fill in the matrix by column. Therefore when the dimensions are
# removed and the matrix is converted back to a vector the data will be in a
# different order. This is seen here with the matrix numsB from above:
dim(numsB) <- NULL
numsB # 10 50 90 20 60 100 30 70 110 40 80 120 [1] 10 50 90 20 60 100 30 70 110 40 80 120# Notice that the order in the resulting vector is derived by reading across the
# rows from the matrix, one row at a time.
# Remember, you can use a matrix as a vector - EXAMPLE
nums <- matrix(c(10,20,30,40,50,60,70,80,90,100,110,120), nrow = 3, ncol=4)
nums [,1] [,2] [,3] [,4]
[1,] 10 40 70 100
[2,] 20 50 80 110
[3,] 30 60 90 120mean(nums)[1] 65sum(nums)[1] 780nums[nums>100] # 100 120 [1] 110 12030.16 CONVERTING DATA FROM ONE TYPE TO ANOTHER USING “as.___” functions,
######################################################################
######################################################################
##
## CONVERTING DATA FROM ONE TYPE TO ANOTHER USING "as.___" functions,
## e.g. as.numeric, as.character, as.logical
##
## Testing the type of data using "is.___" functions
## e.g. is.numeric, is.character, is.logical
##
######################################################################
######################################################################
# Remember, logicals when used in the context of numerics get converted
# implicitly (i.e. "automatically") to numbers. TRUE is converted to 1 and FALSE is converted to 0.
sum (c(TRUE, FALSE, TRUE)) # 2[1] 2mean(c(TRUE, FALSE, TRUE)) # 0.66666, i.e. (1+0+1)/3, i.e. % of values that are true[1] 0.6666667nums <- c(50, 150, 300)
sum(nums > 100) # 2[1] 2# Using the as.numeric function you can force that conversion to happen.
someLogicals <- c(TRUE, FALSE, TRUE)
someLogicals # TRUE FALSE TRUE[1] TRUE FALSE TRUEas.numeric (someLogicals) # 1 0 1[1] 1 0 1someLogicals # TRUE FALSE TRUE (the variable didn't change)[1] TRUE FALSE TRUE# "TRUE" as a character value is NOT the same as
# TRUE as a logical value.
nums <- seq(10,100,10)
nums [1] 10 20 30 40 50 60 70 80 90 100nums[c(TRUE,FALSE)] # every other number: 10 30 50 70 90[1] 10 30 50 70 90nums[c("TRUE","FALSE")] # NA NA (there are no values named "TRUE" or "FALSE")[1] NA NA# You can convert logicals into character also
someLogicals # TRUE FALSE TRUE (no quotes, i.e. logical)[1] TRUE FALSE TRUEas.character(someLogicals) # "TRUE" "FALSE" "TRUE" ("quotes", i.e. character)[1] "TRUE" "FALSE" "TRUE" # In general, you can convert from just about any type into any other
# type. These conversions are accomplished with similar functions such as
#
# as.numeric, as.logical, as.character, etc.
#
# We will discuss these as necessary as the need for them comes up.
prices <- c(1.99,2.99) # numeric data
mean(prices) # 2.49[1] 2.49otherPrices <- c("1.99","2.99") # character data
mean(otherPrices) # NA with a warning Warning in mean.default(otherPrices): argument is not numeric or logical:
returning NA[1] NAas.numeric(otherPrices) # convereted to numeric[1] 1.99 2.99mean(as.numeric(otherPrices)) # 2.49[1] 2.49# Similarly, you can check to see if some data is a particular type
# using "is.____" functions such as is.numeric, is.character, is.logical
is.numeric(otherPrices) # FALSE[1] FALSEis.numeric(prices) # TRUE[1] TRUEis.character(otherPrices) # TRUE[1] TRUEis.character(prices) # FALSE[1] FALSEprices # 1.99 2.99 (numeric data)[1] 1.99 2.99as.character(prices) # "1.99" "2.99" (character data)[1] "1.99" "2.99"30.17 arrays - (A matrix is a 2 dimentional array).
#-------------------------------------------------------------------
# arrays
#
# A matrix is a 2 dimentional array.
#
# arrays can have more than 2 dimensions
#-------------------------------------------------------------------
nums = seq(10,240,by=10)
length(nums) # 24[1] 24# EXAMPLE - a 3 dimensional "array"
#
# The product of the dimensions should equal the length of the underlying vector
dim(nums) = c(3,4,2) # 3*4*2 is 24
nums, , 1
[,1] [,2] [,3] [,4]
[1,] 10 40 70 100
[2,] 20 50 80 110
[3,] 30 60 90 120
, , 2
[,1] [,2] [,3] [,4]
[1,] 130 160 190 220
[2,] 140 170 200 230
[3,] 150 180 210 240class(nums)[1] "array"nums[,,1] # 1st matrix in the array [,1] [,2] [,3] [,4]
[1,] 10 40 70 100
[2,] 20 50 80 110
[3,] 30 60 90 120nums[,,2] # 2nd matrix in the array [,1] [,2] [,3] [,4]
[1,] 130 160 190 220
[2,] 140 170 200 230
[3,] 150 180 210 240nums[3,,1] # 3rd row of first matrix[1] 30 60 90 120nums[3,,2] # 3rd row of 2nd matrix[1] 150 180 210 240nums[3,,1] # 3rd row of first matrix[1] 30 60 90 120nums[3,,2] # 3rd row of 2nd matrix[1] 150 180 210 240nums[1,c(2,3),1] # rows: 1 cols: 2,3 matrix: 1[1] 40 70nums[1,c(2,3),2] # rows: 1 cols: 2,3 matrix: 2[1] 160 190