Beispiel #1
0
        [TestCase(16)] // 4PM
        public void BarsEmitOnTime(int hour)
        {
            // This test just pushes one full hourly bar into a consolidator
            // and scans to see if it will emit immediately as expected

            using var consolidator = new TradeBarConsolidator(Time.OneHour);
            var      consolidatedBarsCount = 0;
            TradeBar latestBar             = null;
            var      time = new DateTime(2015, 04, 13, hour, 0, 0);

            consolidator.DataConsolidated += (sender, bar) =>
            {
                latestBar = bar;
                consolidatedBarsCount++;
            };

            // Update with one tradebar that ends at this time
            // This is to simulate getting a data bar for the last period
            consolidator.Update(new TradeBar {
                Time = time.Subtract(Time.OneMinute), Period = Time.OneMinute
            });

            // Assert that the bar hasn't emitted
            Assert.IsNull(latestBar);
            Assert.AreEqual(0, consolidatedBarsCount);

            // Scan afterwards (Like algorithmManager does)
            consolidator.Scan(time);

            // Assert that the bar emitted
            Assert.IsNotNull(latestBar);
            Assert.IsTrue(latestBar.EndTime == time);
            Assert.AreEqual(1, consolidatedBarsCount);
        }
        public void ZeroSpanAlwaysFires()
        {
            // defining a TradeBarConsolidator with a zero period should cause it to always fire identity

            TradeBar consolidated = null;
            var      consolidator = new TradeBarConsolidator(TimeSpan.Zero);

            consolidator.DataConsolidated += (sender, bar) =>
            {
                consolidated = bar;
            };

            var reference = new DateTime(2014, 12, 01, 01, 01, 00);

            consolidator.Update(new TradeBar {
                Close = 1m, Time = reference
            });
            Assert.IsNotNull(consolidated);
            Assert.AreEqual(1, consolidated.Close);

            consolidator.Update(new TradeBar {
                Close = 2m, Time = reference
            });
            Assert.IsNotNull(consolidated);
            Assert.AreEqual(2, consolidated.Close);

            consolidator.Update(new TradeBar {
                Close = 3m, Time = reference
            });
            Assert.IsNotNull(consolidated);
            Assert.AreEqual(3, consolidated.Close);
        }
        public void OneMinuteAlwaysFiresEveryTimeOnMinueDataExceptFirstPoint()
        {
            // defining a TradeBarConsolidator with the same period as the resolution of input data will cause
            // it to not fire on the first piece of data as it is initializing, but will thenfire for each
            // consecutive data point

            TradeBar consolidated = null;
            var      consolidator = new TradeBarConsolidator(TimeSpan.FromMinutes(1));

            consolidator.DataConsolidated += (sender, bar) =>
            {
                consolidated = bar;
            };

            var reference = new DateTime(2014, 12, 01, 01, 01, 00);

            consolidator.Update(new TradeBar {
                Close = 1m, Time = reference
            });
            Assert.IsNull(consolidated);

            consolidator.Update(new TradeBar {
                Close = 2m, Time = reference.AddMinutes(1)
            });
            Assert.IsNotNull(consolidated);
            Assert.AreEqual(1, consolidated.Close);

            consolidator.Update(new TradeBar {
                Close = 3m, Time = reference.AddMinutes(2)
            });
            Assert.IsNotNull(consolidated);
            Assert.AreEqual(2, consolidated.Close);
        }
Beispiel #4
0
            /// <summary>
            /// Main constructor for the class
            /// </summary>
            /// <param name="rangePeriod">Range period</param>
            /// <param name="consolidatorResolution">Time length of consolidator</param>
            public SymbolData(int rangePeriod, TimeSpan consolidatorResolution)
            {
                _rangeWindow  = new RollingWindow <TradeBar>(rangePeriod);
                _consolidator = new TradeBarConsolidator(consolidatorResolution);

                // event fired at new consolidated trade bar
                _consolidator.DataConsolidated += (sender, consolidated) =>
                {
                    // add new tradebar to
                    _rangeWindow.Add(consolidated);

                    if (IsReady)
                    {
                        var hh = _rangeWindow.Select(x => x.High).Max();
                        var hc = _rangeWindow.Select(x => x.Close).Max();
                        var lc = _rangeWindow.Select(x => x.Close).Min();
                        var ll = _rangeWindow.Select(x => x.Low).Min();

                        Range = Math.Max(hh - lc, hc - ll);

                        UpperLine = consolidated.Close + K1 * Range;
                        LowerLine = consolidated.Close - K2 * Range;
                    }
                };
            }
        public void TwoCountFiresEveryOther()
        {
            // defining a TradeBarConsolidator with a two max count should cause it to fire every other TradeBar

            TradeBar consolidated = null;
            var consolidator = new TradeBarConsolidator(2);
            consolidator.DataConsolidated += (sender, bar) =>
            {
                consolidated = bar;
            };

            consolidator.Update(new TradeBar());
            Assert.IsNull(consolidated);

            consolidator.Update(new TradeBar());
            Assert.IsNotNull(consolidated);

            consolidated = null;

            consolidator.Update(new TradeBar());
            Assert.IsNull(consolidated);

            consolidator.Update(new TradeBar());
            Assert.IsNotNull(consolidated);
        }
Beispiel #6
0
        public void DoesNotConsolidateDifferentSymbols()
        {
            // verifies that the TradeBarConsolidator does not consolidate data with different symbols

            var consolidator = new TradeBarConsolidator(2);

            var tb1 = new TradeBar
            {
                Symbol   = Symbols.AAPL,
                Open     = 10,
                High     = 100,
                Low      = 1,
                Close    = 50,
                Volume   = 75,
                DataType = MarketDataType.TradeBar
            };

            var tb2 = new TradeBar
            {
                Symbol   = Symbols.ZNGA,
                Open     = 50,
                High     = 123,
                Low      = 35,
                Close    = 75,
                Volume   = 100,
                DataType = MarketDataType.TradeBar
            };

            consolidator.Update(tb1);

            Exception ex = Assert.Throws <InvalidOperationException>(() => consolidator.Update(tb2));

            Assert.That(ex.Message, Is.StringContaining("is not the same"));
        }
        private void CalendarConsolidatesWithRegisterIndicator(Func <DateTime, CalendarInfo> calendarType)
        {
            var consolidator = new TradeBarConsolidator(calendarType);

            consolidator.DataConsolidated += (s, e) =>
            {
                if (!indicator.IsReady)
                {
                    return;
                }

                var previous = e.Value - e.Period.Days;
                var actual   = (e.Value + previous) / indicator.Period;
                Assert.AreEqual(indicator, actual);
            };

            indicator = new SimpleMovingAverage(2);
            RegisterIndicator(indicator, consolidator);

            var reference = new DateTime(2019, 4, 1);

            for (var i = 1; i < 100; i++)
            {
                var bar = new TradeBar(reference.AddDays(i - 1), Symbols.SPY, i, i, i, i, 0);
                consolidator.Update(bar);
            }
        }
        public override void Initialize()
        {
            this.UnderlyingTicker = this.GetParameter("symbol");
            //AAPL
            SetStartDate(2018, 01, 01);
            SetEndDate(2018, 11, 30);

            //
            //SetStartDate(2018, 03, 01);
            //SetEndDate(2018, 03, 01);
            //SetStartDate(2015, 01, 01);
            //SetStartDate(2018, 02, 15);
            //SetEndDate(2018, 03, 09);
            SetCash(100000);

            var equity = AddEquity(UnderlyingTicker, RESOLUTION);
            var option = AddOption(UnderlyingTicker, RESOLUTION);

            // use the underlying equity as the benchmark
            SetBenchmark(equity.Symbol);

            var consolidator = new TradeBarConsolidator(TimeSpan.FromMinutes(MINUTE_RATE));

            consolidator.DataConsolidated += Consolidator_DataConsolidated;
            _rocp = new RateOfChangePercent(9);
            RegisterIndicator(equity.Symbol, _rocp, consolidator);
            SubscriptionManager.AddConsolidator(equity.Symbol, consolidator);

            // init strategy
            _Statistics = new OptionStatistics(this, option);
        }
Beispiel #9
0
        public void AggregatesTradeBarToDailyTradeBarProperly(Language language)
        {
            // Monday
            var reference = new DateTime(2019, 3, 18);
            var bars      = new List <TradeBar>
            {
                new TradeBar(reference.AddHours(6), Symbols.SPY, 9, 11, 8, 10, 100, Time.OneHour),
                new TradeBar(reference.AddHours(12), Symbols.SPY, 10, 12, 8, 11, 100, Time.OneHour),
                new TradeBar(reference.AddHours(18), Symbols.SPY, 11, 13, 9, 10, 100, Time.OneHour),
                new TradeBar(reference.AddHours(21), Symbols.SPY, 11, 13, 9, 11, 100, Time.OneHour),
                new TradeBar(reference.AddHours(25), Symbols.SPY, 11, 13, 9, 11, 100, Time.OneHour)
            };

            var dailyConsolidator = new TradeBarConsolidator(_dailyFuncDictionary[language]);

            dailyConsolidator.DataConsolidated += (s, e) =>
            {
                AssertTradeBar(
                    bars.Take(4),
                    reference,
                    reference.AddDays(1),
                    Symbols.SPY,
                    e);
            };

            foreach (var bar in bars)
            {
                dailyConsolidator.Update(bar);
            }
        }
        public void TwoCountFiresEveryOther()
        {
            // defining a TradeBarConsolidator with a two max count should cause it to fire every other TradeBar

            TradeBar consolidated = null;
            var      consolidator = new TradeBarConsolidator(2);

            consolidator.DataConsolidated += (sender, bar) =>
            {
                consolidated = bar;
            };

            consolidator.Update(new TradeBar());
            Assert.IsNull(consolidated);

            consolidator.Update(new TradeBar());
            Assert.IsNotNull(consolidated);

            consolidated = null;

            consolidator.Update(new TradeBar());
            Assert.IsNull(consolidated);

            consolidator.Update(new TradeBar());
            Assert.IsNotNull(consolidated);
        }
        public void AggregatesPeriodInPeriodModeWithDailyData()
        {
            TradeBar consolidated = null;
            var period = TimeSpan.FromDays(1);
            var consolidator = new TradeBarConsolidator(period);
            consolidator.DataConsolidated += (sender, bar) =>
            {
                consolidated = bar;
            };

            var reference = new DateTime(2015, 04, 13);
            consolidator.Update(new TradeBar { Time = reference, Period = period});
            Assert.IsNull(consolidated);

            consolidator.Update(new TradeBar { Time = reference.AddDays(1), Period = period });
            Assert.IsNotNull(consolidated);
            Assert.AreEqual(period, consolidated.Period);
            consolidated = null;

            consolidator.Update(new TradeBar { Time = reference.AddDays(2), Period = period });
            Assert.IsNotNull(consolidated);
            Assert.AreEqual(period, consolidated.Period);
            consolidated = null;

            consolidator.Update(new TradeBar { Time = reference.AddDays(3), Period = period });
            Assert.IsNotNull(consolidated);
            Assert.AreEqual(period, consolidated.Period);
        }
        /// <summary>
        /// Gets the default consolidator for the specified symbol and resolution
        /// </summary>
        /// <param name="symbol">The symbo whose data is to be consolidated</param>
        /// <param name="resolution">The resolution for the consolidator, if null, uses the resolution from subscription</param>
        /// <returns>The new default consolidator</returns>
        protected IDataConsolidator ResolveConsolidator(string symbol, Resolution?resolution)
        {
            symbol = symbol.ToUpper();
            try
            {
                // find our subscription to this symbol
                var subscription = SubscriptionManager.Subscriptions.First(x => x.Symbol == symbol);
                if (subscription.Type == typeof(TradeBar))
                {
                    if (!resolution.HasValue)
                    {
                        // if we want the same resolution as in the subscription then just use identity
                        return(new TradeBarConsolidator(1));
                    }

                    return(TradeBarConsolidator.FromResolution(resolution.Value));
                }

                // TODO : Add default IDataConsolidator for Tick
                // if it is tick data we would need a different consolidator, what should the default consolidator of tick data be?
                // I imagine it would be something that produces a TradeBar from ticks!


                // if it is custom data I don't think we can resolve a default consolidator for the type
            }
            catch (InvalidOperationException)
            {
                // this will happen if wedid not find the subscription, let's give the user a decent error message
                throw new Exception("Please register to receive data for symbol '" + symbol + "' using the AddSecurity() function.");
            }

            throw new NotSupportedException("QCAlgorithm.ResolveConsolidator(): Currently this only supports TradeBar data.");
        }
Beispiel #13
0
        public void FiresEventAfterTimePassesViaScanWithMultipleResolutions()
        {
            TradeBar consolidated = null;
            var      period       = TimeSpan.FromMinutes(2);
            var      consolidator = new TradeBarConsolidator(period);

            consolidator.DataConsolidated += (sender, bar) =>
            {
                consolidated = bar;
            };

            var reference = new DateTime(2015, 04, 13, 10, 20, 0);
            var time      = reference;

            for (int i = 0; i < 10; i++)
            {
                consolidator.Update(new TradeBar {
                    Time = time, Period = Time.OneSecond
                });
                time = time.AddSeconds(1);
                consolidator.Scan(time);
                Assert.IsNull(consolidated);
            }

            consolidator.Update(new TradeBar {
                Time = time, Period = Time.OneMinute
            });
            time = reference.Add(period);
            consolidator.Scan(time);
            Assert.IsNotNull(consolidated);
            Assert.AreEqual(reference, consolidated.Time);
            Assert.AreEqual(period, consolidated.Period);

            consolidated = null;

            consolidator.Update(new TradeBar {
                Time = time, Period = Time.OneSecond
            });
            time = time.AddSeconds(1);
            consolidator.Scan(time);
            Assert.IsNull(consolidated);

            time = time.AddSeconds(-1);
            consolidator.Update(new TradeBar {
                Time = time, Period = Time.OneMinute
            });
            time = time.AddMinutes(1);
            consolidator.Scan(time);
            Assert.IsNull(consolidated);

            consolidator.Update(new TradeBar {
                Time = time, Period = Time.OneMinute
            });
            time = time.AddMinutes(1);
            consolidator.Scan(time);
            Assert.IsNotNull(consolidated);
            Assert.AreEqual(reference.AddMinutes(2), consolidated.Time);
            Assert.AreEqual(period, consolidated.Period);
        }
Beispiel #14
0
        public override void Initialize()
        {
            // backtest parameters
            // we have data for these dates locally
            var start = new DateTime(2020, 01, 01, 09, 30, 0);

            SetStartDate(start);
            SetEndDate(start.AddDays(30));
            SetCash(100000);

            // set security and option universe for tradebar
            _spy = AddEquity("SPY", Resolution.Minute);
            var option = AddOption("SPY", Resolution.Minute);

            // set filter on option universe
            _optionSymbol = option.Symbol;
            option.SetFilter(universe =>
                             from symbol in universe
                             .WeeklysOnly().Expiration(TimeSpan.Zero, TimeSpan.FromDays(10))
                             where symbol.ID.OptionRight != OptionRight.Put
                             select symbol);

            // use the underlying equity as the benchmark
            SetBenchmark("SPY");

            // Creates a Rolling Window indicator to hold 2 TradeBars
            _window = new RollingWindow <TradeBar>(2);

            // Creates a Rolling Window indicator to hold 1 option contract
            _optionWindow = new RollingWindow <OptionContract>(1);

            // create RSI indicator
            fast = new RelativeStrengthIndex("SPY", 14, MovingAverageType.Wilders);

            // Create a Rolling Window to keep two Indicator Data Points
            _rsiLag = new RollingWindow <IndicatorDataPoint>(2);

            // define our 5 minute trade bar consolidator. we can access the 5 minute bar
            // from the DataConsolidated events
            var minConsolidator = new TradeBarConsolidator(TimeSpan.FromMinutes(5));

            // attach our event handler. the event handler is a function that will be called each time we produce
            // a new consolidated piece of data.
            minConsolidator.DataConsolidated += OnFiveMinutes;

            // this call adds our daily consolidator to the manager to receive updates from the engine
            SubscriptionManager.AddConsolidator("SPY", minConsolidator);

            // we need to manually register these indicators for automatic updates
            RegisterIndicator("SPY", fast, minConsolidator);

            Schedule.On(DateRules.EveryDay(), TimeRules.BeforeMarketClose(_spy.Symbol, 4), () =>
            {
                CloseOpenPositions(_spy);
            });

            SetWarmUp(TimeSpan.FromDays(100));
        }
        /// <summary>
        /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
        /// </summary>
        /// <meta name="tag" content="using data" />
        /// <meta name="tag" content="consolidating data" />
        public override void Initialize()
        {
            AddEquity("SPY");
            AddForex("EURUSD", Resolution.Hour);

            // we have data for these dates locally
            var start = new DateTime(2013, 10, 07, 09, 30, 0);

            SetStartDate(start);
            SetEndDate(start.AddDays(1));

            // define our 30 minute trade bar consolidator. we can access the 30 minute bar
            // from the DataConsolidated events
            var thirtyMinuteConsolidator = new TradeBarConsolidator(TimeSpan.FromMinutes(30));

            // attach our event handler. the event handler is a function that will be called each time we produce
            // a new consolidated piece of data.
            thirtyMinuteConsolidator.DataConsolidated += ThirtyMinuteBarHandler;

            // this call adds our 30 minute consolidator to the manager to receive updates from the engine
            SubscriptionManager.AddConsolidator("SPY", thirtyMinuteConsolidator);

            // here we'll define a slightly more complex consolidator. what we're trying to produce is a 3
            // day bar.  Now we could just use a single TradeBarConsolidator like above and pass in TimeSpan.FromDays(3),
            // but in reality that's not what we want. For time spans of longer than a day we'll get incorrect results around
            // weekends and such. What we really want are tradeable days. So we'll create a daily consolidator, and then wrap
            // it with a 3 count consolidator.

            // first define a one day trade bar -- this produces a consolidated piece of data after a day has passed
            var oneDayConsolidator = new TradeBarConsolidator(TimeSpan.FromDays(1));

            // next define our 3 count trade bar -- this produces a consolidated piece of data after it sees 3 pieces of data
            var threeCountConsolidator = new TradeBarConsolidator(3);

            // here we combine them to make a new, 3 day trade bar. The SequentialConsolidator allows composition of consolidators.
            // it takes the consolidated output of one consolidator (in this case, the oneDayConsolidator) and pipes it through to
            // the threeCountConsolidator.  His output will be a 3 day bar.
            var three_oneDayBar = new SequentialConsolidator(oneDayConsolidator, threeCountConsolidator);

            // attach our handler
            three_oneDayBar.DataConsolidated += (sender, consolidated) => ThreeDayBarConsolidatedHandler(sender, (TradeBar)consolidated);

            // this call adds our 3 day to the manager to receive updates from the engine
            SubscriptionManager.AddConsolidator("SPY", three_oneDayBar);

            // API convenience method for easily receiving consolidated data
            Consolidate("SPY", TimeSpan.FromMinutes(45), FortyFiveMinuteBarHandler);
            Consolidate("SPY", Resolution.Hour, HourBarHandler);
            Consolidate("EURUSD", Resolution.Daily, DailyEurUsdBarHandler);

            // requires quote data subscription
            //Consolidate<QuoteBar>("EURUSD", TimeSpan.FromMinutes(45), FortyFiveMinuteBarHandler);
            //Consolidate<QuoteBar>("EURUSD", Resolution.Hour, HourBarHandler);

            // some securities may have trade and quote data available
            //Consolidate<TradeBar>("BTCUSD", Resolution.Hour, HourBarHandler);
            //Consolidate<QuoteBar>("BTCUSD", Resolution.Hour, HourBarHandler);
        }
        public void ConsolidatesOHLCV()
        {
            // verifies that the TradeBarConsolidator correctly consolidates OHLCV data into a new TradeBar instance

            TradeBar consolidated = null;
            var      consolidator = new TradeBarConsolidator(3);

            consolidator.DataConsolidated += (sender, bar) =>
            {
                consolidated = bar;
            };

            var tb1 = new TradeBar
            {
                Symbol   = "SPY",
                Open     = 10,
                High     = 100,
                Low      = 1,
                Close    = 50,
                Volume   = 75,
                DataType = MarketDataType.TradeBar
            };

            var tb2 = new TradeBar
            {
                Symbol   = "SPY",
                Open     = 50,
                High     = 123,
                Low      = 35,
                Close    = 75,
                Volume   = 100,
                DataType = MarketDataType.TradeBar
            };

            var tb3 = new TradeBar
            {
                Symbol   = "SPY",
                Open     = 75,
                High     = 100,
                Low      = 50,
                Close    = 83,
                Volume   = 125,
                DataType = MarketDataType.TradeBar
            };

            consolidator.Update(tb1);
            consolidator.Update(tb2);
            consolidator.Update(tb3);

            Assert.IsNotNull(consolidated);
            Assert.AreEqual("SPY", consolidated.Symbol);
            Assert.AreEqual(10m, consolidated.Open);
            Assert.AreEqual(123m, consolidated.High);
            Assert.AreEqual(1m, consolidated.Low);
            Assert.AreEqual(83m, consolidated.Close);
            Assert.AreEqual(300L, consolidated.Volume);
        }
Beispiel #17
0
        public void CanRemoveConsolidatorWhileEnumeratingList()
        {
            var config        = new SubscriptionDataConfig(typeof(TradeBar), Symbols.SPY, Resolution.Minute, TimeZones.NewYork, TimeZones.NewYork, false, false, false, false, TickType.Trade, false);
            var consolidator1 = new TradeBarConsolidator(1);
            var consolidator2 = new TradeBarConsolidator(2);

            config.Consolidators.Add(consolidator1);
            config.Consolidators.Add(consolidator2);
            foreach (var consolidator in config.Consolidators)
            {
                Assert.DoesNotThrow(() => config.Consolidators.Remove(consolidator));
            }
        }
        public void HandlesDataGapsInMixedMode()
        {
            // define a three minute consolidator on a one minute stream of data
            var consolidator = new TradeBarConsolidator(3, TimeSpan.FromMinutes(3));

            TradeBar consolidated = null;

            consolidator.DataConsolidated += (sender, bar) =>
            {
                consolidated = bar;
            };

            var reference = new DateTime(2014, 12, 1, 10, 00, 0);

            //10:00 - new
            consolidator.Update(new TradeBar {
                Time = reference
            });
            Assert.IsNull(consolidated);

            //10:01 - aggregate
            consolidator.Update(new TradeBar {
                Time = reference.AddMinutes(1)
            });
            Assert.IsNull(consolidated);

            //10:02 - fire
            consolidator.Update(new TradeBar {
                Time = reference.AddMinutes(2)
            });
            Assert.IsNotNull(consolidated);
            Assert.AreEqual(reference, consolidated.Time);

            //10:03 - new
            consolidator.Update(new TradeBar {
                Time = reference.AddMinutes(3)
            });
            Assert.AreEqual(reference, consolidated.Time);

            //10:06 - aggregate/fire
            consolidator.Update(new TradeBar {
                Time = reference.AddMinutes(6)
            });
            Assert.AreEqual(reference.AddMinutes(3), consolidated.Time);

            //10:08 - new/fire -- will have timestamp from 10:08, instead of 10:06
            consolidator.Update(new TradeBar {
                Time = reference.AddMinutes(8)
            });
            Assert.AreEqual(reference.AddMinutes(8), consolidated.Time);
        }
Beispiel #19
0
        public void AddIndicators()
        {
            var consolidator = new TradeBarConsolidator(TimeSpan.FromMinutes(1));

            if (_strategySignals[0])
            {
                RSI = new PLRSI(_innerSymbol.Value.ToString(), 21, MovingAverageType.Simple)
                {
                    Low  = 40,
                    High = 80
                };
                _parent.RegisterIndicator(_innerSymbol, RSI, consolidator);
            }
            if (_strategySignals[1])
            {
                MFI = new PLMFI(_innerSymbol.Value.ToString(), 40)
                {
                    Low  = 40,
                    High = 80
                };
                _parent.RegisterIndicator(_innerSymbol, MFI, consolidator);
            }
            if (_strategySignals[2])
            {
                ADI = new PLADI(_innerSymbol.Value.ToString(), 14)
                {
                    Low  = -50,
                    High = 100
                };
                _parent.RegisterIndicator(_innerSymbol, ADI, consolidator);
            }
            if (_strategySignals[3])
            {
                CMO = new PLCMO(_innerSymbol.Value.ToString(), 14)
                {
                    Low  = 20,
                    High = 70
                };
                _parent.RegisterIndicator(_innerSymbol, CMO, consolidator);
            }
            if (_strategySignals[4])
            {
                UO = new PLUO(_innerSymbol.Value.ToString(), 7, 14, 28)
                {
                    Low  = 40,
                    High = 80
                };
                _parent.RegisterIndicator(_innerSymbol, UO, consolidator);
            }
        }
        public void OneCountAlwaysFires()
        {
            // defining a TradeBarConsolidator with a one max count should cause it to always fire identity

            TradeBar consolidated = null;
            var consolidator = new TradeBarConsolidator(1);
            consolidator.DataConsolidated += (sender, bar) =>
            {
                consolidated = bar;
            };

            consolidator.Update(new TradeBar());
            Assert.IsNotNull(consolidated);
        }
        public void OneCountAlwaysFires()
        {
            // defining a TradeBarConsolidator with a one max count should cause it to always fire identity

            TradeBar consolidated = null;
            var      consolidator = new TradeBarConsolidator(1);

            consolidator.DataConsolidated += (sender, bar) =>
            {
                consolidated = bar;
            };

            consolidator.Update(new TradeBar());
            Assert.IsNotNull(consolidated);
        }
Beispiel #22
0
        private static void PushBarsThrough(int barCount, TimeSpan period, TradeBarConsolidator consolidator, ref DateTime time)
        {
            TradeBar bar;

            for (int i = 0; i < barCount; i++)
            {
                bar = new TradeBar {
                    Time = time, Period = period
                };
                consolidator.Update(bar);

                // Advance time
                time += period;
            }
        }
        public void ConsolidatedTimeIsFromBeginningOfBar()
        {
            // verifies that the consolidated bar uses the time from the beginning of the first bar
            // in the period that covers the current bar

            var consolidator = new TradeBarConsolidator(TimeSpan.FromMinutes(1));

            TradeBar consolidated = null;
            consolidator.DataConsolidated += (sender, bar) =>
            {
                consolidated = bar;
            };

            var reference = new DateTime(2014, 12, 1, 10, 00, 0);

            //10:00 - new
            consolidator.Update(new TradeBar {Time = reference});
            Assert.IsNull(consolidated);

            //10:01 - aggregate/fire
            consolidator.Update(new TradeBar {Time = reference.AddMinutes(1)});
            Assert.IsNotNull(consolidated);
            Assert.AreEqual(reference, consolidated.Time);

            //10:02 - new/fire
            consolidator.Update(new TradeBar {Time = reference.AddMinutes(2)});
            Assert.AreEqual(reference.AddMinutes(2), consolidated.Time);

            //10:03 - new/fire
            consolidator.Update(new TradeBar {Time = reference.AddMinutes(3)});
            Assert.AreEqual(reference.AddMinutes(3), consolidated.Time);

            //10:05 - new/fire
            consolidator.Update(new TradeBar {Time = reference.AddMinutes(5)});
            Assert.AreEqual(reference.AddMinutes(5), consolidated.Time);

            //10:08 - new/fire
            consolidator.Update(new TradeBar {Time = reference.AddMinutes(8)});
            Assert.AreEqual(reference.AddMinutes(8), consolidated.Time);

            //10:08:01 - new
            consolidator.Update(new TradeBar {Time = reference.AddMinutes(8).AddSeconds(1)});
            Assert.AreEqual(reference.AddMinutes(8), consolidated.Time);

            //10:08 - new/fire
            consolidator.Update(new TradeBar {Time = reference.AddMinutes(9)});
            Assert.AreEqual(reference.AddMinutes(8).AddSeconds(1), consolidated.Time);
        }
Beispiel #24
0
        public void ConsolidatorEmitsOffsetBarsCorrectly()
        {
            // This test is to cover an issue seen with the live data stack
            // The consolidator would fail to emit every other bar because of a
            // ms delay in data from a live stream
            var period = TimeSpan.FromHours(2);

            using var consolidator = new TradeBarConsolidator(period);
            var consolidatedBarsCount = 0;

            consolidator.DataConsolidated += (sender, bar) =>
            {
                consolidatedBarsCount++;
            };

            var random = new Random();
            var time   = new DateTime(2015, 04, 13);

            // The bars time is accurate, covering the hour perfectly
            // But the emit time is slightly offset (the timeslice that contains the bar)
            // So add a random ms offset to the scan time
            consolidator.Update(new TradeBar {
                Time = time, Period = Time.OneHour
            });
            time = time.Add(period);
            consolidator.Scan(time.AddMilliseconds(random.Next(800)));

            consolidator.Update(new TradeBar {
                Time = time, Period = Time.OneHour
            });
            time = time.Add(period);
            consolidator.Scan(time.AddMilliseconds(random.Next(800)));

            consolidator.Update(new TradeBar {
                Time = time, Period = Time.OneHour
            });
            time = time.Add(period);
            consolidator.Scan(time.AddMilliseconds(random.Next(800)));

            consolidator.Update(new TradeBar {
                Time = time, Period = Time.OneHour
            });
            time = time.Add(period);
            consolidator.Scan(time.AddMilliseconds(random.Next(800)));

            // We should expect to see 4 bars emitted from the consolidator
            Assert.AreEqual(4, consolidatedBarsCount);
        }
Beispiel #25
0
        public void ThrowsWhenPeriodIsSmallerThanDataPeriod()
        {
            TradeBar consolidated = null;

            using var consolidator         = new TradeBarConsolidator(Time.OneHour);
            consolidator.DataConsolidated += (sender, bar) =>
            {
                consolidated = bar;
            };

            var reference = new DateTime(2015, 04, 13);

            Assert.Throws <ArgumentException>(() => consolidator.Update(new TradeBar {
                Time = reference, Period = Time.OneDay
            }));
        }
        public override void Initialize()
        {
            SetStartDate(2015, 6, 26);
            SetEndDate(2015, 7, 2);
            SetCash(25000);

            AddSecurity(SecurityType.Equity, "SPY", Resolution.Minute);

            // define our 15 minute consolidator
            var fifteenMinuteConsolidator = new TradeBarConsolidator(TimeSpan.FromMinutes(15));

            // if we want to make decisions every 15 minutes as well, we can add an event handler
            // to the DataConsolidated event
            fifteenMinuteConsolidator.DataConsolidated += OnFiftenMinuteSPY;

            int fast = 15;
            int slow = 30;

            // define our EMA, we'll manually register this, so we aren't using the helper function 'EMA(...)'
            var fastEmaOnFifteenMinuteBars = new ExponentialMovingAverage("SPY_EMA15", fast);
            var slowEmaOnFifteenMinuteBars = new ExponentialMovingAverage("SPY_EMA30", slow);

            // we can define complex indicator's using various extension methods.
            // here I use the 'Over' extension method which performs division
            // so this will be fast/slow. This returns a new indicator that represents
            // the division operation between the two
            var ratio = fastEmaOnFifteenMinuteBars.Over(slowEmaOnFifteenMinuteBars, "SPY_Ratio_EMA");

            // now we can use the 'Of' extension method to define the ROC on the ratio
            // The 'Of' extension method allows combining multiple indicators together such
            // that the data from one gets sent into the other
            var rocpOfRatio = new RateOfChangePercent("SPY_ROCP_Ratio", fast).Of(ratio);

            // we an even define a smoothed version of this indicator
            var smoothedRocpOfRatio = new ExponentialMovingAverage("SPY_Smoothed_ROCP_Ratio", 5).Of(rocpOfRatio);

            // register our indicator and consolidator together. this will wire the consolidator up to receive
            // data for the specified symbol, and also set up the indicator to receive its data from the consolidator
            RegisterIndicator("SPY", fastEmaOnFifteenMinuteBars, fifteenMinuteConsolidator, Field.Close);
            RegisterIndicator("SPY", slowEmaOnFifteenMinuteBars, fifteenMinuteConsolidator, Field.Close);

            // register the indicator to be plotted along
            PlotIndicator("SPY", fastEmaOnFifteenMinuteBars);
            PlotIndicator("SPY", slowEmaOnFifteenMinuteBars);
            PlotIndicator("SPY_ROCP_Ratio", rocpOfRatio, smoothedRocpOfRatio);
            PlotIndicator("SPY_Ratio_EMA", ratio);
        }
Beispiel #27
0
        public void AggregatesTradeBarToCalendarTradeBarProperly()
        {
            // Monday
            var reference = new DateTime(2019, 3, 18);
            var bars      = new List <TradeBar>
            {
                new TradeBar(reference.AddDays(1), Symbols.SPY, 9, 11, 8, 10, 100, Time.OneDay),
                new TradeBar(reference.AddDays(3), Symbols.SPY, 10, 12, 8, 11, 100, Time.OneDay),
                new TradeBar(reference.AddDays(5), Symbols.SPY, 11, 13, 9, 10, 100, Time.OneDay),
                new TradeBar(reference.AddDays(7), Symbols.SPY, 11, 13, 9, 11, 100, Time.OneDay),
                new TradeBar(reference.AddDays(14), Symbols.SPY, 11, 13, 9, 11, 100, Time.OneDay)
            };

            var weeklyConsolidator = new TradeBarConsolidator(CalendarType.Weekly);

            weeklyConsolidator.DataConsolidated += (s, e) =>
            {
                AssertTradeBar(
                    bars.Take(3),
                    reference,
                    reference.AddDays(7),
                    Symbols.SPY,
                    e);
            };

            var monthlyConsolidator = new TradeBarConsolidator(CalendarType.Monthly);

            monthlyConsolidator.DataConsolidated += (s, e) =>
            {
                AssertTradeBar(
                    bars.Take(4),
                    new DateTime(reference.Year, reference.Month, 1),
                    new DateTime(reference.Year, reference.Month + 1, 1),
                    Symbols.SPY,
                    e);
            };

            foreach (var bar in bars.Take(4))
            {
                weeklyConsolidator.Update(bar);
            }

            foreach (var bar in bars)
            {
                monthlyConsolidator.Update(bar);
            }
        }
        public override void Initialize()
        {
            SetStartDate(2015, 6, 26);
            SetEndDate(2015, 7, 2);
            SetCash(25000);

            AddSecurity(SecurityType.Equity, "SPY", Resolution.Minute);

            // define our 15 minute consolidator
            var fifteenMinuteConsolidator = new TradeBarConsolidator(TimeSpan.FromMinutes(15));

            // if we want to make decisions every 15 minutes as well, we can add an event handler
            // to the DataConsolidated event
            fifteenMinuteConsolidator.DataConsolidated += OnFiftenMinuteSPY;

            int fast = 15;
            int slow = 30;

            // define our EMA, we'll manually register this, so we aren't using the helper function 'EMA(...)'
            var fastEmaOnFifteenMinuteBars = new ExponentialMovingAverage("SPY_EMA15", fast);
            var slowEmaOnFifteenMinuteBars = new ExponentialMovingAverage("SPY_EMA30", slow);

            // we can define complex indicator's using various extension methods.
            // here I use the 'Over' extension method which performs division
            // so this will be fast/slow. This returns a new indicator that represents
            // the division operation between the two
            var ratio = fastEmaOnFifteenMinuteBars.Over(slowEmaOnFifteenMinuteBars, "SPY_Ratio_EMA");

            // now we can use the 'Of' extension method to define the ROC on the ratio
            // The 'Of' extension method allows combining multiple indicators together such
            // that the data from one gets sent into the other
            var rocpOfRatio = new RateOfChangePercent("SPY_ROCP_Ratio", fast).Of(ratio);

            // we an even define a smoothed version of this indicator
            var smoothedRocpOfRatio = new ExponentialMovingAverage("SPY_Smoothed_ROCP_Ratio", 5).Of(rocpOfRatio);

            // register our indicator and consolidator together. this will wire the consolidator up to receive
            // data for the specified symbol, and also set up the indicator to receive its data from the consolidator
            RegisterIndicator("SPY", fastEmaOnFifteenMinuteBars, fifteenMinuteConsolidator, Field.Close);
            RegisterIndicator("SPY", slowEmaOnFifteenMinuteBars, fifteenMinuteConsolidator, Field.Close);

            // register the indicator to be plotted along
            PlotIndicator("SPY", fastEmaOnFifteenMinuteBars);
            PlotIndicator("SPY", slowEmaOnFifteenMinuteBars);
            PlotIndicator("SPY_ROCP_Ratio", rocpOfRatio, smoothedRocpOfRatio);
            PlotIndicator("SPY_Ratio_EMA", ratio);
        }
Beispiel #29
0
        public override void Initialize()
        {
            UnderlyingTicker = GetParameter("symbol");
            Underlying       = QuantConnect.Symbol.Create(UnderlyingTicker, SecurityType.Equity, Market.USA);
            //AAPL
            //SetStartDate(2014, 06, 06);
            //SetEndDate(2014, 06, 06);

            DateTime startDate = DateTime.Parse(GetParameter("start-date"));
            DateTime endDate   = DateTime.Parse(GetParameter("end-date"));

            _ROC_THRESHOLD = parseInt(GetParameter("roc"), _ROC_THRESHOLD);
            _RocPeriod     = parseInt(GetParameter("roc-period"), _RocPeriod);

            /*
             *          _MinDaysRemaining = parseInt(GetParameter("min-days"), _MinDaysRemaining);
             * _MinDaysRemaining = parseInt(GetParameter("max-days"), _MinDaysRemaining);
             * _AtmSpread = parseInt(GetParameter("atm-spread"), _AtmSpread);
             */

            //
            SetStartDate(startDate);
            SetEndDate(endDate);
            //SetStartDate(2015, 01, 01);
            //SetStartDate(2018, 02, 15);
            //SetEndDate(2018, 03, 09);
            SetCash(50000);

            //this.

            var equity = AddEquity(UnderlyingTicker, RESOLUTION);
            var option = AddOption(UnderlyingTicker, RESOLUTION);

            // use the underlying equity as the benchmark
            SetBenchmark(equity.Symbol);

            var consolidator = new TradeBarConsolidator(TimeSpan.FromMinutes(MINUTE_RATE));

            consolidator.DataConsolidated += Consolidator_DataConsolidated;
            _rocp = new RateOfChangePercent(_RocPeriod);
            RegisterIndicator(Underlying, _rocp, consolidator);
            SubscriptionManager.AddConsolidator(Underlying, consolidator);

            // init strategy
            _Strategy = new OptionTraverseStrategy(this, option);
        }
Beispiel #30
0
        public void ZeroSpanAlwaysThrows()
        {
            // defining a TradeBarConsolidator with a zero period should cause it to always throw an exception

            TradeBar consolidated = null;

            using var consolidator         = new TradeBarConsolidator(TimeSpan.Zero);
            consolidator.DataConsolidated += (sender, bar) =>
            {
                consolidated = bar;
            };

            var reference = new DateTime(2014, 12, 01, 01, 01, 00);

            Assert.Throws <ArgumentException>(() => consolidator.Update(new TradeBar {
                Time = reference, Period = Time.OneDay
            }));
        }
Beispiel #31
0
        public void RegisterIndicator(Symbol symbol, IndicatorBase <IndicatorDataPoint> indicator,
                                      TimeSpan interval, Func <TradeBar, decimal> selector = null)
        {
            selector = selector ?? (x => x.Value);

            var consolidator = new TradeBarConsolidator(interval);

            // register the consolidator for automatic updates via SubscriptionManager
            SubscriptionManager.AddConsolidator(symbol, consolidator);

            // attach to the DataConsolidated event so it updates our indicator
            consolidator.DataConsolidated += (sender, consolidated) =>
            {
                var value = selector(consolidated);
                indicator.Update(new IndicatorDataPoint(consolidated.Symbol, consolidated.EndTime, value));
                positionSetting(symbol, indicator);
            };
        }
        public override void Initialize()
        {
            SetStartDate(2016, 1, 1);
            SetEndDate(DateTime.Now);
            SetCash(10000);

            AddSecurity(SecurityType.Equity, symbol, Resolution.Minute);

            _fisher = new FisherTransform(symbol, 14);
            _rsi    = new RelativeStrengthIndex(symbol, 14, MovingAverageType.Exponential).Of(_fisher);

            var fiveConsolidator = new TradeBarConsolidator(TimeSpan.FromMinutes(60));

            SubscriptionManager.AddConsolidator(symbol, fiveConsolidator);

            fiveConsolidator.DataConsolidated += (sender, bar) => _fisher.Update(bar);
            fiveConsolidator.DataConsolidated += OnHour;
        }
Beispiel #33
0
        /// <summary>
        /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
        /// </summary>
        /// <seealso cref="QCAlgorithm.SetStartDate(System.DateTime)"/>
        /// <seealso cref="QCAlgorithm.SetEndDate(System.DateTime)"/>
        /// <seealso cref="QCAlgorithm.SetCash(decimal)"/>
        public override void Initialize()
        {
            SetStartDate(2014, 12, 01);
            SetEndDate(2015, 02, 01);

            // initialize our equity data
            foreach (var symbol in EquitySymbols)
            {
                Data.Add(symbol, new SymbolData(symbol, SecurityType.Equity, BarPeriod, RollingWindowSize));
            }

            // initialize our forex data
            foreach (var symbol in ForexSymbols)
            {
                Data.Add(symbol, new SymbolData(symbol, SecurityType.Forex, BarPeriod, RollingWindowSize));
            }

            // loop through all our symbols and request data subscriptions and initialize indicatora
            foreach (var kvp in Data)
            {
                // this is required since we're using closures below, for more information
                // see: http://stackoverflow.com/questions/14907987/access-to-foreach-variable-in-closure-warning
                var symbolData = kvp.Value;

                // request data subscription
                AddSecurity(symbolData.SecurityType, symbolData.Symbol, Resolution.Minute);

                // define a consolidator to consolidate data for this symbol on the requested period
                var consolidator = new TradeBarConsolidator(BarPeriod);
                // define our indicator
                symbolData.SMA = new SimpleMovingAverage(CreateIndicatorName(symbolData.Symbol, "SMA" + SimpleMovingAveragePeriod, Resolution.Minute), SimpleMovingAveragePeriod);
                // wire up our consolidator to update the indicator
                consolidator.DataConsolidated += (sender, bar) =>
                {
                    // 'bar' here is our newly consolidated data
                    symbolData.SMA.Update(bar.Time, bar.Close);
                    // we're also going to add this bar to our rolling window so we have access to it later
                    symbolData.Bars.Add(bar);
                };

                // we need to add this consolidator so it gets auto updates
                SubscriptionManager.AddConsolidator(symbolData.Symbol, consolidator);
            }
        }
Beispiel #34
0
        public void GentlyHandlesPeriodAndDataAreSameResolution()
        {
            TradeBar consolidated = null;

            using var consolidator         = new TradeBarConsolidator(Time.OneDay);
            consolidator.DataConsolidated += (sender, bar) =>
            {
                consolidated = bar;
            };

            var reference = new DateTime(2015, 04, 13);

            consolidator.Update(new TradeBar {
                Time = reference, Period = Time.OneDay
            });

            Assert.IsNotNull(consolidated);
            Assert.AreEqual(reference, consolidated.Time);
        }
Beispiel #35
0
        public override void Initialize()
        {
            AddSecurity(SecurityType.Equity, "SPY", Resolution.Minute);

            // we have data for these dates locally
            var start = new DateTime(2013, 10, 07, 09, 30, 0);
            SetStartDate(start);
            SetEndDate(start.AddDays(1));

            // define our 30 minute trade bar consolidator. we can access the 30 minute bar
            // from the DataConsolidated events
            var thirtyMinuteConsolidator = new TradeBarConsolidator(TimeSpan.FromMinutes(30));

            // attach our event handler. the event handler is a function that will be called each time we produce
            // a new consolidated piece of data.
            thirtyMinuteConsolidator.DataConsolidated += ThirtyMinuteBarHandler;

            // this call adds our 30 minute consolidator to the manager to receive updates from the engine
            SubscriptionManager.AddConsolidator("SPY", thirtyMinuteConsolidator);

            // here we'll define a slightly more complex consolidator. what we're trying to produce is a 3
            // day bar.  Now we could just use a single TradeBarConsolidator like above and pass in TimeSpan.FromDays(3),
            // but in reality that's not what we want. For time spans of longer than a day we'll get incorrect results around
            // weekends and such. What we really want are tradeable days. So we'll create a daily consolidator, and then wrap
            // it with a 3 count consolidator.

            // first define a one day trade bar -- this produces a consolidated piece of data after a day has passed
            var oneDayConsolidator = new TradeBarConsolidator(TimeSpan.FromDays(1));

            // next define our 3 count trade bar -- this produces a consolidated piece of data after it sees 3 pieces of data
            var threeCountConsolidator = new TradeBarConsolidator(3);

            // here we combine them to make a new, 3 hour trade bar. The SequentialConsolidator allows composition of consolidators.
            // it takes the consolidated output of one consolidator (in this case, the oneDayConsolidator) and pipes it through to
            // the threeCountConsolidator.  His output will be a 3 day bar.
            var three_oneDayBar = new SequentialConsolidator(oneDayConsolidator, threeCountConsolidator);

            // attach our handler
            three_oneDayBar.DataConsolidated += (sender, consolidated) => ThreeHourBarConsolidatedHandler(sender, (TradeBar) consolidated);

            // this call adds our 3 day to the manager to receive updates from the engine
            SubscriptionManager.AddConsolidator("SPY", three_oneDayBar);
        }
Beispiel #36
0
        //Initialize the data and resolution you require for your strategy:
        public override void Initialize()
        {
            SetStartDate(2007, 4, 1);
            SetEndDate(DateTime.Now);
            SetCash(3000);

            // initialize data for all the symbols
            foreach (var symbol in _symbols)
            {
                _symbolData.Add(symbol, new SymbolData(symbol, SecurityType.Forex, _barPeriod, RollingWindowSize));
            }

            //Set forex securities and Consolidate all the data
            foreach (var symbolData in _symbolData.Select(kvp => kvp.Value))
            {
                //AddSecurity(symbolData.SecurityType, symbolData.Symbol, Resolution.Hour);
                AddForex(symbolData.Symbol, Resolution.Hour, Market.Oanda);
                Securities[symbolData.Symbol].FeeModel = new ConstantFeeModel(0m);

                // define a consolidator to consolidate data for this symbol on the requested period
                var consolidator = new TradeBarConsolidator(_barPeriod);

                // define indicators
                symbolData.StdDev = new StandardDeviation(Period);
                symbolData.Min    = new Minimum(NormPeriod);
                symbolData.Max    = new Maximum(NormPeriod);

                //update indicators
                consolidator.DataConsolidated += (sender, bar) =>
                {
                    // 'bar' here is our newly consolidated data
                    symbolData.Min.Update(bar.Time, symbolData.Portfolio);
                    symbolData.Max.Update(bar.Time, symbolData.Portfolio);
                    symbolData.StdDev.Update(bar.Time, bar.Close);

                    // we're also going to add this bar to our rolling window so we have access to it later
                    symbolData.Bars.Add(bar);
                };

                // we need to add this consolidator so it gets auto updates
                SubscriptionManager.AddConsolidator(symbolData.Symbol, consolidator);
            }
        }
Beispiel #37
0
        public override void Initialize()
        {
            //Start and End Date range for the backtest:
            startTime = DateTime.Now;
            SetStartDate(2016, 1, 02);
            SetEndDate(2016, 1, 07);
            SetCash(26000);
            AddSecurity(SecurityType.Equity, _ticker, Resolution.Minute);
            consolidator = new TradeBarConsolidator(TimeSpan.FromMinutes(_consolidated_minutes));
            consolidator.DataConsolidated += ConsolidatedHandler;
            SubscriptionManager.AddConsolidator(_ticker, consolidator);

            //plotter = new Chart("MAMA", ChartType.Overlay);
            //plotter.AddSeries(new Series("Price", SeriesType.Line));
            //plotter.AddSeries(new Series("MAMA", SeriesType.Line));
            //plotter.AddSeries(new Series("FAMA", SeriesType.Line));
            //AddChart(plotter);

            //Warm up the variables
            for (int i = 0; i < 7; i++)
            {
                Periods.Add(0.0);
                Smooths.Add(0.0);
                Detrenders.Add(0.0);
                Q1s.Add(0.0);
                I1s.Add(0.0);
                Q2s.Add(0.0);
                I2s.Add(0.0);
                Res.Add(0.0);
                Ims.Add(0.0);
                SmoothPeriods.Add(0.0);
                Phases.Add(0.0);
                MAMAs.Add(0.0);
                FAMAs.Add(0.0);
            }
        }
        public void FiresEventAfterTimePassesViaScan()
        {
            TradeBar consolidated = null;
            var period = TimeSpan.FromDays(1);
            var consolidator = new TradeBarConsolidator(period);
            consolidator.DataConsolidated += (sender, bar) =>
            {
                consolidated = bar;
            };

            var reference = new DateTime(2015, 04, 13);
            consolidator.Update(new TradeBar { Time = reference.AddSeconds(45), Period = period });
            Assert.IsNull(consolidated);

            consolidator.Scan(reference + period);
            Assert.IsNotNull(consolidated);
            Assert.AreEqual(reference, consolidated.Time);
        }
        public void HandlesGappingAcrossDays()
        {
            // this test requires inspection to verify we're getting clean bars on the correct times

            var consolidator = new TradeBarConsolidator(TimeSpan.FromHours(1));

            TradeBar consolidated = null;
            consolidator.DataConsolidated += (sender, bar) =>
            {
                consolidated = bar;
            };

            // from 1/1 9:30 to 1/2 12:00 by minute
            var start = new DateTime(2014, 01, 01, 09, 30, 00, 00);
            var end =   new DateTime(2014, 01, 02, 12, 00, 00, 00);
            foreach (var bar in StreamTradeBars(start, end, TimeSpan.FromMinutes(1)))
            {
                consolidator.Update(bar);
            }
        }
        public void FiresEventAfterTimePassesViaScanWithMultipleResolutions()
        {
            TradeBar consolidated = null;
            var period = TimeSpan.FromMinutes(2);
            var consolidator = new TradeBarConsolidator(period);
            consolidator.DataConsolidated += (sender, bar) =>
            {
                consolidated = bar;
            };

            var reference = new DateTime(2015, 04, 13, 10, 20, 0);
            var time = reference; 

            for (int i = 0; i < 10; i++)
            {
                consolidator.Update(new TradeBar {Time = time, Period = Time.OneSecond});
                time = time.AddSeconds(1);
                consolidator.Scan(time);
                Assert.IsNull(consolidated);
            }

            consolidator.Update(new TradeBar { Time = time, Period = Time.OneMinute });
            time = reference.Add(period);
            consolidator.Scan(time);
            Assert.IsNotNull(consolidated);
            Assert.AreEqual(reference, consolidated.Time);
            Assert.AreEqual(period, consolidated.Period);

            consolidated = null;

            consolidator.Update(new TradeBar { Time = time, Period = Time.OneSecond });
            time = time.AddSeconds(1);
            consolidator.Scan(time);
            Assert.IsNull(consolidated);

            time = time.AddSeconds(-1);
            consolidator.Update(new TradeBar { Time = time, Period = Time.OneMinute });
            time = time.AddMinutes(1);
            consolidator.Scan(time);
            Assert.IsNull(consolidated);

            consolidator.Update(new TradeBar { Time = time, Period = Time.OneMinute });
            time = time.AddMinutes(1);
            consolidator.Scan(time);
            Assert.IsNotNull(consolidated);
            Assert.AreEqual(reference.AddMinutes(2), consolidated.Time);
            Assert.AreEqual(period, consolidated.Period);
        }
Beispiel #41
0
        /// <summary>
        /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
        /// </summary>
        public override void Initialize()
        {
            SetCash(25000);
            SetStartDate(2007, 1, 1);

            //UpdateStatus = new List<bool>(Enumerable.Repeat(false,GrowthSymbols.Union(SafetySymbols).ToList().Count()));

            foreach (var symbol in GrowthSymbols.Union(SafetySymbols))
            {
                Data.Add(symbol, new SymbolData(symbol, SecurityType.Equity, BarResolution, LookBackPeriod_Day));
                UpdateStatus[symbol] = false;
            }

            foreach (var kvp in Data)
            {
                // this is required since we're using closures below, for more information
                // see: http://stackoverflow.com/questions/14907987/access-to-foreach-variable-in-closure-warning
                var symbolData = kvp.Value;
                //Minute Level subscriptions
                AddSecurity(SecurityType.Equity, symbolData.Symbol, Resolution.Daily);
                //Construct daily Momentum and SD indication by using Helper function, in which auto daily updates is handled by RegisterIndicator function
                //But this is only litmited to case when Resolution.XXX is ready. Otherwise, e.g. 10minutes bar, separate update function need be created, updated by Indicator's Update functions
                symbolData.Return = new Momentum(CreateIndicatorName(symbolData.Symbol, "MOM" + LookBackPeriod_Day, Resolution.Minute), LookBackPeriod_Day);
                symbolData.SD = new StandardDeviation(CreateIndicatorName(symbolData.Symbol, "SMA" + LookBackPeriod_Day, Resolution.Minute), LookBackPeriod_Day);
                STD(symbolData.Symbol, LookBackPeriod_Day, Resolution.Daily);
                //Daily Level Consolidator for storing history data to Bars
                var consolidator = new TradeBarConsolidator(BarResolution);
                consolidator.DataConsolidated += (sender, bar) => //we may also update Return and SD in this event handler, put Bars as the bottom, such that if Bar is updated, then the other must have been updated
                {
                    symbolData.Return.Update(bar.Time, bar.Value);
                    symbolData.SD.Update(bar.Time, bar.Value);
                    symbolData.Bars.Add(bar);//once bar updated, the return and sd must be updated
                };
                SubscriptionManager.AddConsolidator(symbolData.Symbol, consolidator);
            }
        }
        public void ClosedLeftOpenRightInTimeSpanModeTest()
        {
            // define a three minute consolidator 
            int timeSpanUnits = 3;
            var consolidator = new TradeBarConsolidator(TimeSpan.FromMinutes(timeSpanUnits));

            TradeBar consolidated = null;
            consolidator.DataConsolidated += (sender, bar) =>
            {
                consolidated = bar;
            };

            var refDateTime = new DateTime(2014, 12, 1, 10, 00, 0);

            // loop for 3 times the timeSpanUnits + 1, so it would consolidate the bars 3 times
            for (int i=0; i < 3*timeSpanUnits + 1 ; ++i) 
            {
                consolidator.Update(new TradeBar { Time = refDateTime });

                if (i < timeSpanUnits)  // before initial consolidation happens
                {
                    Assert.IsNull(consolidated);
                }
                else 
                {
                    Assert.IsNotNull(consolidated);
                    if (i % timeSpanUnits == 0) // i = 3, 6, 9
                    {
                        Assert.AreEqual(refDateTime.AddMinutes(-timeSpanUnits), consolidated.Time);
                    }
                }

                refDateTime = refDateTime.AddMinutes(1);
            }
        }
        /// <summary>
        /// Initialise the data and resolution required, as well as the cash and start-end dates for your algorithm. All algorithms must initialized.
        /// </summary>
        /// <seealso cref="QCAlgorithm.SetStartDate(System.DateTime)"/>
        /// <seealso cref="QCAlgorithm.SetEndDate(System.DateTime)"/>
        /// <seealso cref="QCAlgorithm.SetCash(decimal)"/>
        public override void Initialize()
        {
            SetStartDate(2014, 12, 01);
            SetEndDate(2015, 02, 01);

            // initialize our equity data
            foreach (var symbol in EquitySymbols)
            {
                Data.Add(symbol, new SymbolData(symbol, SecurityType.Equity, BarPeriod, RollingWindowSize));
            }

            // initialize our forex data
            foreach (var symbol in ForexSymbols)
            {
                Data.Add(symbol, new SymbolData(symbol, SecurityType.Forex, BarPeriod, RollingWindowSize));
            }

            // loop through all our symbols and request data subscriptions and initialize indicatora
            foreach (var kvp in Data)
            {
                // this is required since we're using closures below, for more information
                // see: http://stackoverflow.com/questions/14907987/access-to-foreach-variable-in-closure-warning
                var symbolData = kvp.Value;

                // request data subscription
                AddSecurity(symbolData.SecurityType, symbolData.Symbol, Resolution.Minute);

                // define a consolidator to consolidate data for this symbol on the requested period
                var consolidator = new TradeBarConsolidator(BarPeriod);
                // define our indicator
                symbolData.SMA = new SimpleMovingAverage(CreateIndicatorName(symbolData.Symbol, "SMA" + SimpleMovingAveragePeriod, Resolution.Minute), SimpleMovingAveragePeriod);
                // wire up our consolidator to update the indicator
                consolidator.DataConsolidated += (sender, bar) =>
                {
                    // 'bar' here is our newly consolidated data
                    symbolData.SMA.Update(bar.Time, bar.Close);
                    // we're also going to add this bar to our rolling window so we have access to it later
                    symbolData.Bars.Add(bar);
                };

                // we need to add this consolidator so it gets auto updates
                SubscriptionManager.AddConsolidator(symbolData.Symbol, consolidator);
            }
        }
        public void ConsolidatedPeriodEqualsTimeBasedConsolidatorPeriod()
        {
            TradeBar consolidated = null;
            var period = TimeSpan.FromMinutes(2);
            var consolidator = new TradeBarConsolidator(period);
            consolidator.DataConsolidated += (sender, bar) =>
            {
                consolidated = bar;
            };

            var reference = new DateTime(2015, 04, 13, 10, 20, 0);
            var time = reference;

            consolidator.Update(new TradeBar { Time = time, Period = Time.OneMinute });
            time = reference.Add(period);
            consolidator.Scan(time);
            Assert.IsNotNull(consolidated);
            Assert.AreEqual(reference, consolidated.Time);
            Assert.AreEqual(period, consolidated.Period);
        }
        public void HandlesDataGapsInMixedMode()
        {
            // define a three minute consolidator on a one minute stream of data
            var consolidator = new TradeBarConsolidator(3, TimeSpan.FromMinutes(3));

            TradeBar consolidated = null;
            consolidator.DataConsolidated += (sender, bar) =>
            {
                consolidated = bar;
            };

            var reference = new DateTime(2014, 12, 1, 10, 00, 0);

            //10:00 - new
            consolidator.Update(new TradeBar {Time = reference});
            Assert.IsNull(consolidated);

            //10:01 - aggregate
            consolidator.Update(new TradeBar {Time = reference.AddMinutes(1)});
            Assert.IsNull(consolidated);

            //10:02 - fire
            consolidator.Update(new TradeBar {Time = reference.AddMinutes(2)});
            Assert.IsNotNull(consolidated);
            Assert.AreEqual(reference, consolidated.Time);

            //10:03 - new
            consolidator.Update(new TradeBar {Time = reference.AddMinutes(3)});
            Assert.AreEqual(reference, consolidated.Time);

            //10:06 - aggregate/fire
            consolidator.Update(new TradeBar {Time = reference.AddMinutes(6)});
            Assert.AreEqual(reference.AddMinutes(3), consolidated.Time);

            //10:08 - new/fire -- will have timestamp from 10:08, instead of 10:06
            consolidator.Update(new TradeBar {Time = reference.AddMinutes(8)});
            Assert.AreEqual(reference.AddMinutes(8), consolidated.Time);
        }
        public void HandlesGappingAcrossDays()
        {
            var consolidator = new TradeBarConsolidator(TimeSpan.FromHours(1));

            TradeBar consolidated = null;
            consolidator.DataConsolidated += (sender, bar) =>
            {
                consolidated = bar;
                Console.WriteLine(bar.Time);
            };

            // from 1/1 9:30 to 1/2 12:00 by minute
            var start = new DateTime(2014, 01, 01, 09, 30, 00, 00);
            var end =   new DateTime(2014, 01, 02, 12, 00, 00, 00);
            foreach (var bar in StreamTradeBars(start, end, TimeSpan.FromMinutes(1)))
            {
                consolidator.Update(bar);
            }
        }
        public void OneMinuteAlwaysFiresEveryTimeOnMinueDataExceptFirstPoint()
        {
            // defining a TradeBarConsolidator with the same period as the resolution of input data will cause
            // it to not fire on the first piece of data as it is initializing, but will thenfire for each
            // consecutive data point

            TradeBar consolidated = null;
            var consolidator = new TradeBarConsolidator(TimeSpan.FromMinutes(1));
            consolidator.DataConsolidated += (sender, bar) =>
            {
                consolidated = bar;
            };

            var reference = new DateTime(2014, 12, 01, 01, 01, 00);
            consolidator.Update(new TradeBar {Close = 1m, Time = reference});
            Assert.IsNull(consolidated);

            consolidator.Update(new TradeBar {Close = 2m, Time = reference.AddMinutes(1)});
            Assert.IsNotNull(consolidated);
            Assert.AreEqual(2, consolidated.Close);

            consolidator.Update(new TradeBar {Close = 3m, Time = reference.AddMinutes(2)});
            Assert.IsNotNull(consolidated);
            Assert.AreEqual(3, consolidated.Close);
        }
        public void ZeroSpanAlwaysFires()
        {
            // defining a TradeBarConsolidator with a zero period should cause it to always fire identity

            TradeBar consolidated = null;
            var consolidator = new TradeBarConsolidator(TimeSpan.Zero);
            consolidator.DataConsolidated += (sender, bar) =>
            {
                consolidated = bar;
            };

            var reference = new DateTime(2014, 12, 01, 01, 01, 00);
            consolidator.Update(new TradeBar {Close = 1m, Time = reference});
            Assert.IsNotNull(consolidated);
            Assert.AreEqual(1, consolidated.Close);

            consolidator.Update(new TradeBar {Close = 2m, Time = reference});
            Assert.IsNotNull(consolidated);
            Assert.AreEqual(2, consolidated.Close);

            consolidator.Update(new TradeBar {Close = 3m, Time = reference});
            Assert.IsNotNull(consolidated);
            Assert.AreEqual(3, consolidated.Close);
        }
        public void ConsolidatesOHLCV()
        {
            // verifies that the TradeBarConsolidator correctly consolidates OHLCV data into a new TradeBar instance

            TradeBar consolidated = null;
            var consolidator = new TradeBarConsolidator(3);
            consolidator.DataConsolidated += (sender, bar) =>
            {
                consolidated = bar;
            };

            var tb1 = new TradeBar
            {
                Symbol = "SPY",
                Open = 10,
                High = 100,
                Low = 1,
                Close = 50,
                Volume = 75,
                DataType = MarketDataType.TradeBar
            };

            var tb2 = new TradeBar
            {
                Symbol = "SPY",
                Open = 50,
                High = 123,
                Low = 35,
                Close = 75,
                Volume = 100,
                DataType = MarketDataType.TradeBar
            };

            var tb3 = new TradeBar
            {
                Symbol = "SPY",
                Open = 75,
                High = 100,
                Low = 50,
                Close = 83,
                Volume = 125,
                DataType = MarketDataType.TradeBar
            };

            consolidator.Update(tb1);
            consolidator.Update(tb2);
            consolidator.Update(tb3);

            Assert.IsNotNull(consolidated);
            Assert.AreEqual("SPY", consolidated.Symbol);
            Assert.AreEqual(10m, consolidated.Open);
            Assert.AreEqual(123m, consolidated.High);
            Assert.AreEqual(1m, consolidated.Low);
            Assert.AreEqual(83m, consolidated.Close);
            Assert.AreEqual(300L, consolidated.Volume);
        }