MQL5: análise e processamento dos relatórios Commodity Futures Trading Commission (CFTC) no MetaTrader 5

31 dezembro 2013, 11:26
Aleksey Sergan
0
2 873

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

deacot2010.zip

dea_cit_txt_2010.zip

fut_disagg_txt_2010.zip

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 http://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 http://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 http://www.cftc.gov/files/dea/history/deacot2010.zip contém relatório para o ano de 2010, o arquivo http://www.cftc.gov/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 buffers
Variá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.

A obtenção dos dados do indicador é realizada na função 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);

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.

Vamos verificar qual vantagem estatística nós teremos, utilizando dados diferentes dos relatórios COT. A maneira mais simples é estimar a probabilidade da determinação correta da cor de vela semanal. Considere a seguinte hipótese:
  • 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

Os resultados da previsão são os mesmos para todos os símbolos. Os valores médios da probabilidade de previsão correta para diferentes tipos de sinais sã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.
Prós:
  • 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 Software Corp.
Artigo original: https://www.mql5.com/ru/articles/34

Arquivos anexados |
sources.zip (211.23 KB)
Implementação prática dos filtros digitais no MQL5 para principiantes Implementação prática dos filtros digitais no MQL5 para principiantes

A ideia da filtragem de sinal digital foi amplamente discutida em tópicos de fóruns sobre a construção dos sistemas de negócio. E seria imprudente não criar um código padrão de filtros digitais no MQL5. Neste artigo, o autor descreve a transformação de um simples código do indicador SMA em seu artigo "Indicadores personalizados no MQL5 para iniciantes" em um código do mais complicado e universal filtro digital. Este artigo é uma sequência lógica do artigo anterior. Ele também fala como substituir o texto no código e como corrigir erros de programação.

Como exportar cotações do MetaTrader5 para aplicações .NET usando serviços WCF Como exportar cotações do MetaTrader5 para aplicações .NET usando serviços WCF

Quer organizar a exportação de cotas do MetaTrader 5 para sua própria aplicação? A junção MQL5-DLL permite criar essas soluções! Este artigo mostrará a você um dos meios de exportação de cotas do MetaTrader 5 para aplicações escritas no .NET. Para mim, é mais interessante, racional e fácil implementar a exportação de cotas usando esta mesma plataforma. Infelizmente, a versão 5 ainda não suporta .NET, então, como antigamente, usaremos o win32 dll com suporte .NET como intercamada.

Tratamento de eventos no MQL5: mudando período MA rapidamente Tratamento de eventos no MQL5: mudando período MA rapidamente

Suponha que um simples indicador MA (média móvel) com período 13 seja aplicado ao gráfico. Queremos mudar o período para 20, mas não queremos ir até a caixa de diálogo de propriedades do indicador e editar o número 13 para 20: por simples cansaço destas ações tediosas com o mouse e teclado. E, especialmente, não queremos abrir o código do indicador e modificá-lo. Queremos fazer tudo isso simplesmente pressionando um botão - "setas para cima" próximas ao teclado numérico. Neste artigo, descreverei como fazer isso.

Criando um indicador com opções de controle gráfico Criando um indicador com opções de controle gráfico

Aqueles que são familiares com os sentimentos do mercado, conhecem o indicador MACD (seu nome completo é convergência/divergência de média móvel) - a poderosa ferramenta para analisar o movimento de preço, usada por negociantes desde os primeiros momentos do aparecimento dos métodos de análise computacionais. Neste artigo, consideraremos possíveis modificações do MACD e o implementaremos no indicador com a possibilidade de mudar graficamente entre as modificações.