Atomic Vectors

Ordered Collections of One Type

Last Time

1. R evaluates expressions like a calculator.
2. Functions take arguments and can have defaults.
3. Values can be saved as objects in the environment.
4. An R session, like the shell, has a working directory.
5. Warnings vs. errors.

Key Ideas for Today

1. An atomic vector holds elements of a single type.
2. Special values mark data that is missing or undefined.
3. Operations are vectorized and vectors are recycled.
4. Mixing types triggers coercion.
5. Elements are pulled out by subsetting.

Concept Acquisition

1. An atomic vector is an ordered collection of elements of the same type.
2. The four common types: logical, integer, double, character.
3. NULL, NA, NaN, and Inf behave differently from one another.
4. Vectorization and vector recycling.
5. Implicit coercion follows a hierarchy; explicit coercion is done by hand.
6. Subsetting by index, by name, and by logical.

Tool Acquisition

1. c(), typeof(), length().
2. :, seq(), rep().
3. na.rm = TRUE.
4. as.double() and friends.
5. vec[...].

Concept Application

1. Predict the type of a vector built from mixed inputs.
2. Write the shortest command that generates a given vector.
3. Predict the result of arithmetic on vectors of unequal length.
4. Extract a subset of elements three different ways.

Atomic Vectors

Maybe start with the teaser: this lecture will show at least TWO features of R that show it was designed for data analysis (relative to Python): vectorization and 1-indexing.

In a separate window bring up JupyterHub with the code from last time: distances came in from readLines() and we called mean() on it. That object wasn’t a single number — it was a vector of many numbers. Today we look at that structure directly, since it is the workhorse of everything that follows.

In general, today work from R at the Terminal, since they should now all have it on their computers.

Atomic Vectors

Atomic Vector

R’s principal data structure: an ordered collection of elements of the same type. Created with the c() function (for combine).

Draw a row of boxes on the board — an ordered sequence of cells, each holding one element. Emphasize ordered (position matters) and same type (no mixing).

The four common types

dbl_vec  <- c(3, 5, 1.2)
int_vec  <- c(3L, 5L, 1L)
char_vec <- c("cat", "dog", "dingo")
log_vec  <- c(TRUE, TRUE, FALSE)

Type	Looks like	Note
double	3, 1.2	R’s default for numbers
integer	3L	the L suffix is required
character	"dog"	quotes required
logical	TRUE, FALSE	also T / F, but spell them out

Live-code each assignment, then call the object on its own to print it. Point out the [1] index marker at the start of the printed line. Ask why c(3, 5, 1.2) is a double and not an integer — because 3 without the L is a double.

Inspecting vectors

typeof() returns the type of the vector.

length() returns the number of elements.

typeof(char_vec)
typeof(log_vec)
typeof(dbl_vec)
typeof(int_vec)

length(char_vec)
length(dbl_vec)

These two functions answer the two questions you can ask of any atomic vector: what’s in it? and how many? Run typeof() on all four and read the answers out loud — note "double" not "numeric".

Guess the metaphor

An atomic vector is like a vineyard, an ordered, 1D set of things of the same type (grapes).

Creating vectors quickly

Three shortcuts

: creates a sequence from the left number to the right, stepping by 1.

seq() creates a sequence from a number to a number by an interval.

rep() replicates a vector times times.

4:8
seq(from = 1, to = 3, by = .1)
seq(1, 3, .1)
rep(1:3, times = 2)

Connect back to the last lecture: seq(1, 3, .1) and seq(from = 1, to = 3, by = .1) are the same call, one by position and one by name. Pull up ?seq and ?rep to show there are more arguments than we’re using (length.out, each) — a hook for the problem set.

Your turn

What three commands will generate the following vectors?

[1] 5.0 5.5 6.0 6.5 7.0
[1]  2  1  0 -1 -2
[1] "cat"   "dog"   "dingo" "cat"   "dog"   "dingo"

01:00

The middle one is the interesting case: by must be negative to count down. seq(from = 2, to = -2, by = 1) errors — a good moment to read the error message together.

Solutions

seq(from = 5, to = 7, by = .5)
seq(from = 2, to = -2, by = -1)
2:-2        # also works!
rep(char_vec, times = 2)

Note that the third answer reuses an object we already made rather than retyping the strings — that’s the point of saving objects.

Special values

Four values that aren’t ordinary data

Value	Meaning
NULL	does not exist
NA	not available / missing
NaN	not a number (e.g. 0/0)
Inf	infinity (e.g. 1/0)

NA is the one you’ll meet constantly in real data. NULL is the odd one: it is the absence of a value, so it takes up no room in a vector. Demonstrate on the board by drawing the row of boxes for c(NA, NULL, 1) — two boxes, not three.

Missing values are contagious

c(NA, NULL, 1)
mean(c(NA, NULL, 1))
mean(c(NA, NULL, 1), na.rm = TRUE)

Ask what length(c(NA, NULL, 1)) will be before running it. Then: why is the mean NA? Because the mean of a set that includes an unknown value is itself unknown — R is being careful, not broken. na.rm = TRUE tells R to drop the missing values first. Stress that this is a choice you are making about your data, not a bug fix.

Behavior of vectors

Your Turn

What will these return?

c(1, 2, 3) + c(2, 3, 4)
c(1, 2, 3) + c(2, 3)
c(1, "dog", TRUE)

01:00

Poll the room on each line before running it. All three surprise people in different ways, and each one motivates a concept on the next slides: vectorization, recycling, and coercion.

Vectorization and recycling

Vectorization

Operations and functions that run on an entire vector at once, element by element.

Vector Recycling

If an operation needs a longer vector than provided, R reuses the existing elements, in order, from the beginning.

Vectorization and recycling

log(c(2, 6, 1))
c(1, 2, 3) + c(2, 3, 4)
c(1, 2, 3) + c(2, 3)

On the board, write the two vectors next to one another and draw the element-wise pairing. For the recycled case, write the shorter vector out again underneath — 2, 3, 2 — so students see where the third element came from. Note that R warns here because 3 isn’t a multiple of 2; when it is a multiple you get no warning at all, which is what makes recycling dangerous.

In most other languages, adding two collections requires writing a loop. Vectorization is a defining feature of R.

Type coercion

Implicit Coercion

When you mix types, R converts them all to a single type so the vector stays atomic. It follows a hierarchy, always moving up:

Annotate slide with:

logical < integer < double < character

Write the hierarchy on the board as an arrow. The rule: R picks the least-general type that can hold everything. c(1, "dog", TRUE) must go all the way up to character because only character can represent all three.

Implicit coercion

c(1, "dog", TRUE)
c(TRUE, FALSE, 3)
mean(c(TRUE, FALSE, FALSE))

The last line is worth dwelling on: TRUE becomes 1 and FALSE becomes 0, so the mean of a logical vector is the proportion of TRUEs. That’s a trick we’ll use over and over once we start filtering data.

Explicit coercion

as.___(x) converts x to the type ___.

distances <- c("2800", "450", "10")
distances
mean(distances)

distances <- as.double(distances)
distances
mean(distances)

This isthe bug from last lecture. readLines() gives us character data; mean() on characters returns NA with a warning. Point out the quotes disappearing in the printed output after coercion.

Ask what as.double("dog") returns. NA, with a warning. Coercion that can’t succeed produces missing values, so always check afterward.

Vector Subsetting

Subsetting by index

vec[index]

char_vec
char_vec[2]
char_vec[2:3]
char_vec[rep(3, 10)]

Annotate the anatomy on the board: the vector, the square bracket, and inside it another numeric vector of positions. That last point is the key insight — the thing inside the brackets is itself a vector, which is why 2:3 and rep(3, 10) both work.

R indexes from 1, unlike Python and most other languages.

The rep(3, 10) example shows the result can be longer than the original.

Subsetting by name

named_char_vec <- c("thrash" = "cat",
                    "buzz" = "dog",
                    "poppy" = "dingo")
named_char_vec
named_char_vec["buzz"]
named_char_vec[rep("poppy", 10)]

Names are an attribute attached to a vector; note how printing changes to show a header row of names. The same pattern holds: whatever is inside the brackets is a vector, here a character vector.

Subsetting by logicals

named_char_vec[c(TRUE, FALSE, TRUE)]

The logical vector acts as a mask, one entry per element: keep, drop, keep. This is the least intuitive of the three but by far the most useful — next lecture we’ll generate those logicals from comparisons instead of typing them out, and that’s how filtering works.

If time permits, ask what happens when the logical vector is shorter than the vector being subset. Recycling, again.

Key Ideas for Today

1. An atomic vector holds elements of a single type.
2. Special values mark data that is missing or undefined.
3. Operations are vectorized and vectors are recycled.
4. Mixing types triggers coercion.
5. Elements are pulled out by subsetting.

For Next Time

1. Work through the atomic vectors questions on PS 1.
2. Read Advanced R, Ch. 3.1 - 3.2.
3. Read R Coding Basics, Ch. 2–3.