One-Percent-a-Week-Strategy

CODE:
            double target = LastOpenPosition.EntryPrice;
            if (LastOpenPosition.ProfitAsOf(idx) > -0.5)

CODE:
            double target = LastOpenPosition.EntryPrice;
            if (LastOpenPosition.ProfitPctAsOf(idx) > -0.5)

QUOTE:
The first exit order is calculated after market close of Monday and placed for Tuesday.

CODE:
         if (HasOpenPosition(bars, PositionType.Long))
         {

......

}

QUOTE:
Backtesting holding TQQQ out performs this strategy

QUOTE:
Because of the way it's coded, it doesn't generate signals like most Strategies

CODE:
using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
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)
        {
         bool isNextBarStartOfWeek = _lastBarofWeek == idx;
         bool isNextBarLastDayOfWeek = bars.TomorrowIsLastTradingDayOfWeek(idx);
         if (isNextBarLastDayOfWeek)
            _lastBarofWeek = idx + 1;

         if (isNextBarStartOfWeek)
         SetBackgroundColor(bars, idx + 1, WLColor.Silver.SetAlpha(32));

         if (isNextBarStartOfWeek)
         {
            if (idx >= bars.Count - 1)
               return;
            mondayOpen = bars.Open[idx + 1];
            tradedThisWeek = false;
         }

         if (HasOpenPosition(bars, PositionType.Long))
         {
         double target = LastOpenPosition.EntryPrice;
         if (LastOpenPosition.ProfitPctAsOf(idx) > -0.5)
               target = target * 1.01;
            PlaceTrade(bars, TransactionType.Sell, OrderType.Limit, target);
            if (isNextBarLastDayOfWeek)
            {
               PlaceTrade(bars, TransactionType.Sell, OrderType.MarketClose);
            }
         }
         else
         {
            if (!Double.IsNaN(mondayOpen) && !tradedThisWeek)
            {
               double mult = 0.99;
               PlaceTrade(bars, TransactionType.Buy, OrderType.Limit, mondayOpen * mult);
               if (isNextBarLastDayOfWeek)
               {
                  PlaceTrade(bars, TransactionType.Sell, OrderType.MarketClose);
               }
            }
         }
        }

      //same bar exit
        public override void AssignAutoStopTargetPrices(Transaction t, double basisPrice, double executionPrice)
        {
         //t.AutoProfitTargetPrice = executionPrice * 1.01;
         tradedThisWeek = true;
        }

        //declare private variables below
        private double mondayOpen = Double.NaN;
      bool tradedThisWeek = false;
      int _lastBarofWeek = -1;
    }
}

QUOTE:
It will not generate a signal because it peeks ahead one bar to look at Monday’s open price.

QUOTE:
Here's a version that can give you a Signal for all days except Monday.

CODE:
See revision in Post #43

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

namespace WealthScript6 
{
    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)
        {
         // assumes run on TQQQ
         _rsiT = RSI.Series(bars.Close, 14);

         _sqqq = GetHistory(bars, "SQQQ");
         PlotBarHistory(_sqqq, "SQQQ");
         
         _rsiS = RSI.Series(_sqqq.Close, 14);
         _tradeBars = 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)
        {
         bool isNextBarStartOfWeek = _lastBarofWeek == idx;
         bool isNextBarLastDayOfWeek = bars.TomorrowIsLastTradingDayOfWeek(idx);
         if (isNextBarLastDayOfWeek)
            _lastBarofWeek = idx + 1;

         if (isNextBarStartOfWeek)
         SetBackgroundColor(bars, idx + 1, WLColor.Silver.SetAlpha(32));

         if (isNextBarStartOfWeek)
         {
            if (idx >= bars.Count - 1)
               return;
            _tradeBars = _rsiT[idx] < _rsiS[idx] ? bars : _sqqq;
            mondayOpen = _tradeBars.Open[idx + 1];
            tradedThisWeek = false;
         }

         Position pos = FindOpenPositionAllSymbols(42); 
         if (pos != null)
         {
            double target = pos.EntryPrice;
            if (pos.ProfitPctAsOf(idx) > -0.5)
               target = target * 1.01;
            PlaceTrade(_tradeBars, TransactionType.Sell, OrderType.Limit, target);
            if (isNextBarLastDayOfWeek)
            {
               PlaceTrade(_tradeBars, TransactionType.Sell, OrderType.MarketClose);
            }
         }
         else
         {   
            if (!Double.IsNaN(mondayOpen) && !tradedThisWeek)
            {
               double mult = 0.99;
               PlaceTrade(_tradeBars, TransactionType.Buy, OrderType.Limit, mondayOpen * mult, 42);
               if (isNextBarLastDayOfWeek)
               {
                  PlaceTrade(_tradeBars, TransactionType.Sell, OrderType.MarketClose);
               }
            }
         }
        }

      //same bar exit
        public override void AssignAutoStopTargetPrices(Transaction t, double basisPrice, double executionPrice)
        {
         //t.AutoProfitTargetPrice = executionPrice * 1.01;
         tradedThisWeek = true;
        }

        //declare private variables below
        private double mondayOpen = Double.NaN;
      bool tradedThisWeek = false;
      int _lastBarofWeek = -1;
      RSI _rsiT;
      RSI _rsiS;
      BarHistory _sqqq;
      BarHistory _tradeBars;
    }
}

CODE:
/* Entry only script for 1% down on Mondays - USE WITH 1-MINUTE INTRADAY BARS */
using WealthLab.Backtest;
using System;
using WealthLab.Core;

namespace WealthScript12
{
   public class BuyOnePercentDownFromOpenOnMonday : UserStrategyBase
   {
      public override void Initialize(BarHistory bars)
      {
         PlotStopsAndLimits(3);
      }


      public override void Execute(BarHistory bars, int idx)
      {
         if (bars.DateTimes[idx].Date != today || bars.DateTimes[idx].DayOfWeek != DayOfWeek.Monday)
            return;

         // Ensure Filter Pre/Post Market Data is checked!
         if (!HasOpenPosition(bars, PositionType.Long))
         {
            int firstBarToday = idx - bars.IntradayBarNumber(idx);
            PlaceTrade(bars, TransactionType.Buy, OrderType.Limit, bars.Open[firstBarToday] * 0.99);
         }
      }      

      DateTime today = DateTime.Now.Date;
   }
}

CODE:
/* Entry only script for 1% down on Mondays - USE WITH 1-MINUTE INTRADAY BARS */
/* Assign TQQQ to a market that opens at 09:29 EST */
using WealthLab.Backtest;
using System;
using WealthLab.Core;

namespace WealthScript5 
{
   public class BuyOnePercentDownFromOpenOnMonday : UserStrategyBase
   {
      public override void Initialize(BarHistory bars)
      {
         PlotStopsAndLimits(3);
      }


      public override void Execute(BarHistory bars, int idx)
      {
         if (bars.DateTimes[idx].Date != today || bars.DateTimes[idx].DayOfWeek != DayOfWeek.Monday)
            return;

         // Ensure Filter Pre/Post Market Data is checked!
         if (!HasOpenPosition(bars, PositionType.Long))
         {
            int firstBarToday = idx - bars.IntradayBarNumber(idx);
            if (bars.DateTimes[firstBarToday].TimeOfDay == ts0930)
            {
               // the first bar was the premarket bar ending at 0930. 
               // if the current bar doesn't equal firstBarToday, add one bar 
               if (idx > firstBarToday)
                  firstBarToday += 1;
            
               _limit = bars.Close[firstBarToday] * 0.99;
            }
            else
            {
               _limit = bars.Open[firstBarToday] * 0.99;
            }

            PlaceTrade(bars, TransactionType.Buy, OrderType.Limit, _limit);
         }
      }      

      DateTime today = DateTime.Now.Date;
      TimeSpan ts0930 = new TimeSpan(9, 30, 0);
      double _limit = 0;
   }
}

QUOTE:
Do I need to use a streaming provider?

CODE:
/* Entry only script for 1% down on the first session of the week - USE WITH 1-MINUTE INTRADAY BARS */
/* Assign TQQQ to a Market that opens at 09:29 EST (Tools > Markets & Symbols) */
using WealthLab.Backtest;
using System;
using WealthLab.Core;

namespace WealthScript1 
{
   public class BuyOnePercentDownFromOpenOnMonday : UserStrategyBase
   {
      public override void Initialize(BarHistory bars)
      {
         PlotStopsAndLimits(3);
      }


      public override void Execute(BarHistory bars, int idx)
      {
         if (!TodayIsFirstSessionOfTheWeek(bars, bars.DateTimes[idx]) || bars.DateTimes[idx].Date != DateTime.Now.Date)
         {
            SetBackgroundColor(bars, idx, WLColor.FromArgb(40, WLColor.Red)); 
            return;
         }

         // Ensure Filter Pre/Post Market Data is checked!
         if (!HasOpenPosition(bars, PositionType.Long))
         {
            int firstBarToday = idx - bars.IntradayBarNumber(idx);
            if (bars.DateTimes[firstBarToday].TimeOfDay == ts0930)      // the first bar was the premarket bar ending at 0930
            {               
               if (idx > firstBarToday)
               {
                  _limit = bars.Open[firstBarToday + 1] * 0.99;
               }
               else
               {
                  // use the close of the last premarket bar
                  _limit = bars.Close[firstBarToday] * 0.99;
               }
            }
            else                                           // the first bar was not a premarket bar
               _limit = bars.Open[firstBarToday] * 0.99;            

            PlaceTrade(bars, TransactionType.Buy, OrderType.Limit, _limit);
         }         
      }

      // pass the current date  to check with the bars
      public bool TodayIsFirstSessionOfTheWeek(BarHistory bars, DateTime dte)
      {
         if (!bars.Market.IsTradingDay(dte.Date))
            return false; 
         
         DayOfWeek dow = dte.DayOfWeek;
         do
         {
            dte = dte.AddDays(-1);            
            if (bars.Market.IsTradingDay(dte.Date))         
               return dow < dte.DayOfWeek;             
         }
         while (dte.Year > 1900); 
         return false; 
      }

      DateTime today = DateTime.Now.Date;
      TimeSpan ts0930 = new TimeSpan(9, 30, 0);
      double _limit = 0;
      bool _todayIsFirstSessionOfTheWeek; 
   }
}

CODE:
         bool isNextBarLastDayOfWeek = bars.TomorrowIsLastTradingDayOfWeek(idx);

QUOTE:

Cone's suggestion is to create a daily strategy to complement the one minute strategy he suggested for automating entry

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

namespace WealthScript6 
{
   public class OnePercentV3P : UserStrategyBase
   {
      public OnePercentV3P()
      {
         _maxDays = AddParameter("Max Days Hold", ParameterType.Int32, 5, 1, 5); 
         _useMOC = AddParameter("Use MOC = 1", ParameterType.Int32, 1, 0, 1); 
      }

      public override void Initialize(BarHistory bars)
      { }
   
      public override void Execute(BarHistory bars, int idx)
      { }
      
      public override void ExecuteSessionOpen(BarHistory bars, int idx, double sessionOpenPrice)
      {
         bool NextBarIsStartOfWeek = _lastBarofWeek == idx;
         bool NextBarIsLastDayOfWeek = bars.TomorrowIsLastTradingDayOfWeek(idx);
         if (NextBarIsLastDayOfWeek)
            _lastBarofWeek = idx + 1;

         if (idx - 1 == _lastBarofWeek)
            SetBackgroundColor(bars, idx, WLColor.Silver.SetAlpha(32));
         
         if (NextBarIsStartOfWeek)
         {
            mondayOpen = sessionOpenPrice;
            tradedThisWeek = false;
         }
         
         if (HasOpenPosition(bars, PositionType.Long))
         {
            double target = LastOpenPosition.EntryPrice;
            if (LastOpenPosition.ProfitPctAsOf(idx) > -0.5)
               target = target * 1.01;
         
            Backtester.CancelationCode = 642;    
            if (idx - LastOpenPosition.EntryBar + 1 >= _maxDays.AsInt)
            {
               ClosePosition(LastOpenPosition, _useMOC.AsInt == 1 ? OrderType.MarketClose : OrderType.Market, 0, "Time-based");
            }
               
            PlaceTrade(bars, TransactionType.Sell, OrderType.Limit, target);
         
            Backtester.CancelationCode = 642;
            if (idx < bars.Count - 1)
            {
               if (NextBarIsLastDayOfWeek)
                  PlaceTrade(bars, TransactionType.Sell, OrderType.MarketClose);
            }
            else
            {
               //last bar: if today is the last trading day of the week, signal MOC for the open position
               if (bars.TomorrowIsLastTradingDayOfWeek(idx))
                  PlaceTrade(bars, TransactionType.Sell, OrderType.MarketClose);
            }
         }
         else
         {
            if (!Double.IsNaN(mondayOpen) && !tradedThisWeek)
            {
               double mult = 0.99;
               PlaceTrade(bars, TransactionType.Buy, OrderType.Limit, mondayOpen * mult);
               if (NextBarIsLastDayOfWeek)
               {
                  Backtester.CancelationCode = 642; 
                  PlaceTrade(bars, TransactionType.Sell, OrderType.MarketClose);
               }
            }
         }
      }


        //same bar exit
        public override void AssignAutoStopTargetPrices(Transaction t, double basisPrice, double executionPrice)
      {
         //t.AutoProfitTargetPrice = executionPrice * 1.01;
         tradedThisWeek = true;
      }

      //declare private variables below
      private double mondayOpen = Double.NaN;
      bool tradedThisWeek = false;
      int _lastBarofWeek = -1;
      Parameter _maxDays; 
      Parameter _useMOC; 
   }
}

QUOTE:
I use the 1-minute strategy myself (modified for NQ futures). It works

CODE:
/* 
 * Modified 1% strategy for NQ Futures
 * 
 * Use with 1 minute chart
 */
using WealthLab.Backtest;
using System;
using WealthLab.Core;

namespace WealthScript2 
{
   public class BuyOnePercentDownFromOpenOnMondayNQ : UserStrategyBase
   {
      public BuyOnePercentDownFromOpenOnMondayNQ()
      {
         AddParameter("Dip %", ParameterType.Double, 0.3333330, 0.333333, 0.999999, 0.1666665);
         AddParameter("Loss %", ParameterType.Double, 0.1666665, 0.1666665, 0.999999, 0.1666665);          
      }

      public override void Initialize(BarHistory bars)
      {
         _pct = Parameters[0].AsDouble / 100.0;
         WriteToDebugLog(_pct);
         _lossPct = Parameters[1].AsDouble;

         if (!bars.Market.Name.Contains("830"))              // "NQ 0830" is modified market for a CME start at 0829
         {
            _openTime = new TimeSpan(9, 30, 0);
            _closeTime =  new TimeSpan(16, 0, 0);   
         }
         
         // find the beginning of the first week loaded - makes sure there's sufficient data to trade
         int bar = bars.Count - 1;
         DayOfWeek dowToday = bars.DateTimes[bar].DayOfWeek;
         do
         {
            bar = bar - bars.IntradayBarNumber(bar);
            if (bar == 0) break; 
            if (bars.DateTimes[bar - 1].DayOfWeek >= dowToday)
            {
               _firstBarThisWeek = bar;
            }
            bar--; 
         }
         while (bar > 0);
         
         StartIndex = _firstBarThisWeek; 
         PlotStopsAndLimits(3);         
      }

      
      public override void Execute(BarHistory bars, int idx)
      {   
         // must have identified a week's open 
         if (_firstBarThisWeek == -1   )
            return;
         DateTime dt = bars.DateTimes[idx];
         bool todayIsLastTradingDayOfWeek = dt.DayOfWeek > dt.GetNextTradingDate(bars).DayOfWeek;

         // ignore Sunday!
         if (bars.DateTimes[idx].DayOfWeek == DayOfWeek.Sunday)
            return; 
         
         if (bars.DateTimes[idx].DayOfWeek < bars.DateTimes[idx - 1].DayOfWeek)
         {
            _firstBarThisWeek = idx;        // new week just started
            _tradedThisWeek = false; 
            
            if (bars.DateTimes[idx].TimeOfDay == _openTime)
            {
               _openThisWeek = bars.Close[idx];
               _firstBarThisWeek = idx + 1;         // first regular session bar
               
            }
            else
            {               
               _openThisWeek = bars.Open[idx];
               _firstBarThisWeek = idx;
            }
         }
         else
         {
            _openThisWeek = bars.Open[_firstBarThisWeek];
         }

         _limit = (1 - _pct) * _openThisWeek;

         // draw a line from this week's opening price
         if (idx == bars.Count - 1 && _firstBarThisWeek < idx)
         {
            DrawLine(_firstBarThisWeek, _openThisWeek, idx, _openThisWeek, WLColor.Orange, 2, LineStyle.Dashed);            
         }

         
         if (!HasOpenPosition(bars, PositionType.Long))
         {
            if (!_tradedThisWeek)
            {
               if (bars.DateTimes[idx].TimeOfDay < _closeTime)
                  PlaceTrade(bars, TransactionType.Buy, OrderType.Limit, _limit);
            }
         }
         else
         {   
            Position pos = LastPosition;
            double profitpct = 100 * (bars.Close[idx] / pos.EntryPrice - 1);

            // check profit at the end of the day to adjust limit price to break even, if required
            if (bars.IsLastBarOfDay(idx))
            {   
               if (profitpct < -_lossPct)
                  _target = pos.EntryPrice;
            }

            //sell on the open of the last bar of the week
            if (todayIsLastTradingDayOfWeek && bars.DateTimes[idx].TimeOfDay >= _closeTime)
            {
               ClosePosition(pos, OrderType.Market);
            }
            else 
            {
               // exit at limit only on a subsequent day
               if (bars.DateTimes[idx].Date != bars.DateTimes[pos.EntryBar].Date || bars.IsLastBarOfDay(idx))
               {
                  string msg = "EntryPrice: " + pos.EntryPriceString;
                  ClosePosition(pos, OrderType.Limit, _target, msg);
                  
                  if (idx == bars.Count - 1)
                     DrawHeaderText(msg, WLColor.Aqua, 14, "Price");
               }
            }
         }
      }

        public override void AssignAutoStopTargetPrices(Transaction t, double basisPrice, double executionPrice)
        {
         _tradedThisWeek = true;
         _target = executionPrice * (1 + _pct);
        }


      double _pct = 0.01 / 3.0;
      double _lossPct = 0.5 / 3.0;
        double _limit;
      double _target;
      int _firstBarThisWeek = -1;
      double _openThisWeek = 0;
      bool _tradedThisWeek = false;
      TimeSpan _closeTime = new TimeSpan(15, 0, 0);      
      TimeSpan _openTime = new TimeSpan(8, 30, 0);      
   }
}

CODE:
   // One Percent Per Week v3  Original version Glitch (Dion)
   // Mods By Guy Fleury. v5. May 2024
   // 7%-8% profit target + positive stance
   using WealthLab.Backtest;
   using System;
   using WealthLab.Core;
   using WealthLab.Indicators;
   using System.Collections.Generic;
   
   namespace WealthScript1 
   {
      public class OnePercentV3 : UserStrategyBase
      {
         public override void Initialize(BarHistory bars)
         { }
      
         public override void Execute(BarHistory bars, int idx)
         { }
         
         public override void ExecuteSessionOpen(BarHistory bars, int idx, double sessionOpenPrice)
         {
            bool NextBarIsStartOfWeek = _lastBarofWeek == idx;
            bool NextBarIsLastDayOfWeek = bars.TomorrowIsLastTradingDayOfWeek(idx);
            if (NextBarIsLastDayOfWeek)
               _lastBarofWeek = idx + 1;

            if (idx - 1 == _lastBarofWeek)
               SetBackgroundColor(bars, idx, WLColor.Silver.SetAlpha(32));
            
            if (NextBarIsStartOfWeek)
            {
               mondayOpen = sessionOpenPrice;
               tradedThisWeek = false;
            }
            
            if (HasOpenPosition(bars, PositionType.Long))
            {
               double target = LastOpenPosition.EntryPrice;
            if (LastOpenPosition.ProfitPctAsOf(idx) > 0.0) 
            {
               target = target * 1.07;  
               if (LastOpenPosition.ProfitPctAsOf(idx) > 0.3)
               { 
                  target = target * 1.011;  
               }
               
            }
               Backtester.CancelationCode = 642;    
               PlaceTrade(bars, TransactionType.Sell, OrderType.Limit, target);
            
               Backtester.CancelationCode = 642;
               if (idx < bars.Count - 1)
               {
                  if (NextBarIsLastDayOfWeek)
                     PlaceTrade(bars, TransactionType.Sell, OrderType.MarketClose);
               }
               else
               {
                  //last bar: if today is the last trading day of the week, signal MOC for the open position
                  if (bars.TomorrowIsLastTradingDayOfWeek(idx))
                     PlaceTrade(bars, TransactionType.Sell, OrderType.MarketClose);
               }
            }
            else
            {
               if (!Double.IsNaN(mondayOpen) && !tradedThisWeek)
               {
                  double mult = 1.001; 
                  PlaceTrade(bars, TransactionType.Buy, OrderType.Limit, mondayOpen * mult);
                                    
                  if (NextBarIsLastDayOfWeek)
                  {
                     Backtester.CancelationCode = 642; 
                     PlaceTrade(bars, TransactionType.Sell, OrderType.MarketClose);
                  }
               }
               else
                { //place trade here if
                }
            }
         }
   
   
           //same bar exit
           public override void AssignAutoStopTargetPrices(Transaction t, double basisPrice, double executionPrice)
         {
            //t.AutoProfitTargetPrice = executionPrice * 0.99;
            tradedThisWeek = true;
         }
   
         //declare private variables below
         private double mondayOpen = Double.NaN;
         bool tradedThisWeek = false;
         int _lastBarofWeek = -1;
      }
   }