/// <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(2015, 11, 12);
SetEndDate(2016, 04, 01);
//Set the cash for the strategy:
SetCash(100000);
SetBrokerageModel(BrokerageName.GDAX, AccountType.Cash);
SetTimeZone(NodaTime.DateTimeZone.Utc);
var security = AddSecurity(SecurityType.Crypto, "BTCUSD", Resolution.Daily, Market.GDAX, false, 3.3m, true);
var con = new QuoteBarConsolidator(1);
SubscriptionManager.AddConsolidator("BTCUSD", con);
con.DataConsolidated += DataConsolidated;
SetBenchmark(security.Symbol);
}
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);
_TargetProfit = parseDec(GetParameter("target-profit"), _TargetProfit);
_PositionSizeStart = parseInt(GetParameter("position-size"), _PositionSizeStart);
_MinDaysRemaining = parseInt(GetParameter("min-days"), _MinDaysRemaining);
_MaxTiers = parseInt(GetParameter("max-tiers"), _MaxTiers);
_ItmDepth = parseInt(GetParameter("itm-depth"), _ItmDepth);
//
SetStartDate(startDate);
SetEndDate(endDate);
//SetStartDate(2015, 01, 01);
//SetStartDate(2018, 02, 15);
//SetEndDate(2018, 03, 09);
SetCash(20000);
//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 OptionStrategy(this, option, _MaxTiers, _PositionSizeStart, _ItmDepth, _MinDaysRemaining);
}
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;
}
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);
};
}
/// <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);
}
}
/// <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()
{
AddSecurity(SecurityType.Equity, "SPY");
// 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);
}
//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);
}
}
public override void OnData(Slice slice)
{
foreach (var chain in slice.FutureChains)
{
foreach (var contract in chain.Value)
{
if (!_futureContracts.Contains(contract.Symbol))
{
_futureContracts.Add(contract.Symbol);
var consolidator = new QuoteBarConsolidator(TimeSpan.FromMinutes(5));
consolidator.DataConsolidated += OnDataConsolidated;
SubscriptionManager.AddConsolidator(contract.Symbol, consolidator);
Log("Added new consolidator for " + contract.Symbol.Value);
}
}
}
}
public override void Initialize()
{
// backtest parameters
SetStartDate(2009, 10, 4);
SetEndDate(2019, 10, 11);
// cash allocation
SetCash(25000);
AddSecurity(SecurityType.Forex, "EURUSD", Resolution.Hour, Market.IB, false, 1, true);
//create a consolidator object; for quotebars; for a timespan of 6 hours
var thirtyMinutes = new QuoteBarConsolidator(TimeSpan.FromHours(6));
//bind event handler to data consolidated event.
thirtyMinutes.DataConsolidated += OnHalfHour;
//register the consolidator for data.
SubscriptionManager.AddConsolidator(_symbol, thirtyMinutes);
}
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"));
_TargetProfit = parseDec(GetParameter("target-profit"), _TargetProfit);
_PositionSizeStart = parseInt(GetParameter("position-size"), _PositionSizeStart);
_MinDaysRemaining = parseInt(GetParameter("min-days"), _MinDaysRemaining);
_MaxTiers = parseInt(GetParameter("max-tiers"), _MaxTiers);
_StrikeSpread = parseInt(GetParameter("strike-spread"), _StrikeSpread);
//
SetStartDate(startDate);
SetEndDate(endDate);
//SetStartDate(2015, 01, 01);
//SetStartDate(2018, 02, 15);
//SetEndDate(2018, 03, 09);
SetCash(20000);
//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;
SubscriptionManager.AddConsolidator(Underlying, consolidator);
// init strategy
_Strategy = new CoveredOptionStrategy(this, option, OptionRight.Call, _MaxTiers, _PositionSizeStart, _MinDaysRemaining);
}
/// <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(2015, 11, 12);
SetEndDate(2016, 04, 01);
//Set the cash for the strategy:
SetCash(100000);
SetBrokerageModel(BrokerageName.GDAX, AccountType.Cash);
SetTimeZone(NodaTime.DateTimeZone.Utc);
var security = AddSecurity(SecurityType.Crypto, "BTCUSD", Resolution.Daily, Market.GDAX, false, 3.3m, true);
// The default buying power model for the Crypto security type is now CashBuyingPowerModel.
// Since this test algorithm uses leverage we need to set a buying power model with margin.
security.BuyingPowerModel = new SecurityMarginModel(3.3m);
var con = new TradeBarConsolidator(1);
SubscriptionManager.AddConsolidator("BTCUSD", con);
con.DataConsolidated += DataConsolidated;
SetBenchmark(security.Symbol);
}
/// <summary>
/// Registers the consolidator to receive automatic updates as well as configures the indicator to receive updates
/// from the consolidator.
/// </summary>
/// <param name="symbol">The symbol to register against</param>
/// <param name="indicator">The indicator to receive data from the consolidator</param>
/// <param name="consolidator">The consolidator to receive raw subscription data</param>
public void RegisterIndicator <T>(string symbol, IndicatorBase <T> indicator, IDataConsolidator consolidator)
where T : BaseData
{
// register the consolidator for automatic updates via SubscriptionManager
SubscriptionManager.AddConsolidator(symbol, consolidator);
// check the output type of the consolidator and verify we can assign it to T
var type = typeof(T);
if (!type.IsAssignableFrom(consolidator.OutputType))
{
throw new ArgumentException(string.Format("Type mismatch found between consolidator and indicator for symbol: {0}." +
"Consolidator outputs type {1} but indicator expects input type {2}",
symbol, consolidator.OutputType.Name, type.Name)
);
}
// attach to the DataConsolidated event so it updates our indicator
consolidator.DataConsolidated += (sender, consolidated) =>
{
indicator.Update(consolidated as T);
};
}
/// <summary>
/// Initializes the algorithm state.
/// </summary>
public override void Initialize()
{
SetStartDate(2012, 01, 01);
SetEndDate(2013, 01, 01);
AddEquity("SPY", Resolution.Daily);
// this is the simple constructor that will perform the renko logic to the Value
// property of the data it receives.
// break SPY into $2.5 renko bricks and send that data to our 'OnRenkoBar' method
var renkoClose = new RenkoConsolidator(2.5m);
renkoClose.DataConsolidated += (sender, consolidated) =>
{
// call our event handler for renko data
HandleRenkoClose(consolidated);
};
// register the consolidator for updates
SubscriptionManager.AddConsolidator("SPY", renkoClose);
// this is the full constructor that can accept a value selector and a volume selector
// this allows us to perform the renko logic on values other than Close, even computed values!
// break SPY into (2*o + h + l + 3*c)/7
var renko7bar = new RenkoConsolidator <TradeBar>(2.5m, x => (2 * x.Open + x.High + x.Low + 3 * x.Close) / 7m, x => x.Volume);
renko7bar.DataConsolidated += (sender, consolidated) =>
{
HandleRenko7Bar(consolidated);
};
// register the consolidator for updates
SubscriptionManager.AddConsolidator("SPY", renko7bar);
}
/// <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 override void Initialize()
{
SetStartDate(2017, 1, 1); //Set Start Date
SetEndDate(2017, 1, 2); //Set End Date
SetCash(_startingCash); //Set Strategy Cash
QuantConnect.Securities.Crypto.Crypto crypto = AddCrypto(_ticker, _resolution);
_baseSymbol = crypto.BaseCurrencySymbol;
SetBrokerageModel(BrokerageName.Bitfinex, AccountType.Cash);
TradeBarConsolidator consolidator = new TradeBarConsolidator(TimeSpan.FromHours(1));
SubscriptionManager.AddConsolidator(_ticker, consolidator);
consolidator.DataConsolidated += OnCustomHandler;
// use constructor for ExponentialMovingAverage instead of QCAlgorithm#EMA
_fastEmaCustomTimeFrame = new ExponentialMovingAverage(_fastPeriod);
_fastEmaStandardResolution = EMA(_ticker, _fastPeriod, _resolution);
RegisterIndicator(_ticker, _fastEmaCustomTimeFrame, consolidator);
var history = History <TradeBar>(_ticker, 12);
foreach (var bar in history)
{
_fastEmaCustomTimeFrame.Update(bar.EndTime, bar.Close);
_fastEmaStandardResolution.Update(bar.EndTime, bar.Close);
}
}
public override void Initialize()
{
SetStartDate(2015, 1, 1);
SetEndDate(DateTime.Now);
SetCash(10000);
foreach (var equity in _equities)
{
AddSecurity(SecurityType.Equity, equity, Resolution.Minute);
}
_s = new int[_stocks.Length];
_x0 = new int[_stocks.Length];
_x1 = Enumerable.Repeat(1d / _stocks.Length, _stocks.Length).ToArray();
_symbolData = new Dictionary <Symbol, SymbolData>();
_bb = new BollingerBands(_spy, 22, 1.05m, MovingAverageType.Simple);
_spyWvf = new RollingWindow <decimal>(22);
foreach (var stock in _stocks)
{
var closes = new RollingWindow <decimal>(17 * 390);
var dailyCloses = new RollingWindow <TradeBar>(29);
var dailyConsolidator = new TradeBarConsolidator(TimeSpan.FromDays(1));
dailyConsolidator.DataConsolidated += (sender, consolidated) => _symbolData[consolidated.Symbol].UpdateDaily(consolidated);
SubscriptionManager.AddConsolidator(stock, dailyConsolidator);
_symbolData.Add(stock, new SymbolData(closes, dailyCloses));
}
var spyDailyCloses = new RollingWindow <TradeBar>(28);
var spyDailyConsolidator = new TradeBarConsolidator(TimeSpan.FromDays(1));
spyDailyConsolidator.DataConsolidated += (sender, consolidated) => _symbolData[consolidated.Symbol].UpdateDaily(consolidated);
SubscriptionManager.AddConsolidator(_spy, spyDailyConsolidator);
_symbolData.Add(_spy, new SymbolData(null, spyDailyCloses));
var vxxDailyConsolidator = new TradeBarConsolidator(TimeSpan.FromDays(1));
vxxDailyConsolidator.DataConsolidated += (sender, consolidated) => _symbolData[consolidated.Symbol].UpdateDaily(consolidated);
SubscriptionManager.AddConsolidator(_vxx, vxxDailyConsolidator);
_symbolData.Add(_spy, new SymbolData(null, spyDailyCloses));
Schedule.On(DateRules.EveryDay(), TimeRules.AfterMarketOpen("SPY", 15d), () =>
{
if (_symbolData[_spy].IsReady)
{
return;
}
var vxxCloses = _symbolData[_vxx].DailyHistory.Select(tb => tb.Close);
var vxxLows = _symbolData[_vxx].DailyHistory.Select(tb => tb.Low);
// William's VIX Fix indicator a.k.a. the Synthetic VIX
var previousMax = vxxCloses.Take(28).Max();
var previousWvf = 100 * (previousMax - vxxLows.Skip(27).First()) / previousMax;
var max = vxxCloses.Skip(1).Max();
var wvf = 100 * (max - vxxLows.Last()) / max;
if (previousWvf < WvfLimit && wvf >= WvfLimit)
{
SetHoldings(_vxx, 0);
SetHoldings(_xiv, 0.07);
}
else if (previousWvf > WvfLimit && wvf <= WvfLimit)
{
SetHoldings(_vxx, 0.07);
SetHoldings(_xiv, 0);
}
});
Schedule.On(DateRules.EveryDay(), TimeRules.AfterMarketOpen("SPY", 15d), () =>
{
if (_symbolData[_spy].IsReady)
{
return;
}
var spyCloses = _symbolData[_spy].NDaysDailyHistory(22).Select(tb => tb.Close);
var spyLows = _symbolData[_spy].NDaysDailyHistory(22).Select(tb => tb.Low);
var max = spyCloses.Max();
var wvf = 100 * (max - spyLows.Last()) / max;
_bb.Update(DateTime.Now, wvf);
_spyWvf.Add(wvf);
var rangeHigh = _spyWvf.Max() * 0.9m;
var latestClose = _symbolData[_spy].NDaysDailyHistory(1).First().Close;
var spy_higher_then_Xdays_back = latestClose > _symbolData[_spy].NDaysDailyHistory(3).First().Close;
var spy_lower_then_longterm = latestClose > _symbolData[_spy].NDaysDailyHistory(40).First().Close;
var spy_lower_then_midterm = latestClose > _symbolData[_spy].NDaysDailyHistory(14).First().Close;
// Alerts Criteria
var alert2 = !(_spyWvf[0] >= _bb.UpperBand && _spyWvf[0] >= rangeHigh) &&
(_spyWvf[1] >= _bb.UpperBand && _spyWvf[2] >= rangeHigh);
if ((alert2 || spy_higher_then_Xdays_back) && (spy_lower_then_longterm || spy_lower_then_midterm))
{
SetHoldings(_spy, 0.3);
SetHoldings(_shortSpy, 0);
}
else
{
SetHoldings(_spy, 0);
SetHoldings(_shortSpy, 0.3);
}
});
Schedule.On(DateRules.EveryDay(), TimeRules.AfterMarketOpen("SPY", 15d), () =>
{
if (_symbolData[_spy].IsReady)
{
return;
}
var returns = new List <double[]>(); // 28?
foreach (var stock in _stocks)
{
_symbolData[stock].UpdateWeights();
returns.Add(_symbolData[stock].PercentReturn.Select(pr => (double)(pr / _symbolData[stock].Norm)).ToArray());
}
var retNorm = _symbolData.Select(s => s.Value.Norm);
var retNormMax = retNorm.Max();
var epsFactor = retNormMax > 0 ? 0.9m : 1.0m;
var eps = (double)(epsFactor * retNormMax);
var constraints = new List <LinearConstraint>();
constraints.Add(new LinearConstraint(Enumerable.Repeat(1.0, _stocks.Length).ToArray())
{
ShouldBe = ConstraintType.EqualTo,
Value = 1
});
constraints.Add(new LinearConstraint(retNorm.Select(x => (double)x).ToArray())
{
ShouldBe = ConstraintType.GreaterThanOrEqualTo,
Value = eps + eps * 0.01
}); // Add and subtract small bounce to achieve inequality?
constraints.Add(new LinearConstraint(retNorm.Select(x => (double)x).ToArray())
{
ShouldBe = ConstraintType.LesserThanOrEqualTo,
Value = eps - eps * 0.01
}); // Add and subtract small bounce to achieve inequality?
constraints.Add(new LinearConstraint(_stocks.Length)
{
VariablesAtIndices = Enumerable.Range(0, _stocks.Length).ToArray(),
ShouldBe = ConstraintType.GreaterThanOrEqualTo,
Value = 0
});
constraints.Add(new LinearConstraint(_stocks.Length)
{
VariablesAtIndices = Enumerable.Range(0, _stocks.Length).ToArray(),
ShouldBe = ConstraintType.LesserThanOrEqualTo,
Value = 1
});
var initialGuess = new double[_stocks.Length];
var f = new QuadraticObjectiveFunction(() => Variance(initialGuess, returns.ToMatrix()));
var solver = new GoldfarbIdnani(f, constraints);
solver.Minimize();
var weights = _x1;
var totalWeight = weights.Sum();
if (solver.Status == GoldfarbIdnaniStatus.Success)
{
weights = solver.Solution;
}
for (var i = 0; i < _stocks.Length; i++)
{
SetHoldings(_stocks[i], weights[i] / totalWeight);
}
});
}
// TODO: check volatilitymodel https://github.com/QuantConnect/Lean/blob/master/Common/Securities/RelativeStandardDeviationVolatilityModel.cs
public override void Initialize()
{
SetStartDate(2016, 1, 1);
SetEndDate(2016, 4, 1);
SetCash(3000);
SetBrokerageMessageHandler(new CustomBrokerageMessageHandler(this));
var allInputs = new List <double[]>();
var allOutputs = new List <int>();
var allWeights = new List <double>();
foreach (var symbol in Symbols)
{
AddForex(symbol, _dataResolution, Market.Oanda, false, 1m);
Securities[symbol].TransactionModel = new OandaTransactionModel();
//Securities[symbol].SlippageModel = new ConstantSlippageModel(0m);
SetBrokerageModel(BrokerageName.OandaBrokerage);
/************ TRAINING ************/
var trainingResolution = Resolution.Minute;
/*var slowT = HMA(symbol, 28, trainingResolution, Field.Close);
* var slowSlopeT = new InstantTrend(symbol, 5).Of(slowT);
* var returnT = LOGR(symbol, 3, trainingResolution, Field.Close);
* var returnSlopeT = LSMA(symbol, 5, trainingResolution).Of(returnT);*/
var consolidatorT = new QuoteBarConsolidator(TimeSpan.FromMinutes(15));
var stochT = new Stochastic(symbol, 14, 3, 3);
var stochTMA = new HullMovingAverage(symbol, 3).Of(stochT);
var emaT = new ExponentialMovingAverage(symbol, 40);
RegisterIndicator(symbol, stochT, consolidatorT);
RegisterIndicator(symbol, emaT, consolidatorT);
SubscriptionManager.AddConsolidator(symbol, consolidatorT);
var historyT = History <QuoteBar>(symbol, TimeSpan.FromDays(500), trainingResolution);
var quoteBars = new List <QuoteBar>();
var stochs = new List <double>();
var rollingStochs = new RollingWindow <double>(1000);
var stochsMA = new List <double>();
var emas = new List <double>();
var stochCount = new List <double>();
var stochAverage = new List <double>();
//consolidatorT.DataConsolidated += (sender, args) => quoteBars.Add(args);
stochTMA.Updated += (sender, args) =>
{
if (!stochTMA.IsReady || !emaT.IsReady)
{
return;
}
quoteBars.Add((QuoteBar)consolidatorT.Consolidated);
stochs.Add((double)stochT.Current.Value);
rollingStochs.Add((double)args.Value);
stochsMA.Add((double)args.Value);
emas.Add((double)emaT.Current.Value);
var filtered = rollingStochs.TakeWhile((s) => args.Value > 50 ? s > 50 : args.Value < 50 ? s < 50 : false);
stochCount.Add(filtered.Count());
try
{
stochAverage.Add(filtered.Average());
}
catch (Exception ex)
{
stochAverage.Add(0);
}
};
foreach (var bar in historyT)
{
consolidatorT.Update(bar);
}
Console.WriteLine("{0} {1} {2} {3} {4}", quoteBars.Count, stochs.Count, stochCount.Count, stochAverage.Count, emas.Count);
var inputs = new List <double[]>();
var outputs = new List <int>();
var weights = new List <double>();
for (var i = 1; i < quoteBars.Count; i++)
{
var longTarget = quoteBars[i].Close + (30m / 10000m);
var longStop = quoteBars[i].Close - (10m / 10000m);
var shortTarget = quoteBars[i].Close - (30m / 10000m);
var shortStop = quoteBars[i].Close + (10m / 10000m);
var longSetup = stochs[i] >= 35 && stochsMA[i] > stochsMA[i - 1] && (double)quoteBars[i].Close > emas[i];
var shortSetup = stochs[i] <= 65 && stochs[i] > 0 && stochsMA[i] < stochsMA[i - 1] && (double)quoteBars[i].Close < emas[i];
if (!longSetup && !shortSetup)
{
continue;
}
for (var j = i + 1; j < quoteBars.Count; j++)
{
var current = quoteBars[j];
if (current.High >= longTarget && current.Low > longStop && longSetup)
{
inputs.Add(new double[] { stochAverage[i], stochCount[i], (double)quoteBars[i].Close / emas[i] });
outputs.Add(1);
var profit = current.High - quoteBars[i].Close;
/*for (var k = j + 1; k < quoteBars.Count; k++)
* {
*
* }*/
weights.Add((double)(1m - (50m / 10000m) / profit));
//i = j;
break;
}
else if (current.Low <= shortTarget && current.High < shortStop && shortSetup)
{
inputs.Add(new double[] { stochAverage[i], stochCount[i], (double)quoteBars[i].Close / emas[i] });
outputs.Add(0);
var profit = quoteBars[i].Close - current.Low;
/*for (var k = j + 1; k < quoteBars.Count; k++)
* {
*
* }*/
weights.Add((double)(1m - (50m / 10000m) / profit));
//i = j;
break;
}
else if ((current.Low <= longStop && longSetup) || (current.High >= shortStop && shortSetup))
{
//inputs.Add(new double[] { stochAverage[i] / stochs[i], stochCount[i], stochAverage[i] });
//outputs.Add(2);
//i = j;
break;
}
/*else if (j - i > 4 * 8)
* {
* inputs.Add(new double[] { stochs[i], stochCount[i], stochAverage[i] });
* outputs.Add(0);
* //i = j;
* break;
* }*/
}
}
allInputs.AddRange(inputs);
allOutputs.AddRange(outputs);
allWeights.AddRange(weights);
for (var i = 0; i < inputs.Count; i++)
{
//Console.WriteLine("Input: " + inputs[i][0] + " " + inputs[i][1] + " " + inputs[i][2] + " Output: " + outputs[i]);
}
var none = outputs.Where((o) => o == 2).Count();
var sell = outputs.Where((o) => o == 0).Count();
var buy = outputs.Where((o) => o == 1).Count();
Console.WriteLine("Total: {0} None: {1} Short: {2} Long: {3}", outputs.Count, none, sell, buy);
/************ HMA ************/
/*var slow = HMA(symbol, 28, trainingResolution, Field.Close);
* var slowSlope = new InstantTrend(symbol, 5).Of(slow);
* var logReturns = LOGR(symbol, 3, trainingResolution, Field.Close);
* var returnSlope = LSMA(symbol, 5, trainingResolution).Of(logReturns);*/
var consolidator = new QuoteBarConsolidator(TimeSpan.FromMinutes(15));
var stoch = new Stochastic(symbol, 14, 3, 3);
var stochMA = new HullMovingAverage(symbol, 2).Of(stoch);
var ema = new ExponentialMovingAverage(symbol, 40);
var rolling = new RollingWindow <double>(1000);
RegisterIndicator(symbol, stoch, consolidator);
RegisterIndicator(symbol, ema, consolidator);
SubscriptionManager.AddConsolidator(symbol, consolidator);
_stoch[symbol] = stoch;
_ema[symbol] = ema;
stochMA.Updated += (sender, args) =>
{
rolling.Add((double)args.Value);
if (Securities[symbol].Price > 0)
{
//Plot("Plotter", "Price", Securities["EURUSD"].Price);
Plot("Indicator", "STO", rolling[0]);
}
};
var std = ATR(symbol, 100, MovingAverageType.DoubleExponential, _dataResolution);
var history = History <QuoteBar>(symbol, TimeSpan.FromDays(20), trainingResolution);
foreach (var bar in history)
{
//slow.Update(bar.EndTime, bar.Close);
//logReturns.Update(bar.EndTime, bar.Close);
std.Update(bar);
consolidator.Update(bar);
}
var signal = new SVMSignal(consolidator, stoch, stochMA, rolling, ema, Portfolio[symbol], this);
signal.TrainSVM(inputs, outputs, weights);
//signal.TrainNN(inputs, outputs, weights);
Securities[symbol].VolatilityModel = new AverageTrueRangeVolatilityModel(std);
_tradingAssets.Add(symbol,
new TradingAsset(Securities[symbol],
new OneShotTrigger(signal),
new ProfitTargetSignalExit(null, _targetProfitLoss),
_maximumTradeRisk,
_maximumTradeSize,
this
));
}
foreach (var symbol in Symbols)
{
//_tradingAssets[symbol].Retrain(allInputs, allOutputs, allWeights);
}
//AddData<DailyFx>("DFX", Resolution.Second, TimeZones.Utc);
Schedule.On(DateRules.Every(DayOfWeek.Monday, DayOfWeek.Tuesday, DayOfWeek.Wednesday, DayOfWeek.Thursday, DayOfWeek.Friday),
TimeRules.At(7, 0, TimeZones.London), () =>
{
var tradeableDay = TradingCalendar.GetTradingDay().BusinessDay;
if (tradeableDay)
{
foreach (var s in Symbols)
{
_tradingAssets[s].IsTradable = true;
}
}
});
Schedule.On(DateRules.Every(DayOfWeek.Monday, DayOfWeek.Tuesday, DayOfWeek.Wednesday, DayOfWeek.Thursday, DayOfWeek.Friday),
TimeRules.At(18, 0, TimeZones.London), () =>
{
foreach (var s in Symbols)
{
_tradingAssets[s].IsTradable = false;
}
});
Schedule.On(DateRules.Every(DayOfWeek.Friday),
TimeRules.BeforeMarketClose(Symbols.First(), 60), () =>
{
foreach (var s in Symbols)
{
_tradingAssets[s].Liquidate();
}
});
Chart plotter = new Chart("Plotter");
plotter.AddSeries(new Series("Price", SeriesType.Line, 0));
plotter.AddSeries(new Series("EMA", SeriesType.Line, 0));
plotter.AddSeries(new Series("Buy", SeriesType.Scatter, "", Color.Green, ScatterMarkerSymbol.Triangle));
plotter.AddSeries(new Series("Sell", SeriesType.Scatter, "", Color.Red, ScatterMarkerSymbol.TriangleDown));
plotter.AddSeries(new Series("Stopped", SeriesType.Scatter, "", Color.Yellow, ScatterMarkerSymbol.Diamond));
plotter.AddSeries(new Series("Prediction", SeriesType.Bar, 1));
plotter.AddSeries(new Series("Probability", SeriesType.Bar, 2));
AddChart(plotter);
Chart indicator = new Chart("Indicator");
indicator.AddSeries(new Series("STO", SeriesType.Line, 0));
AddChart(indicator);
Chart prediction = new Chart("Prediction");
prediction.AddSeries(new Series("Pred", SeriesType.Bar, 0));
AddChart(prediction);
Chart probability = new Chart("Probability");
probability.AddSeries(new Series("Prob", SeriesType.Bar, 0));
AddChart(probability);
}
public void OnData(Slice data)
{
if (!_rsiLag.IsReady || !fast.IsReady)
{
_window.Add(data["SPY"]);
return;
}
var currBar = _window[0]; // Current bar had index zero.
var pastBar = _window[1]; // Past bar has index one.
Log($"Price: {pastBar.Time} -> {pastBar.Close} ... {currBar.Time} -> {currBar.Close}");
var currRSI = _rsiLag[0]; // Current SMA had index zero
var pastRSI = _rsiLag[_rsiLag.Count - 1]; // Oldest SMA has index of window count minus 1
Log($"RSI: {pastRSI.Time} if (!_rsiLag.IsReady || !fast.IsReady )-> {pastRSI.Value} ... {currRSI.Time} -> {currRSI.Value}");
if (!Portfolio.Invested && currRSI >= 29 && pastRSI < 29 && IsMarketOpen(_optionSymbol))
{
var startBreakOut = currRSI.Time;
if (currBar.Value > pastBar.Value)
{
if (data.OptionChains.TryGetValue(_optionSymbol, out chain))
{
var underlying = chain.Underlying;
var closeChain = chain.Underlying.Price;
//Console.WriteLine(string.Join(" ", close));
var contracts = (
from OptionContract in chain.OrderBy(x => x.Expiry)
.ThenBy(x => x.Strike)
// find OTM call strike closest to expiry
where OptionContract.Right == OptionRight.Call
where OptionContract.Strike > closeChain
where DateTime.Compare(OptionContract.Expiry, startBreakOut) > 0
select OptionContract
).FirstOrDefault();
//Console.WriteLine("Elements of Contracts:");
//Console.WriteLine(string.Join(" ", contracts));
var consolidator = new TradeBarConsolidator(TimeSpan.FromMinutes(5));
consolidator.DataConsolidated += OnDataConsolidated;
SubscriptionManager.AddConsolidator(contracts.Symbol, consolidator);
Log("Added new consolidator for " + contracts.Symbol.Value);
Decimal close = contracts.LastPrice;
Decimal stopPrice = contracts.BidPrice * 0.99m;
Decimal askPrice = contracts.AskPrice;
if (contracts != null)
{
if (!_optionContracts.Contains(contracts.Symbol))
{
_optionContracts.Add(contracts.Symbol);
//Console.WriteLine("Elements of _optionContracts:");
foreach (var valu in _optionContracts)
{
//Console.WriteLine(valu);
}
var quantity = (int)Math.Floor(Portfolio.Cash / close);
//SetHoldings(contracts.Symbol, quantity);
currentOrder = Buy(contracts.Symbol, 200);
// profitTarget = LimitOrder(contracts.Symbol, -1, bidPrice * (1.2m));
var stopMarketTicket = LimitOrder(contracts.Symbol, -40, close * 1.20m);
var stopMarketTicket2 = LimitOrder(contracts.Symbol, -40, close * 1.40m);
var stopMarketTicket3 = LimitOrder(contracts.Symbol, -120, close * 1.60m);
//stopLoss = StopMarketOrder(contracts.Symbol, -100, close * 0.98m);
// var limitPrice = close * 1.01; // Sell equal or better than 1% > close.
}
}
}
else
{
Liquidate();
}
previous = data.Time;
}
foreach (var kpv in data.Bars)
{
Log($"---> OnData: {Time}, {kpv.Key.Value}, {kpv.Value.Close:0:00}");
}
}
}
// TODO: check volatilitymodel https://github.com/QuantConnect/Lean/blob/master/Common/Securities/RelativeStandardDeviationVolatilityModel.cs
public override void Initialize()
{
SetStartDate(2016, 1, 1);
SetEndDate(2017, 1, 1);
SetCash(3000);
SetBrokerageMessageHandler(new CustomBrokerageMessageHandler(this));
foreach (var symbol in Symbols)
{
AddForex(symbol, _dataResolution, Market.Oanda, false, 1m);
Securities[symbol].TransactionModel = new OandaTransactionModel();
//Securities[symbol].SlippageModel = new ConstantSlippageModel(0m);
SetBrokerageModel(BrokerageName.OandaBrokerage);
var consolidator = new QuoteBarConsolidator(TimeSpan.FromMinutes(20));
var stoch = new Stochastic(symbol, 10, 3, 3);
var stochMA = new ExponentialMovingAverage(symbol, 25).Of(stoch);
var stochEmaLSMA = new LeastSquaresMovingAverage(symbol, 5).Of(stochMA);
var ema = new ExponentialMovingAverage(symbol, 40);
var emaMA = new LeastSquaresMovingAverage(symbol, 5).Of(ema);
var rollingStochMA = HistoryTracker.Track(stochMA);
var rollingEmaSlope = HistoryTracker.Track(emaMA.Slope);
var rollingStochEmaSlope = HistoryTracker.Track(stochEmaLSMA.Slope);
var shortTermMA = EMA(symbol, 30, Resolution.Minute, Field.Close);
RegisterIndicator(symbol, stoch, consolidator);
RegisterIndicator(symbol, ema, consolidator);
SubscriptionManager.AddConsolidator(symbol, consolidator);
_stoch[symbol] = stoch;
_ema[symbol] = ema;
var consolidatorDaily = new QuoteBarConsolidator(TimeSpan.FromHours(1));
var dailyMA = new HullMovingAverage(symbol, 7);
var dailyEmaLSMA = new LeastSquaresMovingAverage(symbol, 3).Of(dailyMA);
var rollingDailyEmaSlope = HistoryTracker.Track(dailyEmaLSMA.Slope);
RegisterIndicator(symbol, dailyMA, consolidatorDaily);
SubscriptionManager.AddConsolidator(symbol, consolidatorDaily);
stochMA.Updated += (sender, args) =>
{
if (Securities[symbol].Price > 0)
{
Plot("Indicator", "STO", rollingStochMA[0]);
}
};
stochEmaLSMA.Updated += (sender, args) =>
{
if (Securities[symbol].Price > 0)
{
Plot("IndicatorTrend", "STO", stochEmaLSMA.Slope);
}
};
/*emaMA.Updated += (sender, args) =>
* {
* if (Securities[symbol].Price > 0)
* {
* Plot("Trend", "LSMA", emaMA.Slope);
* }
* };*/
dailyEmaLSMA.Updated += (sender, args) =>
{
if (Securities[symbol].Price > 0)
{
Plot("Trend", "LSMA", dailyEmaLSMA.Slope);
Plot("Trend", "EMA", dailyMA);
}
};
var std = ATR(symbol, 100, MovingAverageType.DoubleExponential, _dataResolution);
var history = History <QuoteBar>(symbol, TimeSpan.FromDays(40), _dataResolution);
foreach (var bar in history)
{
std.Update(bar);
consolidator.Update(bar);
shortTermMA.Update(bar.EndTime, bar.Close);
consolidatorDaily.Update(bar);
}
var signal = new SVMBaselineSignalWIP(consolidator, stoch, stochMA, rollingStochMA, stochEmaLSMA, rollingStochEmaSlope, ema, emaMA,
rollingEmaSlope, shortTermMA, dailyEmaLSMA, rollingDailyEmaSlope, Portfolio[symbol], Securities[symbol], this);
Securities[symbol].VolatilityModel = new AverageTrueRangeVolatilityModel(std);
_tradingAssets.Add(symbol,
new TradingAsset(Securities[symbol],
new OneShotTrigger(signal),
new ProfitTargetSignalExit(null, _targetProfitLoss),
_maximumTradeRisk,
_maximumTradeSize,
this
));
}
//AddData<DailyFx>("DFX", Resolution.Second, TimeZones.Utc);
Schedule.On(DateRules.Every(DayOfWeek.Monday, DayOfWeek.Tuesday, DayOfWeek.Wednesday, DayOfWeek.Thursday),
TimeRules.At(7, 0, TimeZones.London), () =>
{
var tradeableDay = TradingCalendar.GetTradingDay().BusinessDay;
if (tradeableDay)
{
foreach (var s in Symbols)
{
_tradingAssets[s].IsTradable = true;
}
}
});
Schedule.On(DateRules.Every(DayOfWeek.Monday, DayOfWeek.Tuesday, DayOfWeek.Wednesday, DayOfWeek.Thursday, DayOfWeek.Friday),
TimeRules.At(20, 0, TimeZones.London), () =>
{
foreach (var s in Symbols)
{
_tradingAssets[s].IsTradable = false;
}
});
Schedule.On(DateRules.Every(DayOfWeek.Friday),
TimeRules.BeforeMarketClose(Symbols.First(), 60), () =>
{
foreach (var s in Symbols)
{
_tradingAssets[s].Liquidate();
}
});
Chart plotter = new Chart("Plotter");
plotter.AddSeries(new Series("Price", SeriesType.Line, 0));
plotter.AddSeries(new Series("EMA", SeriesType.Line, 0));
plotter.AddSeries(new Series("Buy", SeriesType.Scatter, "", Color.Green, ScatterMarkerSymbol.Triangle));
plotter.AddSeries(new Series("Sell", SeriesType.Scatter, "", Color.Red, ScatterMarkerSymbol.TriangleDown));
plotter.AddSeries(new Series("Stopped", SeriesType.Scatter, "", Color.Yellow, ScatterMarkerSymbol.Diamond));
plotter.AddSeries(new Series("Prediction", SeriesType.Bar, 1));
plotter.AddSeries(new Series("Probability", SeriesType.Bar, 2));
AddChart(plotter);
Chart indicator = new Chart("Indicator");
indicator.AddSeries(new Series("STO", SeriesType.Line, 0));
AddChart(indicator);
Chart indicatorTrend = new Chart("IndicatorTrend");
indicatorTrend.AddSeries(new Series("STO", SeriesType.Line, 0));
AddChart(indicatorTrend);
Chart trend = new Chart("Trend");
trend.AddSeries(new Series("LSMA", SeriesType.Line, 0));
trend.AddSeries(new Series("EMA", SeriesType.Line, 1));
AddChart(trend);
Chart prediction = new Chart("Prediction");
prediction.AddSeries(new Series("Pred", SeriesType.Bar, 0));
AddChart(prediction);
Chart probability = new Chart("Probability");
probability.AddSeries(new Series("Prob", SeriesType.Bar, 0));
AddChart(probability);
}
public override void Initialize()
{
SetStartDate(2016, 1, 1);
SetEndDate(2017, 1, 1);
SetCash(3000);
SetBrokerageMessageHandler(new CustomBrokerageMessageHandler(this));
foreach (var symbol in Symbols)
{
AddForex(symbol, _dataResolution, Market.Oanda, false, 1m);
Securities[symbol].TransactionModel = new OandaTransactionModel();
//Securities[symbol].SlippageModel = new ConstantSlippageModel(0m);
SetBrokerageModel(BrokerageName.OandaBrokerage);
/******** LONG TERM TREND ********/
var dailyConsolidator = new QuoteBarConsolidator(TimeSpan.FromDays(1));
var alma = new ExponentialMovingAverage(symbol, 10);
RegisterIndicator(symbol, alma, dailyConsolidator);
SubscriptionManager.AddConsolidator(symbol, dailyConsolidator);
/******** SHORT TERM TRADING ********/
var consolidator = new QuoteBarConsolidator(TimeSpan.FromMinutes(15));
var schaffTrendCycle = new SchaffTrendCycle(symbol);
var atr = new AverageTrueRange(symbol, 10);
var adx = new AverageDirectionalIndex(symbol, 10);
RegisterIndicator(symbol, schaffTrendCycle, consolidator);
RegisterIndicator(symbol, atr, consolidator);
RegisterIndicator(symbol, adx, consolidator);
/****** ALMA Fibonacci ******/
var alma5 = new ArnaudLegouxMovingAverage(symbol, 5);
var alma8 = new ArnaudLegouxMovingAverage(symbol, 8);
var alma13 = new ArnaudLegouxMovingAverage(symbol, 13);
var alma21 = new ArnaudLegouxMovingAverage(symbol, 21);
var alma34 = new ArnaudLegouxMovingAverage(symbol, 34);
var alma55 = new ArnaudLegouxMovingAverage(symbol, 55);
var alma89 = new ArnaudLegouxMovingAverage(symbol, 89);
var alma144 = new ArnaudLegouxMovingAverage(symbol, 144);
RegisterIndicator(symbol, alma5, consolidator);
RegisterIndicator(symbol, alma8, consolidator);
RegisterIndicator(symbol, alma13, consolidator);
RegisterIndicator(symbol, alma21, consolidator);
RegisterIndicator(symbol, alma34, consolidator);
RegisterIndicator(symbol, alma55, consolidator);
RegisterIndicator(symbol, alma89, consolidator);
RegisterIndicator(symbol, alma144, consolidator);
SubscriptionManager.AddConsolidator(symbol, consolidator);
var signal = new SVMBaselineSignal(
dailyConsolidator, alma,
consolidator, alma5, alma8, alma13, alma21, alma34, alma55, alma89, alma144, schaffTrendCycle, atr, adx,
Portfolio[symbol], Securities[symbol], this
);
var std = ATR(symbol, 100, MovingAverageType.DoubleExponential, _dataResolution);
/******** HISTORY ********/
var history = History <QuoteBar>(symbol, TimeSpan.FromDays(100), _dataResolution);
foreach (var bar in history)
{
std.Update(bar);
consolidator.Update(bar);
dailyConsolidator.Update(bar);
}
if (_store)
{
var header = new string[] { "Time", "ALMA_5", "ALMA_8", "ALMA_13", "ALMA_21", "ALMA_34", "ALMA_55", "ALMA_89", "ALMA_144" };
Storage.CreateFile($"C:\\Users\\M\\Desktop\\{symbol}_ALMA.csv", header);
consolidator.DataConsolidated += (sender, args) =>
{
var line = new object[] { Storage.ToUTCTimestamp(args.Time), alma5.Current.Value, alma8.Current.Value, alma13.Current.Value,
alma21.Current.Value, alma34.Current.Value, alma55.Current.Value, alma89.Current.Value, alma144.Current.Value };
Storage.AppendToFile($"C:\\Users\\M\\Desktop\\{symbol}_ALMA.csv", line);
};
}
Securities[symbol].VolatilityModel = new AverageTrueRangeVolatilityModel(std);
_tradingAssets.Add(symbol,
new TradingAsset(Securities[symbol],
new OneShotTrigger(signal),
new ProfitTargetSignalExit(null, _targetProfitLoss),
_maximumTradeRisk,
_maximumTradeSize,
this
));
//_tradingAssets[symbol].IsTradable = true;
var h = new object[] { "Time", "Signal", "Price" };
Storage.CreateFile($"C:\\Users\\M\\Desktop\\{symbol}_ALMA_Signal.csv", h);
}
Schedule.On(DateRules.Every(DayOfWeek.Monday, DayOfWeek.Tuesday, DayOfWeek.Wednesday, DayOfWeek.Thursday, DayOfWeek.Friday),
TimeRules.At(7, 0, TimeZones.London), () =>
{
var tradeableDay = TradingCalendar.GetTradingDay().BusinessDay;
if (tradeableDay)
{
foreach (var s in Symbols)
{
_tradingAssets[s].IsTradable = true;
}
}
});
Schedule.On(DateRules.Every(DayOfWeek.Monday, DayOfWeek.Tuesday, DayOfWeek.Wednesday, DayOfWeek.Thursday, DayOfWeek.Friday),
TimeRules.At(20, 0, TimeZones.London), () =>
{
foreach (var s in Symbols)
{
//_tradingAssets[s].IsTradable = false;
}
});
Schedule.On(DateRules.Every(DayOfWeek.Friday),
TimeRules.BeforeMarketClose(Symbols.First(), 240), () =>
{
foreach (var s in Symbols)
{
//_tradingAssets[s].IsTradable = false;
}
});
Schedule.On(DateRules.Every(DayOfWeek.Friday),
TimeRules.BeforeMarketClose(Symbols.First(), 180), () =>
{
foreach (var s in Symbols)
{
//_tradingAssets[s].Liquidate();
//_tradingAssets[s].IsTradable = false;
}
});
/******** CHARTING ********/
/*Chart price = new Chart("Daily Price");
* price.AddSeries(new Series("Price", SeriesType.Candle, 0));
* price.AddSeries(new Series("MA", SeriesType.Line, 0));
* price.AddSeries(new Series("Slope", SeriesType.Line, 1));
* price.AddSeries(new Series("STC", SeriesType.Line, 2));
* AddChart(price);
*
* Chart ma = new Chart("MA");
* ma.AddSeries(new Series("HMA", SeriesType.Line, 0));
* ma.AddSeries(new Series("FAMA", SeriesType.Line, 1));
* AddChart(ma);
*
* Chart lsma = new Chart("LSMA");
* lsma.AddSeries(new Series("Slope", SeriesType.Line, 0));
* AddChart(lsma);*/
Chart plotter = new Chart("Plotter");
plotter.AddSeries(new Series("Close", SeriesType.Line, 0));
plotter.AddSeries(new Series("EMA", SeriesType.Line, 1));
plotter.AddSeries(new Series("Buy", SeriesType.Scatter, "", Color.Green, ScatterMarkerSymbol.Triangle));
plotter.AddSeries(new Series("Sell", SeriesType.Scatter, "", Color.Red, ScatterMarkerSymbol.TriangleDown));
//plotter.AddSeries(new Series("Stopped", SeriesType.Scatter, "", Color.Yellow, ScatterMarkerSymbol.Diamond));
plotter.AddSeries(new Series("Diff", SeriesType.Bar, 2));
plotter.AddSeries(new Series("Slope", SeriesType.Line, 3));
plotter.AddSeries(new Series("STC", SeriesType.Line, 4));
plotter.AddSeries(new Series("STOCH", SeriesType.Line, 5));
plotter.AddSeries(new Series("Prediction", SeriesType.Bar, 6));
plotter.AddSeries(new Series("Signal", SeriesType.Bar, 7));
AddChart(plotter);
}
