Financial Trading in R

1 Trading basics

https://quantstrattrader.wordpress.com/

1.1 Why do people trade?

1.1.1 Identifying types of trading philosophies

Hello and welcome to Financial Trading in R! This course will teach you how to construct a basic trading strategy in quantstrat, R’s industrial-strength backtesting platform developed by Brian Peterson, Director of Algorithmic Trading at DV Trading. Over the next few chapters, you’ll build a trading strategy in quantstrat from start to finish, including the code to set up a new strategy, as well as the design of indicators, signals, and rules for your strategy. By the end of the course, you’ll be ready to design and implement your own trading strategies directly in R!

quantstrat is currently only available on GitHub. If you want to install it on your own machine, you first need to remotes package.

install.packages("remotes")

Then you can install quantstrat using

remotes::install_github("braverock/quantstrat")

“Introduction to Quantitative Trading With R.”

**Above doesnt seem to work, you can do the below**

1. download package from github (blotter and quantstrat)
2. Open command line
3. build packages using R CMD BUILD
4. install packages using R CMD INSTALL

Before getting into the meat and potatoes of the course, let’s review some phrases and mechanics you may have heard in the world of financial trading, or even in pop culture. As you learned in the video, the mechanics of trading usually come in one of two forms:

• Trend trading (also divergence or momentum), which is a bet that a quantity, such as a price, will keep moving in its current direction.
• Reversion trading (also convergence, cycle, or oscillation), which is a bet that a quantity, such as a price, will reverse. “Buying the dip” can refer to both trend trading and reversion trading.

library(blotter)

Loading required package: xts
package 㤼㸱xts㤼㸲 was built under R version 4.0.3Loading required package: zoo
package 㤼㸱zoo㤼㸲 was built under R version 4.0.3
Attaching package: 㤼㸱zoo㤼㸲

The following objects are masked from 㤼㸱package:base㤼㸲:

    as.Date, as.Date.numeric

Loading required package: FinancialInstrument
package 㤼㸱FinancialInstrument㤼㸲 was built under R version 4.0.3Loading required package: quantmod
package 㤼㸱quantmod㤼㸲 was built under R version 4.0.3Loading required package: TTR
package 㤼㸱TTR㤼㸲 was built under R version 4.0.3Registered S3 method overwritten by 'quantmod':
  method            from
  as.zoo.data.frame zoo 
Version 0.4-0 included new data defaults. See ?getSymbols.
Loading required package: PerformanceAnalytics
package 㤼㸱PerformanceAnalytics㤼㸲 was built under R version 4.0.3
Attaching package: 㤼㸱PerformanceAnalytics㤼㸲

The following object is masked from 㤼㸱package:graphics㤼㸲:

    legend

library(foreach)

package 㤼㸱foreach㤼㸲 was built under R version 4.0.3

library(quantstrat)

1.2 Pitfalls of various trading systems

1.2.1 How to prevent overfitting

When developing a trading system, a major pitfall that can creep into system development is the desire to find a strategy that worked phenomenally in the past. This is known as overfitting. Research by leading authors in the quantitative field has shown that not only is an overfitted system unlikely to generate profits in the future, but also that its performance can lead to losses.

Overfitting can be reduced by:

• Examining the robustness of system performance.
• Reducing the number of parameters in the trading system.
• Conducting tests to determine statistical significance of a strategy.

1.3 Getting financial data

1.3.1 Plotting financial data

Trading strategies developed using quantstrat contain several characteristics, including indicators developed from market data, signals triggered by certain combinations of indicators, and rules acted on by certain signals. The first step in developing any trading system is to obtain market data, and maybe even examine how it looks.

The quantmod package has a function to obtain data from various sources. This is the getSymbols() command, which returns an object with the same name as the symbol.

You will obtain data for SPY, an exchange traded fund (ETF) that tracks the top 500 companies in the United States by market cap. This data is from Yahoo! Finance, which is a sufficient source of data for strategies that do not require instantaneous “see the close, buy the close” execution. You will then plot it and add a trendline to it.

For example, to obtain adjusted data for SPY in 2013 from Yahoo! Finance and then plot the maximum values traded each day, you would run the following code. Notice how only the first reference to the SPY data is enclosed in quotation marks.

getSymbols("SPY", 
           from = "2013-01-01",
           to = "2013-12-31",
           src = "yahoo",
           adjust = TRUE)
plot(Hi(SPY))

# Get SPY from yahoo
getSymbols("SPY", 
           from = "2000-01-01", 
           to = "2016-06-30", 
           src =  "yahoo", 
           adjust =  TRUE)

㤼㸱getSymbols㤼㸲 currently uses auto.assign=TRUE by default, but will
use auto.assign=FALSE in 0.5-0. You will still be able to use
㤼㸱loadSymbols㤼㸲 to automatically load data. getOption("getSymbols.env")
and getOption("getSymbols.auto.assign") will still be checked for
alternate defaults.

This message is shown once per session and may be disabled by setting 
options("getSymbols.warning4.0"=FALSE). See ?getSymbols for details.

incomplete final line found by readTableHeader on 'https://query2.finance.yahoo.com/v7/finance/download/SPY?period1=-2208988800&period2=1605139200&interval=1d&events=split&crumb=babpKD7rHPl'incomplete final line found by readTableHeader on 'https://query2.finance.yahoo.com/v7/finance/download/SPY?period1=-2208988800&period2=1605139200&interval=1d&events=split&crumb=babpKD7rHPl'

[1] "SPY"

# Plot the closing price of SPY
plot(Cl(SPY))

1.4 Adding indicators to financial data

1.4.1 Adding a moving average to financial data

One of the most popular indicators to add to a trading strategy is the 200-day simple moving average (SMA). This is a technical indicator of the average closing price of a stock over the past 200 days. Other moving averages can be of varying length, such as 50-day, 100-day, etc.

Whenever the price is above the 200-day moving average, a whole assortment of good things usually happen, such as the asset appreciating in price, low volatility, and so on. Getting a long-lasting visual might shed light on why this indicator is mentioned so often.

The TTR package has a function that calculates moving averages, SMA(), which takes in a price series x and computes the arithmetic mean over n days. A call of SMA() with a lookback window of 50 days could look like the following:

SMA(Cl(GDX), n = 50)

# Plot the closing prices of SPY
plot(Cl(SPY))

# Add a 200-day SMA using lines()
lines(SMA(Cl(SPY), n = 200), col = "red")

As you can see from your plot, indicators such as the 200-day SMA help you identify trends in your data.

2 A boilerplate for quantstrat strategies

2.1 Setting up a strategy I

2.1.1 Understanding initialization settings – Define boilerplate code

Let’s get started with creating our first strategy in quantstrat. In this exercise, you will need to fill in three dates:

• An initialization date for your backtest.
• The start of your data.
• The end of your data. The initialization date must always come before the start of the data, otherwise there will be serious errors in the output of your backtest.

You should also specify what time zone and currency you will be working with with the functions Sys.setenv() and currency(), respectively. An example is here:

Sys.setenv(TZ = "Europe/London")
currency("EUR")

You’ll use UTC (Coordinated Universal Time) and USD (United States Dollars) for your portfolio settings.

# Load the quantstrat package
library(quantstrat)

# Create initdate, from, and to strings
initdate <- "1999-01-01"
from <- "2003-01-01"
to <- "2015-12-31"

# Set the timezone to UTC
Sys.setenv(TZ = "UTC")

# Set the currency to USD 
currency("USD")

[1] "USD"

2.1.2 Understanding initialization settings – stock()

Like in the previous chapter, you will use getSymbols() to obtain the SPY data from Yahoo! Finance.

After importing the data, use stock() to tell quantstrat what instruments will be present for the simulation, and to treat them just as they are, as opposed to creating a minimum buy size, as with futures. Furthermore, this command specifies which currency to use with the given instruments. Note that whenever you use a function to initialize a data set such as GDX or SPY, you must enclose it in quotation marks:

stock("GDX", currency = "USD")

# Load the quantmod package
library(quantmod)

# Retrieve SPY from yahoo
getSymbols("SPY", from = from, to = to, src = "yahoo", adjust = TRUE)

incomplete final line found by readTableHeader on 'https://query1.finance.yahoo.com/v7/finance/download/SPY?period1=-2208988800&period2=1605139200&interval=1d&events=split&crumb=babpKD7rHPl'incomplete final line found by readTableHeader on 'https://query2.finance.yahoo.com/v7/finance/download/SPY?period1=-2208988800&period2=1605139200&interval=1d&events=split&crumb=babpKD7rHPl'

[1] "SPY"

# Use stock() to initialize SPY and set currency to USD
stock("SPY", currency = "USD")

[1] "SPY"

2.1.3 Understanding initialization settings - account, porfolio and strategy

Let’s continue the setup of your strategy. First, you will set a trade size of 100,000 USD in an object called tradesize which determines the amount you wager on each trade. Second, you will set your initial equity to 100,000 USD in an object called initeq.

Quantstrat requires three different objects to work: an account, a portfolio, and a strategy. An account is comprised of portfolios, and a portfolio is comprised of strategies. For your first strategy, there will only be one account, one portfolio, and one strategy. Let’s call them “firststrat” for “first strategy”.

Finally, before proceeding, you must remove any existing strategies using the strategy removal command rm.strat() which takes in a string of the name of a strategy.

# Define your trade size and initial equity
tradesize <- 100000
initeq <- 100000

# Define the names of your strategy, portfolio and account
strategy.st <- "firststrat"
portfolio.st <- "firststrat"
account.st <- "firststrat"

# Remove the existing strategy if it exists
rm.strat(strategy.st)

2.1.4 Understanding initialization settings – IV

Now that everything has been named, you must initialize the portfolio, the account, the orders, and the strategy to produce results.

• The portfolio initialization initPortf() needs a portfolio string name, a vector for symbols used in the backtest, an initialization date initDate, and a currency.
• The account initialization call initAcct() is identical to the portfolio initialization call except it takes an account string name instead of a new portfolio name, an existing portfolios name, and an initial equity initEq.
• The orders initialization initOrders() needs a portfolio string portfolio and an initialization date initDate.
• The strategy initialization strategy() needs a name of this new strategy and must have store set to TRUE.

# Initialize the portfolio
initPortf(portfolio.st, symbols = "SPY", initDate = initdate, currency = "USD")

[1] "firststrat"

# Initialize the account
initAcct(account.st, portfolios = portfolio.st, initDate = initdate, currency = "USD", initEq = initeq)

[1] "firststrat"

# Initialize the orders
initOrders(portfolio.st, initDate = initdate)

# Store the strategy
strategy(strategy.st, store = TRUE)

Your quantstrat strategy strategy.st is now up and running.

3 Indicators

3.1 Introduction

3.1.1 The SMA and RSI functions

Welcome to the chapter on indicators! An indicator is a transformation of market data that is used to generate signals or filter noise. Indicators form the backbone of many trading systems, and the system you will build in this course uses several of them.

The simple moving average (SMA) and relative strength index (RSI) are two classic indicators. The SMA is an arithmetic moving average of past prices, while the RSI is a bounded oscillating indicator that ranges from 0 to 100. Their respective functions SMA() and RSI() both take in a series of prices, denoted by x and price respectively, and a lookback period n, for example:

SMA(x = Cl(GDX), n = 50)
RSI(price = Cl(GDX), n = 50)

# Create a 200-day SMA
spy_sma <- SMA(x = Cl(SPY), n = 200)

# Create an RSI with a 3-day lookback period
spy_rsi <- RSI(price = Cl(SPY), n = 3)

3.1.2 Visualize an indicator and guess its purpose – SMA

Now you will visualize these indicators to understand why you might want to use the indicator and what it may represent. Recall that a trend indicator attempts to predict whether a price will continue in its current direction, whereas a reversion indicator attempts to predict whether an increasing price will soon decrease, or the opposite.

In this exercise, you will revisit the 200-day SMA. As a refresher, this indicator attempts to smooth out prices, but comes with a tradeoff - a lag. You will plot the prices of SPY and plot a 200-day SMA on top of the price series. Using this information, you will determine if it is a trend indicator or reversion indicator

# Plot the closing prices of SPY
plot(Cl(SPY))

# Overlay a 200-day SMA
lines(SMA(Cl(SPY), n = 200), col = "red")

# What kind of indicator?
print("trend")

[1] "trend"

By averaging over a moving period of 200 days, the SMA helps indicate a trend rather than a reversion.

3.1.3 Visualize an indicator and guess its purpose – RSI

The Relative Strength Index (RSI) is another indicator that rises with positive price changes and falls with negative price changes. It is equal to 100 - 100/(1 + RS), where RS is the average gain over average loss over the lookback period. At various lengths, this indicator can range from a reversion indicator, to a trend filter, or anywhere in between. There are various ways of computing the RSI.

As you already know, RSI() takes in a price series price and a number of periods n which has a default value of 14. Some traders believe that the 2-period RSI, also known as the RSI 2, has even more important properties than the 14-period RSI. Rather than plotting this indicator on the actual price series, you’ll look at a small, one year subset of SPY and how the RSI interacts with the price.

# Plot the closing price of SPY
plot(Cl(SPY))

# Plot the RSI 2
plot(RSI(Cl(SPY), n = 2))

# What kind of indicator?
print("reversion")

[1] "reversion"

By measuring the change of price movements, the RSI indicates a reversion rather than a trend.

3.2 Indicator mechanics

3.2.1 Implementing an indicator – SMA200

At this point, it’s time to start getting into the mechanics of implementing an indicator within the scope of the quantstrat library. In this exercise you will learn how to add an indicator to your strategy. For this exercise you will use the strategy you created in earlier exercises, strategy.st. For your first indicator, you will add a 200-day simple moving average. To add an indicator to your strategy, you will use the add.indicator(). Set strategy equal to the name of your strategy, name to the name of a function in quotes, and arguments to the arguments of the named function in the form of a list. For instance, if your function name was SMA, the arguments argument will contain the arguments to the SMA function:

add.indicator(strategy = strategy.st, 
              name = "SMA", 
              arguments = list(x = quote(Cl(mktdata)), n = 500), 
              label = "SMA500")

When referencing dynamic market data in your add.indicator() call, include mktdata inside the quote() function because it is created inside quantstrat and will change depending on whichever instrument the package is using at the time. quote() ensures that the data can dynamically change over the course of running your strategy.

#Add a 200-day SMA indicator to strategy.st
add.indicator(strategy = strategy.st, 
              
              # Add the SMA function
              name = "SMA", 
              
              # Create a lookback period
              arguments = list(x = quote(Cl(mktdata)), n = 200), 
              
              # Label your indicator SMA50
              label = "SMA200")

[1] "firststrat"

3.2.2 Implementing an indicator – SMA50

Now, you’ll make your strategy even more robust by adding a 50-day SMA. A fast moving average with a slower moving average is a simple and standard way to predict when prices in an asset are expected to rise in the future. While a single indicator can provide a lot of information, a truly robust trading system requires multiple indicators to operate effectively.

# Add a 50-day SMA indicator to strategy.st
add.indicator(strategy = strategy.st, 
              
              # Add the SMA function
              name = "SMA", 
              
              # Create a lookback period
              arguments = list(x = quote(Cl(mktdata)), n = 50), 
              
              # Label your indicator SMA50
              label = "SMA50")

[1] "firststrat"

By adding a second indicator to your strategy, you’ve made it more robust.

3.2.3 Implementing an indicator – RSI

In financial markets, the goal is to buy low and sell high. The RSI can predict when a price has sufficiently pulled back, especially with a short period such as 2 or 3.

Here, you’ll create a 3-period RSI, or RSI 3, to give you more practice in implementing pre-coded indicators.

# Add an RSI 3 indicator to strategy.st
add.indicator(strategy = strategy.st, 
              
              # Add the RSI 3 function
              name = "RSI", 
              
              # Create a lookback period
              arguments = list(price = quote(Cl(mktdata)), n = 3), 
              
              # Label your indicator RSI_3
              label = "RSI_3")

[1] "firststrat"

3.3 Indicator structure review

3.3.1 Code your own indicator – RSI 3.5

So far, you’ve used indicators that have been completely pre-written for you by using the add.indicator() function. Now it’s time for you to write and apply your own indicator.

Your indicator function will calculate the average of two different indicators to create an RSI of 3.5. Here’s how:

• Take in a price series.
• Calculate RSI 3.
• Calculate RSI 4.
• Return the average of RSI 3 and RSI 4.

This RSI can be thought of as an RSI 3.5, because it’s longer than an RSI 3 and shorter than an RSI 4. By averaging, this indicator takes into account the impact of four days ago while still being faster than a simple RSI 4, and also removes the noise of both RSI 3 and RSI 4.

You will create a function for this indicator called calc_RSI_avg() and add it to your strategy strategy.st. All relevant packages are also loaded for you.

# Write the calc_RSI_avg function
calc_RSI_avg <- function(price, n1, n2) {
  
  # RSI 1 takes an input of the price and n1
  RSI_1 <- RSI(price = price, n = n1)
  
  # RSI 2 takes an input of the price and n2
  RSI_2 <- RSI(price = price, n = n2)
  
  # RSI_avg is the average of RSI_1 and RSI_2
  RSI_avg <- (RSI_1 + RSI_2)/2
  
  # Your output of RSI_avg needs a column name of RSI_avg
  colnames(RSI_avg) <- "RSI_avg"
  return(RSI_avg)
}

# Add this function as RSI_3_4 to your strategy with n1 = 3 and n2 = 4
add.indicator(strategy.st, name = "calc_RSI_avg", arguments = list(price = quote(Cl(mktdata)), n1 = 3, n2 = 4), label = "RSI_3_4")

[1] "firststrat"

3.3.2 Code your own indicator – DVO

While the RSI is decent, it is somewhat outdated as far as indicators go. In this exercise, you will code a simplified version of another indicator from scratch. The indicator is called the David Varadi Oscillator (DVO), originated by David Varadi, a quantitative research director.

The purpose of this oscillator is similar to something like the RSI in that it attempts to find opportunities to buy a temporary dip and sell in a temporary uptrend. In addition to obligatory market data, an oscillator function takes in two lookback periods.

First, the function computes a ratio between the closing price and average of high and low prices. Next, it applies an SMA to that quantity to smooth out noise, usually on a very small time frame, such as two days. Finally, it uses the runPercentRank() function to take a running percentage rank of this average ratio, and multiplies it by 100 to convert it to a 0-100 quantity.

Think about the way that students get percentile scores after taking a standardized test (that is, if a student got an 800 on her math section, she might be in the 95th percentile nationally). runPercentRank() does the same thing, except over time. This indicator provides the rank for the latest observation when taken in the context over some past period that the user specifies. For example, if something has a runPercentRank value of .90 when using a lookback period of 126, it means it’s in the 90th percentile when compared to itself and the past 125 observations.

Your job is to implement this indicator and save it as DVO.

# Declare the DVO function
DVO <- function(HLC, navg = 2, percentlookback = 126) {
  
  # Compute the ratio between closing prices to the average of high and low
  ratio <- Cl(HLC)/(Hi(HLC) + Lo(HLC))/2
  
  # Smooth out the ratio outputs using a moving average
  avgratio <- SMA(ratio, n = navg)
  
  # Convert ratio into a 0-100 value using runPercentRank()
  out <- runPercentRank(avgratio, n = percentlookback, exact.multiplier = 1) * 100
  colnames(out) <- "DVO"
  return(out)
}

3.3.3 Apply your own indicator

Now you have a better understanding of indicators as functions that anyone can write. It’s time to apply the indicator you created in the previous exercise. To do so, you will make use of the applyIndicators() command.

From debugging to subsetting, knowing how to step inside your strategy is a valuable piece of knowledge. Every so often, you might have an error in your strategy, and will want to track it down. Knowing how to use the applyIndicators() command will help you identify your errors. Furthermore, sometimes you may want to look at a small chunk of time in your strategy. This exercise will help train you to do this as well.

In order to subset time series data, use brackets with the start date, forward slash symbol, and end date.

# Add the DVO indicator to your strategy
add.indicator(strategy = strategy.st, name = "DVO", 
              arguments = list(HLC = quote(HLC(mktdata)), navg = 2, percentlookback = 126),
              label = "DVO_2_126")

[1] "firststrat"

# Use applyIndicators to test out your indicators
test <- applyIndicators(strategy = strategy.st, mktdata = HLC(SPY))

# Subset your data between Sep. 1 and Sep. 5 of 2013
test_subset <- test["2013-09-01/2013-09-05"]

4 Signals

4.1 Introduction to signals

4.1.1 Signal or not? – I

A signal is an interaction of market data with indicators, or indicators with other indicators, which tells you whether you may wish to buy or sell an asset. Signals can be triggered for a variety of reasons. For example, a signal may be triggered by a shorter lookback moving average going from less than to greater than a longer lookback moving average. Another signal may be triggered when an oscillator goes from being above a certain set quantity (for example, 20) to below, and so on.

In this chapter, you will see various ways in which indicators interact with each other. You will focus on the strategy you developed in the previous chapter (strategy.st). To keep thing simple, you will remove all of the RSI indicators and stick to the DVO (David Varadi’s Oscillator). sigThreshold is a signal threshold argument which assesses whether or not a value is above or below a certain static quantity.

4.2 sigComparison and sigCrossover

4.2.1 Using sigComparison

A sigComparison signal is a simple and useful way to compare two (hopefully related) quantities, such as two moving averages. Often, a sigComparison signal does not create a buy or sell signal by itself (as such a signal would involve buying or selling on every such day), but is most often useful as a filter for when another buy or sell rule should be followed.

In this exercise, you will use sigComparison() to generate a signal comparison that specifies that the 50-day simple moving average (SMA) must be above the 200-day simple moving average (SMA). You will label this signal longfilter, because it signals that the short-term average is above the long-term average.

# Add a sigComparison which specifies that SMA50 must be greater than SMA200, call it longfilter
add.signal(strategy.st, name = "sigComparison", 
           
           # We are interested in the relationship between the SMA50 and the SMA200
           arguments = list(columns = c("SMA50", "SMA200"), 
                            
                            # Particularly, we are interested when the SMA50 is greater than the SMA200
                            relationship = "gt"),
           
           # Label this signal longfilter
           label = "longfilter")

[1] "firststrat"

4.2.2 Using sigCrossover

While having a long filter is necessary, it is not sufficient to put on a trade for this strategy. However, the moment the condition does not hold, the strategy should not hold any position whatsoever. For this exercise, you will implement the opposite of the rule specified above using the sigCrossover() function.

As opposed to sigComparison(), which will always state whether or not a condition holds, sigCrossover() only gives a positive the moment the signal first occurs, and then not again. This is useful for a signal that will be used to initiate a transaction, as you only want one transaction in most cases, rather than having transactions fire again and again.

In this case, you will implement the sigCrossover() function specifying that the SMA50 crosses under the SMA200. You will label this signal filterexit, as it will exit your position when the moving average filter states that the environment is not conducive for the strategy to hold a position.

# Add a sigCrossover which specifies that the SMA50 is less than the SMA200 and label it filterexit
add.signal(strategy.st, name = "sigCrossover",
           
           # We're interested in the relationship between the SMA50 and the SMA200
           arguments = list(columns = c("SMA50", "SMA200"),
                            
                            # The relationship is that the SMA50 crosses under the SMA200
                            relationship = "lt"),
           
           # Label it filterexit
           label = "filterexit")

[1] "firststrat"

4.3 sigThreshold

4.3.1 Using sigThreshold – threshold

In the next two exercises, you will focus on the sigThreshold signal. The sigThreshold signal is mainly used for comparing an indicator to a fixed number, which usually has applications for bounded oscillators, or perhaps rolling statistical scores (for example, for a trading strategy that might choose to go long when a ratio of mean to standard deviation is at -2, or vice versa). Whereas sigComparison and sigCrossover deal with quantities that are usually based off of an indicator that takes values in the same general area as prices, sigThreshold exists specifically to cover those situations outside the bounds of indicators that take values similar to prices.

Furthermore, the sigThreshold() function takes the cross argument, which specifies whether it will function similarly to sigComparison (cross = FALSE) or sigCrossover (cross = TRUE), respectively. In this exercise, you will implement a variant of sigThreshold that functions similarly to sigComparison.

Your job will be to implement a sigThreshold that checks whether or not DVO_2_126 is under 20. This signal will serve as one of the two switches that need to be “on” in order to enter into a long position in the strategy.

# Implement a sigThreshold which specifies that DVO_2_126 must be less than 20, label it longthreshold
add.signal(strategy.st, name = "sigThreshold", 
           
           # Use the DVO_2_126 column
           arguments = list(column = "DVO_2_126", 
                            
                            # The threshold is 20
                            threshold = 20, 
                            
                            # We want the oscillator to be under this value
                            relationship = "lt", 
                            
                            # We're interested in every instance that the oscillator is less than 20
                            cross = FALSE), 
           
           # Label it longthreshold
           label = "longthreshold")

[1] "firststrat"

4.3.2 Using sigThreshold() – exit

In this exercise, you will implement a signal to exit a position given a certain threshold value of the DVO. While there are two entry signals that are both necessary but neither sufficient on its own, the two exit signals (this one and the one you implemented in an earlier exercise) are both sufficient on their own (but neither necessary in the existence of the other) to exit a position.

In this exercise, you will again use sigThreshold(), this time counting when the DVO_2_126 crosses above a threshold of 80. To mimic a sigCrossover signal, set cross equal to TRUE Label this signal thresholdexit.

# Add a sigThreshold signal to your strategy that specifies that DVO_2_126 must cross above 80 and label it thresholdexit
add.signal(strategy.st, name = "sigThreshold", 
           
           # Reference the column of DVO_2_126
           arguments = list(column = "DVO_2_126", 
                            
                            # Set a threshold of 80
                            threshold = 80, 
                            
                            # The oscillator must be greater than 80
                            relationship = "gt", 
                            
                            # We are interested only in the cross
                            cross = TRUE), 
           
           # Label it thresholdexit
           label = "thresholdexit")

[1] "firststrat"

4.4 sigFormula

4.4.1 Using sigFormula()

The last signal function is a bit more open-ended. The sigFormula() function uses string evaluation to offer immense flexibility in combining various indicators and signals you already added to your strategy in order to create composite signals. While such catch-all functionality may seem complicated at first, with proper signal implementation and labeling, a sigFormula signal turns out to be the simplest of logical programming statements encapsulated in some quantstrat syntactical structuring.

# Create your dataset: test
test_init <- applyIndicators(strategy.st, mktdata = OHLC(SPY))
test <- applySignals(strategy = strategy.st, mktdata = test_init)

4.4.2 Combining signals – longfilter & longthreshold

you created a dataset test containing information about whether longfilter is equal to 1 AND longthreshold is equal to 1.

Next, you’ll want to create a signal when BOTH longfilter and longthreshold are equal to 1. Have a look at test on October 8, 2013. Are longfilter and longthreshold both equal to 1 on that date?

test["2013-10-08"]

           SPY.Open SPY.High  SPY.Low SPY.Close SMA.SMA200 SMA.SMA50 rsi.RSI_3 RSI_avg.RSI_3_4
2013-10-08 160.0033 160.2136 158.0535  158.1682   151.4826  160.0628   17.8146        19.85266
           DVO.DVO_2_126 longfilter filterexit longthreshold thresholdexit
2013-10-08      3.174603          1         NA             1             0

print("longfilter = 1, longthreshold = 1")

[1] "longfilter = 1, longthreshold = 1"

4.4.3 Combining signals – longentry

In the previous exercise, you approximated a sigFormula signal by comparing the value of two other signals. In this final exercise, you will take this one step futher by using the sigFormula() function to generate a sigFormula signal.

The goal of this exercise is simple. You want to enter into a position when both longfilter and longthreshold become true at the same time. The idea is this: You don’t want to keep entering into a position for as long as conditions hold true, but you do want to hold a position when there’s a pullback in an uptrending environment.

Writing a sigFormula function is as simple as writing the argument of an “if statement” in base R inside the formula() function. In this case, you want to create a signal labeled longentry, which is true when both longfilter and longthreshold cross over to true at the same time.

# Add a sigFormula signal to your code specifying that both longfilter and longthreshold must be TRUE, label it longentry
add.signal(strategy.st, name = "sigFormula",
           
           # Specify that longfilter and longthreshold must be TRUE
           arguments = list(formula = "longfilter & longthreshold", 
                            
                            # Specify that cross must be TRUE
                            cross = TRUE),
           
           # Label it longentry
           label = "longentry")

[1] "firststrat"

5 Rules

5.1 Introduction to rules

5.1.1 Using add.rule() to implement an exit rule

While rules in quantstrat can become very complex, this chapter will fill in many of the details for you to help you develop an understanding of the actual mechanics of rules. Rules are the final mechanic in the trinity of quantstrat mechanics – indicators, signals, and rules. Rules are a way for you to specify exactly how you will shape your transaction once you decide you wish to execute on a signal.

Throughout this chapter, you will continue working the strategy developed in earlier chapters (strategy.st). Given that there are three rules to the strategy (two exit rules and one entry rule), there will be a handful of exercises to build up some intuition of the mechanics of rules.

This exercise will introduce you to the add.rule() function, which allows you to add customized rules to your strategy.

# Fill in the rule's type as exit
add.rule(strategy.st, name = "ruleSignal", 
         arguments = list(sigcol = "filterexit", sigval = TRUE, orderqty = "all", 
                        ordertype = "market", orderside = "long", 
                        replace = FALSE, prefer = "Open"), 
         type = "exit")

[1] "firststrat"

5.1.2 Specifying sigcol in add.rule()

Although the add.rule() command looks complex, each argument is quite simple. To understand this command, you will explore each argument individually.

First, add.rule() takes the argument sigcol, which specifies the signal column in your strategy. Like signals and indicators, all rules reference a column already present in your strategy. Rules relies on signals, and must therefore reference the signal columns in your strategy.

In this exercise, you will supply the add.rule() call with the sigcol value, which will be set to filterexit (to reference the filterexit signal you created in the previous chapter). Specifically, the filterexit signal refers to the condition that the 50 day SMA has crossed under the 200 day SMA in your strategy. By creating a rule for this signal, you will be indicating that you wish to exit in this condition, as the market environment is no longer conducive to your position.

sigcol = "filterexit"

5.1.3 Specifying sigval in add.rule()

Now that you’ve specified the column containing the relevant signal in your strategy, the next argument to specify in add.rule() is sigval, or the value that your signal should take to trigger the rule.

Remember that all signal outputs are either 1s or 0s. Effectively, a signal is either “on” or “off” at any given time. For our purposes, this is equivalent to two possible logical values: TRUE or FALSE. When specifying sigval in your add.rule() command, you need to indicate whether the rule is triggered when the signal value is TRUE or FALSE.

To proceed with the new exit rule in your strategy, you will want to specify that a transaction should occcur when filterexit is equal to TRUE.

sigval = TRUE

sigval tells your rule which value to look for in your signal in order to act.

5.2 More rule mechanics

5.2.1 Specifying orderqty in add.rule()

Now that you have a grasp of the first set of arguments in the add.rule() function, it’s time to move on to the more important arguments: the actual order being bought or sold! The orderqty argument in the ruleSignal specifies exactly how much of an asset you want to buy or sell, in numbers of shares.

However, one salient feature of the exit rule type is that you can reduce your position to zero instantly with the all argument (hence, exiting).

orderqty = "all"

Remember that the orderqty argument can also take numerical values to indicate the number of shares being bought or sold.

5.2.2 Specifying ordertype in add.rule()

To this point you’ve specified the signal column, signal value, and order quantity associated with your rule. Next you will specify the type of order you will execute (ordertype).

While there are multiple types of orders in quantstrat, for the scope of this course you will stick to market orders (ordertype = “market”). A market order is an order that states that you will buy or sell the asset at the prevailing price, regardless of the conditions in the market. An alternative type of orders is a limit order, which specifies that the transaction will only take place if certain price conditions are met (namely, if the price falls below a certain further threshold on the day of the order).

ordertype = "market"

It is important to specify ordertype for your strategy to function properly.

5.2.3 Specifying orderside in add.rule()

The next critical argument to specify in your order is orderside, which can take two values: either long or short. In quantstrat, long and short side trades are siloed off separately so that quantstrat knows whether a trade is a long trade or a short trade. A long trade is one that profits by buying an asset in the hopes that the asset’s price will rise. A short trade is one that sells an asset before owning it, hoping to buy it back later at a lower price.

For your strategy, you will want to take only long orders.

orderside = "long"

5.2.4 Specifying replace in add.rule()

In quantstrat, the replace argument specifies whether or not to ignore all other signals on the same date when the strategy acts upon one signal. This is generally not a desired quality in a well-crafted trading system. Therefore, for your exit rule, you should set replace to FALSE.

Furthermore, you will be working with a new rule. Previously, the exit rule you worked with was when the market environment was no longer conducive to a trade. In this case, you will be working with a rule that sells when the DVO has crossed a certain threshold. In particular, you will be working with the thresholdexit rule now.

replace = FALSE

5.2.5 Specifying prefer in add.rule()

Lastly, of the basic rule arguments, there is the aspect of the prefer argument. In quantstrat, orders have a “next-bar” mechanism. That is, if you would gain a signal on Tuesday, the earliest that a position would actually fulfil itself would be on the Wednesday after. However, this can be solved by placing orders to execute on the next possible opening price, rather than wait for an entire day to pass before being able to actually purchase/sell the asset.

prefer = "Open"

The prefer argument is the final critical argument to specify to make sure your rule works properly.

5.2.6 Using add.rule() to implement an entry rule

You’ve mastered every element of the rule building process in quantstrat. While thus far you’ve added rules step-by-step, now it’s time to put it all together and see how well you’ve been able to absorb the material in this chapter.

The opposite of an exit rule is an enter rule. On enter rules, orderqty cannot be set to “all” because there is no initial position on which to act. In this exercise, you will implement an enter rule that references the longentry signal in your strategy and will buy one share of an asset.

# Create an entry rule of 1 share when all conditions line up to enter into a position
add.rule(strategy.st, name = "ruleSignal", 
         
         # Use the longentry column as the sigcol
         arguments=list(sigcol = "longentry", 
                        
                        # Set sigval to TRUE
                        sigval = TRUE, 
                        
                        # Set orderqty to 1
                        orderqty = 1,
                        
                        # Use a market type of order
                        ordertype = "market",
                        
                        # Take the long orderside
                        orderside = "long",
                        
                        # Do not replace other signals
                        replace = FALSE, 
                        
                        # Buy at the next day's opening price
                        prefer = "Open"),
         
         # This is an enter type rule, not an exit
         type = "enter")

[1] "firststrat"

5.3 Order sizing functions

5.3.1 Implementing a rule with an order sizing function

In quantstrat, the amount of an asset transacted may not always be a fixed quantity in regards to the actual shares. The constructs that allow quantstrat to vary the amount of shares bought or sold are called order sizing functions. Using a pre-coded order sizing function is straightforward. The first thing to know is that when using an order sizing function, the orderqty argument is no longer relevant, as the order quantity is determined by the order sizing function. Calling an order sizing function with your add.rule() call is fairly straightforward. The inputs for the order sizing function are mixed in with the rest of the inputs inside the arguments that you have been working with throughout this chapter. In this exercise, you will use the osFUN argument to specify a function called osMaxDollar. This is not passed in as a string, but rather as an object. The only difference is that the name of the order sizing function is not encased in quotes.

The additional arguments to this function are tradeSize and maxSize, both of which should take tradesize, which you defined several chapters earlier.

osMaxDollar <- function (data, timestamp, orderqty, ordertype, orderside, portfolio, 
    symbol, prefer = "Open", tradeSize, maxSize, integerQty = TRUE, 
    ...) 
{
    pos <- getPosQty(portfolio, symbol, timestamp)
    if (prefer == "Close") {
        price <- as.numeric(Cl(mktdata[timestamp, ]))
    }
    else {
        price <- as.numeric(Op(mktdata[timestamp, ]))
    }
    posVal <- pos * price
    if (orderside == "short") {
        dollarsToTransact <- max(tradeSize, maxSize - posVal)
        if (dollarsToTransact > 0) {
            dollarsToTransact = 0
        }
    }
    else {
        dollarsToTransact <- min(tradeSize, maxSize - posVal)
        if (dollarsToTransact < 0) {
            dollarsToTransact = 0
        }
    }
    qty <- dollarsToTransact/price
    if (integerQty) {
        qty <- trunc(qty)
    }
    return(qty)
}

# Add a rule that uses an osFUN to size an entry position
add.rule(strategy = strategy.st, name = "ruleSignal",
         arguments = list(sigcol = "longentry", sigval = TRUE, ordertype = "market",
                          orderside = "long", replace = FALSE, prefer = "Open",
                          
                          # Use the osFUN called osMaxDollar
                          osFUN = osMaxDollar,
                          
                          # The tradeSize argument should be equal to tradesize (defined earlier)
                          tradeSize = tradesize,
                          
                          # The maxSize argument should be equal to tradesize as well
                          maxSize = tradesize),
         type = "enter")

[1] "firststrat"

Implementing a rule with an order size function allows much more flexibility than a standard set rule.

6 Analyzing results

6.1 Analyzing your strategy

6.1.1 Running your strategy

To review, your strategy uses three separate indicators and five separate signals. The strategy requires both the threshold of the DVO_2_126 indicator to be under 20 and the SMA50 to be greater than the SMA200. The strategy sells when the DVO_2_126 crosses above 80, or the SMA50 crosses under the SMA200.

For this strategy to work properly, you specified five separate signals:

1. sigComparison for SMA50 being greater than SMA200;
2. sigThreshold with cross set to FALSE for DVO_2_126 less than 20;
3. sigFormula to tie them together and set cross to TRUE;
4. sigCrossover with SMA50 less than SMA200; and
5. sigThreshold with cross set to TRUE for DVO_2_126 greater than 80.

The strategy invests $100,000 (your initeq) into each trade, and may have some small dollar cost averaging if the DVO_2_126 oscillates around 20 (though the effect is mostly negligible compared to the initial allocation).

# Use applyStrategy() to apply your strategy. Save this to out
out <- applyStrategy(strategy = strategy.st, portfolios = portfolio.st)

[1] "2003-11-04 00:00:00 SPY 1 @ 82.8469578360576"
[1] "2003-11-04 00:00:00 SPY 1209 @ 82.8469578360576"
[1] "2003-11-11 00:00:00 SPY 1 @ 82.1434723265441"
[1] "2003-11-17 00:00:00 SPY 1 @ 82.0027817904916"
[1] "2003-11-19 00:00:00 SPY 1 @ 81.3149269126141"
[1] "2003-11-19 00:00:00 SPY 3 @ 81.3149269126141"
[1] "2003-12-04 00:00:00 SPY 1 @ 83.7693034544295"
[1] "2003-12-17 00:00:00 SPY 1 @ 84.4649709123541"
[1] "2004-01-26 00:00:00 SPY 1 @ 89.8352933883476"
[1] "2004-01-29 00:00:00 SPY 1 @ 89.1834585776171"
[1] "2004-02-05 00:00:00 SPY 1 @ 88.8771751199046"
[1] "2004-02-17 00:00:00 SPY 1 @ 90.9818922139293"
[1] "2004-02-20 00:00:00 SPY 1 @ 90.691319526913"
[1] "2004-03-04 00:00:00 SPY 1 @ 90.8798000840517"
[1] "2004-03-09 00:00:00 SPY 1 @ 90.3928855644821"
[1] "2004-03-23 00:00:00 SPY 1 @ 86.8875112703844"
[1] "2004-04-14 00:00:00 SPY 1 @ 88.7474170616372"
[1] "2004-04-21 00:00:00 SPY 1 @ 88.4242948197242"
[1] "2004-04-29 00:00:00 SPY 1 @ 88.8341075490725"
[1] "2004-05-10 00:00:00 SPY 1 @ 86.2491556209151"
[1] "2004-05-20 00:00:00 SPY 1 @ 86.2570326338416"
[1] "2004-06-07 00:00:00 SPY 1 @ 89.393654452605"
[1] "2004-06-22 00:00:00 SPY 1 @ 89.4826721872208"
[1] "2004-06-28 00:00:00 SPY 1 @ 90.5821234171208"
[1] "2004-07-06 00:00:00 SPY 1 @ 88.8815381310937"
[1] "2004-07-16 00:00:00 SPY 1 @ 88.248758071904"
[1] "2004-07-22 00:00:00 SPY 1 @ 86.5007105045458"
[1] "2004-08-06 00:00:00 SPY 1 @ 85.1323255940912"
[1] "2004-08-26 00:00:00 SPY -1238 @ 87.7662642951484"
[1] "2004-11-11 00:00:00 SPY 1 @ 93.0719232673771"
[1] "2004-11-11 00:00:00 SPY 1075 @ 93.0719232673771"
[1] "2004-11-30 00:00:00 SPY 1 @ 94.0009737487592"
[1] "2004-12-06 00:00:00 SPY 1 @ 94.9648812422764"
[1] "2004-12-08 00:00:00 SPY 1 @ 94.1682628206767"
[1] "2004-12-28 00:00:00 SPY 1 @ 96.5580225549442"
[1] "2005-01-03 00:00:00 SPY 1 @ 97.2943727284263"
[1] "2005-01-21 00:00:00 SPY 1 @ 94.2769368997169"
[1] "2005-02-10 00:00:00 SPY 1 @ 95.7736526933884"
[1] "2005-02-23 00:00:00 SPY 1 @ 95.1893710017315"
[1] "2005-03-10 00:00:00 SPY 1 @ 97.006234590446"
[1] "2005-03-17 00:00:00 SPY 1 @ 95.4935143684339"
[1] "2005-03-23 00:00:00 SPY 1 @ 93.9722829469485"
[1] "2005-04-04 00:00:00 SPY 1 @ 94.3017315393874"
[1] "2005-04-12 00:00:00 SPY 1 @ 94.7275983482366"
[1] "2005-04-15 00:00:00 SPY 1 @ 93.0000181217213"
[1] "2005-04-21 00:00:00 SPY 1 @ 92.2366714849296"
[1] "2005-05-16 00:00:00 SPY 1 @ 92.9678763056753"
[1] "2005-06-09 00:00:00 SPY 1 @ 96.2141193737957"
[1] "2005-06-24 00:00:00 SPY 1 @ 96.7153856513278"
[1] "2005-07-01 00:00:00 SPY 1 @ 96.3684752670201"
[1] "2005-08-08 00:00:00 SPY 1 @ 99.3535221425788"
[1] "2005-08-18 00:00:00 SPY 1 @ 98.4660777801881"
[1] "2005-08-26 00:00:00 SPY 1 @ 98.0062198288965"
[1] "2005-09-14 00:00:00 SPY 1 @ 99.829512233509"
[1] "2005-09-21 00:00:00 SPY 1 @ 98.6745715803002"
[1] "2005-10-05 00:00:00 SPY 1 @ 98.2370613833183"
[1] "2005-10-11 00:00:00 SPY 1 @ 96.406001958985"
[1] "2005-10-24 00:00:00 SPY 1 @ 95.9603937873348"
[1] "2005-10-28 00:00:00 SPY 1 @ 95.9522901412486"
[1] "2005-11-02 00:00:00 SPY 1 @ 97.3620409893546"
[1] "2005-11-30 00:00:00 SPY 1 @ 102.215159233548"
[1] "2005-12-08 00:00:00 SPY 1 @ 102.263768957027"
[1] "2005-12-19 00:00:00 SPY 1 @ 103.221266810963"
[1] "2005-12-28 00:00:00 SPY 1 @ 102.414910243219"
[1] "2006-01-03 00:00:00 SPY 1 @ 101.966939892734"
[1] "2006-01-23 00:00:00 SPY 1 @ 102.797724868596"
[1] "2006-02-01 00:00:00 SPY 1 @ 104.109066609722"
[1] "2006-02-06 00:00:00 SPY 1 @ 102.985061730178"
[1] "2006-02-09 00:00:00 SPY 1 @ 103.376017257767"
[1] "2006-03-01 00:00:00 SPY 1 @ 104.744379523272"
[1] "2006-03-07 00:00:00 SPY 1 @ 104.141647323017"
[1] "2006-03-22 00:00:00 SPY 1 @ 105.905045203611"
[1] "2006-04-10 00:00:00 SPY 1 @ 106.093132767411"
[1] "2006-05-15 00:00:00 SPY 1 @ 105.31627331495"
[1] "2006-05-18 00:00:00 SPY 1 @ 104.138736897255"
[1] "2006-05-24 00:00:00 SPY 1 @ 102.773118639915"
[1] "2006-06-06 00:00:00 SPY 1 @ 104.024254610205"
[1] "2006-06-08 00:00:00 SPY 1 @ 102.691346629112"
[1] "2006-06-13 00:00:00 SPY 1 @ 101.186708266684"
[1] "2006-06-20 00:00:00 SPY 1 @ 101.855723704104"
[1] "2006-07-14 00:00:00 SPY 1 @ 101.9542817024"
[1] "2006-07-24 00:00:00 SPY 1 @ 102.208904580536"
[1] "2006-07-26 00:00:00 SPY -1127 @ 103.974804034594"
[1] "2006-10-03 00:00:00 SPY 1 @ 109.629354814303"
[1] "2006-10-03 00:00:00 SPY 907 @ 109.629354814303"
[1] "2006-11-02 00:00:00 SPY 1 @ 112.61571818925"
[1] "2006-11-28 00:00:00 SPY 1 @ 114.042912722695"
[1] "2006-12-08 00:00:00 SPY 1 @ 116.427056283516"
[1] "2006-12-19 00:00:00 SPY 1 @ 117.424163570766"
[1] "2006-12-22 00:00:00 SPY 1 @ 117.498820616338"
[1] "2007-01-03 00:00:00 SPY 1 @ 118.004852800614"
[1] "2007-01-18 00:00:00 SPY 1 @ 118.768045971558"
[1] "2007-01-26 00:00:00 SPY 1 @ 118.270317678858"
[1] "2007-02-13 00:00:00 SPY 1 @ 119.265786707653"
[1] "2007-02-27 00:00:00 SPY 1 @ 119.357039092981"
[1] "2007-03-06 00:00:00 SPY 1 @ 115.126280166357"
[1] "2007-03-09 00:00:00 SPY 1 @ 117.225065119473"
[1] "2007-03-14 00:00:00 SPY 1 @ 114.835929329737"
[1] "2007-03-19 00:00:00 SPY 1 @ 115.982674771383"
[1] "2007-05-01 00:00:00 SPY 1 @ 123.611582476384"
[1] "2007-05-11 00:00:00 SPY 1 @ 124.719274526864"
[1] "2007-05-16 00:00:00 SPY 1 @ 125.59376943445"
[1] "2007-05-23 00:00:00 SPY 1 @ 127.384391751092"
[1] "2007-06-07 00:00:00 SPY 1 @ 126.22673120436"
[1] "2007-06-13 00:00:00 SPY 1 @ 125.34391196189"
[1] "2007-06-19 00:00:00 SPY 1 @ 127.598848330385"
[1] "2007-06-21 00:00:00 SPY 1 @ 126.36928142802"
[1] "2007-06-26 00:00:00 SPY 1 @ 125.64158324467"
[1] "2007-07-11 00:00:00 SPY 1 @ 126.093254719933"
[1] "2007-07-18 00:00:00 SPY 1 @ 129.004060836367"
[1] "2007-07-23 00:00:00 SPY 1 @ 128.962236352017"
[1] "2007-07-30 00:00:00 SPY 1 @ 122.061610471821"
[1] "2007-08-10 00:00:00 SPY 1 @ 120.773498659489"
[1] "2007-08-29 00:00:00 SPY 1 @ 120.756766523718"
[1] "2007-09-21 00:00:00 SPY 1 @ 128.338641306101"
[1] "2007-10-22 00:00:00 SPY 1 @ 125.103067234912"
[1] "2007-11-09 00:00:00 SPY 1 @ 122.43897617373"
[1] "2007-11-16 00:00:00 SPY 1 @ 122.960025486859"
[1] "2007-11-27 00:00:00 SPY 1 @ 119.119368912215"
[1] "2007-12-05 00:00:00 SPY 1 @ 124.321481499513"
[1] "2007-12-12 00:00:00 SPY 1 @ 126.951961301543"
[1] "2007-12-18 00:00:00 SPY 1 @ 122.783546626733"
[1] "2007-12-31 00:00:00 SPY -945 @ 124.280064849843"
[1] "2009-06-23 00:00:00 SPY 1 @ 78.4042142019373"
[1] "2009-06-23 00:00:00 SPY 1252 @ 78.4042142019373"
[1] "2009-07-06 00:00:00 SPY 1 @ 77.9397662902533"
[1] "2009-08-26 00:00:00 SPY 1 @ 90.1205877365573"
[1] "2009-09-02 00:00:00 SPY 1 @ 87.4390558536496"
[1] "2009-09-24 00:00:00 SPY 1 @ 93.6932113415245"
[1] "2009-10-02 00:00:00 SPY 1 @ 89.8278430661716"
[1] "2009-10-22 00:00:00 SPY 1 @ 95.2604862455034"
[1] "2009-10-27 00:00:00 SPY 1 @ 94.2391122942741"
[1] "2009-11-02 00:00:00 SPY 1 @ 91.6856822589097"
[1] "2009-12-04 00:00:00 SPY 1 @ 98.4742786182327"
[1] "2010-01-04 00:00:00 SPY 1 @ 99.4736144672957"
[1] "2010-01-22 00:00:00 SPY 1 @ 98.4378867582876"
[1] "2010-02-01 00:00:00 SPY 1 @ 95.7379310881149"
[1] "2010-02-05 00:00:00 SPY 1 @ 94.3304073658146"
[1] "2010-02-10 00:00:00 SPY 1 @ 94.7641758730295"
[1] "2010-02-24 00:00:00 SPY 1 @ 97.4995417411739"
[1] "2010-03-29 00:00:00 SPY 1 @ 104.149863026265"
[1] "2010-04-19 00:00:00 SPY 1 @ 105.785402565728"
[1] "2010-04-28 00:00:00 SPY 1 @ 105.820958584692"
[1] "2010-05-03 00:00:00 SPY 1 @ 106.114283074631"
[1] "2010-05-06 00:00:00 SPY 1 @ 103.340987372324"
[1] "2010-05-17 00:00:00 SPY 1 @ 101.509893728511"
[1] "2010-05-19 00:00:00 SPY 1 @ 99.3499195757947"
[1] "2010-06-02 00:00:00 SPY 1 @ 96.0699632697649"
[1] "2010-06-07 00:00:00 SPY 1 @ 95.2877459634846"
[1] "2010-06-22 00:00:00 SPY 1 @ 99.5010824293916"
[1] "2010-06-30 00:00:00 SPY 1 @ 92.8117037592083"
[1] "2010-07-07 00:00:00 SPY 1 @ 92.1061481376476"
[1] "2010-07-08 00:00:00 SPY -1280 @ 95.5624758791401"
[1] "2010-11-16 00:00:00 SPY 1 @ 107.10912927803"
[1] "2010-11-16 00:00:00 SPY 923 @ 107.10912927803"
[1] "2010-12-08 00:00:00 SPY 1 @ 110.42233992386"
[1] "2011-01-20 00:00:00 SPY 1 @ 115.498053371796"
[1] "2011-01-31 00:00:00 SPY 1 @ 115.597347760313"
[1] "2011-02-23 00:00:00 SPY 1 @ 118.918948504635"
[1] "2011-03-02 00:00:00 SPY 1 @ 118.016337889799"
[1] "2011-03-08 00:00:00 SPY 1 @ 118.819660434392"
[1] "2011-03-11 00:00:00 SPY 1 @ 116.906130443993"
[1] "2011-03-18 00:00:00 SPY 1 @ 116.797541917344"
[1] "2011-03-29 00:00:00 SPY 1 @ 118.637800382539"
[1] "2011-04-04 00:00:00 SPY 1 @ 120.958519747613"
[1] "2011-04-11 00:00:00 SPY 1 @ 120.568717457945"
[1] "2011-05-06 00:00:00 SPY 1 @ 122.327390788816"
[1] "2011-05-17 00:00:00 SPY 1 @ 120.287694440843"
[1] "2011-05-24 00:00:00 SPY 1 @ 120.061061513291"
[1] "2011-06-02 00:00:00 SPY 1 @ 119.625930825048"
[1] "2011-06-07 00:00:00 SPY 1 @ 117.577160094657"
[1] "2011-06-14 00:00:00 SPY 1 @ 116.824736962119"
[1] "2011-06-16 00:00:00 SPY 1 @ 115.183917286234"
[1] "2011-07-12 00:00:00 SPY 1 @ 119.973017034815"
[1] "2011-07-28 00:00:00 SPY 1 @ 118.980002328384"
[1] "2011-08-03 00:00:00 SPY 1 @ 114.479532018588"
[1] "2011-08-05 00:00:00 SPY 1 @ 110.926528758843"
[1] "2011-08-18 00:00:00 SPY -946 @ 106.134530125954"
[1] "2012-04-10 00:00:00 SPY 1 @ 127.684538407341"
[1] "2012-04-10 00:00:00 SPY 782 @ 127.684538407341"
[1] "2012-04-17 00:00:00 SPY 1 @ 127.582723059644"
[1] "2012-04-20 00:00:00 SPY 1 @ 128.036265584381"
[1] "2012-05-07 00:00:00 SPY 1 @ 126.351693212168"
[1] "2012-05-14 00:00:00 SPY 1 @ 124.315407546699"
[1] "2012-05-14 00:00:00 SPY 13 @ 124.315407546699"
[1] "2012-06-01 00:00:00 SPY 1 @ 119.780043387983"
[1] "2012-06-01 00:00:00 SPY 20 @ 119.780043387983"
[1] "2012-06-12 00:00:00 SPY 1 @ 121.982927066767"
[1] "2012-06-22 00:00:00 SPY 1 @ 123.861694859222"
[1] "2012-07-11 00:00:00 SPY 1 @ 124.866508749008"
[1] "2012-07-24 00:00:00 SPY 1 @ 125.778277975289"
[1] "2012-08-01 00:00:00 SPY 1 @ 129.043912417707"
[1] "2012-09-26 00:00:00 SPY 1 @ 134.755594949074"
[1] "2012-10-10 00:00:00 SPY 1 @ 134.858470135761"
[1] "2012-10-22 00:00:00 SPY 1 @ 133.895062616513"
[1] "2012-11-06 00:00:00 SPY 1 @ 133.081314520924"
[1] "2012-11-09 00:00:00 SPY 1 @ 128.722589033494"
[1] "2012-11-14 00:00:00 SPY 1 @ 129.274455586031"
[1] "2012-12-04 00:00:00 SPY 1 @ 132.295624995064"
[1] "2012-12-13 00:00:00 SPY 1 @ 134.147610321731"
[1] "2013-02-01 00:00:00 SPY 1 @ 141.909563425788"
[1] "2013-02-06 00:00:00 SPY 1 @ 141.787115202194"
[1] "2013-02-22 00:00:00 SPY 1 @ 142.38055436199"
[1] "2013-02-26 00:00:00 SPY 1 @ 141.033526878325"
[1] "2013-04-04 00:00:00 SPY 1 @ 147.06343231595"
[1] "2013-04-16 00:00:00 SPY 1 @ 147.877139820857"
[1] "2013-04-19 00:00:00 SPY 1 @ 146.18349942803"
[1] "2013-05-22 00:00:00 SPY 1 @ 158.332337925907"
[1] "2013-05-30 00:00:00 SPY 1 @ 156.449466068128"
[1] "2013-06-03 00:00:00 SPY 1 @ 155.011281577095"
[1] "2013-06-06 00:00:00 SPY 1 @ 152.52284575565"
[1] "2013-06-12 00:00:00 SPY 1 @ 155.380287522684"
[1] "2013-06-18 00:00:00 SPY 1 @ 155.673598800714"
[1] "2013-06-20 00:00:00 SPY 1 @ 153.147322741777"
[1] "2013-07-01 00:00:00 SPY 1 @ 153.386964644818"
[1] "2013-07-25 00:00:00 SPY 1 @ 160.007169452897"
[1] "2013-08-01 00:00:00 SPY 1 @ 161.690758373814"
[1] "2013-08-16 00:00:00 SPY 1 @ 157.952622050774"
[1] "2013-08-28 00:00:00 SPY 1 @ 155.289320708327"
[1] "2013-09-23 00:00:00 SPY 1 @ 162.956795401376"
[1] "2013-09-26 00:00:00 SPY 1 @ 161.838494509156"
[1] "2013-10-09 00:00:00 SPY 1 @ 158.474024130731"
[1] "2013-11-01 00:00:00 SPY 1 @ 168.242447868879"
[1] "2013-11-08 00:00:00 SPY 1 @ 167.143252749946"
[1] "2013-11-21 00:00:00 SPY 1 @ 171.062097370113"
[1] "2013-12-12 00:00:00 SPY 1 @ 170.746676718937"
[1] "2014-01-06 00:00:00 SPY 1 @ 176.334543928472"
[1] "2014-01-14 00:00:00 SPY 1 @ 175.18132815125"
[1] "2014-01-27 00:00:00 SPY 1 @ 172.077291529657"
[1] "2014-02-04 00:00:00 SPY 1 @ 168.12756602891"
[1] "2014-02-20 00:00:00 SPY 1 @ 176.123122189186"
[1] "2014-02-25 00:00:00 SPY 1 @ 177.843312755559"
[1] "2014-03-14 00:00:00 SPY 1 @ 177.64150970068"
[1] "2014-03-24 00:00:00 SPY 1 @ 180.346364511244"
[1] "2014-03-27 00:00:00 SPY 1 @ 178.329006405312"
[1] "2014-04-07 00:00:00 SPY 1 @ 179.487297461871"
[1] "2014-04-11 00:00:00 SPY 1 @ 175.809716093826"
[1] "2014-05-15 00:00:00 SPY 1 @ 182.122412342361"
[1] "2014-06-25 00:00:00 SPY 1 @ 188.436075649539"
[1] "2014-07-18 00:00:00 SPY 1 @ 190.43402088343"
[1] "2014-07-31 00:00:00 SPY 1 @ 189.716312081201"
[1] "2014-08-07 00:00:00 SPY 1 @ 187.126759599473"
[1] "2014-08-13 00:00:00 SPY 1 @ 188.436075649539"
[1] "2014-09-05 00:00:00 SPY 1 @ 194.138917313647"
[1] "2014-09-10 00:00:00 SPY 1 @ 193.421208511418"
[1] "2014-09-23 00:00:00 SPY 1 @ 193.350934585068"
[1] "2014-09-26 00:00:00 SPY 1 @ 191.665219949033"
[1] "2014-10-02 00:00:00 SPY 1 @ 189.209718534193"
[1] "2014-10-08 00:00:00 SPY 1 @ 188.420453423893"
[1] "2014-10-13 00:00:00 SPY 1 @ 185.58495012661"
[1] "2014-10-24 00:00:00 SPY 1 @ 190.252337396064"
[1] "2014-12-02 00:00:00 SPY 1 @ 200.542039328959"
[1] "2014-12-09 00:00:00 SPY 1 @ 199.138894967333"
[1] "2014-12-12 00:00:00 SPY 1 @ 197.453180331298"
[1] "2014-12-22 00:00:00 SPY 1 @ 202.56987175323"
[1] "2015-01-02 00:00:00 SPY 1 @ 202.207357413693"
[1] "2015-01-13 00:00:00 SPY 1 @ 199.993040916179"
[1] "2015-01-29 00:00:00 SPY 1 @ 196.328667060516"
[1] "2015-02-10 00:00:00 SPY 1 @ 201.717466550928"
[1] "2015-03-09 00:00:00 SPY 1 @ 203.539860560413"
[1] "2015-03-12 00:00:00 SPY 1 @ 201.109992083283"
[1] "2015-03-25 00:00:00 SPY 1 @ 205.75734015615"
[1] "2015-04-28 00:00:00 SPY 1 @ 207.400877416595"
[1] "2015-05-06 00:00:00 SPY 1 @ 206.239567359885"
[1] "2015-05-27 00:00:00 SPY 1 @ 207.902791661487"
[1] "2015-06-05 00:00:00 SPY 1 @ 206.623386914182"
[1] "2015-06-25 00:00:00 SPY 1 @ 208.765742549324"
[1] "2015-07-10 00:00:00 SPY 1 @ 204.997859221705"
[1] "2015-07-27 00:00:00 SPY 1 @ 204.651738288859"
[1] "2015-08-06 00:00:00 SPY 1 @ 207.964686364514"
[1] "2015-08-21 00:00:00 SPY 1 @ 199.499342550526"
[1] "2015-09-02 00:00:00 SPY 1 @ 192.467961233126"
[1] "2015-09-04 00:00:00 SPY -906 @ 190.717544097235"
[1] "2015-12-10 00:00:00 SPY 1 @ 204.204684925897"
[1] "2015-12-10 00:00:00 SPY 487 @ 204.204684925897"
[1] "2015-12-21 00:00:00 SPY 1 @ 201.410004"
[1] "2015-12-21 00:00:00 SPY 5 @ 201.410004"

# Update your portfolio (portfolio.st)
updatePortf(portfolio.st)

[1] "firststrat"

daterange <- time(getPortfolio(portfolio.st)$summary)[-1]

# Update your account (account.st)
updateAcct(account.st, daterange)

[1] "firststrat"

updateEndEq(account.st)

[1] "firststrat"

You are on your way to seeing the results of your strategy. The date of the last trade was 2015-12-23

6.1.2 Profit factor

One of the most vital statistics of any systematic trading strategy is the profit factor. The profit factor is how many dollars you make for each dollar you lose. A profit factor above 1 means your strategy is profitable. A profit factor below 1 means you should head back to the drawing board.

In this exercise, you will explore the profit factor in your strategy by creating an object called tstats that displays the trade statistics for your system. In general, trade statistics are generated by using the tradeStats() command.

# Get the tradeStats for your portfolio
tstats <- tradeStats(Portfolios = portfolio.st)

# Print the profit factor
tstats$Profit.Factor

[1] 92.30839

Trade statistics such as the profit factor are a valuable component of assessing the effectiveness of your strategy.

6.1.3 Percent positive

While profit factor is one important statistic, it may be heavily influenced by only a few good trades. The percent positive statistic lets you know how many of your trades were winners. A trading system based on oscillation trading (such as yours!) will likely have a high percentage of winners. This is certainly a statistic you should look for in your own trade statistics.

tstats$Percent.Positive This percent positive statistic means that approximately 71% of your trades returned a positive result. That’s a great start!

6.2 Using chart.Posn()

6.2.1 Using chart.Posn()

One of the most enlightening things about a trading system is exploring what positions it took over the course of the trading simulation, as well as when it had its profits and drawdowns. Looking at a picture of the performance can deliver a great deal of insight in terms of refining similar trading systems in the future.

In this exercise, you will use the chart.Posn() function. This generates a crisp and informative visualization of the performance of your trading system over the course of the simulation.

# Use chart.Posn to view your system's performance on SPY
chart.Posn(Portfolio = portfolio.st, Symbol = "SPY")

6.2.2 Adding an indicator to a chart.Posn() chart

One of the more interesting things you can do with the chart.Posn() function is to superimpose indicators on top of it. This can help show what the strategy has actually been doing and why. However, in order to do this, you will need to recalculate the indicators outside the scope of your strategy. Once this is done, you simply add them to the chart.Posn plot.

In this exercise, you will add the three indicators from your strategy to the chart.Posn plot you just created. The two moving averages (SMA50 and SMA200) will be superimposed on the price series, while the DVO_2_126 will have its own window.

# Compute the SMA50
sma50 <- SMA(x = Cl(SPY), n = 50)

# Compute the SMA200
sma200 <- SMA(x = Cl(SPY), n = 200)

# Compute the DVO_2_126 with an navg of 2 and a percentlookback of 126
dvo <- DVO(HLC = HLC(SPY), navg = 2, percentlookback = 126)

# Recreate the chart.Posn of the strategy from the previous exercise
chart.Posn(Portfolio = portfolio.st, Symbol = "SPY")

# Overlay the SMA50 on your plot as a blue line
add_TA(sma50, on = 1, col = "blue")

# Overlay the SMA200 on your plot as a red line
add_TA(sma200, on = 1, col = "red")

# Add the DVO_2_126 to the plot in a new window
add_TA(dvo, on = 2, col = "red")

The plot may look a bit complicated, but only because it contains so much vital information about your portfolio performance.

6.3 Additional analytics

6.3.1 Cash Sharpe ratio

When working with cash profit and loss statistics, quantstrat offers a way to compute a Sharpe ratio not just from returns, but from the actual profit and loss statistics themselves. A Sharpe ratio is a metric that compares the average reward to the average risk taken. Generally, a Sharpe ratio above 1 is a marker of a strong strategy.

In this exercise, you will see that because of trading P&L (profit and loss), one can compute a Sharpe ratio based on these metrics. The code below can be used to compute the Sharpe ratio based off of P&L.

portpl <- .blotter$portfolio.firststrat$summary$Net.Trading.PL
SharpeRatio.annualized(portpl, geometric=FALSE)

                                Net.Trading.PL
Annualized Sharpe Ratio (Rf=0%)      0.5629363

Remember that a Sharpe ratio above 1 is indicative of a strong strategy. The Sharpe ratio identified here is a bit low.

6.3.2 Returns Sharpe ratio in quantstrat

One of the main reasons to include an initial equity (in this case, initeq, which is set to 100,000) in your strategy is to be able to work with returns, which are based off of your profit and loss over your initial equity.

While you just computed a cash Sharpe ratio in the previous exercise, you will see in this exercise that quantstrat can also compute the standard returns-based Sharpe ratio as well.

# Get instrument returns
instrets <- PortfReturns(portfolio.st)

# Compute Sharpe ratio from returns
SharpeRatio.annualized(instrets, geometric = FALSE)

                                SPY.DailyEqPL
Annualized Sharpe Ratio (Rf=0%)     0.5630224