MQL5: Analyse und Umgang mit Berichten der US-Warenterminhandelsaufsichtsbehörde (US-Warenterminhandelsaufsichtsbehörde , CFTC) in MetaTrader 5

12 Februar 2016, 13:05
Aleksey Sergan
0
2 226


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

deacot2010.zip

dea_cit_txt_2010.zip

fut_disagg_txt_2010.zip

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 http://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.mqhmit 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 http://www.cftc.gov/files/dea/history/deacot2010.zip Datei den Bericht für das Jahr 2010, die http://www.cftc.gov/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 buffers
Die 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.

Den Erhalt der Daten des Indikators übernimmt die Funktion OnCalculate:
  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.

Überprüfen wir anhand der unterschiedlichen Daten der COT-Berichte welchen statistischen Vorteil wir erhalten. Am einfachsten ist, die Wahrscheinlichkeit der exakten Festlegung der wöchentlichen Kerzenfarbe abzuschätzen. Betrachten wir die folgenden Annahmen:
  • 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

Die Prognoseergebnisse sind für alle Symbole gleich. Die gemittelten Werte der korrekten Prognosewahrscheinlichkeit für unterschiedliche Signaltypen sind:
  • 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.
Vorteile:
  • 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 Software Corp.
Originalartikel: https://www.mql5.com/ru/articles/34

Beigefügte Dateien |
sources.zip (211.23 KB)
Verarbeitung von Ereignissen in MQL5: Unmittelbare Änderung des Zeitraums für den gleitenden Durchschnitt Verarbeitung von Ereignissen in MQL5: Unmittelbare Änderung des Zeitraums für den gleitenden Durchschnitt

Angenommen, dass ein MA (Gleitender Durchschnitt) Indikator mit Zeitraum 13 auf ein Chart angewandt wird. Und wir den Zeitraum auf 20 ändern wollen, wir dazu aber nicht in das Dialogfenster Indikator-Eigenschaften gehen und die Zahl von 13 zu 20 ändern wollen, da wir einfach auf diese Aktionen mit der Maus und der Tastatur keine Lust mehr haben. Und wir wollen vor allem nicht den Indikator-Code öffnen und dort was ändern. Wir wollen einfach nur eine Taste drücken - und zwar "Bild nach oben" neben dem Zahlenfeld auf der Tastatur. In diesem Beitrag sage ich Ihnen wie das geht.

Erzeugung eines Indikators mit graphischen Kontrolloptionen Erzeugung eines Indikators mit graphischen Kontrolloptionen

All diejenigen, die sich mit Stimmungen auf dem Markt auskennen, kennen den MACD Indikator (seiner voller Name lautet Gleitender Durchschnitt Konvergenz/Divergenz) -das leistungsstarke Tool zur Analyse von Kursbewegungen, das von Händlers seit dem ersten Auftauchen von Computer-gestützten Analysemethoden verwendet wird. Dieser Beitrag beschäftigt sich mit möglichen Veränderungen des MACD und ihrer Implementierung in einen Indikator mit der Möglichkeit, zwischen den Veränderungen graphisch hin- und her zu wechseln.

Praktische Implementierung digitaler Filter in MQL5 für Anfänger Praktische Implementierung digitaler Filter in MQL5 für Anfänger

Der Gedanke einer Filterung digitaler Signale ist in Foren für den Aufbau von Handelssystemen umfassend diskutiert worden. Und es wäre sehr unschlau, keinen Standardcode für digitale Filter in MQL5 zu erzeugen. In diesem Beitrag beschreibt der Autor die Umwandlung des Codes eines einfachen SMA Indikators aus seinem Beitrag "Angepasste Indikatoren in MQL5 für Anfänger" in einen Code für einen komplizierteren und digitalen Filter. Daher ist dieser Beitrag die logische Fortsetzung des vorhergehenden. Außerdem wird hier auch gezeigt, wie man Text im Code ersetzen und Programmierfehler korrigieren kann.

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

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