MetaTrader 5 / Negociação
English Русский 中文 Español Deutsch 日本語
preview
Encontrando padrões de velas usando MQL5

Encontrando padrões de velas usando MQL5

MetaTrader 5 — Negociação | 18 julho 2023, 14:48
516 0
Mohamed Abdelmaaboud
Mohamed Abdelmaaboud

Introdução

Os castiçais são uma ferramenta técnica muito útil se a usarmos corretamente, eles formam certos padrões no gráfico que podemos usar para encontrar movimentos potenciais. Existem padrões específicos e esses padrões podem ser divididos em dois tipos: padrões de um único castiçal e padrões de mais de um castiçal. Neste artigo, aprenderemos como podemos usar o MQL5 para detectar alguns desses padrões automaticamente no terminal de negociação MetaTrader 5, abordaremos isso nos seguintes tópicos:

Preciso mencionar que é muito importante usar esses padrões acompanhados de outras ferramentas técnicas para obter sinais relevantes. Dito isso, você precisa entender a ideia principal por trás do uso do MQL5 para detecção dos padrões mencionados como parte do seu sistema, a fim de facilitar sua negociação e obter bons resultados.

Atenção! Todo o conteúdo deste artigo é apresentado "tal qual como está", apenas para fins educacionais e não constitui uma recomendação de trading. O artigo não fornece qualquer garantia de resultados. Tudo o que você implementar baseado neste artigo será por sua conta e risco, o autor não garante nenhum resultado.

Padrões de uma vela

Vejamos dois exemplos de padrão de um único castiçal no gráfico. Você pode vê-los em qualquer período gráfico, serão mais significativos quando aparecem em seu devido lugar em relação à ação do preço. Veremos os padrões Doji e martelo.

Padrão Doji:

É muito popular entre os padrões de castiçais e é o castiçal que tem quase os mesmos preços de abertura e fechamento, o que resulta em um corpo muito pequeno com uma sombra superior e inferior, ou sem sombra nenhuma. A seguinte figura representa esse castiçal:

Doji

Este castiçal Doji indica que há um equilíbrio entre compradores e vendedores e ninguém controla o mercado para mover o preço para cima ou para baixo durante o período em que aparece. Pode sinalizar uma reversão ou correção no mercado se aparecer no lugar adequado no gráfico antes de uma correção ou no final de tendência e será mais significativo se aparecer no maior período gráfico. Existem muitos tipos e formações para este castiçal e cada um tem muitas informações que podem ser usadas a nosso favor na negociação, como libélula e pernas longas.

O que precisamos fazer é que o programa detecte o próprio padrão Doji, definindo os preços e o tempo da última vela, e que a cada tick verifique e compare esses valores no tempo definido e determine as posições de todos eles. Se a abertura for igual ao fechamento, precisamos que o programa retorne um sinal de que está identificando um padrão Doji.

Agora, precisamos criar um programa que possa detectar esse padrão e os seguintes são os passos de um método que pode fazer isso:

Vamos criar uma função para este Doji (getDoji) e vamos chamá-la em OnTick() para verificar cada tick em busca deste padrão.

void OnTick()
  {
   getDoji();
  }

Criamos a função (getDoji) como uma variável inteira.

int getDoji()

Definimos esta função, usando time, open, high, low, e close da última vela.

Para fazer isso, usamos a função iTime que retorna o horário de abertura da vela, a iOpen que retorna o preço de abertura da vela, a iHigh que retorna o preço máximo, a iLow que retorna o preço mínimo, e a iClose que retorna o preço de fechamento da vela. Os parâmetros são os mesmos para todos eles:

  • symbol — nome do símbolo, usaremos _Symbol para o símbolo atual.
  • timeframe — período ou intervalo de tempo do gráfico, usaremos PERIOD_CURRENT para o intervalo de tempo atual.
  • shift — índice do valor retornado, usaremos 1 para definir a última vela.
   datetime time=iTime(_Symbol,PERIOD_CURRENT,1);
   double open=iOpen(_Symbol,PERIOD_CURRENT,1);
   double high=iHigh(_Symbol,PERIOD_CURRENT,1);
   double low=iLow(_Symbol,PERIOD_CURRENT,1);
   double close=iClose(_Symbol,PERIOD_CURRENT,1);

Definimos a condição do Doji que precisamos detectar usando a declaração if

if(open==close)

Se essa condição for atendida, precisamos que o programa crie um objeto baseado na função createObj que criaremos com os parâmetros de tempo, preço, código de seta, cor, e o texto que precisamos. Em seguida, terminamos a função retornando 1.

   if(open==close)
     {
      createObj(time,low,217, clrBlack,"Doji");
        {
         return 1;
        }
     }

Retornaremos 0 para encerrar a função de getDoji

   return 0;

Adicionamos a função createObj com os parâmetros time, price, arrowcode, clr e txt usando a função void

void createObj(datetime time, double price, int arrawCode, color clr, string txt)

Criamos uma variável de string objName e atribuímos a ela o valor " "

string objName=" ";

Concatenamos strings para atribuí-las à variável objName usando a função StringConcatenate que forma uma string dos parâmetros passados e retorna o tamanho da string formada. Os parâmetros da função são:

  • string_var — string que será formada após a concatenação (objName).
  • argument1 — parâmetro de tipo simples, especificaremos o texto "Signal at " para exibir o sinal.
  • argument2 — define a hora da vela encontrada; temos essa hora a partir de uma variável predefinida.
  • argument3 — adicionamos o texto " at ".
  • argument4 — em seguida, adicionamos um preço arredondado ao texto usando DoubleToString, que converte um valor double em uma string.
  • argument5 — novamente adicionamos o texto " (".
  • argument6 — atribuímos um valor a uma variável inteira predefinida (arrowcode) de que precisamos. Este código pode ser encontrado pesquisando por Wingdings na documentação mql5.
  • argument7 — completamos o texto ")".
StringConcatenate(objName, "Signal at ",time, " at ",DoubleToString(price,_Digits)," (",arrawCode,")");

Em seguida, adicionamos uma condição para definir o padrão usando a instrução if e a função ObjectCreate como uma expressão. A função ObjectCreate cria um objeto usando o nome predefinido objName. Seus parâmetros são:

  • chart_id — definimos o gráfico, usaremos 0 para o gráfico atual.
  • name — nome do objeto, usaremos o nome pré-definido objName.
  • type — tipo do objeto, usaremos OBJ_ARROW.
  • nwin — número da sub-janela do gráfico, usaremos 0 para a janela principal do gráfico.
  • time1 — tempo da âncora, usaremos a variável pré-definida time.
  • price1 — preço da âncora, usaremos a variável pré-definida price.
if(ObjectCreate(0,objName,OBJ_ARROW,0,time,price))

Se essa condição for atendida, criamos o objeto. Para isso, definimos suas propriedades, a forma, o código da seta e sua cor usando a função ObjectSetInteger, que define o valor da propriedade do objeto. Os parâmetros da função são:

  • chart_id — definimos o gráfico, usaremos 0 para o gráfico atual.
  • name — nome do objeto, usaremos o nome pré-definido objName.
  • prop_id — identificador da propriedade do objeto, usamos o valor da enumeração ENUM_OBJECT_PROPERTY_INTEGER: OBJPROP_ARROWCODE para seleção de tipo de objeto e OBJPROP_COLOR para cor.
  • prop_value — valor da propriedade, arrawCode para o código da seta e uma variável predefinida (clr) para a cor.
ObjectSetInteger(0,objName,OBJPROP_ARROWCODE,arrawCode);
ObjectSetInteger(0,objName,OBJPROP_COLOR,clr);

Depois disso, criaremos um texto que mostrará informações sobre a vela. Vamos criar uma variável do tipo string candleName com as variáveis ​​predefinidas objName e txt atribuídas.

string candleName=objName+txt;

Criamos um objeto de texto, usamos a instrução if e a função ObjectCreate como uma expressão, aqui o operador será ObjectSetString para definir o valor da string da propriedade do objeto e ObjectSetInteger para definir a cor do objeto de texto.

      ObjectSetString(0,candleName,OBJPROP_TEXT," "+txt);
      ObjectSetInteger(0,candleName,OBJPROP_COLOR,clr);

Agora, podemos ver o código completo do EA:

//+------------------------------------------------------------------+
//|                                        Doji pattern detector.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
void OnTick()
  {
   getDoji();
  }
int getDoji()
  {
   datetime time=iTime(_Symbol,PERIOD_CURRENT,1);
   double open=iOpen(_Symbol,PERIOD_CURRENT,1);
   double high=iHigh(_Symbol,PERIOD_CURRENT,1);
   double low=iLow(_Symbol,PERIOD_CURRENT,1);
   double close=iClose(_Symbol,PERIOD_CURRENT,1);
//Doji
   if(open==close)
     {
      createObj(time,low,217, clrBlack,"Doji");
        {
         return 1;
        }
     }
   return 0;
  }
void createObj(datetime time, double price, int arrawCode, color clr, string txt)
  {
   string objName=" ";
   StringConcatenate(objName, "Signal at ",time, " at ",DoubleToString(price,_Digits)," (",arrawCode,")");
   if(ObjectCreate(0,objName,OBJ_ARROW,0,time,price))
     {
      ObjectSetInteger(0,objName,OBJPROP_ARROWCODE,arrawCode);
      ObjectSetInteger(0,objName,OBJPROP_COLOR,clr);
     }
   string candleName=objName+txt;
   if(ObjectCreate(0,candleName,OBJ_TEXT,0,time,price))
     {
      ObjectSetString(0,candleName,OBJPROP_TEXT," "+txt);
      ObjectSetInteger(0,candleName,OBJPROP_COLOR,clr);
     }
  }

Compilamos o código sem erros. Depois disso, o programa aparecerá no Navegador do terminal. Arrastamos para o gráfico para executá-lo e obter sinais. O EA detecta e exibe o padrão Doji no gráfico. O seguinte é um exemplo de teste:

Exemplo de Doji

Como podemos ver no gráfico anterior, temos um objeto com uma seta preta abaixo da vela e o texto Doji, o padrão da vela.

Padrão de Martelo

O padrão de martelo é um padrão de velas muito popular que podemos ver no gráfico em muitos períodos gráficos. Seu nome vem de sua forma, pois possui uma longa sombra e um corpo pequeno. Há dois tipos de padrões de martelo, martelo e martelo invertido, conforme a posição do corpo pequeno. Se ele tem uma longa sombra inferior e o corpo da vela está acima, é um martelo e pode ser uma vela de alta ou de baixa, com base no preço de abertura e fechamento. As seguintes figuras são exemplos deste padrão de martelo:

  • Martelo de alta

Martelo de alta

Esse padrão indica que o vendedor estava tentando baixar o preço, mas o comprador está no controle do mercado. Aqui a vela fecha mais alto do que sua abertura, o que significa força para o comprador.

  • Martelo de baixa

Martelo de baixa

Esse padrão indica que o vendedor estava tentando empurrar o preço para baixo e o comprador fechou perto do preço de abertura, o que significa que o comprador ainda está no jogo.

Se a vela tiver uma longa sombra superior e seu corpo estiver na parte inferior, trata-se de um padrão de martelo invertido, que também pode ser de alta ou de baixa, dependendo da posição dos preços de abertura e fechamento. Exemplos de martelo invertido:

  • Martelo invertido de alta

Martelo invertido de alta

Isso indica que o comprador tentou empurrar os preços para cima, mas o vendedor fechou a vela em torno da abertura e da mínima, o que significa que o vendedor ainda está no jogo, apesar da força do comprador.

  • Martelo invertido de baixa

Martelo invertido de baixa

Esse padrão indica que o comprador estava tentando baixar o preço, mas o vendedor está no controle do mercado. A vela fecha abaixo da abertura, o que significa a força do vendedor.

Este padrão, assim como todos os padrões de velas, será mais significativo e relevante quando combinado com outras ferramentas técnicas. 

Para encontrar esse tipo de padrão, determinaremos o preço, a hora e o tamanho da vela, comparando o tamanho do corpo e das sombras. Quando um padrão de martelo ou martelo invertido for detectado, uma seta vermelha ou verde e o nome do padrão serão exibidos no gráfico.

O código completo do programa fica assim:

//+------------------------------------------------------------------+
//|                                      Hammer pattern detector.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
void OnTick()
  {
   getHammer(0.07,0.7);
  }
int getHammer(double smallShadowRatio, double longShadowRatio)
  {
   datetime time=iTime(_Symbol,PERIOD_CURRENT,1);
   double open=iOpen(_Symbol,PERIOD_CURRENT,1);
   double high=iHigh(_Symbol,PERIOD_CURRENT,1);
   double low=iLow(_Symbol,PERIOD_CURRENT,1);
   double close=iClose(_Symbol,PERIOD_CURRENT,1);
   double candleSize=high-low;
   if(open<close)
     {
      if(high-close < candleSize*smallShadowRatio)
        {
         if(open-low>candleSize*longShadowRatio)
            createObj(time,low,217, clrGreen,"Hammer");
           {
            return 1;
           }
        }
     }
   if(open>close)
     {
      if(high-open<candleSize*smallShadowRatio)
        {
         if(close-low>candleSize*longShadowRatio)
            createObj(time,high,218,clrRed,"Hammer");
           {
            return 1;
           }
        }
     }
   if(open<close)
     {
      if(open-low < candleSize*smallShadowRatio)
        {
         if(high-close>candleSize*longShadowRatio)
            createObj(time,low,217, clrGreen,"Inverted Hammer");
           {
            return -1;
           }
        }
     }
   if(open>close)
     {
      if(close-low < candleSize*smallShadowRatio)
        {
         if(high-open>candleSize*longShadowRatio)
            createObj(time,high,218, clrRed,"Inverted Hammer");
           {
            return -1;
           }
        }
     }
   return 0;
  }
void createObj(datetime time, double price, int arrawCode, color clr, string txt)
  {
   string objName=" ";
   StringConcatenate(objName, "Signal@",time, "at",DoubleToString(price,_Digits),"(",arrawCode,")");
   if(ObjectCreate(0,objName,OBJ_ARROW,0,time,price))
     {
      ObjectSetInteger(0,objName,OBJPROP_ARROWCODE,arrawCode);
      ObjectSetInteger(0,objName,OBJPROP_COLOR,clr);
      if(clr==clrGreen)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_TOP);
      if(clr==clrRed)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_BOTTOM);
     }
   string candleName=objName+txt;
   if(ObjectCreate(0,candleName,OBJ_TEXT,0,time,price))
     {
      ObjectSetString(0,candleName,OBJPROP_TEXT," "+txt);
      ObjectSetInteger(0,candleName,OBJPROP_COLOR,clr);
     }
  }

Diferenças introduzidas no código:

Aqui chamamos a função getHammer em OnTick() com os parâmetros smallShadowRatio e longShadowRatio necessários definidos.

void OnTick()
  {
   getHammer(0.07,0.7);
  }

Criamos uma função getHammer com parâmetros de duas variáveis ​​do tipo double smallShadowRatio e longShadowRatio

int getHammer(double smallShadowRatio, double longShadowRatio)

Criamos uma variável double para o tamanho da vela candleSize, que será usada para comparação

double candleSize=high-low;

Condições do padrão de martelo:

No caso de um martelo de alta (abertura menor que o fechamento), a última vela deve ser de alta, a sombra superior da vela (máxima-fechamento) é menor que a proporção de sombra curta (0,07) e a sombra inferior (abertura-mínima) é maior que a proporção de sombra longa (0,7). Criamos uma seta verde com o código 217 de Wingdings e um objeto de texto denominado "Hammer" no gráfico abaixo da mínima da vela do martelo e concluímos a função.

   if(open<close)
     {
      if(high-close < candleSize*smallShadowRatio)
        {
         if(open-low>candleSize*longShadowRatio)
            createObj(time,low,217, clrGreen,"Hammer");
           {
            return 1;
           }
        }
     }

No caso de um martelo de baixa (abertura maior que fechamento), a última vela deve ser de baixa, a sombra superior da vela (alta-abertura) é menor que a proporção de sombra curta (0,07) e a sombra inferior (fechada-mínima) é maior que a proporção de sombra longa (0,7). Criamos uma seta vermelha com o código 218 de Wingdings e um objeto de texto denominado "Hammer" no gráfico acima da máxima da vela do martelo e concluímos a função.

   if(open>close)
     {
      if(high-open<candleSize*smallShadowRatio)
        {
         if(close-low>candleSize*longShadowRatio)
            createObj(time,high,218,clrRed,"Hammer");
           {
            return 1;
           }
        }
     }

No caso de um martelo invertido de alta (abertura menor do que o fechamento), a última vela deve ser de alta, a sombra inferior da vela (abertura-mínima) é menor que a proporção de sombra curta (0,07) e a sombra superior (mínima-fechamento) é maior do que proporção de sombra longa (0,7). Criamos uma seta verde com o código 217 de Wingdings e um objeto de texto denominado "Inverted Hammer" no gráfico abaixo da mínima da vela do martelo e concluímos a função.

   if(open<close)
     {
      if(open-low < candleSize*smallShadowRatio)
        {
         if(high-close>candleSize*longShadowRatio)
            createObj(time,low,217, clrGreen,"Inverted Hammer");
           {
            return -1;
           }
        }
     }

No caso de um martelo invertido de baixa (abertura mais alta do que fechada), a última vela deve ser de baixa, a sombra inferior da vela (fechamento-mínima) é menor que proporção da sombra curta (0,07) e a sombra superior (máxima-abertura) é maior que a proporção da sombra longa (0,7). Criamos uma seta vermelha com o código 218 de Wingdings e um objeto de texto denominado "Inverted Hammer" no gráfico acima da máxima da vela do martelo e concluímos a função.

   if(open>close)
     {
      if(close-low < candleSize*smallShadowRatio)
        {
         if(high-open>candleSize*longShadowRatio)
            createObj(time,high,218, clrRed,"Inverted Hammer");
           {
            return -1;
           }
        }
     }

Editamos a posição da seta e sua cor dependendo do tipo de vela, mediante o operador (if), a expressão será a cor, e o operador, se verdadeiro, será a posição da seta, mediante a função ObjectSetInteger.

Caso haja uma seta verde abaixo da vela

      if(clr==clrGreen)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_TOP);

Caso haja uma seta vermelha abaixo da vela 

      if(clr==clrRed)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_BOTTOM);

Compilamos o código do EA. Ele aparece na janela do Navegador no terminal. A partir daí, o executamos no gráfico. Abaixo segue um exemplo de como funciona:

  • Martelo de alta:

Exemplo de martelo de alta

Como você pode ver, temos uma seta verde e um objeto de texto verde "Hammer" no gráfico abaixo da mínima do martelo de alta.

  • Martelo de baixa:

Exemplo de martelo de baixa

Como podemos ver, temos uma seta vermelha e um objeto de texto vermelho "Hammer" no gráfico acima da máxima do martelo de baixa.

  • Martelo invertido de alta:

Exemplo de martelo invertido de alta

O gráfico mostra uma seta verde e um objeto de texto verde "Inverted Hammer" abaixo da mínima do padrão de martelo de alta.

  • Martelo invertido de baixa:

Exemplo de um martelo invertido de baixa

Temos uma seta vermelha e um objeto de texto vermelho "Inverted Hammer" no gráfico acima da máxima do martelo de baixa.

Padrão de duas velas

Nesta parte, veremos outro tipo de padrão de velas que consiste em duas delas, veremos dois padrões populares que são o engolimento (de alta/baixa) e seu oposto de baixa - o padrão cobertura de nuvem escura.

Padrão engolimento:

Esse padrão de vela também é muito popular na análise técnica. Consiste em duas velas, uma delas engloba a outra, o que significa que tem uma vela pequena seguida por uma maior e esta maior cobre a menor completamente.

A cor e a direção da vela definem qual o tipo da vela que «engole»:

  • Engolimento de alta:

Consiste em uma pequena vela de baixa seguida por uma vela grande de alta, e essa vela de alta engloba completamente a menor:

Engolimento de alta

Esse padrão pode indicar que o comprador controla o mercado e que o preço pode continuar subindo após ele.

  • Engolimento de baixa:

Consiste em uma pequena vela de alta seguida por uma grande vela de baixa, e essa vela de baixa engloba completamente a menor:

Engolimento de baixa

Esse padrão pode indicar que o vendedor está no controle do mercado e que o preço pode continuar caindo após ele.

Agora, se quisermos criar um programa que possa ser usado para detectar este padrão automaticamente, precisamos definir a hora da última vela e os preços das duas últimas velas. Para fazer isso, precisamos que o programa verifique continuamente esses valores a cada tick e determine suas posições em relação uns aos outros. Com base nisso, verificamos se temos esse padrão engolimento ou não. Se for encontrado o padrão engolimento, exibiremos um determinado sinal no gráfico, que é uma seta colorida e um objeto de texto, dependendo do tipo do padrão (de alta ou de baixa).

A seguir está o código completo para criar este programa:

//+------------------------------------------------------------------+
//|                                   Engulfing pattern detector.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
void OnTick()
  {
   getEngulfing();
  }
int getEngulfing()
  {
   datetime time=iTime(_Symbol,PERIOD_CURRENT,1);
   double open=iOpen(_Symbol,PERIOD_CURRENT,1);
   double high=iHigh(_Symbol,PERIOD_CURRENT,1);
   double low=iLow(_Symbol,PERIOD_CURRENT,1);
   double close=iClose(_Symbol,PERIOD_CURRENT,1);
   double open2=iOpen(_Symbol,PERIOD_CURRENT,2);
   double high2=iHigh(_Symbol,PERIOD_CURRENT,2);
   double low2=iLow(_Symbol,PERIOD_CURRENT,2);
   double close2=iClose(_Symbol,PERIOD_CURRENT,2);
   if(open<close)
     {
      if(open2>close2)
        {
         if(high>high2&&low<low2)
           {
            if(close>open2&&open<close2)
              {
               createObj(time,low,217, clrGreen,"Bullish Engulfing");
                 {
                  return 1;
                 }
              }
           }
        }
     }
   if(open>close)
     {
      if(open2<close2)
        {
         if(high>high2&&low<low2)
           {
            if(close<open2&&open>close2)
              {
               createObj(time,high,218, clrRed,"Bearish Engulfing");
                 {
                  return -1;
                 }
              }
           }
        }
     }
   return 0;
  }
void createObj(datetime time, double price, int arrawCode, color clr, string txt)
  {
   string objName=" ";
   StringConcatenate(objName, "Signal@",time, "at",DoubleToString(price,_Digits),"(",arrawCode,")");
   if(ObjectCreate(0,objName,OBJ_ARROW,0,time,price))
     {
      ObjectSetInteger(0,objName,OBJPROP_ARROWCODE,arrawCode);
      ObjectSetInteger(0,objName,OBJPROP_COLOR,clr);
      if(clr==clrGreen)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_TOP);
      if(clr==clrRed)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_BOTTOM);
     }
   string candleName=objName+txt;
   if(ObjectCreate(0,candleName,OBJ_TEXT,0,time,price))
     {
      ObjectSetString(0,candleName,OBJPROP_TEXT," "+txt);
      ObjectSetInteger(0,candleName,OBJPROP_COLOR,clr);
     }
  }

Essas são as diferenças neste código:

Criamos duas variáveis double com a hora da última vela e o preço das duas últimas velas a serem usadas na função getEngulfing. Os parâmetros time, open, high, low e close são usados para a última vela, enquanto open2, high2, low2 e close2 são usados para a penúltima vela.

   datetime time=iTime(_Symbol,PERIOD_CURRENT,1);
   double open=iOpen(_Symbol,PERIOD_CURRENT,1);
   double high=iHigh(_Symbol,PERIOD_CURRENT,1);
   double low=iLow(_Symbol,PERIOD_CURRENT,1);
   double close=iClose(_Symbol,PERIOD_CURRENT,1);
   double open2=iOpen(_Symbol,PERIOD_CURRENT,2);
   double high2=iHigh(_Symbol,PERIOD_CURRENT,2);
   double low2=iLow(_Symbol,PERIOD_CURRENT,2);
   double close2=iClose(_Symbol,PERIOD_CURRENT,2);

Condições para identificar este tipo de padrão de velas

No caso de um engolimento de alta, a última vela é de alta (open < close), a penúltima vela deve ser de baixa (open2 > close2), a máxima da última vela (high) é maior que a máxima da penúltima vela (high2) e a mínima da última vela (low) é menor que a mínima da penúltima vela (low2). Além disso, o fechamento da última (close) é maior que a abertura da penúltima (open2) e a abertura da penúltima (open) é menor que o fechamento da penúltima (close2). Depois de definir essa vela, criamos um objeto com base na função criada (createObj) com os seguintes parâmetros:

  • time — hora da última vela, predefinida pela variável.
  • price — mínima da última vela, sob a qual nosso objeto será mostrado.
  • arrowCode — seta com o código 217 Wingdings.
  • clr — cor clrGreen.
  • txt — texto "Bullish Engulfing".

Concluímos a função.

   if(open<close)
     {
      if(open2>close2)
        {
         if(high>high2&&low<low2)
           {
            if(close>open2&&open<close2)
              {
               createObj(time,low,217, clrGreen,"Bullish Engulfing");
                 {
                  return 1;
                 }
              }
           }
        }
     }

No caso de um engolimento de baixa, a última vela é de baixa (open > close), a penúltima vela é de alta (open2 < close2), a máxima está acima da máxima2, a mínima está abaixo da mínima2, o fechamento está abaixo da abertura2 e a abertura está acima do fechamento2. Depois de definir essa vela, criamos um objeto com base na função criada (createObj) com os seguintes parâmetros:

  • time — hora da última vela, predefinida pela variável.
  • price — máxima da última vela, sobre a qual nosso objeto será mostrado.
  • arrowCode — seta com o código 218 Wingdings.
  • clr — cor clrRed.
  • txt — texto "Bearish Engulfing".

Concluímos a função.

   if(open>close)
     {
      if(open2<close2)
        {
         if(high>high2&&low<low2)
           {
            if(close<open2&&open>close2)
              {
               createObj(time,high,218, clrRed,"Bearish Engulfing");
                 {
                  return -1;
                 }
              }
           }
        }
     }

Compilamos o código do EA. Ele aparece na janela do Navegador no terminal. A partir daí, o executamos no gráfico. Abaixo segue um exemplo de como funciona:

  • Engolimento de alta:

Exemplo de engolimento de alta

No gráfico, temos uma seta verde e o texto "Bullish Engulfing" abaixo da mínima da última vela do padrão.

  • Engolimento de baixa:

Exemplo de engolimento de baixa

No gráfico, vemos uma seta vermelha e a legenda "Bearish Engulfing" acima da máxima da última vela do padrão.

Linha de perfuração / Cobertura de nuvem escura

  • Padrão de linha de perfuração

É uma vela de alta e consiste em duas delas, sendo que a primeira vela é de baixa e é seguida por uma vela de alta com abertura mais baixa do que a vela de baixa, depois sobe e fecha acima do ponto médio da primeira vela de baixa. A figura a seguir mostra um gráfico que descreve isso:

Linha de perfuração

Isso indica que o comprador se torna mais forte e controla o mercado após o controle do vendedor. Por isso, esse padrão se refere a uma mudança do poder de venda para o poder de compra, pois o comprador conseguiu empurrar o preço acima do ponto médio da vela de baixa anterior, embora tenha havido uma lacuna durante a abertura.

  • Padrão de cobertura de nuvem escura

É a forma oposta do padrão de perfuração, pois é um padrão de baixa que tem uma estrutura de duas velas: a primeira é de alta e é seguida por uma vela de baixa com um lacuna de abertura e fecha abaixo do ponto médio da primeira vela de alta. A seguir, temos um gráfico para ele:

cobertura de nuvem escura

Isso indica que o vendedor se torna mais forte e controla o mercado após o controle do comprador. Dessa forma, ele se refere a uma mudança do poder de compra para o poder de venda, pois o vendedor conseguiu empurrar o preço abaixo do ponto médio da vela de alta anterior, embora tenha havido uma lacuna durante a abertura.

Quando quisermos criar um programa que possa ser usado para detectar esse tipo de padrão, precisaremos definir a hora e os preços da primeira vela ( time, open, high, low e close) e os preços da segunda vela (open2, high2, low2 e close2), o tamanho da vela da primeira vela (candleSize2) e o ponto médio da primeira vela (candleMidPoint2). Precisamos que o programa verifique continuamente esses valores e determine suas posições em relação uns aos outros e retorne um sinal específico com base em condições específicas baseadas na alta ou na baixa.

A seguir está o código completo para criar este programa:

//+------------------------------------------------------------------+
//|                      Piercing && Dark Cloud pattern detector.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
void OnTick()
  {
   getPiercing();  
  }
int getPiercing()
  {
   datetime time=iTime(_Symbol,PERIOD_CURRENT,1);
   double open=iOpen(_Symbol,PERIOD_CURRENT,1);
   double high=iHigh(_Symbol,PERIOD_CURRENT,1);
   double low=iLow(_Symbol,PERIOD_CURRENT,1);
   double close=iClose(_Symbol,PERIOD_CURRENT,1);
   double open2=iOpen(_Symbol,PERIOD_CURRENT,2);
   double high2=iHigh(_Symbol,PERIOD_CURRENT,2);
   double low2=iLow(_Symbol,PERIOD_CURRENT,2);
   double close2=iClose(_Symbol,PERIOD_CURRENT,2);
   double candleSize2=high2-low2;
   double candleMidPoint2=high2-(candleSize2/2);
   if(open<close)
     {
      if(open2>close2)
        {
         if(open<low2)
           {
            if(close>candleMidPoint2&&close<high2)
              {
               createObj(time,low,217, clrGreen,"Piercing");
                 {
                  return 1;
                 }
              }
           }
        }
     }
   if(open>close)
     {
      if(open2<close2)
        {
         if(open>high2)
           {
            if(close<candleMidPoint2&&close>low2)
              {
               createObj(time,high,218, clrRed,"Dark Cloud");
                 {
                  return -1;
                 }
              }
           }
        }
     }
   return 0;
  }
void createObj(datetime time, double price, int arrawCode, color clr, string txt)
  {
   string objName=" ";
   StringConcatenate(objName, "Signal@",time, "at",DoubleToString(price,_Digits),"(",arrawCode,")");
   if(ObjectCreate(0,objName,OBJ_ARROW,0,time,price))
     {
      ObjectSetInteger(0,objName,OBJPROP_ARROWCODE,arrawCode);
      ObjectSetInteger(0,objName,OBJPROP_COLOR,clr);
      if(clr==clrGreen)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_TOP);
      if(clr==clrRed)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_BOTTOM);
     }
   string candleName=objName+txt;
   if(ObjectCreate(0,candleName,OBJ_TEXT,0,time,price))
     {
      ObjectSetString(0,candleName,OBJPROP_TEXT," "+txt);
      ObjectSetInteger(0,candleName,OBJPROP_COLOR,clr);
     }
  }

Diferenças no código:

Definição de CandleSize2 e CandleMidPoint2

   double candleSize2=high2-low2;
   double candleMidPoint2=high2-(candleSize2/2);

Condições do padrão

No caso do padrão de linha de perfuração

Se a última vela for de alta (open<close), e open2 for maior que close2, open for menor que low2 e close for maior que candleMidPoint2 e, ao mesmo tempo, close for menor que high2, precisamos que o programa retorne um objeto no gráfico com uma seta verde e o texto "Piercing" abaixo da mínima do padrão e, em seguida, encerre a função.

   if(open<close)
     {
      if(open2>close2)
        {
         if(open<low2)
           {
            if(close>candleMidPoint2&&close<high2)
              {
               createObj(time,low,217, clrGreen,"Piercing");
                 {
                  return 1;
                 }
              }
           }
        }
     }

No caso do padrão de cobertura de nuvem escura

Se a última vela for de baixa (open>close), e open2 for menor que close2, open for maior que high2 e close for menor que candleMidPoint2 e, ao mesmo tempo, close for maior que low2, precisamos que o programa retorne um objeto no gráfico com uma seta vermelha e o texto "Dark Cloud" acima da máxima do padrão e, em seguida, encerre a função.

   if(open>close)
     {
      if(open2<close2)
        {
         if(open>high2)
           {
            if(close<candleMidPoint2&&close>low2)
              {
               createObj(time,high,218, clrRed,"Dark Cloud");
                 {
                  return -1;
                 }
              }
           }
        }
     }

Compilamos o código do EA. Ele aparece na janela do Navegador no terminal. A partir daí, o executamos no gráfico. Abaixo segue um exemplo de como funciona:

  • Padrão de linha de perfuração

Exemplo de padrão de linha de perfuração

Como podemos ver no gráfico anterior, temos nossa seta verde e o texto de piercing abaixo da mínima do padrão, da mesma forma que precisamos.

  • Padrão de cobertura de nuvem escura

Exemplo de padrão de cobertura de nuvem escura

Como podemos ver no gráfico anterior, temos uma seta vermelha e o texto Dark Cloud acima da máxima do padrão, da mesma forma que precisamos.

Padrão de três velas

Nesta parte, veremos dois padrões dos padrões combinados, que são o padrão de estrela (manhã, noite) e o padrão de três velas internas (para cima, para baixo).

Padrão de estrela

  • Estrela da manhã:

É uma estrutura de três velas igual à que mencionamos. É formada por uma pequena vela entre duas velas: a primeira é uma longa de baixa e a segunda é uma longa de alta. A seguir, temos um gráfico para ele:

Estrela da manhã

Ele nos diz que o padrão de estrela da noite é um padrão de venda, que indica uma mudança de poder da venda para a compra, já que o comprador controla o mercado e empurra o preço para cima depois de um declínio pelo controle do vendedor.

  • Estrela da noite
É uma estrutura de três velas igual à que mencionamos. É formado por uma pequena vela entre duas velas: a primeira é uma longa de alta e a segunda é uma longa de baixa. A seguir, um gráfico dessa estrutura:

Estrela da noite

Ele nos indica uma mudança de poder da compra para a venda, pois o vendedor controla o mercado e empurra o preço para baixo depois de uma alta pelo controle do comprador.

Quando queremos criar um programa que possa ser usado para detectar esse tipo de padrão, precisamos definir a hora e o preço da última vela e os dados de preço das duas velas anteriores da última, candleSize das três últimas velas e compará-los entre si para determinar suas posições em relação umas às outras para obter sinais específicos com base em condições específicas.

A seguir está o código completo para criar este programa:

//+------------------------------------------------------------------+
//|                                        Star pattern detector.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
void OnTick()
  {
   getStar(0.5);
  }
int getStar(double middleCandleRatio)
  {
   datetime time=iTime(_Symbol,PERIOD_CURRENT,1);
   double open=iOpen(_Symbol,PERIOD_CURRENT,1);
   double high=iHigh(_Symbol,PERIOD_CURRENT,1);
   double low=iLow(_Symbol,PERIOD_CURRENT,1);
   double close=iClose(_Symbol,PERIOD_CURRENT,1);
   double open2=iOpen(_Symbol,PERIOD_CURRENT,2);
   double high2=iHigh(_Symbol,PERIOD_CURRENT,2);
   double low2=iLow(_Symbol,PERIOD_CURRENT,2);
   double close2=iClose(_Symbol,PERIOD_CURRENT,2);
   double open3=iOpen(_Symbol,PERIOD_CURRENT,3);
   double high3=iHigh(_Symbol,PERIOD_CURRENT,3);
   double low3=iLow(_Symbol,PERIOD_CURRENT,3);
   double close3=iClose(_Symbol,PERIOD_CURRENT,3);
   double candleSize=high-low;
   double candleSize2=high2-low2;
   double candleSize3=high3-low3;
   if(open<close)
     {
      if(open3>close3)
        {
         if(candleSize2<candleSize*middleCandleRatio && candleSize2<candleSize3*middleCandleRatio)
           {
            createObj(time,low,217, clrGreen,"Morning Star");
              {
               return 1;
              }
           }
        }

     }
   if(open>close)
     {
      if(open3<close3)
        {
         if(candleSize2<candleSize*middleCandleRatio && candleSize2<candleSize3*middleCandleRatio)
           {
            createObj(time,high,218, clrRed,"Evening Star");
              {
               return -1;
              }
           }
        }

     }
   return 0;
  }
void createObj(datetime time, double price, int arrawCode, color clr, string txt)
  {
   string objName=" ";
   StringConcatenate(objName, "Signal@",time, "at",DoubleToString(price,_Digits),"(",arrawCode,")");
   if(ObjectCreate(0,objName,OBJ_ARROW,0,time,price))
     {
      ObjectSetInteger(0,objName,OBJPROP_ARROWCODE,arrawCode);
      ObjectSetInteger(0,objName,OBJPROP_COLOR,clr);
      if(clr==clrGreen)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_TOP);
      if(clr==clrRed)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_BOTTOM);
     }
   string candleName=objName+txt;
   if(ObjectCreate(0,candleName,OBJ_TEXT,0,time,price))
     {
      ObjectSetString(0,candleName,OBJPROP_TEXT," "+txt);
      ObjectSetInteger(0,candleName,OBJPROP_COLOR,clr);
     }
  }

Diferenças no código:

Criação do (getStar) com o parâmetro middleCandleRatio

int getStar(double middleCandleRatio)

Criação de variáveis de tempo para a última vela e os dados de preço (abertura, alta, baixa, fechamento) e o tamanho da vela para as três últimas velas (candlesize, candleSize2 e candleSize3)

   datetime time=iTime(_Symbol,PERIOD_CURRENT,1);
   double open=iOpen(_Symbol,PERIOD_CURRENT,1);
   double high=iHigh(_Symbol,PERIOD_CURRENT,1);
   double low=iLow(_Symbol,PERIOD_CURRENT,1);
   double close=iClose(_Symbol,PERIOD_CURRENT,1);
   double open2=iOpen(_Symbol,PERIOD_CURRENT,2);
   double high2=iHigh(_Symbol,PERIOD_CURRENT,2);
   double low2=iLow(_Symbol,PERIOD_CURRENT,2);
   double close2=iClose(_Symbol,PERIOD_CURRENT,2);
   double open3=iOpen(_Symbol,PERIOD_CURRENT,3);
   double high3=iHigh(_Symbol,PERIOD_CURRENT,3);
   double low3=iLow(_Symbol,PERIOD_CURRENT,3);
   double close3=iClose(_Symbol,PERIOD_CURRENT,3);
   double candleSize=high-low;
   double candleSize2=high2-low2;
   double candleSize3=high3-low3;

Condições do padrão

No caso do padrão de estrela da manhã:

Se a última vela for de alta (open<close), a terceira for de baixa (open3>close3), o candleSize2 for menor que o middleCandleRatio do candleSize, que é 0,5, e, ao mesmo tempo, o candleSize2 for menor que o middleCandleRatio do candleSize3, precisamos que o programa retorne um objeto com uma seta verde e o texto "Morning Star" abaixo da mínima do padrão e, em seguida, encerre a função.

   if(open<close)
     {
      if(open3>close3)
        {
         if(candleSize2<candleSize*middleCandleRatio && candleSize2<candleSize3*middleCandleRatio)
           {
            createObj(time,low,217, clrGreen,"Morning Star");
              {
               return 1;
              }
           }
        }
     }

No caso do padrão de estrela da noite:

Se a última vela for de baixa (open>close), a terceira for de alta (open3<close3), o candleSize2 for menor que o middleCandleRatio do candleSize, que é 0,5, e, ao mesmo tempo, o candleSize2 for menor que o middleCandleRatio do candleSize3, precisamos que o programa retorne um objeto com uma seta vermelha e o texto "Evening Star" acima da máxima do padrão e, em seguida, encerre a função.

   if(open>close)
     {
      if(open3<close3)
        {
         if(candleSize2<candleSize*middleCandleRatio && candleSize2<candleSize3*middleCandleRatio)
           {
            createObj(time,high,218, clrRed,"Evening Star");
              {
               return -1;
              }
           }
        }
     }

Compilamos o código do EA. Depois disso, ele aparecerá na janela Navegador do terminal, a partir daí o iniciamos no gráfico. Abaixo segue um exemplo de como funciona:

  • Estrela da manhã:

Exemplo de estrela da manhã

Como podemos ver, temos o sinal desejado do objeto necessário no gráfico abaixo do padrão detectado.

  • Estrela da tarde:

Exemplo de estrela da noite

Como podemos ver, temos o sinal desejado do objeto necessário no gráfico abaixo do padrão detectado.

Como observação para o padrão Estrela, a formação do padrão idêntico tem uma lacuna com a vela pequena do meio; você pode adicioná-la como uma condição adicional no código, se quiser obter o padrão idêntico.

Padrão de três dentro

  • Três dentro para cima:

É um padrão de três velas também, a primeira vela é uma longa de baixa, a segunda é uma pequena vela de alta que está sendo negociada dentro da primeira, e a terceira é uma vela longa de alta que fecha acima da máxima da primeira. A seguir, um gráfico desse padrão.

Três dentro para cima:

Ele indica um potencial de alta pelo controle do comprador.

  • Três dentro para baixo:

Também é um padrão de três velas: a primeira é uma vela longa de alta, a segunda é uma pequena vela de baixa que está sendo negociada dentro da primeira, e a terceira é uma vela longa de baixa que fecha abaixo da mínima da primeira. A seguir, um gráfico desse padrão. A seguir, um gráfico desse padrão.

Três dentro para baixo

Ele indica uma possível baixa pelo controle do vendedor. Se quisermos criar um programa que possa ser usado para detectar esse tipo de padrão, definiremos também a hora da última vela e os dados de preço das três últimas velas, deixaremos que o programa verifique esses valores a cada tick e determine suas posições relacionadas entre si para retornar um sinal adequado como um objeto no gráfico, dependendo do padrão. A seguir, o código completo desse programa: 
//+------------------------------------------------------------------+
//|                                Three inside pattern detector.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
void OnTick()
  {
   getthreeInside();
  }
int getthreeInside()
  {
   datetime time=iTime(_Symbol,PERIOD_CURRENT,1);
   double open=iOpen(_Symbol,PERIOD_CURRENT,1);
   double high=iHigh(_Symbol,PERIOD_CURRENT,1);
   double low=iLow(_Symbol,PERIOD_CURRENT,1);
   double close=iClose(_Symbol,PERIOD_CURRENT,1);
   double open2=iOpen(_Symbol,PERIOD_CURRENT,2);
   double high2=iHigh(_Symbol,PERIOD_CURRENT,2);
   double low2=iLow(_Symbol,PERIOD_CURRENT,2);
   double close2=iClose(_Symbol,PERIOD_CURRENT,2);
   double open3=iOpen(_Symbol,PERIOD_CURRENT,3);
   double high3=iHigh(_Symbol,PERIOD_CURRENT,3);
   double low3=iLow(_Symbol,PERIOD_CURRENT,3);
   double close3=iClose(_Symbol,PERIOD_CURRENT,3);
   if(open3>close3)
     {
      if(open2<close2)
        {
         if(open2>low3&&close2<high3)
           {
            if(open<close&&open>open2&&open<close2)
              {
               if(close>high3)
                 {
                  createObj(time,low,217, clrGreen,"3 Inside Up");
                    {
                     return 1;
                    }
                 }
              }
           }
        }

     }
   if(open3<close3)
     {
      if(open2>close2)
        {
         if(open2<high3&&close2>low3)
           {
            if(open>close&&open<open2&&open>close2)
              {
               if(close<low3)
                 {
                  createObj(time,high,218, clrRed,"3 Inside Down");
                    {
                     return -1;
                    }
                 }
              }
           }
        }
     }
   return 0;
  }
void createObj(datetime time, double price, int arrawCode, color clr, string txt)
  {
   string objName=" ";
   StringConcatenate(objName, "Signal@",time, "at",DoubleToString(price,_Digits),"(",arrawCode,")");
   if(ObjectCreate(0,objName,OBJ_ARROW,0,time,price))
     {
      ObjectSetInteger(0,objName,OBJPROP_ARROWCODE,arrawCode);
      ObjectSetInteger(0,objName,OBJPROP_COLOR,clr);
      if(clr==clrGreen)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_TOP);
      if(clr==clrRed)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_BOTTOM);
     }
   string candleName=objName+txt;
   if(ObjectCreate(0,candleName,OBJ_TEXT,0,time,price))
     {
      ObjectSetString(0,candleName,OBJPROP_TEXT," "+txt);
      ObjectSetInteger(0,candleName,OBJPROP_COLOR,clr);
     }
  }

As diferenças nesse código são condições do padrão

No caso do três dentro para cima

   if(open3>close3)
     {
      if(open2<close2)
        {
         if(open2>low3&&close2<high3)
           {
            if(open<close&&open>open2&&open<close2)
              {
               if(close>high3)
                 {
                  createObj(time,low,217, clrGreen,"3 Inside Up");
                    {
                     return 1;
                    }
                 }
              }
           }
        }

     }

No caso do três dentro para baixo

   if(open3<close3)
     {
      if(open2>close2)
        {
         if(open2<high3&&close2>low3)
           {
            if(open>close&&open<open2&&open>close2)
              {
               if(close<low3)
                 {
                  createObj(time,high,218, clrRed,"3 Inside Down");
                    {
                     return -1;
                    }
                 }
              }
           }
        }
     }

Compilamos o código do EA e ele aparece na janela do Navegador no terminal. A partir daí, o executamos no gráfico. Abaixo segue um exemplo de como funciona:

  • Três dentro para cima:

Exemplo três dentro para cima

O padrão é encontrado e mostrado no gráfico.

  • Três dentro para baixo:

Exemplo três dentro para baixo

Também aqui o padrão é encontrado e mostrado no gráfico.

Considerações finais

Após a leitura dos tópicos deste artigo, é de se supor que você tenha aprendido a escrever o código para detectar os padrões de velas em suas diferentes formações, padrões de uma vela, duas velas e três velas:

  • Padrões de vela única: aprendemos a detectar os padrões Doji e martelo.
  • Padrões de duas velas: aprendemos a detectar os padrões engolimento, linha de perfuração e cobertura de nuvem escura.
  • Padrões de três velas: aprendemos a criar um programa capaz de detectar os padrões de estrela e de três velas internas.

Espero que este artigo seja útil para ajudá-lo a atingir seus objetivos de negociação.

Traduzido do Inglês pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/en/articles/12385

Aviso: Todos os direitos sobre esses materiais pertencem à MetaQuotes Ltd. É proibida a reimpressão total ou parcial.

Outros artigos do autor

Ir para discussão
Implementando o fator Janus em MQL5 Implementando o fator Janus em MQL5
Gary Anderson desenvolveu um método de análise de mercado baseado em uma teoria que chamou de fator Janus. Essa teoria descreve um conjunto de indicadores que podem ser usados ​​para identificar tendências e avaliar o risco de mercado. Neste artigo, vamos implementar essas ferramentas no MQL5.
Desenvolvendo um sistema de Replay - Simulação de mercado (Parte 20): FOREX (I) Desenvolvendo um sistema de Replay - Simulação de mercado (Parte 20): FOREX (I)
intenção inicial deste artigo, não será cobrir todas as características do FOREX. Mas sim e apenas, adequar o sistema, de forma que você possa fazer no mínimo, um replay de mercado. Já a simulação, ficará para um outro momento. No entanto, caso você não os tenha os ticks, e tenha apenas as barras. Pode com algum trabalho, simular possíveis transações, que possam ter ocorrido no FOREX. Isto até que eu mostre como adaptar o simulador. O fato de se tentar trabalhar com dados vindos do FOREX, dentro do sistema, sem que ele seja modificado. Faz com que ocorra erros de range.
Redes neurais de maneira fácil (Parte 37): atenção esparsa Redes neurais de maneira fácil (Parte 37): atenção esparsa
No artigo anterior, abordamos modelos relacionais que usavam mecanismos de atenção. Uma das características desses modelos era o aumento do uso de recursos computacionais. O artigo de hoje apresenta um dos mecanismos para reduzir o número de operações computacionais dentro do bloco Self-Attention, o que aumenta o desempenho geral do modelo.
Teoria das Categorias em MQL5 (Parte 5): Equalizadores Teoria das Categorias em MQL5 (Parte 5): Equalizadores
A teoria das categorias é um ramo diversificado e em expansão da matemática que só recentemente começou a ser abordado na comunidade MQL5. Esta série de artigos tem como objetivo analisar alguns de seus conceitos para criar uma biblioteca aberta e utilizar ainda mais essa maravilhosa seção na criação de estratégias de negociação.