Stop-and-Reverse-from-EasyLanguage-to-WL7

Creating a SAR type of system is not very complex in WL7 code:

https://www.wealth-lab.com/Discussion/Reverse-into-short-position-at-market-close-6914
https://www.wealth-lab.com/Discussion/Stop-and-Reverse-not-working-as-expected-6950

I guess the answer is no you don't have a feature to automatically close existing positions when reversing the trade.

I get how to code a SAR in WL, but those examples show how a simple strategy can result in a lot of code. A more complex strategy with protective stops that are expected to reverse could get confusing.

It just seemed like a nice feature to have for those wishing to write SAR strategies. If I converted the EasyLanguage code to WL without adding the appropriate closing trades, there'd be a lot of dangling positions causing NSFs.

If Dion agrees to it you could create a feature request for this?

No need. I realized after backtesting it may appear "easy" to only code the entry trades and have the exit trades done automatically, it didn't always produce the desired results. It was better for the strategy author to have control of the exit trades too.

Let's just take one line of the earlier example...

QUOTE:
If Trigger Crosses Over MA then Buy Next Bar at Close - 0.35*(High-Low) Limit;

After crossing over a MA this strategy is looking for a pullback to get in. But what if it is so bullish that it gaps up -- it will not buy due to the limit price. With a SAR I will most likely have an open short position. If covering the short is contingent on the buy execution, you could be left in a short position that you needed to exit. This happened numerous times when I wrote the cover trade similar to the buy. It was better to cover at market to ensure I exited the short position and then let the buy trade go unexecuted. Probably not a true SAR, but safer than the original code implied.

So I realized the way WL7 works now is fine with me. This was just an exercise in a book I was trying to see how it backtested. I got my answer.

Edit -
I changed the code above to let you enter the OrderType you want to use, Stop or Limit, when a price parameter is passed.

QUOTE:
It's not really clear how the Easy Language code should work.

I agree. The book I was reading had only the script for entering positions, so I assumed the script would automatically generate exit trades when the enter trades were executed. SAR may not have been the correct term to use as it wasn't a stop and reverse.

I did not provide the complete strategy in Post #1. There were protective stops in the script as well which made it more complicated. I was getting stopped out on a short position causing a buy long trade and then cross over the MA causing another buy long. That caused an NSF position (sizing was 80% of equity) until I added code to check if I already had a long position open when I had a cross over. Designing how I wanted the script to work in WL7 seemed too complicated. I found myself with more questions than answers. It was better to leave the strategy author with providing the details.

This is how I pictured a method to specify only the enter trades for SAR strategies...

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

namespace WealthScript
{
    public class SAR_Crossover : UserStrategyBase
    {
      public Parameter _spUseStops;

      public SAR_Crossover()
      {
         _spUseStops = AddParameter("Use Stops", ParameterTypes.Int32, 0, 0, 1, 1);
      }
      
        //create indicators and other objects here, this is executed prior to the main trading loop
        public override void Initialize(BarHistory bars)
        {
         _MaShort = EMA.Series(bars.Close, 12);
         _MaLong = EMA.Series(bars.Close, 26);

         PlotTimeSeriesLine(_MaShort, _MaShort.Description, "Price", Color.Orange, 1, LineStyles.Solid);
         PlotTimeSeriesLine(_MaLong, _MaLong.Description, "Price", Color.Red, 1, LineStyles.Solid);
      }

        //execute the strategy rules here, this is executed once for each bar in the backtest history
        public override void Execute(BarHistory bars, int idx)
        {
         bool UseStops = (_spUseStops.AsInt != 0 ? true : false);
         
            if (_MaShort.CrossesOver(_MaLong, idx) )
            {
            if (UseStops)
            {
               double StopPrice = bars.Close[idx] + 0.35 * (bars.High[idx] - bars.Low[idx]);
               PlaceSARTrade(bars, TransactionType.Buy, OrderType.Stop, StopPrice, "Go Long w/ Stop");
            }
            else
            {
               PlaceSARTrade(bars, TransactionType.Buy, OrderType.Market, 0.0, "Go Long");
            }
         }
            else if (_MaShort.CrossesUnder(_MaLong, idx))
            {
            if (UseStops)
            {
               double StopPrice = bars.Close[idx] - 0.35 * (bars.High[idx] - bars.Low[idx]);
               PlaceSARTrade(bars, TransactionType.Short, OrderType.Stop, StopPrice, "Go Short w/ Stop");
            }
            else
            {
               PlaceSARTrade(bars, TransactionType.Short, OrderType.Market, 0.0, "Go Short");
            }
         }
        }

      public Transaction PlaceSARTrade(BarHistory bars, TransactionType transType, OrderType orderType, Double price, String signalName)
      {
         Transaction openTransaction = null;

         // Only do a reverse trade when entering positions
         if ( transType == TransactionType.Buy || transType == TransactionType.Short)
         {
            // Exit transaction should be opposite position
            TransactionType exitTransType = (transType == TransactionType.Buy ? TransactionType.Cover : TransactionType.Sell);

            if (HasOpenPosition(bars, (exitTransType == TransactionType.Sell ? PositionType.Long : PositionType.Short)))
            {
               PlaceTrade(bars, exitTransType, orderType, price, signalName);
            }
         }

         openTransaction = PlaceTrade(bars, transType, orderType, price, signalName);

         return openTransaction;
      }

      TimeSeries _MaShort;
      TimeSeries _MaLong;
   }
}

I ran backtest using single symbol SPY. If you run this as a Market order, it seems to run fine ("Use Stops" parameter as zero). Once you run this using stop or limit orders, then you end up with dangling positions that should have been closed and a lot of NSF positions. That's when I realized it's not as simple to just specify the enter positions and expect the exit positions to close properly.

Adding a boolean ExitAsMarketOrder helped fix the problem...

CODE:
      public Transaction PlaceSARTrade(BarHistory bars, TransactionType transType, OrderType orderType, double price = 0.0, string signalName = "", bool ExitAsMarketOrder = false)
      {
         Transaction OpenTransaction = null;

         // Only do a reverse trade when entering positions
         if ( transType == TransactionType.Buy || transType == TransactionType.Short)
         {
            // Exit transaction should be opposite position
            TransactionType ExitTransType = (transType == TransactionType.Buy ? TransactionType.Cover : TransactionType.Sell);

            if (HasOpenPosition(bars, (ExitTransType == TransactionType.Sell ? PositionType.Long : PositionType.Short)))
            {
               OrderType ExitOrderType = orderType;
               double ExitPrice = price;
               if (ExitAsMarketOrder)
               {
                  ExitOrderType = OrderType.Market;
                  ExitPrice = 0.0;
               }
               PlaceTrade(bars, ExitTransType, ExitOrderType, ExitPrice, signalName);
            }
         }

         OpenTransaction = PlaceTrade(bars, transType, orderType, price, signalName);

         return OpenTransaction;
      }

Now just set the boolean to true when placing stop or limit orders and it should close the position.

There may still be issues with the times when two moving averages touch and pull away. I think that can trigger a trade that could double your position.