Options 101

Options are explained on many websites and in many trading books, so here’s just a quick overview. An option is a contract that gives its owner the right to buy (call option) or sell (put option) a financial asset (the underlying) at a fixed price (the strike price) at or before a fixed date (the expiry date). If you sell short (write) an option, you’re taking the other side of the trade. So you can enter a position in 4 different ways: buy a call, buy a put, sell short a call, sell short a put. And this with all possible combinations of strike prices and expiry dates.

The premium is the price that you pay or collect for buying or selling an option. It is far less than the price of the underlying stock. Major option markets are usually liquid, so you can anytime buy, write, or sell an option with any reasonable strike price and expiry date. If the current underlying price (the spot price) of a call option lies above the strike price, the option is in the money; otherwise it’s out of the money. The opposite is true for put options. In-the-money is good for the buyer and bad for the seller. Options in the money can be exercised and are then exchanged for the underlying at the strike price. The difference of spot and strike is the buyer’s profit and the seller’s loss. American style options can be exercised anytime, European style options only at expiration.

Out-of-the-money options can not be exercised, at least not at a profit. But they are not worthless, since they have still a chance to walk into the money before expiration. The value of an option depends on that chance, and can be calculated for European options from spot price, strike, expiry, riskless yield rate, dividend rate, and underlying volatility with the famous Black-Scholes formula. This value is the basis of the option premium. The real premium might deviate slightly dependent on supply, demand, and belief in the underlying’s future price.

By reversing the formula with an approximation process, the volatility can be calculated from the real premium. This implied volatility is how the market expects the underlying to fluctuate in the next time. The partial derivatives of the option value are the Greeks (Delta, Vega – don’t know what Greek letter that’s supposed to be – and Theta). They determine in which direction, and how strong, the value will change when a market parameter changes.

That’s all basic info needed for trading options. By the way, it’s interesting to compare the performances of strategies from trading books. While the forex or stock trading systems described in those books are mostly bunk and lose already in a simple backtest, it is not so with option systems. They often win in backtests. And this even though apparently almost no book author has really backtested his system. Are options trading book authors just more intelligent than other trading book authors? Maybe, but we’ll see that there is an alternative explanation.

Why trading options at all?

They are more complex and more difficult to trade, and you need a Nobel prize winning formula to calculate a value that otherwise would simply be a difference of entry and exit price. Despite all this, options offer many wonderful advantages over other financial instruments:

• High leverage. With $100 you can buy only a few shares, but options of several hundred shares.
• Controlled risk. A short position in a stock can wipe your account; positions in options can be clever combined to limit the risk in any desired way. And unlike a stop loss it’s a real risk limit.
• Additional dimensions. Stock profits just depend on rising or falling prices. Option profits can be achieved with rising volatility, falling volatility, prices moving in a range, out of a range, or almost any other imaginable price behavior.
• Fire and forget. Options expire, so you don’t need an algorithm for closing them (unless you want to sell or exercise them on special conditions). And you pay no exit commission for an expired option.
• Seller advantage. Due to the premium, options can still produce a profit to their seller even if the underlying moves in the wrong direction.

Hacker ethics requires that you not just claim something, but prove it. For getting familiar with options, let’s put the last claim, the seller advantage, to the test:

void run() 
{
	BarPeriod = 1440;
	assetList("assetsIB");
	assetHistory("SPY",FROM_YAHOO|UNADJUSTED);
	asset("SPY");
	if(is(INITRUN)) dataLoad(1,"SPY_Options.t8",9);

	Multiplier = 100;
	contractUpdate("SPY",1,CALL|PUT);	
	int Type = ifelse(random() > 0,CALL,PUT);
	contract(Type,30,priceClose());
	static int LastExpiry = 0;
	if(ContractType && LastExpiry != ContractExpiry) {
		enterShort();
		LastExpiry = ContractExpiry;
	}
}

This is a very simple option trading system. It randomly writes call or put options and keeps the positions open until they expire. Due to the put/call randomness it is trend agnostic. Before looking into code details, just run it in [Test] mode a couple times (you’ll need Zorro version 1.53 or above). You’ll notice that the result is different any time, but it is more often positive than negative, even though commission is subtracted from the profit. A typical outcome:

You can see that most trades win, but when they lose, they lose big. Now reverse the strategy and buy the options instead of selling them: Replace enterShort() by enterLong(). Run it again a couple times (the script needs about 3 seconds for a backtest). You will now see that the result is more often negative – in fact almost any time.

It seems that options, at least the tested SPY contracts, indeed favor the seller. This is somewhat similar to the positive expectancy of long positions in stocks, ETFs, or index futures, but the options seller advantage is stronger and independent of the market direction. It might explain a large part of the positive results of option systems in trading books. Why are there then option buyers at all? Options are often purchased not for profit, but as an insurance against unfavorable price trends of the underlying. And why is the seller advantage not arbitraged away by the market sharks? Maybe because there’s yet not much algorithmic trading with options, and because there are anyway more whales than sharks in the financial markets.

Functions for options

We can see that options trading and backtesting requires a couple more functions than just trading the underlying. Without options, the same random trading system would be reduced to this short script:

void run() 
{
	BarPeriod = 1440;
	assetList("assetsIB");
	assetHistory("SPY",FROM_YAHOO);
	asset("SPY");

	if(random() > 0)
		enterLong();
	else
		enterShort();
}

Options require (at least) three additional functions:

• dataLoad(1,”SPY_Options.t8″,9) loads historical options data from the file “SPY_Options.t8” into a data set. Options data includes not only the ask and bid prices, but also the strike price, the expiration date, the type – put or call, American or European – of any option, and some rarely used additional data such as the open interest. Unlike historical price data, options data is usually expensive. You can purchase it from vendors such as iVolatility. But there’s an alternative way to get it for free, which I’ll describe below.
• contractUpdate(“SPY”,1,CALL|PUT) loads the current option chain. In backtest mode it’s loaded from the above data set, in live trading mode it’s loaded from the broker. The option chain is a list of all available option contracts of the selected underlying, with all available strike prices and all expiration dates. If you open it manually in the IB trading platform, it looks like this:

The center column lists different strike prices and expiry dates, the right and left parts are the ask and bid prices and order book sizes for their assigned call (left) and put options (right). The prices are per share; an option contract always covers a certain number of shares, normally 100. So you can see in the list above that you’ll collect $15 premium when you write a SPY call option expiring next week (Feb 03, 2017) with a $230 strike price. If SPY won’t rise above $230 until that date, the $15 are your profit. If it rised to $230 and 10 cents and the option is exercised (happens automatically when it expires in the money), you still keep $5. But if it suddenly soared to $300 (maybe Trump announced 100-ft. walls all around the US, all paid by himself), you have to bear a $6985 loss.

The image displays 54 contracts, but this is only a small part of the option chain, since there are many more expiry dates and strike prices available. The SPY option chain can contain up to 10,000 different options. They all are downloaded to the PC with the above contractUpdate function, which can thus take a couple seconds to complete.

• contract(Type,30,priceClose()) selects a particular option from the previously downloaded option chain. The type (PUT or CALL), the days until expiration (30), and the strike (priceClose() is the current price of the underlying) are enough information to select the best fitting option. Note that for getting correct strike prices in the backtest, we downloaded the underlying price data with the UNADJUSTED flag. Strike prices are always unadjusted.

Once a contract is selected, the next enterLong() or enterShort() buys or sells the option at market. The if() clause checks that the contract is available and its expiry date is different to the previous one (for ensuring that only different contracts are traded). Entry, stop, or profit limits would work as usual, they now only apply to the option value, the premium, instead of the underlying price. The backtest assumes that when an option is exercised or expires in the money, the underlying is immediately sold, and the profit is booked into the buyer’s account and deducted from the seller’s account. If the option expires out of the money, the position just vanishes. So we don’t care about exiting positions in this strategy. Apart from those differences, trading options works just as trading any other financial instrument.

Backtesting option strategies

Here’s an easy way to get rich. Open an IB account and run a software that records the options chains and contract prices in one-minute intervals. That’s what some data vendors did in the last 5 years, and now they are dear selling their data treasures. Although you can easily pay several thousand dollars for a few year’s option chains of major stocks, I am not sure who really owns the copyright of this data – the vendor, the broker, the exchange, or the market participants? This might be a legal grey area. Anyway, you need historical data for developing options strategies, otherwise you could not backtest them.

Here’s a method to get it for free and without any legal issues:

#include <contract.c>

string Code = "SPY"; 
string FileName = "History\\SPY_Options.t8";
var StrikeMax[3] = { 5,25,100 }; // strike ranges
var StrikeStep[3] = { 1,5,10 }; // strike step widths
int DaysMax = 180;  // max contract life in days
var BidAskSpread = 2.5; // bid/ask spread in percent
var Dividend = 2.0; // annual dividend in percent
int Type = 0; // or EUROPEAN, or FUTURE 

/////////////////////////////////////////////////////////

CONTRACT* c;
int N = 0;

void run() 
{
	BarPeriod = 1440;
	StartDate = 2011;
	EndDate = 2017;
	LookBack = 21;
	assetList("AssetsIB");
	assetHistory(Code,FROM_YAHOO|UNADJUSTED);
	asset(Code);
	if(is(INITRUN)) {
		initRQL();
		int MaxContractsPerDay = 2*(1+2*(StrikeMax[0]/StrikeStep[0] + StrikeMax[1]/StrikeStep[1] + StrikeMax[2]/StrikeStep[2])) * (1+DaysMax/7);
		int TotalContracts = (1+EndDate-StartDate)*252*MaxContractsPerDay;
		printf("\nAllocating %d Contracts",TotalContracts);
		c = (CONTRACT*)dataNew(1,TotalContracts,9);
		N = 0;
	}

	vars Close = series(priceClose());
	var HistVolOV = VolatilityOV(20);
	var Unl = Close[0];
	var Interest = yield();

	if(!is(LOOKBACK)) {
		var Strike;
		int i, Days = 1;
		while((dow()+Days)%7 != FRIDAY) Days++;
		for(; Days <= DaysMax; Days += 7)
		for(Strike = max(10,round(Unl-StrikeMax[2],StrikeStep[2])); Strike <= Unl+StrikeMax[2]; Strike)
		for(i = 0; i < 2; i++)
		{
			c->time = wdate();
			c->fUnl = Unl;
			c->fStrike = Strike;
			c->Type = Type | ifelse(i,PUT,CALL);
			c->Expiry = ymd(c->time+Days);
			c->fBid = contractVal(c,Unl,HistVolOV,0.01*Dividend,0.01*Interest);
			if(c->fBid < 0.01) continue; // probably no liquidity
			c->fAsk = (1.0+BidAskSpread/100)*c->fBid;

			if(abs(Unl-Strike) < StrikeMax[0]) Strike += StrikeStep[0];
			else if(abs(Unl-Strike) < StrikeMax[1]) Strike += StrikeStep[1];
			else Strike += StrikeStep[2];
			N++; c++;
		}
	}
	
	if(is(EXITRUN)) {
		printf("\nSaving %d Records",N);
		dataSort(1);	// reverse the entry order
		dataSave(1,FileName,0,N);
		printf("\nOk!");
	}
}

This script is a bit longer than the usual Zorro scripts that I post here, so I won’t explain it in detail. It generates artificial option chains for any day from 2011-2017, and stores them in a historical data file. The option prices are calculated from the underlying price, the volatility, the current risk free interest rate, and the dividend rate of the underlying. It uses three ranges of strike prices, and expiry dates at any Friday of the next 180 days. You need R installed for running it, and also the RQuantlib package for calculating option values. All functions are described in the Zorro manual. The yield() function returns the current yield rate of US treasury bills, and contractVal() calculates the premium by solving a differential equation with all option parameters. The source code of both functions can be found in the contract.c include file.

Due to the slow differential equation solver and the huge number of options, the script needs several hours to complete. Here’s a comparison of the generated data with real SPY options data:

The blue line are the artificial option prices, the black line are the real prices purchased from an options data vendor, both for 3-weeks SPY contracts with 10 points spot-strike distance. You can see that the prices match quite well. There are some tiny differences that might be partially random, partially caused by anomalies in supply and demand. For strategies that exploit those anomalies – that includes all strategies based on implied volatility – you’ll need real historical options prices. For option strategies that exploit only price or volatility changes of the underlying, the artificial data will most likely do. See, reading this article up to the end already saved you a couple thousand dollars.

Conclusion

• Options and option combinations can be used to create artificial financial instruments with very interesting properties.
• Option strategies, especially options selling, are more likely to be profitable than other strategies.
• Algorithmic option strategies are a bit, but not much more complex than strategies with other financial instruments.

I’ve included all scripts in the 2017 script repository, and also a historical data set with the yield rates (otherwise you needed the Quandl bridge or Zorro S for downloading them). You’ll need Zorro 1.53 or above, which is currently available under the “Beta” link of the Zorro download page. The error message from the free Zorro version about the not supported Quandl bridge can be ignored, due to the included yield rates the script will run nevertheless.

In the next article we’ll look more closely into option values and into methods to combine options for limiting risk or trading arbitrary price ranges. Those combinations with funny names like “Iron Condor” or “Butterfly” are often referred to as option strategies, but they are not – they are just artificial financial instruments. How you trade them is up to the real strategy. Some simple, but consistently profitable option strategies will be the topic of the third article of this mini-series.

=> Part 2