wehub-resource-sync
465 lines
19 KiB
C#
465 lines
19 KiB
C#
/*
|
|
* QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
|
|
* Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
using Moq;
|
|
using NUnit.Framework;
|
|
using Python.Runtime;
|
|
using QuantConnect.Algorithm;
|
|
using QuantConnect.Data;
|
|
using QuantConnect.Indicators;
|
|
using QuantConnect.Lean.Engine.DataFeeds;
|
|
using QuantConnect.Lean.Engine.HistoricalData;
|
|
using QuantConnect.Tests.Engine.DataFeeds;
|
|
|
|
namespace QuantConnect.Tests.Indicators
|
|
{
|
|
public abstract class OptionBaseIndicatorTests<T> : CommonIndicatorTests<IBaseData>
|
|
where T : OptionIndicatorBase
|
|
{
|
|
// count of risk free rate calls per each update on opiton indicator
|
|
protected int RiskFreeRateUpdatesPerIteration { get; set; }
|
|
|
|
// count of dividend yield calls per each update on option indicator
|
|
protected int DividendYieldUpdatesPerIteration { get; set; }
|
|
|
|
protected static DateTime _reference = new DateTime(2023, 8, 1, 10, 0, 0);
|
|
protected static Symbol _symbol = Symbol.CreateOption("SPY", Market.USA, OptionStyle.American, OptionRight.Call, 450m, new DateTime(2023, 9, 1));
|
|
protected Symbol _underlying => _symbol.Underlying;
|
|
|
|
protected override IndicatorBase<IBaseData> CreateIndicator()
|
|
{
|
|
throw new NotImplementedException("method `CreateIndicator()` is required to be set up");
|
|
}
|
|
|
|
protected virtual OptionIndicatorBase CreateIndicator(IRiskFreeInterestRateModel riskFreeRateModel)
|
|
{
|
|
throw new NotImplementedException("method `CreateIndicator(IRiskFreeInterestRateModel riskFreeRateModel)` is required to be set up");
|
|
}
|
|
|
|
protected virtual OptionIndicatorBase CreateIndicator(IRiskFreeInterestRateModel riskFreeRateModel, IDividendYieldModel dividendYieldModel)
|
|
{
|
|
throw new NotImplementedException("method `CreateIndicator(IRiskFreeInterestRateModel riskFreeRateModel, IDividendYieldModel dividendYieldModel)` is required to be set up");
|
|
}
|
|
|
|
protected virtual OptionIndicatorBase CreateIndicator(QCAlgorithm algorithm)
|
|
{
|
|
throw new NotImplementedException("method `CreateIndicator(QCAlgorithm algorithm)` is required to be set up");
|
|
}
|
|
|
|
protected OptionPricingModelType ParseSymbols(string[] items, bool american, out Symbol call, out Symbol put)
|
|
{
|
|
var ticker = items[0];
|
|
var expiry = DateTime.ParseExact(items[1], "dd/MM/yyyy HH:mm:ss", CultureInfo.InvariantCulture);
|
|
var strike = Parse.Decimal(items[2]);
|
|
var style = american ? OptionStyle.American : OptionStyle.European;
|
|
|
|
call = Symbol.CreateOption(ticker, Market.USA, style, OptionRight.Call, strike, expiry);
|
|
put = Symbol.CreateOption(ticker, Market.USA, style, OptionRight.Put, strike, expiry);
|
|
|
|
return american ? OptionPricingModelType.ForwardTree : OptionPricingModelType.BlackScholes;
|
|
}
|
|
|
|
protected void RunTestIndicator(Symbol call, Symbol put, OptionIndicatorBase callIndicator, OptionIndicatorBase putIndicator,
|
|
string[] items, int callColumn, int putColumn, double errorRate, double errorMargin = 1e-4)
|
|
{
|
|
var time = DateTime.ParseExact(items[3], "dd/MM/yyyy HH:mm:ss", CultureInfo.InvariantCulture);
|
|
|
|
var callDataPoint = new IndicatorDataPoint(call, time, decimal.Parse(items[5], NumberStyles.Any, CultureInfo.InvariantCulture));
|
|
var putDataPoint = new IndicatorDataPoint(put, time, decimal.Parse(items[4], NumberStyles.Any, CultureInfo.InvariantCulture));
|
|
var underlyingDataPoint = new IndicatorDataPoint(call.Underlying, time, decimal.Parse(items[^4], NumberStyles.Any, CultureInfo.InvariantCulture));
|
|
|
|
callIndicator.Update(callDataPoint);
|
|
callIndicator.Update(underlyingDataPoint);
|
|
if (callIndicator.UseMirrorContract)
|
|
{
|
|
callIndicator.Update(putDataPoint);
|
|
}
|
|
|
|
var expected = double.Parse(items[callColumn], NumberStyles.Any, CultureInfo.InvariantCulture);
|
|
var acceptance = Math.Max(errorRate * Math.Abs(expected), errorMargin); // percentage error
|
|
Assert.AreEqual(expected, (double)callIndicator.Current.Value, acceptance);
|
|
|
|
putIndicator.Update(putDataPoint);
|
|
putIndicator.Update(underlyingDataPoint);
|
|
if (putIndicator.UseMirrorContract)
|
|
{
|
|
putIndicator.Update(callDataPoint);
|
|
}
|
|
|
|
expected = double.Parse(items[putColumn], NumberStyles.Any, CultureInfo.InvariantCulture);
|
|
acceptance = Math.Max(errorRate * Math.Abs(expected), errorMargin); // percentage error
|
|
Assert.AreEqual(expected, (double)putIndicator.Current.Value, acceptance);
|
|
}
|
|
|
|
protected override List<Symbol> GetSymbols()
|
|
{
|
|
return [Symbols.GOOG];
|
|
}
|
|
|
|
[Test]
|
|
public void ZeroGreeksIfExpired()
|
|
{
|
|
var indicator = CreateIndicator();
|
|
var date = new DateTime(2099, 1, 1); // date that the option must be expired already
|
|
var price = 500m;
|
|
var optionPrice = 10m;
|
|
|
|
indicator.Update(new IndicatorDataPoint(_symbol, date, optionPrice));
|
|
indicator.Update(new IndicatorDataPoint(_underlying, date, price));
|
|
|
|
Assert.AreEqual(0m, indicator.Current.Value);
|
|
}
|
|
|
|
[Test]
|
|
public override void ResetsProperly()
|
|
{
|
|
var indicator = CreateIndicator();
|
|
|
|
for (var i = 0; i < 5; i++)
|
|
{
|
|
var price = 500m;
|
|
var optionPrice = Math.Max(price - 450, 0) * 1.1m;
|
|
|
|
indicator.Update(new IndicatorDataPoint(_symbol, _reference.AddDays(1 + i), optionPrice));
|
|
indicator.Update(new IndicatorDataPoint(_underlying, _reference.AddDays(1 + i), price));
|
|
}
|
|
|
|
Assert.IsTrue(indicator.IsReady);
|
|
|
|
indicator.Reset();
|
|
|
|
TestHelper.AssertIndicatorIsInDefaultState(indicator);
|
|
}
|
|
|
|
[Test]
|
|
public override void TimeMovesForward()
|
|
{
|
|
var indicator = CreateIndicator();
|
|
|
|
for (var i = 10; i > 0; i--)
|
|
{
|
|
var price = 500m;
|
|
var optionPrice = Math.Max(price - 450, 0) * 1.1m;
|
|
|
|
indicator.Update(new IndicatorDataPoint(_symbol, _reference.AddDays(1 + i), optionPrice));
|
|
indicator.Update(new IndicatorDataPoint(_underlying, _reference.AddDays(1 + i), price));
|
|
}
|
|
|
|
Assert.AreEqual(2, indicator.Samples);
|
|
}
|
|
|
|
[Test]
|
|
public override void WarmsUpProperly()
|
|
{
|
|
var indicator = CreateIndicator();
|
|
var warmUpPeriod = (indicator as IIndicatorWarmUpPeriodProvider)?.WarmUpPeriod;
|
|
|
|
if (!warmUpPeriod.HasValue)
|
|
{
|
|
Assert.Ignore($"{indicator.Name} is not IIndicatorWarmUpPeriodProvider");
|
|
return;
|
|
}
|
|
|
|
// warmup period is 5 + 1
|
|
for (var i = 1; i <= warmUpPeriod.Value; i++)
|
|
{
|
|
var time = _reference.AddDays(i);
|
|
var price = 500m;
|
|
var optionPrice = Math.Max(price - 450, 0) * 1.1m;
|
|
|
|
indicator.Update(new IndicatorDataPoint(_symbol, time, optionPrice));
|
|
|
|
Assert.IsFalse(indicator.IsReady);
|
|
|
|
indicator.Update(new IndicatorDataPoint(_underlying, time, price));
|
|
|
|
Assert.IsTrue(indicator.IsReady);
|
|
}
|
|
|
|
Assert.AreEqual(2 * warmUpPeriod.Value, indicator.Samples);
|
|
}
|
|
|
|
[Test]
|
|
public override void WarmUpIndicatorProducesConsistentResults()
|
|
{
|
|
var algo = CreateAlgorithm();
|
|
|
|
algo.SetStartDate(2015, 12, 24);
|
|
algo.SetEndDate(2015, 12, 24);
|
|
|
|
var underlying = Symbols.GOOG;
|
|
|
|
var expiration = new DateTime(2015, 12, 24);
|
|
var strike = 650m;
|
|
|
|
var option = Symbol.CreateOption(underlying, Market.USA, OptionStyle.American, OptionRight.Put, strike, expiration);
|
|
SymbolList = [option];
|
|
|
|
var symbolsForWarmUp = new List<Symbol> { option, option.Underlying };
|
|
// Define the risk-free rate and dividend yield models
|
|
var risk = new ConstantRiskFreeRateInterestRateModel(12);
|
|
var dividend = new ConstantDividendYieldModel(12);
|
|
|
|
// Create the first indicator using the risk and dividend models
|
|
var firstIndicator = CreateIndicator(risk, dividend);
|
|
var period = (firstIndicator as IIndicatorWarmUpPeriodProvider)?.WarmUpPeriod;
|
|
if (period == null || period == 0)
|
|
{
|
|
Assert.Ignore($"{firstIndicator.Name}, Skipping this test because it's not applicable.");
|
|
}
|
|
|
|
// Warm up the first indicator
|
|
algo.WarmUpIndicator(symbolsForWarmUp, firstIndicator, Resolution.Daily);
|
|
|
|
// Warm up the second indicator manually
|
|
var secondIndicator = CreateIndicator(risk, dividend);
|
|
var history = algo.History(symbolsForWarmUp, period.Value, Resolution.Daily).ToList();
|
|
foreach (var slice in history)
|
|
{
|
|
foreach (var symbol in symbolsForWarmUp)
|
|
{
|
|
secondIndicator.Update(slice[symbol]);
|
|
}
|
|
}
|
|
SymbolList.Clear();
|
|
|
|
// Assert that the indicators are ready
|
|
Assert.IsTrue(firstIndicator.IsReady);
|
|
Assert.IsTrue(secondIndicator.IsReady);
|
|
if (!ValueCanBeZero)
|
|
{
|
|
Assert.AreNotEqual(firstIndicator.Current.Value, 0);
|
|
}
|
|
|
|
// Ensure that the first indicator has processed some data
|
|
Assert.AreNotEqual(firstIndicator.Samples, 0);
|
|
|
|
// Validate that both indicators have the same number of processed samples
|
|
Assert.AreEqual(firstIndicator.Samples, secondIndicator.Samples);
|
|
|
|
// Validate that both indicators produce the same final computed value
|
|
Assert.AreEqual(firstIndicator.Current.Value, secondIndicator.Current.Value);
|
|
}
|
|
|
|
[Test]
|
|
public override void WorksWithLowValues()
|
|
{
|
|
Symbol = _symbol;
|
|
base.WorksWithLowValues();
|
|
}
|
|
|
|
[Test]
|
|
public void UsesRiskFreeInterestRateModel()
|
|
{
|
|
const int count = 20;
|
|
var dates = Enumerable.Range(0, count).Select(i => new DateTime(2022, 11, 21, 10, 0, 0) + TimeSpan.FromDays(i)).ToList();
|
|
var interestRateValues = Enumerable.Range(0, count).Select(i => 0m + (10 - 0m) * (i / (count - 1m))).ToList();
|
|
|
|
var interestRateProviderMock = new Mock<IRiskFreeInterestRateModel>();
|
|
|
|
// Set up
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
interestRateProviderMock.Setup(x => x.GetInterestRate(dates[i])).Returns(interestRateValues[i]).Verifiable();
|
|
}
|
|
|
|
var indicator = CreateIndicator(interestRateProviderMock.Object);
|
|
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
indicator.Update(new IndicatorDataPoint(_symbol, dates[i], 80m + i));
|
|
indicator.Update(new IndicatorDataPoint(_underlying, dates[i], 500m + i));
|
|
Assert.AreEqual(interestRateValues[i], indicator.RiskFreeRate.Current.Value);
|
|
}
|
|
|
|
// Assert
|
|
Assert.IsTrue(indicator.IsReady);
|
|
interestRateProviderMock.Verify(x => x.GetInterestRate(It.IsAny<DateTime>()), Times.Exactly(dates.Count * RiskFreeRateUpdatesPerIteration));
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
interestRateProviderMock.Verify(x => x.GetInterestRate(dates[i]), Times.Exactly(RiskFreeRateUpdatesPerIteration));
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void UsesPythonDefinedRiskFreeInterestRateModel()
|
|
{
|
|
using var _ = Py.GIL();
|
|
|
|
var module = PyModule.FromString(Guid.NewGuid().ToString(), $@"
|
|
from AlgorithmImports import *
|
|
|
|
class TestRiskFreeInterestRateModel:
|
|
CallCount = 0
|
|
|
|
def GetInterestRate(self, date: datetime) -> float:
|
|
TestRiskFreeInterestRateModel.CallCount += 1
|
|
return 0.5
|
|
|
|
def getOptionIndicatorBaseIndicator(symbol: Symbol) -> OptionIndicatorBase:
|
|
return {typeof(T).Name}(symbol, TestRiskFreeInterestRateModel())
|
|
");
|
|
|
|
var iv = module.GetAttr("getOptionIndicatorBaseIndicator").Invoke(_symbol.ToPython()).GetAndDispose<T>();
|
|
var modelClass = module.GetAttr("TestRiskFreeInterestRateModel");
|
|
|
|
var reference = new DateTime(2022, 11, 21, 10, 0, 0);
|
|
for (int i = 0; i < 20; i++)
|
|
{
|
|
iv.Update(new IndicatorDataPoint(_symbol, reference + TimeSpan.FromMinutes(i), 10m + i));
|
|
iv.Update(new IndicatorDataPoint(_underlying, reference + TimeSpan.FromMinutes(i), 1000m + i));
|
|
Assert.AreEqual((i + 1) * RiskFreeRateUpdatesPerIteration, modelClass.GetAttr("CallCount").GetAndDispose<int>());
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void OptionIndicatorUsesAlgorithmsRiskFreeRateModelSetAfterIndicatorRegistration()
|
|
{
|
|
var algorithm = new QCAlgorithm();
|
|
algorithm.SubscriptionManager.SetDataManager(new DataManagerStub(algorithm));
|
|
|
|
var historyProvider = new SubscriptionDataReaderHistoryProvider();
|
|
historyProvider.Initialize(new HistoryProviderInitializeParameters(null, null,
|
|
TestGlobals.DataProvider, TestGlobals.DataCacheProvider, TestGlobals.MapFileProvider, TestGlobals.FactorFileProvider,
|
|
null, true, new DataPermissionManager(), algorithm.ObjectStore, algorithm.Settings));
|
|
algorithm.SetHistoryProvider(historyProvider);
|
|
|
|
algorithm.SetDateTime(_reference);
|
|
algorithm.AddEquity(_underlying.Value);
|
|
algorithm.AddOptionContract(_symbol);
|
|
algorithm.Settings.AutomaticIndicatorWarmUp = true;
|
|
|
|
// Register indicator
|
|
var indicator = CreateIndicator(algorithm);
|
|
|
|
// Setup risk free rate model
|
|
var interestRateProviderMock = new Mock<IRiskFreeInterestRateModel>();
|
|
interestRateProviderMock.Setup(x => x.GetInterestRate(_reference)).Verifiable();
|
|
|
|
// Update indicator
|
|
indicator.Update(new IndicatorDataPoint(_symbol, _reference, 30m));
|
|
indicator.Update(new IndicatorDataPoint(_underlying, _reference, 300m));
|
|
|
|
// Our interest rate provider shouldn't have been called yet since it's hasn't been set to the algorithm
|
|
interestRateProviderMock.Verify(x => x.GetInterestRate(_reference), Times.Never);
|
|
|
|
// Set the interest rate provider to the algorithm
|
|
algorithm.SetRiskFreeInterestRateModel(interestRateProviderMock.Object);
|
|
|
|
// Update indicator
|
|
indicator.Update(new IndicatorDataPoint(_symbol, _reference.AddDays(1), 30m));
|
|
indicator.Update(new IndicatorDataPoint(_underlying, _reference.AddDays(1), 300m));
|
|
|
|
// Our interest rate provider should have been called once by each update
|
|
interestRateProviderMock.Verify(x => x.GetInterestRate(_reference.AddDays(1)), Times.Exactly(RiskFreeRateUpdatesPerIteration));
|
|
}
|
|
|
|
[Test]
|
|
public void UsesDividendYieldModel()
|
|
{
|
|
const int count = 20;
|
|
var dates = Enumerable.Range(0, count).Select(i => new DateTime(2022, 11, 21, 10, 0, 0) + TimeSpan.FromDays(i)).ToList();
|
|
var dividends = Enumerable.Range(0, count).Select(i => 0m + (10 - 0m) * (i / (count - 1m))).ToList();
|
|
|
|
var dividendYieldProviderMock = new Mock<IDividendYieldModel>();
|
|
|
|
// Set up
|
|
var underlyingBasePrice = 500m;
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
dividendYieldProviderMock.Setup(x => x.GetDividendYield(dates[i], underlyingBasePrice + i)).Returns(dividends[i]).Verifiable();
|
|
}
|
|
|
|
var indicator = CreateIndicator(new ConstantRiskFreeRateInterestRateModel(0.05m), dividendYieldProviderMock.Object);
|
|
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
indicator.Update(new IndicatorDataPoint(_symbol, dates[i], 80m + i));
|
|
indicator.Update(new IndicatorDataPoint(_underlying, dates[i], underlyingBasePrice + i));
|
|
Assert.AreEqual(dividends[i], indicator.DividendYield.Current.Value);
|
|
}
|
|
|
|
// Assert
|
|
Assert.IsTrue(indicator.IsReady);
|
|
dividendYieldProviderMock.Verify(x => x.GetDividendYield(It.IsAny<DateTime>(), It.IsAny<decimal>()), Times.Exactly(dates.Count * DividendYieldUpdatesPerIteration));
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
dividendYieldProviderMock.Verify(x => x.GetDividendYield(dates[i], underlyingBasePrice + i), Times.Exactly(DividendYieldUpdatesPerIteration));
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void UsesPythonDefinedDividendYieldModel()
|
|
{
|
|
using var _ = Py.GIL();
|
|
|
|
var module = PyModule.FromString(Guid.NewGuid().ToString(), $@"
|
|
from AlgorithmImports import *
|
|
|
|
class TestDividendYieldModel:
|
|
call_count = 0
|
|
|
|
def get_dividend_yield(self, date: datetime, price: float) -> float:
|
|
TestDividendYieldModel.call_count += 1
|
|
return 0.5
|
|
|
|
def get_option_indicator_base_indicator(symbol: Symbol) -> OptionIndicatorBase:
|
|
return {typeof(T).Name}(symbol, InterestRateProvider(), TestDividendYieldModel())
|
|
");
|
|
|
|
var indicator = module.GetAttr("get_option_indicator_base_indicator").Invoke(_symbol.ToPython()).GetAndDispose<T>();
|
|
var modelClass = module.GetAttr("TestDividendYieldModel");
|
|
|
|
var reference = new DateTime(2022, 11, 21, 10, 0, 0);
|
|
for (int i = 0; i < 20; i++)
|
|
{
|
|
indicator.Update(new IndicatorDataPoint(_symbol, reference + TimeSpan.FromMinutes(i), 10m + i));
|
|
indicator.Update(new IndicatorDataPoint(_underlying, reference + TimeSpan.FromMinutes(i), 1000m + i));
|
|
Assert.AreEqual((i + 1) * DividendYieldUpdatesPerIteration, modelClass.GetAttr("call_count").GetAndDispose<int>());
|
|
}
|
|
}
|
|
|
|
// Not used
|
|
protected override string TestFileName => null;
|
|
protected override string TestColumnName => null;
|
|
|
|
[Test]
|
|
public override void ComparesAgainstExternalData()
|
|
{
|
|
// Not used
|
|
}
|
|
|
|
[Test]
|
|
public override void ComparesAgainstExternalDataAfterReset()
|
|
{
|
|
// Not used
|
|
}
|
|
|
|
public override void AcceptsRenkoBarsAsInput()
|
|
{
|
|
// Not used
|
|
}
|
|
|
|
public override void AcceptsVolumeRenkoBarsAsInput()
|
|
{
|
|
// Not used
|
|
}
|
|
}
|
|
}
|