Beispiel #1
0
        public ITaLibOutput <(double[] upperBand, double[] middleBand, double[] lowerBand)> BollingerBands(Frequency unitType, int historiesLength, Core.MAType movingAverageType = Core.MAType.Sma, int timePeriod = 5, int nbDevUp = 2, int nbDevDown = 2)
        {
            var inputs = new IndicatorsInputs(database, historiesLength);

            database.FillMarketHistory(unitType, inputs.OutputArrayLength);

            double[] closingHistory = database.CurrentHistory
                                      .Select(bar => bar.ClosingPrice)
                                      .ToArray();

            var output = new TaLibOutput <(double[] upperBand, double[] middleBand, double[] lowerBand)> {
                Series = (upperBand : new double[inputs.OutputArrayLength],
                          middleBand : new double[inputs.OutputArrayLength],
                          lowerBand : new double[inputs.OutputArrayLength]),
                HistoryWasCustom = database.HistoryIsCustom
            };
            int outBeginningIndex = 0;
            int outNBElement      = 0;

            output.Outcome = Core.Bbands(startIdx: inputs.StartingIndex,
                                         endIdx: inputs.EndIndex,
                                         inReal: closingHistory,
                                         optInTimePeriod: timePeriod,
                                         optInNbDevUp: nbDevUp,
                                         optInNbDevDn: nbDevDown,
                                         optInMAType: movingAverageType,
                                         outBegIdx: out outBeginningIndex,
                                         outNBElement: out outNBElement,
                                         outRealUpperBand: output.Series.upperBand,
                                         outRealMiddleBand: output.Series.middleBand,
                                         outRealLowerBand: output.Series.lowerBand);
            output.AlgorithmsBeginningIndex = outBeginningIndex;
            output.NBElement = outNBElement;
            return(output);
        }
Beispiel #2
0
        public ITaLibOutput <double[]> HilbertTransformInstantaneousTrendline(Frequency unitType, int historiesLength)
        {
            var inputs = new IndicatorsInputs(database, historiesLength);

            database.FillMarketHistory(unitType, inputs.OutputArrayLength);

            double[] closingHistory = database.CurrentHistory
                                      .Select(bar => bar.ClosingPrice)
                                      .ToArray();

            var output = new TaLibOutput <double[]> {
                Series           = new double[inputs.OutputArrayLength],
                HistoryWasCustom = database.HistoryIsCustom
            };
            int outBeginningIndex = 0;
            int outNBElement      = 0;

            output.Outcome = Core.HtTrendline(startIdx: inputs.StartingIndex,
                                              endIdx: inputs.EndIndex,
                                              inReal: closingHistory,
                                              outBegIdx: out outBeginningIndex,
                                              outNBElement: out outNBElement,
                                              outReal: output.Series);
            output.AlgorithmsBeginningIndex = outBeginningIndex;
            output.NBElement = outNBElement;
            return(output);
        }
Beispiel #3
0
        public ITaLibOutput <(double[] mama, double[] fama)> MesaAdaptiveMovingAverage(Frequency unitType, int historiesLength, int fastLimit = 0, int slowLimit = 0)
        {
            var inputs = new IndicatorsInputs(database, historiesLength);

            database.FillMarketHistory(unitType, inputs.OutputArrayLength);

            double[] closingHistory = database.CurrentHistory
                                      .Select(bar => bar.ClosingPrice)
                                      .ToArray();

            var output = new TaLibOutput <(double[] mama, double[] fama)> {
                Series           = (mama : new double[inputs.OutputArrayLength], fama : new double[inputs.OutputArrayLength]),
                HistoryWasCustom = database.HistoryIsCustom
            };
            int outBeginningIndex = 0;
            int outNBElement      = 0;

            output.Outcome = Core.Mama(startIdx: inputs.StartingIndex,
                                       endIdx: inputs.EndIndex,
                                       inReal: closingHistory,
                                       optInFastLimit: fastLimit,
                                       optInSlowLimit: slowLimit,
                                       outBegIdx: out outBeginningIndex,
                                       outNBElement: out outNBElement,
                                       outFAMA: output.Series.fama,
                                       outMAMA: output.Series.mama);
            output.AlgorithmsBeginningIndex = outBeginningIndex;
            output.NBElement = outNBElement;
            return(output);
        }
        public ITaLibOutput <(double[] InPhase, double[] Quadrature)> HilbertTransformPhasorComponents(Frequency unitType, int historiesLength)
        {
            var inputs = new IndicatorsInputs(database, historiesLength);

            database.FillMarketHistory(unitType, inputs.OutputArrayLength);

            double[] closingHistory = database.CurrentHistory
                                      .Select(bar => bar.ClosingPrice)
                                      .ToArray();

            var output = new TaLibOutput <(double[] InPhase, double[] Quadrature)> {
                Series = (InPhase : new double[inputs.OutputArrayLength],
                          Quadrature : new double[inputs.OutputArrayLength]),
                HistoryWasCustom = database.HistoryIsCustom
            };
            int outBeginningIndex = 0;
            int outNBElement      = 0;

            output.Outcome = Core.HtPhasor(startIdx: inputs.StartingIndex,
                                           endIdx: inputs.EndIndex,
                                           inReal: closingHistory,
                                           outBegIdx: out outBeginningIndex,
                                           outNBElement: out outNBElement,
                                           outInPhase: output.Series.InPhase,
                                           outQuadrature: output.Series.Quadrature);
            output.AlgorithmsBeginningIndex = outBeginningIndex;
            output.NBElement = outNBElement;
            return(output);
        }
Beispiel #5
0
        public ITaLibOutput <double[]> MovingAverageWithVariablePeriod(Frequency unitType, double[] periodsPerPrices, int historiesLength, Core.MAType movingAverageType = Core.MAType.Sma, int minPeriod = 2, int maxPeriod = 30)
        {
            var inputs = new IndicatorsInputs(database, historiesLength);

            database.FillMarketHistory(unitType, inputs.OutputArrayLength);

            double[] closingHistory = database.CurrentHistory
                                      .Select(bar => bar.ClosingPrice)
                                      .ToArray();

            var output = new TaLibOutput <double[]> {
                Series           = new double[inputs.OutputArrayLength],
                HistoryWasCustom = database.HistoryIsCustom
            };
            int outBeginningIndex = 0;
            int outNBElement      = 0;

            output.Outcome = Core.MovingAverageVariablePeriod(startIdx: inputs.StartingIndex,
                                                              endIdx: inputs.EndIndex,
                                                              inReal: closingHistory,
                                                              inPeriods: periodsPerPrices,
                                                              optInMinPeriod: minPeriod,
                                                              optInMaxPeriod: maxPeriod,
                                                              optInMAType: movingAverageType,
                                                              outBegIdx: out outBeginningIndex,
                                                              outNBElement: out outNBElement,
                                                              outReal: output.Series);
            output.AlgorithmsBeginningIndex = outBeginningIndex;
            output.NBElement = outNBElement;
            return(output);
        }
Beispiel #6
0
        public ITaLibOutput <double[]> ParabolicSar(Frequency unitType, int historiesLength, int acceleration = 0, int maximum = 0)
        {
            var inputs = new IndicatorsInputs(database, historiesLength);

            database.FillMarketHistory(unitType, inputs.OutputArrayLength);

            double[] highs = database.CurrentHistory
                             .Select(bar => bar.PriceHigh)
                             .ToArray();

            double[] lows = database.CurrentHistory
                            .Select(bar => bar.PriceLow)
                            .ToArray();

            var output = new TaLibOutput <double[]> {
                Series           = new double[inputs.OutputArrayLength],
                HistoryWasCustom = database.HistoryIsCustom
            };
            int outBeginningIndex = 0;
            int outNBElement      = 0;

            output.Outcome = Core.Sar(startIdx: inputs.StartingIndex,
                                      endIdx: inputs.EndIndex,
                                      inHigh: highs,
                                      inLow: lows,
                                      optInAcceleration: acceleration,
                                      optInMaximum: maximum,
                                      outBegIdx: out outBeginningIndex,
                                      outNBElement: out outNBElement,
                                      outReal: output.Series);
            output.AlgorithmsBeginningIndex = outBeginningIndex;
            output.NBElement = outNBElement;
            return(output);
        }
Beispiel #7
0
        public ITaLibOutput <(double[] fastK, double[] fastD)> StochasticRelativeStrengthIndex(Frequency unitType, int historiesLength, Core.MAType fastDMaType = Core.MAType.Sma, int timePeriod = 14, int fastKPeriod = 5, int fastDPeriod = 0)
        {
            var inputs = new IndicatorsInputs(database, historiesLength);

            database.FillMarketHistory(unitType, inputs.OutputArrayLength);

            double[] closingHistory = database.CurrentHistory
                                      .Select(bar => bar.ClosingPrice)
                                      .ToArray();

            var output = new TaLibOutput <(double[] fastK, double[] fastD)> {
                Series           = (fastK : new double[inputs.OutputArrayLength], fastD : new double[inputs.OutputArrayLength]),
                HistoryWasCustom = database.HistoryIsCustom
            };
            int outBeginningIndex = 0;
            int outNBElement      = 0;

            output.Outcome = Core.StochRsi(startIdx: inputs.StartingIndex,
                                           endIdx: inputs.EndIndex,
                                           inReal: closingHistory,
                                           optInTimePeriod: timePeriod,
                                           optInFastK_Period: fastKPeriod,
                                           optInFastD_Period: fastDPeriod,
                                           optInFastD_MAType: fastDMaType,
                                           outBegIdx: out outBeginningIndex,
                                           outNBElement: out outNBElement,
                                           outFastK: output.Series.fastK,
                                           outFastD: output.Series.fastD);
            output.AlgorithmsBeginningIndex = outBeginningIndex;
            output.NBElement = outNBElement;
            return(output);
        }
Beispiel #8
0
        public ITaLibOutput <double[]> PercentagePriceOscillator(Frequency unitType, int historiesLength, Core.MAType MovingAverageType = Core.MAType.Sma, int fastPeriod = 12, int slowPeriod = 26)
        {
            var inputs = new IndicatorsInputs(database, historiesLength);

            database.FillMarketHistory(unitType, inputs.OutputArrayLength);

            double[] closingHistory = database.CurrentHistory
                                      .Select(bar => bar.ClosingPrice)
                                      .ToArray();

            var output = new TaLibOutput <double[]> {
                Series           = new double[inputs.OutputArrayLength],
                HistoryWasCustom = database.HistoryIsCustom
            };
            int outBeginningIndex = 0;
            int outNBElement      = 0;

            output.Outcome = Core.Ppo(startIdx: inputs.StartingIndex,
                                      endIdx: inputs.EndIndex,
                                      inReal: closingHistory,
                                      optInFastPeriod: fastPeriod,
                                      optInSlowPeriod: slowPeriod,
                                      optInMAType: MovingAverageType,
                                      outBegIdx: out outBeginningIndex,
                                      outNBElement: out outNBElement,
                                      outReal: output.Series);
            output.AlgorithmsBeginningIndex = outBeginningIndex;
            output.NBElement = outNBElement;
            return(output);
        }
Beispiel #9
0
        public ITaLibOutput <double[]> MidPointPriceOverPeriod(Frequency unitType, int historiesLength, int timePeriod = 14)
        {
            var inputs = new IndicatorsInputs(database, historiesLength);

            database.FillMarketHistory(unitType, inputs.OutputArrayLength);

            double[] highs = database.CurrentHistory
                             .Select(bar => bar.PriceHigh)
                             .ToArray();

            double[] lows = database.CurrentHistory
                            .Select(bar => bar.PriceLow)
                            .ToArray();

            var output = new TaLibOutput <double[]> {
                Series           = new double[inputs.OutputArrayLength],
                HistoryWasCustom = database.HistoryIsCustom
            };
            int outBeginningIndex = 0;
            int outNBElement      = 0;

            output.Outcome = Core.MidPrice(startIdx: inputs.StartingIndex,
                                           endIdx: inputs.EndIndex,
                                           inHigh: highs,
                                           inLow: lows,
                                           optInTimePeriod: timePeriod,
                                           outBegIdx: out outBeginningIndex,
                                           outNBElement: out outNBElement,
                                           outReal: output.Series);
            output.AlgorithmsBeginningIndex = outBeginningIndex;
            output.NBElement = outNBElement;
            return(output);
        }
Beispiel #10
0
        public ITaLibOutput <double[]> ExponentialMovingAverage(Frequency unitType, int historiesLength, int timePeriod = 30)
        {
            var inputs = new IndicatorsInputs(database, historiesLength);

            database.FillMarketHistory(unitType, inputs.OutputArrayLength);

            double[] closingHistory = database.CurrentHistory
                                      .Select(bar => bar.ClosingPrice)
                                      .ToArray();

            var output = new TaLibOutput <double[]> {
                Series           = new double[inputs.OutputArrayLength],
                HistoryWasCustom = database.HistoryIsCustom
            };
            int outBeginningIndex = 0;
            int outNBElement      = 0;

            output.Outcome = Core.Ema(startIdx: inputs.StartingIndex,
                                      endIdx: inputs.EndIndex,
                                      inReal: closingHistory,
                                      optInTimePeriod: timePeriod,
                                      outBegIdx: out outBeginningIndex,
                                      outNBElement: out outNBElement,
                                      outReal: output.Series);
            output.AlgorithmsBeginningIndex = outBeginningIndex;
            output.NBElement = outNBElement;
            return(output);
        }
Beispiel #11
0
        public ITaLibOutput <double[]> ChaikinADOscillator(Frequency unitType, int historiesLength, int fastPeriod = 3, int slowPeriod = 10)
        {
            var inputs = new IndicatorsInputs(database, historiesLength);

            database.FillMarketHistory(unitType, inputs.OutputArrayLength);

            double[] highs = database.CurrentHistory
                             .Select(bar => bar.PriceHigh)
                             .ToArray();

            double[] lows = database.CurrentHistory
                            .Select(bar => bar.PriceLow)
                            .ToArray();

            double[] closes = database.CurrentHistory
                              .Select(bar => bar.ClosingPrice)
                              .ToArray();

            double[] volumes = database.CurrentHistory
                               .Select(bar => bar.Volume)
                               .ToArray();

            var output = new TaLibOutput <double[]> {
                Series           = new double[inputs.OutputArrayLength],
                HistoryWasCustom = database.HistoryIsCustom
            };
            int outBeginningIndex = 0;
            int outNBElement      = 0;

            output.Outcome = Core.AdOsc(startIdx: inputs.StartingIndex,
                                        endIdx: inputs.EndIndex,
                                        inHigh: highs,
                                        inLow: lows,
                                        inClose: closes,
                                        inVolume: volumes,
                                        optInFastPeriod: fastPeriod,
                                        optInSlowPeriod: slowPeriod,
                                        outBegIdx: out outBeginningIndex,
                                        outNBElement: out outNBElement,
                                        outReal: output.Series);
            output.AlgorithmsBeginningIndex = outBeginningIndex;
            output.NBElement = outNBElement;
            return(output);
        }
Beispiel #12
0
        public ITaLibOutput <(double[] slowK, double[] slowD)> Stochastic(Frequency unitType, int historiesLength, Core.MAType slowKMaType = Core.MAType.Sma, Core.MAType slowDMaType = Core.MAType.Sma, int fastKPeriod = 5, int slowKPeriod = 3, int slowDPeriod = 3)
        {
            var inputs = new IndicatorsInputs(database, historiesLength);

            database.FillMarketHistory(unitType, inputs.OutputArrayLength);

            double[] closingHistory = database.CurrentHistory
                                      .Select(bar => bar.ClosingPrice)
                                      .ToArray();

            double[] highs = database.CurrentHistory
                             .Select(bar => bar.PriceHigh)
                             .ToArray();

            double[] lows = database.CurrentHistory
                            .Select(bar => bar.PriceLow)
                            .ToArray();

            var output = new TaLibOutput <(double[] slowK, double[] slowD)> {
                Series           = (slowK : new double[inputs.OutputArrayLength], slowD : new double[inputs.OutputArrayLength]),
                HistoryWasCustom = database.HistoryIsCustom
            };
            int outBeginningIndex = 0;
            int outNBElement      = 0;

            output.Outcome = Core.Stoch(startIdx: inputs.StartingIndex,
                                        endIdx: inputs.EndIndex,
                                        inHigh: highs,
                                        inLow: lows,
                                        inClose: closingHistory,
                                        optInFastK_Period: fastKPeriod,
                                        optInSlowK_Period: slowKPeriod,
                                        optInSlowD_Period: slowDPeriod,
                                        optInSlowD_MAType: slowDMaType,
                                        optInSlowK_MAType: slowKMaType,
                                        outBegIdx: out outBeginningIndex,
                                        outNBElement: out outNBElement,
                                        outSlowD: output.Series.slowD,
                                        outSlowK: output.Series.slowK);
            output.AlgorithmsBeginningIndex = outBeginningIndex;
            output.NBElement = outNBElement;
            return(output);
        }
Beispiel #13
0
        public ITaLibOutput <double[]> MoneyFlowIndex(Frequency unitType, int historiesLength, int timePeriod = 14)
        {
            var inputs = new IndicatorsInputs(database, historiesLength);

            database.FillMarketHistory(unitType, inputs.OutputArrayLength);

            double[] closingHistory = database.CurrentHistory
                                      .Select(bar => bar.ClosingPrice)
                                      .ToArray();

            double[] inHigh = database.CurrentHistory
                              .Select(bar => bar.PriceHigh)
                              .ToArray();

            double[] inClose = database.CurrentHistory
                               .Select(bar => bar.ClosingPrice)
                               .ToArray();

            double[] volumes = database.CurrentHistory
                               .Select(bar => bar.ClosingPrice)
                               .ToArray();

            var output = new TaLibOutput <double[]> {
                Series           = new double[inputs.OutputArrayLength],
                HistoryWasCustom = database.HistoryIsCustom
            };
            int outBeginningIndex = 0;
            int outNBElement      = 0;

            output.Outcome = Core.Mfi(startIdx: inputs.StartingIndex,
                                      endIdx: inputs.EndIndex,
                                      inHigh: inHigh,
                                      inLow: inClose,
                                      inClose: inClose,
                                      inVolume: volumes,
                                      optInTimePeriod: timePeriod,
                                      outBegIdx: out outBeginningIndex,
                                      outNBElement: out outNBElement,
                                      outReal: output.Series);
            output.AlgorithmsBeginningIndex = outBeginningIndex;
            output.NBElement = outNBElement;
            return(output);
        }
        public ITaLibOutput <double[]> AveragePrice(Frequency unitType, int historiesLength)
        {
            var inputs = new IndicatorsInputs(database, historiesLength);

            database.FillMarketHistory(unitType, inputs.OutputArrayLength);

            double[] opens = database.CurrentHistory
                             .Select(bar => bar.OpeningPrice)
                             .ToArray();

            double[] highs = database.CurrentHistory
                             .Select(bar => bar.PriceHigh)
                             .ToArray();

            double[] lows = database.CurrentHistory
                            .Select(bar => bar.PriceLow)
                            .ToArray();

            double[] closes = database.CurrentHistory
                              .Select(bar => bar.ClosingPrice)
                              .ToArray();

            var output = new TaLibOutput <double[]> {
                Series           = new double[inputs.OutputArrayLength],
                HistoryWasCustom = database.HistoryIsCustom
            };
            int outBeginningIndex = 0;
            int outNBElement      = 0;

            output.Outcome = Core.AvgPrice(startIdx: inputs.StartingIndex,
                                           endIdx: inputs.EndIndex,
                                           inOpen: opens,
                                           inHigh: highs,
                                           inLow: lows,
                                           inClose: closes,
                                           outBegIdx: out outBeginningIndex,
                                           outNBElement: out outNBElement,
                                           outReal: output.Series);
            output.AlgorithmsBeginningIndex = outBeginningIndex;
            output.NBElement = outNBElement;
            return(output);
        }
Beispiel #15
0
        public ITaLibOutput <double[]> UltimateOscillator(Frequency unitType, int historiesLength, int timePeriod1 = 7, int timePeriod2 = 14, int timePeriod3 = 28)
        {
            var inputs = new IndicatorsInputs(database, historiesLength);

            database.FillMarketHistory(unitType, inputs.OutputArrayLength);

            double[] closingHistory = database.CurrentHistory
                                      .Select(bar => bar.ClosingPrice)
                                      .ToArray();

            double[] highs = database.CurrentHistory
                             .Select(bar => bar.PriceHigh)
                             .ToArray();

            double[] lows = database.CurrentHistory
                            .Select(bar => bar.PriceLow)
                            .ToArray();

            var output = new TaLibOutput <double[]> {
                Series           = new double[inputs.OutputArrayLength],
                HistoryWasCustom = database.HistoryIsCustom
            };
            int outBeginningIndex = 0;
            int outNBElement      = 0;

            output.Outcome = Core.UltOsc(startIdx: inputs.StartingIndex,
                                         endIdx: inputs.EndIndex,
                                         inHigh: highs,
                                         inLow: lows,
                                         inClose: closingHistory,
                                         optInTimePeriod1: timePeriod1,
                                         optInTimePeriod2: timePeriod2,
                                         optInTimePeriod3: timePeriod3,
                                         outBegIdx: out outBeginningIndex,
                                         outNBElement: out outNBElement,
                                         outReal: output.Series);
            output.AlgorithmsBeginningIndex = outBeginningIndex;
            output.NBElement = outNBElement;
            return(output);
        }
Beispiel #16
0
        public ITaLibOutput <double[]> ParabolicSarExtended(Frequency unitType, int historiesLength, int startvalue = 0, int offsetonreverse = 0, int accelerationinitlong = 0, int accelerationlong = 0, int accelerationmaxlong = 0, int accelerationinitshort = 0, int accelerationshort = 0, int accelerationmaxshort = 0)
        {
            var inputs = new IndicatorsInputs(database, historiesLength);

            database.FillMarketHistory(unitType, inputs.OutputArrayLength);

            double[] highs = database.CurrentHistory
                             .Select(bar => bar.PriceHigh)
                             .ToArray();

            double[] lows = database.CurrentHistory
                            .Select(bar => bar.PriceLow)
                            .ToArray();

            var output = new TaLibOutput <double[]> {
                Series           = new double[inputs.OutputArrayLength],
                HistoryWasCustom = database.HistoryIsCustom
            };
            int outBeginningIndex = 0;
            int outNBElement      = 0;

            output.Outcome = Core.SarExt(startIdx: inputs.StartingIndex,
                                         endIdx: inputs.EndIndex,
                                         inHigh: highs,
                                         inLow: lows,
                                         optInStartValue: startvalue,
                                         optInOffsetOnReverse: offsetonreverse,
                                         optInAccelerationInitLong: accelerationinitlong,
                                         optInAccelerationInitShort: accelerationinitshort,
                                         optInAccelerationLong: accelerationlong,
                                         optInAccelerationMaxLong: accelerationmaxlong,
                                         optInAccelerationMaxShort: accelerationmaxshort,
                                         optInAccelerationShort: accelerationshort,
                                         outBegIdx: out outBeginningIndex,
                                         outNBElement: out outNBElement,
                                         outReal: output.Series);
            output.AlgorithmsBeginningIndex = outBeginningIndex;
            output.NBElement = outNBElement;
            return(output);
        }
Beispiel #17
0
        public ITaLibOutput <(double[] macd, double[] macdSignal, double[] macdHistory)> MovingAverageConvergenceDivergence(Frequency unitType, int historiesLength, Core.MAType fastMaType = Core.MAType.Sma, Core.MAType slowMaType = Core.MAType.Sma, Core.MAType signalMaType = Core.MAType.Sma, int fastPeriod = 12, int slowPeriod = 26, int signalPeriod = 9)
        {
            var inputs = new IndicatorsInputs(database, historiesLength);

            database.FillMarketHistory(unitType, inputs.OutputArrayLength);

            double[] closingHistory = database.CurrentHistory
                                      .Select(bar => bar.ClosingPrice)
                                      .ToArray();

            var output = new TaLibOutput <(double[] macd, double[] macdSignal, double[] macdHistory)> {
                Series = (macd : new double[inputs.OutputArrayLength],
                          macdSignal : new double[inputs.OutputArrayLength],
                          macdHistory : new double[inputs.OutputArrayLength]),
                HistoryWasCustom = database.HistoryIsCustom
            };
            int outBeginningIndex = 0;
            int outNBElement      = 0;

            output.Outcome = Core.MacdExt(startIdx: inputs.StartingIndex,
                                          endIdx: inputs.EndIndex,
                                          inReal: closingHistory,
                                          optInFastPeriod: fastPeriod,
                                          optInSignalPeriod: signalPeriod,
                                          optInSlowPeriod: slowPeriod,
                                          outBegIdx: out outBeginningIndex,
                                          outNBElement: out outNBElement,
                                          outMACD: output.Series.macd,
                                          outMACDHist: output.Series.macdHistory,
                                          outMACDSignal: output.Series.macdSignal,
                                          optInFastMAType: fastMaType,
                                          optInSignalMAType: signalMaType,
                                          optInSlowMAType: slowMaType);
            output.AlgorithmsBeginningIndex = outBeginningIndex;
            output.NBElement = outNBElement;
            return(output);
        }