Pegado de contrato de futuros en MetaTrader 5
1 098
0
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:
- 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.
- 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
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
- 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
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
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
Indicamos el 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
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
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"
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
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
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ímbolo | Comienzo de la circulación | Último día de circulación |
|---|---|---|
| UX-9.13 | 2013.03.15 | 2013.09.16 |
| UX-12.13 | 2013.06.17 | 2013.12.16 |
| UX-3.14 | 2013.09.16 | 2014.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
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":
- AMA (Adaptive Moving Average);
- BB (Bollinger Bands);
- Custom Moving Average;
- DEMA (Double Exponential Moving Average);
- FrAMA (Fractal Adaptive Moving Average);
- TEMA (Triple Exponential Moving Average).
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
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 Ltd.
Artículo original: https://www.mql5.com/ru/articles/802
Creación de filtros digitales sin retardo temporal
Cómo trabajar con el módem GSM de un experto de MQL5
SQL y MQL5: Trabajando con la base de datos SQLite
Indicador para la representación del gráfico "Renko"
- Aplicaciones de trading gratuitas
- 8 000+ señales para copiar
- Noticias económicas para analizar los mercados financieros
Usted acepta la política del sitio web y las condiciones de uso