MQL5 Cookbook - Pivot trading signals

Denis Kirichenko | 16 May, 2017

Introduction

The current article continues the series describing indicators and setups that generate trading signals. This time, we will have a look at the pivots — reversal levels (points). We will apply the Standard Library again. First, we will consider the reversal level indicator, develop a basic strategy based on it and finally search for the means to improve it.

It is assumed that the reader is familiar with the CExpertSignal base class for developing trading signal generators.

1. Pivot (reversal level) indicator

For this strategy, we will use the indicator plotting potential reversal levels. Plotting is performed by means of graphical construction only. No graphical objects are applied. The main advantage of this approach is the ability to refer to the indicator in the optimization mode. On the other hand, graphical constructions cannot exceed the indicator buffers meaning there will be no lines in the future.

Levels can be counted in several different ways. Further information on this subject is available in the article "Trading strategy based on pivot points analysis".

Let's consider the standard approach for now (the levels are defined using the following equations):

RES is an ith resistance level, while SUP is an ith support level. In total, there will be 1 main reversal level (PP), 6 resistance (RES) and 6 support levels (SUP).

So, visually the indicator looks like a set of horizontal levels plotted at different prices. When launched on the chart for the first time, the indicator draws levels for the current day only (Fig.1).

Fig.1. Pivot indicator: plotting for the current day

Let's examine the indicator code block by block beginning with the calculation one.

When a new day begins, we need to count all reversal levels.

The red color highlights the strings where the levels are re-calculated. Next, we should find the bar for the current timeframe to be used as a starting point for plotting levels. Its value is defined by the gBarStart variable. The SUserDateTime custom structure (the descendant of the CDateTime structure) is used during the search for working with dates and time.

Now, let's focus our attention on the block designed for filling buffer values for the current timeframe bars.

Calculation of buffers begins when a new bar appears on the chart the indicator is launched at. The yellow color highlights the definition of the bar number, up to which the buffers are calculated. The local counter of calculated bars is used for that. We need it because the beginning of a new day does not reset the prev_calculated constant value to zero, although such a reset is necessary.

The full code of the pivot indicator can be found in the Pivots.mq5 file.

2. Basic strategy

Let's develop a simple basic strategy based on the described indicator. Let the open signal depend on the Open price location relative to the central pivot. The price touching the pivot level serves as a signal confirmation.

The EURUSD M15 chart (Fig.2) displays the day (January 15, 2015) Open level below the central pivot. However, later during the day, the price touches the pivot level upwards. Thus, there is a sell signal. If neither stop loss nor take profit are activated, the market exit is performed at the beginning of the next day.

Fig.2. Basic strategy: sell signal

Stop levels are bound to the pivot indicator reversal levels. The intermediate resistance level Res0.5 at $1.18153 serves as a stop loss when selling. The main support level Sup1.0 at $1.17301 is used as a take profit. We will return to the trading day of January 14 later. In the meantime, let's have a look at the code that is to form the essence of the basic strategy.

2.1 CSignalPivots signal class

Let's create a signal class that will generate signals from various patterns formed on the basis of price dynamics and the reversal levels indicator.

I already used that approach in the article "MQL5 Cookbook - Trading signals of moving channels": the price touching a line is confirmed when the price falls into the line area. The m_pnt_near data member sets the tolerance for a reversal level.

The signal pattern served by the class plays the most important role. The base class is to have a single pattern. Apart from the weight (m_pattern_0), it also has a completion property within a trading day (m_pattern_0_done).

The CExpertSignal base signal class is rich in virtual methods. This allows for implementing fine-tuning of the derived class.

In particular, I have re-defined the OpenLongParams() and OpenShortParams() methods for calculating trading levels.

Let's examine the code of the first method — defining values for trading levels when buying.

The stop loss price is calculated as the value of the first secondary support level using the MinorSupport() method. The profit is set at the price of the first main resistance level using the MajorResistance() method. In case of selling, the methods are replaced with MinorResistance() and MajorSupport() accordingly.

Make the custom signal the main one to let the methods for defining trading levels work properly. Here is how the method for defining the parent class trading levels looks like:

If no main signal index is set, the levels receive default values. In order to avoid this, set the following in the EA code when initializing the signal:

The buy condition verification method is present as follows:

It is easy to see that the touch from above is checked considering the tolerance last_low<=(m_pivot_val+m_pnt_near).

Apart from other things, the Direction() method for defining the "weighted" direction checks if the basic pattern is complete.

As for exit signals, re-define the parent class methods CloseLongParams() and CloseShortParams(). Sample buy block code:

The exit signal threshold should be reset to zero in the EA code.

No direction check is performed in that case.

The question arises: How is the exit signal checked in that case? First, it is checked by the presence of a position (in the Processing() method ), and second, using the m_pattern_0_done property (in the redefined CloseLongParams() and CloseShortParams() methods). As soon as the EA detects a position while the Pattern 0 is incomplete, it attempts to close it at once. This happens at the beginning of a trading day.

We have examined the basics of the CSignalPivots signal class. Now, let's dwell on the strategy class.

2.2 CPivotsExpert trading strategy class

The derived strategy class is similar to the one for moving channels. The first difference is that minute-by-minute trading mode is used instead of tick-by-tick one. This allows you to quickly test the strategy on a fairly deep history. Second, the check for exit is present. We have already defined when the EA can close a position.

The main handler method looks as follows:

That's it. Now, we may launch the basic strategy. Its code is presented in the BasePivotsTrader.mq5 file.

Fig.3. Basic strategy: sell

Let's get back to the day of January 14, 2015. In this case, the model worked out perfectly. We opened short on the pivot and closed on the main support level Sup1.0.

The run was made in the strategy tester from 07.01.2013 to 07.01.2017 on EURUSD M15 with the following parameters:

• Entry signal threshold, [0...100] = 10;
• Weight, [0...1.0] = 1,0;
• Fixed volume = 0,1;
• Tolerance, points = 15.
  

As it turns out, the strategy trades with a steady result. A negative one (Fig. 4).

Fig.4. EURUSD: Results of the first basic strategy for 2013-2016

Judging by the results, we did everything wrong. We should have bought at a sell signal and sold at a buy one. But is it true? Let's check. To do this, we should develop a basic strategy and implement changes in the signals. In this case, a buy condition will look as follows:

Let's launch another strategy in the tester and obtain the result:

Fig.5. EURUSD: Results of the second basic strategy for 2013-2016

Obviously, the mirroring of the first version did not happen. Probably, the reason is the stop loss and take profit values. Besides, positions with no stop levels activated during a trading day are closed when a new day starts.

Let's try to change the second version of the basic strategy, so that a stop loss level is placed farther when buying — before the main support level Sup1.0, while the profit size is limited by the intermediate resistance level Res0.5. When selling, a stop loss is to be placed on Res1.0, while a take profit — on Sup0.5.

In this case, trading levels for buying are defined the following way:

The result of the third version in the tester is as follows:

Fig.6. EURUSD: Results of the third basic strategy for 2013-2016

The image is more or less similar to the mirrored first version. At first glance, it seems that the Grail is found. But there are some pitfalls we are going to discuss below.

3. Robustness

If we look closely at Fig. 6, we can easily see that the balance curve grew unevenly. There were the segments where the balance accumulated profits steadily. There were also the drawdown segments as well as the ones where the balance curve moved strictly to the right.

In general, we can say that the strategy lacks robustness. Is it possible to improve it? Let's try.

3.1 Trend indicator

In my opinion, the trading rules described above work better when there is a directional movement in the market — a trend. The strategy showed the best result on EURUSD in 2014 — early 2015 when the pair was in a steady decline.

This means we need a filter allowing us to avoid a flat. There are plenty of materials about determining a stable trend. You can also find them in the Articles section on mql5.com. Personally, I like the article "Several ways of finding a trend in MQL5" most. It offers a convenient and, more importantly, universal way of searching for a trend.

I have developed a similar indicator MaTrendCatcher. It compares the fast and slow Moving Averages. If the difference between them is positive, the trend is bullish. The indicator histogram bars are equal to 1. If the difference is negative, the trend is bearish. The bars are equal to minus 1 (Fig. 7).

Fig.7. MaTrendCatcher trend indicator

Besides, if the difference between the Moving Averages increases relative to the previous bar (a trend becomes stronger), the bar is green, otherwise it is red.

Another feature added to the indicator: if the difference between MAs is insignificant, the bars are not displayed. The value of the difference, at which the bars are hidden, depends on the "Cutoff, pp" indicator parameter (Fig. 8).

Fig.8. MaTrendCatcher trend indicator with small differences hidden

So, let's use the MaTrendCatcher indicator for filtration.

To apply the indicator, we need to implement some changes in the code of the project files. Note that the last version of the EA is to be stored in the Model folder.

For this strategy, we need to obtain the calculated value of the "weighted" direction. Therefore, we need a custom class descendant from the base signal class.

Then, a new model appears in the updated signal class of reversal levels — Model 1 "trend-flat-countertrend".

In essence, it complements Model 0. Therefore, it can be called a sub-pattern. We will note that in the code a bit later.

Now, verification of buy conditions looks as follows:

‌

The green block highlights where the sub-pattern is applied.

The idea behind the calculation is as follows: if the market entry is performed without considering the sub-pattern, the signal result is equal to the Pattern 0 weight. If the sub-pattern is considered, the following options are possible:

1. entering in the direction of a trend with acceleration (trend and acceleration bonuses);
2. entering in the direction of a trend without acceleration (trend bonus and acceleration penalty);
3. entering against a trend with acceleration (countertrend and acceleration penalties);
4. entering against a trend with acceleration (countertrend penalty and acceleration bonus).

This approach avoids reacting to a weak signal. If the signal weight overcomes a threshold value, it affects the trading volume size. The pivot EA class features the CPivotsExpert::LotCoefficient() method:

For instance, if the signal has gathered 120 grades, the initial volume is adjusted by 1.2, while in case of 70, it is adjusted by 0.7.

To apply the ratio, it is still necessary to re-define the OpenLong() and OpenShort() methods. For example, the buy method is represented as follows:

The idea with the dynamic formation of the lot size is quite simple: the stronger the signal, the greater the risk.

3.2 Range size

It is easy to see that reversal levels (pivots) are close to each other indicating a low market volatility. To avoid trading on such days, the "Width limit, pp" parameter has been introduced. The Pattern 0 (together with the sub-pattern) is considered complete if the limit is not exceeded. The limit is verified in the Direction() method body. Below is a part of the code:

If the signal does not pass the range width verification, the following entry appears in the Journal:

Launch the strategy in the tester in the optimization mode. I have used the following optimization parameters:

1. "Width limit, pp";
2. "Tolerance, pp";
3. "Fast МА";
4. "Slow МА";
5. "Cut-off, pp".

The most successful run in terms of profitability looks as follows:

Fig.9. EURUSD: Results of the strategy with the use of filters for 2013-2016

‌

As expected, some signals were sorted out. The balance curve became smoother.

But there are also fails. As seen on the chart, the strategy generates segments where the balance curve fluctuates in a narrow range without a visible increase in profit starting with 2015. The optimization results can be found in the EURUSD_model.xml file.

Let's look at the results on other symbols.

The best run for USDJPY is displayed on Fig.10.

Fig.10. USDJPY: Results of the strategy with the use of filters for 2013-2016

‌

Now, let's have a look at spot gold. The best result is shown in Fig. 11.

Fig.11. XAUUSD: Results of the strategy with the use of filters for 2013-2016

‌

During this period, the precious metal was trading in a narrow range, so the strategy did not bring a positive result.

As for GBP, the best run is displayed in Fig. 12.

Fig.12. GBPUSD: Results of the strategy with the use of filters for 2013-2016

‌

GBP traded quite well in the direction of a trend. But the correction in 2015 spoiled the final result.

In general, the strategy works best during a trend.

‌

Conclusion

Trading strategy development consists of several stages. At the initial stage, the trading idea is formulated. In most cases, this is a hypothesis that needs to be formalized in the form of a code and then checked in the tester. It is often necessary to adjust and refine such a hypothesis during the testing process. This is the standard work of a developer. Here we use the same approach to code the pivot strategy. In my opinion, OOP greatly simplifies the task.

All tests in the optimization mode were conducted in the MQL5 Cloud Network. The cloud technology allowed me to evaluate the efficiency of the strategies in quick and non-costly manner.

File location

‌

It is most convenient to put the strategy files to the single Pivots folder. Move the indicator files (Pivots.ex5 and MaTrendCatcher.ex5) to the %MQL5\Indicators indicator folder after the compilation.