Robot Example 4 – Range Breakout

Prompted by the Forex Espionage "Advanced" System here is a robot based around a range breakout system.  It is a much simplified version of the original Turtle Trading system provided to his students by Richard Dennis way back in 1984.  It enters a trade on a breakout from the range of a number of consecutive bars.  It then exits the trade on a breakout in the opposite direction from the range of a smaller number of bars.

To get an initial feel for the system used by the legendary Turtle Traders try out this expert advisor using daily bars and the default input settings with the Long Period set to 55 and the Short Period set to 20.   You may also wish to try other timeframes and other input settings.  Does this type of system show any promise for day trading, for example?

Since this example is for a long term trend following system our initial backtests cover a long period of time! Here are the results from the MetaTrader 4 strategy tester starting on January 1st 2000, using the EUR/USD pair and the default input settings with daily bars:

Here's the source code for this "robot":

//+------------------------------------------------------------------+

//|                                                     GuruEx04.mq4 |

//|     Copyright © 2009, Marketing Dreams Ltd. All Rights Reserved. |

//|                                         http://trading-gurus.com |

//|                                                                  |

//| GuruTrader™ example 4                                            |

//| Version 1.0                                                      |

//|                                                                  |

//| A basic range breakout system                                    |

//| Based on the original Turtle Trading system                      |

//|                                                                  |

//| Wealth Warning! This expert is for educational purposes only.    |

//| It should NEVER be used on a live account. Past performance is   |

//| in no way indicative of future results!                          |

//+------------------------------------------------------------------+

#property copyright "Copyright © 2009, Marketing Dreams Ltd."

#property link      "http://trading-gurus.com"

#define SLEEP_OK     250
#define SLEEP_ERR    250

//---- input parameters
extern int     Magic = 12348;
extern int     Slippage=30;
extern double  Lots=0.1;
extern int     LongPeriod=55;
extern int     ShortPeriod=20;
//---- static variables
static int     Dig;
static double  Points;

static bool    Initialized = FALSE;
static bool    Running = FALSE;
static bool    Long = FALSE;
static double  LongMax;
static double  LongMin;
static double  ShortMax;
static double  ShortMin;
static int     LastBar;
static int     OrderNumber;
static double  PositionSize;

static color   clBuy = DodgerBlue;
static color   clSell = Crimson;

//+------------------------------------------------------------------+
//| Utility functions                                                |
//+------------------------------------------------------------------+
#include <stdlib.mqh>
#include <stderror.mqh>
#include <WinUser32.mqh>

//+------------------------------------------------------------------+
//| Expert helper functions                                          |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Closes an order at market                                        |
//+------------------------------------------------------------------+
int CloseMarket(int Ticket)
{
   int    Type, ErrorCode;
   double Price, Quantity;

   OrderSelect(Ticket, SELECT_BY_TICKET);
   Type = OrderType();

   Quantity = OrderLots();

   while (TRUE) {             // Keep trying until the order really is closed
      if (Type == OP_BUY)
         Price=Bid;
      else if (Type == OP_SELL)
         Price=Ask;
      else
         return (-1);
      Print("CLOSE ", Ticket, ", ", Quantity, ", ", Price);
      if (OrderClose(Ticket, Quantity, Price, Slippage, CLR_NONE) == TRUE) {
         Sleep(SLEEP_OK);
         return (0);
      }
      else {
         ErrorCode = GetLastError();
         Print("Error closing order ", Ticket, ": ", ErrorDescription(ErrorCode),
               " (", ErrorCode, ")", " size: ", Quantity, ", prices: ",
               Price, ", ", Bid, ", ", Ask);
         Sleep(SLEEP_ERR);
         RefreshRates();
      }
   }
   return (-1);
}

//+------------------------------------------------------------------+
//| Places an order                                                  |
//+------------------------------------------------------------------+
int Order(string symbol, int Type, double Entry, double Quantity,
          double TargetPrice, double StopPrice, string comment="")
{
   string TypeStr;
   color  TypeCol;
   int    ErrorCode, Ticket;
   double Price, FillPrice;

   Price = NormalizeDouble(Entry, Dig);

   switch (Type) {
      case OP_BUY:
         TypeStr = "BUY";
         TypeCol = clBuy;
         break;
      case OP_SELL:
         TypeStr = "SELL";
         TypeCol = clSell;
         break;
      default:
         Print("Unknown order type ", Type);
         break;
   }

   Ticket = OrderSend(symbol, Type, Quantity, Price, Slippage,
              StopPrice, TargetPrice, comment, Magic, 0, TypeCol);
   if (Ticket >= 0) {
      Sleep(SLEEP_OK);
      if (OrderSelect(Ticket, SELECT_BY_TICKET) == TRUE) {
         FillPrice = OrderOpenPrice();
         if (Entry != FillPrice) {
            RefreshRates();
            Print("Slippage on order ", Ticket, " - Requested = ",
                  Entry, ", Fill = ", FillPrice, ", Current Bid = ",
                  Bid, ", Current Ask = ", Ask);
         }
      }
      else {
         ErrorCode = GetLastError();
         Print("Error selecting new order ", Ticket, ": ",
               ErrorDescription(ErrorCode), " (", ErrorCode, ")");
      }
      return (Ticket);
   }

   ErrorCode = GetLastError();
   RefreshRates();
   Print("Error opening ", TypeStr, " order: ", ErrorDescription(ErrorCode),
         " (", ErrorCode, ")", ", Entry = ", Price, ", Target = ",
         TargetPrice, ", Stop = ", StopPrice, ", Current Bid = ", Bid,
         ", Current Ask = ", Ask);
   Sleep(SLEEP_ERR);

   return (-1);
}

//+------------------------------------------------------------------+
//| Calculates Long & Short period ranges                            |
//+------------------------------------------------------------------+
void CalcRanges()
{
   int Index;

   Index = ArrayMaximum(High, LongPeriod);
   LongMax = High[Index];
   Index = ArrayMinimum(Low, LongPeriod);
   LongMin = Low[Index];

   Index = ArrayMaximum(High, ShortPeriod);
   ShortMax = High[Index];
   Index = ArrayMinimum(Low, ShortPeriod);
   ShortMin = Low[Index];

   LastBar = Bars;
}

//+------------------------------------------------------------------+
//| Performs system initialisation                                   |
//+------------------------------------------------------------------+
void InitSystem()
{
   Running = FALSE;

   PositionSize = Lots;

   RefreshRates();

   CalcRanges();

   Print("Entry Levels - Upper = ", LongMax, ", Lower = ", LongMin,
         ". Exit Levels - Upper = ", ShortMax, ", Lower = ", ShortMin);

   Initialized = TRUE;
}

//+------------------------------------------------------------------+
//| Checks for entry to a trade                                      |
//+------------------------------------------------------------------+
int CheckEntry(double Size)
{
   if (Bid > LongMax) {
      // Broken out higher so GO LONG!
      if (OrderNumber > 0)
         CloseMarket(OrderNumber);  // Close previous short order
      OrderNumber = Order(Symbol(), OP_BUY, Ask, Size, 0, 0);
      if (OrderNumber > 0) {
         Long = TRUE;
         return(1);
      }
   }
   else if (Bid < LongMin) {
      // Broken out lower so GO SHORT!
      if (OrderNumber > 0)
         CloseMarket(OrderNumber);  // Close previous long order
      OrderNumber = Order(Symbol(), OP_SELL, Bid, Size, 0, 0);
      if (OrderNumber > 0) {
         Long = FALSE;
         return(1);
      }
   }
   return(0);
}

//+------------------------------------------------------------------+
//| Checks for exit from a trade                                     |
//+------------------------------------------------------------------+
int CheckExit()
{
   int ErrorCode;

   if (Long && (Bid < ShortMin)) {
      CloseMarket(OrderNumber);  // Close long order
      if (OrderSelect(OrderNumber, SELECT_BY_TICKET) != TRUE) {
         ErrorCode = GetLastError();
         Print("Error selecting order ", OrderNumber, ": ", ErrorDescription(ErrorCode), " (", ErrorCode, ")");
         return(-1);
      }
      Print("Order ", OrderNumber, " closed: ", OrderClosePrice(), ", at ", TimeToStr(OrderCloseTime()), ". Profit = ", OrderProfit());
      return(1);
   }
   if (!Long && (Bid > ShortMax)) {
      CloseMarket(OrderNumber);  // Close short order
      if (OrderSelect(OrderNumber, SELECT_BY_TICKET) != TRUE) {
         ErrorCode = GetLastError();
         Print("Error selecting order ", OrderNumber, ": ", ErrorDescription(ErrorCode), " (", ErrorCode, ")");
         return(-1);
      }
      Print("Order ", OrderNumber, " closed: ", OrderClosePrice(), ", at ", TimeToStr(OrderCloseTime()), ". Profit = ", OrderProfit());
      return(1);
   }
   else {
      return(0);
   }
}

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
{
   Dig = MarketInfo(Symbol(), MODE_DIGITS);
   Points = MarketInfo(Symbol(), MODE_POINT);

   Print("Digits = ", Dig, ", Points = ", DoubleToStr(Points, 5));

   if (!IsDemo() && !IsTesting()) {
      MessageBox("Wealth Warning! This expert is for educational purposes only." +
            " It should NEVER be used on a live account." +
            " Past performance is in no way indicative of future results!");
      Print("Initialization Failure");
      return(-1);
   }

   if (ShortPeriod >= LongPeriod) {
      Print("Error - ShortPeriod must be less than LongPeriod.");
      return(-1);
   }

   InitSystem();

   Print("Initialized OK");

   return(0);
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
{
    Print("DeInitialized OK");

    return(0);
}

//+------------------------------------------------------------------+
//| Expert start function                                            |
//| Executed on every tick                                           |
//+------------------------------------------------------------------+
int start()
{
   if (!Initialized) {
      return(-1);
   }

   if (Bars > LastBar)
     CalcRanges();

   if (Running) {                         // Are we in a trade at the moment?
      if (CheckExit() > 0) {              // Yes - Last trade complete?
         Initialized = FALSE;             // Yes - Indicate we need to reinitialise,
         OrderNumber = 0;                 //  indicate no open order any more
         InitSystem();                    //  and start all over again!
      }
   }
   else if (CheckEntry(PositionSize) > 0) { // Entered a trade?
      Running = TRUE;                       // Yes - Indicate that we're in a trade
   }

   return(0);
}

You can also download the source code here.