Estudo de técnicas de análise de velas (parte I): Verificação de padrões existentes
5 329
2
Índice
- Introdução
- Definição do problema
- Desenvolvimento do protótipo de interface
- Implementação da ferramenta
- Resultados do estudo
- Resultados
- Conclusões
Introdução
A análise de velas japonesas apareceu há mais de 20 anos e desde então se tornou bem popular. Muitos traders consideram as velas japoneses a forma de visualização de preços de ativos mais conveniente e fácil de compreender. O formato de barra similar não fornecem dados visuais suficientes. As velas japoneses são mais convenientes em termos de configuração e exibição das cores do corpo da vela e, portanto, fornecem uma melhor visualização dos desenvolvimentos do mercado.
Uma infinidade de vários métodos de análise de velas implica várias classificações de velas ou combinações de velas (padrões) que podem sugerir uma possível mudança no mercado. Alguns padrões indicam a continuação da tendência atual, outros sugerem reversão de tendência e movimentos lateralizados.
No entanto, a idade e a popularidade da análise de velas podem ser prejudiciais para aqueles que a seguem cegamente. Os mercados não param. Não só a dinâmica do mercado mudou após 20 anos, mas também os fatores que influenciam o movimento do mercado. Alguns "players" do mercado começaram a usar a popularidade da análise de velas e apostaram contra ela.
Isso é o que nós vamos fazer neste artigo. Vamos considerar alguns métodos bem conhecidos para determinar o movimento do mercado e verificar se eles ainda são relevantes e eficazes nas realidade de hoje.
Definição do problema
A fim de avaliar a eficiência de um padrão, vamos desenvolver um algoritmo universal para avaliar o seu desempenho. A figura 1 mostra o esquema geral da ação. Vamos dar uma olhada mais de perto.
Fig.1 Algoritmo de avaliação de desempenho de padrões
Passo 1. Selecionar um padrão de vela popular para comparar o seu significado esperado e o resultado real. Para uma maior clareza, o algoritmo fornece um exemplo na forma do padrão de vela conhecido como Harami Cross (modelo altista), ou seja, uma tendência de alta é esperada.
Passo 2. Definir o intervalo do histórico e o período de tempo. Isso permitirá uma determinação e confirmação mais profunda da eficiência do padrão. Isso também pode ajudar a encontrar uma dependência da profundidade do histórico analisado ou determinar um período de tempo, em que o padrão será eficiente ou não funcionará de maneira alguma.
Passo 3. Contar o número de ocorrências do padrão no intervalo selecionado. Esse número será usado para a avaliação cumulativa, que será discutida posteriormente.
Passo 4. Analisar cada correspondência de padrão com uma tendência de alta, baixa ou lateralizada. Aqui, nós precisamos definir a precisão da predição, ou seja, quantos pontos o preço moveu na direção esperada. Suponha que a tendência seja formada por um movimento de preço não inferior a 50 pontos em uma direção ou outra. Se o limite de movimento especificado não for atingido, considera-se que a tendência não foi formada após o padrão.
Passo 5. Como determinar a qualidade do movimento da tendência? O preço pode ultrapassar o valor limite de 50 pontos após a formação do padrão, mas quanto tempo demora? Isso pode ser feito em uma vela do período de tempo analisado ou 10 velas. Portanto, a tendência deve ser eficaz, porque encontrar o padrão e depois esperar por um lucro após entrar no sinal do padrão seria muito arriscado e ineficiente. Para este propósito, as seguintes categorias de eficiência de tendência foram introduzidas.
- Categoria A. O limiar de tendência desejado é alcançado dentro de uma vela após o padrão detectado.
- Categoria B. O limiar de tendência desejado é alcançado dentro de duas velas após o padrão detectado.
- Categoria C. O limiar de tendência desejado é alcançado dentro de três velas após o padrão detectado.
Tal categorização de resultados de tendência permitirá uma avaliação mais objetiva da eficiência do padrão atual.
Passo 6. Calcular as seguintes variáveis:
- Quantas vezes após a detecção do padrão, o preço se movimentou para cima. Esses movimentos devem ser avaliados de acordo com as categorias acima.
- Quantas vezes após a detecção do padrão, o preço se movimentou para baixo. Esses movimentos devem ser avaliados de acordo com as categorias acima.
A Figura 2 mostra um exemplo de localização, contagem e categorização da tendência de alta e baixa da amostra total de padrões de velas encontrados.
Fig.2 Algoritmo e exemplo de detecção e categorização de tendências.
Neste exemplo, nós analisamos a amostra de 2000 velas no período de tempo H1 (Fig.1) e definimos 50 correspondências para o nosso padrão. Depois desse padrão, o preço conseguiu ultrapassar o limiar de 50 pontos para cima 20 vezes e 10 vezes para baixo. De todos esses 20 casos de movimento ascendente, o preço atingiu 50 pontos em uma vela 5 vezes, 7 vezes em 2 velas e 8 vezes o limiar foi atingido em 3 velas.
O mesmo foi realizado para a tendência de baixa. Ele pode ser visto na Figura 2 que a chance e a velocidade da tendência de alta é maior. No entanto, nem sempre é possível determinar o estado de imediato. Tal exame visual pode enganar. Você pode ficar facilmente confuso ao analisar um padrão em diferentes amostras e períodos de tempo.
É por isso que eu decidi introduzir um coeficiente cumulativo para a avaliação geral de qualquer padrão de eficiência em uma dada direção de tendência. Ele parece como se segue:
Aqui E é a eficiência da tendência e P é a probabilidade de uma tendência. Vamos considerar a fórmula de eficiência de tendência:
Aqui A, B e C mostra quantas vezes a tendência foi encontrada em uma das categorias. k1, k2, k3 são coeficientes de peso, porque a significância de cair nessas categorias é diferente. A categoria de tendência A, que é para quando o valor limite é alcançado dentro de uma vela, é mais significativa do que quando alcançada em três velas. As prioridades padrão são as seguintes: k1 = 1, k2 = 0.5, k3 = 0.25. Essa é uma percepção subjetiva, para que você possa definir seus próprios valores preferidos. S é o número total da tendência encontrada do tipo dado.
A possibilidade de surgimento de tendência P é a razão entre o número de tendências encontradas de um determinado tipo (A, B ou C) e o número total de padrões de velas encontrados na amostra dada. Esta é, na verdade, a probabilidade de que o preço se mova em uma determinada direção com base nas ações anteriores do histórico.
Vamos calcular a eficiência para a tendência de alta e de baixa no nosso exemplo da Figura 2.
Fig.3 Os resultados do cálculo da taxa de efetividade.
Os seguintes resultados foram obtidos dos cálculos:
- A eficiência da tendência E foi maior para a tendência de alta, que também foi observada visualmente. No entanto, agora nós temos uma avaliação quantitativa.
- A probabilidade de surgimento da tendência P no caso da formação desse padrão é de 40% para uma tendência de alta e de 20% para uma tendência de baixa.
- Assim, a eficiência geral do padrão para a predição da tendência de alta é mais do que duas vezes maior.
Para um estudo mais aprofundado da relevância do padrão, nós vamos prestar atenção a dois parâmetros principais: a probabilidade de que o preço se mova para a direção prevista pelo padrão de velas e o coeficiente de avaliação de eficiência calculado.
Isso permitirá três conclusões principais para a nossa pesquisa:
- O padrão funciona nas condições atuais do mercado?
- Se ele funciona, quais são as chances da previsão ser satisfeita na emergência do padrão?
- Quanto e quão rápido nós podemos ganhar neste caso?
Desenvolvendo um protótipo de interface para a análise do padrão candlestick
Para estudar os padrões existentes dentro do modelo proposto, é necessário projetar um shell gráfico conveniente baseado nas tarefas definidas. Para isso, nós usaremos a biblioteca existente EasyAndFastGUI para a criação de interfaces gráficas.
Antes de prosseguir com a implementação prática, nós precisamos definir a estrutura externa e criar um protótipo da futura aplicação gráfica. Então nós vamos preenchê-lo com a implementação de software.
A estrutura geral consistirá em duas guias. A primeira guia será usada para analisar os padrões existentes e a segunda conterá os elementos de configuração necessários. Vamos ver a primeira guia em mais detalhes.
Fig.4 A estrutura da guia Análise.
Ela consiste de cinco objetos chave de interação:
- Alternando entre as duas guias, Análise e Configurações.
- Ferramenta para procurar instrumentos monetários necessários para a análise.
- Tabela de resultados, que inclui o Nome do padrão em análise, o Número de correspondências encontradas na faixa de amostragem, com que frequência o padrão ocorre no estudo, as probabilidades de tendência de alta e de baixa e o coeficiente de avaliação de eficiência estimado para esse padrão para a direção da tendência de alta e baixa. Essas informações nos ajudarão a entender se o desempenho do padrão corresponde às características de previsão esperadas e se os resultados correspondem às previsões.
- O período de tempo no qual os padrões de velas serão explorados.
- Faixa de amostragem. O número de velas do período de tempo especificado, dentro do qual os padrões serão testados.
Em seguida, considere a guia Configurações.
Fig.5 A estrutura da guia Configurações.
Esta seção apresenta as configurações de parâmetros que influenciam os resultados da análise do padrão.
- A lista de velas básicas que serão usadas na formação de padrões.
- Janela de diálogo. Ele abre com um clique no ícone de roda dentada. Esta janela apresenta as configurações individuais para os parâmetros das velas básicas que participam da formação de padrões.
- Definir os coeficientes de peso utilizados no cálculo das taxas de eficiência do padrão em análise.
- Valor do limiar de tendência em pontos - se o preço atingir esse limiar, isso será uma confirmação do movimento da tendência e o padrão será considerado bem-sucedido.
Implementação da ferramenta
Depois de definir a base teórica e criar o protótipo, nós precisamos determinar a ordem na qual os elementos da aplicação serão construídos. Como pode ser visto na Figura 5, nós temos duas janelas separadas. O primeiro tem duas guias, Análise e Configurações, enquanto o segundo possui configurações individuais adicionais para os tipos de velas. Portanto, os dois principais métodos de construção são assim:
//+------------------------------------------------------------------+ //| Cria a interface gráfica do programa | //+------------------------------------------------------------------+ bool CProgram::CreateGUI(void) { //--- Criando um painel if(!CreateWindow("Pattern Analyzer")) return(false); //--- Criando uma janela de diálogo if(!CreateWindowSetting("Settings")) return(false); //--- Finalizando a criação da GUI CWndEvents::CompletedGUI(); return(true); } //+-----------------------------------------------------------------
Agora, vamos dar uma olhada no que cada um desses métodos inclui. Nós não entraremos nos mínimos detalhes em relação a cada um dos métodos, mas nós vamos nos debruçar sobre os principais recursos, que estão diretamente relacionados aos métodos de análise de velas. Então, cada método para a criação da janela principal do aplicativo CreateWindow() consiste nos seguintes métodos, que implementam elementos de interface:
- CreateTabs() — implementa as guias Análise e Configurações.
- CreateSymbolsFilter() — um campo de entrada e uma caixa de seleção para a busca do símbolo desejado.
- CreateRequest() — o botão, que inicia a busca por um clique.
- CreateRange() — campo de entrada para especificar o intervalo da amostra.
- CreateComboBoxTF() — uma lista suspensa para selecionar um período de tempo no qual a análise será executada.
- CreateSymbTable() — cria uma tabela com os resultados da busca do símbolo.
- CreateTable() — uma tabela com o padrão de vela analisando os resultados.
- CreateStatusBar() — uma barra de estado que mostra o símbolo atualmente selecionado para análise; Como alternativa, ele informa que o símbolo não está selecionado.
Esta lista de métodos implementa elementos gráficos na guia Análise. Abaixo estão os métodos da guia Configurações.
- CreateCandle() — o método para criar um elemento composto, que consiste na imagem do tipo de vela e um botão de engrenagem (posição 1 na Figura 4).
- CreateTextLabel() — o método para visualizar os cabeçalhos de texto antes dos coeficientes do grupo (posição 3 na Figura 4).
- CreateCoef() — o método exibe um campo de entrada para o coeficiente de peso.
- CreateThresholdValue() — o método é usado para exibir o campo de entrada para o valor do limiar de lucro em pontos.
Agora, vamos considerar a estrutura da segunda janela com configurações adicionais implementadas usando o método CreateWindowSetting().
- CreateSettingTextLabel() — o método cria uma dica de rótulo de texto dinâmico, que ajuda a entender qual parâmetro da vela selecionada você está alterando especificamente.
- CreateSettingCoef() — o método cria um campo de entrada para editar as propriedades da vela selecionada.
- CreateSaveButton() — o método cria um botão para salvar e aplicar as propriedades editadas.
- CreateCancelButton() — o método cria um botão para cancelar todas as ações relativas aos parâmetros da vela selecionada.
Nós criamos uma interface para interação. Agora vamos prosseguir com a implementação dos métodos de cálculo e avaliação, que foram descritos no início da seção relacionada à definição da tarefa. Vamos definir os estágios de desenvolvimento e as condições de entrada, que serão aplicados para a análise dos padrões de velas.
Fig.6 Resultado da criação da interface gráfica.
Como você sabe, existem padrões que consistem em uma vela de um certo tipo, de dois, três e mais velas. Vamos enumerar os tipos básicos de velas, que serão usados em nossos padrões de velas:
- Vela de Alta. Corpo da vela > (média do corpo durante os últimos 5 dias)*K1, onde K1 é o coeficiente ajustável (Fig.4).
- Vela de Baixa. Corpo da vela < (média do corpo durante os últimos 5 dias)*K1.
- Spinning Tops. Pavio inferior > corpo*K1 e pavio superior > corpo*K1.
- Doji. Corpo do Doji < (amplitude entre o preço High e Low)*K1.
- Marubozu. Pavio inferior < corpo*K1 pavio superior < corpo*K1.
- Martelo. Pavio inferior > corpo*K1 e pavio superior < corpo*K2.
Agora, vamos considerar os padrões de vela bem conhecidos para serem aplicados em nosso método de análise. Nós vamos trabalhar com as duas categorias de padrão: aquelas consistindo de uma e duas velas.
Padrão de uma vela:
- Martelo (padrão de alta).
- Enforcado (padrão de baixa).
- Martelo invertido (padrão de alta).
Padrões de duas velas:
- Estrela Cadente (padrão de baixa).
- Engolfo de alta (padrão de alta).
- Engolfo de baixa (padrão de baixa).
- Harami Cross de alta (padrão de alta).
- Harami Cross de baixa (padrão de baixa).
- Harami de alta (padrão de alta).
- Harami de baixa (padrão de baixa).
- Estrela Doji de alta (padrão de alta).
- Estrela Doji de baixa (padrão de baixa).
- Piercing (padrão de alta).
- Núvem Negra (padrão de baixa).
Esses tipos de velas e suas formas de identificá-las foram descritas em detalhes no artigo Analisando Padrões de Velas (Modelos). Esses métodos foram ajustados para o algoritmo de análise de velas.
O algoritmo em si é o seguinte:
1. A CandleType() determina o tipo básico da vela.
//--- Determina o tipo de vela res.type=CAND_NONE; //--- alta if(res.bodysize>sum*m_long_coef) res.type=CAND_LONG; //--- baixa if(res.bodysize<sum*m_short_coef) res.type=CAND_SHORT; //--- doji if(res.bodysize<HL*m_doji_coef) res.type=CAND_DOJI; //--- maribozu if((shade_low<res.bodysize*m_maribozu_coef || shade_high<res.bodysize*m_maribozu_coef) && res.bodysize>0) res.type=CAND_MARIBOZU; //--- martelo if(shade_low>res.bodysize*m_hummer_coef2 && shade_high<res.bodysize*m_hummer_coef1) res.type=CAND_HAMMER; //--- martelo invertido if(shade_low<res.bodysize*m_hummer_coef1 && shade_high>res.bodysize*m_hummer_coef2) res.type=CAND_INVERT_HAMMER; //--- spinning top if(res.type==CAND_SHORT && shade_low>res.bodysize*m_spin_coef && shade_high>res.bodysize*m_spin_coef) res.type=CAND_SPIN_TOP;
2. O método PatternType() determina o tipo de padrão com base nos dados fornecidos por CandleType() para a vela analisada ou duas velas que formam um dos padrões mencionados acima.
for(int i=m_range_total;i>3;i--) { CandleType(symbol,cand2,i); // Vela anterior CandleType(symbol,cand1,i-1); // Vela atual //--- Martelo invertido, modelo altista if(cand2.trend==DOWN && // Verifica a direção da tendência cand2.type==CAND_INVERT_HAMMER) // Verifica o "Martelo invertido" { m_invert_hummer_total++; GetCategory(symbol,i-3,invert_hummer_coef); } //--- Enforcado, baixista if(cand2.trend==UPPER && // Verifica a direção da tendência cand2.type==CAND_HAMMER) // Verifica o "Martelo" { m_handing_man_total++; GetCategory(symbol,i-3,handing_man_coef); } //--- Martelo, modelo altista if(cand2.trend==DOWN && // Verifica a direção da tendência cand2.type==CAND_HAMMER) // Verifica o "Martelo" { m_hummer_total++; GetCategory(symbol,i-3,hummer_coef); } //--- //--- Estrela Cadente, modelo baixista if(cand1.trend==UPPER && cand2.trend==UPPER && // Verifica a direção da tendência cand2.type==CAND_INVERT_HAMMER && cand1.close<=cand2.open) // Verifica o "Martelo invertido" { m_shooting_star_total++; GetCategory(symbol,i-4,shooting_star_coef); } //--- Engolfo de alta, modelo altista if(cand1.trend==DOWN && cand1.bull && cand2.trend==DOWN && !cand2.bull && // Verifica a direção da tendência e da vela cand1.bodysize>cand2.bodysize && cand1.close>=cand2.open && cand1.open<cand2.close) { m_engulfing_bull_total++; GetCategory(symbol,i-4,engulfing_bull_coef); } //--- Engolfo de baixa, modelo baixista if(cand1.trend==UPPER && cand1.bull && cand2.trend==UPPER && !cand2.bull && // Verifica a direção da tendência e da vela cand1.bodysize<cand2.bodysize && cand1.close<=cand2.open && cand1.open>cand2.close) { m_engulfing_bear_total++; GetCategory(symbol,i-4,engulfing_bear_coef); } //--- Harami Cross, altista if(cand2.trend==DOWN && !cand2.bull && // Verifica a direção da tendência e da vela (cand2.type==CAND_LONG || cand2.type==CAND_MARIBOZU) && cand1.type==CAND_DOJI && // Verifica a "long" a primeira vela de "alta" e o Doji cand1.close<cand2.open && cand1.open>=cand2.close) // Doji está dentro do corpo da primeira vela { m_harami_cross_bull_total++; GetCategory(symbol,i-4,harami_cross_bull_coef); } //--- Harami Cross, modelo baixista if(cand2.trend==UPPER && cand2.bull && // Verifica a direção da tendência e da vela (cand2.type==CAND_LONG || cand2.type==CAND_MARIBOZU) && cand1.type==CAND_DOJI && // Verifica a vela de "alta" e o Doji cand1.close>cand2.open && cand1.open<=cand2.close) // Doji está dentro do corpo da primeira vela { m_harami_cross_bear_total++; GetCategory(symbol,i-4,harami_cross_bear_coef); } //--- Harami de alta, altista if(cand1.trend==DOWN && cand1.bull && !cand2.bull && // Verifica a direção da tendência e da vela (cand2.type==CAND_LONG || cand2.type==CAND_MARIBOZU) && // Verifica a primeira vela de "alta" cand1.type!=CAND_DOJI && cand1.bodysize<cand2.bodysize && // A segunda vela não é Doji e a primeira vela é maior que a segunda cand1.close<cand2.open && cand1.open>=cand2.close) // O segundo corpo da vela está dentro do primeiro corpo da vela { m_harami_bull_total++; GetCategory(symbol,i-4,harami_bull_coef); } //--- Harami de baixa, baixista if(cand1.trend==UPPER && !cand1.bull && cand2.bull && // Verifica a direção da tendência e da vela (cand2.type==CAND_LONG || cand2.type==CAND_MARIBOZU) && // Verifica a primeira vela de "alta" cand1.type!=CAND_DOJI && cand1.bodysize<cand2.bodysize && // A segunda vela não é Doji e a primeira vela é maior que a segunda cand1.close>cand2.open && cand1.open<=cand2.close) // O segundo corpo da vela está dentro do primeiro corpo da vela { m_harami_bear_total++; GetCategory(symbol,i-4,harami_bear_coef); } //--- Estrela Doji, altista if(cand1.trend==DOWN && !cand2.bull && // Verifica a direção da tendência e da vela (cand2.type==CAND_LONG || cand2.type==CAND_MARIBOZU) && cand1.type==CAND_DOJI && // Verifica a primeira vela de "alta" e o segundo Doji cand1.close<=cand2.open) // Abertura do Doji é menor ou igual ao fechamento da primeira vela { m_doji_star_bull_total++; GetCategory(symbol,i-4,doji_star_bull_coef); } //--- Estrela Doji, baixista if(cand1.trend==UPPER && cand2.bull && // Verifica a direção da tendência e da vela (cand2.type==CAND_LONG || cand2.type==CAND_MARIBOZU) && cand1.type==CAND_DOJI && // Verifica a primeira vela de "alta" e o segundo Doji cand1.open>=cand2.close) //Abertura do Doji é maior ou igual ao fechamento da primeira vela { m_doji_star_bear_total++; GetCategory(symbol,i-4,doji_star_bear_coef); } //--- Piercing, modelo altista if(cand1.trend==DOWN && cand1.bull && !cand2.bull && // Verifica a direção da tendência e da vela (cand1.type==CAND_LONG || cand1.type==CAND_MARIBOZU) && (cand2.type==CAND_LONG || cand2.type==CAND_MARIBOZU) && // Verifica a vela de "alta" cand1.close>(cand2.close+cand2.open)/2 && // Fechamento da segunda vela está acima do meio da primeira vela cand2.open>cand1.close && cand2.close>=cand1.open) { m_piercing_line_total++; GetCategory(symbol,i-4,piercing_line_coef); } //--- Núvem Negra, baixista if(cand1.trend==UPPER && !cand1.bull && cand2.bull && // Verifica a direção da tendência e da vela (cand1.type==CAND_LONG || cand1.type==CAND_MARIBOZU) && (cand2.type==CAND_LONG || cand2.type==CAND_MARIBOZU) && // Verifica a vela de "alta" cand1.close<(cand2.close+cand2.open)/2 && // Fechamento 2 está abaixo do meio do primeiro corpo da vela cand1.close<cand2.open && cand2.close<=cand1.open) { m_dark_cloud_cover_total++; GetCategory(symbol,i-4,dark_cloud_cover_coef); } }
3 Como pode ser visto no código acima, ao determinar um dos padrões especificados, o histórico é verificado usando o método GetCategory(). Ou seja, a direção do preço após a emergência do sinal é verificada. Ou seja, as categorias de movimento de preços são determinadas para cada um dos padrões encontrados, conforme descrito na Figura 1.
//+------------------------------------------------------------------+ //| Determina as categorias de lucro | //+------------------------------------------------------------------+ bool CProgram::GetCategory(const string symbol,const int shift,int &category[]) { MqlRates rt[]; int copied=CopyRates(symbol,m_timeframe,shift,4,rt); int rating=0; //--- Obtém os detalhes da vela anterior if(copied<4) return(false); double high1,high2,high3,low1,low2,low3,close0,point; close0=rt[0].close; high1=rt[1].high; high2=rt[2].high; high3=rt[3].high; low1=rt[1].low; low2=rt[2].low; low3=rt[3].low; if(!SymbolInfoDouble(symbol,SYMBOL_POINT,point)) return(false); //--- Verifica se é uma tendência de alta if((int)((high1-close0)/point)>=m_threshold_value) { category[0]++; } else if((int)((high2-close0)/point)>=m_threshold_value) { category[1]++; } else if((int)((high3-close0)/point)>=m_threshold_value) { category[2]++; } //--- Verifica se é uma tendência de baixa if((int)((close0-low1)/point)>=m_threshold_value) { category[3]++; } else if((int)((close0-low2)/point)>=m_threshold_value) { category[4]++; } else if((int)((close0-low3)/point)>=m_threshold_value) { category[5]++; } return(true); }
4 Após determinar a categoria e calcular "quantas vezes e em que direção o preço se moveu após a detecção do padrão", outros parâmetros são calculados, como Ocorrência, tendência de alta e baixa, bem como o coeficiente de avaliação de eficiência para este padrão para a direção da tendência de alta e baixa. Este cálculo é realizado pelo método CoefCalculation().
//+------------------------------------------------------------------+ //| Cálculo dos coeficientes de avaliação de eficiência | //+------------------------------------------------------------------+ bool CProgram::CoefCalculation(const int row,int &category[],int found) { double p1,p2,k1,k2; int sum1=0,sum2=0; for(int i=0;i<3;i++) { sum1+=category[i]; sum2+=category[i+3]; } //--- p1=(found>0)?NormalizeDouble((double)sum1/found*100,2):0; p2=(found>0)?NormalizeDouble((double)sum2/found*100,2):0; k1=(found>0)?NormalizeDouble((m_k1*category[0]+m_k2*category[1]+m_k3*category[2])/found,3):0; k2=(found>0)?NormalizeDouble((m_k1*category[3]+m_k2*category[4]+m_k3*category[5])/found,3):0; m_table.SetValue(3,row,(string)p1,2); m_table.SetValue(4,row,(string)p2,2); m_table.SetValue(5,row,(string)k1,2); m_table.SetValue(6,row,(string)k2,2); //--- Atualiza a tabela m_table.Update(true); m_table.GetScrollVPointer().Update(true); m_table.GetScrollHPointer().Update(true); return(true); }
Com base nesses cálculos, nós podemos avaliar se o padrão corresponde às características esperadas do movimento.
Resultados do estudo
Para analisar os padrões de velas, vamos usar um conjunto de símbolos da categoria forex.major no terminal MetaTrader 5. Para não inseri-los um por um, uma palavra especial foi adicionada para fornecer a lista inteira. Quando você digita a palavra Major, a lista desejada mostrada na Fig. 7 será exibida.
Fig.7 Seleção rápida dos principais símbolos.
Nós não executaremos as configurações adicionais para os padrões de velas. O único parâmetro editável é o valor do limiar de tendência em pontos. As metas de lucro em diferentes períodos de tempo devem ser ajustadas, uma vez que metas muito grandes em pequenos períodos de tempo levarão a resultados nulos, e metas muito pequenas em períodos de tempo mais elevados levarão ao resultado oposto.
Para testar a suposição acima, vamos selecionar dois períodos de tempo e alterar o valor do Limiar. Isso nos permitirá ver o efeito do parâmetro. Eu decidi considerar uma pequena amostra de teste, porque se considerarmos cada par de moedas nos 21 períodos de tempo propostos e alterarmos os parâmetros, haverá muita informação confusa. Você pode selecionar o par desejado, o período de tempo e o histórico para testar vários valores do limiar.
Aqui está o primeiro conjunto de parâmetros não padrão:
- Definido Major.
- Período de tempo M15.
- Limiar do valor do lucro é de 100 pontos (para cotações de 5 dígitos).
Os resultados dos testes de todos os sete pares são apresentados na Figura 8.
Fig.8 Resultados da análise do período de tempo M15.
Vamos dar uma olhada mais próxima no EURUSD e usar seu exemplo para verificar se os padrões de velas são relevantes nas condições dadas. Os padrões na imagem acima são destacados em uma cor específica, que indica o caráter de seu movimento. A cor vermelha é usada para os padrões que indicam uma possível tendência de baixa, enquanto o verde é usado para aqueles que mostram tendência de alta. Vamos ver se as cores estão de acordo com o resultado.
Fig.9 Resultados da análise no EURUSD.
O primeiro padrão em análise é o Martelo. De acordo com as características do padrão, ele prevê um movimento ascendente. Durante nossos testes, um movimento ascendente foi observado em 30% dos casos e o movimento descendente ocorreu em 10% dos casos. Note que este é o movimento não inferior ao valor do limiar especificado de 100 pontos. Considerando que, em uma amostra histórica, o padrão foi seguido por um movimento ascendente em mais de um terço dos casos, podemos supor que ele confirma a hipótese de que esse padrão de vela sinaliza uma tendência de alta.
No entanto, essa observação não pode ser aplicada automaticamente a todos os outros períodos de tempo e amostras. Isso se refere a esse caso e resultado específico.
Agora vamos considerar o padrão Engolfo de baixa. O padrão é para indicar uma tendência de baixa, portanto, depois disso, você deve realizar uma operação vendida. No entanto, o resultado mostra que o comportamento deste padrão de vela é completamente diferente na maioria dos casos: em 20% dos casos, após o aparecimento do padrão, o preço subiu em pelo menos 100 pontos, enquanto a participação dos movimentos descendentes foi de apenas 9% de todos os casos, o que é mais do que duas vezes menor. Assim, o teste mostrou que o padrão se comporta de maneira oposta.
O terceiro padrão a analisar é o Harami de alta. Como o nome e a etiqueta verde indicam, esse padrão é um sinal de compra. No entanto, o número de casos de baixa e de alta é quase igual: 17% e 19%. Nós podemos dizer que esse padrão mostra um certo sinal? Eu duvido, já que não há uma prevalência clara de nenhum dos lados. Assim, o resultado do teste sugere que você deve abster-se mais de usar esse padrão para negociar EURUSD no período de 15 minutos.
Resultados
Com base nos resultados obtidos, as seguintes observações podem ser feitas: é difícil interpretar claramente os padrões de vela. Os resultados dependem muito das condições em que elas aparecem. Assim, um padrão não se comporta da mesma forma, não apenas em todo o mercado, mas também no mesmo par de moedas com diferentes períodos de tempo. Você deve sempre verificar novamente os sinais de padrão.
Conclusões
O arquivo anexado contém todos os arquivos listados, localizados nas pastas apropriadas. Para o seu bom funcionamento, você só precisa salvar a pasta MQL5 na pasta do terminal.
Programas utilizados no artigo
| # |
Nome |
Tipo |
Explicação |
|---|---|---|---|
| 1 |
PatternAnalyzer.mq5 | Interface gráfica |
Barra de ferramentas para analisar padrões de velas |
| 2 | MainWindow.mqh | Código Base | Biblioteca GUI |
| 3 | Program.mqh | Código Base | Biblioteca de métodos para a criação de interface e cálculo de elementos |
Traduzido do russo pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/ru/articles/5576
O poder do ZigZag (parte II). Exemplos de recebimento, processamento e exibição de dados
O poder do ZigZag (parte I). Desenvolvimento da classe base do indicador
Análise sintática MQL via ferramentas MQL
Aplicação prática das correlações na negociação
- 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
I got the library working but just copying the files to the folder did not do the trick. What should I do?