Agenda

• Finishing up on coercion

• Attributes

• Missing values

• Intro to lists

• Subsetting

Learning objectives

• Understand the fundamental difference between lists and atomic vectors

• Understand how atomic vectors are coerced, implicitly or explicitly

• Understand various ways to subset vectors, and how subsetting differs for lists

• Understand what an attribute is, and how to set and modify attributes

Pop quiz

Without actually running the code, predict which type each of the following will coerce to.

c(TRUE, 1L, 0L, "False")
c(1L, FALSE)
c(7L, 6.23, "eight")
c(1.25, TRUE, 4L)Copy Code

Answers

typeof(c(TRUE, 1L, 0L, "False"))Copy Code

## [1] "character"Copy Code

typeof(c(1L, FALSE))Copy Code

## [1] "integer"Copy Code

typeof(c(7L, 6.23, "eight"))Copy Code

## [1] "character"Copy Code

typeof(c(1.25, TRUE, 4L))Copy Code

## [1] "double"Copy Code

Challenge

Work with a partner

One of you share your screen:

• Create four atomic vectors, one for each of the fundamental types

• Combine two or more of the vectors. Predict the implicit coercion of each.

• Apply explicit coercions, and predict the output for each.

(basically quiz each other)

Attributes

• What are attributes?

  • metadata... what's metadata?

  • Data about the data

Other data types

Atomic vectors by themselves make up only a small fraction of the total number of data types in R

What are some other data types?

• Data frames
• Matrices & arrays
• Factors
• Dates

Remember, atomic vectors are the atoms of R. Many other data structures are built from atomic vectors.

• We use attributes to create other data types from atomic vectors

Attributes

Common

• Names
• Dimensions

Less common

• Arbitrary metadata

Examples

Please follow along!

• See all attributes associated with a give object with attributes

library(palmerpenguins)
attributes(penguins[1:50, ]) # limiting rows just for slidesCopy Code

## $names
## [1] "species"           "island"            "bill_length_mm"    "bill_depth_mm"    
## [5] "flipper_length_mm" "body_mass_g"       "sex"               "year"             
## 
## $row.names
##  [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
## [29] 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
## 
## $class
## [1] "tbl_df"     "tbl"        "data.frame"Copy Code

head(penguins)Copy Code

## # A tibble: 6 x 8
##   species island    bill_length_mm bill_depth_mm flipper_length_mm body_mass_g sex   
##   <fct>   <fct>              <dbl>         <dbl>             <int>       <int> <fct> 
## 1 Big one Torgersen         39.1          18.7                 181        3750 male  
## 2 Big one Torgersen         39.5          17.400               186        3800 female
## 3 Big one Torgersen         40.300        18                   195        3250 female
## 4 Big one Torgersen         NA            NA                    NA          NA <NA>  
## 5 Big one Torgersen         36.7          19.3                 193        3450 female
## 6 Big one Torgersen         39.300        20.6                 190        3650 male  
## # … with 1 more variable: year <int>Copy Code

Get specific attribute

• Access just a single attribute by naming it within attr

attr(penguins, "class")Copy Code

## [1] "tbl_df"     "tbl"        "data.frame"Copy Code

attr(penguins, "names")Copy Code

## [1] "species"           "island"            "bill_length_mm"    "bill_depth_mm"    
## [5] "flipper_length_mm" "body_mass_g"       "sex"               "year"Copy Code

Note - this is not generally how you would pull these attributes. Rather, you would use class() and names().

Be specific

• Note in the prior slides, I'm asking for attributes on the entire data frame.

• Is that what I want?... maybe. But the individual vectors may have attributes as well

attributes(penguins$species)Copy Code

## $levels
## [1] "Big one"    "Little one" "Funny one" 
## 
## $class
## [1] "factor"Copy Code

attributes(penguins$bill_length_mm)Copy Code

## NULLCopy Code

Set attributes

• Just redefine them within attr

attr(penguins$species, "levels") <- c("Big one", 
                                      "Little one", 
                                      "Funny one")
head(penguins)Copy Code

## # A tibble: 6 x 8
##   species island    bill_length_mm bill_depth_mm flipper_length_mm body_mass_g sex   
##   <fct>   <fct>              <dbl>         <dbl>             <int>       <int> <fct> 
## 1 Big one Torgersen         39.1          18.7                 181        3750 male  
## 2 Big one Torgersen         39.5          17.400               186        3800 female
## 3 Big one Torgersen         40.300        18                   195        3250 female
## 4 Big one Torgersen         NA            NA                    NA          NA <NA>  
## 5 Big one Torgersen         36.7          19.3                 193        3450 female
## 6 Big one Torgersen         39.300        20.6                 190        3650 male  
## # … with 1 more variable: year <int>Copy Code

Note - you would generally not define levels this way either, but it is a general method for modifying attributes.

Dimensions

• Let's create a matrix (please do it with me)

m <- matrix(1:6, ncol = 2)
mCopy Code

##      [,1] [,2]
## [1,]    1    4
## [2,]    2    5
## [3,]    3    6Copy Code

• Notice how the matrix fills
• Check out the attributes

attributes(m)Copy Code

## $dim
## [1] 3 2Copy Code

Modify the attributes

• Let's change it to a 2 x 3 matrix, instead of 3 x 2 (you try first)

attr(m, "dim") <- c(2, 3)
mCopy Code

##      [,1] [,2] [,3]
## [1,]    1    3    5
## [2,]    2    4    6Copy Code

• is this the result you expected?

Alternative creation

• Create an atomic vector, assign a dimension attribute

v <- 1:6
vCopy Code

## [1] 1 2 3 4 5 6Copy Code

attr(v, "dim") <- c(3, 2)
vCopy Code

##      [,1] [,2]
## [1,]    1    4
## [2,]    2    5
## [3,]    3    6Copy Code

Aside

• What if we wanted it to fill by row?

matrix(6:13, 
       ncol = 2, 
       byrow = TRUE)Copy Code

##      [,1] [,2]
## [1,]    6    7
## [2,]    8    9
## [3,]   10   11
## [4,]   12   13Copy Code

vect <- 6:13
dim(vect) <- c(2, 4)
vectCopy Code

##      [,1] [,2] [,3] [,4]
## [1,]    6    8   10   12
## [2,]    7    9   11   13Copy Code

t(vect)Copy Code

##      [,1] [,2]
## [1,]    6    7
## [2,]    8    9
## [3,]   10   11
## [4,]   12   13Copy Code

Names

• The following (this slide and the next) are equivalent

attr(v, "dimnames") <- list(c("the first", "second", "III"),
                            c("index", "value"))
vCopy Code

##           index value
## the first     1     4
## second        2     5
## III           3     6Copy Code

Names

v2 <- 1:6
attr(v2, "dim") <- c(3, 2)
rownames(v2) <- c("the first", "second", "III")
colnames(v2) <- c("index", "value")
v2Copy Code

##           index value
## the first     1     4
## second        2     5
## III           3     6Copy Code

Arbitrary metadata

• I don't use this often (wouldn't recommend you do either)

attr(v, "matrix_mean") <- mean(v)
vCopy Code

##           index value
## the first     1     4
## second        2     5
## III           3     6
## attr(,"matrix_mean")
## [1] 3.5Copy Code

attr(v, "matrix_mean")Copy Code

## [1] 3.5Copy Code

• Note that anything can be stored as an attribute (including matrices or data frames, etc.)

Real example

Fit a multilevel model and pull the variance-covariance matrix

m <- lme4::lmer(Reaction ~ 1 + Days + (1 + Days|Subject), 
                data = lme4::sleepstudy)
lme4::VarCorr(m)$SubjectCopy Code

##             (Intercept)      Days
## (Intercept)  612.100158  9.604409
## Days           9.604409 35.071714
## attr(,"stddev")
## (Intercept)        Days 
##   24.740658    5.922138 
## attr(,"correlation")
##             (Intercept)       Days
## (Intercept)  1.00000000 0.06555124
## Days         0.06555124 1.00000000Copy Code

Matrices vs Data frames

Usually we want to work with data frames because they represent our data better.

Sometimes a matrix is more efficient because you can operat on the entire matrix at once.

set.seed(42)
m <- matrix(rnorm(100, 200, 10), ncol = 10)
mCopy Code

##           [,1]     [,2]     [,3]     [,4]     [,5]     [,6]     [,7]     [,8]     [,9]
##  [1,] 213.7096 213.0487 196.9336 204.5545 202.0600 203.2193 196.3277 189.5688 215.1271
##  [2,] 194.3530 222.8665 182.1869 207.0484 196.3894 192.1616 201.8523 199.0981 202.5792
##  [3,] 203.6313 186.1114 198.2808 210.3510 207.5816 215.7573 205.8182 206.2352 200.8844
##  [4,] 206.3286 197.2121 212.1467 193.9107 192.7330 206.4290 213.9974 190.4648 198.7910
##  [5,] 204.0427 198.6668 218.9519 205.0496 186.3172 200.8976 192.7271 194.5717 188.0567
##  [6,] 198.9388 206.3595 195.6953 182.8299 204.3282 202.7655 213.0254 205.8100 206.1200
##  [7,] 215.1152 197.1575 197.4273 192.1554 191.8861 206.7929 203.3585 207.6818 197.8286
##  [8,] 199.0534 173.4354 182.3684 191.4909 214.4410 200.8983 210.3851 204.6377 198.1724
##  [9,] 220.1842 175.5953 204.6010 175.8579 195.6855 170.0691 209.2073 191.1422 209.3335
## [10,] 199.3729 213.2011 193.6001 200.3612 206.5565 202.8488 207.2088 189.0022 208.2177
##          [,10]
##  [1,] 213.9212
##  [2,] 195.2383
##  [3,] 206.5035
##  [4,] 213.9111
##  [5,] 188.8921
##  [6,] 191.3921
##  [7,] 188.6826
##  [8,] 185.4079
##  [9,] 200.7998
## [10,] 206.5320Copy Code

sum(m)Copy Code

## [1] 20032.51Copy Code

mean(m)Copy Code

## [1] 200.3251Copy Code

rowSums(m)Copy Code

##  [1] 2048.470 1993.774 2041.155 2025.924 1978.173 2007.265 1998.086 1960.291 1952.476
## [10] 2026.901Copy Code

colSums(m)Copy Code

##  [1] 2054.730 1983.654 1982.192 1963.610 1997.978 2001.839 2053.908 1978.212 2025.111
## [10] 1991.281Copy Code

# standardize the matrix
z <- (m - mean(m)) / sd(m)Copy Code

zCopy Code

##              [,1]       [,2]       [,3]        [,4]       [,5]        [,6]       [,7]
##  [1,]  1.28528802  1.2218239 -0.3256841  0.40613865  0.1665940  0.27791666 -0.3838736
##  [2,] -0.57349498  2.1646089 -1.7417882  0.64562157 -0.3779416 -0.78393268  0.1466507
##  [3,]  0.31748345 -1.3649263 -0.1963133  0.96277141  0.6968297  1.48192480  0.5274934
##  [4,]  0.57650528 -0.2989403  1.1352110 -0.61596668 -0.7290676  0.58614338  1.3129235
##  [5,]  0.35698951 -0.1592501  1.7887033  0.45367758 -1.3451640  0.05497234 -0.7296315
##  [6,] -0.13313334  0.5794704 -0.4445968 -1.68004206  0.3844054  0.23434417  1.2195893
##  [7,]  1.42026916 -0.3041875 -0.2782756 -0.78452812 -0.8103926  0.62108770  0.2912866
##  [8,] -0.12212321 -2.5821792 -1.7243635 -0.84833774  1.3555260  0.05504171  0.9660389
##  [9,]  1.90703954 -2.3747685  0.4106013 -2.34955213 -0.4455350 -2.90544454  0.8529388
## [10,] -0.09144695  1.2364622 -0.6458013  0.00346451  0.5983857  0.24234547  0.6610253
##             [,8]        [,9]       [,10]
##  [1,] -1.0329155  1.42140711  1.30560568
##  [2,] -0.1178282  0.21645471 -0.48848642
##  [3,]  0.5675319  0.05370436  0.59329679
##  [4,] -0.9468782 -0.14731870  1.30463971
##  [5,] -0.5524942 -1.17812024 -1.09789797
##  [6,]  0.5266990  0.55646825 -0.85783015
##  [7,]  0.7064474 -0.23973975 -1.11801576
##  [8,]  0.4141258 -0.20672212 -1.43248556
##  [9,] -0.8818216  0.86505545  0.04558258
## [10,] -1.0873272  0.75791330  0.59603916Copy Code

Stripping attributes

• Many operations will strip attributes (generally why it's not a good idea to store important things in them)

vCopy Code

##           index value
## the first     1     4
## second        2     5
## III           3     6
## attr(,"matrix_mean")
## [1] 3.5Copy Code

rowSums(v)Copy Code

## the first    second       III 
##         5         7         9Copy Code

attributes(rowSums(v))Copy Code

## $names
## [1] "the first" "second"    "III"Copy Code

More on names

• The names attribute corresponds to the individual elements within a vector

names(v)Copy Code

## NULLCopy Code

names(v) <- letters[1:6]
vCopy Code

##           index value
## the first     1     4
## second        2     5
## III           3     6
## attr(,"matrix_mean")
## [1] 3.5
## attr(,"names")
## [1] "a" "b" "c" "d" "e" "f"Copy Code

• Perhaps more straightforward

v3a <- c(a = 5, b = 7, c = 12)
v3aCopy Code

##  a  b  c 
##  5  7 12Copy Code

names(v3a)Copy Code

## [1] "a" "b" "c"Copy Code

attributes(v3a)Copy Code

## $names
## [1] "a" "b" "c"Copy Code

Alternatives

v3b <- c(5, 7, 12)
names(v3b) <- c("a", "b", "c")
v3bCopy Code

##  a  b  c 
##  5  7 12Copy Code

v3c <- setNames(c(5, 7, 12), c("a", "b", "c"))
v3cCopy Code

##  a  b  c 
##  5  7 12Copy Code

• Note that names is not the same thing as colnames, but, somewhat confusingly, both work to rename the variables (columns) of a data frame. We'll talk more about why this is momentarily.

Why names might be helpful

vCopy Code

##           index value
## the first     1     4
## second        2     5
## III           3     6
## attr(,"matrix_mean")
## [1] 3.5
## attr(,"names")
## [1] "a" "b" "c" "d" "e" "f"Copy Code

v["b"]Copy Code

## b 
## 2Copy Code

v["e"]Copy Code

## e 
## 5Copy Code

Implementation of factors

Quickly

fct <- factor(c("a", "a", "b", "c"))
typeof(fct)Copy Code

## [1] "integer"Copy Code

attributes(fct)Copy Code

## $levels
## [1] "a" "b" "c"
## 
## $class
## [1] "factor"Copy Code

str(fct)Copy Code

##  Factor w/ 3 levels "a","b","c": 1 1 2 3Copy Code

More manually

# First create integer vector
int <- c(1L, 1L, 2L, 3L, 1L, 3L)
# assign some levels
attr(int, "levels") <- c("red", "green", "blue")
# change the class to a factor
class(int) <- "factor"
intCopy Code

## [1] red   red   green blue  red   blue 
## Levels: red green blueCopy Code

Implementation of dates

Quickly

date <- Sys.Date()
typeof(date)Copy Code

## [1] "double"Copy Code

attributes(date)Copy Code

## $class
## [1] "Date"Copy Code

attributes(date) <- NULL
dateCopy Code

## [1] 18730Copy Code

• This number represents the days passed since January 1, 1970, known as the Unix epoch.

Missing values

• Missing values breed missing values

NA > 5Copy Code

## [1] NACopy Code

NA * 7Copy Code

## [1] NACopy Code

• What about this one?

NA == NACopy Code

## [1] NACopy Code

It is correct because there's no reason to presume that one missing value is or is not equal to another missing value.

When missing values don't propagate

NA | TRUECopy Code

## [1] TRUECopy Code

x <- c(NA, 3, NA, 5)
any(x > 4)Copy Code

## [1] TRUECopy Code

How to test missingness?

• We've already seen the following doesn't work

x == NACopy Code

## [1] NA NA NA NACopy Code

• Instead, use is.na

is.na(x)Copy Code

## [1]  TRUE FALSE  TRUE FALSECopy Code

• When does this regularly come into play?

Lists

• Lists are vectors, but not atomic vectors

• Fundamental difference - each element can be a different type

list("a", 7L, 3.25, TRUE)Copy Code

## [[1]]
## [1] "a"
## 
## [[2]]
## [1] 7
## 
## [[3]]
## [1] 3.25
## 
## [[4]]
## [1] TRUECopy Code

Lists

l <- list(
  c("a", "b", "c"),
  rnorm(5),
  c(7L, 2L),
  c(TRUE, TRUE, FALSE, TRUE)
)
lCopy Code

## [[1]]
## [1] "a" "b" "c"
## 
## [[2]]
## [1]  1.2009654  1.0447511 -1.0032086  1.8484819 -0.6667734
## 
## [[3]]
## [1] 7 2
## 
## [[4]]
## [1]  TRUE  TRUE FALSE  TRUECopy Code

Check the list

typeof(l)Copy Code

## [1] "list"Copy Code

attributes(l)Copy Code

## NULLCopy Code

str(l)Copy Code

## List of 4
##  $ : chr [1:3] "a" "b" "c"
##  $ : num [1:5] 1.201 1.045 -1.003 1.848 -0.667
##  $ : int [1:2] 7 2
##  $ : logi [1:4] TRUE TRUE FALSE TRUECopy Code

Data frames as lists

• A data frame is just a special case of a list, where all the elements are of the same length.

l_df <- list(
  a = c("red", "blue"),
  b = rnorm(2),
  c = c(7L, 2L),
  d = c(TRUE, FALSE)
)
l_dfCopy Code

## $a
## [1] "red"  "blue"
## 
## $b
## [1]  0.1055138 -0.4222559
## 
## $c
## [1] 7 2
## 
## $d
## [1]  TRUE FALSECopy Code

data.frame(l_df)Copy Code

##      a          b c     d
## 1  red  0.1055138 7  TRUE
## 2 blue -0.4222559 2 FALSECopy Code

A nested list

Lists are often complicated objects. Let's create a somewhat complicated one

x <- c(a = 3, b = 5, c = 7)
l <- list(
  x = x,
  x2 = c(x, x),
  x3 = list(
    vect = x,
    squared = x^2,
    cubed = x^3)
)Copy Code

Subsetting lists

Multiple methods

• Most common: $, [, and [[

l[1]Copy Code

## $x
## a b c 
## 3 5 7Copy Code

typeof(l[1])Copy Code

## [1] "list"Copy Code

l[[1]]Copy Code

## a b c 
## 3 5 7Copy Code

typeof(l[[1]])Copy Code

## [1] "double"Copy Code

l[[1]]["c"]Copy Code

## c 
## 7Copy Code

Named list

• Because the elements of the list are named, we can use $

l$x2Copy Code

## a b c a b c 
## 3 5 7 3 5 7Copy Code

l$x3Copy Code

## $vect
## a b c 
## 3 5 7 
## 
## $squared
##  a  b  c 
##  9 25 49 
## 
## $cubed
##   a   b   c 
##  27 125 343Copy Code

Subsetting nested lists

• Multiple $ if all named

l$x3$squaredCopy Code

##  a  b  c 
##  9 25 49Copy Code

• Note this doesn't work on named elements of an atomic vector, just the named elements of a list

l$x3$squared$bCopy Code

## Error in l$x3$squared$b: $ operator is invalid for atomic vectorsCopy Code

But we could do something like...

l$x3$squared["b"]Copy Code

##  b 
## 25Copy Code

Alternatives

• You can always use logical

• Indexing works too

l[c(TRUE, FALSE, TRUE)]Copy Code

## $x
## a b c 
## 3 5 7 
## 
## $x3
## $x3$vect
## a b c 
## 3 5 7 
## 
## $x3$squared
##  a  b  c 
##  9 25 49 
## 
## $x3$cubed
##   a   b   c 
##  27 125 343Copy Code

l[c(1, 3)]Copy Code

## $x
## a b c 
## 3 5 7 
## 
## $x3
## $x3$vect
## a b c 
## 3 5 7 
## 
## $x3$squared
##  a  b  c 
##  9 25 49 
## 
## $x3$cubed
##   a   b   c 
##  27 125 343Copy Code

Careful with your brackets

l[[c(TRUE, FALSE, FALSE)]]Copy Code

## Error in l[[c(TRUE, FALSE, FALSE)]]: recursive indexing failed at level 2Copy Code

• Why doesn't the above work?

Subsetting in multiple dimensions

• Generally we deal with 2d data frames

• If there are two dimensions, we separate the [ subsetting with a comma

head(mtcars)Copy Code

##                    mpg cyl disp  hp drat    wt  qsec vs am gear carb
## Mazda RX4         21.0   6  160 110 3.90 2.620 16.46  0  1    4    4
## Mazda RX4 Wag     21.0   6  160 110 3.90 2.875 17.02  0  1    4    4
## Datsun 710        22.8   4  108  93 3.85 2.320 18.61  1  1    4    1
## Hornet 4 Drive    21.4   6  258 110 3.08 3.215 19.44  1  0    3    1
## Hornet Sportabout 18.7   8  360 175 3.15 3.440 17.02  0  0    3    2
## Valiant           18.1   6  225 105 2.76 3.460 20.22  1  0    3    1Copy Code

mtcars[3, 4]Copy Code

## [1] 93Copy Code

Empty indicators

• An empty indicator implies "all"

Select the entire fourth column

mtcars[ ,4]Copy Code

##  [1] 110 110  93 110 175 105 245  62  95 123 123 180 180 180 205 215 230  66  52  65  97
## [22] 150 150 245 175  66  91 113 264 175 335 109Copy Code

Select the entire 4th row

mtcars[4, ]Copy Code

##                 mpg cyl disp  hp drat    wt  qsec vs am gear carb
## Hornet 4 Drive 21.4   6  258 110 3.08 3.215 19.44  1  0    3    1Copy Code

Data types returned

• By default, each of the prior will return a vector, which itself can be subset

The following are equivalent

mtcars[4, c("mpg", "hp")]Copy Code

##                 mpg  hp
## Hornet 4 Drive 21.4 110Copy Code

mtcars[4, ][c("mpg", "hp")]Copy Code

##                 mpg  hp
## Hornet 4 Drive 21.4 110Copy Code

Return a data frame

• Often, you don't want the vector returned, but rather the modified data frame.

• Specify drop = FALSE

mtcars[ ,4]Copy Code

##  [1] 110 110  93 110 175 105 245  62  95 123 123 180 180 180 205 215 230  66  52  65  97
## [22] 150 150 245 175  66  91 113 264 175 335 109Copy Code

mtcars[ ,4, drop = FALSE]Copy Code

##                      hp
## Mazda RX4           110
## Mazda RX4 Wag       110
## Datsun 710           93
## Hornet 4 Drive      110
## Hornet Sportabout   175
## Valiant             105
## Duster 360          245
## Merc 240D            62
## Merc 230             95
## Merc 280            123
## Merc 280C           123
## Merc 450SE          180
## Merc 450SL          180
## Merc 450SLC         180
## Cadillac Fleetwood  205
## Lincoln Continental 215
## Chrysler Imperial   230
## Fiat 128             66
## Honda Civic          52
## Toyota Corolla       65
## Toyota Corona        97
## Dodge Challenger    150
## AMC Javelin         150
## Camaro Z28          245
## Pontiac Firebird    175
## Fiat X1-9            66
## Porsche 914-2        91
## Lotus Europa        113
## Ford Pantera L      264
## Ferrari Dino        175
## Maserati Bora       335
## Volvo 142E          109Copy Code

tibbles

• Note dropping the data frame attribute is the default for a data.frame but NOT a tibble.

mtcars_tbl <- tibble::as_tibble(mtcars)
mtcars_tbl[ ,4]Copy Code

## # A tibble: 32 x 1
##       hp
##    <dbl>
##  1   110
##  2   110
##  3    93
##  4   110
##  5   175
##  6   105
##  7   245
##  8    62
##  9    95
## 10   123
## # … with 22 more rowsCopy Code

You can override this

mtcars_tbl[ ,4, drop = TRUE]Copy Code

##  [1] 110 110  93 110 175 105 245  62  95 123 123 180 180 180 205 215 230  66  52  65  97
## [22] 150 150 245 175  66  91 113 264 175 335 109Copy Code

More than two dimensions

• Depending on your applications, you may not run into this much

array <- 1:12
dim(array) <- c(2, 3, 2)
arrayCopy Code

## , , 1
## 
##      [,1] [,2] [,3]
## [1,]    1    3    5
## [2,]    2    4    6
## 
## , , 2
## 
##      [,1] [,2] [,3]
## [1,]    7    9   11
## [2,]    8   10   12Copy Code

Subset array

Select just the second matrix

array[ , ,2]Copy Code

##      [,1] [,2] [,3]
## [1,]    7    9   11
## [2,]    8   10   12Copy Code

Select first column of each matrix

array[ ,1, ]Copy Code

##      [,1] [,2]
## [1,]    1    7
## [2,]    2    8Copy Code

Back to lists

Why are they so useful?

• Fairly obviously, they're much more flexible

• Often returned by functions, for example, lm

m <- lm(mpg ~ hp, mtcars)
str(m)Copy Code

## List of 12
##  $ coefficients : Named num [1:2] 30.0989 -0.0682
##   ..- attr(*, "names")= chr [1:2] "(Intercept)" "hp"
##  $ residuals    : Named num [1:32] -1.594 -1.594 -0.954 -1.194 0.541 ...
##   ..- attr(*, "names")= chr [1:32] "Mazda RX4" "Mazda RX4 Wag" "Datsun 710" "Hornet 4 Drive" ...
##  $ effects      : Named num [1:32] -113.65 -26.046 -0.556 -0.852 0.67 ...
##   ..- attr(*, "names")= chr [1:32] "(Intercept)" "hp" "" "" ...
##  $ rank         : int 2
##  $ fitted.values: Named num [1:32] 22.6 22.6 23.8 22.6 18.2 ...
##   ..- attr(*, "names")= chr [1:32] "Mazda RX4" "Mazda RX4 Wag" "Datsun 710" "Hornet 4 Drive" ...
##  $ assign       : int [1:2] 0 1
##  $ qr           :List of 5
##   ..$ qr   : num [1:32, 1:2] -5.657 0.177 0.177 0.177 0.177 ...
##   .. ..- attr(*, "dimnames")=List of 2
##   .. .. ..$ : chr [1:32] "Mazda RX4" "Mazda RX4 Wag" "Datsun 710" "Hornet 4 Drive" ...
##   .. .. ..$ : chr [1:2] "(Intercept)" "hp"
##   .. ..- attr(*, "assign")= int [1:2] 0 1
##   ..$ qraux: num [1:2] 1.18 1.08
##   ..$ pivot: int [1:2] 1 2
##   ..$ tol  : num 1e-07
##   ..$ rank : int 2
##   ..- attr(*, "class")= chr "qr"
##  $ df.residual  : int 30
##  $ xlevels      : Named list()
##  $ call         : language lm(formula = mpg ~ hp, data = mtcars)
##  $ terms        :Classes 'terms', 'formula'  language mpg ~ hp
##   .. ..- attr(*, "variables")= language list(mpg, hp)
##   .. ..- attr(*, "factors")= int [1:2, 1] 0 1
##   .. .. ..- attr(*, "dimnames")=List of 2
##   .. .. .. ..$ : chr [1:2] "mpg" "hp"
##   .. .. .. ..$ : chr "hp"
##   .. ..- attr(*, "term.labels")= chr "hp"
##   .. ..- attr(*, "order")= int 1
##   .. ..- attr(*, "intercept")= int 1
##   .. ..- attr(*, "response")= int 1
##   .. ..- attr(*, ".Environment")=<environment: 0x7fd864e4b5c0> 
##   .. ..- attr(*, "predvars")= language list(mpg, hp)
##   .. ..- attr(*, "dataClasses")= Named chr [1:2] "numeric" "numeric"
##   .. .. ..- attr(*, "names")= chr [1:2] "mpg" "hp"
##  $ model        :'data.frame':    32 obs. of  2 variables:
##   ..$ mpg: num [1:32] 21 21 22.8 21.4 18.7 18.1 14.3 24.4 22.8 19.2 ...
##   ..$ hp : num [1:32] 110 110 93 110 175 105 245 62 95 123 ...
##   ..- attr(*, "terms")=Classes 'terms', 'formula'  language mpg ~ hp
##   .. .. ..- attr(*, "variables")= language list(mpg, hp)
##   .. .. ..- attr(*, "factors")= int [1:2, 1] 0 1
##   .. .. .. ..- attr(*, "dimnames")=List of 2
##   .. .. .. .. ..$ : chr [1:2] "mpg" "hp"
##   .. .. .. .. ..$ : chr "hp"
##   .. .. ..- attr(*, "term.labels")= chr "hp"
##   .. .. ..- attr(*, "order")= int 1
##   .. .. ..- attr(*, "intercept")= int 1
##   .. .. ..- attr(*, "response")= int 1
##   .. .. ..- attr(*, ".Environment")=<environment: 0x7fd864e4b5c0> 
##   .. .. ..- attr(*, "predvars")= language list(mpg, hp)
##   .. .. ..- attr(*, "dataClasses")= Named chr [1:2] "numeric" "numeric"
##   .. .. .. ..- attr(*, "names")= chr [1:2] "mpg" "hp"
##  - attr(*, "class")= chr "lm"Copy Code

Summary

• Atomic vectors must all be the same type

  • implicit coercion occurs if not (and you haven't specified the coercion explicitly)

• Lists are also vectors, but not atomic vectors

  • Each element can be of a different type and length

  • Incredibly flexible, but often a little more difficult to get the hang of, particularly with subsetting

Any time left?

Practice: Fit the model on the slide two previous

m <- lm(mpg ~ hp, mtcars)Copy Code

Pull each of the following from the model object

• effects
• names of the effects
• qr matrix
• third row of the qr matrix
• fifth rowname of the qr matrix
• data.frame used in the estimation of the model