Exemple #1
0
        public async Task TestDmiAsync()
        {
            var equity = await ImportEquityAsync();

            var indicator = new DirectionalMovementIndex(equity, 14);
            var result    = indicator.ComputeByIndex(equity.Count - 1);

            Assert.IsTrue(29.50m.IsApproximatelyEquals(result.Pdi.Value));
            Assert.IsTrue(7.91m.IsApproximatelyEquals(result.Mdi.Value));
            Assert.IsTrue(57.57m.IsApproximatelyEquals(result.Adx.Value));
        }
Exemple #2
0
        public static IEnumerable <(TimeSeries, Color)> GetIndicators(CandleTimeSeries series
                                                                      , int indicatorPeriod
                                                                      , int smoothingPeriod
                                                                      , DateTime?startDate = null)
        {
            if (startDate == null)
            {
                startDate = series.Candles.Min(candle => candle.Start);
            }

            DirectionalIndicatorPlus diPlus =
                DirectionalIndicatorPlus.Create(indicatorPeriod);
            TimeSeries diPlusSeries = series.Candles
                                      .Where((candle, index) => index > 0 &&
                                             candle.Start >= startDate)
                                      .Select(candle => new DateValue(candle.Start, diPlus[series, candle.Start]))
                                      .ToTimeSeries(DiPlusIndicatorName);

            yield return(diPlusSeries, Color.Blue);

            DirectionalIndicatorMinus diMinus =
                DirectionalIndicatorMinus.Create(indicatorPeriod);
            TimeSeries diMinusSeries = series.Candles
                                       .Where((candle, index) => index > 0 &&
                                              candle.Start >= startDate)
                                       .Select(candle => new DateValue(candle.Start, diMinus[series, candle.Start]))
                                       .ToTimeSeries(DiMinusIndicatorName);

            yield return(diMinusSeries, Color.Red);

            DirectionalMovementIndex dx = DirectionalMovementIndex.Create(indicatorPeriod);
            TimeSeries dxSeries         = series.Candles
                                          .Where((candle, index) => index > 0 &&
                                                 candle.Start >= startDate)
                                          .Select(candle => new DateValue(candle.Start, dx[series, candle.Start]))
                                          .ToTimeSeries(DxIndicatorName);

            yield return(dxSeries, Color.DarkSlateGray);

            AverageDirectionalMovementIndex adx =
                AverageDirectionalMovementIndex.Create(indicatorPeriod, smoothingPeriod);
            TimeSeries adxSeries = series.Candles
                                   .Where((candle, index) => index > 0 &&
                                          candle.Start >= startDate)
                                   .Select(candle => new DateValue(candle.Start, adx[series, candle.Start]))
                                   .ToTimeSeries(AdxIndicatorName);

            yield return(adxSeries, Color.DarkGray);
        }