Como desenvolver um sistema de negociação baseado no indicador Gator Oscillator
761
0
Introdução
Nós abordaremos este indicador tanto quanto pudermos através dos seguintes tópicos:
- Definição do Gator Oscillator
- Estratégia do Gator Oscillator
- Esquema do Gator Oscillator
- Sistema de negociação do Gator Oscillator
- Conclusão
Nós usaremos a plataforma de negociação MetaTrader 5 para testar a estratégia mencionada e construir o nosso sistema de negociação pela linguagem de programação MetaQuotes language (MQL5) que é incorporada ao MetaTrader 5. Se você não sabe como baixar e usar a MetaTrader 5 e o IDE do MQL5, você pode ler o tópico "Escrevendo códigos em MQL5 no MetaEditor" do meu artigo anterior para aprender mais sobre este tópico.
Eu preciso mencionar aqui que você deve testar qualquer estratégia mencionada antes de usá-la para ter certeza de que será útil e lucrativa para você, pois não há nada adequado para todas as pessoas e o objetivo principal aqui é apenas educacional para aprender o conceito principal e a raiz por trás do indicador. Além disso, há um conselho que preciso mencionar aqui: é que você deve tentar escrever os códigos deste artigo e de outros por conta própria, se quiser melhorar suas habilidades de programação.
Ressalva: Qualquer informação fornecida aqui é apenas para fins educacionais e sem fins comerciais ou de aconselhamento. As informações não garantem nenhum tipo de resultado. Se você optar por usar esses materiais em qualquer uma de suas contas de negociação, você fará isso por sua conta e risco, sendo o único responsável.
Definição do Gator Oscillator
Nesta parte, identificaremos o indicador Gator Oscillator com mais detalhes para entender e reconhecer o conceito principal por trás dele e usá-lo de maneira adequada e eficaz. O indicador Gator Oscillator foi criado por Bill Williams para nos ajudar a identificar se o mercado está tendendo ou variando se há uma tendência quanto essa tendência pode continuar em termos de impulso, além de dar o momento de entrar ou sair de uma negociação. Como todos nós sabemos que essas duas coisas são muito importantes na negociação, o Gator Oscillator é baseado no indicador Alligator e você pode lê-lo no meu artigo anterior Como desenvolver um sistema de negociação baseado no indicador Alligator para mais detalhes sobre o indicador Alligator.
O cálculo do indicador Gator é o mesmo que nós veremos mostrando o quanto de convergência e divergência das linhas de equilíbrio do indicador Alligator. A seguir está o cálculo do indicador Gator:
- Etapa um: nós precisamos calcular o preço mediano:
Median Price = (High + Low) /2
- Etapa dois: nós precisamos calcular as mandíbulas do jacaré, os dentes do jacaré e os lábios do jacaré:
Alligator Jaw = SMMA (Median Price, 13,8)
Alligator Teeth = SMMA (Median Price, 8, 5)
Alligator Lips = SMMA (Median Price, 5, 3)
- Onde:
Median Price: o tipo do preço.
High: a máxima do preço.
Low: a mínima do preço.
SMMA: a média móvel suavizada é um tipo de média móvel, ela é uma forma de suavização para os dados, período e deslocamento, se existir. Se dissermos que a SMMA (Median Price, 13, 5), significa que a SMMA, que é a média móvel suavizada derivada do preço mediano como um tipo de dado, o período de suavização é 13 e o deslocamento para o futuro será de 5.
Mandíbula do jacaré: a linha azul do indicador Alligator.
Dentes do jacaré: a linha vermelha do indicador Alligator.
Lábios do jacaré: a linha verde do indicador de jacaré.
O cálculo anterior produz o indicador Gator Oscillator, mas não precisamos calculá-lo manualmente, pois ele está embutido na MetaTrader 5 e tudo o que precisamos fazer é escolhê-lo entre os outros indicadores técnicos disponíveis e inseri-lo no gráfico da mesma forma que a seguir.
Ao abrir a MetaTrader 5, escolha a aba Inserir --> Indicadores --> Bill Williams --> Gator Oscillator
Depois de selecionar o Gator Oscillator, nós encontraremos a janela de parâmetros do Gator igual à seguinte:
Na figura anterior, nós temos os parâmetros do indicador Gator Oscillator para determinar as configurações desejadas do indicador e ela é o mesmo que a seguir:
- Para determinar o período das mandíbulas.
- Para determinar o deslocamento horizontal dos dentes.
- Para determinar o período dos dentes.
- Para determinar o deslocamento horizontal dos dentes.
- Para determinar o período dos lábios.
- Para determinar o deslocamento horizontal dos lábios.
- Para determinar o método preferido da média.
- Para determinar o tipo de preço que será utilizado no cálculo do Gator.
- Para determinar a cor dos valores Gator up.
- Para determinar a cor dos valores do gator down.
- Para determinar a espessura das barras do Gator.
Depois de determinar todos os parâmetros preferenciais do indicador Gator Oscillator, descobriremos que o indicador está anexado ao gráfico na parte inferior da mesma forma que a seguir:
Como nós podemos ver no gráfico anterior, temos o indicador com os valores para cima e para baixo do Gator Oscillator, onde pode ser visto claramente que nós temos os valores acima de zero e os valores abaixo de zero. Nós também temos as barras verdes e vermelhas com base na relação entre cada barra e sua anterior a barra atual é maior que a anterior. Nós veremos que a atual é verde e vice-versa, se a atual for menor que a anterior nós encontraremos a cor da atual sendo vermelha.
Estratégia do Gator Oscillator
Neste tópico, eu compartilharei com você algumas estratégias simples que podem ser usadas pelo indicador Gator Oscillator apenas para fins de aprendizado. Você deve testar qualquer estratégia mencionada antes de usá-la em uma conta real para ter certeza de que ela será útil para você.
Com base nessa estratégia, nós precisamos identificar o estado do Gator com base nas barras do indicador. De acordo com isso, nós teremos quatro estados do Gator. Se nós tivermos ambas as barras vermelhas, o estado do Gator será uma fase de sono. Se nós tivermos ambas as barras verdes, ela será uma fase de alimentação. Se nós tivermos as duas barras verdes depois do vermelho, ela será a fase do despertar. Se nós tivermos ambas as barras vermelhas após as verdes, ela será uma fase saciada.
Então, simplesmente,
Ambas as barras vermelhas ==> Fase de sono
Ambas as barras verdes ==> Fase de alimentação
Ambas as barras verdes após o vermelho ==> Fase de despertar
Ambas as barras vermelhas após o verde ==> Fase saciada
De acordo com esta estratégia, nós precisamos obter os sinais com base no indicador Gator. Se o jacaré estiver na fase de despertar, nós precisamos obter um sinal para encontrar uma boa entrada. Se o indicador Gator estiver na fase de alimentação, nós precisamos obter um sinal para manter a posição atual. Se o indicador Gator estiver na fase de saciedade, nós precisamos encontrar uma boa saída. Se o estado do Gator for outra coisa, nós não precisamos obter nada.
Simplesmente,
O indicador Gator = Fase de despertar ==> Encontrar uma boa entrada.
O Indicador Gator = Fase de comer ==> Manter a posição atual.
O indicador Gator = Fase saciada ==> Encontrar uma boa saída.
Se o estado do indicador Gator = outra coisa ==> Não faça nada.
De acordo com esta estratégia, nós combinaremos o sinal do Gator com o sinal da média móvel. Se nós tivermos as barras verdes duplas e o preço de fechamento estiver acima do valor da média móvel, será um sinal de uma boa posição de compra. o outro cenário, se o indicador Gator tiver barras vermelhas duplas e o preço de fechamento estiver abaixo do valor da média móvel, será uma boa posição de venda. Ou, se nós tivermos mais alguma coisa, nós não precisamos fazer nada.
Simplesmente,
Barras verdes duplas e o preço de fechamento > a média móvel ==> Encontrar uma boa posição de compra.
Barras vermelhas duplas e o preço de fechamento < o valor da média móvel ==> Encontrar uma boa posição de venda.
Qualquer outra coisa ==> Não fazer nada
Esquema do Gator Oscillator
Nesta parte, nós criaremos os esquemas passo a passo para cada estratégia mencionada para nos ajudar a criar o nosso sistema de negociação de maneira eficaz e fácil. Acredito que esta etapa é muito importante e essencial para o desenvolvimento do sistema de negociação, pois ela economizará muito tempo, mesmo que demore para criar, pois ela permitirá que você evite esquecer qualquer etapa importante e repetir as tarefas para fazer as coisas bem. Nós trabalharemos para entender o que nós precisamos fazer para deixar o computador fazer por nós, organizando as nossas ideias em etapas claras.
Com base no conceito por trás dessa estratégia, nós precisamos do computador ou da criação de um expert advisor que pode ser usado para verificar alguns valores do indicador Gator a cada tick automaticamente, que são a alta atual, as duas altas anteriores a atual e a baixa atual, e os dois anteriores da baixa atual. Após essa verificação, nós precisamos que o expert determine a posição de cada valor e faça a seguinte comparação, a primeira trata de comparar os valores do Gator atual e anterior e determinar qual é maior que o outro. o segundo é sobre comparar os valores do Gator atual e anterior e determinar qual é maior que o outro. O resultado desta comparação serão os nossos sinais desejados para identificar o estado do Gator.
Se o valor atual para cima for menor que o anterior e o valor atual para baixo for maior que o anterior, nós precisamos que o expert ou o sistema de negociação retorne um sinal da fase de hibernação como um comentário no gráfico. Em outro caso, se o valor atual para cima for maior que o anterior e ao mesmo tempo o valor atual para baixo for menor que o anterior, nós precisamos que o sistema de negociação retorne um sinal da fase de alimentação como um comentário no gráfico. No terceiro caso, se o primeiro valor da alta anterior for menor que o segundo anterior e o primeiro valor de baixa anterior for maior que o segundo de baixa anterior e, ao mesmo tempo, o valor de alta atual for maior que o primeiro anterior e o valor de baixa atual for menor que o primeiro anterior, nós precisamos que o sistema de negociação retorne um comentário no gráfico com o sinal da fase de despertar. No quarto e último estado, se o primeiro valor de alta anterior for maior que o segundo e o valor de baixa anterior for menor que o segundo anterior e ao mesmo tempo, o valor de alta atual for menor que o primeiro anterior e o valor atual para baixo é maior que o primeiro anterior, nós precisamos que o sistema de negociação retorne um comentário no gráfico com um sinal da fase saciada.
A seguir está um gráfico simples para o projeto deste sistema de negociação:
Estratégia dois: Sinais do Gator:
De acordo com a ideia principal desta estratégia de negociação, nós precisamos criar um sistema de negociação que possa ser usado para retornar um sinal de um ótimo momento de entrada, saída ou manutenção da posição atual. Para fazer isso, nós precisamos que o sistema de negociação verifique continuamente os valores de alta atual e dois de alta anteriores, além da de baixa atual e dois de baixa anteriores para obter o sinal com base no estado do Gator.
O primeiro sinal de que nós precisamos que o sistema de negociação retorne é (Encontrar uma boa entrada) como um comentário no gráfico após verificar os valores do Gator e descobrir que houve uma fase de despertar porque a primeira alta anterior é menor que a segunda anterior e o primeiro valor de baixa anterior é maior que o segundo e, ao mesmo tempo, o valor de alta atual é maior que o primeiro anterior e o valor de baixa atual é menor que o primeiro anterior.
O segundo sinal que nós precisamos obter pelo sistema de negociação é (Manter a posição atual) como um comentário no gráfico após verificar os valores do Gator e descobrir que houve uma fase de alimentação porque o valor atual é maior que o primeiro anterior e o valor atual para baixo é menor que o primeiro anterior.
O terceiro sinal que nós precisamos obter para este sistema de negociação é (Encontrar uma boa saída) como um comentário no gráfico depois de verificar os valores do Gator e descobrir que houve uma fase saciada porque o primeiro valor de alta anterior é maior que o segundo anterior e o primeiro valor de baixa anterior é maior que o segundo anterior.
A última coisa que nós precisamos no sistema de negociação é não fazer nada se houver algo além do que mencionamos nos três sinais anteriores. A seguir está o esquema deste sistema de negociação:
Estratégia três: Gator com MA:
De acordo com a estratégia de negociação, nós precisamos ter um bom tempo para encontrar as posições de compra ou venda com base no indicador Gator, no preço de fechamento e na média móvel da mesma forma que aprendemos na seção da estratégia, a seguir está como deixar o computador fazer isso.
O primeiro sinal que nós precisamos que o sistema de negociação retorne é (Encontrar uma boa posição de compra) ao verificar os valores do Gator e descobrir que a alta atual é maior que a primeira anterior e a primeira alta anterior é maior que a segunda anterior e ao mesmo tempo, a baixa atual é menor que a primeiro anterior e a primeiro baixa anterior é menor que a segunda anterior, isso significa que agora nós temos as barras verdes duplas. Então, o preço de fechamento é maior que o valor da média móvel.
O segundo sinal é obter (Encontrar uma boa posição de venda) ao verificar o Gator e descobrir que a alta atual é menor que a primeira anterior e a primeiro alta anterior é menor que a segundo anterior e, ao mesmo tempo, a baixa atual for maior que a primeira anterior e a primeiro baixa anterior for maior que a segundo anterior, isso significa que nós temos as barras vermelhas duplas. Então, o preço de fechamento é menor que a média móvel.
A terceira coisa que nós precisamos é que o sistema de negociação não retorne nada se houver outra coisa. A seguir está o esquema deste sistema de negociação:
Sistema de negociação do Gator Oscillator
Agora, nós chegamos ao tópico mais interessante deste artigo para criar o nosso sistema de negociação para cada estratégia mencionada. Este sistema de negociação pode nos ajudar a negociar de forma eficaz, portanto, começaremos a criar um sistema de negociação simples para ser usado como base para nossas estratégias.
O "Simple Gator Oscillator System" é criado para retornar um comentário no gráfico com o valor atual para cima e para baixo do indicador Gator. As etapas a seguir são para criar este sistema de negociação:
Criamos os Arrays upGator e downGator usando uma função do tipo double que é um dos tipos reais para retornar os valores com as frações.
double upGatorArray[]; double downGatorArray[];
Ordenamos os dados desses arrays usando a função "ArraySetAsSeries". Seus parâmetros:
ArraySetAsSeries(upGatorArray,true); ArraySetAsSeries(downGatorArray,true);
Criamos a variável inteira para o gatorDef e definimos o Gator Oscillator usando a função "iGator". para retornar o manipualdor do indicador com base em seus parâmetros:
- symbol: para determinar o nome do símbolo, usaremos _SYMBOL a ser aplicado ao símbolo atual.
- period: para determinar o período, usaremos _PERIOD a ser aplicado ao período atual.
- jaw_period: para determinar o período desejado do cálculo das mandíbulas, usaremos (13).
- jaw_shift: para determinar o deslocamento horizontal das mandíbulas, se necessário. Usaremos (8).
- teeth_period: para determinar o período do cálculo dos dentes. Usaremos (8).
- teeth_shift: para determinar o deslocamento horizontal dos dentes, se necessário. Usaremos (5).
- lips_period: para determinar o período de cálculo dos lábios. Usaremos (5).
- lips_shift: para determinar o deslocamento horizontal dos lábios, se necessário. Usaremos (3).
- ma_method: para determinar o tipo da média móvel. Usaremos (MODE_SMMA).
- applied_price: para determinar o tipo de preço aplicado no cálculo. Usaremos (PRICE_MEDIAN).
int gatorDef=iGator(_Symbol,_Period,13,8,8,5,5,3,MODE_SMMA,PRICE_MEDIAN);
Definimos os dados e armazenamos os resultados usando a função "CopyBuffer" para upGatorArray e downGatorArray. Seus parâmetros:
- indicator_handle: para determinar o manipulador do indicador, usaremos (gatorDef).
- buffer_num: para determinar o número do buffer do indicador, usaremos (0 para upGator), (2 para downGator).
- start_pos: para determinar a posição inicial, vamos determinar (0).
- count: para determinar a quantidade a copiar, usaremos (3).
- buffer[]: para determinar o array de destino a ser copiado, usaremos (upGatorArray, downGatorArray).
CopyBuffer(gatorDef,0,0,3,upGatorArray); CopyBuffer(gatorDef,2,0,3,downGatorArray);
Obtemos os valores de upGator e downGator após criar as variáveis duplas para eles. Em seguida, nós usaremos a função (NormalizeDouble) para fins de arredondamento.
- value: Usaremos upGatorArray[0] para o valor atual.
- digits: usaremos (6) para os dígitos após o ponto decimal.
double gatorUpValue=NormalizeDouble(upGatorArray[0],6); double gatorDownValue=NormalizeDouble(downGatorArray[0],6);
Utilizando a função (Comment) para aparecer os valores do upGator e downGator atuais.
Comment("gatorUpValue = ",gatorUpValue,"\n", "gatorDownValue = ",gatorDownValue);
A seguir está o código completo do sistema de negociação anterior:
//+------------------------------------------------------------------+ //| Simple Gator Oscillator System.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ void OnTick() { double upGatorArray[]; double downGatorArray[]; ArraySetAsSeries(upGatorArray,true); ArraySetAsSeries(downGatorArray,true); int gatorDef=iGator(_Symbol,_Period,13,8,8,5,5,3,MODE_SMMA,PRICE_MEDIAN); CopyBuffer(gatorDef,0,0,3,upGatorArray); CopyBuffer(gatorDef,2,0,3,downGatorArray); double gatorUpValue=NormalizeDouble(upGatorArray[0],6); double gatorDownValue=NormalizeDouble(downGatorArray[0],6); Comment("gatorUpValue = ",gatorUpValue,"\n", "gatorDownValue = ",gatorDownValue); } //+------------------------------------------------------------------+
Depois de escrever as linhas de código anteriores, iremos compilá-lo, certificando-nos de que não há erros, então encontraremos este expert na janela do navegador na pasta Expert Advisors na plataforma de negociação MetaTrader 5 da mesma forma que a seguir:
Ao arrastar e soltar o expert no gráfico desejado, encontraremos a janela deste EA igual à seguinte:
Após marcar "Permitir a Negociação Automatizada" pressionando o botão "OK", é possível encontrar o expert advisor anexado ao gráfico igual à imagem a seguir:
Agora, estamos prontos para receber os sinais deste sistema de negociação, o mesmo do seguinte exemplo de teste:
Estratégia um: Identificador de Estado do Gator:
Com base nessa estratégia, a seguir está o bloco completo do código para criá-lo:
//+------------------------------------------------------------------+ //| Gator Status Identifier.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ void OnTick() { double upGatorArray[]; double downGatorArray[]; ArraySetAsSeries(upGatorArray,true); ArraySetAsSeries(downGatorArray,true); int gatorDef=iGator(_Symbol,_Period,13,8,8,5,5,3,MODE_SMMA,PRICE_MEDIAN); CopyBuffer(gatorDef,0,0,5,upGatorArray); CopyBuffer(gatorDef,2,0,5,downGatorArray); double gatorUpValue=NormalizeDouble(upGatorArray[0],6); double gatorUpPreValue1=NormalizeDouble(upGatorArray[1],6); double gatorUpPreValue2=NormalizeDouble(upGatorArray[2],6); double gatorDownValue=NormalizeDouble(downGatorArray[0],6); double gatorDownPreValue1=NormalizeDouble(downGatorArray[1],6); double gatorDownPreValue2=NormalizeDouble(downGatorArray[2],6); if(gatorUpValue<gatorUpPreValue1&&gatorDownValue>gatorDownPreValue1) { Comment("Sleeping Phase"); } else if(gatorUpValue>gatorUpPreValue1&&gatorDownValue<gatorDownPreValue1) { Comment("Eating Phase"); } if(gatorUpPreValue1<gatorUpPreValue2&&gatorDownPreValue1>gatorDownPreValue2&& gatorUpValue>gatorUpPreValue1&&gatorDownValue<gatorDownPreValue1) { Comment("Awakening Phase"); } else if( gatorUpPreValue1>gatorUpPreValue2&&gatorDownPreValue1<gatorDownPreValue2&& gatorUpValue<gatorUpPreValue1&&gatorDownValue>gatorDownPreValue1) { Comment("Sated Phase"); } } //+------------------------------------------------------------------+
Diferenças neste código:
Definindo e obtendo os três últimos valores de upGator
double gatorUpValue=NormalizeDouble(upGatorArray[0],6); double gatorUpPreValue1=NormalizeDouble(upGatorArray[1],6); double gatorUpPreValue2=NormalizeDouble(upGatorArray[2],6);
Definindo e obtendo os três últimos valores de downGator
double gatorDownValue=NormalizeDouble(downGatorArray[0],6); double gatorDownPreValue1=NormalizeDouble(downGatorArray[1],6); double gatorDownPreValue2=NormalizeDouble(downGatorArray[2],6);
Condições da estratégia:
No caso da fase do sono,
if(gatorUpValue<gatorUpPreValue1&&gatorDownValue>gatorDownPreValue1) { Comment("Sleeping Phase"); }
No caso da fase de alimentação,
else if(gatorUpValue>gatorUpPreValue1&&gatorDownValue<gatorDownPreValue1) { Comment("Eating Phase"); }
No caso da fase de despertar,
if(gatorUpPreValue1<gatorUpPreValue2&&gatorDownPreValue1>gatorDownPreValue2&& gatorUpValue>gatorUpPreValue1&&gatorDownValue<gatorDownPreValue1) { Comment("Awakening Phase"); }
No caso da fase saciada,
else if( gatorUpPreValue1>gatorUpPreValue2&&gatorDownPreValue1<gatorDownPreValue2&& gatorUpValue<gatorUpPreValue1&&gatorDownValue>gatorDownPreValue1) { Comment("Sated Phase"); }
Depois de compilar este código sem erros e executar o EA, nós veremos que ele está anexado ao gráfico igual ao seguinte:
Como nós podemos ver no canto superior direito do gráfico anterior, nós temos o EA Gator Status Identifier anexado ao gráfico.
Nós podemos encontrar os sinais com base nessa estratégia da mesma forma que os seguintes testes:
No caso de um sinal para dormir:
Como nós podemos ver no gráfico anterior no canto superior esquerdo nós temos um sinal da fase de dormir com base nesta estratégia.
No caso da fase de alimentação:
Com base no gráfico anterior, nós podemos encontrar no canto superior esquerdo que temos um sinal da fase de alimentação dependendo dessa estratégia.
No caso da fase de despertar:
Como nós podemos ver no gráfico anterior, nós temos um sinal de fase de despertar baseado na estratégia Identificador de Estado do Gator.
No caso da fase saciada:
Como nós podemos ver na figura anterior, nós temos uma fase saciada no canto superior esquerdo.
Segue o código completo para criar um sistema de negociação baseado nesta estratégia:
//+------------------------------------------------------------------+ //| Gator signals.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ void OnTick() { double upGatorArray[]; double downGatorArray[]; ArraySetAsSeries(upGatorArray,true); ArraySetAsSeries(downGatorArray,true); int gatorDef=iGator(_Symbol,_Period,13,8,8,5,5,3,MODE_SMMA,PRICE_MEDIAN); CopyBuffer(gatorDef,0,0,3,upGatorArray); CopyBuffer(gatorDef,2,0,3,downGatorArray); double gatorUpValue=NormalizeDouble(upGatorArray[0],6); double gatorUpPreValue1=NormalizeDouble(upGatorArray[1],6); double gatorUpPreValue2=NormalizeDouble(upGatorArray[2],6); double gatorDownValue=NormalizeDouble(downGatorArray[0],6); double gatorDownPreValue1=NormalizeDouble(downGatorArray[1],6); double gatorDownPreValue2=NormalizeDouble(downGatorArray[2],6); bool awakeningPhase = gatorUpPreValue1<gatorUpPreValue2&&gatorDownPreValue1>gatorDownPreValue2&& gatorUpValue>gatorUpPreValue1&&gatorDownValue<gatorDownPreValue1; bool eatingPhase = gatorUpValue>gatorUpPreValue1&&gatorDownValue<gatorDownPreValue1; bool satedPhase = gatorUpPreValue1>gatorUpPreValue2&&gatorDownPreValue1<gatorDownPreValue2&& gatorUpValue<gatorUpPreValue1&&gatorDownValue>gatorDownPreValue1; if(awakeningPhase) { Comment("Find a good entry"); } else if(eatingPhase) { Comment("Hold current position"); } else if(satedPhase) { Comment("Find a good exit"); } else Comment(""); } //+------------------------------------------------------------------+
Diferenças nesta estratégia:
Criaçã de uma variável booleana para as três fases seguintes (wakeningPhase, EatingPhase e SatedPhase);
bool awakeningPhase = gatorUpPreValue1<gatorUpPreValue2&&gatorDownPreValue1>gatorDownPreValue2&& gatorUpValue>gatorUpPreValue1&&gatorDownValue<gatorDownPreValue1; bool eatingPhase = gatorUpValue>gatorUpPreValue1&&gatorDownValue<gatorDownPreValue1; bool satedPhase = gatorUpPreValue1>gatorUpPreValue2&&gatorDownPreValue1<gatorDownPreValue2&& gatorUpValue<gatorUpPreValue1&&gatorDownValue>gatorDownPreValue1;
Condições da estratégia:
No caso da Fase do Despertar
if(awakeningPhase) { Comment("Find a good entry"); }
No caso da fase de alimentação
else if(eatingPhase) { Comment("Hold current position"); }
No caso da fase saciada
else if(satedPhase) { Comment("Find a good exit"); }
Outros
else Comment("");
Após compilar este código e executá-lo, veremos que o EA está anexado ao gráfico igual ao seguinte:
Como nós podemos ver no canto superior direito, os sinais do EA do Gator estão anexados ao gráfico.
Agora, nós estamos prontos para receber os sinais desta estratégia e a seguir são os exemplos de testes:
No caso da fase de despertar;
Como nós podemos ver no gráfico anterior, temos um sinal "Find a good entry" no canto superior esquerdo.
No caso da fase de alimentação
Como nós podemos ver na figura anterior, temos um sinal "Hold current position" no canto superior esquerdo.
No caso da fase saciada
Como nós podemos ver no gráfico anterior do teste como exemplo, nós temos um sinal "Find a good exit" no canto superior esquerdo.
Estratégia três: Estratégia do Gator com MA:
A seguir está o código completo para criar um sistema de negociação baseado nesta estratégia.
//+------------------------------------------------------------------+ //| Gator with MA strategy.mq5 | //| Copyright 2022, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ void OnTick() { double upGatorArray[]; double downGatorArray[]; MqlRates pArray[]; double maArray[]; ArraySetAsSeries(upGatorArray,true); ArraySetAsSeries(downGatorArray,true); ArraySetAsSeries(maArray,true); int gatorDef=iGator(_Symbol,_Period,13,8,8,5,5,3,MODE_SMMA,PRICE_MEDIAN); int maDef=iMA(_Symbol,_Period,13,0,MODE_EMA,PRICE_CLOSE); int data=CopyRates(_Symbol,_Period,0,13,pArray); CopyBuffer(gatorDef,0,0,3,upGatorArray); CopyBuffer(gatorDef,2,0,3,downGatorArray); CopyBuffer(maDef,0,0,3,maArray); double gatorUpValue=NormalizeDouble(upGatorArray[0],6); double gatorUpPreValue1=NormalizeDouble(upGatorArray[1],6); double gatorUpPreValue2=NormalizeDouble(upGatorArray[2],6); double gatorDownValue=NormalizeDouble(downGatorArray[0],6); double gatorDownPreValue1=NormalizeDouble(downGatorArray[1],6); double gatorDownPreValue2=NormalizeDouble(downGatorArray[2],6); double maValue=NormalizeDouble(maArray[0],5); double closingPrice=pArray[0].close; bool douleGreen = gatorUpValue>gatorUpPreValue1&&gatorUpPreValue1>gatorUpPreValue2&& gatorDownValue<gatorDownPreValue1&&gatorDownPreValue1<gatorDownPreValue2; bool douleRed = gatorUpValue<gatorUpPreValue1&&gatorUpPreValue1<gatorUpPreValue2&& gatorDownValue>gatorDownPreValue1&&gatorDownPreValue1>gatorDownPreValue2; if(douleGreen&&closingPrice>maValue) { Comment("Find a good buy position"); } else if(douleRed&&closingPrice<maValue) { Comment("Find a good sell position"); } else Comment(""); } //+------------------------------------------------------------------+
Diferenças nesta estratégia:
Criação de mais dois arrays para pArray e maArray; usaremos a função "MqlRates" para pArray para armazenar as informações de preços. e a função "double" para maArray;
MqlRates pArray[]; double maArray[];
Ordenação dos dados em maArray usando a função "ArraySetAsSeries";
ArraySetAsSeries(maArray,true);
Criação de uma variável inteira para maDef e definição da Média Móvel usando a função "iMA" para retornar o identificador do indicador e seus parâmetros:
- symbol: para determinar o nome do símbolo. Vamos determinar (_SYMBOL) a ser aplicado para o gráfico atual.
- period: para determinar o período, usaremos _PERIOD para ser aplicado ao período de tempo atual e você também pode definir (PERIOD_CURRENT) para o mesmo.
- ma_period: para determinar o período médio, usaremos (13).
- ma_shift: para determinar o deslocamento horizontal, se necessário. Vamos definir (0) porque nós não precisamos mudar a MA.
- ma_method: para determinar o tipo da média móvel, definiremos EMA (Média Móvel Exponencial).
- applied_price: para determinar o tipo de preço utilizado no cálculo, usaremos o preço de fechamento.
int maDef=iMA(_Symbol,_Period,13,0,MODE_EMA,PRICE_CLOSE);
Obtendo os dados históricos de MqlRates usando a função "CopyRates":
- symbol_name: para determinar o nome do símbolo, nós usaremos (_Symbol) a ser aplicado ao símbolo atual.
- timeframe: para determinar o o tempo gráfico nós usaremos o (_Period) a ser aplicado para o time frame atual.
- start_pos: para determinar o ponto ou posição inicial, usaremos (0) para iniciar a partir da posição atual.
- count: para determinar quantidade a copiar, usaremos (13).
- rates_array[]: para determinar o destino do array a ser copiado, usaremos (pArray).
int data=CopyRates(_Symbol,_Period,0,13,pArray);
Definindo os dados e armazenando os resultados usando a função "CopyBuffer" para o maArray.
CopyBuffer(maDef,0,0,3,maArray);
Obtendo o valor da média móvel exponencial atual e normalizando-a.
double maValue=NormalizeDouble(maArray[0],5);
Obtendo o valor atual do preço de fechamento.
double closingPrice=pArray[0].close;
Criando as variáveis booleanas de barras verdes duplas e barras vermelhas duplas do indicador Gator Oscillator.
bool douleGreen = gatorUpValue>gatorUpPreValue1&&gatorUpPreValue1>gatorUpPreValue2&&
gatorDownValue<gatorDownPreValue1&&gatorDownPreValue1<gatorDownPreValue2;
bool douleRed = gatorUpValue<gatorUpPreValue1&&gatorUpPreValue1<gatorUpPreValue2&&
gatorDownValue>gatorDownPreValue1&&gatorDownPreValue1>gatorDownPreValue2; Condições da estratégia:
No caso de compra;
if(douleGreen&&closingPrice>maValue) { Comment("Find a good buy position"); }
No caso de venda;
else if(douleRed&&closingPrice<maValue) { Comment("Find a good sell position"); }
Outros;
else Comment("");
Depois de compilar e executar este código para ser anexado ao gráfico desejado, nós encontraremos o EA anexado ao gráfico igual ao seguinte:
Como nós podemos ver no canto superior direito do gráfico, temos o EA do Gator com a MA anexada ao gráfico.
Agora, nós estamos prontos para receber os sinais desta estratégia e a seguir são os exemplos de testes;
No caso de compra;
Como nós podemos ver na figura anterior, no canto superior esquerdo, temos um sinal (Find a good buy position).
No caso de venda;
Como nós podemos ver, nós temos um sinal (Find a good sell position).
Agora nós aprendemos como podemos criar sistemas de negociação baseados em diferentes estratégias e essa abordagem tem que abrir seus olhos para diferentes ideias que você possa aplicar, esse é o principal objetivo deste artigo e série.
Conclusão
Agora, nós cobrimos todos os tópicos deste artigo para aprender como desenvolver um sistema de negociação pelo Gator Oscillator enquanto aprendemos o que é o indicador Gator Oscillator, como calculá-lo, como usá-lo através de três estratégias de negociação simples e são elas:
- Indentificador de Estado do Gator: esta estratégia determina qual é o estado do Gator Oscillator (acordado, dormindo, comendo, saciado) com base em diferentes condições.
- Sinais do Gator: para obter os sinais do momento adequado para a decisão (encontrar uma boa entrada, manter a posição atual ou encontrar uma boa saída) com base em diferentes condições do Gator Oscillator.
- Estratégia do Gator com a MA: para obter os sinais do momento das posições de compra ou venda com base no Gator Oscillator com o indicador de média móvel.
Depois aprendemos como criar um esquema passo a passo para nos ajudar a criar um sistema de negociação para cada estratégia mencionada de forma eficaz e fácil. Em seguida, nós criamos um sistema de negociação para que essas estratégias sejam executadas na plataforma de negociação MetaTrader5, criando o seu código-fonte na IDE MQL5.
Espero que você tenha achado este artigo útil para ajudá-lo a obter os melhores resultados em suas negociações e espero também que esta conta o tenha ajudado a encontrar uma nova abordagem que possa ser usada em suas negociações ou a obter mais informações sobre o tópico deste artigo ou qualquer tópico relacionado e se isso acontecer e você quiser ler mais artigos semelhantes, você pode ler meus outros artigos nesta série sobre como aprender a desenvolver um sistema de negociação com base nos indicadores técnicos mais populares.
Traduzido do Inglês pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/en/articles/11928
Teoria das Categorias em MQL5 (Parte 2)
Ciência de dados e Aprendizado de Máquina (parte 10): Regressão de Ridge
Desenvolvendo um sistema de Replay - Simulação de mercado (Parte 04): Ajustando as coisas (II)
Desenvolvendo um sistema de Replay — Simulação de mercado (Parte 03): Ajustando as coisas (I)
- 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