Options, Futures, FOPs

contractUpdate (string Name, int Handle, int Mode): int

contractRecord (string Name, var MinStrike, var MaxStrike, int MinDays, int MaxDays)

contract (int Type, int Expiry, var Strike): CONTRACT*

contract (int Type, int Days, var Strike): CONTRACT*

contract (int N): CONTRACT*

contract (CONTRACT*): CONTRACT*

contract (TRADE*): CONTRACT*

contractNext (int Type, int Expiry, var Strike): CONTRACT*

contractFind (int Type, int Days, var Find, int N): CONTRACT*

contractFind (int Type, int Days, var Find, int N, var MinStrike, var MaxStrike): CONTRACT*

contractFind (int Type, int Expiry, var Find, int N): CONTRACT*

contractFind (int Type, int Expiry, var Find, int N, var MinStrike, var MaxStrike): CONTRACT*

contractDays (CONTRACT*): var

contractDays (TRADE*): var

contractPrice (CONTRACT*): var

contractPrice (TRADE*): var

contractUnderlying (): var

contractPosition (TRADE*): int

contractCheck (TRADE*, int Mode): int

contractRoll (TRADE*, int Days, var Strike, function TMF): TRADE*

contractSellUnderlying (): int

contractExercise (TRADE*)

contractVal (CONTRACT*, var Price, var HistVol, var Dividend, var RiskFree, var* Delta, var* Gamma, var* Vega, var* Theta, var* Rho): var

contractVol (CONTRACT*, var Price, var HistVol, var Value, var Dividend, var RiskFree): var

contractDelta (int Type, int Days, var Price, var HistVol, var RiskFree, var Strike): var

contractStrike (int Type, int Days, var Price, var HistVol, var RiskFree, var Delta): var

contractIntrinsic (CONTRACT*, var Price): var

contractIntrinsic (TRADE*, var Price): var

contractProfit (CONTRACT*, var Price, var Premium): var

contractMargin (CONTRACT*, int AssetType): var

contractLetter (int AssetMonth): string

contractPrint ()

contractPrint (CONTRACT*)

plotContract (int N, CONTRACT*, var HistVol, var Min, var Max, int Days, int Modus)

yield(): var

yieldCSV(): var

initRQL(): int

Parameters:

Remarks:

• contract.c must be included for all contract functions. The underlying asset must be selected and a contract chain must be loaded before calling a contract function.
• The contractVal and contractVol functions also require R with the Rcpp and RQuantLib packages that you can install from the Cran repository, either with the install.packages command or from the menu when using RStudio. For checking if everything is working, call a library function from the R console, like this:
  
  

  require('RQuantLib')
  AmericanOption('put', underlying=100, strike=100, dividendYield=0.02, riskFreeRate=0.01, maturity=0.5, volatility=0.4, engine='CrankNicolson')
  
  Concise summary of valuation for AmericanOption
    value  delta  gamma  vega theta rho divRho
  11.4122 -0.4463 0.0139  NA   NA   NA   NA

  
  RQuantLib must be initialized in the INITRUN by calling initRQL The current RQuantLib version tends to crash when a function is called with bad parameters, like negative volatility, or with a value that contradicts the strike and spot price, or with too long strike distances. After a crash, all RQuantLib functions return 0.
• Contract chains loaded from historical data normally contain prices, underlying, and optional data such as delta. Chains downloaded from the broker normally contain only strikes and expirations. Since loading option chains can take a long time (~15 minutes for long chains with some brokers), and expirations and strikes don't change intraday, it is recommended to call contractUpdate in live trading only once per day, preferably outside market hours. Prices can then be updated with contractPrice; prices of open trades are automatically updated. In test and training, contractUpdate should be called at any bar for updating the prices.
• Some brokers are reported to return already-expired contracts in their contract chain. Make sure to check the expiration date when selectiung a contract.
• High resolution options data can be split in monthly or daily .t8 files and loaded per script in a dataset that is then fed to the contractUpdate function (see example).
• Entry, Stop, and TakeProfit limits also work for trading options and futures. They must be given as an absolute price limit to the ask price of the contract, not as a distance. When an exit limit is hit, the contract is sold at market. Of course the usefulness of stop/profit limits for option values is arguable.
• For entering a trade, make sure that a contract is selected. Otherwise you would unwillingly open a position of the underlying. Check with contracePrice() that a nonzero ask or bid price, depending trade direction, is available for the contract or for all contracts of a combo. Set the Multiplier correctly, otherwise the backtest result will be wrong. Some brokers also require the Exchange to be set. The correct multiplier of an option or future contract can be found on the asset description on the website of the broker or the exchange. For stocks, the multiplier is normally 100.
• Underlying prices downloaded with the assetHistory function are normally split and dividend adjusted and therefore won't match strike prices. You can use the UNADJUSTED flag for downloading unadjusted prices instead. But often you'll need both sorts of prices in an options trading system, unadjusted prices for calculating greeks or determining strikes, and adjusted prices for historical volatility and for indicators. The usual convention is having adjusted prices in .t6 history and using the contractUnderlying() function for the unadjusted prices.
• When an option is closed, either by an exit command or by reaching a stop or profit target, it is automatically sold back or covered at the current ask or bid price. If no market price is available, the option stays open until the next exit command or until it expires or is exercised. Options and futures can only be traded, and their prices can only be downloaded when the market is open. Do not send enter, exit, or exercise option positions outside market hours.
• If an option expires or is exercised, a position of the underlying can appear. For live trading, the contractCheck command can check if an underlying position is open, and sell it automatically. In the backtest, underlying positions opened by expired or exercised options are immediately sold at market, and the profit or loss is booked on the account.
• For calculating profit/loss of an option, the following algorithm is used:
  - A call is assumed in the money when the strike is below the bid price (i.e. ask - spread); a put is assumed in the money when the strike is above the ask price.
  - A long call or short put in the money buys the underlying at strike price, and sells it at bid price. The difference is added to or subtracted from the account.
  - A long put or short call in the money sells the underlying at strike price, and buys it back at ask price. The difference is added to or subtracted from the account.
  - For a long position the premium is subtracted from the account, for a short position the premium is added to the account.
• An example for finding the parameters of commodity FOPs. Go to https://www.cmegroup.com/trading and enter the name, for instance "Natural Gas", in the search field. A list of symbols will appear (otherwise you have to look it up at a different exhange). Select the symbol with the high trade volume, in the example "NG". Click on the link under Product Name. Then select Contract Specs. The multiplier (10,000 for NG) is the Contract Unit, the pip size of the underlying is the Minimum Price Fluctuation ($0.001). Pip cost are the $0.001 in your account currency. Under Quotes you can see the current price per underlying unit ($3.146). Check if the price is in cents or dollars (see below). Under Margins you can see that the most recent November 2018 contract has $1950 maintenance margin. That's $0.195 margin cost per underlying unit. Now look up the symbol in your broker platform and check its ticker name. Check also if your broker uses the same margin. That's all you need to add the underlying to your asset list. The line will look like this (on an USD account): NG,3.146,0.001,0,0,0.001,0.001,0.195,0,1,0.002,NG.
• Futures and options on futures (FOPs) sometimes have prices sometimes in cents, sometimes in dollars, sometimes mixed in any possible combination of historical and live data. For trading with FOPs, check historical data and broker data and determine which prices - ask/bid, strike, underlying - are in cents and which in dollars. This can be different with any future and any broker. Set the Centage variable accordingly for using consistent dollar prices in the strategy, charts, and reports.
• The class or root symbol of a contract can be retrieved in live trading from the first element of a CONTRACT struct: string RootSymbol = (string)MyContract;. Note that this only works in Live mode, as in the backtest the first CONTRACT element is the time.
• Many broker APIs, for instance IB, do not manage trades, but only positions. Those APIs can not distinguish between an underlying position opened by a normal trade, and a position opened by an exercised option. This must be considered in the script. Buying long and short the same contract with the same strike and expiry is treated as two different trades by Zorro, but as two positions that cancel each other by most brokers.
• Some broker APIs, for instance IB, need a certain "recovery time" after downloading an options chain before downloading the next chain. When downloading chains of multiple assets, wait some seconds between contractUpdate calls.
• Use the exit command if you want to close a contract by selling it or buying it back. On NFA accounts, functions like contractPosition or contractCheck only check the net position of open option trades, and will return wrong results when several long and short positions of the same contract are open. For the same reason, multiple scripts can trade options on the same NFA account only when they don't open the same contracts.
• Slippage is not simulated for options. Commission and margin are set by default to the commission and margin of the underlying in the asset list, multiplied with the Multiplier. Commission is reduced by 50% when an option expires worthless. Since most brokers have different and complex calculation methods for option margins, the default margin is just an approximation. For better accuracy, use the contractMargin or comboMargin functions or calculate Commission and MarginCost parameters explicitely in the script prior to entering a trade. For instance when trading vertical spreads, margin cost is often determined by the strike price difference, therefore set MarginCost = 0.5 * (Strike1-Strike2) before opening the two positions. The margin cost of covered contracts is usually 0. The margin requirements by IB can be found on https://www.interactivebrokers.com/en/index.php?f=24176.
• When optimizing option strategies, the default objective function is not the ideal performance measure for options. Better is dividing the total profit by the required margin. Example:

  var objective()
  {
    if(!NumWinTotal && !NumLossTotal) return 0;
    return (WinTotal-LossTotal)/MarginMax;
  }

• Phantom trades and virtual hedging are not used for contracts. Options can always be hedged regardless of the Hedge setting.
• Some historical options before 2014 expired on Saturday; afterwards they expired on Friday. Options with Saturday expiration are treated as if they expired on Friday. The expiration hour can be set up with the ExpiryTime variable.
• The CONTRACT struct is defined in trading.h. For backtests the following struct elements must be filled in the data set; for futures: time, fAsk, fBid, Expiry, Type; for options: time, fAsk, fBid, fStrike, Expiry, Type. The other CONTRACT elements are optional and for use in the script only.
• contract(Contracts) selects the first contract in the chain.
• For calculating the option value, American options are approximated with the Crank-Nicolson method, while European options are calculated with the (much faster) Black-Scholes formula. For short-term options the results of both methods are not very different, so the EUROPEAN flag can be used in such cases even for Americon options in order to speed up the calculation.
• The contractVol function is known to terminate the R session when called with unrealistic parameters, such as an unlikely small option value for a high strike-spot difference and short expiration date. This can be tested with the Rrun function ( if(!Rrun()) quit("R terminated!"); ). When the R session is terminated by an exception in the backtest, Zorro must be restarted.
• For finding the contract with the lowest strike and a particular property, start the with strike price at the current price, then call contract(...) in a loop and modify the strike in steps until the condition is fulfilled. For CALL options increase the strike, for PUT options decrease it.
• For converting dates from or to the YYYYMMDD format or for finding the 3rd Friday of a month, use the dmy, ymd, and nthDay functions.
• Several option scripts are included. The TradeOptions script can be used for testing the opening and closing of SPY options via broker API. It only runs at NY market hours and takes about 30 seconds for downloading the option chain at start. The Payoff script can interactively display payoff and delta diagrams of option combinations. The OptionsCalculator script calculates the price and delta of calls and puts, where underlying, strike, and expiration of options can be set up with sliders. Feel free to combine the scripts to your own specialized options tool.
  

Examples:

// Sell call and put options at 1 stddev of the underlying
// Buy them back 2 days before expiration
#include <contract.c>

void run() 
{
  BarPeriod = 1440;
  BarZone = ET;
  BarOffset = 15*60; // trade at 3 pm Eastern time
  assetList("AssetsIB");
  assetHistory("SPY",FROM_AV|UNADJUSTED);
  asset("SPY");
  Multiplier = 100;
 
  contractUpdate(Asset,0,PUT|CALL);
  vars Close = series(priceClose());  
  int DTE = 6*7; // look for 6-week contracts
  var Strangle = StdDev(Close,20);
  CONTRACT* Call = contract(CALL,DTE,Close[0] + Strangle);
  CONTRACT* Put = contract(PUT,DTE,Close[0] - Strangle);
  if(!NumOpenTotal && Call && Put && !is(LOOKBACK)) {
    contract(Call); enterShort();
    contract(Put); enterShort();
  }

// Check expiration and buy them back when in the money  
  for(open_trades) 
  {
    if(contractDays(ThisTrade) <= 2
      && contractIntrinsic(ThisTrade,Close[0]) > 0)
         exitTrade(ThisTrade);
  }
}

// Load high res contract chains from daily files like "SPY_20210505.t8"
if(day(0) != day(1)) { // new day?
  if(Live) // load a new contract chain without prices
    contractUpdate(0,1,CALL|PUT);
  else // load a new t8 file with prices 
    dataLoad(1,strf("History\\%s_%04d%02d%02d.t8",Asset,year(0),month(0),day(0)),9);
}
if(!Live) // in the backtest, update prices at any bar
  contractUpdate(0,1,CALL|PUT);

// Example script for converting EOD options data to .t8:
// Format: underlying symbol, exchange, date MMDDYYYY, adj close, option symbol, expiry MMDDYYYY, strike, Call/Put, American/European, ask, bid, volume, open interest, close
// Sample: "TLT,NYSEArca,04/10/2015,129.62,TLT   150410C00112500,04/10/2015,112.5,C,A,17.3,16.2,0,0,129.62"
string Format = ",,%m/%d/%Y,,,i,f,s,s,f,f,f,f,f";

void main() 
{
// first step: parse the CSV file into a dataset
  int Records = dataParse(1,Format,FILENAME);
  printf("\n%d Records parsed",Records);
// second step: convert the raw data to the final CONTRACT format
  for(i=0; i<Records; i++) 
  {
    CONTRACT* C = dataAppendRow(2,9);
    C->time = dataVar(1,i,0);
    string PC = dataStr(1,i,3);
    string EA = dataStr(1,i,4);
    C->Type = ifelse(*PC == 'P',PUT,CALL) + ifelse(*EA == 'E',EUROPEAN,0);
    int Expiry = dataInt(1,i,1); 
    C->Expiry = 10000*(Expiry%10000) + Expiry/10000; // MMDDYYYY -> YYYYMMDD
    C->fStrike = dataVar(1,i,2);
    C->fAsk = dataVar(1,i,5);
    C->fBid = dataVar(1,i,6);
    C->fVol = dataVar(1,i,7);
    C->fVal = dataVar(1,i,8); // open interest
    C->fUnl = dataVar(1,i,9);
    if(!progress(100*i/Records,0)) break; // show a progress bar
  }
  dataSort(2);
  dataSave(2,"History\\MyOptions.t8");
}

See also: