Data Types & Structures

class: title-slide, center, middle

# Data Types & Structures

---
# Types of data

R has different types of data, and an object’s type affects how it interacts with functions and other objects.

So far, we’ve just been working with numeric data, but there are several other types to be aware of...

Type | Definition | Example
-----|------------|--------
Integer | whole numbers from -Inf to +Inf | `1L`, `-2L`
Double | numbers, fractions & decimals | `-7`, `0.2`, `-5/2`
Character | quoted strings of letters, numbers, and allowed symbols | `"1"`, `"one"`, `"o-n-e"`, `"o.n.e"`
Logical | logical constants of true or false | `TRUE`, `FALSE`
Factor | ordered, labelled variable | variable for year in college labelled `"Freshman"`, `"Sophomore"`, etc.

---
# Types of data

You can use `typeof()` to find out the type of a value or object

```r
typeof(1)
```

```
## [1] "double"
```

```r
typeof(TRUE)
```

```
## [1] "logical"
```

```r
typeof(1L)
```

```
## [1] "integer"
```

```r
typeof("one")
```

```
## [1] "character"
```

---
# Types of data

There are a few special values worth knowing about too

Value | Definition
-----|------------
`NA`   | Missing value ("not available")
`NaN ` | Not a Number (e.g. 0/0)
`Inf` | Positive infinity
`-Inf` | Negative infinity
`NULL` | An object that exists but is completely empty
---
class: inverse, center, middle
# Data structures

---
# Vectors

Often, we’re not working with individual values, but with a group of multiple related values -- or a **vector** of values.

--
***

We can create a vector of ordered numbers using the form <br> `starting_number` **:** `ending_number`.

For example, we could make `x` a vector with the numbers between 1 and 5.

```r
x <- 1:5
x
```

```
## [1] 1 2 3 4 5
```

--
***
Let's look at the Environment pane in RStudio... <i class="fas  fa-cloud "></i>

Since `x` is a vector, it tells us what type of vector it is and its length in addition to its contents (which can be abbreviated if the object is larger).

---
# Vectors

We can create a vector of any numbers we want using `c()`, which is a **function**. You can think of `c()` as short for "combine".

--
***

You use `c()` by putting numbers separated by a comma within the parentheses.

```r
# combine values into a vector and assign to an object names 'x'
x <- c(2, 8.5, 1, 9)

# print x
x
```

```
## [1] 2.0 8.5 1.0 9.0
```

--
***

We can also create a vector of numbers using `seq()`.

`seq()` is a function that creates a sequence of numbers.

---
# Vectors

To learn how any R function works, you can access the help documentation by typing `?function_name`.

--
***

Let's take a look at how `seq()` works... <i class="fas  fa-cloud "></i>

```r
?seq
```

---
# Vectors

What happens if we run `seq()` with no arguments?

```r
seq()
```

```
## [1] 1
```

--
***

The `seq()` function has **arguments** with default values.

The first two arguments are `from` and `to`, which specify the starting and end values of the sequence. By *default* `from = 1` and `to = 1`.

This means that typing `seq()` is equivalent to typing `seq(from = 1, to = 1)`, which generates a sequence with just one value: `1`.

We will talk more about how functions work in the next slide deck.

---
# Vectors

To make a sequence from 1 to 5 with this function, we have to set the arguments accordingly: `from = 1` and `to = 5`

```r
seq(from = 1, to = 5)
```

```
## [1] 1 2 3 4 5
```

--
***

We can also set one or more of the other arguments...

The `by` argument allows us to change the increment of the sequence. For example, to get every *other* number between 1 and 5, we would set `by = 2`

```r
seq(from = 1, to = 5, by = 2)
```

```
## [1] 1 3 5
```

---
# Vectors

Vectors are just 1-dimensional sequences **of a single type of data**.

Note that vectors can also include strings or character values.

```r
letters <- c("a", "b", "c", "d")
letters
```

```
## [1] "a" "b" "c" "d"
```

--
***

The general rule R uses is to set the vector to be the most "permissive" type necessary.

For example, what happens if we combine the vectors `x` (from earlier) and `letters` together?

```r
mixed_vec <- c(x, letters)
mixed_vec
```

```
## [1] "2"   "8.5" "1"   "9"   "a"   "b"   "c"   "d"
```

---
# Vectors

```r
mixed_vec
```

```
## [1] "2"   "8.5" "1"   "9"   "a"   "b"   "c"   "d"
```

Notice the quotes? R turned all of our numbers into strings, since strings are more "permissive" than numbers.

```r
typeof(mixed_vec)
```

```
## [1] "character"
```

--
***

This is called **coercion**. R coerces a vector into whichever type will accommodate all of the values. We can coerce `mixed_vec` to be numeric using `as.numeric()`, but notice  what happens to the character values 👀

```r
as.numeric(mixed_vec)
```

```
## Warning: NAs introduced by coercion
```

```
## [1] 2.0 8.5 1.0 9.0  NA  NA  NA  NA
```

---
class: inverse
# Your turn 1

1. Create an object called `x` that is assigned the number 8.

1. Create an object called `y` that is a sequence of numbers from 2 to 16, by 2.

1. Add `x` and `y`. What happens?

---
class: solution

# Solution

.panelset[
.panel[.panel-name[Q1]

```r
# Q1.
x <- 8
```
]

.panel[.panel-name[Q2]

```r
# Q2.
y <- seq(from = 2, to = 16, by = 2)
y
```

```
## [1]  2  4  6  8 10 12 14 16
```
]

.panel[.panel-name[Q3]

```r
# Q3
x + y
```

```
## [1] 10 12 14 16 18 20 22 24
```

***

This is an example of **vector recycling**.

When applying an operation to two vectors that requires them to be the same length, R automatically recycles, or repeats, the shorter one, until it is long enough to match the longer one.
]
]
---
class: inverse
# Your turn 2

1. Create an object called `a` that is just the letter "a" and an object `x` that is assigned the number 8. Add `a` to `x`. What happens?

1. Create a vector called `b` that is just the number 8 in quotes. Add `b` to `x` (from above). What happens?

1. Find some way to add `b` to `x`. (*Hint*: Don't forget about coercion.)

---
class: solution 
# Solution

.panelset[
.panel[.panel-name[Q1]

```r
# Q1.
a <- "a"
x <- 8

a + x 
```

```
## Error in a + x: non-numeric argument to binary operator
```
]

.panel[.panel-name[Q2]

```r
# Q2.
b <- "8"

b + x
```

```
## Error in b + x: non-numeric argument to binary operator
```
]

.panel[.panel-name[Q3]

```r
# Q3.
as.numeric(b) + x
```

```
## [1] 16
```
]
]

---
# Indexing vectors

How do we extract elements out of vectors?

This is called **indexing**, and it is frequently quite useful

There are a number of methods for indexing that are good to be familiar with

---
# Indexing vectors

### Indexing by position

Vectors can be indexed numerically, starting with 1 (not 0). We can extract specific elements from a vector by putting the index of their position inside brackets `[]`.

--
***

Let's take a new vector `z` as an example:

```r
z <- 6:10
```

--
***

.panelset[
.panel[.panel-name[Example 1]

Let's get just the first element of `z`:

```r
z[1]
```

```
## [1] 6
```

]

.panel[.panel-name[Example 2]

Get the first and third element by passing those indexes as a vector using `c()`.

```r
z[c(1, 3)]
```

```
## [1] 6 8
```
]
]

---
# Indexing Vectors

### Negative indexing

```r
z
```

```
## [1]  6  7  8  9 10
```

***

We could also say which elements *not* to give us using the minus sign (`-`).

.panelset[
.panel[.panel-name[Example 1]

Let's get rid of the first element:

```r
z[-1]
```

```
## [1]  7  8  9 10
```
]

.panel[.panel-name[Example 2]

Get rid of the first and third elements

```r
z[-c(1, 3)]
```

```
## [1]  7  9 10
```
]
]

---
# Indexing Vectors

### Indexing by name

Finally, if the elements in the vector have names, we can refer to them by name instead of their numerical index. You can see the names of a vector using `names()`.

```r
names(z)
```

```
## NULL
```

--
***

Looks like the elements in `z` have no names.  We can change that by assigning them names using a vector of character values.

```r
names(z) <- c("first", "second", "third", "fourth", "fifth")
z
```

```
##  first second  third fourth  fifth 
##      6      7      8      9     10
```

---
# Indexing Vectors

### Indexing by name

```r
z
```

```
##  first second  third fourth  fifth 
##      6      7      8      9     10
```

***

Now we can use the names of the elements in `z` for subsetting, using quotes

```r
z["first"]
```

```
## first 
##     6
```

---
# Modifying Vectors

You can use indexing to change elements within a vector.

For example, we could change the first element of `z` to missing, or `NA`.

```r
z[1] <- NA
z
```

```
##  first second  third fourth  fifth 
##     NA      7      8      9     10
```

---
class: inverse
# Your turn 3

1. Create a vector called `named` that includes the numbers 1 to 5. Name the values "a", "b", "c", "d", and "e" (in order).

1. Print the first element using numerical indexing and the last element using name indexing.

1. Change the  third element of `named` to the value 21 and then show your results.

---
class: solution
# Solution

.panelset[
.panel[.panel-name[Q1]

```r
# Q1. 
named <- c(a = 1, b = 2, c = 3, d = 4, e = 5)
named 
```

```
## a b c d e 
## 1 2 3 4 5
```

```r
# this works too
named <- c(1, 2, 3, 4, 5)
names(named) <- c("a", "b", "c", "d", "e")
named
```

```
## a b c d e 
## 1 2 3 4 5
```

]

.panel[.panel-name[Q2]

```r
named[1]
```

```
## a 
## 1
```

```r
named["e"]
```

```
## e 
## 5
```

]

.panel[.panel-name[Q3]

```r
# Q2.
named[3] <- named[3]*7
named
```

```
##  a  b  c  d  e 
##  1  2 21  4  5
```

```r
# this works too
named[3] <- 21
```

]
]

---
# Lists

Vectors are great for storing a single type of data, but what if we have a variety of different kinds of data we want to store together?

--
***

For example, let's say I have some information about Jane Doe that I want to store together in a single object:

- her name ("Jane Doe") -- a **string**
- her height in feet (5.5) -- a **number**
- whether or not she is right-handed (TRUE) -- a **logical**

A vector won't work -- every element is coerced to a character (notice the quotes).

```r
c("Jane Doe", 5.5, TRUE)
```

```
## [1] "Jane Doe" "5.5"      "TRUE"
```

Instead, we can put them in a **list**. Lists are very flexible -- they can contain different types of data and preserve those types.

---
# Creating Lists

We can create a list with the `list()` function

```r
jane_doe <- list("Jane Doe", 5.5, TRUE)

jane_doe
```

```
## [[1]]
## [1] "Jane Doe"
## 
## [[2]]
## [1] 5.5
## 
## [[3]]
## [1] TRUE
```

---
# Creating Lists

And, we can give each element of the list a name to make it easier to keep track of them.

```r
jane_doe <- list(name = "Jane Doe",
                height = 5.5,
                right_handed = TRUE)

jane_doe
```

```
## $name
## [1] "Jane Doe"
## 
## $height
## [1] 5.5
## 
## $right_handed
## [1] TRUE
```

--
***

Notice that `[[1]]`, `[[2]]`, and `[[3]]`, the element indices, have been replaced by the names `name`, `height` and `right_handed` 👀

---
# Creating Lists

You can also see the names of a list by running `names()` on it

```r
names(jane_doe)
```

```
## [1] "name"         "height"       "right_handed"
```

--
***

Lists are even more flexible than we've seen so far. In addition to being of heterogeneous type, each element of a list can be of different lengths.

---
# Creating Lists

Let's add another element to the list about Jane that contains her favorite types of ice cream (she can't choose just one!)

Notice use of `c()` to create the element `ice_cream` 👀

```r
jane_doe <- list(name = "Jane Doe",
                height = 5.5,
                right_handed = TRUE,
                ice_cream = c("mint chip", "pistachio"))
jane_doe
```

```
## $name
## [1] "Jane Doe"
## 
## $height
## [1] 5.5
## 
## $right_handed
## [1] TRUE
## 
## $ice_cream
## [1] "mint chip" "pistachio"
```

---
# Indexing Lists

### Indexing by position

Like vectors, lists can be indexed by their name or their position (numerically).

.panelset[
.panel[.panel-name[Example 1]

For example, if we wanted the `height` element, we could get it out using its position as the second element of the list:

```r
jane_doe[2]
```

```
## $height
## [1] 5.5
```
]

.panel[.panel-name[Example 2]

Now let's say we want to know Jane's height in *inches*. Let's see if we can get that by multiplying the `height` element by 12.

```r
jane_doe[2] * 12
```

```
## Error in jane_doe[2] * 12: non-numeric argument to binary operator
```

***
R is telling us that we supplied a non-numeric argument, i.e. `jane_doe[2]`.

This happened because single bracket indexing on a list returns a list -- but what we need is the *contents* of the list (in this case, just the number `5.5`).
]

.panel[.panel-name[Example 3]

If we want the actual object stored at the first position instead of a list containing that object, we have to use double-bracket indexing `list[[i]]`:

```r
jane_doe[[2]] 
```

```
## [1] 5.5
```

***
Notice it no longer has the `$height`.

In general, a `$label` is a hint that you're looking at a list (the container) and not just the object stored at that position (the contents).

]

.panel[.panel-name[Example 4]
Now let's see Jane's height in inches.

```r
jane_doe[[2]] * 12
```

```
## [1] 66
```
]
]

---
# Indexing Lists

### Indexing by name

.panelset[
.panel[.panel-name[Example 1]

The same applies to name indexing. With lists, you can get a list containing the indexed object with single brackets `[]`.

```r
jane_doe["height"]
```

```
## $height
## [1] 5.5
```
]

.panel[.panel-name[Example 2]

And double brackets `[[]]` can be used to get the *contents* -- the  object stored with that name.

```r
jane_doe[["height"]]
```

```
## [1] 5.5
```
]

.panel[.panel-name[Example 3]

You can also use `list$name` to get the object stored with a particular name too. It is equivalent to double brackets, but you don't need quotes

```r
jane_doe$height
```

```
## [1] 5.5
```
]
]

---
# Modifying Lists

Just like vectors, we can change or add elements to our list using indexing.

--
***

Let's save the inches transformation of the `height` element as `height_in`.

```r
jane_doe$height_in <- jane_doe$height * 12
jane_doe
```

```
## $name
## [1] "Jane Doe"
## 
## $height
## [1] 5.5
## 
## $right_handed
## [1] TRUE
## 
## $ice_cream
## [1] "mint chip" "pistachio"
## 
## $height_in
## [1] 66
```

---
class: inverse
# Your turn 4

1. Create a list like `jane_doe` that is made up of `name`, `height`, `right_handed`, and `ice_cream`, but corresponds to information about you.

1. Index your list to print only your name.

---
class: solution
# Solution

.panelset[
.panel[.panel-name[Q1]

```r
# Q1. (Answers will vary)
jane_doe <- list(name = "Jane Doe",
                height = 5.5,
                right_handed = TRUE,
                ice_cream = c("mint chip", "pistachio"))
jane_doe
```

```
## $name
## [1] "Jane Doe"
## 
## $height
## [1] 5.5
## 
## $right_handed
## [1] TRUE
## 
## $ice_cream
## [1] "mint chip" "pistachio"
```
]

.panel[.panel-name[Q2]

```r
# Q2. 
jane_doe$name
```

```
## [1] "Jane Doe"
```

```r
jane_doe[["name"]]
```

```
## [1] "Jane Doe"
```

]
]

---
# Indexing Lists

### Indexing objects within lists

As we saw with the object `ice_cream` stored in the list `jane_doe`, objects within lists can have different dimensions and length.

What if we wanted just one element of an object in a list, such as just the second element of `ice_cream`?

We can use indexing on the `ice_cream` vector stored within the `jane_doe` list by chaining indexes.

.panelset[
.panel[.panel-name[Example 1]

We could do that with numerical indexing...

```r
jane_doe[[4]][2]
```

```
## [1] "pistachio"
```
]

.panel[.panel-name[Example 2]
...or with name indexing

```r
jane_doe[["ice_cream"]][2]
```

```
## [1] "pistachio"
```
]

.panel[.panel-name[Example 3]

...or with dollar sign (`$`) indexing:

```r
jane_doe$ice_cream[2]
```

```
## [1] "pistachio"
```
]
]

---
# Data frames

A **data frame** is a common way of representing rectangular data -- collections of values that are each associated with a variable (column) and an observation (row). In other words, it has 2 dimensions.

A data frame is technically a special kind of list -- it can contain different kinds of data in different columns, but each column must be the same length.

--
***

We can create a data frame very similarly to how we made a list, but replacing `list()` with `data.frame()`.

```r
df_1 <- data.frame(c1 = c(1, 3),
                   c2 = c(2, 4), 
                   c3 = c("a", "b"))

df_1
```

```
##   c1 c2 c3
## 1  1  2  a
## 2  3  4  b
```

---
# Indexing data frames

```r
df_1
```

```
##   c1 c2 c3
## 1  1  2  a
## 2  3  4  b
```

***

Indexing data frames is similar to how we index vectors, except we have two dimensions, which we use like so: `[row, column]`

--
***

.panelset[
.panel[.panel-name[Example 1]

Let's get the first row and third column of `df_1` using numerical indexing

```r
df_1[1, 3]
```

```
## [1] "a"
```

]
.panel[.panel-name[Example 2]

You can also get an entire row or column by leaving an index blank. Let's get all rows but only column 2:

```r
df_1[, 2]
```

```
## [1] 2 4
```

]

.panel[.panel-name[Example 3]

We can also index by name

```r
df_1[, "c2"]
```

```
## [1] 2 4
```
]
]

---
# Indexing data frames

```r
df_1
```

```
##   c1 c2 c3
## 1  1  2  a
## 2  3  4  b
```

***

As with lists, we can use the `$` operator in the form `dataframe$column_name` (similar to `list$object`).

--
***

.panelset[
.panel[.panel-name[Example 1]

Let's get the first column

```r
df_1$c1
```

```
## [1] 1 3
```
]

.panel[.panel-name[Example 2]

We can also index a column using vector indexing, since a single column is just a 1-dimensional vector.

```r
df_1$c1[1] # get the first value in column 1
```

```
## [1] 1
```
]
]

---
# Modifying data frames

```r
df_1
```

```
##   c1 c2 c3
## 1  1  2  a
## 2  3  4  b
```

***

Just like lists and vectors, you can modify a data frame and add new elements or change existing elements by referencing indexes.

--
***

.panelset[
.panel[.panel-name[Example 1]

We could create `c4` as the sum of `c1` and `c2`:

```r
df_1$c4 <- df_1$c1 + df_1$c2

df_1
```

```
##   c1 c2 c3 c4
## 1  1  2  a  3
## 2  3  4  b  7
```
]

.panel[.panel-name[Example 2]
Or we could replace an element using indexing too. Let's replace `c1` with `c1^2`:

```r
df_1$c1 <-  df_1$c1^2

df_1
```

```
##   c1 c2 c3 c4
## 1  1  2  a  3
## 2  9  4  b  7
```

]
]

---
# Inspecting data frames

```r
df_1
```

```
##   c1 c2 c3 c4
## 1  1  2  a  3
## 2  9  4  b  7
```

***

We can use the `str()` function to get the structure of the data. This tells us the type of each column.

```r
str(df_1)
```

```
## 'data.frame':	2 obs. of  4 variables:
##  $ c1: num  1 9
##  $ c2: num  2 4
##  $ c3: chr  "a" "b"
##  $ c4: num  3 7
```

---
class: inverse

# Your turn 5

1. Make a data frame, called `df_2`, that has 3 columns as shown below. After you create it, check the structure with `str()`.

```
##   c1 c2 c3
## 1  1  2  a
## 2  2  4  b
## 3  3  6  c
```

2. Add a fourth column, `c4`, which is the first and second columns multiplied together.

---
class: solution

# Solution

.panelset[
.panel[.panel-name[Q1]

```r
# Q1.
df_2 <- data.frame(c1 = c(1, 2, 3),
                   c2 = c(2, 4, 6),
                   c3 = c("a", "b", "c"))

str(df_2)
```

```
## 'data.frame':	3 obs. of  3 variables:
##  $ c1: num  1 2 3
##  $ c2: num  2 4 6
##  $ c3: chr  "a" "b" "c"
```
]

.panel[.panel-name[Q2]

```r
# Q2.
df_2$c4 <- df_2$c1 * df_2$c2

df_2
```

```
##   c1 c2 c3 c4
## 1  1  2  a  2
## 2  2  4  b  8
## 3  3  6  c 18
```
]
]

---
# Recap

We just learned about different types of data (numeric, character, logical, factor, etc.) and some different ways they can be structured -- including vectors, lists and data frames.

--
***

Here's a quick table that summarizes data structures.

<br>

| | Homogeneous data | Heterogeneous data |
|------------|----------------| ------------------|
| 1-Dimensional | Atomic Vector | List |
| 2-Dimensional | Matrix `*` | Data frame |

<br>

***
`*` We didn't talk about matrices today, but if you take PSY611, you will learn more about them in the context of the General Linear Model

---
# Concept map

.footnote[Source: [rstudio/concept-maps](https://github.com/rstudio/concept-maps)]

---
class: inverse, center, middle
# Q & A

---
class: inverse, center, middle
# Next up...

## Functions & Debugging

---
class: inverse, center, middle
# Break!