Técnicas do MQL5 Wizard que você deve conhecer (Parte 38): Bandas de Bollinger
98
5
Introdução
As Bandas de Bollinger são um indicador técnico popular desenvolvido por John Bollinger em 1987, composto por 3 linhas (ou buffers de dados). Sua função principal é encontrar uma maneira de quantificar a volatilidade do mercado, identificando pontos de preço de sobrecompra e sobrevenda dos ativos negociados. As Bandas de Bollinger se expandem e se contraem de acordo com a volatilidade do mercado. Quando a volatilidade aumenta, as duas bandas externas se afastam mais; quando há contração na volatilidade, essas bandas se aproximam.
Os traders utilizam essas expansões e contrações para antecipar períodos de rompimento de preços ou consolidação, respectivamente. As bandas superior e inferior também atuam como níveis dinâmicos de Suporte e Resistência, pois os preços tendem a recuar nesses níveis, oferecendo pistas potenciais de reversões ou continuações. As Bandas de Bollinger frequentemente favorecem estratégias de reversão à média, nas quais se espera que os preços retornem à média (a banda do meio) após tocarem a banda superior ou inferior. Condições de sobrecompra e sobrevenda também são identificadas quando o preço ultrapassa as bandas externas, sinalizando pontos potenciais de reversão.
Além disso, quando os preços permanecem consistentemente próximos da banda superior, isso indica que uma tendência de alta pode estar se formando, enquanto uma predominância próxima à banda inferior frequentemente implica em tendências de baixa. Rompimentos dessas bandas podem, portanto, indicar o início de uma nova tendência ou um ponto de virada. Por fim, o “squeeze” das Bandas de Bollinger ocorre quando as bandas superior e inferior estão muito próximas uma da outra por um determinado período, o que indica baixa volatilidade e potencial iminente para oportunidades de rompimento. Os traders monitoram isso de perto, muitas vezes usando a direção do rompimento como sinal para entrada. A fórmula para os 3 buffers de dados é simples e pode ser representada pelas seguintes equações:
Onde:
- MB é o buffer da banda do meio
- SMA é uma função de média móvel simples
- P representa o histórico de preços de fechamento
- n é o período sobre o qual a média móvel simples é calculada
Onde:
- UB é o buffer da banda superior
- k é um fator ajustável que normalmente é definido como 2 por padrão
- Sigma é o desvio padrão calculado sobre o período da média
Onde:
- LB é o buffer da banda inferior
O objetivo deste artigo não é apenas listar os diferentes sinais que as Bandas de Bollinger podem gerar, mas também, como sempre, mostrar como eles podem ser integrados em um único arquivo de classe de sinal personalizada. Normalmente, esses artigos são estruturados de forma que a parte teórica venha primeiro, seguida pelos testes de estratégia e seus resultados ao final. No entanto, neste artigo — como fizemos em alguns anteriores — vamos compartilhar os resultados dos testes para cada configuração de sinal apresentada, junto com o código dessa configuração. Isso significa que vamos apresentar múltiplos resultados de testes ao longo do artigo, em vez de deixá-los apenas no final. Vamos analisar até 8 possíveis sinais com Bandas de Bollinger que podem ser explorados por traders.
Classes de sinal personalizadas são fundamentais não apenas para desenvolver sinais versáteis e robustos, devido à forma como permitem combinar diferentes estratégias, mas também porque a abordagem minimalista na codificação permite, em princípio, testar e validar ideias de forma rápida. O código anexado ao final deste artigo é destinado ao uso com o MQL5 Wizard para montar um Expert Advisor. Leitores novos podem encontrar orientações aqui e aqui sobre como fazer isso Uma vez validadas, os traders podem optar por implantar o Expert Advisor montado ou recodificá-lo com personalizações na execução de ordens, mantendo a estratégia base.
Antes de analisarmos os sinais, pode ser útil demonstrar como preparamos a classe de sinal personalizada para lidar ou processar essas 8 alternativas de sinal. Abaixo está a interface da classe de sinal personalizada:
//+------------------------------------------------------------------+ //| Class CSignalBollingerBands. | //| Purpose: Class of generator of trade signals based on | //| the 'BollingerBands' indicator. | //| Is derived from the CExpertSignal class. | //+------------------------------------------------------------------+ class CSignalBollingerBands : public CExpertSignal { protected: CiBands m_bands; // object-indicator .... //--- "weights" of market models (0-100) int m_pattern_0; // model 0 "Price Crossing the Upper Band or the Lower Band" int m_pattern_1; // model 1 "Price Bouncing Off Lower Band or Upper Band " int m_pattern_2; // model 2 "Price Squeeze Followed by a Breakout Above Upper Band or Below Lower Band " int m_pattern_3; // model 3 "Price Double Bottoms Near Lower Band or Double Top Near Upper Band " int m_pattern_4; // model 4 "Price Bounces Off the Middle Band from Above & Bounce Off from Below " int m_pattern_5; // model 5 "Volume Divergence at Lower Band or Upper Band " int m_pattern_6; // model 6 "Bands Widening After Downtrend or After Uptrend " int m_pattern_7; // model 7 "Bands Orientation and Angle Changes " uchar m_patterns_used; // bit-map integer for used pattens public: CSignalBollingerBands(void); ~CSignalBollingerBands(void); .... protected: ... //--- methods to check for patterns bool IsPattern_0(ENUM_POSITION_TYPE T); bool IsPattern_1(ENUM_POSITION_TYPE T); bool IsPattern_2(ENUM_POSITION_TYPE T); bool IsPattern_3(ENUM_POSITION_TYPE T); bool IsPattern_4(ENUM_POSITION_TYPE T); bool IsPattern_5(ENUM_POSITION_TYPE T); bool IsPattern_6(ENUM_POSITION_TYPE T); bool IsPattern_7(ENUM_POSITION_TYPE T); };
Ele segue a abordagem padrão da maioria dos sinais personalizados, com o principal acréscimo para este artigo sendo as variáveis ‘m_pattern_XX’ listadas, que estão destacadas no código. Essas variáveis, que representam um peso (um valor na faixa de 0 a 100), são comuns em classes de sinal personalizadas montadas via o wizard. Exemplos rápidos disso são a classe de sinal de envelopes e a classe de sinal RSI. Ambas utilizam essas variáveis de padrão com um peso constante pré-definido, frequentemente abaixo de 100. Atribuir-lhes um peso constante não é problemático por si só, pois, em princípio, cada classe é projetada para ser usada com outras classes de sinal, de forma que o que é otimizado ou ajustado é o peso relativo de cada classe no sinal total do Expert Advisor.
Portanto, a noção de otimizá-las é um pouco estranha, dado o grande risco de overfitting para o símbolo ou ativo testado, e o uso desses padrões geralmente assume que o trader está bem familiarizado com a importância relativa e o peso de cada padrão. Ele não precisa que um otimizador lhe diga isso. Além disso, caso múltiplas classes de sinal sejam usadas e todas tenham seus próprios padrões, os requisitos de otimização explodiriam. Por isso, é sempre melhor que sejam constantes baseadas em conhecimento, e não pesos a serem treinados.
Entretanto, neste artigo, vamos explorar a opção de otimizar esses padrões. Faremos isso principalmente porque esta classe está sendo montada exclusivamente dentro do wizard. Ela não será ponderada contra outro sinal. Nosso parâmetro de peso para esse sinal, portanto, permanecerá em 1.0, como tem sido para a maioria das classes de sinal testadas nesta série. Além disso, geralmente, quando os valores dos padrões são constantes, apenas um desses padrões é utilizado, enquanto os outros permanecem inativos. Isso normalmente implica que, como a classe de sinal é montada junto com outras, o seu peso é otimizado, e o padrão selecionado é otimizado para funcionar com os outros sinais, enquanto os demais padrões não selecionados permanecem ociosos.
Neste artigo, queremos usar todos os padrões, sempre que estiverem presentes. Os padrões são naturalmente pareados, ou seja, para condições de compra e venda, e é improvável que dois padrões de tipo diferente sejam sinalizados ao mesmo tempo. (Com isso queremos dizer que os padrões 1 e 2, por exemplo, poderiam ser sinalizados em momentos distintos, mas não que uma condição de compra e venda do mesmo padrão apareça simultaneamente.)Assim, o uso concorrente implica que um padrão pode indicar uma posição comprada, enquanto outro padrão, em outro momento, indica uma posição vendida ou o encerramento da posição anteriormente aberta. Essas classes de sinal personalizadas têm limiares de abertura e de fechamento, portanto, quando um padrão estiver presente, dependendo do seu valor otimizado, ele pode simplesmente fechar uma posição já aberta ou fechá-la e abrir uma operação contrária. Nosso Expert Advisor, portanto, vai otimizar os pesos desses padrões em uma janela curta, para um único símbolo, e ver se isso nos traz algum resultado interessante.
Nossa classe de sinal personalizada herda da classe ‘CExpertSignal’, que possui a função ‘PatternsUsage’, a qual recebe como entrada um número inteiro com máscara de bits para os padrões usados na classe de sinal. Como podemos usar até 8 padrões de sinal, nosso mapa de bits terá tamanho variando de 0 até 2 elevado à oitava potência menos um, ou seja, 255. Isso implica que, além de determinar os limiares individuais dos padrões (que definem abertura e fechamento das posições), vamos selecionar quais padrões dentre os 8 são mais adequados como uma estratégia baseada nas Bandas de Bollinger. Essa seleção da combinação de padrões a ser usada simultaneamente é mostrada no relatório final do testador ao final deste artigo (devido à extensão do artigo, será apresentada na próxima parte). Para cada um dos padrões disponíveis, os resultados dos testes abaixo são quando o Expert Advisor utiliza apenas um padrão.
A partir dos testes, entretanto, atribuir o número de padrões usados não permite, de fato, utilizar corretamente a função de definição ‘IS_PATTERN_USAGE()’, como se esperaria. Parece que a atribuição padrão de -1 como número de padrões usados — o que implica que todos os padrões podem ser usados — é sempre implementada, independentemente da entrada que fornecemos. Como solução alternativa, usamos nossa própria implementação com operações de bits, permitindo converter o número inteiro do mapa de padrões em uma sequência de 0s e 1s, da qual podemos identificar quais padrões foram selecionados. A tabela abaixo pode servir como guia dos 8 mapas de padrões individuais e como os interpretamos no código:
| mapa de entrada (m_patterns_used) | bits implícitos | verificador de bytes |
| 1 | 00000001 | 0x01 |
| 2 | 00000010 | 0x02 |
| 4 | 00000100 | 0x04 |
| 8 | 00001000 | 0x08 |
| 16 | 00010000 | 0x10 |
| 32 | 00100000 | 0x20 |
| 64 | 01000000 | 0x40 |
| 128 | 10000000 | 0x80 |
Como pode ser visto, cada um dos 8 mapas listados implica o uso de um único padrão. Isso é melhor ilustrado nos bits implícitos, onde, em uma sequência de 8 caracteres, todos são zeros exceto um deles. A entrada pode, na verdade, ser atribuída a qualquer valor de 0 até 255, razão pela qual é do tipo de dado uchar (caractere sem sinal).
Preço Cruzando a Banda Superior ou Inferior
Nosso primeiro sinal é quando o preço cruza a banda superior ou inferior. Quando o preço cruza a banda superior de cima para baixo, interpretamos isso como um sinal de baixa. Por outro lado, quando o preço cruza a banda inferior de baixo para cima e fecha acima dela, interpretamos isso como um sinal de alta. Implementamos essa lógica em uma função que verifica o padrão 0, da seguinte forma:
//+------------------------------------------------------------------+ //| Check for Pattern 0. | //+------------------------------------------------------------------+ bool CSignalBollingerBands::IsPattern_0(ENUM_POSITION_TYPE T) { m_bands.Refresh(-1); m_close.Refresh(-1); if(T == POSITION_TYPE_BUY && Close(StartIndex() + 1) < Lower(StartIndex() + 1) && Close(StartIndex()) > Lower(StartIndex())) { return(true); } else if(T == POSITION_TYPE_SELL && Close(StartIndex() + 1) > Upper(StartIndex() + 1) && Close(StartIndex()) < Upper(StartIndex())) { return(true); } return(false); }
Nosso código é bastante direto, em parte graças à biblioteca padrão do MQL5, onde a codificação para o indicador Bollinger Bands é simplificada de modo que, uma vez que uma instância da classe do indicador é declarada assim:
//+------------------------------------------------------------------+ //| Class CSignalBollingerBands. | //| Purpose: Class of generator of trade signals based on | //| the 'BollingerBands' indicator. | //| Is derived from the CExpertSignal class. | //+------------------------------------------------------------------+ class CSignalBollingerBands : public CExpertSignal { protected: CiBands m_bands; // object-indicator ... ... };
E é inicializada da seguinte forma:
//+------------------------------------------------------------------+ //| Create indicators. | //+------------------------------------------------------------------+ bool CSignalBollingerBands::InitIndicators(CIndicators *indicators) { //--- check pointer if(indicators == NULL) return(false); //--- initialization of indicators and timeseries of additional filters if(!CExpertSignal::InitIndicators(indicators)) return(false); //--- create and initialize MA indicator if(!InitMA(indicators)) return(false); //--- ok return(true); }
Tudo o que precisamos fazer é atualizá-la como indicado na função acima. Não nos preocupamos com os números dos buffers, já que funções para lidar com a banda superior, banda inferior e banda do meio já estão embutidas na classe. Além disso, os preços de abertura, máxima, mínima e fechamento do símbolo principal são inicializados dentro das classes referenciadas, desde que declarados no construtor da classe, conforme o exemplo:
//+------------------------------------------------------------------+ //| Constructor | //+------------------------------------------------------------------+ CSignalBollingerBands::CSignalBollingerBands(void) ... { //--- initialization of protected data m_used_series = USE_SERIES_OPEN + USE_SERIES_HIGH + USE_SERIES_LOW + USE_SERIES_CLOSE; ... }
Isso novamente só nos exige atualizar o respectivo identificador de preços, a cada barra, antes de obter o preço atual. No nosso caso, usamos o preço de fechamento, então é isso que precisamos atualizar. Executamos testes com o Expert Advisor montado no wizard, onde atribuimos o mapa de bits dos padrões utilizados para 1, pois estamos usando apenas o primeiro padrão. Resultados de testes parcialmente otimizados utilizando apenas o padrão 0 nos fornecem o seguinte relatório:
Os resultados acima são de testes com USDCHF no timeframe diário para o ano de 2023. Como estamos utilizando apenas o padrão 0, o número inteiro do mapa de padrões é 1. Verificamos esse padrão da seguinte forma nas condições de compra e venda compartilhadas no código ao final deste artigo, juntamente com os resultados dos testes de todos os padrões.
Recuo do Preço na Banda Inferior ou Superior
Nosso próximo sinal é o recuo dos preços em qualquer uma das bandas externas. Se o preço toca a banda superior e depois recua, isso é interpretado como sinal de baixa. Por outro lado, se o preço desce até a banda inferior das Bollinger e depois se recupera, isso é interpretado como sinal de alta. Essa interpretação vem do fato de que as bandas superior e inferior são zonas-chave de reversão. Isso, por sua vez, pode ser explicado pela psicologia do mercado, onde os traders sentem que, quando um preço avança demais em uma direção, uma correção é iminente. Lembre-se, as Bandas de Bollinger não apenas acompanham tendências, graças ao buffer da linha média, mas também monitoram a volatilidade. Assim, quando o preço se aproxima de qualquer uma das bandas externas ou quando elas se alargam, isso indica aumento de volatilidade.
Ferramentas de confirmação, como indicadores alternativos, seriam ideais para serem usadas em conjunto com as Bandas de Bollinger. Para implementar a verificação desse recuo nas bandas externas no MQL5, usamos a seguinte fonte:
//+------------------------------------------------------------------+ //| Check for Pattern 1. | //+------------------------------------------------------------------+ bool CSignalBollingerBands::IsPattern_1(ENUM_POSITION_TYPE T) { m_bands.Refresh(-1); m_close.Refresh(-1); if(T == POSITION_TYPE_BUY && Close(StartIndex() + 2) > Lower(StartIndex() + 2) && Close(StartIndex() + 1) <= Lower(StartIndex() + 1) && Close(StartIndex()) > Lower(StartIndex())) { return(true); } else if(T == POSITION_TYPE_SELL && Close(StartIndex() + 2) < Upper(StartIndex() + 2) && Close(StartIndex() + 1) >= Upper(StartIndex() + 1) && Close(StartIndex()) < Upper(StartIndex())) { return(true); } return(false); }
Estamos utilizando até 8 padrões e, como pode ser visto na tabela compartilhada acima, o mapa de entrada (input dos padrões usados) para o segundo padrão é 2. Isso garante que, ao verificarmos as condições de compra e venda, usamos apenas esse padrão — o recuo nas bandas superior e inferior. Executamos testes com o par USDCHF no timeframe diário para o ano de 2023 e obtivemos os seguintes resultados:
Aperto do Preço seguido por Rompimento Acima da Banda Superior ou Abaixo da Inferior
Nosso padrão tipo 2 é o aperto de preço seguido por um rompimento. A definição de aperto de preço normalmente é um período prolongado de baixa volatilidade, o que, nas Bandas de Bollinger, é marcado por um estreitamento entre as bandas superior e inferior. Por quanto tempo essa estreiteza deve ocorrer é algo subjetivo. Para os nossos propósitos, estamos sendo um pouco simplistas, pois interpretamos um squeeze como qualquer encolhimento simultâneo das bandas em direção à base das Bandas de Bollinger. Isso significa que, mesmo que o squeeze dure apenas uma barra, vamos utilizá-lo. Abaixo está a implementação disso em MQL5:
//+------------------------------------------------------------------+ //| Check for Pattern 2. | //+------------------------------------------------------------------+ bool CSignalBollingerBands::IsPattern_2(ENUM_POSITION_TYPE T) { m_bands.Refresh(-1); m_close.Refresh(-1); if(Upper(StartIndex()) > Upper(StartIndex() + 1) && Upper(StartIndex() + 1) < Upper(StartIndex() + 2) && Lower(StartIndex()) < Lower(StartIndex() + 1) && Lower(StartIndex() + 1) > Lower(StartIndex() + 2)) { if(T == POSITION_TYPE_BUY && Close(StartIndex()) >= Upper(StartIndex())) { return(true); } else if(T == POSITION_TYPE_SELL && Close(StartIndex()) <= Lower(StartIndex())) { return(true); } } return(false); }
Na verdade, em nosso código, a duração do squeeze é estritamente de uma barra. Nosso código nem sequer leva em consideração a largura do intervalo entre a banda superior e a banda inferior — e ainda assim, esse é outro fator importante que poderia ser considerado ao definir esse padrão. A partir do nosso código-fonte acima, qualquer queda na banda superior que ocorra simultaneamente com um pico na banda inferior caracteriza um squeeze. Se, após esse squeeze, o preço estiver na banda superior ou mais próximo dela, isso indica um sinal de alta. Se, por outro lado, o preço estiver na banda inferior após o squeeze, então interpretamos isso como um sinal de baixa. Os testes executados utilizando apenas esse padrão nos fornecem os seguintes resultados:
Nossos resultados acima, provenientes de uma breve execução de otimização ao longo do ano de 2023 no timeframe diário para o símbolo USDCHF, não foram validados cruzadamente e servem apenas para indicar o potencial do padrão 2.
Fundo Duplo Próximo à Banda Inferior ou Topo Duplo Próximo à Banda Superior
Esse padrão também está em nossa lista e, francamente, é um pouco semelhante ao padrão 1 (o 2º padrão acima). A principal diferença aqui é que temos mais de um recuo nas bandas externas, em contraste com o recuo único do padrão 1. Portanto, esse padrão, que é rotulado como padrão 3, pode ser considerado como o padrão 1 com uma confirmação. Por esse motivo, nem muitos setups de trade são iniciados ao confiar apenas nesse padrão. Sua implementação em MQL5 é a seguinte:
//+------------------------------------------------------------------+ //| Check for Pattern 3. | //+------------------------------------------------------------------+ bool CSignalBollingerBands::IsPattern_3(ENUM_POSITION_TYPE T) { m_bands.Refresh(-1); m_close.Refresh(-1); m_high.Refresh(-1); m_low.Refresh(-1); if ( T == POSITION_TYPE_BUY && Close(StartIndex() + 4) < Close(StartIndex() + 3) && Close(StartIndex() + 3) > Close(StartIndex() + 2) && Close(StartIndex() + 2) < Close(StartIndex() + 1) && Close(StartIndex() + 1) > Close(StartIndex()) && Close(m_close.MinIndex(StartIndex(), 5)) - Upper(StartIndex()) >= -1.0 * Range(StartIndex()) ) { return(true); } else if ( T == POSITION_TYPE_SELL && Close(StartIndex() + 4) > Close(StartIndex() + 3) && Close(StartIndex() + 3) < Close(StartIndex() + 2) && Close(StartIndex() + 2) > Close(StartIndex() + 1) && Close(StartIndex() + 1) < Close(StartIndex()) && Lower(StartIndex()) - Close(m_close.MaxIndex(StartIndex(), 5)) >= -1.0 * Range(StartIndex()) ) { return(true); } return(false); }
O mapa de entrada que nos restringe a operar somente com esse padrão é o bit-map 4. Como pode ser visto em nossa tabela de referência acima, observando os bits implícitos, percebe-se que, ao contar da direita para a esquerda, todos são zeros, exceto o 4º caractere, que representa nosso padrão 3. Os testes executados em configurações semelhantes às anteriores — USDCHF, timeframe diário, 2023 — nos dão os seguintes resultados:
Como é claramente visível, não muitas operações são executadas, pois fundos duplos em qualquer uma das bandas não são uma ocorrência comum. Isso talvez indique que esse padrão pode ser usado de forma independente, sem necessidade de emparelhamento com outro indicador, ao contrário de alguns dos padrões que acabamos de ver acima.
Recuo na Banda do Meio de Cima para Baixo e de Baixo para Cima
Nosso próximo e quinto padrão é o padrão 4, que se baseia em padrões de continuação dentro de uma tendência. Sempre que o preço está em tendência em determinada direção, é comum que ele faça algumas pausas ao longo do caminho. Durante essas pausas, há mais volatilidade lateral (whipsaw) do que tendência definida, no entanto, muitas vezes (mas nem sempre), antes de retomar a tendência, o preço pode testar a resistência (em tendência de baixa) ou o suporte (em tendência de alta). Esse teste desses níveis pode ser marcado pelo buffer da banda base das Bandas de Bollinger, pois ele também, como as bandas superior e inferior, tende a atuar como um nível dinâmico de suporte/resistência
Com esse padrão, interpretamos um padrão de alta quando o preço testa a base (buffer do meio) de cima e depois recua para cima, e um padrão de baixa quando o mesmo acontece no sentido contrário. Ou seja, um recuo vindo de baixo. A implementação disso em MQL5 é a seguinte:
//+------------------------------------------------------------------+ //| Check for Pattern 4. | //+------------------------------------------------------------------+ bool CSignalBollingerBands::IsPattern_4(ENUM_POSITION_TYPE T) { m_bands.Refresh(-1); m_close.Refresh(-1); if(T == POSITION_TYPE_BUY && Close(StartIndex() + 2) > Base(StartIndex() + 2) && Close(StartIndex() + 1) <= Base(StartIndex() + 1) && Close(StartIndex()) > Base(StartIndex())) { return(true); } else if(T == POSITION_TYPE_SELL && Close(StartIndex() + 2) < Base(StartIndex() + 2) && Close(StartIndex() + 1) >= Base(StartIndex() + 1) && Close(StartIndex()) < Base(StartIndex())) { return(true); } return(false); }
Os testes com configurações de ambiente semelhantes às anteriores nos fornecem os seguintes resultados:
Nosso indicador de Bandas de Bollinger usa as mesmas configurações em todos os testes deste artigo, com período do indicador igual a 20 e desvio igual a 2.
Divergência de Volume na Banda Inferior ou Banda Superior
Em seguida temos nosso sexto padrão, que busca rastrear divergências entre volume e volatilidade. Agora, muitos traders — especialmente nesta plataforma — operam pares de forex, que raramente possuem dados confiáveis de volume, devido às dificuldades em integrar essas informações entre várias corretoras. Portanto, ao rastrear ou medir o volume nessa implementação, usamos, talvez, o próximo melhor indicador substituto: A amplitude da barra de preço. Os argumentos para isso são de que, quando muitos compradores estão ofertando determinado par, esse par tende a se mover bastante na direção da oferta. Isso, claro, não é totalmente verdade, pois um número igualmente grande de contratos de venda do outro lado pode inibir o movimento de preço e, ainda assim, o volume total envolvido não seria refletido na amplitude da barra de preço resultante.
Portanto, trata-se apenas de um compromisso Interpretamos um sinal de alta quando a amplitude da barra de preço diminui sistematicamente por 3 barras consecutivas, enquanto o preço de fechamento está na banda inferior ou abaixo dela. De forma semelhante, temos um sinal de baixa quando há queda na amplitude da barra de preço por 3 barras e o preço de fechamento está na banda superior ou acima dela. O raciocínio por trás disso pode estar relacionado ao esgotamento de tendências anteriores, onde a queda no "volume" nas extremidades do intervalo de preço indica uma reversão ou ao menos um recuo. A implementação disso em MQL5 é a seguinte:
//+------------------------------------------------------------------+ //| Check for Pattern 5. | //+------------------------------------------------------------------+ bool CSignalBollingerBands::IsPattern_5(ENUM_POSITION_TYPE T) { m_bands.Refresh(-1); m_close.Refresh(-1); m_high.Refresh(-1); m_low.Refresh(-1); if(Range(StartIndex()) < Range(StartIndex() + 1) && Range(StartIndex() + 1) < Range(StartIndex() + 2)) { if(T == POSITION_TYPE_BUY && fabs(m_close.GetData(StartIndex()) - Lower(StartIndex())) < fabs(m_close.GetData(StartIndex()) - Base(StartIndex()))) { return(true); } else if(T == POSITION_TYPE_SELL && fabs(m_close.GetData(StartIndex()) - Upper(StartIndex())) < fabs(m_close.GetData(StartIndex()) - Base(StartIndex()))) { return(true); } } return(false); }
Os testes com apenas esse padrão, usando configurações de ambiente semelhantes às anteriores, nos fornecem os seguintes resultados:
Conclusão
Minha intenção era cobrir todos os 8 padrões do indicador Bandas de Bollinger, como indicado no código anexo, mas este artigo acabou ficando um pouco extenso demais. Portanto, abordarei o restante em um próximo artigo em breve.
Para concluir, examinamos 5 de pelo menos 8 padrões de sinal que podem ser utilizados ao operar com as Bandas de Bollinger. Este indicador não apenas capta a tendência geral dos preços, como também acompanha a volatilidade graças aos seus dois buffers externos. Quando essa informação é combinada com a psicologia do mercado, como vimos, uma variedade de sinais pode ser gerada a partir desse único indicador. Embora cada um desses padrões possa ser usado isoladamente — como fizemos neste artigo que precisou ser interrompido —, o parâmetro de entrada dos padrões utilizados pode, na verdade, permitir a seleção múltipla de padrões, para que possam ser combinados e otimizados, resultando em uma configuração mais dinâmica e adaptável a diferentes tipos de mercado. Esperançosamente, abordaremos isso e muito mais no próximo artigo.
Traduzido do Inglês pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/en/articles/15803
Aviso: Todos os direitos sobre esses materiais pertencem à MetaQuotes Ltd. É proibida a reimpressão total ou parcial.
Esse artigo foi escrito por um usuário do site e reflete seu ponto de vista pessoal. A MetaQuotes Ltd. não se responsabiliza pela precisão das informações apresentadas nem pelas possíveis consequências decorrentes do uso das soluções, estratégias ou recomendações descritas.
Redes neurais em trading: Agente com memória em camadas
Algoritmo do Big Bang e do Grande Colapso — BBBC (Big Bang - Big Crunch)
Instalação do MetaTrader 5 e de outros aplicativos da MetaQuotes no HarmonyOS NEXT
Criando um Expert Advisor Integrado ao Telegram em MQL5 (Parte 6): Adicionando Botões Inline Interativos
- Aplicativos de negociação gratuitos
- 8 000+ sinais para cópia
- Notícias econômicas para análise dos mercados financeiros
Você concorda com a política do site e com os termos de uso
Bom trabalho!!! Você pode compartilhar o arquivo de conjunto para esses resultados?
Não, eu não guardo esses arquivos. Eles são muito específicos.
Obrigado, Stephen, por esse excelente artigo.