示例#1
0
        public void ComparesWithExternalData()
        {
            var aroon = new AroonOscillator(14, 14);

            TestHelper.TestIndicator(aroon, "spy_aroon_oscillator.txt", "Aroon Oscillator 14",
                                     (i, expected) => Assert.AreEqual(expected, (double)aroon.Current.Value, 1e-3));
        }
示例#2
0
        public void ComparesWithExternalData()
        {
            var aroon = new AroonOscillator(14, 14);

            TestHelper.TestIndicator(aroon, "spy_aroon_oscillator.txt", "Aroon Oscillator 14",
                                     (i, expected) => ((double)aroon.Current.Price).Should().BeApproximately(expected, 1e-3));
        }
示例#3
0
        public void ComparesWithExternalData()
        {
            // this test currently fails 57 points
            const int maxFailures   = 57;
            int       totalFailures = 0;
            var       aroon         = new AroonOscillator(14, 14);

            TestHelper.TestIndicator(aroon, "spy_aroon_oscillator.txt", "Aroon Oscillator 14", (i, expected) =>
            {
                try
                {
                    Assert.AreEqual(expected, (double)aroon.Current.Value, 1e-3);
                }
                catch
                {
                    totalFailures++;
                }
            });

            if (totalFailures > maxFailures)
            {
                Assert.Fail("Aroon did worse than previously expected. Failed: {0} Expected: {1}", totalFailures, maxFailures);
            }
            else
            {
                Console.WriteLine("Aroon failed {0} data points against an expected of {1}", totalFailures, maxFailures);
            }
        }
示例#4
0
        /// <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 specied periods</returns>
        public AroonOscillator AROON(string symbol, int upPeriod, int downPeriod, Resolution?resolution = null, Func <BaseData, TradeBar> selector = null)
        {
            var name  = CreateIndicatorName(symbol, string.Format("AROON({0},{1})", upPeriod, downPeriod), resolution);
            var aroon = new AroonOscillator(name, upPeriod, downPeriod);

            RegisterIndicator(symbol, aroon, resolution, selector);
            return(aroon);
        }
示例#5
0
        public async Task TestAroonOscAsync()
        {
            var candles = await ImportCandlesAsync();

            var indicator = new AroonOscillator(candles, 25);
            var result    = indicator[candles.Count - 1];

            Assert.IsTrue(88.0m.IsApproximatelyEquals(result.Value));
        }
示例#6
0
        public async Task TestAroonOscAsync()
        {
            var equity = await ImportEquityAsync();

            var indicator = new AroonOscillator(equity, 25);
            var result    = indicator.ComputeByIndex(equity.Count - 1);

            Assert.IsTrue(88.0m.IsApproximatelyEquals(result.Osc.Value));
        }
示例#7
0
        public void ResetsProperly()
        {
            var aroon = new AroonOscillator(3, 3);

            aroon.Update(new TradeBar
            {
                Ticker   = Props.TickerSymbol,
                Occured  = DateTime.Today,
                Open     = 3m,
                High     = 7m,
                Low      = 2m,
                Close    = 5m,
                Volume   = 10,
                TimeZone = TimeZone.Utc
            });
            aroon.Update(new TradeBar
            {
                Ticker   = Props.TickerSymbol,
                Occured  = DateTime.Today.AddSeconds(1),
                Open     = 3m,
                High     = 7m,
                Low      = 2m,
                Close    = 5m,
                Volume   = 10,
                TimeZone = TimeZone.Utc
            });
            aroon.Update(new TradeBar
            {
                Ticker   = Props.TickerSymbol,
                Occured  = DateTime.Today.AddSeconds(2),
                Open     = 3m,
                High     = 7m,
                Low      = 2m,
                Close    = 5m,
                Volume   = 10,
                TimeZone = TimeZone.Utc
            });
            Assert.False(aroon.IsReady);
            aroon.Update(new TradeBar
            {
                Ticker   = Props.TickerSymbol,
                Occured  = DateTime.Today.AddSeconds(3),
                Open     = 3m,
                High     = 7m,
                Low      = 2m,
                Close    = 5m,
                Volume   = 10,
                TimeZone = TimeZone.Utc
            });
            Assert.True(aroon.IsReady);

            aroon.Reset();
            TestHelper.AssertIndicatorIsInDefaultState(aroon);
            TestHelper.AssertIndicatorIsInDefaultState(aroon.AroonUp);
            TestHelper.AssertIndicatorIsInDefaultState(aroon.AroonDown);
        }
示例#8
0
        public void ResetsProperly()
        {
            var aroon = new AroonOscillator(3, 3);

            aroon.Update(new TradeBar
            {
                Symbol = "SPY",
                Time   = DateTime.Today,
                Open   = 3m,
                High   = 7m,
                Low    = 2m,
                Close  = 5m,
                Volume = 10
            });
            aroon.Update(new TradeBar
            {
                Symbol = "SPY",
                Time   = DateTime.Today.AddSeconds(1),
                Open   = 3m,
                High   = 7m,
                Low    = 2m,
                Close  = 5m,
                Volume = 10
            });
            aroon.Update(new TradeBar
            {
                Symbol = "SPY",
                Time   = DateTime.Today.AddSeconds(2),
                Open   = 3m,
                High   = 7m,
                Low    = 2m,
                Close  = 5m,
                Volume = 10
            });
            Assert.IsFalse(aroon.IsReady);
            aroon.Update(new TradeBar
            {
                Symbol = "SPY",
                Time   = DateTime.Today.AddSeconds(3),
                Open   = 3m,
                High   = 7m,
                Low    = 2m,
                Close  = 5m,
                Volume = 10
            });
            Assert.IsTrue(aroon.IsReady);

            aroon.Reset();
            TestHelper.AssertIndicatorIsInDefaultState(aroon);
            TestHelper.AssertIndicatorIsInDefaultState(aroon.AroonUp);
            TestHelper.AssertIndicatorIsInDefaultState(aroon.AroonDown);
        }
        public void ResetsProperly()
        {
            var aroon = new AroonOscillator(3, 3);

            aroon.Update(DateTime.Today.ToEpochTime(), new TradeBarValue {
                Open   = 3d,
                High   = 7d,
                Low    = 2d,
                Close  = 5d,
                Volume = 10
            });
            aroon.Update(DateTime.Today.AddSeconds(1).ToEpochTime(), new TradeBarValue {
                Open   = 3d,
                High   = 7d,
                Low    = 2d,
                Close  = 5d,
                Volume = 10
            });
            aroon.Update(DateTime.Today.AddSeconds(2).ToEpochTime(), new TradeBarValue {
                Open   = 3d,
                High   = 7d,
                Low    = 2d,
                Close  = 5d,
                Volume = 10
            });
            Assert.IsFalse(aroon.IsReady);
            aroon.Update(DateTime.Today.AddSeconds(3).ToEpochTime(), new TradeBarValue {
                Open   = 3d,
                High   = 7d,
                Low    = 2d,
                Close  = 5d,
                Volume = 10
            });
            Assert.IsTrue(aroon.IsReady);

            aroon.Reset();
            TestHelper.AssertIndicatorIsInDefaultState(aroon);
            TestHelper.AssertIndicatorIsInDefaultState(aroon.AroonUp);
            TestHelper.AssertIndicatorIsInDefaultState(aroon.AroonDown);
        }
        /// <summary>
        /// Initialize test
        /// </summary>
        public TestIndicatorAroonOscillator()
        {
            DataStream stream = new OHLCBarStream(new ForexSecurity("EURUSD"), BarInterval.FiveMin);

            _sut = new AroonOscillator(Period, stream.DefaultInterval, stream);
        }