Construindo um Modelo de Restrição de Tendências de Candlestick (Parte 3): Detectando mudanças nas tendências ao usar este sistema

MetaTrader 5 — Negociação | 8 outubro 2024, 09:54

Clemence Benjamin

Conteúdo

Introdução

Geralmente, os mercados não permanecem estáticos. Seja em tendência de alta ou baixa, mudanças inesperadas podem ocorrer quando o mercado altera sua trajetória. É vital que um sistema identifique e se ajuste a essas mudanças. Até mesmo uma vela D1 baixista prolongada pode sinalizar uma mudança na dinâmica quando ocorre uma reversão em um prazo menor. Este artigo investiga vários métodos empregados para reconhecer mudanças nas tendências de ação do preço. À medida que os traders navegam pelas complexidades dos mercados financeiros, a capacidade de se adaptar rapidamente às condições em evolução se torna essencial. Reconhecer as nuances dos movimentos de preço, entender a importância de indicadores-chave e interpretar o sentimento de mercado são componentes cruciais para se manter à frente. Ao aprimorar a habilidade de identificar mudanças nas tendências, os traders podem se posicionar estrategicamente para capitalizar as oportunidades que surgem no cenário sempre mutável do mundo financeiro.

Vários fatores influenciam ou impulsionam mudanças nas tendências de mercado. Aqui estão alguns exemplos:

comportamento dos investidores, ou seja, compra e venda
divulgação de notícias econômicas, como PIB e Folha de Pagamento Não-Agrícola
políticas monetárias
eventos globais como desastres naturais
eventos políticos como guerras, etc.

Por meio de diferentes recursos de aprendizado, adquirimos um vasto conhecimento sobre como detectar manualmente mudanças nas tendências. Isso inclui o conceito de análise de linha de tendência, que envolve traçar linhas em um gráfico de preços para conectar os pontos altos ou baixos do movimento de preços de um ativo, de modo que os traders possam obter insights sobre possíveis mudanças de tendência quando o preço rompe acima ou abaixo dessas linhas. Mais adiante neste artigo, selecionaremos um método para detectar mudanças de tendência de mercado e integrá-lo ao nosso indicador de Restrição de Tendências usando MQL5. Primeiro, exploraremos várias ferramentas de análise técnica, como médias móveis, padrões de velas, índice de força relativa (ver parte 2) e linhas de tendência (ver Fig. 1) para identificar possíveis reversões de tendência. Prosseguiremos modificando nosso indicador de Restrição de Tendências em MQL5 para incorporar essa nova funcionalidade.

Aviso legal: As estratégias e técnicas descritas neste artigo são apenas para fins educacionais Suas negociações são resultado de suas próprias ações. Não me responsabilizo por quaisquer perdas decorrentes do uso das informações ou ferramentas fornecidas aqui.

ilustração de tendência

FIG 1: ilustração de tendências

Nota: A imagem acima foi desenhada à mão para fins de aprendizado; nenhum ativo real está sendo apresentado.

A ilustração acima mostra uma típica tendência de alta com os pontos A e B conectados por uma linha de tendência azul, indicando uma tendência ascendente. Nos exemplos a seguir, exploraremos instâncias reais de gráficos para entender melhor as tendências. Nosso principal objetivo é reconhecer mudanças nas tendências de mercado e incorporar um método adequado ao nosso sistema usando código MQL5.

Maneiras de detectar mudanças nas tendências de mercado.

Vamos começar definindo tendências de mercado como:

A tendência de mercado significa a direção geral que um mercado se move ao longo do tempo, refletindo o comportamento dos compradores e vendedores. As tendências podem ser de alta (bullish), de baixa (bearish) ou lateral (consolidação), ver (Fig. 1) em introdução.

Agora, vamos definir uma reversão de tendência como:

Uma reversão de tendência ocorre quando o movimento de preço muda de uma tendência de alta para uma tendência de baixa, ou vice-versa. Essa mudança pode ser identificada analisando indicadores técnicos importantes, como médias móveis, linhas de tendência, padrões de velas e níveis de suporte/resistência. Traders e investidores monitoram de perto essas mudanças nas tendências de mercado para tomar decisões informadas e ajustar suas estratégias conforme necessário.

Usando médias móveis para identificar reversão de tendência

Na parte 1 desta série, criamos um indicador de cruzamento de média móvel rápida para fornecer sinais de continuação de tendência quando ocorre um cruzamento. No entanto, médias móveis de período maior podem indicar uma mudança significativa de tendência durante um cruzamento. Neste artigo, examinaremos como as médias móveis reagem quando o mercado muda de direção. Abaixo está uma imagem

USDJPYmicroM5 mostrando como Médias Móveis podem sinalizar uma reversão

Fig 2: Cruzamento de média móvel como um sinal de reversão de tendência.

Usando padrões de velas para identificar reversões de tendência

Padrões de velas podem ser usados de forma eficaz para identificar possíveis reversões. Eles têm sido analisados ao longo da história por sua capacidade de alterar significativamente o sentimento do mercado. Visionários como Honma Munehisa, o criador da Bíblia dos Candlestick, enriqueceram nosso entendimento sobre velas. Aqui estão alguns dos padrões de velas mais prevalentes para reversões de mercado:

Nome da vela	Descrição
martelo	pequeno corpo e longa sombra inferior
martelo invertido	pequeno corpo e longa sombra superior
padrão envolvente de alta	uma vela de alta envolve completamente a vela de baixa anterior
padrão envolvente de baixa	um candle de baixa engloba completamente o candle de alta anterior
doji	um corpo pequeno e longas sombras superior e inferior
estrela cadente	pequeno corpo e longa sombra superior
enforcado	pequeno corpo e longa sombra inferior
estrela da manhã	um longo candle de baixa, seguido por um candle de corpo pequeno com mínima inferior e máxima superior
estrela da noite	um longo candle de alta, seguido por um candle de corpo pequeno com máxima superior e mínima inferior

Todas essas características de candles são programáveis usando MQL5 porque possuem todos os níveis de preço de abertura, fechamento, máxima e mínima, que são cruciais ao programar.

Usando Linhas de Tendência para identificar reversão de tendência

No gráfico da plataforma Mt5, podemos usar a ferramenta de objeto linha de tendência para traçar tendências conectando vales consecutivos em uma série de preços de um ativo digital. Uma linha de tendência rompida indica uma mudança de tendência. Para desenhar uma linha de tendência, basta clicar na ferramenta de linha de tendência na barra de ferramentas, depois clicar no primeiro vale e arrastar a linha até o próximo vale. A linha de tendência se estenderá automaticamente para o lado direito do gráfico.

Linha de tendência do índice B300 rompida

Fig 3: Linha de tendência como uma ferramenta para detectar reversão de tendência

Usando níveis de Suporte/resistência para identificar reversão de tendência

Uma ferramenta de linha horizontal no gráfico MT5 pode ser utilizada para traçar níveis de suporte e resistência em tendências, colocando-a sobre os picos de preço. Observar o preço quando rompe esses níveis pode indicar uma mudança de tendência. Confira o vídeo explicativo abaixo.

Problemas com nosso sistema atual.

Conseguimos configurar nosso sistema para alinhar seu sinal com a forma da tendência D1 e incorporar indicadores como SMA 400 na parte 2. No entanto, há desafios significativos observados em dados históricos. Devemos considerar as flutuações em timeframes menores, que podem reverter o sentimento inicial no começo do dia; por exemplo, um dia pode começar com uma perspectiva de baixa, mas terminar com um pin bar ou sentimento de alta. Sinais de reversão costumam surgir em timeframes menores, o que nos obriga a adaptar o mecanismo de sinalização do sistema para levar em conta mudanças de tendência, mesmo que inicialmente estejam confinadas ao sentimento diário do mercado.

Incorporando a função de detecção de mudança de tendência com MQL5

Optei por usar SMA 200 como uma média móvel lenta e EMA 100 como uma média móvel rápida. Normalmente, essas médias móveis estão mais distantes durante tendências fortes, mas mais próximas quando o momento do mercado é fraco ou o preço está lateralizando. Quando as duas médias se cruzam, geralmente isso sinaliza uma mudança de direção. Seria muito benéfico se nosso sistema detectasse isso e nos alertasse. Nosso objetivo é que o sistema apenas nos forneça o sinal, para que nossos sinais restritos possam ser ajustados conforme necessário. Com essa abordagem, pretendemos capturar possíveis reversões de tendência e aproveitar oportunidades de negociação lucrativas. Vou explicar alguns recursos-chave e depois incluir o código principal.

Nosso manipulador de MA é declarado da seguinte forma.

MA_handle3 = iMA(NULL, PERIOD_CURRENT, 100, 0, MODE_EMA, PRICE_CLOSE); // For EMA 100

MA_handle4 = iMA(NULL, PERIOD_CURRENT, 200, 0, MODE_SMA, PRICE_CLOSE); // For SMA 200

O código abaixo mostra as condições de cruzamento em MQL5 na função de iteração.

//Indicator Buffer 3
      if(MA3[i] > MA4[i]
      && MA3[i+1] < MA4[i+1] //Moving Average crosses above Moving Average
      )
        {
         Buffer3[i] = Low[i]; //Set indicator value at Candlestick Low
         if(i == 1 && Time[1] != time_alert) myAlert("indicator", "Buy Reversal"); //Alert on next bar open
         time_alert = Time[1];
        }
      else
        {
         Buffer3[i] = EMPTY_VALUE;
        }
      //Indicator Buffer 4
      if(MA3[i] < MA4[i]
      && MA3[i+1] > MA4[i+1] //Moving Average crosses below Moving Average
      )
        {
         Buffer4[i] = High[i]; //Set indicator value at Candlestick High
         if(i == 1 && Time[1] != time_alert) myAlert("indicator", "Sell Reversal"); //Alert on next bar open
         time_alert = Time[1];
        }
      else
        {
         Buffer4[i] = EMPTY_VALUE;
        }

A Restrição de Tendência do artigo anterior apresentava 2 buffers, um para sinais de compra e outro para sinais de venda, para a continuação da tendência. Para alcançar nosso objetivo, queremos adicionar mais dois buffers, um para venda e outro para compra, todos representando sinais de reversão quando um cruzamento ocorre. No programa, eles são consecutivamente chamados de Buffer3 e Buffer4. Otimizamos um novo estilo de exibição para essa função. A exibição do indicador pode ser personalizada selecionando a partir do objeto mql5 Wingdings. Aqui, utilizei o objeto número 236 para meu sinal de reversão de compra e o objeto número 238 para o sinal de reversão de venda.

// under OnInit() function. The wingding objects can be customized by altering those highlighted values choosing from wingding listing.
  SetIndexBuffer(2, Buffer3);
   PlotIndexSetDouble(2, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetInteger(2, PLOT_DRAW_BEGIN, MathMax(Bars(Symbol(), PERIOD_CURRENT)-PLOT_MAXIMUM_BARS_BACK+1, OMIT_OLDEST_BARS+1));
   PlotIndexSetInteger(2, PLOT_ARROW, 236);
   SetIndexBuffer(3, Buffer4);
   PlotIndexSetDouble(3, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetInteger(3, PLOT_DRAW_BEGIN, MathMax(Bars(Symbol(), PERIOD_CURRENT)-PLOT_MAXIMUM_BARS_BACK+1, OMIT_OLDEST_BARS+1));
   PlotIndexSetInteger(3, PLOT_ARROW, 238);

Outro aspecto é a codificação de cores usando MQL5. Essas cores podem ser otimizadas através das configurações de entrada no metatrader 5. Cada cor é representada por um código único dentro de um programa, por exemplo: "C'0,0,0'" representa a cor preta. Veja o trecho de código abaixo.

#property indicator_type3 DRAW_ARROW
#property indicator_width3 1  // with can be adjusted up to 5 times.
#property indicator_color3 0x04CC04 //color for buy reversal
#property indicator_label3 "buy reversal"

#property indicator_type4 DRAW_ARROW
#property indicator_width4 1              //with can be adjusted up to 5 times.
#property indicator_color4 0xE81AC6  // Color code for sell reversal
#property indicator_label4 "sell reversal"

Mais detalhes e comentários no código principal abaixo, combinando todas as partes e ideias.

///Indicator Name: Trend Constraint
#property copyright "Clemence Benjamin"
#property link      "https://mql5.com"
#property version   "1.03"
#property description "A model that seek to produce sell signal when D1 candle is Bearish only and  buy signal when it is Bullish"

//+------------------------------------------------------------------------------------------------------------------------------+
//--- indicator settings
#property indicator_chart_window
#property indicator_buffers 4
#property indicator_plots 4

#property indicator_type1 DRAW_ARROW
#property indicator_width1 5
#property indicator_color1 0xFF3C00
#property indicator_label1 "Buy"

#property indicator_type2 DRAW_ARROW
#property indicator_width2 5
#property indicator_color2 0x0000FF
#property indicator_label2 "Sell"

#property indicator_type3 DRAW_ARROW
#property indicator_width3 1
#property indicator_color3 0x04CC04
#property indicator_label3 "Buy Reversal"

#property indicator_type4 DRAW_ARROW
#property indicator_width4 1
#property indicator_color4 0xE81AC6
#property indicator_label4 "Sell Reversal"

#define PLOT_MAXIMUM_BARS_BACK 5000
#define OMIT_OLDEST_BARS 50

//--- indicator buffers
double Buffer1[];
double Buffer2[];
double Buffer3[];
double Buffer4[];

input double Oversold = 30;
input double Overbought = 70;
datetime time_alert; //used when sending alert
input bool Audible_Alerts = true;
input bool Push_Notifications = true;
double myPoint; //initialized in OnInit
int RSI_handle;
double RSI[];
double Open[];
double Close[];
int MA_handle;
double MA[];
int MA_handle2;
double MA2[];
int MA_handle3;
double MA3[];
int MA_handle4;
double MA4[];
double Low[];
double High[];

void myAlert(string type, string message)
  {
   if(type == "print")
      Print(message);
   else if(type == "error")
     {
      Print(type+" | Trend Constraint V1.03 @ "+Symbol()+","+IntegerToString(Period())+" | "+message);
     }
   else if(type == "order")
     {
     }
   else if(type == "modify")
     {
     }
   else if(type == "indicator")
     {
      if(Audible_Alerts) Alert(type+" | Trend Constraint V1.03 @ "+Symbol()+","+IntegerToString(Period())+" | "+message);
      if(Push_Notifications) SendNotification(type+" | Trend Constraint V1.03 @ "+Symbol()+","+IntegerToString(Period())+" | "+message);
     }
  }

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {   
   SetIndexBuffer(0, Buffer1);
   PlotIndexSetDouble(0, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetInteger(0, PLOT_DRAW_BEGIN, MathMax(Bars(Symbol(), PERIOD_CURRENT)-PLOT_MAXIMUM_BARS_BACK+1, OMIT_OLDEST_BARS+1));
   PlotIndexSetInteger(0, PLOT_ARROW, 241);
   SetIndexBuffer(1, Buffer2);
   PlotIndexSetDouble(1, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetInteger(1, PLOT_DRAW_BEGIN, MathMax(Bars(Symbol(), PERIOD_CURRENT)-PLOT_MAXIMUM_BARS_BACK+1, OMIT_OLDEST_BARS+1));
   PlotIndexSetInteger(1, PLOT_ARROW, 242);
   SetIndexBuffer(2, Buffer3);
   PlotIndexSetDouble(2, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetInteger(2, PLOT_DRAW_BEGIN, MathMax(Bars(Symbol(), PERIOD_CURRENT)-PLOT_MAXIMUM_BARS_BACK+1, OMIT_OLDEST_BARS+1));
   PlotIndexSetInteger(2, PLOT_ARROW, 236);
   SetIndexBuffer(3, Buffer4);
   PlotIndexSetDouble(3, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetInteger(3, PLOT_DRAW_BEGIN, MathMax(Bars(Symbol(), PERIOD_CURRENT)-PLOT_MAXIMUM_BARS_BACK+1, OMIT_OLDEST_BARS+1));
   PlotIndexSetInteger(3, PLOT_ARROW, 238);
   //initialize myPoint
   myPoint = Point();
   if(Digits() == 5 || Digits() == 3)
     {
      myPoint *= 10;
     }
   RSI_handle = iRSI(NULL, PERIOD_CURRENT, 14, PRICE_CLOSE);
   if(RSI_handle < 0)
     {
      Print("The creation of iRSI has failed: RSI_handle=", INVALID_HANDLE);
      Print("Runtime error = ", GetLastError());
      return(INIT_FAILED);
     }
   
   MA_handle = iMA(NULL, PERIOD_CURRENT, 7, 0, MODE_SMMA, PRICE_CLOSE);
   if(MA_handle < 0)
     {
      Print("The creation of iMA has failed: MA_handle=", INVALID_HANDLE);
      Print("Runtime error = ", GetLastError());
      return(INIT_FAILED);
     }
   
   MA_handle2 = iMA(NULL, PERIOD_CURRENT, 400, 0, MODE_SMA, PRICE_CLOSE);
   if(MA_handle2 < 0)
     {
      Print("The creation of iMA has failed: MA_handle2=", INVALID_HANDLE);
      Print("Runtime error = ", GetLastError());
      return(INIT_FAILED);
     }
   
   MA_handle3 = iMA(NULL, PERIOD_CURRENT, 100, 0, MODE_EMA, PRICE_CLOSE);
   if(MA_handle3 < 0)
     {
      Print("The creation of iMA has failed: MA_handle3=", INVALID_HANDLE);
      Print("Runtime error = ", GetLastError());
      return(INIT_FAILED);
     }
   
   MA_handle4 = iMA(NULL, PERIOD_CURRENT, 200, 0, MODE_SMA, PRICE_CLOSE);
   if(MA_handle4 < 0)
     {
      Print("The creation of iMA has failed: MA_handle4=", INVALID_HANDLE);
      Print("Runtime error = ", GetLastError());
      return(INIT_FAILED);
     }
   
   return(INIT_SUCCEEDED);
  }

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime& time[],
                const double& open[],
                const double& high[],
                const double& low[],
                const double& close[],
                const long& tick_volume[],
                const long& volume[],
                const int& spread[])
  {
   int limit = rates_total - prev_calculated;
   //--- counting from 0 to rates_total
   ArraySetAsSeries(Buffer1, true);
   ArraySetAsSeries(Buffer2, true);
   ArraySetAsSeries(Buffer3, true);
   ArraySetAsSeries(Buffer4, true);
   //--- initial zero
   if(prev_calculated < 1)
     {
      ArrayInitialize(Buffer1, EMPTY_VALUE);
      ArrayInitialize(Buffer2, EMPTY_VALUE);
      ArrayInitialize(Buffer3, EMPTY_VALUE);
      ArrayInitialize(Buffer4, EMPTY_VALUE);
     }
   else
      limit++;
   datetime Time[];
   
   datetime TimeShift[];
   if(CopyTime(Symbol(), PERIOD_CURRENT, 0, rates_total, TimeShift) <= 0) return(rates_total);
   ArraySetAsSeries(TimeShift, true);
   int barshift_M1[];
   ArrayResize(barshift_M1, rates_total);
   int barshift_D1[];
   ArrayResize(barshift_D1, rates_total);
   for(int i = 0; i < rates_total; i++)
     {
      barshift_M1[i] = iBarShift(Symbol(), PERIOD_M1, TimeShift[i]);
      barshift_D1[i] = iBarShift(Symbol(), PERIOD_D1, TimeShift[i]);
   }
   if(BarsCalculated(RSI_handle) <= 0) 
      return(0);
   if(CopyBuffer(RSI_handle, 0, 0, rates_total, RSI) <= 0) return(rates_total);
   ArraySetAsSeries(RSI, true);
   if(CopyOpen(Symbol(), PERIOD_M1, 0, rates_total, Open) <= 0) return(rates_total);
   ArraySetAsSeries(Open, true);
   if(CopyClose(Symbol(), PERIOD_D1, 0, rates_total, Close) <= 0) return(rates_total);
   ArraySetAsSeries(Close, true);
   if(BarsCalculated(MA_handle) <= 0) 
      return(0);
   if(CopyBuffer(MA_handle, 0, 0, rates_total, MA) <= 0) return(rates_total);
   ArraySetAsSeries(MA, true);
   if(BarsCalculated(MA_handle2) <= 0) 
      return(0);
   if(CopyBuffer(MA_handle2, 0, 0, rates_total, MA2) <= 0) return(rates_total);
   ArraySetAsSeries(MA2, true);
   if(BarsCalculated(MA_handle3) <= 0) 
      return(0);
   if(CopyBuffer(MA_handle3, 0, 0, rates_total, MA3) <= 0) return(rates_total);
   ArraySetAsSeries(MA3, true);
   if(BarsCalculated(MA_handle4) <= 0) 
      return(0);
   if(CopyBuffer(MA_handle4, 0, 0, rates_total, MA4) <= 0) return(rates_total);
   ArraySetAsSeries(MA4, true);
   if(CopyLow(Symbol(), PERIOD_CURRENT, 0, rates_total, Low) <= 0) return(rates_total);
   ArraySetAsSeries(Low, true);
   if(CopyHigh(Symbol(), PERIOD_CURRENT, 0, rates_total, High) <= 0) return(rates_total);
   ArraySetAsSeries(High, true);
   if(CopyTime(Symbol(), Period(), 0, rates_total, Time) <= 0) return(rates_total);
   ArraySetAsSeries(Time, true);
   //--- main loop
   for(int i = limit-1; i >= 0; i--)
     {
      if (i >= MathMin(PLOT_MAXIMUM_BARS_BACK-1, rates_total-1-OMIT_OLDEST_BARS)) continue; //omit some old rates to prevent "Array out of range" or slow calculation   
      
      if(barshift_M1[i] < 0 || barshift_M1[i] >= rates_total) continue;
      if(barshift_D1[i] < 0 || barshift_D1[i] >= rates_total) continue;
      
      //Indicator Buffer 1
      if(RSI[i] < Oversold
      && RSI[i+1] > Oversold //Relative Strength Index crosses below fixed value
      && Open[barshift_M1[i]] >= Close[1+barshift_D1[i]] //Candlestick Open >= Candlestick Close
      && MA[i] > MA2[i] //Moving Average > Moving Average
      && MA3[i] > MA4[i] //Moving Average > Moving Average
      )
        {
         Buffer1[i] = Low[i]; //Set indicator value at Candlestick Low
         if(i == 1 && Time[1] != time_alert) myAlert("indicator", "Buy"); //Alert on next bar open
         time_alert = Time[1];
        }
      else
        {
         Buffer1[i] = EMPTY_VALUE;
        }
      //Indicator Buffer 2
      if(RSI[i] > Overbought
      && RSI[i+1] < Overbought //Relative Strength Index crosses above fixed value
      && Open[barshift_M1[i]] <= Close[1+barshift_D1[i]] //Candlestick Open <= Candlestick Close
      && MA[i] < MA2[i] //Moving Average < Moving Average
      && MA3[i] < MA4[i] //Moving Average < Moving Average
      )
        {
         Buffer2[i] = High[i]; //Set indicator value at Candlestick High
         if(i == 1 && Time[1] != time_alert) myAlert("indicator", "Sell"); //Alert on next bar open
         time_alert = Time[1];
        }
      else
        {
         Buffer2[i] = EMPTY_VALUE;
        }
      //Indicator Buffer 3
      if(MA3[i] > MA4[i]
      && MA3[i+1] < MA4[i+1] //Moving Average crosses above Moving Average
      )
        {
         Buffer3[i] = Low[i]; //Set indicator value at Candlestick Low
         if(i == 1 && Time[1] != time_alert) myAlert("indicator", "Buy Reversal"); //Alert on next bar open
         time_alert = Time[1];
        }
      else
        {
         Buffer3[i] = EMPTY_VALUE;
        }
      //Indicator Buffer 4
      if(MA3[i] < MA4[i]
      && MA3[i+1] > MA4[i+1] //Moving Average crosses below Moving Average
      )
        {
         Buffer4[i] = High[i]; //Set indicator value at Candlestick High
         if(i == 1 && Time[1] != time_alert) myAlert("indicator", "Sell Reversal"); //Alert on next bar open
         time_alert = Time[1];
        }
      else
        {
         Buffer4[i] = EMPTY_VALUE;
        }
     }
   return(rates_total);
  }
//Thank you for getting this far, you are amazing.
//+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

Explorando os resultados do sistema finalidade

Os resultados do sistema são impressionantes. Agora podemos limitar nosso sistema de sinais ao sentimento do Mercado D1 e também receber sinais quando um impulso de reversão ocorre através do cruzamento da EMA(100) e SMA(200). Aqui estão imagens mostrando a saída do indicador em um histórico de gráficos real. O sistema parece estar funcionando excepcionalmente bem em capturar mudanças de sentimento no mercado e identificar possíveis pontos de reversão. Ao focar no sentimento do Mercado D1 e utilizar os sinais de cruzamento da EMA(100) e SMA(200), conseguimos melhorar nossas estratégias de negociação e tomar decisões mais informadas. A saída do indicador nos dados históricos do gráfico demonstra claramente a eficácia desses sinais na previsão dos movimentos de mercado.

USDJPYM1 com Restrição de Tendência v1.03

Fig 4: Resultados da Restrição de Tendência V1.03 no USDJPYmicroM1

Nota: Se você estiver enfrentando problemas com setas de sinal ausentes no seu gráfico após adicionar o indicador, tente atualizar clicando com o botão direito do mouse (RMB) enquanto estiver no gráfico MT5 e selecione "Atualizar" no menu que aparecer.

Os dados coletados a partir dos desenvolvimentos que estamos realizando podem ser incorporados posteriormente em sistemas de aprendizado de máquina e inteligência artificial para refinamento adicional. Esses sistemas podem ser treinados para realizar análises avançadas, o que seria benéfico para superar os desafios que enfrentamos com o modelo atual. Os sinais na imagem do resultado acima estão alinhados com a ideia, mas também houve alguns sinais enganosos. Isso é típico de qualquer sistema e serve como motivação para explorar métodos adicionais para melhorar nosso sistema atual. Os sintéticos podem fornecer vários resultados ao utilizar este sistema, como oferecido pela Deriv Limited.

Explicação dos resultados em vídeo

Veja o vídeo abaixo para explorar o desempenho de nossa nova versão em desenvolvimento.

Conclusão

A incorporação de funções de detecção de mudanças de tendência em nosso sistema o aprimorou significativamente. Embora limitemos nossos sinais à tendência atual do mercado, conseguimos mitigar perdas potenciais que poderiam surgir de sinais apoiando uma tendência invalidada, mesmo que o sentimento D1 a apoie. Encontramos problemas com os sinais de reversão fornecidos por este sistema durante uma tendência persistente. Para resolver isso, decidi estender o período das médias móveis utilizadas. Nos próximos artigos, revisitarei este tópico para aprofundar como esse ajuste se desenrolou. Espero que você tenha encontrado valor nesta conversa e fico à disposição para receber seus pensamentos na seção de comentários abaixo. Nossos futuros artigos irão incorporar visualizações avançadas de nosso sistema de indicadores usando a versátil linguagem MQL5.

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

Arquivos anexados |

Baixar como ZIP

Trend_Constraint_V1.03.ex5 (17.04 KB)

Trend_Constraint_V1.03.mq5 (10.62 KB)

Trend_Constraint_V1.03.zip (2.4 KB)

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

Outros artigos do autor

Construindo um Modelo de Restrição de Tendência de Candlestick (Parte 2): Mesclando Indicadores Nativos

Ir para discussão

Redes neurais de maneira fácil (Parte 89): Transformador de decomposição por frequência do sinal (FEDformer)

Todos os modelos que analisamos anteriormente examinam o estado do ambiente na forma de uma sequência temporal. No entanto, a mesma série temporal pode ser representada por suas características de frequência. Neste artigo, proponho que você conheça um algoritmo que utiliza as características de frequência da sequência temporal para prever estados futuros.

Do básico ao intermediário: Array e String (III)

Neste artigo iremos ver duas coisas. A primeira é como a biblioteca padrão consegue transformar valores binários em outras formas de representação, como octal, decimal e hexadecimal. A segunda coisa será a de como poderíamos com o conhecimento mostrado até aqui, definir uma largura para nossa senha, baseada em uma frase secreta. O conteúdo exposto aqui, visa e tem como objetivo, pura e simplesmente a didática. De modo algum deve ser encarado como sendo, uma aplicação cuja finalidade não venha a ser o aprendizado e estudo dos conceitos mostrados.

Reimaginando Estratégias Clássicas: Petróleo Bruto

Neste artigo, revisitamos uma estratégia clássica de negociação de petróleo bruto com o objetivo de aprimorá-la, utilizando algoritmos de aprendizado de máquina supervisionado. Vamos construir um modelo de mínimos quadrados para prever os preços futuros do petróleo Brent, com base na diferença entre os preços do Brent e do WTI. Nosso objetivo é identificar um indicador líder de futuras mudanças nos preços do Brent.

Desenvolvendo um sistema de Replay (Parte 68): Acertando o tempo (I)

Aqui vamos dar prosseguimento, ao trabalho de conseguir fazer com que o indicador de mouse, consiga nos informar o tempo restante da barra, quando em momentos de baixa liquidez. Apesar de a primeira vista parecer algo simples, você verá que esta tarefa é bem mais complicada do que parece. Isto por conta de alguns percalços que teremos de enfrentar. Então acompanhe esta primeira parte para entender as próximas.