Desenvolvimento do Toolkit de Análise de Price Action (Parte 15): Introduzindo a Teoria dos Quartos (I) — Script Quarters Drawer

Conteúdo:

• Introdução
• Visão Geral do Conceito
• Implementação em MQL5
• Script MQL5
• Resultados
• Conclusão

Introdução

Em todo mercado, os preços se movem em ciclos. Seja com tendência de alta ou de baixa, os preços oscilam repetidamente dentro de intervalos definidos. Com o tempo, os traders desenvolveram muitas teorias para explicar esses padrões. Em nossa série contínua, estamos construindo um toolkit abrangente de análise de price action. Hoje apresentamos uma abordagem inovadora que automatizamos usando MQL5 para simplificar sua aplicação e alcançar resultados impressionantes.

A Teoria dos Quartos é o foco deste artigo. Ela foi desenvolvida por Ilian Yotov, um nome familiar para milhares de traders de moedas e estrategistas de Forex por seu trabalho na Traders Television Network. Ilian fundou AllThingsForex.com e TraderTape.com e apresenta o popular programa diário All Things Forex. Sua teoria sugere que movimentos significativos de preço ocorrem entre dois Large Quarter Points e avançam em incrementos de 250 PIPs. Esse método oferece marcadores claros para identificar níveis-chave de suporte e resistência, além de fornecer insights práticos para os traders.

Este artigo é a primeira parte da nossa Teoria dos Quartos. Nesta etapa, focamos na construção dos quarters utilizando nosso script "quarters drawer". Ao automatizar o desenho desses níveis cruciais, oferecemos um ponto de partida prático para visualizar zonas importantes de reversão e continuação. À medida que avançarmos nesta teoria, desenvolveremos ferramentas ainda mais robustas para apoiar a geração de sinais e análises de mercado mais avançadas.

Visão Geral do Conceito

A Teoria dos Quartos é uma abordagem de análise técnica que divide um intervalo significativo de preço em segmentos menores e mais significativos. Nesse framework, um "MajorStep" — por exemplo, 0.1000 em pares de moedas como EUR/USD — define a diferença entre números inteiros principais (como 1.2000 a 1.3000). Esse intervalo é então subdividido em quatro partes iguais, conhecidas como large quarters. Cada large quarter representa um nível crítico onde o preço pode pausar, reverter ou acelerar, oferecendo aos traders possíveis áreas de suporte e resistência.

Os principais componentes da Teoria dos Quartos incluem

• Números Inteiros Principais: Estes são os níveis primários (por exemplo, 1.2000, 1.3000) que delimitam o intervalo de negociação. Eles são usados como pontos de referência para construir a estrutura mais detalhada da teoria.
• Linhas de Large Quarter: O intervalo entre dois níveis principais é dividido igualmente em quatro segmentos. Essas linhas indicam níveis intermediários que frequentemente desempenham um papel importante no comportamento do preço. Os traders utilizam esses níveis para antecipar possíveis pontos de reversão ou áreas de consolidação.
• Linhas de Small Quarter (Opcional): Para maior precisão, cada segmento de 100 pips pode ser subdividido em intervalos ainda menores, chamados small quarters. Embora essas linhas ofereçam granularidade adicional, o foco principal permanece nos níveis de large quarter.
• Áreas de Overshoot/Undershoot: Ao redor de cada linha de large quarter, pequenos deslocamentos (overshoots e undershoots) são desenhados para sinalizar zonas onde o preço pode momentaneamente ultrapassar ou ficar aquém do nível esperado. Essas áreas ajudam a identificar possíveis correções ou reversões.

Para obter mais informações, consulte os diagramas a seguir.

Fig 1. Os Quarters

Fig 2. Os QUARTERS

Ao marcar visualmente esses níveis-chave em um gráfico, a Teoria dos Quarters fornece aos traders uma forma estruturada de avaliar a dinâmica do preço. A abordagem é implementada no script “Quarters Drawer”, que desenha linhas distintas com diferentes estilos e cores para aumentar a clareza, garantindo que cada grupo (linhas principais, large quarter e small quarter) seja facilmente distinguível. Essa ferramenta visual reforça a teoria ao destacar claramente os segmentos cruciais de preço.

Implementação em MQL5

O primeiro bloco do script inclui um comentário de cabeçalho que fornece detalhes essenciais, como o nome do script, versão, informações de copyright e um link para o perfil do autor. Em seguida, declarações de propriedade incorporam metadados importantes (como copyright e versão) e aplicam configurações de compilação estritas. Essa combinação estabelece a identidade do script e garante que ele siga padrões robustos de programação.

//+------------------------------------------------------------------+
//|                                              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

Em seguida, os parâmetros de entrada são definidos para dar aos usuários controle total sobre o comportamento e a aparência do script. Aqui você define o intervalo entre níveis principais de preço com um parâmetro como MajorStep e utiliza flags boolean para ativar ou desativar o desenho de linhas large quarter, linhas small quarter e marcadores de overshoot/undershoot. Por exemplo, se DrawLargeQuarters estiver definido como true, o script desenhará as linhas large quarter, mas ao alterar para false elas não serão exibidas.

O mesmo se aplica a DrawSmallQuarters e DrawOvershootAreas; se você não quiser visualizar as linhas small quarter ou as zonas de overshoot, basta definir seus valores como false. Isso facilita a personalização da exibição sem modificar a lógica central. Além disso, configurações de cor e opções de estilo/espessura de linha são fornecidas para cada tipo de linha, permitindo que os traders personalizem facilmente o resultado visual de acordo com suas preferências e estratégias de negociação.

//---- 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;

Quando você vê códigos de cores hexadecimais no script, eles representam cores específicas combinando valores de vermelho, verde e azul. Por exemplo:

• 0x2F4F4F – Esse código corresponde a Dark Slate Gray. Os pares de dois dígitos representam respectivamente os componentes vermelho, verde e azul. Aqui, “2F” (47 em decimal) representa o vermelho e “4F” (79 em decimal) representa tanto o verde quanto o azul, criando um tom de cinza frio e suave ideal para linhas principais em um gráfico.
• 0x8B0000 – Esse código representa Dark Red. Nesse valor, “8B” (139 em decimal) é um componente vermelho forte, enquanto os componentes verde e azul são “00” (zero), resultando em um vermelho profundo e intenso. Essa cor é usada no script para enfatizar as linhas de large quarter.
• 0x00008B – Esse código representa Dark Blue. Nesse caso, os componentes vermelho e verde são “00”, e o componente azul é “8B” (139 em decimal), produzindo uma cor azul profunda. Ela é aplicada às linhas small quarter, proporcionando um contraste visual distinto.

Além desses valores hexadecimais codificados diretamente, o script também utiliza uma constante predefinida chamada clrRed. Em vez de especificar manualmente um código hexadecimal, você pode simplesmente usar essa constante embutida, que normalmente representa a cor vermelha com os valores RGB (255, 0, 0). Por exemplo, o script define a cor de overshoot da seguinte forma:

input color OvershootColor = clrRed;

Após os inputs, o script apresenta uma função dedicada responsável por desenhar linhas horizontais no gráfico. Essa função primeiro verifica se já existe uma linha com o nome especificado, removendo-a se necessário para evitar duplicações. Em seguida, cria uma nova linha horizontal em um nível de preço específico e aplica a cor, estilo e largura definidos. Ao garantir que cada linha se estenda por todo o gráfico, essa função modular simplifica o processo de desenhar múltiplas linhas de forma consistente ao longo do script.

//+------------------------------------------------------------------+
//| 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);
}

A execução principal do script começa na função OnStart, onde ele recupera o símbolo atual e seu preço bid. Esse passo é crucial, pois todos os cálculos subsequentes dependem de um preço de mercado válido. Se o preço bid não estiver disponível, o script encerra sua execução antecipadamente para evitar erros, garantindo que as operações seguintes sejam realizadas apenas com dados válidos.

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

Depois que o preço atual é obtido, o script calcula os níveis principais de preço que servirão como pontos de referência primários. Ele determina o nível inferior arredondando o preço atual para baixo até o intervalo mais próximo definido por MajorStep, e então calcula o nível superior adicionando esse mesmo intervalo. Esses níveis calculados criam uma estrutura organizada, estabelecendo limites claros para o restante da grade visual.

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

Utilizando esses níveis principais de preço, o script então desenha duas linhas horizontais proeminentes nos limites inferior e superior. Essas linhas principais são estilizadas com cores, espessuras e padrões específicos, tornando-as facilmente identificáveis no gráfico. Elas atuam como a espinha dorsal da estrutura visual do gráfico, ajudando os traders a identificar rapidamente áreas significativas de suporte e resistência.

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

Se a opção de desenhar linhas de large quarter estiver habilitada, o script subdivide o intervalo principal em quatro partes iguais. Ele calcula níveis intermediários entre os limites principais e desenha linhas horizontais nesses pontos. Além disso, se os marcadores de overshoot/undershoot também estiverem ativados, linhas adicionais são desenhadas logo acima e abaixo de cada linha de large quarter. Esses marcadores extras destacam áreas onde o preço pode temporariamente se estender além do intervalo esperado, oferecendo aos traders insights valiosos sobre possíveis reversões de preço.

   // 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 obter ainda mais detalhamento, o script também pode desenhar linhas de small quarter quando essa opção estiver habilitada. Ele divide o intervalo principal em dez segmentos e depois subdivide cada segmento em divisões menores. Isso cria uma grade mais granular que captura movimentos sutis de preço, fornecendo aos traders uma visão detalhada que pode ser particularmente útil para identificar pontos precisos de entrada e saída.

   // 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 as melhorias visuais, o script adiciona um rótulo persistente, ou logotipo, ao gráfico. Esse rótulo exibe o nome do script, a versão e as informações do autor, servindo tanto como crédito quanto como referência rápida para os usuários. Antes de posicionar o rótulo, o script verifica se já existe uma instância para evitar duplicações e então o posiciona no canto superior direito com tamanho de fonte e cores cuidadosamente escolhidos para garantir boa visibilidade.

   // 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 fim, o script atualiza o gráfico com um comando de redesenho, garantindo que todos os objetos desenhados (linhas e rótulos) fiquem imediatamente visíveis. Esse passo final é crucial, pois atualiza a exibição para refletir os dados mais recentes do mercado e as configurações personalizadas, apresentando uma ferramenta visual completa e atualizada para análise técnica.

   // 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 os resultados, veja como criar e compilar o script. Abra o MetaEditor e selecione "New" e depois escolha "Script." Digite um nome para o seu script e comece a escrever o código. Compile o script. Se aparecerem erros, corrija-os até que a compilação seja bem-sucedida. Depois de compilado, teste o script em um gráfico. Como não se trata de um EA, você pode executá-lo em um gráfico ao vivo em modo demo ou real sem afetar o seu saldo.

Nesta seção, apresento vários diagramas para facilitar o entendimento visual. Vou guiá-lo por cada diagrama passo a passo. O primeiro diagrama mostra um teste no par AUD/USD. Nesse teste, habilitei DrawLargeQuarters junto com as áreas de overshoot e undershoot e defini DrawSmallQuarters como 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.

Vamos analisar a Figura 2 abaixo. Ela mostra como adicionei o script e os resultados registrados. Podemos observar como o preço interage com os Quarters e com seus overshoot e undershoot.

Fig 2. AUDUSD Quarters

Abaixo está uma captura de tela do mesmo par. Destaquei o efeito dos quarters no gráfico. Os resultados são claros: o mercado encontra suporte e resistência em nossos níveis de large quarter. Defini as opções overshoot e smaller quartile como false para visualizar claramente esses large quarters.

//---- 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.

Veja a Figura 3 abaixo

Fig 3. Large Quarters

Ampliei ainda mais para que você possa ver claramente como o preço interage com a linha de large quarter, incluindo seus undershoots e overshoots.

Fig 4. Overshoot and Undershoot

Por fim, vamos examinar o desempenho do script no EUR/USD. Níveis-chave que todo trader de FX procura são claramente identificados pelos níveis de quarter.

Fig 5. EURUSD Quarters

Consulte o livro: The_Quarters_Theory_-_Ilian_Yotov

Conclusão

Tenho certeza de que todos conseguem perceber o impacto deste script. Ele desenha os quarters e realiza cálculos que seriam demorados se feitos manualmente. Um aspecto notável é como as linhas de quartile funcionam como níveis de suporte e reversão. Os large quartiles, juntamente com os níveis principais inferior e superior, atuam como resistência e suporte significativos, enquanto os quartiles menores funcionam como níveis secundários. Essa abordagem inicial é um forte ponto de partida para análise automatizada. Esperamos desenvolver mais ferramentas à medida que aprofundamos esta teoria. Se você tiver sugestões ou recomendações, compartilhe.

Data	Nome da Ferramenta	Descrição	Versão	Atualizações	Notas
01/10/24	Projetor de Gráficos	Script para sobrepor a ação de preço do dia anterior com efeito fantasma..	1.0	Lançamento Inicial	Ferramenta número 1
18/11/24	Comentário Analítico	Ele fornece informações do dia anterior em formato tabular, além de antecipar a direção futura do mercado.	1.0	Lançamento Inicial	Ferramenta número 2
27/11/24	Mestre em Análise	Atualização regular das métricas de mercado a cada duas horas	1.01	Segundo Lançamento	Ferramenta número 3
02/12/24	Previsor Analítico	Atualização regular das métricas de mercado a cada duas horas com integração ao Telegram	1.1	Terceira Edição	Ferramenta número 4
09/12/24	Navegador de Volatilidade	O EA analisa as condições de mercado usando os indicadores Bandas de Bollinger, RSI e ATR	1.0	Lançamento Inicial	Ferramenta número 5
19/12/24	Reversão à Média Ceifador de Sinal	Analisa o mercado usando a estratégia de reversão à média e fornece sinais	1.0	Lançamento Inicial	Ferramenta número 6
9/01/25	Pulso de sinal	Analisador de múltiplos períodos de tempo	1.0	Lançamento Inicial	Ferramenta número 7
17/01/25	Quadro de Métricas	Painel com botão para análise	1.0	Lançamento Inicial	Ferramenta número 8
21/01/25	Fluxo externo	Análises por meio de bibliotecas externas	1.0	Lançamento Inicial	Ferramenta número 9
27/01/25	VWAP	Preço médio ponderado por volume	1.3	Lançamento Inicial	Ferramenta número 10
02/02/25	Heikin Ashi	Suavização de Tendência e identificação de sinais de reversão	1.0	Lançamento Inicial	Ferramenta número 11
04/02/25	FibVWAP	Geração de sinais por meio de análise em Python	1.0	Lançamento Inicial	Ferramenta número 12
14/02/25	DIVERGÊNCIA RSI	Divergências entre ação do preço e RSI	1.0	Lançamento Inicial	Ferramenta número 13
17/02/25	Parada e Reversão Parabólicas (PSAR)	Automatizando a estratégia PSAR	1.0	Lançamento Inicial	Ferramenta número 14
20/02/25	Quarters Drawer Script	Desenhar os níveis dos trimestres no gráfico	1.0	Lançamento Inicial	Ferramenta número 15