R has a lot to offer in terms of dates and times. The two main classes of data for this are Date and POSIXct. Date is used for calendar date objects like “2015-01-22”. POSIXct is a way to represent datetime objects like “2015-01-22 08:39:40 EST”, meaning that it is 40 seconds after 8:39 AM Eastern Standard Time.

In practice, the best strategy is to use the simplest class that you need. Often, Date will be the simplest choice. This course will use the Date class almost exclusively, but it is important to be aware of POSIXct as well for storing intraday financial data.

In the exercise below, you will explore your first date and time objects by asking R to return the current date and the current time.

You will often have to create dates yourself from character strings. The as.Date() function is the best way to do this:

# The Great Crash of 1929
great_crash <- as.Date("1929-11-29")

great_crash
[1] "1929-11-29"

class(great_crash)
[1] "Date"

Notice that the date is given in the format of “yyyy-mm-dd”. This is known as ISO format (ISO = International Organization for Standardization), and is the way R accepts and displays dates.

Internally, dates are stored as the number of days since January 1, 1970, and datetimes are stored as the number of seconds since then. You will confirm this in the exercises below.

Creating a single date is nice to know how to do, but with financial data you will often have a large number of dates to work with. When this is the case, you will need to convert multiple dates from character to date format. You can do this all at once using vectors. In fact, if you remembered that a single character is actually a vector of length 1, then you would know that you have been doing this all along!

# Create a vector of daily character dates
dates <- c("2017-01-01", "2017-01-02",
           "2017-01-03", "2017-01-04") 

as.Date(dates)
[1] "2017-01-01" "2017-01-02" "2017-01-03" "2017-01-04"

Like before, this might look like it returned another character vector, but internally these are all stored as numerics, with some special properties that only dates have.

As you saw earlier, R is picky about how it reads dates. To remind you, as.Date(“09/28/2008”) threw an error because it was not in the correct format. The fix for this is to specify the format you are using through the format argument:

as.Date("09/28/2008", format = "%m / %d / %Y")
[1] "2008-09-29"

This might look strange, but the basic idea is that you are defining a character vector telling R that your date is in the form of mm/dd/yyyy. It then knows how to extract the components and switch to yyyy-mm-dd.

There are a number of different formats you can specify, here are a few of them:

Not only can you convert characters to dates, but you can convert objects that are already dates to differently formatted dates using format():

# The best point move in stock market history. A +936 point change in the Dow!
best_date
[1] "2008-10-13"

format(best_date, format = "%Y/%m/%d")
[1] "2008/10/13"

format(best_date, format = "%B %d, %Y")
[1] "October 13, 2008"

As a reminder, here are the formats:

Just like with numerics, arithmetic can be done on dates. In particular, you can find the difference between two dates, in days, by using subtraction:

today <- as.Date("2017-01-02")
tomorrow <- as.Date("2017-01-03")
one_year_away <- as.Date("2018-01-02")

tomorrow - today
Time difference of 1 days

one_year_away - today
Time difference of 365 days

Equivalently, you could use the difftime() function to find the time interval instead.

difftime(tomorrow, today)
Time difference of 1 days

# With some extra options!
difftime(tomorrow, today, units = "secs")
Time difference of 86400 secs

As a final lesson on dates, there are a few functions that are useful for extracting date components. One of those is months().

my_date <- as.Date("2017-01-02")

months(my_date)
[1] "January"

Two other useful functions are weekdays() to extract the day of the week that your date falls on, and quarters() to determine which quarter of the year (Q1-Q4) that your date falls in.

In the video, Lore taught you all about different types of relational operators. For reference, here they are again:

These relational operators let us make comparisons in our data. If the equation is true, then the relational operator will return TRUE, otherwise it will return FALSE.

apple <- 45.46
microsoft <- 67.88

apple <= microsoft
[1] TRUE

hello <- "Hello world"

# Case sensitive!
hello == "hello world"
[1] FALSE

micr and apple stock prices and two dates, today and tomorrow, have been created for you.

You can extend the concept of relational operators to vectors of any arbitrary length. Compare two vectors using > to get a logical vector back of the same length, holding TRUE when the first is greater than the second, and FALSE otherwise.

apple <- c(120.00, 120.08, 119.97, 121.88)
datacamp  <- c(118.5, 124.21, 125.20, 120.22)

apple > datacamp
[1]  TRUE FALSE FALSE  TRUE

Comparing a vector and a single number works as well. R will recycle the number to be the same length as the vector:

apple > 120
[1] FALSE  TRUE FALSE  TRUE

Imagine how this could be used as a buy/sell signal in stock analysis! A data frame, stocks, is available for you to use.

You might want to check multiple relational conditions at once. What if you wanted to know if Apple stock was above 120, but below 121? Simple relational operators are not enough! For multiple conditions, you need the And operator &, and the Or operator |.

apple <- c(120.00, 120.08, 119.97, 121.88)

# Both conditions must hold
(apple > 120) & (apple < 121)
[1] FALSE  TRUE FALSE FALSE

# Only one condition has to hold
(apple <= 120) | (apple > 121)
[1]  TRUE FALSE  TRUE  TRUE

The stocks data frame is available for you to use.

One last operator to introduce is ! or, Not. You have already seen a similar operator, !=, so you might be able to guess what it does. Add ! in front of a logical expression, and it will flip that expression from TRUE to FALSE (and vice versa).

!TRUE
[1] FALSE

apple <- c(120.00, 120.08, 119.97, 121.88)

!(apple < 121)
[1] FALSE FALSE FALSE  TRUE

The stocks data frame is available for you to use.

Here’s a fun problem. You know how to create logical vectors that tell you when a certain condition is true, but can you subset a data frame to only contains rows where that condition is true?

If you took Introduction to R for Finance, you might remember the subset() function. subset() takes as arguments a data frame (or vector/matrix) and a logical vector of which rows to return:

stocks
        date    ibm panera
1 2017-01-20 170.55 216.65
2 2017-01-23 171.03 216.06
3 2017-01-24 175.90 213.55
4 2017-01-25 178.29 212.22

subset(stocks, ibm < 175)
        date    ibm panera
1 2017-01-20 170.55 216.65
2 2017-01-23 171.03 216.06

Useful, right? The stocks data frame is available for you to use.

Great! You have learned a lot about operators and subsetting. This will serve you well in future data analysis projects. Let’s do one last exercise that combines a number of operators together.

A new version of the stocks data frame is available for you to use.

If statements are great for adding extra logical flow to your code. First, let’s look at the basic structure of an if statement:

if(condition) {
    code
}

The condition is anything that returns a single TRUE or FALSE. If the condition is TRUE, then the code inside gets executed. Otherwise, the code gets skipped and the program continues. Here is an example:

apple <- 54.3

if(apple < 70) {
    print("Apple is less than 70")
}
[1] "Apple is less than 70"

Relational operators are a common way to create the condition in the if statement! The variable, micr, has been created for you.

An extension of the if statement is to perform a different action if the condition is false. You can do this by adding else after your if statement:

if(condition) {
    code if true
} else {
    code if false 
}

To add even more logic, you can follow the pattern of if, else if, else. You can add as many else if’s as you need for your control logic.

if(condition1) {
    code if condition1 is true
} else if(condition2) {
    code if condition2 is true
} else {
    code if both are false
}

Sometimes it makes sense to have nested if statements to add even more control. In the following exercise, you will add an if statement that checks if you are holding a share of the Microsoft stock before you attempt to sell it.

Here is the structure of nested if statements, it should look somewhat familiar:

if(condition1) {        
    if(condition2) {     
        code if both pass
    } else {            
        code if 1 passes, 2 fails
    }
} else {            
    code if 1 fails
}

The variables, micr and shares, have been created for you.

A powerful function to know about is ifelse(). It creates an if statement in 1 line of code, and more than that, it works on entire vectors!

Suppose you have a vector of stock prices. What if you want to return “Buy!” each time apple > 110, and “Do nothing!”, otherwise? A simple if statement would not be enough to solve this problem. However, with ifelse() you can do:

apple
[1] 109.49 109.90 109.11 109.95 111.03 112.12

ifelse(test = apple > 110, yes = "Buy!", no = "Do nothing!")
[1] "Do nothing!" "Do nothing!" "Do nothing!" "Do nothing!" "Buy!"       
[6] "Buy!"

ifelse() evaluates the test to get a logical vector, and where the logical vector is TRUE it replaces TRUE with whatever is in yes. Similarly, FALSE is replaced by no.

The stocks data frame is available for you to use.

Loops are a core concept in programming. They are used in almost every language. In R, there is another way of performing repeated actions using apply functions, but we will save those until chapter 5. For now, let’s look at the repeat loop!

This is the simplest loop. You use repeat, and inside the curly braces perform some action. You must specify when you want to break out of the loop. Otherwise it runs for eternity!

repeat {
    code
    if(condition) {
        break
    }
}

Do not do the following. This is an infinite loop! In words, you are telling R to repeat your code for eternity.

repeat {
    code
}

The order in which you execute your code inside the loop and check when you should break is important. The following would run the code a different number of times.

# Code, then check condition
repeat {
    code
    if(condition) {
        break
    }
}

# Check condition, then code
repeat {
    if(condition) {
        break
    }
    code
}

Let’s see this in an extension of the previous exercise. For the purposes of this example, the runif() function has been replaced with a static multiplier to remove randomness.

While loops are slightly different from repeat loops. Like if statements, you specify the condition for them to run at the very beginning. There is no need for a break statement because the condition is checked at each iteration.

while (condition) {
    code
}

It might seem like the while loop is doing the exact same thing as the repeat loop, just with less code. In our cases, this is true. So, why ever use the repeat loop? Occasionally, there are cases when using a repeat loop to run forever is desired. If you are interested, click here and check out Intentional Looping.

For the exercise, imagine that you have a debt of $5000 that you need to pay back. Each month, you pay off $500 dollars, until you’ve paid everything off. You will use a loop to model the process of paying off the debt each month, where each iteration you decrease your total debt and print out the new total!

The variable debt has been created for you.

Loops can be used for all kinds of fun examples! What if you wanted to visualize your debt decreasing over time? Like the last exercise, this one uses a loop to model paying it off, $500 at a time. However, at each iteration you will also append your remaining debt total to a plot, so that you can visualize the total decreasing as you go.

This exercise has already been done for you. Let’s talk about what is happening here.

After you run the code, you can use Previous Plot to go back and view all 11 of the created plots!

Sometimes, you have to end your while loop early. With the debt example, if you don’t have enough cash to pay off all of your debt, you won’t be able to continuing paying it down. In this exercise, you will add an if statement and a break to let you know if you run out of money!

while (condition) {
    code
    if (breaking_condition) {
        break
    }
}

The while loop will completely stop, and all lines after it will be run, if the breaking_condition is met. In this case, that condition will be running out of cash!

debt and cash have been defined for you.

Last, but not least, in our discussion of loops is the for loop. When you know how many times you want to repeat an action, a for loop is a good option. The idea of the for loop is that you are stepping through a sequence, one at a time, and performing an action at each step along the way. That sequence is commonly a vector of numbers (such as the sequence from 1:10), but could also be numbers that are not in any order like c(2, 5, 4, 6), or even a sequence of characters!

for (value in sequence) {
    code
}

In words this is saying, “for each value in my sequence, run this code.” Examples could be, “for each row of my data frame, print column 1”, or “for each word in my sentence, check if that word is DataCamp.”

Let’s try an example! First, you will create a loop that prints out the values in a sequence from 1 to 10. Then, you will modify that loop to also sum the values from 1 to 10, where at each iteration the next value in the sequence is added to the running sum.

A vector seq and a variable sum have been defined for you.

Imagine that you are interested in the days where the stock price of Apple rises above 117. If it goes above this value, you want to print out the current date and stock price. If you have a stock data frame with a date and apple price column, could you loop over the rows of the data frame to accomplish this? You certainly could!

Before you do so, note that you can get the number of rows in your data frame using nrow(stock). Then, you can create a sequence to loop over from 1:nrow(stock).

for (row in 1:nrow(stock)) {
    price <- stock[row, "apple"]
    date  <- stock[row, "date"]

    if(price > 117) {
        print(paste("On", date, 
                    "the stock price was", price))
    }
}
[1] "On 2016-12-21 the stock price was 117.06"
[1] "On 2016-12-27 the stock price was 117.26"

This incorporates a number of things we have learned so far. If statements, subsetting vectors, conditionals, and loops! Congratulations for learning so much!

The stocks data frame is available for you to use.

So far, you have been looping over 1 dimensional data types. If you want to loop over elements in a matrix (columns and rows), then you will have to use nested loops. You will use this idea to print out the correlations between three stocks.

The easiest way to think about this is that you are going to start on row1, and move to the right, hitting col1, col2, …, up until the last column in row1. Then, you move down to row2 and repeat the process.

my_matrix
     [,1]   [,2]  
[1,] "r1c1" "r1c2"
[2,] "r2c1" "r2c2"

# Loop over my_matrix
for(row in 1:nrow(my_matrix)) {
    for(col in 1:ncol(my_matrix)) {
        print(my_matrix[row, col])
    }
}
[1] "r1c1"
[1] "r1c2"
[1] "r2c1"
[1] "r2c2"

The correlation matrix, corr, is available for you to use.

To finish your lesson on loops, let’s return to the concept of break, and the related concept of next. Just like with repeat and while loops, you can break out of a for loop completely by using the break statement. Additionally, if you just want to skip the current iteration, and continue the loop, you can use the next statement. This can be useful if your loop encounters an error, but you don’t want it to break everything.

for (value in sequence) {
    if(next_condition) {
        next
    }
    code
    if(breaking_condition) {
        break
    }
}

You don’t have to use both break and next at the same time, this simply shows the general structure of using them.

The point of using next at the beginning, before the code runs, is to check for a problem before it happens.

When you don’t know how to use a function, or don’t know what arguments it takes, where do you turn? Luckily for you, R has built in documentation. For example, to get help for the names() function, you can type one of:

?names

?names()

help(names)

These all do the same thing; they take you straight to the help page for names()!

In the DataCamp console, this takes you to the RDocumentation site to get help from there, but the information is all the same!

Below, you will explore the documentation for a few other functions.

Let’s look at some of the round() function’s help documentation. It simply rounds a numeric vector off to a specified number of decimal places.

round(x, digits = 0)

The first argument, x is required. Without it, the function will not work!

The argument digits is known as an optional argument. Optional arguments are ones that don’t have to be set by the user, either because they are given a default value, or because the function can infer them from the other data you have given it. Even though they don’t have to be set, they often provide extra flexibility. Here, digits specifies the number of decimal places to round to.

Explore the round() function in the exercise!

To write clean code, sometimes it is useful to use functions inside of other functions. This let’s you use the result of one function directly in another one, without having to create an intermediate variable. You have actually already seen an example of this with print() and paste().

company <- c("Goldman Sachs", "J.P. Morgan", "Fidelity Investments")

for(i in 1:3) {
    print(paste("A large financial institution is", company[i]))
}
[1] "A large financial institution is Goldman Sachs"
[1] "A large financial institution is J.P. Morgan"
[1] "A large financial institution is Fidelity Investments"

paste() strings together the character vectors, and print() prints it to the console.

The exercise below explores simplifying the calculation of the correlation matrix using nested functions. Three vectors of stock prices, apple, ibm, and micr, are available for you to use.

Time for your first function! This is a big step in an R programmer’s journey. “Functions are a fundamental building block of R: to master many of the more advanced techniques … you need a solid foundation in how functions work.” -Hadley Wickham

Here is the basic structure of a function:

func_name <- function(arguments) {
    body
}

And here is an example:

square <- function(x) {
    x^2
}

square(2)
[1] 4

Two things to remember from what Lore taught you are arguments and the function body. Arguments are user inputs that the function works on. They can be the data that the function manipulates, or options that affect the calculation. The body of the function is the code that actually performs the manipulation.

The value that a function returns is simply the last executed line of the function body. In the example, since x^2 is the last line of the body, that is what gets returned.

In the exercise, you will create your first function to turn a percentage into a decimal, a useful calculation in finance!

As you saw in the optional arguments example, functions can have multiple arguments. These can help extend the flexibility of your function. Let’s see this in action.

pow <- function(x, power = 2) {
    x^power
}

pow(2)
[1] 4

pow(2, power = 3)
[1] 8

Instead of a square() function, we now have a version that works with any power.

The power argument is optional and has a default value of 2, but the user can easily change this. It is also an example of how you can add multiple arguments. Notice how the arguments are separated by a comma, and the default value is set using an equals sign.

Let’s add some more functionality to percent_to_decimal() that allows you to round the percentage to a certain number of digits.

Let’s think about a more complicated example. Do you remember present value from the Introduction to R for Finance course? If not, you can review the video for that here. The idea is that you want to discount money that you will get in the future at a specific interest rate to represent the value of that money in today’s dollars. The following general formula was developed to help with this:

present_value <- cash_flow * (1 + i / 100) ^ -year

Wouldn’t it be nice to have a function that did this calculation for you? Maybe something of the form:

present_value <- pv(cash_flow, i, year)

This function should work if you pass in numerics like pv(1500, 5, 2) and it should work if you pass in vectors of equal length to calculate an entire present value vector at once!

The percent_to_decimal() function is available for you to use.

Scoping is the process of how R looks a variable’s value when given a name. For example, given x <- 5, scoping is how R knows where to look to find that the value of x is 5.

Try this scoping exercise!

percent_to_decimal <- function(percent) {
    decimal <- percent / 100
    decimal
}

percent_to_decimal(6)
[1] 0.06

What does typing decimal now return?

Let’s try another one. Here, hundred is defined outside of the function scope, but is used inside of the function.

hundred <- 100

percent_to_decimal <- function(percent) {
    percent / hundred
}

What will percent_to_decimal(6) return?

The tidyquant package is focused on retrieving, manipulating, and scaling financial data analysis in the easiest way possible. To get the tidyquant package and start working with it, you first have to install it.

install.packages("tidyquant")

This places it on your local computer. You then have to load it into your current R session. This gives you access to all of the functions in the package.

library(tidyquant)

These steps of installing and librarying packages are necessary for any CRAN package you want to use.

The exercise code is already written for you. You will explore some of the functions that tidyquant has for financial analysis.

The first function in the apply family that you will learn is lapply(), which is short for “list apply.” When you have a list, and you want to apply the same function to each element of the list, lapply() is a potential solution that always returns another list. How might this work?

Let’s look at a simple example. Suppose you want to find the length of each vector in the following list.

my_list
$a
[1] 2 4 5

$b
[1] 10 14  5  3  4  5  6

# Using lapply
# Note that you don't need parenthesis when calling length
lapply(my_list, FUN = length)
$a
[1] 3

$b
[1] 7

As noted in the video, if at first you thought about looping over each element in the list, and using length() at each iteration, you aren’t wrong. lapply() is the vectorized version of this kind of loop, and is often preferred (and simpler) in the R world.

A list of daily stock returns as percentages called stock_return and the percent_to_decimal() function have been provided.

If, instead of a list, you had a data frame of stock returns, could you still use lapply()? Yes! Perhaps surprisingly, data frames are actually lists under the hood, and an lapply() call would apply the function to each column of the data frame.

df
  a b
1 1 4
2 2 6

class(df)
[1] "data.frame"

lapply(df, FUN = sum)
$a
[1] 3

$b
[1] 10

lapply() summed each column in the data frame, but still follows its convention of always returning a list. A data frame of daily stock returns as decimals called stock_return has been provided.

Often, the function that you want to apply will have other optional arguments that you may want to tweak. Consider the percent_to_decimal() function that allows the user to specify the number of decimal places.

percent_to_decimal(5.4, digits = 3)
[1] 0.054

In the call to lapply() you can specify the named optional arguments after the FUN argument, and they will get passed to the function that you are applying.

my_list
$a
[1] 2.444 3.500

$b
[1] 1.100 2.678 3.450

lapply(my_list, FUN = percent_to_decimal, digits = 4)
$a
[1] 0.0244 0.0350

$b
[1] 0.0110 0.0268 0.0345

In the exercise, you will extend the capability of your sharpe ratio function to allow the user to input the risk free rate as an argument, and then use this with lapply(). A data frame of daily stock returns as decimals called stock_return is available.

lapply() is great, but sometimes you might want the returned data in a nicer form than a list. For instance, with the sharpe ratio, wouldn’t it be great if the returned sharpe ratios were in a vector rather than a list? Further analysis would likely be easier!

For this, you might want to consider sapply(), or simplify apply. It performs exactly like lapply(), but will attempt to simplify the output if it can. The basic syntax is the same, with a few additional arguments:

sapply(X, FUN, ..., simplify = TRUE, USE.NAMES = TRUE)

These additional optional arguments let you specify if you want sapply() to try and simplify the output, and if you want it to use the names of the object in the output.

In the exercise, you will recalculate sharpe ratios using sapply() to simplify the output. stock_return and the sharpe function are available for you.

For interactive use, sapply() is great. It guesses the output type so that it can simplify, and normally that is fine. However, sapply() is not a safe option to be used when writing functions. If sapply() cannot simplify your output, then it will default to returning a list just like lapply(). This can be dangerous and break custom functions if you wrote them expecting sapply() to return a simplified vector.

Let’s look at an exercise using a list containing information about the stock market crash of 2008.

In the last example, sapply() failed to simplify because the date element of market_crash2 had two classes (POSIXct and POSIXt). Notice, however, that no error was thrown! If a function you had written expected a simplified vector to be returned by sapply(), this would be confusing.

To account for this, there is a more strict apply function called vapply(), which contains an extra argument FUN.VALUE where you can specify the type and length of the output that should be returned each time your applied function is called.

If you expected the return value of class() to be a character vector of length 1, you can specify that using vapply():

vapply(market_crash, class, FUN.VALUE = character(1))
dow_jones_drop           date 
     "numeric"         "Date"

Other examples of FUN.VALUE might be numeric(2) or logical(1). market_crash2 is again defined for you.

The difference between vapply() and sapply() was shown in the last example to demonstrate vapply() appropriately failing, but what about when it doesn’t fail? When there are no errors, vapply() returns a simplified result according to the FUN.VALUE argument.

The stock_return dataset containing daily returns for Apple, IBM, and Microsoft has been provided. The sharpe() function is also available.

As a last exercise, you’ll learn about a concept called anonymous functions. So far, when calling an apply function like vapply(), you have been passing in named functions to FUN. Doesn’t it seem like a waste to have to create a function just for that specific vapply() call? Instead, you can use anonymous functions!

Named function:

percent_to_decimal <- function(percent) {
    percent / 100
}

Anonymous function:

function(percent) { percent / 100 }

As you can see, anonymous functions are basically functions that aren’t assigned a name. To use them in vapply() you might do:

vapply(stock_return, FUN = function(percent) { percent / 100 }, 
       FUN.VALUE = numeric(2))
            apple          ibm
[1,]  0.003744634  0.001251408
[2,] -0.007188353 -0.001124859

stock_return is available to use.