Some Major Stock Indices and Visualization

library(tidyverse)
library(tidyquant)
library(timetk)
library(tibbletime)
library(viridis)
library(highcharter)
library(ggthemes)
library(dygraphs)
library(knitr)
library(stringr)
library(plotly)
library(scales)

S&P 500 stock,Russell 3000, Stockholm 30 Index, NASDAQ Global Market Composite NYSE Composite,State Street Global Advisors launched the SPDR S&P 500 ETF (NYSE:SPY),the SPDR Dow Jones Industrial Average (NYSE:DIA)

# The symbols vector holds our tickers. 
tickers <- c( "SPX","NYA","SPY","DIA")
# The prices object will hold our raw price data throughout this book.
prices <- 
  getSymbols(tickers, src = 'yahoo', from = "2015-01-01", 
             auto.assign = TRUE, warnings = FALSE)
prices

[1] "SPX" "NYA" "SPY" "DIA"

^IXIC is Nasdaq symbol,RUSSELL 2000 INDEX (^RUT),Dow Jones Industrial Average (NYSE:DIA),State Street Global Advisors launched the SPDR S&P 500 ETF (NYSE:SPY)

prices1=tq_get(c( "SPY","DIA","^IXIC","^RUT"), from = "2012-01-01", get = 'stock.prices')
tail(prices1)

head(prices1)

prices2<-prices1%>%select(-c(open,high,low,close,volume))
prices2

#remove non alphabet characters
prices2$symbol<-gsub("[^[:alpha:]]", "", prices2$symbol)
head(prices2)

tail(prices2)

prices1$symbol = str_replace_all(prices1$symbol, pattern = "[^[:alpha:]]", "")
head(prices1)

tail(prices1)

prices1%>%
ggplot(aes(date, adjusted, color = symbol)) +
geom_line() +
labs(title = "Multi stock example",
xlab = "Date",
ylab = "Adjusted Close")+theme_economist_white()+
  
  geom_area(fill = "cyan", alpha = .1)

ggplotly()

# Get stock prices
stocks <- c("AAPL", "FB", "NFLX", "GOOG","AMZN") %>%
tq_get(from = "2012-01-01")
stocks

# Plot for stocks
stocks %>%
ggplot(aes(date, adjusted, color = symbol)) +
geom_line() +
labs(title = "Multi stock example",
xlab = "Date",
ylab = "Adjusted Close")+theme_economist_white()

Use quantmod periodReturn to Convert Prices to Returns

The quantmod::periodReturn() function generates returns by periodicity.

We want to use the adjusted closing prices column (adjusted for stock splits, which can make it appear that a stock is performing poorly if a split is included). We set select = adjusted. We research the periodReturn function, and we found that it accepts type = “arithmetic” and period = “yearly”, which returns the annual returns.

Annual_returns <- prices1 %>%
    group_by(symbol) %>%
    tq_transmute(select     = adjusted, 
                 mutate_fun = periodReturn, 
                 period     = "yearly", 
                 type       = "arithmetic")
Annual_returns

#Annual_returns %>%
   # ggplot(aes(x = date, y = yearly.returns, fill = symbol))+stat_count(stat = "identity")
Annual_returns<- prices2 %>%tk_tbl()%>%
    group_by(symbol) %>%
    tq_transmute(mutate_fun = periodReturn, 
                 period     = "yearly", 
                 type       = "arithmetic")
Annual_returns%>%head()

Annual_returns %>%
    ggplot(aes(x = date, y = yearly.returns, color = symbol)) +
    geom_line(size = 1) +
    labs(title = "Yearly Stock returns Prices",
         x = "", y = "Adjusted Prices", color = "") +
    #facet_wrap(~ symbol, ncol = 2, scales = "free_y") +
    scale_y_continuous(labels = scales::percent) +
    theme_tq() + 
    scale_color_tq()

#ggplotly()

Annual_returns %>%
 ggplot(aes(x = date, y = yearly.returns, fill = symbol)) +
    geom_bar(stat = "identity", width = 200) +
    geom_hline(yintercept = 0, color = palette_light()[[1]]) +
    scale_y_continuous(labels = scales::percent) +
    labs(title = "Annual Returns",
         subtitle = "",
         y = "Annual Returns", x = "") + 
    facet_wrap(~ symbol, ncol = 2,scales = "free_y") +
    theme_tq() + 
    scale_fill_tq()

Daily Log Returns

We want to use the adjusted closing prices column (adjusted for stock splits, which can make it appear that a stock is performing poorly if a split is included), so we set select = adjusted. We researched the periodReturn function, and we found that it accepts type = “log” and period = “daily”, which returns the daily log returns.

Daily_log_returns <- prices1 %>%
    group_by(symbol) %>%
    tq_transmute(select     = adjusted, 
                 mutate_fun = periodReturn, 
                 period     = "daily", 
                 type       = "log",
                 col_rename = "monthly.returns")

Daily_log_returns %>%
    ggplot(aes(x = monthly.returns, fill = symbol)) +
    geom_density(alpha = 0.5) +
    labs(title = "Daily Log Returns",
         x = "Monthly Returns", y = "Density") +
    theme_tq() +
    scale_fill_tq() + 
    facet_wrap(~ symbol, ncol = 2,scales = "free_y")

#facet_grid(.~symbol,scales="free",space="free") 
  #scale_y_continuous(labels = scales::percent)
  #facet_wrap(~symbol, scales = "free_y", nrow = 2, strip.position = "bottom") 

Use xts to.period to Change the Periodicity from Daily to Monthly

The xts::to.period function is used for periodicity aggregation (converting from a lower level periodicity to a higher level such as minutes to hours or months to years). Because we are seeking a return structure that is on a different time scale than the input (daily versus weekly), we need to use a transmute function. We select tq_transmute() and pass the open, high, low, close and volume columns via select = open:volume. Looking at the documentation for to.period, we see that it accepts a period argument that we can set to “weeks”. The result is the OHLCV data returned with the dates changed to one day per week.

prices1 %>%
    group_by(symbol) %>%
    tq_transmute(select     = open:volume, 
                 mutate_fun = to.period, 
                 period     = "months")%>%head()

Without Periodicity Aggregation

Daily <- prices2 %>%
    group_by(symbol)
Daily %>%
    ggplot(aes(x = date, y = adjusted, color = symbol)) +
    geom_line(size = 1) +
    labs(title = "Daily Stock Prices",
         x = "", y = "Adjusted Prices", color = "") +
    facet_wrap(~ symbol, ncol = 2, scales = "free_y") +
    scale_y_continuous(labels = scales::dollar) +
    theme_tq() + 
    scale_color_tq()

With Periodicity Aggregation

Monthly <- prices2%>%
    group_by(symbol) %>%
    tq_transmute(select     = adjusted, 
                 mutate_fun = to.period, 
                 period     = "months")
Monthly %>%
    ggplot(aes(x = date, y = adjusted, color = symbol)) +
    geom_line(size = 1) +
    labs(title = "Monthly Stock Prices",
         x = "", y = "Adjusted Prices", color = "") +
    facet_wrap(~ symbol, ncol = 2, scales = "free_y") +
    scale_y_continuous(labels = scales::dollar) +
    theme_tq() + 
    scale_color_tq()

Use TTR runCor to Visualize Rolling Correlations of Returns

Return correlations are a common way to analyze how closely an asset or portfolio mimics a baseline index or fund. We will need a set of returns for both the stocks and baseline. The baseline will be the Spdr XLK technology sector.

# Asset Returns
returns_monthly <- prices1%>%
    group_by(symbol) %>%
    tq_transmute(select     = adjusted, 
                 mutate_fun = periodReturn,
                 period     = "monthly")
# Baseline Returns
baseline_returns_monthly <- "XLK" %>%
    tq_get(get  = "stock.prices",
           from = "2012-01-01") %>%
    tq_transmute(select     = adjusted, 
                 mutate_fun = periodReturn,
                 period     = "monthly")

returns_joined <-inner_join(returns_monthly, 
                            baseline_returns_monthly,
                            by = "date")
#alternatively
returns_joined2 <- merge(returns_monthly, 
                            baseline_returns_monthly,
                            by = "date")
returns_joined%>%dim()

[1] 275   4

returns_joined2%>%dim()

[1] 275   4

returns_joined%>%head()

returns_joined$symbol=factor(returns_joined$symbol)
str(returns_joined)

Classes ‘grouped_df’, ‘tbl_df’, ‘tbl’ and 'data.frame': 275 obs. of  4 variables:
 $ symbol           : Factor w/ 4 levels "DIA","IXIC","RUT",..: 4 4 4 4 4 4 4 4 4 4 ...
 $ date             : Date, format: "2012-01-31" "2012-02-29" "2012-03-30" ...
 $ monthly.returns.x: num  0.02996 0.04341 0.03216 -0.00668 -0.06006 ...
 $ monthly.returns.y: num  0.0473 0.071 0.0451 -0.0113 -0.0634 ...
 - attr(*, "vars")= chr "symbol"

6-month rolling correlation

When something is said to be rolling it’s tracking a certain amount of time in the past, and then rolls forward as time progresses. So the the 30 day rolling correlation would be the correlation between the basket of assets for the past 30 days. Tomorrow we add one more day and subtract the first day, to maintain 30 days.

The TTR::runCor function can be used to evaluate rolling correlations using the xy pattern. Because the scale is monthly, we’ll go with n = 6 for a 6-month rolling correlation. The col_rename argument enables easy renaming of the output column(s).

rolling_corr <- returns_joined %>%
    tq_transmute_xy(x          = monthly.returns.x, 
                    y          = monthly.returns.y,
                    mutate_fun = runCor,
                    n          = 6,
                    col_rename = "rolling.corr.6")

rolling_corr %>%
    ggplot(aes(x = date, y = rolling.corr.6, color = symbol)) +
    geom_hline(yintercept = 0, color = palette_light()[[1]]) +
    geom_line(size = 1) +
    labs(title = " Six Month Rolling Correlation to XLK",
         x = "", y = "Correlation", color = "") +
    facet_wrap(~ symbol, ncol = 2) +
    theme_tq() + 
    scale_color_tq()

Use TTR MACD to Visualize Moving Average Convergence Divergence

In reviewing the available options in the TTR package, we see that MACD will get us the Moving Average Convergence Divergence (MACD). In researching the documentation, the return is in the same periodicity as the input and the functions work with OHLC functions, so we can use tq_mutate(). MACD requires a price, so we select close.

macd <- prices1 %>%
    group_by(symbol) %>%
    tq_mutate(select     = close, 
              mutate_fun = MACD, 
              nFast      = 12, 
              nSlow      = 26, 
              nSig       = 9, 
              maType     = DEMA) %>%
    mutate(diff = macd - signal) %>%
    select(-(open:volume))
macd%>%head()

macd %>%
    filter(date >= as_date("2012-03-15")) %>%
    ggplot(aes(x = date)) + 
    geom_hline(yintercept = 0, color = palette_light()[[1]]) +
    geom_line(aes(y = macd, col = symbol)) +
    geom_line(aes(y = signal), color = "blue", linetype = 2) +
    geom_bar(aes(y = diff), stat = "identity", color = palette_light()[[1]]) +
    facet_wrap(~ symbol, ncol = 2, scale = "free_y") +
    labs(title = "FANG: Moving Average Convergence Divergence",
         y = "MACD", x = "", color = "") +
    theme_tq() +
    scale_color_tq()

Use xts apply.quarterly to Get the Max and Min Price for Each Quarter

The xts::apply.quarterly() function that is part of the period apply group can be used to apply functions by quarterly time segments. Because we are seeking a return structure that is on a different time scale than the input (quarterly versus daily), we need to use a transmute function. We select tq_transmute and pass the close price using select, and we send this subset of the data to the apply.quarterly function via the mutate_fun argument. Looking at the documentation for apply.quarterly, we see that we can pass a function to the argument, FUN. We want the maximum values, so we set FUN = max. The result is the quarters returned as a date and the maximum closing price during the quarter returned as a double.

max_by_qtr <- prices1 %>%
    group_by(symbol) %>%
    tq_transmute(select     = adjusted, 
                 mutate_fun = apply.quarterly, 
                 FUN        = max, 
                 col_rename = "max.close") %>%
    mutate(year.qtr = paste0(year(date), "-Q", quarter(date))) %>%
    select(-date)
max_by_qtr%>%head()

The minimum each quarter can be retrieved in much the same way. The data frames can be joined using left_join to get the max and min by quarter.

min_by_qtr <- FANG %>%
    group_by(symbol) %>%
    tq_transmute(select     = adjusted, 
                 mutate_fun = apply.quarterly, 
                 FUN        = min, 
                 col_rename = "min.close") %>%
    mutate(year.qtr = paste0(year(date), "-Q", quarter(date))) %>%
    select(-date)
by_qtr <- left_join(max_by_qtr, min_by_qtr,
                         by = c("symbol"   = "symbol",
                                "year.qtr" = "year.qtr"))
by_qtr%>%head()

by_qtr %>%
    ggplot(aes(x = year.qtr, color = symbol)) +
    geom_segment(aes(xend = year.qtr, y = min.close, yend = max.close),
                 size = 2) +
    geom_point(aes(y = max.close), size = 2) +
    geom_point(aes(y = min.close), size = 2) +
    facet_wrap(~ symbol, ncol = 2, scale = "free_y") +
    labs(title = " Min/Max Price By Quarter",
         y = "Stock Price", color = "") +
    theme_tq() +
    scale_color_tq() +
    scale_y_continuous(labels = scales::dollar) +
    theme(axis.text.x = element_text(angle = 90, hjust = 1),
          axis.title.x = element_blank())

Use zoo rollapply to visualize a rolling regression

A good way to analyze relationships over time is using rolling calculations that compare two assets. Pairs trading is a common mechanism for similar assets. In this example we will analyze two similar assets, Ford(F) and General Motors(GM) to show the relationship via regression.

# Get stock pairs
stock_prices <- c("F", "GM") %>%
    tq_get(get  = "stock.prices",
           from = "2012-01-01") %>%
    group_by(symbol) 
stock_pairs <- stock_prices %>%
    tq_transmute(select     = adjusted,
                 mutate_fun = periodReturn,
                 period     = "daily",
                 type       = "log",
                 col_rename = "returns") %>%
    spread(key = symbol, value = returns)
stock_prices%>%head()

stock_pairs %>%
    ggplot(aes(x = F, y = GM)) +
    geom_point(color = palette_light()[[1]], alpha = 0.5) +
    geom_smooth(method = "lm") +
    labs(title = "Visualizing Returns Relationship of Stock Pairs") +
    theme_tq()

We can get statistcs on the relationship from the lm function. The model is highly correlated with a p-value of essential zero. The coefficient estimate for GM (Coefficient 1) is 0.63 indicating a positive relationship, meaning as F increases GM also tends to increase.

lm(F ~ GM, data = stock_pairs) %>%
    broom::tidy()

The data will be passed to the regression function as an xts object. The timetk::tk_tbl function takes care of converting to a data frame.

regr_fun <- function(data) {
    coef(lm(F ~ GM, data = timetk::tk_tbl(data, silent = TRUE)))
}

We can use tq_mutate() to apply the custom regression function over a rolling window using rollapply from the zoo package. Internally, the returns_combined data frame is being passed automatically to the data argument of the rollapply function. All you need to specify is the mutate_fun = rollapply and any additional arguments necessary to apply the rollapply function. We’ll specify a 90 day window via width = 90. The FUN argument is our custom regression function, regr_fun. It’s extremely important to specify by.column = FALSE, which tells rollapply to perform the computation using the data as a whole rather than apply the function to each column independently. The col_rename argument is used to rename the added columns.

stock_pairs <- stock_pairs %>%
         tq_mutate(mutate_fun = rollapply,
                   width      = 90,
                   FUN        = regr_fun,
                   by.column  = FALSE,
                   col_rename = c("coef.0", "coef.1"))
stock_pairs%>%head()

stock_pairs %>%
    ggplot(aes(x = date, y = coef.1)) +
    geom_line(size = 1, color = palette_light()[[1]]) +
    geom_hline(yintercept = 0.8134, size = 1, color = palette_light()[[2]]) +
    labs(title = "F ~ GM: Visualizing Rolling Regression Coefficient", x = "") +
    theme_tq()

Stock returns during this time period.

stock_prices %>%
    tq_transmute(adjusted, 
                 periodReturn, 
                 period = "daily", 
                 type = "log", 
                 col_rename = "returns") %>%
    mutate(wealth.index = 100 * cumprod(1 + returns)) %>%
    ggplot(aes(x = date, y = wealth.index, color = symbol)) +
    geom_line(size = 1) +
    labs(title = "F and GM: Stock Prices") +
    theme_tq() + 
    scale_color_tq()

Use Return.clean and Return.excess to clean and calculate excess returns

We use several of the PerformanceAnalytics functions to clean and format returns. The example uses three progressive applications of tq_transmute to apply various quant functions to the grouped stock prices from the initial data set. First, we calculate daily returns using quantmod::periodReturn. Next, we use Return.clean to clean outliers from the return data. The alpha parameter is the percentage of oultiers to be cleaned. Finally, the excess returns are calculated using a risk-free rate of 3% (divided by 252 for 252 trade days in one year).

prices1 %>%
    group_by(symbol) %>%
    tq_transmute(adjusted, periodReturn, period = "daily") %>%
    tq_transmute(daily.returns, Return.clean, alpha = 0.05) %>%
    tq_transmute(daily.returns, Return.excess, Rf = 0.03 / 252)