Extracting Elements from a Vector

To extract an element from a vector we use the bracket ([]) notation. Recall, a vector has only one dimension, so inside the brackets goes one number. To extract elements of a vector, we can give their corresponding index, starting from the number one. (R uses a one-based numbering system.)

x <- c(5.4, 6.2, 7.1, 4.8, 7.5)

x[1] ## Extracts the first element of x 

x[1:3] ## Extracts a slice of x, from the first index to the third index 

x[-2] ## Extracts everything in x BUT the second index

Challenge 1

Why does R produce an error for the following code?

x[-1:3]

Extracting Elements from a Dataframe

A dataframe is a list of vectors, where each vector is permitted to have a different data type. Because dataframes have two dimensions (columns and rows), we are able to extract two types of elements.

To extract a column from a dataframe we can use the familiar $ operator:

example_df <- data.frame(A = c(1, 5, 9, 13),
                B = c(2, 6, 10, 14),
                C = c(3, 7, 11, 15),
                D = c(4, 8, 12, 16)
                )

example_df$A ## Extracts the A column from the dataframe

This is useful if we only wish to extract a single vector from our dataframe. If we want multiple vectors, then using matrix notation is more simple.

To extract a column from a dataframe using brackets ([row, column]):

example_df[1, 1] ## Extracts the first row, first column entry  

example_df[, 1] ## Extracts EVERY row in the first column  

example_df[1, ] ## Extracts EVERY column in the first row  

Challenge 2 (Part 1)

I want to extract the 3rd and 4th columns. What is wrong with my code?

## Change the code below to extract the 3rd and 4th columns

example_df[, 3, 4]

example_df[, 3:4]

Challenge 2 (Part 2)

How would you change it to extract these columns? What if I wanted to extract the 2nd and 4th columns?

## Write code to extract the 2nd and 4th columns

example_df[, c(2,4)]

Equality & Inequality

This type of operator tells whether an object is equivalent to another object (==), or its negation (!=).

dna1 == dna2
dna1 != dna2

Greater & Less

These statements should be familiar, with a bit of a notation twist. To write a strict greater than or less than statement you would use > or < in your statement. To add an equality constraint, you would add a = sign the inequality statement (>= or <=).

w > 10
x > y

Inclusion

This type of statement checks if a character, number, or factor are included in a vector. The %in% operator tells you whether a value is included in an object. These values can be linked together into a vector, and the output will be a vector of logical values.

colors <- c("green", "pink", "red")

"blue" %in% colors

numbers <- c(1, 2, 3, 4, 5)

5 %in% numbers

some_letters <- c("a", "b", "c", "d", "e")

c("a", "b") %in% some_letters

Challenge 3

Write R code to see if:

• 2 * x + 0.2 is equal to y
• “hello” is greater than or equal to “goodbye”
• TRUE is greater than FALSE
• dna1 is longer than 5 bases (use nchar() to figure out how long a string is)

# Challenge 3 R code goes here

2 * x + 0.2 == y

"hello" > "goodbye"

TRUE > FALSE

nchar(dna1)

Comparing Decimal Valued Numbers

Why does the output from 2 * x + 0.2 == y not seem right? What do you think might be going on?

General R advice is that the == operator should only be used for comparisons of integer and Boolean data types. To store decimal valued data types (doubles) R, like other programming systems, uses a format (binary floating-point) that doesn’t accurately represent a number like 1.3. When the code is interpreted by R, the “1.3” is rounded to the nearest number in floating-point format, which results in a small rounding error even before the calculation happens.

This is why, general R advice is to use the all.equal(x, y) function to check for equality of two doubles. This function, applied to the two arguments, “is a utility to compare R objects x and y testing near equality.” This means that the function allows for a little bit of wiggle room in the rounding errors that are associated with doubles.

#Verify the result using all.equal(..., ...)

all.equal(2 * x + 0.2, y)

Comparing Characters

How did R know how to compare the words hello and goodbye?

"hello" > "goodbye"

# What does this output suggest?
Sys.getlocale(category = "LC_COLLATE")

Challenge 4

What is going on in the code below? Why is R giving an error?

some_letters != c("a", "c") 

Why does R give TRUE as the third element of this vector, when some_letters[3] != "c" is obviously false?

Recycling

When you use != or ==, R tries to compare each element of the left argument with the corresponding element of its right argument. Then what happens when you compare vectors of different lengths?

When one vector is shorter than the other, it gets recycled:

In this case, R repeats c("a", "c") as many times as necessary to match the length of the some_letters vector. So, we get c("a", "c", "a", "c", "a"). Since the recycled "a" doesn’t match the third element of some_letters, the value of != is in fact TRUE.

Note: We got lucky here! R output an error because the length of our vectors was not a constant multiple (e.g. 2 times as long). If they were, R would have carried out the same recycling procedure, but would not have output an error!

This is why the inclusion (%in%) operator is so great! It does carry out the procedure we wish for R to do, without any silly recycling! To exclude values you place a ! in front of the entire statement, not directly in front of the %in%.

!c("a", "b") %in% some_letters

Logical Values

You can also use logical values (TRUE, FALSE) to extract elements of a vector.

some_letters[c(TRUE, TRUE, FALSE, FALSE, FALSE)] 
## Extracts the first two elements of the some_letters vector 

This should give you an intuition as to how we might be able to use the results of relational statements to extract the elements of the vector that satisfy the relation.

Which

The which statement returns the indices of a vector, where a relational statement is satisfied (evaluates to TRUE).

x_2 <- c(3, 5, 7, 9, 11, 13, 15)  

which(x_2 > 8) 

which(x_2 == 7)

## Mini-challenge: How would you use the indices from these "which" statements to 
##            extract the elements of x_2 that meet the criteria?

Matrices

The above relational and which statements can be applied to a matrix, or to a subset of the matrix (e.g., a vector). The relational and which statements are applied element wise (a step-by-step progression through the matrix/vector entries).

# The following are dating data, of one person's messages received per day for one week

messages <- data.frame(okcupid = c(16, 9, 13, 5, 2, 17, 14),  
                       match = c(17, 7, 5, 16, 8, 13, 14))
# This makes the data from OkCupid the first column and the data from Match the second column

row.names(messages) <- c("Monday", "Tuesday", "Wednesday", "Thursday",
                         "Friday", "Saturday", "Sunday")

Challenge 5

Use the messages matrix to return a matrix of logical values which answer the following question:

1. For what days were the number of messages at either site greater than 12?

# Create a logical matrix to provide information that would allow you to answer the question: 
# For what days were the number of messages at either site greater than 12? 

messages > 12

Challenge 6

Use the messages matrix to return the rows of messages which answer the following questions (Use rows of the matrix to answer):

1. when were the messages at OkCupid equal to 13?

2. when were the messages at OkCupid greater than Match?

# Use rows of the matrix to answer:  

# when were the messages at OkCupid equal to 13?


# when were the messages at OkCupid greater than Match?

messages[which(messages[,1] == 13),]

messages[which(messages[,1] > messages[,2]),]

Subset

The subset command takes in an object (vector, matrix, data frame) and returns the subset of that object where the entries meet the relational conditions specified (evaluates to TRUE).

x_3 <- c(3, 5, 7, 9, 11, 13, 15)  

subset(x_3, x_3 > 6)

Challenge 7

Using the okcupid “data” from above, answer the following question:

1. Change the which() statement code to a subset() statement, extracting the days that the number of messages at OkCupid greater than the messages at Match.

# Change the which() statement code to a subset() statement, extracting the days that the number of messages at OkCupid greater than the messages at Match

subset(messages, messages[,1] > messages[,2])

“and” statements (&)

These statements evaluate to TRUE only if every relational statement evaluates to TRUE.

• (3 < 5) & (9 > 7) would evaluate to TRUE because both relational statements are TRUE
  
• (3 > 5) & (9 > 7), this would evaluate to FALSE as only one of the relational statements is FALSE (the first one)

“or” statements (|)

These statements evaluate to TRUE if at least one relational statement evaluates to TRUE.

• (3 > 5) | (9 > 7) would evaluate to TRUE because one of the relational statements is TRUE (the second one)
  
• (3 > 5) | (9 < 7) would evaluate to FALSE as both relational statements evaluate to FALSE

“not” statements (!)

These statements convert (negate) the statement it proceeds, changing TRUE to FALSE and FALSE to TRUE.

• is.numeric(5) would evaluate to TRUE because 5 is a number
  
• !is.numeric(5) would evaluate to FALSE as it negates the statement it proceeds (!TRUE = FALSE)

NOTE:

The && and || logical statements do not evaluate the same as their single counterparts. Instead, these logical operators evaluate to TRUE or FALSE based only on the first element of the statement, vector, or matrix.

Below are examples of using logicals to evaluate vectors. For example, in the first line of code three statements are checked, TRUE & TRUE, TRUE & FALSE, and FALSE & FALSE. The first statement is “TRUE” since both elements were “TRUE”. The second and third statements are “FALSE” since at least one element was “FALSE”.

c(TRUE, TRUE, FALSE) & c(TRUE, FALSE, FALSE)

c(TRUE, TRUE, FALSE) | c(TRUE, FALSE, FALSE)

c(TRUE, TRUE, FALSE) && c(TRUE, FALSE, FALSE)

Challenge 8

Using the okcupid vector from above, answer the following questions:
1. Is the last day of the week under 5 messages or above 10 messages?
(HINT: last <- tail(messages$okcupid, n=1) could be helpful)
2. Is the last day of the week between 15 and 20 messages, excluding 15 but including 20?

# Is the last day of the week under 5 messages or above 10 messages? 
# (hint: last <- tail(messages$okcupid, n=1) could be helpful)

# Is the last day of the week between 15 and 20 messages, excluding 15 but including 20?

# Make sure you test your code with some other values

last <- tail(messages$okcupid, 1)

last < 5 | last >10

last > 15 & last <= 20 #Or last > 15 & (last < 20 | last == 20)

The subset command (from before) can also accept more than one relational condition if joined by logicals.

bad_days <- subset(messages, okcupid < 6 | match < 6)

bad_days

good_days <- subset(messages, okcupid > 10 & match > 10)

good_days

If Statements

First, let’s start with an if statement, the often overlooked building block of the if else statement. The if statement is structured as follows:

if(condition){
              statement
}

• the condition inside the parentheses (a relational statement) is what the computer executes to check its logical value,
  • if the condition evaluates to TRUE then the statement inside the curly braces ({}) is output, and
    
  • if the condition is FALSE nothing is output.

NOTE: In R the if statement, as described above, will only accept a single value (not a vector or matrix).

y <- -3 ## Try changing this number, for example y <- 5 

if(y < 0){
  "y is a negative number"
}

Challenge 9

Using the last number from Challenge 8, write an if statement that prints “You’re popular!” if the number of messages from okcupid exceeds 10.

# hint: use the last day of the week for okcupid that you made above
last <- tail(messages$okcupid, 1)

last <- tail(messages$okcupid, 1)

if (last > 10){
  "You're popular!"
}

If/Else Statements

Since whenever an if statement evaluates to FALSE nothing is output, you might see why an else statement could be beneficial! An else statement allows for a different statement to be output whenever the if condition evaluates to FALSE. The if else statement is structured as follows:

if(condition){
              statement1
}
else{
              statement2      
}

• again, the if condition is executed first,
  • if it evaluates to TRUE then the first statement (statement1) is output,
  • if the condition is FALSE the computer moves on to the else statement, and the second statement (statement2) is output.

NOTE: In R the if else statement, as described above, will only accept a single value (not a vector or matrix).

y <- -3 ## Try changing this number, for example y <- 5

if(y < 0){
  "y is a negative number"
} else{
  "y is either positive or zero"
}

NOTE: R accepts both if else statements structured as outlined above, but also if else statements using the built-in ifelse() function. This function accepts both singular and vector inputs and is structured as follows:

ifelse(condition, statement1, statement2)

where the first argument is the conditional (relational) statement, the second argument is the statement that is evaluated when the condition is TRUE (statement1), and the third statement is the statement that is evaluated when the condition is FALSE (statement2).

y <- -3 ## Try changing this number, for example y <- 5

ifelse(y < 0, "y is a negative number", "y is either positive or zero")

Challenge 10

Using the “if” statement from Challenge 9, add the following else statement: When the “if”-condition on messages is not met, R prints out “Send more messages!”.

# Challenge: Rewrite the if, else function from above using R's built in ifelse() function. 
last <- tail(messages$okcupid, 1)

last <- tail(messages$okcupid, 1)

ifelse(last > 10, "You're popular!", "Send more messages!")

Else/If Statements

On occasion, you may want to add a third (or fourth, or fifth, …) condition to your if else statement, which is where the else if statement comes in. The else if statement is added to the if else as follows:

if(condition1){
              statement1
}
else if(condition2){
              statement2
}
else{
              statement3      
}

• The if condition (condition1) is executed first,

  • if it evaluates to TRUE then the first statement (statement1) is output,

  • if the condition is FALSE the computer moves on to the else if condition,

• Now the second condition (condition2) is executed,

  • if it evaluates to TRUE then the second statement (statement2) is output,

  • if the condition is FALSE the computer moves on to the else statement, and

• the third statement (statement3) is output.

y <- -3 ## Try changing this number, for example y <- 5 and y <- 0

if(y < 0){
  "y is a negative number"
} else if(y == 0){
    "y is zero"
} else{
    "y is positive"}

NOTE: Conditional statements should be written so that the components are mutually exclusive (an observation can only belong to one piece).

The modulo (%%) returns the remainder of the division of the number to the left by the number on the right, for example 5 modulo 3 or 5 %% 3 is 2.

x <- 6

if(x %% 2 == 0){
  "x is divisible by 2"
} else if(x %% 3 == 0){
  "x is divisible by 3"
} else{
  "x is not divisible by 2 or 3"
}

For Loops

In the for loop figure above:

• The starting point (black dot) represents the initialization of the object(s) being used in the for loop (i.e., the variables). R requires you to initialize the objects you will use in your loop before you use them, it does not automatically create the objects for you!

• The diamond shapes represent the repeat condition the computer is required to evaluate. The computer evaluates the conditional statement (i in sequence) as either TRUE or FALSE. In other terms, you are testing if the current value of i (the index/counter) is within the specified range of values (sequence), where this range is either defined in the initialization or directly within the condition statement (like 1:100).

• The rectangle represents the set of instructions to execute for every iteration. This could be a simple statement, a block of instructions, or another loop (nested loops).

The computer marches through this process until the repeat decision (condition) evaluates to FALSE (i is not in sequence).

num <- 100
for(i in 1:num){
              statement
}

sequence <- 1:100

for(i in sequence){
              statement
}

for(i in 1:10) {
    print(i)
  }

i ## should be 10 (the last number of the sequence 1:10), unless the loop had issues!

x <- seq(1, 10, by = 1)
y <- seq(10, 28, by = 2)

## create an empty vector to store added quantities
z <- rep(NA, length(x))


for(i in 1:10) {
# write a loop to store the entries of x added to the entries of y in z
  
}

z ## examine the resulting vector

# code to execute adding of the x and y vectors from the example above,
# NOT in a loop

z <- x + y
z

BlackfootFish <- read.csv("https://raw.githubusercontent.com/saramannheimer/data-science-r-workshops/master/Intermediate%20R/AY%202020-2021/data/BlackfootFish2.csv", header = TRUE)

n_testing <- 1200

samps <- rep(NA, n_testing)
## Initializing the samps vector, for storing indicies

samps[1] <- 1
## Setting first sample index to 1 (first row)

# Code snippet: 
# Create the code for the process will be executed at each step
# e.g., How will you get the next sample after 1?

for(i in 2:#ending index here){
  samps[i] <- # process you execute at every index
}

testing <- BlackfootFish[samps, ]
training <- BlackfootFish[-samps, ]

BlackfootFish <- read.csv("https://raw.githubusercontent.com/saramannheimer/data-science-r-workshops/master/Intermediate%20R/AY%202020-2021/data/BlackfootFish2.csv", header = TRUE)

n_testing <- 1200

samps <- rep(NA, n_testing)
## Initializing the samps vector, for storing indices

samps[1] <- 1
## Setting first sample index to 1 (first row)

# Code snippet: 
# Create the code for the process will be executed at each step
# e.g., How will you get the next sample after 1?

for(i in 2:n_testing){
  samps[i] <- samps[i-1] + 7
}

testing <- BlackfootFish[samps, ]
training <- BlackfootFish[-samps, ]

for(i in 1:5){
  for(j in c("a", "b", "c", "d", "e")){
    print(paste(i, j))
  }
}

User Defined Functions

A function allows for us to repeat several operations with a single command. Take for instance a function which converts heights from feet and inches to centimeters, named feet_inch_to_cm().

feet_inch_to_cm <- function(feet, inches) {
  inches <- feet*12 + inches
  cm <- inches * 2.54
  
  return(cm)
}

Challenge 13

Use the feet_inch_to_cm function to convert your height to cm!

## Your code goes here. NOTE, the solution will use a height of 5' 7"

feet_inch_to_cm(5,7)

We define feet_inch_to_cm() by assigning it to the output of function. The list of argument names are contained within parentheses. Next, the body of the function (the statements that are executed when it runs) is contained within the curly braces ({}). The statements in the body are indented by two spaces. This makes the code easier to read but does not affect how the code operates.

It is useful to think of creating functions like writing a cookbook.

1. Define the “ingredients” that your function needs. In this case, we only need two ingredients to use our function: “feet” and “inches”.
2. State what we to do with the ingredients. In this case, we are taking our ingredient and applying a set of mathematical operators to it.
3. Declare what the final product (output) of your function will be. This typically lives in a return() statement, but we will see other methods to use.

When we call the function, the values we pass to it as arguments are assigned to those variables so that we can use them inside the function. Inside the function, we use a return statement to send a result back to whoever asked for it.

Function Scoping

When writing and using functions, you should be careful to consider where each of the variables you are using are defined. Variables that are defined within a function belong to a local environment, and are not accessible from outside of the function. Take this example:

x <- 10
## globally defined variable 

f <- function(){
  ## locally defined x and y
  x <- 1 
  y <- 2
  c(x, y)
}

f()

x

We notice that the globally defined value of x is not called inside the function, as the function defines x within itself, so it does not search for a value of x! Now look at another example, where x is not defined within the function.

g <- function(){
  ## locally defined y
  y <- 2
  c(x, y)
}

x <- 15

g()

x <- 20

g()

Summary

1. When you call a function, a new environment is created for the function to do its work in.
   
2. The new environment is populated with the argument values passed in to the function.
   
3. Objects are looked for first in the function environment.
   
4. If objects are not found in the function environment, they are then looked for in the global environment.

• This scoping issue emphasizes the need for using good global variable and data frame names that are informative and explicit, not reused, and also not function or typical argument names.

Why Write a Function?

Similar to loops, you will often find that you have performed the same task multiple times. A good rule of thumb is that if you’ve copied and pasted the same code twice (so you have three copies), you should write a function instead!

BlackfootFish$length_scaled <- (BlackfootFish$length - min(BlackfootFish$length, na.rm = TRUE)) /
  (max(BlackfootFish$length, na.rm = TRUE) - min(BlackfootFish$length, na.rm = TRUE))

BlackfootFish$weight_scaled <- (BlackfootFish$weight - min(BlackfootFish$weight, na.rm = TRUE)) /
  (max(BlackfootFish$weight, na.rm = TRUE) - min(BlackfootFish$length, na.rm = TRUE))

(BlackfootFish$length - min(BlackfootFish$length, na.rm = TRUE)) / 
  (max(BlackfootFish$length, na.rm = TRUE) - min(BlackfootFish$length, na.rm = TRUE))

# code modification with temporary variable "x"
x <- BlackfootFish$length

x <- BlackfootFish$length
x_rescaled <- (x - min(x, na.rm = TRUE)) / 
  (max(x, na.rm = TRUE) - min(x, na.rm = TRUE))

range(seq(1, 5))     

x <- BlackfootFish$length
# Create x_range = the range of x 


# Rewrite the code snippet from Exercise 14 to now 
# refer to x_range instead of min(x) and max(x)

x <- BlackfootFish$length

x_range <- range(x, na.rm = TRUE)
x_rescaled <- (x - x_range[1]) /   
  (x_range[2] - x_range[1])

myFunction <- function(argument1, argument2,...){
                body
}

# Use the function template to create a function named rescale that performs the process outlined above, using the intermediate variables you previously defined

myfunction <- function(arg1,...){
  # body 
}

rescale <- function(x){
  x_range <- range(x, na.rm = TRUE)
  x_rescaled <- (x - x_range[1]) / (x_range[2] - x_range[1])
  return(x_rescaled)
}

# Copy the body code from the function to unit test the code in your function on a simple vector named x <- c(1, 2, 3, 4, 5)

x <- c(1, 2, 3, 4, 5)

x_range <- range(x, na.rm = TRUE)
x_rescaled <- (x - x_range[1]) / (x_range[2] - x_range[1])

x_rescaled

# Test your function out on the BlackfootFish data's length variable

BlackfootFish$length_scaled <- rescale(BlackfootFish$length)
summary(BlackfootFish$length_scaled)

Process of Creating a Function

You should never start writing a function with the function template. Instead, you start with a problem that you need to solve and work through the following steps:

1. Define the problem you need to solve.

2. Get a working snippet of code that solves the simple problem. (Where you start when you’re copying and pasting)

3. Rewrite the code snippet to use temporary variables.

4. Rewrite the code for clarity (remove redundancy or multiple calculations of the same value).

5. Turn everything into a function! The code snippet forms the body of the function, the temporary variables are the arguments, and you choose the name of your function.

6. Test your function! Start with a simple example and then go big!

Challenge 19 (Part 1)

Putting it All Together! Start by creating a data subset with just the species, length, and weight variables from the BlackfootFish dataset. Call the data subset BlackfootFish_subset.

BlackfootFish_subset <- data.frame(species = BlackfootFish$species, length = BlackfootFish$length, weight = BlackfootFish$weight)

Challenge 19 (Part 2)

Now, given the matrix of species, length, and weights above, use the tools from the workshop (for loop, function, conditional, and/or relational statements) to:

• compute Fulton’s condition factor of each fish (\(condition = \frac{100000 \ast weight}{length^3}\)), making any fish with weight or lengths of 0s to be NAs on the condition factor since those are obvious data entry errors.
  
• then remove the fish from the dataset whose condition index is NA or more than 2 (values larger than 2 are not typical and might suggest further data entry errors).
• If you attended our data visualization workshop, try to make a plot of condition factors based on the fish species with jittered points and violins.

condition_index <- function (x, y) {
  ifelse(x==0|y==0, c_in<- NA, c_in <- 100000*(x/(y^3)))
  
  return(c_in)
}


BlackfootFish_subset$condind <- condition_index(BlackfootFish_subset$weight, BlackfootFish_subset$length)

summary(BlackfootFish_subset$condind)

D1 <- subset(BlackfootFish_subset, !is.na(condind) & condind <= 2)

library(ggplot2)

D1 %>% 
  ggplot(aes(x=species, y=condind)) +
  geom_jitter() +
  geom_violin() + 
  theme_bw()

Greta Linse

• Greta Linse is the Interim Director of Statistical Consulting and Research Services (https://www.montana.edu/statisticalconsulting/) and the Project Manager for the Human Ecology Learning and Problem Solving (HELPS) Lab (https://helpslab.montana.edu). Greta has been teaching, documenting and working with statistical software including R and RStudio for over 10 years.

Sara Mannheimer

• Sara Mannheimer is an Associate Professor and Data Librarian at Montana State University, where she helps shape practices and theories for curation, publication, and preservation of data. Her research examines the social, ethical, and technical issues of a data-driven world. She is the project lead for the MSU Dataset Search, and she is working on a book about data curation to support responsible qualitative data reuse and big social research.

The materials have also been modified and improved by:

• Dr. Mark Greenwood
• Harley Clifton
• Eliot Liucci
• Dr. Allison Theobold