Robot Example 2 – Martingale Money Management

This example adds Martingale-style position sizing to example 1, as NOT recommended by the Forex MegaDroid team!

Note that we have changed the default Profit Target and Stop Loss settings from the values used in example 1. If you plug these numbers into example 1 you will see that this results in that system losing money. Note also that adding position sizing to a losing system can turn it into a winning system. Imagine what a suitable position sizing method can do for a winning system. As long as you can survive the drawdowns, that is!

Here are the results from the MetaTrader strategy tester (but with the list of trades shortened):

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

//+------------------------------------------------------------------+
//|                                                     GuruEx02.mq4 |
//|     Copyright © 2009, Marketing Dreams Ltd. All Rights Reserved. |
//|                                         http://trading-gurus.com |
//|                                                                  |
//| GuruTrader™ example 2                                            |
//| Version 1.10                                                      |
//|                                                                  |
//| Adds Martingale style position sizing to example 1               |
//|                                                                  |
//| 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!                          |
//+------------------------------------------------------------------+
//+ Revision History                                                 +
//+                                                                  +
//+ 1.10 - May 21st 2009                                             +
//+        Added display of stop level.                              +
//+        Added support for STP mode.                               +
//+        Gets around a "feature" of Boston Technologies FIFO       +
//+        implementation which rejects market orders with non-zero  +
//+        stop-loss/take-profit levels.                             +
//+------------------------------------------------------------------+
#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 = 12346;
extern int     Slippage = 30;
extern int     ProfitTarget = 100;
extern int     StopLoss = 1000;
extern double  Lots = 0.1;
extern bool    StpMode = TRUE;

//---- static variables
static int     Dig;
static int     Stops;
static double  Points;
static double  ProfitPerPip;

static bool    Initialized = FALSE;
static bool    Running = FALSE;
static int     OrderNumber;
static double  PositionSize;
static double  LastBid;
static double  LastAsk;

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

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

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

//+------------------------------------------------------------------+
//| Calculates a Martingale style position size                      |
//+------------------------------------------------------------------+
double MartingaleSize()
{
   int Index, Size;
   double Loss;

   Size = 1;
   Loss = 0;

   for (Index = OrdersHistoryTotal() - 1; Index >= 0; Index--) {
      OrderSelect(Index, SELECT_BY_POS, MODE_HISTORY);
      if ((OrderSymbol() == Symbol()) && (OrderMagicNumber() == Magic)) {
         if (OrderProfit() <= 0) {
            Loss = Loss - OrderProfit();  // Add up our previous losses
            Size = 1 + MathRound(0.5 + Loss / (ProfitPerPip * Lots * ProfitTarget));
         }
         else {
            break;                        // Found a profitable trade, so we're all done
         }

      }
   }
   Print("Loss = ", Loss, ", Size = ", Size);
   return (Lots * Size);
}

//+------------------------------------------------------------------+
//| 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;
   }

   if (StpMode) {
      Ticket = OrderSend(symbol, Type, Quantity, Price, Slippage,
               0, 0, comment, Magic, 0, TypeCol);
   }
   else {
      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);
         }
         if (StpMode && ((StopPrice > 0) || (TargetPrice > 0))) {
            if (OrderModify(Ticket, FillPrice, StopPrice, TargetPrice, 0, TypeCol)) {
               Sleep(SLEEP_OK);
               return (Ticket);
            }
   	   }
      }
      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);
}

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

   PositionSize = MartingaleSize();

   RefreshRates();
   LastBid = Bid;
   LastAsk = Ask;

   Initialized = TRUE;
}

//+------------------------------------------------------------------+
//| Checks for entry to a trade                                      |
//+------------------------------------------------------------------+
int CheckEntry(double Size)
{
   if (Ask > LastAsk) {  // Short term uptrend so GO LONG!
      OrderNumber = Order(Symbol(), OP_BUY, Ask, Size, Ask + (Points * ProfitTarget), Bid - (Points * StopLoss));
      if (OrderNumber > 0)
         return(1);
   }
   else if (Bid < LastBid) {  // Short term downtrend so GO SHORT!
      OrderNumber = Order(Symbol(), OP_SELL, Bid, Size, Bid - (Points * ProfitTarget), Ask + (Points * StopLoss));
      if (OrderNumber > 0)
         return(1);
   }
   return(0);
}

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

   if (OrderSelect(OrderNumber, SELECT_BY_TICKET) != TRUE) {
      ErrorCode = GetLastError();
      Print("Error selecting order ", OrderNumber, ": ", ErrorDescription(ErrorCode), " (", ErrorCode, ")");
      return(-1);
   }
   else if (OrderCloseTime() > 0) {
      Print("Order ", OrderNumber, " closed: ", OrderClosePrice(), ", at ", TimeToStr(OrderCloseTime()));
      return(1);
   }
   else {
      return(0);
   }
}

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
{
   Dig = MarketInfo(Symbol(), MODE_DIGITS);
   Points = MarketInfo(Symbol(), MODE_POINT);
   Stops = MarketInfo(Symbol(), MODE_STOPLEVEL);
   ProfitPerPip = 100000 / MathPow(10, Dig);

   Print("Profit per pip per lot = ", ProfitPerPip, ", Stops = ", Stops, ", 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);
   }

   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);
   }
   else 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
         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.