Aprendiendo a diseñar un sistema comercial con Gator Oscillator
425
0
Introducción
Para estudiar con detalle el indicador, dividiremos el trabajo en varios subapartados:
- Definición del indicador Gator Oscillator
- Estrategia del oscilador Gator
- Esquemas de estrategias comerciales basadas en el indicador Gator Oscillator
- Sistemas comerciales con Gator Oscillator
- Conclusión
Para escribir los códigos en este artículo, utilizaremos el lenguaje de programación MQL5 (MetaQuotes Language) integrado en la plataforma comercial MetaTrader 5, así como la propia plataforma para probar las estrategias resultantes. Si no sabe cómo descargar o usar MetaTrader 5 y el entorno de desarrollo MQL5, lea la sección "Escribiendo el código MQL5 en el MetaEditor" en uno de los artículos anteriores; todo se describe con detalle allí.
Atención, todas las estrategias de las que hablaremos en este artículo requieren pruebas y un desarrollo escrupuloso. Si desea continuar usando alguna estrategia, asegúrese de probarla para asegurarse de que le funcione. Después de todo, no existen cosas universales que resulten adecuadas para absolutamente todos. En cualquier caso, el propósito principal de este artículo es ilustrativo, solo analizaremos la esencia del indicador. También le recomendamos escribir todos los códigos de este artículo por su cuenta, porque es precisamente la práctica lo que le ayudará a desarrollar las habilidades de programación.
¡Atención! Toda la información del presente artículo se ofrece «tal cual», únicamente con fines ilustrativos, y no supone ningún tipo de recomendación. El artículo no garantiza ningún resultado en absoluto. Todo lo que ponga en práctica usando este artículo como base, lo hará bajo su propia cuenta y riesgo; el autor no garantiza resultado alguno.
Definición del indicador Gator Oscillator
En esta sección, veremos más de cerca el indicador Gator Oscillator para comprender el concepto detrás de este y aprender a usarlo de forma correcta y efectiva. El oscilador Gator fue desarrollado por Bill Williams. En esencia, debe determinar si el mercado se encuentra en una tendencia o se está moviendo en algún tipo de rango lateral, y si está en una tendencia, cuánto tiempo puede durar esta en términos de impulso. Esta información debe usarse para determinar cuándo entrar y salir de una transacción. Como todos entendemos, estas dos cosas son muy importantes en el trading. Gator Oscillator se basa en el indicador Alligator, que ya analizamos con detalle en un artículo anterior, Aprendiendo a diseñar un sistema de trading con Alligator.
El cálculo del indicador Gator se basa en la convergencia y divergencia de las líneas de balance de Alligator. A continuación, le mostramos el cálculo del indicador Gator:
- Paso uno: calculamos el precio medio
Median Price = (High + Low) /2
- Paso dos: calculamos las mandíbulas (Jaw), los dientes (Teeth) y los labios (Lips) del caimán
Alligator Jaw = SMMA (Median Price, 13,8)
Alligator Teeth = SMMA (Median Price, 8, 5)
Alligator Lips = SMMA (Median Price, 5, 3)
- donde:
Median Price — tipo de precio utilizado para los cálculos (mediana)
High — valor máximo del precio
Low — valor mínimo del precio
SMMA — media móvil suavizada que encuentra la media móvil de un precio con un suavizado específico y un posible desplazamiento. Si tenemos una media SMMA (Median Price, 13, 5), esto significará que hemos obtenido una media móvil suavizada de los precios medianos con un periodo de suavizado de 13 y un desplazamiento hacia adelante de 5.
Alligator Jaws — línea de la mandíbula del indicador, mostrada en azul
Alligator Teeth — línea de dientes de cocodrilo, de color rojo
Alligator Lips — línea de labios de cocodrilo, de color verde
Con todos estos datos, podremos calcular manualmente el valor del indicador Gator. Sin embargo, en la práctica, no necesitamos calcularlo manualmente, ya que ya existe un indicador listo para usar en el terminal comercial MetaTrader 5, y todo lo que debemos hacer es seleccionarlo de la lista.
Para ello, abrimos el terminal comercial MetaTrader 5, y seleccionamos el menú "Insertar" --> Indicadores --> Bill Williams --> Gator Oscillator
Después de seleccionar Gator Oscillator, se abrirá la ventana Gator Options como mostramos en la siguiente figura:
La figura anterior muestra la ventana de configuración del indicador Gator Oscillator, en la que podemos configurar los siguientes parámetros:
- El periodo de la línea de la mandíbula
- El desplazamiento horizontal de la línea de la mandíbula.
- El periodo de cálculo de la línea de dientes.
- El desplazamiento horizontal de la línea de los dientes.
- El periodo de cálculo de la línea de labios
- El desplazamiento horizontal de la línea de los labios
- El método de promediación
- El tipo de precio usado para calcular el indicador Gator Oscillator.
- El color para las lecturas ascendentes
- El color para las lecturas descendentes
- El grosor de las barras del indicador Gator.
Seleccionamos los parámetros necesarios del indicador, presionamos el botón OK y el indicador se iniciará en el gráfico como mostramos a continuación:
Como podemos ver en el gráfico anterior, ha aparecido una ventana indicadora adicional en la parte inferior, en la que se muestran los valores del oscilador Gator por encima y por debajo del nivel cero. El indicador consta de barras verdes y rojas que muestran la relación entre cada barra actual y la anterior: si la barra actual es superior a la anterior, el color será verde, si es inferior a la anterior, la barra actual será roja.
Estrategia del oscilador Gator
En esta sección, veremos algunas estrategias sencillas basadas en el rendimiento del indicador Gator Oscillator. Una vez más: analizaremos estas solo con fines ilustrativos. Resulta vital probar y optimizar cuidadosamente las estrategias antes de aplicarlas para comerciar.
Esta estrategia determinará el estado del Gator según las barras del indicador. En función de los colores de las barras, Gator puede tener cuatro estados. Si ambas barras son rojas en lados opuestos de la línea cero, significará que el caimán está dormido (fase de sueño del indicador Gator). Si ambas barras en lados opuestos de la línea cero son verdes, significará que el caimán está comiendo. Si los colores de las barras cambian de rojo a verde, significará que el caimán se está despertando. Si la barra cambia de color de verde a rojo, significará que el caimán se está saciando.
Así, tenemos que:
Ambas barras son rojas ==> Fase de sueño
Ambas barras son verdes ==> Fase de alimentación
Las barras inicialmente rojas se vuelven verdes ==> fase de despertar
Las barras inicialmente verdes se vuelven rojas ==> fase de saturación
Esta estrategia generará señales basadas en el rendimiento del indicador. Si el caimán está en la fase de despertar, nos llegará una señal para encontrar una buena entrada. Si el indicador está en la fase de comer, la estrategia generará una señal para mantener la posición actual. Si el indicador Gator está en la fase de saturación, deberemos encontrar una buena salida. En otras situaciones, no haremos nada.
Si lo miramos esquemáticamente:
Indicador Gator en fase de despertar ==> Oportunidades de entrada
Indicador Gator en la fase de alimentación ==> Mantendremos la posición actual
Indicador Gator en fase de saturación ==> Buscaremos una salida
Si el indicador está en cualquier otro estado ==> No haremos nada
Para esta estrategia, combinaremos la señal del indicador Gator con la señal de la media móvil. Si ambas barras son verdes y el precio de cierre es superior a la media móvil, esto será señal de una posible apertura de una transacción de compra. En caso contrario, si ambas barras del indicador Gator están de color rojo y el precio de cierre se encuentra por debajo del valor de la media móvil, se considerará una oportunidad de venta. Con cualquier otra lectura, no haremos nada.
Si lo miramos esquemáticamente:
Dos barras verdes y precio de cierre > media móvil ==> oportunidad de posición de compra
Dos barras rojas y precio de cierre < media móvil ==> oportunidad de posición de venta
Otras señales ==> no haremos nada
Esquemas de estrategias comerciales basadas en el indicador Gator Oscillator
En esta parte, crearemos esquemas paso a paso para las estrategias analizadas. En el siguiente paso, nos ayudarán a crear sistemas comerciales de manera eficiente y sencilla. A nuestro juicio, este paso es muy importante y necesario para el desarrollo de un sistema comercial, ya que, creando todos los pasos necesarios secuencialmente, sin omitir o repetir ninguno de ellos, ahorraremos mucho tiempo. Ahora necesitaremos definir claramente qué debe hacer la computadora para implementar nuestras ideas paso a paso.
Usando como base esta estrategia, crearemos un programa asesor que utilizaremos para verificar automáticamente los valores del indicador Gator en cada tick. El programa definirá dos estados: cuando los valores aumentan secuencialmente y cuando los valores descienden secuencialmente. El asesor realiza esta verificación y determina la posición de los valores comparándolos entre sí. Primero compara los valores más altos, los valores actuales y anteriores de Gator, y determina cuál de ellos es más alto. Luego compara los mínimos de las barras actuales y anteriores, determinando cuál de los dos es más alto. El resultado de tal comparación serán las señales esperadas para determinar el estado del indicador Gator.
Si el valor actual en la parte superior es inferior al anterior, y el valor actual en la parte inferior es superior al anterior, el asesor o el sistema comercial deberá retornar una señal de fase de sueño como comentario al gráfico. En la segunda opción, si el valor actual es superior al anterior y el valor actual es inferior al anterior, el asesor debería retornar una señal sobre la fase de alimentación en el indicador como un comentario en el gráfico. En el tercer caso, si el primer valor anterior ascendente es inferior al segundo anterior y el primer valor anterior descendente es superior al segundo anterior descendente y, al mismo tiempo, el valor actual ascendente es superior al primero anterior y el valor actual descendente es inferior al primero anterior, necesitaremos que el sistema comercial retorne un comentario en el gráfico con la señal de fase de despertar. En el cuarto y último estado, si el primer valor anterior ascendente es superior al segundo y el primer valor anterior descendente es inferior al segundo anterior y, al mismo tiempo, el valor actual ascendente es superior al primero anterior y el valor actual descendente es superior al primero anterior, necesitaremos que el sistema comercial retorne un comentario en el gráfico con una señal de fase de saturación.
A continuación, le mostramos un esquema con el funcionamiento de dicho sistema comercial:
Estrategia dos — señales de Gator
Según esta estrategia, crearemos un sistema comercial que se puede utilizar para generar señales para la posible entrada, salida o mantenimiento de una posición. Para hacer esto, el programa verificará constantemente los valores de tres barras consecutivas por arriba y por abajo para determinar la fase actual del indicador Gator.
La primera señal la obtendremos en el gráfico como comentario sobre la posibilidad de entrar en una posición cuando el asesor determine que el caimán está en fase de despertar.
El segundo tipo de señal se obtendrá en el gráfico como un comentario sobre la posibilidad de mantener la posición cuando el asesor determine que el caimán está en la fase de alimentación.
El tercer tipo de señal sobre una buena oportunidad para salir de la posición la obtendremos cuando el asesor determine que el caimán está en fase de saturación.
En cualquier otra situación salvo las tres anteriores, no será necesario realizar ninguna acción. Esquema paso a paso para desarrollar un sistema comercial utilizando esta estrategia:
Estrategia tres: Gator con MA
Con esta estrategia, obtendremos señales sobre la posibilidad de realizar una transacción de compra o venta según la fase del indicador Gator y la posición del precio de cierre respecto a la media móvil.
La primera señal sobre la posibilidad de entrar en una posición de compra la recibiremos cuando el asesor determine que el valor actual del indicador es superior al primero anterior, y el primer valor anterior es superior al segundo anterior, y al mismo tiempo el valor actual sea inferior al primero anterior, y el primer valor anterior sea inferior al segundo anterior: con esta formación, las barras serán verdes. El precio de cierre deberá estar por encima del valor de la media móvil.
La segunda señal sobre la posibilidad de entrar en una posición de venta la obtendremos cuando el asesor determine que el valor actual del indicador está por debajo del primero anterior, y el primero anterior está por debajo del segundo anterior, y al mismo tiempo, el valor actual ascendente sea mayor que el primero anterior, y el primer valor anterior sea mayor que el segundo anterior: con esta formación, las barras serán rojas. En este caso, el precio de cierre deberá estar por debajo del valor de la media móvil.
Si se ha formado cualquier otra situación, no tendremos señales. Esquema paso a paso para desarrollar un sistema comercial utilizando esta estrategia:
Sistemas comerciales con Gator Oscillator
Bien, ya hemos llegado a la parte más interesante del artículo. En esta, crearemos sistemas comerciales basados en las estrategias discutidas anteriormente. El propósito de dichos sistemas comerciales automatizados es servir de ayuda en el trading. Para empezar, escribiremos un programa simple que servirá como base para todos los demás sistemas:
un programa de oscilador Gator tan sencillo retornará los valores actuales del indicador como un comentario en el gráfico. Vamos a ver cómo escribir el código para dicho programa paso a paso.
Ahora, crearemos los arrays upGator y downGator usando la función double. El tipo double es un tipo real, un número de punto flotante, es decir, un valor con una parte fraccionaria.
double upGatorArray[]; double downGatorArray[];
Luego, estableceremos la clasificación de los datos en el array usando la función ArraySetAsSeries: Parámetros de la función:
ArraySetAsSeries(upGatorArray,true); ArraySetAsSeries(downGatorArray,true);
Luego crearemos la variable de tipo entero gatorDef, y definiremos el oscilador Gator usando la función iGator. La función retornará el identificador del indicador. Parámetros de la función:
- symbol — nombre del símbolo; nosotros tenemos _SYMBOL, es decir, calcularemos el indicador según el símbolo del gráfico actual.
- period — marco temporal para el cálculo; si usamos el valor _PERIOD, significará que el indicador se calculará en el marco temporal actual.
- jaw_period — periodo medio para calcular la línea de las mandíbulas, utilizaremos 13.
- jaw_shift — desplazamiento horizontal de la línea de la mandíbula, fuera es necesario. Estableceremos el valor en 8.
- teeth_period — periodo de cálculo de la línea de los dientes. Estableceremos el valor en 8.
- teeth_shift — desplazamiento horizontal de la línea de los dientes, si fuera necesario. Pondremos el valor en 5.
- lips_period — periodo de cálculo de la línea de los labios. Pondremos el valor en 5.
- lips_shift — establece el desplazamiento horizontal para la línea de los labios, en nuestro caso, 3.
- ma_method — método de suavizado de la media móvil. Usaremos MODE_SMMA.
- apply_price — tipo de precio usado en los cálculos. Estableceremos el valor PRICE_MEDIAN.
int gatorDef=iGator(_Symbol,_Period,13,8,8,5,5,3,MODE_SMMA,PRICE_MEDIAN);
A continuación, definiremos los datos y guardaremos los resultados usando la función CopyBuffer para upGatorArray y downGatorArray. Parámetros de la función:
- indicator_handle — identificador del indicador, gatorDef
- buffer_num — número de búfer de indicador, estableceremos 0 para upGator y 2 para downGator.
- start_pos — indica la posición para el inicio de los cálculos; estableceremos 0
- count — cantidad de datos a copiar; estableceremos 3.
- buffer[] — definiremos el array de precios para copiar, en nuestro caso, upGatorArray, downGatorArray.
CopyBuffer(gatorDef,0,0,3,upGatorArray); CopyBuffer(gatorDef,2,0,3,downGatorArray);
Luego obtendremos los valores de upGator y downGator en las variables de tipo double creadas para ellos. Luego usaremos la función NormalizeDouble para redondear.
- value — upGatorArray[0] valor actual.
- digits — número de dígitos decimales, 6.
double gatorUpValue=NormalizeDouble(upGatorArray[0],6); double gatorDownValue=NormalizeDouble(downGatorArray[0],6);
Después usaremos la función Comment para mostrar los valores actuales de upGator y downGator.
Comment("gatorUpValue = ",gatorUpValue,"\n", "gatorDownValue = ",gatorDownValue);
A continuación, le mostramos el código completo para crear la estrategia mencionada:
//+------------------------------------------------------------------+ //| Simple Gator Oscillator System.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ void OnTick() { double upGatorArray[]; double downGatorArray[]; ArraySetAsSeries(upGatorArray,true); ArraySetAsSeries(downGatorArray,true); int gatorDef=iGator(_Symbol,_Period,13,8,8,5,5,3,MODE_SMMA,PRICE_MEDIAN); CopyBuffer(gatorDef,0,0,3,upGatorArray); CopyBuffer(gatorDef,2,0,3,downGatorArray); double gatorUpValue=NormalizeDouble(upGatorArray[0],6); double gatorDownValue=NormalizeDouble(downGatorArray[0],6); Comment("gatorUpValue = ",gatorUpValue,"\n", "gatorDownValue = ",gatorDownValue); } //+------------------------------------------------------------------+
Después de escribir este código, deberemos compilarlo. Al realizar la compilación, deberemos asegurarnos de que no haya errores ni advertencias. A continuación, el programa compilado debería aparecer en el Navegador del terminal comercial:
Clicamos dos veces en el archivo o lo arrastramos y soltamos en el gráfico. Después de eso, aparecerá la ventana del asesor:
Asimismo, permitiremos el comercio automático (Allow Algo Trading), clique en OK y el programa se ejecutará en el gráfico como se muestra a continuación:
Ahora estamos listos para obtener las señales para esta estrategia. A continuación, le mostraremos algunos ejemplos de señales de prueba.
Estrategia uno — Gator Status
El código completo del sistema comercial basado en esta estrategia se muestra a continuación:
//+------------------------------------------------------------------+ //| Gator Status Identifier.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ void OnTick() { double upGatorArray[]; double downGatorArray[]; ArraySetAsSeries(upGatorArray,true); ArraySetAsSeries(downGatorArray,true); int gatorDef=iGator(_Symbol,_Period,13,8,8,5,5,3,MODE_SMMA,PRICE_MEDIAN); CopyBuffer(gatorDef,0,0,5,upGatorArray); CopyBuffer(gatorDef,2,0,5,downGatorArray); double gatorUpValue=NormalizeDouble(upGatorArray[0],6); double gatorUpPreValue1=NormalizeDouble(upGatorArray[1],6); double gatorUpPreValue2=NormalizeDouble(upGatorArray[2],6); double gatorDownValue=NormalizeDouble(downGatorArray[0],6); double gatorDownPreValue1=NormalizeDouble(downGatorArray[1],6); double gatorDownPreValue2=NormalizeDouble(downGatorArray[2],6); if(gatorUpValue<gatorUpPreValue1&&gatorDownValue>gatorDownPreValue1) { Comment("Sleeping Phase"); } else if(gatorUpValue>gatorUpPreValue1&&gatorDownValue<gatorDownPreValue1) { Comment("Eating Phase"); } if(gatorUpPreValue1<gatorUpPreValue2&&gatorDownPreValue1>gatorDownPreValue2&& gatorUpValue>gatorUpPreValue1&&gatorDownValue<gatorDownPreValue1) { Comment("Awakening Phase"); } else if( gatorUpPreValue1>gatorUpPreValue2&&gatorDownPreValue1<gatorDownPreValue2&& gatorUpValue<gatorUpPreValue1&&gatorDownValue>gatorDownPreValue1) { Comment("Sated Phase"); } } //+------------------------------------------------------------------+
Diferencias en este código:
Determinación y obtención de los últimos tres valores de UpGator
double gatorUpValue=NormalizeDouble(upGatorArray[0],6); double gatorUpPreValue1=NormalizeDouble(upGatorArray[1],6); double gatorUpPreValue2=NormalizeDouble(upGatorArray[2],6);
Determinación y obtención de los últimos tres valores de DownGator
double gatorDownValue=NormalizeDouble(downGatorArray[0],6); double gatorDownPreValue1=NormalizeDouble(downGatorArray[1],6); double gatorDownPreValue2=NormalizeDouble(downGatorArray[2],6);
Condiciones de la estrategia.
Condiciones para determinar la fase del sueño.
if(gatorUpValue<gatorUpPreValue1&&gatorDownValue>gatorDownPreValue1) { Comment("Sleeping Phase"); }
Condiciones para determinar la fase de comida.
else if(gatorUpValue>gatorUpPreValue1&&gatorDownValue<gatorDownPreValue1) { Comment("Eating Phase"); }
Condiciones para determinar la fase de despertar
if(gatorUpPreValue1<gatorUpPreValue2&&gatorDownPreValue1>gatorDownPreValue2&& gatorUpValue>gatorUpPreValue1&&gatorDownValue<gatorDownPreValue1) { Comment("Awakening Phase"); }
Condiciones para determinar la fase de saciedad
else if( gatorUpPreValue1>gatorUpPreValue2&&gatorDownPreValue1<gatorDownPreValue2&& gatorUpValue<gatorUpPreValue1&&gatorDownValue>gatorDownPreValue1) { Comment("Sated Phase"); }
Después de compilar el código y ejecutar el programa desde el Navegador, el asesor comenzará a funcionar en el gráfico:
Como podemos ver, ha aparecido una indicación en la esquina superior derecha del gráfico mostrando que el asesor experto Gator Status Identifier está funcionando en el gráfico.
Las señales del asesor se muestran de la forma siguiente (hemos obtenido ejemplos durante las pruebas).
Cocodrilo en la fase de sueño:
En la esquina superior izquierda del gráfico se representa un comentario que muestra que el indicador está en la fase de sueño.
El caimán está comiendo:
En la esquina superior izquierda del gráfico se representa un comentario informando de que el indicador está en la fase de alimentación:
Indicador Gator en la fase de despertar:
El gráfico muestra la señal de la fase de despertar de la estrategia Gator Status Identifier.
Indicador Gator en fase de saciedad:
El comentario en el gráfico muestra la fase de saturación.
El código completo del sistema comercial que opera según esta estrategia tiene el aspecto que sigue:
//+------------------------------------------------------------------+ //| Gator signals.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ void OnTick() { double upGatorArray[]; double downGatorArray[]; ArraySetAsSeries(upGatorArray,true); ArraySetAsSeries(downGatorArray,true); int gatorDef=iGator(_Symbol,_Period,13,8,8,5,5,3,MODE_SMMA,PRICE_MEDIAN); CopyBuffer(gatorDef,0,0,3,upGatorArray); CopyBuffer(gatorDef,2,0,3,downGatorArray); double gatorUpValue=NormalizeDouble(upGatorArray[0],6); double gatorUpPreValue1=NormalizeDouble(upGatorArray[1],6); double gatorUpPreValue2=NormalizeDouble(upGatorArray[2],6); double gatorDownValue=NormalizeDouble(downGatorArray[0],6); double gatorDownPreValue1=NormalizeDouble(downGatorArray[1],6); double gatorDownPreValue2=NormalizeDouble(downGatorArray[2],6); bool awakeningPhase = gatorUpPreValue1<gatorUpPreValue2&&gatorDownPreValue1>gatorDownPreValue2&& gatorUpValue>gatorUpPreValue1&&gatorDownValue<gatorDownPreValue1; bool eatingPhase = gatorUpValue>gatorUpPreValue1&&gatorDownValue<gatorDownPreValue1; bool satedPhase = gatorUpPreValue1>gatorUpPreValue2&&gatorDownPreValue1<gatorDownPreValue2&& gatorUpValue<gatorUpPreValue1&&gatorDownValue>gatorDownPreValue1; if(awakeningPhase) { Comment("Find a good entry"); } else if(eatingPhase) { Comment("Hold current position"); } else if(satedPhase) { Comment("Find a good exit"); } else Comment(""); } //+------------------------------------------------------------------+
Qué ha cambiado en el código con respecto al anterior:
Ahora crearemos una variable booleana para las tres posibles fases del caimán: fase de despertar, fase de alimentación y fase de saciedad;
bool awakeningPhase = gatorUpPreValue1<gatorUpPreValue2&&gatorDownPreValue1>gatorDownPreValue2&& gatorUpValue>gatorUpPreValue1&&gatorDownValue<gatorDownPreValue1; bool eatingPhase = gatorUpValue>gatorUpPreValue1&&gatorDownValue<gatorDownPreValue1; bool satedPhase = gatorUpPreValue1>gatorUpPreValue2&&gatorDownPreValue1<gatorDownPreValue2&& gatorUpValue<gatorUpPreValue1&&gatorDownValue>gatorDownPreValue1;
Condiciones de la estrategia.
En caso de la fase de despertar
if(awakeningPhase) { Comment("Find a good entry"); }
Cuando el caimán está comiendo
else if(eatingPhase) { Comment("Hold current position"); }
Indicador en la fase de saciedad
else if(satedPhase) { Comment("Find a good exit"); }
En los demás casos
else Comment("");
Después de compilar el código y ejecutar el programa desde la ventana del Navegador, el asesor comenzará a funcionar en el gráfico:
Como podemos ver, en la esquina superior derecha del gráfico, tenemos una indicación que muestra que el asesor experto está funcionando en el gráfico.
Esto significa que el asesor puede generar señales basadas en esta estrategia. A continuación, le mostraremos algunos ejemplos de señales de prueba.
En caso de la fase de despertar
En el gráfico anterior, el comentario sobre la entrada "Find a good entry" se muestra en la esquina superior izquierda.
Cuando el caimán está comiendo
En el gráfico anterior, en la esquina superior izquierda, se muestra un comentario sobre el mantenimiento de la posición "Hold current position".
Indicador en la fase de saciedad
En el gráfico anterior, en la esquina superior izquierda, se muestra un comentario sobre la salida de la posición "Find a good exit".
Estrategia tres: Gator con MA
El código completo del sistema comercial que opera según esta estrategia tiene el aspecto siguiente:
//+------------------------------------------------------------------+ //| Gator with MA strategy.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ void OnTick() { double upGatorArray[]; double downGatorArray[]; MqlRates pArray[]; double maArray[]; ArraySetAsSeries(upGatorArray,true); ArraySetAsSeries(downGatorArray,true); ArraySetAsSeries(maArray,true); int gatorDef=iGator(_Symbol,_Period,13,8,8,5,5,3,MODE_SMMA,PRICE_MEDIAN); int maDef=iMA(_Symbol,_Period,13,0,MODE_EMA,PRICE_CLOSE); int data=CopyRates(_Symbol,_Period,0,13,pArray); CopyBuffer(gatorDef,0,0,3,upGatorArray); CopyBuffer(gatorDef,2,0,3,downGatorArray); CopyBuffer(maDef,0,0,3,maArray); double gatorUpValue=NormalizeDouble(upGatorArray[0],6); double gatorUpPreValue1=NormalizeDouble(upGatorArray[1],6); double gatorUpPreValue2=NormalizeDouble(upGatorArray[2],6); double gatorDownValue=NormalizeDouble(downGatorArray[0],6); double gatorDownPreValue1=NormalizeDouble(downGatorArray[1],6); double gatorDownPreValue2=NormalizeDouble(downGatorArray[2],6); double maValue=NormalizeDouble(maArray[0],5); double closingPrice=pArray[0].close; bool douleGreen = gatorUpValue>gatorUpPreValue1&&gatorUpPreValue1>gatorUpPreValue2&& gatorDownValue<gatorDownPreValue1&&gatorDownPreValue1<gatorDownPreValue2; bool douleRed = gatorUpValue<gatorUpPreValue1&&gatorUpPreValue1<gatorUpPreValue2&& gatorDownValue>gatorDownPreValue1&&gatorDownPreValue1>gatorDownPreValue2; if(douleGreen&&closingPrice>maValue) { Comment("Find a good buy position"); } else if(douleRed&&closingPrice<maValue) { Comment("Find a good sell position"); } else Comment(""); } //+------------------------------------------------------------------+
Qué ha cambiado en el código con respecto al anterior:
Ahora, crearemos dos arrays adicionales pArray y maArray. Después usaremos la función MqlRates para el array pArray para almacenar información de precios y "double" para el array maArray;
MqlRates pArray[]; double maArray[];
Luego, estableceremos la clasificación de los datos en el array usando la función ArraySetAsSeries:
ArraySetAsSeries(maArray,true);
Creamos una variable de tipo entero maDef y definimos la media móvil usando la función iMA, que retorna el identificador del indicador. Parámetros de la función:
- symbol — nombre del símbolo. Usaremos _SYMBOL, el símbolo del gráfico actual.
- period — marco temporal para el cálculo; si se usa el valor _PERIOD, significará que el indicador se calculará en el marco temporal actual, al igual que PERIOD_CURRENT.
- ma_period — periodo de cálculo de la media móvil; 13
- ma_shift — desplazamiento horizontal de MA. Estableceremos 0, para no cambiar.
- ma_method — tipo de media móvil,; en nuestro caso, EMA (Exponential Moving Average)
- applied_price — define el tipo de precio utilizado para el cálculo; nosotros utilizaremos el precio de cierre
int maDef=iMA(_Symbol,_Period,13,0,MODE_EMA,PRICE_CLOSE);
Obtendremos los datos históricos de MqlRates usando la función CopyRates:
- symbol_name — nombre del símbolo para el cálculo del indicador, _Symbol, símbolo actual.
- timeframe — marco temporal a calcular, _Period indicará el marco temporal actual del gráfico.
- start_pos — posición de inicio del cálculo del indicador; estableceremos 0 para realizar el cálculo desde la posición actual
- count — cantidad de datos a copiar, 13.
- rates_array[] — array al que copiamos los datos, pArray
int data=CopyRates(_Symbol,_Period,0,13,pArray);
Definiremos los datos y el almacenamiento de los resultados en maArray usando la función CopyBuffer
CopyBuffer(maDef,0,0,3,maArray);
Luego obtendremos los valores de la media móvil exponencial actual y los normalizaremos.
double maValue=NormalizeDouble(maArray[0],5);
Después obtendremos el valor actual del precio de cierre.
double closingPrice=pArray[0].close;
Vamos a crear las variables booleanas de la barra doble verde y la barra doble roja del indicador Gator Oscillator.
bool douleGreen = gatorUpValue>gatorUpPreValue1&&gatorUpPreValue1>gatorUpPreValue2&&
gatorDownValue<gatorDownPreValue1&&gatorDownPreValue1<gatorDownPreValue2;
bool douleRed = gatorUpValue<gatorUpPreValue1&&gatorUpPreValue1<gatorUpPreValue2&&
gatorDownValue>gatorDownPreValue1&&gatorDownPreValue1>gatorDownPreValue2;
Condiciones de la estrategia.
Condiciones de compra
if(douleGreen&&closingPrice>maValue) { Comment("Find a good buy position"); }
Condiciones de venta
else if(douleRed&&closingPrice<maValue) { Comment("Find a good sell position"); }
En los demás casos
else Comment("");
A continuación, compilaremos el código, buscaremos el archivo resultante en el Navegador del terminal y ejecutaremos el asesor experto en el gráfico del símbolo comercial:
Como podemos ver, en la esquina superior derecha del gráfico, tenemos una indicación que muestra que el asesor experto está funcionando en el gráfico.
Esto significa que el asesor puede generar señales basadas en esta estrategia. A continuación, le mostraremos algunos ejemplos de señales de prueba.
Condiciones de compra
En el gráfico anterior, tendremos un comentario con una señal de compra (Find a good buy position).
Condiciones de venta
Aquí, en el comentario hay una señal de venta (Find a good sell position).
Bien, ya hemos visto cómo crear sistemas comerciales basados en varias estrategias. Quizás encuentre nuevas ideas que pueda aplicar: precisamente este es el objetivo principal del artículo y toda la serie.
Conclusión
Ya hemos abarcado todos los temas de este artículo, en el que hemos aprendido cómo desarrollar sistemas comerciales utilizando el indicador Gator Oscillator. Asimismo, hemos aprendido qué es el indicador Gator Oscillator, cómo calcularlo y cómo usarlo, utilizando el ejemplo de tres estrategias comerciales simples, a saber:
- La detección del estado de Gator: esta estrategia determina el estado del oscilador Gator (despertar, sueño, alimentación, saciedad) en función de varias condiciones.
- Las señales en el indicador Gator: para obtener las señales sobre la posibilidad de tomar una decisión (buscar una buena oportunidad de entrada, mantener la posición actual o buscar una salida) en función de diversas condiciones del oscilador Gator.
- El uso combinado de Gator y MA: señales de compra o venta basadas en el oscilador Gator con un indicador de media móvil.
Después, hemos desarrollado esquemas paso a paso para cada una de las estrategias analizadas, que luego se usan para desarrollar sistemas comerciales basados en ellas. Después de eso, nos familiarizamos con el desarrollo de sistemas comerciales: crearemos un asesor experto MQL5 para cada estrategia, obtendremos un programa que puede funcionar en la plataforma comercial MetaTrader 5 y veremos ejemplos de señales generadas para estas estrategias.
Esperamos que haya disfrutado el artículo y haya aprendido algo nuevo de él. Si lo ha encontrado útil, podrá leer los artículos anteriores de esta serie para aprender a desarrollar sistemas comerciales basados en indicadores técnicos populares. Si le ha gustado este artículo y lo ha encontrado útil, lea los artículos anteriores de la misma serie para aprender a desarrollar un sistema comercial basado en los indicadores técnicos más populares.
Traducción del inglés realizada por MetaQuotes Ltd.
Artículo original: https://www.mql5.com/en/articles/11928
Cómo construir un EA que opere automáticamente (Parte 09): Automatización (I)
Características del Wizard MQL5 que debe conocer (Parte 5): Cadenas de Markov
Algoritmos de optimización de la población: Algoritmo de murciélago (Bat algorithm - BA)
DoEasy. Elementos de control (Parte 31): Desplazamiento por el contenido del control "ScrollBar"
- 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