Características del Wizard MQL5 que debe conocer (Parte 40): SAR parabólico

Introducción

Continuamos con esta serie que analiza las diferentes configuraciones e ideas comerciales que se pueden explotar y probar rápidamente gracias al Asistente MQL5 (MQL5 Wizard). En los últimos 2 artículos nos hemos centrado en los indicadores y osciladores muy básicos como los que vienen con las clases de asistente en el IDE. Al hacerlo, explotamos los diversos patrones que cada uno de los indicadores considerados puede proporcionar, los probamos de forma independiente y también los optimizamos para configuraciones que usan una selección de múltiples patrones para poder comparar los resultados de las pruebas de ejecuciones de patrones independientes contra una configuración colectiva u optimizada. 

Nos ceñimos a este formato para este artículo, en el que repasamos pauta por pauta para el SAR parabólico antes de concluir con una prueba que combina múltiples pautas como hicimos en los últimos artículos. El SAR parabólico se calcula casi independientemente con cada nueva barra, ya que algunos de los parámetros que intervienen en su fórmula necesitan ser ajustados, como veremos a continuación. Sin embargo, esta característica lo hace muy sensible a los cambios de precios y las tendencias en general, lo que a su vez justifica su uso dentro de una clase de señal personalizada. En este artículo, exploraremos 10 patrones separados de este indicador probando cada uno de ellos independientemente y luego concluiremos, como en los artículos recientes, con una prueba que combina una selección de estos patrones.

El código fuente adjunto al final de este artículo está destinado a ser utilizado en un asistente MQL5 para ensamblar un Asesor Experto que lo utilice. Hay orientación aquí y aquí sobre cómo hacerlo para los lectores que son nuevos.

Definición del SAR parabólico

El SAR parabólico es un búfer de valores que se compensan con los valores extremos de la tendencia actual en cantidades crecientes (o escalones) hasta un umbral preestablecido. Puede parecer un trabalenguas, pero se trata simplemente de una forma muy dinámica de indicar la tendencia actual y de trazar los puntos en los que la tendencia dada podría invertirse. La fórmula del SAR parabólico es muy fluida; es diferente en tendencias alcistas y bajistas. Para los alcistas tenemos:

Donde:  

• SAR n+1 ​ es el valor del SAR para el periodo siguiente.
• SAR n ​ es el valor SAR actual.
• EP (Extreme Point) es el precio más alto de la tendencia actual.
• α es el factor de aceleración (Acceleration Factor, AF), que normalmente comienza en 0,02 y se incrementa en 0,02 cada vez que se alcanza un nuevo EP (Extreme Point), con un máximo de 0,20 (puede variar en función de la configuración del usuario).

También cabe señalar que en una tendencia alcista:

• EP es el máximo desde que comenzó la tendencia.
• El valor del SAR aumentará a medida que continúe la tendencia, ajustándose para seguir el movimiento del precio.

Y para los bajistas, tenemos:

Donde:

• EP es el precio más bajo de la tendencia bajista actual.

Igualmente digno de mención, en una tendencia bajista:

• EP es el mínimo más bajo desde que comenzó la tendencia.
• El valor SAR disminuirá con el tiempo, siguiendo la tendencia descendente.

Así, a medida que avanza una tendencia, los incrementos o decrementos (como en un caso bajista) del SAR, tienden a comprimirlo hacia los precios, lo que a su vez hace más inminente un giro o cambio de tendencia. La implementación de esto en MQL5 es manejada por indicadores incorporados y clases de la biblioteca estándar, por lo que para este artículo simplemente nos referiremos a estos. Profundicemos ahora en los distintos patrones que ofrece el SAR.

Cruce de brecha de reversión

Nuestro primer patrón, 0, es el cruce de brecha, donde los puntos indicadores del SAR cambian de lado, desde estar por encima de los máximos de precios a estar por debajo de los mínimos en el caso de una brecha alcista, o desde estar por debajo de los mínimos a estar por encima de los máximos en una brecha bajista. A menudo, el tamaño de la brecha entre los puntos SAR parabólicos y el punto de precio más cercano (que sería un precio bajo para la brecha alcista o un precio alto para la brecha bajista) es indicativo de la fuerza de la señal. Cuanto más amplia sea esta brecha, más fuerte será la nueva tendencia.

Sin embargo, también se deben tener en cuenta las condiciones macro del mercado, ya que estos cruces de brechas pueden ocurrir con bastante frecuencia, especialmente en mercados muy volátiles, lo que daría lugar a muchas señales falsas. Por lo tanto, es conveniente depender más de esta señal en mercados que tienen una volatilidad mínima. En los casos en que se utiliza el SAR en el ajuste del stop-loss, es en estos puntos de cruce donde, en lugar de cerrar una posición, el stop-loss simplemente se acerca al SAR y el cierre y la reversión de la posición real dependen de otra señal.

Para implementar nuestro patrón 0, en nuestra clase de señal personalizada, usamos la siguiente función:

//+------------------------------------------------------------------+
//| Check for Pattern 0.                                             |
//+------------------------------------------------------------------+
bool CSignalSAR::IsPattern_0(ENUM_POSITION_TYPE T)
{  if(T == POSITION_TYPE_BUY && Base(StartIndex() + 1) > High(StartIndex() + 1) && Base(StartIndex()) < Low(StartIndex()))
   {  return(true);
   }
   else if(T == POSITION_TYPE_SELL && Base(StartIndex() + 1) < Low(StartIndex() + 1) && Base(StartIndex()) > High(StartIndex()))
   {  return(true);
   }
   return(false);
}

Además, las ejecuciones de prueba para un Asesor Experto ensamblado por un asistente que únicamente utiliza el patrón 0 nos dan los siguientes resultados:

Zona de compresión SAR

Nuestro siguiente patrón es la zona de compresión, y podría decirse que es un refinamiento del patrón 0. Su principal diferencia, como sugiere su nombre, es el requisito de una compresión en el precio (lo que se traduce en una tendencia previa de baja volatilidad) antes del cambio en el indicador SAR. Como ya se ha introducido, el SAR indica qué tendencia prevalece actualmente (entre alcista y bajista) y, por lo tanto, si una tendencia anterior ha tenido una tracción insignificante, esto puede interpretarse como una compresión. La cuantificación de lo "despreciable" podría implicar la necesidad de añadir otro parámetro de entrada para definir este valor; sin embargo, optamos por implementarlo mediante una función de compresión de la siguiente manera:

bool              Compression(ENUM_POSITION_TYPE T, double &Out)
   {                 Out = 0.0;
                     int _i = StartIndex() + 1, _c = 0;
                     double _last = Base(StartIndex() + 1);
                     double _first = 0.0;
                     if
                     (
                     T == POSITION_TYPE_BUY &&
                     Base(StartIndex()) < Low(StartIndex()) &&
                     Base(_i) < Close(StartIndex()) &&
                     Base(_i) > High(_i)
                     )
                     {  while(Base(_i) > High(_i) && _c < __COMPRESSION_LIMIT)
                        {  _first = Base(_i);
                           _i++;
                           _c++;
                        }
                        if(_c > 0)
                        {  Out = fabs(_first - _last)/_c;
                           return(true);
                        }
                     }
                     else if
                     (
                     T == POSITION_TYPE_SELL &&
                     Base(StartIndex()) > High(StartIndex()) &&
                     Base(_i) > Close(StartIndex()) &&
                     Base(_i) < Low(_i)
                     )
                     {  while(Base(_i) < Low(_i) && _c < __COMPRESSION_LIMIT)
                        {  _first = Base(_i);
                           _i++;
                           _c++;
                        }
                        if(_c > 0)
                        {  Out = fabs(_first - _last)/_c;
                           return(true);
                        }
                     }
                     return(false);
   }

Esto a su vez significa que nuestra función de patrón 0 se maneja de la siguiente manera:

//+------------------------------------------------------------------+
//| Check for Pattern 1.                                             |
//+------------------------------------------------------------------+
bool CSignalSAR::IsPattern_1(ENUM_POSITION_TYPE T)
{  double _compression = 0.0;
   if(Compression(T, _compression))
   {  if(T == POSITION_TYPE_BUY && _compression < 0.02*fabs(Base(StartIndex())-Low(StartIndex())))
      {  return(true);
      }
      else if(T == POSITION_TYPE_SELL && _compression < 0.02*fabs(Base(StartIndex())-High(StartIndex())))
      {  return(true);
      }
   }
   return(false);
}

Esta función cuantifica en qué medida, en la tendencia anterior, se fueron ajustando los valores del indicador. Lo que utilizamos como nuestro umbral para definir insignificante como entrada es lo que ya tenemos como entrada y esta es la entrada de paso SAR. Entonces, si una fracción de la brecha SAR inicial con respecto al precio es mayor que el cambio medio en los valores SAR durante la tendencia anterior, entonces tuvimos una compresión. Y dado que las condiciones para este patrón son simplemente una compresión y un cambio de tendencia, procederíamos a abrir una posición en línea con las condiciones de cambio de tendencia del patrón 0 ya compartidas anteriormente. La prueba con nuestro Asesor Experto ensamblado por el asistente, exclusivamente para el patrón 1, nos arroja los siguientes resultados:

Estamos probando con el símbolo EURJPY para el año 2023, en el marco de tiempo diario. Al ser un patrón de compresión que hemos definido estrictamente limitando la tendencia general utilizando la entrada escalonada como nuestra fracción, no se colocan muchas operaciones. Sin embargo, esto puede ajustarse introduciendo otro parámetro para moderarlo. La entrada para el uso de patrones utilizada para este patrón es 2.

SAR de tendencia ampliada

Este patrón es de continuación y puede adoptarse en los casos en los que el cambio de tendencia inicial fue moderado, por ejemplo, en los casos en los que la diferencia entre el SAR y el precio era muy pequeña al principio. Es bastante sencillo, con un patrón alcista que se indica por la ampliación de la brecha entre los puntos SAR, mientras que el indicador SAR se mantiene por debajo de los precios bajos y una señal bajista que se indica en el escenario inverso, donde las brechas de puntos también aumentan mientras que el SAR se mantiene por encima de los precios altos. Algunos podrían calificarlo de rezagado, pero siempre es mejor probarlo primero antes de sacar tales conclusiones. Lo implementamos de la siguiente manera en MQL5:

//+------------------------------------------------------------------+
//| Check for Pattern 2.                                             |
//+------------------------------------------------------------------+
bool CSignalSAR::IsPattern_2(ENUM_POSITION_TYPE T)
{  if(T == POSITION_TYPE_BUY && 
   Base(StartIndex()) - Base(StartIndex() + 1) > Base(StartIndex() + 1) - Base(StartIndex() + 2) && 
   Base(StartIndex() + 1) - Base(StartIndex() + 2) > Base(StartIndex() + 2) - Base(StartIndex() + 3) && 
   Base(StartIndex() + 2) - Base(StartIndex() + 3) > Base(StartIndex() + 3) - Base(StartIndex() + 4) 
   )
   {  return(true);
   }
   else if(T == POSITION_TYPE_SELL && 
   Base(StartIndex() + 1) - Base(StartIndex()) > Base(StartIndex() + 2) - Base(StartIndex() + 1) && 
   Base(StartIndex() + 2) - Base(StartIndex() + 1) > Base(StartIndex() + 3) - Base(StartIndex() + 2) && 
   Base(StartIndex() + 3) - Base(StartIndex() + 2) > Base(StartIndex() + 4) - Base(StartIndex() + 3) 
   )
   {  return(true);
   }
   return(false);
}

Y para probar sólo este patrón, el patrón 2, tendríamos el mapa de entrada para los patrones utilizados como 4. Probando sólo con este patrón con los mismos ajustes que hemos utilizado anteriormente, obtenemos los siguientes resultados:

Falsa señal de cambio del SAR

Este patrón, como su nombre indica, se refiere a un cambio a una nueva tendencia que se invierte casi inmediatamente volviendo a la anterior. Esto a menudo se indica mediante tendencias de uno o dos puntos en el gráfico de precios SAR, y la tendencia que sigue a estos puntos mientras está en su lado opuesto indica en qué deben centrarse los operadores. Así, para una señal alcista, se tendría una tendencia alcista regular seguida de un cambio de tendencia que se caracteriza por durar solo una o dos barras de precio y luego una reanudación de la tendencia larga, siendo la señal la reanudación de la tendencia. De igual forma, el patrón bajista comenzaría con una tendencia bajista que se transforma brevemente alcista tras una o dos barras de precio antes de reanudar un descenso. Codificaríamos este patrón de la siguiente manera:

//+------------------------------------------------------------------+
//| Check for Pattern 3.                                             |
//+------------------------------------------------------------------+
bool CSignalSAR::IsPattern_3(ENUM_POSITION_TYPE T)
{  if(T == POSITION_TYPE_BUY && Base(StartIndex()) < Low(StartIndex()) && Base(StartIndex() + 1) > High(StartIndex() + 1) && Base(StartIndex() + 2) < Low(StartIndex() + 2))
   {  return(true);
   }
   else if(T == POSITION_TYPE_SELL && Base(StartIndex()) > High(StartIndex()) && Base(StartIndex() + 1) < Low(StartIndex() + 1) && Base(StartIndex() + 2) > High(StartIndex() + 2))
   {  return(true);
   }
   return(false);
}

El hecho de que este sea nuestro cuarto patrón, que indexamos como patrón 3, implica realizar operaciones basándose únicamente en sus señales; por lo tanto, nuestro mapa de entrada para los patrones utilizados tendría que ser 8. Las pruebas se ejecutaron con configuraciones similares a las anteriores para este patrón durante el período de prueba y no se realizaron operaciones, por lo que no se pueden compartir resultados. No obstante, las causas comunes de estas falsas señales de cambio suelen ser las de siempre: mercados entrecortados o laterales, baja volatilidad o ruido del mercado. El impacto de esto en los operadores no suspicaces puede ser drástico, por lo que los indicadores secundarios (como el MACD), el análisis de la acción del precio (para soporte y resistencia), o el análisis del volumen (si esta información está disponible) pueden ayudar con esto. Dicho esto, esta señal debería ser más confiable que un único cambio, como el del patrón 0.

Doble giro del SAR con continuación de la tendencia

Este patrón, es nuestro patrón 3 más 2 vueltas más. Resulta en una continuación igual que el patrón 3, y de la misma manera que se puede argumentar que el patrón 3 es más fuerte que el patrón 0, este patrón, el 4, es más fiable o más fuerte que el patrón 3. Hemos proporcionado una implementación de código de esto como se indica a continuación, sin embargo, no estamos ejecutando pruebas para ello y estamos dejando esto al lector para una mayor exploración, que idealmente debería requerir un período de prueba más allá de la ventana de 1 año que estamos considerando. Dado que no se colocaron operaciones para el patrón 3 en 2023 para EURJPY en el diario, no esperamos ninguna señal y por lo tanto operaciones para el patrón 4.

//+------------------------------------------------------------------+
//| Check for Pattern 4.                                             |
//+------------------------------------------------------------------+
bool CSignalSAR::IsPattern_4(ENUM_POSITION_TYPE T)
{  if(T == POSITION_TYPE_BUY && 
   Base(StartIndex()) < Low(StartIndex()) && 
   Base(StartIndex() + 1) > High(StartIndex() + 1) && 
   Base(StartIndex() + 2) < Low(StartIndex() + 2) && 
   Base(StartIndex() + 3) > High(StartIndex() + 4) && 
   Base(StartIndex() + 4) < Low(StartIndex() + 5)
   )
   {  return(true);
   }
   else if(T == POSITION_TYPE_SELL && 
   Base(StartIndex()) > High(StartIndex()) && 
   Base(StartIndex() + 1) < Low(StartIndex() + 1) && 
   Base(StartIndex() + 2) > High(StartIndex() + 2) && 
   Base(StartIndex() + 3) < Low(StartIndex() + 4) && 
   Base(StartIndex() + 4) > High(StartIndex() + 5)
   )
   {  return(true);
   }
   return(false);
}

Divergencia SAR con Media Móvil

Patrón 5, se deriva de la divergencia. Dado que las divergencias entre los precios y el SAR son bastante comunes, el indicador de media móvil sirve como confirmación. Entonces, para una señal alcista, el precio estaría cayendo hacia el SAR mientras que el SAR también está subiendo y el promedio móvil está por debajo o igual al SAR. Por el contrario, en el patrón bajista, el precio subiría con un SAR descendente y el promedio móvil aún por encima o igual a ambos. La cantidad de pasos necesarios para medir un aumento o una disminución se puede determinar a discreción (o mediante pruebas); sin embargo, para nuestros propósitos simplemente los tomamos como tres. Por lo tanto, implementamos la función que llama a estos patrones de la siguiente manera:

//+------------------------------------------------------------------+
//| Check for Pattern 5.                                             |
//+------------------------------------------------------------------+
bool CSignalSAR::IsPattern_5(ENUM_POSITION_TYPE T)
{  if(T == POSITION_TYPE_BUY && 
   MA(StartIndex()) <= Base(StartIndex()) && 
   Base(StartIndex()) > Base(StartIndex() + 1) && 
   Base(StartIndex() + 1) > Base(StartIndex() + 2) && 
   Close(StartIndex()) < Close(StartIndex() + 1) && 
   Close(StartIndex() + 1) < Close(StartIndex() + 2)
   )
   {  return(true);
   }
   else if(T == POSITION_TYPE_SELL && 
   MA(StartIndex()) >= Base(StartIndex()) && 
   Base(StartIndex()) < Base(StartIndex() + 1) && 
   Base(StartIndex() + 1) < Base(StartIndex() + 2) && 
   Close(StartIndex()) > Close(StartIndex() + 1) && 
   Close(StartIndex() + 1) > Close(StartIndex() + 2)
   )
   {  return(true);
   }
   return(false);
}

La prueba de nuestro Asesor Experto ejecutando únicamente estos patrones nos arroja los siguientes resultados:

Vale la pena señalar que estamos tratando con tres buffers de datos aquí, a saber, los precios, la media móvil y el SAR. Nuestra desviación elegida es entre los precios y el SAR, aunque también se pueden considerar desviaciones alternativas, como entre la media móvil y el SAR. Esta divergencia, sin embargo, debido a los efectos retardados de la media móvil, también está destinada a ser un poco rezagada en comparación con la divergencia precio-SAR que hemos implementado para este artículo. Por otro lado, también es menos ruidoso, ya que la acción del precio produce mucha acción a corto plazo que a menudo no es significativa a largo plazo. Por lo tanto, podría tener algunos usos, y el lector es bienvenido a explorar esta vía también. La entrada para el uso de patrones para este patrón es 32.

Canalización SAR parabólico

El patrón de canalización SAR parabólico combina la acción del precio con la tendencia SAR actual para generar señales. Los canales de precios son relativamente fáciles de entender cuando se encuentran en un gráfico de precios, pero intentar poner esa lógica en código suele ser más complicado de lo que se imagina en un principio. Entonces, desde el principio, puede ser una buena idea definir una función rudimentaria que defina el límite superior y el límite inferior actuales de un canal de precios cuyo rango está determinado por la cantidad de barras de precios a observar en el historial. A esta función la llamamos 'Channel' y su lógica, que se encuentra en la interfaz, se comparte a continuación:

bool              Channel(ENUM_POSITION_TYPE T)
   {                 vector _max,_max_i;
                     vector _min,_min_i;
                     _max.Init(2);
                     _max.Fill(High(0));
                     _max_i.Init(2);
                     _max_i.Fill(0.0);
                     _min.Init(2);
                     _min.Fill(Low(0));
                     _min_i.Init(2);
                     _min_i.Fill(0.0);
                     for(int i=0;i<m_ma_period;i++)
                     {  if(High(i) > _max[0])
                        {  _max[0] = High(i);
                           _max_i[0] = i;
                        }
                        if(Low(i) < _min[0])
                        {  _min[0] = Low(i);
                           _min_i[0] = i;
                        }
                     }
                     double _slope = (Close(0) - Close(m_ma_period-1))/m_ma_period;
                     double _upper_scale = fabs(_slope);
                     double _lower_scale = fabs(_slope);
                     for(int i=0;i<m_ma_period;i++)
                     {  if(i == _max_i[0])
                        {  continue;
                        }
                        else
                        {  double _i_slope = (High(i) - _max[0])/(i - _max_i[0]);
                           if((_i_slope > 0.0 && _slope > 0.0)||(_i_slope < 0.0 && _slope < 0.0))
                           {  if(fabs(_i_slope-_slope) < _upper_scale)
                              {  _max[1] = High(i);
                                 _max_i[1] = i;
                              } 
                           }
                        }
                     }
                     for(int i=0;i<m_ma_period;i++)
                     {  if(i == _min_i[0])
                        {  continue;
                        }
                        else
                        {  double _i_slope = (Low(i) - _min[0])/(i - _min_i[0]);
                           if((_i_slope > 0.0 && _slope > 0.0)||(_i_slope < 0.0 && _slope < 0.0))
                           {  if(fabs(_i_slope-_slope) < _lower_scale)
                              {  _min[1] = Low(i);
                                 _min_i[1] = i;
                              } 
                           }
                        }
                     }
                     vector _projections;
                     _projections.Init(4);
                     _projections[0] = _max[0] + (_max_i[0]*_slope);
                     _projections[1] = _min[0] + (_min_i[0]*_slope);
                     _projections[2] = _max[1] + (_max_i[1]*_slope);
                     _projections[3] = _min[1] + (_min_i[1]*_slope);
                     if(T == POSITION_TYPE_BUY && Close(0) < Close(m_ma_period) && Close(0) < _projections.Mean())
                     {  return(true);
                     }
                     else if(T == POSITION_TYPE_SELL && Close(0) > Close(m_ma_period) && Close(0) > _projections.Mean())
                     {  return(true);
                     }
                     return(false);
   }

Los resultados principales de este canal serán, dado un tipo de posición, ¿el canal está indicando una posible reversión? Y para responder a esta pregunta, primero debemos determinar qué puntos de precio definen la línea superior y la línea inferior. Tan fácil como es distinguir visiblemente un gráfico de precios normal, en el código, uno podría fácilmente verse arrastrado a confiar en los fractales. Y si bien esto podría funcionar si el indicador fractal en uso es realmente bueno, descubrí que centrarse en la pendiente general del período de retrospección dado proporciona una solución más generalizable.

Entonces, para definir nuestro canal, primero obtenemos una idea de la pendiente a lo largo del período retrospectivo. Nuestro período de retrospección se establece para ser igual al período utilizado por el indicador de promedio móvil, que se destacó en el patrón 5 anterior. Los lectores pueden crear su propio parámetro secundario para definir esto, pero siempre creo que cuanto menos parámetros de entrada, más generalizable será el modelo. Entonces, una vez que tenemos la pendiente, necesitamos obtener los dos máximos en el período retrospectivo definido que mejor se alineen con esta pendiente.

Por lo general, sin embargo, siempre se espera que el punto más alto en el período de retrospección esté a lo largo de esta línea superior del canal, por lo tanto, si comenzamos obteniendo este valor máximo, luego necesitaremos revisar todos los otros máximos hasta que lleguemos a un segundo valor alto tal que su pendiente desde nuestro punto más alto esté más en línea con la pendiente de la tendencia general. Aquí, por supuesto, la tendencia general es el cambio de precio de cierre estrictamente a lo largo del período retrospectivo.

Una vez que tengamos estos dos puntos, haríamos lo mismo para el límite inferior del canal nuevamente, encontrando el mínimo más bajo y otro mínimo que se alinee mejor con la pendiente de la tendencia cuando se conecta al punto más bajo. Dos pares de puntos definen dos líneas y, por lo tanto, con ellos sí tienes un canal, basado únicamente en el período de retrospección. Al observar un gráfico de precios, uno ciertamente no va a adoptar un enfoque tan mecanicista, ya que es poco probable que un historial fijo tenga siempre suficientes puntos de datos para definir esto. Es por esto que simplemente conectar estos puntos e intentar extrapolarlos seguramente generará muchos canales aleatorios o salvajes. A menudo, un historial retrospectivo fijo no captura todos los puntos de precios históricos clave para el análisis.

Es por eso que definimos nuestro canal como si tuviera dos y no solo una línea de límite superior e inferior. Cada una de estas líneas pasaría por los 4 puntos que ya hemos definido anteriormente. Nuestra señal alcista con el patrón 6 es que el precio se encuentre en la mitad inferior del canal, y el SAR parabólico también indica una tendencia larga. Por el contrario, para los bajistas, el precio estaría en la mitad superior del canal, con el SAR indicando una tendencia bajista. Para determinar en qué mitad del canal se encuentra nuestro precio actual, simplemente tomaríamos la media de los cuatro puntos de precio de proyección. Estas proyecciones son simplemente extensiones de las líneas que pasan por nuestros dos puntos altos y dos puntos bajos hasta el índice actual, manteniendo la misma pendiente de la tendencia general. Implementamos este patrón de la siguiente manera en MQL5:

//+------------------------------------------------------------------+
//| Check for Pattern 6.                                             |
//+------------------------------------------------------------------+
bool CSignalSAR::IsPattern_6(ENUM_POSITION_TYPE T)
{  if(T == POSITION_TYPE_BUY && Base(StartIndex()) < Low(StartIndex()))
   {  return(Channel(T));
   }
   else if(T == POSITION_TYPE_SELL && Base(StartIndex()) > High(StartIndex()))
   {  return(Channel(T));
   }
   return(false);
}

Y probando con la misma configuración que usamos arriba para el EURJPY diario para 2023 obtenemos los siguientes resultados:

La entrada para el uso de patrones para este patrón es 64.

Conclusión

Hemos analizado 7 de los 10 patrones posibles del SAR parabólico y lo dejamos aquí por ahora para que este artículo no sea tan extenso. Los patrones que consideraremos en el artículo de seguimiento serán el SAR parabólico y la divergencia de volumen, el SAR invertido en un marco de tiempo superior y la superposición del SAR y el RSI. Cada uno de los patrones ya tratados en este artículo se puede explotar más e implementar de diversas maneras y formatos. Para este artículo y los dos anteriores similares, nos basamos en los métodos de patrón integrados del archivo de clase de señal, del cual hereda nuestra clase de señal personalizada. En los dos últimos artículos, declaramos y usamos un parámetro 'm_patterns_used' que era engañoso e innecesario porque nuestra clase padre ya tiene el parámetro 'm_patterns_usage'. Este último minimiza nuestros requisitos de codificación y, cuando se utiliza, también ofrece resultados más concisos porque el mapa de entrada real se utiliza correctamente.

Esto es algo que los lectores no deberían hacer y deberían realizar cambios en el código adjunto a estos dos artículos recientes en consecuencia. Además, cabe destacar, y quizás como conclusión de este artículo, que la implementación de canales de precios en Asesores Expertos no es muy común, por lo que en un artículo independiente podría analizar cómo esto también podría ser una clase de señal. Si bien la lectura visual de un gráfico de precios con un canal es sencilla porque los puntos definitorios del límite superior e inferior se pueden señalar fácilmente de manera visual, hacerlo en código no es lo mismo, por lo que esto es algo que también podemos considerar en un artículo futuro.

Finalmente, en estas series de patrones, estamos haciendo algo que va en contra de la corriente de algunas de las señales basadas en patrones incorporadas que vienen con la biblioteca estándar. Estamos optimizando las condiciones de umbral ideales para cada patrón. Esto va en contra de la convención de tener estos umbrales preestablecidos por el comerciante en función de su propia experiencia y observaciones al tratar con los indicadores. Si bien los resultados de nuestras pruebas parecen prometedores porque utilizamos múltiples patrones, se puede argumentar que son más difíciles de generalizar y, por lo tanto, de validar de forma cruzada. Por lo tanto, podría recomendarse que el comerciante asigne previamente estos pesos umbral en caso de que se vayan a utilizar múltiples patrones. Si se trata de utilizar un solo patrón, que es algo que podemos adaptar, como se compartió en un artículo anterior que enumeraba los valores del mapa de entrada para cada patrón individual, entonces se podría argumentar a favor de optimizar solo para este umbral.