Using-Spread-Equity-Equally-sizer-after-signals-prioritizing

Make the strategy generate 25 signals.

Hm. The question is how. There is a dataset (500 symbols). It can be 0-500 signals out of it per candle (Daily). I can't control the final number. I can select TOP 25, but the quantities are already set by that moment.

Here's how, for example:

CODE:
using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Drawing;
using System.Collections.Generic;

namespace WealthScript1 
{
    public class MyStrategy : UserStrategyBase
    {
        //create indicators and other objects here, this is executed prior to the main trading loop
        public override void Initialize(BarHistory bars)
        {
        }

        //execute the strategy rules here, this is executed once for each bar in the backtest history
        public override void Execute(BarHistory bars, int idx)
        {
            if (idx == bars.Count-1)
            {
            PlaceTrade(bars, TransactionType.Buy, OrderType.Market);
            }
        }

        public override void BacktestComplete()
        {
         //last bar
         if (Backtester.Orders.Count > 0)
         {
            WriteToDebugLog(string.Format("Signals: {0}", Backtester.Orders.Count));
            WriteToDebugLog("Removing last signal...");
            Backtester.Orders.RemoveAt(Backtester.Orders.Count - 1);
            WriteToDebugLog(string.Format("Signals now: {0}", Backtester.Orders.Count));
         }
        }
    }
}

Hmmm, presumably you'd want to perform some kind of sort first to get the TOP 25 Orders?

Also, the Orders property gives both Entry and Exit Signals, where Replicant wants to filter only the top 25 Entries.

You're right, the example is missing a check for IsEntry:

CODE:

using System.Linq;
...
public override void BacktestComplete()
        {
         var s = Backtester.Orders.Where(o => o.IsEntry).ToList();

         //last bar
         if (s.Count > 0)
         {            
            WriteToDebugLog(string.Format("Signals: {0}", s.Count));
            WriteToDebugLog("Removing last signal...");
            Backtester.Orders.RemoveAt(s.Count - 1);
            WriteToDebugLog(string.Format("Signals now: {0}", Backtester.Orders.Where(o => o.IsEntry).ToList().Count));
         }
        }

Here's a complete, minimal example that keeps the top 5 entries each bar and discards the rest. Also keeps all the exits.

I assign a Weight, and have to sort the Orders because the Backtester doesn't sort the next bar Signals by Weight.

Doing this process in PostExecute also lets you see the effects during the entire backtest, rather than just on the last bar of data, which is what would happen if you did this in BacktestComplete.

CODE:

using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Drawing;
using System.Collections.Generic;

namespace WealthScript1 
{
    public class MyStrategy : UserStrategyBase
    {
        //Initialize
        public override void Initialize(BarHistory bars)
        {
         rsi = RSI.Series(bars.Close, 20);
        }

        //Execute
        public override void Execute(BarHistory bars, int idx)
        {
         if (idx == bars.Count - 1)
         {
            Transaction t = PlaceTrade(bars, TransactionType.Buy, OrderType.Market);
            t.Weight = rsi[idx];
         }
        }

        //remove unwanted signals
        public override void PostExecute(DateTime dt, List<BarHistory> participants)
        {
         //Keep top 5 Orders
         Backtester.Orders.Sort((a, b) => a.Weight.CompareTo(b.Weight));
         List<Transaction> top5 = new List<Transaction>();
         foreach (Transaction t in Backtester.Orders)
         {
            if (t.IsEntry)
               if (top5.Count < 5)
                  top5.Add(t);
         }

         //Remove entries that are not in the Top 5
         for (int n = Backtester.Orders.Count - 1; n >= 0; n--)
         {
            Transaction t = Backtester.Orders[n];
            if (t.IsEntry && !top5.Contains(t))
               Backtester.Orders.RemoveAt(n);
         }
        }

        //private members
        private RSI rsi;
    }
}

I've been doing this type of order filtering in PreExecute. Which approach do you guys think is better? and why?

Wow! Thanks guys.

Glitch special thanks for your example – with sorting and all this stuff (as I’m not a native programmer it will help me a lot).

And being able to do this in PostExecute() is also a very good news.
Looks like I am one step to being able to use advanced pos sizers logic on Daily with Strategy Monitor. So I need to get equity value somewhere, using manually filled txt file is a good start for this. So I get the equity, I select orders needed, I recalculate quantities, I set new quantities.

My strategy with such PostExecute() generates top 5 opening orders and much much more closing orders). What am I doing wrong?) Looks like the strategy doesn’t know I deleted those orders).

Just because you limit the Strategy to 5 open ORDERS per bar, doesn't mean it cannot accumulate more than 5 open open positions at once, therefore perhaps giving you more than 5 exit orders. Without seeing the full Strategy (or a minimal example of the issue) I can only speculate.

You are right.

Here are some details:

CODE:

if (isLongOpening)
                    {
                        double something = 0;

                        PlaceTrade(bars, TransactionType.Buy, OrderType.Limit, bars.Low[idx] - something / 4);
                        PlaceTrade(bars, TransactionType.Buy, OrderType.Limit, bars.Low[idx] - something);
                        PlaceTrade(bars, TransactionType.Buy, OrderType.Limit, bars.Low[idx] - something * 2);

                        PlaceTrade(bars, TransactionType.Sell, OrderType.MarketClose, signalName: "sellCloseMarketclose_candleCLose");

                        PlaceTrade(bars, TransactionType.Sell, OrderType.MarketClose, signalName: "sellCloseMarketclose_candleCLose");

                        PlaceTrade(bars, TransactionType.Sell, OrderType.MarketClose, signalName: "sellCloseMarketclose_candleCLose");
}

So maybe it's because same bar exit is a question of adding new feature still?

I gave you a piece of code, I need to stop guessing)).

your code is placing 3 buys and 3 sells per symbol. assuming you’re using the method i provided to keep the top 5 entries, it makes sense that you’re seeing 5 buys and a ton of sells. that’s what your code is doing 🤷🏼‍♂️

So how can I operate withing the same bar without closing positions that were not opened?

Thanks, Glitch, I got the idea.

@mjj3
Re: Pre/Post Execute
If you're filtering in PreExecute, it's because you're also creating the trades there and most likely not using Execute. In the case show above, trades are created in Execute (run once for each symbol) and then the list of existing orders are managed in PostExecute, which is run once each bar after all symbols have finished Execute.

QUOTE:
But note that the exit signals will all be zero quantity. This is because you're placing a buy and a sell on the same bar. So, the sell does not yet have any pre-existing position on which to base its quantity on.

So is it "the same bar exit" 's problem inly?

Looks like same bar exit is a little bit unnatural for WL7. I better not use one, right? I will not have this exit signals quantity issut if exiting after current bar, right?

It shoudn't be a problem in backtesting, WL7 will match the exit to the position because it processes MarketClose orders last. But for trading, how can WL7 know what quantity to assign if the position isn't created yet? I guess we could get clever and look at the other entry orders in this case for a match, which is possible future enhancement?

Yes, you can do it smart, I tried to do something like that in my library. I guess the main problem is how to trigger those closing orders?

Now if my strategy enters and exits on the same bar, the strategy generates entering and exiting signals at the same moment. So opening a position must trigger closing logic or like that.