Como desenvolver um sistema de negociação baseado no indicador Fractais

MetaTrader 5 — Negociação | 6 fevereiro 2023, 10:12

632

Mohamed Abdelmaaboud

Introdução

Um novo artigo com um novo indicador técnico em nossa série, pois nós aprenderemos como desenvolver um sistema de negociação baseado em um dos indicadores técnicos mais populares que é o indicador Fractais. Nós vamos aprender sobre isso em detalhes através dos seguintes tópicos:

Nós aprenderemos o que ele é, o que ele mede e como nós podemos calculá-lo manualmente para entender a ideia principal por trás dele. Nós aprenderemos como deixá-lo trabalhar a nosso favor por meio das estratégias de negociação simples baseadas no conceito básico do indicador. Depois disso, nós criaremos um sistema de negociação baseado nessas estratégias para ser usado na plataforma de negociação MetaTrader 5 para gerar os sinais automáticos.

Nós usaremos a MQL5 (MetaQuotes Language 5) que está embutido na IDE na plataforma de negociação MetaTrader 5 para escrever os nossos códigos. Se você não sabe como baixar e usar a MetaTrader 5 e a MQL5, você pode ler o tópico Escrevendo códigos em MQL5 no MetaEditor para saber mais sobre isso. A propósito, eu aconselho você a tentar aplicar o que aprendeu sozinho se quiser melhorar suas habilidades de codificação.

Você deve testar qualquer estratégia mencionada antes de usá-la em sua conta real, pois o principal objetivo deste artigo é educacional. Além disso, não há nada adequado para todos. Portanto, você deve se certificar de que isso é adequado para a sua negociaçã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 de Fractais

O indicador Fractais foi desenvolvido por Bill Williams. Ele foi desenvolvido para tentar antecipar os potenciais movimentos da ação do preço, dando sinais de alta ou baixa. O sinal de alta dá um movimento em potencial para o lado positivo, mas o sinal de baixa dá um movimento em potencial para o lado negativo. Nós podemos dizer também que este indicador tenta antecipar as altas e baixas no gráfico. Nós podemos ver esses sinais visualizando as setas geradas no gráfico abaixo e acima dos preços.

Ele forma duas setas diferentes, a seta dos Fractais para cima e a seta dos Fractais para baixo. Se você pedir o método de cálculo dessas duas setas a serem formadas, a seguir está a resposta a esta pergunta:

O indicador Fractais precisa de um padrão específico da ação do preço a ser formado no gráfico em ambas as direções para cima ou para baixo.

Para os Fractais ascendentes, na ação do preço, nós precisamos do seguinte:

Pelo menos cinco velas ou barras consecutivas.
A máxima na vela do meio (3ª).
Elevações mais baixas em cada lado desta alta.
Depois que a quinta vela fechar com as mesmas condições anteriores, a seta para cima dos Fractais será formada acima da vela (3ª).

Para os Fractais descendentes, na ação do preço, nós precisamos do seguinte:

Pelo menos cinco velas ou barras consecutivas.
A mínima na vela do meio (3ª).
mínimas mais altas em cada lado desta mínima.
Depois que a quinta vela fechar com as mesmas condições anteriores, a seta descendente dos Fractais será formada abaixo da vela (3ª).

Felizmente, nós não precisamos fazer essas etapas anteriores para desenhar o indicador Fractais em nosso gráfico porque ele está pronto para nós na MetaTrader 5, basta escolher o indicador Fractais entre os indicadores disponíveis. nós podemos fazer isso abrindo a plataforma MetaTrader 5 e pressionando,

Inserir --> Indicadores --> Bill Williams --> Fractais

Inserção dos Fractais

Depois de escolher os Fractais, nós encontraremos a seguinte janela de parâmetros do indicador:

Parâmetro dos Fractais

1- Para determinar a cor das setas.

2- Para determinar a espessura.

Depois de pressionar OK, nós encontraremos o indicador inserido no gráfico igual ao seguinte:

Frac anexado

Como nós podemos ver, nós temos setas acima e abaixo das velas referindo-se ao movimento em potencial na ação do preço. Temos setas para baixo abaixo das velas que mostram um movimento ascendente em potencial e setas para cima acima das velas que mostram um movimento descendente em potencial.

Estratégia dos Fractais

Nós aprenderemos como usar este indicador com base nas estratégias simples baseadas no conceito principal deste indicador técnico. Nós usaremos apenas o indicador Fractais e aprenderemos o conceito de usá-lo com outros indicadores técnicos para obter mais informações e aprimorar os seus sinais.

Estratégia um: Altas e baixas dos Fractais

De acordo com esta estratégia, nós precisamos obter os sinais das altas e baixas com base nas posições das altas e baixas dos Fractais. Se o indicador gerou a seta inferior, ele será um sinal de baixa. Se os Fractals geraram a seta superior, ele será um sinal de alta.

Simplesmente,

Seta inferior --> Baixa dos Fractais

Seta superior --> Alta dos Fractais

Estratégia dois: Fractais com uma MA

De acordo com esta estratégia, nós precisamos obter os sinais de compra e venda com base na direção da ação do preço com base na posição do preço e na média móvel, além dos sinais gerados do indicador Fractais. Se o preço de fechamento estiver acima da média móvel e o indicador de Fractais gerar uma seta para baixo, ele será um sinal de compra. Se o preço de fechamento estiver abaixo da média móvel e o indicador Fractais gerar a seta superior, será um sinal de venda.

Simplesmente,

Preço de fechamento > MA e seta inferior gerada --> sinal de compra

Preço de fechamento < MA e seta superior gerada --> sinal de venda

Estratégia três: Fractais com o Alligator

De acordo com esta estratégia, nós precisamos obter os sinais de compra e venda com base na direção da ação do preço, dependendo de sua posição com o indicador Alligator, além dos sinais gerados do indicador Fractais. Se a linha dos lábios do Alligator estiver acima dos dentes e das mandíbulas, a linha dos dentes estiver acima das mandíbulas, o preço de fechamento estiver acima dos dentes e o sinal do indicador Fractais for uma seta para baixo, será um sinal de compra. No outro cenário, se a linha dos lábios for menor que os dentes e mandíbulas, os dentes forem menores que as mandíbulas, o preço de fechamento for menor que os dentes e o sinal dos Fractais for uma seta para cima, será um sinal de venda.

Simplesmente,

Os lábios > os dentes e as mandíbulas, os dentes > as mandíbulas, o preço de fechamento > os dentes, e o sinal dos Fractais for uma seta para baixo --> sinal de compra

Os lábios < os dentes e as mandíbulas, os dentes < as mandíbulas, o preço de fechamento < os dentes, e o sinal dos Fractais for uma seta superior --> sinal de venda

Esquema da estratégia dos Fractais

Nós desenharemos um esquema passo a passo para cada estratégia mencionada para nos ajudar a criar os sistemas de negociação para eles de maneira suave e fácil, organizando as nossas ideias.

1. Fractais de alta e baixa

Com base nessa estratégia, nós precisamos criar um sistema de negociação que possa ser usado para retornar as máximas e mínimas do indicador Fractais como um comentário no gráfico, verificando continuamente os valores fracUpvalue e fracDownValue. Se o fracUp for maior que zero ou não tiver um valor vazio e o fracDown tiver um valor vazio, nós precisamos que o sistema de negociação retorne um sinal no gráfico como um comentário com o seguinte valor:

Fractais de alta em torno de: n

No outro caso, se o fracDown for maior que zero ou não tiver valor vazio e o fracUp tiver um valor vazio, nós precisamos que o sistema de negociação retorne um sinal no gráfico como um comentário com o seguinte valor:

Fractais de baixa em torno de: n

A seguir está o projeto desta estratégia:

Esquema dos Fractais de alta e baixa

2. Fractais com a MA

Com base nessa estratégia, nós precisamos criar um sistema de negociação que possa ser usado para retornar os sinais de compra e venda como um comentário no gráfico com base na verificação contínua dos seguintes valores:

o preço de fechamento
Valor da EMA (Média Móvel Exponencial)
valor do fracDown
valor do fracUp

Se o preço de fechamento for maior que o valor da EMA e o valor de fracDown não for igual a um valor vazio, nós precisamos que o sistema de negociação retorne os seguintes valores:

Compra
EMA atual
Valor dos Fractais de baixa: n

No outro caso, se o preço de fechamento for menor que o valor de EMA e o valor de fracUp não for igual a um valor vazio, nós precisamos que o sistema de negociação retorne os seguintes valores:

Venda
EMA atual
Valor dos Fractais de alta: n

O gráfico a seguir é para este esquema:

Esquema Frac com a MA

3. Fractais com o Alligator

Com base nessa estratégia de negociação, nós precisamos criar um sistema que possa ser usado para gerar os sinais de compra e venda, verificando continuamente as posições para os seguintes valores:

O valor dos lábios
O valor dos dentes
O valor das mandíbulas
O preço de fechamento
O valor de fracDown
O valor de fracUp

Se o valor dos lábios for maior que o valor dos dentes e o valor das mandíbulas, o valor dos dentes for maior que o valor das mandíbulas, o preço de fechamento for maior que o valor dos dentes e o valor de fracDown não for igual a um valor vazio, nós precisamos do sistema de negociação para retornar um comentário no gráfico com os seguintes valores:

Compra
Valor n das mandíbulas
Valor n dos dentes
Valor n dos lábios
Fractais de baixa em torno de: n

No outro caso, se o valor dos lábios for menor que os valores dos dentes e das mandíbulas, a linha dos dentes for menor que o valor das mandíbulas, o preço de fechamento for menor que os dentes e o valor de fracUp não for igual a um valor vazio, nós precisamos que o sistema de negociação retorne os seguintes valores:

Venda
Valor n das mandíbulas
Valor n dos dentes
Valor n dos lábios
Fractais de alta em torno de: n

O gráfico a seguir é para este esquema:

Esquema do Frac com o Alligator

Sistema de negociação dos Fractais

Neste tópico, nós aprenderemos como criar um sistema de negociação baseado nas estratégias mencionadas passo a passo para executá-las na plataforma MetaTrader 5. Nós começaremos criando um sistema simples de Fractais que pode ser usado para retornar os comentários no gráfico com os valores do indicador Fractais e a seguir encontramos como fazer isso.

Criação dos arrays para os fractais de alta e baixa usando a função double.

   double fracUpArray[];
   double fracDownArray[];

Classificando os dados usando a função ArraySetAsSeries. Seus parâmetros são:

array[]: usaremos os arrays criados fracUpArray e fracDownArray.
flag: usaremos true.

   ArraySetAsSeries(fracUpArray,true);
   ArraySetAsSeries(fracDownArray,true);

Definição do indicador de fractais usando a função "iFractals" para retornar o identificador do indicador de Fractais. Seus parâmetros são:

symbol: usaremos o _Symbol a ser aplicado ao gráfico atual.
período: usaremos _Period para ser aplicado ao período de tempo atual.

int fracDef=iFractals(_Symbol,_Period);

Obtendo os dados e armazenando o resultado usando a função "CopyBuffer". Seus parâmetros são:

indicator_handle: para determinar o identificador do indicador, nós usaremos (fracDef).
buffer_num: para determinar o número do buffer do indicador, nós usaremos (UPPER_LINE para fracUp), (LOWER_LINE para fracDown).
start_pos: para determinar a posição inicial, nós determinaremos (1).
count: para determinar a quantidade a copiar, usaremos (3).
buffer[]: para definir o array de destino a ser copiado, nós usaremos (fracUpArray, fracDownArray).

   CopyBuffer(fracDef,UPPER_LINE,2,1,fracUpArray);
   CopyBuffer(fracDef,LOWER_LINE,2,1,fracDownArray);

Obteção dos valores de fractais para cima e para baixo.

   double fracUpValue=NormalizeDouble(fracUpArray[0],5);
   double fracDownValue=NormalizeDouble(fracDownArray[0],5);

Retorno do valor zero em caso de um valor vazio para fracUpValue e fracDownValue.

   if(fracUpValue==EMPTY_VALUE)
      fracUpValue = 0;
   if(fracDownValue==EMPTY_VALUE)
      fracDownValue = 0;

Usando a função "Comentário" para retornar comentários no gráfico com valores de fractais.

   Comment("Fractals Up Value = ",fracUpValue,"\n",
           "Fractals Down Value = ",fracDownValue);

O seguir está o código completo para criar este sistema de negociação.

//+------------------------------------------------------------------+
//|                                       Simple Fractals 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()
  {
//creating price array
   double fracUpArray[];
   double fracDownArray[];
//Sorting data
   ArraySetAsSeries(fracUpArray,true);
   ArraySetAsSeries(fracDownArray,true);
//define frac
   int fracDef=iFractals(_Symbol,_Period);
//define data and store result
   CopyBuffer(fracDef,UPPER_LINE,2,1,fracUpArray);
   CopyBuffer(fracDef,LOWER_LINE,2,1,fracDownArray);
//get values of fracUp and fracDown
   double fracUpValue=NormalizeDouble(fracUpArray[0],5);
   double fracDownValue=NormalizeDouble(fracDownArray[0],5);
//returning zero if there is empty value of fracUp
   if(fracUpValue==EMPTY_VALUE)
      fracUpValue = 0;
//returning zero if there is empty value of fracDown
   if(fracDownValue==EMPTY_VALUE)
      fracDownValue = 0;
//comment on the chart
   Comment("Fractals Up Value = ",fracUpValue,"\n",
           "Fractals Down Value = ",fracDownValue);
  }
//+------------------------------------------------------------------+

Depois de compilar este código, nós encontraremos o seu arquivo na pasta do navegador igual ao seguinte:

Frac Nav

Arrastando e soltando este arquivo no gráfico, nós encontraremos a sua janela igual à seguinte:

Janela Simple Frac System

Após marcar "Permitir a Negociação Automatizada" e pressionar o botão OK, o programa será anexado ao gráfico:

Sistema Frac Simples anexado

Como nós podemos ver no canto superior direito do gráfico, o expert está anexado e estamos prontos para receber os sinais desejados, a seguir encontramos os exemplos de testes:

Sinal do Sistema Frac Simples

Como nós podemos ver no canto superior esquerdo, nós temos dois valores:

Valor dos Fractais de alta = n
Valor dos Fractais de baixa = 0

E é claro que o valor dos Fractais de baixa é zero, pois temos o valor dos Fractais de alta.

Sinal do Sistema Frac Simples 2

Temos dois valores:

Valor dos Fractais de alta = 0
Valor dos Fractais de baixa = n

Mas o valor do Fractais de alta é zero, pois temos o valor dos Fractais de baixa.

1. Fractais de alta e baixa

A seguir encontramos o código completo para criar um sistema de negociação dos Fractais de alta e baixa.

//+------------------------------------------------------------------+
//|                                      Fractals highs and lows.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()
  {
//creating arrays
   double fracUpArray[];
   double fracDownArray[];
//Sorting data
   ArraySetAsSeries(fracUpArray,true);
   ArraySetAsSeries(fracDownArray,true);
//define frac
   int fracDef = iFractals(_Symbol,_Period);
//define data and store result
   CopyBuffer(fracDef,UPPER_LINE,2,1,fracUpArray);
   CopyBuffer(fracDef,LOWER_LINE,2,1,fracDownArray);
//define values
   double fracUpValue = NormalizeDouble(fracUpArray[0],5);
   double fracDownValue = NormalizeDouble(fracDownArray[0],5);
//returning zero in case of empty values
   if(fracUpValue ==EMPTY_VALUE)
      fracUpValue = 0;
   if(fracDownValue ==EMPTY_VALUE)
      fracDownValue = 0;
//conditions of the strategy and comment on the chart with highs and lows
//in case of high
   if(fracUpValue>0)
     {
      Comment("Fractals High around: ",fracUpValue);
     }
//in case of low
   if(fracDownValue>0)
     {
      Comment("Fractals Low around: ",fracDownValue);
     }
  }
//+------------------------------------------------------------------+

Diferenças neste código.

Condições da estratégia:

Em caso de alta,

   if(fracUpValue>0)
     {
      Comment("Fractals High around: ",fracUpValue);
     }

Em caso de baixa,

   if(fracDownValue>0)
     {
      Comment("Fractals Low around: ",fracDownValue);
     }

Depois de compilar este código e anexá-lo ao gráfico da mesma forma que nós aprendemos antes, nós descobriremos que o expert dos fractais de alta e baixa está anexado da mesma forma que o seguinte:

Fractais de alta e baixa anexados

Agora, nós podemos receber os resultados desejados para as altas e baixas. No caso de baixas:

Fractais de alta e baixa - sinal de baixa

Nós podemos ver no gráfico anterior no canto superior esquerdo que nós temos o valor dos Fractais de baixa, pois o indicador Fractais formou uma baixa.

No caso de altas:

Fractais de alta e baixa - sinal de alta

Como nós podemos ver, nós temos o valor dos Fractais de alta, pois o indicador formou uma alta no gráfico.

2. Fractais com a MA

A seguir está o código completo para criar um sistema de negociação para a estratégia Fractais com a MA.

//+------------------------------------------------------------------+
//|                                             Fractals with MA.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()
  {
//creating arrays
   double fracUpArray[];
   double fracDownArray[];
   MqlRates priceArray[];
   double maArray[];
//Sorting data
   ArraySetAsSeries(fracUpArray,true);
   ArraySetAsSeries(fracDownArray,true);
   ArraySetAsSeries(priceArray,true);
   ArraySetAsSeries(maArray,true);
//define values
   int fracDef = iFractals(_Symbol,_Period);
   int Data = CopyRates(_Symbol,_Period,0,3,priceArray);
   int maDef = iMA(_Symbol,_Period,50,0,MODE_EMA,PRICE_CLOSE);
//define data and store result
   CopyBuffer(fracDef,UPPER_LINE,2,1,fracUpArray);
   CopyBuffer(fracDef,LOWER_LINE,2,1,fracDownArray);
   CopyBuffer(maDef,0,0,3,maArray);
//get values
   double fracUpValue = NormalizeDouble(fracUpArray[0],5);
   double fracDownValue = NormalizeDouble(fracDownArray[0],5);
   double closingPrice = priceArray[0].close;
   double maValue = NormalizeDouble(maArray[0],6);
   bool isBuy = false;
   bool isSell = false;
//conditions of the strategy and comment on the chart
//in case of buy
   if(closingPrice > maValue && fracDownValue != EMPTY_VALUE)
     {
      Comment("Buy","\n",
              "Current EMA: ",maValue,"\n",
              "Fractals Low around: ",fracDownValue);
      isBuy = true;
     }
//in case of sell
   if(closingPrice < maValue && fracUpValue != EMPTY_VALUE)
     {
      Comment("Sell","\n",
              "Current EMA: ",maValue,"\n",
              "Fractals High around: ",fracUpValue);
      isSell = true;
     }
  }
//+------------------------------------------------------------------+

Diferenças neste código.

Criando mais dois arrays do priceArray usando a função "MqlRates" para armazenar as informações sobre os preços, volumes, spread e maArray usando a função "double".

   MqlRates priceArray[];
   double maArray[];

Ordenando os dados desses dois arrays.

   ArraySetAsSeries(priceArray,true);
   ArraySetAsSeries(maArray,true);

Obtendo os dados históricos de MqlRates usando a função "CopyRates". Seus parâmetros são:

symbol_name: para determinar o nome do símbolo, usaremos (_Symbol).
timeframe: para determinar o período, usaremos (_period).
start_pos: para determinar a posição inicial, usaremos (0).
count: para determinar a contagem de dados a copiar, usaremos (3).
rates_array[]: para determinar o array de destino a ser copiado, usaremos (priceArray).

Definindo a média móvel usando a função "iMA". Seus parâmetros:

symbol: para determinar o nome do símbolo.
period: para determinar o período.
ma_period: para determinar o período médio, será (50).
ma_shift: para determinar o deslocamento horizontal, será (0).
ma_method: para determinar o tipo de média móvel, será a EMA (Média Móvel Exponencial).
applied_price: para determinar o tipo de preço, será o preço de fechamento.

   int Data = CopyRates(_Symbol,_Period,0,3,priceArray);
   int maDef = iMA(_Symbol,_Period,50,0,MODE_EMA,PRICE_CLOSE);

Dados ordenados.

CopyBuffer(maDef,0,0,3,maArray);

Definição do preço de fechamento e o valor da MA.

double closingPrice = priceArray[0].close;
double maValue = NormalizeDouble(maArray[0],6);

Criação de duas variáveis booleanas para isBuy e isSell para evitar conflito entre os sinais de compra e venda da mesma vela.

   bool isBuy = false;
   bool isSell = false;

Condições da estratégia.

No caso de sinal de compra:

   if(closingPrice > maValue && fracDownValue != EMPTY_VALUE)
     {
      Comment("Buy","\n",
              "Current EMA: ",maValue,"\n",
              "Fractals Low around: ",fracDownValue);
      isBuy = true;
     }

No caso de sinal de venda:

   if(closingPrice < maValue && fracUpValue != EMPTY_VALUE)
     {
      Comment("Sell","\n",
              "Current EMA: ",maValue,"\n",
              "Fractals High around: ",fracUpValue);
      isSell = true;
     }

Depois de compilar este código e executá-lo, nós encontraremos o expert em anexo.

Frac com a MA anexado

Como nós podemos ver, o expert de Fractais com a MA está anexado ao gráfico no canto superior direito. Nós receberemos os sinais desejados da mesma forma que nos exemplos a seguir:

No caso de sinal de compra:

Frac com a MA - sinal de compra

Nós temos um comentário no gráfico com os seguintes valores:

Compra
EMA atual
Fractais de baixa em torno de: n

No caso de sinal de venda:

Frac com a MA - sinal de venda

Temos os seguintes valores:

Venda
EMA atual
Fractais de alta em torno de: n

3. Fractais com o Alligator

A seguir, o código completo para criar um sistema de negociação para a estratégia com o Alligator.

//+------------------------------------------------------------------+
//|                                      Fractals with Alligator.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()
  {
//creating arrays
   double fracUpArray[];
   double fracDownArray[];
   MqlRates priceArray[];
   double jawsArray[];
   double teethArray[];
   double lipsArray[];
//Sorting data
   ArraySetAsSeries(fracUpArray,true);
   ArraySetAsSeries(fracDownArray,true);
   ArraySetAsSeries(jawsArray,true);
   ArraySetAsSeries(teethArray,true);
   ArraySetAsSeries(lipsArray,true);
//define values
   int fracDef=iFractals(_Symbol,_Period);
   int Data = CopyRates(_Symbol,_Period,0,3,priceArray);
   int alligatorDef=iAlligator(_Symbol,_Period,13,8,8,5,5,3,MODE_SMMA,PRICE_MEDIAN);
//define data and store result
   CopyBuffer(fracDef,UPPER_LINE,2,1,fracUpArray);
   CopyBuffer(fracDef,LOWER_LINE,2,1,fracDownArray);
   CopyBuffer(alligatorDef,0,0,3,jawsArray);
   CopyBuffer(alligatorDef,1,0,3,teethArray);
   CopyBuffer(alligatorDef,2,0,3,lipsArray);
//get values
   double fracUpValue=NormalizeDouble(fracUpArray[0],5);
   double fracDownValue=NormalizeDouble(fracDownArray[0],5);
   double closingPrice = priceArray[0].close;
   double jawsValue=NormalizeDouble(jawsArray[0],5);
   double teethValue=NormalizeDouble(teethArray[0],5);
   double lipsValue=NormalizeDouble(lipsArray[0],5);
//creating bool variables to aviod buy ans sell signals at the same time
   bool isBuy = false;
   bool isSell = false;
//conditions of the strategy and comment on the chart
//in case of buy
   if(lipsValue>teethValue && lipsValue>jawsValue && teethValue>jawsValue
   && closingPrice > teethValue && fracDownValue != EMPTY_VALUE)
     {
      Comment("Buy","\n",
              "jawsValue = ",jawsValue,"\n",
              "teethValue = ",teethValue,"\n",
              "lipsValue = ",lipsValue,"\n",
              "Fractals Low around: ",fracDownValue);
      isBuy = true;
     }
//in case of sell
   if(lipsValue<teethValue && lipsValue<jawsValue && teethValue<jawsValue
   && closingPrice < teethValue && fracUpValue != EMPTY_VALUE)
     {
      Comment("Sell","\n",
              "jawsValue = ",jawsValue,"\n",
              "teethValue = ",teethValue,"\n",
              "lipsValue = ",lipsValue,"\n",
              "Fractals High around: ",fracUpValue);
      isSell = true;
     }
  }
//+------------------------------------------------------------------+

Diferenças neste código.

Cração dos três arrays dos componentes do Alligator.

   double jawsArray[];
   double teethArray[];
   double lipsArray[];

Ordenação dos dados desses arrays usando a função "ArraySetAsSeries".

   ArraySetAsSeries(jawsArray,true);
   ArraySetAsSeries(teethArray,true);
   ArraySetAsSeries(lipsArray,true);

Definição do Alligator usando a função "iAlligator". Seus parâmetros:

symbol: usaremos o (_Symbol) para ser aplicado ao símbolo atual.
period: usaremos (_Period) para ser aplicado ao tempo gráfico atual.
jaw_period: para determinar o período do cálculo das mandíbulas, usaremos (13).
jaw_shift: para determinar o deslocamento horizontal das mandíbulas, 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, usaremos (5).
lips_period: para determinar o período do cálculo dos lábios, usaremos (5).
lips_shift: para determinar o deslocamento horizontal dos lábios, usaremos (3).
ma_method: para determinar o tipo da média móvel, usaremos (MODE_SMA).
applied_price: para determinar o tipo de preço, usaremos (PRICE_MEDIAN).

int alligatorDef=iAlligator(_Symbol,_Period,13,8,8,5,5,3,MODE_SMMA,PRICE_MEDIAN);

Definição dos dados e armazenando os resultados usando a função "CopyBuffer". Seus parâmetros:

indicador_handle: para determinar o identificador do indicador, nós usaremos (alligatorDef).
buffer_num: para determinar o número do buffer do indicador, nós usaremos (0 para mandíbulas), (1 para dentes) e (2 para lábios).
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 (jawsArray, teethArray, lipsArray).

   CopyBuffer(alligatorDef,0,0,3,jawsArray);
   CopyBuffer(alligatorDef,1,0,3,teethArray);
   CopyBuffer(alligatorDef,2,0,3,lipsArray);

Obtenção dos valores dos componentes do Alligator.

   double jawsValue=NormalizeDouble(jawsArray[0],5);
   double teethValue=NormalizeDouble(teethArray[0],5);
   double lipsValue=NormalizeDouble(lipsArray[0],5);

Condições da estratégia:

No caso de sinal de compra:

   if(lipsValue>teethValue && lipsValue>jawsValue && teethValue>jawsValue
   && closingPrice > teethValue && fracDownValue != EMPTY_VALUE)
     {
      Comment("Buy","\n",
              "jawsValue = ",jawsValue,"\n",
              "teethValue = ",teethValue,"\n",
              "lipsValue = ",lipsValue,"\n",
              "Fractals Low around: ",fracDownValue);
      isBuy = true;
     }

No caso de sinal de venda:

   if(lipsValue<teethValue && lipsValue<jawsValue && teethValue<jawsValue
   && closingPrice < teethValue && fracUpValue != EMPTY_VALUE)
     {
      Comment("Sell","\n",
              "jawsValue = ",jawsValue,"\n",
              "teethValue = ",teethValue,"\n",
              "lipsValue = ",lipsValue,"\n",
              "Fractals High around: ",fracUpValue);
      isSell = true;
     }

Depois de compilar este código e executá-lo no gráfico desejado, nós encontraremos o expert anexado ao gráfico igual ao seguinte:

Frac com o Alligator anexado

Nós podemos obter os sinais desejados com base nessa estratégia depois de anexar esse expert ao gráfico da mesma forma que nós podemos ver no gráfico anterior no canto superior direito.

A seguir estão os exemplos de sinais gerados a partir do teste:

No caso de sinal de compra

Frac com o Alligator - sinal de compra

Como podemos ver, temos os seguintes valores como um sinal no gráfico anterior no canto superior esquerdo:

Compra
valor das mandíbulas
valor dos dentes
Valor dos lábios
Valor dos Fractais de baixa

Frac com o Alligator - sinal de venda

Temos os seguintes valores como um sinal no gráfico anterior:

Venda
valor das mandíbulas
valor dos dentes
Valor dos lábios
Valor dos Fractais de alta

Conclusão

O indicador técnico Fractais é uma ferramenta útil e eficaz na negociação, mesmo como uma ferramenta independente ou acompanhada por outro indicador técnico, pois ele fornece informações úteis como nós aprendemos neste artigo. Supõe-se que você tenha aprendido o que ele é, o que ele mede, como ele pode ser formado no gráfico através do método de cálculo e como inseri-lo para ser exibido na plataforma MetaTrader 5. Além disso, nós aprendemos como podemos usá-lo por meio das seguintes estratégias de negociação simples:

Fractais de alta e baixa: para detectar as altas e baixas do indicador Fractais e obter um sinal no gráfico.
Fractais com a MA: para obter os sinais de compra e venda com base nos sinais dos Fractais gerados de acordo com a posição dos preços e sua média móvel.
Fractais com o Alligator: para obter os sinais de compra e venda com base nos sinais dos Fractais de acordo com a posição dos preços e o indicador Alligator.

Nós aprendemos também como nós podemos criar um sistema de negociação com base em cada estratégia mencionada para obter os sinais automáticos no gráfico da MetaTrader 5, através do desenvolvimento dessas estratégias via MQL5. Espero que você tenha tentado aplicá-los sozinho para uma compreensão profunda e obter mais informações sobre o tópico deste artigo ou qualquer tópico relacionado para obter um benefício completo da leitura deste artigo.

É importante confirmar novamente que você deve testar qualquer estratégia antes de usá-la em sua conta real, pois não há nada adequado para todas as pessoas. Espero que você ache este artigo útil, entendendo o tópico dele e obtendo novas ideias que podem ser úteis para aprimorar a sua negociação. Se você quiser ler mais artigos semelhantes, leia meus outros artigos da série sobre como 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/11620

Arquivos anexados |

Baixar como ZIP

Simple_Fractals_System.mq5 (1.5 KB)

Fractals_highs_and_lows.mq5 (1.59 KB)

Fractals_with_MA.mq5 (2.09 KB)

Fractals_with_Alligator.mq5 (2.82 KB)

Aviso: Todos os direitos sobre esses materiais pertencem à MetaQuotes Ltd. É proibida a reimpressão total ou parcial.

Outros artigos do autor

Ir para discussão

Ciência de Dados e Aprendizado de Máquina (Parte 08): Agrupamento K-Means em MQL5

A mineração de dados é crucial para um cientista de dados e um trader porque, muitas vezes, os dados não são tão diretos quanto pensamos, o olho humano não consegue entender o padrão subjacente menor e as relações no conjunto de dados, talvez o algoritmo K-means pode nos ajudar com isso. Vamos descobrir...

Como desenvolver um sistema de negociação baseado no indicador Alligator

Neste artigo, completaremos nossa série sobre como projetar um sistema de negociação baseado no indicador técnico mais popular. Nós aprenderemos como criar um sistema de negociação baseado no indicador Alligator.

Ciência de dados e Aprendizado de Máquina (parte 09): O algoritmo K-vizinhos mais próximos (KNN)

Este é um algoritmo preguiçoso que não aprende com o conjunto de dados de treinamento, ele armazena o conjunto de dados e age imediatamente quando ele recebe uma nova amostra. Por mais simples que ele seja, ele é usado em uma variedade de aplicações do mundo real

Como trabalhar com linhas usando MQL5

Neste artigo, falaremos sobre como trabalhar com os gráficos de linhas mais importantes, como linhas de tendência, suporte e resistência, usando as ferramentas da linguagem MQL5.