MQL5: Analyse und Umgang mit Berichten der US-Warenterminhandelsaufsichtsbehörde (US-Warenterminhandelsaufsichtsbehörde , CFTC) in MetaTrader 5
Einleitung
Das MetaTrader 5 Handels-Terminal, von MetaQuotes Software Corp. als eins der Tools für Händler entwickelt, enthält die MQL5 Programmiersprache, die Objekt-orientiertes Programmieren unterstützt. Einerseits ist MQL5 nicht mit der Vorgängerversion kompatibel - MQL4 -, anderseits besitzt sie eine Menge neuer Möglichkeiten voll funktionaler Objekt-orientierter Programmiersprache. Daher müssen Händler, die sich bereits mit MQL4 auskennen, diese (in der Tat) neue Sprache verstehen lernen. Dieser Beitrag richtet sich insbesondere an sie.
In diesem Beitrag zeige ich Ihnen, wie man folgendes Problem löst: die Notwendigkeit das Händlertool zu entwickeln, mit dem man unterschiedliche Daten der Berichte der US-Warenterminhandelsaufsichtsbehörde (CFTC) bekommen und analysieren kann. Um dieses Thema ging es ja bereits im Beitrag Das Meta COT Projekt - Neue Horizonte für die CFTC-Berichtsanalyse in MetaTrader 4, daher gehe ich davon aus, dass der Leser mit den Konzepten vertraut ist und wir uns hier auf die Details konzentrieren, die in diesem Beitrag nicht beschrieben sind.
Folgender Gedanke liegt zugrunde: Entwicklung eines Indikators mit dem man Daten aus von der Behörde zur Verfügung gestellten Datendateien ohne Zwischenschritte und Konvertierung erhalten kann. Und darüber hinaus noch für weitere Zwecke genutzt werden kann: die Daten als einen Indikator zeichnen, mit den Daten in anderen Indikatoren, in den Scripts für die automatische Analyse und im Expert Advisors zur Verwendung in den Handelsstrategien fortfahren.
1.Die verschiedenen COT-Berichte
Es gibt drei Arten von Berichten: Aktueller Legacy-Bericht (COT), ergänzendes Warenverzeichnis (CIT), aktueller aufgeschlüsselter Bericht (DCOT). Ihre Unterschiede sind in Tabelle 1 gezeigt.
Beschreibung | Aktuelle Legacy-Berichte | Ergänzendes Warenverzeichnis | Aktuelle aufgeschlüsselte Berichte |
---|---|---|---|
Kürzel | COT | CIT | DCOT |
Referenz | Aktuelle Legacy-Berichte | Ergänzendes Warenverzeichnis | Aktuelle aufgeschlüsselte Berichte |
Referenz auf die jüngste Datendatei | |||
Die in diesem Bericht aufgeführte Händler-Gruppen | nicht gewerblich gewerblich nicht meldepflichtig | nicht gewerblich gewerblich nicht meldepflichtig Index-Händler | Hersteller/Händler/Verarbeiter/Nutzer Swap-Dealer(Tausch-Händler) Verwaltetes Geld/Managed Money andere Meldepflichtige nicht meldepflichtig |
Tabelle 1 Arten der Verpflichtungen von Händler-Berichten
Informationen über Händler, die ihre Positions auf zukünftigen Märkten melden sollten sowie die Prinzipien der Klassifikation und Regelmäßigkeit der Berichte finden Sie in "Der Handel mit Aktien und Waren mit Insidern: Im Buch Geheimnisse des COT-Berichts" und im Beitrag Das Meta COT Projekt - Neue Horizonte für die CFTC-Berichtsanalyse in MetaTrader 4.
Ich beschäftige mich mit zwei Berichten, die in diesen Quellen nicht beschrieben werden.
Das Kürzel CIT steht für Verpflichtungen der Index-Händler. Dieser Bericht wird seit 2007 veröffentlicht. Die aktuelle CIT Berichts-Webseite finden sie unter https://cftc.gov/dea/options/deaviewcit.htm. Index-Händler sind in einer extra Gruppe neben den Hedgers und den Spekulanten aufgeführt.
Die Beschreibung des Ergänzenden Berichts findet sich in http://www.cftc.gov/MarketReports/CommitmentsofTraders/AbouttheCOTBerichts/index.htm. All diese Index-Händler eröffnen oft Long Positions auf den Märkten und verlängern sie von Kontrakt zu Kontrakt.
Die Behörde veröffentlicht seit 2009 die Aufgeschlüsselten Verpflichtungen des Händler-Berichts, dessen Beschreibung in den erklärenden Hinweisen gefunden werden kann.
Der aufgeschlüsselte COT-Bericht erhöht die Transparenz aus den Legacy COT-Berichten durch Einteilung der Händler in die folgenden vier Kategorien: Hersteller/Händler/Verarbeiter/Nutzer, Swap-Dealer, Managed Money und andere Meldepflichtige.
- Hersteller/Händler/Verarbeiter/Nutzer. Ein “Hersteller/Händler/Verarbeiter/Nutzer” ist eine Einheit, die hauptsächlich mit der Herstellung, Verarbeitung, Verpackung oder Bearbeitung einer physikalischen Ware zu tun hat und die zukünftigen Märkte zur Verwaltung oder dem Hedging von mit diesen Aktivitäten zusammenhängenden Risiken nutzt.
- Swap-Dealer. Ein “Swap-Dealer” ist eine Einheit, die hauptsächlich mit Tauschgeschäften für einer Ware zu tun hat und die zukünftigen Märkte zur Verwaltung oder dem Hedging von mit diesen Tausch-Transaktionen zusammenhängenden Risiken nutzt. Das Gegenteil zu Swap-Händler sind spekulative Händler, wie Hedgefonds, oder traditionelle, gewerbliche Kunden, die die Risiken im Zusammenhang mit ihren Geschäften mit der physikalischen Ware verwalten.
- Money Manager. Im Rahmen dieses Berichts versteht man unter einem “Money Manager” einen registrierten Warenhandel-Berater (CTA), einen registrierten Terminverwalter (CPO) oder einen nicht registrierten Fonds, der von der CFTC identifiziert wurde. All diese Händler haben mit der Verwaltung und Durchführung von organisiertem Terminhandel im Auftrag ihrer Kunden zu tun.
- Andere Meldepflichtige. Jeder andere meldepflichtige Händler, der nicht zu einer der drei anderen Kategorien gehört, taucht in der Kategorie “andere Meldepflichtige” auf.
Die komplette Liste der gemeldeten Instrumente findet sich in Anhang 2. Es gibt auch Spalten, die die Anwesenheit eines bestimmten Instruments in den CIT- und DCOT-Berichten anzeigen.
2. Einen COT-Indikator schreiben, der mit externen Daten aus CSV-Dateien arbeitet
Der Indikator funktioniert folgendermaßen. Art des Berichts (einer der in Tabelle 1 aufgeführten Berichte), der Datentyp und die Händler-Gruppe sind in den Eingabeparametern des Indikators festgelegt.
Der Datentyp kann so sein:
- Netto-Long Positions
- Netto Long Positions Rate in Open Interest
- Williams-Index, für Netto Long Positions berechnet
- Open Interest
Die Liste möglicher Datentypen ist nicht vollständig und kann leicht noch erweitert werden, um die wichtigsten Daten, die ich verwende, mit einzuschließen. Für das aktuelle Symbol werden die spezifizierten Daten von den Datendateien verlangt (wie man sie herunterlädt und entpackt wird weiter unten beschrieben). Wir verwenden die CCFTCReport Klasse für den Zugriff auf die Daten und das Herunterladen aus diesen Dateien.
Der Indikator hat folgende Struktur:
2.1 Konstanten
Zur Definition von Konstanten verwenden wir den Datentyp Enum. Folgende Berichtarten werden vom Indikator unterstützt:enum cot_type_report // type of report { COT, DCOT, CIT };
Händler-Gruppe:
enum cot_type_traders // types of traders { noncommercial, // Non-commercial commercial, // Commercial nonreportable, // Non-reportable index, // Index traders producer, // Producers swapdealers, // Swap dealers managedmoney, // Managed money otherreportables // Other reportable traders };
Datentypen, die im Indikator verwendet werden können:
enum cot_type_data // type of COT data { netlongs, // net longs netlongsrate, // net longs rate in the open interest willams_index, // Williams index openinterest // Open interest };
2.2 Klassen
Zur Speicherung verschiedener Objekte innerhalb einer einzigen Variable kann man durchaus Strukturen und Klassen verwenden. Es ist jedoch nicht möglich zwei Variablen des Strukturtyps zuzuweisen, wenn sie dynamische Arrays enthalten oder Werte vom Typ String. Deshalb haben wir Speicherung des COT-Eintrags Klasse anstatt Struktur verwendet sowie Methode zur Datenzuweisung.
class cot_record // class for data record of COT report { public: datetime COT_DATE; //date double COT_OPENINTEREST; //open interest double COT_LONGNONCOM; //longs of non-commercial traders double COT_SHORTNONCOM; //shorts of non-commercial traders double COT_LONGCOM; //longs of commercial traders double COT_SHORTCOM; //shorts of commercial traders double COT_LONGNONREPORTABLE; //longs of the other non-reportable traders double COT_SHORTNONREPORTABLE; //shorts of the other non-reportable traders double COT_LONGINDEX; //longs of index traders double COT_SHORTINDEX; //shorts of index traders double COT_LONGPRODUCER; //longs of Producer/Merchant/Processor/User double COT_SHORTPRODUCER; //shorts of Producer/Merchant/Processor/User double COT_LONGSWAPDEALERS; //longs of Swap Dealers double COT_SHORTSWAPDEALERS; //shorts of Swap Dealers double COT_LONGMANAGEDMONEY; //longs of Managed Money traders double COT_SHORTMANAGEDMONEY; //shorts of the Managed Money traders double COT_LONGOTHERREPORTABLES; //Other Reportables double COT_SHORTOTHERREPORTABLES; string COT_ID; //instrument identifier string COT_NAME; //instrument (symbol) name void copyvar(const cot_record &from) // copying contents (values of variables) from one class to another { COT_ID = from.COT_ID; COT_NAME = from.COT_NAME; COT_DATE = from.COT_DATE; COT_OPENINTEREST = from.COT_OPENINTEREST; COT_LONGNONCOM = from.COT_LONGNONCOM; COT_SHORTNONCOM = from.COT_SHORTNONCOM; COT_LONGCOM = from.COT_LONGCOM; COT_SHORTCOM = from.COT_SHORTCOM; COT_LONGNONREPORTABLE = from.COT_LONGNONREPORTABLE; COT_SHORTNONREPORTABLE = from.COT_SHORTNONREPORTABLE; COT_LONGINDEX = from.COT_LONGINDEX; COT_SHORTINDEX = from.COT_SHORTINDEX; COT_LONGPRODUCER = from.COT_LONGPRODUCER; COT_SHORTPRODUCER = from.COT_SHORTPRODUCER; COT_LONGSWAPDEALERS = from.COT_LONGSWAPDEALERS; COT_SHORTSWAPDEALERS = from.COT_SHORTSWAPDEALERS; COT_LONGMANAGEDMONEY = from.COT_LONGMANAGEDMONEY; COT_SHORTMANAGEDMONEY = from.COT_SHORTMANAGEDMONEY; COT_LONGOTHERREPORTABLES = from.COT_LONGOTHERREPORTABLES; COT_SHORTOTHERREPORTABLES = from.COT_SHORTOTHERREPORTABLES; }; };
Ab jetzt gehe ich davon aus, dass der Leser mit dem CSV-Format der COT-Berichte vertraut ist, das im Beitrag Das Meta COT Projekt - Neue Horizonte für die CFTC-Berichtsanalyse in MetaTrader 4 beschrieben ist. Die Klassen-Instanz dieses Typs wird zur Speicherung einer einzelnen Zeile des COT-Berichts verwendet. Ein Array dieser Klassen-Instanzen erlaubt sie zur Speicherung und bequemen Zugriff auf Felder in den COT-Einträgen zu verwenden. Die CCFTCReport Klasse wurde für Datenspeicherung und Datenzugriff entwickelt:
class CCFTCReport // COT report { private: cot_type_report type; //type of current report cot_record data[]; //cot report data int sizedata; //number of records in the current report string idsymbol; //symbol identifier in cot ("CFTC Contract Market Code" field) string terminalsymbol; //symbol name in the client terminal public: void ~CCFTCReport(){ sizedata=0; }; bool Init( cot_type_report passedtype, string sym="" ); //initialization of class instance bool LoadFile( string filename ); //load data from file string Name(); //returns short report name bool Type(cot_type_report passedtype); //sets type of report cot_type_report Type(){return(type);}; //returns report type bool TestGroup( cot_type_traders type_trader ); //check for the presence of specified group of traders bool DefineIdSymbol(); //definition of id in the cot report bool GetString( int handle, cot_record& arr ); //gets line (record) from csv file string GetFieldCommaDelimited(string &str); //gets field from csv string double At(datetime time,cot_type_traders type_trader,cot_type_data typedata=netlongs); //gets data from the report };
Eine Instanz der CCFTCReport Klasse enthält den gesamten Bericht für ein einziges Symbol, wobei die Berichtsart kann COT, CIT oder DCOTsein kann.Die Aufzählungen und Klassen sind in der "cot.mqh" mit eingeschlossenen Datei enthalten.
2.3 Eingabeparameter
Die Eingabeparameter werden durch die Eingabevariablen festgelegt. Mit diesen Parametern kann man die Händler-Gruppe, den Datentyp und die benötigte Art des COT-Berichts spezifizieren:
input cot_type_traders type_trader = noncommercial; //type of traders input cot_type_data type_data = netlongs; //type of the indicator input cot_type_report type_report = COT; //type of report
2.4 OnInit Funktion
Ein Indikator hat die OnInit Funktion, die für folgende Zwecke verwendet wird: Daten-Download aus der Berichts-Datei, Prüfung der Eingabeparameter und Zuordnung der Indikator-Buffer.
Der mit der Indikator_DATA Eigenschaft initialisierte Buffer enthält Daten, die auf einem Chart grafisch dargestellt werden. Der mit der INDICATOR_CALCULATIONS Eigenschaft initialisierte Buffer enthält unmittelbare Berechnungen.
SetIndexBuffer( 0, BufferData, INDICATOR_DATA ); IndicatorSetString(INDICATOR_SHORTNAME,indname); SetIndexBuffer( 1, BufferCalculations, INDICATOR_CALCULATIONS );
2.5 Die OnCalculate Funktion
Diese Funktion wird zur Auswahl der notwendigen Daten, der Berechnung der verlangten Daten und ihrer grafischen Darstellung verwendet.
Sehen wir uns ihre Arbeit im einzelnen an. Es wird die zweite Form des Aufrufs benutzt:
int OnCalculate(const int rates_total, const int prev_calculated, const datetime &Time[], const double &Open[], const double &High[], const double &Low[], const double &Close[], const long &TickVolume[], const long &Volume[], const int &Spread[]){
Legen wir Balken für Berechnung und grafischer Darstellung fest.
int pos=rates_total-prev_calculated-1; if( pos >= rates_total-1 )pos--;
Und geben an, dass Elemente als Zeitreihen indiziert werden müssen.
ArraySetAsSeries(Time, true); ArraySetAsSeries(BufferData, true); ArraySetAsSeries(BufferCalculations, true);
Nach einigem Herumprobieren, habe ich festgestellt, dass es besser ist, für alle Arrays, die mit den Indikator-Buffer zusammenhängen, die Zeitreihen-Indizierung zu verwenden. Das gleiche gilt ebenso für Arrays, die an die OnCalculate Funktion als Parameter übertragen werden, sodass das letzte (jüngste) Element einen Index = 0 hat.
So sieht die Berechnungsschleife aus:
for(int i=pos;i>=0;i--) { cot_type_data passed = type_data; if(type_data==netlongs || type_data==netlongsrate || type_data==willams_index) { // For the types of the data (net longs, net longs rate, Williams Index) it returns net longs // Further calculations are based on these data. passed = netlongs; } double res = Report.At(Time[i], type_trader, type_data ); //get report data BufferCalculations[i] = res; BufferData[i] = CalcData( type_data, i, Time ); }
Das BufferCalculations Array wird zur Speicherung primärer Daten verwendet, die aus dem COT-Bericht ausgewählt wurden.
Das BufferData Array enthält alle Daten, die sofort auf einem Chart grafisch dargestellt werden können. Das können die Werte aus Berichten sein (Netto-Long Positions, Open Interest) sowie auch berechnete Werte (Long Positions Rate, Williams-Index) sein. Ich möchte kurz den folgenden Punkt beschreiben, für den ich keine elegante Lösung gefunden habe. An die OnCalculate Funktion übertragene Arrays werden vielleicht auf nachfolgenden Ebenen gebraucht, und wir können nur auf sie zugreifen, wenn sie in diesen Aufrufen übertragen werden, sodass ich denke, sie würden den Code überladen.
Der CalcData Funktions-Aufruf:
BufferData[i] = CalcData( type_data, i, Time );
Die CalcData Funktion ruft die CalcIndex Funktion auf:
double CalcData( cot_type_data type_data, int i, const datetime& Time[] ) { // net longs rate in the open interest if( type_data == netlongsrate ) return( BufferCalculations[ i ] / Report.At( Time[i], type_trader, openinterest )); // Williams Index if( type_data == willams_index )return( CalcIndex( i, Time, BufferCalculations ) ); return(BufferCalculations[i]); }
Ich musste auf das Zeit-Array innerhalb der CalcIndex Funktion zugreifen können, daher war ich gezwungen, es gemäß der Aufruf-Hierarchie zu übertragen. Stellen Sie sich nur vor wie der Code aussieht, wenn wir alle 8 Arrays verwenden müssen.
3. Datendateien herunterladen
Tabelle 1 enthält alle Links zu den Dateien. Für jedes Jahr gibt es eine extra Datei. Die Jahreszahl steht bereits im Dateinamen. So enthält z.B. die https://www.cftc.gov/sites/default/files/files/dea/history/deacot2010.zip Datei den Bericht für das Jahr 2010, die https://www.cftc.gov/sites/default/files/files/dea/history/deacot2009.zip Datei den für 2009, usw.
Man muss all diese Dateien herunterladen und in den \MQL5\files\ Ordner der Client-Terminal Installierungs-Directory entpacken. Und man muss für jedes Jahr einen eigenen extra Ordner mit einem Namen deacotXXXX anlegen, wo XXXX für die Jahreszahl steht. Das Ergebnis ist folgende Ordnerstruktur.
Abb. 1 Ordnerstuktur für die Berichte
Der Vorgang der Datenvorbereitung kann vereinfacht werden. Alle folgenden Vorgänge (Prüfung nach Aktualisierungen auf der CFTC Website, Download und Entpacken in die entsprechenden Ordner) übernimmt das "Cotdownloader" Script. Der Scriptkern (Datendownload) basiert auf dem WININET_TEST Script. Ich habe die CProgressBar Klasse verwendet, die im Beitrag Das Kurs-Histogramm (Marktprofil) und seine Implementierung in MQL5 beschrieben wird. Externe Anwendungen werden mit Hilfe von Windows API ausgeführt, was im Beitrag Automatische Optimierung eines Handelsroboters in Echtem Handel beschrieben ist.
Die Verwendung eines Scripts ist einfach - einfach an jedes Chart anhängen. Sobald es arbeitet zeigt es die Informationen über den Datendownload als Fortschrittsbalken auf dem Chart und als Textmeldung im Experts-Tab an.
Abb. 2 Datendownload
4. Anwendungsbeispiel
Um einen Indikator laufen zu lassen, muss man ihn an das Chart eines gewählten Symbols anhängen und die Eingabeparameters festlegen.
Fig. 3 Eingabeparameter des cot Indikators
Beachten Sie bitte, dass Sie jetzt ein benutzerfreundliches Abbild angeben können anstatt Variablen-Namen und Werte aufgezählter Datentypen. Und so wird's gemacht: Um den Variablen-Namen zu ersetzen, sollten Sie bei der Deklarierung einer Eingabe-Variable einen Kommentar festlegen:
input cot_type_traders type_trader = noncommercial; //Type of traders input cot_type_data type_data = netlongs; //Type of the indicator input cot_type_report type_report = COT; //Type of report
Das gilt auch für Werte - Die Beschreibung muss bei der Deklarierung der aufgezählten Werte in den Kommentaren festgelegt werden:
enum cot_type_data // types of data { netlongs, // Net longs netlongsrate, // Net longs rate in open interest willams_index, // Williams Index openinterest // Open Interest };
Sind die Eingabeparameter korrekt spezifiziert und alle Dateien heruntergeladen und entpackt, dann erscheint der Indikator in einem extra Fenster:
Fig. 4 COT Indikator
Sollten Fehler auftauchen, werden sie im "Experts"-Tab des "Toolbox"-Fenster gedruckt.
Fig. 5 Fehlermeldung
5. Hinweise zur Freigabe
Der Indikator ist nicht als voll funktionsfähiges Endprodukt dargestellt. Das ist nur ein Beispiel, das zeigt, wie man durch das Schreiben eines einfachen Codes Ergebnisse bekommt, mit denen man weiter arbeiten kann. Wir haben z.B. das Modul nicht entwickelt mit dessen Hilfe man die Art des COT-Berichts durch Client-Terminal Einstellungen, die man von einem gewissen Makler erhält, individuell anpassen kann. Diese Feature wird innerhalb der DefineIdSymbol Funktion implementiert. Dies sind seine ersten paar Zeilen:
bool CCFTCReport::DefineIdSymbol() { idsymbol=""; if(terminalsymbol=="USDLFX" || terminalsymbol=="DX_CONT" || StringFind(terminalsymbol,"DX")==0)idsymbol="098662"; //U.S. DOLLAR INDEX - CE FUTURES U.S. if( terminalsymbol == "FC_CONT" || StringFind( terminalsymbol, "FC")== 0)idsymbol = "061641"; //FEEDER CATTLE if( terminalsymbol == "LC_CONT" || StringFind( terminalsymbol, "LC")== 0)idsymbol = "057642"; //LIVE CATTLE if( terminalsymbol == "QM_CONT" || StringFind( terminalsymbol, "QM")== 0)idsymbol = "067651"; //CRUDE OIL, LIGHT SWEET - NEW YORK MERCANTILE EXCHANGE
Wenn Sie ein Symbol aus einem Bericht einem Symbol im Client-Terminal zuweisen müssen, sollten Sie dies manuell durch Veränderung dieses Codes tun. Ich habe mit den Einstellungen des BrocoHändler4 Terminals gearbeitet. Als Beispiele in diesem Beitrag habe ich Demo-Accounts verwendet, die auf Metaquotes-Demo und Alpari-Demo Server angelegt wurden. Für DCOT-Berichte stehen nur 2 Instrumente zur Verfügung: XAUUSD (Gold), XAGUSD (Silber).
CIT-Berichte werden derzeit nicht unterstützt, da es auf diesen Servern keine Finanzinstrumente gibt. Sobald es sie später mal geben wird kann man ihren Support leicht mit einschließen, indem man den Kommentar in einigen Codezeilen entfernt und sie verändert.
6. Verwendung des COT-Indikators via iCustom
Ich verwende keinen Indikator in einem Formular, wie in Abb. 3 gezeigt. Die MQL5-Sprache besitzt die Möglichkeit, mit Hilfe der iCustom Funktion die individuell angepassten Indikatoren erneut zu verwenden.
6.1Einen neuen Indikator erzeugen
Für visuelle Analysen von COT-Berichten stehen mehrere Wege zur Verfügung. Einer ist z.B. ein Histogramm, das die Position verschiedener Gruppen von Händler verschiedenfarbig anzeigt.
Stellen wir uns mal folgende Aufgabe vor: Erzeugung eines COTnet Indikators, der die Position verschiedener Gruppen von Händler grafisch als ein Histogramm darstellt (gewerblich und nicht gewerblich aus den COT-Berichten). Der Benutzer muss die Möglichkeit haben den Type der Daten wählen zu können: Netto-Long Positions, Netto-Long Position Rate, Williams-Index.
Dies kann man mit dem MQL5 Assistenten, der im Beitrag MQL5: Seinen eigenen Indikator erzeugen berücksichtigt wurde, vereinfachen. Als Ergebnis sieht der Indikator-Code (der MQL5 Assistent hat die Zeichnungsstile erzeugt) folgendermaßen aus:
#property indicator_separate_window #property indicator_buffers 2 #property indicator_plots 2 //---- plot Noncommercial #property indicator_label1 "Noncommercial" #property indicator_type1 DRAW_HISTOGRAM #property indicator_color1 Blue #property indicator_style1 STYLE_SOLID #property indicator_width1 5 //---- plot Commercial #property indicator_label2 "Commercial" #property indicator_type2 DRAW_HISTOGRAM #property indicator_color2 Red #property indicator_style2 STYLE_SOLID #property indicator_width2 5 //--- indicator buffersDie Eingabe-Variablen, globale Variablen und Präprozessor-Direktive die Library mit Klassen mit einzuschließen sehen so aus:
#include <cot.mqh> input cot_type_data type_data = netlongs; // Indicator's type double NoncommercialBuffer[]; double CommercialBuffer[]; //+------------------------------------------------------------------+ //| Custom indicator initialization function | //+------------------------------------------------------------------+ int handlecomm, handlenoncomm;
Und das ist der Code der OnInit Funktion:
int OnInit() { SetIndexBuffer(0,NoncommercialBuffer,INDICATOR_DATA); SetIndexBuffer(1,CommercialBuffer,INDICATOR_DATA); cot_type_traders td = commercial; cot_type_report tr = COT; handlecomm = iCustom(NULL, 0, "cot", td, type_data, tr ); td = noncommercial; handlenoncomm = iCustom(NULL, 0, "cot", td, type_data, tr ); return(0); }Schauen wir uns nun an, wie man individuell angepasste Indikatoren verwendet (anhand des Beispiels nicht gewerblicher Händler). Beim ersten Aufruf der iCustom Funktion werden die folgenden Parameter (für unseren Bericht notwendig) an die Funktion übertragen:
- NULL – aktuelles Symbol im Client-Terminal
- 0 – aktueller Zeitrahmen
- "cot" – Dateiname (bitte beachten, dass er ohne Erweiterung angegeben ist) unseres individuell angepassten Indikators
- td = gewerblich (die Gruppe an Händlern, die wir brauchen)
- type_data = Indikatorytyp, angegeben in den Eingabeparametern
- tr = COT – Art des Berichts
Als Ergebnis haben wir einen Handle der zum Erhalt der Daten des Indikators weiter verwendet wird.
if(BarsCalculated(handlecomm)<rates_total || BarsCalculated(handlenoncomm)<rates_total) return(0); int to_copy = clctocopy(rates_total, prev_calculated ); if( !copycotbuf(handlecomm, CommercialBuffer, to_copy ) ) { Print("Error in data of commercial traders"); return( 0 ); } if( !copycotbuf(handlenoncomm, NoncommercialBuffer, to_copy ) ) { Print("Error in data of non-commercial traders"); return( 0 ); } return(rates_total);
Wir haben etwas Zeit investiert, einen kurzen Code geschrieben und bekommen das als Ergebnis:
Fig. 6 Der cotnet Indikator
6.2 iCustom kann auch in Scripts verwendet werden
Stellen wir uns folgende Aufgabe: Erzeugung des cotsignals Scripts zur Berechnung statistischer Schätzungen.
- Das Zeichen der Netto-Long Positions des nicht gewerblichen Händlers hat die gleiche Farbe wie die Kerze: ist es positiv, dann ist der Wochentrend eine Hausse; ist es negativ, dann ist der Trend eine Baisse.
- Die Kerzenfarbe (weiß/schwarz) hängt direkt mit dem Anstieg/Abnahme Netto-Long Positions des nicht gewerblichen Händlers zusammen.
- Je nach dem Williams-Index Wert, der auf den Netto-Long Positions des nicht gewerblichen Händlers berechnet wurde, ist die Kerze schwarz oder weiß. Ist es überkauft (mehr als 75%), ist die Farbe schwarz; ist es überverkauft (weniger als 25%), dann ist die Kerze weiß.
Wir verwenden Daten aus dem COT-Bericht. Mit Hilfe dieser Beispiele können Sie Ihre eigenen Methoden zur Interpretation von COT- Daten entwickeln und davon profitieren. In unserem Fall prüfen wir auf 150 wöchentlichen Balken der History, die einem Zeitraum von 3 Jahren entsprechen. Bevor wir ein Script schreiben, müssen wir noch die notwendigen Datentypen und Klassen festlegen:
Die Aufzählung für mögliche Statistikarten ist:
enum cot_type_statistics //types of statistics, used for calculation { speculantsign, //Sign of non-commercial traders' net longs speculantchange, //Volume changes of non-commercial traders' longs willamszones //Overbought/oversold zones of Williams Index };
Um die Statistik für das spezifizierte Symbol zu bekommen, erzeugen wir eine spezielle Klasse:
class CCOTStatistic { private: int bars ; // number of weekly bars in symbol history string symbol; // symbol name in Client Terminal double netlongsspeculantsdata[]; // data for speculators' net longs double willamsindexspeculantsdata[]; // data for speculators' Williams index net longs cot_type_statistics liststatistic[]; // list of statistics public: //initialization and initial setup void Init( string symbol_passed, cot_type_statistics& listpassed[] ); //Get the forecast for the direction int GetCotSignalDirection( int ibar, cot_type_statistics type_stat ); bool Get( double& probably[] ); // returns statistics };
Die 'Get'-Methode liefert uns die geforderte Statistik - wie, das beschreiben wir jetzt. Zuerst werden die notwendigen Arrays mit Hilfe des individuell angepassten Indikators mit Daten gefüllt. Wir brauchen die Werte der Netto-Long Positions nicht gewerblicher Händler und die die Williams-Index Werte:
if (!LoadDataFromCOTIndicator(symbol, PERIOD_W1, noncommercial, netlongs, COT, netlongsspeculantsdata, bars)) return(false); // we have got the data - speculators' net longs if (!LoadDataFromCOTIndicator(symbol, PERIOD_W1, noncommercial, willams_index, COT, willamsindexspeculantsdata, bars)) return(false); // we have got the data - speculators' Williams Index
Der Code zur Statistikberechnung (wir müssen nur einen Parameter berechnen - die Prognosewahrscheinlichkeit für die Farbe der wöchentlichen Kerze) sieht so aus:
for(int istat = 0; istat < ArraySize(liststatistic); istat++) { int cntsignals = 0; int cntsucsess = 0; for(int i=bars-1; i>=0; i--) { double colorcandle=iClose(symbol,PERIOD_W1,i)-iOpen(symbol,PERIOD_W1,i); if(symbol=="USDCHF" || symbol=="USDCAD" || symbol=="USDJPY") colorcandle=-colorcandle; double cotdirection=GetCotSignalDirection(i,liststatistic[istat]); if(cotdirection==0)continue; //no signal cntsignals++; if(cotdirection*colorcandle>0) cntsucsess++; //color and direction are same } if(cntsignals!=0) probably[istat]=1.*cntsucsess/cntsignals; Print("Calculation complete for ",symbol,GetStringTypeStatistic(liststatistic[istat]), " the correct forecast probability=",DoubleToString(probably[istat],2)); Print("Total signals:",cntsignals,"success:",cntsucsess); }Die LoadDataFromCOTIndikator Funktion ist kompliziert, da hier zahlreiche Prüfungen durchgeführt werden müssen, damit man Daten vom Indikator erhält. Also müssen wir sie uns im Einzelnen ansehen:
bool LoadDataFromCOTIndicator( string symbol, //symbol name ENUM_TIMEFRAMES timeframe, //timeframe cot_type_traders type_trader, //group of traders type cot_type_data type_data , //indicator type cot_type_report type_report, //report type double& loadto[], //output data array int nbars ) //number of requested bars { int cothandle; nbars+=10 ; //for reserve cothandle = iCustom( symbol , timeframe, "cot", type_trader, type_data, type_report );
In der letzten Zeile erhalten wir den Handle des individuell angepassten Indikators mit dessen Hilfe man die Daten aus den Buffern bekommt.
Hier müssen wir überprüfen, ob der Indikator erfolgreich erzeugt wurde:
if( cothandle == INVALID_HANDLE ){ Print("Error in indicator creation for symbol ", symbol ); return(false); }
Wir müssen nach History-Daten suchen, die wir brauchen:
int n = BarsSinh( symbol, timeframe ); if( n < nbars ) {
Sind nicht genügend History-Daten vorhanden, müssen wir welche laden:
Print("Loading history for ", symbol ); //, " start at ", loadtm CheckLoadHistory( symbol ,timeframe, loadtm ); n = BarsSinh( symbol, timeframe ); if( n < nbars ) { Print("Not enough history for the "+symbol, " total ", n, "bars"); return(false); } }
Die BarsSinh (liefert die Anzahl der Balken, die auf dem spezifizierten Symbol und dem Zeitrahmen vorhanden sind) und CheckLoadHistory (Download der History) Funktion beruhen auf dem Script code aus der MQL5 Referenz.
Bevor wir die Daten aus dem Indikator-Buffer verwenden können, müssen wir überprüfen, ob die Daten vorbereitet worden sind, denn die Anwesenheit eines Handles allein heißt noch lange nicht, dass die Berechnung auch abgeschlossen ist.
Der nächste Aufruf führt diese Prüfung durch und wartet, wenn die Berechnung abgeschlossen ist:
if( !WaitForCalculcateIndicator( cothandle ) ){ Print("Timeout for the COT indicator calculation"); return(false); }
Die Daten sind OK, jetzt müssen wir sie kopieren:
int res = CopyBuffer(cothandle, 0, 0, nbars, loadto );
Danach überprüfen wir, ob die Daten auch erfolgreich kopiert wurden:
if( res != nbars ){ Print("Error in obtaining the data, ", MyErrorDescription(_LastError) ); return(false); }
Und schließlich
return(true);
haben wir dann die Daten und liefern sie in da Array, dass von einem Funktionsparameter übertragen wurde.
Die so entstandene Statistik wird in die CSV-Datei geschrieben, denn zu diesem Zweck wurde ja die CCOTOutFile Klasse entwickelt:
class CCOTOutFile { private: string filename; int handle; public: bool Init( string passedname ); void PutString( string symbol, double& probably[] ); void PutHeader( cot_type_statistics& arrheaders[] ) ; void ~CCOTOutFile(){ FileClose(handle); } };
Sie erzeugt die Datei mit den Ausgabedaten, schreibt Strings im .csv-Format, erzeugt die Kopfzeile und schließt die Datei während der Vernichtung der Klasseninstanz.
Der Code für das Script ist nur kurz, denn alle notwendigen Libraries sind bereits schon geschrieben.
Die Eingabeparameter und mit eingeschlossenen Libraries:
input int NBars =150; //History depth W1 #include <common.mqh> #include <cot.mqh>
Liste der Symbole für die Analyse:
string listsymbols[] = {"EURUSD", "GBPUSD", "USDCHF", "USDCAD", "USDJPY", "AUDUSD", "XAUUSD"};
Objekt-Initialisierung:
void OnStart() { CCOTOutFile outfile; //file with results if( !outfile.Init("cotw1signals.csv") )return;
Liste der Statistik zur Berechnung:
cot_type_statistics list_statistic[]= // statistic types list
{ speculantsign, speculantchange, willamszones };
CSV-Datei Kopfzeile wird geschrieben:
outfile.PutHeader( list_statistic ); //writing CSV file header
In der Hauptschleife erhalten wir die Statistik für jedes Symbol und Signal und schreiben die Ergebnisse in eine Datei:
for( int i = 0; i < ArraySize(listsymbols); i++ ) //for all symbols in the list { Print( "Analysis for "+listsymbols[i] ); CCOTStatistic stat; stat.Init( listsymbols[i ], list_statistic ); double probably[]; //probability of a signal if( !stat.Get( probably ) ) { Print( "Error in statistics calculation for the symbol ", listsymbols[i] ); return; } outfile.PutString( listsymbols[i], probably ); //write string to .csv file } Print("Calculation complete."); }
Das Script ist auf einem Alpari-Demo Server getestet worden. Wenn Sie es auf einem MetaQuotes-Demo Server laufen lassen, wird die Meldung "Fehler bei der Statistik-Berechnung für das XAUUSD Symbol" erscheinen, denn dieses Symbol ist jetzt nicht verfügbar.
Das Ergebnis der Ausführung des Scripts ist eine Datei, die folgendermaßen aussieht:
Um sie verständlicher zu machen, öffnen wir sie in Excel, berechnen die Durchschnittswerte und erzeugen das Histogramm der Wahrscheinlichkeiten:
Fig. 8 Prognosewahrscheinlichkeit
- 0,54 – Zeichen für nicht gewerbliche Händler;
- 0,50 – Volumenänderungen bei Netto-Long Positions nicht gewerblicher Händler;
- 0,48 – die überkauft/überverkauft Bereiche des Williams-Index.
Wie Sie sehen, haben wir für die Netto-Long Positions nicht gewerblicher Händler die besten Prognoseergebnisse erhalten. Am schlechtesten schneiden die Bereiche des Williams-Index ab. Der Wert 0,48 besagt, dass die Wahrscheinlichkeit für eine weiße Kerze = 0,52 ist, selbst wenn der Williams-Index überkauft ist und eine schwarze Kerze, falls er überverkauf tist. Daher ist seine Verwendung in der Form wie sie von Williams gezeigt wird, nicht logisch. Vielleicht können die Ergebnisse mit Hilfe größerer Zeiträume - einem Monat oder länger - verbessert werden. Wir haben alle auf den Demo-Servern und in den COT-Berichten vorhandenen Symbole verwendet.
Fazit
MQL5 ist ein Tool mit dem Sie den gesamten Zyklus an Aufgaben programmieren können, der zur Entwicklung eines Handelssystems notwendig ist:- Die Indikatoren mit komplizierten Algorithmen, die für den Zugriff auf externe Datenquellen verwendet werden;
- Ihre Wiederverwendung in anderen Indikatoren, Scripts und Expert Advisors;
- Die Implementierung eigener Algorithmen für statistische und quantitative Analyse.
- Objekt-orientiertes Programmieren bringt eine erheblich Zeitersparnis im Hinblick auf Fehlersuche und Behebung.
- Fehlersuchprogramm.
- Leichte Migration von MQL4 auf MQL5.
- Die Implementierung des Objekt-orientierten Modells ist dann gelungen, wenn es leicht zu verwenden ist
- Die Dokumentation ist gut und klar aufgebaut.
- Die Integration mit Windows API erweitert die Plattform, da nun z.B. die Arbeit mit Internetseiten möglich ist.
Nachteile:
Das größte Problem für mich war der Zugriff auf die historischen Daten:- Mangel an notwendigen, primitiven Funktion für einen Zugriff auf Zeitreihen (wie Time[], Open[], Close[] und andere in MQL4)
- Beim Zugriff auf Daten müssen zahlreiche Überprüfungen durchgeführt werden, ob auf sie auch zugegriffen werden kann und es ist notwendig sie in ihren Einzelheiten zu verstehen.
Es gibt zwar ein Fehlersuchprogramm, aber mit kaum wirklich nützlichen Features: es gibt keine Fehlersuche bei Indikatoren und des weiteren ist es auch nicht möglich komplizierte Objekte, wie Arrays und Klassen zu prüfen. Diese Aufzählung der Vor- und Nachteile ist nicht vollständig. Ich habe hier nur das aufgeführt, was mir während des Verfassens dieses Beitrags aufgefallen ist.
Anhang 1 Liste der Dateien
Alle Dateien finden sich im Client-Terminal Ordner. Entpacken Sie diese Dateien aus sources.zip in den Client-Terminal Ordner.
№ | Dateiname | Beschreibung |
---|---|---|
1 | MQL5\Files\unzip.exe | Windows-Anwendung zum Entpacken von .zip Archiven |
2 | MQL5\Include\Cdownloader.mqh | Klasse, die CFTC-Archive aus dem Internet herunterlädt |
3 | MQL5\Include\ClassProgressBar.mqh | Klasse CProgressBar, mit deren Hilfe der Download-Vorgang im Chartfenster angezeigt wird |
4 | MQL5\Include\common.mqh | Gemeinsame Funktionen und Konstanten, die in allen Indikatoren und Scripts verwendet werden |
5 | MQL5\Include\cot.mqh | Klasse CCFTCReport, die die Daten aus COT-Berichten auswählt |
6 | MQL5\Include\ErrorDescription.mqh | Fehlerbeschreibungs-Library |
7 | MQL5\Indikators\cot.mq5 | Der Basisindikator cot |
8 | MQL5\Indikators\cotnet.mq5 | Der Indikator cotnet, ein einfaches Anwendungsbeispiel des cot.mq5 benutzerdefinierten Indikators |
9 | MQL5\Scripts\cotdownloader.mq5 | Script cotdownloader: lädt die ArchivDateien aus dem Internet herunter |
10 | MQL5\Scripts\cotsignals.mq5 | Script cotsignals: Beispiel einer statistischen Analyse von COT-Berichten |
Tabelle 2 Liste der Dateien
Anhang 2 Liste aller in COT-Berichten verfügbaren Symbole
№ | Symbolname | ID an der Börse | ID im Client-Terminal | In CIT vorhanden | In DCOT vorhanden |
---|---|---|---|---|---|
1 | WHEAT - CHICAGO BOARD OF TRADE | 001602 | ZW | x | x |
2 | WHEAT - KANSAS CITY BOARD OF TRADE | 001612 | x | x | |
3 | WHEAT - MINNEAPOLIS GRAIN EXCHANGE | 001626 | x | ||
4 | CORN - CHICAGO BOARD OF TRADE | 002602 | ZC | x | x |
5 | OATS - CHICAGO BOARD OF TRADE | 004603 | ZO | x | |
6 | SOYBEANS - CHICAGO BOARD OF TRADE | 005602 | ZS | x | x |
7 | MINI SOYBEANS - CHICAGO BOARD OF TRADE | 005603 | x | ||
8 | SULFUR FINANCIAL INSTRUMENT - CHICAGO CLIMATE FUTURES EXCHANGE | 006261 | x | ||
9 | CARBON FINANCIAL INSTRUMENT - CHICAGO CLIMATE FUTURES EXCHANGE | 006268 | x | ||
10 | RGGI CO2 ALLOWANCE 2009 - CHICAGO CLIMATE FUTURES EXCHANGE | 00626U | x | ||
11 | SOYBEAN OIL - CHICAGO BOARD OF TRADE | 007601 | ZL | x | x |
12 | U.S. TREASURY BONDS - CHICAGO BOARD OF TRADE | 020601 | ZB | ||
13 | LONG-TERM U.S. TREASURY BONDS - CHICAGO BOARD OF TRADE | 020604 | |||
14 | GULF # 6 FUEL 3.0% SULFUR SWAP - NEW YORK MERCANTILE EXCHANGE | 02165A | x | ||
15 | NY RES FUEL 1.0% SULFUR SWAP - NEW YORK MERCANTILE EXCHANGE | 02165B | x | ||
16 | EUR 1% FUEL OIL NWE CAL SWAP - NEW YORK MERCANTILE EXCHANGE | 02165C | x | ||
17 | EUR 3.5% FUEL OIL RTD CAL SWAP - NEW YORK MERCANTILE EXCHANGE | 02165E | x | ||
18 | SING FUEL OIL 180 CAL SWAP - NEW YORK MERCANTILE EXCHANGE | 02165G | x | ||
19 | EAST WEST FUEL OIL SPR SWAP - NEW YORK MERCANTILE EXCHANGE | 02165I | x | ||
20 | NY 1% V GULF 3% FUEL OIL SPR - NEW YORK MERCANTILE EXCHANGE | 02165T | x | ||
21 | NO. 2 HEATING OIL | 022651 | x | ||
22 | SING GASOIL SWAP - NEW YORK MERCANTILE EXCHANGE | 02265J | x | ||
23 | SING GASOIL/RDAM GASOIL SWAP - NEW YORK MERCANTILE EXCHANGE | 02265T | x | ||
24 | NYMEX HEATING OIL/RDAM GASOIL - NEW YORK MERCANTILE EXCHANGE | 02265U | x | ||
25 | GASOIL (ICE) SWAP - NEW YORK MERCANTILE EXCHANGE | 02265V | x | ||
26 | UP DOWN GC ULSD VS HO SPR SWAP - NEW YORK MERCANTILE EXCHANGE | 022A13 | x | ||
27 | SING GASOIL BALMO SWAP - NEW YORK MERCANTILE EXCHANGE | 022A22 | x | ||
28 | NATURAL GAS ICE HENRY HUB - ICE OTC | 023391 | x | ||
29 | NATURAL GAS - NEW YORK MERCANTILE EXCHANGE | 023651 | QG | x | |
30 | MICHCON BASIS SWAP - NEW YORK MERCANTILE EXCHANGE | 02365A | x | ||
31 | M-3 BASIS SWAP - NEW YORK MERCANTILE EXCHANGE | 02365C | x | ||
32 | TCO BASIS SWAP - NEW YORK MERCANTILE EXCHANGE | 02365D | |||
33 | NGPL TEXOK BASIS SWAP - NEW YORK MERCANTILE EXCHANGE | 02365G | x | ||
34 | NGPL MIDCON BASIS SWAP - NEW YORK MERCANTILE EXCHANGE | 02365K | x | ||
35 | WAHA BASIS SWAP - NEW YORK MERCANTILE EXCHANGE | 02365O | x | ||
36 | HOUSTON SHIP CH INDEX SWAP - NEW YORK MERCANTILE EXCHANGE | 023A10 | x | ||
37 | CBT ETHANOL - CHICAGO BOARD OF TRADE | 025601 | x | ||
38 | CHICAGO ETHANOL SWAP - NEW YORK MERCANTILE EXCHANGE | 025651 | x | ||
39 | SOYBEAN MEAL - CHICAGO BOARD OF TRADE | 026603 | ZM | x | |
40 | JAPAN C&F NAPTHA SWAP - NEW YORK MERCANTILE EXCHANGE | 03265C | x | ||
41 | COTTON NO. 2 - ICE FUTURES U.S. | 033661 | CT | x | x |
42 | HENRY HUB BASIS SWAP - NEW YORK MERCANTILE EXCHANGE | 035652 | x | ||
43 | HOUSTON SHIP CH BASIS SWAP - NEW YORK MERCANTILE EXCHANGE | 035653 | x | ||
44 | NW PIPE ROCKIES BASIS SWAP - NEW YORK MERCANTILE EXCHANGE | 035654 | x | ||
45 | PANHANDLE BASIS SWAP - NEW YORK MERCANTILE EXCHANGE | 035655 | x | ||
46 | HENRY HUB SWAP - NEW YORK MERCANTILE EXCHANGE | 03565B | |||
47 | HENRY HUB PENULTIMATE GAS SWAP - NEW YORK MERCANTILE EXCHANGE | 03565C | x | ||
48 | ROUGH RICE - CHICAGO BOARD OF TRADE | 039601 | ZR | x | |
49 | FRZN CONCENTRATED ORANGE JUICE - ICE FUTURES U.S. | 040701 | JO | x | |
50 | 2-YEAR U.S. TREASURY NOTES - CHICAGO BOARD OF TRADE | 042601 | |||
51 | 10-YEAR U.S. TREASURY NOTES - CHICAGO BOARD OF TRADE | 043602 | ZN | ||
52 | 5-YEAR U.S. TREASURY NOTES - CHICAGO BOARD OF TRADE | 044601 | |||
53 | 30-DAY FEDERAL FUNDS - CHICAGO BOARD OF TRADE | 045601 | ZQ | ||
54 | MILK Class III - CHICAGO MERCANTILE EXCHANGE | 052641 | x | ||
55 | LEAN HOGS - CHICAGO MERCANTILE EXCHANGE | 054642 | HE | x | x |
56 | LIVE CATTLE - CHICAGO MERCANTILE EXCHANGE | 057642 | LC | x | x |
57 | RANDOM LENGTH LUMBER - CHICAGO MERCANTILE EXCHANGE | 058643 | LB | x | |
58 | FEEDER CATTLE - CHICAGO MERCANTILE EXCHANGE | 061641 | FC | x | x |
59 | PJM ELECTRICITY MONTHLY - NEW YORK MERCANTILE EXCHANGE | 064657 | x | ||
60 | ISO NEW ENGLAND LMP SWAP - NEW YORK MERCANTILE EXCHANGE | 06465H | x | ||
61 | PJM CAL MONTH OFF PK LMP SWAP - NEW YORK MERCANTILE EXCHANGE | 06465M | x | ||
62 | ISO NEW ENG OFF PK LMP SWAP - NEW YORK MERCANTILE EXCHANGE | 06465S | x | ||
63 | CINERGY CAL MONTH LMP SWAP - NEW YORK MERCANTILE EXCHANGE | 064A01 | x | ||
64 | CINERGY OFF PEAK LMP SWAP - NEW YORK MERCANTILE EXCHANGE | 064A02 | |||
65 | PJM N ILL PEAK DAY AHEAD - NEW YORK MERCANTILE EXCHANGE | 064A34 | x | ||
66 | PJM JCPL PEAK DAY AHEAD - NEW YORK MERCANTILE EXCHANGE | 064A48 | x | ||
67 | PJM PEPCO PEAK DAY AHEAD - NEW YORK MERCANTILE EXCHANGE | 064A50 | x | ||
68 | PJM PSEG PEAK DAY AHEAD - NEW YORK MERCANTILE EXCHANGE | 064A54 | x | ||
69 | PJM WESTERN PEAK DAY AHEAD - NEW YORK MERCANTILE EXCHANGE | 064A56 | |||
70 | PJM WESTERN PEAK REAL TIME - NEW YORK MERCANTILE EXCHANGE | 064A58 | x | ||
71 | PJM WESTERN OFF PEAK REAL TIME - NEW YORK MERCANTILE EXCHANGE | 064A59 | x | ||
72 | ISO NEW ENG INT HUB PEAK SWAP - NEW YORK MERCANTILE EXCHANGE | 064A60 | x | ||
73 | MW IND TRANS PEAK SWAP - NEW YORK MERCANTILE EXCHANGE | 064A62 | x | ||
74 | NYISO ZONE 5 MW PEAK SWAP - NEW YORK MERCANTILE EXCHANGE | 064A66 | |||
75 | ISO NEW ENG HUB OFF PEAK SWAP - NEW YORK MERCANTILE EXCHANGE | 064A78 | |||
76 | MT BELVIEU PROPANE 5 DEC SWAP - NEW YORK MERCANTILE EXCHANGE | 06665O | |||
77 | MT BELVIEU ETHANE 5 DEC SWAP - NEW YORK MERCANTILE EXCHANGE | 06665P | x | ||
78 | MT BELV NORM BUTANE 5 DEC SWAP - NEW YORK MERCANTILE EXCHANGE | 06665Q | x | ||
79 | MT BELV NAT GASOLINE 5 DEC SWP - NEW YORK MERCANTILE EXCHANGE | 06665R | x | ||
80 | CRUDE OIL LIGHT SWEET - ICE FUTURES EUROPE LIGHT SWEET - ICE FUTURES EUROPE | 067411 | x | ||
81 | CRUDE OIL, LIGHT SWEET - NEW YORK MERCANTILE EXCHANGE | 067651 | QM | x | |
82 | WTI CRUDE OIL CALENDAR SWAP - NEW YORK MERCANTILE EXCHANGE | 06765A | x | ||
83 | DUBAI CRUDE OIL CALENDAR SWAP - NEW YORK MERCANTILE EXCHANGE | 06765G | x | ||
84 | WTI CRUDE OIL FINANCIAL - NEW YORK MERCANTILE EXCHANGE | 06765I | x | ||
85 | BRENT FINANCIAL - NEW YORK MERCANTILE EXCHANGE | 06765J | x | ||
86 | BRENT (ICE) CALENDAR SWAP - NEW YORK MERCANTILE EXCHANGE | 06765N | x | ||
87 | BRENT-DUBAI SWAP - NEW YORK MERCANTILE EXCHANGE | 06765O | x | ||
88 | COCOA - ICE FUTURES U.S. | 073732 | CC | x | x |
89 | PALLADIUM - NEW YORK MERCANTILE EXCHANGE | 075651 | PA | x | |
90 | PLATINUM - NEW YORK MERCANTILE EXCHANGE | 076651 | PL | x | |
91 | SUGAR NO. 11 - ICE FUTURES U.S. | 080732 | SB | x | x |
92 | COFFEE C - ICE FUTURES U.S. | 083731 | KC | x | x |
93 | SILVER - COMMODITY EXCHANGE INC. | 084691 | SI,XAGUSD,ZI | x | |
94 | COPPER-GRADE #1 - COMMODITY EXCHANGE INC. | 085692 | HG | x | |
95 | GOLD - COMMODITY EXCHANGE INC. | 088691 | GC,GOLD,XAUUSD | x | |
96 | RUSSIAN RUBLE - CHICAGO MERCANTILE EXCHANGE | 089741 | USDRUB,USDRUR | ||
97 | CANADIAN DOLLAR - CHICAGO MERCANTILE EXCHANGE | 090741 | 6C,USDCAD | ||
98 | SWISS FRANC - CHICAGO MERCANTILE EXCHANGE | 092741 | 6S,USDCHF | ||
99 | MEXICAN PESO - CHICAGO MERCANTILE EXCHANGE | 095741 | |||
100 | BRITISH POUND STERLING - CHICAGO MERCANTILE EXCHANGE | 096742 | 6B,GBPUSD | ||
101 | JAPANESE YEN - CHICAGO MERCANTILE EXCHANGE | 097741 | 6J,USDJPY | ||
102 | U.S. DOLLAR INDEX - ICE FUTURES U.S. | 098662 | DX | ||
103 | EURO FX - CHICAGO MERCANTILE EXCHANGE | 099741 | 6E,EURUSD | ||
104 | GASOLINE BLENDSTOCK (RBOB) - NEW YORK MERCANTILE EXCHANGE | 111659 | XRB | x | |
105 | RBOB CALENDAR SWAP - NEW YORK MERCANTILE EXCHANGE | 11165K | x | ||
106 | NEW ZEALAND DOLLAR - CHICAGO MERCANTILE EXCHANGE | 112741 | 6N,NZDUSD | ||
107 | VIX FUTURES - CBOE FUTURES EXCHANGE | 011700 | |||
108 | DOW JONES INDUSTRIAL AVERAGE - CHICAGO BOARD OF TRADE | 124601 | |||
109 | 3-MONTH EURODOLLARS - CHICAGO MERCANTILE EXCHANGE | 132741 | |||
110 | S&P 500 STOCK INDEX - CHICAGO MERCANTILE EXCHANGE | 138741 | |||
111 | E-MINI S&P 500 STOCK INDEX - CHICAGO MERCANTILE EXCHANGE | 13874A | ES,SPX | ||
112 | NASDAQ-100 STOCK INDEX - CHICAGO MERCANTILE EXCHANGE | 209741 | NQ | ||
113 | NASDAQ-100 STOCK INDEX (MINI) - CHICAGO MERCANTILE EXCHANGE | 209742 | |||
114 | DOW JONES UBS EXCESS RETURN - CHICAGO BOARD OF TRADE | 221602 | |||
115 | AUSTRALIAN DOLLAR - CHICAGO MERCANTILE EXCHANGE | 232741 | 6A,AUDUSD | ||
116 | RUSSELL 2000 MINI INDEX FUTURE - ICE FUTURES U.S. | 23977A | |||
117 | NIKKEI STOCK AVERAGE - CHICAGO MERCANTILE EXCHANGE | 240741 | |||
118 | NIKKEI STOCK AVERAGE YEN DENOM - CHICAGO MERCANTILE EXCHANGE | 240743 | |||
119 | E-MINI MSCI EAFE - CHICAGO MERCANTILE EXCHANGE | 244741 | |||
120 | E-MINI MSCI EMERGING MARKETS - CHICAGO MERCANTILE EXCHANGE | 244742 | |||
121 | INTEREST RATE SWAPS 10YR - CHICAGO BOARD OF TRADE | 246602 | |||
122 | INTEREST RATE SWAPS 5YR - CHICAGO BOARD OF TRADE | 247602 | |||
123 | S&P GSCI COMMODITY INDEX - CHICAGO MERCANTILE EXCHANGE | 256741 | |||
124 | SING JET KERO SWAP - NEW YORK MERCANTILE EXCHANGE | 26265D | |||
125 | E-MINI S&P 400 STOCK INDEX - CHICAGO MERCANTILE EXCHANGE | 33874A | |||
126 | GULF JET NY HEAT OIL SPR SWAP - NEW YORK MERCANTILE EXCHANGE | 86465A | x | ||
127 | SING JET KERO GASOIL SPR SWAP - NEW YORK MERCANTILE EXCHANGE | 86465C | x | ||
128 | JET CIF NWE/GASOIL FUT - NEW YORK MERCANTILE EXCHANGE | 86465D | x | ||
129 | GULF # 6 FUEL OIL CRACK SWAP - NEW YORK MERCANTILE EXCHANGE | 86565A | x | ||
130 | 3.5% FUEL OIL RDAM CRACK SPR - NEW YORK MERCANTILE EXCHANGE | 86565C | x | ||
131 | NAPTHA CRACK SPR SWAP - NEW YORK MERCANTILE EXCHANGE | 86665A | x | ||
132 | GASOIL CRACK SPR SWAP - NEW YORK MERCANTILE EXCHANGE | 86765C | x |
Tabelle 3 Liste aller in COT-Berichten verfügbaren Symbole
Übersetzt aus dem Russischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/ru/articles/34
- 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.