Descargar MetaTrader 5

Pegado de contrato de futuros en MetaTrader 5

18 abril 2014, 10:22
Vladimir Karputov
0
558

Introducción

En MetaTrader 5 el usuario no puede utilizar sus propios gráficos, dado que el gráfico sólo puede representarse en base a los símbolos que suministra su bróker. En el caso de los futuros, el trader necesita para el análisis un instrumento sintético, un futuro contínuo, fruto del pegado. El problema es que semejante pagado lo lleva a cabo sólo el bróker, y eso significa que sólo el bróker decide si va a realizar el pegado conforme al símbolo dado o no.

Por fortuna, en el terminal se puede acceder a la historia de los futuros, cuya información de circulación ya ha expirado. Esto significa que utilizaremos la historia y la pegaremos por nosotros mismos en el terminal.


Requisitos adoptados:

  1. Todos los datos y cálculos, así como los dibujos y las capturas de pantalla en el artículo están basadas en valores reales de futuros en el índice de la bolsa ucraniana.
  2. Los fragmentos de código que hayan sido cambiados o añadidos se destacarán en color. Por ejemplo:
    //+------------------------------------------------------------------+
    //|                                             Este es un ejemplo   |
    //|                                            de código redactado   |
    //+------------------------------------------------------------------+

Primer problema: superposición de fechas

Los futuros colindantes comercian con superposición de fechas.

Es decir, cuando queden aproximadamente dos meses antes del último día de cumplimiento del futuro actual, comenzará a negociarse el siguiente futuro.

Dib. 1. Superposición de fechas de los futuros

Dib. 1. Superposición de fechas de los futuros

En el dibujo se puede ver que el 2013.09.16 es la fecha de comienzo de circulación del futuro siguiente UX-3.14, aunque en ese momento exista aún el futuro actual UX-12.13.


Segundo problema: eligiendo el tipo de pegado

El pegado tiene los siguientes tipos:

  • añadido simple para el instrumento actual ya ha llegado la fecha final de circulación, y a partir de la barra próxima comenzará el instrumento siguiente. Al añadir de manera simple un precio en el gráfico, se corresponderán exactamente en sus valores históricos, pero en el lugar de transición de un instrumento a otro siempre se producirá una brecha entre los precios. Es decir, el gráfico no estará suavizado en el lugar de la transición. 

Dib. 2. Pegado. Añadido simple.

Dib. 2. Pegado. Añadido simple

  • añadido con desplazamiento: al instrumento actual le quedan de 5 a 10 días hasta la fecha final de circulación, y nosotros comenzamos a sustituir estas 5-10 barras por barras del instrumento siguiente. Este intervalo de 5-10 barras se conocerá como periodo de transición. Al producirse el añadido con desplazamiento, durante el periodo de transición los precios serán incorrectos (es decir, no se corresponderán con el instrumento actual), pero el gráfico, sin embargo, resultará más suavizado en comparación con el método del «añadido simple».

Dib. 3. Pegado. Añadido con desplazamiento

Dib. 3. Pegado. Añadido con desplazamiento


Ajustes necesarios en el terminal

En la ventana «Observación del mercado» se deben distribuir los futuros en orden decreciente:

Dib. 4. Observación del mercado
 Dib. 4. Observación del mercado


Creamos un indicador

Por defecto, el indicador debe encontrarse en la carpeta terminal_data_folder\MQL5\Indicators. Para no "ensuciar" la carpeta ...\Indicators de la Biblioteca estándar y para que, en lo sucesivo, sea más cómoda la sicronización de nuestros propios indicadores con la ayuda de MQL5 Storage, creamos en el directorio ...\Indicators nuestra propia carpeta MyIndicators y dentro de ella la carpeta Synthetics. La ruta final hasta la carpeta tendrá el aspecto siguiente: terminal_data_folder\MQL5\Indicators\MyIndicators\Synthetics.

En la carpeta Synthetics creamos un archivo nuevo:

Dib. 5. Creamos el nuevo archivo del indicador

Dib. 5. Creamos el nuevo archivo del indicador

Indicamos el tipo del nuevo archivo - "Indicador personalizado":

Dib. 6. Tipo del nuevo archivo - "Indicador personalizado"

Dib. 6. Tipo del nuevo archivo - "Indicador personalizado"

Después de elegir el tipo del nuevo archivo, hay que pulsar "Siguiente" y se abrirá la ventana "Ajustes generales del indicador personalizado". En esta ventana hay que introducir el nombre del indicador - "SYNT", y además añadir dos parámetros. El primer parámetro es: "Cantidad de futuros a pegar" y determina la cantidad de instrumentos que se va a pegar. Es de notar que el valor mínimo posible del parámetro "Cantidad de futuros a pegar" es igual a 2. El segundo parámetro es: "Tipo de pegado" y determina el tipo de pegado por defecto en el indicador - "añadido simple":

Dib. 7. Parámetros del indicador personalizado

Dib. 7. Parámetros del indicador personalizado

Preste atención al hecho de que en el parámetro "tipo de pegado", el tipo de pegado puede ser "añadido simple" o "añadido con desplazamiento". Pero en esta etapa del añadido de parámetros no podemos agregar estos dos tipos de pegado de golpe. Por eso dejamos el "añadido simple" por defecto. Más tarde implementaremos la posibilidad de ver una lista desplegable de los tipos de pegado en las propiedades del indicador, cuando escribamos el código del indicador "SYNT".

En la ventana siguiente elegimos el operador informático de los eventos para el indicador:

Dib. 8. Operador informático de los eventos para el indicador

Dib. 8. Operador informático de los eventos para el indicador

Nótese que en el indicador "SYNT" se usará la función OnTimer() En OnTimer() se organizará la funcional principal del indicador. El indicador se podrá ajustar tanto al gráfico del símbolo conforme al cual el comercio se ha interrumpido (propiamente, sobre dicho símbolo no se darán eventos OnCalculate), como al gráfico del símbolo conforme al cual el comercio está activo.

Pulsamos "Siguiente" en la ventana "Parámetros de respresentación del indicador personalizado" y ponemos el aspa "Indicador en una ventana por separado":

Dib. 9. Elegir la opción del "indicador en una ventana por separado"

Dib. 9. Elegir la opción del "indicador en una ventana por separado"

Pulsamos el botón "Listo" y aparecerá el modelo en bruto del indicador "SYNT".


Organización de la lista desplegable del tipo de pegado

Para que la lista de los tipos de pegado se pueda ver en forma de lista desplegable, en los parámetros del indicador hay que declarar la enumeración  ENUM_GLUING_TYPE.

La enumeración indicada la declaramos como zona global al comienzo del bloque de los parámetros de entrada:

#property indicator_separate_window
//+------------------------------------------------------------------+
//|  enumeración de los métodos de pegadura                          |
//+------------------------------------------------------------------+
enum ENUM_GLUING_TYPE
  {
   simple_addition,        // añadido simple||simple addition
   addition_with_shift     // añadido con desplazamiento||addition with shift
  };  
//--- input parameters || parámetros de entrada
input ENUM_GLUING_TYPE  gluing_type=simple_addition;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+

Ahora podemos comprobar cómo aparece la lista desplegable.

Hay que compilar el archivo del indicador (F7). Ahora, cuando fijemos el indicador, en los parámetros podremos ver que la lista desplegable funciona:

Dib. 10. Ahora tenemos una lista desplegable en los parámetros

Dib. 10. Ahora tenemos una lista desplegable en los parámetros
 

Añadimos la descripción del indicador, que estará visible en la pestaña "General", en la primera unión del indicador al gráfico o al cambiar las porpiedades del indicador:

#property version   "1.00"
//+------------------------------------------------------------------+
//| version   "1.00": Adición de la historia según el temporizador   |
//+------------------------------------------------------------------+
#property description "Indicador para el pegado de varios futuros."
#property description "Se dibuja en una ventana por separado del futuro más reciente."
#property description "Para el dibujado utiliza N primeros símbolos"
#property description "tomados de la ventana \"Observación del mercado\"."

#property indicator_separate_window 

Estilo de representación del indicador - DRAW_COLOR_CANDLES - velas de colores diversos.

Para este estilo son necesarios 4 indicadores de búfer y 1 búfer para el almacenamiento del índice del color. Estilo de la línea del indicador - STYLE_SOLID - línea continua. Representamos todo esto en el código del indicador:

#property description "tomados de la ventana \"Observación del mercado\"."

//--- indicator settings || ajustes del indicador
#property indicator_separate_window
#property indicator_buffers 5 
#property indicator_plots   1
//--- plot Bars || dibujado de las barras
#property indicator_label1    "SYNT"
#property indicator_type1     DRAW_COLOR_CANDLES
#property indicator_style1    STYLE_SOLID
#property indicator_width1    1
//+------------------------------------------------------------------+
//|  enumeración de los métodos de pegado                            |
//+------------------------------------------------------------------+

Introducimos el parámetro de entrada "numder_futures_gluing" - cantidad de instrumentos a construir. El valor "numder_futures_gluing" es, por defecto, igual a 2:

//--- input parameters || parámetros de entrada
input int               numder_futures_gluing=2;
input ENUM_GLUING_TYPE  gluing_type=simple_addition;

Declaramos 4 indicadores de búfer y 1 búfer para el almacenamiento del índice del color, así como la matriz auxiliar LoadHistory[]:

#property indicator_style1    STYLE_SOLID
#property indicator_width1    1
//--- indicator buffers || búfers de indicador
double            OpenBuffer[];
double            HighBuffer[];
double            LowBuffer[];
double            CloseBuffer[];
double            ColorCandlesColors[];
double            LoadHistory[];
//+------------------------------------------------------------------+
//|  enumeración de los métodos de pegadura                          |
//+------------------------------------------------------------------+

Unimos los búfers de indicador con las matrices dinámicas unidimensionales, además, para las matrices establecemos una indexación como en las series tamporales:

//--- indicator buffers mapping
//--- unión de los búfers de indicador
   SetIndexBuffer(0,OpenBuffer,INDICATOR_DATA);
   SetIndexBuffer(1,HighBuffer,INDICATOR_DATA);
   SetIndexBuffer(2,LowBuffer,INDICATOR_DATA);
   SetIndexBuffer(3,CloseBuffer,INDICATOR_DATA);
   SetIndexBuffer(4,ColorCandlesColors,INDICATOR_COLOR_INDEX);
   SetIndexBuffer(5,LoadHistory,INDICATOR_CALCULATIONS);
//--- set buffer indexing as timeseries
//--- establecemos la indexación para el búfer como en la serie temporal
   ArraySetAsSeries(OpenBuffer,true);
   ArraySetAsSeries(HighBuffer,true);
   ArraySetAsSeries(LowBuffer,true);
   ArraySetAsSeries(CloseBuffer,true);
   ArraySetAsSeries(ColorCandlesColors,true);
//---
   return(INIT_SUCCEEDED);

Para representar los nombres de las series indicadoras ("Open", "High", "Low" y "Close") en la ventana "Ventana de datos" es necesaria la variable s_symbol:

input int               numder_futures_gluing=2;
input ENUM_GLUING_TYPE  gluing_type=simple_addition;
//--- symbol name
string s_symbol;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+

Para que el indicador funcione será necesaria la variable shft_array y las dos banderas good_history y indicator_rendered:

input ENUM_GLUING_TYPE  gluing_type=simple_addition;
//--- symbol name
string   s_symbol;
int      shift_array=0;
bool     good_history=false;        // la historia no está preparada||history not prepared
bool     indicator_rendered=false;  // el indicador no está dibujado
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+

A continuación vienen los ajustes del indicador y la unión del índice del búfer que contiene el color del dibujado, con un color determinado:

   ArraySetAsSeries(CloseBuffer,true);
   ArraySetAsSeries(ColorCandlesColors,true);
//--- set accuracy || precisión de la representación de los valores del indicador
   IndicatorSetInteger(INDICATOR_DIGITS,0);
//--- set drawing line empty value || valor vacío para la representación, para el que no existe dibujado
   PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0.0);
//--- set labels for the line || nombre para la representación en la ventana DataWindow
   PlotIndexSetString(0,PLOT_LABEL,s_symbol+" Open;"+s_symbol+" High;"+s_symbol+" Low;"+s_symbol+" Close");
   IndicatorSetString(INDICATOR_SHORTNAME,"SYNT");
//--- set number of colors in color buffer || número de colores en el búfer
   PlotIndexSetInteger(0,PLOT_COLOR_INDEXES,9);
//--- set line color || introducir el color de la línea
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,0,clrBlue);
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,1,clrOrange);
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,2,clrRed);
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,3,clrGreen);
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,4,clrPink);
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,5,clrIndigo);
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,6,clrPaleVioletRed);
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,7,clrDarkViolet);
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,8,clrDimGray);
//---
   return(INIT_SUCCEEDED);

De igual manera, a la función de inicialización OnInit() le añadimos la inicialización de un temporizador con un intervalo de 3 segundos y la inicialización de un generador de números al azar:

   PlotIndexSetInteger(0,PLOT_LINE_COLOR,7,clrDarkViolet);
   PlotIndexSetInteger(0,PLOT_LINE_COLOR,8,clrDimGray);
//---
   EventSetTimer(3);
//--- inicializamos un generador de números al azar
   MathSrand(GetTickCount());
//---
   return(INIT_SUCCEEDED);

Para la operación de pegado son necesarios, como mínimo, dos símbolos.

En la función OnCalculate() comprobamos la cantidad de instrumentos que participan en el pegado:

                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
//--- checking the number of instruments || comprobando del número de instrumentos
   if(numder_futures_gluing<=1)
     {
      //--- formamos la línea del mensaje
      string comm=StringFormat("Para que el indicador funcione es necesario elegir no menos de %d símbolos",numder_futures_gluing);
      //--- representamos el mensaje en los comentarios en la ventana principal del gráfico
      Comment(comm);
      return(0);
     }
//--- return value of prev_calculated for next call
   return(rates_total);

Tras comprobar que el número de símbolos es suficiente para realizar el pegado, comprobamos si el indicador ya ha sido dibujado. Si el indicador ya ha sido dibujado, significa que deOnCalculate() puede salir:

      Comment(comm);
      return(0);
     }
   if(indicator_rendered==true) return(rates_total);
//--- return value of prev_calculated for next call
   return(rates_total);

Dado que el indicador "SYNT" se usa mayormente para analizar el desarrollo de la tendencia de las barras diurnas, considero que no es necesario el recuento en cada tick. Es decir, el indicador "SYNT" no será recalculado en cada tick.

Lo que es más, sólo se recalculará el indicador en los casos siguientes:

  • si es la primera vez que se inicia el indicador;
  • si ha tenido lugar algún cambio en la historia (por ejemplo, si se ha producido una adición en la historia).
   if(indicator_rendered==true) return(rates_total);
//--- es el primer inicio de cáculos de nuestro indicador
//--- si es necesario calcular el indicador para dos o más barras (significa que algo ha cambiado en la historia)
//--- recordemos que la barra número "0" es la que está más a la izquierda
   if(prev_calculated==0 || rates_total>prev_calculated+1)
     {
     }
//--- return value of prev_calculated for next call
   return(rates_total);


Inicialización forzosa de los búfers de indicador

Los búfers de indicador del indicador "SYNT" son matrices dinámicas unidas.

Cuando iniciemos por primera vez el indicador, estos búfers deberán ser inicializados obligatoriamente de manera forzosa. La inicialización se debe llevar a cabo en  OnCalculate(). ¿Por qué en OnCalculate(), y no en OnInit? La aclaración la tenemos en el dibujo de más abajo:


Dib. 11. Por qué la inicialización de la matriz tiene lugar precisamente en OnCalculate()

Como se puede ver en el dib.11, el evento OnCalculate() tendrá lugar en cualquiera de los casos en que el evento OnInit() no suceda al ejecutar el comando "actualizar" para actualizar el gráfico. Por eso, la actualización de matrices la realizaremos en OnCalculate():

//--- recordemos que la barra número "0" es la que está más a la izquierda
   if(prev_calculated==0 || rates_total>prev_calculated+1)
     {
      //--- inicializamos las matrices
      ArrayInitialize(OpenBuffer,0);
      ArrayInitialize(HighBuffer,0);
      ArrayInitialize(LowBuffer,0);
      ArrayInitialize(CloseBuffer,0);
     }
//--- return value of prev_calculated for next call
   return(rates_total);

La función  ArrayInitialize() lleva a cabo la inicialización del búfer indicador. En este caso la inicialización tiene lugar con ceros.

Si se intenta inicializar el búfer indicador con el valor EMPTY_VALUE en el indicador "SYNT" no será posible colocar indicadores.


Algoritmo del añadido simple

Dib. 12. Algoritmo del añadido simple

Dib. 12. Algoritmo del añadido simple

 

Las fechas en el dibujo son las fechas del inicio de la circulación y del último día de circulación para los futuros UX-9.13, UX-12.13 y UX-3.14. Aquí tenemos los mismos datos en forma de recuadro:

SímboloComienzo de la circulaciónÚltimo día de circulación
UX-9.132013.03.152013.09.16
UX-12.132013.06.172013.12.16
UX-3.142013.09.162014.03.17

 

En el dib. 10, la fecha 2013.12.25 - es la fecha real en el calendario. Es decir, el símbolo UX-3.14 todavía no está activo.

El método de pegado "Añadido simple" se implementará en la función SimpleAddition:

//+------------------------------------------------------------------+
//| Timer function                                                   |
//+------------------------------------------------------------------+
void OnTimer()
  {
//---
  }
//+------------------------------------------------------------------+
//| Simple addition                                                  |
//| Añadido simple. A la matriz de indicador le añadimos sólo        |
//| el símbolo sibmUP                                                |
//+------------------------------------------------------------------+
bool SimpleAddition(string simbUP,string simbDOWN,ENUM_TIMEFRAMES period,int Color)
  {
  }
//+------------------------------------------------------------------+

simbUP y simbDOWN - son los futuros ubicados en la ventana "Observación del mercado", más arriba y más abajo, respectivamente. Color - es el color con el que se dibujará el futuro. 

El código completo de la función SimpleAddition() se muestra más abajo:

//+------------------------------------------------------------------+
//| Simple addition                                                  |
//| Añadido simple. A la matriz de indicador le añadimos sólo        |
//| el símbolo sibmUP                                                |
//+------------------------------------------------------------------+
bool SimpleAddition(string simbUP,string simbDOWN,ENUM_TIMEFRAMES period,int Color)//////
  {
   datetime expiration_time_UP;     // fecha de expiración del símbolo simbUP
   datetime expiration_time_DOWN;   // fecha de expiración del símbolo simbDOWN

   expiration_time_UP=int(SymbolInfoInteger(simbUP,SYMBOL_EXPIRATION_TIME));
   if(expiration_time_UP>TimeLocal())
     {
      expiration_time_UP=TimeLocal();
     }
   if(simbDOWN!="")
     {
      expiration_time_DOWN=int(SymbolInfoInteger(simbDOWN,SYMBOL_EXPIRATION_TIME));
     }
   else
     {
      expiration_time_DOWN=int(SymbolInfoInteger(simbUP,SYMBOL_START_TIME));
     }
//--- copiaremos en la matriz rates[] los precios Open, High, Low y Close
   MqlRates rates[];
   ArraySetAsSeries(rates,true);
   int copied=0;           //--- cuánto se ha copiado
   copied=CopyRates(simbUP,period,expiration_time_DOWN,expiration_time_UP,rates);
   if(copied>0)
     {
      for(int j=shift_array;j<shift_array+copied;j++)
        {
         //--- grabamos los precios en los búfers
         OpenBuffer[j]=rates[j-shift_array].open;
         HighBuffer[j]=rates[j-shift_array].high;
         LowBuffer[j]=rates[j-shift_array].low;
         CloseBuffer[j]=rates[j-shift_array].close;
         ColorCandlesColors[j]=Color;
        }
      shift_array=shift_array+copied;
      indicator_rendered=true;
      ChartRedraw();
     }
   else
     {
      Print("No se ha logrado obtener los datos históricos sobre el símbolo ",simbUP);
      indicator_rendered=false;
      return(false);
     }
//---  Simple addition end
   return(true);
  }
//+------------------------------------------------------------------+


Algoritmo del añadido con desplazamiento


Dib. 13. Algoritmo de pegado - añadido con desplazamiento

Dib. 13. Algoritmo de pegado - añadido con desplazamiento 

La diferencia más importante con el algoritmo de añadido simple es que el pegado comienza 10 días antes del último día de circulación del símbolo. El método de pegadura "Añadido con desplazamiento" será implementado en la función AdditionWithShift():

//--- Simple addition end
   return(true);
  }
//+------------------------------------------------------------------+
//| Addition With Shift                                              |
//| Añadido con desplazamiento. A la matriz de indicador             |
//| le añadimos sólo el símbolo sibmUP                               |
//+------------------------------------------------------------------+
bool AdditionWithShift(string simbUP,string simbDOWN,ENUM_TIMEFRAMES period,int Color)
  {
//--- 
   return(true);
  }
//+------------------------------------------------------------------+

La función  AdditionWithShift() se diferencia sólo de la función SimpleAddition() en dos líneas - de las fechas se quitan 10 días:

   .
   .
   .
   expiration_time_UP=int(SymbolInfoInteger(simbUP,SYMBOL_EXPIRATION_TIME))-86400*10;
   .
   .
   .
   expiration_time_DOWN=int(SymbolInfoInteger(simbDOWN,SYMBOL_EXPIRATION_TIME))-86400*10;
   .
   .
   .

Con una diferencia tan pequeña en el código, no tiene sentido que muestre el código completo de la función AdditionWithShift(), el código se puede ver en el archivo del indicador al final del artículo.

A pesar de la pequeña diferencia existente en el código de las funciones AdditionWithShift() y SimpleAddition(), es mejor no unirlas en una función universal (en el caso de que se introduzcan más tarde cambios en el algoritmo, por ejemplo, introducciones de comprobaciones).


Carga preliminar de la historia sobre un símbolo

La función CheckLoadHistory() efectúa la copia de toda la historia sobre un símbolo en el búfer auxiliar tmp_rates.

Si se copia con éxito, a la bandera good_history se le asigna el valor true - esto significa que ahora se puede dibujar el indicador:

//--- Addition With Shift end
   return(true);
  }
//+------------------------------------------------------------------+
//| Request to receive all history from a trade server               |
//| Obtener toda la historia desde el servidor comercial             |
//+------------------------------------------------------------------+
bool CheckLoadHistory(string symbol,ENUM_TIMEFRAMES period)
  {
   MqlRates tmp_rates[];      // copiaremos en la matriz rates[] los precios Open, High, Low y Close
   datetime start_time;       // fecha de comienzo del comercio con el instrumento
   datetime expiration_time;  // fecha de finalización del comercio con el instrumento
   start_time=int(SymbolInfoInteger(symbol,SYMBOL_START_TIME));
   expiration_time=int(SymbolInfoInteger(symbol,SYMBOL_EXPIRATION_TIME));
   if(CopyRates(symbol,period,start_time,expiration_time,tmp_rates)>0)
     {
      good_history=true;
     }
   else
     {
      good_history=false;
     }
//--- 
   return(true);
  }
//+------------------------------------------------------------------+

En este caso, la copia de toda la historia sobre un símbolo es permisible, dado que los futuros tienen un periodo de circulación relativamente breve, y la copia de toda la historia no conllevará un gasto excesivo de memoria.


OnTimer - es la función principal del indicador

Ahora que ya tenemos un código para los dos tipos de pegado y el código de carga preliminar de la historia, podemos cambiar la función OnTimer():

//+------------------------------------------------------------------+
//| Timer function                                                   |
//+------------------------------------------------------------------+
void OnTimer()
  {
   if(indicator_rendered==true) return;
   if(good_history==true)
     {
      int t=0;       // color || color
      int number;
      switch(gluing_type)
        {
         case simple_addition:
            for(int n=0;n<numder_futures_gluing;n++)
              {
               //--- obtenemos número al azar
               number=MathRand();
               //--- obtenemos el índice del color, como resto de la división entera
               t=number%(PlotIndexGetInteger(0,PLOT_COLOR_INDEXES)-1);
               SimpleAddition(SymbolName(n,true),SymbolName(n+1,true),PERIOD_D1,t);
              }
            break;
         case addition_with_shift:
            for(int n=0;n<numder_futures_gluing;n++)
              {
               //--- obtenemos número al azar
               number=MathRand();
               //--- obtenemos el índice del color, como resto de la división entera
               t=number%(PlotIndexGetInteger(0,PLOT_COLOR_INDEXES)-1);
               AdditionWithShift(SymbolName(n,true),SymbolName(n+1,true),PERIOD_D1,t);
              }
            break;
        }
     }
   else
     {
      for(int n=0;n<numder_futures_gluing;n++)
        {
         CheckLoadHistory(SymbolName(n,true),PERIOD_D1);
        }
     }
  }
//+------------------------------------------------------------------+

La idea principal del indicador ha sido implementada. Podemos hacer la compilación y fijarla al gráifico. Será mejor elegir un símbolo según el cual el comercio ya se haya cerrado, y establecer un periodo H1.


Resultados preliminares del funcionamiento del indicador "SYNT"

Tras fijar al gráfico dos ejemplares del indicador "SYNT" con variantes diferentes del tipo de pegado, se pueden comparar de manera visual los dos métodos de pegado:


  Dib. 14. Comparación de los métodos de pegado de futuros


Posibilidad de colocar sobre el indicador otros indicadores (de tipo estándar o personalizados)

Al indicador "SYNT" se le pueden fijar indicadores personalizados, que tienen la primera forma de la llamada OnCalculate:

int OnCalculate (const int rates_total,      // tamaño de la matriz price[]
                 const int prev_calculated,  // barras procesadas en la llamada anterior
                 const int begin,            // a partir de dónde comienzan los datos significativos
                 const double& price[]       // matriz para el cálculo
   );

Para ello, en la ventana del "Navegador" se abre la lista de "Indicadores personalizados", y después se despliega la lista "Examples" en la cual se debe elegir un indicador para, a continuación, trasladarlo a "SYNT". Acto seguido, en la pestaña "Parámetros" en la lista desplegable se debe elegir aplicar los "Datos del indicador anterior". 

Lista de indicadores que se pueden aplicar sobre el indicador "SYNT", y que funcionan correctamente en el indicador "SYNT":

Ejemplo del indicador "SYNT", que incluye tres futuros pegados, con el indicador Custom Moving Average fijado sobre é:

Dib. 15. Ejemplo de pegado de tres símbolos

Dib. 15. Ejemplo de pegado de tres símbolos


Conclusión

En los intervalos diurnos de los futuros, ahora ya es más cómodo llevar a cabo un análisis del movimiento anterior de símbolos más antiguos. Aunque en el gráfico pegado se puede aplicar una cantidad limitada de indicadores técnicos, este instrumento permite ver de manera más ilustrativa la dinámica de los precios en varios futuros consecutivos.


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

Archivos adjuntos |
synt.mq5 (24.66 KB)
Cómo trabajar con el módem GSM de un experto de MQL5 Cómo trabajar con el módem GSM de un experto de MQL5

En la actualidad existen medios suficientes para monitorizar a distancia una cuenta comercial, con toda comodidad: con la ayuda de los terminales móviles, las notificaciones push y el trabajo con ICQ. Pero para todo ello se debe tener conexión a internet. Este artículo describe la creación un experto que les permitirá mantenerse en contacto con su terminal comercial, incluso en el caso de que el internet móvil no está disponible, más concretamente con ayuda de llamadas y mensajes SMS.

Indicador para la representación del gráfico "Renko" Indicador para la representación del gráfico "Renko"

En el artículo vamos a hablar del gráfico "Renko" y mostraremos una de las variantes de su realización en el lenguaje MQL5, en forma de indicador. El indicador tiene multitud de modificaciones que lo distinguen del gráfico clásico. La representación se realiza no sólo en la ventana del indicador, sino también el gráfico principal. Además, se ve realizada la representación del indicador en forma de línea en "ZigZag". Les mostraremos, igualmente, varios ejemplos de estrategias de trabajo con el gráfico.

Creación de filtros digitales sin retardo temporal Creación de filtros digitales sin retardo temporal

En el presente artículo se estudia una de las aproximaciones para determinar la utilidad de una señal (tendencia) de flujo de datos. Algunos tests para el filtrado (suavización) de las cotizaciones de la bolsa, bastante útiles, demuestran la posibilidad potencial de crear filtros digitales (indicadores) que no sufran retrasos temporales y no se redibujen en las últimas barras.

SQL y MQL5: Trabajando con la base de datos SQLite SQL y MQL5: Trabajando con la base de datos SQLite

El presente artículo va dirigido a programadores a los que les interesa el uso de SQL en sus proyectos. En el mismo, presentamos a los lectores la funcionalidad de SQLite y sus ventajas. El artículo no exige de conocimientos previos de SQLite, pero si sería de agradecer un conocimiento mínimo de SQL.