Library of functions and Experts for tracking / Yury Dzyuban - MetaTrader 4 Library

blank trailing atr( integer tickets, integer atr_timerange, integer atr1_period,
integer atr1_shift, integer atr2_period, integer atr2_shift,
Coefficient of double , boolean TrillingLoss)

 blank trailing ratchetB( integer votes, integer pf_level_1, integer pf_level_2,
Integer pf_level_3, integer ls_level_1,
Integer ls_level_2, integer ls_level_3,
boolean trillinglos)

A ratchet key is a key that "moves in one direction only." The name is mine, in the Barishpolts' description it is called the "second trailing strategy" (as opposed to the "first" with "standard" - further stop loss), in the Barishpolts version Golden IV - the so-called "third level" trailing. The idea: quickly move to the breakeven point and follow it step by step with small profits (after that it is recommended to use a different tracking method, such as the standard method, or my standard "step by step" or any of the above). The feasibility of this kind of tracking - "Absolutely most positions are profitable at least for a while", so the stop loss should be moved to breakeven as soon as possible. If it "closes" early but the opening signal is still present, a re-entry is possible. Generally speaking, there will be a large number of trades that close at breakeven, and there may also be some trades that make a good profit - these trades move significantly in the profitable direction after opening the trade. The author emphasizes that this tracking is not for "spreads" but to achieve a low proportion of unprofitable trades.

parameter:
ticket - unique order number (selected before calling function OrderSelect() );
pf_level_1 - the profit level (in pips) to move the stop loss to the breakeven point;
pf_level_2 - the distance to move the stop loss from +1 to the profit level (in points) pf_level_1 the opening price in pips;
pf_level_3 - the profit level of the trailing stop (in points) pf_level_1 to pf_level_2 opening price in points (end of function operation);
ls_level_1 - when the position profit reaches +1 (i.e. at +1, the stop loss will be moved to ls_level_1 );
ls_level_2 - the distance to set the stop loss if the price initially falls below the opening price ls_level_1 and then rises (i.e. there is a loss, but starts to decrease - it is not allowed to increase again);
ls_level_3 - sets a stop loss distance of ls_level_2 if the price is initially below the opening price and then rises;
Trillinlos - > Whether to move the stop loss to the "unprofitable" zone, i.e. the interval between the initial stop loss and the opening price (true - trailing, false - trailing is only activated if the new stop loss is "better" than the opening price, "profitable").

The author of this idea recommends using the following values ​​for EURUSD: "5, 10, 25", that is, at +5 (i.e. "compensate" the spread and get 5 more profit points), the stop loss is moved to +1 (during manual trading it is recommended to "remember this number" so as not to tempt the trader), at +10 pips the stop loss is moved to +5, at +25 pips the stop loss is moved to +10 and the price "lets go" (it can be tightened by other methods). The author does not describe a similar part of the loss interval function, which was developed by his followers in discussions. There is evidence that the author (quite successfully) uses this method of trading on his investment projects, and this may be one of the factors that contributes to the very high profit margins in his trades. At the same time, it should be noted that this trailing algorithm is very specific and may not suit everyone.

8. Trailing by price channel (suggested by rebus ).

 Blank tracking by price channel ( integer e-ticket, integer iBars_n, integer i indent)

parameter:
eTicketing - unique order number (selected before calling function OrderSelect() );
iBars_n - channel period (find the number of bars with the highest and lowest prices respectively - the upper and lower borders of the channel);
Indent - Set the indent of the stop loss from the channel borders (in points).

The results of price channel tracking are actually consistent with the results of candle shadow tracking (see above), and are somewhat similar to fractal tracking, although it differs in "concept" and "feasibility".

9. Behind the moving average.

 blank tracking MA( integer e-ticket, integer iTmFrme, integer iMAP period, integer iMA move,
integer MA method, integer iAppl price, integer move, integer i indent)

This idea is basically “half a step away” from the tracking of price channels. The function is passed the warehouse order, the required time frame, the MA offset (in points) to set the stop loss, and MA parameters (similar to those in standard iMA()). Considering the nature of moving averages, it is easy to guess that this algorithm is capable of producing a reasonably good tightening during trends, although during consolidation it can "confuse" the price and often lead to premature closing of positions. However, tracking parameters (especially the averaging method and period) can be changed appropriately to suit market conditions (e.g. to take volatility into account).

parameter:
eTicketing - unique order number (selected before calling function OrderSelect() );
iTmFrme - chart period for calculating moving averages; allowed input options: 1 (M1), 5 (M5), 15 (M15), 30 (M30), 60 (H1), 240 (H4), 1440 (D), 10080 (W), 43200 (MN);
iMAPeriod - calculates the average period of the moving average;
iMAShift - movement of the indicator relative to the price chart;
iMA method - averaging method; allowed input options: 0 (MODE_SMA), 1 (MODE_EMA), 2 (MODE_SMMA), 3 (MODE_LWMA);
iAppl price- Applicable prices; input options: 0 (PRICE_CLOSE), 1 (PRICE_OPEN), 2 (PRICE_HIGH), 3 (PRICE_LOW), 4 (PRICE_MEDIAN), 5 (PRICE_TYPICAL), 6 (PRICE_WEIGHTED);
iShift - moves backward by the specified number of periods relative to the current bar;
iIndent - the indent (in points) from the MA value to set the stop loss.

10. "Fifty-five" follows.

 Blank trailing fifty-fifty ( integer ticket, integer iTmFrme, double d coefficient,
Boolean bTrlinloss)

The idea is as follows: when another bar closes, reduce the distance between the stop loss and the current price by dCoeff times (the initial value is 0.5, hence the name). For example, there is an open buy position with a stop loss of 40 pips. When the entry bar closes, the bid price will be 42 points higher than the opening price. If the only "profitable" (bTrlinloss==true) tracking mode is selected, then take the distance from the opening price to the current price - 42 pips, multiply by dCoeff (for example 0.5), get 21 pips, move the stop loss to +21. Assume that at the close of the next bar the profit reaches +71 pips. Then the difference between the current stop loss and the price is 71-21=50, and half of this value is 50*0.5=25, so the new stop loss must be 25 points higher than the previous one (21+25=46 points from the opening price).

When using the trailing mode described, "Profit" (bTrlinloss==true), the stop is moved only if the new stop is "better" than the opening price. If bTrlinloss is set to false, then tracking will also be performed in the loss zone (i.e. in the interval between the open price and the stop loss, by the way, this value must be defined (not equal to 0) for this element to work). That is, if the above variant is used, at the close of the next bar, the stop loss will be moved to the 0.5 distance between the stop loss and the current price, instead of the distance between the open price and the current price (with a stop loss of 40 pips and a profit of 42 pips, this distance will be equal to (40+42)/2 = 82/2 = 41 pips, and the stop loss will be set at a distance of +1 pip from the open price. At a profit of 71 The second bar of: a) 71 - 1 = 70, b) 70*0.5 = 35, c) 1 + 35 = 36 points. It can be seen that this variant will start at a greater "distance" and will lag behind the first variant. Its main function is to tighten stops during negative developments. For example, if after the first bar is closed, the profit reaches -10 pips, then bTrlinloss==true: a) find the distance from the price to the stop loss, |-40 + (-10)| = 30 pips, b) calculate half of this value - 30*0.5 = 15 pips, c) move the stop loss towards this distance with the profit: -40 + 15 = -25.

Although accounts are protected from large losses, trailing losses results in an increased number of early closures (as well as small losses).

dCoeff - the coefficient that determines the number of times to decrease the distance between the price at the moment the bar closes and the current stop loss;

bTrlinloss - Activate tracking in unprofitable areas.

11. “KillLoss” tailgating.

 Blank kill loss ( integer ticket, double d speed factor)

I came up with the idea for this maintenance in the process of developing combined types of tails, including the ones mentioned above (i.e. Barishpolts' "ratchet" tails and fractals' tails). According to this idea, it is designed to work only in the loss zone (when the position is at a loss). For example, if the entry is obviously wrong, the losses increase rapidly, and the price quickly approaches the initial stop loss, then it is recommended to limit the possible losses by moving the stop loss towards the price at a speed equal to or greater than the price. This is what the kill loss function does. Once started, it "remembers" the distance between the stop loss and the price in a global variable of the terminal, and in the future if the price is close to the stop loss point X, it moves the stop loss to point X * d speed coefficient of its coefficient. The above coefficient can be either a constant (for example, 1 - for every pip the price approaches, the stop loss will move 1 pip, or 1.5 - the stop loss will move towards the price 1.5 times faster than the price speed), or it can be a variable value that changes depending on the market conditions (for example, its volatility - "if the market is volatile and losses are increasing, cut the stop loss faster"). The kill loss function does nothing when the price rolls back towards profits (losses decrease). P.S. Keep in mind that this function uses 2 global variables of the terminal during runtime - Steve and Zepiao, the latter of which is also used in some of the trailing functions above. Be careful to change the name of a global variable in one of these functions if necessary (such as during combined or alternate use of these functions).

All the above functions are concentrated in the TrailingFuncLib.mq4 library file, which is attached to the article title. For me it is more convenient to use a library, although it is a bit slow, but you can include these functions in your program. I have also attached an example of my fractal called EA and the functions included. Someone may also be interested in EA.

August 11, 2007. For those who do "semi-automatic" trading by controlling part of the trade manually (for example, opening positions, simply because some strategies are almost impossible to algorithmize) and using scripts and MQL4 experts to control another part of the trade (for example, position maintenance and closing), I developed an EA based on each of the above-mentioned tracking functions of the library. They are in the TrailingExperts.zip file. So, now, after opening a position manually, you can run the EA with the required tracking type simply by specifying the ticket (a unique number of the position) and setting the necessary parameters. And, if necessary, you can easily change one tracking type to another as market conditions change, simply by running another expert. More detailed instructions can be found in the comments of each EA. I really hope these programs are useful to you in your work.

I started learning the MQL4 language only recently (end of March 2007). Therefore, I am happy to accept any constructive comments, tips, suggestions, ideas, etc. regarding the above features. I hope they are useful to you.

Sincerely,
Yuri Zhuban.

---

Attachment download

📎MyFractalsgexamplea.mq4 (8.17 KB)

📎 TrailingFuncLib.mq4 (58.4 KB)

Source: MQL5 #7108