/// <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;
 }
Beispiel #3
0
        /// <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;
 }
Beispiel #5
0
        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));
        }
Beispiel #6
0
 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;
            }
        }
Beispiel #9
0
        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);
                    }
                }
            }
        }
Beispiel #10
0
        /// <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;
                }
            }
        }
Beispiel #11
0
        /// <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);
        }
Beispiel #12
0
        /// <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;
            }
        }
Beispiel #13
0
        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);
                    }
                }
            }
        }
Beispiel #14
0
        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;
        }
        /// <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;
            }
        }
        //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);
                }
            }
        }
Beispiel #18
0
        /// <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;
            }
        }
Beispiel #22
0
        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());
                }
            }
        }
Beispiel #23
0
 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);
 }
Beispiel #24
0
        /// <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());
         }
     }
 }