OptionsHelper (Wealth-Lab Framework)

OptionsHelper is a static class with methods to assist with converting and parsing option symbols with different formast. The primary method is C2Symbol which converts an option symbol of any format to the Collective2 option symbol format.

OptionSynthetic is useful for devoloping strategies that trade options.

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Data;
using WealthLab.Indicators;
using System.Collections.Generic;

namespace WealthScript123
{
	public class SyntheticOptionSymbol : UserStrategyBase
	{
		public override void Initialize(BarHistory bars)
		{			
			//identify an ATM call with an expiration at least 5 days in the future
			string symbol = OptionSynthetic.GetOptionsSymbol(bars, OptionType.Call, bars.LastValue, bars.DateTimes[bars.Count - 1], 5); 
			string c2sym = OptionsHelper.C2Symbol(symbol); 
			
			//show the symbols
			DrawHeaderText($"Synthetic symbol is {symbol}", WLColor.Gold, 12, "Price");
			DrawHeaderText($"C2 symbol is {c2sym}", WLColor.Gold, 12, "Price");
		}

		//execute the strategy rules here, this is executed once for each bar in the backtest history
		public override void Execute(BarHistory bars, int idx)
		{ }
	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Data;
using WealthLab.Indicators;
using WealthLab.InteractiveBrokers;

namespace WealthScript2 
{
    public class MyStrategy : UserStrategyBase
    {
        public override void Initialize(BarHistory bars)
        {
			// get the last expired call for the ATM strike on that day
			int bar = bars.Count - 1;
			DateTime nextEx = bars.NextOptionExpiryDate(bar);
			DateTime exp = nextEx;
			do
			{
				exp = bars.NextOptionExpiryDate(--bar);
			}
			while (exp == nextEx && bar > 0);

			DrawHeaderText($"Previous expiration was {exp:yyyy-MM-dd}", WLColor.NeonGreen, 14);	
			
			int idx = bars.DateTimes.IndexOf(exp);
			if (idx == -1)
			{
				DrawHeaderText($"Expiration for {exp:yyyy-MM-dd} is not loaded in the chart");
				return; 
			}
			
			double strike = Math.Round(bars.Close[idx] / 5) * 5;
			string osym = OptionSynthetic.Symbol(bars, OptionType.Call, strike, exp);

			// first check if the IB real contract data is available in cache
			string ibsym = OptionsHelper.ConvertSymbol(osym, 1);
			BarHistory obars = GetHistory(bars, ibsym);

			if (obars == null)
			{
				// data wasn't in cache - we need to go synthetic
				obars = OptionSynthetic.GetHistory(bars, osym, 0.15); 
			}
	        
	        PlotBarHistory(obars, "opane"); 
        }

        public override void Execute(BarHistory bars, int idx)
        { }
    }
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Data;

namespace WealthScript123
{
	public class MyStrategy : UserStrategyBase
	{
		public override void Initialize(BarHistory bars)
		{
			_lastIdx = bars.Count - 1;
			string osym = OptionSynthetic.GetOptionsSymbol(bars, OptionType.Call, bars.Close[_lastIdx], bars.DateTimes[_lastIdx], 10);
			(string, OptionType, double, DateTime) optionParts = OptionsHelper.ParseSymbol(osym);
			
			string underlier = optionParts.Item1;
			OptionType otype = optionParts.Item2; 
			double strike = optionParts.Item3; 
			DateTime expiry = optionParts.Item4; 
						
			WriteToDebugLog($"The underlier for {osym} is {underlier}"); 
			WriteToDebugLog($"The option type is {otype}"); 
			WriteToDebugLog($"The strike is {strike}"); 			
			WriteToDebugLog($"The expiration date is {expiry:yyyy-MM-dd}"); 
		}

		public override void Execute(BarHistory bars, int idx)
		{ }

		//declare private variables below
		int _lastIdx;
	}
}

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Data;
using System.Collections.Generic;
using WealthLab.Indicators;

namespace WealthScript125
{
    public class StrikeAtDelta: UserStrategyBase
    {
		Parameter _deltaParam;
		bool _weeklies = false; 
		WLColor _clr = WLColor.NeonGreen;
		TimeSeries _iv;
		
		public StrikeAtDelta()
		{
			_deltaParam = AddParameter("Target Delta", ParameterType.Double, 0.12, 0, 1, 0.01); 
		}				
		
        public override void Initialize(BarHistory bars)
        {
			double delta = _deltaParam.AsDouble;
			DateTime expiry = bars.NextOptionExpiryDate(bars.Count - 1);

			//estimate IV using HV
			_iv = HV.Series(bars.Close, 21, 252) / 100.0;
			
			DrawHeaderText($"Delta: {delta:N4}; expiry: {expiry:yyyy-MM-dd}", _clr, 14);
			DrawHeaderText($"IV: {_iv.LastValue :N4}", _clr, 14);		
			
			double price = OptionsHelper.PriceAtDelta(OptionType.Call, delta, bars.LastValue, _iv.LastValue, expiry);
			DrawHeaderText($"Stock Price at Delta {delta:N4} is {price:N2}", _clr, 14);

			//use the price to identify the closest strike
			string osym = OptionSynthetic.GetOptionsSymbol(bars, OptionType.Call, price, bars.EndDate, 0);
			DrawHeaderText($"The nearest Call at Delta {delta:N4}: {osym}", _clr, 14);
        }

        public override void Execute(BarHistory bars, int idx)
        {  }
    }
}