IIndicatorsAccessor¶

public abstract interface IIndicatorsAccessor

public abstract TIndicator GetIndicator(object[] parameterValues)

 private SampleSMA sma;
 protected override void Initialize()
 {
     sma = Indicators.GetIndicator<SampleSMA>(Source, Period);
 }
 public override void Calculate(int index)
 {
     // Display the sma result on the chart
     Result[index] = sma.Result[index];
 }

public abstract TIndicator GetIndicator(Bars bars, object[] parameterValues)

 private SampleSMA sma;
 protected override void Initialize()
 {
     sma = Indicators.GetIndicator<SampleSMA>(Source, Period);
 }
 public override void Calculate(int index)
 {
     // Display the sma result on the chart
     Result[index] = sma.Result[index];
 }

public abstract TIndicator GetIndicator(MarketSeries marketSeries, object[] parameterValues)

public abstract MovingAverage MovingAverage(DataSeries source, int periods, MovingAverageType maType)

 private MovingAverage ma;
 protected override void Initialize()
 {
     ma = Indicators.MovingAverage(MarketSeries.Close, 50, MovingAverageType.Simple);
 }
 public override void Calculate(int index)
 {
     // Display the ma result on the chart
     Result[index] = ma.Result[index];
 }

public abstract ExponentialMovingAverage ExponentialMovingAverage(DataSeries source, int periods)

 private ExponentialMovingAverage ema;
 protected override void Initialize()
 {
     ema = Indicators.ExponentialMovingAverage(MarketSeries.Close, 50);
 }
 public override void Calculate(int index)
 {
     // Display the ema result on the chart
     Result[index] = ema.Result[index];
 }

public abstract WeightedMovingAverage WeightedMovingAverage(DataSeries source, int periods)

 private WeigthedMovingAverage wma;
 protected override void Initialize()
 {
     wma = Indicators.WeightedMovingAverage(MarketSeries.Close, 20);
 }
 public override void Calculate(int index)
 {
     Result[index] = wma.Result[index];
 }

public abstract SimpleMovingAverage SimpleMovingAverage(DataSeries source, int periods)

 private SimpleMovingAverage sma;
 protected override void Initialize()
 {
     sma = Indicators.SimpleMovingAverage(MarketSeries.Close, 14);
 }
 public override void Calculate(int index)
 {
     Result[index] = sma.Result[index];
 }

public abstract TriangularMovingAverage TriangularMovingAverage(DataSeries source, int periods)

 [Parameter]
 public DataSeries Source { get; set; }
 [Output("Result", Color = Colors.Orange)]
 public IndicatorDataSeries Result { get; set; }
 private SimpleMovingAverage tma;
 protected override void Initialize()
 {
     tma = Indicators.TriangularMovingAverage(Source, 10);
 }
 public override void Calculate(int index)
 {
     Result[index] = tma.Result[index];
 }

public abstract HighMinusLow HighMinusLow()

 [Output("Main")]
 public IndicatorDataSeries Result {get; set;}
 private HighMinusLow highMinusLow;
 protected override void Initialize()
 {
     highMinusLow = Indicators.HighMinusLow();
 }
 public override void Calculate(int index)
 {
     // Display the High Minus Low indicator on the chart
     Result[index] = highMinusLow.Result[index];
     Print("Previous HighMinusLow is: {0}", highMinusLow.Result[index-1]);
 }
 //...

public abstract HighMinusLow HighMinusLow(Bars bars)

 [Output("Main")]
 public IndicatorDataSeries Result {get; set;}
 private HighMinusLow highMinusLow;
 protected override void Initialize()
 {
     highMinusLow = Indicators.HighMinusLow(Bars);
 }
 public override void Calculate(int index)
 {
     // Display the High Minus Low indicator on the chart
     Result[index] = highMinusLow.Result[index];
     Print("Previous HighMinusLow is: {0}", highMinusLow.Result[index-1]);
 }
 //...

public abstract HighMinusLow HighMinusLow(MarketSeries marketSeries)

public abstract TrueRange TrueRange()

 [Output("Main")]
 public IndicatorDataSeries Result {get; set;}
 private TrueRange trueRange;
 protected override void Initialize()
 {
     trueRange = Indicators.TrueRange();
 }
 public override void Calculate(int index)
 {
     Result[index] = trueRange.Result[index];
 }

public abstract TrueRange TrueRange(Bars bars)

 [Output("Main")]
 public IndicatorDataSeries Result {get; set;}
 private TrueRange trueRange;
 protected override void Initialize()
 {
     trueRange = Indicators.TrueRange(Bars);
 }
 public override void Calculate(int index)
 {
     Result[index] = trueRange.Result[index];
 }

public abstract TrueRange TrueRange(MarketSeries marketSeries)

public abstract WellesWilderSmoothing WellesWilderSmoothing(DataSeries source, int periods)

 [Output("Main")]
 public IndicatorDataSeries Result {get; set;}
 private WellesWilderSmoothing wws;
 protected override void Initialize()
 {
     wws = Indicators.WellesWilderSmoothing(MarketSeries.Close, 14);
 }
 public override void Calculate(int index)
 {
     Result[index] = wws.Result[index];
 }

public abstract HullMovingAverage HullMovingAverage(DataSeries source, int periods)

 [Output("Main")]
 public IndicatorDataSeries Result {get; set;}
 private HullMovingAverage hma;
 protected override void Initialize()
 {
     hma = Indicators.HullMovingAverage(MarketSeries.Close, 14);
 }
 public override void Calculate(int index)
 {
     Result[index] = hma.Result[index];
 }

public abstract SwingIndex SwingIndex(int limitMoveValue)

 [Parameter(DefaultValue = 20)]
 public int limitMove { get; set; }
 [Output("Main")]
 public IndicatorDataSeries Result { get; set; }
 private SwingIndex si;
 protected override void Initialize()
 {
    si = Indicators.SwingIndex(limitMove);
 }
 public override void Calculate(int index)
 {
     //This stores current SwingIndex to Result Output
     Result[index] = si.Result[index];
     // This prints previous SwingIndex to log
     Print("Previous SwingIndex is: {0}", si.Result[index-1]);
 }

public abstract SwingIndex SwingIndex(Bars bars, int limitMoveValue)

 [Parameter(DefaultValue = 20)]
 public int limitMove { get; set; }
 [Output("Main")]
 public IndicatorDataSeries Result { get; set; }
 private SwingIndex si;
 protected override void Initialize()
 {
    si = Indicators.SwingIndex(Bars, limitMove);
 }
 public override void Calculate(int index)
 {
     //This stores current SwingIndex to Result Output
     Result[index] = si.Result[index];
     // This prints previous SwingIndex to log
     Print("Previous SwingIndex is: {0}", si.Result[index-1]);
 }

public abstract SwingIndex SwingIndex(MarketSeries marketSeries, int limitMoveValue)

public abstract AccumulativeSwingIndex AccumulativeSwingIndex(int limitMoveValue)

 [Parameter(DefaultValue = 20)]
 public int limitMove { get; set; }
 [Output("Main")]
 public IndicatorDataSeries Result { get; set; }
 private AccumulativeSwingIndex asi;
 protected override void Initialize()
 {
    asi = Indicators.AccumulativeSwingIndex(limitMove);
 }
 public override void Calculate(int index)
 {
     //This stores current AccumulativeSwingIndex to Result Output
     Result[index] = asi.Result[index];
     // This prints previous AccumulativeSwingIndex to log
     Print("Previous AccumulativeSwingIndex is: {0}", asi.Result[index-1]);
 }

public abstract AccumulativeSwingIndex AccumulativeSwingIndex(Bars bars, int limitMoveValue)

 [Parameter(DefaultValue = 20)]
 public int limitMove { get; set; }
 [Output("Main")]
 public IndicatorDataSeries Result { get; set; }
 private AccumulativeSwingIndex asi;
 protected override void Initialize()
 {
    asi = Indicators.AccumulativeSwingIndex(Bars, limitMove);
 }
 public override void Calculate(int index)
 {
     //This stores current AccumulativeSwingIndex to Result Output
     Result[index] = asi.Result[index];
     // This prints previous AccumulativeSwingIndex to log
     Print("Previous AccumulativeSwingIndex is: {0}", asi.Result[index-1]);
 }

public abstract AccumulativeSwingIndex AccumulativeSwingIndex(MarketSeries marketSeries, int limitMoveValue)

public abstract Aroon Aroon(int periods)

 [Parameter("Period")]
 public int Period { get; set; }
 private Aroon aroon;
 protected override void OnStart()
 {
     aroon = Indicators.Aroon(Period);
 }
 protected override void OnTick()
 {
     if (aroon.Up.LastValue < aroon.Down.LastValue)
     {
         //Do something
     }
 }

public abstract Aroon Aroon(Bars bars, int periods)

 [Parameter("Period")]
 public int Period { get; set; }
 private Aroon aroon;
 protected override void OnStart()
 {
     aroon = Indicators.Aroon(Bars, Period);
 }
 protected override void OnTick()
 {
     if (aroon.Up.LastValue < aroon.Down.LastValue)
     {
         //Do something
     }
 }

public abstract Aroon Aroon(MarketSeries marketSeries, int periods)

public abstract StandardDeviation StandardDeviation(DataSeries source, int periods, MovingAverageType maType)

 [Parameter]
 public DataSeries Source { get; set; }
 [Parameter(DefaultValue = 20)]
 public int Period { get; set; }
 [Parameter("MA Type", DefaultValue = MovingAverageType.Simple)]
 public MovingAverageType MAType { get; set; }
 private StandardDeviation sd;
 private double previousValue;
 protected override void OnStart()
 {
     sd = Indicators.StandardDeviation(Source, Period, MAType);
     previousValue = sd.Result.LastValue;
 }
 protected override void OnBar()
 {
     //If StandardDeviation has increased
     if (sd.Result.LastValue > previousValue)
     {
         //Do something
     }
     //...
     previousValue = sd.Result.LastValue;
 }

public abstract BollingerBands BollingerBands(DataSeries source, int periods, double standardDeviations, MovingAverageType maType)

 [Parameter]
 public DataSeries Source { get; set; }
 [Parameter(DefaultValue = 20)]
 public int period { get; set; }
 [Parameter("MA Type", DefaultValue = MovingAverageType.Simple)]
 public MovingAverageType MAType { get; set; }
 [Parameter(DefaultValue = 1.5)]
 public double std { get; set; }
 private BollingerBands bb;
 protected override void OnStart()
 {
     bb = Indicators.BollingerBands(Source, period, std, MAType);
 }
 protected override void OnTick()
 {
     if (bb.Top.LastValue > Symbol.Bid)
     {
         Print("Bid price is higher than the Top Bollinger Band");
     }
 }

public abstract RelativeStrengthIndex RelativeStrengthIndex(DataSeries source, int periods)

 [Parameter]
 public DataSeries Source { get; set; }
 [Parameter(DefaultValue = 20)]
 public int Period { get; set; }
 private RelativeStrengthIndex rsi;
 protected override void OnStart()
 {
     rsi = Indicators.RelativeStrengthIndex(Source, Period);
 }
 protected override void OnBar()
 {
     if (rsi.Result.LastValue > 70)
     {
         Print("RSI is higher than 70");
     }
 }

public abstract TimeSeriesMovingAverage TimeSeriesMovingAverage(DataSeries source, int periods)

 [Parameter]
 public DataSeries Source { get; set; }
 [Parameter(DefaultValue = 14)]
 public int periodfast { get; set; }
 [Parameter(DefaultValue = 24)]
 public int periodslow { get; set; }
 private TimeSeriesMovingAverage tsmfast;
 private TimeSeriesMovingAverage tsmslow;
 protected override void OnStart()
 {
     tsmfast = Indicators.TimeSeriesMovingAverage(Source, periodfast);
     tsmslow = Indicators.TimeSeriesMovingAverage(Source, periodslow);
 }
 protected override void OnTick()
 {
     //If TSMA with period 14 moves above TSMA with period 24
     if (tsmfast.Result.LastValue > tsmslow.Result.LastValue)
     {
         //Do something
     }
 }

public abstract LinearRegressionForecast LinearRegressionForecast(DataSeries source, int periods)

 private LinearRegressionForecast lrForecast;
 protected override void OnStart()
 {
     lrForecast = Indicators.LinearRegressionForecast(Source, Period);
 }
 protected override void OnTick()
 {
     Print("LRF Last Value = {0}", lrForecast.Result.LastValue);
 }

public abstract LinearRegressionRSquared LinearRegressionRSquared(DataSeries source, int periods)

 private LinearRegressionRSquared rSquared;
 protected override void OnStart()
 {
     rSquared = Indicators.LinearRegressionRSquared(Source, Period);
 }
 protected override void OnTick()
 {
     Print("R squared is {0}", rSquared.Result.LastValue)
 }

public abstract PriceROC PriceROC(DataSeries source, int periods)

 [Parameter("Source")]
 public DataSeries Source { get; set; }
 [Parameter(DefaultValue = 14)]
 public int Period { get; set; }
 private PriceROC priceROC;
 protected override void OnStart()
 {
     priceROC = Indicators.PriceROC(Source, Period);
 }
 protected override void OnTick()
 {
    Print("{0}", priceROC.Result.LastValue);
 }

public abstract Vidya Vidya(DataSeries source, int periods, double r2Scale)

 [Parameter]
 public DataSeries Price { get; set; }
 [Parameter("Period", DefaultValue = 14)]
 public int Period { get; set; }
 [Parameter("Sigma", DefaultValue = 0.65, MinValue = 0.1, MaxValue = 0.95)]
 public double Sigma { get; set; }
 private Vidya vidya;
 protected override void OnStart()
 {
     vidya = Indicators.Vidya(Price, Period, Sigma);
 }
 protected override void OnTick()
 {
     //If vidya is greater than a specific value
     if (vidya.Result.LastValue > Value)
     {
         //Do something
         Print("LastValue {0}", vidya.Result.LastValue);
     }
     //...
 }

public abstract UltimateOscillator UltimateOscillator(int cycle1, int cycle2, int cycle3)

 protected override void OnStart()
 {
    ultimateOscillator = Indicators.UltimateOscillator(Cycle1,Cycle2,Cycle3);
 }
 protected override void OnTick()
 {
    double currentValue = ultimateOscillator.Result.LastValue;
     //...
 }

public abstract UltimateOscillator UltimateOscillator(Bars bars, int cycle1, int cycle2, int cycle3)

 protected override void OnStart()
 {
    ultimateOscillator = Indicators.UltimateOscillator(Bars, Cycle1,Cycle2,Cycle3);
 }
 protected override void OnTick()
 {
    double currentValue = ultimateOscillator.Result.LastValue;
     //...
 }

public abstract UltimateOscillator UltimateOscillator(MarketSeries marketSeries, int cycle1, int cycle2, int cycle3)

public abstract DirectionalMovementSystem DirectionalMovementSystem(int periods)

 private DirectionalMovementSystem _dms;
 private double _dIplus;
 private double _dIminus;
 [Parameter("ADX Period", DefaultValue = 14)]
 public int Period { get; set; }
 protected override void OnStart()
 {
     _dms = Indicators.DirectionalMovementSystem(Period);
 }
 protected override void OnTick()
 {
     _dIplus = _dms.DIPlus.LastValue;
     _dIminus = _dms.DIMinus.LastValue;
     if (_dIminus > _dIplus)
     {
         // Do something
     }
     //...
 }

public abstract DirectionalMovementSystem DirectionalMovementSystem(Bars bars, int periods)

 private DirectionalMovementSystem _dms;
 private double _dIplus;
 private double _dIminus;
 [Parameter("ADX Period", DefaultValue = 14)]
 public int Period { get; set; }
 protected override void OnStart()
 {
     _dms = Indicators.DirectionalMovementSystem(Bars, Period);
 }
 protected override void OnTick()
 {
     _dIplus = _dms.DIPlus.LastValue;
     _dIminus = _dms.DIMinus.LastValue;
     if (_dIminus > _dIplus)
     {
         // Do something
     }
     //...
 }

public abstract DirectionalMovementSystem DirectionalMovementSystem(MarketSeries marketSeries, int periods)

public abstract ParabolicSAR ParabolicSAR(double minAf, double maxAf)

 private ParabolicSAR parabolicSar;
 //...
 protected override void OnStart()
 {
    parabolicSar = Indicators.ParabolicSAR(minaf, maxaf);
 }
 protected override void OnTick()
 {
    double currentValue = parabolicSar.Result.LastValue;
     //...
 }

public abstract ParabolicSAR ParabolicSAR(Bars bars, double minAf, double maxAf)

 private ParabolicSAR parabolicSar;
 //...
 protected override void OnStart()
 {
    parabolicSar = Indicators.ParabolicSAR(Bars, minaf, maxaf);
 }
 protected override void OnTick()
 {
    double currentValue = parabolicSar.Result.LastValue;
     //...
 }

public abstract ParabolicSAR ParabolicSAR(MarketSeries marketSeries, double minAf, double maxAf)

public abstract StochasticOscillator StochasticOscillator(int kPeriods, int kSlowing, int dPeriods, MovingAverageType maType)

 private StochasticOscillator stochastic;
 //...
 protected override void OnStart()
 {
    stochastic = Indicators.StochasticOscillator(kPeriods, kSlowing, dPeriods, maType);
 }
 protected override void OnTick()
 {
    double percentD = stochastic.PercentD.LastValue;
    double percentK = stochastic.PercentK.LastValue;
     //...
 }

public abstract StochasticOscillator StochasticOscillator(Bars bars, int kPeriods, int kSlowing, int dPeriods, MovingAverageType maType)

 private StochasticOscillator stochastic;
 //...
 protected override void OnStart()
 {
    stochastic = Indicators.StochasticOscillator(Bars, kPeriods, kSlowing, dPeriods, maType);
 }
 protected override void OnTick()
 {
    double percentD = stochastic.PercentD.LastValue;
    double percentK = stochastic.PercentK.LastValue;
     //...
 }

public abstract StochasticOscillator StochasticOscillator(MarketSeries marketSeries, int kPeriods, int kSlowing, int dPeriods, MovingAverageType maType)

public abstract MomentumOscillator MomentumOscillator(DataSeries source, int periods)

 private MomentumOscillator _momentum;
 protected override void OnStart()
 {
     _momentum = Indicators.MomentumOscillator(MarketSeries.Close, 14);
 }
 protected override void OnTick()
 {
     double momentum = _momentum.Result[index];
 }

public abstract MedianPrice MedianPrice()

 private MedianPrice medianPrice;
 protected override void OnStart()
 {
     medianPrice = Indicators.MedianPrice();
 }
 protected override void OnTick()
 {
     double price = medianPrice.Result[index];
 }

public abstract MedianPrice MedianPrice(Bars bars)

 private MedianPrice medianPrice;
 protected override void OnStart()
 {
     medianPrice = Indicators.MedianPrice(Bars);
 }
 protected override void OnTick()
 {
     double price = medianPrice.Result[index];
 }

public abstract MedianPrice MedianPrice(MarketSeries marketSeries)

public abstract WilliamsAccumulationDistribution WilliamsAccumulationDistribution()

 private WilliamsAccumulationDistribution williamsAD;
 protected override void OnStart()
 {
     williamsAD = Indicators.WilliamsAccumulationDistribution();
 }
 protected override void OnTick()
 {
     double result = williamsAD.Result[index];
 }

public abstract WilliamsAccumulationDistribution WilliamsAccumulationDistribution(Bars bars)

 private WilliamsAccumulationDistribution williamsAD;
 protected override void OnStart()
 {
     williamsAD = Indicators.WilliamsAccumulationDistribution(Bars);
 }
 protected override void OnTick()
 {
     double result = williamsAD.Result[index];
 }

public abstract WilliamsAccumulationDistribution WilliamsAccumulationDistribution(MarketSeries marketSeries)

public abstract FractalChaosBands FractalChaosBands()

 private FractalChaosBands fractalChaosBands;
    protected override void Initialize()
    {
        fractalChaosBands = Indicators.FractalChaosBands();
    }
 public override void Calculate(int index)
    {
        Print("Fractal Chaos Bands High = {0}", fractalChaosBands.High[index]);
    }

public abstract FractalChaosBands FractalChaosBands(Bars bars)

 private FractalChaosBands fractalChaosBands;
    protected override void Initialize()
    {
        fractalChaosBands = Indicators.FractalChaosBands(Bars);
    }
 public override void Calculate(int index)
    {
        Print("Fractal Chaos Bands High = {0}", fractalChaosBands.High[index]);
    }

public abstract FractalChaosBands FractalChaosBands(int periods)