Ständige Terminkontrakte in MetaTrader 5
529
0
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:
- Alle Daten, Zeichnungen und Screenshots dieses Beitrags beruhen auf den echten Ukrainischen Aktienindexfutures.
- 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
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
- 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
Einstellungen im Terminal
Termingeschäfte sollten im "Marktbeobachtungs"-Fenster in absteigender Reihenfolge platziert werden:
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
Stellen Sie den Dateityp auf "angepasster Indikator" ein:
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
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
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"
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
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
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ürzel | Zirkulation beginnt | Zirkulation endet |
|---|---|---|
| UX-9,13 | 15.03.2013 | 16.09.2013 |
| UX-12,13 | 17.06.2013 | 16.12.2013 |
| UX-3,14 | 16.09.2013 | 17.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
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:
- AMA (Adaptiver Gleitender Mittelwert);
- BB (Bollinger-Bänder);
- Angepasster Gleitender Mittelwert;
- DEMA (Doppelter Exponentieller Gleitender Mittelwert);
- FrAMA (Fraktaler Adaptiver Gleitender Mittelwert);
- TEMA (Dreifacher Exponentieller Gleitender Mittelwert).
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
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 Ltd.
Originalartikel: https://www.mql5.com/ru/articles/802
Wie man nicht hinterherhinkende digitale Filter erzeugt
Ein Indikator zum Anlegen eines Kagi-Diagramms
Lernvideo: MetaTrader Signale-Service
Anlegen eines systemübergreifenden mehrwährungsfähigen automatischen Handelssystems
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.