MetaTrader 5 herunterladen

Beispiel einer Handelsstrategie auf Grundlage verschiedener Zeitzonen in unterschiedlichen Kontinenten

2 März 2016, 13:14
Vasily
0
367

Einleitung

Ich hatte gerade etwas Zeit und da war es natürlich klar, dass ich die Märkte ein wenig beobachtet und mich mit der Divergenz ökonomischer Zyklen und technischer Indikatoren beschäftigt habe. Die Ergebnisse finden Sie im folgenden Beitrag Erzeugung eines Indikators mit grafischen Kontrolloptionen. Aber das war nicht alles, was ich herausgefunden habe! Ich bin noch auf ein Phänomen größeren Ausmaßes gestoßen, doch um das zu verstehen, sollten wir uns die Welt im Hinblick auf ihre Zeitzonen ansehen (Abb. 1).

Abb. 1 Zeitzonen

Hier sehen wir, das jeder Tag in jedem Land zu unterschiedlichen Uhrzeiten beginnt und sich dies auch so fortsetzt. Unser riesiges Land allein erstreckt sich schon fast über 10 Zeitzonen und der Atlantik erstreckt sich nur über 6.

Welches Grundmuster erkennen wir hier? Betrachten wir uns die Markteröffnung in folgenden Ländern: Japan, Australien, China und Russland. Wenn die Angestellten in Russland ihren Arbeitstag und ihre Tradings beginnen, ist es in Asien bereits abends. Und wenn die Börse in Europa eröffnet, ist in Russland alles schon wieder zu für den Tag.

Und hier wird's lustig. Sobald der Markt eröffnet ist, stoßen die Makler und Fondsmanager in Europa ihre Assets auf den Markt und machen spekulative oder mit den Zinsen ihrer Investoren übereinstimmend Geschäfte. Abwarten - das wirklich Interessante kommt erst noch und zwar dann, wenn in Chicago die Sonne aufgeht, zusammen mit dem kleineren Teil des Atlantiks, denn dann eröffnen die Manager der Börse in Chicago ihre Handelsterminals und beginnen ihr Kapitel zu verwalten.

Halten wir hier kurz inne - in Zusammenhang mit dem kleineren Teil des Atlantiks. Der Börsentag in Europa ist noch nicht geschlossen (Fig. 1). London und Chicago trennen 8 Zeitzonen, und wenn wir von einem achtstündigen Arbeitstag (plus 45 Minuten Pause) und einer Stunde Mittag ausgehen, verlängert sich die Zeitdifferenz um weitere 90-120 Minuten (all diejenigen, die in Büros arbeiten, kennen das). 

Und genau jetzt erwerben wir die Markt-Assets europäischer und amerikanischer Manager. Ich möchte an dieser Stelle nicht alle Nullen der Assets auflisten. Europäische und amerikanische Manager beginnen ihren täglichen Kampf um den Kurs der Wertpapierbörse und genau jetzt entsteht das in Abb. 2 gezeigte Phänomen. 

Abb. 2 Marktpuls

Finanzkämpfe füllen den Markt, Assets wechseln sekündlich ihre Besitzer, doch das ist nicht das, worum es letztendlich im Markt geht! Denn wenn diese Periode um ist, setzt eine ruhigere Bewegung ein und bewegt sich in Richtung des aktuellen Trends. Jetzt dehnt der Bereich seine Grenzen aus, engt sie dann wieder ein und bewegt sich weiter in Richtung des hauptsächlichen Trends

Sicherlich haben Sie bemerkt, dass der Marktpreis entweder nach oben oder unten geht, doch sich stets nach rechts bewegt.


2. Flowcharts als primäre Methode zur Entwicklung eines Algorithmus

Abb. 3 zeigt den ersten Block des "Start-Stop" Programms:


Abb. 3 "Start-Stop" Block

Mit Hilfe dieses Blocks wird der Start des Programms bezeichnet, der Anfang oder das Ende einer Funktion oder eines anderen Vorgangs wie z.B. eine Initialisierung oder De-Initialisierung. Als nächsten Block sehen wir uns den Block "Daten" an, der in Abb. 4 gezeigt wird.


Abb. 4 "Datenblock"

Mit Hilfe des "Datenblocks" werden die spezifizierten Parameter beim Start des Programms festgelegt oder, wie im Fall von MQL5, die Ausgabeparameter. Diese Einheit erfüllt auch die Funktion der Richtungsvorgabe der globalen Parameter.

Nun sehen wir uns einen häufig verwendeten Block an (99% aller Programme in MQL arbeiten mit dieser Methode), der in zwei Teilen, die die Begrenzungen eines Zyklus markieren, abgebildet ist. Abb. 5

Zyklusblöcke

Abb. 5 Zyklusblöcke

In diesen Zyklen finden normalerweise Vorgänge wie Zurechnung oder Accounting statt. Abb. 6 zeigt die entsprechenden Beispiele.

Handlungen

Abb. 6 Handlungen

Und wir dürfen auch die logischen Blöcke nicht vergessen. Abb. 7 zeigt einen "Lösungsblock".


Abb. 7 Der "Lösungsblock"

Der "Lösungsblock" kann durchaus mehr als zwei Ausgaben haben, wenn er sich innerhalb des Operators vom Typ "Wechseln in Abhängigkeit der Anzahl der Platzierungen" befindet. Dieser Block hat dann eine entsprechende Anzahl Ausgaben.

Der nächste Block enthält vorab festgelegte Funktionen, wie z.B. iMACD oder iRSA, sowie auch angepasste Funktionen, die an einer anderen Stelle im Programm oder in der Library festgelegt sind (Abb. 8).


Abb. 8 Funktion

Und die letzten beiden Blöcke implementieren ausschließlich Dienstfunktionen - wie z.B. Kommentare und den Verstoß (Abb. 9).

Dienstblöcke

Abb. 9 Dienstblöcke

Dies sind alle Arten von Blöcken mit deren Hilfe jedes für eine Maschine geschriebene Programm beschrieben werden kann. Sie alle sind eindeutig, einfach und im grundlegenden Stadium der Entwicklung leicht zu verwenden. Sie decken zugleich auch die Schwachpunkte des Systems auf und entwickeln Methoden zur ihrer Beseitigung.

Jetzt kennen Sie also diese Methode. Doch ist es m. E. nicht erforderlich, dass Sie exakt gemäß dieser Schemata handeln, sondern sich einfach nur den anfänglichen Wert von Flowcharts vor Augen führen, damit Sie einige Arten der Berechnungsmethode leicht verstehen. Mit dieser Methode kann ich rasch einen Gedanken formulieren, der mir so ganz schnell in der linken Gehirnhälfte gekommen ist und gleich aus der rechten wieder verschwinden wird.

3. Bau des Algorithmus

Machen wir uns nun an die Vorbereitung eines Expert Advisors auf Grundlage der Flowchart-Strategie.

Der erste Block verlangt nach den Eingabeparametern. Wie wir festgestellt haben, ist es extrem wichtig den Augenblick der hauptsächlichen "Kämpfe" abzuwarten, also 2 Stunden nach der Eröffnung in den USA, dann wenn die Märkte in Europa schließen. Dazu blicken wir immer wieder auf die Weltuhr, d.h. die Terminalzeit, und errechnen uns die Uhrzeit der Eröffnung selbst.

Dann legen wir die Größe der Positions und die Profit- und Loss-Ebenen fest, die sich späer dann durchaus noch optimieren lassen. Hier sollte man besonders auf den Magic Nummer-Parameter achten, da er von unserem Expert Advisor zur Festlegung seiner Order und offenen Handel benutzt wird. Des Weiteren machen wir einen nachfolgenden Stop zur Begrenzung der Risiken unserer Positions, entsprechend dem, was wir beobachten.

Und wir brauchen noch einen weiteren, interessante Parameter - ein Sicherheits-Level, entsprechend dem wir das Vorhandensein signifikanter wirtschaftlicher Neuigkeiten im Augenblick beobachten, und ob sie eine Bedrohung darstellen oder nicht. Denn wir wissen ja, dass die große "Panik" auf den Märkten genau innerhalb dieser 2 Stunden losbricht.


Abb. 10 Eingabeparameter

//--- input parameters
input int      America=16;
input double   Lots=0.1;
input int      TakeProfit=500;
input long     MagicNumber=665;
input int      Limited=600;
input int      TrailingStop=100;

Kommen wir nun zum nächsten Teil der Strategiebildung.

Hier müssen wir festlegen, ob es sich um eine Cross-Session gehandelt hat und ob die Order eingerichtet wurden oder gerade werden. (Abb. 11)

Zeit für den Handel

Abb. 11. Zeit für den Handel

Wie Sie sehen ist er gegebene Algorithmus ein geschlossenes Programm mit Eingabeparametern, abgeschlossenen Berechnungen und Ausgabe-Ergebnissen. Solche Mini-Programme nennt man Funktionen. Sie sind vom Hauptprogramm durch Verkapselung geschützt.

Verkapselung ist eine Barriere zwischen den Programmen oder seinen Teilen, das durch Methoden getrennt ist, wie z.B. 'Get' und 'Set' , damit sie sich nicht in den Bereichen anderer Gets' und Sets' zu schaffen machen. Das Wesen dieses Vorgangs liegt in der Tatsache, dass die Namen der Variablen innerhalb der Funktionen und innerhalb des Hauptprogramms die gleichen sein können, doch wenn die Get-Methode versucht, von einer Zelle mit einem Variablen-Namen etwas zu 'holen', stößt sie eben auf die Verkapselung, die ihr nur Zugriff auf einen bestimmten Sektor der Memory-Zellen gewährt, die für diese Funktionen oder Programm zugewiesen wurden.

Das gleiche gilt für die Set-Methode, nur halt anders als wie bei 'Get'. 'Set' stellt den Wert im Memory der Zelle auf den Variablen-Namen ein, und sollten sich die Namen der Variablen innerhalb des Programms und innerhalb der Funktion überschneiden, erlaubt die Verkapselung der Set-Methode nicht, die Werte der Variablen innerhalb eines anderen Programms oder Funktion zuzuweisen.

bool time2trade(int TradeHour,int Number)
  {
   MqlDateTime time2trade;
   TimeTradeServer(time2trade);
   if(time2trade.hour!=TradeHour) return(false);
   time2trade.hour= 0;
   time2trade.min = 0;
   time2trade.sec = 1;
   for(int ii=OrdersTotal()-1;ii>=0;ii--)
     {
      OrderGetTicket(ii);
      long ordmagic=OrderGetInteger(ORDER_MAGIC);
      if(Number==ordmagic) return(false);
     }
   HistorySelect(StructToTime(time2trade),TimeTradeServer());
   for(int ii=HistoryOrdersTotal()-1;ii>=0;ii--)
     {
      long HistMagic=HistoryOrderGetInteger(HistoryOrderGetTicket(ii),ORDER_MAGIC);
      if(Number==HistMagic) return(false);
     }
   return(true);
  }

Wir haben die erforderliche Sitzung identifiziert und festgelegt, ob wir Orders eingerichtet haben oder nicht. Sehen wir uns an, was als nächstes drankommt.

Vorhin haben wir bemerkt, dass die wichtigsten Fluktuationen 2 Stunden nach der Eröffnung der Sitzung in den USA stattfinden. Nach Eröffnung der Sitzung in Amerika erhalten wir 9 Balken à 15 Minuten. Wir finden den Maximalbereich für diesen Zeitraum und betrachten ihn sorgfältig – wenn diese Veränderung groß genug ist, dann herrscht auf dem Markt höchstwahrscheinlich eine große Panik und zukünftige Trends können nur schwer ausgemacht werden. Deshalb brauchen wir hier eine gewisse Einschränkung.

Verhält sich der Markt ruhig, wird die Sitzung an Unbeständigkeit zunehmen. Das gibt uns die Gelegenheit, die Maximalabweichung vom Haupttrend festzustellen und die Order-Traps in sicherem Abstand dazu zu platzieren, was funktionieren wird, da der Haupttrend ja weiterhin anhalten wird. Wie wir zuvor vermerkt haben, geht der Kurs entweder rauf oder runter, doch orientiert sich immer nach rechts. (Abb. 12)

Algorithmus zur Platzierung einer Order

Abb. 12 Algorithmus zur Einrichtung einer Order

Bei der Gestaltung des Programmcodes die Tatsache bitte beachten, dass im Meta Trader 5 Handels-Terminal keine Order nahe des Preises der letzten Transaktion eingerichtet werden kann. Falls in diesem Moment der Preis ein neues Minimum oder Maximum zieht, verteidigen wir unsere Position, indem wir uns für eine zuverlässige Festlegung einer Order auf einen Mindestabstand vom Preis der letzten Transaktion zurückziehen. Zudem richten wir die Dauer unserer Orders bis vor Ende des Tages ein, sodass sie danach nicht mehr länger wirksam sind.

void OnTick()
  {
//---
   if(time2trade(America+2,MagicNumber))
     {
      int i;
      double Highest = 0;
      double Lowest = 0;
      MqlRates Range[];
      CopyRates(Symbol(),15,0,9,Range);
      Lowest=Range[1].low;
      for(i=0; i<9;i++)
        {
         if(Highest<Range[i].high) Highest=Range[i].high;//MathMax(,Highest);
         if(Lowest>Range[i].low)  Lowest=Range[i].low;
        }
      long StopLevel=SymbolInfoInteger(Symbol(),SYMBOL_TRADE_STOPS_LEVEL);
      Highest=Highest+StopLevel*Point();
      // add to the current prices parameters of the minimum distance possible for the setting of orders
      Lowest=Lowest-StopLevel*Point();
      // to ensure the maximum probability of the acceptance of our order 30>

      if((Higest-Lowest)/Point()<Limited)
        {
         MqlTradeRequest BigDogBuy;
         MqlTradeRequest BigDogSell;
         BigDogBuy.action=TRADE_ACTION_PENDING;
         // Set the pending order
         BigDogBuy.magic = MagicNumber;
         BigDogBuy.symbol=Symbol();
         BigDogBuy.price=Highest;
         //Price by which the order will be set
         BigDogBuy.volume=Lots;
         BigDogBuy.sl=Lowest;
         //if the stop loss is not set, then set by the strategy /s39>
         BigDogBuy.tp=Highest+TakeProfit*Point();
         //set the take profit/s41>
         BigDogBuy.deviation=dev;
         //minimum deviation from the requested price, 
         //in other words, by how much the executed price can differ from the specified price
         BigDogBuy.type=ORDER_TYPE_BUY_STOP;
         //order type, which is executed based on the specified price or by a higher than specified price
         //in this case the order is set to a higher or equal amount to the specified price 
         //if the order type was buy_limit, then it would be executed 
         //by the specified price, or prices lower than the specified price
         BigDogBuy.type_filling=ORDER_FILLING_AON;
         //the given parameter demonstrates how the order acts 
         //with partial execution of the scope 
         BigDogBuy.expiration=TimeTradeServer()+6*60*60;
         //by the strategy text the order life span only for the current work day
         //since it has been 2 hours since the opening of the American market, and the work day is 8 hours, we have 8-2 = 6
         BigDogSell.action=TRADE_ACTION_PENDING;

         // Set the pending order
         BigDogSell.magic = MagicNumber;
         BigDogSell.symbol=Symbol();
         BigDogSell.price=Lowest;
         //Price, by which the order will be set
         BigDogSell.volume=Lots;
         BigDogSell.sl=Highest;
         //Stop loss set by the strategy
         BigDogSell.tp=Lowest-TakeProfit*Point();
         //set the take profit
         BigDogSell.deviation=dev;
         //Minimum deviation from the requested price, 
         //in other words, by how much the executed price can differ from the specified price
         BigDogSell.type=ORDER_TYPE_SELL_STOP;
         //order type, which is executed based on the specified price or by a higher than specified price
         //in this case the order is set to a higher or equal amount to the specified price  
         //if the order type was buy_limit, then it would be executed
         //by the specified price, or prices lower than the specified price
         BigDogSell.type_filling=ORDER_FILLING_AON;
         //the given parameter demonstrates how the order acts 
         ///with partial execution of the scope  
         BigDogSell.expiration=TimeTradeServer()+6*60*60;
         //by the strategy text the order life span only for the current work day
         //since it has been 2 hours since the opening of the American market, and the work day is 8 hours, we have 8-2 = 6
         MqlTradeResult ResultBuy,ResultSell;
         OrderSend(BigDogBuy,ResultBuy);
         OrderSend(BigDogSell,ResultSell);
        }
     }

Order sind platziert, die Fallen gestellt, also machen wir uns dran, die Risiken unserer Positions zu verringern - und dazu verwenden wir die Technologie des nachfolgenden Stops.

Mit Hilfe der Magic Nummer identifizieren wir unsere Position und verschieben die Stop-Loss Ebene, sobald sie eine gewisse Gewinnebene bei minimalen Kursveränderungen erreicht. (Abb. 13).

Implementierung des nachfolgenden Stops

Abb. 13 Implementierung des nachfolgenden Stops

Der nachfolgende Stop wird für die unterschiedlichen Strategien mit Hilfe der einfachsten Methode implementiert, obwohl es sich bei einigen Strategien empfiehlt, nicht mit nachfolgenden Stops zu arbeiten, damit man so den Kurs nicht daran hindert, genau das zu tun, was man von ihm will, oder einen derartigen Mechanismus nur für den Transfer von Positions auf No-Loss zu benutzen. Doch in unserer Strategie hier, wenden wir den klassischen Mechanismus zur Verschiebung des schützenden Stops im Falle einer Kursverschiebung in unsere Richtung für eine bestimmte Anzahl an minimalen Kursveränderungen an.

//--- trailing implementation
   int PosTotal=PositionsTotal();
   for(int i=PosTotal-1; i>=0; i--)
     {
      //--- go through open positions and see if there are positions created by this Expert Advisor.
      if(PositionGetSymbol(i)==Symbol())
        {
         if(MagicNumber==PositionGetInteger(POSITION_MAGIC))
           {
            MqlTick lasttick;
            SymbolInfoTick(Symbol(),lasttick);
            if(PositionGetInteger(POSITION_TYPE)==0)
              { //--- buy
               if(TrailingStop>0
                  &&(((lasttick.bid-PositionGetDouble(POSITION_PRICE_OPEN))/Point())>TrailingStop)
                  && ((lasttick.bid-PositionGetDouble(POSITION_SL))/Point())>TrailingStop)
                 {
                  MqlTradeRequest BigDogModif;
                  ZeroMemory(BigDogModif);
                  BigDogModif.action= TRADE_ACTION_SLTP;
                  BigDogModif.symbol= Symbol();
                  BigDogModif.sl = lasttick.bid - TrailingStop*Point();
                  BigDogModif.tp = PositionGetDouble(POSITION_TP);
                  BigDogModif.deviation=3;
                  MqlTradeResult BigDogModifResult;
                  ZeroMemory(BigDogModifResult);
                  OrderSend(BigDogModif,BigDogModifResult);
                 }
              }
            if(PositionGetInteger(POSITION_TYPE)==1)
              {//--- sell
               if(TrailingStop>0
                  && ((PositionGetDouble(POSITION_PRICE_OPEN)-lasttick.ask)/Point()>TrailingStop)
                  && (PositionGetDouble(POSITION_SL)==0
                  || (PositionGetDouble(POSITION_SL)-lasttick.ask)/Point()>TrailingStop))
                 {
                  MqlTradeRequest BigDogModif;
                  ZeroMemory(BigDogModif);
                  BigDogModif.action= TRADE_ACTION_SLTP;
                  BigDogModif.symbol= Symbol();
                  BigDogModif.sl = lasttick.ask + TrailingStop*Point();
                  BigDogModif.tp = PositionGetDouble(POSITION_TP);
                  BigDogModif.deviation=3;
                  MqlTradeResult BigDogModifResult;
                  ZeroMemory(BigDogModifResult);
                  OrderSend(BigDogModif,BigDogModifResult);
                 }
              }
           }
        }
     }
  }

Als nächstes fügen wir unseren Algorithmus zusammen (Fig. 14).





Fig. 14. Algorithmus zusammenfügen

//+------------------------------------------------------------------+
//|                                          BigDog_By_CoreWinTT.mq5 |
//|                        Copyright 2010, MetaQuotes Software Corp. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "2010, MetaQuotes Software Corp."
#property link      "http://www.mql5.com"
#property version   "1.00"
//--- input parameters
input int      America=16;
input double   Lots=0.1;
input int      TakeProfit=500;
input long     MagicNumber=665;
input int      Limited=600;
input int      TrailingStop=100;
int dev=30;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
  }
//+------------------------------------------------------------------+
bool time2trade(int TradeHour,int Number)
  {
   MqlDateTime time2trade;
   TimeTradeServer(time2trade);
   if(time2trade.hour!=TradeHour) return(false);
   time2trade.hour= 0;
   time2trade.min = 0;
   time2trade.sec = 1;
   for(int ii=OrdersTotal()-1;ii>=0;ii--)
     {
      OrderGetTicket(ii);
      long ordmagic=OrderGetInteger(ORDER_MAGIC);
      if(Number==ordmagic) return(false);
     }
   HistorySelect(StructToTime(time2trade),TimeTradeServer());
   for(int ii=HistoryOrdersTotal()-1;ii>=0;ii--)
     {
      long HistMagic=HistoryOrderGetInteger(HistoryOrderGetTicket(ii),ORDER_MAGIC);
      if(Number==HistMagic) return(false);
     }
   return(true);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
   if(time2trade(America+2,int(MagicNumber)))
     {
      int i;
      double Highest= 0;
      double Lowest = 0;
      MqlRates Range[];
      CopyRates(Symbol(),15,0,9,Range);
      Lowest=Range[1].low;
      for(i=0; i<9;i++)
        {
         if(Highest<Range[i].high) Highest=Range[i].high;
         if(Lowest>Range[i].low) Lowest=Range[i].low;
        }
      long StopLevel=SymbolInfoInteger(Symbol(),SYMBOL_TRADE_STOPS_LEVEL);
      Highest=Highest+StopLevel*Point();
      //--- add to the current prices the parameters of a minimum possible distance for the order set.
      Lowest=Lowest-StopLevel*Point();
      //--- to ensure the maximum probability of the acceptance of our order.

      if((Highest-Lowest)/Point()<Limited)
        {
         MqlTradeRequest BigDogBuy;
         MqlTradeRequest BigDogSell;
         ZeroMemory(BigDogBuy);
         ZeroMemory(BigDogSell);
         BigDogBuy.action=TRADE_ACTION_PENDING;
         //--- set the pending order
         BigDogBuy.magic = MagicNumber;
         BigDogBuy.symbol=Symbol();
         BigDogBuy.price=Highest;
         //--- Price by which the order will be set
         BigDogBuy.volume=Lots;
         BigDogBuy.sl=Lowest;
         //--- if the stop loss is not established, then we set by the strategy
         BigDogBuy.tp=Highest+TakeProfit*Point();
         //--- set the take profit
         BigDogBuy.deviation=dev;
         //--- Minimum deviation from the requested price, 
         //--- in other words, by how much the executed price can differ from the specified price
         BigDogBuy.type=ORDER_TYPE_BUY_STOP;
         //--- order type, which is executed based on the specified price or by a higher than specified price
         //--- in this case the order is set to a higher or equal amount to the specified price 
         //--- if the order type was buy_limit, then it would be executed 
         //--- by the specified price, or prices lower than the specified price
         BigDogBuy.type_filling=ORDER_FILLING_FOK;
         //--- the given parameter demonstrates how the order acts  
         //--- with partial execution of the scope   
         BigDogBuy.expiration=TimeTradeServer()+6*60*60;
         //--- by the strategy text the order life span only for the current work day
         //--- since it has been 2 hours since the opening of the American market, 
         //--- and the work day is 8 hours, we have 8-2 = 6
         BigDogSell.action=TRADE_ACTION_PENDING;

         //-- Set the pending order
         BigDogSell.magic = MagicNumber;
         BigDogSell.symbol=Symbol();
         BigDogSell.price=Lowest;
         //--- Price by which the order will be set
         BigDogSell.volume=Lots;
         BigDogSell.sl=Highest;
         //-- Stop loss set by the strategy
         BigDogSell.tp=Lowest-TakeProfit*Point();
         //--- Set take profit
         BigDogSell.deviation=dev;
         //--- Minimum deviation from the requested price, 
         //--- in other words, by how much the executed price can differ from the specified price
         BigDogSell.type=ORDER_TYPE_SELL_STOP;
         //--- order type, which is executed based on the specified price or by a higher than specified price
         //--- in this case the order is set to a higher or equal amount to the specified price  
         //--- if the order type was buy_limit, then it would be executed
         //--- by the specified price, or prices lower than the specified price
         BigDogSell.type_filling=ORDER_FILLING_FOK;
         //--- the given parameter demonstrates how the order acts  
         //--- with partial execution of the scope 
         BigDogSell.expiration=TimeTradeServer()+6*60*60;
         //-- by the strategy text the order life span only for the current work day
         //--- since it has been 2 hours since the opening of the American market, 
         //--- and the work day is 8 hours, we have 8-2 = 6
         MqlTradeResult ResultBuy,ResultSell;
         ZeroMemory(ResultBuy);
         ZeroMemory(ResultSell);
         OrderSend(BigDogBuy,ResultBuy);
         OrderSend(BigDogSell,ResultSell);
        }
     }

//--- trailing implementation
   int PosTotal=PositionsTotal();
   for(int i=PosTotal-1; i>=0; i--)
     {
      //--- go through open positions and see if there are positions created by this Expert Advisor.
      if(PositionGetSymbol(i)==Symbol())
        {
         if(MagicNumber==PositionGetInteger(POSITION_MAGIC))
           {
            MqlTick lasttick;
            SymbolInfoTick(Symbol(),lasttick);
            if(PositionGetInteger(POSITION_TYPE)==0)
              { //--- buy
               if(TrailingStop>0
                  &&(((lasttick.bid-PositionGetDouble(POSITION_PRICE_OPEN))/Point())>TrailingStop)
                  && ((lasttick.bid-PositionGetDouble(POSITION_SL))/Point())>TrailingStop)
                 {
                  MqlTradeRequest BigDogModif;
                  ZeroMemory(BigDogModif);
                  BigDogModif.action= TRADE_ACTION_SLTP;
                  BigDogModif.symbol= Symbol();
                  BigDogModif.sl = lasttick.bid - TrailingStop*Point();
                  BigDogModif.tp = PositionGetDouble(POSITION_TP);
                  BigDogModif.deviation=3;
                  MqlTradeResult BigDogModifResult;
                  ZeroMemory(BigDogModifResult);
                  OrderSend(BigDogModif,BigDogModifResult);
                 }
              }
            if(PositionGetInteger(POSITION_TYPE)==1)
              {//--- sell
               if(TrailingStop>0
                  && ((PositionGetDouble(POSITION_PRICE_OPEN)-lasttick.ask)/Point()>TrailingStop)
                  && (PositionGetDouble(POSITION_SL)==0
                  || (PositionGetDouble(POSITION_SL)-lasttick.ask)/Point()>TrailingStop))
                 {
                  MqlTradeRequest BigDogModif;
                  ZeroMemory(BigDogModif);
                  BigDogModif.action= TRADE_ACTION_SLTP;
                  BigDogModif.symbol= Symbol();
                  BigDogModif.sl = lasttick.ask + TrailingStop*Point();
                  BigDogModif.tp = PositionGetDouble(POSITION_TP);
                  BigDogModif.deviation=3;
                  MqlTradeResult BigDogModifResult;
                  ZeroMemory(BigDogModifResult);
                  OrderSend(BigDogModif,BigDogModifResult);
                 }
              }
           }
        }
     }
  }
//+------------------------------------------------------------------+


Fazit

Es gibt viele regelmäßig und periodisch auftretende Marktphänomene, die uns, wenn man sich genau mit ihnen beschäftigt, gewisse Vorteile bringen können. Vielleicht haben bereits erfahrene Händler hier gewisse Überschneidungen mit der gut bekannten "BigDog"-Strategie bemerkt, die ich in diesem Beitrag mit Absicht nicht angesprochen habe, damit der Leser nicht denkt, er wäre schon super vorbereitet.

Sie können sich im Internet mit den verschiedenen Varianten dieser Strategie vertraut machen - dieser Beitrag hier beschäftigt sich nur mit dem Phänomen auf dem diese Strategie beruht.

Übersetzt aus dem Russischen von MetaQuotes Software Corp.
Originalartikel: https://www.mql5.com/ru/articles/59

Beigefügte Dateien |
Modul von Handelssignalen nach dem Bill-Williams-System Modul von Handelssignalen nach dem Bill-Williams-System

Der Beitrag handelt sich um die Regeln des Handelssystems von Bill Williams, bietet einen Leitfaden für die Anwendung des entwickelten MQL5-Moduls für die Suche und Markierung von Mustern dieses Systems auf dem Chart, automatischen Handel nach gefundenen Mustern sowie stellt Testergebnisse für verschiedene Symbole dar.

Einführung in die Theorie der Fuzzylogik Einführung in die Theorie der Fuzzylogik

Die Fuzzylogik geht über die üblichen Grenzen der mathematischen Logik und der Mengentheorie hinaus. Der vorliegende Artikel erläutert die Hauptprinzipien dieser Theorie und beschreibt die Inferenz-Systeme vom Typ Mamdani und Sugeno. Darüber hinaus werden im Artikel Beispiele zur Umsetzung unscharfer Modelle anhand dieser zwei Systeme durch die Mittel der FuzzyNet Bibliothek für MQL5 angeführt.

Erstellung und Ausgabe von Handelsberichten sowie Mitteilungsversand per SMS Erstellung und Ausgabe von Handelsberichten sowie Mitteilungsversand per SMS

Börsenhändler haben nicht immer Zeit und Lust stundenlang an Ihrem Ausgabegerät für Geschäftsvorgänge zu sitzen. Besonders dann nicht, wenn ihre Handelssysteme mehr oder weniger formelgestützt arbeiten und in der Lage sind, einige Marktlagen automatisch zu erkennen. In diesem Beitrag wird beschrieben, wie man einen Bericht über Handelsergebnisse mithilfe eines Expert-Systems, eines Indikators oder eines Skripts in Form einer Datei im HTML-Format erstellt und mittels FTP auf einen Webserver lädt. Überdies wird die Frage des Versandes von Mitteilungen über Handelsereignisse per E-Mail sowie per SMS an Mobiltelefone erörtert.

Orders.Erstellen aktiver MQL5-Bedienfelder für den Handel Orders.Erstellen aktiver MQL5-Bedienfelder für den Handel

Dieser Beitrag behandelt die Frage des Problems der Entwicklung aktiver Bedienfelder in MQL5. Die Elemente der Benutzeroberfläche werden von dem Ereignisverarbeitungsmechanismus gesteuert. Darüber hinaus besteht die Möglichkeit zur flexiblen Anpassung der Eigenschaften der Bedienfelder. Aktive Bedienfelder ermöglichen die Arbeit mit Positionen sowie die Platzierung, Änderung und Löschung von Bestensaufträgen und Pending Orders.