/*

* 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 QuantConnect.Data;

using QuantConnect.Data.Consolidators;

using QuantConnect.Data.Market;

using QuantConnect.Indicators;

using System;

using System.Collections.Generic;

using System.Linq;

using QuantConnect.Util;

using static QuantConnect.StringExtensions;

namespace QuantConnect.Algorithm

{

public partial class QCAlgorithm

{

private bool _isWarmUpIndicatorWarningSent = false;

/// <summary>

/// Gets whether or not WarmUpIndicator is allowed to warm up indicators/>

/// </summary>

public bool EnableAutomaticIndicatorWarmUp { get; set; } = false;

/// <summary>

/// Creates a new Acceleration Bands indicator.

/// </summary>

/// <param name="symbol">The symbol whose Acceleration Bands we want.</param>

/// <param name="period">The period of the three moving average (middle, upper and lower band).</param>

/// <param name="width">A coefficient specifying the distance between the middle band and upper or lower bands.</param>

/// <param name="movingAverageType">Type of the moving average.</param>

/// <param name="resolution">The resolution.</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to casting the input value to a TradeBar.</param>

/// <returns></returns>

public AccelerationBands ABANDS(Symbol symbol, int period, decimal width = 4, MovingAverageType movingAverageType = MovingAverageType.Simple,

Resolution? resolution = null, Func<IBaseData, TradeBar> selector = null)

{

var name = CreateIndicatorName(symbol, $"ABANDS({period},{width})", resolution);

var accelerationBands = new AccelerationBands(name, period, width, movingAverageType);

RegisterIndicator(symbol, accelerationBands, resolution, selector);

if (EnableAutomaticIndicatorWarmUp)

{

WarmUpIndicator(symbol, accelerationBands, resolution);

}

return accelerationBands;

}

/// <summary>

/// Creates a new AccumulationDistribution indicator.

/// </summary>

/// <param name="symbol">The symbol whose AD we want</param>

/// <param name="resolution">The resolution</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to the Value property of BaseData (x => x.Value)</param>

/// <returns>The AccumulationDistribution indicator for the requested symbol over the speified period</returns>

public AccumulationDistribution AD(Symbol symbol, Resolution? resolution = null, Func<IBaseData, TradeBar> selector = null)

{

var name = CreateIndicatorName(symbol, "AD", resolution);

var accumulationDistribution = new AccumulationDistribution(name);

RegisterIndicator(symbol, accumulationDistribution, resolution, selector);

if (EnableAutomaticIndicatorWarmUp)

{

WarmUpIndicator(symbol, accumulationDistribution, resolution);

}

return accumulationDistribution;

}

/// <summary>

/// Creates a new AccumulationDistributionOscillator indicator.

/// </summary>

/// <param name="symbol">The symbol whose ADOSC we want</param>

/// <param name="fastPeriod">The fast moving average period</param>

/// <param name="slowPeriod">The slow moving average period</param>

/// <param name="resolution">The resolution</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to the Value property of BaseData (x => x.Value)</param>

/// <returns>The AccumulationDistributionOscillator indicator for the requested symbol over the speified period</returns>

public AccumulationDistributionOscillator ADOSC(Symbol symbol, int fastPeriod, int slowPeriod, Resolution? resolution = null, Func<IBaseData, TradeBar> selector = null)

{

var name = CreateIndicatorName(symbol, $"ADOSC({fastPeriod},{slowPeriod})", resolution);

var accumulationDistributionOscillator = new AccumulationDistributionOscillator(name, fastPeriod, slowPeriod);

RegisterIndicator(symbol, accumulationDistributionOscillator, resolution, selector);

if (EnableAutomaticIndicatorWarmUp)

{

WarmUpIndicator(symbol, accumulationDistributionOscillator, resolution);

}

return accumulationDistributionOscillator;

}

/// <summary>

/// Creates a new Average Directional Index indicator.

/// The indicator will be automatically updated on the given resolution.

/// </summary>

/// <param name="symbol">The symbol whose Average Directional Index we seek</param>

/// <param name="resolution">The resolution.</param>

/// <param name="period">The period over which to compute the Average Directional Index</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to casting the input value to a TradeBar</param>

/// <returns>The Average Directional Index indicator for the requested symbol.</returns>

public AverageDirectionalIndex ADX(Symbol symbol, int period, Resolution? resolution = null, Func<IBaseData, IBaseDataBar> selector = null)

{

var name = CreateIndicatorName(symbol, $"ADX({period})", resolution);

var averageDirectionalIndex = new AverageDirectionalIndex(name, period);

RegisterIndicator(symbol, averageDirectionalIndex, resolution, selector);

if (EnableAutomaticIndicatorWarmUp)

{

WarmUpIndicator(symbol, averageDirectionalIndex, resolution);

}

return averageDirectionalIndex;

}

/// <summary>

/// Creates a new Awesome Oscillator from the specified periods.

/// </summary>

/// <param name="symbol">The symbol whose Awesome Oscillator we seek</param>

/// <param name="resolution">The resolution.</param>

/// <param name="fastPeriod">The period of the fast moving average associated with the AO</param>

/// <param name="slowPeriod">The period of the slow moving average associated with the AO</param>

/// <param name="type">The type of moving average used when computing the fast and slow term. Defaults to simple moving average.</param>

public AwesomeOscillator AO(Symbol symbol, int slowPeriod, int fastPeriod, MovingAverageType type, Resolution? resolution = null, Func<IBaseData, IBaseDataBar> selector = null)

{

var name = CreateIndicatorName(symbol, $"AO({fastPeriod},{slowPeriod},{type})", resolution);

var awesomeOscillator = new AwesomeOscillator(name, fastPeriod, slowPeriod, type);

RegisterIndicator(symbol, awesomeOscillator, resolution, selector);

if (EnableAutomaticIndicatorWarmUp)

{

WarmUpIndicator(symbol, awesomeOscillator, resolution);

}

return awesomeOscillator;

}

/// <summary>

/// Creates a new AverageDirectionalMovementIndexRating indicator.

/// </summary>

/// <param name="symbol">The symbol whose ADXR we want</param>

/// <param name="period">The period over which to compute the ADXR</param>

/// <param name="resolution">The resolution.</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to the Value property of BaseData (x => x.Value)</param>

/// <returns>The AverageDirectionalMovementIndexRating indicator for the requested symbol over the specified period</returns>

public AverageDirectionalMovementIndexRating ADXR(Symbol symbol, int period, Resolution? resolution = null, Func<IBaseData, IBaseDataBar> selector = null)

{

var name = CreateIndicatorName(symbol, $"ADXR({period})", resolution);

var averageDirectionalMovementIndexRating = new AverageDirectionalMovementIndexRating(name, period);

RegisterIndicator(symbol, averageDirectionalMovementIndexRating, resolution, selector);

if (EnableAutomaticIndicatorWarmUp)

{

WarmUpIndicator(symbol, averageDirectionalMovementIndexRating, resolution);

}

return averageDirectionalMovementIndexRating;

}

/// <summary>

/// Creates a new ArnaudLegouxMovingAverage indicator.

/// </summary>

/// <param name="symbol">The symbol whose ALMA we want</param>

/// <param name="period">int - the number of periods to calculate the ALMA</param>

/// <param name="sigma"> int - this parameter is responsible for the shape of the curve coefficients.

/// </param>

/// <param name="offset">

/// decimal - This parameter allows regulating the smoothness and high sensitivity of the

/// Moving Average. The range for this parameter is [0, 1].

/// </param>

/// <param name="resolution">The resolution</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to the Value property of BaseData (x => x.Value)</param>

/// <returns>The ArnaudLegouxMovingAverage indicator for the requested symbol over the specified period</returns>

public ArnaudLegouxMovingAverage ALMA(Symbol symbol, int period, int sigma = 6, decimal offset = 0.85m, Resolution? resolution = null, Func<IBaseData, decimal> selector = null)

{

var name = CreateIndicatorName(symbol, $"ALMA({period},{sigma},{offset})", resolution);

var arnaudLegouxMovingAverage = new ArnaudLegouxMovingAverage(name, period, sigma, offset);

RegisterIndicator(symbol, arnaudLegouxMovingAverage, resolution, selector);

if (EnableAutomaticIndicatorWarmUp)

{

WarmUpIndicator(symbol, arnaudLegouxMovingAverage, resolution);

}

return arnaudLegouxMovingAverage;

}

/// <summary>

/// Creates a new AbsolutePriceOscillator indicator.

/// </summary>

/// <param name="symbol">The symbol whose APO we want</param>

/// <param name="fastPeriod">The fast moving average period</param>

/// <param name="slowPeriod">The slow moving average period</param>

/// <param name="movingAverageType">The type of moving average to use</param>

/// <param name="resolution">The resolution</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to the Value property of BaseData (x => x.Value)</param>

/// <returns>The AbsolutePriceOscillator indicator for the requested symbol over the specified period</returns>

public AbsolutePriceOscillator APO(Symbol symbol, int fastPeriod, int slowPeriod, MovingAverageType movingAverageType, Resolution? resolution = null, Func<IBaseData, decimal> selector = null)

{

var name = CreateIndicatorName(symbol, $"APO({fastPeriod},{slowPeriod})", resolution);

var absolutePriceOscillator = new AbsolutePriceOscillator(name, fastPeriod, slowPeriod, movingAverageType);

RegisterIndicator(symbol, absolutePriceOscillator, resolution, selector);

if (EnableAutomaticIndicatorWarmUp)

{

WarmUpIndicator(symbol, absolutePriceOscillator, resolution);

}

return absolutePriceOscillator;

}

/// <summary>

/// Creates a new AroonOscillator indicator which will compute the AroonUp and AroonDown (as well as the delta)

/// </summary>

/// <param name="symbol">The symbol whose Aroon we seek</param>

/// <param name="period">The look back period for computing number of periods since maximum and minimum</param>

/// <param name="resolution">The resolution</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to casting the input value to a TradeBar</param>

/// <returns>An AroonOscillator configured with the specied periods</returns>

public AroonOscillator AROON(Symbol symbol, int period, Resolution? resolution = null, Func<IBaseData, IBaseDataBar> selector = null)

{

return AROON(symbol, period, period, resolution, selector);

}

/// <summary>

/// Creates a new AroonOscillator indicator which will compute the AroonUp and AroonDown (as well as the delta)

/// </summary>

/// <param name="symbol">The symbol whose Aroon we seek</param>

/// <param name="upPeriod">The look back period for computing number of periods since maximum</param>

/// <param name="downPeriod">The look back period for computing number of periods since minimum</param>

/// <param name="resolution">The resolution</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to casting the input value to a TradeBar</param>

/// <returns>An AroonOscillator configured with the specified periods</returns>

public AroonOscillator AROON(Symbol symbol, int upPeriod, int downPeriod, Resolution? resolution = null, Func<IBaseData, IBaseDataBar> selector = null)

{

var name = CreateIndicatorName(symbol, $"AROON({upPeriod},{downPeriod})", resolution);

var aroonOscillator = new AroonOscillator(name, upPeriod, downPeriod);

RegisterIndicator(symbol, aroonOscillator, resolution, selector);

if (EnableAutomaticIndicatorWarmUp)

{

WarmUpIndicator(symbol, aroonOscillator, resolution);

}

return aroonOscillator;

}

/// <summary>

/// Creates a new AverageTrueRange indicator for the symbol. The indicator will be automatically

/// updated on the given resolution.

/// </summary>

/// <param name="symbol">The symbol whose ATR we want</param>

/// <param name="period">The smoothing period used to smooth the computed TrueRange values</param>

/// <param name="type">The type of smoothing to use</param>

/// <param name="resolution">The resolution</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to casting the input value to a TradeBar</param>

/// <returns>A new AverageTrueRange indicator with the specified smoothing type and period</returns>

public AverageTrueRange ATR(Symbol symbol, int period, MovingAverageType type = MovingAverageType.Simple, Resolution? resolution = null, Func<IBaseData, IBaseDataBar> selector = null)

{

var name = CreateIndicatorName(symbol, $"ATR({period})", resolution);

var averageTrueRange = new AverageTrueRange(name, period, type);

RegisterIndicator(symbol, averageTrueRange, resolution, selector);

if (EnableAutomaticIndicatorWarmUp)

{

WarmUpIndicator(symbol, averageTrueRange, resolution);

}

return averageTrueRange;

}

/// <summary>

/// Creates a new BollingerBands indicator which will compute the MiddleBand, UpperBand, LowerBand, and StandardDeviation

/// </summary>

/// <param name="symbol">The symbol whose BollingerBands we seek</param>

/// <param name="period">The period of the standard deviation and moving average (middle band)</param>

/// <param name="k">The number of standard deviations specifying the distance between the middle band and upper or lower bands</param>

/// <param name="movingAverageType">The type of moving average to be used</param>

/// <param name="resolution">The resolution</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to the Value property of BaseData (x => x.Value)</param>

/// <returns>A BollingerBands configured with the specified period</returns>

public BollingerBands BB(Symbol symbol, int period, decimal k, MovingAverageType movingAverageType = MovingAverageType.Simple, Resolution? resolution = null, Func<IBaseData, decimal> selector = null)

{

var name = CreateIndicatorName(symbol, $"BB({period},{k})", resolution);

var bollingerBands = new BollingerBands(name, period, k, movingAverageType);

RegisterIndicator(symbol, bollingerBands, resolution, selector);

if (EnableAutomaticIndicatorWarmUp)

{

WarmUpIndicator(symbol, bollingerBands, resolution);

}

return bollingerBands;

}

/// <summary>

/// Creates a new Balance Of Power indicator.

/// The indicator will be automatically updated on the given resolution.

/// </summary>

/// <param name="symbol">The symbol whose Balance Of Power we seek</param>

/// <param name="resolution">The resolution.</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to casting the input value to a TradeBar</param>

/// <returns>The Balance Of Power indicator for the requested symbol.</returns>

public BalanceOfPower BOP(Symbol symbol, Resolution? resolution = null, Func<IBaseData, IBaseDataBar> selector = null)

{

var name = CreateIndicatorName(symbol, "BOP", resolution);

var balanceOfPower = new BalanceOfPower(name);

RegisterIndicator(symbol, balanceOfPower, resolution, selector);

if (EnableAutomaticIndicatorWarmUp)

{

WarmUpIndicator(symbol, balanceOfPower, resolution);

}

return balanceOfPower;

}

/// <summary>

/// Initializes a new instance of the <see cref="CoppockCurve"/> indicator

/// </summary>

/// <param name="symbol">The symbol whose Coppock Curve we want</param>

/// <param name="shortRocPeriod">The period for the short ROC</param>

/// <param name="longRocPeriod">The period for the long ROC</param>

/// <param name="lwmaPeriod">The period for the LWMA</param>

/// <param name="resolution">The resolution</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to casting the input value to a TradeBar</param>

/// <returns>The Coppock Curve indicator for the requested symbol over the specified period</returns>

public CoppockCurve CC(Symbol symbol, int shortRocPeriod = 11, int longRocPeriod = 14, int lwmaPeriod = 10, Resolution? resolution = null,

Func<IBaseData, decimal> selector = null)

{

var name = CreateIndicatorName(symbol, $"CC({shortRocPeriod},{longRocPeriod},{lwmaPeriod})", resolution);

var coppockCurve = new CoppockCurve(name, shortRocPeriod, longRocPeriod, lwmaPeriod);

RegisterIndicator(symbol, coppockCurve, resolution, selector);

if (EnableAutomaticIndicatorWarmUp)

{

WarmUpIndicator(symbol, coppockCurve, resolution);

}

return coppockCurve;

}

/// <summary>

/// Creates a new CommodityChannelIndex indicator. The indicator will be automatically

/// updated on the given resolution.

/// </summary>

/// <param name="symbol">The symbol whose CCI we want</param>

/// <param name="period">The period over which to compute the CCI</param>

/// <param name="movingAverageType">The type of moving average to use in computing the typical price average</param>

/// <param name="resolution">The resolution</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to casting the input value to a TradeBar</param>

/// <returns>The CommodityChannelIndex indicator for the requested symbol over the specified period</returns>

public CommodityChannelIndex CCI(Symbol symbol, int period, MovingAverageType movingAverageType = MovingAverageType.Simple, Resolution? resolution = null, Func<IBaseData, IBaseDataBar> selector = null)

{

var name = CreateIndicatorName(symbol, $"CCI({period})", resolution);

var commodityChannelIndex = new CommodityChannelIndex(name, period, movingAverageType);

RegisterIndicator(symbol, commodityChannelIndex, resolution, selector);

if (EnableAutomaticIndicatorWarmUp)

{

WarmUpIndicator(symbol, commodityChannelIndex, resolution);

}

return commodityChannelIndex;

}

/// <summary>

/// Creates a new ChaikinMoneyFlow indicator.

/// </summary>

/// <param name="symbol">The symbol whose CMF we want</param>

/// <param name="period">The period over which to compute the CMF</param>

/// <param name="resolution">The resolution</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to casting the input value to a TradeBar</param>

/// <returns>The ChaikinMoneyFlow indicator for the requested symbol over the specified period</returns>

public ChaikinMoneyFlow CMF(Symbol symbol, int period, Resolution? resolution = null, Func<IBaseData, TradeBar> selector = null)

{

var name = CreateIndicatorName(symbol, $"CMF({period})", resolution);

var chaikinMoneyFlow = new ChaikinMoneyFlow(name, period);

RegisterIndicator(symbol, chaikinMoneyFlow, resolution, selector);

if (EnableAutomaticIndicatorWarmUp)

{

WarmUpIndicator(symbol, chaikinMoneyFlow, resolution);

}

return chaikinMoneyFlow;

}

/// <summary>

/// Creates a new ChandeMomentumOscillator indicator.

/// </summary>

/// <param name="symbol">The symbol whose CMO we want</param>

/// <param name="period">The period over which to compute the CMO</param>

/// <param name="resolution">The resolution</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to the Value property of BaseData (x => x.Value)</param>

/// <returns>The ChandeMomentumOscillator indicator for the requested symbol over the specified period</returns>

public ChandeMomentumOscillator CMO(Symbol symbol, int period, Resolution? resolution = null, Func<IBaseData, decimal> selector = null)

{

var name = CreateIndicatorName(symbol, $"CMO({period})", resolution);

var chandeMomentumOscillator = new ChandeMomentumOscillator(name, period);

RegisterIndicator(symbol, chandeMomentumOscillator, resolution, selector);

if (EnableAutomaticIndicatorWarmUp)

{

WarmUpIndicator(symbol, chandeMomentumOscillator, resolution);

}

return chandeMomentumOscillator;

}

///<summary>

/// Creates a new DeMarker Indicator (DEM), an oscillator-type indicator measuring changes in terms of an asset's

/// High and Low tradebar values.

///</summary>

/// <param name="symbol">The symbol whose DEM we seek.</param>

/// <param name="period">The period of the moving average implemented</param>

/// <param name="movingAverageType">Specifies the type of moving average to be used</param>

/// <param name="resolution">The resolution.</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to casting the input value to a TradeBar</param>

/// <returns>The DeMarker indicator for the requested symbol.</returns>

public DeMarkerIndicator DEM(Symbol symbol, int period, MovingAverageType type, Resolution? resolution = null, Func<IBaseData, TradeBar> selector = null)

{

var name = CreateIndicatorName(symbol, $"DEM({period},{type})", resolution);

var deMarkerIndicator = new DeMarkerIndicator(name, period, type);

RegisterIndicator(symbol, deMarkerIndicator, resolution, selector);

if (EnableAutomaticIndicatorWarmUp)

{

WarmUpIndicator(symbol, deMarkerIndicator, resolution);

}

return deMarkerIndicator;

}

/// <summary>

/// Creates a new Donchian Channel indicator which will compute the Upper Band and Lower Band.

/// The indicator will be automatically updated on the given resolution.

/// </summary>

/// <param name="symbol">The symbol whose Donchian Channel we seek.</param>

/// <param name="upperPeriod">The period over which to compute the upper Donchian Channel.</param>

/// <param name="lowerPeriod">The period over which to compute the lower Donchian Channel.</param>

/// <param name="resolution">The resolution.</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to casting the input value to a TradeBar</param>

/// <returns>The Donchian Channel indicator for the requested symbol.</returns>

public DonchianChannel DCH(Symbol symbol, int upperPeriod, int lowerPeriod, Resolution? resolution = null, Func<IBaseData, IBaseDataBar> selector = null)

{

var name = CreateIndicatorName(symbol, $"DCH({upperPeriod},{lowerPeriod})", resolution);

var donchianChannel = new DonchianChannel(name, upperPeriod, lowerPeriod);

RegisterIndicator(symbol, donchianChannel, resolution, selector);

if (EnableAutomaticIndicatorWarmUp)

{

WarmUpIndicator(symbol, donchianChannel, resolution);

}

return donchianChannel;

}

/// <summary>

/// Overload shorthand to create a new symmetric Donchian Channel indicator which

/// has the upper and lower channels set to the same period length.

/// </summary>

/// <param name="symbol">The symbol whose Donchian Channel we seek.</param>

/// <param name="period">The period over which to compute the Donchian Channel.</param>

/// <param name="resolution">The resolution.</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to casting the input value to a TradeBar</param>

/// <returns>The Donchian Channel indicator for the requested symbol.</returns>

public DonchianChannel DCH(Symbol symbol, int period, Resolution? resolution = null, Func<IBaseData, IBaseDataBar> selector = null)

{

return DCH(symbol, period, period, resolution, selector);

}

/// <summary>

/// Creates a new DoubleExponentialMovingAverage indicator.

/// </summary>

/// <param name="symbol">The symbol whose DEMA we want</param>

/// <param name="period">The period over which to compute the DEMA</param>

/// <param name="resolution">The resolution</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to the Value property of BaseData (x => x.Value)</param>

/// <returns>The DoubleExponentialMovingAverage indicator for the requested symbol over the specified period</returns>

public DoubleExponentialMovingAverage DEMA(Symbol symbol, int period, Resolution? resolution = null, Func<IBaseData, decimal> selector = null)

{

var name = CreateIndicatorName(symbol, $"DEMA({period})", resolution);

var doubleExponentialMovingAverage = new DoubleExponentialMovingAverage(name, period);

RegisterIndicator(symbol, doubleExponentialMovingAverage, resolution, selector);

if (EnableAutomaticIndicatorWarmUp)

{

WarmUpIndicator(symbol, doubleExponentialMovingAverage, resolution);

}

return doubleExponentialMovingAverage;

}

/// <summary>

/// Creates a new <see cref="DetrendedPriceOscillator"/> indicator.

/// </summary>

/// <param name="symbol">The symbol whose DPO we want</param>

/// <param name="period">The period over which to compute the DPO</param>

/// <param name="resolution">The resolution</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to the Value property of BaseData (x => x.Value)</param>

/// <returns>A new registered DetrendedPriceOscillator indicator for the requested symbol over the specified period</returns>

public DetrendedPriceOscillator DPO(Symbol symbol, int period, Resolution? resolution = null, Func<IBaseData, decimal> selector = null)

{

var name = CreateIndicatorName(symbol, $"DPO({period})", resolution);

var detrendedPriceOscillator = new DetrendedPriceOscillator(name, period);

RegisterIndicator(symbol, detrendedPriceOscillator, resolution, selector);

if (EnableAutomaticIndicatorWarmUp)

{

WarmUpIndicator(symbol, detrendedPriceOscillator, resolution);

}

return detrendedPriceOscillator;

}

/// <summary>

/// Creates an ExponentialMovingAverage indicator for the symbol. The indicator will be automatically

/// updated on the given resolution.

/// </summary>

/// <param name="symbol">The symbol whose EMA we want</param>

/// <param name="period">The period of the EMA</param>

/// <param name="resolution">The resolution</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to the Value property of BaseData (x => x.Value)</param>

/// <returns>The ExponentialMovingAverage for the given parameters</returns>

public ExponentialMovingAverage EMA(Symbol symbol, int period, Resolution? resolution = null, Func<IBaseData, decimal> selector = null)

{

return EMA(symbol, period, ExponentialMovingAverage.SmoothingFactorDefault(period), resolution, selector);

}

/// <summary>

/// Creates an ExponentialMovingAverage indicator for the symbol. The indicator will be automatically

/// updated on the given resolution.

/// </summary>

/// <param name="symbol">The symbol whose EMA we want</param>

/// <param name="period">The period of the EMA</param>

/// <param name="smoothingFactor">The percentage of data from the previous value to be carried into the next value</param>

/// <param name="resolution">The resolution</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to the Value property of BaseData (x => x.Value)</param>

/// <returns>The ExponentialMovingAverage for the given parameters</returns>

public ExponentialMovingAverage EMA(Symbol symbol, int period, decimal smoothingFactor, Resolution? resolution = null, Func<IBaseData, decimal> selector = null)

{

var name = CreateIndicatorName(symbol, $"EMA({period})", resolution);

var exponentialMovingAverage = new ExponentialMovingAverage(name, period, smoothingFactor);

RegisterIndicator(symbol, exponentialMovingAverage, resolution, selector);

if (EnableAutomaticIndicatorWarmUp)

{

WarmUpIndicator(symbol, exponentialMovingAverage, resolution);

}

return exponentialMovingAverage;

}

/// <summary>

/// Creates an EaseOfMovementValue indicator for the symbol. The indicator will be automatically

/// updated on the given resolution.

/// </summary>

/// <param name="symbol">The symbol whose EMV we want</param>

/// <param name="period">The period of the EMV</param>

/// <param name="scale">The length of the outputed value</param>

/// <param name="resolution">The resolution</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to the Value property of BaseData (x => x.Value)</param>

/// <returns>The EaseOfMovementValue indicator for the given parameters</returns>

public EaseOfMovementValue EMV(Symbol symbol, int period = 1, int scale = 10000, Resolution? resolution = null, Func<IBaseData, TradeBar> selector = null)

{

var name = CreateIndicatorName(symbol, $"EMV({period}, {scale})", resolution);

var easeOfMovementValue = new EaseOfMovementValue(name, period, scale);

RegisterIndicator(symbol, easeOfMovementValue, resolution, selector);

if (EnableAutomaticIndicatorWarmUp)

{

WarmUpIndicator(symbol, easeOfMovementValue, resolution);

}

return easeOfMovementValue;

}

/// <summary>

/// Creates a new FilteredIdentity indicator for the symbol The indicator will be automatically

/// updated on the symbol's subscription resolution

/// </summary>

/// <param name="symbol">The symbol whose values we want as an indicator</param>

/// <param name="selector">Selects a value from the BaseData, if null defaults to the .Value property (x => x.Value)</param>

/// <param name="filter">Filters the IBaseData send into the indicator, if null defaults to true (x => true) which means no filter</param>

/// <param name="fieldName">The name of the field being selected</param>

/// <returns>A new FilteredIdentity indicator for the specified symbol and selector</returns>

public FilteredIdentity FilteredIdentity(Symbol symbol, Func<IBaseData, IBaseDataBar> selector = null, Func<IBaseData, bool> filter = null, string fieldName = null)

{

var resolution = GetSubscription(symbol).Resolution;

return FilteredIdentity(symbol, resolution, selector, filter, fieldName);

}

/// <summary>

/// Creates a new FilteredIdentity indicator for the symbol The indicator will be automatically

/// updated on the symbol's subscription resolution

/// </summary>

/// <param name="symbol">The symbol whose values we want as an indicator</param>

/// <param name="resolution">The desired resolution of the data</param>

/// <param name="selector">Selects a value from the BaseData, if null defaults to the .Value property (x => x.Value)</param>

/// <param name="filter">Filters the IBaseData send into the indicator, if null defaults to true (x => true) which means no filter</param>

/// <param name="fieldName">The name of the field being selected</param>

/// <returns>A new FilteredIdentity indicator for the specified symbol and selector</returns>

public FilteredIdentity FilteredIdentity(Symbol symbol, Resolution resolution, Func<IBaseData, IBaseDataBar> selector = null, Func<IBaseData, bool> filter = null, string fieldName = null)

{

var name = CreateIndicatorName(symbol, fieldName ?? "close", resolution);

var filteredIdentity = new FilteredIdentity(name, filter);

RegisterIndicator<IBaseData>(symbol, filteredIdentity, resolution, selector);

return filteredIdentity;

}

/// <summary>

/// Creates a new FilteredIdentity indicator for the symbol The indicator will be automatically

/// updated on the symbol's subscription resolution

/// </summary>

/// <param name="symbol">The symbol whose values we want as an indicator</param>

/// <param name="resolution">The desired resolution of the data</param>

/// <param name="selector">Selects a value from the BaseData, if null defaults to the .Value property (x => x.Value)</param>

/// <param name="filter">Filters the IBaseData send into the indicator, if null defaults to true (x => true) which means no filter</param>

/// <param name="fieldName">The name of the field being selected</param>

/// <returns>A new FilteredIdentity indicator for the specified symbol and selector</returns>

public FilteredIdentity FilteredIdentity(Symbol symbol, TimeSpan resolution, Func<IBaseData, IBaseDataBar> selector = null, Func<IBaseData, bool> filter = null, string fieldName = null)

{

var name = Invariant($"{symbol}({fieldName ?? "close"}_{resolution})");

var filteredIdentity = new FilteredIdentity(name, filter);

RegisterIndicator<IBaseData>(symbol, filteredIdentity, ResolveConsolidator(symbol, resolution), selector);

return filteredIdentity;

}

/// <summary>

/// Creates an FisherTransform indicator for the symbol.

/// The indicator will be automatically updated on the given resolution.

/// </summary>

/// <param name="symbol">The symbol whose FisherTransform we want</param>

/// <param name="period">The period of the FisherTransform</param>

/// <param name="resolution">The resolution</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to the Value property of BaseData (x => x.Value)</param>

/// <returns>The FisherTransform for the given parameters</returns>

public FisherTransform FISH(Symbol symbol, int period, Resolution? resolution = null, Func<IBaseData, IBaseDataBar> selector = null)

{

var name = CreateIndicatorName(symbol, $"FISH({period})", resolution);

var fisherTransform = new FisherTransform(name, period);

RegisterIndicator(symbol, fisherTransform, resolution, selector);

if (EnableAutomaticIndicatorWarmUp)

{

WarmUpIndicator(symbol, fisherTransform, resolution);

}

return fisherTransform;

}

/// <summary>

/// Creates an FractalAdaptiveMovingAverage (FRAMA) indicator for the symbol. The indicator will be automatically

/// updated on the given resolution.

/// </summary>

/// <param name="symbol">The symbol whose FRAMA we want</param>

/// <param name="period">The period of the FRAMA</param>

/// <param name="longPeriod">The long period of the FRAMA</param>

/// <param name="resolution">The resolution</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to the Value property of BaseData (x => x.Value)</param>

/// <returns>The FRAMA for the given parameters</returns>

public FractalAdaptiveMovingAverage FRAMA(Symbol symbol, int period, int longPeriod = 198, Resolution? resolution = null, Func<IBaseData, IBaseDataBar> selector = null)

{

var name = CreateIndicatorName(symbol, $"FRAMA({period},{longPeriod})", resolution);

var fractalAdaptiveMovingAverage = new FractalAdaptiveMovingAverage(name, period, longPeriod);

RegisterIndicator(symbol, fractalAdaptiveMovingAverage, resolution, selector);

if (EnableAutomaticIndicatorWarmUp)

{

WarmUpIndicator(symbol, fractalAdaptiveMovingAverage, resolution);

}

return fractalAdaptiveMovingAverage;

}

/// <summary>

/// Creates a new Heikin-Ashi indicator.

/// </summary>

/// <param name="symbol">The symbol whose Heikin-Ashi we want</param>

/// <param name="resolution">The resolution</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to the Value property of BaseData (x => x.Value)</param>

/// <returns>The Heikin-Ashi indicator for the requested symbol over the specified period</returns>

public HeikinAshi HeikinAshi(Symbol symbol, Resolution? resolution = null, Func<IBaseData, TradeBar> selector = null)

{

var name = CreateIndicatorName(symbol, "HA", resolution);

var heikinAshi = new HeikinAshi(name);

RegisterIndicator(symbol, heikinAshi, resolution, selector);

if (EnableAutomaticIndicatorWarmUp)

{

WarmUpIndicator(symbol, heikinAshi, resolution);

}

return heikinAshi;

}

/// <summary>

/// Creates a new HullMovingAverage indicator. The Hull moving average is a series of nested weighted moving averages, is fast and smooth.

/// </summary>

/// <param name="symbol">The symbol whose Hull moving average we want</param>

/// <param name="period">The period over which to compute the Hull moving average</param>

/// <param name="resolution">The resolution</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to the Value property of BaseData (x => x.Value)</param>

/// <returns></returns>

public HullMovingAverage HMA(Symbol symbol, int period, Resolution? resolution = null, Func<IBaseData, decimal> selector = null)

{

var name = CreateIndicatorName(symbol, $"HMA({period})", resolution);

var hullMovingAverage = new HullMovingAverage(name, period);

RegisterIndicator(symbol, hullMovingAverage, resolution, selector);

if (EnableAutomaticIndicatorWarmUp)

{

WarmUpIndicator(symbol, hullMovingAverage, resolution);

}

return hullMovingAverage;

}

/// <summary>

/// Creates a new IchimokuKinkoHyo indicator for the symbol. The indicator will be automatically

/// updated on the given resolution.

/// </summary>

/// <param name="symbol">The symbol whose ICHIMOKU we want</param>

/// <param name="tenkanPeriod">The period to calculate the Tenkan-sen period</param>

/// <param name="kijunPeriod">The period to calculate the Kijun-sen period</param>

/// <param name="senkouAPeriod">The period to calculate the Tenkan-sen period</param>

/// <param name="senkouBPeriod">The period to calculate the Tenkan-sen period</param>

/// <param name="senkouADelayPeriod">The period to calculate the Tenkan-sen period</param>

/// <param name="senkouBDelayPeriod">The period to calculate the Tenkan-sen period</param>

/// <param name="resolution">The resolution</param>

/// <returns>A new IchimokuKinkoHyo indicator with the specified periods and delays</returns>

public IchimokuKinkoHyo ICHIMOKU(Symbol symbol, int tenkanPeriod, int kijunPeriod, int senkouAPeriod, int senkouBPeriod, int senkouADelayPeriod, int senkouBDelayPeriod, Resolution? resolution = null)

{

var name = CreateIndicatorName(symbol, $"ICHIMOKU({tenkanPeriod},{kijunPeriod},{senkouAPeriod},{senkouBPeriod},{senkouADelayPeriod},{senkouBDelayPeriod})", resolution);

var ichimokuKinkoHyo = new IchimokuKinkoHyo(name, tenkanPeriod, kijunPeriod, senkouAPeriod, senkouBPeriod, senkouADelayPeriod, senkouBDelayPeriod);

RegisterIndicator(symbol, ichimokuKinkoHyo, resolution);

if (EnableAutomaticIndicatorWarmUp)

{

WarmUpIndicator(symbol, ichimokuKinkoHyo, resolution);

}

return ichimokuKinkoHyo;

}

/// <summary>

/// Creates a new Identity indicator for the symbol The indicator will be automatically

/// updated on the symbol's subscription resolution

/// </summary>

/// <param name="symbol">The symbol whose values we want as an indicator</param>

/// <param name="selector">Selects a value from the BaseData, if null defaults to the .Value property (x => x.Value)</param>

/// <param name="fieldName">The name of the field being selected</param>

/// <returns>A new Identity indicator for the specified symbol and selector</returns>

public Identity Identity(Symbol symbol, Func<IBaseData, decimal> selector = null, string fieldName = null)

{

var resolution = GetSubscription(symbol).Resolution;

return Identity(symbol, resolution, selector, fieldName);

}

/// <summary>

/// Creates a new Identity indicator for the symbol The indicator will be automatically

/// updated on the symbol's subscription resolution

/// </summary>

/// <param name="symbol">The symbol whose values we want as an indicator</param>

/// <param name="resolution">The desired resolution of the data</param>

/// <param name="selector">Selects a value from the BaseData, if null defaults to the .Value property (x => x.Value)</param>

/// <param name="fieldName">The name of the field being selected</param>

/// <returns>A new Identity indicator for the specified symbol and selector</returns>

public Identity Identity(Symbol symbol, Resolution resolution, Func<IBaseData, decimal> selector = null, string fieldName = null)

{

var name = CreateIndicatorName(symbol, fieldName ?? "close", resolution);

var identity = new Identity(name);

RegisterIndicator(symbol, identity, resolution, selector);

return identity;

}

/// <summary>

/// Creates a new Identity indicator for the symbol The indicator will be automatically

/// updated on the symbol's subscription resolution

/// </summary>

/// <param name="symbol">The symbol whose values we want as an indicator</param>

/// <param name="resolution">The desired resolution of the data</param>

/// <param name="selector">Selects a value from the BaseData, if null defaults to the .Value property (x => x.Value)</param>

/// <param name="fieldName">The name of the field being selected</param>

/// <returns>A new Identity indicator for the specified symbol and selector</returns>

public Identity Identity(Symbol symbol, TimeSpan resolution, Func<IBaseData, decimal> selector = null, string fieldName = null)

{

var name = Invariant($"{symbol}({fieldName ?? "close"},{resolution})");

var identity = new Identity(name);

RegisterIndicator(symbol, identity, ResolveConsolidator(symbol, resolution), selector);

return identity;

}

/// <summary>

/// Creates a new KaufmanAdaptiveMovingAverage indicator.

/// </summary>

/// <param name="symbol">The symbol whose KAMA we want</param>

/// <param name="period">The period of the Efficiency Ratio (ER) of KAMA</param>

/// <param name="resolution">The resolution</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to the Value property of BaseData (x => x.Value)</param>

/// <returns>The KaufmanAdaptiveMovingAverage indicator for the requested symbol over the specified period</returns>

public KaufmanAdaptiveMovingAverage KAMA(Symbol symbol, int period, Resolution? resolution = null, Func<IBaseData, decimal> selector = null)

{

return KAMA(symbol, period, 2, 30, resolution, selector);

}

/// <summary>

/// Creates a new KaufmanAdaptiveMovingAverage indicator.

/// </summary>

/// <param name="symbol">The symbol whose KAMA we want</param>

/// <param name="period">The period of the Efficiency Ratio (ER)</param>

/// <param name="fastEmaPeriod">The period of the fast EMA used to calculate the Smoothing Constant (SC)</param>

/// <param name="slowEmaPeriod">The period of the slow EMA used to calculate the Smoothing Constant (SC)</param>

/// <param name="resolution">The resolution</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to the Value property of BaseData (x => x.Value)</param>

/// <returns>The KaufmanAdaptiveMovingAverage indicator for the requested symbol over the specified period</returns>

public KaufmanAdaptiveMovingAverage KAMA(Symbol symbol, int period, int fastEmaPeriod, int slowEmaPeriod, Resolution? resolution = null, Func<IBaseData, decimal> selector = null)

{

var name = CreateIndicatorName(symbol, $"KAMA({period},{fastEmaPeriod},{slowEmaPeriod})", resolution);

var kaufmanAdaptiveMovingAverage = new KaufmanAdaptiveMovingAverage(name, period, fastEmaPeriod, slowEmaPeriod);

RegisterIndicator(symbol, kaufmanAdaptiveMovingAverage, resolution, selector);

if (EnableAutomaticIndicatorWarmUp)

{

WarmUpIndicator(symbol, kaufmanAdaptiveMovingAverage, resolution);

}

return kaufmanAdaptiveMovingAverage;

}

/// <summary>

/// Creates a new Keltner Channels indicator.

/// The indicator will be automatically updated on the given resolution.

/// </summary>

/// <param name="symbol">The symbol whose Keltner Channel we seek</param>

/// <param name="period">The period over which to compute the Keltner Channels</param>

/// <param name="k">The number of multiples of the <see cref="AverageTrueRange"/> from the middle band of the Keltner Channels</param>

/// <param name="movingAverageType">Specifies the type of moving average to be used as the middle line of the Keltner Channel</param>

/// <param name="resolution">The resolution.</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to casting the input value to a TradeBar</param>

/// <returns>The Keltner Channel indicator for the requested symbol.</returns>

public KeltnerChannels KCH(Symbol symbol, int period, decimal k, MovingAverageType movingAverageType = MovingAverageType.Simple, Resolution? resolution = null, Func<IBaseData, IBaseDataBar> selector = null)

{

var name = CreateIndicatorName(symbol, $"KCH({period},{k})", resolution);

var keltnerChannels = new KeltnerChannels(name, period, k, movingAverageType);

RegisterIndicator(symbol, keltnerChannels, resolution, selector);

if (EnableAutomaticIndicatorWarmUp)

{

WarmUpIndicator(symbol, keltnerChannels, resolution);

}

return keltnerChannels;

}

/// <summary>

/// Creates a new LogReturn indicator.

/// </summary>

/// <param name="symbol">The symbol whose log return we seek</param>

/// <param name="period">The period of the log return.</param>

/// <param name="resolution">The resolution.</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to casting the input value to a TradeBar.</param>

/// <returns>log return indicator for the requested symbol.</returns>

public LogReturn LOGR(Symbol symbol, int period, Resolution? resolution = null, Func<IBaseData, decimal> selector = null)

{

var name = CreateIndicatorName(symbol, $"LOGR({period})", resolution);

var logReturn = new LogReturn(name, period);

RegisterIndicator(symbol, logReturn, resolution, selector);

if (EnableAutomaticIndicatorWarmUp)

{

WarmUpIndicator(symbol, logReturn, resolution);

}

return logReturn;

}

/// <summary>

/// Creates and registers a new Least Squares Moving Average instance.

/// </summary>

/// <param name="symbol">The symbol whose LSMA we seek.</param>

/// <param name="period">The LSMA period. Normally 14.</param>

/// <param name="resolution">The resolution.</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to casting the input value to a TradeBar.</param>

/// <returns>A LeastSquaredMovingAverage configured with the specified period</returns>

public LeastSquaresMovingAverage LSMA(Symbol symbol, int period, Resolution? resolution = null, Func<IBaseData, decimal> selector = null)

{

var name = CreateIndicatorName(symbol, $"LSMA({period})", resolution);

var leastSquaresMovingAverage = new LeastSquaresMovingAverage(name, period);

RegisterIndicator(symbol, leastSquaresMovingAverage, resolution, selector);

if (EnableAutomaticIndicatorWarmUp)

{

WarmUpIndicator(symbol, leastSquaresMovingAverage, resolution);

}

return leastSquaresMovingAverage;

}

/// <summary>

/// Creates a new LinearWeightedMovingAverage indicator. This indicator will linearly distribute

/// the weights across the periods.

/// </summary>

/// <param name="symbol">The symbol whose LWMA we want</param>

/// <param name="period">The period over which to compute the LWMA</param>

/// <param name="resolution">The resolution</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to the Value property of BaseData (x => x.Value)</param>

/// <returns></returns>

public LinearWeightedMovingAverage LWMA(Symbol symbol, int period, Resolution? resolution = null, Func<IBaseData, decimal> selector = null)

{

var name = CreateIndicatorName(symbol, $"LWMA({period})", resolution);

var linearWeightedMovingAverage = new LinearWeightedMovingAverage(name, period);

if (EnableAutomaticIndicatorWarmUp)

{

WarmUpIndicator(symbol, linearWeightedMovingAverage, resolution);

}

RegisterIndicator(symbol, linearWeightedMovingAverage, resolution, selector);

return linearWeightedMovingAverage;

}

/// <summary>

/// Creates a MACD indicator for the symbol. The indicator will be automatically updated on the given resolution.

/// </summary>

/// <param name="symbol">The symbol whose MACD we want</param>

/// <param name="fastPeriod">The period for the fast moving average</param>

/// <param name="slowPeriod">The period for the slow moving average</param>

/// <param name="signalPeriod">The period for the signal moving average</param>

/// <param name="type">The type of moving average to use for the MACD</param>

/// <param name="resolution">The resolution</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to the Value property of BaseData (x => x.Value)</param>

/// <returns>The moving average convergence divergence between the fast and slow averages</returns>

public MovingAverageConvergenceDivergence MACD(Symbol symbol, int fastPeriod, int slowPeriod, int signalPeriod, MovingAverageType type = MovingAverageType.Exponential, Resolution? resolution = null, Func<IBaseData, decimal> selector = null)

{

var name = CreateIndicatorName(symbol, $"MACD({fastPeriod},{slowPeriod},{signalPeriod})", resolution);

var movingAverageConvergenceDivergence = new MovingAverageConvergenceDivergence(name, fastPeriod, slowPeriod, signalPeriod, type);

RegisterIndicator(symbol, movingAverageConvergenceDivergence, resolution, selector);

if (EnableAutomaticIndicatorWarmUp)

{

WarmUpIndicator(symbol, movingAverageConvergenceDivergence, resolution);

}

return movingAverageConvergenceDivergence;

}

/// <summary>

/// Creates a new MeanAbsoluteDeviation indicator.

/// </summary>

/// <param name="symbol">The symbol whose MeanAbsoluteDeviation we want</param>

/// <param name="period">The period over which to compute the MeanAbsoluteDeviation</param>

/// <param name="resolution">The resolution</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null defaults to the Value property of BaseData (x => x.Value)</param>

/// <returns>The MeanAbsoluteDeviation indicator for the requested symbol over the specified period</returns>

public MeanAbsoluteDeviation MAD(Symbol symbol, int period, Resolution? resolution = null, Func<IBaseData, decimal> selector = null)

{

var name = CreateIndicatorName(symbol, $"MAD({period})", resolution);

var meanAbsoluteDeviation = new MeanAbsoluteDeviation(name, period);

RegisterIndicator(symbol, meanAbsoluteDeviation, resolution, selector);

if (EnableAutomaticIndicatorWarmUp)

{

WarmUpIndicator(symbol, meanAbsoluteDeviation, resolution);

}

return meanAbsoluteDeviation;

}

/// <summary>

/// Creates a new Maximum indicator to compute the maximum value

/// </summary>

/// <param name="symbol">The symbol whose max we want</param>

/// <param name="period">The look back period over which to compute the max value</param>

/// <param name="resolution">The resolution</param>

/// <param name="selector">Selects a value from the BaseData to send into the indicator, if null and the symbol is of type TradeBar defaults to the High property,

/// otherwise it defaults to Value property of BaseData (x => x.Value)</param>

/// <returns>A Maximum indicator that compute the max value and the periods since the max value</returns>

public Maximum MAX(Symbol symbol, int period, Resolution? resolution = null, Func<IBaseData, decimal> selector = null)

{

var name = CreateIndicatorName(symbol, $"MAX({period})", resolution);

var maximum = new Maximum(name, period);

// assign a default value for the selector function

if (selector == null)

{