IlanTree

Mutual Exclusion (Mutex) Implementation in MQL4

2019-02-05T11:18:00.000+01:00

Introduction

In computer science, mutual exclusion is a property of concurrency control, which is instituted for the purpose of preventing race conditions; it is the requirement that one thread of execution never enters its critical section at the same time that another concurrent thread of execution enters its own critical section.

In Algotrading, you may encounter this situation while:

Running several expert advisers using a shared object which may worked on only once and not in parallel.
Trading only in certain conditions, for example allowing only one expert adviser to open a position while the other ones are blocked.

In my case, I am running several expert advisers on the same account trading different currencies. But, I wanted to have only one product open at a given moment while the others are blocked. So, if for example both EURUSD & EURJPY have the right conditions to open an order, only one order will be open. I wanted to avoid to be double exposed to products which are correlated between them, but there could be many other reasons to prevent it.

Implementation

MQL4 language supports global variables which may use as the lock mechanism to prevent parallel execution of the same code and / or accessing a shared object.

We start by declaring the Mutex variable as:

#define MUTEX "Mutex"

Also, we declare two constants which hold the different Mutex status, locked / unlocked:
#define LOCKED 1 #define UNLOCKED 0

We will use this variable and the different status throughout the code to make sure certain code parts are not accessed in parallel, but first, we need to initialize it in the OnInit() function:
if(GlobalVariableSet(MUTEX,UNLOCKED)==0) { Log("OnInit Mutex GlobalVariableSet failed",true,GetLastError()); return INIT_FAILED; }
This code initializes the Mutex to unlocked status.

Then, throughout the execution, whenever we have a certain code we want to lock, we will add the following condition:

&& GlobalVariableSetOnCondition(MUTEX,LOCKED,UNLOCKED) &&

As per the function definition, the unction provides atomic access to the global variable, so it can be used for providing of a Mutex at interaction of several Expert Advisors working simultaneously within one client terminal.

As soon as the critical code is over, add the following piece of code to release the Mutex:

GlobalVariableSetOnCondition(MUTEX,UNLOCKED,LOCKED);

With this simple utility, you can ensure that the critical part is not executed in parallel, as the first thread / expert adviser will get the lock while the others will not be able to enter this block of code until the mutex is locked.

Concrete Example

As part of my trading, I am interested to know whenever the balance changed due to a profit / loss. As I run several expert advisers on the same account, so I don't want to get notified X times about balance change, rather once as this is a shared value.

Mutual exclusion solves exactly that problem as the balance value is a shared value among the different expert advisers. To implement that, I created a global variable to hold the balance value:

const string BALANCE="Balance";

I initialize it with the current value in the OnInit() function:
if(GlobalVariableSetOnCondition(MUTEX,LOCKED,UNLOCKED)==true) { if(GlobalVariableSet(BALANCE,AccountBalance())==0) { SendNotification("OnInit BALANCE GlobalVariableSet failed, please update manually"); return INIT_FAILED; } GlobalVariableSetOnCondition(MUTEX,UNLOCKED,LOCKED); }

And then, whenever the OrdersTotal() number changes, I send a notification about the new balance value, but I use the Mutex object to make sure that only one Expert adviser sends the notification while the other are locked:

if(GlobalVariableSetOnCondition(MUTEX,LOCKED,UNLOCKED)==true) { if(GlobalVariableGet(BALANCE)!=AccountBalance()) { double DailyProfit=AccountBalance()-GlobalVariableGet(BALANCE); if(DailyProfit!=0) SendNotification(StringConcatenate(SYMBOL," daily Profit = ",DoubleToString(DailyProfit,2))); if(GlobalVariableSet(BALANCE,AccountBalance())==0) SendNotification("BALANCE GlobalVariableSet update failed, please update manually"); } GlobalVariableSetOnCondition(MUTEX,UNLOCKED,LOCKED); }

This way, the critical path of checking the balance value and sending notification will not happen in parallel. By the time the next expert adviser gets the balance value, it is already updated by the previous expert adviser, so, the notification will be send once.

Join the Telegram channel to stay updated with trading ideas, articles and signals t.me/ForexAlgotrading

MetaTrader 4 Indicator to show Currency trend in Different Timeframes

2019-01-24T12:00:00.000+01:00

Usage

When trading, you probably have several windows open next to each other, different products, different time frames. Or, you have the same product but in different timeframes to see how it performs.

I wrote this indicator so I can see for a given product, how it behaves in the different timeframes available by MetaTradre 4. It has three different lines to express the following information:

The trend for a given timeframe, blue arrow means bullish, red arrow means bearish.
The pips change for a given timeframe, blue text means bullish, red text means bearish.
The standard deviation for a given timeframe, red text means that the timeframe movement is higher thatn the volatility, otherwise black.

Once attached, a panel will be drawn in the lower left corner as in the following screenshot for EURUSD:

You may see, that the daily trend for example is bullish. And that the hourly movement in pips is higher than the volatility, thus the STD value for hourly timeframe is painted in red.

To download, use the following links:
1. The indicator, to be placed and compiled in the indicators folder - Indicator.
2. The common library, to placed and compilied in the common folder - Library
Compile and attached to your product.

For any queries, don't hesitate to contact me.

Looking back at 2018 and forward to 2019

2019-01-01T13:04:00.001+01:00

Introduction

Every year brings with it 365 opportunities to make a difference, so did 2018 and so will 2019. The last was very exciting and challenging. Since going live with my algorithmic strategies to the public, it a was a roller coaster. As soon as you expose your ideas and start getting an inflow of investors it's a whole new and different experience.

The challenge we face as FX traders, specifically as retail ones is that we don't have enough equity to make a living out of the trading, which drives us to take more risky positions with insane leverage hoping this will make us overnight rich. Of course, in reality the market has its own rules and most of the traders gets punished for acting foolish, seeing their account gets blown. This is one of the reasons that 80% of retails traders lose money on average, a figure which can be seen on many FX brokers sites:

2018

Lessons Learned

In 2018 I learned the hard way how risk management is critical. I got burnt with GBPUSD crash in Q1. So, if you don't want to end underwater, make sure you manage your risk properly, that's the number 1 killer to accounts. A simple calculation to check if your risk makes sense is to multiply your margin with your account leverage and divide with your equity, if the result is above 10, you better think carefully, if its over 50, one wrong move and your account will be wiped out...

For example, say my broker offers me a leverage of 1:200 and I currently have margin equals to 57.25$ with equity of 1,753.07$. Making the above calculation of 52.25*200/1,753.07 = 6.53 teaches me I am in the right risk area. Unless I am on the right side of the trend, I make sure this value stays within the 10 boundaries. Otherwise, the higher the leverage, the higher the change per pip which is happening. It could work for me, but most likely it will work against me due to volatility.

My lessons from the previous year are:

To focus on a single currency, get to know it inside out, understand clearly what is the impact of news events on it, what are the different dependencies and so on. Forget about trading multiple currencies in a single account, the orders gets mixed and the management becomes challenging.

Have a clear open and close strategy and stick to it. The main problem with the market is the volatility, that noise that surrounds the trend and prevents us from seeing clearly where the currency goes. There are so many moments the market goes against what I think and I get tempted to close my position and move on with my life, but that's exactly the problem, that's where the amateurs are separated from the pros. As Nassim Taleb says in his brilliant book "Fooled by Randomness", the less you look at the market, the better. The more often you check the positions, you will get turned off by volatility and what it does to your positions and P&L.

Don't over trade! If you reach your daily, weekly, monthly goal stop trading and do something else with your time. The more you trade, the higher the risk the strategy will miss and you'll incur losses. Sometimes, I have a take profit taken already at 10:00, which leaves me free the whole day not to worry and look at the market, it's amazing feeling.

Strategies

In 2018, I was operating two strategies with EURUSD as the underline:

Day trading strategy - Focusing on short term opportunities with using scale in approach, this strategy achieved 52.26% return. It outperformed every index out there and provided myself and my investors brilliant return. December especially was remarkable, while the equities were hammered, my strategy managed to grow 16.05%.

Volatility trading strategy - focusing on volatility and momentum opportunities, this strategy had a 22.31% return. As these opportunities don't come so frequently, there were months where almost nothing happened and months (like August) where the strategy enjoyed the high volatility of the Turkish lira crises and made 8.04%.

As part of new investors, Relton Captial which is a Zurich-based private investment company operating an array of tailor-made investment strategies added my strategies to their offerings and had them published on their homepage - http://www.reltoncap.com/investments/index. These investments will help me to refinance the DARWINs I sell, so the equity grows larger and the VAR goes lower, thus ensuring better return to the investors.

2019

This year, I am planning to introduce a grid trading based product. A strategy which is independent of market direction and driven by fixed spaced grid. Thus, making profit no matter where the market heads whether its trending or ranging. It is in a final stage of testing and about to be turned into a real account soon.

With that, I will have three different products which have no correlation between them to make up a portfolio. I normally divide my funds equally along my products, even I am tempted to put it all on the day trading one. But as they say, don't put all of your eggs in a single basket...

Besides that, I want to increase my investors streams, either by having visibility on the social media, or by letting Darwinex do their magic and show case my success on their front page. For me, ending 2019 with three DARWINs with a return of above 10% and total investment of 5 million will be considered a success.

I opened up a telegram channel to show case my day trading strategy, it is limited to 100 actions per month, where open or close order is considered a single action, so in total around 50 trades you get for free if you join t.me/ForexAlgotrading. Otherwise, for the full strategy you can either register to the signal available here - https://www.mql5.com/en/signals/450569 or invest in the original DARWIN where you can get a leverage of 1:4 as an investor.

For example, assuming you had an investor account with 25k $ in Darwinex with a leverage of 1:4, it would have translated to 100k $ investment in the strategy which will have a return of 16.05% which is 16k $. That is more that 50% on your original investment!

So, happy new year everyone and I hope you'll make it big time in 2019!

Implementing Trailing Stop Loss in MQL4

2018-12-10T08:00:00.001+01:00

Cut your losses early, and let your winners runs.
Trading circles

Introduction

This is the most common quote you'll probably hear in trading circles. Which basically means, that as soon as you open a position, you need to monitor it and make a decision against it or for it. When you move into the algotrading regime, I would modify this quote into the following one:

Cut your losses early, and let your winners run... to your trailing stop loss.
Roy Meshulam

That's because you don't want to spend your time in front your PC monitoring the order. The contrary, you want to have a fully automated expert adviser that does it for you, opening and closing order according to the logic you built.

Trailing stop loss a strong utility to have. It is basically the logic to update the stop loss value and move it together with the price. So, if the price is in your favour, you move the stop loss, thus, capturing more profit. If it is against, you keep the stop loss with the same value. Hence, it is called trailing stop loss.

Stop Loss / Take Profit Function

The first thing we must have is a safe function to update an order with a stop loss / take profit value. We can't rely on the OrderModify one, as there is no proper error handling, value checking etc.

Function Signature

So, we will use our own function, which takes the following parameters:

bool AddStopProfit(int argOrder,double argStopLoss,double argTakeProfit,bool argForceCorrectValue=false) export

The order we want to modify
The stop loss value
The take profit value
A boolean flag to force a new value or not

The return value will be a boolean which indicates whether the value modifications succeeded or not.

Verification Step

Next, we need to check if the order is still open. If yes, whether the new stop loss / take profit values are different than the existing ones. If the order is closed already, or the values are the same, then, there is nothing to change so we will return true:

if(OrderCloseTime()!=0 || 
     (NormalizeDouble(argStopLoss,(int)MarketInfo(OrderSymbol(),MODE_DIGITS))==OrderStopLoss() && 
     NormalizeDouble(argTakeProfit,(int)MarketInfo(OrderSymbol(),MODE_DIGITS))==OrderTakeProfit()))
     return true;

Modification Step

Next, we will check what are the legal values for stop loss / take profit for the order. We will use as an example a long order. But the same logic will be applicable to a short one.

Long Order Stop Loss Value Verification

Normally, the broker has a maximum value for the stop loss. Which means, that if you try setting up one above this point, the OrderModify function will fail. To check what is this value we use the following code:

StopLoss=MarketInfo(OrderSymbol(),MODE_BID)-MarketInfo(OrderSymbol(),MODE_STOPLEVEL)*MarketInfo(OrderSymbol(),MODE_POINT);
        if(argStopLoss!=0 && argStopLoss>StopLoss)
          {
           if(argForceCorrectValue==false)
             {
              SendNotification(StringConcatenate("OP_BUY illegal SL for #",argOrder,", New / Allowed = ",argStopLoss,"/",StopLoss));
              return false;
             }
           else
              argStopLoss=StopLoss;
          }

The first line check what is the maximum stop loss value we can set by subtracting the stop level value from the current bid price. The MODE_STOPLEVEL according to https://docs.mql4.com/constants/environment_state/marketinfoconstants: Is the stop level in points. A zero value of MODE_STOPLEVEL means either absence of any restrictions on the minimal distance for Stop Loss/Take Profit or the fact that a trade server utilizes some external mechanisms for dynamic level control, which cannot be translated in the client terminal. In the second case, GetLastError() can return error 130, because MODE_STOPLEVEL is actually "floating" here.

If the argForceCorrectValue is set to false and the stop level value is illegal. The function will terminate and return false value, otherwise, we will use the maximum calculated stop level value instead of the function argument.

The same logic applies for the take profit, there we need to check the that take profit value is not smaller than the minimum one allowed by the broker.

Calling OrderModify

Finally, we will call MQL4 OrderModify function to set the stop loss / take profit value, either the calculated one or the one we got as an argument:

if(OrderModify(argOrder,OrderOpenPrice(),NormalizeDouble(argStopLoss,(int)MarketInfo(OrderSymbol(),MODE_DIGITS)),NormalizeDouble(argTakeProfit,(int)MarketInfo(OrderSymbol(),MODE_DIGITS)),0)==false)
       {
        SendNotification(StringConcatenate("Add Stop/Profit failed updating order #",argOrder,", SL (N/E) = ",argStopLoss,"/",OrderStopLoss(),", TP (N/E) = ",argTakeProfit,"/",OrderTakeProfit()),true,GetLastError());
        return false;
       }

With this step completed, we updated the order values successfully. A typical call to this function will be something like:

AddStopProfit(OrderTicket(), 1.23456,1.43589,true);

Meaning, modify the current ticket with a stop loss equal to 1.23456, take profit equals to 1.43589 and force valid values for them by setting the force flag to true.

Full Function Code

Putting it all together we have the following code:

    bool AddStopProfit(int argOrder,double argStopLoss,double argTakeProfit,bool argForceCorrectValue=false) export
  {
   if(OrderSelect(argOrder,SELECT_BY_TICKET))
     {
      if(OrderCloseTime()!=0 || 
         (NormalizeDouble(argStopLoss,(int)MarketInfo(OrderSymbol(),MODE_DIGITS))==OrderStopLoss() && 
         NormalizeDouble(argTakeProfit,(int)MarketInfo(OrderSymbol(),MODE_DIGITS))==OrderTakeProfit()))
         return true;
      else if(OrderCloseTime()==0)
        {
         double StopLoss,TakeProfit;
         if(OrderType()==OP_BUY)
           {
            StopLoss=MarketInfo(OrderSymbol(),MODE_BID)-MarketInfo(OrderSymbol(),MODE_STOPLEVEL)*MarketInfo(OrderSymbol(),MODE_POINT);
            if(argStopLoss!=0 && argStopLoss>StopLoss)
              {
               if(argForceCorrectValue==false)
                 {
                  Log(StringConcatenate("OP_BUY illegal SL for #",argOrder,", New / Allowed = ",argStopLoss,"/",StopLoss));
                  return false;
                 }
               else
                  argStopLoss=StopLoss;
              }

            TakeProfit=MarketInfo(OrderSymbol(),MODE_ASK)+MarketInfo(OrderSymbol(),MODE_STOPLEVEL)*MarketInfo(OrderSymbol(),MODE_POINT);
            if(argTakeProfit!=0 && argTakeProfit<TakeProfit)
              {
               if(argForceCorrectValue==false)
                 {
                  Log(StringConcatenate("OP_BUY illegal TP for order #",argOrder,", New / Allowed = ",argTakeProfit,"/",TakeProfit));
                  return false;
                 }
               else
                  argTakeProfit=TakeProfit;
              }
           }
         else if(OrderType()==OP_SELL)
           {
            StopLoss=MarketInfo(OrderSymbol(),MODE_ASK)+MarketInfo(OrderSymbol(),MODE_STOPLEVEL)*MarketInfo(OrderSymbol(),MODE_POINT);
            if(argStopLoss!=0 && argStopLoss<StopLoss)
              {
               if(argForceCorrectValue==false)
                 {
                  Log(StringConcatenate("OP_SELL illegal SL value for #",argOrder,", New / Allowed = ",argStopLoss,"/",StopLoss));
                  return false;
                 }
               else
                  argStopLoss=StopLoss;
              }

            TakeProfit=MarketInfo(OrderSymbol(),MODE_BID)-MarketInfo(OrderSymbol(),MODE_STOPLEVEL)*MarketInfo(OrderSymbol(),MODE_POINT);
            if(argTakeProfit!=0 && argTakeProfit>TakeProfit)
              {
               if(argForceCorrectValue==false)
                 {
                  Log(StringConcatenate("OP_SELL illegal TP for order #",argOrder,", New / Allowed = ",argTakeProfit,"/",TakeProfit));
                  return false;
                 }
               else
                  argTakeProfit=TakeProfit;
              }
           }
         if(OrderModify(argOrder,OrderOpenPrice(),NormalizeDouble(argStopLoss,(int)MarketInfo(OrderSymbol(),MODE_DIGITS)),NormalizeDouble(argTakeProfit,(int)MarketInfo(OrderSymbol(),MODE_DIGITS)),0)==false)
           {
            Log(StringConcatenate("Add Stop/Profit failed updating order #",argOrder,", SL (N/E) = ",argStopLoss,"/",OrderStopLoss(),", TP (N/E) = ",argTakeProfit,"/",OrderTakeProfit()),true,GetLastError());
            return false;
           }
         else
            return true;
        }
     }
   else
     {
      Log(StringConcatenate("Add Stop/Profit failed selecting order #",argOrder),true,GetLastError());
      return false;
     }
   return true;
  }

Trailing Stop Loss Implementation

Now that the we have a correct function to update an order with stop loss / take profit values. Implementing a trailing stop loss will use it whenever the ticket progress in the right direction:

double GAP=0.00100;

int Ticket=OrderTicket();
if((MarketInfo(Symbol(),MODE_BID)-OrderStopLoss())>GAP)
    AddStopProfit(Ticket,MarketInfo(Symbol(),MODE_BID)-GAP,0,true);

In this example, I chose a long order and checked whether the current price minus the order stop loss price is bigger than the predefined GAP value of 100 pips. If it is the case, I subtract the GAP from the current price. Thus, I ensure the gap is kept constant between the current price to the stop loss of 100 pips.

It is straightforward to use and I tried to keep it as simple as possible. Another possibility is to set the stop loss based on an indicator value, for example using the Trailing ATR indicator:

In this example, you may adjust the code to have the trailing stop equal the value of the Trailing ATR value. There's a really nice value capturing in this image if you calculate properly...

Summary

In this post, I introduce the code I use for algorithmic trailing stop value. You may use this code as is in your programs and update the stop loss every X minutes / every predefined event etc.

As usual, feel free to contact me for any query / topic. Join the telegram chat for free signals and trading ideas t.me/ForexAlgotrading.

How to Communicate Between MetaTrader Terminals using Files

2018-11-18T10:50:00.001+01:00

Introduction

Do you need different MetaTrader terminals to be able to communicate between themselves?

Some reasons to implement this logic could be:

Trading with different accounts which need to know on each other status.

Trading with different brokers which needs to have the same orders open.

Using one terminal to notify another terminal upon a certain trading condition.

The use case which enforced me to communicate between different terminals, was a strategy running on one account that had to notify another terminal to open orders once certain conditions were met. The second strategy was a derivative of the first one, so it had a dependency on its behavior. But I didn’t want to run both strategies in the same terminal as I wanted the order book to be clean and not a mixture of these two strategies.

Important: this solution will only work if the terminals are running on the same PC, otherwise, you need to consider using other methods like reading remote URL or using FTP.

Solution

Using Common Files

MetaTrader has a feature to handle files located in the common data folder. A location accessible by using the option FILE_COMMON upon file functions call. This is where we will place our shared files which will be used to hold the information different terminals need to use.

Normally, there is a single producer who writes the file and N consumers who reads it. Otherwise, a solution needs to take file synchronization in consideration, not to get to a state where two processes are writing at the same time and corrupting the file.

There must be a shared name between all the participants, so all the terminals refer to the same file on the common folder.

So, high level the solution will be to open up a file in the common folder, update it with whatever information we want to share, close it. In parallel, the consumers check for changes every X minute, as soon as a change detected. They read it and act accordingly. Meaning that our code will have two sides, the producer and the consumer of the information.

To locate the common data folder location, click in MetaEditor File -> “Open Common Data Folder”.

Producer

This instance is responsible to open up the file as a write only file and update it with the relevant information for the consumers. It will do so in the common folders so other terminals will be able to access it.

The first thing we need is a shared file name, one which will be used within all the MetaTrader terminals. I will declare it as follows:

const string FILENAME="Pipe.txt";

It may be any given name, I chose Pipe as it is behaving like an information pipe between the different terminals.

Next, once a new information is ready to be shared, we will do the following:

int FileHandle=FileOpen(FILENAME,FILE_TXT|FILE_WRITE|FILE_COMMON);
 if(FileHandle==INVALID_HANDLE) 
    SendNotification(StringConcatenate("Operation FileOpen failed: ",IntegerToString(GetLastError()))); 
else {
    if(FileWriteString(FileHandle,StringConcatenate("OP_SELL",";",DoubleToString(0.29,2)))==0) 
        SendNotification(StringConcatenate("Operation FileWrite failed: ",IntegerToString(GetLastError())));
 FileClose(FileHandle);
 }

We start by opening a file for writing in the common data folder, by using the flag FILE_COMMON flag. Then, if the file open was successful, we write into the file the information we want. In this case, I wrote an instruction to open a short order with a certain order lots value. If the write was successful, the return value will not be 0, rather, the number of the bytes written. We finish by closing the shared file.

Consumer

On the consumer side, we will use the same file name to refer to the same information pipe with the producer from the previous part:

const string FILENAME="Pipe.txt";

Then, we will check every X minute whether a pipe exists with new information. Once there, we will open for reading and get the new information to be used:

if(TheMinute!=Minute()) 
{
 TheMinute=Minute();
  if(FileIsExist(FILENAME,FILE_COMMON)==true)
 {
     int FileHandle=FileOpen(FILENAME,FILE_TXT|FILE_READ| FILE_COMMON);
    if(FileHandle==INVALID_HANDLE) 
    {
         SendNotification(StringConcatenate("Operation FileOpen failed: ",IntegerToString(GetLastError())));
         ExpertRemove();
         return; 
    }
      string Line,Values[]; 
    while(FileIsEnding(FileHandle)==false)
     {
         Line=FileReadString(FileHandle);
         StringSplit(Line,StringGetCharacter(";",0),Values);  
        //do something with the values… 
    } 
    FileClose(FileHandle);
     if(FileDelete(FILENAME,FILE_COMMON)==false) 
    { 
       SendNotification(StringConcatenate("Operation FileClose failed: ",IntegerToString(GetLastError())));
        ExpertRemove();
        return; 
     }
   } 
}

As soon as we see the file exists, we will open it for reading, again in the common data folder by using the FILE_COMMON flag. Then we read line by line and split the line into the Values array using the “;” as the separator. Then the consumer has all the information he needs to use in the internal logic. Finally, we close and delete the file to make sure we will not use old information.

Using this piece of code, we ensured we are checking regularly for new input and once we have it, we are able to use it across multiple MetaTrader instances. In my case, I only need it in one instance of MetaTrader. But If I had to use it in more than one instance, I would use the file timestamp as the indicator if something changed instead of deleting the file as multiple instances would be using it. It is a simple check:

FileGetInteger(FileHandle,FILE_MODIFY_DATE);

Conclusion

I have introduced a method I am using with my expert advisers to communicate between different MetaTrader instances using files in the common data folder. It is based on a communication between a single producer to multiple consumers. With that in hand, you can create a multi strategy across several different accounts.

As always, for any information on my trading activity or any other information, don’t hesitate to contact me.

I launched the community page with different forums, please register and discuss with the community about FX trading and / or Expert Advisors programming.

How I make Money trading Forex

2018-10-31T11:00:00.001+01:00

Did you know that on average 80% of retail traders lose money when trading Forex?

But, if you've been following my blog, you realized by now that I make my income from trading Forex, and to be specific from trading EURUSD only. This is the only product I trade and live from, which is quite counter intuitive, how is it possible to trade only one product with all it's ups and downs and live from it? In this post, I will explain exactly how I make a living from trading Forex and which traps to avoid.

Still, even that it worked for me and the setup is quite simple, there's no guarantee it will work for you the reader. We are all in a different situations in life, with more or less to risk, knowledge and so on. But still, I suggest to read this post to understand which traps are out there and which path you can follow to avoid losing your money.

The Traps

But first, let's start with the typical pitfalls out there, unfortunately, in some of them I fell myself and lost money:

Buying Expert Advisers / Trading Robots

There are so many robots out there for sale. With insane back testing results and promises to for guaranteed returns of 100%+ per year. This is absolutely nonsense!!! No one with successful strategy which makes money will sell it to the public with retarded prices as done on the market. It is not realistic and you can forget about their ability to forecast what will come next and earn for you.

When I started trading 10 years ago, I fell into this trap and bought some robots from a merchant. I had no clue why the robot behaves as it behaves, how the risk management works and what are the trading triggers. The customer service was horrible, no matter how I tried reaching the team who sold the robot, I got no response and complete ignorance. As soon as they got the money, it wasn't possible to get a reply within a reasonable time, horrible support!

Eventually, I lost quite a sum on this expert adviser, at least 10 times more than it cost to be specific. From that point onward, I never bought expert advisers and did it all myself from the following reasons:

I wanted to have full control on the risk management

I wanted to know exactly what triggers an order

I wanted to know exactly how the expert adviser behaves when an exception happens

I wanted to understand exactly the expert adviser behavior

I didn't want to rely on anyone else

Empty Promises

Did you ever see this sort of promises online?

"GET XXX PIPS EVERY MONTH WITH FREE!!! FOREX SIGNALS IT 100% ASK ME HOW?"

"Who's new in trading and looking for a MENTOR? I'll teach you for FREE. NO SIGNALS, JUST YOU and THE CHART"

Looking for reliable FREE FOREX SIGNAL to recover your all loses! Reply 'YES' you will get the telegram link

"Stop paying for Forex signal .. join our VIP channel and get free Forex signals on a daily base ...COMMENT "yes" to be added."

"XXX pips sure shot strategy 100% guaranteed only in YYY$ anyone need can send me msg"

Following on the previous paragraph, this is nonsense! No one will provide you signals for free, no one will educate you for free and no one will make you money without return. If you want to make money, you need to invest time and money to make it happen, there is no free lunch. These are mostly fraudsters with no clue on trading, I followed some of their accounts and saw how they gets blown away from over leverage, with effective leverage of more than 1:20...

Some of them wants to get your mobile, to harass you with commercials or just adding you to some database, some of them will sell you dreams for nothing. It is normally a post which promises for free insane returns, spelling mistakes, request for your private number and so on. Don't let greed to influence your decision and just ignore these type of messages.

NON-DMA Broker

Working with non Direct Market Access broker is one of the most critical mistakes you can do. It's basically trading with a broker who has interest in you're losing your money!!! DMA broker means a broker which simply forward your orders to the markets using liquidity providers and taking a commission for that.

There are hundreds of brokers out there, choosing the right one based on conditions, regulations and geography is almost impossible, but having a broker which doesn't trades against you is the right starting point. Normally it is stated clearly in the website which type of broker is it, read the fine printing, the terms and conditions, it will cost you if you won't...

Bonus Upon Signing Up

If a broker gives you a bonus for depositing with him, be sure that you will lose this money to him. Again, there is no free lunch. If you get money for free, it means the spreads are massive, the execution is retarded or the trading house is opening positions against you. Don't be tempted to get his 50$ or whatever amount you're offered only to discover it is gone together with your initial deposit...

Non Regulated Broker

The regulation is here to protect us, the traders. A thumb rule is NEVER trading with a non regulated broker!

Together with that, as part of the regulation, brokers must state how much % of their traders losing money with them. You may see it normally at the bottom of the screen, a statement which looks like:

"Risk Warning: CFDs are complex instruments and come with a high risk of losing money rapidly due to leverage. XX.XX% of retail investor accounts lose money when trading CFDs with this provider. You should consider whether you understand how CFDs work and whether you can afford to take the high risk of losing your money."

Normally, this number should be 70-80%, if it is higher than, run away as fast as you can. If the numbers are high, something is dodgy and you don't want to be there with your hard earned money.

My Way

Finding the right Strategies

Now that we understand what are the pitfalls / traps out there, it's time to find a solution to all of that issues. Having so many risks and challenges was the main reason it took me so much time to find the right setup for me.

Starting with the main thing, finding a winning strategy. I realized that the main problem new traders have is greed. They come up with 1000, take insane leverage and hope to make millions out of it, which will never ever works, only in a rare cases and after years of successful trades, it might be possible. Instead, I focused on finding a conservative strategy which makes 0-2% a month, mostly close to 1%. That's how I come up with the Day Trading Strategy. An algorithm which opens one order maximum per day, 0.1% lot size of the equity and trading today's movement. If it makes money, it closes the same day, if not, it continues until a fine closure is achieved.

Together with this strategy, I wrote the more aggressive strategy, so called Volatility Trading Strategy. Strategy which is driven, as the name suggests, from the product's volatility. It is much more aggressive with returns up to 8% a month.

I ran them both on EURUSD, thus ensuring liquidity with narrow spreads. I didn't want to use any exotics or bizarre products with weird behavior. Rather the most familiar with the most information and tick data out there.

Finding the right Broker

With the right strategies in hand, it was time to find the right broker. This was super challenging task with all the brokers out there. But I started narrowing down all of them by the following criteria:

Regulation - I filtered out all the non-regulated brokers, specifically, those which are not regulated by some European known one such as ESMA, FINMA etc.

DMA - As mentioned above, I filtered out all the non-DMA brokers, meaning, I looked for those with strong liquidity providers and direct market access.

Social trading - As I am confident with my strategies, I wanted to have the possibility to open them up for investors and receive fee from those copying it.

Customer service - I reached out to the different brokers left and checked who is the most approachable team, who is nice and has 24/5 opening hours.

After this tedious process was over, I had a winner, a broker called Darwinex. A regulated, DMA broker with an amazing support team and cutting edge technology. They introduced the concept of DARWIN, an instrument which encapsulates trading strategies and open it up for investors. So not only I make money with my own equity, I also get performance fees from the interested investors.

On top of that, Darwinex offers for investors an investor account with up to 4 times leverage on their equity, so not only you get to invest in successful strategies if you choose right, you also get to quadruple your profits. For example, assuming you invest 10k in a certain DARWIN which makes 20% a year, you'll actually make 410k20%=8k, not bad, right?!

Putting it all together

Connecting all the dots together, I basically run my own algorithms, hosting them on Darwinex and getting performance fees from the investors:

Day trading strategy - https://www.darwinex.com/darwin/ZEB.4.8/

Volatility trading strategy - https://www.darwinex.com/darwin/GFA.4.21

I aim to make 2% per month combined from both strategies, so after 3 years with 125k initial investment times 4 leverage, I will reach my first million:

500k * (1+2%)^36 = 1M+ $.

The broker is completely transparent, there is an insurance up to 500k $ so the funds are safe, these are my strategies running so I have 100% confidence about their behavior so I can sleep good at night. And that's exactly I make money from trading Forex.

Conclusions

We all have financial goals we want to achieve, but seems that 80% of us have unrealistic ones. It doesn't have to be like that. In this post, I wrote transparently how Forex trading works for me. The main take away is that there is no free lunch. It is your money and you must make smart decisions with it. Don't get tempted by empty promises and look for the most reliable way to invest it.

If you continue falling in the traps mentioned above, then next year, you will be exactly in the same state, reading this article and thinking what went wrong.

As usual, if you have any questions please don’t hesitate to contact me over sales@ilantree.com or +41 76 236 59 58.

Please note, that starting October I launched my free signal providing available via Twitter at https://twitter.com/IlanTree or Telegram at https://t.me/IlanTreeGroup. With these possibilities, you get the signals but with a certain delay, if you want to get the signals at real time, you’d have to register and pay here – https://www.mql5.com/en/signals/450569.

How I use Properties Files in Expert Advisers

2018-10-25T14:00:00.001+02:00

Introduction

The classic way of defining input parameters for an expert adviser is using a variable, for example:
input double Lots=0.01; //Default lots to use
In this case the input variable will hold the default value to use in the expert adviser throughout the execution. If you want to change the value, you’d have to restart the expert adviser to enter the new value.
But, what if you could have avoided restarting the expert adviser, in some cases, the expert adviser is doing something or holding some valuable piece of information which might get lost if you restart it again.

My way of using parameters solves exactly that challenge, in my solution which I will explain later on, I am using properties files and updating the expert adviser on the fly, thus, avoiding the unnecessary restart of the expert adviser.

File Structure

As I am using the plain text files as properties files, the structure is mostly as key=value structure. For example, the Lots input parameter mentioned above will be written as:

Lots=0.01

In its own line.

As for the file name convention, I normally use the expert adviser name concatenate with “Properties.txt”. So, if the expert adviser is called Trader, there will be a file called TraderProperties.txt under the files folder with the relevant properties. You may form this file name programmatically by calling the following function:

string PropertiesFilename=StringConcatenate(MQLInfoString(MQL_PROGRAM_NAME) ,"Properties.txt");

Reading Properties Files on the Fly
Assuming your expert adviser is running with a certain setup and you want to fine tune it by changing one of the parameters you use. Like mentioned above, one option will be to restart the expert adviser and enter the new values, or, using the following code to check for updated properties. You may put this code with the OnTimer function to check on periods or to call it upon a certain condition.

Create a global variable to store the last time the properties file was modified, we will see how to use it within the code. For the moment, have this initialization in your code:
long PropertiesFileModifyDate;

Start by opening the file by calling the next set of functions:
string PropertiesFileName;
if(IsDemo()==true)
PropertiesFileName=StringConcatenate(MQLInfoString(MQL_PROGRAM_NAME) ,"DemoProperties.txt");
else
PropertiesFileName=StringConcatenate(MQLInfoString(MQL_PROGRAM_NAME) ,"Properties.txt");
if(FileIsExist(PropertiesFileName)==false)
{
Log(StringConcatenate("Properties file ",PropertiesFileName," doesn't exist, line ",__LINE__));
return false;
}

With these lines, we create the properties file name, we may distinguish between demo environment to production one as the code suggests, but it is not mandatory. I use as I have different properties for testing and for live accounts. If the file doesn’t exist, the function finishes here and return false to the calling environment.

Otherwise, we open the file for reading as a text file and check the return handler. If it’s invalid, we print an error and return false:
else
{
int PropertiesFileHandle=FileOpen(PropertiesFileName,FILE_TXT|FILE_READ);
if(PropertiesFileHandle==INVALID_HANDLE)
{
Log(StringConcatenate("Operation FileOpen failed, error ",ErrorDescription(GetLastError()),", line ",__LINE__));
return false;
}

Now that we opened the file successfully, we check whether its modify date is different than the one we store in the global variable. If it equals -1 we return an error, if it equals the global variable PropertiesFileModifyDate we do nothing and return:
long ModifyDate=FileGetInteger(PropertiesFileHandle,FILE_MODIFY_DATE);
if(ModifyDate==-1)
{
Log(StringConcatenate("Operation FileGetInteger failed, error ",ErrorDescription(GetLastError()),", line ",__LINE__));
FileClose(PropertiesFileHandle);
return false;
}
else if(ModifyDate==PropertiesFileModifyDate)
{
FileClose(PropertiesFileHandle);
return true;
}
Finally, if the file got changed, we update the global PropertiesFileModifyDate and read the file’s contents. In this simple example, I suppose there is a single value to read which is Lots, so I get the value and update the internal variable:
else
{
PropertiesFileModifyDate=ModifyDate;
string Line,Values[];
while(FileIsEnding(PropertiesFileHandle)==false)
{
Line=FileReadString(PropertiesFileHandle);
if(StringSplit(Line,StringGetCharacter("=",0),Values)!=2)
{
Log(StringConcatenate("Operation StringSplit return more than two values, line ",__LINE__));
return false;

if(StringCompare(Values[0],"Lots")==0)

Lots=StringToDouble(Values[1])==0;
}

FileClose(PropertiesFileHandle);

return true;
}
In the end of the reading process, I close the file and return true to the calling function. In the next calls, we will again compare the modify date and only read the file if necessary.

Putting it all together in a function we have:
bool SetInputVariables()
{
string PropertiesFileName;
if(IsDemo()==true)
PropertiesFileName=StringConcatenate(MQLInfoString(MQL_PROGRAM_NAME) ,"DemoProperties.txt");
else
PropertiesFileName=StringConcatenate(MQLInfoString(MQL_PROGRAM_NAME) ,"Properties.txt");
if(FileIsExist(PropertiesFileName)==false)
{
Log(StringConcatenate("Properties file ",PropertiesFileName," doesn't exist, line ",__LINE__));
return false;
}
else
{
int PropertiesFileHandle=FileOpen(PropertiesFileName,FILE_TXT|FILE_READ);
if(PropertiesFileHandle==INVALID_HANDLE)
{
Log(StringConcatenate("Operation FileOpen failed, error ",ErrorDescription(GetLastError()),", line ",__LINE__));
return false;
}
long ModifyDate=FileGetInteger(PropertiesFileHandle,FILE_MODIFY_DATE);
if(ModifyDate==-1)
{
Log(StringConcatenate("Operation FileGetInteger failed, error ",ErrorDescription(GetLastError()),", line ",__LINE__));
FileClose(PropertiesFileHandle);
return false;
}
else if(ModifyDate==PropertiesFileModifyDate)
{
FileClose(PropertiesFileHandle);
return true;
}
else
{
PropertiesFileModifyDate=ModifyDate;
string Line,Values[];
while(FileIsEnding(PropertiesFileHandle)==false)
{
Line=FileReadString(PropertiesFileHandle);
if(StringSplit(Line,StringGetCharacter("=",0),Values)!=2)
{
Log(StringConcatenate("Operation StringSplit return more than two values, line ",__LINE__));
return false;
}
if(StringCompare(Values[0],"Lots")==0)
Lots=StringToDouble(Values[1])==0;
return true;
}
}
}

With Log utility function as follows (my own implementation):
void Log(string argMessage,bool argSendNotificationFlag=true,int argErrorCode=0) export
{
if(argErrorCode!=0)
argMessage=StringConcatenate(argMessage,", Error: ",argErrorCode," - ",ErrorDescription(argErrorCode));

Print(StringConcatenate(AccountServer(),", ",IntegerToString(AccountNumber()),", ",MQLInfoString(MQL_PROGRAM_NAME),", ",Symbol()," ",argMessage,", Balance = ",DoubleToString(AccountBalance(),2)," ",AccountCurrency(),", P&L = ",DoubleToString(AccountProfit(),2)," ",AccountCurrency(),", Equity = ",DoubleToString(AccountEquity(),2)," ",AccountCurrency(),", Margin = ",DoubleToString(AccountMargin(),2)," ",AccountCurrency(),", Margin (%) = ",DoubleToString(AccountInfoDouble(ACCOUNT_MARGIN_LEVEL),2),"%"));

if(argSendNotificationFlag==true)

SendNotification(StringConcatenate(AccountServer(),", ",IntegerToString(AccountNumber()),", ",MQLInfoString(MQL_PROGRAM_NAME),", ",Symbol()," ",argMessage,", Balance = ",DoubleToString(AccountBalance(),2)," ",AccountCurrency(),", P&L = ",DoubleToString(AccountProfit(),2)," ",AccountCurrency(),", Equity = ",DoubleToString(AccountEquity(),2)," ",AccountCurrency(),", Margin = ",DoubleToString(AccountMargin(),2)," ",AccountCurrency(),", Margin (%) = ",DoubleToString(AccountInfoDouble(ACCOUNT_MARGIN_LEVEL),2),"%"));

}

Usage

Equipped with this code, you may update the properties files with new parameter values and put on the relevant environment. Then, upon specific timing or condition you set in your expert adviser, you can call this function and update the parameters on the fly:

From within OnInit function

From within OnTimer function

Upon a certain code condition

The only occasions you need to compile the original expert adviser and restart it is if you introduce new properties to take into consideration or changed its logic.

As usual, if you have any questions please don’t hesitate to contact me over sales@ilantree.com or +41 76 236 59 58.

Please note, that starting October I launched my free signal providing available via Twitter at https://twitter.com/IlanTree or Telegram at https://t.me/IlanTreeGroup. With these possibilities, you get the signals but with a certain delay, if you want to get the signals at real time, you’d have to register and pay here - https://www.mql5.com/en/signals/450569.

MQL Functions to Close All Orders

2018-10-14T13:00:00.001+02:00

This code and much utility functions are available for purchase as part of the Common library.

Introduction

It is a common practice in my code to close all the orders once a certain condition is fulfilled. Normally, a profit target is reached, but there could be other reasons. In this post I will introduce some of the functions I am using to perform that. The main common feature to all of these functions is the counting starts from OrdersTotal()-1 and goes down to 0. This to prevent closing already closed orders as noted in this article - https://book.mql4.com/trading/orderclose.

Functions

Standard

The standard function to close all the orders is simply going through the open ones and close them one by one, starting from the last towards the first:

bool CloseAllOrders(string argSymbol="") export
{
for(int i=OrdersTotal()-1; i>=0; i--)
{

if(OrderSelect(i,SELECT_BY_POS) && (StringLen(argSymbol)==0 || StringCompare(argSymbol,OrderSymbol())==0) && (OrderProfit()+OrderCommission()+OrderSwap())>=0 && CloseOrder(OrderTicket(),OrderLots())==false)

return false;
Sleep(250);
}
for(int i=OrdersTotal()-1; i>=0; i--)
{

if(OrderSelect(i,SELECT_BY_POS) && (StringLen(argSymbol)==0 || StringCompare(argSymbol,OrderSymbol())==0) && (OrderProfit()+OrderCommission()+OrderSwap())<0 && CloseOrder(OrderTicket(),OrderLots())==false)

return false;
Sleep(250);
}
return true;
}

Where CloseOrder is:

bool CloseOrder(int argOrder,double argLotSize) export
{
if(OrderSelect(argOrder,SELECT_BY_TICKET) && OrderCloseTime()==0)
{
if(OrderType()!=OP_BUY && OrderType()!=OP_SELL)
return ClosePendingOrder(argOrder);

else if(OrderCloseTime()==0 && OrderClose(argOrder,VerifyLotSize(OrderSymbol(),argLotSize),OrderType()==OP_BUY?MarketInfo(OrderSymbol(),MODE_BID):MarketInfo(OrderSymbol(),MODE_ASK),Slippage,OrderType()==OP_BUY?clrGreen:clrRed)==false)

{

Log(StringConcatenate("Closing order #",argOrder," failed, verified lot size = ",VerifyLotSize(OrderSymbol(),argLotSize)),false,GetLastError());

return false;
}
}
else
{

Log(StringConcatenate("Closing order failed selecting order #",argOrder,", verified lot size = ",VerifyLotSize(OrderSymbol(),argLotSize)),false,GetLastError());

return false;
}
return true;
}

And ClosePendingOrder() is

bool ClosePendingOrder(int argOrder) export
{
if(OrderSelect(argOrder,SELECT_BY_TICKET) && OrderCloseTime()==0)
{
if(OrderDelete(argOrder)==false)
{
Log(StringConcatenate("Delete pending order #",argOrder," failed"),false,GetLastError());
return false;
}
}
else
{
Log(StringConcatenate("Delete pending order failed selecting order #",argOrder),false,GetLastError());
return false;
}
return true;
}

With a small utility function:

void Log(string argMessage,bool argSendNotificationFlag=true,int argErrorCode=0) export
{
if(argErrorCode!=0)
argMessage=StringConcatenate(argMessage,", Error: ",argErrorCode," - ",ErrorDescription(argErrorCode));
Print(StringConcatenate(AccountServer(),", ",IntegerToString(AccountNumber()),", ",MQLInfoString(MQL_PROGRAM_NAME),", ",Symbol()," ",argMessage,", Balance = ",DoubleToString(AccountBalance(),2)," ",AccountCurrency(),", P&L = ",DoubleToString(AccountProfit(),2)," ",AccountCurrency(),", Equity = ",DoubleToString(AccountEquity(),2)," ",AccountCurrency(),", Margin = ",DoubleToString(AccountMargin(),2)," ",AccountCurrency(),", Margin (%) = ",DoubleToString(AccountInfoDouble(ACCOUNT_MARGIN_LEVEL),2),"%"));
if(argSendNotificationFlag==true)
SendNotification(StringConcatenate(AccountServer(),", ",IntegerToString(AccountNumber()),", ",MQLInfoString(MQL_PROGRAM_NAME),", ",Symbol()," ",argMessage,", Balance = ",DoubleToString(AccountBalance(),2)," ",AccountCurrency(),", P&L = ",DoubleToString(AccountProfit(),2)," ",AccountCurrency(),", Equity = ",DoubleToString(AccountEquity(),2)," ",AccountCurrency(),", Margin = ",DoubleToString(AccountMargin(),2)," ",AccountCurrency(),", Margin (%) = ",DoubleToString(AccountInfoDouble(ACCOUNT_MARGIN_LEVEL),2),"%"));
}

And

double VerifyLotSize(string argSymbol,double argLotSize) export
{
argLotSize=MarketInfo(argSymbol,MODE_LOTSTEP)==0.1?NormalizeDouble(argLotSize,1):NormalizeDouble(argLotSize,2);
return MathMax(MarketInfo(argSymbol,MODE_MINLOT),MathMin(MarketInfo(argSymbol,MODE_MAXLOT),argLotSize));
}

In this standard implementation, I choose to close first all the profiting orders and then to close the losing ones. Reason for that is keeping the balance / equity high thus the margin % high so we will not run into unwanted situations. Once all the profiting ones are close, the losing ones are closed too. If there is a pending order, such a Stop or Limit one, it is taken care of separately in the ClosePendingOrder function.

Closing by Lot Size

With this implementation, I am closing all the profiting orders first and then I close the different orders according to their size until the profit == loss. I am using this function whenever there are large positions which are covered by other large positions and I want them to net each other. It is comfortable to call this function, leaving behind the small lots size orders which are still open:

bool CloseAllOrdersByLotSize(string argSymbol="") export
{
double MaxLotSize=0;
double ClosedProfit=0;
for(int i=OrdersTotal()-1; i>=0; i--)
if(OrderSelect(i,SELECT_BY_POS) && (StringLen(argSymbol)==0 || StringCompare(argSymbol,OrderSymbol())==0))
{
if((OrderProfit()+OrderCommission()+OrderSwap())>=0)
{
if(CloseOrder(OrderTicket())==false)
{
Log(StringConcatenate("Failed closing position #",IntegerToString(OrderTicket())),true,GetLastError());
return false;
}
ClosedProfit+=OrderProfit()+OrderCommission()+OrderSwap();
}
else if(OrderLots()>MaxLotSize)
MaxLotSize=OrderLots();
}
for(double LotSize=MaxLotSize;LotSize>0;LotSize-=MarketInfo(argSymbol,MODE_MINLOT))
for(int j=OrdersTotal()-1;j>=0;j--)

if(OrderSelect(j,SELECT_BY_POS) && (StringLen(argSymbol)==0 || StringCompare(argSymbol,OrderSymbol())==0) && OrderLots()>=LotSize && (ClosedProfit+OrderProfit()+OrderCommission()+OrderSwap())>=0)

{
if(CloseOrder(OrderTicket())==false)
{
Log(StringConcatenate("Failed closing position #",IntegerToString(OrderTicket())),true,GetLastError());
return false;
}
ClosedProfit+=OrderProfit()+OrderCommission()+OrderSwap();
}
return true;
}

The first loop finds the highest order lots size, the second double loop goes through the different orders and closes them if their lot size is higher than the current one. Once a loop is completed, the current lot size reference decreases with the minimum lot avaialble - LotSize-=MarketInfo(argSymbol,MODE_MINLOT).

Closing by Type

These functions close all orders according to their type, whether they are long or short:

bool CloseAllLongOrders(string argSymbol="") export
{
for(int i=OrdersTotal()-1; i>=0; i--)
{

if(OrderSelect(i,SELECT_BY_POS) && (OrderType()==OP_BUY || OrderType()==OP_BUYLIMIT || OrderType()==OP_BUYSTOP) && (StringLen(argSymbol)==0 || StringCompare(argSymbol,OrderSymbol())==0) && CloseOrder(OrderTicket())==false)

return false;
Sleep(250);
}
return true;
}

and

bool CloseAllShortOrders(string argSymbol="") export
{
for(int i=OrdersTotal()-1; i>=0; i--)
{

if(OrderSelect(i,SELECT_BY_POS) && (OrderType()==OP_SELL || OrderType()==OP_SELLLIMIT || OrderType()==OP_SELLSTOP) && (StringLen(argSymbol)==0 || StringCompare(argSymbol,OrderSymbol())==0) && CloseOrder(OrderTicket())==false)

return false;
Sleep(250);
}
return true;
}

It is closing the open orders as well as the pending ones.

Closing by Profit

These functions close all the profiting orders or the losing ones:

bool CloseAllProfitingOrders(string argSymbol="") export
{
for(int i=OrdersTotal()-1; i>=0; i--)
{

if(OrderSelect(i,SELECT_BY_POS) && (StringLen(argSymbol)==0 || StringCompare(argSymbol,OrderSymbol())==0) && (OrderProfit()+OrderCommission()+OrderSwap())>0 && CloseOrder(OrderTicket())==false)

return false;
Sleep(250);
}
return true;
}

and

bool CloseAllLosingOrders(string argSymbol="") export
{
for(int i=OrdersTotal()-1; i>=0; i--)
{

if(OrderSelect(i,SELECT_BY_POS) && (StringLen(argSymbol)==0 || StringCompare(argSymbol,OrderSymbol())==0) && (OrderProfit()+OrderCommission()+OrderSwap())<0 && CloseOrder(OrderTicket())==false)

return false;
Sleep(250);
}
return true;
}

Closing Live vs. Pending Orders

Finally, these functions close all live orders or pending ones:

bool CloseAllLiveOrders(string argSymbol="") export
{
for(int i=OrdersTotal()-1; i>=0; i--)
{

if(OrderSelect(i,SELECT_BY_POS) && (StringLen(argSymbol)==0 || StringCompare(argSymbol,OrderSymbol())==0) && (OrderType()==OP_BUY || OrderType()==OP_SELL) && CloseOrder(OrderTicket())==false)

return false;
Sleep(250);
}
return true;
}

and

bool CloseAllPendingOrders(string argSymbol="") export
{
for(int i=OrdersTotal()-1; i>=0; i--)
{

if(OrderSelect(i,SELECT_BY_POS) && (StringLen(argSymbol)==0 || StringCompare(argSymbol,OrderSymbol())==0) && OrderType()!=OP_BUY && OrderType()!=OP_SELL && ClosePendingOrder(OrderTicket())==false)

return false;
Sleep(250);
}
return true;
}

In Common.

All the functions are boolean and return the failure / success upon completion, you may use it and act accordingly if something went wrong.

All the functions starts closing from the last function and works backwards to the first one.

All the functions have a sleeping time between each closure, to prevent overflooding the running thread and miss an order closure.

As always, I am happy for any inquiries or suggestions for post per email and / or mobile.

FX Algotrading Q&A Session 16/08/2018

2018-08-28T17:40:00.001+02:00

On the 16th August I delivered a webinar on the topic of "introduction to FX Algotrading". In this 40 minutes I introduced myself, the strategies I am running and the platform I am using.

Here is the replay:

Toggling the Auto Trading Button in MQL4

2018-08-20T14:00:00.001+02:00

Introduction

In this post, I will introduce an MQL4 code I use to control remotely the auto trading button on/off status, this code is part of the RemoteControl library product available for purchase here.

There are some scenarios where we would like to stop trading completely such as:

Extreme market conditions or

Below a certain equity threshold.

Negative P&L below a certain threshold.

But when we are not near the PC, this could be a challenging task to do. We can either close all of our positions and take some loss, or, let the positions run and hope for the best…

In this post, I will introduce a code snippet which you can plant in your code, which upon certain conditions can mimic halt trading by toggling the auto trading button on / off:

So, upon executing this code, the button will be toggled between on and off, and you will get notified about the new state.

Implementation

First of all, we need to modify the WinUser32.mqh which is shipped as part of the MetaEditor installation, by adding the following two lines:

int GetAncestor(int hWnd,int uCmd); - A function to get the parent of the current window, will be used later on to get the handler of the chart parent, the MetaTrader workstation.

#define WM_AUTOTRADING 0x80FC – A constant holding the toggle auto trading
button action. Will be used later on as part of the call for an action message.

The code is as follows:

ResetLastError();
int hWnd=GetAncestor(WindowHandle(Symbol(),Period()),GA_ROOT);
if(hWnd!=-1)
{
if(PostMessageA(hWnd,WM_COMMAND,WM_AUTOTRADING,0)!=0)
SendNotification(StringConcatenate("Toggling automated trading button succeeded, ",OriginalTradeAllowedFlag==false?"trading enabled":"trading disabled"));
else
SendNotification ("Toggling automated trading button failed messaging the button");
}
else
SendNotification ("Toggling automated trading button failed getting the ancestor window");

First, I reset the last error to make sure, that if something goes wrong, we have the latest error code.

Then, using the call to GetAncestor, I getting a window handler to the parent window of the current chart. In our case, this is the MetaTrader application itself.

If the call was successful, and hWnd isn’t -1, rather a handler to the root window. We post a message to that window using the function PostMessageA, which mimic the behavior of clicking the automated trading button. The WM_ AUTOTRADING constant holds the value of the button clicking event.

If successful, the function will return a non-zero value and the button will be clicked to look as:

At this point, no trading is possible and the following functions will fail - OrderSend(), OrderClose(), OrderCloseBy(), OrderModify(), OrderDelete(). We can always call this function again once the risk condition was finished and we are interested to start trading again.

Usage

I am using this logic across my expert advisers in the following manners:

if((IsTradeAllowed()==true && AccountInfoDouble(ACCOUNT_MARGIN_LEVEL)>0 && AccountInfoDouble(ACCOUNT_MARGIN_LEVEL)<200) || (IsTradeAllowed()==false && AccountInfoDouble(ACCOUNT_MARGIN_LEVEL)>400))
{
“TOGGLE AUTOMATED TRADING BUTTON”

Meaning, I set certain threshold levels, in this case 200 and 400. If the account margin level in % goes below 200%, I will disable the trading by firing this event. Then, if the account margin level goes above 400%, I will switch trading back again. I am using the IsTradeAllowed function to verify the current state before firing this event. Normally, I put this logic in the OnTimer() function which I call on an hourly basis, but you may plant anywhere you’d like.

Or:

Using my remote-control framework to fire a message based on a OP_BUYSTOP message with the value of 1011 as explained in this post.

As always, I am happy for any inquiries or suggestions for post per email and / or mobile.

Linear Hedging Framework for MQL4

2018-08-12T11:25:00.001+02:00

Introduction

When opening an order, we are all hoping that our analysis was correct and our position will make a profit. But, when this is not the case, there are in general three possibilities to continue:

Close the order upon a predefined stop-loss, if we were able to close the order on the opening price, then it's even better and no harm was done - The challenge with this approach is to know where to set the stop loss point, not to make too tight so it doesn't get hit quick, or too wide and then the loss is massive.

Let the order run and hope that at some case the trend will reverse and our analysis was correct - Challenging as well, since we will never know with 100% accuracy that this level will be reached again, so in the meantime our P&L gets more and more negative and we make loss on the swap if it is against us.

Hedge the order - meaning opening an opposite order upon a predefined gap and close it once the orders cancel each other profit wise.

I will dedicate this post to the third option and introduce a linear hedging framework I use myself.

Linear Hedging Framework Explained

High level logic

Before diving into the code itself, I will explain the behavior high level:

We open an order and let it run, if it reaches our take profit target, fine, happy days we close it and move on to the next order. If not...

We open a second order with the same direction and size after a predefined pips gap, for example 500 pips. Then, if the 2nd order, which is the hedge in this case, goes up 250 pips, both orders cancel each other and we close both of them. If not...

We open a third order with the same direction, but this time we use twice the lots. Following the logic above, if it climbs up 375 pips, we will close all the three positions.

We continue opening orders according to this series 1x 1x 2x 2x 3x 3x 4x 4x... where x is the original lot size.

The gap between the orders can be a fixed value or according to some indicator such as volatility/standard deviation.

This method is not dangerous as the infamous martingale in that the margin is reasonable and doesn't cause the account to explode. I am running a live account using this system with the gap set to 500 pips and so far, I didn't have any issues whatsoever. You are welcome to use this code as you wish, stick it in your expert adviser and share the results with me.

MQL4 Full Code

The full code is as follows:

const string SYMBOL=Symbol();
const double CLEANUP_TRIGGER=500*MarketInfo(SYMBOL,MODE_POINT);

if(CleanupFlag==true)
{
CleanupFlag=false;

for(int i=OrdersTotal()-1;i>=0;i--)
if(OrderSelect(i,SELECT_BY_POS) && StringCompare(SYMBOL,OrderSymbol())==0 && StringLen(OrderComment())!=0)
{
CleanupFlag=true;

string Tickets=IntegerToString(OrderTicket());
double Profit=OrderProfit()+OrderCommission()+OrderSwap();

while(StringFind(OrderComment(),";")!=-1)
{
string TheCommentDetails[];
StringSplit(OrderComment(),StringGetCharacter(";",0),TheCommentDetails);
if(OrderSelect((int)StringToInteger(TheCommentDetails[1]),SELECT_BY_TICKET) && OrderCloseTime()==0)
{
Tickets=StringConcatenate(IntegerToString(OrderTicket()),";",Tickets);
Profit+=OrderProfit()+OrderCommission()+OrderSwap();
}
else
{
Log(StringConcatenate("Failed selecing ticket #",IntegerToString(OrderTicket())," line ",__LINE__));
ExpertRemove();
return;
}
}

if(Profit>0)
{
string TheTickets[];
if(StringSplit(Tickets,StringGetCharacter(";",0),TheTickets)>1)
for(int j=ArraySize(TheTickets)-1;j>=0;j--)
if(OrderSelect((int)StringToInteger(TheTickets[j]),SELECT_BY_TICKET) && OrderCloseTime()==0 && CloseOrder((int)StringToInteger(TheTickets[j]))==false)
{
Log(StringConcatenate("Failed closing ticket #",IntegerToString(OrderTicket())," line ",__LINE__));
ExpertRemove();
return;
}
}
}
}

for(int i=OrdersTotal()-1;i>=0;
if(OrderSelect(i,SELECT_BY_POS) && StringCompare(SYMBOL,OrderSymbol())==0 && (OrderProfit()+OrderSwap()+OrderCommission())<0 && MathAbs(OrderOpenPrice()-iClose(SYMBOL,PERIOD_M1,0))>CLEANUP_TRIGGER)
{
CleanupFlag=true;

bool HedgeExists=false;
int TheTicket=OrderTicket();
int TheTicketType=OrderType();
string TheTicketComment=OrderComment();

for(int j=OrdersTotal()-1;j>=0;j--)
if(OrderSelect(j,SELECT_BY_POS) && StringCompare(SYMBOL,OrderSymbol())==0)
{
string TheCommentDetails[];
if(StringSplit(OrderComment(),StringGetCharacter(";",0),TheCommentDetails)==2)
{
if(StringToInteger(TheCommentDetails[1])==TheTicket)
{
HedgeExists=true;
break;
}
}
}

if(HedgeExists==true)
continue;
else if(StringFind(TheTicketComment,";")==-1)
{
if(OpenOrder(SYMBOL,TheTicketType,LOTS,0,0,StringConcatenate(IntegerToString(2),";",IntegerToString(TheTicket)))==-1)
{
Log(StringConcatenate("Failed opening a cleanup position on ticket #",IntegerToString(TheTicket)," line ",__LINE__));
ExpertRemove();
return;
}
}
else
{
string TheCommentDetails[];
StringSplit(TheTicketComment,StringGetCharacter(";",0),TheCommentDetails);
if(OpenOrder(SYMBOL,TheTicketType,(int)MathCeil((double)(StringToInteger(TheCommentDetails[0])+1)/2)*LOTS,0,0,StringConcatenate(IntegerToString(StringToInteger(TheCommentDetails[0])+1),";",IntegerToString(TheTicket)))==-1)
{
Log(StringConcatenate("Failed opening a cleanup position on ticket #",IntegerToString(TheTicket)," line ",__LINE__));
ExpertRemove();
return;
}
}
}

Breaking It Down

Setting the Gap

As mentioned, the first step is deciding what will be the gap we let an order run until we hedge it. This is the same like having a stop loss at the point, but instead, we open another trade with the same direction. In my case, following some exhaustive testing, I realized that a fixed gap works the best for me:

const string SYMBOL=Symbol();
const double CLEANUP_TRIGGER=500*MarketInfo(SYMBOL,MODE_POINT);

In this case, I set the cleanup trigger to 500 pips, so every 500 pips against the order type original direction a new hedge will open.

Hedging

The acutal code to open a new hedge is straightforward. Simply go through the open orders and check if any of their open price is remote from the current price with more than the predefined gap:

for(int i=OrdersTotal()-1;i>=0;i--) 
    if(OrderSelect(i,SELECT_BY_POS) && StringCompare(SYMBOL,OrderSymbol())==0 && (OrderProfit()+OrderSwap()+OrderCommission())<0 && MathAbs(OrderOpenPrice()-iClose(SYMBOL,PERIOD_M1,0))>CLEANUP_TRIGGER)
        {

Then, go through all the open orders and check if there is already a hedge open for this order.

CleanupFlag=true; 
bool HedgeExists=false; 
int TheTicket=OrderTicket(); 
int TheTicketType=OrderType(); 
string TheTicketComment=OrderComment(); 
for(int j=OrdersTotal()-1;j>=0;j--) 
if(OrderSelect(j,SELECT_BY_POS) && StringCompare(SYMBOL,OrderSymbol())==0) 
{ 
string TheCommentDetails[]; if(StringSplit(OrderComment(),StringGetCharacter(";",0),TheCommentDetails)==2) 
{
if(StringToInteger(TheCommentDetails[1])==TheTicket)
{ 
HedgeExists=true; break; 
} 
}
}

Notice that I am using the order comment to tag the order being hedged by a two size array:

TheCommentDetails[0] will hold the hedge level we have at the moment, the higher the level, the bigger the lot size we will open.

TheCommentDetails[1] will hold the order number being hedged, so when the loop is running, we compare if the current prolematic order was hedged already or not.

If there is no hedge for this order, we will open one:

if(HedgeExists==true)
continue;
else if(StringFind(TheTicketComment,";")==-1)
{
if(OpenOrder(SYMBOL,TheTicketType,LOTS,0,0,StringConcatenate(IntegerToString(2),";",IntegerToString(TheTicket)))==-1)
{
Log(StringConcatenate("Failed opening a cleanup position on ticket #",IntegerToString(TheTicket)," line ",__LINE__));
ExpertRemove();
return;
}
}
else
{
string TheCommentDetails[];
StringSplit(TheTicketComment,StringGetCharacter(";",0),TheCommentDetails);
if(OpenOrder(SYMBOL,TheTicketType,(int)MathCeil((double)(StringToInteger(TheCommentDetails[0])+1)/2)*LOTS,0,0,StringConcatenate(IntegerToString(StringToInteger(TheCommentDetails[0])+1),";",IntegerToString(TheTicket)))==-1)
{
Log(StringConcatenate("Failed opening a cleanup position on ticket #",IntegerToString(TheTicket)," line ",__LINE__));
ExpertRemove();
return;
}
}

Closing Hedges

Finally, we go over a loop and check for all the orders, if the hedges sum > 0. If yes, we close them all:

if(CleanupFlag==true)
{
CleanupFlag=false;

for(int i=OrdersTotal()-1;i>=0;i--)
if(OrderSelect(i,SELECT_BY_POS) && StringCompare(SYMBOL,OrderSymbol())==0 && StringLen(OrderComment())!=0)
{
CleanupFlag=true;

string Tickets=IntegerToString(OrderTicket());
double Profit=OrderProfit()+OrderCommission()+OrderSwap();

while(StringFind(OrderComment(),";")!=-1)
{
string TheCommentDetails[];
StringSplit(OrderComment(),StringGetCharacter(";",0),TheCommentDetails);
if(OrderSelect((int)StringToInteger(TheCommentDetails[1]),SELECT_BY_TICKET) && OrderCloseTime()==0)
{
Tickets=StringConcatenate(IntegerToString(OrderTicket()),";",Tickets);
Profit+=OrderProfit()+OrderCommission()+OrderSwap();
}
else
{
Log(StringConcatenate("Failed selecing ticket #",IntegerToString(OrderTicket())," line ",__LINE__));
ExpertRemove();
return;
}
}

if(Profit>0)
{
string TheTickets[];
if(StringSplit(Tickets,StringGetCharacter(";",0),TheTickets)>1)
for(int j=ArraySize(TheTickets)-1;j>=0;j--)
if(OrderSelect((int)StringToInteger(TheTickets[j]),SELECT_BY_TICKET) && OrderCloseTime()==0 && CloseOrder((int)StringToInteger(TheTickets[j]))==false)
{
Log(StringConcatenate("Failed closing ticket #",IntegerToString(OrderTicket())," line ",__LINE__));
ExpertRemove();
return;
}
}
}
}

Stay tuned for my next webinar "FX Algotraind Q&A" scheduled for Thursday 16th August, 19:00-20:00 GMT+2.

For any inquiries, please don’t hesitate to contact me per email or mobile.

FX Trading Q&A

2018-07-29T21:50:00.001+02:00

Introduction

Since I joined Quora platform, my profile is overflooded with questions to do with FX Trading, investig and algotrading. The goal of this post is to summarize the different quetsions I answered already so there is single point to search.

Questions & Answers

How long did it take you to become a profitable trader?
I started in 2008, but only in the last three years my hard work started to pay off. Until then, it was mostly losses, mistakes, wrong strategies and decisions.

The main things I wish I knew back then:

Choose the right broker, one that has the best execution, minimal spreads and excellent customer service. Those who offer gifts and bonuses were mainly causing me more damage than benefit. I did find Darwinex but it took me ages.

Don't buy robots, develop your own strategy. All the robots I bought was a complete disaster and cause me more losses, I learned the hard way that no one sells a successful strategy.

Keep the leverage as low as possible, never use the full leverage offered by the broker.

Earn less but many times, meaning to open small positions and make small profits that accumulate than big positions with high moving p&l.

Later on, when I got confident enough, I started writing a blog myself on Algotrading to share my exprience.

What trading rules do you use or are generally considered best practices in financial speculation?

Personally, the most important one is risk management which mainly rolls around keeping the effective margin below 1:10 ratio. Calculating the effective ratio is straightforward:

Sum all the lots you have opened.

Multiply with 100,000

Divide with your equity

for example, assuming we have 1.5 lots open, it means we control 150,000 units. If we have an equity of 1,000, the effective leverage is 1:15… getting risky.

In my blog, I dedicated a full entry on risk management tools I use, if you’re into algorithmic trading, it might interest you as well.

How can I be a forex trader?
Start by learning what is trade all about and start trading a demo account to get a feeling about it. From educational point of view The School of Pipsology is our free online course that helps beginners learn how to trade forex. If you've always wanted to learn to trade but have no idea where to begin, then this course is for you - School of Pipsology.

What is the best free trading course?
School of Pipsology is a really good start, I used it myself when I started trading. It is build as different levels starting from the basics of pip definition all the way up to advanced indicators and risk management topics.

“The School of Pipsology is our free online course that helps beginners learn how to trade forex. If you've always wanted to learn to trade but have no idea where to begin, then this course is for you.”

If you want to learn about FX Algotrading, I have several articles in my site Ilan Tree - FX Trading 2.0 about this topic as well adics a dedicated course.

What should I learn before starting trading as begginer?
You may have a look at School of Pipsology as a starting point, to understand the basics of trading Forex, right from the pip value.

Once you grasp the knowledge of manual trading, perhaps you will have the interest to move to automated, then you may check Ilan Tree - FX Trading 2.0 course for understanding how to do with MetaTrader and MQL4.

What is your favorite trading (forex, stocks, crypto, etc) platform and why?
I only trade FX actively, the other products like stocks and crypto are done passively. I do so from several reasons:

Liquidity - FX is a very liquid product which is always available for purchasing and selling.

Spread - is minimal and can be close to zero.

Volatility - active and moving quite a lot compare to stocks.

Hard to manipulate the price compare to other products.

I do my trading solely with expert advisers trading on my behalf 24/5. I interfere only when needed, otherwise, I let them run. While with the other products, the market times are changing and available around certain hours.

What percent per year do you make with automated trading strategies? Is it possible to create a profitable strategy based on something as simple as RSI or moving averages crossover?
I am running several strategies in parallel on EURUSD, all have a different reutrn per month but more importantly, they are not correlated.

In general, I am aiming to have between 1–5% return per month. I keep the strategies as simple as possible, but the risk management is the complicated thing. So, for example one of my strategies is using internal bar strength indicator as a signal, but the strategy risk management makes it a profitable one.

This strategy for example - Investment - Ilan Tree is based on bollinger bands. So, you may as simple as you want, but the risk management will be the edge to make your trading a successful one.

I currently use a fix loss value as a border, if the P&L goes below it, the algorithm starts to close positions smartly and go bac into the reasonable levels.

How can I develop a trading robot or Forex signal prediction software using JavaScript?
I am using MQL4 solely for my trading purposes, I didn't have the chance to use JavaScript and honestly I don't see the added value in doing so.

If you're looking to learn about algorithmic trading, have a look at my website Ilan Tree - FX Trading 2.0 and discover how the MetaTrader language works, you might find it simpler than JavaScript and faster time to market.

Must every forex trader have a Myfxbook account?
No, it’s absolutely optional for you to have an account in Myfxbook, it is mainly used to track your performance and show case to potential investors but it’s not a must.

I personally don’t have an account there as I show case my performance in my personal website.

What is your experience of Darwinex, in particular the slippage on connecting your account to a trader?
I use Darwinex brokerage services since two years and so far I can warmly recommend it. The slippage is perfect, their execution is flawless and there are many financial benefits.

I have my own strategy running over their platform, you may see it in my website.

What are the various sources of capital for a sole trader?
There are couple of sources:

Own capital, using savings and/or money you don’t mind putting in risk.

Family/friends

Loans - least recommended if you’re not having a winning strategy which can cover the loan.

Rebates and awards from your broker - personally I am trading with Darwinex who offers rebates on the trading commissions and a competition for the best 48 traders.

If you have a strategy you want to automate, consider writing a code which does what you do manually, then you can minimize the emotional risks involved with trading, see here for some coding examples.

What strategy do you prefer for Intraday Trading, trend following or setting a target and exiting it when the target is achieved?
I always follow the trend and let the winners run, the losers closed. This can be achieved by having a stop loss which progress with the trend or an algorithm which checks every X minutes the current status and makes a decision on what to do next.

See my blog for some ideas how to automate your trading in case that something you thought on doing.

How generic should algorithmic trading be? Should it fit in many pair forex or only one it is okay?
It's a matter of taste, some make it unique to a specific pair but have the risk of over fitting their algorithm. So, when a new information comes, their algorithm fails miserably.

I do as generic as possible so I am able to run it on multiple currencies. Having it simple makes it easier to track the algorithm and understand what went right or wrong.

Are there any trading platforms that run on Linux?
You can even have MetaTrader running on Linux if you follow this article- Install on Linux - Getting Started - MetaTrader 4 Help. I did so myself on my Mac and it works flawlessly.

Does a college degree matter to be a trader? I find all the stuff in my high school class as irrelevant to Forex, stocks and crypto trading.
No, there’s nothing you can’t study online nowadays including trading. There’s so much material available online which can focus on forex, stocks, trading etc.

Personally, I taught myself programming expert advises which are algorithms running in MetaTrader and trade the market on my behalf. I share what I learn in my website and you are welcome to visit and educate yourself.

Is Forex trading easy or difficult?
It’s all a matter of practice and knowledge. Nowadays you can learn a lot online and get equipped with the right tools to succeed. I am in it for years, started manually and now it’s fully automated.

First, you need to decide what are your goals with trading, if it’s to become a millionaire or financially free, I chose the latter as it is more realistic.

As the first step, visit a good website to learn it, something like Learn Forex Trading With BabyPips.com, and then, once you did some trading in demo and real account, think about automating your trading.

What broker provides an international trading account in euro?
The broker I work with and prefer over all the others I used offers it - Darwinex.

You may see examples for algorithmic trading in my website if that’s your goal in trading - www.ilantree.com.

What do you think about online forex trading platforms, and what platform is best and most safe to trade with?
It depends on your needs and legal situation, I personally use Darwinex.

How should I start creating my own trading bot with no foundation in coding?
You can learn MQL programming online, or register to an online course like I am leading.

Is quantitative trading as simple as coding TA rules/strategies into MQL and creating an EA? Is there more to it?
There are many things to consider like:

Finding the right broker

Finding a winning strategy

Managing the risk

etc.

On the programming side, I am leading a course to educate beginners on writing their own expert advisers, check it here.

Does Algotech trading work and how?
Yes, if you have the right strategy in hand and you are able to monitor and intervene when things go out of control you can make a living out of it.

It’s a combination of having a good strategy and the right broker, for me it took several years to find the broker and the strategy. I trade mainly with Darwinex and I publish my strategy performance for interested investors.

If you’re interested to learn about Algotrading, I have my own course with the following syllabus. It all depends on you in this field, it’s not easy, but super interesting.

Moving Averages Trader Implementation for MetaTrader 4

2018-07-12T17:08:00.001+02:00

Introduction

Moving averages trading is the most basic and common trading strategy. It is quoted in most of the trading books and articles and is very easy to follow and implement. The basic strategy is two moving averages, a fast one which is adjusting quicker to the current trend than a slow one.

A classic setup is looking at the 50 days moving average of a certain product and check whether it is above or below the 200 days moving average. If it is above, it is an indicator for going long with this product, if it is below, it is an indicator to short the product.

In this post, I will introduce a basic implementation of an expert adviser, which based on the inputs will trade the product using the price moving averages. You may use it as a basis for something else, modify it as you wish etc.

Input Parameters

These input parameters are controlling the moving average calculation:

input int FastMovingAveragePeriod=50;//Fast Moving Average Period 
input int SlowMovingAveragePeriod=100;//slow Moving Average Period 
input ENUM_TIMEFRAMES Timeframe=PERIOD_D1;//Moving Average Timeframe 
input ENUM_MA_METHOD AveragingMethod=MODE_SMA;//Moving Average Averaging Method 
input ENUM_APPLIED_PRICE AppliedPrice=PRICE_CLOSE;//Moving Average Applied Price 
input int Shift=0;//Moving Average Shift
input double Lots=0.01;//Order Lots

The periods are defined as 50 for the fast moving average and 100 for the slow moving average, which control how many periods will look back when calculating the average.

The Timeframe is the reference for the moving average calculation and data.

The applied price influences which values we use for calculating the moving average.

Shift is the moving average shift in value, the default value is 0, meaning calculating the present value. If you set it for 1 for example the moving average will be calculated on the previous period.

Lots captures the volume to open an order, you may change it to a larger value based on your risk appetite.

Initialization

The OnInit() function is short and verify the periods input parameters. If the fast period is longer than the slow period, the function will return an error and the expert adviser will fail to start. So, when entering values for the periods, make sure that the FastMovingAveragePeriod is smaller than the SlowMovingAveragePeriod:

int OnInit() { 
if(FastMovingAveragePeriod>=SlowMovingAveragePeriod) { 
SendNotification("Fast moving average period value must be smaller than the slow moving average period value"); 
return INIT_PARAMETERS_INCORRECT; 
} 
return INIT_SUCCEEDED; 
}

Trading Logic

Going Long

The first part of the algorithm checks whether the conditions match to go long on the product. It does so by comparing the current fast-moving average value to the slow one. If the fast-moving average value is larger than the short moving average, it will close the short position (if any) and open a long one.

Since we always have one order open, we can call the order select function, choose the only open order and close it safely, having in mind that if the fast is above the slow, there is a chance that the market trend is moving upwards:

if(iMA(Symbol(),Timeframe,FastMovingAveragePeriod,0,AveragingMethod,AppliedPrice,0)>iMA(Symbol(),Timeframe,SlowMovingAveragePeriod,0,AveragingMethod,AppliedPrice,0)) 
{
    if(OrdersTotal()>0 && OrderSelect(0,SELECT_BY_POS) && OrderType()==OP_SELL) 
    {
        if(OrderClose(OrderTicket(),OrderLots(),MarketInfo(Symbol(),MODE_ASK),SLIPPAGE)==false) 
        { 
            SendNotification("Something went wrong when closing an order, existing"); ExpertRemove(); 
            return; 
         } 
    }
    if(OrdersTotal()==0)
    {
        if(OrderSend(Symbol(),OP_BUY,Lots,MarketInfo(Symbol(),MODE_ASK),SLIPPAGE,0,0)==-1) 
        { 
            SendNotification("Something went wrong when opening an order, existing"); 
            ExpertRemove(); 
            return;
        }   
    } 
}

Going Short

The same logic goes for the short direction. Here, we are checking that the fast-moving average value is smaller than the long moving average value. If this is the case, we close the long position (if any) and open a short one:

else 
{ 
    if(OrdersTotal()>0 && OrderSelect(0,SELECT_BY_POS) && OrderType()==OP_BUY) 
    { 
        if(OrderClose(OrderTicket(),OrderLots(),MarketInfo(Symbol(),MODE_BID),SLIPPAGE)==false) 
        { 
            SendNotification("Something went wrong when closing an order, existing"); 
            ExpertRemove(); 
            return; 
        }
    }
    if(OrdersTotal()==0) 
    {
        if(OrderSend(Symbol(),OP_SELL,Lots,MarketInfo(Symbol(),MODE_BID),SLIPPAGE,0,0)==-1)
        { 
            SendNotification("Something went wrong when opening an order, existing"); 
            ExpertRemove(); 
            return; 
         }
     }
 }

Testing

To see how this basic implementation performs, I ran it using the default values with my favorite currency - EURUSD - for the year 2017:

As you see, most of the year, the fast-moving average was above the slow one, so the long position was dominant and captured more than 10,000 pips, or 103.56 dollars in profit. Towards the end of the year, the trend reversed and the a new sell position was opened.

Summary

I introduced a simple working MQL moving averages code for MetaTrader 4 which is available for download here. This strategy closes and opens a position as the trend changes using the moving averages crossover as an indicator. It is only a template and I would not recommend using it with real money, rather as an educational or a starting point for improved strategy such as the Martingale implementation article was.

As always, feel free to leave comments or join our discussion in Facebook.

5 Checks to Enhance your MQL4 Code

2018-06-26T18:25:00.001+02:00

Introduction

Throughout my years as an algotrader, I gained a lot experience with writing optimized MQL4 code. In this post, I am going to share some patterns I am using in my on robots. Some check for connectivity, some for spread, some for volatility etc. Embedding these code snippets in your own, will make your robot more resilient and you will more relax, as you will add self monitoring capabilities to it as well as better trade entry rules.

Server Connectivity Check

From time to time, MetaTrader station losses connectivity with the broker's server. And when that happens, normally, the only thing which works is to restart the platform (or hopefully wait the problem will fix itself). But how can you monitor the platform and get a notification once it is happening?

That's exactly the solution I built for myself. Since the function OnTick() is not called anymore as there is no connectivity. The only solution was to place the monitoring in the OnTimer() function and check every X minutes, normally I do it once per hour.

First, in the OnInit() function, I initialize the timer by calling:

EventSetTimer(PERIOD_H1*60);

This is to call it once per hour, but you may also call it more frequently if you want.

Then, in the OnTimer() function I use the following code:

void OnTimer()
  {
   static bool IsDisconnectedFlag=false;
   if(IsDisconnectedFlag==false && IsConnected()==false)
     {
      SendNotification(StringConcatenate(IntegerToString(AccountNumber()),": Broker connection lost..."));
      IsDisconnectedFlag=true;
     }
   else if(IsDisconnectedFlag==true && IsConnected()==true)
     {
      SendNotification(StringConcatenate(IntegerToString(AccountNumber()),": Broker connection retrieved..."));
      IsDisconnectedFlag=false;
     }
}

First, I set a static variable called IsDisconnectedFlag to false. Then, I check, if the flag is false and the system is disconnected, I send a notification and set the flag to true (so I won't send the notification more than once). Then, in the next calls, if the system is still disconnected, I do nothing as the flag is already set to false. But, if the system got connected from its own, then I will send a notification to inform myself about it and set the IsDisconnectedFlag back to false.

Finally, in the DeInit() function, I call EventKillTimer() to delete the timer.

With this simple code pattern, I don't have the hassle anymore of checking server connectivity. My expert adviser runs and checks itself if the terminal connected to the broker or not, and notify me so I only need to act when needed.

Platform Running Check

What happens if the platform itself shut down unexpectedly? How would you know? It happened to me from time to time that the terminal itself crashed from whatever reason and I missed some good trades. If I wasn't checking the platform or paying attention that something is wrong, I would probably have missed it. So how can you get a notification as soon as the platform crashes?

For that, I am using the following function which is placed within the OnDeinit() function:

void OnDeinit(const int reason)
{
SendNotification(GetUninitReasonText(reason));
}

where

string GetUninitReasonText(int reasonCode) export
{
switch(reasonCode)
{
case REASON_PROGRAM:
return "Expert Advisor terminated its operation by calling the ExpertRemove() function";
case REASON_REMOVE:
return MQLInfoString(MQL_PROGRAM_NAME)+" has been deleted from the chart";
case REASON_RECOMPILE:
return MQLInfoString(MQL_PROGRAM_NAME)+" has been recompiled";
case REASON_CHARTCHANGE:
return "Symbol or chart period has been changed";
case REASON_CHARTCLOSE:
return "Chart was closed";
case REASON_PARAMETERS:
return MQLInfoString(MQL_PROGRAM_NAME)+" input parameters have been changed by a user";
case REASON_ACCOUNT:
return "Another account has been activated or reconnection to the trade server has occurred due to changes in the account settings";
case REASON_TEMPLATE:
return "A new template has been applied";
case REASON_INITFAILED:
return MQLInfoString(MQL_PROGRAM_NAME)+" OnInit() handler has returned a nonzero value";
case REASON_CLOSE:
return "Terminal has been closed";
default:
return "Another reason";
}
}

As you can see in the function body, there are many reasons for the DeInit function to be called and one of them is the REASON_CLOSE which is closing the terminal. With this function, I am notified immediately once the terminal shut down from any reason. Normally, the other reasons are within your control, such as program compiling or closing the chart, but I included them as well for the sake of completion.

Spread Check

I always use this check before opening an order, making sure that the BId-Ask spread is not too big so I don't finance the broker. For that, I am using a fixed value saved as a constant at the global scope of the robot:

const int SPREAD=25;

Then, whenever I want to open an order, I do the following check:

if(MarketInfo(TheSymbol,MODE_SPREAD)<=SPREAD)

Basically, if the symbol spread is below the value I set up, then I will perform the action. In my case is opening an order, but you may do whatever you want, depending on the spread. If the spread is big, it will take longer until you will start profiting from this trade.

For example, let's assume you opened a buy order with a spread of 30 pips. The bid has to move 30 pips and only then you will start seeing some profits. If the volatility for this pair is low, 30 pips will be a long time to wait or it might reach it but turn around after it. As I am mainly trading EURUSD, the spread is not a concern, but there are always events where the broker increases the spread due to some news event or liquidity and I want to be protected for it.

Volatility Check

Volatility can impact your trading significantly. If a currency has a high volatility, it basically means that this currency is vibrating strongly around its price, which means that there are higher chances for your take profit as well as your stop-loss to get hit. As a trader, you have a view on the market, and the last thing you want is to lose it because of the volatility noise (unless you are trading volatility, then you may use this pattern to enter the market when the volatility is high).

To solve this problem, I am only entering the market when the volatility is low in the last hour compare to the last 24 hours. I do it by checking the standard deviation of the price, which is a really good indicator of the volatility:

double STD=iStdDev(Symbol(),PERIOD_H1,24,0,MODE_SMA,PRICE_CLOSE,0);
for(int i=1;i<=24;i++)
if(STD==0 || STD>iStdDev(Symbol(),PERIOD_H1,24,0,MODE_SMA,PRICE_CLOSE,i))
return;

In the first line, I store the current volatility in a variable called STD. Then, I check if in compare to the last 24 hours, the volatility is lower than the current one. If the answer is yes, then I return and do nothing, But, if the volatility is lower than the previous 24 hours. Then, I may continue and trade during this time period.

With a small modification, you may check if the volatility is the highest in the last 24 hours. If you are trading the news, or want to enter only the volatility is high, just use the following code:

double STD=iStdDev(Symbol(),PERIOD_H1,24,0,MODE_SMA,PRICE_CLOSE,0);
for(int i=1;i<=24;i++)
if(STD==0 || STD<iStdDev(Symbol(),PERIOD_H1,24,0,MODE_SMA,PRICE_CLOSE,i))
return;

With that, if in the last 24 hours the product was more volatile than now, the function will return and do nothing.

Worth mentioning. I chose 24 hours as I believe it's enough time to look back and see how the product behave, but you may use different periods and checks.

Chart Period Check

In case your expert adviser must run on a specific chart period (as mine only runs on the 1M). Use the following code and place it at the beginning of the OnInit() function to verify that:

if(ChartPeriod()!=PERIOD_M1)
   ChartSetSymbolPeriod(ChartID(),TheSymbol,PERIOD_M1);

It will check whether the chart period is the one you expect to use. If not, it will change the chart period immediately. In this example, I checked if it's the 1M chart, otherwise, I restart the chart into this period.

Summary

In this post, I introduced 5 code snippets which you can add to your existing MQL4 programs to improve its stability and resilience. I use these patterns in most of the expert advisers I run and have them included in an external library available for purchase here. I hope you will find it useful for your trading.

Martingale MQL Implementation for MetaTrader 4

2018-05-26T16:49:00.001+02:00

Introduction

Martingale per definition is a gambling system of continually doubling the stakes in the hope of an eventual win that must yield a net profit. It is based on the mathematical statement that:

Sum 2^[0... (k-1)]<2^k, meaning the previous sum is always small than the next 2 exponent.

Originally, the method was used in casinos to overcome loses by taking a double position each time. In trading, the method was adopted by setting a target imaginary stop loss, once crossed, a double size position with the same direction would open. If the position will go back enough, the whole structure would close, otherwise, another double position will open after the target point.

What I would like to present in this post is a raw implementation of the martingale strategy in less than 50 lines of code. It is only for educational purposes, so use it on your own risk. Personally, I am using a modified version of the martingale which has a better risk management feature. Nevertheless, it can give you a good starting point to implement your own version.

From performance point of view, you can see in the following picture a typical graph of the martingale strategy:

Which is a smooth graph going up with little hills from time to time. These "hills" are the martingale strategy opening and doubling the positions until the overall account P&L is positive. The higher the hill, the bigger the position which was used to close the martingale.

Implementation

The full code is available here.

Let's look at the main parts of the code:

extern double MartingalePips=100;//Pips gap between Martingale levels

That's the only input the Martingale expert adviser has. This is the gap, or so called the imaginary stop loss level where we will double the position in attempt to close the martingale. Whenever the position goes against it's take profit direction for 100 pips as the default value, a new order will open up.

int OnInit()
{
MartingalePips*=Point;
MathSrand(GetTickCount());
return INIT_SUCCEEDED;
}

The initialization function is straight forward, I convert the input points to pips and set the seed for the random numbers we will use later on using the recommend value of GetTickCount() as per https://docs.mql4.com/math/mathsrand.

The main body is what makes the martingale magic works:

void OnTick()
{
if(OrdersTotal()==0)
{
if(MathRand()%2==0 && OrderSend(Symbol(),OP_BUY,MarketInfo(Symbol(),MODE_MINLOT),Ask,3,0,NormalizeDouble(Bid+MartingalePips,Digits))==-1)
{
SendNotification("Something went wrong when opening an order, existing");
ExpertRemove();
return;
}
else if(OrdersTotal()==0 && OrderSend(Symbol(),OP_SELL,MarketInfo(Symbol(),MODE_MINLOT),Bid,3,0,NormalizeDouble(Ask-MartingalePips,Digits))==-1)
{
SendNotification("Something went wrong when opening an order, existing");
ExpertRemove();
return;
}
}

If there are no orders open, I use a random number and decide based if it's even or not to go long or short. I do this as I have no idea in which direction the market will go and I am using the martingale input pips as the take profit level. For example, if the random number is 11232 I will open a long position with a take profit target of Bid+MartingalePips.
Of course, you may improve this logic and decide smarter using indicators or some statistical values to take a long or short position, I kept it simple for the sake of education.

Next is where the real martingale kicks in:

else
{
if(OrdersTotal()>1 && AccountProfit()>0)
{
for(int i=OrdersTotal()-1; i>=0; i--)
if(OrderSelect(i,SELECT_BY_POS) && OrderClose(OrderTicket(),OrderLots(),OrderType()==OP_BUY?Bid:Ask,3)==false)
{
SendNotification("Something went wrong when closing an order, existing");
ExpertRemove();
return;
}
}
else if(OrderSelect(OrdersTotal()-1,SELECT_BY_POS) && MathAbs(OrderOpenPrice()-(OrderType()==OP_BUY?Ask:Bid))>MartingalePips
&& OrderSend(Symbol(),OrderType(),2*OrderLots(),OrderType()==OP_BUY?Ask:Bid,3,0,0)==-1)
{
SendNotification("Something went wrong when opening an order, existing");
ExpertRemove();
return;
}
}
}

As soon as the position was opened, there could be two options:

The take profit level reached and the position is closed successfully.

The price went against us MartingalePips so we must double our position to close it.

The first case is where we make the money. The second is only to be able to close the martingale with 0 profit (again, you can improve this logic and try capturing some profit when the trend changes).

The first case checks if we have more than one trade and whether the account profit is larger than 0. This case relates to the open martingale, and can only happen when the last order is big enough to cover the other open orders. For example, having 0.01, 0.02, 0.04 and then the last order of the 0.08 profit is larger than the sum of the first three orders.

The second case checks if the last order which was open went below the imaginary stop loss of MartingalePips. If yes, then it opens a new order with the same direction but double the lot size - 2*OrderLots(). Then, if the trend reverses and last position gets stronger than the others, the martingale closes and we open a new position with a take profit.

Run the code yourself, just download the mq4 file, compile it and back test it. There is always a trade off between the martingale pips and the risk, the smaller the more frequent a new position will open with double size.

Summary

I introduced a simple working MQL Martingale code for MetaTrader 4. This strategy doubles the position every X pips aiming to close all the positions as soon as the trend changes. It carries significant risk and I would not recommend using it with real money, rather as an educational or a starting point for improved strategy.

As always, feel free to leave comments or join our discussion in Facebook.

The Ten Commandments for Successful Trading - Part 2

2018-05-06T13:23:00.001+02:00

This is the second part of the "The Ten Commandments for Successful Trading" post.

4th Commandment - Choose the right Broker

I can be the best trader in the world, with the best algorithms, risk management paradigms, trading methods etc. But if I won't have the right broker with me, I would be a complete loser! It took me ages, a lot of reading and disappointments until I found the right one for me, in this case it was Darwinex:

They have the tightest spread on EURUSD I could get, even over the weekend when the market is, the spread is 0.7 pips and less compare to other brokers who could reach 2.5+ easily. During trading hours EURUSD spread becomes so tiny that I don't even consider it in my algorithm. Since I only trade EURUSD like the 1st Commandment says, I don't care about the other currencies at all.

Darwinex has a Direct Market Access, meaning they send all of the client orders direct to market with institutional quality spreads and execution speeds of <5ms. They don't mess with your orders, they don't open a trade again you or net it with others, they just execute it without messing around!

Their team is super nice and supportive, always available via their online chat or phone. I never had an issue getting a response to any of my queries during and after working hours. Their CEO has a startup mentality and bring a lot of innovation to the platform.

They have the best method to let investors invest in my trading algorithm without giving up my proprietary knowledge. So on top of the equity I invested in my algorithm, investors are able to trade my algorithm as if it is a registered product - https://www.darwinex.com/darwin/GFA.4.21. I don't need to deal with regulation or money management, I leave it up to Darwinex and focus on what I know, to trade.

On those investors, I earn performance fees equal to 20% every three months, so the more money I make for them, means more money is made for me. There are traders in Darwinex with millions in investment, they basically living off their trading skills. No other broker I know opens up the door for investors like Darwinex does.

They don't give bonuses for signing up or gifts for nothing. I stay away from all the brokers out there promising you X amount of $$ if you sign up with them. This is so wrong, there is no free money, they only give it away as they know how to get it back from you. For me, a broker who gives money, is a warning sign.

Darwinex do have a certain method you can earn based on performance. So, the better trader you are, the better changes you win a monthly competition called Darwinia which entitles you to earn X thousands $ to manage.

Darwinex analyses my algorithm from different statistical and performance angles which helps me to refine and optimise it. Since I started trading with them, I improved my risk management significantly and started to perform much better thanks to their intuitive repots and information, all for free. So they help you to become a better trader instead of working against you like other brokers.

Deposit and withdrawal is straight forward, no need to wait X days to see my money withdrawn to my account like other brokers out there.

These are the main reasons I chose Darwinex, it helped me to become a better trader and it helped me to get visibility for other investors to buy into my product. So, just like the picture is saying, I work with a broker who helps me to generate money and not eat it away from me.

The 5th Commandment - Be Real

Get real about your return expectations. Don't aim for imaginary numbers like 100%, 70% or even 10% return per month, this will not happen consistently and you will have to take insane risk which will bite you in the end, just a matter of time.

As a comparison, the hedge funds industry finished the year with an average return of 8.5% - https://www.ft.com/content/cd928772-f08a-11e7-b220-857e26d1aca4! So, I am VERY happy if I manage to make a return of 0.5-2% a month. Even it seems very little compare to the many offers out there, it's realistic, and if you add compounding, a monthly return of 2% ends up with 26% annually.

The 6th Commandment - Automate your Trading

I was so relived when I finished automated my trading style and let it run. To trade manually took me so much time and effort. Sitting in front of the screen all day, tracking the news, seeing how the currency moves, the volatility, the risk. So, I decided I take it serious, learn to program MQL, the MetaTrader language and did it.

As my trading style is based on technical details, mathematically simple, it took couple of months to work it out and build a reliable algorithm which runs on real money and open for investor to buy in - https://www.darwinex.com/darwin/GFA.4.21.

If you want a really good starting point to start programming your own algorithm, I suggest you attend one of my webinars where I explain step by step how to develop your own expert adviser from scratch, it's only a matter of time until you are able to write your own code, test it and run it. Otherwise, there are numerous of books on the topic like this one - https://www.amazon.com/Expert-Advisor-Programming-Automated-MetaTrader/dp/0982645902. The moment your algorithm will run, you will relieved, you will not have to worry yourself anymore with looking at the charts non-stop, checking the risk, open and close timing and so on. Just let the PC do it for you. In this time, you will be able to do other things like getting more education, learn new things and improve your strategy.

I am not saying it is straightforward thing to build up a successful expert adviser, otherwise, everyone will do so, but it is far more better than sitting and waiting for the right movement to come, plus, there are so many fake signal providers and expert advisers for sale, I wouldn't count on them to do what I do best.

tbc

The Ten Commandments for Successful Trading

2018-04-29T21:57:00.001+02:00

Introduction

By now, you have probably numerous articles written by professionals telling you how to succeed in trading. These posts were basically telling that you do X or follow plan Y, your trading skills will improve significantly and you will be one step away from retirement and living the dream.

And then reality kicked in, you actually tried, follow the plan step by step but it didn't work. So you read another article, another tip and nothing changes. Why?! I asked myself the same question, and to be honest the answer is quite simple, there is no magic trick, there is no single trick that works generically for everyone and there's no plan for beating the market!

So, instead of telling you what you should do, I will tell you what I do and leave the choice with you if you want to follow or not. I will not claim that I have a method to make you a millionaire overnight and all this crap... I will simply write 10 points which I do my best to follow, 10 painful points which I had to learn by mistake and money loss...

1st Commandment - Trade one product

Just like the first commandment "I am the Lord thy God" I learned the hard way that less is more. I used to trade up to 10 products simultaneously, trying to follow up all the news, all the events, around the clock, non stop. I missed opportunities, closed positions too late, my VAR was insane and overall, I lost more than I gained.

It might sound weird and counterintuitive, but since I started trading only one product, namely - EURUSD, my returns improved significantly and above all, I wasn't worried anymore from burn out. Unless you have some extraordinary artificial intelligence trading system who can go through thousands of news items and understand the impact on the market, then you may ignore what I wrote above. But honestly, my life became much more easy when I started running my algorithmic trading system on EURUSD only. Even it's 95% automated, there are some events which I decide to switch it off, like high volatility ones as non farm payroll in the US (so called NFP), or end of a period to capture the return for that time, so, having it run on a single product, gave me tight control on what's going on.

Now, if you think that I miss other opportunities or make less than I used to, believe me I am not. When EURUSD is ranging, I scalp it, when it is trending, I go with the trend and when it's undergoing some high volatility event, I either ride the wave or pull out. Since I switched, I made in the first month 3.94% and 1.90% in the second.

just to give an example, looking at the upcoming events for the following week using Forex Factory calendar, it was insane and stressful to follow all the high volatility events for the week for all the products I traded, each one can either makes a lot of profit, or ends in a loss:

Now, filtering for EURUSD, it's much more easier to follow what's coming and act accordingly, from 22 high impact events, it went down to only 9 I need to track:

2nd Commandment - Become product expert

Going along with the 1st commandment and with "Thou shalt have no other gods before me", it is critical that now that you chose a single product, become an expert on it, and I am talking to know the internal organs of it if needed:

What is the current rate?

What was the rate a month ago?

What is the expectations of the price to go this year?

Where can you find reliable information on the product? Is it a blog? New agency?...

Are there any analysts covering this product? Is it possible to follow them?

What is a typical volatility of the product? What is a typical a technical indicator of this product?

When is the best time to trade it? Morning? Afternoon? Monday?

Is the product pegged to another product? Are the governments involved tightly overlook the price? How is supply and demand works for this product?

Which impacts certain news events have on the product, what happens to the price if the outcome is above/below expectations etc.

These are some of the questions you need to know even you get woken up in the middle of the night, especially the current price! And that's what I learned on EURUSD, compare to trading and learning ten products in parallel and knowing their behaviour on the surface, I dig deep into EURUSD and understood how it behaves and what impact it.

Only when I truly understand the product I am dealing with, I started to trade it successfully. I minimised the surprise factor to a minimum and then I automated what I learned. You could argue that I over optimised my system for this single product, but that's actually what I wanted, there is no single system fits all in my eyes anyway...

On the other hand, if at some point in the future the product I chose will fail and proves itself unworthy anymore, I will move on and choose another one, just to say, it is not till death do us part, only until the product cheats on us again and again so we have no chance but move on with our life.

3rd Commandment - Manage risk

I already dedicated a full post about managing risk just to stress how much it is important. The majority of accounts blowing up is due to poor risk management, meaning opening far too many orders with massive lot sizes which can't be managed. And once the margin is below the critical level, each order gets closed one after the other leaving the investor with nothing. It happened to me so many times when I started trading years ago, super frustrating!

And still, it is always amazes me to see people posting pictures of their accounts claiming they made thousands in couple of days, then people are super excited and actually follow these clowns. Every time I took a chance and follow these over-leveraged account they blew out, it is not the way it should work.

Just as an example, I recently followed a guy who claimed he was able to make 3,000$ every week using an initial investment of 1,000$ which is of course not possible, guess what, here was his account after couple of weeks:

So things started to get out of control, then what he did was even more insane was to open more positions agains the trend, obviously EURUSD was going down but this guy went with more positions against it, only to get:

Obviously, it didn't less for long and his account got blown up...

As a rule of thumb, perform this calculation BEFORE opening a new order:

Sum up all the lots, longs as positive, shorts as negative

Get the absolute value of the previous step

Multiply with 100,000

Divide with your account balance

For example, the guy had 8 long positions of 0.25 which is 2 lots in total minus two short positions of 0.25 which leaves us with 1.5 lots. Multiply with 100,000 gives 150,000 and dividing with his equity is 150,000 / 2,087 = 71. This is INSANE leverage, so called effective leverage of 1:71. When I speak with investors, they want values in the range of 1:5-6 maximum.

So bottom line, I always make sure my risk is under control and I never over leverage and keeping my trading under control. For example, one of my algorithms has effective leverage of 0 as I am net zero on both directions:

The numbers might look small, but as I am trading over Darwinex, the investor copies the strategy and enjoys a nice return 1-4% with minimum risk.

How to Remote Control an Expert Adviser in MQL4 using Pending Orders

2018-03-31T18:21:00.001+02:00

Introduction

Our goal as algotraders, is to create an autonomous trading algorithm with as little as possible manual intervention. An algorithm which can run by it's own on a certain product while we are doing something else, letting the money work classic paradigm.

Alas, sometimes life is not the way we want to be and the algorithm we design, programmed and tested behaves completely different under certain market conditions. But you're not always next to your PC, you're not always able to perform or change something as you have your own life. Assuming you're sitting in your favourite bar with friends and suddenly some news event happens which impacts significantly the volatility, what can you do then?

I had the same scenarios over and over again, where I couldn't control my expert adviser without logging into my PC or to the remote PC to make the actual change, which was really frustrating and time consuming. I was thinking again and again, why isn't there a way to signal the EA to do something and move on, how can I "speak" with the EA even I am 100km away...

Solution

I realised that the solution is much simpler than I thought. Basically, my idea was having a listener on the number of the orders opened, and each time a new order was added, I would check whether it's an ordinary order or an instruction order. Where an instruction order is a normal pending order with a dedicated range of prices, in my case 2000-... (I am trading mainly FX products who are not in this range of pricing).

Setup

Before looking at the code itself, you must make sure that you enabled notifications in Metatrader. Doing so is quite straightforward, select from the menu tools -> options and navigate to the notifications tab:

In there, tick the "Enable Push Notifications" and enter your MetaQuotes ID, a value which can be found in the mobile application you're using. In iPhone the ID is found at the bottom of the "Chat and Messages Page":

Once you entered the ID details in Metatrader, click test and expect to see a message in your mobile device, if not, double check your input.

Orders Number Listener

As the title suggests, this piece of code listens to the Orders number and acts upon a change:

if(OrdersNumber!=OrdersTotal())

  OrdersNumber=OrdersTotal();

  ProcessRemoteInstructions();

I place it in the OnTick function and check whether the Orders Number changed from the last tick, normally I check every minute as I don't expect to have so many instructions coming in.

OrdersNumber is a global integer variable which I initialise as part of the OnInit function to the current OrdersNumber value:

OrdersNumber=OrdersTotal();

So the number did change, I store the new value and process the remote instructions if any.

Processing Remote Instructions

Now that we are listening on the orders number, it's time to do something if the number changed. In the following function, I run over the orders and if it is a pending buy sell order with a price in the range of 2000... I execute according to predefined action:

void ProcessRemoteInstructions()

 for(int i=OrdersTotal()-1;i>=0;i--)

 if(OrderSelect(i,SELECT_BY_POS) && StringCompare(TheSymbol,OrderSymbol())==0 && (OrderType()==OP_BUYSTOP || OrderType()==OP_SELLLIMIT))

 switch((int)OrderOpenPrice())

 case 2000:

 OrderDelete(OrderTicket());

SendNotification(StringConcatenate(

 "1 Remove expert\n"

 "2 ..."

));

 break;

 case 2001:

OrderDelete(OrderTicket());

SendNotification("Incoming request to remove the expert, exiting...");

 ExpertRemove();

 return;

 case 2002:...

In this small example, I loop through the open orders looking for pending orders. If the pending order is in the price range of 2000+ I act upon it and delete it. In this case, I have two scenarios:

2000: In this case just send a notification to the mobile device with all the avaialble remote instructions.

2001: Terminate the expert adviser.

Usage

Coming back to our scenario. Assuming I am sitting in a bar chilling out after a long day of trading and suddenly I see something I don't like in the market. All I need to do now is open a pending order with the price of 2001 and the expert adviser will pick it up and terminate itself so I can go back and relax (instead of login into the remote host and do the same, which is not straightforward).

Of course, I gave here a simple example of a remote instruction. In my expert adviser, I tailored the instructions to my trading style, there in an instruction to open up a specific order, or open a hedge, calculate volatility and so on. But the pattern is still the same:

Open a pending order with a specific price

The expert adviser picks up the instruction and execute remotly

The expert adviser sends a notification open receipt / completion.

Hope it helps, for any questions don't hesitate to comment here or contact me per telegram / email.

Release Management Pattern for Expert Advisors

2018-01-13T16:34:00.001+01:00

The Challenge

As an FX algotrader who is implementing his own Expert Advisers, I make code changes from time to time which must be reflected in the production environment as soon as possible. But running Experts on different hosts with different brokers means that I need to login to each box, update the SVN repo, compile and install the Expert again. What if this task could be automated? So every time I check in a new version, the Expert auto update and restarts itself.

That´s exactly the setup I am going to explain in this post. Once understood, you will be able to implement the same method in your code and have your Experts always running the last version as soon as you check in, sort of release management setup for Metatrader.

Before divining into the actual setup, make sure you familiarize yourself with MQL5Storage and how to register to get it by visiting this link.

Metatrader Setup

Before looking at the code changes, we need to make sure Metatrader is set up properly to update the local repository. We do that by navigating to the MQL4 folder where the SVN root is located and checking out the files again (It might sound weird to check out via the terminal even we check out inside the platform, but it is necessary as the platform does not create the .svn folder).

We do this by checking out the repository by typing:

svn co https://storage.mql5.com/svn/personal/REPO_NAME.

Once the MQL4 folder is checked out, you may test is by typing svn info and get an informative response such as:

Working Copy Root Path: C:\Users\...\MQL4
URL: https://storage.mql5.com/svn/personal/.../MQL4
Relative URL: ^/..../MQL4
Repository Root: https://storage.mql5.com/svn/personal
Repository UUID: ...
Revision: ...
Node Kind: directory
Schedule: normal
Last Changed Author: ...
Last Changed Rev: ...
Last Changed Date: 2018-01-18 17:36:26 +0100 (Thu, 18 Jan 2018)

Next, in the /files folder create a file called SVNUP.bat with the following contents:

svn cleanup ../
svn up ../

This file will be used later when updating the repository from within the Expert Advisor.

Also, create a file called revision.txt with a numerical value representing the current SVN version you work on, in my case I marked the starting value as 1.

If you follow the above steps, the MQL4 folder should have the .svn folder containing the repository information:

and the Files folder should have two new files, SVNUP.bat and revision.txt:

Let´s move on to the next step...

Shell Execute Function

For the release management tool to work, you must be familiar with ShellExecuteW function available by importing shell32.dll in Windows. As noted in MSDN, this function call allows you to perform an action on a file. We will use this function in our calls for the following actions:

Update the local SVN repository using the SVNUP.bat we created in the previous step.

Compile the relevant files using a call to Metaeditor /compile

Starting with the first step, in my code I created an hourly timer event to check whether something changed in the repository, sort of pulling behavior. In the Timer I execute the following code snippet:

int HINSTANCE=ShellExecuteW(NULL,NULL,"SVNUP.bat","",StringConcatenate(TerminalInfoString(TERMINAL_DATA_PATH),"\\MQL4\\Files"),0);
if(HINSTANCE<=32)
{
SendNotification(StringConcatenate(IntegerToString(AccountNumber()),": ShellExecuteW SVNUP.bat failed - ",ShellExecuteErrorDescription(HINSTANCE)));
return false;
}

This basically calls the SVNUP.bat file I created in the previous stage which check and updates the local SVN repo. If the return code is smaller than 32, it means some error occurred while calling ShellExecuteW function. If all went well, the local repo has the latest files locally, so we can go ahead and check whether something actually changed.

As mentioned above, I created a text file called Revision.txt where I save a numerical value which tracks the current version. Each time I make a code change worth updating, I change this value, i.e 19 -> 20...

Next, following a SVN update call, I have a function checking whether this version changed by reading the file and comparing the value to the current one in the memory:

int GetRevision()
{
string RevisionFileName="Revision.txt";
if(FileIsExist(RevisionFileName)==false)
    {
    SendNotification(StringConcatenate(IntegerToString(AccountNumber()),": Revision file doesn't exist"));
    return -1;
    }
else
    {
    int RevisionFileHandle=FileOpen(RevisionFileName,FILE_TXT|FILE_READ);
    if(RevisionFileHandle==INVALID_HANDLE)
        {
        SendNotification(StringConcatenate(IntegerToString(AccountNumber()),": Operation FileOpen failed, ",ErrorDescription(GetLastError())));
        return -1;
        }
    else
        {
        int Output=(int)StringToInteger(FileReadString(RevisionFileHandle));
        FileClose(RevisionFileHandle);
        return Output;
        }
    }
}

Now that I have the revision value, I call the following check (worth mentioning that I let the adviser sleep for a minute to make sure the updated files are available already and got synched locally after the svn up call):

Sleep(60000);
int Output=GetRevision();
if(Output==-1)
    return false;
else if(Revision!=Output)
{
    Revision=Output;
    SendNotification(StringConcatenate(IntegerToString(AccountNumber()),": Revision updated to ",IntegerToString(Revision),", initializing experts"));
    if(CompileFile(FilePath)==false)
        return false;

I am checking whether the revision value changed, and if it did, I call CompileFile function which compile the path to the file I work on:

bool CompileFile(string Filename)
{
int HINSTANCE=ShellExecuteW(NULL,NULL,"metaeditor.exe",StringConcatenate("/compile:\"",Filename,"\""),TerminalPath(),4);
if(HINSTANCE<=32)
    {
    SendNotification(StringConcatenate(IntegerToString(AccountNumber()),": ShellExecuteW metaeditor.exe ",Filename," failed - ",ShellExecuteErrorDescription(HINSTANCE)));
    return false;
    }
return true;
}

This is achieved again by using ShellExecuteW and calling Metaeditor, which with the /compile parameter is compiling the input file. After compilation, I let the adviser sleep again a minute before restarting the it:

Sleep(60000);
ChartApplyTemplate(ChartID(),"Template.tpl");

In this case, the template Controller.tpl is applying the same adviser on the current chart, thus triggering a restart with the new code I just created.

For completeness, here is the function I am using to describe the error in case ShellExecuteW fails:

string ShellExecuteErrorDescription(int error_code) export
 {
 string error_string;

 switch(error_code)
 {
 //--- codes returned from shell execute
 case 0: error_string="The operating system is out of memory or resources."; break;
 case 2: error_string="The specified file was not found"; break;
 case 3: error_string="The specified path was not found."; break;
 case 5: error_string="Windows 95 only: The operating system denied access to the specified file"; break;
 case 8: error_string="Windows 95 only: There was not enough memory to complete the operation."; break;
 case 10: error_string="Wrong Windows version"; break;
 case 11: error_string="The .EXE file is invalid (non-Win32 .EXE or error in .EXE image)."; break;
 case 12: error_string="Application was designed for a different operating system"; break;
 case 13: error_string="Application was designed for MS-DOS 4.0"; break;
 case 15: error_string="Attempt to load a real-mode program"; break;
 case 16: error_string="Attempt to load a second instance of an application with non-readonly data segments"; break;
 case 19: error_string="Attempt to load a compressed application file"; break;
 case 20: error_string="Dynamic-link library (DLL) file failure"; break;
 case 26: error_string="A sharing violation occurred."; break;
 case 27: error_string="The filename association is incomplete or invalid."; break;
 case 28: error_string="The DDE transaction could not be completed because the request timed out."; break;
 case 29: error_string="The DDE transaction failed."; break;
 case 30: error_string="The DDE transaction could not be completed because other DDE transactions were being processed."; break;
 case 31: error_string="There is no application associated with the given filename extension."; break;
 case 32: error_string="Windows 95 only: The specified dynamic-link library was not found."; break;
 default: error_string=StringConcatenate("unknown error - ",IntegerToString(
 return(error_string);
 }

Summary

In this post, I introduced the method I am using to monitor and update my Expert advisers remotely across the different brokers I work with. Using this method, you will be able to develop, compile and check in your code locally followed by an auto updated of the remote Experts.

I used an hourly check where I am calling a function to confirm whether the code actually changed using the revision file, but you may want to use shorter timer if you want more frequent checks.

This method saved me time login into different hosts and made it quite simple and convenient for me to check in once and have all of the different experts updated at the same time.

Using the Donchian Indicator to enhance your Trading

2017-09-23T13:13:00.001+02:00

The Donchian channel is available for purchase here.

Richard Davoud Donchian was an Armenian-American commodities and futures trader, and pioneer in the field of managed futures who came up with a simple intuitive indicator called the Donchian channel. It is basically based on the lowest low value or the highest high value in a given period of time:

Calculation

As mentioned, Donchian is based on marking the lowest low line or the highest high line, so visually you see the trend of the product. Whenever the product reached a value which is higher than the last 24 values or lower than the previous ones, a new markup will start until it reverses.
Calculating it with MQL is straightforward, to find out the highest value of the product in a given period, we use the following snippet:

double HighestHigh=iClose(Symbol(),Period(),iHighest(Symbol(),Period(),MODE_CLOSE,TradePeriod,0));

Here, reading from right to left, we first find the shift of the highest value using a call to iHighest, and then, using the return value which is the shift itself, calling iClose to retrieve it. It is possible to run this code with MODE_HIGH, MODE_OPEN etc to get the highest value, but normally I call it with MODE_CLOSE as this is the final value after the price vibrated in that period.
Calculating the lowest low is more or less the same:
double LowestLow=iClose(Symbol(),Period(),iLowest(Symbol(),Period(),MODE_CLOSE,TradePeriod,0));
Here, we just call the iLowest function instead to receive the value.

Now that we have these values, we can mark them on the indicator and paint the chart accordingly. For example, I use the following code to make the painting:

  if(i>0)
{
if(CLOSE>HighestHigh && TrendDirection[i+1]!=OP_BUY)
{
TrendDirection[i]=OP_BUY;
SendNotification(StringConcatenate(Symbol()," go long"));
}
else if(CLOSE
{
TrendDirection[i]=OP_SELL;
SendNotification(StringConcatenate(Symbol()," go short"));
}
}
if(TrendDirection[i]==OP_BUY)
ExtMapBuffer1[i]=LowestLow;
else if(TrendDirection[i]==OP_SELL)
ExtMapBuffer2[i]=HighestHigh;

Whenever the trend changed direction, I get notified over Metatrader, but it is possible also to get an E-mail or any other means of communication. This way, whenever new highs or lows are achieved, I am notified immediately and can make trading decisions on how to proceed with my positions.

Usage

I mostly run this indicator on the hourly chart of the products I trade. It is not too short time frame for randomness and noise to kick in, and not too long that the trend might be discovered towards the end. On my mobile, the notifications will look like:

EURGBP go long 10:30
EURGBP go short 12:45
...

As it is just one of the indicators I use, I don't rush and open a position, rather check the current market conditions and news to see what the overall sentiment for this product.
For example, I was long EURGBP the last month, strongly believing the Brexit does good to the EUR, the upcoming elections and many supporting ideas for me to follow. But actually, after looking at the Donchian around the time I opened the order, I noticed it is a free fall, which only recently is coming towards an end:

Looking at the indicator behavior around the 8th September, shows a clear sign of an upcoming bearish trend of EURGBP, with a short reversal and then down again. So, going long was not the right choice at the time and closing the positions was the right choice.

Normally, as I am a volatility trader, I don't look for trend and trade both directions of the market to capture profit. But still, as I like simplicity, the Donchian give me that trending piece of information I need to make a decision whether it is a ranging market which is my favorite or a trending market and then my decisions on taking a side are critical.

Turtle Trading

Interesting point was that during the 80's, there was the famous experiment to prove that anyone can be a trader, so called the turtle traders. And as mentioned in the original rules which can be found here - http://bigpicture.typepad.com/comments/files/turtlerules.pdf. The trading entry system was based on breakouts, where breakout was defined as the price exceeding the high or low of a particular number of days. Thus a 20-day breakout would be defined as exceeding the high or low of the preceding 20 days.
In my trading, I use it more as a flag signaling me whether I should go into a trade or not, but only after I have several positions and I want to hedge them, plus, I am using the hourly chart as mentioned above.

Code

The full code is here and in the downloads page for you to use it, feel free to contact me for any questions:
//+------------------------------------------------------------------+
//| Donchian |
//| Copyright 2017, IlanTree |
//| http://www.ilantree.com |
//+------------------------------------------------------------------+
#property copyright "Roy Meshulam"
#property version "1.00"
#property description "As a user of this trading system, you acknowledge and agree to accept complete responsibility for ANY and ALL results in your trading account. You acknowledge and agree that you are fully aware of the high risk associated with trading. You acknowledge and agree that leveraged currency trading can cause losses greater than your beginning balance. You acknowledge and agree that Roy Meshulam has made NO promises or guarantees suggesting that this trading system will result in a profit or loss."
#property link "http://www.ilantree.com"
#property strict

#property indicator_chart_window
#property indicator_buffers 2
#property indicator_color1 DodgerBlue
#property indicator_color2 Red
#property indicator_width1 3
#property indicator_width2 3

input int TradePeriod=24;// Donchian channel period

double ExtMapBuffer1[];
double ExtMapBuffer2[];
double TrendDirection[];

static datetime TimeStamp;
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int init()
{
IndicatorBuffers(3);

SetIndexStyle(0,DRAW_LINE);
SetIndexStyle(1,DRAW_LINE);
IndicatorDigits((int)MarketInfo(Symbol(),MODE_DIGITS));

IndicatorShortName("Donchian Channels ("+IntegerToString(TradePeriod)+")");
SetIndexLabel(0,"Lower channel");
SetIndexLabel(1,"Upper channel");

SetIndexBuffer(0,ExtMapBuffer1);
SetIndexBuffer(1,ExtMapBuffer2);
SetIndexBuffer(2,TrendDirection);

return(0);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int start()
{
int counted_bars=IndicatorCounted();
if(counted_bars<0) return(-1); int limit=Bars-1-counted_bars; if(counted_bars==0) limit-=1+1; for(int i=limit; i>=0; i--)
{
TrendDirection[i]=TrendDirection[i+1];

ExtMapBuffer1[i]=ExtMapBuffer2[i]=EMPTY_VALUE;

double HighestHigh=iClose(Symbol(),Period(),iHighest(Symbol(),Period(),MODE_CLOSE,TradePeriod,i+1));
double LowestLow=iClose(Symbol(),Period(),iLowest(Symbol(),Period(),MODE_CLOSE,TradePeriod,i+1));

double CLOSE=iClose(Symbol(),0,i);

if(i>0)
{
if(CLOSE>HighestHigh && TrendDirection[i+1]!=OP_BUY)
{
TrendDirection[i]=OP_BUY;
SendNotification(StringConcatenate(Symbol()," go long"));
}
else if(CLOSE {
TrendDirection[i]=OP_SELL;
SendNotification(StringConcatenate(Symbol()," go short"));
}
}

if(TrendDirection[i]==OP_BUY)
ExtMapBuffer1[i]=LowestLow;
else if(TrendDirection[i]==OP_SELL)
ExtMapBuffer2[i]=HighestHigh;
}

return(0);
}
//+------------------------------------------------------------------+

Checking Metatrader connectivity

2017-08-20T17:37:00.001+02:00

When running Metatrader locally, the first action the platform does when it starts up is connecting to the near by broker server. You may it clearly by looking at the lower right part of the platform and checking the connectivity status:

In this case, you may see it is green and traffic is floating successfully between the terminal to the server. If from some reason, there is no connectivity, this terminal section would look like:

Manual solution

The manual solution is quite straightforward, mainly close and reopening the terminal. The challenge is knowing the connectivity got lost at the first place. When it happens, there is no way to tell unless you write the code which tells you the connectivity got lost. Once you know it happened, you need to restart the terminal and hope the problem got sorted out. If it continues, you can either scan the available serves or contact your broker.

Automated Connection monitoring

As noted above, it is challenging to know when the connectivity is lost if you're not sitting in front of your PC 24/5. For someone like who uses fully automated expert advisers, it is critical for me to know ASAP when the connectivity got lost. So, I will able to action on this issue and resolve it. The good news are that with 10-20 lines of code, you may create your own monitoring utility:
- first, we setup a timer. As we can't trust OnTick function to be called when there is a disconnection with the server, we must check it every X minutes, I personally use an hourly timer:
EventSetTimer(60*PERIOD_H1);
This will call OnTimer function every hour so we will be able to test for connectivity.
- In the function OnTimer, I will check for connectivity and set a certain flag to notify me if the connectivity got restored:

void OnTimer()
{
if(IsDisconnectedFlag==false && IsConnected()==false)
{
SendNotification("Broker connection lost...");
IsDisconnectedFlag=true;
}
else if(IsDisconnectedFlag==true && IsConnected()==true)
{
SendNotification("Broker connection retrieved...");
IsDisconnectedFlag=false;
}
}

This code simply notifies you if the connection got lost, or later on restored. Since the server connectivity is lost and not the internet connection, it is still possible to send notifications to your mobile device.

With this simple addition to your expert adviser, you will be able to get notified in real time that the terminal lost connection with the broker so you can safely act on it and try to fix it.

Don't forget to visit my downloads page for additional expert advisers, indicators and libraries.

How to safely open an order in MQL4

2017-08-06T19:02:00.001+02:00

All the functions discussed here are part of the Common library available for purchase.

In trading, it's critical to confirm certain criteria and conditions before opening an order. These checks may impact on your profitability or notify you in case something failed.

My checks

For me, it's important to verify before opening an order in MQL4 the following conditions:
- Is the spread acceptable? i.e. whether it's below a certain fixed value which I predefined.
- Is the trade context busy? This thread is the one which eventually opens the orders, if busy, it will not be possible to open the order anyway.
- Do we have enough margin to trade? As noted here, margin is critical factor when trading and could make a difference between a successful account to wiped one.
- Check open order returned value. As per MQL4 specifications, open order returns the order id which was opened or -1 in case it failed - https://docs.mql4.com/trading/ordersend. It is a good practice to check the value before doing anything with that order.

Coding it all

Let's build the code that does these checks and open an order if all conditions are satisfied. The function signature is:

int OpenOrder(string argSymbol,int argOrderType,double argLotSize,double argSL=0,double argTP=0,string argComment=NULL,int argMagicNumber=0,int argSpread=0) export

The function returns the value received from OrderSend function, or -1 if the function fails from any reason.
1. argSymbol is the symbol we want to open order on.
2. argOrderType whether it's OP_BUY or OP_SELL
3. argLotSize - how many lots we want to trade
4. argSL - optional argument holding the order stop loss level. If the order is a Buy, then the stop loss must be below the open price, otherwise, for a sell, the stop loss must be above the open price.
5. argTP - optional argument holding the order take profit level. If the order is a Buy, then the take profit must be above the open price, otherwise, for a sell, the take profit must be below the open price.
6. argComment - optional string to use as the order's comment. Please note, that If the order comment length is above 31 characters. the mt4 server will automatically reject the order.
7. argMagicNumber - optional integer representing the order magic number, a value which can be used later to link order to an expert adviser.
8. argSpread - an optional value used as a spread threshold to open an order.

putting it all together

starting from the last argument, if provided I will not open an order, if the symbol spread is larger than the value:
if(argSpread>0 && MarketInfo(argSymbol,MODE_SPREAD)>argSpread) { SendNotification(StringConcatenate("Open order declined, symbol spread ",DoubleToString(MarketInfo(argSymbol,MODE_SPREAD),0)," is larger than ",IntegerToString(argSpread))); return -1; }
Using the latest spread value for this symbol, I reject it if it's larger.

Next, I am checking whether the trade context, the thread which is responsible for the order themselves is busy. If it is, I will reject the open order request:
else if(IsTradeContextBusy()) { SendNotification("Open order declined, trade context is busy"); return -1; }

If the function was called with an order type different than OP_BUY/OP_SELL this code will reject if(argOrderType!=OP_BUY && argOrderType!=OP_SELL) { SendNotification(StringConcatenate("Open order declined, illegal order type = ",IntegerToString(argOrderType))); return -1; }

We then check for enough margin to make this order, but calling a function I mentioned in my post about margin:
else if(ConfirmEnoughMargin(argSymbol,argOrderType,argLotSize)==false) { SendNotification(StringConcatenate("Open order declined, not enough equity to open new position, remaining equity if opened = ",DoubleToString(AccountFreeMarginCheck(argSymbol,argOrderType,argLotSize),2)," ",AccountCurrency())); return -1; }
Where ConfirmEnoughMargin is defined as:
bool ConfirmEnoughMargin(string argSymbol,int argOrderType,double argLotSize) export { if(AccountStopoutMode()==0 && MathRound(AccountMargin()+AccountFreeMargin()-AccountFreeMarginCheck(argSymbol,argOrderType,argLotSize))!=0 && (100*AccountEquity()/(AccountMargin()+AccountFreeMargin()-AccountFreeMarginCheck(argSymbol,argOrderType,argLotSize)))<AccountStopoutLevel() && GetLastError()==134) { SendNotification(StringConcatenate("Confrim enough margin failed with account stopout mode 0, free margin if opened will be ",DoubleToString(AccountFreeMarginCheck(argSymbol,argOrderType,argLotSize),2)),134); return false; } else if(AccountStopoutMode()==1 && AccountFreeMarginCheck(argSymbol,argOrderType,argLotSize)<AccountStopoutLevel() && GetLastError()==134) { SendNotification(argSymbol,argLotSize,StringConcatenate("Confrim enough margin failed with account stopout mode 1, free margin if opened will be ",DoubleToString(AccountFreeMarginCheck(argSymbol,argOrderType,argLotSize),2)),134); return false; } return true; }

Finally, if all the checks passed successfully, we call MQL4 internal OrderSend function and return the value:
else { int Order=OrderSend(argSymbol,argOrderType,VerifyLotSize(argSymbol,argLotSize),argOrderType==OP_BUY?MarketInfo(argSymbol,MODE_ASK):MarketInfo(argSymbol,MODE_BID),Slippage,NormalizeDouble(argSL,(int)MarketInfo(argSymbol,MODE_DIGITS)),NormalizeDouble(argTP,(int)MarketInfo(argSymbol,MODE_DIGITS)),argComment==NULL?MQLInfoString(MQL_PROGRAM_NAME):argComment,argMagicNumber,0,argOrderType==OP_BUY?clrGreen:clrRed); if(Order==-1) LogError(argSymbol,argLotSize,"Open order failed"); return Order; }

The whole function is:

int OpenOrder(string argSymbol,int argOrderType,double argLotSize,double argSL=0,double argTP=0,string argComment=NULL,int argMagicNumber=0,int argSpread=0) export
{
if(argSpread>0 && MarketInfo(argSymbol,MODE_SPREAD)>argSpread)
{
LogError(argSymbol,argLotSize,StringConcatenate("Open order declined, symbol spread ",DoubleToString(MarketInfo(argSymbol,MODE_SPREAD),0)," is larger than ",IntegerToString(argSpread)));
return -1;
}
else if(IsTradeContextBusy())
{
LogError(argSymbol,argLotSize,"Open order declined, trade context is busy");
return -1;
}
if(argOrderType!=OP_BUY && argOrderType!=OP_SELL)
{
LogError(argSymbol,argLotSize,StringConcatenate("Open order declined, illegal order type = ",IntegerToString(argOrderType)));
return -1;
}
else if(ConfirmEnoughMargin(argSymbol,argOrderType,argLotSize)==false)
{
LogError(argSymbol,argLotSize,StringConcatenate("Open order declined, not enough equity to open new position, remaining equity if opened = ",DoubleToString(AccountFreeMarginCheck(argSymbol,argOrderType,argLotSize),2)," ",AccountCurrency()));
return -1;
}
else
{
int Order=OrderSend(argSymbol,argOrderType,VerifyLotSize(argSymbol,argLotSize),argOrderType==OP_BUY?MarketInfo(argSymbol,MODE_ASK):MarketInfo(argSymbol,MODE_BID),Slippage,NormalizeDouble(argSL,(int)MarketInfo(argSymbol,MODE_DIGITS)),NormalizeDouble(argTP,(int)MarketInfo(argSymbol,MODE_DIGITS)),argComment==NULL?MQLInfoString(MQL_PROGRAM_NAME):argComment,argMagicNumber,0,argOrderType==OP_BUY?clrGreen:clrRed);
if(Order==-1)
LogError(argSymbol,argLotSize,"Open order failed");
return Order;
}
}

Forex correlation calculation with MQL4

2017-07-17T13:37:00.001+02:00

All the functions discussed here are part of the Statistics library available for purchase.

While watching Wimbledon finals yesterday in the UK. I was thinking of all the significant economical events we are going through in Europe, the Brexit, elections etc. and how are the different pairs I am trading got affected. The statistical value which show the significance of the dependency between two products is called Correlation.

According to https://en.wikipedia.org/wiki/Correlation_and_dependence, Correlation can be calculated using the following equation:

Correlation(EURUSD,USDJPY)=Covariance(EURUSD,USDJPY) / STD(EURUSD)*STD(USDJPY)

Correlation ranges between -1, that when EURUSD trends upwards, USDJPY expected to trend downwards. 0, meaning there is no dependency between these currencies at all. Or +1, meaning the currencies are expected to trend in the same direction.

Why would you care?

EURUSD and EURCHF have correlation of -1 in most of the times. Imagine you went long on EURUSD believing there is an upwards potential for the currency and profit to be made. Now, if indeed EURCHF is reversed correlated to EURUSD, opening a short position on EURCHF will increase your risk twice when EURUSD changes direction. Because now, EURUSD will be short, and EURCHF which is reversed correlated will go long. You are losing both on the long EURUSD position AND the short EURCHF one.

If you are not able to calculate Correlations dynamically, you would not identify this situation and make this mistake, not able to recognize what went wrong. The challenge with calculating correlation is the dynamics of the products. The values are always changing, it is not a static set of values which are easy to calculate.

Calculating Correlation step by step

We start with the simple part of the equation and that is the denominator. Meaning, we need to calculate the standard deviation of the currency for a given values over a period of time. Standard deviation is defined as the squared root of the sample variance, which is the sum of differences of the sample from the sample mean:

Standard Deviation = Square(Variance(EURUSD)) = Square(∑(EURUSDi - mean(EURUSD)) / Sample Size)

Calculating the mean

Let's start by calculating the sample mean. This is basically running over the sample which is captured in an array, summing the values and dividing with the sample size.

double Mean(double &argArr[]) export
{
double length=ArraySize(argArr);

double sum=0;
for(int i=(int)(length-1); i>=0; i--)
sum+=argArr[i];
return sum/length;
}
Since I place this function in a library, I used the keyword export. This function runs on argArr, summing it's values and then dividing by the array size.

Calculating the variance

In the previous step, we calculated the sample mean. Now we will use it to calculate the sample variance. As per the variance formula, we need to sum up the square difference of the sample values from it's mean:

double Variance(double &argArr[]) export
{
double length=ArraySize(argArr);
double mean=Mean(argArr);

double sum=0;
for(int i=(int)(length-1); i>=0; i--)
sum+=MathPow(argArr[i]-mean,2);
return sum/(length-1);
}

Again, I am using this function from within a library, so I used the export reserved keyword. Then, calling the Mean function introduced in the previous part, mean saves the argArr mean value. All we have to do, is to run over the array and sum up the difference between the array values in index i to the mean we calculated. The returned value is the sample's variance, thus we divide it with (n-1).

Calculating the standard deviation

This part is rather simple. Since we have the sample's variance calculated already, all we need to do is to return it's squared root:

double StandardDeviation(double &argArr[]) export
{
return MathSqrt(Variance(argArr));
}

As you can see, the standard deviation function only calculates the squared root on the variance function return value.

Calculating Covariance

double Covariance(double &arrX[],double &arrY[]) export
{
if(ArraySize(arrX)!=ArraySize(arrY))
return -1;

double length=ArraySize(arrX);
double meanX=Mean(arrX);
double meanY=Mean(arrY);

numerator=0;
for(int i=(int)(length-1); i>=0; i--)
numerator+=(arrX[i]-meanX)*(arrY[i]-meanY);
return numerator/(length-1);
}

Covariance is the sum of differences between a value to it's mean between two series. So, in this case we calculate the mean of EURUSD, the mean of USDJPY and sum up the differences of the values from the currency series with the mean. Then dividing it with the series length-1 as it is a sample.

Putting it all together

Now that we have it all the necessary code to calculate the correlation between two products, it's time to put it into action. The following code shows as an example how to print the correlation between the current product to the other open orders you have. You may use this code and print to the screen the correlation between the different products:

const int CORRELATION_HISTORY=2524;
double X[],Y[];
ArrayResize(X,CORRELATION_HISTORY);
ArrayInitialize(X,0);

for(int i=0;i<CORRELATION_HISTORY;i++)
X[i]=iClose(Symbol(),PERIOD_H1,i);

ArrayResize(Y,CORRELATION_HISTORY);
string CorrelationStr="";
string CurrSymbol="";
for(int i=OrdersTotal()-1;i>=0;i--)
if(OrderSelect(i,SELECT_BY_POS) && StringFind(CorrelationStr,OrderSymbol())==-1 && StringCompare(OrderSymbol(),Symbol())!=0)
{
CurrSymbol=OrderSymbol();
ArrayInitialize(Y,0);
for(int j=0;j<CORRELATION_HISTORY;j++)
Y[j]=iClose(CurrSymbol,PERIOD_H1,j); CorrelationStr=StringConcatenate(CurrSymbol," ",DoubleToString(Correlation(X,Y),2)," ",CorrelationStr);
}
Print(CorrelationStr);

I normally take a period of 240 values, but of course you may take larger values if you want. The following output shows the correlation between USDJPY to the other products I have open orders on:

The MQL4 Lot Size Functions I Use In My Algotrading Code

2017-07-02T18:10:00.001+02:00

All the functions discussed here are part of the Common library available for purchase.

The goal of this post is to share with you some functions I am using to verify and manage the lot size I used when opening an order. As mentioned in my home page, I am using proprietary algorithm to trade the 25% cash I don't invest in the permanent portfolio. To achieve that, I programmed an Expert Advisor using MQL language which is running 24/5 and trade 5 currency pairs. In here, you can find the relevant darwin which can be traded as a normal financial product thanks to the Darwinex broker.

Managing Lot Size

As noted in another post about leverage, it is important to keep the leverage / lot size under control. Most common junior mistakes are trading massive lot sizes to gain quick wins, but as soon as the market turns against them, their account is completely wiped out without a chance to react (speaking from experience). So, in this post I will share three functions I am using to verify and manage lot sizes I am using in my own expert advisor. You may copy paste this code and use it on your own responsibility in your own code.

Verify Lot Size

Perhaps the simplest and most common function of all. I use this one whenever I am about to open a position, to verify the lot size is:

Above the minimum lot size allowed

Below the maximum lot size allowed

Allows micro or mini lots as per the broker.

double VerifyLotSize(string argSymbol,double argLotSize) export
{
argLotSize=MarketInfo(argSymbol,MODE_LOTSTEP)==0.1?NormalizeDouble(argLotSize,1):NormalizeDouble(argLotSize,2);
return MathMax(MarketInfo(argSymbol,MODE_MINLOT),MathMin(MarketInfo(argSymbol,MODE_MAXLOT),argLotSize));
}

Starting from the declaration, you can the return value is the actual verified lot size. There are two arguments, the symbol you want to open the order for and the lot size you want to open. A typical call would look like:

double Lots=VerifyLotSize("EURUSD",0.02);

If the size provided is legitimate, the return value will be equal to the input, in this case to 0.02 lot size. On the other hand, there are a couple of checks happening which will influence the result:

First, we check in MarketInfo(argSymbol,MODE_LOTSTEP) how many digits the broker allows, whether mini lots are allowed (0.1) or micro as well (0.01). Based on the return value, we trim the lot size if needed. If for example, the broker only allows mini lots, 0.11 will turn into 0.1 lots and the 0.01 will get trimmed.

Then, MathMin(MarketInfo(argSymbol,MODE_MAXLOT),argLotSize) verifies that the requested lot size is smaller than the maximum for that currency, in my case, the maximum lot size I can open per trade is 1,000 which is 100,000,000 units.

Finally, MathMax is called on the result of the previous step to verify the lot size is larger than the minimum lot size offered by the broker.

Running this function on several examples for EURUSD will give the following output:

Print(VerifyLotSize(Symbol(),0.001)); --> 0.01
Print(VerifyLotSize(Symbol(),0.00)); --> 0.01
Print(VerifyLotSize(Symbol(),100000.001)); --> 1,000
Print(VerifyLotSize(Symbol(),0.123)); --> 0.12

Best place to use this function is right before opening an order, so you can be certain that the lot size you are using is legal. I normally use specific exposure per trade based on percentage from my equity so it looks like that:

double Lots = VerifyLotSize(TheSymbol,(Exposure/100)*AccountEquity()/100000);

Confirm Enough Margin

[caption id="attachment_176" align="alignnone" width="300"] photo by CafeCredit[/caption]

The next function verifies whether you have enough margin before opening the order. So, if you know how much lots you want to trade and verified it in the previous step, this step will check if you even have enough margin to open the order at all.

bool ConfirmEnoughMargin(string argSymbol,int argOrderType,double argLotSize) export { if(AccountStopoutMode()==0 && (AccountMargin()+AccountFreeMargin()-AccountFreeMarginCheck(argSymbol,argOrderType,argLotSize))!=0 && (100*AccountEquity()/(AccountMargin()+AccountFreeMargin()-AccountFreeMarginCheck(argSymbol,argOrderType,argLotSize)))

As per the signature, this function returns true or false based on the check it performs. The inputs are the symbol you want to open the order on, the lots size you want to trade and order type which is either OP_BUY or OP_SELL.

As described in MQL reference, there are two modes to calculate whether you have enough margin to open the order:

0 - calculation of percentage ratio between margin and equity.
1 - comparison of the free margin level to the absolute value.

Based on that, I built the function to confirm there is enough margin to open the trade:

If your broker is using the percentage method. We need to check that the ratio between the account equity and the margin is less the the stop out level using the following code - (100*AccountEquity()/(AccountMargin()+AccountFreeMargin()-AccountFreeMarginCheck(argSymbol,argOrderType,argLotSize)))

On the other case, if you broker is using method number 1 to compare the margin to the absolute value, we use the following code - AccountFreeMarginCheck(argSymbol,argOrderType,argLotSize)

In both case, if the check fails, and opening the order will result with a situation you won`t have enough margin, error 134 will be thrown. In this case the function fails and a false value will return. Otherwise, if both checks passes, a true will return and you may proceed and open this position. Using this function will save you an error returned from the open order and check whether the order ticket is not equal to -1 upon failure.

Running this function on several examples for EURUSD will give the following output, assuming equity is 100,000:

Print(ConfirmEnoughMargin(Symbol(),OP_BUY,0.01)); --> true
Print(ConfirmEnoughMargin(Symbol(),OP_BUY,1)); --> true
Print(ConfirmEnoughMargin(Symbol(),OP_BUY,100)); --> true
Print(ConfirmEnoughMargin(Symbol(),OP_BUY,1000)); --> false

You can see in the last case it is failing, as I am trying to open a position to control 100,000,000 Units which requires a margin of 500,000 which is more than my equity. Otherwise, the other functions return true so it is safe from margin point of view to open them. Still, it doesn`t mean you need to ignore your effective leverage and make sure you are still nicely leverage, i.e. below 1:10 as explained here.

Calculate Lot Size Based On Risk

The last function in my arsenal is to calculate the lot size I want to open based on a risk parameter. In my case, I use the volatility to open an order which will loss at the worse case a certain percentage of my account over a specific timeframe.

double CalcRiskBasedLotSize(string argSymbol,double argPercentageRiskPerOrder,int argTimeframe,int argSTDFactor,int argSTDPeriod) export { double Risk=AccountBalance()*argPercentageRiskPerOrder/100; double STDPips=argSTDFactor*iStdDev(argSymbol,argTimeframe,argSTDPeriod,0,MODE_SMA,PRICE_CLOSE,0)/MarketInfo(argSymbol,MODE_POINT); return STDPips==0?MarketInfo(argSymbol,MODE_MINLOT):VerifyLotSize(argSymbol,Risk/(STDPips*MarketInfo(argSymbol,MODE_TICKVALUE))); }

This function return value is the calculated lot size based on the risk parameters you provide:

argSymbol - product the calculate the lot for.

argPercentageRiskPerOrder - how much you want to risk for this trade (1%, 2%...).

argTimeframe - timeframe to calculate the volatility (PERIOD_D1, PERIOD_H1...).

argSTDFactor - factor to multiply the volatility, in case you want to have double the amount, triple etc...

argSTDPeriod - period to test the volatility over

The first line of code calculate how much of your balance you would like to risk as per the first argument - double Risk=AccountBalance()*argPercentageRiskPerOrder/100;

Then, using the next parameters we calculate how much volatility in pips we have in his timeframe -

double STDPips=argSTDFactor*iStdDev(argSymbol,argTimeframe,argSTDPeriod,0,MODE_SMA,PRICE_CLOSE,0)/MarketInfo(argSymbol,MODE_POINT);

The division with MarketInfo(argSymbol, MODE_POINT) make sure we convert it from decimal value to pips value.

Finally, the last line calculate the lot size according to the risk parameters. The main part is Risk/(STDPips*MarketInfo(argSymbol,MODE_TICKVALUE)). Here, we divide the amount we would like to risk with the volatility. The value we get is the lot size, that over this volatility will lose the amount we calculated in the first stage.
For example, let's say you have an account with 100,000 USD and you want to risk 2% of it using the daily volatility. Using a daily volatility of 890 pips the calculated pips will be:

(2%*100,000) / 890 = 2.24.

Meaning, that if the order goes 890 pips against you as per the daily volatility, you will lost 2,000 USD which is 2% from your equity.

In my code, usually I run it with the following input - double Lots = CalcRiskBasedLotSize("EURUSD",2%,PERIOD_D1,1,20), which calculates the lot size based on 20 days volatility.

Running an example code with different values gives the following values:

Print(CalcRiskBasedLotSize("EURUSD",1,PERIOD_D1,1,20)); --> 1.69
Print(CalcRiskBasedLotSize("EURUSD",2,PERIOD_D1,1,20)); --> 3.38
Print(CalcRiskBasedLotSize("EURUSD",1,PERIOD_M1,1,20)); --> 140.98
Print(CalcRiskBasedLotSize("EURUSD",1,PERIOD_W1,1,20)); --> 0.63

If you look at the third line, you might be surprise we got 140.98 as lot size. But if you think about it, the volatility for one minute is really low, so to risk 1% of your balance, you must open a very large lot size position.

Summary

I presented these three functions I used almost always in my algotrading code. It make my code safe to use and run 24/5 a week, recognize errors and prevent over leveraging my portfolio. On top of these functions I have separate error handling logic I didn`t present when this functions return a negative value. One trick I usually do is setting a value to the AccountMargin() and "putting" the EA to sleep until the margin changes, but I will cover error handling in another post.

Swiss Permanent Portfolio Performance H1/2017

2017-07-01T22:39:00.001+02:00

The first half of the year is over, time to check the Swiss permanent portfolio performance. As per the definition set by Harry Brown, the permanent portfolio should consist of 4 pillars:

Equities

Bondsbonds.

Gold

Cash

Swiss Permanent Portfolio Version

Using the above template as basis and as explained in here, I split my investment within 3 funds:

AUCHAH - The fund aims to primarily reflect gold's performance, after deduction of the running costs. The fund's assets are exclusively invested in physical Gold.

CSBGC0 - The fund invests exclusively in bonds and other fixed or variable-rate debt instruments and rights, denominated in Swiss francs, of the Swiss Confederation, which are included in the Swiss Bond Index Domestic Government 7+.

SPICHA - The fund's investment objective is to replicate the price performance and returns of the Swiss Performance Index SPI(R). The SPI(R) comprises the about 230 largest stocks in the Swiss equity market.

Cash - Using my own proprietary algorithm to trade with Darwinex.

January - June Performance

Just looking at the first three asset classes during the first six months. We can see that both equities and gold performed well, summing up to 16.46%:

This is somehow weird behavior as normally Gold and Equities are correlated reversely to each other, i.e. Gold tends to rise when Equities fall and vice versa. For me it shows that the market is not really certain what is going on, from one side rise of the equities is a good sign of stability and growth, but on the side gold appreciation shows a mood of uncertainty and worries.

In Summary

The beauty of the permanent portfolio is it's ability to generate positive revenue independently of the market behavior. There will always be a part which benefits of the current financial atmosphere. Growth environment will push the equities part upwards, inflation affects the gold and deflation affects positively the bonds. I created the Swiss version mentioned above since I want to remove the currency risk out of the equation.

I love this setup as it is so easy to build and maintain. Basically, you need to make sure there is always equal parts of your capital split between the assets. Once in every three months invest your saved capital and re-balance the portfolio, that`s about it.

Disclaimer: I am an amateur investor. I don

t have financial adviser license or any other financial license. The contents of this post are not professional guidance or recommendation to do any action with any financial instrument and you can

t use them instead of consulting a professional who knows your specific needs. If you choose to use this information, you are doing it on your account and responsibility.