Intro R Course, Workshop 3: Vectors

  - creating vectors (lists of things)
  - consecutive sequences of numbers
  - math with vectors
  - pulling specific elements out of vectors
  - vector types

Solutions to this workshop can be found here

Review from last time

Let’s review variables and types

# Create a variable that holds the number 53

# Create a variable that holds two times the value of the first variable

# Create a variable that holds the word "science"

# Get R to tell you the "type" of the last variable you created

# What happens if you try to add two of the "science" variables together? Why?

Introduction to vectors

So far, we’ve been using R to do things we can easily do on our own, or with a simple calculator. We don’t need R to add two numbers. But where programming languages start to get really powerful is when you have to do the same thing over and over. Today, we’re going to learn how R deals with lists of multiple numbers or strings. These lists are called vectors. (Actually, a ‘list’ is also a thing in R, but it means something slightly different… very confusing. So let’s stick with calling these things vectors.)

We can create a vector by using c(), with the things we want to put inside the vector going in parentheses. (c stands for concatenate/combine.) For example:

# Create a vector
vector_1 <- c(1, 4, 3, 18)
print(vector_1)

You can use variables to define vectors too! Try it below:

# Create 3 variables, named variable_1, variable_2, and bob, and have each of
# them hold a single number
variable_1 <- 1
variable_2 <- 2
bob <- 9
# Combine these variables in any order you want into a vector named bob_the_vector
bob_the_vector <- c(variable_1, variable_2, bob)
# print out bob_the_vector
print(bob_the_vector)

Vectors can also hold character types!

# Create a vector, char_vector_1 containing multiple strings, and print it out
char_vector_1 = c('stuff', 'things')
char_vector_1

Let’s check the types that these vectors belong to

# check the type of bob_the_vector
is(bob_the_vector)
# check the type of char_vector_1
is(char_vector_1)
# by the way... what is the type of c, as in, the thing you put before your vector?

What if we wanted to store the number 3 and the character “3” together in a vector?

# Create a vector, mix_vector, with 3 and "3"

# check the type of mix_vector

# why is this happening (check the documentation of c)

Converting between numeric and character types

Finally, it’s sometimes really helpful to be able to switch something between a numeric and a character type. Let’s say you import some data and your computer insists on thinking it’s letters, when it is clearly numbers (this happens a lot!) We can use the as.numeric() function to set things right.

bad_numeric_vector <- c('1','3','4','7','11')

# check the type of bad_numeric_vector

# why is it not numeric?

# use as.numeric() to create a new vector, good_numeric_vector, which has all
# the values from bad_numeric_vector but as numbers instead of characters

# check the type of good_numeric_vector

We can also do this change backwards. Based on what you saw right above, what do you think the function is called that converts numeric values to character type?

num_vector <- c(81, 243, 729)

# convert num_vector to a character vector

Making consecutive sequences

One really useful thing we can do in R is make vectors of evenly spaced numbers. To do this, we can use the seq() function. Let’s try to use the built-in R documentation of seq() to figure out how to use it.

# On your own:
# Based on the documentation from of seq, make the sequence: 1, 2, 3, 4

# In pairs:
# Now make the sequence: 2, 2.5, 3, 3.5

# Identify what values are corresponding to what arguments

Seq can work in both directions (i.e., the numbers don’t have to be going up)

# Use seq to make the following sequence: 5, 3, 1, -1

There are three things that make seq really powerful compared to just typing out vectors of numbers by hand:

1. It can generate reaaaaaally long sequences of numbers

2. Like all functions, it can use variables as inputs, which means you don’t have to change your whole code every time you change your mind about what numbers you’re interested in working with

3. When you want to make a vector of a certain length, it will do the math for you of what the spacing between your numbers needs to look like

Let’s try using some of this!

# Make a variable number_elements, which will tell you how many numbers you want
# in your final vector

# Make a variable first_number, containing any number you want your vector to
# start with

# Make a variable last_number, containing any number you want your vector to
# end with

# Use first_number, last_number, and number_elements as arguments to seq to
# create your vector, final_vector

Relatedly, a really useful function in R is length(). It can tell you how long your vector is (how many elements are in your vector)

# Use length() to find out how long number_elements is

# Use length() to find out how long final_vector is

# Does this make sense?

Operations on vectors of numbers

One of the best things about vectors that will come up again and again soon is that you can do operations on them, just like with numbers. Here’s one example:

# Create a variable holding a vector that contains an evenly spaced sequence of
# five numbers, from 2 to 4

# Add 3 to the vector. What happens?

You can also add vectors together!

vector_a <- c(1,2,3)
vector_b <- c(4,5,6)

# Add vector_a and vector_b

And finally… many math-related functions can work on vectors! sum() is a great example of this.

# Create a vector of consecutive numbers between 1 and 100

# Use sum() to add up those numbers

Getting specific elements from vectors

Often, it’s really useful to find out what the value of a specific position (or index) in a vector is. R makes this easy.

Let’s create a really long vector and ask R to tell us about specific points along that vector.

# Create three variables, first_num, last_num, and num_of_elements
# The first two can be whatever numbers you want, num_of_elements should be 100
# DON'T use 1 for first_num, and don't use 100 for last_num. Be creative.

# Use the function we learned during the last class to make a sequence of length
# num_of_elements starting at first_num and going to last_num, and put that in a
# vector called new_vector

# Check the length of the vector you just created

To access the number at a specific position, we can use square brackets!

# Make a vector called long_vector that goes from -1 to 50 and has 100 numbers inside

# Let's check what the first number in long_vector is
print(long_vector[1])

# Now check what the 32nd number in long_vector is

# Now check what the last number in long_vector is
# (bonus: do this using a variable you've already created, rather than just
# typing out 100)

You don’t have to just provide a single number as in index (the thing inside the square brackets); vectors work too!

# Print out the 4th, 5th, 6th, 7th, and 8th number in long_vector
print(long_vector[c(4,5,6,7,8)])
# Now do the same thing as above, but using a function we have learned today to
# specificy the indices (4, 5, 6, 7, 8)

Actually, we can get even more creative here. Let’s say you wanted to create a vector that had inside it every other number from a vector (i.e. the 1st, 3rd, 5th, etc numbers that are in that vector). Let’s try this. Hint: you can use seq() to create a vector of positions (indices) that you then use to get the positions you want from that vector

long_vector_2_start <- -1
long_vector_2_end <- 50
long_vector_2_length <- 20
long_vector_2 <-
  seq(long_vector_2_start, long_vector_2_end, length.out = long_vector_2_length)
# Create position_vector, which will hold the positions you want to get out of
# long_vector_2 (i.e. c(1,3,5,....))

# Use long_vector together with position_vector to create shorter_vector, which
# will hold every othern number from long_vector

# print out long_vector_2, then shorter_vector

Things we hope you’ve learned today (and will hopefully remember next time)

• Vectors are lists of either numeric or character type
• You can do math on numeric vectors
• You can convert between numeric and character type vectors using as.numeric() and as.character()
• You can use the seq() function to generate vectors of evenly spaced numbers
• Indexing!!!