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

Aleksey Sergan | 31 dezembro, 2013

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 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.

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

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

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

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:

Fig. 7 Arquivo de saída

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