private static QCAlgorithm GetAlgorithm(out Security security, decimal fee, SecurityType securityType = SecurityType.Crypto)
{
SymbolCache.Clear();
// Initialize algorithm
var algo = new QCAlgorithm();
algo.SubscriptionManager.SetDataManager(new DataManagerStub(algo));
algo.SetCash(100000);
algo.SetBrokerageModel(BrokerageName.GDAX, AccountType.Cash);
algo.Transactions.SetOrderProcessor(new FakeOrderProcessor());
algo.SetFinishedWarmingUp();
var cashSymbol = string.Empty;
if (securityType == SecurityType.Crypto)
{
cashSymbol = "BTC";
security = algo.AddSecurity(securityType, "BTCUSD");
}
else if (securityType == SecurityType.Forex)
{
cashSymbol = "EUR";
security = algo.AddSecurity(securityType, "EURUSD");
// set BPM to cash, since it's not the default
security.BuyingPowerModel = new CashBuyingPowerModel();
}
else
{
throw new NotImplementedException("Unexpected security type");
}
security.FeeModel = new ConstantFeeModel(fee);
//Set price to $25
Update(algo.Portfolio.CashBook, security, 25, cashSymbol);
return(algo);
}
public void DefaultDataFeeds_AreAdded_Successfully()
{
var algo = new QCAlgorithm();
// forex
var forex = algo.AddSecurity(SecurityType.Forex, "eurusd");
Assert.IsTrue(forex.Subscriptions.Count() == 1);
Assert.IsTrue(GetMatchingSubscription(forex, typeof(QuoteBar)) != null);
// equity
var equity = algo.AddSecurity(SecurityType.Equity, "goog");
Assert.IsTrue(equity.Subscriptions.Count() == 1);
Assert.IsTrue(GetMatchingSubscription(equity, typeof(TradeBar)) != null);
// option
var option = algo.AddSecurity(SecurityType.Option, "goog");
Assert.IsTrue(option.Subscriptions.Count() == 1);
Assert.IsTrue(GetMatchingSubscription(option, typeof(ZipEntryName)) != null);
// cfd
var cfd = algo.AddSecurity(SecurityType.Cfd, "abc");
Assert.IsTrue(cfd.Subscriptions.Count() == 1);
Assert.IsTrue(GetMatchingSubscription(cfd, typeof(QuoteBar)) != null);
// future
var future = algo.AddSecurity(SecurityType.Future, "ES");
Assert.IsTrue(future.Subscriptions.Count() == 1);
Assert.IsTrue(future.Subscriptions.FirstOrDefault(x => typeof(ZipEntryName).IsAssignableFrom(x.Type)) != null);
}
public void CreatesSubscriptions(SubscriptionRequest subscriptionRequest, bool liveMode, bool expectNewSubscription)
{
_algorithm.SetLiveMode(liveMode);
var added = false;
var start = DateTime.UtcNow;
var tokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(15));
foreach (var timeSlice in _synchronizer.StreamData(tokenSource.Token))
{
if (!added)
{
added = true;
_algorithm.AddSecurity(subscriptionRequest.Security.Symbol, subscriptionRequest.Configuration.Resolution);
}
else if (!timeSlice.IsTimePulse)
{
Assert.AreEqual(
expectNewSubscription,
_algorithm.SubscriptionManager.SubscriptionDataConfigService
.GetSubscriptionDataConfigs(Symbols.BTCUSD, includeInternalConfigs: true).Any(config => config.IsInternalFeed)
);
if (expectNewSubscription)
{
// let's wait for a data point
if (timeSlice.DataPointCount > 0)
{
break;
}
if (DateTime.UtcNow - start > TimeSpan.FromSeconds(5))
{
Assert.Fail("Timeout waiting for data point");
}
}
else
{
break;
}
}
// give time for the base exchange to pick up the data point that will trigger the universe selection
// so next step we assert the internal config is there
Thread.Sleep(100);
_algorithm.OnEndOfTimeStep();
}
Assert.IsFalse(tokenSource.IsCancellationRequested);
}
public void DefaultDataFeeds_AreAdded_Successfully()
{
var algo = new QCAlgorithm();
algo.SubscriptionManager.SetDataManager(new DataManagerStub(algo));
// forex
var forex = algo.AddSecurity(SecurityType.Forex, "eurusd");
Assert.IsTrue(forex.Subscriptions.Count() == 1);
Assert.IsTrue(GetMatchingSubscription(forex, typeof(QuoteBar)) != null);
// equity high resolution
var equityMinute = algo.AddSecurity(SecurityType.Equity, "goog");
Assert.IsTrue(equityMinute.Subscriptions.Count() == 2);
Assert.IsTrue(GetMatchingSubscription(equityMinute, typeof(TradeBar)) != null);
Assert.IsTrue(GetMatchingSubscription(equityMinute, typeof(QuoteBar)) != null);
// equity low resolution
var equityDaily = algo.AddSecurity(SecurityType.Equity, "goog", Resolution.Daily);
Assert.IsTrue(equityDaily.Subscriptions.Count() == 1);
Assert.IsTrue(GetMatchingSubscription(equityDaily, typeof(TradeBar)) != null);
// option
var option = algo.AddSecurity(SecurityType.Option, "goog");
Assert.IsTrue(option.Subscriptions.Count() == 1);
Assert.IsTrue(GetMatchingSubscription(option, typeof(ZipEntryName)) != null);
// cfd
var cfd = algo.AddSecurity(SecurityType.Cfd, "abc");
Assert.IsTrue(cfd.Subscriptions.Count() == 1);
Assert.IsTrue(GetMatchingSubscription(cfd, typeof(QuoteBar)) != null);
// future
var future = algo.AddSecurity(SecurityType.Future, "ES");
Assert.IsTrue(future.Subscriptions.Count() == 1);
Assert.IsTrue(future.Subscriptions.FirstOrDefault(x => typeof(ZipEntryName).IsAssignableFrom(x.Type)) != null);
// Crypto high resolution
var cryptoMinute = algo.AddSecurity(SecurityType.Equity, "goog");
Assert.IsTrue(cryptoMinute.Subscriptions.Count() == 2);
Assert.IsTrue(GetMatchingSubscription(cryptoMinute, typeof(TradeBar)) != null);
Assert.IsTrue(GetMatchingSubscription(cryptoMinute, typeof(QuoteBar)) != null);
// Crypto low resolution
var cryptoHourly = algo.AddSecurity(SecurityType.Crypto, "btcusd", Resolution.Hour);
Assert.IsTrue(cryptoHourly.Subscriptions.Count() == 2);
Assert.IsTrue(GetMatchingSubscription(cryptoHourly, typeof(TradeBar)) != null);
Assert.IsTrue(GetMatchingSubscription(cryptoHourly, typeof(QuoteBar)) != null);
}
public void AddOrderWaitsForOrderToBeProcessed()
{
var algorithm = new QCAlgorithm();
algorithm.SubscriptionManager.SetDataManager(new DataManagerStub(algorithm));
var security = algorithm.AddSecurity(SecurityType.Equity, "SPY");
security.SetMarketPrice(new Tick {
Value = 150
});
algorithm.SetFinishedWarmingUp();
var transactionHandler = new BrokerageTransactionHandler();
transactionHandler.Initialize(algorithm, new BacktestingBrokerage(algorithm), new BacktestingResultHandler());
algorithm.Transactions.SetOrderProcessor(transactionHandler);
Task.Run(() => transactionHandler.Run());
var ticket = algorithm.LimitOrder(security.Symbol, 1, 100);
var openOrders = algorithm.Transactions.GetOpenOrders();
transactionHandler.Exit();
Assert.AreEqual(1, openOrders.Count);
Assert.IsTrue(ticket.HasOrder);
}
public void SetHoldings_Short_RoundOff()
{
var algo = new QCAlgorithm();
algo.AddSecurity(SecurityType.Forex, "EURUSD");
algo.SetCash(100000);
algo.SetBrokerageModel(BrokerageName.FxcmBrokerage);
algo.Securities[Symbols.EURUSD].TransactionModel = new ConstantFeeTransactionModel(0);
Security eurusd = algo.Securities[Symbols.EURUSD];
// Set Price to $26
Update(eurusd, 26);
// So -100000/26 = -3846, After Rounding off becomes -3000
var actual = algo.CalculateOrderQuantity(Symbols.EURUSD, -1m);
Assert.AreEqual(-3000m, actual);
var btcusd = algo.AddCrypto("BTCUSD", market: Market.GDAX);
btcusd.TransactionModel = new ConstantFeeTransactionModel(0);
// Set Price to $26
Update(btcusd, 26);
// So -100000/26 = 3846.153846153846, After Rounding off becomes -3846.15384615, since lot size is 0.00000001
actual = algo.CalculateOrderQuantity(Symbols.BTCUSD, -1m);
Assert.AreEqual(-3846.15384615m, actual);
}
/// <summary>
/// Will handle adding and removing securities from the algorithm based on the current portfolio of the different alphas
/// </summary>
private void ProcessPortfolioState(QCAlgorithm algorithm, AlphaStreamsPortfolioState portfolioState)
{
if (portfolioState == null)
{
return;
}
var alphaId = portfolioState.Symbol;
if (!_symbolsPerAlpha.TryGetValue(alphaId, out var currentSymbols))
{
_symbolsPerAlpha[alphaId] = currentSymbols = new HashSet <Symbol>();
}
var newSymbols = new HashSet <Symbol>(currentSymbols.Count);
foreach (var symbol in portfolioState.PositionGroups?.SelectMany(positionGroup => positionGroup.Positions).Select(state => state.Symbol) ?? Enumerable.Empty <Symbol>())
{
// only add it if it's not used by any alpha (already added check)
if (newSymbols.Add(symbol) && !UsedBySomeAlpha(symbol))
{
algorithm.AddSecurity(symbol,
resolution: algorithm.UniverseSettings.Resolution,
extendedMarketHours: algorithm.UniverseSettings.ExtendedMarketHours);
}
}
_symbolsPerAlpha[alphaId] = newSymbols;
foreach (var symbol in currentSymbols.Where(symbol => !UsedBySomeAlpha(symbol)))
{
algorithm.RemoveSecurity(symbol);
}
}
private void AddSecurities(QCAlgorithm algorithm, AlphaStreamsPortfolioState portfolioState)
{
foreach (var symbol in portfolioState.PositionGroups?.SelectMany(positionGroup => positionGroup.Positions)
.Select(state => state.Symbol) ?? Enumerable.Empty <Symbol>())
{
_algorithm.AddSecurity(symbol);
}
}
public void Initialize()
{
_algorithm = new QCAlgorithm();
_algorithm.SetBrokerageModel(BrokerageName.FxcmBrokerage);
_algorithm.SetCash(100000);
_algorithm.AddSecurity(SecurityType.Forex, Ticker);
_algorithm.SetFinishedWarmingUp();
}
public void AddSecurityWithSymbol(Symbol symbol, Type type = null)
{
var security = type != null?_algo.AddData(type, symbol.Underlying) : _algo.AddSecurity(symbol);
Assert.AreEqual(security.Symbol, symbol);
Assert.IsTrue(_algo.Securities.ContainsKey(symbol));
Assert.DoesNotThrow(() =>
{
switch (symbol.SecurityType)
{
case SecurityType.Equity:
var equity = (Equity)security;
break;
case SecurityType.Option:
var option = (Option)security;
break;
case SecurityType.Forex:
var forex = (Forex)security;
break;
case SecurityType.Future:
var future = (Future)security;
break;
case SecurityType.Cfd:
var cfd = (Cfd)security;
break;
case SecurityType.Index:
var index = (Index)security;
break;
case SecurityType.IndexOption:
var indexOption = (IndexOption)security;
break;
case SecurityType.Crypto:
var crypto = (Crypto)security;
break;
case SecurityType.Base:
break;
default:
throw new Exception($"Invalid Security Type: {symbol.SecurityType}");
}
});
if (symbol.IsCanonical())
{
Assert.DoesNotThrow(() => _algo.OnEndOfTimeStep());
Assert.IsTrue(_algo.UniverseManager.ContainsKey(symbol));
}
}
public void AddSecurityWithSymbol(Symbol symbol)
{
var security = _algo.AddSecurity(symbol);
Assert.AreEqual(security.Symbol, symbol);
Assert.IsTrue(_algo.Securities.ContainsKey(symbol));
Assert.DoesNotThrow(() =>
{
switch (symbol.SecurityType)
{
case SecurityType.Equity:
var equity = (Equity)security;
break;
case SecurityType.Option:
var option = (Option)security;
break;
case SecurityType.Forex:
var forex = (Forex)security;
break;
case SecurityType.Future:
var future = (Future)security;
break;
case SecurityType.Cfd:
var cfd = (Cfd)security;
break;
case SecurityType.Index:
var index = (Index)security;
break;
case SecurityType.Crypto:
var crypto = (Crypto)security;
break;
case SecurityType.Base:
break;
default:
throw new Exception($"Invalid Security Type: {symbol.SecurityType}");
}
});
if (symbol.IsCanonical())
{
// Throws NotImplementedException because we are using NullDataFeed
// We need to call this to add the pending universe additions
Assert.Throws <NotImplementedException>(() => _algo.OnEndOfTimeStep());
Assert.IsTrue(_algo.UniverseManager.ContainsKey(symbol));
}
}
//[Test]
//public void SetHoldings_LongToLonger_PriceRise()
//{
// var algo = GetAlgorithm();
// //Set price to $25
// algo.Securities.Update(DateTime.Now, Update("MSFT", 25));
// //Half cash spent on 2000 MSFT shares.
// algo.Portfolio.SetCash(50000);
// algo.Portfolio["MSFT"].SetHoldings(25, 2000);
// //Price rises to $50.
// algo.Securities.Update(DateTime.Now, Update("MSFT", 50));
// //Now: 2000 * 50 = $100k Holdings, $50k Cash: $150k. MSFT is already 66% of holdings.
// //Calculate the order for 75% MSFT:
// var actual = algo.CalculateOrderQuantity("MSFT", 0.75m);
// //Need to buy to make position $112.5k == $12.5k / 50 = 250 shares
// Assert.AreEqual(250, actual);
//}
//[Test]
//public void SetHoldings_LongerToLong_PriceRise()
//{
// var algo = GetAlgorithm();
// //Set price to $25
// algo.Securities.Update(DateTime.Now, Update("MSFT", 25));
// //75% cash spent on 3000 MSFT shares.
// algo.Portfolio.SetCash(25000);
// algo.Portfolio["MSFT"].SetHoldings(25, 3000);
// //Price rises to $50.
// algo.Securities.Update(DateTime.Now, Update("MSFT", 50));
// //Now: 3000 * 50 = $150k Holdings, $25k Cash: $175k. MSFT is 86% of holdings.
// //Calculate the order for 50% MSFT:
// var actual = algo.CalculateOrderQuantity("MSFT", 0.5m);
// //Need to sell to 50% = 87.5k target from $150k = 62.5 / $50-share = 1250
// Assert.AreEqual(-1250, actual);
//}
//[Test]
//public void SetHoldings_LongToShort_PriceRise()
//{
// var algo = GetAlgorithm();
// //Set price to $25
// algo.Securities.Update(DateTime.Now, Update("MSFT", 25));
// //Half cash spent on 2000 MSFT shares.
// algo.Portfolio.SetCash(50000);
// algo.Portfolio["MSFT"].SetHoldings(25, 2000);
// //Price rises to $50.
// algo.Securities.Update(DateTime.Now, Update("MSFT", 50));
// //Now: 2000 * 50 = $100k Holdings, $50k Cash: $150k. MSFT is 66% of holdings.
// var actual = algo.CalculateOrderQuantity("MSFT", -0.5m);
// // Need to hold -75k from $100k = delta: $175k / $50-share = -3500 shares.
// Assert.AreEqual(-3500, actual);
//}
//[Test]
//public void SetHoldings_ShortToShorter_PriceRise()
//{
// var algo = GetAlgorithm();
// //Set price to $25
// algo.Securities.Update(DateTime.Now, Update("MSFT", 25));
// //Half cash spent on -2000 MSFT shares.
// algo.Portfolio.SetCash(50000);
// algo.Portfolio["MSFT"].SetHoldings(25, -2000);
// //Price rises to $50.
// algo.Securities.Update(DateTime.Now, Update("MSFT", 50));
// //Now: 2000 * 50 = $0k Net Holdings, $50k Cash: $50k. MSFT is 0% of holdings.
// var actual = algo.CalculateOrderQuantity("MSFT", -0.75m);
// //Want to hold -75% of MSFT: 50k total, -37.5k / $50-share = -750 TOTAL.
// // Currently -2000, so net order +1250.
// Assert.AreEqual(1250, actual);
//}
//[Test]
//public void SetHoldings_ShortToLong_PriceRise()
//{
// var algo = GetAlgorithm();
// //Set price to $25
// algo.Securities.Update(DateTime.Now, Update("MSFT", 25));
// //Half cash spent on -2000 MSFT shares.
// algo.Portfolio.SetCash(50000);
// algo.Portfolio["MSFT"].SetHoldings(25, -2000);
// //Price rises to $50.
// algo.Securities.Update(DateTime.Now, Update("MSFT", 50));
// //Now: 2000 * 50 = $0k Net Holdings, $50k Cash: $50k. MSFT is 0% of holdings.
// var actual = algo.CalculateOrderQuantity("MSFT", 0.5m);
// //We want to be 50% long, this is currently +2000 holdings + 50% 50k = $25k/ $50-share=500
// Assert.AreEqual(2500, actual);
//}
private QCAlgorithm GetAlgorithm(decimal fee = 0)
{
//Initialize algorithm
var algo = new QCAlgorithm();
algo.AddSecurity(SecurityType.Equity, "MSFT");
algo.SetCash(100000);
algo.Securities["MSFT"].TransactionModel = new ConstantFeeTransactionModel(fee);
return(algo);
}
private static QCAlgorithm GetAlgorithm(out Security security, decimal fee)
{
// Initialize algorithm
var algo = new QCAlgorithm();
algo.SetCash(100000);
algo.SetBrokerageModel(BrokerageName.GDAX, AccountType.Cash);
security = algo.AddSecurity(SecurityType.Crypto, "BTCUSD");
security.TransactionModel = new ConstantFeeTransactionModel(fee);
return(algo);
}
public void ZeroTargetWithZeroHoldingsIsNotAnError()
{
var algorithm = new QCAlgorithm();
var security = algorithm.AddSecurity(SecurityType.Equity, "SPY");
var model = new SecurityMarginModel();
var result = model.GetMaximumOrderQuantityForTargetValue(algorithm.Portfolio, security, 0);
Assert.AreEqual(0, result.Quantity);
Assert.AreEqual(string.Empty, result.Reason);
Assert.AreEqual(false, result.IsError);
}
private QCAlgorithm GetAlgorithm(out Security msft, decimal leverage, decimal fee)
{
//Initialize algorithm
var algo = new QCAlgorithm();
algo.AddSecurity(SecurityType.Equity, "MSFT");
algo.SetCash(100000);
algo.Securities[Symbols.MSFT].TransactionModel = new ConstantFeeTransactionModel(fee);
msft = algo.Securities[Symbols.MSFT];
msft.SetLeverage(leverage);
return(algo);
}
private QCAlgorithm GetAlgorithm(out Security msft, decimal initialMarginRequirement, decimal maintenanceMarginRequirement, decimal fee)
{
//Initialize algorithm
var algo = new QCAlgorithm();
algo.AddSecurity(SecurityType.Equity, "MSFT");
algo.SetCash(100000);
algo.Securities[Symbols.MSFT].TransactionModel = new ConstantFeeTransactionModel(fee);
msft = algo.Securities[Symbols.MSFT];
msft.BuyingPowerModel = new SecurityMarginModel(initialMarginRequirement, maintenanceMarginRequirement);
return(algo);
}
public void ConsolidatorHasSameTypeAsSubscriptionDataConfig(SecurityType securityType, TickType expectedTickType, string ticker)
{
var algorithm = new QCAlgorithm();
algorithm.SubscriptionManager.SetDataManager(new DataManagerStub(algorithm));
var security = algorithm.AddSecurity(securityType, ticker);
var consolidator = algorithm.ResolveConsolidator(ticker, Resolution.Minute);
var inputType = security.Subscriptions.Single(s => s.TickType == expectedTickType).Type;
var outputType = consolidator.OutputType;
Assert.AreEqual(inputType, outputType);
}
public void ZeroTargetWithNonZeroHoldingsReturnsNegativeOfQuantity()
{
var algorithm = new QCAlgorithm();
var security = algorithm.AddSecurity(SecurityType.Equity, "SPY");
security.Holdings.SetHoldings(200, 10);
var model = new SecurityMarginModel();
var result = model.GetMaximumOrderQuantityForTargetValue(algorithm.Portfolio, security, 0);
Assert.AreEqual(-10, result.Quantity);
Assert.AreEqual(string.Empty, result.Reason);
Assert.AreEqual(false, result.IsError);
}
public void OnEndOfTimeStepSeedsUnderlyingSecuritiesThatHaveNoData()
{
var qcAlgorithm = new QCAlgorithm();
qcAlgorithm.SetLiveMode(true);
var testHistoryProvider = new TestHistoryProvider();
qcAlgorithm.HistoryProvider = testHistoryProvider;
var option = qcAlgorithm.AddSecurity(SecurityType.Option, testHistoryProvider.underlyingSymbol);
var option2 = qcAlgorithm.AddSecurity(SecurityType.Option, testHistoryProvider.underlyingSymbol2);
Assert.IsFalse(qcAlgorithm.Securities.ContainsKey(option.Symbol.Underlying));
Assert.IsFalse(qcAlgorithm.Securities.ContainsKey(option2.Symbol.Underlying));
qcAlgorithm.OnEndOfTimeStep();
var data = qcAlgorithm.Securities[testHistoryProvider.underlyingSymbol].GetLastData();
var data2 = qcAlgorithm.Securities[testHistoryProvider.underlyingSymbol2].GetLastData();
Assert.IsNotNull(data);
Assert.IsNotNull(data2);
Assert.AreEqual(data.Price, 2);
Assert.AreEqual(data2.Price, 3);
}
public void AddSecurity_Follows_SetBrokerageModel()
{
// No brokerage set
var equity = _algo.AddSecurity(SecurityType.Equity, Sym);
string equityBrokerage = GetDefaultBrokerageForSecurityType(SecurityType.Equity);
Assert.IsTrue(equity.Symbol.ID.Market == Market.USA);
Assert.IsTrue(_algo.BrokerageModel.GetType() == typeof(DefaultBrokerageModel));
Assert.IsTrue(equityBrokerage == Market.USA);
// Set Brokerage
_algo.SetBrokerageModel(BrokerageName.OandaBrokerage);
var sec = _algo.AddSecurity(SecurityType.Forex, ForexSym, Resolution.Daily, false, 1, false);
string forexBrokerage = GetDefaultBrokerageForSecurityType(SecurityType.Forex);
Assert.IsTrue(sec.Symbol.ID.Market == Market.Oanda);
Assert.IsTrue(_algo.BrokerageModel.GetType() == typeof(OandaBrokerageModel));
Assert.IsTrue(forexBrokerage == Market.Oanda);
}
private static QCAlgorithm GetAlgorithm(out Security security, decimal fee)
{
SymbolCache.Clear();
// Initialize algorithm
var algo = new QCAlgorithm();
algo.SetCash(100000);
algo.SetBrokerageModel(BrokerageName.GDAX, AccountType.Cash);
algo.Transactions.SetOrderProcessor(new FakeOrderProcessor());
algo.SetFinishedWarmingUp();
security = algo.AddSecurity(SecurityType.Crypto, "BTCUSD");
security.TransactionModel = new ConstantFeeTransactionModel(fee);
//Set price to $25
Update(algo.Portfolio.CashBook, security, 25);
return(algo);
}
public void SetHoldings_Long_ToZero_RoundOff()
{
var algo = new QCAlgorithm();
algo.AddSecurity(SecurityType.Forex, "EURUSD");
algo.SetCash(10000);
algo.SetBrokerageModel(BrokerageName.FxcmBrokerage);
algo.Securities[Symbols.EURUSD].TransactionModel = new ConstantFeeTransactionModel(0);
Security eurusd = algo.Securities[Symbols.EURUSD];
// Set Price to $25
Update(eurusd, 25);
// So 10000/25 = 400, After Rounding off becomes 0
var actual = algo.CalculateOrderQuantity(Symbols.EURUSD, 1m);
Assert.AreEqual(0m, actual);
}
public void SetHoldings_Short_RoundOff()
{
var algo = new QCAlgorithm();
algo.AddSecurity(SecurityType.Forex, "EURUSD");
algo.SetCash(100000);
algo.SetBrokerageModel(BrokerageName.FxcmBrokerage);
algo.Securities[Symbols.EURUSD].TransactionModel = new ConstantFeeTransactionModel(0);
Security eurusd = algo.Securities[Symbols.EURUSD];
// Set Price to $26
Update(eurusd, 26);
// So -100000/26 = -3846, After Rounding off becomes -3000
var actual = algo.CalculateOrderQuantity("EURUSD", -1m);
Assert.AreEqual(-3000m, actual);
}
public void RoundOff_LessThanLotSize_Fractional_Orders()
{
var algo = new QCAlgorithm();
algo.SetBrokerageModel(BrokerageName.Default);
algo.SetCash(100000);
// Sets the Security
var security = algo.AddSecurity(SecurityType.Forex, "BTCUSD", Resolution.Hour, Market.Bitfinex, false, 3.3m, true);
//Initializes the transaction handler
var transactionHandler = new BrokerageTransactionHandler();
transactionHandler.Initialize(algo, new BacktestingBrokerage(algo), new BacktestingResultHandler());
// Creates the order
var orderRequest = new SubmitOrderRequest(OrderType.Market, security.Type, security.Symbol, 0.009m, 0, 0, DateTime.Now, "");
var order = Order.CreateOrder(orderRequest);
var actual = transactionHandler.RoundOffOrder(order, security);
Assert.AreEqual(0, actual);
}
public void RoundOff_Short_Fractional_Orders()
{
var algo = new QCAlgorithm();
algo.SubscriptionManager.SetDataManager(new DataManagerStub(algo));
algo.SetBrokerageModel(BrokerageName.Default);
algo.SetCash(100000);
// Sets the Security
var security = algo.AddSecurity(SecurityType.Crypto, "BTCUSD", Resolution.Hour, Market.GDAX, false, 3.3m, true);
//Initializes the transaction handler
var transactionHandler = new BrokerageTransactionHandler();
transactionHandler.Initialize(algo, new BacktestingBrokerage(algo), new BacktestingResultHandler());
// Creates the order
var orderRequest = new SubmitOrderRequest(OrderType.Market, security.Type, security.Symbol, -123.123456789m, 0, 0, DateTime.Now, "");
var order = Order.CreateOrder(orderRequest);
var actual = transactionHandler.RoundOffOrder(order, security);
Assert.AreEqual(-123.12345678m, actual);
}
public void Run(Position initialPosition, Position finalPosition, FeeType feeType, PriceMovement priceMovement, int leverage)
{
//Console.WriteLine("----------");
//Console.WriteLine("PARAMETERS");
//Console.WriteLine("Initial position: " + initialPosition);
//Console.WriteLine("Final position: " + finalPosition);
//Console.WriteLine("Fee type: " + feeType);
//Console.WriteLine("Price movement: " + priceMovement);
//Console.WriteLine("Leverage: " + leverage);
//Console.WriteLine("----------");
//Console.WriteLine();
var algorithm = new QCAlgorithm();
var security = algorithm.AddSecurity(_symbol.ID.SecurityType, _symbol.ID.Symbol);
security.FeeModel = _feeModels[feeType];
security.SetLeverage(leverage);
algorithm.SetCash(Cash);
Update(security, BasePrice);
decimal targetPercentage;
OrderDirection orderDirection;
MarketOrder order;
decimal orderFee;
OrderEvent fill;
int orderQuantity;
decimal freeMargin;
decimal requiredMargin;
if (initialPosition != Position.Zero)
{
targetPercentage = (decimal)initialPosition;
orderDirection = initialPosition == Position.Long ? OrderDirection.Buy : OrderDirection.Sell;
orderQuantity = algorithm.CalculateOrderQuantity(_symbol, targetPercentage);
order = new MarketOrder(_symbol, orderQuantity, DateTime.UtcNow);
freeMargin = algorithm.Portfolio.GetMarginRemaining(_symbol, orderDirection);
requiredMargin = security.MarginModel.GetInitialMarginRequiredForOrder(security, order);
//Console.WriteLine("Current price: " + security.Price);
//Console.WriteLine("Target percentage: " + targetPercentage);
//Console.WriteLine("Order direction: " + orderDirection);
//Console.WriteLine("Order quantity: " + orderQuantity);
//Console.WriteLine("Free margin: " + freeMargin);
//Console.WriteLine("Required margin: " + requiredMargin);
//Console.WriteLine();
Assert.That(Math.Abs(requiredMargin) <= freeMargin);
orderFee = security.FeeModel.GetOrderFee(security, order);
fill = new OrderEvent(order, DateTime.UtcNow, orderFee)
{
FillPrice = security.Price, FillQuantity = orderQuantity
};
algorithm.Portfolio.ProcessFill(fill);
//Console.WriteLine("Portfolio.Cash: " + algorithm.Portfolio.Cash);
//Console.WriteLine("Portfolio.TotalPortfolioValue: " + algorithm.Portfolio.TotalPortfolioValue);
//Console.WriteLine();
if (priceMovement == PriceMovement.RisingSmall)
{
Update(security, HighPrice);
}
else if (priceMovement == PriceMovement.FallingSmall)
{
Update(security, LowPrice);
}
else if (priceMovement == PriceMovement.RisingLarge)
{
Update(security, VeryHighPrice);
}
else if (priceMovement == PriceMovement.FallingLarge)
{
Update(security, VeryLowPrice);
}
}
targetPercentage = (decimal)finalPosition;
orderDirection = finalPosition == Position.Long || (finalPosition == Position.Zero && initialPosition == Position.Short) ? OrderDirection.Buy : OrderDirection.Sell;
orderQuantity = algorithm.CalculateOrderQuantity(_symbol, targetPercentage);
order = new MarketOrder(_symbol, orderQuantity, DateTime.UtcNow);
freeMargin = algorithm.Portfolio.GetMarginRemaining(_symbol, orderDirection);
requiredMargin = security.MarginModel.GetInitialMarginRequiredForOrder(security, order);
//Console.WriteLine("Current price: " + security.Price);
//Console.WriteLine("Target percentage: " + targetPercentage);
//Console.WriteLine("Order direction: " + orderDirection);
//Console.WriteLine("Order quantity: " + orderQuantity);
//Console.WriteLine("Free margin: " + freeMargin);
//Console.WriteLine("Required margin: " + requiredMargin);
//Console.WriteLine();
Assert.That(Math.Abs(requiredMargin) <= freeMargin);
orderFee = security.FeeModel.GetOrderFee(security, order);
fill = new OrderEvent(order, DateTime.UtcNow, orderFee)
{
FillPrice = security.Price, FillQuantity = orderQuantity
};
algorithm.Portfolio.ProcessFill(fill);
//Console.WriteLine("Portfolio.Cash: " + algorithm.Portfolio.Cash);
//Console.WriteLine("Portfolio.TotalPortfolioValue: " + algorithm.Portfolio.TotalPortfolioValue);
//Console.WriteLine();
}
/// <summary>
/// Set a required SecurityType-symbol and resolution for algorithm
/// </summary>
/// <param name="securityType">SecurityType Enum: Equity, Commodity, FOREX or Future</param>
/// <param name="symbol">Symbol Representation of the MarketType, e.g. AAPL</param>
/// <param name="resolution">Resolution of the MarketType required: MarketData, Second or Minute</param>
/// <param name="market">The market the requested security belongs to, such as 'usa' or 'fxcm'</param>
/// <param name="fillDataForward">If true, returns the last available data even if none in that timeslice.</param>
/// <param name="leverage">leverage for this security</param>
/// <param name="extendedMarketHours">ExtendedMarketHours send in data from 4am - 8pm, not used for FOREX</param>
public Security AddSecurity(SecurityType securityType, string symbol, Resolution resolution, string market, bool fillDataForward, decimal leverage, bool extendedMarketHours)
{
return(_baseAlgorithm.AddSecurity(securityType, symbol, resolution, market, fillDataForward, leverage, extendedMarketHours));
}
public void Run(object[] parameters)
{
Position initialPosition = (Position)parameters[0];
Position finalPosition = (Position)parameters[1];
FeeType feeType = (FeeType)parameters[2];
PriceMovement priceMovement = (PriceMovement)parameters[3];
int leverage = (int)parameters[4];
//Console.WriteLine("----------");
//Console.WriteLine("PARAMETERS");
//Console.WriteLine("Initial position: " + initialPosition);
//Console.WriteLine("Final position: " + finalPosition);
//Console.WriteLine("Fee type: " + feeType);
//Console.WriteLine("Price movement: " + priceMovement);
//Console.WriteLine("Leverage: " + leverage);
//Console.WriteLine("----------");
//Console.WriteLine();
var algorithm = new QCAlgorithm();
algorithm.SubscriptionManager.SetDataManager(new DataManagerStub(algorithm));
var security = algorithm.AddSecurity(_symbol.ID.SecurityType, _symbol.ID.Symbol);
security.FeeModel = _feeModels[feeType];
security.SetLeverage(leverage);
var buyingPowerModel = new TestSecurityMarginModel(leverage);
security.BuyingPowerModel = buyingPowerModel;
algorithm.SetCash(Cash);
Update(security, BasePrice);
decimal targetPercentage;
OrderDirection orderDirection;
MarketOrder order;
OrderFee orderFee;
OrderEvent fill;
decimal orderQuantity;
decimal freeMargin;
decimal requiredMargin;
if (initialPosition != Position.Zero)
{
targetPercentage = (decimal)initialPosition;
orderDirection = initialPosition == Position.Long ? OrderDirection.Buy : OrderDirection.Sell;
orderQuantity = algorithm.CalculateOrderQuantity(_symbol, targetPercentage);
order = new MarketOrder(_symbol, orderQuantity, DateTime.UtcNow);
freeMargin = buyingPowerModel.GetMarginRemaining(algorithm.Portfolio, security, orderDirection);
requiredMargin = buyingPowerModel.GetInitialMarginRequiredForOrder(
new InitialMarginRequiredForOrderParameters(
new IdentityCurrencyConverter(algorithm.Portfolio.CashBook.AccountCurrency), security, order));
//Console.WriteLine("Current price: " + security.Price);
//Console.WriteLine("Target percentage: " + targetPercentage);
//Console.WriteLine("Order direction: " + orderDirection);
//Console.WriteLine("Order quantity: " + orderQuantity);
//Console.WriteLine("Free margin: " + freeMargin);
//Console.WriteLine("Required margin: " + requiredMargin);
//Console.WriteLine();
Assert.That(Math.Abs(requiredMargin) <= freeMargin);
orderFee = security.FeeModel.GetOrderFee(
new OrderFeeParameters(security, order));
fill = new OrderEvent(order, DateTime.UtcNow, orderFee)
{
FillPrice = security.Price, FillQuantity = orderQuantity
};
algorithm.Portfolio.ProcessFill(fill);
//Console.WriteLine("Portfolio.Cash: " + algorithm.Portfolio.Cash);
//Console.WriteLine("Portfolio.TotalPortfolioValue: " + algorithm.Portfolio.TotalPortfolioValue);
//Console.WriteLine();
if (priceMovement == PriceMovement.RisingSmall)
{
Update(security, HighPrice);
}
else if (priceMovement == PriceMovement.FallingSmall)
{
Update(security, LowPrice);
}
else if (priceMovement == PriceMovement.RisingLarge)
{
Update(security, VeryHighPrice);
}
else if (priceMovement == PriceMovement.FallingLarge)
{
Update(security, VeryLowPrice);
}
}
targetPercentage = (decimal)finalPosition;
orderDirection = finalPosition == Position.Long || (finalPosition == Position.Zero && initialPosition == Position.Short) ? OrderDirection.Buy : OrderDirection.Sell;
orderQuantity = algorithm.CalculateOrderQuantity(_symbol, targetPercentage);
order = new MarketOrder(_symbol, orderQuantity, DateTime.UtcNow);
freeMargin = buyingPowerModel.GetMarginRemaining(algorithm.Portfolio, security, orderDirection);
requiredMargin = buyingPowerModel.GetInitialMarginRequiredForOrder(
new InitialMarginRequiredForOrderParameters(
new IdentityCurrencyConverter(algorithm.Portfolio.CashBook.AccountCurrency), security, order));
//Console.WriteLine("Current price: " + security.Price);
//Console.WriteLine("Target percentage: " + targetPercentage);
//Console.WriteLine("Order direction: " + orderDirection);
//Console.WriteLine("Order quantity: " + orderQuantity);
//Console.WriteLine("Free margin: " + freeMargin);
//Console.WriteLine("Required margin: " + requiredMargin);
//Console.WriteLine();
Assert.That(Math.Abs(requiredMargin) <= freeMargin);
orderFee = security.FeeModel.GetOrderFee(
new OrderFeeParameters(security, order));
fill = new OrderEvent(order, DateTime.UtcNow, orderFee)
{
FillPrice = security.Price, FillQuantity = orderQuantity
};
algorithm.Portfolio.ProcessFill(fill);
//Console.WriteLine("Portfolio.Cash: " + algorithm.Portfolio.Cash);
//Console.WriteLine("Portfolio.TotalPortfolioValue: " + algorithm.Portfolio.TotalPortfolioValue);
//Console.WriteLine();
}
