namespace QuantConnect
{
/// <summary>
/// Cloned from https://github.com/QuantConnect/Lean/blob/master/Algorithm.CSharp/MultipleSymbolConsolidationAlgorithm.cs
/// </summary>
/* Things to do:
1. Add two or more symbols to be looked at.
2. Get the last 10 prices for each 2 hour period.
This could be over multiple days, ignore weekend and holidays.
3. Warmup does not seem to be working
4. In the documentation I saw a line for RegisterIndicator. Is this not required?
5. How would I used Consolidators with long and short SMA.
6. How would I used Consolidators withe multiple indicators - SMA, RSI - Long and short for each
7. The "Bar" has two values Time and EndTime. The data provided is for which time?
8. Could the SMA be defined with
symbolData.SMA = SMA(symbolData.Symbol, SimpleMovingAveragePeriod, ResolutionPeriod);
9.
*/
/* Errors:
*/
public class TestConsolidatedIndicator : QCAlgorithm
{
private const int BarPeriodValue = 2;
/// <summary>
/// This is the period of bars we'll be creating
/// </summary>
public readonly Resolution ResolutionPeriod = Resolution.Hour;
/// <summary>
/// This is the period of bars we'll be creating
/// </summary>
//public readonly TimeSpan BarPeriod; //= GetBarPeriod();
/// <summary>
/// This is the period of our sma indicators
/// </summary>
public readonly int SimpleMovingAveragePeriod = 3;
/// <summary>
/// This is the number of consolidated bars we'll hold in symbol data for reference
/// </summary>
public readonly int RollingWindowSize = 5;
/// <summary>
/// Holds all of our data keyed by each symbol
/// </summary>
public readonly Dictionary<string, SymbolData> Data = new Dictionary<string, SymbolData>();
/// <summary>
/// Contains all of our equity symbols
/// </summary>
public readonly IReadOnlyList<string> EquitySymbols = new List<string>
{
// "AAPL",
// "SPY",
"IBM"
};
/// <summary>
/// This is the period of bars we'll be creating
/// </summary>
private TimeSpan GetBarPeriod()
{
switch (ResolutionPeriod)
{
case Resolution.Minute:
return TimeSpan.FromMinutes(BarPeriodValue);
case Resolution.Hour:
return TimeSpan.FromHours(BarPeriodValue);
case Resolution.Daily:
return TimeSpan.FromDays(BarPeriodValue);
default:
throw new ArgumentOutOfRangeException();
}
}
/// <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()
{
SetStartDate(1998, 01, 03); // Set Start Date
SetEndDate(1998, 1, 5); // Set End Date
SetCash(10000); // Set Strategy Cash
SetWarmUp(RollingWindowSize); // Happens after Initalize is done.
// initialize our equity data
foreach (var symbol in EquitySymbols)
{
var equity = AddEquity(symbol, ResolutionPeriod);
Data.Add(symbol, new SymbolData(equity.Symbol, GetBarPeriod(), RollingWindowSize));
}
// loop through all our symbols and request data subscriptions and initialize indicators
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;
// define a consolidator to consolidate data for this symbol on the requested period
var consolidator = symbolData.Symbol.SecurityType == SecurityType.Equity
? (IDataConsolidator)new TradeBarConsolidator(GetBarPeriod())
: (IDataConsolidator)new QuoteBarConsolidator(GetBarPeriod());
// define our indicator
symbolData.SMA = new SimpleMovingAverage(CreateIndicatorName(symbolData.Symbol, "SMA" + SimpleMovingAveragePeriod, ResolutionPeriod), SimpleMovingAveragePeriod);
//symbolData.SMA = SMA(symbolData.Symbol, SimpleMovingAveragePeriod, ResolutionPeriod);
// wire up our consolidator to update the indicator
consolidator.DataConsolidated += (sender, baseData) =>
{
// 'bar' here is our newly consolidated data
var bar = (IBaseDataBar)baseData;
// update the indicator
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);
};
consolidator.DataConsolidated += HandleConsolidatedData; // HERE: Need this
// we need to add this consolidator so it gets auto updates
SubscriptionManager.AddConsolidator(symbolData.Symbol, consolidator);
}
// Debug("Is the warmup done?");
}
public void HandleConsolidatedData(object pSender, IBaseData pBaseData)
{
//if (IsWarmingUp) return;
var vMethodName = "HandleConsolidatedData";
LogMethodStart(vMethodName);
// loop through each symbol in our structure
foreach (var symbolData in Data.Values)
{
// this check proves that this symbol was JUST updated prior to this OnData function being called
if (symbolData.IsReady && symbolData.WasJustUpdated(Time))
{
LogMethodStart(vMethodName + " - " + symbolData.Symbol);
foreach(var bar in symbolData.Bars)
{
var message = String.Format("{4} - Time: {0:ddd} {0} ; EndTime: {1:ddd} {1} ; Value: {2} ; Price: {3}", bar.Time, bar.EndTime, bar.Value, bar.Price, vMethodName);
// Debug(bar.ToString());
Debug(message);
}
if (!Portfolio[symbolData.Symbol].Invested)
{
MarketOrder(symbolData.Symbol, 1);
}
}
}
}
/// <summary>
/// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
/// </summary>
/// <param name="data">TradeBars IDictionary object with your stock data</param>
public override void OnData(Slice data)
// public void OnData(TradeBars data)
{
var vMethodName = "OnData";
if (IsWarmingUp) return;
LogMethodStart(vMethodName);
// loop through each symbol in our structure
foreach (var symbolData in Data.Values)
{
// this check proves that this symbol was JUST updated prior to this OnData function being called
if (symbolData.IsReady && symbolData.WasJustUpdated(Time))
{
// LogMethodStart(vMethodName + " - " + symbolData.Symbol);
// foreach(var bar in symbolData.Bars)
// {
// var message = String.Format("{4} - Time: {0:ddd} {0} ; EndTime: {1:ddd} {1} ; Value: {2} ; Price: {3}", bar.Time, bar.EndTime, bar.Value, bar.Price, vMethodName);
// // Debug(bar.ToString());
// Debug(message);
// }
if (!Portfolio[symbolData.Symbol].Invested)
{
MarketOrder(symbolData.Symbol, 1);
}
}
}
}
/// <summary>
/// End of a trading day event handler. This method is called at the end of the algorithm day (or multiple times if trading multiple assets).
/// </summary>
/// <remarks>Method is called 10 minutes before closing to allow user to close out position.</remarks>
public override void OnEndOfDay()
{
LogMethodStart("OnEndOfDay");
int i = 0;
foreach (var kvp in Data.OrderBy(x => x.Value.Symbol))
{
// we have too many symbols to plot them all, so plot ever other
if (kvp.Value.IsReady && ++i%2 == 0)
{
Plot(kvp.Value.Symbol.ToString(), kvp.Value.SMA);
}
}
}
#region Log Method Start & End
private void LogMethodStart(string pMethodName)
{
LogMethod(pMethodName);
}
private void LogMethodEnd(string pMethodName)
{
LogMethod(pMethodName, false);
}
private void LogMethod(string pMethodName, bool pIsStart = true)
{
var vState = pIsStart ? "Start" : "End";
var vMessage = String.Format("Method: {0} {1} - {2:MM/dd/yy H:mm:ss:fff}", pMethodName, vState, Time);
LogIt(vMessage);
}
#endregion Log Method Start & End
private void LogIt(string pMessage)
{
//Debug(pMessage);
Log(pMessage);
}
/// <summary>
/// Contains data pertaining to a symbol in our algorithm
/// </summary>
public class SymbolData
{
/// <summary>
/// This symbol the other data in this class is associated with
/// </summary>
public readonly Symbol Symbol;
/// <summary>
/// A rolling window of data, data needs to be pumped into Bars by using Bars.Update( tradeBar ) and
/// can be accessed like:
/// mySymbolData.Bars[0] - most first recent piece of data
/// mySymbolData.Bars[5] - the sixth most recent piece of data (zero based indexing)
/// </summary>
public readonly RollingWindow<IBaseDataBar> Bars;
/// <summary>
/// The period used when population the Bars rolling window.
/// </summary>
public readonly TimeSpan BarPeriod;
/// <summary>
/// The simple moving average indicator for our symbol
/// </summary>
public SimpleMovingAverage SMA;
/// <summary>
/// Initializes a new instance of SymbolData
/// </summary>
public SymbolData(Symbol symbol, TimeSpan barPeriod, int windowSize)
{
Symbol = symbol;
BarPeriod = barPeriod;
Bars = new RollingWindow<IBaseDataBar>(windowSize);
}
/// <summary>
/// Returns true if all the data in this instance is ready (indicators, rolling windows, ect...)
/// </summary>
public bool IsReady
{
get { return Bars.IsReady && SMA.IsReady; }
}
/// <summary>
/// Returns true if the most recent trade bar time matches the current time minus the bar's period, this
/// indicates that update was just called on this instance
/// </summary>
/// <param name="current">The current algorithm time</param>
/// <returns>True if this instance was just updated with new data, false otherwise</returns>
public bool WasJustUpdated(DateTime current)
{
return Bars.Count > 0 && Bars[0].Time == current - this.BarPeriod;
}
public void ShowBars()
{
Console.WriteLine("Show Bars for: " + Symbol.ToString());
foreach(var bar in Bars)
{
Console.WriteLine(bar.ToString());
}
}
}
}
}