Schau, wie man Roboter kostenlos herunterladen kann

Interessantes Skript?
Veröffentliche einen Link auf das Skript, damit die anderen ihn auch nutzen können

Hat Ihnen das Skript gefallen?
Bewerten Sie es im Terminal MetaTrader 5

Bibliotheken

Funktionen Bibliothek und Experts für Trailing / Yury Dzyuban - Bibliothek für den MetaTrader 4

I_D | German English Español Русский 中文 日本語 Português

Ansichten:
658
Rating:
Stimmen: 42
Veröffentlicht:
2016.04.22 10:30

Bekanntermaßen ist der Algorithmus für das Verfolgen und Schließen einer Position fast noch wichtiger als die Regeln der Positionseröffnung. Und manchmal verursacht eine Änderung des "Trailing" Systems drastische Änderungen der Handelergebnisse - entweder zu einer Steigerung oder Verringerung derselben. Dies ist eine Bibliothek mit Funktionen für das Management offener Positionen, die ich für meine Systeme verwende.


Die vorgestellten Funktionen beruhen auf einige der bekanntesten Trailing Strategien, andere habe ich vielleicht selbst entwickelt, zumindest habe ich sie noch nicht gesehen. Die Funktionen sind einfach zu importieren/verwenden, das eine leichte Verwendung in jedem System ermöglicht, um so unterschiedliche Trailing Systeme zu testen. Die vorgestellten Funktionen sind elementar und ermöglichen ggf. komplexere Trailing Strategien auf ihrer Basis zu konstruieren. Es sind sehr unterschiedliche Funktionen, dass damit das Programmieren neuer EAs zu einfacher wird.


Also, die Funktionen selbst:

1. Trailing durch die Schatten der letzten N-Bars..

void TrailingByShadows(int ticket,int tmfrm,int bars_n, 
                       int indent,bool trlinloss)

Die Funktion verwendet als Trailing Stopp das tiefste Tief (für Kauf-Positionen) oder höchste Hoch (für Verkauf-Positionen) der angegebenen Anzahl von Balken des aktuellen Zeitrahmens oder eines angegebenens.

Parameter:

ticket - eindeutige Nummer der Position (bestimmt vor dem Aufruf der Funktion durch OrderSelect());
tmfrm - der Zeitrahmen der Bars für das Trailing (möglich - 1, 5, 15, 30, 60, 240, 1440, 10080, 43200);
bars_n - die Anzahl der Bars, um die StopLoss Levels zu bestimmen (nicht kleiner als 1);
indent - die Differenz (in Points) vom gewählten Hoch/Tief zum StopLoss (nicht kleiner 0);
trlinloss - soll das Trailing der Stopps bereits in der "unrentablen" Zone, d.h. zwischen dem ersten StopLoss und dem Eröffnungskurs beginnen (true - ja, false - Trailing beginnt erst, nach dem neue StopLoss "besser" ist als der Eröffnungskurs, also im Gewinn).

Diese Art des Trailing wurde von V. Barishpolts in "Durchbrechen des Durchschnitts auf dem Tages-Chart" beschrieben, wo er vorschlug eine Kauf-Position mit dem Tief und eine Verkauf-Position mit dem Hoch der beiden letzten 2 Bars (Kerzen) als StopLoss abzusichern. Dieser Algorithmus "trailt" überraschend "nett" (verfolgen Sie das auf dem Chart "mit den Augen"), ermöglicht auch Kursrückfälle zu überleben (die Tiefe hängt ab von der festgelegten Anzahl der Bars, in bars_n) und die Perioden einer erhöhten Volatilität. (Per Definition) es wird ausgelöst, wenn die nächste Bar geschlossen wird, auch wenn Sie mit jeden Tick testen. Vor allem nutze ich es auf den täglichen Charts mit den letzten 2-4 (meistens) Bars.


2. Trailing durch die X-Bars-Fraktale.

void TrailingByFractals(int ticket,int tmfrm,int frktl_bars,
                        int indent,bool trlinloss)

Diese Funktion zieht den StopLoss nach mittels der Fraktale bestimmter Größe (Anzahl der Bars zur Ermittlung der Fraktale) im angegebenen Zeitrahmen. Bekanntermaßen ist das "klassische" Fraktal (von Williams, wenn ich mich nicht irre) eine Kombination von 5 Balken. Aber dann dachte ich - warum nicht auch "andere" Größen - von 3 Bars und mehr, einschließlich der gekoppelten Anzahl der Bars (im letzteren Fall wird die Anzahl von Bars nach dem Extremwert größer sein als vor ihm beim Verschieben "in die Vergangenheit").

Parameter:

ticket - eindeutige Nummer der Position (bestimmt vor dem Aufruf der Funktion durch OrderSelect());
tmfrm - der Zeitrahmen der Bars für das Trailing (möglich - 1, 5, 15, 30, 60, 240, 1440, 10080, 43200);
bars_n - die Anzahl der Bars zur Ermittlung des Fraktals (nicht kleiner als 3);
indent - die Differenz (in Points) zwischen Extremem des letzten Fraktals und dem StopLoss (nicht kleiner 0);
trlinloss - soll das Trailing der Stopps bereits in der "unrentablen" Zone, d.h. zwischen dem ersten StopLoss und dem Eröffnungskurs beginnen (true - ja, false - Trailing beginnt erst, nach dem neue StopLoss "besser" ist als der Eröffnungskurs, also im Gewinn).

In mehreren russischen Forex-Foren hieß es, dass "fraktal-basiertes Trailing besser auf einem niedrigeren Zeitrahmen funktioniert". Fraktale sind ja lokale Extrema, ein Trailing damit ist also ein Trailing mittels lokaler Extrema. Die Idee ist nicht neu, ziemlich robust, und wird von vielen bekannten Händlern verwendet (oben erwähnter Williams, wenn ich mich nicht Irre). Es ermöglicht Kursrückschläge zu überleben, "reagiert" sehr gut auf spürbare Bewegungen, funktioniert aber nicht so gut in Seitwärtsmärkten (aus eigener Erfahrung). Wie die vorherige Funktion rechnet auch diese auf Basis geschlossener Bars. Wenn notwendig, können die Parameter dynamisch geändert werden (während die Position offen ist). Beispielsweise bei einem schnellen "Wachstum" des Gewinns (z.B. bei einem starken Trend), "Vergröbern" der Empfindlichkeit durch einen Wechsel zu einem höheren Zeitrahmen oder durch die Erhöhung der Anzahl der Balken der Fraktale. Oder Umgekehrt, erhöhen Sie die Empfindlichkeit, während die Volatilität fällt durch die Umstellung auf einen kleineren Zeitraum oder durch eine Verringerung der Anzahl der Balken der Fraktale. Andere Optionen sind ebenfalls möglich.


3. Standard Trailing - 'schrittweise'.

void TrailingStairs(int ticket,int trldistance,int trlstep)

Der Trailing-Typ ist eine Verbesserung der Standardversion. Soweit ich weiß, gibt es eine ähnliche Funktion von KimIV (da aber "das eigene noch wertvoller",... :) Im Gegensatz zur Standardversion wird der StopLoss nicht "Point für Point" verschoben (z.B. bei einem Trailing-Abstand von 30 Punkten und aktueller Differenz von 31 zum StopLoss, wird er um +1, bei +32 um 2 etc. bewegt), sondern in "Schritten" einer bestimmten Größe. Wenn zum Beispiel das Trailing in einer Entfernung von 40 Points und mit "Schrittweite" 10 erfolgen soll, wird der StopLoss erst bei einer Differenz von 50 (40 pt + Schrittweite) nachgezogen, vorher passiert nichts (d.h. der Preis hat eine gewisse Freiheit, der Kern dieses Algorithmus), also bei einer Differenz von 50 Nachzug um +10, bei 60 um 20 usw.

Parameter:
ticket -
eindeutige Nummer der Position (zuvor bestimmt durch die Funktion OrderSelect());
trldistance - Erst-Differenz zum aktuellen Preis (in Points) für denn Start des Trailing (nicht weniger als MarketInfo(Symbol(),MODE_STOPLEVEL));
trlstep - Die Schrittweite für das Nachziehen des StopLoss (in Points) (nicht weniger als 1).

Wenn trlstep=1, verhält diese Funktion wie das Standard-Trailing. Das wichtigste Merkmal dieses Algorithmus ist dem Preis eine gewisse "Bewegungsfreiheit" zu geben - der StopLoss wird nur verschoben, nachdem der Preis hat entsprechend "gewanderte" ist. Der Trailing-Algorithmus folgt der Beschreibung aus "Kanäle Verschieben" vom oben erwähnten V. Barishpolts.


4. Standard Trailing - 'Schlinge'.

void TrailingUdavka(int ticket,int trl_dist_1,int level_1,
                    int trl_dist_2,int level_2,int trl_dist_3)

Bekanntermaßen gibt es keine unbegrenzte Bewegungen ohne Rückfälle (igitt...). Nach einem gewissen "Spike" (statistisch bestimmbar zum Beispiel durch einen Durchschnitt) ist oft eine Konsolidierung oder ein Rückfall der Preise zu beobachten. Die Idee dieses Algorithmus ist, den Trailing-Abstand dann zu verringern, wenn sich der Gewinn erhöht und Zonen erreicht, die eine Rückfall/Konsolidierung wahrscheinlich machen. Zusätzlich zur Reaktion auf die genannten "Spikes" (die in der Regel bei Nachrichten oder bei Ausbrüchen von historischen Levels), kann die Funktion auch bei Preiskanälen verwendet werden, in dem der Trailing-Abstand beim Erreichen der (bezogen auf die Positionsrichtung) gegenüber liegenden Kanalgrenze verringert wird.


Parameters:
ticket -
eindeutige Positionsnummer (aktiviert vor dem Aufruf durch die Funktion mit OrderSelect());
trl_dist_1 - der erste Trailing-Abstand (in Points) (nicht weniger als MarketInfo(Symbol(),MODE_STOPLEVEL) und größer als - trl_dist_2 und trl_dist_3);
level_1 - die Gewinnschwelle (in Points), wenn erreicht, wird der Trailing-Abstand reduziert von trl_dist_1 trl_dist_2 (weniger als level_2; größer als trl_dist_1);
trl dist_2 - der Trailing-Abstand (in Points) nachdem der Preis das Gewinn-Niveau von level_1 Punkte (nicht weniger als MarketInfo(Symbol(),MODE_STOPLEVEL)) erreicht hat;
level_2 - die Gewinnschwelle (in Points), wenn erreicht, wird der Trailing-Abstand reduziert von trl_dist_2 trl_dist_3 Points (größer als trl_dist_1 und als level_1);
trl dist_3 - der Trailing-Abstand (in Points) nachdem der Preis eine Gewinnschwelle von level_1 Points (nicht weniger als MarketInfo(Symbol(),MODE_STOPLEVEL)) erreicht hat.


Zum Beispiel die Werte "ticket#, 30, 50, 20, 70, 10", das Trailing beginnt im Abstand von 30 Points, nachdem der Preis sich um 50 Points vom Eröffnungskurs wegbewegt hat, das Trailing "verengt" sich auf 20 Points, wenn der Preis sich über 70 Points in Richtung Gewinn erhöht hat, und "zieht die Schlinge zu" (daher dann der Name) mit einem Trailing-Abstand von 10 Points (das sehr wahrscheinlich bald zum Schließen der Position führt).

5. Trailing Zeit-Gesteuert.


void TrailingByTime(int ticket,int interval,int trlstep,
                    bool trlinloss)


Zeit gesteuertes Trailing unabhängig vom aktuellen Ergebnis die Position und der Lage am Markt.. In festgelegten Zeitabständen (ganze Minuten) versucht er (wenn möglich) den StopLoss um den angegebenen Schritt zu verschieben. Diese Trailing-Methode allein war nicht sehr erfolgreich (zumindest nicht für mich, vielleicht für jemand anderen aber doch), obwohl, wenn Sie sie mit anderen Trailing-Methoden kombinieren oder nur unter bestimmte Bedingung aktivieren, könnte es doch nützlich sein.

Parameter:
ticket -
eindeutige Positionsnummer (bestimmt vor dem Aufruf der Funktion mit OrderSelect());
intervall die Anzahl ganzer Minuten nach dem Öffnen der Position, danach wird versucht den StopLoss in Schritten zu trlstep Points nachzuziehen;
trlstep - die Schrittweite (in Points) um den der StopLoss nach jedem intervall Minuten nachgezogen werden soll,
trlinloss - wenn trlinloss==true, wird der Trailing-StopLoss entweder vom StopLoss oder, wenn es den (noch) nicht gibt, vom Eröffnungskurs errechnet (wenn der StopLoss nicht gesetzt wurde, ==0, dann vom Eröffnungspreis der Position).


6. Trailing durch ATR.

void TrailingByATR(int ticket,int atr_timeframe,int atr1_period,
                   int atr1_shift,int atr2_period,int atr2_shift,
                   double coeff,bool trlinloss)

ATR (Average True Range) ist ein Volatilitätsindikator; je größer der Wert, desto höher ist die durchschnittliche Volatilität im angegebenen Zeitraum (Anzeige); in Points gemessen. Trailing mittels ATR erlaubt in den meisten Fällen das Ändern ("angemessen", "adaptiven") der StopLoss' gemäß der Preisbewegungen - bei hoher Volatilität (sichtbaren Spikes) wird der Preis "los gelassen", andernfalls sind die StopLoss "enger". Das Trailing verwendet 2 ATRs, es sollten verschiedene Periodenlängen - eine kurz (z.B. 5), die andere länger (z.B. 20) sein. Die Berechnung der StopLoss verwendet immer den größeren Wert der beiden ATR - dies wird gemacht, um zu verhindern, dass mehrere Bars mit kleiner Volatilität (zum Beispiel vor Pressemitteilung) zu zu engen StopLoss' führen könnte.

Parameter:

ticket - eindeutige Nummer der Position (zuvor bestimmt durch die Funktion OrderSelect());
atr_timeframe - der Zeitrahmen für die Berechnung der ATR-Wert (möglich: - 1, 5, 15, 30, 60, 240, 1440, 10080, 43200);
atr1_period - die Periodenlänge des ersten ATR (größer als 0 ist; kann gleich atr2_period sein, aber es wird empfohlen, einen anderen Wert zu wählen, wie oben erwähnt);
atr1_shift - der "Zeit-Index" für den ersten ATR, , für den der ATR-Wert berechnet wird, bedeutet die Anzahl der Bars zurück (nicht negative ganze Zahl) relativ zu der aktuellen Bar;
atr2_period - die Periodenlänge des zweiten ATR (größer als 0);
atr2_shift - der "Zeit-Index" für den zweiten ATR für den der ATR-Wert berechnet wird, bedeutet die Anzahl der Bars zurück (nicht negative ganze Zahl) relativ zu der aktuellen Bar;
coeff - der StopLoss wird ermittelt als ATR*coeff, d.h. der ATR wird mit diesem Koeffizienten multipliziert zur Bestimmung der Entfernungen des StopLoss vom aktuellen Kurs;
trlinloss - > soll das Trailing der Stopps bereits in der "unrentablen" Zone, d.h. zwischen dem ersten StopLoss und dem Eröffnungskurs beginnen (true - ja, false - Trailing beginnt erst, nach dem neue StopLoss "besser" ist als der Eröffnungskurs, also im Gewinn).

Es ist auch eine beliebte Trailing Methode, die sich (in den meisten Fällen vorteilhaft) von den Standardanpassungen an den Markt unterscheidet.


7. 'Ratschen'-Trailing (von Barishpolts).


void TrailingRatchetB(int ticket,int pf_level_1,int pf_level_2,
                      int pf_level_3,int ls_level_1,
                      int ls_level_2,int ls_level_3,
                      bool trlinloss)

Eine Ratsche, ist ein Rad, das sich nur in eine Richtung bewegt. Der Name ist von mir, in der Beschreibung von Barishpolts ist es, wie schon erwähnt, die "zweite Trailing-Taktik" (im Gegensatz zur "ersten", mit "standardmäßig" weiten StopLoss'), in der Fassung von KimIV - so genanntes "drei-Ebenen" Trailing. Die Idee: schnelles Übertragen zur Gewinnschwelle und dann schrittweises Trailing für einen kleinen Gewinn (verschiedene Methoden wurden im Nachgang vorgeschlagen, zum Beispiel der Standard oder mein Standard-"schrittweise" oder die oben genannten). Die Machbarkeit eines solchen Trailings - "die absolute Mehrheit der Positionen sind im Gewinn, zumindest für einige Zeit", daher bewegen Sie den StopLoss sobald wie möglich auf Breakeven. Wenn die Position vorzeitig geschlossen wurde, aber die Eröffnung Signale noch existieren, ist ein Wiedereinstieg möglich. Im Allgemeinen werden zahlreiche Positionen in der Gewinnzone geschlossen und möglicherweise einige mit gutem Gewinn - die Positionen, die eine starke Bewegung in die profitable Richtung nach der Eröffnung erleben. Der Autor betont, dies Trailing ist nicht für "pipsing", sondern für das Erreichung eines Handels mit niedrigen % unprofitabler Positionen.

Parameter:
ticket -
eindeutige Nummer der Position (zuvor bestimmt durch die Funktion OrderSelect());
pf_level_1 - Profit-Level (in Points), um StopLoss auf Breakeven + 1 Point zu setzen;
pf_level_2 - Profit-Level (in Points), um StopLoss auf pf_level_1 + Eröffnungspreis der Position zu setzen;
pf_level_3 - Profit-Level (in Points), um StopLoss von pf_level_1 auf pf_level_2 + Eröffnungspreis der Position zu setzen (damit beendet sich diese Funktion);
ls_level_1 - der Abstand vom Eröffnungspreis gegenüber dem Verlust an Stelle des StopLoss, wenn die Position die Gewinnschwelle +1 Point erreicht (d.h. bei +1 wird StopLoss auf ls_level_1 verschoben);
ls_level_2 - Abstand vom Eröffnungspreis im Verlust, platziert wird der StopLoss dann, wenn der Preis zunächst schlechter als ls_level_1 und dann besser wurde (d.h. ein kleiner werdender Verlust, er soll sich nicht wieder erhöhen);
ls_level_3 - Abstand vom Eröffnungspreis im Verlust, platziert wird der StopLoss dann, wenn der Preis zunächst schlechter als ls_level_2 und dann besser wurde;
trlinloss - > soll das Trailing der Stopps bereits in der "unrentablen" Zone, d.h. zwischen dem ersten StopLoss und dem Eröffnungskurs beginnen (true - ja, false - Trailing beginnt erst, nach dem neue StopLoss "besser" ist als der Eröffnungskurs, also im Gewinn).

Der Autor der Idee schlägt folgende Werte für EURUSD vor: "5, 10, 25", d.h. bei +5 (also "kompensiere" den Spread und gewinne 5 zusätzliche Points) der StopLoss verschiebt sich auf +1 (beim manuellen Handel sollten die Zahlen im Kopf sein, um nicht in Versuchung zu geraten), bei +10 Points bewegt sich der StopLoss auf +5, bei +25 Points im Gewinn verschiebt sich der StopLoss auf +10 und dann wird "losgelassen" (die Position kann mit anderen Methoden gesichert werden). Der Teil der Funktion über die Intervalle der StopLosse wurde nicht vom Autor sondern von Lesern der Diskussion entwickelt. Es gibt Hinweise, dass der Autor (durchaus erfolgreich) diese Methode bei seinem Eigenhandel verwendet, das ist möglicherweise einer der Faktoren des hohen % der Gewinner seines Handels. Zur gleichen Zeit sollte angemerkt werden, dass dieser Trailingalgorithmus sehr speziell ist und sich vielleicht nicht für alle eignet.


8. Trailing mittels Preiskanal (vorgeschlagen von rebus).

void TrailingByPriceChannel(int iTicket,int iBars_n,int iIndent)

Parameter:
iTicket -
eindeutige Positionsnummer (aktiviert vor dem Aufruf durch die Funktion mit OrderSelect());
iBars_n - Periodenlänge des Kanals (die Anzahl der Bars, das höchste Hoch und tiefste Tief zu suchen - die obere und untere Grenze des Kanals);
iIndent - Abstand (in Points) des StopLoss von den Kanalgrenzen.

Die Ergebnisse des Trailings mittels Preiskanal sind durchaus ähnlich dem Trailing mit "Kerzenschatten" (siehe oben) oder dem Trailing mittels Fraktale, obwohl es sich in "Konzept" und "Zweckmäßigkeit" unterscheidet.


9. Trailing mittels Gleitendem Durchschnitt.

void TrailingByMA(int iTicket,int iTmFrme,int iMAPeriod,int iMAShift,
                  int MAMethod,int iApplPrice,int iShift,int iIndent)

Die Idee ist im Grunde "einen halben Schritt entfernt" von der Trailing mittels Preiskanal. Der Funktion übergeben Sie die Ticketnummer, den erforderlichen Zeitrahmen, den Abstand zum MA (Points), der StopLoss und die Parameter des MAs (gleich denen des normalen iMA()). Angesichts des Wesens der gleitenden Durchschnitte, ist es leicht zu vermuten, dass dieser Algorithmus gute Ergebnisse in Trends erzielt, aber in Seitwärtsmärkten etwas "verwirrt" zu früh die Positionen schließt. Es ist jedoch möglich die Parameter (die Methode und die Periodenlänge der Mittelung im besonderen) den Marktbedingungen (Berücksichtigung der Volatilität zum Beispiel) anzupassen.


Parameter:
iTicket -
eindeutige Positionsnummer (aktiviert vor dem Aufruf durch die Funktion mit OrderSelect());
iTmFrme - Zeitrahmen zur Berechnung des gleitenden Durchschnitts, möglich sind: 1 (M1), 5 (M5), 15 (M15), 30 (M30), 60 (H1), 240 (H4), 1440 (D), 10080 (W), 43200 (MN);
iMAPeriod - Periodenlänge für die Berechnung des gleitenden Durchschnitts;
iMAShift - Verschiebung des Indikators in Bezug auf den Preischart;
iMAMethod - Methode der Mittelwertbildung; möglich sind: 0 (MODE_SMA), 1 (MODE_EMA), 2 (MODE_SMMA), 3 (MODE_LWMA);
iApplPrice - anzuwendender Preis; möglich sind: 0 (PRICE_CLOSE), 1 (PRICE_OPEN), 2 (PRICE_HIGH), 3 (PRICE_LOW), 4 (PRICE_MEDIAN), 5 (PRICE_TYPICAL), 6 (PRICE_WEIGHTED);
<n51><N52><n53>iShift -
Indikatorwert relativ zur aktuellen Bar um die angegebene Anzahl von Bars zurück;<n57>
iIndent - Abstand (in Points) des StopLoss vom MA-Wert.


10. "Halbe-Halbe" Trailing.

void TrailingFiftyFifty(int iTicket,int iTmFrme,double dCoeff,
                        bool bTrlinloss)

Die Idee ist wie folgt: wenn sich die aktuelle Bar beendet, wird der Abstand zwischen dem StopLoss und dem aktuellen Preis mal dCoeff (Standardwert ist 0,5 - daher der Name) verringert. Zum Beispiel gibt es eine offene Kauf-Position mit StopLoss von 40 Punkten. Angenommen die Bar der Eröffnung der Kauf-Position schließt +42 Points über dem Eröffnungspreis. Wenn der nur "Profit" (bTrlinloss==true) Trailing-Modus ausgewählt wurde, wird die Differenz zum Eröffnungspreis Preis von 42 Punkte mit dCoeff (z.B., 0.5) multipliziert und daher der StopLoss um 21 Points nachgezogen. Angenommen, der Gewinn beläuft sich dann auf +71 Punkte bei der Schließung der nächsten Bar. Nun ist die Differenz zwischen StopLoss und dem Preis ist 71-21=50, die Hälfte davon ist 50*0.5=25, so dass der neue StopLoss um weitere 25 Points nach oben geschoben wird (21+25=46 Points über dem Eröffnungspreis).

Der beschriebene Trailing-Modus, "Gewinn" (bTrlinloss==true) bewegt den StopLoss nur, wenn der neue StopLoss "besser" ist als der Eröffnungskurs. Wenn bTrlinloss auf false gesetzt ist, dann wird das Trailing auch dann durchgeführt, wenn die Position im Verlust ist (d.h. im Intervall zwischen dem Eröffnungskurs und StopLoss, der notwendigerweise bestimmt werden musste (ungleich 0). Das heißt, wenn die oben genannten Variante verwendet wird, dann wird, sobald die aktuelle Bar sich schließt, der StopLoss verschoben, aber nicht um 0,5 mal der Differenz zwischen dem Eröffnungskurs und dem aktuellen Preis, sondern zwischen dem StopLoss und dem aktuellen Preis (bei einem StopLoss von 40 Points und Gewinn von 42 (40+42)/2 = 82/2 = 41 Points wird der StopLoss +1 Point über dem Eröffnungspreis platziert. Wenn die zweite Bar die 71 Points gewinnt: a) 71 - 1 = 70, b) 70*0.5 = 35, c) 1 + 35 = 36 Points. Es wird klar, diese Variante hat eine größeren "Abstand" und fällt hinter der ersten zurück. Seine Hauptfunktion ist, den StopLoss bei negativen Entwicklungen zu verengen. Wenn zum Beispiel nach der Schließung der ersten Bar der Gewinn sich auf -10 Points beläuft und gilt bTrlinloss==true: a) ist die Differenz zwischen Preis und StopLoss |-40 + (-10)| = 30 Points, b) davon die Hälfte - 30*0.5 = 15 Points und c) der StopLoss verbessert sich auf: -40 + 15 = -25.

Trailing eine Position im Verlust führt zu einer erhöhten Zahl vorzeitiger Schließung (mit kleinen Verlusten), aber es schützt das Konto vor größeren Verlusten.

Parameter:
iTicket -
eindeutige Positionsnummer (aktiviert vor dem Aufruf durch die Funktion mit OrderSelect());
iTmFrme - Zeitrahmen der Bars des Trailings, möglich sind: 1 (M1), 5 (M5), 15 (M15), 30 (M30), 60 (H1), 240 (H4), 1440 (D), 10080 (W), 43200 (MN);

dCoeff - der Faktor mit dem der verwendete Kursabstand multipliziert wird;

bTrlinloss - aktiviert das Trailing auch in Verlustzonen.


11. "KillLoss" Trailing.

void KillLoss(int iTicket,double dSpeedCoeff)

Ich hatte die Idee zu einer kombinierten Art von Trailing, die mehrere der oben genannten (vor allem das "Ratsche" Trailing von Barishpolts und Trailing mittels Fraktale) kombiniert. Gemäß der Idee wurde sie nur für Positionen im Verlust entwickelt. Zum Beispiel, wenn der Einstieg offensichtlich falsch war, steigt der Verlust schnell an und der Preis nähert sich rasch dem anfänglichen StopLoss, wäre es vielleicht ratsam, den möglichen Verlust zu begrenzen durch das Verschieben des StopLoss hin zum aktuellen Preis mit der gleichen oder höheren Geschwindigkeit wie der Preis selbst. Dies ist, was die KillLoss -Funktion macht. Einmal gestartet "erinnert" sie sich des Abstands zwischen StopLoss und den Preis mittels einer Globalen Variablen des Terminals, und wenn dann der Preis sich dem StopLoss um X Points nähert, bewegt sich der StopLoss auch um X Points * dSpeedCoeff zum Preis. Die genannte Koeffizient kann sowohl eine Konstante (z.B. 1 - StopLoss wird verschoben um 1 Point je Point Preisbewegung, oder 1,5 - StopLoss bewegt sich in Richtung Preis 1,5 mal schneller als der Preis selbst), als auch ein variabler Wert sein, der sich je nach den Marktbedingungen ändert (z.B. die Volatilität - "wenn der Markt volatil ist und der Verlust wächst, ziehen Sie den StopLoss schneller an"). Wenn der Preis einen Rückfall in Richtung Gewinn zeigt (geringerer Verlust), tut KillLoss nichts. P.S. Bedenken Sie, die Funktion verwendet 2 globale Variable des Terminals während sie läuft - <B4>sldiff und zeticket, von denen die letztere auch in einigen der oben genannten Trailing-Funktionen verwendet wird. Seien Sie vorsichtig, wenn notwendig (z.B. während einer gemeinsamen oder alternativen Nutzung dieser Funktionen) ändern Sie den Namen der globalen Variablen in einer der Funktionen.


Alle oben genannten Funktionen finden Sie in der TrailingFuncLib.mq4 Bibliotheksdatei, die oben im Header des Artikels beigefügt ist. Es ist bequemer für mich, eine Bibliothek zu verwenden, obwohl es etwas langsamer ist, allerdings können Sie die Funktionen in Ihre Programme einfügen. Ich ergänzte auch eine Beispiel EA mit dem Namen MyFractals mit allen Funktionen. Jemand könnte auch an dem EA interessiert sein.


11.08.2007. Für diejenigen, die "semi-automatisch" handeln, also teilweise manuell (beispielsweise Positionen manuell öffnen, weil einige Taktiken kaum algorithmierbar sind) aber anderer Teile des Handels mit Hilfe von Skripten und Experten der Programmiersprache MQL4 (zum Beispiel, Positionen, Wartung und Stilllegung) ausführen lassen, habe ich diesen EA, basierend auf jeder der oben genannten Trailing-Funktion der Bibliothek, entwickelt. Sie sind in der Datei TrailingExperts.zip. Damit können Sie jetzt eine Position manuell eröffnen und dann starten Sie den EA, geben die Trailing-Methode an, spezifizieren die Ticket (eindeutige Nummer der Position) und die anderen notwendigen Parameter. Und, wenn nötig, können Sie jederzeit die Trailing-Methode ändern, wenn das der Markt verlangt, in dem Sie einfach einen anderen EA starten. Weitere detaillierte Anweisungen finden Sie in den Kommentaren der einzelnen EAs. Ich hoffe wirklich, dass Ihnen diese Programme bei Ihrer Arbeit helfen können.


Ich habe erst vor kurzem angefangen die MQL4 Sprache zu lernen (Ende März 2007). Daher akzeptieren ich gerne konstruktive Anmerkungen, Tipps, Anregungen, Ideen, etc. in Bezug auf die oben genannten Funktionen. Ich hoffe, Sie nützen Ihnen.

Beste Grüße,
Yuri Dzyuban.

Die Übersetzung aus dem Russischen wurde durch die MetaQuotes Software Corp. ausgeführt
Originalpublikation: https://www.mql5.com/ru/code/7108

Dealers Trade v 7.74 MACD Dealers Trade v 7.74 MACD

Der Dealers Trade v 7.74 RIVOT EA basiert auf dem Algorithmus des Multi-Lot Scalping. Der EA wurde mehrfach getestet auf einem live-Konto.

Dealers Trade v 7.51 RIVOT Dealers Trade v 7.51 RIVOT

Der Dealers Trade v 7.51 RIVOT EA basiert auf dem Algorithmus des Multi-Lot Scalping. Der EA wurde mehrfach getestet auf einem live-Konto.

SymbolLister SymbolLister

Eine einfache Funktion, die eine Liste der verfügbaren Währungspaar-Symbole erstellt.

ZZ_All Quotings 0-0050 ZZ_All Quotings 0-0050

Das ZZ_All Quotings 0-0050 Skript ist konzipiert für das Herunterladen von historischen Kursen für alle Währungspaare, Metalle, bekannte Indizes, CFD und für die Kontrolle von "Löchern" in den zurückliegenden Daten.