Desarrollo de un kit de herramientas para el análisis de la acción del precio (Parte 15): Introducción a la teoría de los cuartos (I) - Dibujando la teoría de cuartos

MetaTrader 5 — Ejemplos | 7 enero 2026, 09:18

113

Christian Benjamin

Contenido

Introducción

En cada mercado los precios se mueven en ciclos. Independientemente de que los precios tiendan a subir o a bajar, oscilan repetidamente dentro de rangos definidos. Con el tiempo, los comerciantes han desarrollado muchas teorías para explicar estos patrones. En nuestra serie actual, estamos creando un completo kit de herramientas de análisis de la acción del precio. Hoy presentamos un enfoque innovador que hemos automatizado utilizando MQL5 para simplificar la aplicación y lograr resultados impresionantes.

La teoría de los cuartos es el foco de este artículo. Fue desarrollado por Ilian Yotov, un nombre familiar para miles de operadores de divisas y estrategas de Forex por su trabajo en Traders Television Network. Ilian fundó AllThingsForex.com y TraderTape.com y presenta el popular programa diario All Things Forex. Su teoría sugiere que se producen movimientos de precios significativos entre dos grandes puntos de cuarto y progresan en incrementos de 250 pips. Este método ofrece marcadores claros para identificar niveles clave de soporte y resistencia y al mismo tiempo brinda a los operadores información práctica.

Este artículo es la primera parte sobre nuestra teoría de cuartos. En esta entrega, nos centramos en construir los cuartos utilizando nuestro código «Quarters Drawer». Al automatizar el trazado de estos niveles cruciales, ofrecemos un punto de partida práctico para visualizar las zonas clave de reversión y continuación. A medida que avancemos en esta teoría, desarrollaremos herramientas aún más sólidas para respaldar la generación de señales y el análisis avanzado de mercados.

Descripción general del concepto

La teoría de los cuartos es un enfoque de análisis técnico que divide un rango de precios significativo en segmentos más pequeños y significativos. En este marco, un «MajorStep» por ejemplo, 0,1000 en pares de divisas como el EURUSD, define la diferencia entre números enteros importantes (como 1,2000 y 1,3000). Este rango se subdivide a su vez en cuatro partes iguales, conocidas como cuartos grandes. Cada cuarto grande representa un nivel crítico en el que el precio puede detenerse, revertirse o acelerarse, lo que ofrece a los operadores posibles áreas de soporte y resistencia.

Componentes clave de la teoría de cuartos:

Números enteros principales: Son los niveles primarios (por ejemplo, 1,2000, 1,3000) que enmarcan el rango de negociación. Se utilizan como puntos de referencia para construir la estructura más detallada de la teoría.
Líneas de cuartos grandes: El intervalo entre dos niveles principales se divide en cuatro segmentos iguales. Estas líneas indican los niveles intermedios que a menudo desempeñan un papel importante en el comportamiento de los precios. Los traders utilizan estos niveles para anticipar posibles puntos de inflexión o áreas de consolidación.
Líneas de cuartos pequeños (opcional): Para mayor precisión, cada segmento de 100 pips se puede subdividir en intervalos aún más pequeños, los cuartos pequeños. Si bien estas líneas ofrecen granularidad adicional, el enfoque principal sigue estando en los grandes niveles de cuartos.
Áreas Overshoot/Undershoot: Alrededor de cada línea trimestral grande, se dibujan ligeros desplazamientos (Overshoot/Undershoot) para señalar las zonas en las que el precio podría superar o quedarse por debajo del nivel esperado momentáneamente. Estas áreas ayudan a identificar posibles correcciones o reversiones.

Para obtener más información, consulte los siguientes diagramas.

Cuartos

Figura 1. Los cuartos

Cuartos

Figura 2. Los cuartos

Al marcar visualmente estos niveles clave en un gráfico, la teoría de los cuartos proporciona a los operadores una forma estructurada de evaluar la dinámica de los precios. El enfoque se implementa en el código «Quarters Drawer», que dibuja líneas distintas con diferentes estilos y colores para mejorar la claridad, asegurando que cada grupo (líneas principales, cuartos grandes y cuartos pequeños) sea fácilmente distinguible. Esta herramienta visual refuerza la teoría al resaltar claramente los segmentos de precios cruciales.

Implementación en MQL5

El primer bloque del código incluye un comentario de encabezado que proporciona detalles esenciales, como el nombre del código, la versión, la información de derechos de autor y un enlace al perfil del autor. A continuación, las declaraciones de propiedad incorporan metadatos importantes (como los derechos de autor y la versión) y aplican ajustes de compilación estrictos. Esta combinación establece la identidad del script y garantiza que cumpla con estrictos estándares de codificación.

//+------------------------------------------------------------------+
//|                                              Quarters Drawer.mql5|
//|                                Copyright 2025, Christian Benjamin|
//|                           https://www.mql5.com/en/users/lynnchris|
//+------------------------------------------------------------------+
#property copyright "Christian Benjamin"
#property link      "https://www.mql5.com/en/users/lynnchris"
#property version   "1.0"
#property strict

A continuación, se definen los parámetros de entrada para que los usuarios tengan un control total sobre el comportamiento y la apariencia del código. Aquí, se establece el intervalo entre los niveles de precios principales con un parámetro como MajorStep y se utilizan indicadores booleanos para alternar el dibujo de líneas de cuartos grandes, líneas de cuartos pequeñas y marcadores Overshoot/Undershoot. Por ejemplo, si DrawLargeQuarters se establece en verdadero, el script dibujará líneas de cuartos grandes, pero si se cambia a falso, se evitará que aparezcan.

Lo mismo se aplica a DrawSmallQuarters y DrawOvershootAreas. Si no desea ver las líneas de los cuartos pequeños o las zonas Overshoot/Undershoot, simplemente cambie sus valores a falso. Esto facilita la personalización de la visualización sin modificar la lógica central. Además, se proporcionan ajustes de color y opciones de estilo y grosor de línea para cada tipo de línea, lo que permite a los traders personalizar fácilmente la salida visual para que se adapte a sus preferencias personales y estrategias de trading.

//---- Input parameters -------------------------------------------------
input double MajorStep          = 0.1000;   // Difference between major whole numbers.
input bool   DrawLargeQuarters  = true;     // Draw intermediate large quarter lines.
input bool   DrawSmallQuarters  = true;     // Draw small quarter lines.
input bool   DrawOvershootAreas = true;     // Mark overshoot/undershoot areas for large quarter lines.

//---- Color settings ---------------------------------------------------
input color  MajorColor         = 0x2F4F4F; // Dark Slate Gray for major lines.
input color  LargeQuarterColor  = 0x8B0000; // Dark Red for large quarter lines.
input color  SmallQuarterColor  = 0x00008B; // Dark Blue for small quarter lines.
input color  OvershootColor     = clrRed;   // Red for overshoot/undershoot lines.

//---- Group style and thickness settings -------------------------------
input ENUM_LINE_STYLE MajorLineStyle       = STYLE_SOLID;
input int    MajorLineWidth                 = 4;
input ENUM_LINE_STYLE LargeQuarterLineStyle  = STYLE_DOT;
input int    LargeQuarterLineWidth          = 3;
input ENUM_LINE_STYLE OvershootLineStyle     = STYLE_DASH;
input int    OvershootLineWidth             = 1;
input ENUM_LINE_STYLE SmallQuarterLineStyle  = STYLE_SOLID;
input int    SmallQuarterLineWidth          = 1;

Cuando veas códigos de color hexadecimales en el código, estos representan colores específicos mediante la combinación de valores de rojo, verde y azul. Por ejemplo:

0x2F4F4F – Este código corresponde al color gris pizarra oscuro (Dark Slate Gray). Los pares de dos dígitos representan los componentes rojo, verde y azul, respectivamente. Aquí, «2F» (47 en decimal) es para el rojo, y «4F» (79 en decimal) para el verde y el azul, creando un tono gris frío y apagado que es ideal para las líneas principales de un gráfico.
0x8B0000 – Este código representa el color rojo oscuro (Dark Red). En este valor, «8B» (139 en decimal) es un componente rojo intenso, mientras que los componentes verde y azul son «00» (cero), lo que da como resultado un rojo profundo e intenso. Este color se utiliza en el guion para resaltar las líneas de cuarto grandes.
0x00008B – Este código significa azul oscuro (Dark Blue). En este caso, los componentes rojo y verde son «00», y el componente azul es «8B» (139 en decimal), lo que da como resultado un color azul intenso. Esto se aplica a pequeñas líneas de cuarto, proporcionando un contraste visual distintivo.

Además de estos valores hexadecimales codificados, el código también utiliza una constante predefinida llamada clrRed. En lugar de especificar un código hexadecimal manualmente, puedes utilizar simplemente esta constante integrada, que normalmente representa el color rojo con los valores RGB (255, 0, 0). Por ejemplo, el código establece el color de sobrepasamiento de la siguiente manera:

input color OvershootColor = clrRed;

Tras las entradas, el código incluye una función específica que se encarga de dibujar líneas horizontales en el gráfico. Esta función comprueba primero si ya existe una línea con el nombre especificado y, si es necesario, la elimina para evitar duplicados. A continuación, crea una nueva línea horizontal en un nivel de precio especificado y aplica el color, el estilo y el grosor definidos. Al garantizar que cada línea se extienda a lo largo del gráfico, esta función modular simplifica el proceso de dibujar múltiples líneas de manera consistente en todo el código.

//+------------------------------------------------------------------+
//| DrawHorizontalLine: Creates or replaces a horizontal line        |
//+------------------------------------------------------------------+
void DrawHorizontalLine(string name, double price, color lineColor, int width, ENUM_LINE_STYLE style)
{
   // Delete the object if it already exists
   if(ObjectFind(0, name) != -1)
      ObjectDelete(0, name);

   // Create a new horizontal line object
   if(!ObjectCreate(0, name, OBJ_HLINE, 0, 0, price))
   {
      Print("Failed to create line: ", name);
      return;
   }

   // Set properties: color, style, width, and extension to the right
   ObjectSetInteger(0, name, OBJPROP_COLOR, lineColor);
   ObjectSetInteger(0, name, OBJPROP_STYLE, style);
   ObjectSetInteger(0, name, OBJPROP_WIDTH, width);
   ObjectSetInteger(0, name, OBJPROP_RAY_RIGHT, true);
}

La ejecución principal del código comienza con la función OnStart, donde recupera el símbolo actual y su precio de compra. Este paso es crucial, ya que todos los cálculos posteriores dependen de un precio de mercado válido. Si el precio de oferta (Bid) no está disponible, el código sale antes de tiempo para evitar cualquier error, asegurando que las operaciones posteriores solo se realicen con datos válidos.

void OnStart()
{
   // Get current symbol price
   string symbol = _Symbol;
   double currentPrice = SymbolInfoDouble(symbol, SYMBOL_BID);
   if(currentPrice == 0)
      return;

Una vez obtenido el precio actual, el código calcula los principales niveles de precios que servirán como puntos de referencia primarios. Determina el nivel inferior redondeando hacia abajo el precio actual al intervalo más cercano definido por MajorStep y, a continuación, calcula el nivel superior añadiendo ese mismo paso. Estos niveles calculados crean un marco estructurado, estableciendo límites claros para el resto de la cuadrícula visual.

   // Calculate the major range based on the current price and MajorStep
   double lowerMajor = MathFloor(currentPrice / MajorStep) * MajorStep;
   double upperMajor = lowerMajor + MajorStep;

Utilizando estos niveles de precios principales, el código dibuja dos líneas horizontales prominentes en los límites inferior y superior. Estas líneas principales están diseñadas con colores, tamaños y patrones específicos, lo que las hace fácilmente identificables en el gráfico. Actúan como columna vertebral de la estructura visual del gráfico, ayudando a los operadores a identificar rápidamente las áreas significativas de soporte y resistencia.

   // Draw Major Whole Number lines at lower and upper boundaries
   DrawHorizontalLine("MajorLower", lowerMajor, MajorColor, MajorLineWidth, MajorLineStyle);
   DrawHorizontalLine("MajorUpper", upperMajor, MajorColor, MajorLineWidth, MajorLineStyle);

Si la opción de dibujar líneas de cuartos grandes está habilitada, el código subdivide el intervalo mayor en cuatro partes iguales. Calcula los niveles intermedios entre los límites principales y traza líneas horizontales en estos puntos. Además, si también se activan los marcadores Overshoot/Undershoot, se trazan líneas adicionales justo por encima y por debajo de cada línea de cuarto grande. Estos marcadores adicionales sirven para resaltar las áreas en las que el precio podría extenderse temporalmente más allá de su rango esperado, lo que ofrece a los operadores información valiosa sobre posibles reversiones de precios.

   // Draw Large Quarter lines and overshoot/undershoot lines if enabled
   if(DrawLargeQuarters)
   {
      double LQIncrement = MajorStep / 4.0;
      for(int i = 1; i < 4; i++)
      {
         double level = lowerMajor + i * LQIncrement;
         string objName = "LargeQuarter_" + IntegerToString(i);
         DrawHorizontalLine(objName, level, LargeQuarterColor, LargeQuarterLineWidth, LargeQuarterLineStyle);

         if(DrawOvershootAreas)
         {
            double smallQuarter = MajorStep / 40.0;
            DrawHorizontalLine("Overshoot_" + IntegerToString(i) + "_up", level + smallQuarter, OvershootColor, OvershootLineWidth, OvershootLineStyle);
            DrawHorizontalLine("Undershoot_" + IntegerToString(i) + "_down", level - smallQuarter, OvershootColor, OvershootLineWidth, OvershootLineStyle);
         }
      }
   }

Para obtener detalles aún más precisos, el código también puede dibujar pequeñas líneas de cuarto cuando se habilita esa opción. Divide el intervalo mayor en diez segmentos y, a continuación, divide cada segmento en subdivisiones más pequeñas. Esto crea una cuadrícula más granular que capta los movimientos sutiles de los precios, proporcionando a los operadores una visión detallada que puede resultar especialmente útil para identificar puntos de entrada y salida precisos.

   // Draw Small Quarter lines if enabled
   if(DrawSmallQuarters)
   {
      double segStep = MajorStep / 10.0;
      double smallQuarter = segStep / 4.0;
      for(int seg = 0; seg < 10; seg++)
      {
         double segStart = lowerMajor + seg * segStep;
         for(int j = 1; j < 4; j++)
         {
            double level = segStart + j * smallQuarter;
            string objName = "SmallQuarter_" + IntegerToString(seg) + "_" + IntegerToString(j);
            DrawHorizontalLine(objName, level, SmallQuarterColor, SmallQuarterLineWidth, SmallQuarterLineStyle);
         }
      }
   }

Para completar las mejoras visuales, el código añade una etiqueta persistente, o logotipo, al gráfico. Esta etiqueta muestra el nombre del código, la versión y la información del autor, y sirve tanto como crédito como referencia rápida para los usuarios. Antes de colocar la etiqueta, el código comprueba si existe alguna instancia para evitar duplicados y, a continuación, coloca la etiqueta en la esquina superior derecha con un tamaño de fuente y una configuración de color cuidadosamente seleccionados para garantizar una visibilidad clara.

   // Create a persistent label (logo) in the top-right corner
   if(ObjectFind(0, "ScriptLogo") != -1)
      ObjectDelete(0, "ScriptLogo");
   if(ObjectCreate(0, "ScriptLogo", OBJ_LABEL, 0, 0, 0))
   {
      string logoText = "Script: DrawQuarters_DarkBold\nv1.04\nby Christian Benjamin";
      ObjectSetString(0, "ScriptLogo", OBJPROP_TEXT, logoText);
      ObjectSetInteger(0, "ScriptLogo", OBJPROP_COLOR, clrYellow);
      ObjectSetInteger(0, "ScriptLogo", OBJPROP_FONTSIZE, 14);
      ObjectSetInteger(0, "ScriptLogo", OBJPROP_CORNER, CORNER_RIGHT_UPPER);
      ObjectSetInteger(0, "ScriptLogo", OBJPROP_XDISTANCE, 80);
      ObjectSetInteger(0, "ScriptLogo", OBJPROP_YDISTANCE, 10);
   }

Por último, el código actualiza el gráfico con un comando de redibujado, lo que garantiza que todos los objetos dibujados (líneas y etiquetas) sean visibles de inmediato. Este último paso es crucial, ya que actualiza la pantalla para reflejar los últimos datos del mercado y la configuración personalizada, presentando una herramienta visual completa y actualizada para el análisis técnico.

   // Redraw the chart to display all objects
   ChartRedraw();
}

Código MQL5

//+------------------------------------------------------------------+
//|                                              Quarters Drawer.mql5|
//|                                Copyright 2025, Christian Benjamin|
//|                           https://www.mql5.com/en/users/lynnchris|
//+------------------------------------------------------------------+
#property copyright "Christian Benjamin"
#property link      "https://www.mql5.com/en/users/lynnchris"
#property version   "1.0"
#property strict

//---- Input parameters -------------------------------------------------
input double MajorStep          = 0.1000;   // Difference between major whole numbers.
input bool   DrawLargeQuarters  = true;     // Draw intermediate large quarter lines.
input bool   DrawSmallQuarters  = true;    // Draw small quarter lines.
input bool   DrawOvershootAreas = true;     // Mark overshoot/undershoot areas for large quarter lines.

//---- Color settings ---------------------------------------------------
input color  MajorColor         = 0x2F4F4F; // Dark Slate Gray for major lines.
input color  LargeQuarterColor  = 0x8B0000; // Dark Red for large quarter lines.
input color  SmallQuarterColor  = 0x00008B; // Dark Blue for small quarter lines.
input color  OvershootColor     = clrRed;   // Red for overshoot/undershoot lines.

//---- Group style and thickness settings -------------------------------
input ENUM_LINE_STYLE MajorLineStyle       = STYLE_SOLID;
input int    MajorLineWidth                 = 4;
input ENUM_LINE_STYLE LargeQuarterLineStyle  = STYLE_DOT;
input int    LargeQuarterLineWidth          = 3;
input ENUM_LINE_STYLE OvershootLineStyle     = STYLE_DASH;
input int    OvershootLineWidth             = 1;
// For small quarter lines, we now use a continuous (solid) style.
input ENUM_LINE_STYLE SmallQuarterLineStyle  = STYLE_SOLID;
input int    SmallQuarterLineWidth          = 1;

//+------------------------------------------------------------------+
//| DrawHorizontalLine: Creates or replaces a horizontal line        |
//+------------------------------------------------------------------+
void DrawHorizontalLine(string name, double price, color lineColor, int width, ENUM_LINE_STYLE style)
  {
   if(ObjectFind(0, name) != -1)
      ObjectDelete(0, name);

   if(!ObjectCreate(0, name, OBJ_HLINE, 0, 0, price))
     {
      Print("Failed to create line: ", name);
      return;
     }

   ObjectSetInteger(0, name, OBJPROP_COLOR, lineColor);
   ObjectSetInteger(0, name, OBJPROP_STYLE, style);
   ObjectSetInteger(0, name, OBJPROP_WIDTH, width);
   ObjectSetInteger(0, name, OBJPROP_RAY_RIGHT, true);
  }

//+------------------------------------------------------------------+
//| Script entry point                                               |
//+------------------------------------------------------------------+
void OnStart()
  {
// Get current symbol price
   string symbol = _Symbol;
   double currentPrice = SymbolInfoDouble(symbol, SYMBOL_BID);
   if(currentPrice == 0)
      return;

// Calculate the major range
   double lowerMajor = MathFloor(currentPrice / MajorStep) * MajorStep;
   double upperMajor = lowerMajor + MajorStep;

// Draw Major Whole Number lines
   DrawHorizontalLine("MajorLower", lowerMajor, MajorColor, MajorLineWidth, MajorLineStyle);
   DrawHorizontalLine("MajorUpper", upperMajor, MajorColor, MajorLineWidth, MajorLineStyle);

// Draw Large Quarter lines and their overshoot/undershoot lines
   if(DrawLargeQuarters)
     {
      double LQIncrement = MajorStep / 4.0;
      for(int i = 1; i < 4; i++)
        {
         double level = lowerMajor + i * LQIncrement;
         string objName = "LargeQuarter_" + IntegerToString(i);
         DrawHorizontalLine(objName, level, LargeQuarterColor, LargeQuarterLineWidth, LargeQuarterLineStyle);

         if(DrawOvershootAreas)
           {
            double smallQuarter = MajorStep / 40.0;
            DrawHorizontalLine("Overshoot_" + IntegerToString(i) + "_up", level + smallQuarter, OvershootColor, OvershootLineWidth, OvershootLineStyle);
            DrawHorizontalLine("Undershoot_" + IntegerToString(i) + "_down", level - smallQuarter, OvershootColor, OvershootLineWidth, OvershootLineStyle);
           }
        }
     }

// Draw Small Quarter lines if enabled (continuous lines, without overshoot/undershoot)
   if(DrawSmallQuarters)
     {
      double segStep = MajorStep / 10.0;
      double smallQuarter = segStep / 4.0;
      for(int seg = 0; seg < 10; seg++)
        {
         double segStart = lowerMajor + seg * segStep;
         for(int j = 1; j < 4; j++)
           {
            double level = segStart + j * smallQuarter;
            string objName = "SmallQuarter_" + IntegerToString(seg) + "_" + IntegerToString(j);
            DrawHorizontalLine(objName, level, SmallQuarterColor, SmallQuarterLineWidth, SmallQuarterLineStyle);
           }
        }
     }

// Create a persistent label (logo) in the top-right corner
   if(ObjectFind(0, "ScriptLogo") != -1)
      ObjectDelete(0, "ScriptLogo");
   if(ObjectCreate(0, "ScriptLogo", OBJ_LABEL, 0, 0, 0))
     {
      string logoText = "Script: DrawQuarters_DarkBold\nv1.04\nby Christian Benjamin";
      ObjectSetString(0, "ScriptLogo", OBJPROP_TEXT, logoText);
      ObjectSetInteger(0, "ScriptLogo", OBJPROP_COLOR, clrYellow);
      ObjectSetInteger(0, "ScriptLogo", OBJPROP_FONTSIZE, 14);
      ObjectSetInteger(0, "ScriptLogo", OBJPROP_CORNER, CORNER_RIGHT_UPPER);
      ObjectSetInteger(0, "ScriptLogo", OBJPROP_XDISTANCE, 80);
      ObjectSetInteger(0, "ScriptLogo", OBJPROP_YDISTANCE, 10);
     }

   ChartRedraw();
  }
//+------------------------------------------------------------------+

Resultados

Antes de explorar los resultados, veamos cómo crear y compilar el código. Abre MetaEditor y selecciona «Nuevo» y, a continuación, «Script». Introduce un nombre para tu script y empieza a escribir el código. Compila el script. Si aparecen errores, corríjalos hasta que la compilación se realice correctamente. Una vez compilado, prueba tu script en un gráfico. Como no es un EA, puede ejecutarlo en un gráfico en tiempo real, ya sea en modo demo o en vivo, sin que ello afecte a su saldo.

En esta sección tengo varios diagramas para comprensión visual. Te guiaré a través de cada diagrama paso a paso. El primer diagrama muestra una prueba del par AUDUSD. En esa prueba, habilité DrawLargeQuarters junto con las áreas Overshoot/Undershoot, y establecí DrawSmallQuarters en false.

//---- Input parameters -------------------------------------------------
input double MajorStep          = 0.1000;   // Difference between major whole numbers.
input bool   DrawLargeQuarters  = true;     // Draw intermediate large quarter lines.
input bool   DrawSmallQuarters  = false;    // Draw small quarter lines.
input bool   DrawOvershootAreas = true;     // Mark overshoot/undershoot areas for large quarter lines.

Repasemos la figura 2 a continuación. Muestra cómo añadí el script y los resultados registrados. Vemos cómo interactúa el precio con los cuartos y sus rebasamientos al alza y a la baja.

Quartile Drawer

Figura 2. Cuartos (AUDUSD)

A continuación se muestra una captura de pantalla tomada en el mismo par. He resaltado el efecto de los cuartos en el gráfico. Los resultados son claros: el mercado encuentra soporte y resistencia en nuestros niveles de los cuartos más grandes. He establecido las opciones overshoot y smaller quartile en falso para visualizar claramente estos cuartos grandes.

//---- Input parameters -------------------------------------------------
input double MajorStep          = 0.1000;   // Difference between major whole numbers.
input bool   DrawLargeQuarters  = true;     // Draw intermediate large quarter lines.
input bool   DrawSmallQuarters  = false;    // Draw small quarter lines.
input bool   DrawOvershootAreas = false;     // Mark overshoot/undershoot areas for large quarter lines.

Véase la figura 3 a continuación.

Grandes cuartos

Figura 3. Grandes cuartos

He ampliado aún más la imagen para que se pueda ver claramente cómo interactúa el precio con la línea del cuarto grande, incluyendo sus subidas y bajadas.

Barras de cuartos

Figura 4. Overshoot/Undershoot

Por último, examinemos el rendimiento del script en el EURUSD. Los niveles clave que todo operador de divisas busca están claramente identificados por los niveles de cuartos.

EURUSD

Figura 5. Cuartos (EURUSD)

Consulte el libro: The Quarters Theory: The Revolutionary New Foreign Currencies Trading Method (Ilian Yotov)

Conclusión

Estoy seguro de que todos pueden ver el impacto de este script. Dibuja los cuartos y realiza los cálculos que llevarían mucho tiempo hacer manualmente. Un aspecto destacable es cómo las líneas cuartiles sirven como niveles de soporte y reversión. Los cuartiles grandes, los niveles inferiores y superiores principales, actúan como resistencia y soporte significativos, mientras que los cuartiles más pequeños sirven como niveles menores. Este enfoque inicial es un sólido punto de partida para el análisis automatizado. Esperamos desarrollar más herramientas a medida que profundizamos en esta teoría. Si tienes alguna sugerencia o recomendación, por favor compártela.

Fecha	Nombre de la herramienta	Descripción	Versión	Actualizaciones	Notas
01/10/24	Chart Projector	Script para superponer la acción del precio del día anterior con efecto fantasma.	1.0	Lanzamiento inicial	Herramienta número 1
18/11/24	Analytical Comment	Proporciona información del día anterior en formato tabular y anticipa la dirección futura del mercado.	1.0	Lanzamiento inicial	Herramienta número 2
27/11/24	Analytics Master	Actualización periódica de las métricas del mercado cada dos horas.	1.01	Segundo lanzamiento	Herramienta número 3
02/12/24	Analytics Forecaster	Actualización periódica de las métricas del mercado cada dos horas con integración de Telegram.	1.1	Tercera edición	Herramienta número 4
09/12/24	Volatility Navigator	El EA analiza las condiciones del mercado utilizando los indicadores Bandas de Bollinger, RSI y ATR.	1.0	Lanzamiento inicial	Herramienta número 5
19/12/24	Mean Reversion Signal Reaper	Analiza el mercado utilizando la estrategia de reversión a la media y proporciona señales.	1.0	Lanzamiento inicial	Herramienta número 6
9/01/25	Signal Pulse	Analizador de múltiples marcos temporales.	1.0	Lanzamiento inicial	Herramienta número 7
17/01/25	Metrics Board	Panel con botón para análisis.	1.0	Lanzamiento inicial	Herramienta número 8
21/01/25	External Flow	Análisis mediante librerías externas.	1.0	Lanzamiento inicial	Herramienta número 9
27/01/25	VWAP	Volume Weighted Average Price (Precio promedio ponderado por volumen)	1.3	Lanzamiento inicial	Herramienta número 10
02/02/25	Heikin Ashi	Identificación de señales de suavizado y reversión de tendencias.	1.0	Lanzamiento inicial	Herramienta número 11
04/02/25	FibVWAP	Generación de señales mediante análisis de Python.	1.0	Lanzamiento inicial	Herramienta número 12
14/02/25	RSI DIVERGENCE	Acción del precio frente a divergencias del RSI.	1.0	Lanzamiento inicial	Herramienta número 13
17/02/25	Parabolic Stop and Reverse (PSAR)	Automatización de la estrategia PSAR.	1.0	Lanzamiento inicial	Herramienta número 14
20/02/25	Quarters Drawer Script	Dibujar los niveles de los cuartos en el gráfico.	1.0	Lanzamiento inicial	Herramienta número 15

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

Archivos adjuntos |

Descargar ZIP

Quarters_Drawer.mq5 (5.67 KB)

Advertencia: todos los derechos de estos materiales pertenecen a MetaQuotes Ltd. Queda totalmente prohibido el copiado total o parcial.

Este artículo ha sido escrito por un usuario del sitio web y refleja su punto de vista personal. MetaQuotes Ltd. no se responsabiliza de la exactitud de la información ofrecida, ni de las posibles consecuencias del uso de las soluciones, estrategias o recomendaciones descritas.

Otros artículos del autor

Pasar a la discusión en el foro de los operadores

Un nuevo enfoque para los criterios personalizados en las optimizaciones (Parte 1): Ejemplos de funciones de activación

El primero de una serie de artículos que analizan las matemáticas de los criterios personalizados, con especial atención a las funciones no lineales utilizadas en las redes neuronales, el código MQL5 para su implementación y el uso de compensaciones específicas y correccionales.

Kit de herramientas de negociación MQL5 (Parte 8): Cómo implementar y utilizar la librería History Manager en sus proyectos

Descubra cómo importar y utilizar sin esfuerzo la librería History Manager en su código MQL5 para procesar los historiales de operaciones en su cuenta MetaTrader 5 en el último artículo de esta serie. Con simples llamadas a funciones de una sola línea en MQL5, puede gestionar y analizar de forma eficaz sus datos de trading. Además, aprenderá a crear diferentes scripts de análisis del historial comercial y a desarrollar un asesor experto basado en precios como ejemplos prácticos de uso. El EA de ejemplo aprovecha los datos de precios y la librería History Manager para tomar decisiones de trading informadas, ajustar los volúmenes de operaciones e implementar estrategias de recuperación basadas en operaciones cerradas anteriormente.

Desarrollo de un kit de herramientas para el análisis de la acción del precio (Parte 16): Introducción a la teoría de los cuartos (II) - Intrusion Detector EA

En nuestro artículo anterior presentamos un script sencillo llamado «The Quarters Drawer». Partiendo de esa base, ahora damos el siguiente paso creando un Asesor Experto (Expert Advisor, EA) de monitoreo, destinado a seguir estos cuartos y a proporcionar supervisión sobre posibles reacciones del mercado en dichos niveles. Acompáñenos mientras exploramos el proceso de desarrollo de una herramienta de detección de zonas en este artículo.

Características del Wizard MQL5 que debe conocer (Parte 56): Fractales de Bill Williams

Los fractales de Bill Williams son un indicador potente que es fácil pasar por alto cuando se ve por primera vez en un gráfico de precios. Parece demasiado recargado y probablemente no lo suficientemente incisivo. Nuestro objetivo es desvelar este indicador examinando lo que sus diversos patrones podrían lograr cuando se analizan con pruebas de avance en todos los casos, con un asesor experto creado por un asistente.