Download MetaTrader 5

Exemplo de indicador que constrói uma linha de suporte e resistência

5 julho 2017, 08:55
Andrey Kisselyov
0
2 719

Introdução

Usando este artigo a forma mais antiga - na análise técnica - de prever níveis de preço tornar-se-á disponível para quem queira trabalhar de acordo com ele. Você não só poderá implementar o indicador para construir linhas de tendência (linhas de suporte e resistência), mas também entenderá quão simples é implementá-lo. Agora você será capaz de formular as condições para desenhar linhas alterando o código do indicador ligeiramente para atender às suas necessidades.

ATENÇÃO: esta descrição, bem como tudo o que está escrito neste artigo, não tem a ver com recomendações para negociação e é apenas para fins informativos. O autor não é responsável por suas ações, incluindo perdas ou lucros obtidos ao trabalhar segundo o método descrito.


O que são as linhas de suporte e resistência?

Para entender alguma coisa, em primeiro lugar, é preciso definir o objeto de estudo. Abaixo estão as definições das linhas de suporte e resistência que, na minha opinião, melhor refletem sua essência.

A linha de resistência (Resistance) é uma linha de movimento do preço num determinado intervalo de tempo que ela não ultrapassa para cima.

A linha de suporte (Support) é uma linha de movimento do preço num determinado intervalo de tempo que ela não ultrapassa para baixo.

A linha de suporte pode ser horizontal ou inclinada em alguma direção. Mas o papel da linha muda dependendo do que vemos no gráfico. Falemos sobre a linha de suporte. Tudo mencionado será verdade também para a linha de resistência, a única diferença é que elas são espelhadas.
Quando a linha é horizontal, o preço está dentro da faixa de preço. O papel da linha consiste na abertura de ordens de compra, fixação do lucro das ordens de venda.
Quando a linha é ascendente, o preço está em alta. O papel da linha é o nível de abertura de ordens de compra.
Quando a linha é descendente, o preço está em baixa ou queda. O papel da linha consiste na fixação do lucro para as ordens de venda.

Como pode ser visto a partir da definição, qualquer uma destas linhas é uma espécie de barreira ao movimento do preço numa determinada direção. Isto, por sua vez, permite sugerir que o preço se afastará da linha e irá na direção certa, isto é, se o preço atinge a linha de suporte, ele vira para cima, se alcança a linha de resistência, ele vira para baixo. Se a linha de rompimento e o preço ultrapassam suas bordas, podemos concluir que a tendência em tal direção está concluída. Isso não significa que o preço muda de direção, mas você pode dizer com confiança que a tendência tem dificuldade em continuar o movimento. Será lógico relacionar a linha de resistência com o movimento descendente do preço, enquanto a linha de suporte, com o movimento ascendente. Neste caso, as linhas perfeitamente sugerem ao trader a direção na qual está indo o mercado exatamente, isto é, para cima ou para baixo.

Você pode construir linhas horizontais, o que indicará que o preço se encontra num determinado corredor. Por exemplo, o preço não pode cair abaixo de 1,1545 e não pode subir acima 1,1834 num determinado intervalo de tempo. Você também pode construir tanto uma linha de resistência no movimento ascendente do preço quanto uma linha de suporte no movimento descendente, mas, neste último caso, as linhas de fixação serão as operações feitas por você na direção do movimento do preço. Nós aqui consideraremos a construção de linhas inclinadas de suporte e resistência, e, além disso, construiremos níveis horizontais de suporte e resistência.


Condições para selecionar o ponto inicial para a construção da linha inclinada.

Que parâmetros devem ser tomados para a construção adequada das linhas do gráfico no modo automático?

Como a linha de suporte não permite que o preço suba, é lógico construí-la por picos, enquanto a linha de suporte não deixa cair o preço - por fundos. Para não fazer uma embrulhada, aplicamos o indicador fractal de Bill Williams a partir do terminal MetaTrader 5 e vemos no gráfico os possíveis pontos de construção. Podemos ver no gráfico qual fractal é que precisamos tomar como ponto zero. Para a linha de suporte, convém que seja o fractal superior no gráfico, acima do qual não há mais fractais, e acima do qual o preço não sobe. Para a linha de suporte, respectivamente, será o fractal inferior, abaixo do qual não há mais fractais no gráfico. Aqui não é considerado todo o gráfico, mas apenas a parte que é visível para nós, e que vamos analisar. A partir disto, segue logicamente uma condição que podemos usar na construção, isto é: o fractal superior deve estar acima de dois fractais adjacentes, enquanto o inferior, abaixo de dois de seus "vizinhos". Assim, temos o ponto zero.

Condições para selecionar o segundo ponto para a construção da linha inclinada.

Como cada linha deve ser construída pelo menos por dois pontos, precisamos formalizar as regras para a seleção do segundo ponto de nossas linhas de suporte e resistência.

Quais são os critérios que aplicaremos à seleção do segundo ponto? Em primeiro lugar, podemos tomar o segundo fractal, que vai depois do nosso primeiro ponto, uma vez que isso faz com que se mostre a linha mais próxima. Mas podemos usar outras regras de seleção, por exemplo, o ponto mais alto no gráfico, a linha através da qual o preço ainda não cruzou para cima até a linha de resistência (ou o ponto mais baixo no gráfico, a linha através da qual o preço ainda não cruzou para baixo até a linha de suporte). Vocês podem definir suas regras para a seleção do segundo ponto. Nós consideramos o segundo fractal mais próximo, segundo ele construímos as linhas de suporte e resistência.  

seleção de pontos de construção de linhas


Condições de reposição de linhas e a busca de novos pontos para a construção da linha inclinada

Nós já temos pontos de construção de linhas. Agora seria bom determinar quando devem terminar nossas linhas. É bastante natural aplicar a fuga para cima como condição de terminação para a linha de resistência, enquanto, ao contrário, para a linha de suporte, ou seja, aplicar a fuga ou rompimento para baixo. Como, às vezes, o preço rompe as linhas vários pontos e, depois, se afasta, definimos o limite de tolerância no qual a linha ainda é considerada não ultrapassada ou não rota. Isso serve como uma salvaguarda contra cancelamentos falsos das linhas.

Também é preciso ter em mente que às vezes o preço se afasta muito do nível e, por um longo tempo, não volta para a linha. Nas configurações, definimos o comprimento máximo da linha em barras. Isso dá a possibilidade de começar a desenhar uma nova linha se de repente a anterior "ficar suspensa no ar". Como o movimento do preço não pode ter simultaneamente 2 linhas de resistência e 2 linhas de suporte, é lógico supor que, depois de se formar, a linha age até ser ultrapassada. Portanto, só após a linha se finalizar, procuraremos as condições para construir uma nova.

Assim que a linha seja ultrapassada, esperamos que sejam geradas as condições para desenhar a nova linha. Para cada linha, destinamos um  buffer separado e geramos cada um separadamente. Isso permite ver como decorre a luta entre touros e ursos. Como resultado, para o primeiro ponto, podemos selecionar os fractais mais altos (para resistência) e mais baixos (para suporte). O segundo ponto é o seguinte ponto semelhante; ponto alto (para resistência) ou baixo (para suporte). Condições para a construção prontas. Resta implementá-las como código do indicador. Procedemos a escrevê-las.

Exemplo de implementação de construção de linhas com base no indicador para linhas inclinadas

A primeira coisa que fazemos é criar um modelo para as configurações padrão. Em seguida, criamos 2 buffers, isto é, um para resistência e outro para suporte. Introduzimos as configurações Pips_ (valor em que foi quebrada a linha) e MaxBars (comprimento máximo da linha). Aqui finalizam os procedimentos automáticos para a criação do indicador. Seguidamente, começa um trabalho criativo que precisa de atenção.

Ao executar o indicador, verificamos onde estamos. Se o indicador for executado pela primeira vez, definimos o início como a segunda barra, isto a fim de não considerar as primeiras 2, em que - obviamente - não pode haver fractais gerados. Segundo Bill Williams, um fractal é um pico (ou fundo) que está acima (ou abaixo) de dois picos (ou fundos) adjacentes à esquerda e dois à direta. 

Se nosso indicador já foi executado, calculamos o indicador a partir da última barra contada.

   int limit=prev_calculated;
   if(limit>3)limit-=3;
   if(limit<2)limit=2;

Não copiaremos o buffer a partir do indicador fractal de Bill Williams, mas sim escreveremos um par de funções quer verificarão se nossa barra é um fractal. Não se esqueça, ao fazer isto, você deve se proteger de erros de acesso ao buffer: ativamos o processamento caso surjam valores inesperados.

bool up(const double &h[],int q)
  {
// verificamos se a barra tem menos de 2 barras após ela, 
// se, após nossa barra, houver menos de 2 barras, de acordo com as regras ela não poderá ser considerada um fractal
// neste caso, retornamos false, sem verificar mais
   if(q>=ArraySize(h)-2)return(false);
// verificamos se a barra tem menos de 2 barras antes dela, 
// se, antes de nossa barra, houver menos de 2 barras, segundo as regras ela não poderá ser considerada um fractal
// neste caso, retornamos false, sem verificar mais
   if(q<2)return(false);
// verificamos se nossa barra é um fractal. Se for, retornaremos true
   if(h[q]>=h[q-1])
      if(h[q]>=h[q-2])
         if(h[q]>h[q+1])
            if(h[q]>h[q+2])
               return(true);
// se nós passarmos todas as verificações e ainda estiver no bloco, a barra não será um fractal, e retornaremos false
   return(false);
  }
//+------------------------------------------------------------------+
bool down(const double &h[],int q)
  {
// neste bloco todo é similar ao bloco anterior
   if(q>=ArraySize(h)-2)return(false);
   if(q<2)return(false);
   if(h[q]<=h[q-1])
      if(h[q]<=h[q-2])
         if(h[q]<h[q+1])
            if(h[q]<h[q+2])
               return(true);
   return(false);
  }

A seguir, deve se encontrar 1 barra na matriz HIGH e verificar corresponde com nossos parâmetros. Se ela corresponder, iremos memorizá-la e procurar um ponto 2 para a construção da linha. Caso contrário, passamos para outra barra.

for(int w=limit;w<rates_total;w++)
  {
   if(up(high,w))                  //verificamos se há fractal nesta barra
     {
      if(r1==0)r1=w;               //se, por um lado, não houver fractal e, por outro lado, não tivermos 1 pico, definimos 1 para o pico
     }
  }

Uma vez que tenhamos encontrado o primeiro fractal, procuramos o seguinte. Ao fazer isto, é preciso lembrar que ele deve estar abaixo de nossa primeira barra, e, portanto, se ele está acima, é necessário transferir o novo valor de 1 para o fractal.

if(high[w]>=high[r1])r1=w;                   //comparamos com o primeiro pico. Se o fractal estiver acima, consideraremos esse pico o primeiro
else
   {
    r2=w;                                    //obtivemos o valor do segundo pico    
    speedr=(high[r2]-high[r1])/(r2-r1);      //calculamos a velocidade da linha
    w=r1-1;                                  //voltamos para desenhar a nova linha
   }

Depois de encontrar o segundo fractal, que atende a todas as nossas necessidades, calculamos a velocidade do movimento da linha e passamos para sua construção a partir do primeiro fractal (após termos voltado para a ele). Consideraremos a linha desde o início de sua construção, a fim de evitar erros que inevitavelmente se acumulam na construção do ponto anterior. Como consequência, o erro na construção em cada ponto não ultrapassará o limite de tolerância de erro do indicador. Imediatamente verificamos se foi quebrada a linha de acordo com nossas condições, e se for assim, ficaremos à espera de uma nova construção. Notar-se que é só após o segundo fractal que se verifica se foi quebrada ou não. O comportamento dos preços entre fractais não nos interessa. Para a linha de suporte, os cálculos são semelhantes.

ResistanceBuffer[w]=high[r1]+speedr*(w-r1);               //para que o limite de tolerância de erro seja mínimo, calculamos desde o topo
if(w>r2)                                                  //verificamos se a linha foi quebrada ou não
if(high[w]>ResistanceBuffer[w]+Pips_*_Point){r1=0;r2=0;}

Este é o indicador com diferentes configurações.

ind1

ind2

ind3

E isto são vários indicadores no gráfico ao mesmo tempo.

ind4

ind5

Seleção de pontos de construção para níveis de suporte e resistência horizontais

Para construir níveis horizontais, precisamos de apenas um ponto. Isso facilita nossa tarefa. Opções de seleção de pontos de construção há muitas. Mencionarei somente alguns:

  • níveis de Fibonacci a partir do cálculo do dia anterior (barras);
  • níveis de Fibonacci a partir do cálculo do ATP médio do dia, a partir do intervalo médio de preços do dia anterior;
  • número máximo de fractais dentro de um determinado intervalo;
  • acumulação de máximos ou mínimos, preços de abertura ou fechamento de barras dentro de um determinado intervalo;
  • nível de acumulação de volumes segundo um determinado preço (perfil de mercado);
  • nível de reversão de preços com base em figuras;
  • e assim por diante.

Você pode adicionar aqui quaisquer condições que considere necessárias para serem analisadas, mas a essência é a mesma, isto é, nós estamos procurando a condição segundo a qual o preço se afasta de um certo nível. Quanto mais frequentemente esta condição é desencadeada, mais eficaz é nossa linha horizontal de suporte ou resistência. Como exemplo, consideraremos a primeira opção de construção. Tomamos o movimento do preço durante o dia.

movimento diário

Como você pode ver, às vezes, o preço sobe, outras cai. O extremo diário é sempre um nível a partir do qual o preço se afasta e continua numa outra direção. Muito raramente acontece que o preço em alta (ou em baixa) termina seu movimento diário. Portanto, podemos assumir que qualquer máximo é um nível de resistência, enquanto que qualquer mínimo é considerado como nível de suporte.

Como, em nosso caso, o nível é gerado no final do pregão, nos iremos considerá-lo, na sessão de negociação do dia seguinte, como uma guia para atividades financeiras. No entanto, o mercado sempre está em constante movimento, e o preço muda de direção e intervalo ininterruptamente. Nós implementamos a possibilidade de ver vários níveis calculados em relação ao preço do dia anterior. Quando falamos em dia anterior, estamos falando da barra anterior que se encontra em qualquer gráfico cujo timeframe é maior do que o timeframe em que estamos operando. Consequentemente, no indicador, deve ser implementada a possibilidade de selecionar um timeframe. Adicionamos aos cálculos o coeficiente que nos permite deslocar a linha em relação aos preços do dia anterior. Para cada nível, aplicamos o coeficiente adequado. Agora procedemos a escrever nosso indicador.

Exemplo de implementação do indicador de níveis de suporte e resistência horizontais

Primeiro, criamos o indicador através de propriedades estáticas. Iremos chamá-lo da mesma forma que o anterior, adicionaremos apenas a letra H no final, o que significará "horizontal". Definimos o timeframe, em que tomamos: dados, 3 coeficientes para cada par de linhas, 7 buffers para desenhar níveis.

Ao avançar para a escrita, é preciso ter em mente que tomaremos os dados do timeframe maior em três buffers separados, isto é: para o tempo, máximos e mínimos. Escrevemos a função de cópia de dados em nossas matrizes sem esquecer aumentar seu tamanho se necessário.

void array_copy(int b_)
  {
   ArrayResize(time_tf,b_);                         //alteramos o tamanho do buffer de acordo com os dados disponíveis
   ArrayResize(high_tf,b_);
   ArrayResize(low_tf,b_);

   int total=b_-bars_tf;                            //calculamos qual cópia de dados é necessário implementar

   CopyTime(_Symbol,Period_TF,0,total,time_tf)      //copiamos e colamos os dados em falta na matriz
   CopyHigh(_Symbol,Period_TF,0,total,high_tf);
   CopyLow(_Symbol,Period_TF,0,total,low_tf);

   bars_tf=b_;                                      //lembramos o tamanho da matriz e quantidade de dados
  }

É necessário processar os dados obtidos e introduzir os cálculos nas matrizes. Como todos os cálculos dos dados são idênticos, será razoável realizar os cálculos numa função e transferir os dados para ela.

void f1(double k_fibo,int~ q,int r,const datetime &time_[],double &b1[],double &b2[])
  {
   for(int w=q;w<r;w++)
     {
      int b=f2(time_[w]);         //procuramos a hora da barra atual na matriz do timeframe maior
      double h=high_tf[b];        //obtemos o máximo
      double l=low_tf[b];         //obtemos o mínimo
      double hl=h-l;              //encontramos o intervalo do movimento
      b1[w]=h-hl*k_fibo;          //inserimos o valor calculado no buffer de suporte
      b2[w]=l+hl*k_fibo;          //inserimos o valor no buffer de resistência
     }
  }

Como os intervalos de tempo não são iguais, precisamos de encontrar o tempo da barra da matriz atual, na matriz de tempo da matriz mais antiga. Fazemos isso no seguinte trecho de código.

int f2(datetime t_)
  {
   int b_=ArrayBsearch(time_tf,t_);      //procuramos a barra usando um procedimento de busca padrão nas matrizes classificadas
   if(time_tf[b_]>t_)b_--;               //se for retornado o tempo da barra mais próxima e mais antiga, reduziremos o tempo a 1
   return(MathMax(0,b_-1));              //não nos esquecemos de retornar a barra tendo em conta a restrição de acordo com o mínimo
  }

Isso é tudo o indicador que nos vai desenhar os níveis de suporte e resistência necessários em relação ao preço do dia anterior.
   int limit=prev_calculated;
   if(limit>0)limit--;

   int bar=Bars(_Symbol,Period_TF);
   if(bars_tf==0 || bar>bars_tf)array_copy(bar);

   f1(0.5,limit,rates_total,time,buffer7,buffer7);           //desenhamos a mediana
   f1(K_Fibo_1,limit,rates_total,time,buffer1,buffer2);      //desenhamos os níveis para 1 coeficiente
   f1(K_Fibo_2,limit,rates_total,time,buffer3,buffer4);      //desenhamos os níveis para e coeficientes
   f1(K_Fibo_3,limit,rates_total,time,buffer5,buffer6);      //desenhamos os níveis para 3 coeficientes

Assim é como de maneira simples conseguimos o indicador de níveis horizontais de suporte e resistência. Esse é ele no gráfico.

Como você pode ver na imagem, o preço se afasta dos níveis construídos pelo indicador. Um deles serviu de suporte por um longo período. A seleção de níveis mais produtivos é uma questão de técnica e otimização de parâmetros para sistemas de negociação específicos.

Níveis de suporte e resistência com base em médias móveis

Aparentemente o tema chegou ao seu fim, uma vez que surge a questão: "o que é que podemos dizer além de falar da tendência e linhas horizontais de suporte e resistência?"

Preste atenção aos indicadores baseados em médias móveis. Entre os primeiros nós chamamos, é claro, Moving Average, em seguida, Bollinger Bands e Envelopes, incluídos no conjunto padrão do terminal. Estes indicadores parecem destinados a mostrar os níveis de suporte e resistência no gráfico. Abrimos as propriedades do indicador na aba "Níveis" e inserimos um par de níveis com um sinal de menos e outro par, com um sinal de mais. Obtemos algo do genro:

Os mesmos resultados são obtidos para os outros indicadores. O preço "vê" níveis e se afasta deles, bem como dos níveis de suporte e resistência habituais.

Fim do artigo

Em conclusão, gostaria de ressaltar uma caraterística importante dos níveis de suporte e resistência. Após o preço romper o nível, a linha de suporte repetidamente se torna uma linha de resistência, e vice-versa. O trabalho em si a partir dos níveis de resistência e de suporte requerem sinais adicionais para abertura de posições em ambos os sentidos, porque você não sabe ao certo o que vai acontecer com o preço ao ser atingido o nível. Mas quando ele se aproxima de um determinado nível, você tem que ter muito cuidado. Desenvolvimento de uma estratégia de trabalho a partir de níveis não é o assunto deste artigo.


Obrigado pela sua atenção.

Traduzido do russo por MetaQuotes Software Corp.
Artigo original: https://www.mql5.com/ru/articles/3186

Arquivos anexados |
Interfaces gráficas X: Seleção de texto na caixa de texto multilinha (build 13) Interfaces gráficas X: Seleção de texto na caixa de texto multilinha (build 13)

Este artigo implementará a possibilidade de selecionar o texto usando várias combinações de teclas e excluir o texto selecionado, da mesma maneira que é feito em outros editores de texto. Além disso, vamos continuar com a otimização do código e prepararemos as classes para avançar para o processo final do segundo estágio da evolução da biblioteca, onde todos os controles serão renderizados como imagens separadas (telas).

Quanto dura a tendência? Quanto dura a tendência?

No artigo, são selecionadas várias maneiras de identificar a tendência, a fim de definir sua duração em relação ao estado de correção do mercado. Na teoria, acredita-se numa correlação tendência-fase de correção de 30% para 70%. Nós temos que verificar isso.

Previsão de movimentos do mercado utilizando a classificação Bayesiana e indicadores com base na análise de espectro singular Previsão de movimentos do mercado utilizando a classificação Bayesiana e indicadores com base na análise de espectro singular

Nesta pesquisa, são consideradas uma ideologia e metodologia a fim de construir um sistema de recomendação para negociar rápido com base na combinação de possibilidades de previsão com ajuda da Análise de Espetro Singular (SSA) e o método de aprendizado de máquina baseado no teorema de Bayes.

Expert Advisor multiplataforma: Gerenciador de ordens Expert Advisor multiplataforma: Gerenciador de ordens

No artigo, é discutida a criação de um gerenciador de ordens para um EA de negociação multiplataforma. O gerenciador de ordens é responsável pela abertura e fechamento de ordens ou posições efetuadas pelo Expert Advisor, bem como pela manutenção de seus registros independentes, e estará disponível para ambas as versões do terminal.