MetaTrader 5 herunterladen

Ständige Terminkontrakte in MetaTrader 5

1 Juni 2016, 10:51
Vladimir Karputov
0
208

Einleitung

Händler können in MetaTrader 5 nicht ihre eigenen Charts anlegen, da dies nur mit den Kürzeln des Maklers möglich ist Der Händler verlangt ein synthetisches Produkt – den ständigen Terminkontrakt. Das Problem hier ist, dass nur ein Makler Termingeschäfte zusammenfügen kann und nur er entscheidet, ob er Termingeschäfte auf einem gegebenen Kürzel zusammenführen möchte

Zum Glück kann im Terminal immer die History geschlossener Termingeschäfte abgerufen werden. Diese History sollte man zur Zusammenführung von Terminkontrakten im Terminal verwenden.


Generelles:

  1. Alle Daten, Zeichnungen und Screenshots dieses Beitrags beruhen auf den echten Ukrainischen Aktienindexfutures.
  2. Codeabschnitte, die ausgetauscht oder diesem Beitrag hinzugefügt wurden, werden farblich hervorgehoben. Zum Beispiel:
    //+------------------------------------------------------------------+
    //|                                               This is an example |
    //|                                               of the edited code |
    //+------------------------------------------------------------------+
    

Das erste Problem: Datumsüberschneidung

Zeitnahe Termingeschäfte werden mit Datumsüberschneidung gehandelt.

D.h., dass die Termingeschäfte in den Handel gesetzt werden, während andere Termingeschäfte erst in zwei Monaten geschlossen werden.

Abb. 1 Datumsüberschneidung in den Terminkontrakten

Abb. 1 Datumsüberschneidung in den Terminkontrakten

Die Abbildung zeigt, dass der 16.09.2013 der Start des UX-3,14 Termingeschäfte-Handels ist, obwohl die UX-12,13 Termingeschäfte immer noch offen sind.


Das zweite Problem: die Art der Zusammenführung wählen

Es gibt dazu zwei Methoden:

  • Die einfache Addition – wenn das Datum der Zirkulation des aktuellen Instruments abgelaufen ist und das nächste Instrument in einem anderen Bar geöffnet wird. Während der einfachen Addition entsprechen die Kurse auf dem Chart ihren History-Werten, doch gleichzeitig wird es an den Stellen der Zusammenführung immer wieder zu Kursunterschieden kommen, sodass das Chart nicht gleichmäßig ist. 

Abb. 2 Zusammenführung. Einfache Addition.

Abb. 2 Zusammenführung. Einfache Addition

  • Addition mit Verschiebung: das aktuelle Instrument wird erst in 5-10 Tagen geschlossen und wir beginnen, diese 5-10 Bars durch die Bars des nächsten Instruments zu ersetzen. Dieser 5-10 Bars-Intervall ist der sog. Übergangszeitraum. Während der Addition mit Verschiebung werden die Kurs falsche Werte zeigen (sie entsprechen nicht dem aktuellen Instrument), doch verglichen mit der Methode der einfachen Addition, ist der Chart gleichmäßiger.

Abb. 3 Zusammenführung. Addition mit Verschiebung

Abb. 3 Zusammenführung. Addition mit Verschiebung


Einstellungen im Terminal

Termingeschäfte sollten im "Marktbeobachtungs"-Fenster in absteigender Reihenfolge platziert werden:

Abb. 4 Marktbeobachtung

Abb. 4 Marktbeobachtung


Schreiben eines Indikators

Der Standard-Indikator sollte im Ordner terminal_data_folder\MQL5\Indicators abgelegt werden. Legen Sie den Ordner Synthetics in MyIndicators an (den Sie im Order \Indicators öffnen). Damit sparen Sie im Ordner \Indicators der Standard-Library Platz und erleichtern sich die MQL5 Storage Start-Synchronisation von Indikatoren. Der endgültige Pfad des Ordners sieht so aus: terminal_data_folder\MQL5\Indicators\MyIndicators\Synthetics.

Im Ordner Synthetics legen Sie dann eine neue Datei an:

Abb. 5. Anlegen der neuen Datei für den Indikator

Abb. 5 Anlegen der neuen Datei für den Indikator

Stellen Sie den Dateityp auf "angepasster Indikator" ein:

Abb. 6 Der neue Dateityp - "angepasster Indikator"

Abb. 6 Der neue Dateityp - "angepasster Indikator"

Drücken Sie "Weiter" und öffnen das Fenster "Allgemeine Eigenschaften des angepassten Indikators". Geben Sie den Namen des Indikators ein - "SYNT" - und fügen zwei Optionen hinzu. Die erste Option "Anzahl der Termingeschäfte für Zusammenführung" legt die Menge der Instrumente fest, die verbunden werden sollen. Bitte beachten Sie: Der minimal mögliche Wert für "Anzahl der Termingeschäfte für Zusammenführung" beträgt 2. Die zweite Option "Art der Zusammenführung" legt die Art der Zusammenführung im Standard-Indikator fest - "einfache Addition":

Abb. 7. Die Parameter des angepassten Indikators

Abb. 7 Die Parameter des angepassten Indikators

Passen Sie bei der Option "Art der Zusammenführung" auf: die Zusammenführung kann entweder durch "einfache Addition" oder "Addition mit Verschiebung" erfolgen. In dieser Phase können Sie diese beiden Zusammenführungsarten nicht in die Liste aufnehmen. Daher sollte weiterhin "einfache Addition" stehen bleiben. Während des Schreibens des "SYNT" Indikators sollten Sie die Option Später aktivieren, um die Dropdown-Liste mit allen Zusammenführungsarten sehen zu können.

Im nächsten Fenster wählen Sie die Indikator Ereignis-Handles aus:

Abb. 8 Der Indikator Ereignis-Handle

Abb. 8 Der Indikator Ereignis-Handle

Bitte beachten Sie: im "SYNT" Indikator wird die OnTimer() Funktion verwendet. Die Hauptfunktionalität dieses Indikators wird in OnTimer() eingestellt. Der Indikator kann sowohl an den Kürzelchart mit dem erledigten Handel (dieses Kürzel beinhaltet keine OnCalculate Ereignisse), als auch an den Kürzelchart mit noch aktiven Handel angehängt werden.

Drücken Sie "Weiter" und kreuzen im Fenster "Allgemeine Eigenschaften des angepassten Indikators" "Indikator in separatem Fenster" an:

Abb. 9 Option "Indikator in separatem Fenster" wählen

Abb. 9 Option "Indikator in separatem Fenster"

Drücken Sie auf "Fertig" und Sie sehen das "SYNT" Indikator-Template.


Die Dropdown-Liste organisieren

Um die Zusammenführungsarten als Dropdown-Liste zu erhalten, müssen Sie in den Indikator-Optionen die ENUM_GLUING_TYPE Aufzählung deklarieren.

Deklarieren Sie die Aufzählung im globalen Bereich am Anfang des Eingabe-Parameter Blocks:

#property indicator_separate_window
//+------------------------------------------------------------------+
//|  Splicing types enumeration                                      |
//+------------------------------------------------------------------+
enum ENUM_GLUING_TYPE
  {
   simple_addition,        // simple addition||simple addition
   addition_with_shift     // addition with shift||addition with shift
  };  
//--- input parameters || input parameters
input ENUM_GLUING_TYPE  gluing_type=simple_addition;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+

Hier können Sie überprüfen, wie die Dropdown-Liste angezeigt wird.

Jetzt sollten Sie die Indikator-Datei erstellen (F7). Nachdem Sie dann den Indikator angehängt haben, sehen Sie in den Optionen, das die Dropdown-Liste startet:

Abb. 10 Jetzt haben Sie die Dropdown-Liste in den Parametern

Abb. 10 Jetzt haben Sie die
Dropdown-Liste in den Parametern
 

Fügen Sie die Beschreibung des Indikators hinzu, die, sobald er zum ersten Mal an den Chart angehängt wird oder wenn seine Eigenschaften geändert werden in der Registerkarte "Allgemein" angezeigt wird:

#property version   "1.00"
//+------------------------------------------------------------------+
//| version   "1.00": The timer history swapping                     |
//+------------------------------------------------------------------+
#property description "Indicator for several futures splicing."
#property description "Is drawn in the latest futures window"
#property description "Uses N first symbols for drawing"
#property description "which were taken from the \"Market review\"."

#property indicator_separate_window 

Die Konstruktionsweise des Indikators - DRAW_COLOR_CANDLES - farbige Kerzen.

Sie brauchen 4 Indikator-Puffer und 1 Puffer zur Speicherung des Farbindex. Die Art der Linie, Indikator - STYLE_SOLID - durchgängige Linie. Alles im Indikatorcode anzeigen:

#property description "taken from the \"Market review\"."

//--- indicator settings || indicator settings
#property indicator_separate_window
#property indicator_buffers 5 
#property indicator_plots   1
//--- plot Bars || bars plotting
#property indicator_label1    "SYNT"
#property indicator_type1     DRAW_COLOR_CANDLES
#property indicator_style1    STYLE_SOLID
#property indicator_width1    1
//+------------------------------------------------------------------+
//|  enumeration of splicing methods                                 |
//+------------------------------------------------------------------+

Geben Sie die Eingabe-Parameter "number_futures_gluing" an - Anzahl der für die Konstruktion erforderlichen Instrumente. Der Standardwert "number_futures_gluing" = 2:

//--- input parameters || input parameters
input int               numder_futures_gluing=2;
input ENUM_GLUING_TYPE  gluing_type=simple_addition;

Deklarieren Sie 4 Indikator-Puffer, 1 Puffer für die Speicherung des Farbindex und das Hilfsarray LoadHistory[]:

#property indicator_style1    STYLE_SOLID
#property indicator_width1    1
//--- indicator buffers || indicator buffers
double            OpenBuffer[];
double            HighBuffer[];
double            LowBuffer[];
double            CloseBuffer[];
double            ColorCandlesColors[];
double            LoadHistory[];
//+------------------------------------------------------------------+
//|  enumeration of splicing methods                                 |
//+------------------------------------------------------------------+

Hängen Sie an die eindimensionalen dynamischen Arrays Indikator-Puffer an und richten die Puffer-Indizierung wie in Zeitreihen ein:

//--- indicator buffers mapping
//--- indicator buffers mapping
   SetIndexBuffer(0,OpenBuffer,INDICATOR_DATA);
   SetIndexBuffer(1,HighBuffer,INDICATOR_DATA);
   SetIndexBuffer(2,LowBuffer,INDICATOR_DATA);
   SetIndexBuffer(3,CloseBuffer,INDICATOR_DATA);
   SetIndexBuffer(4,ColorCandlesColors,INDICATOR_COLOR_INDEX);
   SetIndexBuffer(5,LoadHistory,INDICATOR_CALCULATIONS);
//--- set buffer indexing as timeseries
//--- set buffer indexing as in timeseries
   ArraySetAsSeries(OpenBuffer,true);
   ArraySetAsSeries(HighBuffer,true);
   ArraySetAsSeries(LowBuffer,true);
   ArraySetAsSeries(CloseBuffer,true);
   ArraySetAsSeries(ColorCandlesColors,true);
//---
   return(INIT_SUCCEEDED);

Zur Anzeige des Namens der Indikatorreihen ("Offen", "Hoch", "Niedrig" und "Geschlossen") im "Datenfenster", brauchen Sie die Variable s_symbol:

input int               numder_futures_gluing=2;
input ENUM_GLUING_TYPE  gluing_type=simple_addition;
//--- symbol name
string s_symbol;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+

Um den Indikator zu aktivieren, brauchen Sie die Variable shft_array und zwei Marker -good_history und indicator_rendered:

input ENUM_GLUING_TYPE  gluing_type=simple_addition;
//--- symbol name
string   s_symbol;
int      shift_array=0;
bool     good_history=false;        //history is not prepared||history not prepared
bool     indicator_rendered=false;  // indicator is not drawn
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+

Anschließend richten Sie den Indikator ein und verknüpfen den Puffer-Farbindex mit der gewünschten Farbe:

   ArraySetAsSeries(CloseBuffer,true);
   ArraySetAsSeries(ColorCandlesColors,true);
//--- set accuracy || accuracy of the indicator values 
   IndicatorSetInteger(INDICATOR_DIGITS,0);
//--- set drawing line empty value || empty value of the drawing line 
   PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0.0);
//--- set labels for the line || displayed name in the DataWindow
   PlotIndexSetString(0,PLOT_LABEL,s_symbol+" Open;"+s_symbol+" High;"+s_symbol+" Low;"+s_symbol+" Close");
   IndicatorSetString(INDICATOR_SHORTNAME,"SYNT");
//--- set number of colors in color buffer || number of colors in the buffer
   PlotIndexSetInteger(0,PLOT_COLOR_INDEXES,9);
//--- set line color || set the line color
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,0,clrBlue);
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,1,clrOrange);
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,2,clrRed);
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,3,clrGreen);
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,4,clrPink);
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,5,clrIndigo);
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,6,clrPaleVioletRed);
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,7,clrDarkViolet);
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,8,clrDimGray);
//---
   return(INIT_SUCCEEDED);

Ergänzen Sie die OnInit()-Funktion mit der Initialisierung des Timers mit einem Intervall von 3 Sekunden und dem Generator für die zufällige Anzahl :

   PlotIndexSetInteger(0,PLOT_LINE_COLOR,7,clrDarkViolet);
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,8,clrDimGray);
//---
   EventSetTimer(3);
//--- random number generator initializor
   MathSrand(GetTickCount());
//---
   return(INIT_SUCCEEDED);

Zur Ausführung der Zusammenführung sind mind. zwei Kürzel notwendig.

Überprüfen Sie die Anzahl der Instrumente für eine Zusammenführung in der OnCalculate() Funktion:

                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
//--- checking the number of instruments || checking the number of instruments
   if(numder_futures_gluing<=1)
     {
      //--- create the message line
      string comm=StringFormat("For the indicator choose not less than %d symbols",numder_futures_gluing);
      //--- display the message in comment in the chart main window
      Comment(comm);
      return(0);
     }
//--- return value of prev_calculated for next call
   return(rates_total);

Nachdem Sie die Anzahl der Instrumente für eine Zusammenführung geprüft haben, kontrollieren Sie nach, ob der Indikator nicht vielleicht schon gezeichnet wurde. Wurde der Indikator bereits gezeichnet, können Sie OnCalculate() verlassen:

      Comment(comm);
      return(0);
     }
   if(indicator_rendered==true) return(rates_total);
//--- return value of prev_calculated for next call
   return(rates_total);

Das der "SYNT"-Indikator hauptsächlich zur Analyse der Entwicklungstendenz der Tages-Bars verwendet wird, bin ich der Meinung, dass man nicht bei jeder Kursschwankung gleich Neuberechnungen machen muss. Es gibt keine Berechnungen des "SYNT"-Indikators bei jeder Kursschwankung.

Sie müssen darüber hinaus den Indikator auch nur in folgenden Fällen berechnen:

  • wenn der Indikator zum ersten Mal gestartet wurde;
  • wenn sich die History verändert hat (z.B. aufgrund von Additionen).
   if(indicator_rendered==true) return(rates_total);
//--- if calculations were started the first time
//--- or if we need to calculate the indicator for two or more bars (changes in history)
//--- remember, that the "0" bar - is the left-most
   if(prev_calculated==0 || rates_total>prev_calculated+1)
     {
     }
//--- return value of prev_calculated for next call
   return(rates_total);


Erzwungene Initialisierung von Indikator-Puffern

Die Indikator "SYNT"-Puffer sind verknüpfte dynamische Arrays.

Wird der Indikator zum ersten Mal gestartet, werden diese Puffer zwangsweise initialisiert. Fahren Sie mit der Initialisierung in der OnCalculate() Funktion fort. Warum müssen Sie dies in der OnCalculate() und nicht in der OnInit-Funktion machen? Die Erklärung können Sie der folgenden Abbildung entnehmen:

Abb. 11 Die Array-Initialisierung in OnCalculate()

Wie Sie in Abb. 11 sehen können, tritt das OnCalculate() Ereignis in jedem Fall ein, das OnInit() Ereignis hingegen wird nur dann aktiviert, wenn Sie die Chart-Aktualisierung via des Befehls "Update" starten. Daher wird die Array-Initialisierung in der OnCalculate() ausgeführt:

//--- remember, that the "0" bar - is the left-most
   if(prev_calculated==0 || rates_total>prev_calculated+1)
     {
      //--- arrays initialization
      ArrayInitialize(OpenBuffer,0);
      ArrayInitialize(HighBuffer,0);
      ArrayInitialize(LowBuffer,0);
      ArrayInitialize(CloseBuffer,0);
     }
//--- return value of prev_calculated for next call
   return(rates_total);

Die ArrayInitialize() Funktion initialisiert den Indikator-Puffer In diesem Fall zeigt die Initialisierung Nullen.

Wenn Sie den Puffer-Indikator mit Hilfe von EMPTY_VALUE zu initialisieren versuchen, können Sie keine Indikatoren auf "SYNT" Zusammenführung.


Einfache Addition - Algorithmus

Abb. 12 Einfache Addition - Algorithmus

Abb. 12 Einfache Addition - Algorithmus

 

Die Daten im Bild sind die Start- und Enddaten der UX-9,13, UX-12,13 und UX-3,14 Termingeschäfte-Zirkulation. Diese Daten sind in der Tabelle vorhanden:

KürzelZirkulation beginntZirkulation endet
UX-9,1315.03.201316.09.2013
UX-12,1317.06.201316.12.2013
UX-3,1416.09.201317.03.2014

 

In Abb. 10 ist der 25.12. 2013 ein echtes Kalenderdatum. Das UX-3,14 Kürzel ist immer noch gültig.

Die Zusammenführungs-Methode "einfache Addition" wird in der Funktion EinfacheAddition implementiert:

//+------------------------------------------------------------------+
//| Timer function                                                   |
//+------------------------------------------------------------------+
void OnTimer()
  {
//---
  }
//+------------------------------------------------------------------+
//| Simple addition                                                  |
//| Simple addition. Add in the indicator array                      |
//| sibmUP symbol                                                    |
//+------------------------------------------------------------------+
bool SimpleAddition(string simbUP,string simbDOWN,ENUM_TIMEFRAMES period,int Color)
  {
  }
//+------------------------------------------------------------------+

simbUP bezeichnet die ansteigenden, simbDOWN die fallenden Termingeschäfte - beide befinden sich im Fenster "Marktbeobachtung". Farbe - Farbe, die zur Zeichnung von Termingeschäften verwendet wird. 

Unten steht der vollständige Code der Funktion 'EinfacheAddition()':

//+------------------------------------------------------------------+
//| Simple addition                                                  |
//| Simple addition. Add in the indicator array                      |
//| sibmUP symbol                                                    |
//+------------------------------------------------------------------+
bool SimpleAddition(string simbUP,string simbDOWN,ENUM_TIMEFRAMES period,int Color)//////
  {
   datetime expiration_time_UP;     // simbUP symbol expiration date
   datetime expiration_time_DOWN;   // simbDOWN expiration date

   expiration_time_UP=int(SymbolInfoInteger(simbUP,SYMBOL_EXPIRATION_TIME));
   if(expiration_time_UP>TimeLocal())
     {
      expiration_time_UP=TimeLocal();
     }
   if(simbDOWN!="")
     {
      expiration_time_DOWN=int(SymbolInfoInteger(simbDOWN,SYMBOL_EXPIRATION_TIME));
     }
   else
     {
      expiration_time_DOWN=int(SymbolInfoInteger(simbUP,SYMBOL_START_TIME));
     }
//--- Open, High, Low and Close prices will be copied in the rates[] array 
   MqlRates rates[];
   ArraySetAsSeries(rates,true);
   int copied=0;           //--- copied number
   copied=CopyRates(simbUP,period,expiration_time_DOWN,expiration_time_UP,rates);
   if(copied>0)
     {
      for(int j=shift_array;j<shift_array+copied;j++)
        {
         //--- write prices in buffers
         OpenBuffer[j]=rates[j-shift_array].open;
         HighBuffer[j]=rates[j-shift_array].high;
         LowBuffer[j]=rates[j-shift_array].low;
         CloseBuffer[j]=rates[j-shift_array].close;
         ColorCandlesColors[j]=Color;
        }
      shift_array=shift_array+copied;
      indicator_rendered=true;
      ChartRedraw();
     }
   else
     {
      Print("Unable to get the symbol history data",simbUP);
      indicator_rendered=false;
      return(false);
     }
//---  Simple addition end
   return(true);
  }
//+------------------------------------------------------------------+


Addition mit Verschiebung - Algorithmus


Abb. 13 Algorithmus der Addition mit Verschiebung - Zusammenführung

Abb. 13 Algorithmus der Addition mit Verschiebung - Zusammenführung 

Die Zusammenführung in diesem Algorithmus, verglichen mit einer einfachen Addition, beginnt 10 Tage bevor das Kürzel geschlossen wird. Die Zusammenführungs-Methode "Addition mit Verschiebung" wird in der gleichnamigen Funktion AdditionMitVerschiebung() ausgeführt:

//--- Simple addition end
   return(true);
  }
//+------------------------------------------------------------------+
//| Addition With Shift                                              |
//| Addition with Shift. Add in the indicator array only             |
//| sibmUP symbol                                                    |
//+------------------------------------------------------------------+
bool AdditionWithShift(string simbUP,string simbDOWN,ENUM_TIMEFRAMES period,int Color)
  {
//--- 
   return(true);
  }
//+------------------------------------------------------------------+

Der Unterschied zwischen der AdditionMitVerschiebung() und der EinfacheAddition() Funktion besteht in 2 Zeilen - man zieht von den Daten 10 Tage ab:

   .
   .
   .
   expiration_time_UP=int(SymbolInfoInteger(simbUP,SYMBOL_EXPIRATION_TIME))-86400*10;
   .
   .
   .
   expiration_time_DOWN=int(SymbolInfoInteger(simbDOWN,SYMBOL_EXPIRATION_TIME))-86400*10;
   .
   .
   .

Weil der Unterschied in den Codes nur minimal ist, führe ich den vollständigen Code der AdditionMitVerschiebung()-Funktion hier nicht an. Sie finden den Code in der Indikator-Datei dieses Beitrags.

Doch trotz des winzigen Unterschieds zwischen den AdditionMitVerschiebung() und EinfacheAddition() Funktionen, empfiehlt es sich, sie nicht zu einer universellen Funktion zusammenzuführen (z.B. für den Fall zukünftiger Änderungen im Algorithmus oder beim Starten von Tests).


Vorladen der Kürzel-History

Die CheckLoadHistory()-Funktion kopiert die gesamte Kürzel-History in das Hilfsarray tmp_rates.

War der Kopiervorgang erfolgreich, wird dem 'good_history' Marker der Wert 'true' zugewiesen, d.h. Sie können den Indikator zu zeichnen beginnen:

//--- Addition With Shift end
   return(true);
  }
//+------------------------------------------------------------------+
//| Request to receive all history from a trade server               |
//| Request to recieve all history from a trade server               |
//+------------------------------------------------------------------+
bool CheckLoadHistory(string symbol,ENUM_TIMEFRAMES period)
  {
   MqlRates tmp_rates[];      // the Open, High, Low and Close prices will be copied in the rates[]array 
   datetime start_time;       // start time of the instrument trades
   datetime expiration_time;  // expiration time of the instrument trade
   start_time=int(SymbolInfoInteger(symbol,SYMBOL_START_TIME));
   expiration_time=int(SymbolInfoInteger(symbol,SYMBOL_EXPIRATION_TIME));
   if(CopyRates(symbol,period,start_time,expiration_time,tmp_rates)>0)
     {
      good_history=true;
     }
   else
     {
      good_history=false;
     }
//--- 
   return(true);
  }
//+------------------------------------------------------------------+

Sie können die gesamte Kürzel-History als Lebensdauer der Termingeschäfte kopieren - sie ist sehr kurz, sodass das Kopieren der gesamten History wenig Speicherplatz benötigt.


OnTimer - die Hauptfunktion des Indikators

Jetzt haben Sie den Code für zwei Zusammenführungs-Methoden und den Code für das Laden der Histoty, also können Sie nun die OnTimer()-Funktion verändern:

//+------------------------------------------------------------------+
//| Timer function                                                   |
//+------------------------------------------------------------------+
void OnTimer()
  {
   if(indicator_rendered==true) return;
   if(good_history==true)
     {
      int t=0;       // color || color
      int number;
      switch(gluing_type)
        {
         case simple_addition:
            for(int n=0;n<numder_futures_gluing;n++)
              {
               //--- get the random number
               number=MathRand();
               //--- get the color index as the modulo
               t=number%(PlotIndexGetInteger(0,PLOT_COLOR_INDEXES)-1);
               SimpleAddition(SymbolName(n,true),SymbolName(n+1,true),PERIOD_D1,t);
              }
            break;
         case addition_with_shift:
            for(int n=0;n<numder_futures_gluing;n++)
              {
               //--- get random number
               number=MathRand();
               //--- get the color index as the modulo
               t=number%(PlotIndexGetInteger(0,PLOT_COLOR_INDEXES)-1);
               AdditionWithShift(SymbolName(n,true),SymbolName(n+1,true),PERIOD_D1,t);
              }
            break;
        }
     }
   else
     {
      for(int n=0;n<numder_futures_gluing;n++)
        {
         CheckLoadHistory(SymbolName(n,true),PERIOD_D1);
        }
     }
  }
//+------------------------------------------------------------------+

Der Indikator wird konstruiert. Sie können ihn kompilieren und an das Chart anhängen. Hier empfiehlt es sich, das Kürzel für geschlossenen Handel zu wählen und den H1 Zeitraum einzustellen.


Anfängliche Ausgabe des "SYNT" Indikators

Nachdem Sie die zwei "SYNT" Indikator-Templates der unterschiedlichen Zusammenführungs-Methoden an das Chart angehängt haben, können Sie diese Methoden vergleichen:

  Abb. 14 Zwei Methoden zum Vergleich der Zusammenführung von Termingeschäften


Die Möglichkeit, Indikatoren zusammenzuführen (Standard und angepasst)

Die Zusammenführung von angepassten Indikatoren geht mittels des ersten Aufrufs von OnCalculate und dem "SYNT"-Indikator:

int OnCalculate (const int rates_total,      // size of the array price[]
                 const int prev_calculated,  // calculated bars during the previous call
                 const int begin,            // tangible data starting point
                 const double& price[]       // calculation array
   );

Öffnen Sie im "Navigator" Fenster die Liste mit den "angepassten Indikatoren". Danach die Liste "Beispiele" öffnen, den Indikator wählen und ihn in "SYNT" platzieren. In der Registerkarte "Parameter" anschließend aus der Dropdown-Liste "Vorangegangene Indikatordaten" wählen. 

Hier folgt eine Liste mit Indikatoren, die Sie mit dem "SYNT"-Indikator zusammenführen können, und die ohne Fehler auf dem "SYNT" starten:

Der Indikator "SYNT", der drei Termingeschäfte zusammengeführt hat mit dem angehängten Angepasster Gleitender Mittelwert Indikator:

Abb. 15 Beispiel dreier zusammengeführter Kürzel

Abb. 15 Beispiel dreier zusammengeführter Kürzel


Fazit

Die Analyse des Verhaltens älterer Chart-Kürzel, die innerhalb von Tages-Zeitrahmen geöffnet sind, ist einfacher. Zwar ist die Menge der technischen Indikatoren beschränkt, doch kann man mit dieser Methode das Kursverhalten bei ständigen Termingeschäften nachverfolgen.


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

Beigefügte Dateien |
synt.mq5 (24.66 KB)
Ein Indikator zum Anlegen eines Kagi-Diagramms Ein Indikator zum Anlegen eines Kagi-Diagramms

In diesem Beitrag wird ein Indikator für ein Kagi-Diagramm nebst unterschiedlicher Darstellungsvarianten und Zusatzfunktionen vorgestellt. Darüber hinaus werden die Abbildungsgrundlagen des Indikators sowie die Möglichkeiten zu seiner Umsetzung in MQL5 betrachtet. Die verbreitetsten Fälle seiner Umsetzung im Börsenhandel werden ebenfalls aufgeführt: die Strategie zum Wechsel von Yin und Yang, das „Abstoßen“ von der Trendlinie sowie die anhaltende Verbreiterung der „Schultern“ / Verjüngung der „Taillen“.

Anlegen eines systemübergreifenden mehrwährungsfähigen automatischen Handelssystems Anlegen eines systemübergreifenden mehrwährungsfähigen automatischen Handelssystems

In diesem Beitrag wird ein Gerüst für ein automatisches Handelssystem, im Weiteren kurz: Expert-System, vorgestellt, das in der Lage ist mehrere Währungspaare (Kürzel) gleichzeitig zu handeln und sich dabei ebenfalls gleichzeitig unterschiedlicher Handelssysteme zu bedienen. Wenn Sie bereits die optimalen Eingangsparameter für all Ihre Expert-Systeme ermittelt und für jedes einzelne gute Rückvergleichsergebnisse erzielt haben, sollten Sie sich fragen, welche Ergebnisse Sie erhalten würden, wenn Sie sie alle gleichzeitig und für die Gesamtheit all Ihrer Strategien auf einmal prüfen würden.

Wie man nicht hinterherhinkende digitale Filter erzeugt Wie man nicht hinterherhinkende digitale Filter erzeugt

Dieser Beitrag beschreibt einen der Ansätze zur Bestimmung eines nützlichen Signals (Trend) in Datenströmen. Kleine filternde (glättende) Tests, die auf Marktnotierungen angewendet werden, belegen das Potential zur Erzeugung nicht hinterherhinkender digitaler Filter (Indikatoren), die auf den letzten Bars nicht erneut gezeichnet werden.

Lernvideo: MetaTrader Signale-Service Lernvideo: MetaTrader Signale-Service

Dieses Lernvideo erklärt Ihnen in nur 15 Minuten was der MetaTrader Signale-Service ist, und schildert Ihnen in allen Einzelheiten wie man in unserem Service ein Abonnent und ein Anbieter von Handelssignalen wird. Wenn Sie sich das Lernvideo ansehen, können Sie jedes Handelssignal abonnieren oder Ihre eigenen Signale in unserem Service veröffentlichen und bewerben.