/// <summary> /// Estimate number of shares, given a kind of operation. /// </summary> /// <param name="symbol">The symbol to operate.</param> /// <param name="order">The kind of order.</param> /// <returns>The signed number of shares given the operation.</returns> public int PositionShares(Symbol symbol, SignalInfo signalInfo) { int quantity = 0; int operationQuantity; decimal targetSize; targetSize = GetBetSize(symbol, signalInfo); switch (signalInfo.Value) { case OrderSignal.goLongLimit: case OrderSignal.goLong: //operationQuantity = CalculateOrderQuantity(symbol, targetSize); // let the algo decide on order quantity operationQuantity = (int)targetSize; quantity = Math.Min(maxOperationQuantity, operationQuantity); break; case OrderSignal.goShortLimit: case OrderSignal.goShort: //operationQuantity = CalculateOrderQuantity(symbol, targetSize); // let the algo decide on order quantity operationQuantity = (int)targetSize; quantity = -Math.Min(maxOperationQuantity, operationQuantity); break; case OrderSignal.closeLong: case OrderSignal.closeShort: if (signalInfo.IsActive) { quantity = -Portfolio[symbol].Quantity; } //else //{ // quantity = -_proformaProcessor.GetPosition(symbol); //} break; case OrderSignal.revertToLong: case OrderSignal.revertToShort: if (signalInfo.IsActive) { quantity = -2 * Portfolio[symbol].Quantity; } //else //{ // quantity = -2 * _proformaProcessor.GetPosition(symbol); //} break; default: quantity = 0; break; } if (quantity == 0) { System.Diagnostics.Debug.WriteLine("Position Quantity is 0"); } return(quantity); }
/// <summary> /// Calculates the bet size for this turn /// </summary> /// <param name="symbol">Symbol - the symbol to size the bet for</param> /// <param name="currentPrice">The current price of the security</param> /// <param name="transactionSize">The transaction size from the algorithm</param> /// <param name="signalInfo"></param> /// <param name="proformaProcessor"></param> /// <returns></returns> public decimal BetSize(Symbol symbol, decimal currentPrice, decimal transactionSize, SignalInfo signalInfo, OrderTransactionProcessor proformaProcessor) { decimal betsize = _algorithm.Portfolio[symbol].Invested ? Math.Abs(_algorithm.Portfolio[symbol].Quantity) : Math.Abs(transactionSize / currentPrice); if (betsize <= 10) betsize = 100; return betsize; }
/// <summary> /// Executes the ITrend strategy orders. /// </summary> /// <param name="symbol">The symbol to be traded.</param> /// <param name="actualOrder">The actual arder to be execute.</param> /// <param name="data">The actual TradeBar data.</param> private void ExecuteStrategy(Symbol symbol, SignalInfo actualOrder, TradeBars data) { decimal limitPrice = 0m; int shares = PositionShares(symbol, actualOrder); ILimitPriceCalculator priceCalculator = new InstantTrendLimitPriceCalculator(); OrderTicket ticket; switch (actualOrder.Value) { case OrderSignal.goLongLimit: // Define the limit price. limitPrice = priceCalculator.Calculate(data[symbol], actualOrder, RngFac); ticket = LimitOrder(symbol, shares, limitPrice, actualOrder.Id.ToString(CultureInfo.InvariantCulture)); _ticketsQueue.Add(ticket); break; case OrderSignal.goShortLimit: limitPrice = priceCalculator.Calculate(data[symbol], actualOrder, RngFac); ticket = LimitOrder(symbol, shares, limitPrice, actualOrder.Id.ToString(CultureInfo.InvariantCulture)); _ticketsQueue.Add(ticket); break; case OrderSignal.goLong: case OrderSignal.goShort: case OrderSignal.closeLong: case OrderSignal.closeShort: case OrderSignal.revertToLong: case OrderSignal.revertToShort: ticket = MarketOrder(symbol, shares, false, actualOrder.Id.ToString(CultureInfo.InvariantCulture)); _ticketsQueue.Add(ticket); break; } }
/// <summary> /// Calculates the Limit Price /// </summary> /// <param name="data">The current bar</param> /// <param name="signal">The signal as to which side to limit</param> /// <param name="rangeFactor">A coefficient to decide where in the range to pick</param> /// <returns></returns> public decimal Calculate(TradeBar data, SignalInfo signalInfo, decimal rangeFactor) { decimal nLimitPrice = 0; if (signalInfo.Value == OrderSignal.goLongLimit) nLimitPrice = Math.Round(Math.Max(data.Low, (data.Close - (data.High - data.Low) * rangeFactor)), 2, MidpointRounding.ToEven); if (signalInfo.Value == OrderSignal.goShortLimit) nLimitPrice = Math.Round(Math.Min(data.High, (data.Close + (data.High - data.Low) * rangeFactor)), 2, MidpointRounding.ToEven); return nLimitPrice; }
private decimal GetBetSize(Symbol symbol, SignalInfo signalInfo) { // ********************************* // ToDo: Kelly Goes here in a custom bet sizer // This implementation uses the same as the original algo // and just refactors it out to a class. // ********************************* IBetSizer allocator = new InstantTrendBetSizer(this); return(allocator.BetSize(symbol, signalInfo.Price[0].Value, _transactionSize, signalInfo)); }
public decimal BetSize(Symbol symbol, decimal currentPrice, decimal transactionSize, SignalInfo signalInfo) { decimal betsize = _algorithm.Portfolio[symbol].Invested ? Math.Abs(_algorithm.Portfolio[symbol].Quantity) : Math.Abs((15m / 26m) * _algorithm.Portfolio.Cash / currentPrice); if (betsize <= 10) { betsize = 0; signalInfo.Value = OrderSignal.doNothing; } return betsize; }
/// <summary> /// Calculates the Limit Price /// </summary> /// <param name="data">The current bar</param> /// <param name="signal">The signal as to which side to limit</param> /// <param name="rangeFactor">A coefficient to decide where in the range to pick</param> /// <returns></returns> public decimal Calculate(TradeBar data, SignalInfo signalInfo, decimal rangeFactor) { decimal nLimitPrice = 0; if (signalInfo.Value == OrderSignal.goLongLimit) { nLimitPrice = Math.Round(Math.Max(data.Low, (data.Close - (data.High - data.Low) * rangeFactor)), 2, MidpointRounding.ToEven); } if (signalInfo.Value == OrderSignal.goShortLimit) { nLimitPrice = Math.Round(Math.Min(data.High, (data.Close + (data.High - data.Low) * rangeFactor)), 2, MidpointRounding.ToEven); } return(nLimitPrice); }
/// <summary> /// Executes the ITrend strategy orders. /// </summary> /// <param name="symbol">The symbol to be traded.</param> /// <param name="signalInfo">The actual arder to be execute.</param> /// <param name="data">The actual TradeBar data.</param> private void ExecuteStrategy(Symbol symbol, SignalInfo signalInfo, KeyValuePair <Symbol, TradeBar> data) { decimal limitPrice = 0m; int shares = PositionShares(symbol, signalInfo); if (shares == 0) { return; } ILimitPriceCalculator priceCalculator = new InstantTrendLimitPriceCalculator(); OrderTicket ticket; switch (signalInfo.Value) { case OrderSignal.goLongLimit: // Define the limit price. signalInfo.IsActive = false; limitPrice = priceCalculator.Calculate(data.Value, signalInfo, RngFac); ticket = LimitOrder(symbol, shares, limitPrice, signalInfo.Id.ToString(CultureInfo.InvariantCulture)); _ticketsQueue.Add(ticket); break; case OrderSignal.goShortLimit: signalInfo.IsActive = false; limitPrice = priceCalculator.Calculate(data.Value, signalInfo, RngFac); ticket = LimitOrder(symbol, shares, limitPrice, signalInfo.Id.ToString(CultureInfo.InvariantCulture)); _ticketsQueue.Add(ticket); break; case OrderSignal.goLong: case OrderSignal.goShort: case OrderSignal.closeLong: case OrderSignal.closeShort: case OrderSignal.revertToLong: case OrderSignal.revertToShort: signalInfo.IsActive = false; ticket = MarketOrder(symbol, shares, false, signalInfo.Id.ToString(CultureInfo.InvariantCulture)); _ticketsQueue.Add(ticket); break; default: break; } }
private void HandleSubmitted(KeyValuePair <Symbol, TradeBar> data, SignalInfo currentSignalInfo) { IEnumerable <OrderTicket> livetickets = Transactions.GetOrderTickets( t => t.Symbol == data.Key && t.Status == OrderStatus.Submitted); if (livetickets != null) { foreach (OrderTicket liveticket in livetickets) { if (liveticket.Quantity > 0) // long { AlterLongLimit(data, liveticket, currentSignalInfo); } else // short { AlterShortLimit(data, liveticket, currentSignalInfo); } } } }
/// <summary> /// Executes the ITrend strategy orders. /// </summary> /// <param name="symbol">The symbol to be traded.</param> /// <param name="signalInfo">The actual arder to be execute.</param> /// <param name="data">The actual TradeBar data.</param> private void ExecuteStrategy(Symbol symbol, SignalInfo signalInfo, KeyValuePair <Symbol, TradeBar> data) { int shares = Convert.ToInt32(PositionShares(symbol, signalInfo)); if (shares != 0) { ILimitPriceCalculator priceCalculator = new InstantTrendLimitPriceCalculator(); OrderTicket ticket; decimal limitPrice; switch (signalInfo.Value) { case OrderSignal.goLongLimit: // Define the limit price. limitPrice = priceCalculator.Calculate(data.Value, signalInfo, RngFac); ticket = LimitOrder(symbol, shares, limitPrice, signalInfo.Id.ToString(CultureInfo.InvariantCulture)); break; case OrderSignal.goShortLimit: limitPrice = priceCalculator.Calculate(data.Value, signalInfo, RngFac); ticket = LimitOrder(symbol, shares, limitPrice, signalInfo.Id.ToString(CultureInfo.InvariantCulture)); break; case OrderSignal.goLong: case OrderSignal.goShort: case OrderSignal.closeLong: case OrderSignal.closeShort: case OrderSignal.revertToLong: case OrderSignal.revertToShort: ticket = MarketOrder(symbol, shares, false, signalInfo.Id.ToString(CultureInfo.InvariantCulture)); break; default: break; } } }
/// <summary> /// Estimate number of shares, given a kind of operation. /// </summary> /// <param name="symbol">The symbol to operate.</param> /// <param name="signalInfo">The signalInfo.</param> /// <returns>The signed number of shares given the operation.</returns> public decimal PositionShares(Symbol symbol, SignalInfo signalInfo) { decimal quantity = 0; int operationQuantity; decimal targetSize = GetBetSize(symbol, signalInfo); switch (signalInfo.Value) { case OrderSignal.goLongLimit: case OrderSignal.goLong: quantity = Math.Min(maxOperationQuantity, targetSize); break; case OrderSignal.goShortLimit: case OrderSignal.goShort: quantity = -Math.Min(maxOperationQuantity, targetSize); break; case OrderSignal.closeLong: case OrderSignal.closeShort: if (Portfolio[symbol].Quantity != 0) { quantity = -Portfolio[symbol].Quantity; } break; case OrderSignal.revertToLong: case OrderSignal.revertToShort: if (Portfolio[symbol].Quantity != 0) { quantity = -2 * Portfolio[symbol].Quantity; } break; } return(quantity); }
/// <summary> /// Executes the ITrend strategy orders. /// </summary> /// <param name="symbol">The symbol to be traded.</param> /// <param name="signalInfo">The actual arder to be execute.</param> /// <param name="data">The actual TradeBar data.</param> private void ExecuteStrategy(Symbol symbol, SignalInfo signalInfo, KeyValuePair<Symbol, TradeBar> data) { decimal limitPrice = 0m; int shares = Convert.ToInt32(PositionShares(symbol, signalInfo)); if (shares == 0) { return; } ILimitPriceCalculator priceCalculator = new InstantTrendLimitPriceCalculator(); OrderTicket ticket; if (shares == 0) signalInfo.Value = OrderSignal.doNothing; switch (signalInfo.Value) { case OrderSignal.goLongLimit: // Define the limit price. limitPrice = priceCalculator.Calculate(data.Value, signalInfo, RngFac); //ticket = MarketOrder(symbol, shares, false, signalInfo.Id.ToString(CultureInfo.InvariantCulture)); ticket = LimitOrder(symbol, shares, limitPrice, signalInfo.Id.ToString(CultureInfo.InvariantCulture)); //_ticketsQueue.Add(ticket); break; case OrderSignal.goShortLimit: limitPrice = priceCalculator.Calculate(data.Value, signalInfo, RngFac); ticket = MarketOrder(symbol, shares, false, signalInfo.Id.ToString(CultureInfo.InvariantCulture)); //ticket = LimitOrder(symbol, shares, limitPrice, signalInfo.Id.ToString(CultureInfo.InvariantCulture)); //_ticketsQueue.Add(ticket); break; case OrderSignal.goLong: case OrderSignal.goShort: case OrderSignal.closeLong: case OrderSignal.closeShort: case OrderSignal.revertToLong: case OrderSignal.revertToShort: ticket = MarketOrder(symbol, shares, false, signalInfo.Id.ToString(CultureInfo.InvariantCulture)); //_ticketsQueue.Add(ticket); break; default: break; } }
private void HandleSubmitted(KeyValuePair<Symbol, TradeBar> data, SignalInfo currentSignalInfo) { IEnumerable<OrderTicket> livetickets = Transactions.GetOrderTickets( t => t.Symbol == data.Key && t.Status == OrderStatus.Submitted); if (livetickets != null) { foreach (OrderTicket liveticket in livetickets) { if (liveticket.Quantity > 0) // long { AlterLongLimit(data, liveticket, currentSignalInfo); } else // short { AlterShortLimit(data, liveticket, currentSignalInfo); } } } }
private void AlterLongLimit(KeyValuePair<Symbol, TradeBar> data, OrderTicket liveticket, SignalInfo currentSignalInfo) { //Log(string.Format("Trade Attempts: {0} OrderId {1}", currentSignalInfo.TradeAttempts, liveticket.OrderId)); if (currentSignalInfo.TradeAttempts++ > 3) { liveticket.Cancel(); //Log(string.Format("Order {0} cancellation sent. Trade attempts > 3.", liveticket.OrderId)); } }
/// <summary> /// Estimate number of shares, given a kind of operation. /// </summary> /// <param name="symbol">The symbol to operate.</param> /// <param name="order">The kind of order.</param> /// <returns>The signed number of shares given the operation.</returns> public int PositionShares(Symbol symbol, SignalInfo signalInfo) { int quantity = 0; int operationQuantity; decimal targetSize = GetBetSize(symbol, signalInfo); switch (signalInfo.Value) { case OrderSignal.goLongLimit: case OrderSignal.goLong: //operationQuantity = CalculateOrderQuantity(symbol, targetSize); // let the algo decide on order quantity operationQuantity = (int)targetSize; quantity = Math.Min(maxOperationQuantity, operationQuantity); break; case OrderSignal.goShortLimit: case OrderSignal.goShort: operationQuantity = (int)targetSize; quantity = -Math.Min(maxOperationQuantity, operationQuantity); break; case OrderSignal.closeLong: case OrderSignal.closeShort: quantity = -Portfolio[symbol].Quantity; break; case OrderSignal.revertToLong: case OrderSignal.revertToShort: quantity = -2 * Portfolio[symbol].Quantity; break; default: quantity = 0; break; } if (quantity == 0) System.Diagnostics.Debug.WriteLine("x"); return quantity; }
//private decimal CalculateTradeProfit(Symbol symbol) //{ // return _orderTransactionProcessor.CalculateLastTradePandL(symbol); //} #region "Methods" /// <summary> /// Executes the ITrend strategy orders. /// </summary> /// <param name="symbol">The symbol to be traded.</param> /// <param name="signalInfo">The actual arder to be execute.</param> /// <param name="data">The actual TradeBar data.</param> private void ExecuteStrategy(Symbol symbol, SignalInfo signalInfo, KeyValuePair<Symbol, TradeBar> data) { return; int shares = Convert.ToInt32(PositionShares(symbol, signalInfo)); if (shares != 0) { ILimitPriceCalculator priceCalculator = new InstantTrendLimitPriceCalculator(); OrderTicket ticket = null; decimal limitPrice = 0; switch (signalInfo.Value) { case OrderSignal.goLongLimit: // Define the limit price. limitPrice = priceCalculator.Calculate(data.Value, signalInfo, RngFac); ticket = LimitOrder(symbol, shares, limitPrice, signalInfo.Id.ToString(CultureInfo.InvariantCulture)); break; case OrderSignal.goShortLimit: limitPrice = priceCalculator.Calculate(data.Value, signalInfo, RngFac); ticket = LimitOrder(symbol, shares, limitPrice, signalInfo.Id.ToString(CultureInfo.InvariantCulture)); break; case OrderSignal.goLong: case OrderSignal.goShort: case OrderSignal.closeLong: case OrderSignal.closeShort: case OrderSignal.revertToLong: case OrderSignal.revertToShort: ticket = MarketOrder(symbol, shares, false, signalInfo.Id.ToString(CultureInfo.InvariantCulture)); limitPrice = ticket.AverageFillPrice; break; default: break; } if (ticket != null) { if (ticket.OrderId == 82) System.Diagnostics.Debug.WriteLine("Send order 82"); string msg = string.Format("Order {0} Sent {1}, {2}, {3} at {4} bar {5}", ticket.OrderId, signalInfo.Value, signalInfo.Name, shares, limitPrice, barcount); Log(msg); } } }
/// <summary> /// Calculates the bet size for this turn /// </summary> /// <param name="symbol">Symbol - the symbol to size the bet for</param> /// <param name="currentPrice">The current price of the security</param> /// <param name="transactionSize">The transaction size from the algorithm</param> /// <param name="signalInfo"></param> /// <param name="proformaProcessor"></param> /// <returns></returns> public decimal BetSize(Symbol symbol, decimal currentPrice, decimal transactionSize, SignalInfo signalInfo, OrderTransactionProcessor proformaProcessor) { decimal betsize = _algorithm.Portfolio[symbol].Invested ? Math.Abs(_algorithm.Portfolio[symbol].Quantity) : Math.Abs(transactionSize / currentPrice); if (betsize <= 10) { betsize = 100; } return(betsize); }
/// <summary> /// Estimate number of shares, given a kind of operation. /// </summary> /// <param name="symbol">The symbol to operate.</param> /// <param name="signalInfo">The signalInfo.</param> /// <returns>The signed number of shares given the operation.</returns> public decimal PositionShares(Symbol symbol, SignalInfo signalInfo) { decimal quantity = 0; // int operationQuantity; decimal targetSize = GetBetSize(symbol, signalInfo); switch (signalInfo.Value) { case OrderSignal.goLongLimit: case OrderSignal.goLong: quantity = Math.Min(maxOperationQuantity, targetSize); break; case OrderSignal.goShortLimit: case OrderSignal.goShort: quantity = -Math.Min(maxOperationQuantity, targetSize); break; case OrderSignal.closeLong: case OrderSignal.closeShort: if (Portfolio[symbol].Quantity != 0) quantity = -Portfolio[symbol].Quantity; break; case OrderSignal.revertToLong: case OrderSignal.revertToShort: if (Portfolio[symbol].Quantity != 0) quantity = -2 * Portfolio[symbol].Quantity; break; } return quantity; }
/// <summary> /// Estimate number of shares, given a kind of operation. /// </summary> /// <param name="symbol">The symbol to operate.</param> /// <param name="order">The kind of order.</param> /// <returns>The signed number of shares given the operation.</returns> public int PositionShares(Symbol symbol, SignalInfo signalInfo) { int quantity = 0; int operationQuantity; decimal targetSize; targetSize = GetBetSize(symbol, signalInfo); switch (signalInfo.Value) { case OrderSignal.goLongLimit: case OrderSignal.goLong: //operationQuantity = CalculateOrderQuantity(symbol, targetSize); // let the algo decide on order quantity operationQuantity = (int)targetSize; quantity = Math.Min(maxOperationQuantity, operationQuantity); break; case OrderSignal.goShortLimit: case OrderSignal.goShort: //operationQuantity = CalculateOrderQuantity(symbol, targetSize); // let the algo decide on order quantity operationQuantity = (int)targetSize; quantity = -Math.Min(maxOperationQuantity, operationQuantity); break; case OrderSignal.closeLong: case OrderSignal.closeShort: if (signalInfo.IsActive) { quantity = -Portfolio[symbol].Quantity; } //else //{ // quantity = -_proformaProcessor.GetPosition(symbol); //} break; case OrderSignal.revertToLong: case OrderSignal.revertToShort: if (signalInfo.IsActive) { quantity = -2 * Portfolio[symbol].Quantity; } //else //{ // quantity = -2 * _proformaProcessor.GetPosition(symbol); //} break; default: quantity = 0; break; } return quantity; }
/// <summary> /// Local processing of the order event. It only logs the transaction and orderEvent /// </summary> /// <param name="orderEvent">OrderEvent - the order event</param> private void ProcessOrderEvent(OrderEvent orderEvent) { IEnumerable <OrderTicket> tickets; //add to the list of order events which is saved to a file when running locally // I will use this file to test Stefano Raggi's code if (orderEvent.Status == OrderStatus.Filled) { _orderEvents.Add(orderEvent); } orderId = orderEvent.OrderId; tradeResult = orderEvent.Status; switch (orderEvent.Status) { case OrderStatus.New: case OrderStatus.None: case OrderStatus.Submitted: // just checking to make sure they are coming through tickets = Transactions.GetOrderTickets(t => t.OrderId == orderId && t.Status == orderEvent.Status); break; case OrderStatus.Canceled: tickets = Transactions.GetOrderTickets(t => t.OrderId == orderId && t.Status == orderEvent.Status); if (tickets != null) { foreach (OrderTicket ticket in tickets) { int infoId = Convert.ToInt32(ticket.Tag); SignalInfo si = signalInfos.FirstOrDefault(f => f.Id == infoId); if (si != null) { si.IsActive = true; } } } break; case OrderStatus.Filled: case OrderStatus.PartiallyFilled: tickets = Transactions.GetOrderTickets(t => t.OrderId == orderId && t.Status == orderEvent.Status); if (tickets != null) { foreach (OrderTicket ticket in tickets) { int infoId = Convert.ToInt32(ticket.Tag); SignalInfo si = signalInfos.FirstOrDefault(f => f.Id == infoId); if (si != null) { si.IsActive = true; } #region "log the ticket as a OrderTransacton" OrderTransactionFactory transactionFactory = new OrderTransactionFactory((QCAlgorithm)this); OrderTransaction t = transactionFactory.Create(orderEvent, ticket, false); _transactions.Add(t); _orderTransactionProcessor.ProcessTransaction(t); _tradecount++; if (_orderTransactionProcessor.TotalProfit != totalProfit) { CalculateTradeProfit(t.Symbol); } totalProfit = _orderTransactionProcessor.TotalProfit; #endregion } } break; } }
private void AlterLongLimit(KeyValuePair <Symbol, TradeBar> data, OrderTicket liveticket, SignalInfo currentSignalInfo) { var limit = liveticket.Get(OrderField.LimitPrice); decimal newLimit = limit; currentSignalInfo.TradeAttempts++; if (newLimit < data.Value.Low) { newLimit = data.Value.Close + 0.01m; } OrderResponse response = liveticket.Update(new UpdateOrderFields { LimitPrice = newLimit, Tag = "Update #" + (liveticket.UpdateRequests.Count + 1) }); if (response.IsSuccess) { Log(string.Format("Long Order {0}. Status: {1} Updated {2} to new price {3}. Trade Attempts: {4}", liveticket.OrderId, liveticket.Status, limit, newLimit, currentSignalInfo.TradeAttempts)); } else { if (!response.IsProcessed) { Log(string.Format("Order {0} not yet processed to new price {1}", liveticket.OrderId, limit)); } if (response.IsError) { Log(response.ToString()); } } }
private decimal GetBetSize(Symbol symbol, SignalInfo signalInfo) { // ********************************* // ToDo: Kelly Goes here in a custom bet sizer // This implementation uses the same as the original algo // and just refactors it out to a class. // ********************************* IBetSizer allocator = new InstantTrendBetSizer(this); return allocator.BetSize(symbol, signalInfo.Price[0].Value, _transactionSize, signalInfo); }
/// <summary> /// Estimate number of shares, given a kind of operation. /// </summary> /// <param name="symbol">The symbol to operate.</param> /// <param name="order">The kind of order.</param> /// <returns>The signed number of shares given the operation.</returns> public decimal PositionShares(Symbol symbol, SignalInfo signalInfo) { decimal quantity = 0; int operationQuantity; decimal targetSize = GetBetSize(symbol, signalInfo); switch (signalInfo.Value) { case OrderSignal.goLongLimit: case OrderSignal.goLong: //operationQuantity = CalculateOrderQuantity(symbol, targetSize); // let the algo decide on order quantity //operationQuantity = (int)targetSize; quantity = Math.Min(maxOperationQuantity, targetSize); break; case OrderSignal.goShortLimit: case OrderSignal.goShort: //operationQuantity = CalculateOrderQuantity(symbol, targetSize); // let the algo decide on order quantity operationQuantity = (int)targetSize; quantity = -Math.Min(maxOperationQuantity, targetSize); break; case OrderSignal.closeLong: case OrderSignal.closeShort: if (Portfolio[symbol].Quantity != 0) quantity = -Portfolio[symbol].Quantity; break; case OrderSignal.revertToLong: case OrderSignal.revertToShort: if (Portfolio[symbol].Quantity != 0) quantity = -2 * Portfolio[symbol].Quantity; break; default: quantity = 0; break; } return quantity; }
private void AlterShortLimit(KeyValuePair<Symbol, TradeBar> data, OrderTicket liveticket, SignalInfo currentSignalInfo) { var limit = liveticket.Get(OrderField.LimitPrice); decimal newLimit = limit; currentSignalInfo.TradeAttempts++; if (limit > data.Value.High) { newLimit = data.Value.Close - 0.01m; } OrderResponse response = liveticket.Update(new UpdateOrderFields { LimitPrice = newLimit, Tag = "Update #" + (liveticket.UpdateRequests.Count + 1) }); if (response.IsSuccess) { Log(string.Format("Short Order {0}. Status: {1} Updated {2} to new price {3}. Trade Attempts: {4}", liveticket.OrderId, liveticket.Status, limit, newLimit, currentSignalInfo.TradeAttempts)); } else { if (!response.IsProcessed) { Log(string.Format("Order {0} not yet processed to new price {1}", liveticket.OrderId, limit)); } if (response.IsError) { Log(response.ToString()); } } }