Beispiel #1
0
        /// <summary>
        /// Calculates indicator.
        /// </summary>
        /// <param name="price">Price series.</param>
        /// <param name="period">Indicator period.</param>
        /// <param name="timeSeries">Instrument <c>ohlc</c> time series.</param>
        /// <returns>Calculated indicator series.</returns>
        public static double[] Calculate(double[] price, int period, TimeSeries timeSeries)
        {
            Condition.Requires(price, "price")
            .IsNotEmpty();
            Condition.Requires(period, "period")
            .IsGreaterThan(0)
            .IsLessOrEqual(price.Length);
            Condition.Requires(timeSeries, "timeSeries")
            .IsNotNull();

            var dx  = new double[price.Length];
            var pDi = DmiPlus.Calculate(price, period, timeSeries);
            var mDi = DmiMinus.Calculate(price, period, timeSeries);

            for (var i = 0; i < price.Length; ++i)
            {
                var diff = pDi[i] + mDi[i];
                if (diff.IsAlmostZero())
                {
                    dx[i] = 0;
                }
                else
                {
                    dx[i] = 100 * (Math.Abs(pDi[i] - mDi[i]) / (pDi[i] + mDi[i]));
                }
            }

            var adx = EMA.Calculate(dx, period);

            return(adx);
        }
Beispiel #2
0
        /// <summary>
        /// Calculates indicator.
        /// </summary>
        /// <param name="price">Price series.</param>
        /// <param name="period">Indicator period.</param>
        /// <returns>Calculated indicator series.</returns>
        public static double[] Calculate(double[] price, int period)
        {
            Condition.Requires(price, "price")
            .IsNotEmpty();
            Condition.Requires(period, "period")
            .IsGreaterThan(1)
            .IsLessOrEqual(price.Length);

            var trix = new double[price.Length];
            var ema1 = EMA.Calculate(price, period);
            var ema2 = EMA.Calculate(ema1, period);
            var ema3 = EMA.Calculate(ema2, period);

            trix[0] = 0.0;
            for (int i = 1; i < price.Length; ++i)
            {
                if (ema3[i].IsAlmostZero())
                {
                    trix[i] = 0.0;
                }
                else
                {
                    trix[i] = 100.0 * ((ema3[i] - ema3[i - 1]) / ema3[i]);
                }
            }

            return(trix);
        }
Beispiel #3
0
        /// <summary>
        /// Calculates indicator.
        /// </summary>
        /// <param name="price">Price series.</param>
        /// <param name="period">Indicator period.</param>
        /// <param name="timeSeries">Instrument <c>ohlc</c> time series.</param>
        /// <returns>Calculated indicator series.</returns>
        public static double[] Calculate(double[] price, int period, TimeSeries timeSeries)
        {
            Condition.Requires(price, "price")
            .IsNotEmpty();
            Condition.Requires(period, "period")
            .IsGreaterThan(0)
            .IsLessOrEqual(price.Length);
            Condition.Requires(timeSeries, "timeSeries")
            .IsNotNull();

            var pdm = new double[price.Length];

            pdm[0] = 0.0;

            for (int i = 1; i < price.Length; ++i)
            {
                var plusDm  = timeSeries.High[i] - timeSeries.High[i - 1];
                var minusDm = timeSeries.Low[i - 1] - timeSeries.Low[i];

                if (plusDm < 0)
                {
                    plusDm = 0;
                }

                if (minusDm < 0)
                {
                    minusDm = 0;
                }

                if (plusDm.AlmostEqual(minusDm))
                {
                    plusDm = 0;
                }
                else if (plusDm < minusDm)
                {
                    plusDm = 0;
                }

                var trueHigh = timeSeries.High[i] > price[i - 1] ? timeSeries.High[i] : price[i - 1];
                var trueLow  = timeSeries.Low[i] < price[i - 1] ? timeSeries.Low[i] : price[i - 1];
                var tr       = trueHigh - trueLow;
                if (tr.IsAlmostZero())
                {
                    pdm[i] = 0;
                }
                else
                {
                    pdm[i] = 100 * plusDm / tr;
                }
            }

            var dmi = EMA.Calculate(pdm, period);

            return(dmi);
        }
Beispiel #4
0
        /// <summary>
        /// Calculates indicator.
        /// </summary>
        /// <param name="price">Price series.</param>
        /// <param name="period">Indicator period.</param>
        /// <param name="timeSeries">Instrument <c>ohlc</c> time series.</param>
        /// <returns>Calculated indicator series.</returns>
        public static double[] Calculate(double[] price, int period, TimeSeries timeSeries)
        {
            Condition.Requires(price, "price")
            .IsNotEmpty();
            Condition.Requires(period, "period")
            .IsGreaterThan(0)
            .IsLessOrEqual(price.Length);
            Condition.Requires(timeSeries, "timeSeries")
            .IsNotNull();

            var bulls = new double[price.Length];

            var ema = EMA.Calculate(price, period);

            for (var i = 0; i < price.Length; i++)
            {
                bulls[i] = timeSeries.High[i] - ema[i];
            }

            return(bulls);
        }