Descargar MetaTrader 5

MQL5: análisis y procesado de informes de la Comisión de Operaciones del Mercado de Futuros (CFTC) en MetaTrader 5

22 enero 2014, 15:09
Aleksey Sergan
0
831


Introducción

El terminal de cliente de MetaTrader 5, desarrollado por MetaQuotes Software Corp. como una de las herramientas de los operadores, comprende el lenguaje de programación MQL5 que soporta la programación orientada a objeto. Por un lado, MQL5 no es compatible con su versión anterior - MQL4, y por otro lado dispone de una gran cantidad de nuevas posibilidades como lenguaje orientado a objeto con todas sus características. Por tanto, los operadores que tengan conocimientos de MQL4 debe entender este (de hecho) nuevo lenguaje y considerarse como destinatarios de este artículo.

En este artículo voy a mostrar una solución para el problema siguiente: es necesario desarrollar una herramienta para los operadores que permita obtener y analizar los distintos datos de los informes de la Comisión de Operaciones del Mercado de Futuros (CFTC). Este tema ya se ha tratado en el artículo Proyecto Meta COT - nuevos horizontes para el análisis de informes en MetaTrader 4, por lo que voy a asumir que el lector está familiarizado con los conceptos y vamos a tratar los detalles que no se describen ahí.

La idea es la siguiente: desarrollar un único indicador que permita obtener datos de los archivos proporcionados por la Comisión sin necesidad de un procesamiento o una conversión intermedia. Además puede usarse para diferentes finalidades: para trazar los datos como un indicador, como fuente de datos en los demás indicadores, en los scripts para el análisis automatizado y en los asesores expertos para su uso en las estrategias de trading.


1. Tipos de informes COT

Hay tres tipos de informes: Current Legacy Report (COT), Supplemental Commodity Index (CIT),  Current Disaggregated Report (DCOT), las diferencias entre cada uno se presentan en la Tabla 1.

Descripción
Current Legacy Reports Supplemental Commodity Index Current Disaggregated Reports
Nombre corto COT CIT DCOT
 Título de la referencia
Current Legacy Reports
Supplemental Commodity Index
Current Disaggregated Reports
Referencia al archivo de datos actuales

deacot2010.zip

dea_cit_txt_2010.zip

fut_disagg_txt_2010.zip

Grupo de operadores incluidos en el informe
No comercial
Comercial
No sujeto a informe
No comercial
Comercial
No sujeto a informe
Operadores del índice
Productor/Comerciante/Procesador/Usuario
Operadores de swap
dinero gestionado
Otros
No sujeto a informe

Tabla 1. Tipos de compromisos de los informes sobre operadores  

La información relativa a los operadores que deben informar sobre sus posiciones en los mercados de futuros, principios de clasificación y periodicidad de los informes pueden consultarse en el libro "Trade Stocks and Commodities With the Insiders: Secrets of the COT Report" y en el artículo Proyecto Meta COT - Nuevos horizontes para el análisis de informes CFTC en MetaTrader 4.

Voy a considerar dos informes que no se describen en estas fuentes. 

La abreviatura CIT significa Commitments of Index Traders (Compromiso de los operadores del índice). Este informe se publica desde 2007. La página web actual del informe CIT se encuentra disponible en http://cftc.gov/dea/options/deaviewcit.htm. Los operadores del índice están en un grupo separado de los hedgers y especuladores.

La descripción del informe complementario puede consultarse en http://www.cftc.gov/MarketReports/CommitmentsofTraders/AbouttheCOTReports/index.htm. Todos estos operadores del índice abren a menudo posiciones largas en los mercados y pasan sobre ellas de contrato en contrato.

Desde 2009 la Comisión publica el Informe sobre compromisos desagregados de los operadores, cuya descripción se encuentra en las notas explicativas.

El informe desagregado de COT aumenta la transparencia de los informes COT separando a los operadores en las siguientes cuatro categorías: Productor/Comerciante/Procesador/Usuario; Operadores de swap; dinero gestionado y otros.

  • Productor/Comerciante/Procesador/Usuario. Un "Productor/Comerciante/Procesador/Usuario" es una entidad que se dedica principalmente a la producción, procesado, envasado o manipulación de productos materiales y utiliza los mercados de futuros para gestionar y obtener protección frente a los riesgos derivados de dichas actividades.
  • Operadores de swap. Un "operador de swap" es una entidad que negocia principalmente con permutas (swaps) para gestionar u obtener protección frente a los riesgos derivados de tales transacciones. Las contrapartes de los operadores de swaps pueden ser operadores especulativos, como los hedge funds (fondos de protección) o clientes comerciales tradicionales que están gestionando el riesgo derivado de sus transacciones con productos materiales.
  • Gestor de dinero. Un "gestor de dinero", a los efectos de este informe, es un asesor registrado sobre comercio de productos básicos (CTA), un operador de productos básicos registrado (CPO) o un fondo no registrado identificado por la CFTC. Estos operadores participan en la gestión operativa de futuros organizados en nombre de clientes.
  • Otros. Cualquier otro operador que pueda incluirse en el informe distinto de las otras tres categorías se califica en una categoría separada denominada "otros".

La lista completa de instrumentos se encuentra en el Apéndice 2. Hay también columnas que muestran la existencia de instrumentos particulares en los informes de CIT y DCOT.


2. Escribir un indicador COT que utiliza datos externos de archivos CSV

El indicador funciona de la siguiente forma. El tipo de informe (uno de los que aparecen en la Tabla 1), el tipo de datos y el grupo de operadores se define en los parámetros de entrada del indicador.

Los datos pueden ser de los siguientes tipos:

  • largos netos
  • ratio de largos netos en interés abierto
  • índice Williams calculado para largos netos
  • interés abierto

La lista de posibles datos no está completa y puede aumentarse fácilmente para incluir los datos más esenciales que yo uso. Para el símbolo actual, los datos especificados se solicitan a partir de los archivos de datos (la descarga y desempaquetado de estos se describe más adelante). Vamos a usar la clase CCFTCReport para el acceso a los datos y su descarga de estos archivos.

El indicador tiene la siguiente estructura:


2.1. Constantes

Para definir las constantes se usa el tipo de dato enum. Los tipos de informe admitidos por el indicador son:
enum cot_type_report // type of report
{ 
  COT, DCOT, CIT
};

Grupos de operadores:

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 datos que se pueden usar en el 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. Clases

Para almacenar diferentes objetos en una sola variable es posible usar estructuras y clases. Sin embargo, no es posible asignar dos variables de tipo estructural si contienen matrices dinámicas o valores del tipo string. Por esta razón hemos usado la clase en lugar de la estructura para almacenar el informe COT y el método para la asignación de datos.

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 ahora voy a asumir que el lector está familiarizado con el formato CSV de los informes COT usado en el artículo Proyecto Meta COT - Nuevos horizontes para el análisis de informes en MetaTrader 4. La instancia de clase para este tipo se usará para almacenar una única línea del informe COT. La matriz de estas instancias de clase permitirá usarlas para almacenar y acceder a los campos de los informes COT. La clase CCFTCReport ha sido desarrollada para el alamcenamiento de datos y el acceso:

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
  };

Instancia de la clase CCFTCReport contiene todo el informe para un único símbolo y el tipo de informe puede ser COT, CIT o DCOT. Las enumeraciones y clases se incluyen en el archivo "cot.mqh" incluido.


2.3. Parámetros de entrada

Los parámetros de entrada se definen por las variables de entrada. Estos parámetros permiten especificar grupos de operadores, tipos de datos y los tipos necesarios de informes COT:

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. Función OnInit 

Un indicador tiene la función OnInit() usada para las siguientes finalidades: para descargar datos del archivo del informe, para verificar parámetros de entrada y para asignar buffers de indicador.

El buffer, inicializado con la propiedad INDICATOR_DATA, contiene datos que se trazan en el gráfico. El buffer, inicializado con la propiedad INDICATOR_CALCULATIONS, contiene cálculos intermedios.

SetIndexBuffer( 0, BufferData, INDICATOR_DATA );
IndicatorSetString(INDICATOR_SHORTNAME,indname);
SetIndexBuffer( 1, BufferCalculations, INDICATOR_CALCULATIONS );


2.5. Función OnCalculate

Esta función se usa para la selección de los datos necesarios y para el cálculo de los datos solicitados y su trazado.

Vamos a ver su funcionamiento en profundidad. Se usa la segunda forma de la llamada:

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 a determinar las barras para el cálculo y trazado.

int pos=rates_total-prev_calculated-1;
if( pos >= rates_total-1 )pos--;

Vamos a especificar que los elementos deben indexarse como series de tiempo.

ArraySetAsSeries(Time, true);
ArraySetAsSeries(BufferData, true);
ArraySetAsSeries(BufferCalculations, true);

Después de algunos experimentos he descubierto que es mejor usar la indexación de series de tiempo para todas las matrices que se refieren a los buffers del indicador. Se aconseja lo mismo para las matrices que se pasan a la función OnCalculate como parámetros, el último (reciente) elemento tiene un índice igual a 0.

El bucle de cálculo es como sigue: 

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 );
  }

La matriz BufferCalculations se usa para almacenar datos primarios seleccionados del informe COT.

La matriz BufferData contiene datos listos para trazarse en el gráfico. Pueden ser los valores del informe (largas netas, interés abierto) así como valores calculados (ratios largos, índices Williams). Me gustaría describir el punto siguiente, para el que no he encontrado ninguna solución elegante. Las matrices pasadas a la función OnCalculate pueden ser necesarias en niveles subsiguientes y solo podemos acceder a ellas si se han pasado en esas llamadas, por lo que creo que desordenan el código.

La llamada de la función CalcData :

BufferData[i]         = CalcData( type_data, i, Time );

La función CalcData llama a la función 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]);        
}

Necesito acceder a la matriz Time dentro de la función CalcIndex, por lo que me he visto forzado a pasarla según la jerarquía de llamadas. Imagine cómo sería el código si necesitáramos usar las 8 matrices.


3. Descargar los archivos de datos

Todos los enlaces se muestran en la Tabla 1. Es un archivo distinto para cada año y el número está incluido en el nombre del archivo. Por ejemplo, el archivo http://www.cftc.gov/files/dea/history/deacot2010.zip contiene el informe del año 2010, el archivo http://www.cftc.gov/files/dea/history/deacot2009.zip para 2009, etc.

Es necesario descargar todos estos archivos y desempaquetarlos en la carpeta \MQL5\files\ del directorio de instalación del terminal de cliente. Para cada año, es necesario crear su propia carpeta separada con un nombre deacotXXXX, donde XXXX es el año. Como resultado obtendremos la siguiente estructura de carpetas.

Fig.1. Estructura de carpetas para los informes.

El proceso de preparación de los datos puede simplificarse. Todas las operaciones siguientes (comprobar las actualizaciones en el sitio web de CFTC, descargar y desempaquetar en las carpetas adecuadas) son realizadas por el script "Cotdownloader". El kernel del script (descarga de datos) está basado en el script WININET_TEST. He usado la clase CProgressBar, publicada en el artículo El histograma del precio (perfil de mercado) y su implementación en MQL5. Las aplicaciones externas se ejecutan usando la API de Windows que se describe en el artículo Optimización automatizada de un robot de trading en el trading real.

Usar un script es sencillo: lo adjuntamos a cualquier gráfico. Cuando trabaja, proporciona información sobre la descarga de datos como una barra de progreso en el gráfico y como mensajes de texto en la pestaña Expertos.

Fig.2. Proceso de descarga de datos.


4. Ejemplo de su uso

Para ejecutar un indicador es necesario adjuntarlo al gráfico del símbolo elegido y especificar los parámetros de entrada.


Fig. 3 Parámetros de entrada del indicador cot

Observe que ahora podemos especificar una representación más sencilla en lugar de los nombres de las variables y los valores de los tipos de datos enumerados. Esto se hace de la siguiente forma: para reemplazar el nombre de la variable debemos especificar un comentario cuando declaramos una variable 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

Lo mismo para los valores, es necesario especificar la descripción con comentarios al declarar los 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
};

Si los parámetros de entrada han sido especificados correctamente y los archivos se han descargado y desempaquetado, el indicador aparecerá en una ventana separada.


Fig. 4 Indicador Cot

En caso de que se produzcan errores, estos se imprimirán en la pestaña "Expertos" de la ventana de "Herramientas".

Fig. 5 Mensaje de error


5. Notas de la versión

El indicador no está posicionado como un producto acabado completo. Es un ejemplo que muestra cómo podemos obtener resultados que puedan utilizarse posteriormente escribiendo un sencillo código. Por ejemplo, no hemos desarrollado el módulo que permite personalizar el tipo de datos del informe COT con la configuración del terminal de cliente proporcionado por un broker determinado. Esta característica se incluye en la función DefineIdSymbol. Estas son las primeras líneas 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

Si necesitamos asignar un símbolo de un informe a un símbolo del terminal de cliente, debemos hacerlo manualmente modificando este código. He utilizado los ajustes del terminal BroccoTrader4. Para los ejemplos de este artículo he usado cuentas de prueba abiertas en los servidores de Metaquotes-Demo y Alpari-Demo. Solo hay disponibles 2 instrumentos para los informes DCOT: XAUUSD (gold) y XAGUSD (silver). 

Actualmente, los informes CIT no están soportados ya que no existen instrumentos financieros en estos servidores. Cuando existan será fácil incluir sus informes con solo eliminar los comentarios y modificar algunas líneas de código.


6. Cómo usar el indicador COT mediante iCustom

No utiliza el indicador en una forma, como se presenta en la Fig.3. El lenguaje MQL5 tiene la posibilidad de reutilizar los indicadores personalizados usando la función iCustom.


6.1. Crear un nuevo indicador

Hay muchas formas de realizar análisis visuales de informes COT. Uno de ellas es un histograma que muestra posiciones de distintos grupos de operadores con distintos colores.

Vamos a considerar la siguiente tarea: crear un indicador COTnet que trace posiciones de diferentes grupos de operadores (comerciales y no comerciales de los informes COT), como un histograma. El usuario debe tener la posibilidad de elegir el tipo de datoa: largas netas, ratio de largas netas o índice Williams.

El proceso puede simplificarse con el MQL5 Wizard del que se trata en el artículo MQL5: crear su propio indicador. Como resultado, el código del indicador (los estilos de dibujo han sido creados por el MQL5 Wizard) tiene este aspecto:

#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
Las variables de entrada, variables globales y directiva del preprocesador para incluir la librería con las clases son las siguientes:
#include <cot.mqh>
input cot_type_data    type_data   = netlongs;  // Indicator's type
double         NoncommercialBuffer[];
double         CommercialBuffer[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int handlecomm, handlenoncomm;

El código de la función OnInit es:

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 a ver ahora cómo utilizar indicadores personalizados (en el ejemplo de los operadores no comerciales). Después de la primera llamada de la función iCustom, se pasan los siguientes parámetros (necesarios para nuestro informe) a la función:
  • NULL – símbolo actual en el terminal de cliente
  • 0 – periodo de tiempo actual
  • "cot" – nombre de archivo (observe que se especifica sin la extensión) de nuestro indicador personalizado.
  •  td = comercial (grupo de operadores que necesitamos)
  •  type_data = tipo de indicador especificado en los parámetros de entrada
  •  tr = COT – tipo de informe

Como resultado tenemos un controlador que usaremos posteriormente para obtener los datos del indicador.

La obtención de los datos del indicador se realiza en la función 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);

Dedicamos algo de tiempo, escribimos un código breve y obtenemos el siguiente resultado:


Fig. 6 El indicador cotnet

6.2. iCustom también puede usarse en scripts

Vamos a ver la siguiente tarea: crear el script cotsignals para calcular estimaciones estadísticas.

Vamos a comprobar qué ventaja estadística obtendremos usando datos distintos de los informes COT. La forma más simple es estimar la probabilidad de una determinación correcta del color de la vela semanal. Consideremos las siguientes hipótesis:
  • El signo de los largos netos de los operadores no comerciales es el mismo que el color de la vela: si es positivo la tendencia semanal es alcista y si es negativo es con tendencia a la baja.
  • El color de la vela (blanco/negro) está directamente relacionado con el aumento/disminución de las largas netas de los operadores no comerciales.
  • El color de la vela es negro o blanco dependiendo del valor del índice William calculado en las largas netas de los operadores no comerciales. Si es sobrecompra (más del 75%) el color es negro y si es sobreventa (menos del 25%) el color de la vela es el blanco.

Usaremos los datos del informe COT. Usando estos ejemplos podemos desarrollar nuestros propios métodos de interpretación de datos del COT y sacar provecho de ellos. En nuestro caso vamos a verificar las 150 barras semanales del historial que se corresponden con un periodo de 3 años. Antes de escribir un script tenemos que definir los tipos de datos necesarios y las clases:

La enumeración de los posibles tipos de estadísticas es:

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 obtener las estadísticas del símbolo especificado vamos a crear una clase 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
};

Las estadísticas solicitadas son devueltas por el método Get. Vamos a describir cómo funciona. En primer lugar, las matrices necesarias se rellenan con datos usando un indicador personalizado. Necesitamos valores de posiciones netas largas de los operadores no comerciales (especuladores):

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

El código para el cálculo de las estadísticas (solo tenemos que calcular un parámetro, es una probabilidad de previsión para el color de la vela semanal) es el siguiente:

for(int istat = 0; istat < ArraySize(liststatistic); istat++)
  {
   int cntsignals = 0;
   int cntsucsess = 0;
   for(int i=bars-1; i>=0; i--)
     {
      double colorcandle=iClose(symbol,PERIOD_W1,i)-iOpen(symbol,PERIOD_W1,i);
      if(symbol=="USDCHF" || symbol=="USDCAD" || symbol=="USDJPY") colorcandle=-colorcandle;
      double cotdirection=GetCotSignalDirection(i,liststatistic[istat]);
      if(cotdirection==0)continue;                 //no signal
      cntsignals++;
      if(cotdirection*colorcandle>0) cntsucsess++; //color and direction are same
     }

   if(cntsignals!=0) probably[istat]=1.*cntsucsess/cntsignals;

   Print("Calculation complete for ",symbol,GetStringTypeStatistic(liststatistic[istat]),
                 " the correct forecast probability=",DoubleToString(probably[istat],2));
   Print("Total signals:",cntsignals,"success:",cntsucsess);
  }
La función LoadDataFromCOTIndicator es compleja ya que es necesario realizar numerosas comprobaciones para obtener datos del indicador, por lo que vamos a verla en detalle:
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 );

En la última línea obtenemos el controlador del indicador personalizado que puede usarse para obtener datos de los buffers.

Tenemos que comprobar que el indicador se ha creado con éxito:

  if( cothandle == INVALID_HANDLE ){
    Print("Error in indicator creation for symbol ", symbol );
    return(false);
  }

Comprobando los datos históricos que necesitamos:

int n = BarsSinh( symbol, timeframe );
  if(  n < nbars    )
{ 

Si hay suficientes datos históricos los cargamos:

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);
    }
  }

La función BarsSinh (devuelve el número de barras disponibles en el periodo de tiempo y símbolo especificado) y CheckLoadHistory (descarga del historial) se basan en el código del script de la Referencia de MQL5.

Antes de usar los datos del buffer del indicador tenemos que comprobar que los datos se han preparado, ya que la sola presencia del controlador no garantiza que ha finalizado el cálculo.

La siguiente llamada realiza esta comprobación y espera cuando terminan los cálculos:

if( !WaitForCalculcateIndicator( cothandle ) ){
    Print("Timeout for the COT indicator calculation");
    return(false);
  }

Los datos están preparados y tenemos que copiarlos:

int res = CopyBuffer(cothandle, 0, 0, nbars, loadto );

A continuación comprobamos que los datos se han copiado correctamente:

if( res != nbars ){
    Print("Error in obtaining the data, ", MyErrorDescription(_LastError) );
    return(false);
  }

Y finalmente:

return(true);

Tenemos los datos y los devolvemos a la matriz pasada como parámetro de la función.

Las estadísticas resultantes se imprimirán en el archivo CSV y la clase CCOTOutFile ha sido desarrollada para esta finalidad:

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);    }
};

Esta crea el archivo con los datos de salida, estribe los strings en formato .csv, forma el encabezado y cierra el archivo mientras se destruye la instancia de la clase.

El código del script será breve ya que todas las librerías necesarias han sido ya escritas.

Los parámetros de entrada y las librerías incluidas:

input int      NBars =150; //History depth W1
#include <common.mqh>
#include <cot.mqh>

La lista de símbolos para el análisis:

string listsymbols[] = {"EURUSD", "GBPUSD", "USDCHF", "USDCAD", "USDJPY", "AUDUSD", "XAUUSD"};

La inicialización del objeto:

void OnStart()
{
  CCOTOutFile outfile;  //file with results
  if( !outfile.Init("cotw1signals.csv") )return;

La lista de estadísticas para el análisis:

  cot_type_statistics list_statistic[]= // statistic types list
  { speculantsign, speculantchange, willamszones };

Escribir la cabecera del archivo CSV :

outfile.PutHeader( list_statistic ); //writing CSV file header

En el bucle principal obtenemos las estadísticas para cada símbolo y señal y escribimos los resultados en el archivo:

  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.");
}

El script se ha probado en el servidor Alpari-Demo. Si solo lo ejecutamos en el servidor MetaQuotes-Demo mostrará el mensaje "Error en el cálculo de las estadísticas para el símbolo XAUUSD" ya que este símbolo no está disponible en este momento.

Como resultado de la ejecución del script obtendremos el archivo que se muestra a continuación:


Para hacerlo más claro vamos a abrirlo en Excel, calculamos los valores promedio y creamos un histograma de probabilidades:

Fig. 8 Probabilidades de la predicción

Los resultados de la predicción son los mismos para todos los símbolos. Los valores promedio de la probabilidad del pronóstico correctos para los distintos tipos de señales son:
  • 0.54 – signo para los operadores no comerciales;
  • 0.50 – el volumen cambia en las posiciones largas netas de los operadores no comerciales;
  • 0.48 – zonas de sobrecompra/sobreventa del índice Williams.

Como podemos comprobar, tenemos los mejores resultados del pronóstico para las posiciones largas netas de los operadores no comerciales. El peor resultado es para las zonas del índice Williams. El valor 0.48 significa que la probabilidad para la vela blanca es igual a 0.52 incluso si el índice Williams es de sobrecompra y de color negra cuando es de sobreventa. Por tanto, su uso en la forma presentada por Williams es irracional. Es posible que los resultados puedan mejorarse usando periodos de tiempo más largos como mesas o aún más largos. Hemos usado todos los símbolos que estaban disponibles en los servidores demo en los informes COT.


Conclusión

MQL5 es una herramienta que nos permite programar todo el ciclo de tareas necesarias para desarrollar un sistema de trading.
  • Los indicadores con algoritmos complicados que se usan para acceder a las fuentes de datos externas;
  • Su reutilización en otros indicadores, scripts y asesores expertos;
  • La implementación de algoritmos propios de análisis estadístico y cuantitativo.
Ventajas:
  • La programación orientada a objetos reduce enormemente el tiempo necesario de depuración.
  • Depurador.
  • Es fácil cambiarse de MQL4 a MQL5.
  • La implementación del modelo orientado a objeto es acertada, es fácil de usar. 
  • La documentación se encuentra bien organizada. 
  • La integración con la API de Windows amplía la plataforma ya que, por ejemplo, permite trabajar con páginas de internet.

Desventajas:

El principal problema para mí fue el acceso a los datos históricos:  
  • La falta de funciones primitivas necesarias para acceder a las series de tiempo (como Time[], Open[], Close[]  y otras de MQL4)
  • Al acceder a los datos es necesario realizar muchas comprobaciones sobre su accesibilidad y es necesario conocer sus detalles.

Hay un depurador pero no dispone de muchas características útiles y es imposible realizar comprobaciones de objetos complejos como matrices y clases. La lista de ventajas y desventajas no es exhaustiva. He incluido solo las que me he encontrado al preparar este artículo.


Apéndice 1. Lista de archivos

Todos los archivos están en la carpeta del terminal de cliente. Desempaquetar los archivos de sources.zip a la carpeta del terminal de cliente.

 № Nombre de archivo
Descripción
 1  MQL5\Files\unzip.exe
 Aplicación Windows para descomprimir los archivos .zip
 2  MQL5\Include\Cdownloader.mqh
 Clase que descarga los archivos de CFTC de internet
 3  MQL5\Include\ClassProgressBar.mqh
 Clase CProgressBar usada para mostrar el proceso de descarga en la ventana del gráfico
 4  MQL5\Include\common.mqh
 Funciones y constantes habituales usadas en todos los indicadores y scripts
 5  MQL5\Include\cot.mqh
 Clase CCFTCReport que selecciona los datos de los informes cot
 6  MQL5\Include\ErrorDescription.mqh
 Librería de descripción de errores
 7  MQL5\Indicators\cot.mq5
 El indicador base cot
 8  MQL5\Indicators\cotnet.mq5
 EL indicador cotnet, un simple ejemplo de uso de cot.mq5 como un indicador de usuario personalizado
 9  MQL5\Scripts\cotdownloader.mq5
 Script cotdownloader que descarga los archivos de internet
 10  MQL5\Scripts\cotsignals.mq5
 Script cotsignals, ejemplo de los análisis estadísticos de los informes COT


Tabla 2. Lista de archivos


Apéndice 2. Lista de símbolos disponibles en los informes COT


Nombre del símbolo
ID en el intercambio ID en el terminal de cliente Presente en CIT Presente en DCOT
 1 WHEAT - CHICAGO BOARD OF TRADE  001602 ZW x x
 2 WHEAT - KANSAS CITY BOARD OF TRADE  001612   x x
 3 WHEAT - MINNEAPOLIS GRAIN EXCHANGE  001626     x
 4 CORN - CHICAGO BOARD OF TRADE  002602 ZC x x
 5 OATS - CHICAGO BOARD OF TRADE 004603 ZO   x
 6 SOYBEANS - CHICAGO BOARD OF TRADE  005602 ZS x x
 7 MINI SOYBEANS - CHICAGO BOARD OF TRADE  005603     x
 8 SULFUR FINANCIAL INSTRUMENT - CHICAGO CLIMATE FUTURES EXCHANGE  006261     x
 9 CARBON FINANCIAL INSTRUMENT - CHICAGO CLIMATE FUTURES EXCHANGE  006268     x
 10 RGGI CO2 ALLOWANCE 2009 - CHICAGO CLIMATE FUTURES EXCHANGE  00626U      x
 11 SOYBEAN OIL - CHICAGO BOARD OF TRADE  007601 ZL x x
 12 U.S. TREASURY BONDS - CHICAGO BOARD OF TRADE  020601 ZB    
 13 LONG-TERM U.S. TREASURY BONDS - CHICAGO BOARD OF TRADE  020604      
 14 GULF # 6 FUEL 3.0% SULFUR SWAP - NEW YORK MERCANTILE EXCHANGE  02165A      x
 15 NY RES FUEL 1.0% SULFUR SWAP - NEW YORK MERCANTILE EXCHANGE  02165B      x
 16 EUR 1% FUEL OIL NWE CAL SWAP - NEW YORK MERCANTILE EXCHANGE  02165C      x
 17 EUR 3.5% FUEL OIL RTD CAL SWAP - NEW YORK MERCANTILE EXCHANGE  02165E      x
 18 SING FUEL OIL 180 CAL SWAP - NEW YORK MERCANTILE EXCHANGE  02165G      x
 19 EAST WEST FUEL OIL SPR SWAP - NEW YORK MERCANTILE EXCHANGE  02165I      x
 20 NY 1% V GULF 3% FUEL OIL SPR - NEW YORK MERCANTILE EXCHANGE  02165T      x
 21 NO. 2 HEATING OIL 022651     x
 22 SING GASOIL SWAP - NEW YORK MERCANTILE EXCHANGE  02265J      x
 23 SING GASOIL/RDAM GASOIL SWAP - NEW YORK MERCANTILE EXCHANGE  02265T      x
 24 NYMEX HEATING OIL/RDAM GASOIL - NEW YORK MERCANTILE EXCHANGE  02265U      x
 25 GASOIL (ICE) SWAP - NEW YORK MERCANTILE EXCHANGE  02265V      x
 26 UP DOWN GC ULSD VS HO SPR SWAP - NEW YORK MERCANTILE EXCHANGE  022A13      x
 27 SING GASOIL BALMO SWAP - NEW YORK MERCANTILE EXCHANGE  022A22      x
 28 NATURAL GAS ICE HENRY HUB - ICE OTC  023391     x
 29 NATURAL GAS - NEW YORK MERCANTILE EXCHANGE  023651 QG   x
 30 MICHCON BASIS SWAP - NEW YORK MERCANTILE EXCHANGE  02365A      x
 31 M-3 BASIS SWAP - NEW YORK MERCANTILE EXCHANGE  02365C      x
 32 TCO BASIS SWAP - NEW YORK MERCANTILE EXCHANGE  02365D       
 33 NGPL TEXOK BASIS SWAP - NEW YORK MERCANTILE EXCHANGE  02365G      x
 34 NGPL MIDCON BASIS SWAP - NEW YORK MERCANTILE EXCHANGE  02365K      x
 35 WAHA BASIS SWAP - NEW YORK MERCANTILE EXCHANGE  02365O      x
 36 HOUSTON SHIP CH INDEX SWAP - NEW YORK MERCANTILE EXCHANGE  023A10      x
 37 CBT ETHANOL - CHICAGO BOARD OF TRADE  025601     x
 38 CHICAGO ETHANOL SWAP - NEW YORK MERCANTILE EXCHANGE  025651     x
 39 SOYBEAN MEAL - CHICAGO BOARD OF TRADE  026603 ZM   x
 40 JAPAN C&F NAPTHA SWAP - NEW YORK MERCANTILE EXCHANGE  03265C      x
 41 COTTON NO. 2 - ICE FUTURES U.S.  033661 CT x x
 42 HENRY HUB BASIS SWAP - NEW YORK MERCANTILE EXCHANGE  035652     x
 43 HOUSTON SHIP CH BASIS SWAP - NEW YORK MERCANTILE EXCHANGE  035653     x
 44 NW PIPE ROCKIES BASIS SWAP - NEW YORK MERCANTILE EXCHANGE  035654     x
 45 PANHANDLE BASIS SWAP - NEW YORK MERCANTILE EXCHANGE  035655     x
 46 HENRY HUB SWAP - NEW YORK MERCANTILE EXCHANGE  03565B       
 47 HENRY HUB PENULTIMATE GAS SWAP - NEW YORK MERCANTILE EXCHANGE  03565C      x
 48 ROUGH RICE - CHICAGO BOARD OF TRADE  039601 ZR   x
 49 FRZN CONCENTRATED ORANGE JUICE - ICE FUTURES U.S.  040701 JO   x
 50 2-YEAR U.S. TREASURY NOTES - CHICAGO BOARD OF TRADE  042601      
 51 10-YEAR U.S. TREASURY NOTES - CHICAGO BOARD OF TRADE  043602 ZN    
 52 5-YEAR U.S. TREASURY NOTES - CHICAGO BOARD OF TRADE  044601      
 53 30-DAY FEDERAL FUNDS - CHICAGO BOARD OF TRADE  045601 ZQ    
 54 MILK Class III - CHICAGO MERCANTILE EXCHANGE  052641     x
 55 LEAN HOGS - CHICAGO MERCANTILE EXCHANGE  054642 HE x x
 56 LIVE CATTLE - CHICAGO MERCANTILE EXCHANGE  057642 LC x x
 57 RANDOM LENGTH LUMBER - CHICAGO MERCANTILE EXCHANGE  058643 LB   x
 58 FEEDER CATTLE - CHICAGO MERCANTILE EXCHANGE  061641 FC x x
 59 PJM ELECTRICITY MONTHLY - NEW YORK MERCANTILE EXCHANGE  064657     x
 60 ISO NEW ENGLAND LMP SWAP - NEW YORK MERCANTILE EXCHANGE  06465H      x
 61 PJM CAL MONTH OFF PK LMP SWAP - NEW YORK MERCANTILE EXCHANGE  06465M      x
 62 ISO NEW ENG OFF PK LMP SWAP - NEW YORK MERCANTILE EXCHANGE  06465S      x
 63 CINERGY CAL MONTH LMP SWAP - NEW YORK MERCANTILE EXCHANGE  064A01      x
 64 CINERGY OFF PEAK LMP SWAP - NEW YORK MERCANTILE EXCHANGE  064A02       
 65 PJM N ILL PEAK DAY AHEAD - NEW YORK MERCANTILE EXCHANGE  064A34      x
 66 PJM JCPL PEAK DAY AHEAD - NEW YORK MERCANTILE EXCHANGE  064A48      x
 67 PJM PEPCO PEAK DAY AHEAD - NEW YORK MERCANTILE EXCHANGE  064A50      x
 68 PJM PSEG PEAK DAY AHEAD - NEW YORK MERCANTILE EXCHANGE  064A54      x
 69 PJM WESTERN PEAK DAY AHEAD - NEW YORK MERCANTILE EXCHANGE  064A56       
 70 PJM WESTERN PEAK REAL TIME - NEW YORK MERCANTILE EXCHANGE  064A58      x
 71 PJM WESTERN OFF PEAK REAL TIME - NEW YORK MERCANTILE EXCHANGE  064A59      x
 72 ISO NEW ENG INT HUB PEAK SWAP - NEW YORK MERCANTILE EXCHANGE  064A60      x
 73 MW IND TRANS PEAK SWAP - NEW YORK MERCANTILE EXCHANGE  064A62      x
 74 NYISO ZONE 5 MW PEAK SWAP - NEW YORK MERCANTILE EXCHANGE  064A66       
 75 ISO NEW ENG HUB OFF PEAK SWAP - NEW YORK MERCANTILE EXCHANGE  064A78       
 76 MT BELVIEU PROPANE 5 DEC SWAP - NEW YORK MERCANTILE EXCHANGE  06665O       
 77 MT BELVIEU ETHANE 5 DEC SWAP - NEW YORK MERCANTILE EXCHANGE  06665P      x
 78 MT BELV NORM BUTANE 5 DEC SWAP - NEW YORK MERCANTILE EXCHANGE  06665Q      x
 79 MT BELV NAT GASOLINE 5 DEC SWP - NEW YORK MERCANTILE EXCHANGE  06665R      x
 80 CRUDE OIL LIGHT SWEET - ICE FUTURES EUROPE   LIGHT SWEET - ICE FUTURES EUROPE  067411     x
 81 CRUDE OIL, LIGHT SWEET - NEW YORK MERCANTILE EXCHANGE 067651 QM   x
 82 WTI CRUDE OIL CALENDAR SWAP - NEW YORK MERCANTILE EXCHANGE  06765A      x
 83 DUBAI CRUDE OIL CALENDAR SWAP - NEW YORK MERCANTILE EXCHANGE  06765G      x
 84 WTI CRUDE OIL FINANCIAL - NEW YORK MERCANTILE EXCHANGE  06765I      x
 85 BRENT FINANCIAL - NEW YORK MERCANTILE EXCHANGE  06765J      x
 86 BRENT (ICE) CALENDAR SWAP - NEW YORK MERCANTILE EXCHANGE  06765N      x
 87 BRENT-DUBAI SWAP - NEW YORK MERCANTILE EXCHANGE  06765O      x
 88 COCOA - ICE FUTURES U.S.  073732 CC x x
 89 PALLADIUM - NEW YORK MERCANTILE EXCHANGE  075651 PA   x
 90 PLATINUM - NEW YORK MERCANTILE EXCHANGE  076651 PL   x
 91 SUGAR NO. 11 - ICE FUTURES U.S.  080732 SB x x
 92 COFFEE C - ICE FUTURES U.S.  083731 KC x x
 93 SILVER - COMMODITY EXCHANGE INC.  084691 SI,XAGUSD,ZI   x
 94 COPPER-GRADE #1 - COMMODITY EXCHANGE INC.  085692 HG   x
 95 GOLD - COMMODITY EXCHANGE INC.  088691 GC,GOLD,XAUUSD   x
 96 RUSSIAN RUBLE - CHICAGO MERCANTILE EXCHANGE  089741 USDRUB,USDRUR    
 97 CANADIAN DOLLAR - CHICAGO MERCANTILE EXCHANGE  090741 6C,USDCAD    
 98 SWISS FRANC - CHICAGO MERCANTILE EXCHANGE  092741 6S,USDCHF    
 99 MEXICAN PESO - CHICAGO MERCANTILE EXCHANGE  095741      
 100 BRITISH POUND STERLING - CHICAGO MERCANTILE EXCHANGE  096742 6B,GBPUSD    
 101 JAPANESE YEN - CHICAGO MERCANTILE EXCHANGE  097741 6J,USDJPY    
 102 U.S. DOLLAR INDEX - ICE FUTURES U.S.  098662 DX    
 103 EURO FX - CHICAGO MERCANTILE EXCHANGE 099741 6E,EURUSD    
 104 GASOLINE BLENDSTOCK (RBOB) - NEW YORK MERCANTILE EXCHANGE  111659 XRB   x
 105 RBOB CALENDAR SWAP - NEW YORK MERCANTILE EXCHANGE  11165K      x
 106 NEW ZEALAND DOLLAR - CHICAGO MERCANTILE EXCHANGE  112741 6N,NZDUSD    
 107 VIX FUTURES - CBOE FUTURES EXCHANGE  011700      
 108 DOW JONES INDUSTRIAL AVERAGE - CHICAGO BOARD OF TRADE  124601      
 109 3-MONTH EURODOLLARS - CHICAGO MERCANTILE EXCHANGE  132741      
 110 S&P 500 STOCK INDEX - CHICAGO MERCANTILE EXCHANGE  138741      
 111 E-MINI S&P 500 STOCK INDEX - CHICAGO MERCANTILE EXCHANGE  13874A  ES,SPX    
 112 NASDAQ-100 STOCK INDEX - CHICAGO MERCANTILE EXCHANGE  209741 NQ    
 113 NASDAQ-100 STOCK INDEX (MINI) - CHICAGO MERCANTILE EXCHANGE  209742      
 114 DOW JONES UBS EXCESS RETURN - CHICAGO BOARD OF TRADE  221602      
 115 AUSTRALIAN DOLLAR - CHICAGO MERCANTILE EXCHANGE  232741 6A,AUDUSD    
 116 RUSSELL 2000 MINI INDEX FUTURE - ICE FUTURES U.S.  23977A       
 117 NIKKEI STOCK AVERAGE - CHICAGO MERCANTILE EXCHANGE  240741      
 118 NIKKEI STOCK AVERAGE YEN DENOM - CHICAGO MERCANTILE EXCHANGE  240743      
 119 E-MINI MSCI EAFE - CHICAGO MERCANTILE EXCHANGE  244741      
 120 E-MINI MSCI EMERGING MARKETS - CHICAGO MERCANTILE EXCHANGE  244742      
 121 INTEREST RATE SWAPS 10YR - CHICAGO BOARD OF TRADE  246602      
 122 INTEREST RATE SWAPS 5YR - CHICAGO BOARD OF TRADE  247602      
 123 S&P GSCI COMMODITY INDEX - CHICAGO MERCANTILE EXCHANGE  256741      
 124 SING JET KERO SWAP - NEW YORK MERCANTILE EXCHANGE  26265D       
 125 E-MINI S&P 400 STOCK INDEX - CHICAGO MERCANTILE EXCHANGE  33874A       
 126 GULF JET NY HEAT OIL SPR SWAP - NEW YORK MERCANTILE EXCHANGE  86465A      x
 127 SING JET KERO GASOIL SPR SWAP - NEW YORK MERCANTILE EXCHANGE  86465C      x
 128 JET CIF NWE/GASOIL FUT - NEW YORK MERCANTILE EXCHANGE  86465D      x
 129 GULF # 6 FUEL OIL CRACK SWAP - NEW YORK MERCANTILE EXCHANGE  86565A      x
 130 3.5% FUEL OIL RDAM CRACK SPR - NEW YORK MERCANTILE EXCHANGE  86565C      x
 131 NAPTHA CRACK SPR SWAP - NEW YORK MERCANTILE EXCHANGE  86665A      x
 132 GASOIL CRACK SPR SWAP - NEW YORK MERCANTILE EXCHANGE  86765C      x


Tabla 3. Lista de símbolos disponibles en los informes COT


Traducción del ruso hecha por MetaQuotes Software Corp.
Artículo original: https://www.mql5.com/ru/articles/34

Archivos adjuntos |
sources.zip (211.23 KB)
Implementación práctica de filtros digitales en MQL5 para principiantes Implementación práctica de filtros digitales en MQL5 para principiantes

La idea del filtrado de señales digitales ha sido ampliamente discutida en foros sobre el tema de la elaboración de sistemas de trading. Y sería imprudente no crear un código estándar de filtros digitales en MQL5. En este artículo el autor describe la transformación de código simple de indicadores SMA de su artículo "Indicadores personalizados en MQL5 para principiantes", en el código de un filtro digital más complejo y universal. Este artículo es consecuencia del artículo anterior. También trata sobre cómo reemplazar texto en el código y cómo corregir errores de programación.

Como exportar cotizaciones desde MetaTrader 5 a aplicaciones .NET usando los servicios de WCF Como exportar cotizaciones desde MetaTrader 5 a aplicaciones .NET usando los servicios de WCF

¿Quiere organizar la exportación de cotización desde MetaTrader 5 a su propia aplicación? ¡La compatibilidad entre MQL5 y DLL permite crear este tipo de soluciones! Este artículo le mostrará una de las formas de exportar cotizaciones desde MetaTrader 5 a aplicaciones escritas en .NET. Para mí, la exportación de cotizaciones usando esta plataforma fue más interesante, racional y fácil de implementar. Por desgracia, la versión 5 todavía no soporta .NET, por lo que, como en los viejos tiempos, usaremos win32 dell con .NET como capa intermedia.

Control de eventos en MQL5: cambiar el periodo de la media móvil sobre la marcha Control de eventos en MQL5: cambiar el periodo de la media móvil sobre la marcha

Supongamos que se aplica al gráfico un simple indicador de media móvil con periodo 13. Y queremos cambiar el periodo a 20, pero no queremos ir al cuadro de diálogo de las propiedades del indicador y cambiar el número 13 por el 20: simplemente porque estamos cansados de realizar estas acciones tan tediosas con el ratón y el teclado. Y especialmente no queremos abrir el código del indicador y modificarlo. Queremos hacer todo esto con solo pulsar un botón -"flecha arriba" junto al teclado numérico. En este artículo veremos cómo hacer esto.

Crear un indicador con opciones de control gráficas Crear un indicador con opciones de control gráficas

Aquellos que estén familiarizados con las emociones del mercado conocen el indicador MACD (su nombre completo es Moving Average Convergence/Divergence, Media Móvil Convergencia/Divergencia) - la poderosa herramienta para analizar el movimiento del precio usada por los operadores desde los primeros momentos en que aparecieron los métodos de análisis por computadora. En este artículo vamos a considerar las posibles modificaciones de MACD y a implementarlas en un indicador con la posibilidad de cambiar gráficamente entre las modificaciones.