![MQL5: análise e processamento dos relatórios Commodity Futures Trading Commission (CFTC) no MetaTrader 5](https://c.mql5.com/i/articles/overlay.png)
MQL5: análise e processamento dos relatórios Commodity Futures Trading Commission (CFTC) no MetaTrader 5
Introdução
O terminal de trading MetaTrader 5, desenvolvido pela MetaQuotes Software Corp., como uma das ferramentas de trader contém a linguagem de programação MQL5, que suporta programação orientada a objetos. Por um lado, o MQL5 não é compatível com sua versão anterior - MQL4, por outro - ele possui muitas novas possibilidades de linguagem orientada a objetos completa. Portanto, traders, que já possuem habilidades em MQL4, têm que compreender (de fato) esta nova linguagem e eu considero-os como o público alvo deste artigo.
Neste artigo, eu mostrarei uma solução para o seguinte problema: é necessário desenvolver a ferramenta trader, que permite obter e analisar diferentes dados de relatórios da Commodity Futures Trading Commission (CFTC). Este tópico já foi considerado no artigo Projeto Meta COT - Novos horizontes para análise de relatório CFTC no MetaTrader 4, então, vou presumir que o leitor seja familiar com os conceitos, e consideraremos os detalhes que não são descritos lá.
A ideia é a seguinte: desenvolver um indicador único, que permita obter dados de arquivos, fornecidos pela Comission, sem processamento e conversão intermediários. Além disso, ele pode ser utilizado para diferentes propósitos: organizar dados como um indicador, como fonte de dados em outros indicadores, em scripts para análise automatizada, no Expert Advisor ao desenvolver estratégias de trading.
1. Tipos de relatórios COT
Há três tipos de relatórios: Current Legacy Report (COT), Supplemental Commodity Index (CIT), Current Disaggregated Report (DCOT), a diferença entre eles é apresentada na Tabela 1.
Descrição | Current Legacy Reports | Supplemental Commodity Index | Current Disaggregated Reports |
---|---|---|---|
Sigla | COT | CIT | DCOT |
Título da referência | Current Legacy Reports | Supplemental Commodity Index | Current Disaggregated Reports |
Referência para o arquivo de dados recente | |||
Grupos de traders, apresentados no relatório | Não comerciais Comerciais Não relatáveis | Não comerciais Comerciais Não relatáveis Index Traders | Produtor/comerciante/processador/usuário Negociantes Swap Dinheiro gerenciado Outros relatáveis Não relatáveis |
Tabela 1. Tipos de relatórios de Commitments of Traders
Informações sobre os negociantes, que devem relatar suas posições nos mercados futuros, princípios da classificação e periodicidade dos relatórios podem ser encontradas em "Negociar ações e commodities com os internos: Secrets of the COT Report" e no artigo Projeto Meta COT - Novos horizontes para análise de relatório CFTC em MetaTrader 4 .
Eu vou considerar dois relatórios, que não estão descritos nestas fontes.
A sigla CIT significa Commitments of Index Traders. Este relatório está sendo publicado desde 2007. A página atual do relatório CIT está disponível em https://cftc.gov/dea/options/deaviewcit.htm. Os index traders estão em um grupo separado dos investidores e especuladores.
A descrição do Relatório suplementar pode ser encontrada em https://www.cftc.gov/MarketReports/CommitmentsofTraders/AbouttheCOTReports/index.htm. Todos estes index traders frequentemente abrem longas posições nos mercados e rolam elas de contrato em contrato.
Desde 2009, a Comission publica o relatório Disaggregated Commitments of Traders Report, sua descrição pode ser encontrada nas notas explanatórias.
O relatório COT desagregado aumenta a transparência dos relatórios COT de herança, separando traders nas seguintes quatro categorias de traders: Produtor/comerciante/processador/usuário; Negociantes Swap; Dinheiro gerenciado; Outros relatáveis.
- Produtor/comerciante/processador/usuário. Um “produtor/comerciante/processador/usuário” é uma entidade que predominantemente ocupa-se na produção, processamento, embalamento ou manuseio de um commodity físico e utiliza os mercados futuros para gerenciar ou investir riscos associados com tais atividades.
- Dealer de troca. Um “dealer de troca” é uma entidade que lida primeiramente em trocas por um commodity e utiliza os mercados futuros para gerenciar ou investir o risco associado com tais transações de troca. As contrapartes do dealer de troca podem ser traders especulativos, como fundos de investimento, ou clientes comerciais tradicionais que estão gerenciando o risco originando de suas interações no commodity físico.
- Money Manager. Um “money manager”, para o propósito deste relatório, é um conselheiro de transação de commodity (CTA); um operador de consórcio de commodity (CPO)ou um fundo não-registrado identificado pelo CFTC. Estes traders são encarregados de gerenciar e conduzir negociações futuras organizadas em nome de clientes.
- Outros relatáveis. Todo outro trader relatável que não está em uma das outras três categorias, é colocado na categoria “outros relatáveis”.
A lista completa dos instrumentos relatados está presente no Apêndice 2. Há também colunas que refletem a presença de instrumento em particular nos relatórios CIT e DCOT.
2. Escrever um indicador COT que utiliza dados externos dos arquivos CSV
O indicador funcionará como segue. O tipo de relatório (um dos listados na Tabela 1), os tipos de dados e o grupo de traders são definidos nos parâmetros de entrada do indicador.
Os tipos de dados podem ser os seguintes:
- Longos líquidos;
- Taxa de longos líquidos em posição aberta;
- Williams Index, calculado para longos líquidos;
- Posição aberta.
A lista de possíveis tipos de dados não está completa, ela pode ser facilmente estendida para incluir dados mais essenciais, que eu uso. Para o símbolo atual, os dados especificados são requisitados dos arquivos de dados (como baixá-los e descompactá-los está descrito abaixo). Nós usaremos a classe CCFTCReport para acessar os dados e baixá-los destes arquivos.
O indicador possui a seguinte estrutura:
2.1. Constantes
Para definir constantes, o tipo de dados enum é utilizado. Os tipos de relatório, suportados pelo indicador, são os seguintes:enum cot_type_report // type of report { COT, DCOT, CIT };
Grupos de traders:
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 };
Tipos de dados, que podem ser utilizados em indicador:
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. Classes
Para armazenar objetos diferentes dentro de uma única variável, é possível utilizar estruturas e classes. Entretanto, não é possível designar duas variáveis de tipo de estrutura, se elas contiverem ordens dinâmicas ou valores de um tipo de string. Este é o motivo pelo qual usei a classe em vez da estrutura para armazenar o registro COT e método para atribuição de dados.
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; }; };
A partir de agora, vou supor que o leitor está familiarizado com o formato CSV dos relatórios COT, que é considerado no artigo Projeto Meta COT - Novos horizontes para análise de relatório CFTC no MetaTrader 4. A instância de classe deste tipo será utilizada para armazenar uma única linha do relatório COT. Uma ordem destas instâncias de classe permitirá utilizá-las para armazenagem e acesso conveniente aos campos dos relatórios COT. A classe CCFTCReport foi desenvolvida para armazenagem de dados e acesso:
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 };
A instância da classe CCFTCReport contém o relatório inteiro para um único símbolo, o tipo de relatório pode ser COT, CIT ou DCOT. As enumerações e classes são listadas no arquivo "cot.mqh" incluso.
2.3. Parâmetros de entrada
Os parâmetros de entrada são definidos pelas variáveis input. Estes parâmetros permitem especificar grupo de traders, tipo de dados e tipo de relatório COT necessário:
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. Função OnInit
Um indicador possui a função OnInit, que é usada para os seguintes propósitos: fazer o download de dados do arquivo do relatório, verificar os parâmetros de entrada, atribuir os buffers do indicador.
O buffer, inicializado com a propriedade INDICATOR_DATA contém dados que estão plotados na tabela. O buffer, inicializado com a propriedade INDICATOR_CALCULATIONS contém cálculos intermediários.
SetIndexBuffer( 0, BufferData, INDICATOR_DATA ); IndicatorSetString(INDICATOR_SHORTNAME,indname); SetIndexBuffer( 1, BufferCalculations, INDICATOR_CALCULATIONS );
2.5. Função OnCalculate
Esta função é usada para seleção dos dados necessários, cálculo dos dados solicitados e sua diagramação.
Vamos considerar seu trabalho em detalhes. A segunda forma de solicitação é utilizada:
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[]){
Vamos determinar barras para cálculo e plotagem.
int pos=rates_total-prev_calculated-1; if( pos >= rates_total-1 )pos--;
Vamos especificar que elementos devem ser indexados como timeseries.
ArraySetAsSeries(Time, true); ArraySetAsSeries(BufferData, true); ArraySetAsSeries(BufferCalculations, true);
Após alguns experimentos, eu descobri que é melhor utilizar a indexação timeseries para todas as ordens, que estão relacionadas aos buffers do indicador. O mesmo é conveniente para ordens, que são passadas à função OnCalculate como parâmetros, o último elemento (recente) possui um índice, igual a 0.
O loop de cálculo parece o seguinte:
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 ); }
A ordem BufferCalculations é utilizada para armazenar dados primários, selecionados do relatório COT.
A ordem BufferData contém dados prontos para plotagem na tabela. Podem ser os valores do relatório (líquido longos, posição aberta) também como valores calculados (taxa de longos, Williams Index). Eu gostaria de destacar o seguinte ponto, para o qual eu não encontrei uma solução elegante. Arrays, passados para função OnCalculate podem ser necessários nos níveis subsequentes, e podemos acessá-los apenas se forem passados nestas chamadas, então, eu acho que isso confunde o código.
A solicitação de função CalcData:
BufferData[i] = CalcData( type_data, i, Time );
A função CalcData solicita a função 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]); }
Preciso acessar o array de tempo dentro da função CalcIndex, então fui forçado a passar de acordo com a hierarquia de chamada. Imagine como o código se parecerá, se precisarmos utilizar todas as 8 ordens.
3. Fazendo o download dos arquivos de dados
Todos os links dos arquivos são apresentados na Tabela 1. Há um arquivo separado para cada ano, o número do ano está presente no nome do arquivo. Por exemplo, o arquivo https://www.cftc.gov/sites/default/files/files/dea/history/deacot2010.zip contém relatório para o ano de 2010, o arquivo https://www.cftc.gov/sites/default/files/files/dea/history/deacot2009.zip - para 2009, etc.
É necessário fazer download de todos estes arquivos e descompactá-los na pasta \MQL5\files do diretório de instalação do Client Terminal. Para cada ano, é necessário criar sua própria pasta separada com um nome deacotXXXX, onde XXXX corresponde a um ano. Como resultado, nós obteremos a seguinte estrutura de pasta.
Figura 1. Estrutura de pastas para os relatórios
O processo de preparação dos dados pode ser simplificado. Todas as seguintes operações (verificando pelas atualizações no site CFTC, fazendo o download e extraindo para as pastas apropriadas) são realizadas pelo script "Cotdownloader". O script kernel (download de dados) é baseado no script WININET_TEST. Usei a classe CProgressBar, publiquei no artigo O histograma de preço (perfil de mercado) e sua implementação no MQL5 . Aplicações externas são executadas usando o Windows API, que é descrito no artigo Otimização automatizada de um robô de negócio em negociação real.
Usar um script é simples: basta anexá-lo a qualquer gráfico. Quando está funcionando, ele relata informações sobre download de dados como uma barra de progresso na tabela, e como mensagens de texto na aba Experts.
Figura 2. Processo de download de dados
4. Exemplo de uso
Para executar um indicador é necessário anexá-lo à tabela de símbolo escolhido e especificar os parâmetros de entrada.
Fig.3 Parâmetros de entrada do indicador COT
Note que agora você pode especificar uma representação de fácil utilização ao invés de nomes variáveis e valores de tipos de dados enumerados. Isso é feito da seguinte forma: para substituir o nome variável, você deve especificar um comentário quando você declara uma variável de entrada:
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
O mesmo é para valores - é necessário especificar a descrição nos comentários ao declarar os valores enumerados:
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 os parâmetros de entrada foram especificados corretamente, e os arquivos foram baixados e descompactados, então o indicador aparecerá em uma janela separada:
Fig. 4 Indicador COT
No caso de erros, eles serão impressos na aba "Experts" da janela "Toolbox".
Fig. 5 Mensagem de erro
5. Notas de lançamento
O indicador não é posicionado como um produto finalizado completo. É um exemplo que mostra como nós podemos obter resultados, que podem ser utilizados mais tarde, escrevendo um código simples. Por exemplo, nós não desenvolvemos o módulo, permitindo a personalização do tipo dos dados do relatório COT com configurações do Client Terminal, fornecido por um certo broker. Este recurso é implementado dentro da função DefineIdSymbol. Aqui estão as primeiras linhas de:
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 você precisa designar um símbolo de um relatório a um símbolo do terminal do cliente, você deve fazê-lo manualmente modificando este código. Eu utilizei configurações do terminal BrocoTrader4. Para exemplos neste artigo, eu utilizei demo-accounts, abertos nos servidores Metaquotes-Demo e AlpariDemo. Há apenas 2 instrumentos disponíveis para relatórios DCOT: XAUUSD (ouro), XAGUSD (prata).
Atualmente, relatórios CIT não são suportados, pois não há instrumentos financeiros nestes servidores. Quando eles aparecerem, é fácil de incluir seus suportes, apenas removendo os comentários e modificando algumas linhas no código.
6. Como usar o indicador COT através do iCustom
Eu não utilizo indicador em um formulário, apresentado na Fig. 3. A linguagem MQL5 possui a possibilidade de reutilizar os indicadores personalizados usando a função iCustom.
6.1. Criar um novo indicador
Há muitas formas de análises virtuais de relatórios COT. Uma delas é um histograma que mostra posições de diferentes grupos de traders em diferentes cores.
Vamos considerar a seguinte tarefa: criar um indicador COTnet, que plota posições de diferentes grupos de traders (comerciais e não-comerciais, a partir de relatórios COT), como um histograma. O usuário deve ter uma possibilidade de escolher os tipos de dados: líquidos longos, taxa de líquidos longos, Williams Index.
O processo pode ser simplificado pelo MQL5 Wizard, considerado no artigo MQL5: artigo Crie seu próprio indicador. Como resultado, o código do indicador (estilos de desenho foram criados pelo MQL5 Wizard) parece o seguinte:
#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 buffersVariáveis de entrada, variáveis globais e diretiva do pré-processador para incluir a biblioteca com classes, parecem o seguinte:
#include input cot_type_data type_data = netlongs; // Indicator's type double NoncommercialBuffer[]; double CommercialBuffer[]; //+------------------------------------------------------------------+ //| Custom indicator initialization function | //+------------------------------------------------------------------+ int handlecomm, handlenoncomm;
O código da função OnInit é o seguinte:
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); }Vamos considerar como utilizar indicadores personalizados (no exemplo de traders não-comerciais). Após a primeira solicitação da função iCustom, os seguintes parâmetros (necessários para nosso relatório) são transmitidos à função:
- NULL – símbolo atual no terminal do cliente;
- 0 – período de tempo atual;
- "cot" – nome do arquivo (note que ele é especificado sem extensão) de nosso indicador personalizado;
- td = commercial (grupo de traders que precisamos);
- type_data = tipo do indicador, especificado nos parâmetros de entrada;
- tr = COT – tipo de relatório.
Como resultado, nós temos um identificador que será utilizado mais adiante, para obter os dados do indicador.
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);
Nós gastamos pouco tempo, escrevemos um código curto e obtivemos o resultado:
Fig. 6 O indicador COTnet
6.2. iCustom também pode ser utilizado em scripts
Vamos considerar a seguinte tarefa: criar o script cotsignals para calcular estimativas estatísticas.
- O sinal dos líquidos longos de traders não comerciais são os mesmos da cor da vela: se for positivo, a tendência semanal é de alta, se for negativo, a tendência é de baixa.
- A cor da vela (preto/branco) está relacionada diretamente com o aumento/diminuição dos líquidos longos dos traders não comerciais.
- A cor da vela está preta ou branca dependendo do valor do Williams Index, calculado sobre os líquidos longos dos traders não-comerciais. Se houver sobrecompra (mais de 75%), então a cor é preta, se houver sobrevenda (menos de 25%) - a cor da vela é branca.
Nós utilizaremos dados do relatório COT. Utilizando estes exemplos você pode desenvolver seus próprios métodos de interpretação de dados COT e tirar vantagem disso. Em seu caso, nós verificaremos por 150 barras semanais de histórico, o que corresponde a um período de 3 anos. Antes de escrever um script, nós temos que definir os tipos de dados e classes necessárias:
A enumeração para possíveis tipos de estatísticas é:
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 };
Para obter as estatísticas para o símbolo especificado, vamos criar uma classe especial:
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 };
As estatísticas requisitadas são retornadas pelo método Get, vamos descrever como ele funciona. Primeiro, as ordens necessárias são preenchidas com dados utilizando o indicador personalizado. Nós precisamos de valores de líquidos longos de traders (especuladores) não-comerciais e valores Williams Index:
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
O código para cálculo de estatísticas (nós temos somente um parâmetro a ser calculado - é uma previsão para a cor da vela semanal) parece o seguinte:
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); }A função LoadDataFromCOTIndicator é complicada, pois é necessário realizar numerosas verificações para obter dados do indicador, portanto, vamos considerá-la em detalhes:
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 );
Na última linha nós obtemos o identificador do indicador personalizado, que pode ser utilizado para obter dados dos buffers.
Nós temos que verificar se o indicador foi criado de forma bem sucedida:
if( cothandle == INVALID_HANDLE ){ Print("Error in indicator creation for symbol ", symbol ); return(false); }
Verificando os dados do histórico que precisamos:
int n = BarsSinh( symbol, timeframe ); if( n < nbars ) {
Se não há dados de históricos suficientes, vamos carregá-los:
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); } }
A função BarsSinh (retorna o número de barras, disponíveis no símbolo e período de tempo especificados) e CheckLoadHistory (download do histórico) são baseadas no código de script do MQL5 Reference.
Antes de utilizar os dados do buffer do indicador, nós precisamos verificar se os dados foram preparados, pois apenas a presença de um identificador não garante que o cálculo foi finalizado.
A próxima solicitação realiza esta verificação e aguarda quando os cálculos são finalizados:
if( !WaitForCalculcateIndicator( cothandle ) ){ Print("Timeout for the COT indicator calculation"); return(false); }
Os dados estão prontos, nós temos que copiá-los:
int res = CopyBuffer(cothandle, 0, 0, nbars, loadto );
Depois nós verificamos se os dados foram copiados de forma bem sucedida:
if( res != nbars ){ Print("Error in obtaining the data, ", MyErrorDescription(_LastError) ); return(false); }
E finalmente:
return(true);
Nós obtemos os dados e os retornamos à ordem, transferidos pelo parâmetro da função.
As estatísticas resultantes serão impressas no arquivo CSV, a classe CCOTOutFile é desenvolvida para este propósito:
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); } };
Ela cria o arquivo sem dados de saída, escreve strings no formato .csv, forma o cabeçalho e fecha o arquivo durante a destruição da instância da classe.
O código do script será curto, pois todas as bibliotecas necessárias foram escritas.
Os parâmetros de entrada e bibliotecas inclusas:
input int NBars =150; //History depth W1 #include #include
A lista de símbolos para análise:
string listsymbols[] = {"EURUSD", "GBPUSD", "USDCHF", "USDCAD", "USDJPY", "AUDUSD", "XAUUSD"};
A inicialização do objeto:
void OnStart() { CCOTOutFile outfile; //file with results if( !outfile.Init("cotw1signals.csv") )return;
A lista de estatísticas para cálculo:
cot_type_statistics list_statistic[]= // statistic types list
{ speculantsign, speculantchange, willamszones };
Escrever o cabeçalho do arquivo CSV:
outfile.PutHeader( list_statistic ); //writing CSV file header
No loop principal nós obtemos estatísticas para cada símbolo e sinal, e escrevemos resultados para o arquivo:
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."); }
O script foi testado no servidor Alpari-Demo. Se você irá executá-lo no servidor MetaQuotes-Demo, ele imprimirá a mensagem "Erro no cálculo de estatísticas para o símbolo XAUUSD", pois este símbolo não está disponível agora.
Como resultado da execução do script, nós obteremos o arquivo, que parece o seguinte:
Para deixá-lo mais claro, vamos abrí-lo no Excel, calcular os valores médios e criar um histograma de probabilidades:
Fig. 8 Probabilidade de previsão
- 0.54 – sinal de traders não-comerciais;
- 0.50 – mudanças de volume em líquidos longos de traders não-comerciais;
- 0.48 – zonas de sobrecompra/sobrevenda de Williams Index.
Como vemos, nós obtivemos os melhores resultados de previsão para líquidos longos de traders não-comerciais. O pior resultado é para as zonas de Williams Index. O valor 0.48 significa que a probabilidade para vela branca é igual a 0.52, mesmo se houver sobrecompra do Williams Index, e cor preta para o caso, se houver sobrevenda. Portanto, sua utilização no formulário, apresentado por Williams, não é racional. Talvez, os resultados possam ser melhorados utilizando maiores períodos de tempo: mês, ou talvez maiores. Nós utilizamos todos os símbolos que estão disponíveis nos servidores de demonstração e nos relatórios COT.
Conclusão
MQL5 é uma ferramenta que permite a você programar o inteiro ciclo de tarefas, necessárias para desenvolver um sistema de trading:- Os indicadores com algoritmos complicados, que são utilizados para acessar as fontes de dados externas;
- Sua reutilização em outros indicadores, scripts e Expert Advisors;
- A implementação de algoritmos próprios de análise estatística e quantitativa.
- Programação com orientação a objetos reduz fortemente o tempo gasto para depuração.
- Depurador.
- É fácil migrar do MQL4 para MQL5.
- A implementação do modelo com orientação a objetos é bem sucedida, é fácil de utilizá-la.
- A documentação é bem organizada.
- Integração com Windows API estende a plataforma. Por exemplo, ela permite trabalhar com páginas da internet.
Contras:
O principal problema para mim foi o acesso aos dados do histórico:- A falta de funções primitivas necessárias para acessar timeseries (como Time[], Open[], Close[] e outros em MQL4).
- Ao acessar os dados, é necessário realizar numerosas verificações de suas acessibilidades, é necessário entender seus detalhes.
Há um depurador, mas ele não possui muitos recursos úteis: não há depuração de indicadores e também é impossível realizar verificações de objetos complicados, como ordens e classes. A lista de prós e contras não é abrangente, eu listei apenas o que encontrei ao preparar este artigo.
Apêndice 1. Lista de arquivos
Todos os arquivos estão localizados na pasta do Client Terminal. Descompacte os arquivos de sources.zip para a pasta do Client Terminal.
№ | Nome do arquivo | Descrição |
---|---|---|
1 | MQL5\Files\unzip.exe | Aplicação do Windows para descompactar arquivos .zip |
2 | MQL5\Include\Cdownloader.mqh | Classe, que faz download de arquivos CFTC da internet |
3 | MQL5\Include\ClassProgressBar.mqh | Classe CProgressBar, que é utilizada para mostrar o processo de download na janela da tabela |
4 | MQL5\Include\common.mqh | Funções comuns e constantes, que são usadas em todos os indicadores e scripts |
5 | MQL5\Include\cot.mqh | Classe CCFTCReport, que seleciona os dados dos relatórios COT |
6 | MQL5\Include\ErrorDescription.mqh | Biblioteca de descrição de erro |
7 | MQL5\Indicators\cot.mq5 | O indicador COT base |
8 | MQL5\Indicators\cotnet.mq5 | O indicador COTnet, um exemplo simples de uso de cot.mq5 como indicador de usuário personalizado |
9 | MQL5\Scripts\cotdownloader.mq5 | Cotdownloader de script, ele faz download dos arquivos de registro da internet |
10 | MQL5\Scripts\cotsignals.mq5 | Cotsignals de script, exemplo de análise estatística de relatórios COT |
Tabela 2. Lista de arquivos
Apêndice 2. Lista de símbolos disponíveis em relatórios COT
№ | Nome do símbolo | ID na troca | ID no Client Terminal | Presente em CIT | Presente em DCOT |
---|---|---|---|---|---|
1 | TRIGO - CHICAGO BOARD OF TRADE | 001602 | ZW | x | x |
2 | TRIGO - KANSAS CITY BOARD OF TRADE | 001612 | x | x | |
3 | TRIGO - MINNEAPOLIS GRAIN EXCHANGE | 001626 | x | ||
4 | MILHO - CHICAGO BOARD OF TRADE | 002602 | ZC | x | x |
5 | AVEIA - CHICAGO BOARD OF TRADE | 004603 | ZO | x | |
6 | SOJA - CHICAGO BOARD OF TRADE | 005602 | ZS | x | x |
7 | MINI SOJA - CHICAGO BOARD OF TRADE | 005603 | x | ||
8 | INSTRUMENTO FINANCEIRO DE ENXOFRE - CHICAGO CLIMATE FUTURES EXCHANGE | 006261 | x | ||
9 | INSTRUMENTO FINANCEIRO DE CARBONO - CHICAGO CLIMATE FUTURES EXCHANGE | 006268 | x | ||
10 | RGGI CONCESSÃO DE CO2 2009 - CHICAGO CLIMATE FUTURES EXCHANGE | 00626U | x | ||
11 | ÓLEO DE SOJA - CHICAGO BOARD OF TRADE | 007601 | ZL | x | x |
12 | TÍTULOS DO TESOURO DOS EUA - CHICAGO BOARD OF TRADE | 020601 | ZB | ||
13 | TÍTULOS DO TESOURO DOS EUA A LONGO PRAZO - CHICAGO BOARD OF TRADE | 020604 | |||
14 | TROCA DE ENXOFRE 3,0% DE COMBUSTÍVEL N° 6 DO GOLFO - NEW YORK MERCANTILE EXCHANGE | 02165A | x | ||
15 | TROCA DE ENXOFRE 1,0% DE COMBUSTÍVEL RESIDUAL DE NOVA YORK - NEW YORK MERCANTILE EXCHANGE | 02165B | x | ||
16 | TROCA NWE CAL DE ÓLEO COMBUSTÍVEL 1% DA EUROPA - NEW YORK MERCANTILE EXCHANGE | 02165C | x | ||
17 | TROCA RTD CAL DE óLEO COMBUSTíVEL 3,5% DA EUROPA - NEW YORK MERCANTILE EXCHANGE | 02165E | x | ||
18 | TROCA 180 CAL DE ÓLEO COMBUSTÍVEL DE CINGAPURA - NEW YORK MERCANTILE EXCHANGE | 02165G | x | ||
19 | TROCA SPR DE ÓLEO LESTE OESTE - NEW YORK MERCANTILE EXCHANGE | 02165I | x | ||
20 | SPR ÓLEO COMBUSTÍVEL 3% DO GOLFO 1% V DE NOVA YORK - NEW YORK MERCANTILE EXCHANGE | 02165T | x | ||
21 | NO. 2 GASÓLEO | 022651 | x | ||
22 | TROCA DE GASÓLEO DE CINGAPURA - NEW YORK MERCANTILE EXCHANGE | 02265J | x | ||
23 | TROCA DE GASÓLEO/RDAM GASÓLEO DE CINGAPURA - NEW YORK MERCANTILE EXCHANGE | 02265T | x | ||
24 | GASÓLEO RDAM/GASÓLEO DA NYMEX - NEW YORK MERCANTILE EXCHANGE | 02265U | x | ||
25 | TROCA (ICE) DE GASÓLEO - NEW YORK MERCANTILE EXCHANGE | 02265V | x | ||
26 | TROCA UP DOWN GC ULSD VS HO SPR - NEW YORK MERCANTILE EXCHANGE | 022A13 | x | ||
27 | TROCA BALMO DE GASÓLEO DE CINGAPURA - NEW YORK MERCANTILE EXCHANGE | 022A22 | x | ||
28 | DISTRIBUIDOR HENRY ICE DE GÁS NATURAL - ICE OTC | 023391 | x | ||
29 | GÁS NATURAL - NEW YORK MERCANTILE EXCHANGE | 023651 | QG | x | |
30 | TROCA DE BASE MICHCON - NEW YORK MERCANTILE EXCHANGE | 02365A | x | ||
31 | TROCA DE BASE M-3 - NEW YORK MERCANTILE EXCHANGE | 02365C | x | ||
32 | TROCA DE BASE TCO - NEW YORK MERCANTILE EXCHANGE | 02365D | |||
33 | TROCA DE BASE NGPL TEXOK - NEW YORK MERCANTILE EXCHANGE | 02365G | x | ||
34 | TROCA DE BASE NGPL MIDCON - NEW YORK MERCANTILE EXCHANGE | 02365K | x | ||
35 | TROCA DE BASE WAHA - NEW YORK MERCANTILE EXCHANGE | 02365O | x | ||
36 | TROCA DE ÍNDICE SHIP CH DE HOUSTON - NEW YORK MERCANTILE EXCHANGE | 023A10 | x | ||
37 | CBT ETANOL - CHICAGO BOARD OF TRADE | 025601 | x | ||
38 | TROCA DE ETANOL DE CHICAGO - NEW YORK MERCANTILE EXCHANGE | 025651 | x | ||
39 | FARINHA DE SOJA - CHICAGO BOARD OF TRADE | 026603 | ZM | x | |
40 | TROCA C&F NAPTHA DO JAPÃO - NEW YORK MERCANTILE EXCHANGE | 03265C | x | ||
41 | ALGODÃO NO. 2 - FUTUROS ICE EUA. | 033661 | CT | x | x |
42 | TROCA DE BASE DISTRIBUIDOR HENRY - NEW YORK MERCANTILE EXCHANGE | 035652 | x | ||
43 | TROCA DE BASE NAVIO CH DE HOUSTON - NEW YORK MERCANTILE EXCHANGE | 035653 | x | ||
44 | TROCA DE BASE NW PIPE ROCKIES - NEW YORK MERCANTILE EXCHANGE | 035654 | x | ||
45 | TROCA DE BASE PANHANDLE - NEW YORK MERCANTILE EXCHANGE | 035655 | x | ||
46 | TROCA DE DISTRIBUIDOR HENRY - NEW YORK MERCANTILE EXCHANGE | 03565B | |||
47 | PENÚLTIMA TROCA DE GASOLINA DE DISTRIBUIDOR HENRY - NEW YORK MERCANTILE EXCHANGE | 03565C | x | ||
48 | ARROZ COM CASCA - CHICAGO BOARD OF TRADE | 039601 | ZR | x | |
49 | SUCO DE LARANJA CONCENTRADO CONGELADO - ICE FUTURES U.S. | 040701 | JO | x | |
50 | NOTAS DO TESOURO DOS EUA DE 2 ANOS - CHICAGO BOARD OF TRADE | 042601 | |||
51 | NOTAS DO TESOURO DOS EUA DE 10 ANOS - CHICAGO BOARD OF TRADE | 043602 | ZN | ||
52 | NOTAS DO TESOURO DOS EUA DE 5 ANOS - CHICAGO BOARD OF TRADE | 044601 | |||
53 | FUNDOS FEDERAIS DE 30 DIAS - CHICAGO BOARD OF TRADE | 045601 | ZQ | ||
54 | LEITE Classe III - CHICAGO MERCANTILE EXCHANGE | 052641 | x | ||
55 | CARNE DE PORCO - CHICAGO MERCANTILE EXCHANGE | 054642 | HE | x | x |
56 | GADO VIVO - CHICAGO MERCANTILE EXCHANGE | 057642 | LC | x | x |
57 | MADEIRA DE TAMANHO ALEATÓRIO - CHICAGO MERCANTILE EXCHANGE | 058643 | LB | x | |
58 | GADO DE CORTE - CHICAGO MERCANTILE EXCHANGE | 061641 | FC | x | x |
59 | ELETRICIDADE PJM MENSAL - NEW YORK MERCANTILE EXCHANGE | 064657 | x | ||
60 | TROCA ISO NEW ENGLAND LMP - NEW YORK MERCANTILE EXCHANGE | 06465H | x | ||
61 | TROCA PJM CAL MONTH OFF PK LMP - NEW YORK MERCANTILE EXCHANGE | 06465M | x | ||
62 | TROCA ISO NEW ENG OFF PK LMP - NEW YORK MERCANTILE EXCHANGE | 06465S | x | ||
63 | TROCA CINERGY CAL MONTH LMP - NEW YORK MERCANTILE EXCHANGE | 064A01 | x | ||
64 | TROCA CINERGY OFF PEAK LMP - NEW YORK MERCANTILE EXCHANGE | 064A02 | |||
65 | DIA POSTERIOR PJM N ILL PEAK - NEW YORK MERCANTILE EXCHANGE | 064A34 | x | ||
66 | DIA POSTERIOR PJM JCPL PEAK - NEW YORK MERCANTILE EXCHANGE | 064A48 | x | ||
67 | DIA POSTERIOR PJM PEPCO PEAK - NEW YORK MERCANTILE EXCHANGE | 064A50 | x | ||
68 | DIA POSTERIOR PJM PSEG PEAK - NEW YORK MERCANTILE EXCHANGE | 064A54 | x | ||
69 | DIA POSTERIOR PJM WESTERN PEAK - NEW YORK MERCANTILE EXCHANGE | 064A56 | |||
70 | TEMPO REAL PJM WESTERN PEAK - NEW YORK MERCANTILE EXCHANGE | 064A58 | x | ||
71 | TEMPO REAL PJM WESTERN OFF PEAK - NEW YORK MERCANTILE EXCHANGE | 064A59 | x | ||
72 | TROCA ISO NEW ENG INT HUB PEAK - NEW YORK MERCANTILE EXCHANGE | 064A60 | x | ||
73 | TROCA MW IND TRANS PEAK - NEW YORK MERCANTILE EXCHANGE | 064A62 | x | ||
74 | TROCA NYISO ZONE 5 MW PEAK - NEW YORK MERCANTILE EXCHANGE | 064A66 | |||
75 | TROCA DISTRIBUIDOR ISO NEW ENG OFF PEAK - NEW YORK MERCANTILE EXCHANGE | 064A78 | |||
76 | TROCA MT BELVIEU PROPANO 5 DEC - NEW YORK MERCANTILE EXCHANGE | 06665O | |||
77 | TROCA MT BELVIEU ETANO 5 DEC - NEW YORK MERCANTILE EXCHANGE | 06665P | x | ||
78 | TROCA MT BELV NORM BUTANO 5 DEC - NEW YORK MERCANTILE EXCHANGE | 06665Q | x | ||
79 | TROCA MT BELV NAT GASOLINA 5 DEC - NEW YORK MERCANTILE EXCHANGE | 06665R | x | ||
80 | PETRÓLEO BRUTO LIGHT SWEET - ICE FUTUROS EUROPA LIGHT SWEET - ICE FUTURES EUROPE | 067411 | x | ||
81 | PETRÓLEO BRUTO, LIGHT SWEET - NEW YORK MERCANTILE EXCHANGE | 067651 | QM | x | |
82 | TROCA CALENDÁRIO PETRÓLEO BRUTO WTI - NEW YORK MERCANTILE EXCHANGE | 06765A | x | ||
83 | TROCA CALENDÁRIO PETRÓLEO BRUTO DUBAI - NEW YORK MERCANTILE EXCHANGE | 06765G | x | ||
84 | FINANCEIRO PETRÓLEO BRUTO WTI - NEW YORK MERCANTILE EXCHANGE | 06765I | x | ||
85 | FINANCEIRO BRENT - NEW YORK MERCANTILE EXCHANGE | 06765J | x | ||
86 | TROCA CALENDÁRIO BRENT (ICE) - NEW YORK MERCANTILE EXCHANGE | 06765N | x | ||
87 | TROCA BRENT-DUBAI - NEW YORK MERCANTILE EXCHANGE | 06765O | x | ||
88 | CACAU - ICE FUTURES U.S. | 073732 | CC | x | x |
89 | PALÁDIO - NEW YORK MERCANTILE EXCHANGE | 075651 | PA | x | |
90 | PLATINA - NEW YORK MERCANTILE EXCHANGE | 076651 | PL | x | |
91 | AÇÚCAR NO. 11 - ICE FUTUROS EUA | 080732 | SB | x | x |
92 | CAFÉ C - ICE FUTUROS EUA | 083731 | KC | x | x |
93 | PRATA - COMMODITY EXCHANGE INC. | 084691 | SI,XAGUSD,ZI | x | |
94 | GRAU DE COBRE N° 1 - COMMODITY EXCHANGE INC. | 085692 | HG | x | |
95 | OURO - COMMODITY EXCHANGE INC. | 088691 | GC,GOLD,XAUUSD | x | |
96 | RUBLO RUSSO - CHICAGO MERCANTILE EXCHANGE | 089741 | USDRUB,USDRUR | ||
97 | DÓLAR CANADENSE - CHICAGO MERCANTILE EXCHANGE | 090741 | 6C,USDCAD | ||
98 | FRANCO SUÍÇO - CHICAGO MERCANTILE EXCHANGE | 092741 | 6S,USDCHF | ||
99 | PESO MEXICANO - CHICAGO MERCANTILE EXCHANGE | 095741 | |||
100 | LIBRAS ESTERLINAS BRITÂNICAS - CHICAGO MERCANTILE EXCHANGE | 096742 | 6B,GBPUSD | ||
101 | IENE JAPONÊS - CHICAGO MERCANTILE EXCHANGE | 097741 | 6J,USDJPY | ||
102 | ÍNDICE DO DÓLAR AMERICANO - ICE FUTURES U.S. | 098662 | DX | ||
103 | EURO FX - CHICAGO MERCANTILE EXCHANGE | 099741 | 6E,EURUSD | ||
104 | GASOLINA BLENDSTOCK (RBOB) - NEW YORK MERCANTILE EXCHANGE | 111659 | XRB | x | |
105 | TROCA CALENDÁRIO RBOB - NEW YORK MERCANTILE EXCHANGE | 11165K | x | ||
106 | DÓLAR NEOZELANDÊS - CHICAGO MERCANTILE EXCHANGE | 112741 | 6N,NZDUSD | ||
107 | VIX FUTUROS - CBOE FUTURES EXCHANGE | 011700 | |||
108 | MÉDIA INDUSTRIAL DOW JONES - CHICAGO BOARD OF TRADE | 124601 | |||
109 | EURODÓLAR DE 3 MESES - CHICAGO MERCANTILE EXCHANGE | 132741 | |||
110 | ÍNDICE DE AÇÕES S&P 500 - CHICAGO MERCANTILE EXCHANGE | 138741 | |||
111 | ÍNDICE DE AÇÕES E-MINI S&P 500 - CHICAGO MERCANTILE EXCHANGE | 13874A | ES,SPX | ||
112 | ÍNDICE DE AÇÕES NASDAQ-100 - CHICAGO MERCANTILE EXCHANGE | 209741 | NQ | ||
113 | ÍNDICE DE AÇÕES NASDAQ-100 (MINI) - CHICAGO MERCANTILE EXCHANGE | 209742 | |||
114 | RETORNO DE EXCESSO DOW JONES UBS - CHICAGO BOARD OF TRADE | 221602 | |||
115 | DóLAR AUSTRALIANO - CHICAGO MERCANTILE EXCHANGE | 232741 | 6A,AUDUSD | ||
116 | FUTURO DE ÍNDICE RUSSELL 2000 MINI - ICE FUTURES U.S. | 23977A | |||
117 | MÉDIA DE AÇÕES NIKKEI - CHICAGO MERCANTILE EXCHANGE | 240741 | |||
118 | MÉDIA DE AÇÕES NIKKEI YEN DENOM - CHICAGO MERCANTILE EXCHANGE | 240743 | |||
119 | E-MINI MSCI EAFE - CHICAGO MERCANTILE EXCHANGE | 244741 | |||
120 | MERCADOS EMERGENTES E-MINI MSCI - CHICAGO MERCANTILE EXCHANGE | 244742 | |||
121 | TROCAS DE TAXA DE JURO 10YR - CHICAGO BOARD OF TRADE | 246602 | |||
122 | TROCAS DE TAXA DE JURO 5YR - CHICAGO BOARD OF TRADE | 247602 | |||
123 | ÍNDICE DE COMMODITY S&P GSCI - CHICAGO MERCANTILE EXCHANGE | 256741 | |||
124 | TROCA SING JET KERO - NEW YORK MERCANTILE EXCHANGE | 26265D | |||
125 | ÍNDICE DE AÇÕES E-MINI S&P 400 - CHICAGO MERCANTILE EXCHANGE | 33874A | |||
126 | TROCA JET NY GASÓLEO SPR DO GOLFO - NEW YORK MERCANTILE EXCHANGE | 86465A | x | ||
127 | TROCA JET KERO GASÓLEO SPR DE CINGAPURA - NEW YORK MERCANTILE EXCHANGE | 86465C | x | ||
128 | JET CIF NWE/GASÓLEO FUT - NEW YORK MERCANTILE EXCHANGE | 86465D | x | ||
129 | TROCA DE ÓLEO COMBUSTÍVEL CRACK N° 6 DO GOLFO - NEW YORK MERCANTILE EXCHANGE | 86565A | x | ||
130 | 3.5% ÓLEO COMBUSTÍVEL RDAM CRACK SPR - NEW YORK MERCANTILE EXCHANGE | 86565C | x | ||
131 | TROCA NAPTHA CRACK SPR - NEW YORK MERCANTILE EXCHANGE | 86665A | x | ||
132 | TROCA GASÓLEO CRACK SPR - NEW YORK MERCANTILE EXCHANGE | 86765C | x |
Tabela 3. Lista de símbolos, disponíveis em relatórios COT
Traduzido do russo pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/ru/articles/34
![Tratamento de eventos no MQL5: mudando período MA rapidamente](https://c.mql5.com/2/0/How_Change_Period_Moving_Average_on_the_fly_MQL5__1.png)
![Implementação prática dos filtros digitais no MQL5 para principiantes](https://c.mql5.com/2/0/Filter.png)
![Criando um indicador com opções de controle gráfico](https://c.mql5.com/2/0/macd__1.png)
![Como exportar cotações do MetaTrader5 para aplicações .NET usando serviços WCF](https://c.mql5.com/2/0/mql_net__1.png)
![MQL5 - Linguagem para estratégias de negociação inseridas no terminal do cliente MetaTrader 5](https://c.mql5.com/i/registerlandings/logo-2.png)
- Aplicativos de negociação gratuitos
- 8 000+ sinais para cópia
- Notícias econômicas para análise dos mercados financeiros
Você concorda com a política do site e com os termos de uso