Desarrollo de un kit de herramientas para el análisis de la acción del precio (Parte 29): Boom and Crash Interceptor EA

Contenido

• Introducción
• Comprender la estrategia
• Desglose del código
• Backtesting y resultados
• Conclusión

Introducción

En las redes modernas de defensa aérea, un conjunto de sensores distribuidos en capas evalúa cada eco de radar y cada traza infrarroja con precisión forense. Se miden la velocidad, la trayectoria y la firma de cada contacto, y a continuación se cotejan con una amplia base de datos de amenazas. Solo cuando varios filtros independientes coinciden, el sistema autoriza el lanzamiento de un interceptor, lo que permite ahorrar recursos al tiempo que garantiza que las amenazas reales se neutralicen sin demora.

El EA «Boom & Crash Interceptor» adopta el mismo enfoque disciplinado respecto a los datos del mercado. Una ventana de velocidad móvil determina si el impulso actual del precio supera el comportamiento reciente; un multiplicador de impulso basado en ATR confirma que la volatilidad se ha ampliado de forma significativa; y los filtros de tendencia de media móvil validan la tendencia direccional. Los filtros opcionales de zona de pivote y de horario de sesión suprimen aún más las señales que, de otro modo, surgirían durante los periodos de escasa liquidez. 

Cuando todas las capas lo confirman, el EA traza una flecha definitiva con la indicación «BOOM» o «CRASH» en el gráfico, con colores, desplazamientos y registro en CSV definidos por el usuario. Esto garantiza que la atención se centre en las oportunidades con mayor probabilidad de éxito. En las páginas siguientes se explica cómo se puede calibrar cada capa de detección y cómo implementar esta herramienta MQL5 como un componente sólido y basado en señales dentro de un marco de negociación más amplio.

Comprender la estrategia

Inspirándose en los sistemas de defensa antimisiles, el Boom & Crash Interceptor EA aborda movimientos bruscos del mercado como si fueran amenazas inminentes. Históricamente, incluso una lanza o flecha arrojada podía considerarse un “misil”, en el sentido de proyectil dirigido hacia un objetivo. Las variantes modernas son cohetes autopropulsados equipados con ojivas y guiados por sistemas inerciales, de radar, satelitales u ópticos; entre los ejemplos se incluyen desde misiles balísticos intercontinentales (ICBM) hasta misiles de crucero y proyectiles defensivos tierra-aire. Históricamente, incluso una lanza o una flecha lanzada se considera un proyectil, ya que su trayectoria se dirige deliberadamente hacia un objetivo.

En el ámbito bursátil, una subida repentina y brusca del precio puede resultar igual de peligrosa: se produce rápidamente, a menudo de forma inesperada, y puede causar graves pérdidas a una cuenta que no esté preparada. En este caso, la analogía con los misiles interceptores resulta muy útil. Un interceptor de misiles es un sistema defensivo que detecta, sigue y neutraliza una ojiva enemiga antes de que impacte. Su funcionamiento se desarrolla en cuatro fases estrechamente integradas:

Detección y seguimiento

• Los sensores terrestres, embarcados o espaciales detectan el lanzamiento de un proyectil hostil.
• El software de control de fuego calcula la trayectoria, la velocidad y el punto de impacto previsto.

Lanzamiento y guiado

• Una vez verificado, un misil interceptor despega desde un silo, un vehículo, una embarcación o una aeronave.
• Las correcciones de rumbo se realizan mediante guía inercial, enlaces de datos a mitad de trayectoria y guía por radar o infrarrojos en la fase terminal.

Métodos de interceptación (destrucción del objetivo)

• «Hit-to-kill»: el interceptor choca directamente contra la ojiva a velocidades de aproximación superiores a Mach 10, utilizando la energía cinética para destruirla.
• Explosión de proximidad: una detonación controlada cerca del objetivo que lo destroza o lo desvía mediante metralla o una onda de choque concentrada.

Defensa por capas

• Los sistemas de corto alcance (por ejemplo, el Patriot PAC-3) interceptan las amenazas en la fase terminal.
• Los sistemas de defensa de fase intermedia (por ejemplo, el SM-3 o el sistema de defensa de fase intermedia terrestre) atacan en el espacio.
• Los conceptos de la «fase de impulso», aún en fase experimental, se centran en los misiles en los instantes inmediatamente posteriores al lanzamiento.

Estas capas tienen como objetivo maximizar la protección y minimizar los disparos erróneos, un equilibrio que se consigue mediante una rápida fusión de datos y una rigurosa lógica de confirmación.

El EA «Boom & Crash Interceptor» refleja esta arquitectura. La vigilancia continua del mercado funciona como una red de radares; los umbrales de velocidad, los filtros de picos de ATR y la alineación de medias móviles actúan como capas de confirmación independientes; los filtros opcionales de zona de pivote y de sesión imitan la discriminación de señuelos; y, solo cuando se cumplen todos los criterios, el EA «se activa» trazando una flecha de «BOOM» o «CRASH» y registrando el evento. De este modo, reserva la atención de los operadores y el capital de negociación para aquellas amenazas que realmente merecen una respuesta, del mismo modo que una batería de defensa antimisiles reserva sus interceptores para las ojivas que suponen un peligro real.

Figura 1: Estrategia

Radar de velocidad

Mide la variación del precio a lo largo de VelocityHistoryBars y la compara con un umbral percentil histórico; solo se tienen en cuenta los movimientos «inusualmente grandes».

// Record current vs. old price
double priceNow = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
double priceOld = velHistory[VelocityHistoryBars - 1];
double delta    = priceNow - priceOld;

// Build and sort past deltas
double d[];
ArrayResize(d, VelocityHistoryBars - 1);
for(int i = 1; i < VelocityHistoryBars; i++)
    d[i - 1] = velHistory[0] - velHistory[i];
ArraySort(d);

// Pick the (100–VelocityPctile)% threshold
int idx      = (int)MathRound((VelocityPctile / 100.0) * (ArraySize(d) - 1));
double velTh = d[ArraySize(d) - 1 - idx];

// Pass if current move exceeds threshold
bool okVel = (delta > velTh || delta < -velTh);

Detector de sobretensión ATR

Comprueba si se ha producido un aumento repentino de la volatilidad comparando el ATR más reciente con el ATR de la barra anterior multiplicado por ATRMultiplier.

// Fetch two most recent ATR values
double atrArr[2];
CopyBuffer(atrHandle, 0, 0, 2, atrArr);

// Pass if ATR_now > ATR_prev × ATRMultiplier
bool okATR = (atrArr[0] > atrArr[1] * ATRMultiplier);

Comprobación de la alineación con las tendencias

Garantiza que la evolución del precio se ajuste a la tendencia, comprobando que la media móvil simple (SMA) también suba en las fases alcistas (o baje en las bajistas).

// Fetch two most recent SMA values
double maArr[2];
CopyBuffer(maHandle, 0, 0, 2, maArr);

// If delta>0 require SMA_now>SMA_prev; if delta<0 require SMA_now<SMA_prev
bool okTrend = (delta > 0 
                ? maArr[0] > maArr[1] 
                : maArr[0] < maArr[1]);

Filtro de zona de pivote (opcional)

Bloquea las señales que se encuentran demasiado cerca del punto de pivote de la barra anterior, aplicando un margen de ZoneBufferPoints.

// Compute prior bar’s pivot
double h1    = iHigh(_Symbol, MainTF, 1),
       l1    = iLow (_Symbol, MainTF, 1),
       c1    = iClose(_Symbol, MainTF, 1);
double pivot = (h1 + l1 + c1) / 3.0;

// Pass if priceNow is beyond pivot ± buffer
bool okZone = (delta > 0
               ? priceNow < pivot - ZoneBufferPoints * _Point
               : priceNow > pivot + ZoneBufferPoints * _Point);

Lógica final del «lanzamiento de misiles»

Lanza un «Boom» (flecha hacia arriba) o un «Crash» (flecha hacia abajo) solo cuando se superan todos los filtros.

// Determine direction
bool isBoom  = (delta  >  velTh);
bool isCrash = (delta  < -velTh);

// Fire only if velocity, ATR, trend, and zone all passed
bool fire    = ((isBoom || isCrash) && okVel && okATR && okTrend && okZone);

if(fire)
    GenerateSignal(isBoom, priceNow, delta, atrArr[0], MainTF);

Desglose del código

A continuación se ofrece una guía paso a paso de todas las secciones principales del asesor experto «Boom & Crash Interceptor».

Directivas de encabezado y de compilación

El bloque de comentarios inicial y las líneas #property posteriores actúan como la «tarjeta de visita» del EA. En ellas se indican la titularidad de los derechos de autor, un enlace de asistencia técnica, la versión actual y la directiva de compilación estricta. La compilación en modo estricto obliga a MetaTrader 5 a aplicar las comprobaciones de tipo y rango más rigurosas, lo que nos ayuda a detectar errores latentes en una fase temprana del proceso de compilación. Estos detalles también permiten a MetaQuotes Market realizar un seguimiento del historial del producto y facilitar actualizaciones fluidas y versionadas para los usuarios finales.

//+------------------------------------------------------------------+
//|                                     Boom and Crash Interceptor EA|
//|                                   Copyright 2025, MetaQuotes Ltd.|
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, MetaQuotes Ltd."
#property link      "https://www.mql5.com/en/users/lynnchris"
#property version   "1.0"
#property strict

Inclusión de biblioteca y objeto de trading

Al incluir <Trade\Trade.mqh> y crear una instancia del objeto global CTrade, el código obtiene acceso a un envoltorio orientado a objetos para la API de negociación de MetaTrader. Aunque la versión actual solo genera alertas y gráficos, la presencia de este objeto prepara la base del código para una migración fluida a la ejecución de órdenes en tiempo real cuando sea necesario.

#include <Trade\Trade.mqh>
CTrade trade;            // object-oriented trading wrapper

Entradas externas: el panel de control del EA

Todos los parámetros de ejecución se declaran con la palabra clave «input», lo que permite su optimización en el Probador de estrategias o su rápida modificación en la pestaña «Parámetros de entrada» del gráfico. Se dividen en cuatro grupos lógicos:

• Ajustes de generación de señales: intervalos de tiempo, período de retrospectiva de la velocidad, parámetros ATR, parámetros de la media móvil.

• Filtros opcionales: lógica de zona de pivote y horario de sesión.

• Ajustes de presentación: ubicación del panel de control, colores, grosor de las líneas y desplazamientos de las flechas.

• Registro de datos: nombre del archivo CSV.

input ENUM_TIMEFRAMES MainTF            = PERIOD_CURRENT; // Signal TF
input int            VelocityHistoryBars = 96;
input double         VelocityPctile      = 120.0;          // >100 ⇒ extreme
input int            ATRPeriod           = 14;
input double         ATRMultiplier       = 1.5;
input bool           UseZoneFilter       = true;
input int            SessionStartHour    = 7;
input int            SessionEndHour      = 17;
input string         LogFilename         = "BoCrashLog.csv";

Un matiz interesante es el valor predeterminado de VelocityPctile, que es del 120 %. Dado que el algoritmo de percentiles tiene un límite máximo en el extremo de la distribución, establecer un valor superior al 100 % exige, en la práctica, que el precio supere el movimiento más brusco observado dentro de la ventana de análisis retrospectivo, lo que hace que el umbral de activación sea deliberadamente selectivo.

Variables globales y convenciones de nomenclatura

La matriz velHistory[] almacena la ventana móvil necesaria para el análisis de la velocidad, mientras que varias constantes de cadena centralizan los nombres de los objetos de la interfaz gráfica de usuario. La consolidación de los nombres en matrices (dashNames, hVelUp, etc.) garantiza una creación y eliminación deterministas, lo que evita que queden objetos huérfanos y simplifica la refactorización futura.

double  velHistory[];
string  dashBG      = "DashBG";
string  dashNames[] = {"Delta","VelThr","ATR","ATRm","Trend",
                       "Pivot","Zone","Signal"};
string  hVelUp      = "VelUp";
string  hVelDown    = "VelDown";

OnInit(): adquiere recursos y construye la interfaz gráfica de usuario

Durante la inicialización, redimensionamos la matriz de velocidades, obtenemos los identificadores de los indicadores ATR y de media móvil, y terminamos con INIT_FAILED si algún identificador no está disponible —es preferible un fallo temprano a la inestabilidad en tiempo de ejecución—. A continuación, el EA abre o crea el archivo de registro CSV, escribiendo un encabezado si el archivo es nuevo y desplazándose hasta el final para añadir los registros posteriores. Por último, la rutina crea un rectángulo semitransparente en el panel de control, lo rellena con etiquetas de texto y precrea líneas de referencia horizontales y verticales. Todos los elementos gráficos aparecen en el gráfico antes de que llegue el primer tick del mercado.

int OnInit()
  {
   ArrayResize(velHistory,VelocityHistoryBars);

   atrHandle = iATR(_Symbol, ATRTF, ATRPeriod);
   maHandle  = iMA (_Symbol, TrendTF, TrendMAPeriod, 0, MODE_SMA, PRICE_CLOSE);
   if(atrHandle==INVALID_HANDLE || maHandle==INVALID_HANDLE)
      return INIT_FAILED;

   logHandle = FileOpen(LogFilename, FILE_READ|FILE_WRITE|FILE_CSV|FILE_ANSI);
   if(logHandle>=0 && FileSize(logHandle)==0)
         FileWrite(logHandle,"DateTime,Type,Velocity,ATR,Price");

   // dashboard background
   ObjectCreate(0,dashBG,OBJ_RECTANGLE_LABEL,0,0,0);
   ObjectSetInteger(0,dashBG,OBJPROP_XSIZE,200);
   ObjectSetInteger(0,dashBG,OBJPROP_YSIZE,140);

   // dashboard labels
   for(int i=0;i<ArraySize(dashNames);i++)
     {
      string name="Dash_"+dashNames[i];
      ObjectCreate(0,name,OBJ_LABEL,0,0,0);
      ObjectSetString(0,name,OBJPROP_TEXT,dashNames[i]+": ?");
     }

   // reference lines
   ObjectCreate(0,hVelUp ,OBJ_HLINE,0,0,0);
   ObjectCreate(0,hVelDown,OBJ_HLINE,0,0,0);
   return INIT_SUCCEEDED;
  }

OnDeinit(): apagado ordenado

Al eliminarse, el EA libera los identificadores de los indicadores, cierra el identificador del archivo y elimina todos los objetos gráficos a los que se hace referencia en las matrices de nombres. Esta simetría entre la creación y la destrucción es fundamental para mantener limpia la lista de objetos del terminal y ahorrar recursos del sistema operativo.

void OnDeinit(const int reason)
  {
   if(atrHandle!=INVALID_HANDLE) IndicatorRelease(atrHandle);
   if(maHandle !=INVALID_HANDLE) IndicatorRelease(maHandle);
   if(logHandle>=0)              FileClose(logHandle);

   string objs[]={dashBG,hVelUp,hVelDown};
   for(int i=0;i<ArraySize(objs);i++) ObjectDelete(0,objs[i]);
   for(int i=0;i<ArraySize(dashNames);i++)
      ObjectDelete(0,"Dash_"+dashNames[i]);
  }

OnTick(): motor de toma de decisiones en tiempo real

La rutina comprueba en primer lugar si se ha cerrado una nueva barra en MainTF. Si no es así, la función vuelve inmediatamente, evitando cálculos innecesarios. En caso de que se detecte una transición de barra, el código tiene en cuenta el filtro de sesión opcional, garantizando que las operaciones se realicen únicamente dentro de la ventana definida por el operador.

void OnTick()
  {
   // process only on completed bar
   int cur=iBars(_Symbol,MainTF)-1;
   if(cur==lastBar) return;
   lastBar=cur;

   // optional session filter
   MqlDateTime now; TimeToStruct(TimeCurrent(),now);
   if(UseSessionFilter && (now.hour<SessionStartHour || now.hour>SessionEndHour))
      return;

   // velocity calculation
   double priceNow = SymbolInfoDouble(_Symbol,SYMBOL_ASK);
   ArrayMove(velHistory,1,0,VelocityHistoryBars-1); // shift right
   velHistory[0]=priceNow;
   double delta  = priceNow-velHistory[VelocityHistoryBars-1];
   double velTh  = ComputeVelocityPercentile(velHistory,VelocityPctile);
   bool   okVel  = (delta>velTh || delta<-velTh);

   // ATR, MA, pivot-zone checks ...
   /* …remaining signal logic… */

   if(fire) GenerateSignal(isBoom,priceNow,delta,atrArr[0],MainTF);
  }

A continuación, el último precio ask se inserta al principio de velHistory, desplazando las entradas más antiguas un índice hacia abajo. Calculamos el delta, es decir, la distancia entre el precio más reciente y el más antiguo de la ventana, y obtenemos un umbral de percentil mediante ComputeVelocityPercentile(). Una condición de velocidad se cumple cuando el delta supera el umbral superior o inferior.

Los filtros ATR y de media móvil se evalúan en marcos temporales potencialmente diferentes y más cortos, captando el aumento de la volatilidad a corto plazo y confirmando la tendencia direccional. El filtro de zona de pivote, cuando está activado, calcula un pivote clásico H+L+C sobre la vela anterior y limita las señales a los movimientos que aún se encuentran en el lado «incorrecto» de ese pivote más un margen configurable, buscando así el potencial de reversión a la media.

El panel de control se actualiza con los valores de diagnóstico sin procesar; los colores indican de inmediato si se cumple cada criterio. Al mismo tiempo, las líneas de velocidad horizontal y de pivote, así como la línea de sincronización vertical, se reubican para mantener el contexto visual del gráfico sincronizado con la barra más reciente. Una señal solo se considera válida si los cuatro filtros —pico de velocidad, aumento del ATR, coincidencia de tendencia y superación de la zona— devuelven el valor «true».

Función auxiliar: UpdateLabel()

Esta pequeña rutina centraliza las actualizaciones de texto y color del panel de control. Al agrupar el formato en un único lugar, garantizamos un estilo coherente y facilitamos los ajustes estéticos generales.

void UpdateLabel(int idx,string txt,bool pass)
  {
   string name="Dash_"+dashNames[idx];
   ObjectSetString (0,name,OBJPROP_TEXT ,txt);
   ObjectSetInteger(0,name,OBJPROP_COLOR, pass ? clrLime : clrRed);
  }

Función auxiliar: ComputeVelocityPercentile()

El algoritmo convierte la serie de precios almacenada en una lista de deltas con signo, ordena la lista y la indexa según el percentil solicitado por el usuario. Al seleccionar datos del extremo de la matriz ordenada, el método puede respetar el signo del movimiento (auge o caída) sin necesidad de lógica adicional. Los valores percentiles superiores al 100 % se reducen al valor máximo, lo que impone un umbral de «valor extremo histórico dentro del intervalo».

double ComputeVelocityPercentile(double &hist[],double pct)
  {
   int n=ArraySize(hist);
   if(n<2) return 0;
   double d[]; ArrayResize(d,n-1);
   for(int i=1;i<n;i++) d[i-1]=hist[0]-hist[i];
   ArraySort(d);                        // ascending
   int idx=(int)MathRound((pct/100.0)*(ArraySize(d)-1));
   return d[ArraySize(d)-1-idx];        // mirror to get extreme with sign
  }

Función auxiliar: SetHLine()

Al manipular las propiedades de los objetos existentes en lugar de volver a crear líneas, este método evita el parpadeo y el retraso gráfico, lo que permite mantener una experiencia de usuario fluida incluso en equipos con especificaciones más modestas.

void SetHLine(string name,double price,color clr)
  {
   ObjectSetDouble (0,name,OBJPROP_PRICE, price);
   ObjectSetInteger(0,name,OBJPROP_COLOR, clr);
   ObjectSetInteger(0,name,OBJPROP_WIDTH, 1);
  }

Función auxiliar: GenerateSignal()

Cuando se cumplen todos los filtros, esta rutina dibuja una flecha de Wingdings codificada por colores a una cierta distancia del mínimo (boom) o del máximo (crash) de la barra, registra una entrada detallada en el registro CSV (marca de tiempo, tipo, delta, ATR, precio) y activa una alerta sonora. Al mantener CTrade en el ámbito, convertir estos marcadores visuales en órdenes activas solo implica llamar a trade.Buy() o trade.Sell() aquí.

void GenerateSignal(bool isBoom,double price,double delta,
                    double atr,ENUM_TIMEFRAMES tf)
  {
   int    code = isBoom ? 233 : 234;
   double y    = isBoom ? iLow(_Symbol,tf,0)-ArrowOffsetPips*_Point
                        : iHigh(_Symbol,tf,0)+ArrowOffsetPips*_Point;
   color  clr  = isBoom ? BoomArrowColor : CrashArrowColor;
   string tag  = (isBoom?"BOOM":"CRASH")+"_"+
                 TimeToString(TimeCurrent(),TIME_SECONDS);

   datetime t0 = iTime(_Symbol,tf,0);
   ObjectCreate(0,tag,OBJ_ARROW,0,t0,y);
   ObjectSetInteger(0,tag,OBJPROP_ARROWCODE,code);
   ObjectSetInteger(0,tag,OBJPROP_COLOR,clr);

   if(logHandle>=0)
      FileWrite(logHandle,TimeToString(TimeCurrent(),TIME_DATE|TIME_SECONDS),
                isBoom?"BOOM":"CRASH",DoubleToString(delta,2),
                DoubleToString(atr,_Digits),DoubleToString(price,_Digits));

   Alert((isBoom?"BOOM":"CRASH")+" signal @"+
         DoubleToString(price,_Digits));
  }

Objetivos estratégicos y oportunidades de expansión.

// Inside GenerateSignal(), after drawing the arrow:
double lot   = 0.02;                        // example risk sizing
double sl    = isBoom ? price - atr*2 : price + atr*2;
double tp    = pivot;                       // mean-reversion target

if(AutoTrade)                               // user-controlled switch
  {
   if(isBoom) trade.Buy(lot,_Symbol,price,sl,tp,"Boom-auto");
   else       trade.Sell(lot,_Symbol,price,sl,tp,"Crash-auto");
  }

En términos conceptuales, el EA busca aceleraciones explosivas de una sola barra que se produzcan en medio de una nueva expansión de la volatilidad, pero que sigan posicionadas para una reversión a la media hacia el pivote anterior. Este comportamiento es característico de los índices de auge y caída, en los que los picos bruscos suelen retroceder. Actualmente, el código genera alertas informativas; para integrar la ejecución automatizada sería necesario añadir el cálculo del tamaño de la posición, el stop-loss (por ejemplo, la línea de velocidad opuesta) y la lógica de take-profit (quizás el punto de pivote o la mitad del margen de seguridad). Por último, el desplazamiento de la matriz lineal dentro de velHistory es aceptable para la ventana predeterminada de 96 barras, pero podría sustituirse por un búfer circular en caso de que el usuario optara por historiales mucho más amplios.

Backtesting y resultados

Antes de poner en marcha nuestro sistema de interceptación, realicemos una prueba retrospectiva exhaustiva en una cuenta de demostración para ajustar su configuración:

1. Compilar y cargar

Una vez que tu EA se haya compilado correctamente en MetaEditor, cambia a MetaTrader.

2. Abrir el Probador de estrategias

En la barra de herramientas de MetaTrader, haz clic en el icono «Probador de estrategias». Elige tu EA «Boom & Crash Interceptor» de la lista de expertos.

3. Configura tu prueba

• Símbolo y marco temporal: Selecciona el instrumento exacto y el marco temporal principal con los que operarás en vivo.
• Período: Elige un intervalo que abarque diferentes condiciones de mercado (tranquilo, con tendencia, volátil).
• Parámetros: Ajusta VelocityHistoryBars, VelocityPctile, ATRMultiplier, TrendMAPeriod, ZoneBufferPoints, etc., para ver cómo influyen en la frecuencia y la precisión de la señal.
• Ejecución: Utiliza el modo «Cada tick» para obtener los resultados más precisos.

4. Ejecutar y revisar

Haz clic en «Empezar». Una vez finalizada la prueba retrospectiva, examina la curva de capital, la lista de señales y cualquier interceptación fallida o tardía. Fíjate en los puntos en los que las señales se agrupaban o no detectaban picos reales.

5. Perfeccionar y repetir

Ajusta uno o dos parámetros cada vez, por ejemplo, reduce el percentil de velocidad o amplía el margen de pivote, y luego vuelve a probar. Repite el proceso hasta que los resultados de tu demostración muestren señales de «Boom» y «Crash» claras y repetibles, con una caída máxima aceptable.

Una vez que estés seguro del rendimiento del EA tras varias pruebas en cuenta demo, estarás listo para implementarlo en una cuenta real con un riesgo controlado.

A continuación, voy a compartir los resultados de la prueba retrospectiva del EA «Boom & Crash Interceptor», y he encontrado los resultados especialmente reveladores.

Figura 2: Pruebas retrospectivas de Boom 900

En la prueba retrospectiva de Boom 900, nuestro EA registró todas las señales de «Boom» y «Crash» en el diario, tal y como se esperaba. La línea de pivote aparece en azul y el umbral de velocidad en naranja, lo que ofrece una guía visual clara. También verás flechas verdes hacia arriba que indican cada «BOOM» y flechas rojas hacia abajo que indican cada «CRASH». A continuación, he incluido una imagen fija para que se vea claramente lo que aparecía en el GIF.

Figura 3: Resultados de las pruebas retrospectivas

Conclusión

Hemos desarrollado y sometido a rigurosas pruebas retrospectivas el EA «Boom & Crash Interceptor», y los resultados hablan por sí solos. Detecta con precisión los movimientos extremos de los precios mediante el seguimiento de la velocidad, los picos del ATR, la alineación con la tendencia y las rupturas de las zonas de pivote, y a continuación traza únicamente las flechas más claras de «Boom» (verde) o «Crash» (rojo). Nuestra ejecución de demostración del Boom 900 registró todas las señales, representó las líneas de pivote y de velocidad en azul y naranja, y la imagen fija reproduce fielmente lo mostrado en el GIF.

Dicho esto, es posible que algunas señales aún puedan beneficiarse de un filtrado adicional. Piensa en este EA como tu radar táctico, no como un ejecutor de órdenes autónomo; ten siempre en cuenta tus propios criterios relacionados con la hora del día, los patrones o los análisis fundamentales antes de dar el paso. Y si quieres reducir aún más los falsos positivos, cambia a marcos temporales más amplios (H1, H4 o diario) para suavizar el ruido.

Gracias a unas pruebas retrospectivas rigurosas, un filtrado inteligente y una implementación en vivo controlada, el EA «Boom & Crash Interceptor» se convierte en un auténtico interceptor de picos de mercado, lo que te permite ir por delante del resto, en lugar de tener que ir a la zaga de cada movimiento.

Chart Projector	Analytical Comment	Analytics Master	Analytics Forecaster	Volatility Navigator	Mean Reversion Signal Reaper
Signal Pulse	Metrics Board	External Flow	VWAP	Heikin Ashi	FibVWAP
RSI DIVERGENCE	Parabolic Stop and Reverse (PSAR)	Quarters Drawer Script	Intrusion Detector	TrendLoom Tool	Quarters Board
ZigZag Analyzer	Correlation Pathfinder	Market Structure Flip Detector Tool	Correlation Dashboard	Currency Strength Meter	PAQ Analysis Tool
Dual EMA Fractal Breaker	Pin bar, Engulfing and RSI divergence	Liquidity Sweep	Opening Range Breakout Tool	Boom and Crash Interceptor