R Note 2 - Portfolio Formation using R

Author
Affiliation

Asst. Prof. Calvin J. Chiou

National Chengchi University (NCCU)

Course Information

  • Course Name: Investments | 000351051

  • Semester: Spring 2025

1. Fetching Stock Data

We use R to create an equally weighted portfolio consisting of four stocks: ExxonMobil (XOM), Walmart (WMT), NVIDIA (NVDA), and Apple (AAPL). Using tidyquant to fetch stock prices via Yahoo Finance. Note that the corresponding ticker for a given stock can be found on its website.

library(tidyquant)
library(tidyverse)
library(highcharter)
library(DT)
# Define stock tickers and date range
stocks <- c("XOM", "WMT", "NVDA", "AAPL")
start_date <- "2023-01-01"
end_date <- "2023-04-30"
# Download stock prices
prices <- tq_get(stocks, from = start_date, to = end_date)
# Print out interactive table
datatable(prices) |> 
  formatRound(columns = c("open","high","low","close","adjusted"), digits = 2)

2. Constructing an Equally Weighted Portfolio

Assuming a $1,000,000 budget divided equally among the four stocks, we calculate how many shares we can purchase on the first business day in January 2023.

# Assigned budget
budget <- 1000000
num_stocks <- length(stocks)
budget_per_stock <- budget / length(stocks)
# Positions for each stock
initial_positions <- prices |> 
  filter(date == min(date)) |> 
  mutate(shares = floor(budget_per_stock / adjusted)) |> 
  select(symbol, shares)

datatable(initial_positions)

3. Portfolio Valuation and Return Calculation

Portfolio Value

Calculate the portfolio value for each trading day:

portfolio <- prices |> 
  inner_join(initial_positions, by = "symbol") |> 
  mutate(position_value = shares * adjusted) |> 
  group_by(date) |> 
  summarize(total_value = sum(position_value)) |> 
  arrange(date)

datatable(portfolio) |> 
  formatRound(columns = c("total_value"), digits = 2)

Portfolio Returns

A. Calculating returns from the net value of portfolio

Returns in finance can be calculated using either discrete or continuous methods. Both approaches measure investment performance but have different interpretations and applications. Here presents the key difference between these two:

Feature Discrete Returns Continuous Returns
Formula \[ R_t=P_t/P_{t-1}-1 \] \[ R_t=ln(P_t/P_{t-1}) \]
Interpretation Simple percentage change Log-based compounding change
Time Additivity ❌ No ✅ Yes
Compounding Not considered Naturally accounts for compounding
Use Case Short-term analysis (daily, weekly returns), industry Long-term modeling (portfolio returns, Black-Scholes model), academics

Calculate discrete and continuous returns for the portfolio:

portfolio <- portfolio |> 
  mutate(discrete_return = 100*(total_value / lag(total_value) - 1),
         continuous_return = 100*log(total_value / lag(total_value)))

datatable(portfolio) |> 
  formatRound(columns = c("total_value","discrete_return","continuous_return"), digits = 2)

B. Calculating returns directly from portfolio securities

Similar to the previous method, we calculate discrete and continuous returns for the portfolio through portfoflio stocks directly rather than net value:

individual_ret <- prices |> 
  mutate(
    # 1. assign portfolio weights on corresponding stocks
    portfolio_weight = case_when(
      symbol == "XOM" ~ 0.25, 
      symbol == "WMT" ~ 0.25, 
      symbol == "NVDA" ~ 0.25, 
      symbol == "AAPL" ~ 0.25
    ),
    # 2. individual returns (grouped by each stock)
    discrete_return = 100*(adjusted / lag(adjusted) - 1),
    continuous_return = 100*log(adjusted / lag(adjusted)),
    .by = symbol
  ) |> 
  select(symbol, date, portfolio_weight, discrete_return, continuous_return) |> 
  # the first obervation of each stock will naturally be missing since there is no lagged value, then we drop it out
  drop_na(continuous_return)
# print out individual returns
datatable(individual_ret) |> 
  formatRound(columns = c("discrete_return","continuous_return"), digits = 2)
# Aggregate returns of four individual stocks by each day (DATE)
portfolio_ret <- individual_ret |> 
  group_by(date) |> 
  summarise(port_return = sum(portfolio_weight*continuous_return),
            .groups = "drop")
datatable(portfolio_ret) |> 
  formatRound(columns = c("port_return"), digits = 2)

Portfolio Volatility

Calculate variance and volatility (standard deviation) of portfolio returns from individual stocks.

The portfolio volatility (standard deviation of portfolio returns) is given by:

\[ \sigma_p = \sqrt{ w^T \mathbf{\Sigma}w}\]

Where:

  • \(\sigma_p\) = Portfolio volatility

  • \(w\) = Column vector of asset weights (\(w_1, w_2, w_3, w_4\))

  • \(\mathbf{\Sigma}\) = Covariance matrix of asset returns

  • \(w^T\) = Transposed weight vector

# sigma for each stock
portfolio_volatility <- individual_ret |> 
  group_by(symbol) |> 
  summarise(sigma = sd(continuous_return),
            .groups = "drop")
head(portfolio_volatility)
# A tibble: 4 × 2
  symbol sigma
  <chr>  <dbl>
1 AAPL   1.40 
2 NVDA   3.09 
3 WMT    0.944
4 XOM    1.77 
# stock weights
weights <- c(0.25, 0.25, 0.25, 0.25)
# individual stock volatilities (standard deviations)
volatilities <- portfolio_volatility$sigma
# correlation matrix
returns_wide <- individual_ret |> 
  select(symbol, date, continuous_return) |> 
  pivot_wider(names_from = symbol, values_from = continuous_return)
# Calculate correlation matrix
cor_matrix <- cor(returns_wide[, -1], use = "pairwise.complete.obs")
datatable(cor_matrix)
# Compute covariance matrix
cov_matrix <- (volatilities %*% t(volatilities)) * cor_matrix
# Calculate portfolio volatility
portfolio_volatility <- sqrt(t(weights) %*% cov_matrix %*% weights)
# Print result
cat(sprintf("Portfolio return is %.2f percent", portfolio_volatility))
Portfolio return is 1.21 percent

4. Visualizing Portfolio Value with highcharter

# Portfolio value
hchart(portfolio, type = "area", hcaes(x = date, y = total_value)) |> 
  hc_title(text = "Portfolio Value Over Time") |> 
  hc_yAxis(title = list(text = "Total Portfolio Value ($)")) |> 
  hc_xAxis(title = list(text = "Date")) |> 
  hc_tooltip(pointFormat = "Value: ${point.y:,.0f}") |> 
  hc_add_theme(hc_theme_smpl())
# Portfolio returns (continous returns)
hchart(portfolio, type = "line", hcaes(x = date, y = continuous_return)) |> 
  hc_title(text = "Portfolio Returns Over Time") |> 
  hc_yAxis(title = list(text = "Portfolio Return (%)")) |> 
  hc_xAxis(title = list(text = "Date")) |> 
  hc_tooltip(pointFormat = "Return: {point.y:.2f} %") |> 
  hc_add_theme(hc_theme_smpl())

This interactive visualization shows how the value of your equally weighted portfolio changes throughout sample period.

5. Buy-and-Hold Returns

Buy-and-hold returns represent the total return from buying a stock and holding it over a specified period, without any transactions in between.

Calculation

To calculate buy-and-hold returns:

buy_hold_returns <- portfolio |> 
  mutate(buy_hold_return = 100*(total_value / first(total_value) - 1),
         cumulative_return = cumsum(coalesce(discrete_return, 0)))

head(buy_hold_returns)
# A tibble: 6 × 6
  date       total_value discrete_return continuous_return buy_hold_return
  <date>           <dbl>           <dbl>             <dbl>           <dbl>
1 2023-01-03     999917.          NA                NA               0    
2 2023-01-04    1011080.           1.12              1.11            1.12 
3 2023-01-05    1004705.          -0.631            -0.633           0.479
4 2023-01-06    1033481.           2.86              2.82            3.36 
5 2023-01-09    1039950.           0.626             0.624           4.00 
6 2023-01-10    1049662.           0.934             0.930           4.97 
# ℹ 1 more variable: cumulative_return <dbl>

6. Portfolio Comparison: Equally Weighted Portfolio vs. 100% NVDA Portfolio

Let’s compare our equally weighted portfolio against a portfolio fully invested in NVDA.

# NVDA only portfolio: see how many shares we can purchase at most
nvda_only_position <- prices |> 
  filter(symbol == "NVDA", date == min(date)) |> 
  mutate(shares = floor(budget / adjusted)) |> 
  select(symbol, shares)
# Hold such shares of Nvdia
nvda_portfolio <- prices |> 
  filter(symbol == "NVDA") |> 
  inner_join(nvda_only_position, by = "symbol") |> 
  mutate(total_value = shares * adjusted) |> 
  select(date, nvda_only = total_value)

# Combine both portfolios for comparison
combined_portfolios <- portfolio |> 
  select(date, equally_weighted = total_value) |> 
  inner_join(nvda_portfolio, by = "date")

head(combined_portfolios)
# A tibble: 6 × 3
  date       equally_weighted nvda_only
  <date>                <dbl>     <dbl>
1 2023-01-03          999917.   999999.
2 2023-01-04         1011080.  1030317.
3 2023-01-05         1004705.   996507.
4 2023-01-06         1033481.  1038002.
5 2023-01-09         1039950.  1091721.
6 2023-01-10         1049662.  1111351.

Visualization of Both Portfolios

combined_portfolios_long <- combined_portfolios |> 
  pivot_longer(cols = c(equally_weighted, nvda_only), names_to = "Portfolio", values_to = "Value")

hchart(combined_portfolios_long, "line", hcaes(x = date, y = Value, group = Portfolio)) |> 
  hc_title(text = "Equally Weighted vs. 100% NVDA Portfolio") |> 
  hc_yAxis(title = list(text = "Portfolio Value ($)")) |> 
  hc_xAxis(title = list(text = "Date")) |> 
  hc_tooltip(pointFormat = "{series.name}: ${point.y:,.0f}") |> 
  hc_add_theme(hc_theme_smpl())

Exercises

  1. Suppose we use the following portfolio weights: XOM (20%), WMT (30%), NVDA (30%), and AAPL (20%).

    • Recalculate how many shares you would purchase initially.
    • Compute and visualize the portfolio value and returns.

  2. Change the budget to $500,000 and use portfolio weights: XOM (25%), WMT (25%), NVDA (25%), and AAPL (25%).

    • Recalculate the shares purchased, portfolio value, and returns.
    • Provide an interactive visualization for this scenario.

Happy coding! 🚀 This version will be continuously updated.

Back to top