Harp 325 Topic 1: Intro to R

Welcome to your first R Notebook! We will use notebooks throughout the class because they make it easy to organize your code. When you submit problem sets, R Notebooks are ideal because you can publish this entire file as PDF or html file, complete with your code in R code chunks (in gray) and the output of your code below it. This way, I can see your answers and the code you used to calculate them - if your answer is incorrect, I can still award partial credit based on your code.

You’ll notice that right now this document is functioning like any word processing software - we are currently not using R. We will begin to use R once we start typing in one of the gray code blocks below. You can insert a new code block by going to insert > R in the top right-hand side.

#Now, we are working in R
#Note that if you want to annotate your code or leave comments, you need to use the '#' symbol
#Otherwise, R thinks that you are typing a command and your code will return an error
######You can use as many '#'s as you like#########
#To begin typing R code, simply press enter
#To improve readability, I like to keep one line of space between comments and code
#Get into the habit of annotating code now!
#Annotating your code will help you to remember the steps in your analysis, and it will help others (like me) better understand what you are doing

#let's try typing our first command into R

10 + 30

#Once you have typed the command (or commands) you would like to run, press the play icon at the top of the code block to run the code
#if you have multiple lines of code in a chunk and only want to run one, you can highlight that line and press ctrl+enter to run a single line

10*5

#note that "*" symbolizes multiplication in R
#The output of your code appears below the code block 

#spacing doesn't really matter too much for most R commands, as long as everything is on the same line
10   *    5

#Importantly, R has no spell check - you need to make sure you type everything out correctly
#R cannot correct your code if you make a mistake, it will just report an error
#R will usually give you an explanation for the error, but it is not always easy to understand
#If you get an error and you're not sure what it means, google it! Someone else has probably had the same error before and asked about it online
10 + 5

#What happens if I accidentally run a line of code before I'm finished?
#In an R notebook, it'll tell you when your expression is incomplete (if R can tell - sometimes, you'll forget something but your line of code will still be a complete command, which is a trickier situation to be in - always double check your code!)
10 +  

#Sometimes, you might want to use a function on a group of numbers
#(I'll explain more about functions later)
#Here, sum is telling R to add the numbers in ()
1+2+3
sum(1,2,3)

#what happens if I leave this function blank?
sum()

#what if I forget the ()?
sum
#What's going on? R is telling me what is going on underneath the function, which, for right now, I don't need to really know. If I want to read more about what the function is doing, I can use a "?" in front of the function to pull up its help page. This is much more helpful!
?sum

#Let's learn some basic arithmetic operators! You've already seen '+' and '*' to add and multiply, respectively

#We can easily subtract numbers
10 - 5

#And divide them
10/5

#Raise a number to a power of x
10 ^ 3

#recall that 10^3 is also equivalent to:
10 * 10 * 10

#Unlike a cheap calculator, R also uses the order of operations (think PEMDAS from HS algebra class) to calculate more complex operations

3 + 4 * 10

#Here, R multiplied 4*10 first, and then added 3
#If we wanted it to run the calculation from left to right, we need to add () like so:

(3 + 4) * 10

#Remember, the order of operations is 1) Parentheses, 2) Exponents, 3) Multiplication and Division, and 4) Addition and Subtraction. When you calculate complex formulas in R, you need to be very careful where you put your () . I will show more examples of this later. 

#What happens when you try to use two operations that have the same level of priority in PEMDAS? R will calculate from left to right in this case, for example:

4 / 2 * 3

#Note that, in this case, reversing the order yields the same answer.

What else can R do that a calculator cannot?

#One of the most useful things about R is the ability to store objects and perform operations on them
#In the text, these are referred to as variables in Chapter 3.4 - I am calling them objects because that is a more general term - an object can consist of one variable, but it can also contain multiple variables, so I find the term "variable" somewhat confusing here
#The simplest object that you can create is a single value. We'll learn about other objects later
#let's say I want to remember the number of birds outside of my window today - maybe there are 5 birds
#I can store that value in a meaningful way so I can use it later, like so:

birds <- 5

#Note that the '<-' symbol indicates that something (e.g. a number) is being stored under the name that we've chosen. Here, we've created a new object (variable) called birds.

#Run this block of code! Does anything happen?

On the right-hand side of R Studio you will see the “Environment” tab. This tells us all of the objects that we have stored in our current R Session (our environment). You’ll notice that birds appears there under “values”.

#Let's use R to print out birds

birds
print(birds)

#Maybe I want to track how many birds there are on different days of the week 
#Let's say there were 5 birds on Monday and 7 birds on Tuesday
#We can store both of those values as variables (there are more efficient ways to do this, but we'll get to that later)

birds_mon <- 5
birds_tues <- 7

#Now, we can perform operations using these variables!
#How many birds were there on both days?

birds_mon + birds_tues

#What is the average number of birds for the two days?

(birds_mon + birds_tues)/2

#Wait, I miscounted the number of birds on Tuesday! Can I update the variable?
#Let's say there were actually 10 birds. We can update it like so:

birds_tues <- birds_tues + 3

#You can also redefine the object to overwrite the incorrect variable:
birds_tues <- 10

Clearly, objects are very helpful. They are, however, only helpful to you if they are meaningful - creating objects with confusing or overly complicated names might make your life more difficult! Here are some tips and conventions for naming objects in R:

• Object names are case sensitive - Birds and birds can be two separate objects
• In general, don’t make your object names so similar that you can’t tell them apart!
• You cannot use spaces in object names (i.e. “birds_mon” works, but “birds mon” does not)
• You can use some special characters in names - you will commonly see “_” and “.” in place of a space, as I have used in the example. Most special characters will not work, particularly if they mean something else in the R language (e.g. you cannot put a “*” in a name for obvious reasons; you also wouldn’t put quotes around a name in practice)
• You can use a combination of characters and numbers, but you cannot just use numbers as object names (e.g. “birds1” works, but you can’t just name an object “1”)
• Try to be as specific as possible - “birds” is a lot more helpful than just “value” or “example”
• You will often find yourself typing out object names more than once - shorter names are much more convenient (but again, don’t make them so short that you don’t know what they mean - it might be tempting to name an object “a” or “b”, but if you have many objects in your environment, you may forget what they are later)

Returning to Functions

#I told you we'd come back to this! Functions are a really important component of R
#When we use a function, this is often referred to as "calling a function"
#The content inside of the () are called the arguments of the function
#recall the function:

sum(1,2,3)

#we can use our objects as arguments inside of the function call like so:
sum(birds_mon, birds_tues)


#so far, using functions hasn't really been any easier than typing out the operations manually
#Often, functions will perform operations that we can't easily type out in R
#For example, what if we want to get the absolute value of a number? Typing out |x| doesn't work in R
#Recall that the absolute value of any number is the positive (non-negative) version of it
#We can use a function as follows:

abs(-56)

#That was easy! We can also use multiple functions to perform some complex operations:

sum(26, abs(-56))

#Here, I've used the function that calculates the square root of a value
sum(2,4,6) - sqrt(64)

#Don't worry, you won't have to guess the names of functions! I'll tell you which functions to use in my tutorials. If you're ever really stumped, you can always google the name of a function too!

#Sometimes, functions will have multiple arguments. You can check all of the arguments that a function takes by visiting its help page. Let's use the round() function

?round

#based on this, we can see that the round function looks like this:
#round(x, digits = 0)
#There are two arguments here: the first is the value to be rounded (x) and the second tells the function how many digits to include after the decimal point. The default value of digits is shown, and it looks like it is set at 0. Let's test this:

round(5.66678)

#what if we change the digits argument? Let's round our value to two digits after the decimal place. We can do this in two ways:

round(5.66678, digits = 2)

#Or, we can simplify the argument:
round(5.66678, 2)

#You often won't have to use the name of the argument in the call to the function, but it can be helpful to use it so that you know what is happening inside the function. If you do not use the name of the argument, order matters! For example, I can change the order of the arguments if I use the names:

round(digits = 2, x = 5.66678)

#But I must use the arguments in the order specified by the help file if I do not use the argument names. So, this doesn't give me the same result that I was looking for:

round(2, 5.66678)

#In general, I would use the arguments in the specified order to avoid any confusion!

What if you don’t know what function to use? For the most part, I will give you the functions that you will need in my tutorials each week. You shouldn’t need to look up anything else. When you start doing your own programming projects, however, you may find that you need additional functions. Often, the best way to find other functions is to simply search google; most of the time, someone else has already created a package that contains the function you will need. If you think you know the name of a function, but aren’t sure, you can start typing a function in R and press Tab: this will bring up a list of functions to choose from.

Next, we will move on to another useful object type. So far, I have shown you how to store a single value. Often, you will need to perform calculations on multiple values. How can we store multiple values at once? The simplest way to do this is using an object called a Vector.

#Let's say I have bird data for an entire week. How can I store that data as a vector? I can use the Combine function, or c(), with a comma after each value I want to store in my vector. Here's what it looks like:

birds_week <- c(5, 7, 8, 4, 5, 3, 9)
birds_week

#What if I want to inspect one element of the vector? An index would come in handy here! An index tells R which element number to print out; the first element is element 1 and the last is element 5. We can see the number of birds on Wednesday (element 3) like so:

birds_week[3]

#That was easy! What if I want to see the birds on Tuesday through Thursday? I can use a ":" like so to print those elements:

birds_week[2:4]

#Note that, in R, indexing in this way is inclusive: we've selected all elements between 2 and 4, including elements 2 and 4. Not all programming languages function this way.

#What if we wanted to change one of the elements of the vector?
#That's easy too! We can tell R to change just one element like so:

birds_week[2] <- 10

#We have just assigned the number 10 to element 2. 
#What if my vector is very long? I can check the number of elements like so:

length(birds_week)

#This tells me that there are 5 elements in the vector (I can also see that by looking at the Global Environment pane)

#Can we perform computations on the elements of a vector? We sure can! Let's say bird food costs $0.50/bird, and I want to know how much it would cost for me to feed each bird. I can multiply each element by 0.5 like so:

birds_cost <- birds_week*0.50
birds_cost

#Note that, if you perform a calculation on the vector (as above) it will alter each element in the vector. If we wanted to just perform the computation on one element, we could have done the following:

cost_tues <- birds_week[2]*0.50
cost_tues

#What if the cost of feeding the birds changes during the week? Here's a new vector of bird food prices:

price <- c(0.50, 0.40, 1.00, 0.65, 0.30, 0.5, 0.7)

#We can multiply a vector by a vector! Can you tell what R did here?

birds_cost1 <- birds_week*price
birds_cost1

#Finally, we can also use functions on our vector. I'll get into this in more depth later, but here is an example:

mean(birds_week)

#This tells us the average number of birds per day
#Note that, if you don't store the value as an object, R will just print it out (as below). 

#So far, we have been working with numeric data! But there are a number of different data types that R will allow you to work with. You can find out what type of data you are working with by typing the following:

str(birds_week)

#str gives us a lot of information! If you only want to know the object type, you can use:

class(birds_week)

#This tells us that our vector is numeric! What if we wanted to work with another data type? For example, what if I want to know the type of the birds in the lot? I can store the names as a Character String. If I have five birds, it might look like this:

bird_type <- c("robin", "cardinal", "blue jay", "crow", "warbler")
bird_type

#The quotations tell us that each make is a character string; trying to create a character vector without the quotes will throw an error:

bird_type1 <- c(robin, cardinal)

#Why? Because without quotes, R is looking for an object that matches the names robin and cardinal. There are no such objects. This is very important to remember when working with characters. You can also use single quotes interchangeably:

bird_type1 <- c('cardinal', 'robin')

#I can select elements of a character vector in the same way I did for numeric vectors:

bird_type[3]

#If I check the structure of the vector, R will tell me that it is a character this time:

str(bird_type)

#What kinds of functions can we use on character vectors? Most of the functions we will be using are only for numeric data. There are a few functions that work for character data. For example, what if we wanted to know how many letters were in each element of the vector? We can use the function nchar() to find out:

nchar(bird_type)

Next, we’ll take a look at a third type of data: logical data. Before we store any logical data, I will first introduce what I mean by this data type. Logical data consists of True and False. We will rarely ever work with this data on its own: usually we use this data to index a vector based on a condition (I’ll explain this further in a minute). We can see how logical data is collected by using logical operations.

#For example, let's test a statement that we know is true. 

2+2 == 4

#Note that you must use the "==" when you are using a logical operation
#What happens if we input a logical operation that isn't true?

2+2 == 5

#We can do more than test equality. Here are some additional examples:

#Greater than:

2+2 > 4

#Less than:

2+2 < 5

#Less than or equal to:

2 + 2 <= 5

#Greater than or equal to:

2 + 2 >= 5

#We can also ask R if a value is simply not equal to another value, using a "!":

2 + 2 != 5

#There are two more important operations you should know using symbols
#Let's say we want to know if two conditions are true - if they both need to be true, we can use &:

4 > 5 & 4 < 6

#If we just want at least one condition to be true, we can use or, which is symbolized using a "|" symbol:

4 > 5 | 4 < 6

#As you can see, the first statement (using &) was false, but if we substitute an | instead, it becomes true. This is because only one of the logical conditions (4<6) was true. 

#We can also store TRUE and FALSE as logical data, as a value or vector like so:

answer <- 2+2 == 4

#What happens if I display the object, answer?

answer

#I can also store logical data by inputting directly, like this:
#Note that I can use an uppercase T or F as shorthand for TRUE and FALSE 

log1 <- T

log2 <- c(T, F, T)

log2

#I can also perform logical operations on a vector, like the birds_week vector we created earlier
#Let's find out which days there were more than 6 birds in my yard:

birds_week > 6

#If we wanted to, we could also store that as a vector

#Finally, you can use logical operations on text, for example:

"cat" == "cat"
"cat" == "dog"

#So, what do we actually do with logical data?
#In this next section, I will show you why logical data is so useful
#We typically use logical data to index vectors
#But before we do that, a few additional notes on indexing vectors:

#So far, we've indexed vector as follows:
birds_week[2]

#And we know that we can select multiple elements of a vector like this:
#Note that we need to use the c() when we specify individual elements in this way:

birds_week[c(2,3,4)]

#Order matters! Notice that this does not return the same result:

birds_week[c(3,2,4)]

#Remember that we can also tell R that we want to select elements 2 through 4, using "2:4"
#If we do it this way, we do not need the c()

birds_week[2:4]

#We will primarily use logical data to index vectors
#Say we want to select only the days of the week where there were more than 6 birds in my yard
#We can do that easily like this:

birds_week[birds_week > 6]

#Why did that work? Recall that "birds_week > 6" produced a vector of logical data, where days > 6 returned TRUE and days < 6 returned FALSE
#When we index a numeric vector by a logical vector in this way, it tells R to only return the numeric vector elements that correspond to TRUE in the logical vector - in this case, the entries for Tuesday, Wednesday, and Sunday are TRUE because they are >6

#We can also index character vectors
#Let's say I have the days of the week in a vector:

week <- c("Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday")

#If I want to know what weekdays there were more than 6 birds in the parking lot, I can also index the character vector like this:

week[birds_week > 6]

#Here, R matches the elements of each vector by their element number (e.g. Monday and 5 are element 1, Tuesday and 10 are element 2, etc.) and selects the elements in week that correspond with the element numbers in birds_week that are greater than 6
#Note that order matters here! If my days of the week were out of order, then I would not get the correct answers:

week1 <- c("Tuesday", "Monday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday")

week1[birds_week > 6]

#If I want to know what days of the week there were either greater than 8 birds or less than 5 birds, I can found out like so:

week[birds_week > 8 | birds_week < 5]

Resources Navarro, D. (2019). Learning Statistics with R. Retrieved from: https://learningstatisticswithr.com/book/index.html.