English Русский 中文 Deutsch 日本語 Português 한국어 Français Italiano Türkçe
preview
Aprendiendo a diseñar un sistema de trading con Fractals

Aprendiendo a diseñar un sistema de trading con Fractals

MetaTrader 5Trading | 7 febrero 2023, 16:45
1 461 0
Mohamed Abdelmaaboud
Mohamed Abdelmaaboud

Introducción

Este nuevo artículo de la serie destinada a la presentación de indicadores técnicos populares se centra en otra herramienta ampliamente utilizada, el indicador Fractals. Hoy analizaremos con detalle este indicador. El artículo incluye los siguientes apartados:

  1. Definición de los fractales
  2. Estrategias basadas en el indicador Fractals
  3. Esquemas de estrategias basadas en el indicador Fractals
  4. Sistemas comerciales basados en los fractales
  5. Conclusión

Aprenderemos qué es este indicador, qué mide y la idea principal detrás de él; para esto, veremos cómo calcularlo manualmente. Usando estrategias simples como ejemplo, aprenderemos a usar el indicador de fractales según su concepto. Luego, en base a estas estrategias, crearemos sistemas comerciales que funcionarán en el terminal comercial MetaTrader 5 y generarán señales automáticamente.

Para escribir los códigos en el artículo, usaremos el lenguaje de programación MQL5 (MetaQuotes Language) integrado en el terminal comercial MetaTrader 5. Si no sabe cómo descargar o usar MetaTrader 5 y MQL5, lea la sección "Escribiendo el código MQL5 en el MetaEditor" en el artículo anterior. Por cierto, recomendamos a los lectores que apliquen de forma independiente todo lo que hablemos aquí, sobre todo si su objetivo es desarrollar habilidades de codificación.

Además, antes de usar cualquier desarrollo en una cuenta real, deberá ponerlo a prueba, ya que todas las estrategias se presentan aquí solo con fines ilustrativos. Asimismo, no existen cosas universales que resulten adecuadas para absolutamente todos los usuarios. Por lo tanto, primero deberá entender si dicha estrategia comercial resulta adecuada para usted.

¡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 de los fractales

El indicador Fractals fue desarrollado por Bill Williams en un intento de predecir la acción potencial del precio según las señales alcistas o bajistas. Una señal alcista indicará un posible movimiento alcista, mientras que una señal bajista indicará un posible movimiento bajista. Podemos decir que el indicador trata de predecir los máximos y los mínimos en el gráfico. En el gráfico, las señales se muestran como flechas por encima y por debajo del precio.

El indicador genera flechas de dos tipos: flechas fractales ascendentes y descendentes. Entonces, ¿qué cálculos usa como base el indicador para generar las señales y flechas correspondientes?

Para ello, el indicador buscará ciertos patrones formados en la dirección del crecimiento o la caída.

Este es el patrón que debe formarse para un fractal ascendente:

  • Una serie de al menos cinco velas o barras consecutivas.
  • El máximo más alto de las cinco velas deberá encontrarse en el centro (tercera vela).
  • Los máximos a cada lado de esta vela central deberán ser más bajos.
  • Tras cerrarse la quinta vela en esta formación, aparecerá una flecha de fractal ascendente sobre la tercera vela.

Para formar el fractal descendente opuesto, el patrón tendrá el aspecto siguiente:

  • Una serie de al menos cinco velas o barras consecutivas.
  • El mínimo más bajo de las cinco velas deberá encontrarse en el centro (tercera vela).
  • Los mínimos a cada lado de esta vela central deberán ser más altos.
  • Tras cerrarse la quinta vela en esta formación, aparecerá una flecha de fractal descendente sobre la tercera vela.

Por suerte, no tendremos que calcular manualmente el indicador y analizar visualmente las velas, ya que ya existe un indicador listo para usar en la terminal comercial MetaTrader 5. Todo lo que deberemos hacer es seleccionarlo de la lista con otros indicadores disponibles. Para hacer esto, deberemos abrir el terminal MetaTrader 5 y añadir el indicador al gráfico a través del menú "Pestaña".

Insertar --> Indicadores --> Bill Williams --> Fractales

 Inicio del indicador Fractals incorporado

Después de seleccionar un indicador de la lista, se abrirá la ventana de parámetros:

 Parámetros del indicador Fractals

1 - color de la flecha

2 - grosor

Seleccione la configuración correspondiente, clique en Aceptar y el indicador se iniciará en el gráfico:

 Indicador Fractals en el gráfico

Como puede ver, han aparecido flechas por encima y por debajo de las velas, lo cual indica un movimiento potencial en la acción del precio. Las flechas hacia abajo por debajo del precio indican un posible movimiento hacia arriba, mientras que las flechas hacia arriba por encima de las velas indican un posible movimiento hacia abajo.

Estrategias basadas en el indicador Fractals

A continuación, veremos varios ejemplos de estrategias sencillas basadas en el indicador Fractals que nos ayudarán a comprender cómo podemos usar este indicador. Para ello, utilizaremos los fractales por separado y luego veremos opciones para usarlos en combinación con otros indicadores técnicos. Este enfoque nos permitirá obtener más información y hacer que las señales resulten más precisas.

Primera estrategia: máximos y mínimos de los fractales

    Según esta estrategia, obtendremos las señales de los máximos y mínimos según la posición de los fractales superior e inferior. Si Fractals ha generado una flecha hacia abajo, esto indicará un mínimo. Si Fractals ha generado una flecha hacia arriba, esto indicará un máximo.

    Es decir:

    Flecha hacia abajo --> Fractals Low

    Flecha hacia arriba --> Fractals High

    Segunda estrategia: Fractals y media móvil

      Con esta estrategia se generarán señales de compra y venta usando como base la dirección de la acción del precio según la posición del precio y la media móvil, además de las señales generadas por el indicador Fractals. Si el precio de cierre se encuentra por encima de la media móvil y el indicador Fractals ha generado una flecha hacia abajo, tendremos una señal de compra. Si el precio de cierre se encuentra por debajo de la media móvil y el indicador Fractals ha generado una flecha hacia arriba, tendremos una señal de venta.

      Es decir:

      Precio de cierre > MA + ha aparecido hacia abajo --> señal de compra

      Precio de cierre < MA + ha aparecido flecha hacia arriba --> señal de venta

      Tercera estrategia: Fractals y Alligator

        Con esta estrategia, se generarán señales de compra y venta basadas en la dirección de la acción del precio según la posición del precio y el indicador Alligator, además de las señales generadas por el indicador Fractals. Si la línea de los labios del caimán se encuentra por encima de los dientes y las mandíbulas, la línea de los dientes está por encima de las mandíbulas, el precio de cierre está por encima de los dientes y la señal del indicador de fractales es una flecha hacia abajo, tendremos una señal de compra. Y si la línea de los labios se encuentra por debajo de los dientes y las mandíbulas, los dientes están por debajo de las mandíbulas, el precio de cierre está por debajo de los dientes y el indicador de fractales ha formado una flecha hacia arriba, tendremos una señal de venta.

        Es decir:

        Línea de labios > líneas de dientes y mandíbula, línea de dientes > líneas de mandíbulas, precio de cierre > líneas de dientes, flecha de Fractals hacia abajo --> señal de compra

        Línea de labios < líneas de dientes y mandíbula, línea de dientes < líneas de mandíbulas, precio de cierre < líneas de dientes, flecha de Fractals hacia arriba --> señal de venta

        Esquemas de estrategias basadas en el indicador Fractals

        En esta parte, crearemos esquemas paso a paso para cada estrategia analizada. Estos esquemas nos ayudarán a avanzar hacia el desarrollo de sistemas comerciales basados en ellos.

        1. Máximos y mínimos de los fractales

          Para esta estrategia, crearemos un sistema comercial que retornará los máximos y mínimos del indicador Fractals como un comentario en el gráfico. Para hacer esto, se monitorearán los valores de fracUp y fracDown. Si el valor de fracUp es mayor que cero, o si su valor no está vacío y fracDown está vacío, el sistema comercial retornará la señal como un comentario en el gráfico con los siguientes valores:

            • Máximo de Fractals: n

          De lo contrario, si el valor de fracDown es mayor que cero o si su valor no está vacío y fracUp está vacío, el sistema comercial retornará una señal bajista como un comentario en el gráfico con los siguientes valores:

            • Mínimo de Fractals: n

          El esquema de esta estrategia se muestra en la siguiente figura:

          Esquema de la estrategia máximos y mínimos de Fractals

          2. Fractals y media móvil

            Usando como base esta estrategia, desarrollaremos un sistema comercial que retornará señales de compra y venta como comentarios en el gráfico. Para hacer esto, deberemos observar los siguientes valores:

              • El precio de cierre
              • El valor de la media móvil exponencial (EMA)
              • El valor de fracDown
              • El valor de fracUp

            Si el precio de cierre se encuentra por encima del valor de EMA y el valor de fracDown no está vacío, la señal retornada por el sistema será:

              • Compra
              • MME actual
              • Mínimo de Fractals: n

            Por el contrario, si el precio de cierre se encuentra por debajo del valor de la media EMA y el valor de fracUp no está vacío, el sistema retornará la señal opuesta y mostrará los siguientes valores:

              • Venta
              • MME actual
              • Máximo de Fractals: n

            Este será el aspecto del esquema para desarrollar este sistema:

            Esquema de la estrategia Frac y MA

            3. Fractals y Alligator

              Usando esta estrategia como base, desarrollaremos un sistema comercial que retornará señales de compra y venta basadas en el análisis de los siguientes valores:

                • El valor de la línea de los labios.
                • El valor de la línea de los dientes.
                • El valor de la línea de las mandíbulas.
                • El precio de cierre
                • El valor de fracDown
                • El valor de fracUp

              Si la línea de los labios está por encima de la línea de los dientes y las mandíbulas, el valor de los dientes está por encima de la línea de las mandíbulas, el precio de cierre está por encima de la línea de los dientes y el valor de fracDown no es igual a un valor vacío, el sistema comercial retornará una señal de compra como comentario en el gráfico, así como el valor del indicador:

                • Compra
                • Valor de Jaws = n
                • Valor de Teeth = n
                • Valor de Lips = n
                • Mínimo de Fractals: n

              En la situación opuesta, si la línea de los labios se encuentra por debajo de la línea de los dientes y las mandíbulas, el valor de los dientes está por debajo de la línea de las mandíbulas, el precio de cierre está por debajo de la línea de los dientes y el valor de fracUp no está vacío, el sistema comercial deberá retornar una señal de venta y los valores del indicador como un comentario en el gráfico:

                • Venta
                • Valor de Jaws = n
                • Valor de Teeth = n
                • Valor de Lips = n
                • Máximo de Fractals: n

              Este será el aspecto del esquema para desarrollar este sistema:

              Esquema de la estrategia Frac y Alligator

              Sistemas comerciales basados en los fractales

              En esta sección, analizaremos paso a paso cómo escribir sistemas comerciales en MQL5 basados en las lecturas de este indicador y luego usarlos en MetaTrader 5. Comenzaremos con un sistema Fractals simple que mostrará un comentario en el gráfico con los valores del indicador de fractales.

              Para hacer esto, crearemos arrays para los fractales hacia arriba y hacia abajo usando la función double.

                 double fracUpArray[];
                 double fracDownArray[];
              

              Luego, estableceremos la clasificación de los datos en el array usando la función ArraySetAsSeries: Parámetros de la función:

              • array[] — arrays fracUpArray y fracDownArray creados.
              • flag — establezca la bandera en verdadero.
                 ArraySetAsSeries(fracUpArray,true);
                 ArraySetAsSeries(fracDownArray,true);
              

              Ahora definiremos el indicador de fractales utilizando la función iFractals, que retorna el manejador del indicador. Parámetros de la función:

              • symbol — símbolo para los cálculos; _Symbol indica el símbolo del gráfico actual.
              • period — periodo para los cálculos, _Period indica el marco temporal actual.
              int fracDef=iFractals(_Symbol,_Period);

              Luego obtendremos los datos y guardaremos el resultado usando la función CopyBuffer. Parámetros de la función:

              • indicator_handle — manejador del indicador, fracDef
              • buffer_num — búferes de indicador; en nuestro caso, tendremos UPPER_LINE para los superiores y LOWER_LINE para los inferiores.
              • start_pos — indica la posición para el inicio de los cálculos; estableceremos 0
              • count — cantidad de datos a copiar; estableceremos 3.
              • buffer[] — array en el que se copiarán los datos (fracUpArray, fracDownArray).
                 CopyBuffer(fracDef,UPPER_LINE,2,1,fracUpArray);
                 CopyBuffer(fracDef,LOWER_LINE,2,1,fracDownArray);
              

              A continuación, obtendremos los valores del máximo y mínimo de los fractales.

                 double fracUpValue=NormalizeDouble(fracUpArray[0],5);
                 double fracDownValue=NormalizeDouble(fracDownArray[0],5);
              

              Luego retornaremos el valor cero en caso de que exista un valor vacío para fracUpValue y faceDownValue.

                 if(fracUpValue==EMPTY_VALUE)
                    fracUpValue = 0;
                 if(fracDownValue==EMPTY_VALUE)
                    fracDownValue = 0;
              

              Después usaremos la función Comment para crear un comentario en el gráfico con el valor actual de los fractales:

                 Comment("Fractals Up Value = ",fracUpValue,"\n",
                         "Fractals Down Value = ",fracDownValue);
              

              Más abajo se muestra el código completo de este sistema comercial.

              //+------------------------------------------------------------------+
              //|                                       Simple Fractals 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()
                {
              //creating price array
                 double fracUpArray[];
                 double fracDownArray[];
              //Sorting data
                 ArraySetAsSeries(fracUpArray,true);
                 ArraySetAsSeries(fracDownArray,true);
              //define frac
                 int fracDef=iFractals(_Symbol,_Period);
              //define data and store result
                 CopyBuffer(fracDef,UPPER_LINE,2,1,fracUpArray);
                 CopyBuffer(fracDef,LOWER_LINE,2,1,fracDownArray);
              //get values of fracUp and fracDown
                 double fracUpValue=NormalizeDouble(fracUpArray[0],5);
                 double fracDownValue=NormalizeDouble(fracDownArray[0],5);
              //returning zero if there is empty value of fracUp
                 if(fracUpValue==EMPTY_VALUE)
                    fracUpValue = 0;
              //returning zero if there is empty value of fracDown
                 if(fracDownValue==EMPTY_VALUE)
                    fracDownValue = 0;
              //comment on the chart
                 Comment("Fractals Up Value = ",fracUpValue,"\n",
                         "Fractals Down Value = ",fracDownValue);
                }
              //+------------------------------------------------------------------+
              

              Después compilaremos el código del asesor, y este aparecerá en la ventana del Navegador en el terminal de MetaTrader 5:

               Asesor Fractals en el Navegador

              Luego lo inicializaremos en el gráfico necesario clicando dos veces en el archivo o arrastrando y soltando. Después de eso, aparecerá la ventana del asesor.

               Ventana del asesor Simple Fractals

              Luego permitiremos el comercio automático "Allow Algo Trading", pulsaremos OK y el programa se iniciará en el gráfico:

              Asesor Simple Fractals en el gráfico

              Como podemos ver, en la esquina superior derecha del gráfico hay una indicación de que el asesor está funcionando en el gráfico. El asesor se está ejecutando y generando señales.

               Señales del asesor Simple Fractals

              En la esquina superior izquierda del gráfico se muestran dos valores:

              • Fractals Up = n
              • Fractals Down = 0

              En este ejemplo, el valor de Fractals Down es igual a cero porque tenemos un valor de Fractals up.

               Señales del asesor Simple Fractals 2

              Tenemos dos significados:

              • Fractals Up = 0
              • Fractals Down = n

              Pero el valor de Fractals Up es igual a cero ya que tenemos un valor de Fractals down.

              1. Máximos y mínimos de los fractales

                A continuación, podrá ver el código completo del sistema comercial de máximos y mínimos de fractal.

                //+------------------------------------------------------------------+
                //|                                      Fractals highs and lows.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()
                  {
                //creating arrays
                   double fracUpArray[];
                   double fracDownArray[];
                //Sorting data
                   ArraySetAsSeries(fracUpArray,true);
                   ArraySetAsSeries(fracDownArray,true);
                //define frac
                   int fracDef = iFractals(_Symbol,_Period);
                //define data and store result
                   CopyBuffer(fracDef,UPPER_LINE,2,1,fracUpArray);
                   CopyBuffer(fracDef,LOWER_LINE,2,1,fracDownArray);
                //define values
                   double fracUpValue = NormalizeDouble(fracUpArray[0],5);
                   double fracDownValue = NormalizeDouble(fracDownArray[0],5);
                //returning zero in case of empty values
                   if(fracUpValue ==EMPTY_VALUE)
                      fracUpValue = 0;
                   if(fracDownValue ==EMPTY_VALUE)
                      fracDownValue = 0;
                //conditions of the strategy and comment on the chart with highs and lows
                //in case of high
                   if(fracUpValue>0)
                     {
                      Comment("Fractals High around: ",fracUpValue);
                     }
                //in case of low
                   if(fracDownValue>0)
                     {
                      Comment("Fractals Low around: ",fracDownValue);
                     }
                  }
                //+------------------------------------------------------------------+
                

                Diferencias en este código:

                Las condiciones de la estrategia.

                Máximo:

                   if(fracUpValue>0)
                     {
                      Comment("Fractals High around: ",fracUpValue);
                     }
                

                Mínimo:

                   if(fracDownValue>0)
                     {
                      Comment("Fractals Low around: ",fracDownValue);
                     }
                

                Después de compilar el código, ejecutaremos el archivo resultante en el gráfico, como hicimos la última vez. El asesor experto Fractal Highs and Lows se iniciará en el gráfico:

                 Asesor Fractals highs and lows en el gráfico

                Ahora podemos obtener los máximos y mínimos necesarios. Señales de mínimos:

                 Asesor Fractals highs and lows — señal low

                Como podemos ver en el gráfico anterior, el valor del mínimo de los fractales se muestra en la esquina superior izquierda, ya que se ha formado el patrón correspondiente en el gráfico.

                Señal del máximo:

                Asesor Fractals highs and lows — señal high

                Aquí, en los comentarios del gráfico, se muestran los fractales máximos.

                2. Fractals y media móvil

                  A continuación, mostraremos el código completo para crear un sistema comercial usando la estrategia Fractals + MA:

                  //+------------------------------------------------------------------+
                  //|                                             Fractals with MA.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()
                    {
                  //creating arrays
                     double fracUpArray[];
                     double fracDownArray[];
                     MqlRates priceArray[];
                     double maArray[];
                  //Sorting data
                     ArraySetAsSeries(fracUpArray,true);
                     ArraySetAsSeries(fracDownArray,true);
                     ArraySetAsSeries(priceArray,true);
                     ArraySetAsSeries(maArray,true);
                  //define values
                     int fracDef = iFractals(_Symbol,_Period);
                     int Data = CopyRates(_Symbol,_Period,0,3,priceArray);
                     int maDef = iMA(_Symbol,_Period,50,0,MODE_EMA,PRICE_CLOSE);
                  //define data and store result
                     CopyBuffer(fracDef,UPPER_LINE,2,1,fracUpArray);
                     CopyBuffer(fracDef,LOWER_LINE,2,1,fracDownArray);
                     CopyBuffer(maDef,0,0,3,maArray);
                  //get values
                     double fracUpValue = NormalizeDouble(fracUpArray[0],5);
                     double fracDownValue = NormalizeDouble(fracDownArray[0],5);
                     double closingPrice = priceArray[0].close;
                     double maValue = NormalizeDouble(maArray[0],6);
                     bool isBuy = false;
                     bool isSell = false;
                  //conditions of the strategy and comment on the chart
                  //in case of buy
                     if(closingPrice > maValue && fracDownValue != EMPTY_VALUE)
                       {
                        Comment("Buy","\n",
                                "Current EMA: ",maValue,"\n",
                                "Fractals Low around: ",fracDownValue);
                        isBuy = true;
                       }
                  //in case of sell
                     if(closingPrice < maValue && fracUpValue != EMPTY_VALUE)
                       {
                        Comment("Sell","\n",
                                "Current EMA: ",maValue,"\n",
                                "Fractals High around: ",fracUpValue);
                        isSell = true;
                       }
                    }
                  //+------------------------------------------------------------------+
                  

                  Diferencias en este código:

                  Creamos dos arrays adicionales: el array de precios priceArray usando la función MqlRates, que almacenará la información sobre los precios, los volúmenes y el spread, y el array maArray usando la función double.

                     MqlRates priceArray[];
                     double maArray[];
                  

                  Clasificamos estos arrays:

                     ArraySetAsSeries(priceArray,true);
                     ArraySetAsSeries(maArray,true);
                  

                  Luego recuperaremos los datos históricos de MqlRates usando la función CopyRates. Parámetros de la función:

                  • symbol — nombre del símbolo; en nuestro caso, _Symbol
                  • timeframe — periodo de tiempo a calcular (_period)
                  • start_pos — indica la posición para el inicio de los cálculos; estableceremos 0
                  • count — cantidad de datos a copiar; estableceremos 3.
                  • rates_array[] — array para copiar los datos; priceArray

                  Declararemos la media móvil usando la función iMA. Parámetros de la función:

                  • symbol — nombre del símbolo
                  • period — periodo de cálculo
                  • ma_period — periodo de promediación; en nuestro caso, 50
                  • ma_shift — desplazamiento en horizontal, 0
                  • ma_method — tipo de media móvil,; en nuestro caso, EMA (Exponential Moving Average)
                  • apply_price — tipo de precio usado en los cálculos (precio de cierre)
                     int Data = CopyRates(_Symbol,_Period,0,3,priceArray);
                     int maDef = iMA(_Symbol,_Period,50,0,MODE_EMA,PRICE_CLOSE);
                  

                  Clasificación de datos.

                  CopyBuffer(maDef,0,0,3,maArray);

                  Determinación del precio de cierre y el valor de MA.

                  double closingPrice = priceArray[0].close;
                  double maValue = NormalizeDouble(maArray[0],6);
                  

                  Ahora crearemos dos variables booleanas para isBuy e isSell: así evitaremos conflictos entre las señales de compra y venta de la misma vela.

                     bool isBuy = false;
                     bool isSell = false;
                  

                  Las condiciones de la estrategia.

                  Para generar una señal de compra:

                     if(closingPrice > maValue && fracDownValue != EMPTY_VALUE)
                       {
                        Comment("Buy","\n",
                                "Current EMA: ",maValue,"\n",
                                "Fractals Low around: ",fracDownValue);
                        isBuy = true;
                       }
                  

                  Para generar una señal de venta:

                     if(closingPrice < maValue && fracUpValue != EMPTY_VALUE)
                       {
                        Comment("Sell","\n",
                                "Current EMA: ",maValue,"\n",
                                "Fractals High around: ",fracUpValue);
                        isSell = true;
                       }
                  

                  Luego compilaremos el código y ejecutamos el asesor experto resultante desde el navegador en el terminal MetaTrader 5.

                   Sistema Fractals y MA en el gráfico

                  Como podemos ver, el asesor experto de Fractals + MA está adjunto al gráfico (tenemos el icono correspondiente en la esquina superior derecha). Veamos ejemplos de las señales generadas por el asesor.

                  Señal de compra:

                   Fractals + MA - señal de compra

                  El gráfico muestra un comentario con los siguientes valores:

                  • Compra
                  • MME actual
                  • Mínimo de Fractals: n

                  Señal de venta:

                   Fractals + MA - señal de venta

                  Tenemos los siguientes valores:

                  • Venta
                  • MME actual
                  • Máximo de Fractals: n

                  3. Fractals y Alligator

                    A continuación, le mostraremos el código completo para crear un sistema comercial usando la estrategia Fractals + Alligator:

                    //+------------------------------------------------------------------+
                    //|                                      Fractals with Alligator.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()
                      {
                    //creating arrays
                       double fracUpArray[];
                       double fracDownArray[];
                       MqlRates priceArray[];
                       double jawsArray[];
                       double teethArray[];
                       double lipsArray[];
                    //Sorting data
                       ArraySetAsSeries(fracUpArray,true);
                       ArraySetAsSeries(fracDownArray,true);
                       ArraySetAsSeries(jawsArray,true);
                       ArraySetAsSeries(teethArray,true);
                       ArraySetAsSeries(lipsArray,true);
                    //define values
                       int fracDef=iFractals(_Symbol,_Period);
                       int Data = CopyRates(_Symbol,_Period,0,3,priceArray);
                       int alligatorDef=iAlligator(_Symbol,_Period,13,8,8,5,5,3,MODE_SMMA,PRICE_MEDIAN);
                    //define data and store result
                       CopyBuffer(fracDef,UPPER_LINE,2,1,fracUpArray);
                       CopyBuffer(fracDef,LOWER_LINE,2,1,fracDownArray);
                       CopyBuffer(alligatorDef,0,0,3,jawsArray);
                       CopyBuffer(alligatorDef,1,0,3,teethArray);
                       CopyBuffer(alligatorDef,2,0,3,lipsArray);
                    //get values
                       double fracUpValue=NormalizeDouble(fracUpArray[0],5);
                       double fracDownValue=NormalizeDouble(fracDownArray[0],5);
                       double closingPrice = priceArray[0].close;
                       double jawsValue=NormalizeDouble(jawsArray[0],5);
                       double teethValue=NormalizeDouble(teethArray[0],5);
                       double lipsValue=NormalizeDouble(lipsArray[0],5);
                    //creating bool variables to avoid buy and sell signals at the same time
                       bool isBuy = false;
                       bool isSell = false;
                    //conditions of the strategy and comment on the chart
                    //in case of buy
                       if(lipsValue>teethValue && lipsValue>jawsValue && teethValue>jawsValue
                       && closingPrice > teethValue && fracDownValue != EMPTY_VALUE)
                         {
                          Comment("Buy","\n",
                                  "jawsValue = ",jawsValue,"\n",
                                  "teethValue = ",teethValue,"\n",
                                  "lipsValue = ",lipsValue,"\n",
                                  "Fractals Low around: ",fracDownValue);
                          isBuy = true;
                         }
                    //in case of sell
                       if(lipsValue<teethValue && lipsValue<jawsValue && teethValue<jawsValue
                       && closingPrice < teethValue && fracUpValue != EMPTY_VALUE)
                         {
                          Comment("Sell","\n",
                                  "jawsValue = ",jawsValue,"\n",
                                  "teethValue = ",teethValue,"\n",
                                  "lipsValue = ",lipsValue,"\n",
                                  "Fractals High around: ",fracUpValue);
                          isSell = true;
                         }
                      }
                    //+------------------------------------------------------------------+
                    

                    Diferencias en este código:

                    Primero crearemos tres arrays para los componentes de Alligator.

                       double jawsArray[];
                       double teethArray[];
                       double lipsArray[];
                    

                    Luego, estableceremos la clasificación de los datos en el array con la ayuda de la función ArraySetAsSeries:

                       ArraySetAsSeries(jawsArray,true);
                       ArraySetAsSeries(teethArray,true);
                       ArraySetAsSeries(lipsArray,true);
                    

                    Asimismo, declararemos el indicador Alligator usando la función iAlligator. 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; el valor "_Period" señalará 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 — establece el desplazamiento horizontal para la línea de las mandíbulas, aquí será 8.
                    • teeth_period — periodo medio para calcular la línea de los dientes, utilizaremos 8.
                    • teeth_shift — establece el desplazamiento horizontal para la línea de los dientes, usaremos 5.
                    • lips_period — periodo medio para calcular la línea de los labios, en nuestro caso, será 5.
                    • lips_shift — establece el desplazamiento horizontal para la línea de los labios, aquí será 3.
                    • ma_method — tipo de suavizado de la media móvil, MODE_SMA.
                    • applied_price — define el tipo de precio usado para el cálculo; utilizaremos el precio medio.
                    int alligatorDef=iAlligator(_Symbol,_Period,13,8,8,5,5,3,MODE_SMMA,PRICE_MEDIAN);

                    A continuación, definiremos los datos y guardaremos los resultados utilizando la función CopyBuffer. Parámetros de la función:

                    • indicator_handle — manejador del indicador, alligatorDef
                    • buffer_num — número del búfer de indicador, 0 - mandíbulas, 1 - dientes, 2 - labios.
                    • start_pos — indica la posición para el inicio de los cálculos; estableceremos 0
                    • count — cantidad de datos a copiar; estableceremos 3.
                    • buffer[] — define el array de precios a copiar, tendremos jawsArray, teethArray, lipsArray.
                       CopyBuffer(alligatorDef,0,0,3,jawsArray);
                       CopyBuffer(alligatorDef,1,0,3,teethArray);
                       CopyBuffer(alligatorDef,2,0,3,lipsArray);
                    

                    Luego obtendremos los valores de los componentes de Alligator.

                       double jawsValue=NormalizeDouble(jawsArray[0],5);
                       double teethValue=NormalizeDouble(teethArray[0],5);
                       double lipsValue=NormalizeDouble(lipsArray[0],5);
                    

                    Las condiciones de la estrategia.

                    Para generar una señal de compra:

                       if(lipsValue>teethValue && lipsValue>jawsValue && teethValue>jawsValue
                       && closingPrice > teethValue && fracDownValue != EMPTY_VALUE)
                         {
                          Comment("Buy","\n",
                                  "jawsValue = ",jawsValue,"\n",
                                  "teethValue = ",teethValue,"\n",
                                  "lipsValue = ",lipsValue,"\n",
                                  "Fractals Low around: ",fracDownValue);
                          isBuy = true;
                         }
                    

                    Para generar una señal de venta:

                       if(lipsValue<teethValue && lipsValue<jawsValue && teethValue<jawsValue
                       && closingPrice < teethValue && fracUpValue != EMPTY_VALUE)
                         {
                          Comment("Sell","\n",
                                  "jawsValue = ",jawsValue,"\n",
                                  "teethValue = ",teethValue,"\n",
                                  "lipsValue = ",lipsValue,"\n",
                                  "Fractals High around: ",fracUpValue);
                          isSell = true;
                         }
                    

                    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:

                     Sistema Fractals y Alligator en el gráfico

                    El asesor experto se ha iniciado y está funcionando en el gráfico; esto se indica usando la indicación en la esquina superior derecha del gráfico. Ahora podremos recibir señales.

                    Ejemplos de señales generadas al poner a prueba esta estrategia.

                    Señal de compra

                     Fractals + Alligator - señal de compra

                    Como podemos ver, en el gráfico de arriba en la parte superior izquierda, se ha formado una señal con los siguientes valores:

                    • Compra
                    • El valor de las mandíbulas
                    • El valor de los dientes
                    • El valor de los labios
                    • El mínimo de Fractals

                     Fractals + Alligator - señal de venta

                    En el gráfico anterior, tenemos una señal y los siguientes valores:

                    • Venta
                    • El valor de las mandíbulas
                    • El valor de los dientes
                    • El valor de los labios
                    • El máximo de Fractals


                    Conclusión

                    El indicador técnico Fractals es una herramienta útil y eficaz que podemos utilizar solo o en combinación con otros indicadores técnicos. Bien, tras familiarizarnos hoy con el indicador, el lector ha podido aprender lo que mide, cómo se forma en el gráfico y cómo encontrar el indicador integrado en el terminal MetaTrader 5. Además, hemos analizado cómo se pueden usar los fractales con las siguientes estrategias comerciales simples:

                    • Máximos y mínimos de Fractals: para encontrar los máximos y mínimos del indicador Fractals y obtener una señal en el gráfico.
                    • Fractales y media móvil: señales de compra basadas en las lecturas del indicador de fractales y la posición del precio en relación con la media móvil.
                    • Fractales y Alligator: señales de compra basadas en las lecturas del indicador de fractales, el indicador Alligator y la posición del precio.

                    También hemos aprendido a crear sistemas automáticos basados en cada una de las estrategias analizadas, y hemos escrito el código de asesores expertos que generan señales en el terminal MetaTrader 5. Esperamos que haya intentado repetir por su cuenta todo lo aquí escrito para comprender completamente los materiales y sacarles el máximo provecho, y también, por qué no, para encontrar nuevas ideas.

                    Una vez más, resulta vital probar y optimizar cuidadosamente las estrategias antes de aplicarlas en una cuenta real. Esperamos que este artículo le haya sido útil y que haya aprendido algo nuevo que lo ayude a mejorar sus resultados comerciales. Si le ha gustado, lea los artículos anteriores de la misma serie; en cada uno de ellos analizamos un instrumento técnico popular y desarrollamos estrategias comerciales basadas en él.

                    Traducción del inglés realizada por MetaQuotes Ltd.
                    Artículo original: https://www.mql5.com/en/articles/11620

                    Aprendizaje automático y Data Science (Parte 8): Clusterización con el método de k-medias en MQL5 Aprendizaje automático y Data Science (Parte 8): Clusterización con el método de k-medias en MQL5
                    Para todos los que trabajan con datos, incluidos los tráders, la minería de datos puede descubrir posibilidades completamente nuevas, porque a menudo los datos no son tan simples como parecen. Resulta difícil para el ojo humano ver patrones y relaciones profundas en un conjunto de datos. Una solución sería el algoritmo de k-medias o k-means. Veamos si resulta útil.
                    Redes neuronales: así de sencillo (Parte 31): Algoritmos evolutivos Redes neuronales: así de sencillo (Parte 31): Algoritmos evolutivos
                    En el artículo anterior, comenzamos a analizar los métodos de optimización sin gradiente, y también nos familiarizamos con el algoritmo genético. Hoy continuaremos con el tema iniciado, y estudiaremos otra clase de algoritmos evolutivos.
                    Indicadores adaptativos Indicadores adaptativos
                    En este artículo, analizaremos varios enfoques posibles en la creación de indicadores adaptativos. Los indicadores adaptativos se distinguen por la presencia de retroalimentación entre los valores de las señales de entrada y salida. Esta relación permite que el indicador se ajuste de forma independiente al procesamiento óptimo de los valores de las series temporales financieras.
                    Cómo construir un EA que opere automáticamente (Parte 08): OnTradeTransaction Cómo construir un EA que opere automáticamente (Parte 08): OnTradeTransaction
                    En este artículo, te mostraré cómo puedes utilizar el sistema de manejo de eventos para poder procesar con más agilidad y de mejor manera las cuestiones relacionadas con el sistema de órdenes, para que el EA sea más rápido. Así, éste no tendrá que estar buscando información todo el tiempo.