MQL5: Analisi ed Elaborazione dei Report della Commodity Futures Trading Commission (CFTC) in MetaTrader 5
220
0
Introduzione
Terminale di trading MetaTrader 5, sviluppato da MetaQuotes Software Corp., come uno degli strumenti del trader contiene il linguaggio di programmazione MQL5 che supporta la programmazione orientata agli oggetti. Da un lato, MQL5 non è compatibile con la sua versione precedente - MQL4, dall'altro - ha molte nuove possibilità di linguaggio orientato agli oggetti completo. Quindi, i trader, che hanno già competenze in MQL4, devono comprendere questo (di fatto) nuovo linguaggio e li considero come pubblico di destinazione di questo articolo.
In questo articolo, mostrerò una soluzione del seguente problema: è necessario sviluppare lo strumento trader che consente di ottenere e analizzare diversi dati dei report della Commodity Futures Trading Commission (CFTC). Questo argomento è già stato considerato nell'articolo Meta COT Project - Nuovi Orizzonti per le Analisi dei Report CFTC in MetaTrader 4 quindi presumo che il lettore abbia familiarità con i concetti e considereremo i dettagli che non sono descritti lì.
L'idea è la seguente: sviluppare un unico indicatore che consenta di ottenere dati dai file, forniti dalla Commissione, senza elaborazione intermedia e conversione. Inoltre, può essere utilizzato per i diversi scopi: tracciare i dati come indicatore; come fonte di dati in altri indicatori; in script per l'analisi automatizzata; negli Expert Advisor durante lo sviluppo di strategie di trading.
1.Tipi di report COT
Ci sono tre tipi di report: Current Legacy Report (COT), Supplemental Commodity Index (CIT), Current Disaggregated Report (DCOT), la differenza tra loro è presentata nella Tabella 1.
| Descrizione | Rapporti sull'Eredità Corrente | Indice Supplementare delle Materie Prime | Report Disaggregati Attuali |
|---|---|---|---|
| Short name | COT | CIT | DCOT |
| Titolo di riferimento | Report sull'Eredità Corrente | Indice Supplementare delle Materie Prime | Report Disaggregati Attuali |
| Riferimento al file di dati recente | |||
| Gruppi di trader, presentati nel report | Non commerciali Commerciali Non segnalabili | Non commerciali Commerciali Non segnalabili Traders dell'indice | Produttore/Commerciante/Trasformatore/Utente Commercianti di Scambio Denaro Gestito Altri Segnalabili Non segnalabili |
Tabella 1. Tipi di Report sugli Impegni dei Trader
Informazioni sui trader che dovrebbero riportare le loro posizioni sui mercati dei futures, i principi di classificazione e la periodicità dei report sono disponibili su "Trade Stocks and Commodities With the Insiders: Secrets of the COT Report" e nell'articolo Il progetto Meta COT- Nuovi Orizzonti per l’Analisi Report CFTC in MetaTrader 4.
Prenderò in considerazione due report che non sono descritti in queste fonti.
L'acronimo CIT sta per Impegni dei Trader degli Indici. Questo report è stato pubblicato dal 2007. L'attuale pagina Web del report CIT è disponibile all'indirizzo https://cftc.gov/dea/options/deaviewcit.htm. I trader dell'indice sono in un gruppo separato dagli hedger e dagli speculatori.
La descrizione del Report Supplementare è disponibile su https://www.cftc.gov/MarketReports/CommitmentsofTraders/AbouttheCOTReports/index.htm. Tutti questi trader di indici spesso aprono posizioni lunghe sui mercati e le rinnovano da contratto a contratto.
Dal 2009 la Commissione pubblica il Report sugli Impegni Disaggregati dei Traderla cui descrizione è disponibile nelle note esplicative .
Il report COT disaggregato aumenta la trasparenza rispetto ai report COT legacy separando i trader nelle seguenti quattro categorie di trader: Produttore/Commerciante/Trasformatore/Utente; Rivenditori di Scambio; Denaro gestito; e altri Segnalabili.
- Produttore/Commerciante/Trasformatore/Utente. Un "produttore/commerciante/trasformatore/utente" è un'entità che si impegna prevalentemente nella produzione, trasformazione, imballaggio o manipolazione di una merce fisica e utilizza i mercati dei futures per gestire o coprire i rischi associati a tali attività.
- Swap Dealer. Uno "swap dealer" è un'entità che si occupa principalmente di scambiare una merce e utilizza i mercati dei futures per gestire o coprire il rischio associato a tali transazioni di scambio. Le controparti del rivenditori di scambio possono essere trader speculativi, come gli hedge fund, o clienti commerciali tradizionali che gestiscono il rischio derivante dalle loro transazioni nella merce fisica.
- Money Manager. Un "gestore di denaro", ai fini di questo rapporto, è un consulente registrato per il trading di materie prime (CTA); un operatore registrato di commodity pool (CPO); o un fondo non registrato identificato dalla CFTC. Questi trader sono impegnati nella gestione e nella conduzione di trading di futures organizzati per conto dei clienti.
- Altri Segnalabili. Ogni altro trader segnalabile che non è collocato in una delle altre tre categorie viene inserito nella categoria "altri segnalabili".
L'elenco completo degli strumenti segnalati è presentato nell’Appendice 2. Ci sono anche colonne che riflettono la presenza di unparticolare strumento nei report CIT e DCOT.
2. Scrittura di un indicatore COT che utilizza dati esterni da file CSV
L'indicatore funzionerà come segue. Il tipo di report (uno di quelli elencati nella Tabella 1), il tipo di dati e il gruppo di trader sono definiti nei parametri di input dell'indicatore.
La tipologia di dati può essere la seguente:
- lunghi netti
- tasso long netto in open interest
- Indice Williams, calcolato per i lunghi netti
- open interest
L'elenco dei possibili tipi di dati non è completo, può essere facilmente esteso ulteriormente per includere la maggior parte dei dati essenziali, che utilizzo. Per il simbolo corrente, i dati specificati vengono richiesti dai file di dati (il download e il decompressione sono descritti di seguito). Utilizzeremo la classe CCFTCReport per l'accesso ai dati e il loro download da questi file.
L'indicatore ha la seguente struttura:
2.1. Costanti
Per definire le costanti viene utilizzato il tipo di dati enum. I tipi di report, supportati da indicatori, sono i seguenti:enum cot_type_report // type of report { COT, DCOT, CIT };
Gruppi di trader:
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 };
Tipi di dati che possono essere utilizzati nell'indicatore:
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. Classi
Per memorizzare oggetti diversi all'interno di un'unica variabile è possibile utilizzare strutture e classi. Tuttavia, non è possibile assegnare due variabili di tipo struttura, se contengono array dinamici o valori di tipo stringa. Ecco perché abbiamo usato la classe invece della struttura per archiviare il record COT e il metodo per l'assegnazione dei dati.
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; }; };
Da ora, presumo che il lettore abbia familiarità con il formato CSV dei report COT che è considerato nell'articolo Meta COT Project - Nuovi Orizzonti per l'Analisi dei Report CFTC in MetaTrader 4. L'istanza di classe di questo tipo verrà utilizzata per archiviare una singola riga del report COT. Un array di queste istanze di classe consentirà di utilizzarle per l'archiviazione e un comodo accesso ai campi dei record COT. La classe CCFTCReport è stata sviluppata per l'archiviazione e l'accesso ai dati:
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 };
L’istanza della classe CCFTCReport contiene l'intero report per un singolo simbolo, il tipo di report può essere COT, CIT o DCOT Le enumerazioni e le classi sono elencate nella "cot.mqh" file included.
2.3. Parametri di Input
I parametri di input sono definiti da variabili di input. Questi parametri consentono di specificare il gruppo di trader, il tipo di dati e il tipo di report COT necessario:
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. Funzione OnInit
Un indicatore ha la funzione OnInit che viene utilizzata per i seguenti scopi: scaricare dati dal file di report, controllare i parametri di input, assegnare i buffer dell'indicatore.
Il buffer, inizializzato con la proprietà INDICATOR_DATA, contiene dati tracciati sul grafico. Il buffer, inizializzato con la proprietà INDICATOR_CALCULATIONS contiene calcoli intermedi.
SetIndexBuffer( 0, BufferData, INDICATOR_DATA ); IndicatorSetString(INDICATOR_SHORTNAME,indname); SetIndexBuffer( 1, BufferCalculations, INDICATOR_CALCULATIONS );
2.5. Funzione OnCalculate
Questa funzione viene utilizzata per la selezione dei dati necessari, il calcolo dei dati richiesti e il loro grafico.
Consideriamo il suo lavoro in dettaglio. Viene utilizzata la seconda forma di invito:
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[]){
Determiniamo le barre per il calcolo e la tracciatura.
int pos=rates_total-prev_calculated-1; if( pos >= rates_total-1 )pos--;
Specifichiamo che gli elementi devono essere indicizzati come timeseries.
ArraySetAsSeries(Time, true); ArraySetAsSeries(BufferData, true); ArraySetAsSeries(BufferCalculations, true);
Dopo alcuni esperimenti, ho scoperto che è meglio usare l'indicizzazione delle timeseries per tutti gli array che sono associati ai buffer degli indicatori. Lo stesso vale per gli array che vengono passati alla funzione OnCalculate come parametri, l'ultimo elemento (recente) ha un indice, pari a 0.
Il ciclo di calcolo è simile al seguente:
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 ); }
L’ array BufferCalculations viene utilizzato per archiviare i dati primari, selezionati dal report COT.
L’array BufferData contiene dati pronti per la tracciatura sul grafico. Possono essere i valori del report (net longs, open interest) e i valori calcolati (longs rate, Williams Index). Vorrei definire il seguente punto, per il quale non ho trovato una soluzione elegante. Gli array, passati alla funzione OnCalculate, possono essere richiesti ai livelli successivi e possiamo accedervi solo se vengono passati in queste chiamate, quindi penso che ingombri il codice.
Lachiamata alla funzione CalcData:
BufferData[i] = CalcData( type_data, i, Time );
La funzioneCalcData chiama la funzione CalcIndex :
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]); }
Avevo bisogno di accedere all'array Time all'interno della funzione CalcIndex, quindi sono stato costretto a passarlo secondo la gerarchia delle chiamate. Immagina come apparirà il codice, se abbiamo bisogno di usare tutti e 8 gli array.
3. Download dei File di Dati
Tutti i collegamenti ai file sono presentati nella Tabella 1. C'è un file separato per ogni anno, il numero dell'anno è presente nel nome del file. Ad esempio, il file https://www.cftc.gov/sites/default/files/files/dea/history/deacot2010.zip contiene il report per l'anno 2010, il file https://www.cftc.gov/sites/default/files/files/dea/history/deacot2009.zip - per il 2009, ecc.
È necessario scaricare tutti questi file e decomprimerli nella cartella \MQL5\files\ della directory di installazione del Client Terminal. Per ogni anno, è necessario creare una propria cartella separata con un nome deacotXXXX, dove XXXX corrisponde ad un anno. Di conseguenza, otterremo la seguente struttura di cartelle.
Fig.1. Struttura delle cartelle per i report.
Il processo di preparazione dei dati può essere semplificato. Tutte le seguenti operazioni (verifica degli aggiornamenti sul sito CFTC, download e decompressione nelle apposite cartelle) vengono eseguite dallo script "Cotdownloader" . Il kernel dello script (download dei dati) si basa su WININET_TEST script. Ho utilizzato la CProgressBar, pubblicata nell'articolo L’Istogramma dei Prezzi (Profilo di Mercato) e la sua implementazione nell'articoloMQL5 . Le applicazioni esterne vengonoeseguite utilizzando la Windows API che è descritta nell'articolo Ottimizzazione Automatizzata di un Robot di trading nel Trading Reale.
Usare uno script è semplice: basta allegarlo a qualsiasi grafico. Quando funziona, riporta le informazioni sul download dei dati come barra di avanzamento sul grafico e come messaggi di testo nel tab Experts.
Fig.2. Processo di download dei dati.
4. Esempio di Utilizzo
Per eseguire un indicatore, è necessario collegarlo al grafico del simbolo scelto e specificare i parametri di input.
Fig. 3 Parametri di input dell'indicatore COT
Si noti che ora è possibile specificare una rappresentazione intuitiva anziché nomi di variabili e valori dei tipi di dati elencati. Ciò viene fatto come segue: per sostituire il nome della variabile, è necessario specificare un commento quando si dichiara una variabile di input:
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
Lo stesso avviene con i valori: è necessario specificare la descrizione nei commenti quando si dichiarano i valori elencati:
enum cot_type_data // types of data { netlongs, // Net longs netlongsrate, // Net longs rate in open interest willams_index, // Williams Index openinterest // Open Interest };
Se i parametri di input sono stati specificati correttamente e i file sono stati scaricati e decompressi, l'indicatore apparirà in una finestra separata:
Fig. 4 Indicatore COT
In caso di errori, verranno stampati nel tab "Experts" della finestra "Toolbox".
Fig. 5 Messaggio di errore
5. Note di Rilascio
L'indicatore non è posizionato come un prodotto finito completo. È un esempio che mostra come possiamo ottenere risultati, che possono essere utilizzati ulteriormente, scrivendo un semplice codice. Ad esempio, non abbiamo sviluppato il modulo, che consente di personalizzare il tipo di dati del report COT con le impostazioni del client terminal, fornite da un determinato broker. Questa funzionalità viene implementata all'interno della funzione DefineIdSymbol. Ecco le prime righe di:
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
Se è necessario assegnare un simbolo dal report a un simbolo del client terminal, è necessario farlo manualmente modificando questo codice. Ho usato le impostazioni dal terminale BrocoTrader4. Ad esempio in questo articolo, ho usato account demo, aperti sui server Metaquotes-Demo e Alpari-Demo. Ci sono solo 2 strumenti disponibili per i report DCOT: XAUUSD (oro), XAGUSD (argento).
Attualmente i report CIT non sono supportati, poiché non ci sono strumenti finanziari su questi server. Quando appariranno, è facile includere il loro report semplicemente rimuovendo i commenti e modificando alcune righe nel codice.
6. Come Utilizzare l'Indicatore COT tramite iCustom
Non uso l'indicatore in un modulo, presentato in Fig.3. Il linguaggio MQL5 ha la possibilità di riutilizzare gli indicatori personalizzati utilizzando la funzione iCustom.
6.1. Creazione di un nuovo indicatore
Esistono molti modi in cuiCOT riporta analisi visive. Uno di questi è un istogramma che mostra le posizioni di diversi gruppi di trader con colori diversi.
Consideriamo il seguente compito: creare un indicatoreCOTnet che traccia le posizioni di diversi gruppi ditrader (commerciali e non commerciali dai report COT), come un istogramma. L'utente deve avere la possibilità di scegliere il tipo di dati:net longs, net longs rate, Williams Index.
Il processo può essere semplificato da MQL5 Wizard, considerato nell’articolo MQL5: Crea il Tuo Indicatore. Di conseguenza, il codice dell'indicatore (gli stili di disegno sono stati creati dalla MQL5 Wizard) ha il seguente aspetto:
#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 buffersLe variabili di input, le variabili globali e la direttiva del preprocessore per includere la libreria con le classi sono le seguenti:
#include <cot.mqh> input cot_type_data type_data = netlongs; // Indicator's type double NoncommercialBuffer[]; double CommercialBuffer[]; //+------------------------------------------------------------------+ //| Custom indicator initialization function | //+------------------------------------------------------------------+ int handlecomm, handlenoncomm;
Il codice della funzione OnInit è il seguente:
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); }Consideriamo come utilizzare gli indicatori personalizzati (ad esempio di trader non commerciali). Dopo la prima chiamata della funzione iCustom, i seguenti parametri (necessari per il nostro report) vengono passati alla funzione:
- NULL – simbolo corrente nel client terminal
- 0 – intervallo corrente
- "cot" – nome file (nota, che è specificato senza estensione) del nostro indicatore personalizzato
- td = commerciale (gruppo di trader di cui abbiamo bisogno)
- type_data = tipo di indicatore, specificato nei parametri di input
- tr = COT – tipo di report
Di conseguenza, abbiamo una handle che verrà utilizzato ulteriormente per ottenere i dati dell'indicatore.
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);
Abbiamo trascorso un po’ di tempo, scritto un breve codice e ottenuto il risultato:
Fig. 6 L'indicatore cotnet
6.2. iCustom può essere utilizzato anche negli script
Consideriamo il seguente compito: creare lo script cotsignals per calcolare stime statistiche.
- Il segno dei long netti dei trader non commerciali è lo stesso del colore della candela: se è positivo, il trend settimanale è rialzista, se è negativo, il trend è ribassista.
- Il colore della candela (bianco/nero) è direttamente associato all'aumento/diminuzione dei lunghi netti dei trader non commerciali.
- Il colore della candela è bianco o nero a seconda del valore dell'indice Williams, calcolato sui long netti dei trader non commerciali. Se è ipercomprato (più del 75%), allora il colore è nero, se è ipervenduto (meno del 25%) - il colore della candela è bianco.
Utilizzeremo i dati del report COT. Utilizzando questi esempi, è possibile sviluppare i propri metodi di interpretazione dei dati COT e trarne vantaggio. Nel tuo caso controlleremo 150 barre settimanali di cronologia che corrispondono a un periodo di 3 anni. Prima di scrivere uno script, dobbiamo definire i tipi di dati e le classi necessarie:
L'enumerazione per i possibili tipi di statistiche è:
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 };
Per ottenere le statistiche per il simbolo specificato, creiamo una classe speciale:
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 };
Le statistiche richieste vengono restituite dal metodo Get, descriviamo come funziona. Innanzitutto, gli array necessari vengono riempiti con dati utilizzando un indicatore personalizzato. Abbiamo bisogno dei valori lunghi netti dei trader non commerciali (speculatori) e dei valori dell'Indice Williams:
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
Il codice per il calcolo delle statistiche (abbiamo solo un parametro da calcolare - è una probabilità di previsione per il colore della candela settimanale) è il seguente:
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); }La funzione LoadDataFromCOTIndicator è complicata, perché è necessario eseguire numerosi controlli per ottenere dati dall'indicatore, quindi consideriamola nel dettaglio:
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 );
Nell'ultima riga, otteniamo l’handle dell'indicatore personalizzato che può essere utilizzato per ottenere dati dai buffer.
Dobbiamo verificare che l'indicatore sia stato creato con successo:
if( cothandle == INVALID_HANDLE ){ Print("Error in indicator creation for symbol ", symbol ); return(false); }
Controllo dei dati storici di cui abbiamo bisogno:
int n = BarsSinh( symbol, timeframe ); if( n < nbars ) {
Se non ci sono abbastanza dati storici, carichiamolo:
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); } }
Le funzioni BarsSinh (restituisce il numero di barre, disponibili sul simbolo e sull'intervallo di tempo specificati) e CheckLoadHistory (download della cronologia) si basano sul codice dello script del riferimentoMQL5.
Prima di utilizzare i dati dal buffer dell'indicatore, dobbiamo verificare che i dati siano stati preparati, perché solo la presenza di un handle non garantisce che il calcolo sia stato completato.
La chiamata successiva esegue questo controllo e attende il termine dei calcoli:
if( !WaitForCalculcateIndicator( cothandle ) ){ Print("Timeout for the COT indicator calculation"); return(false); }
I dati sono pronti, dobbiamo copiarli:
int res = CopyBuffer(cothandle, 0, 0, nbars, loadto );
Successivamente, stiamo verificando che i dati siano stati copiati correttamente:
if( res != nbars ){ Print("Error in obtaining the data, ", MyErrorDescription(_LastError) ); return(false); }
E infine:
return(true);
Abbiamo i dati e li restituiamo nell’array, passati dal parametro della funzione.
Le statistiche risultanti verranno stampate in file CSV, la classe CCOTOutFile viene sviluppata per questo scopo:
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); } };
Crea il file con i dati di output, scrive stringhe in formato .csv, forma l'intestazione e chiude il file durante la distruzione dell'istanza di classe.
Il codice dello script sarà breve, perché sono state scritte tutte le librerie necessarie.
I parametri di input e le librerie incluse:
input int NBars =150; //History depth W1 #include <common.mqh> #include <cot.mqh>
L'elenco dei simboli per l'analisi:
string listsymbols[] = {"EURUSD", "GBPUSD", "USDCHF", "USDCAD", "USDJPY", "AUDUSD", "XAUUSD"};
Inizializzazione dell'oggetto:
void OnStart() { CCOTOutFile outfile; //file with results if( !outfile.Init("cotw1signals.csv") )return;
L'elenco delle statistiche per il calcolo:
cot_type_statistics list_statistic[]= // statistic types list
{ speculantsign, speculantchange, willamszones };
Scrittura dell'intestazione del file CSV:
outfile.PutHeader( list_statistic ); //writing CSV file header
Nel ciclo principale, otteniamo statistiche per ogni simbolo e segnale e scriviamo i risultati su file:
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."); }
Lo script è stato testato sul server Alpari-Demo. Se lo eseguirai sul server MetaQuotes-Demo, stamperà il messaggio "Errore nel calcolo delle statistiche per il simbolo XAUUSD", perché questo simbolo non è disponibile ora.
Come risultato dell'esecuzione dello script, otterremo il file che appare come segue:
Per renderlo più chiaro, apriamolo in Excel, calcoliamo i valori medi e creiamo un istogramma di probabilità:
Fig. 8 Probabilità di previsione
- 0.54 – segno dei commercianti non commerciali;
- 0,50 – variazioni di volume dei long netti degli operatori non commerciali;
- 0,48 – zone di ipercomprato/ipervenduto dell'indice Williams.
Come vediamo, abbiamo ottenuto i migliori risultati di previsione per i long netti dei trader non commerciali. Il risultato peggiore è per le zone dell’indice Williams. Il valore 0,48 significa che la probabilità per la candela bianca è pari a 0,52, anche se l'indice Williams è ipercomprato, e il colore nero per il caso in cui sia ipervenduto. Quindi, il suo uso nella forma, presentata da Williams, non è razionale. Forse, i risultati possono essere migliorati utilizzando intervalli di tempo più ampi: mese o addirittura più grandi. Abbiamo utilizzato tutti i simboli disponibili sui server demo e nei report COT.
Conclusione
MQL5 è uno strumento che consente di programmare l'intero ciclo di attività necessarie per sviluppare un sistema di trading:- Gli indicatori con algoritmi che vengono utilizzati per accedere a fonti di dati esterne;
- Il suo riutilizzo in altri indicatori, script ed Expert Advisor;
- L'implementazione di propri algoritmi di analisi statistica e quantitativa.
- La programmazione orientata agli oggetti riduce notevolmente il tempo impiegato per il debug.
- Debugger.
- È facile migrare da MQL4 a MQL5.
- L'implementazione del modello orientato agli oggetti ha successo, è facile da usare.
- La documentazione è ben organizzata.
- L'integrazione conWindows API estende la piattaforma, ad esempio permette di lavorare con le pagine Internet.
Contro:
Il problema principale per me è stato l'accesso ai dati storici:- Mancanza di funzioni primitive necessarie per accedere alle timeseries (come Time[], Open[], Close[] e altre in MQL4)
- Quando si accede ai dati, è necessario eseguire numerosi controlli della loro accessibilità, è necessario comprenderne i dettagli.
C'è un debugger, ma non ha molte funzionalità utili: non ci sono indicatori di debug, inoltre è impossibile eseguire controlli di oggetti complicati, come array e classi. L'elenco dei pro e dei contro non è completo, ho elencato solo ciò che ho incontrato durante la preparazione di questo articolo.
Appendice 1. Elenco dei file
Tutti i file si trovano nella cartella Client Terminal. Decomprimere i file da sources.zip nella cartella Client Terminal.
| № | Nome del File | Descrizione |
|---|---|---|
| 1 | MQL5\Files\unzip.exe | Applicazione Windows per la decompressione di archivi .zip |
| 2 | MQL5\Include\Cdownloader.mqh | Classe che scarica gli archivi CFTC da Internet |
| 3 | MQL5\Include\ClassProgressBar.mqh | Classe CProgressBar utilizzato per visualizzare il processo di download nella finestra del grafico |
| 4 | MQL5\Include\common.mqh | Funzioni e costanti comuni, utilizzate in tutti gli indicatori e gli script |
| 5 | MQL5\Include\cot.mqh | Classe CCFTCReport che seleziona i dati dai report cot |
| 6 | MQL5\Include\ErrorDescription.mqh | Libreria Descrizione Errore |
| 7 | MQL5\Indicators\cot.mq5 | Indicatore cot di base |
| 8 | MQL5\Indicators\cotnet.mq5 | L'indicatore cotnet, un semplice esempio di utilizzo di cot.mq5 come indicatore utente personalizzato |
| 9 | MQL5\Scripts\cotdownloader.mq5 | Script cotdownloader, scarica i file di archivio da Internet |
| 10 | MQL5\Scripts\cotsignals.mq5 | Script cotsignals, esempio di analisi statistica dei report COT |
Tabella 2. Elenco dei file
Appendice 2. Elenco dei simboli, disponibile nei report COT
| № | Nome del simbolo; | ID in borsa | ID nel Client Terminal | Presente in CIT | Presente in DCOT |
|---|---|---|---|---|---|
| 1 | GRANO - CHICAGO BOARD OF TRADE | 001602 | ZW | x | x |
| 2 | GRANO - KANSAS CITY BOARD OF TRADE | 001612 | x | x | |
| 3 | GRANO - MINNEAPOLIS GRAIN EXCHANGE | 001626 | x | ||
| 4 | MAIS - CHICAGO BOARD OF TRADE | 002602 | ZC | x | x |
| 5 | AVENA - CHICAGO BOARD OF TRADE | 004603 | ZO | x | |
| 6 | SOIA - CHICAGO BOARD OF TRADE | 005602 | ZS | x | x |
| 7 | MINI SEMI DI SOIA - CHICAGO BOARD OF TRADE | 005603 | x | ||
| 8 | STRUMENTO FINANZIARIO DI ZOLFO - CHICAGO CLIMATE FUTURES EXCHANGE | 006261 | x | ||
| 9 | STRUMENTO FINANZIARIO DEL CARBONIO - CHICAGO CLIMATE FUTURES EXCHANGE | 006268 | x | ||
| 10 | RGGI CO2 ALLOWANCE 2009 - CHICAGO CLIMATE FUTURES EXCHANGE | 00626U | x | ||
| 11 | OLIO DI SOIA - CHICAGO BOARD OF TRADE | 007601 | ZL | x | x |
| 12 | STATI UNITI BUONI DEL TESORO - CHICAGO BOARD OF TRADE | 020601 | ZB | ||
| 13 | BUONI DEL TESORO A LUNGO TERMINE USA - 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% OLIO COMBUSTIBILE 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 | RISO GREZZO - CHICAGO BOARD OF TRADE | 039601 | ZR | x | |
| 49 | FRZN CONCENTRATED ORANGE JUICE - ICE FUTURES U.S. | 040701 | JO | x | |
| 50 | BUONI DEL TESORO USA 2 ANNI- CHICAGO BOARD OF TRADE | 042601 | |||
| 51 | BUONI DEL TESORO- USA 10 ANNI- CHICAGO BOARD OF TRADE | 043602 | ZN | ||
| 52 | BUONI DEL TESORO USA 5 ANNI- CHICAGO BOARD OF TRADE | 044601 | |||
| 53 | FONDI FEDERALI 30 GIORNI - CHICAGO BOARD OF TRADE | 045601 | ZQ | ||
| 54 | LATTE Classe III - CHICAGO MERCANTILE EXCHANGE | 052641 | x | ||
| 55 | LEAN HOGS -CHICAGO MERCANTILE EXCHANGE | 054642 | HE | x | x |
| 56 | BESTIAME VIVO - CHICAGO MERCANTILE EXCHANGE | 057642 | LC | x | x |
| 57 | LEGNAME DI LUNGHEZZA CASUALE - CHICAGO MERCANTILE EXCHANGE | 058643 | LB | x | |
| 58 | BESTIAME DA ALIMENTAZIONE - 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 BUTANO 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 | CACAO - ICE FUTURES U.S. | 073732 | CC | x | x |
| 89 | PALLADIO - NEW YORK MERCANTILE EXCHANGE | 075651 | PA | x | |
| 90 | PLATINUM - NEW YORK MERCANTILE EXCHANGE | 076651 | PL | x | |
| 91 | ZUCCHERO N. 11 - ICE FUTURES U.S. | 080732 | SB | x | x |
| 92 | CAFFÈ C - ICE FUTURES U.S. | 083731 | KC | x | x |
| 93 | ARGENTO - COMMODITY EXCHANGE INC, | 084691 | SI,XAGUSD,ZI | x | |
| 94 | GRADO RAME #1 - COMMODITY EXCHANGE INC. | 085692 | HG | x | |
| 95 | ORO - COMMODITY EXCHANGE INC. | 088691 | GC,GOLD,XAUUSD | x | |
| 96 | RUBLO RUSSO - CHICAGO MERCANTILE EXCHANGE | 089741 | USDRUB,USDRUR | ||
| 97 | DOLLARO CANADESE - CHICAGO MERCANTILE EXCHANGE | 090741 | 6C, USDCAD | ||
| 98 | FRANCO SVIZZERO - CHICAGO MERCANTILE EXCHANGE | 092741 | 6S, USDCHF | ||
| 99 | PESO MESSICANO - CHICAGO MERCANTILE EXCHANGE | 095741 | |||
| 100 | STERLINA BRITANNICA - CHICAGO MERCANTILE EXCHANGE | 096742 | 6B,GBPUSD | ||
| 101 | YEN GIAPPONESE - CHICAGO MERCANTILE EXCHANGE | 097741 | 6J,USDJPY | ||
| 102 | STATI UNITI INDICE DEL DOLLARO - 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 | DOLLARO NEOZELANDESE - CHICAGO MERCANTILE EXCHANGE | 112741 | 6N,NZDUSD | ||
| 107 | VIX FUTURES - CBOE FUTURES EXCHANGE | 011700 | |||
| 108 | DOW JONES INDUSTRIAL AVERAGE - CHICAGO BOARD OF TRADE | 124601 | |||
| 109 | EURODOLLARI A 3 MESI - CHICAGO MERCANTILE EXCHANGE | 132741 | |||
| 110 | INDICE AZIONARIO S&P 500 - CHICAGO MERCANTILE EXCHANGE | 138741 | |||
| 111 | INDICE AZIONARIO E-MINI S&P 500 - CHICAGO MERCANTILE EXCHANGE | 13874A | ES,SPX | ||
| 112 | INDICE AZIONARIO NASDAQ-100 - 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 | DOLLARO AUSTRALIANO- CHICAGO MERCANTILE EXCHANGE | 232741 | 6A,AUDUSD | ||
| 116 | RUSSELL 2000 MINI INDEX FUTURE - ICE FUTURES USA | 23977A | |||
| 117 | NIKKEI STOCK AVERAGE - CHICAGO MERCANTILE EXCHANGE | 240741 | |||
| 118 | NIKKEI STOCK MEDIA YEN DENOM - CHICAGO MERCANTILE EXCHANGE | 240743 | |||
| 119 | E-MINI MSCI EAFE - CHICAGO MERCANTILE EXCHANGE | 244741 | |||
| 120 | E-MINI MSCI MERCATI EMERGENTI - CHICAGO MERCANTILE EXCHANGE | 244742 | |||
| 121 | SWAP SU TASSI DI INTERESSE 10 ANNI - CHICAGO BOARD OF TRADE | 246602 | |||
| 122 | SWAP SU TASSI DI INTERESSE 5 ANNI - 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% OLIO COMBUSTIBILE 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 |
Tabella 3. Elenco dei simboli, disponibile nei report COT
Tradotto dal russo da MetaQuotes Ltd.
Articolo originale: https://www.mql5.com/ru/articles/34
Gestione degli Eventi in MQL5: Modifica del periodo MA al volo
Implementazione Pratica di Filtri Digitali in MQL5 per Principianti
Creazione di un Indicatore con Opzioni di Controllo del Grafico
Come Esportare Quotazioni da МetaTrader 5 ad Applicazioni .NET Utilizzando i Servizi WCF
- App di trading gratuite
- Oltre 8.000 segnali per il copy trading
- Notizie economiche per esplorare i mercati finanziari
Accetti la politica del sito e le condizioni d’uso