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

Conteúdo

1. Introdução
2. Revisitando a história
3. Identificando alguns problemas com o sistema atual
4. Versionando nosso próximo programa MQL5
5. Explorando médias móveis
6. Incorporando médias móveis em nosso programa
7. Explorando o RSI
8. Implementando o RSI
9. Comparando resultados
10. Conclusão

Introdução

O MetaTrader 5 inclui vários indicadores embutidos que proporcionam aos traders uma vantagem analítica significativa no mercado. Este artigo discutirá especificamente dois deles: Médias Móveis e o Índice de Força Relativa (RSI). As Médias Móveis são comumente usadas para identificar a direção de uma tendência e possíveis níveis de suporte e resistência. Elas suavizam os dados de preços para criar uma linha contínua, facilitando a identificação de tendências. Por outro lado, o Índice de Força Relativa (RSI) é um oscilador de momento que mede a velocidade e a mudança dos movimentos de preço. Os traders usam o RSI para determinar condições de sobrecompra e sobrevenda no mercado, o que pode ajudá-los a tomar decisões de negociação mais informadas. Ao combinar esses dois indicadores, os traders podem obter valiosos insights sobre tendências de mercado e possíveis pontos de entrada e saída para suas negociações. 

Aqui estão alguns dos indicadores embutidos mais comumente usados no MetaTrader 5:

• Médias Móveis
• Bandas de Bollinger
• Índice de Força Relativa (RSI)
• MACD (Convergência/Divergência de Média Móvel)
• Oscilador Estocástico
• Intervalo Médio Verdadeiro
• Ichimoku Kinko Hyo
• Retração de Fibonacci

Ao utilizar as Médias Móveis e o Índice de Força Relativa em conjunto com outras ferramentas de análise técnica, os traders podem desenvolver uma estratégia de negociação mais abrangente. Monitorando continuamente as condições do mercado e ajustando suas estratégias de acordo, os traders podem se manter à frente e capitalizar oportunidades lucrativas. É essencial permanecer disciplinado e paciente, já que a negociação pode ser imprevisível e volátil. Incorporando as Médias Móveis e o Índice de Força Relativa em sua análise, os traders podem aprimorar seu processo de tomada de decisão e aumentar suas chances de sucesso no mercado. Lembre-se, negociar é uma habilidade que leva tempo e prática para dominar, então é importante manter o compromisso de aprender e melhorar suas habilidades de negociação.

Revisitando a história

Vamos examinar o código abaixo para nos permitir avaliar o desempenho do indicador em dados históricos que abrangem pelo menos alguns milhares de barras. Os gráficos de velas são cruciais para identificar tendências de mercado ao ilustrar a relação entre os preços de abertura, fechamento, alta e baixa para cada período. Analisando os movimentos de preços passados, os traders podem determinar a direção e a força da tendência, alinhando suas estratégias de negociação de acordo. Os padrões históricos de velas podem identificar níveis-chave de suporte e resistência, onde os preços geralmente pausam ou revertem. Ao estudar como os preços se comportaram nesses níveis anteriormente, os traders podem antecipar futuros movimentos de preços e estabelecer pontos de entrada e saída eficazes para suas negociações.

Os traders podem utilizar dados históricos de velas para realizar testes retrospectivos de suas estratégias de negociação e avaliar seu desempenho em diferentes cenários de mercado. Ao testar negociações usando dados históricos, os traders podem avaliar a eficácia de suas estratégias e fazer os ajustes necessários para melhorar seus resultados de negociação. Em essência, mergulhar na história dos gráficos de velas é um componente vital da análise técnica, oferecendo aos traders insights valiosos sobre tendências de mercado, padrões e comportamentos que podem guiá-los na tomada de decisões de negociação informadas e lucrativas. 

Além de analisar padrões históricos de velas, os traders também podem usar indicadores técnicos para melhorar ainda mais sua compreensão da dinâmica do mercado. Esses indicadores podem ajudar a identificar possíveis pontos de entrada e saída, bem como fornecer sinais de reversão ou continuação de tendência. Ao combinar os insights dos gráficos de velas com os sinais gerados por indicadores, os traders podem desenvolver uma estratégia de negociação mais abrangente que leve em consideração tanto a ação do preço quanto a análise técnica. Essa abordagem holística pode melhorar a tomada de decisões e aumentar a probabilidade de negociações bem-sucedidas nos mercados financeiros dinâmicos e em constante mudança.

Vamos examinar este trecho que define até que ponto nosso indicador visualizará na história do gráfico de velas como parte de nosso código principal.

#define PLOT_MAXIMUM_BARS_BACK 10000 //the integer value can be made higher expanding the gap you can visualize in history
#define OMIT_OLDEST_BARS 50

Identificando alguns problemas com o sistema atual

Nesta etapa, estamos examinando os sinais fornecidos no gráfico pelo Indicador de Restrição de Tendência. Embora a restrição tenha filtrado com sucesso os sinais negativos, ainda enfrentamos problemas com sinais fora da tendência em uma escala visual muito pequena. É importante eliminar esses sinais e focar nos sinais genuínos de tendência. Isso destaca a necessidade de utilizar ferramentas integradas como a média móvel e o RSI através do MQL5. Nas seções seguintes, exploraremos essas ferramentas com mais detalhes.

Fig 1: Restrição de tendência v1.00, índice Boom 500

Nas próximas seções, exploraremos como a média móvel e o RSI podem ajudar a aprimorar nossa análise de tendências e fornecer sinais mais precisos para a tomada de decisões. Ao incorporar essas ferramentas em nossa análise, pretendemos melhorar a eficácia geral de nossa estratégia de negociação e alcançar melhores resultados no mercado. Vamos nos aprofundar nas funcionalidades e benefícios dessas ferramentas para otimizar nossa abordagem de negociação.

Versionando nosso próximo programa MQL5

Quando nossa jornada no MQL5 começa, cada etapa concluída marca uma versão. À medida que continuamos adicionando recursos ao nosso programa, precisamos versioná-lo para um novo nível, atualizando-o. Vamos ver como fazemos isso no início de nosso código. Abaixo está nossa primeira versão do Trend Constraint em código.

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

Para atualizar nossa versão, basta alterar os dígitos na propriedade de versão em nosso código. Por exemplo, neste artigo, a próxima versão do Trend Constraint será 1.01. Abaixo está o trecho de código atualizado mostrando como ele aparecerá no código principal mais adiante no artigo.

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

Muito bem! É assim que atualizamos nosso programa MQL5. Em seguida, avançaremos para as versões 1.02, 1.03, 1.04, e assim por diante.

Explorando médias móveis

As médias móveis são cruciais para ilustrar as tendências do mercado, compreendendo médias móveis rápidas e lentas. O cruzamento dessas duas pode indicar a continuação de uma tendência ou uma reversão. Neste artigo, utilizei uma média móvel suavizada com um período de 7 em comparação com uma média móvel simples significativamente mais lenta com um período de 400 para eliminar certos sinais fora da tendência. Essa abordagem permitiu uma representação mais precisa da tendência subjacente do mercado, filtrando flutuações e ruídos de curto prazo. Usando uma combinação de médias móveis rápidas e lentas, consegui identificar mudanças significativas na tendência, minimizando sinais falsos. Esse método provou ser eficaz na captura dos movimentos mais amplos do mercado e forneceu insights valiosos para tomar decisões de negociação informadas.

A média móvel é uma ferramenta amplamente utilizada na análise técnica que suaviza os dados de preço ao criar uma média de preço constantemente atualizada. Ela ajuda os traders a identificar tendências e possíveis pontos de reversão. O conceito de média móvel foi desenvolvido para reduzir o impacto das flutuações de curto prazo e destacar tendências de longo prazo no movimento dos preços.

 O uso de médias móveis na análise financeira remonta aos primeiros analistas técnicos, como Richard Donchian e George Marechal, em meados do século XX.

A fórmula para calcular uma média móvel simples (SMA) é simples:

SMA = (P1 + P2 ... + Pn)/n

onde:

• SMA = Média Móvel Simples
• P1,P2,...,Pn = Preço para os períodos especificados (por exemplo, preços de fechamento)
• n = Número de períodos (por exemplo, dias) sobre os quais calcular as médias.

Fig 2: Médias Móveis, EURUSD

Incorporando Médias Móveis no programa

A média móvel mais lenta pode ser significativa na identificação de mudanças de tendência. Isso é evidente em como o preço interage com as médias móveis lentas. Normalmente, o preço testa a média móvel lenta várias vezes antes de continuar ou mudar a tendência. A média móvel lenta segue de perto o movimento atual dos preços. Dessa forma, a média móvel lenta atua como um nível robusto de suporte ou resistência, refletindo a força da tendência subjacente. Os traders frequentemente utilizam esse indicador para confirmar reversões ou continuidades de tendência, já que sua natureza atrasada oferece um indicador confiável do sentimento do mercado. Ao observar a relação entre o preço e a média móvel lenta, os investidores podem obter insights valiosos sobre a dinâmica do mercado e tomar decisões de negociação informadas.

Além disso, a capacidade da média móvel lenta de suavizar as flutuações de preços pode oferecer aos traders uma visão mais clara da direção geral do mercado. Ao focar na convergência ou divergência entre o preço e a média móvel lenta, os investidores podem antecipar possíveis mudanças de momentum. A confiabilidade deste indicador em capturar tendências de longo prazo o torna uma ferramenta valiosa para traders que buscam surfar movimentos de preço substanciais, filtrando o ruído de curto prazo. Compreender as nuances da média móvel lenta pode aprimorar a capacidade do trader de navegar pelas complexidades dos mercados financeiros com maior precisão e confiança.

No artigo anterior, desenvolvemos um Indicador de Restrição de Tendência D1 com 2 buffers para compra e venda. Embora tenha parecido satisfatório inicialmente, nosso objetivo agora é melhorar ainda mais sua eficácia. Semelhante ao nosso trabalho anterior, o código consiste em 2 buffers. Nosso objetivo é restringir a saída às médias móveis lentas para filtrar sinais falsos. As médias móveis lentas desempenham um papel significativo na determinação das tendências. A restrição dita a compra apenas quando o preço está acima da SMA 400 e a venda exclusivamente quando está abaixo.

1. Média Móvel Simples Suavizada (SSMA) de 7 para representar o preço
2. Média Móvel Simples de 400 para representar a imposição da tendência
3. Código MQL5 para a condição.

///Indicator Name: Trend Constraint
#property copyright "Clemence Benjamin"
#property link      "https://mql5.com"
#property version   "1.00"
#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 2
#property indicator_plots 2

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

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

#define PLOT_MAXIMUM_BARS_BACK 5000
#define OMIT_OLDEST_BARS 50

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

double myPoint; //initialized in OnInit
int MA_handle;
double MA[];
int MA_handle2;
double MA2[];
double Open[];
double Close[];
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 @ "+Symbol()+","+IntegerToString(Period())+" | "+message);
     }
   else if(type == "order")
     {
     }
   else if(type == "modify")
     {
     }
  }

//+------------------------------------------------------------------+
//| 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);
   //initialize myPoint
   myPoint = Point();
   if(Digits() == 5 || Digits() == 3)
     {
      myPoint *= 10;
     }
   MA_handle = iMA(NULL, PERIOD_CURRENT, 7, 0, MODE_EMA, 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, 21, 0, MODE_EMA, 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, 7, 0, MODE_SMMA, 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, 400, 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);
   //--- initial zero
   if(prev_calculated < 1)
     {
      ArrayInitialize(Buffer1, EMPTY_VALUE);
      ArrayInitialize(Buffer2, EMPTY_VALUE);
     }
   else
      limit++;
   
   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(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(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_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);
   //--- 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(MA[i] > MA2[i]
      && MA[i+1] < MA2[i+1] //Moving Average crosses above Moving Average
      && Open[barshift_M1[i]] >= Close[1+barshift_D1[i]] //Candlestick Open >= Candlestick Close
      && MA3[i] > MA4[i] //Moving Average > Moving Average
      )
        {
         Buffer1[i] = Low[i]; //Set indicator value at Candlestick Low
        }
      else
        {
         Buffer1[i] = EMPTY_VALUE;
        }
      //Indicator Buffer 2
      if(MA[i] < MA2[i]
      && MA[i+1] > MA2[i+1] //Moving Average crosses below Moving Average
      && Open[barshift_M1[i]] <= Close[1+barshift_D1[i]] //Candlestick Open <= Candlestick Close
      && MA3[i] < MA4[i] //Moving Average < Moving Average
      )
        {
         Buffer2[i] = High[i]; //Set indicator value at Candlestick High
        }
      else
        {
         Buffer2[i] = EMPTY_VALUE;
        }
     }
   return(rates_total);
  }
//Thank you for following along this is ready to  compile

Explorando o Oscilador RSI

O RSI ajuda a identificar as zonas extremas do mercado, incluindo áreas de sobrecompra e sobrevenda. Isso pode ser útil para traders que desejam determinar pontos potenciais de reversão ou oportunidades de continuação de tendência. Usando o RSI em conjunto com outros indicadores técnicos e métodos de análise, os traders podem tomar decisões mais informadas ao entrar ou sair de operações. Além disso, o RSI também pode ser utilizado para confirmar a força de uma tendência ou para detectar divergências entre o preço e o momentum, o que pode indicar uma possível mudança de direção. Os traders devem ter cautela ao confiar exclusivamente no RSI e sempre considerar outros fatores, como condições de mercado, eventos noticiosos e o sentimento geral do mercado antes de tomar decisões de negociação. É importante lembrar que nenhum indicador é infalível, e uma combinação de ferramentas e análises geralmente é necessária para estratégias de negociação bem-sucedidas.

A fórmula para o RSI abaixo é atribuída a J. Welles Wilder Jr., que introduziu o conceito em 1978.

RSI = 100 - (100/(1+RS))

onde:

• RS = Ganho Médio / Perda Média
• Ganho Médio = Soma dos ganhos durante o período especificado / Número de períodos
• Perda Média = Soma das perdas durante o período especificado / Número de períodos

Fig 3: Níveis de RSI, Índice Boom 500

Implementando o RSI

Identificar níveis de RSI no código e alinhá-los com as principais tendências pode ser muito útil. Nesta seção, incorporamos as condições de RSI no nosso programa de indicador MQL5. A incorporação das condições de RSI em nosso programa de indicador MQL5 nos permite analisar melhor as tendências do mercado e tomar decisões de negociação mais informadas. Ao alinhar os níveis de RSI com as principais tendências, podemos identificar potenciais pontos de entrada e saída com maior precisão, aumentando a eficácia de nossa estratégia de negociação. Anteriormente, dependíamos de cruzamentos de médias móveis como nossa condição de entrada. Agora, estamos removendo o cruzamento de médias móveis e, em vez disso, utilizando níveis de RSI para entrada, junto com outras condições recentemente incorporadas para criar uma nova versão, Trend Constrain V1.02.

 Nesta fase, precisamos incorporar entradas para o valor do RSI para otimizar as zonas de Sobrecompra e Sobrevenda. Confira o código abaixo.

input double Oversold = 30;
input double Overbought = 70;
//I have set the default standard values, but you can alter them to suit your strategy and instrument being traded.

Agora vamos implementar essas condições de RSI em nosso código para aprimorar a funcionalidade do nosso indicador. Vamos começar definindo os níveis de RSI que queremos usar em nosso indicador. Podemos definir o nível de sobrecompra em 70 e o nível de sobrevenda em 30. Isso nos ajudará a identificar potenciais pontos de reversão no mercado. Em seguida, adicionaremos a lógica necessária ao nosso código para verificar essas condições de RSI e gerar sinais de acordo. Isso nos dará uma visão mais abrangente da dinâmica do mercado e nos ajudará a tomar decisões de negociação mais informadas. Vamos prosseguir com a implementação dessas alterações no nosso programa de indicador MQL5.

///Indicator Name: Trend Constraint
#property copyright "Clemence Benjamin"
#property link      "https://mql5.com"
#property version   "1.02"
#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 2
#property indicator_plots 2

#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"

#define PLOT_MAXIMUM_BARS_BACK 5000
#define OMIT_OLDEST_BARS 50

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

input double Oversold = 30;
input double Overbought = 70;
double myPoint; //initialized in OnInit
int RSI_handle;
double RSI[];
double Open[];
double Close[];
int MA_handle;
double MA[];
int MA_handle2;
double MA2[];
double Low[];
double High[];

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

//+------------------------------------------------------------------+
//| 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);
   //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);
     }
   
   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);
   //--- initial zero
   if(prev_calculated < 1)
     {
      ArrayInitialize(Buffer1, EMPTY_VALUE);
      ArrayInitialize(Buffer2, EMPTY_VALUE);
     }
   else
      limit++;
   
   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(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);
   //--- 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
      )
        {
         Buffer1[i] = Low[i]; //Set indicator value at Candlestick Low
        }
      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
      )
        {
         Buffer2[i] = High[i]; //Set indicator value at Candlestick High
        }
      else
        {
         Buffer2[i] = EMPTY_VALUE;
        }
     }
   return(rates_total);
  }
// Thank you for following along we are here

Comparando resultados

Após revisar o artigo anterior, fizemos progressos significativos na criação de um gráfico claro com o número de sinais apresentados. O RSI e as Médias Móveis tiveram um efeito positivo em nossos resultados, servindo como indicadores visuais para monitorar as mudanças de tendência. Nosso indicador de restrição de tendência baseado em candles de um intervalo de tempo maior também mostrou melhorias. Além disso, a incorporação do indicador SMA 400 forneceu mais insights sobre potenciais reversões de mercado, aprimorando a precisão geral de nossa análise. Ao combinar esses diversos sinais, estamos melhor equipados para tomar decisões de negociação informadas e nos adaptar às condições de mercado em evolução. Estou entusiasmado com o progresso que fizemos e continuo comprometido em refinar essa estratégia para obter resultados ainda melhores no futuro.

Fig 4: Trend Constraint v1.02, Índice Boom 500

A imagem acima pode ser referenciada no início do artigo, quando estávamos identificando alguns problemas com o sistema atual.

Fig 5: Trend Constraint v1.02, Índice Boom 500

Conclusão

O Indicador de Restrição de Tendência baseado em Candlestick não pode substituir as Médias Móveis, mas pode complementá-las para alcançar excelentes resultados. Os indicadores embutidos no MT5 servem de base para a criação de outros indicadores personalizados. Quando usados em conjunto, essas ferramentas podem ser muito eficazes. Avançamos para uma nova etapa neste desenvolvimento e começamos a enfrentar questões relacionadas a pesos e desafios de atualização que precisam de atenção. Nosso próximo artigo se concentrará em enfrentar esses desafios enquanto continuamos a refinar este sistema.

Consulte Algobook