I’m in the thick of our annual portfolio investment due diligence at work. Basically, this involves surveying all the potential investments we could hold in our portfolios, and then deciding whether we should continue to hold what we own or switch to something else. It is a big job, involving lots of data analysis.

I forget how much I rely on the PerformanceAnalytics package to help me tell the data’s story. It really is an all-in-one package for any quantitative analysis. I’d like to give you a rough-and-tumble of just some of its features.

To start, let’s load two libraries, and gather some data:

library(quantmod)
library(PerformanceAnalytics)

# List some ETFs to run our mock-analysis on.
symbols=c("IVV", "GLD", "VBR", "VWO", "VTI", "DBC")
getSymbols( symbols )

I’ve pulled several different symbols for two main reasons. (1) We need multiple data sets to really understand what this puppy can do, and (2) I’d like to demonstrate how to run analysis en masse.

The code block above will pull OHLC+Volume+Adjusted Close data for each symbol. We need to convert that structure to monthly returns. So,

for(i in 1:length(symbols)){ # Iterate through each symbol
  etf = get( symbols[i] ) # Set up temp variable to store data from symbol
  etf = etf[xts:::startof( etf, "months" )] # Convert to monthly structure
  chg = Delt( etf[,6], k=1 ) # Convert to monthly return
  assign( # Assign a unique variable name to this data set: <ticker>.r
    paste( symbols[i], ".r", sep="" ),
    chg
  )
}

Note that for loops are somewhat frowned upon in R. For my purposes, I haven’t had any trouble with them, so until I do, I keep using them! Okay, we now have return data for each symbol. We will call these variables later!

Now that we have data in the format we want, let’s move on to our first demonstration.

Correlation Visualizations
Portfolio management is, at heart, understanding how assets relate to one another. Understanding these relationships can be made easier through visualizations, of which there are few better than the chart.Correlation() function. First, we need our return data in a tidy data frame structure. I do this with the merge() command. Also, you can see how I’ve used the get() and paste() commands to call my custom variables.

return.data = merge( # Set up the data.frame
  IVV.r,
  GLD.r
)
# I've already included symbols[1] & [2], so this iterates through the rest
for(i in 3:length(symbols)){ 
  return.data = merge( return.data, get( paste( symbols[i], ".r", sep="" ) ) )
}
colnames(return.data) = symbols # Make column names the ticker

And we are ready to use the correlation viz tool!

chart.Correlation( return.data )

Which yields the very sexy plot below.

Other than its sexiness, this plot is very helpful. The diagonal gives you the return distribution of each ETF. I like to see how the returns are distributed—are the concentrated in the center? are there lots of outliers? are they heavily skewed? is something just weird? Indeed, this plot recently helped me immediately throw out a position under consideration because the distribution was barbelled (but more heavy left-tailed).

On the lower half, we have the returns of the column-row ETFs plotted against each other. This helps us understand how and when the two positions move with respect to each other. Some positions I like to have a strong linear relationship—say IVV (large cap) and VBR (small cap). Others should serve to offset losses and be strong diversifiers in a portfolio—say IVV (large cap) and GLD (gold). Sometimes, you can find a good replacement position, VTI, for example, which moves in lock-step with IVV. If we find in later analysis that VTI offers a better risk/return profile, we could consider swapping IVV for VTI.

On the top half, we have the traditional correlation metric with its significance level (the asterisks). Honestly, this is the least helpful part of the plot though it can help sum up the other two data points we just reviewed. Ultimately, this is typically the number that feeds into a portfolio optimizer, so it is important. I’d argue, however, that one should use our other observations as primary filters.

Upside/Downside Capture
Another helpful plot is the upside/downside capture. This visualizes the percentage of upside and downside captured by a position relative to a benchmark. Let’s analyze these relative to IVV, our mock core position.

Let’s have R open a new window, then arrange the plots in a 2×3 grid. We will fill the grid with a loop, iterating through each ETF. It looks like this:

dev.new() # Open new plot window
par(mfrow=c(2,3)) # Arrange plots in a 2-row, 3-column grid
for(i in 1:length(symbols)){ # Iterate through each ETF
  etf = get( paste( symbols[i], ".r", sep="" ) )
  bmark = IVV.r # Ratio relative to IVV's return
  colnames( bmark ) = "IVV" # Header on data as IVV
  colnames( etf ) = symbols[i] # Header on data as the ticker
  chart.CaptureRatios(etf, bmark, colorset="dodgerblue4", 
    main=paste(symbols[i]))
}

This block yields the Upside/Downside capture ratios for our ETFs:

Note that we could (and should) use a benchmark return as a comparison, but I’m just showing you the ropes here.

Return Distributions
Also helpful are the return distribution visualizations available. Let’s say, for example, I want to understand how non-normal a given asset’s returns are, and I’d like to get a sense of it’s Value at Risk (VaR). We can quickly build some visualizations with the following code:

dev.new() # new Plot
par(mfrow=c(2,3)) # arrange plots in a 2x3 grid
for(i in 1:length(symbols)){ # iterate through each symbol
  etf = get( paste( symbols[i], ".r", sep="" ) ) # load data into temp variable
  colnames( etf ) = symbols[i] # data header as the ticker
  chart.Histogram( etf, main=paste(symbols[i], " Return Distribution"), 
    breaks=15, methods=c("add.normal", "add.risk"), # Add the normal curve, and the VaR levels
    colorset=c("steelblue", "darkgreen", "navy") # colors for each (middle color not used)
  )
}

In this block, we have iterated through each ticker, then plotted the return histogram. In addition, I’ve told R to include a normal curve for comparison (it will auto-calculate the mean and standard deviation of the distribution) and the VaR levels. All of that yields this plot:

We can see, quite clearly, that none of these returns are statistically normal, but that shouldn’t be too big a surprise. Also, the vertical dashed lines show us the VaR levels. This is a good way to filter out core strategies from more binary strategies.

Drawdowns
Finally, let’s look at the drawdown plot. This is helpful to get a sense of a fund’s…you guessed it…drawdowns. Just to clarify, a drawdown plot looks at only downward movement relative to a high; it is not a view of the full performance. These visualizations are helpful to compare funds through stressful times, how they perform, and how the recover.

We follow a similar coding pattern as before.

dev.new()
par(mfrow=c(2,3))
for(i in 1:length(symbols)){
  etf = get( paste( symbols[i], ".r", sep="" ) )
  colnames( etf ) = symbols[i]
  chart.Drawdown( etf, geometric=TRUE, colorset="firebrick4" )
}

Which yields

Closing
These are just a few of the capabilities of the PerformanceAnalytics package. Indeed, this is just a few of the visualization tools, there are many more functions which are helpful. The documentation is 200+ pages of quantitative awesomeness.

After quantmod, this is my favorite quantitative package. It can easily serve as the quantitative toolbox for an investor.