Geração automática de linhas de suporte e resistência

22 fevereiro 2018, 12:01
Vladimir Mametov
0
3 304

Introdução

Neste artigo, examinaremos a construção automática linhas de suporte e resistência. A análise técnica de instrumentos Forex é uma parte importante da negociação, nos mercados financeiros. Por isso, a construção automática dessas linhas facilitará o trabalho de analistas financeiros e traders, e será uma oportunidade para acelerar a análise técnica. Além disso, você pode criar EAs com base no indicador aqui examinado.

Encontrando todos os máximos e mínimos locais

As linhas de suporte e resistência são construídas atravessando máximos e mínimos locais, em gráficos de preços. Para definir estes extremos, utilizaremos o conhecido indicador ZigZag. Nos seus parâmetros de entrada, podem-se definir as propriedades necessárias para as linhas de suporte e resistência.

A escala das linhas pode ser alterada por meio dos parâmetros do indicador ZigZag. Os mesmos parâmetros podem ser utilizados em diferentes timeframes. Isto permitir-nos-á obter os extremos necessários, para, em seguida, construir com base neles os níveis de suporte e resistência.

As ilustrações que se seguem mostram como muda a natureza dos picos ao alterar o timeframe. A primeira imagem é um gráfico de 30 minutos, enquanto a segunda, um de 4 horas.





Seleção dos extremos adequados para a construção de níveis

Nós vamos construir apenas as linhas de suporte e resistência que passam perto do preço atual, isto é, as que serão relevantes em termos de análise técnica, naquele momento em particular. Adicionalmente, para as linhas terem uma inclinação convergindo no preço, se a tendência for de baixa, usamos todos os extremos superiores ou iguais ao extremo anterior, se ela for de alta, empregamos todos os extremos inferiores ou iguais ao extremo anterior. Na primeira figura, eles podem ser os pontos 1-2-3-4-5-7, enquanto, na segunda, 1-2-3-6-7-8.

Já temos estabelecido os critérios de seleção dos extremos. Agora, examinemos sua realização como código. Nós o apresentaremos aqui apenas parcialmente para esclarecer pontos chave.

//+------------------------------------------------------------------+
struct trade_points               // Definimos a estrutura dos extremos
  {
   double            price;       // Preço
   int               pos;         // Localização, número da barra
   bool              hpoint;      // Se sim, trata-se do máximo
   bool              lpoint;      // Se sim, trata-se do mínimo
  };

Na função OnInit(), criamos o indicador do indicador ZigZag:

int OnInit()
  {

   ZZ_handle=iCustom(_Symbol,_Period,"ZigZag",ExtDepth,ExtDeviation,ExtBackstep);

   return(INIT_SUCCEEDED);
  }

Em seguida, encontrando alternadamente todos os extremos do Zigzag, na matriz, introduzimos as informações sobre eles:

double max=close[1];
   double min=close[1];
   int z=0;

   for(shift=0;shift<rates_total && !IsStopped();shift++)
     {
      CopyBuffer(ZZ_handle,0,shift,1,ZigzagBuffer);

      if(ZigzagBuffer[0]>0)
        {

         if(ZigzagBuffer[0]>=max && ZigzagBuffer[0]==high[shift])
           {
            ArrayResize(mass,z+1);
            max=ZigzagBuffer[0];
            mass[z].price=ZigzagBuffer[0];
            mass[z].pos=shift;
            mass[z].hpoint=true;
            mass[z].lpoint=false;
            z++;
           }

         if(ZigzagBuffer[0]<=min && ZigzagBuffer[0]==low[shift])
           {
            ArrayResize(mass,z+1);
            min=ZigzagBuffer[0];
            mass[z].price=ZigzagBuffer[0];
            mass[z].pos=shift;
            mass[z].lpoint=true;
            mass[z].hpoint=false;
            z++;
           }

        }
     }

Definição de critérios para a construção de linhas de tendência

Agora, como a matriz com picos está formada, podemos construir as linhas de suporte e resistência que necessitamos. A definição dos principais critérios para a construção das linhas é explicada abaixo.

A partir do ponto 1, podemos construir linhas que atravessam qualquer um dos seguintes pontos. Mas nem todas essas linhas podem ser consideradas linhas de suporte e resistência. Talvez sejam irrelevantes nesse momento e, portanto, não precisaremos delas no gráfico. Nós preferimos que o gráfico esteja livre de construções desnecessárias, por isso, pesquisamos e filtramos as linhas de mais.

Assumimos que A é o ponto de partida da linha, B - o segundo pico, e, S - o ponto perto da última barra.

Os critérios podem ser muitos, em situações diferentes eles variam. Aqui, consideramos apenas os principais. No futuro, quem estiver interessado pode melhorar esse indicador a seu exclusivo critério. Assim, os principais critérios são:

  1. Correlação entre as distâncias de AB e BC
  2. O número de vezes que o preço cruza o segmento AB
  3. O número de vezes que o preço cruza o segmento BC
  4. Distância entre C e o preço atual
  5. Comprimento máximo e mínimo da linha
  6. Inclinação da linha
  7. Permanência do preço acima ou abaixo da linha de resistência

Consideramos estes critérios em mais detalhes, a fim de entender melhor a configuração dos parâmetros de entrada.

  1. Para cumprir com as proporções aceitáveis, podem-se utilizar os coeficientes de Fibonacci e tomar uma correlação mínima admissível de não menos do que 0,25 ou 0,382. De acordo com este critério, a correlação entre os comprimentos deve corresponder à condição AB/AC>=02.25 (0,382) e a BC/AC>=02.25 (0,382). Por conveniência, este valor pode ser definido nas configurações de entrada.
  2. Dependendo do número de vezes que o preço cruza a linha AB, também é necessário filtrar cuidadosamente todas as linhas existentes. Há muitas opções sobre como realizar essa verificação. Podem-se considerar apenas as barras que se fecharam após o rompimento de dada linha, ou, pode-se considerar o rompimento segundo os preços High ou Low. O segundo critério desta verificação é o número de barras que atravessa este segmento da linha. Estes parâmetros também estão nas configurações de entrada.
  3. A importância da linha se pode julgar pelo número de rompimentos (e sua natureza) e pela posição do preço atual em relação ao segmento BC. Todos esses critérios podem ser utilizados para tanto formar uma linha quanto criar estratégias de negociação, ao desenvolver EAs. Neste indicador, nós vamos mostrar apenas as linhas que ainda não tenham atravessado dado segmento.
  4. Em primeiro lugar, a distância entre o preço atual e a linha pode ser filtrada dependendo de se esta linha é relevante ou não, atualmente. Por exemplo, podem-se traçar só linhas cuja distância é inferior a 50 - 100 pontos.
  5. Neste caso, o comprimento mínimo da linha é determinado pelo parâmetro de entrada do ZigZag, mas este parâmetro também pode ser controlado, se necessário. No indicador, serão verificados os comprimentos mínimos dos segmentos AB e BC.
  6. Como as linhas de suporte são mais significativa, pelo fato de abrirem posições, o indicador construirá, para a linha de tendência ascendente, linhas com uma inclinação zero ou positiva, enquanto, para a descendente - com uma inclinação zero ou negativa.
  7. Podemos usar as linhas de duas maneiras. A primeira seria considerando apenas as linhas de que não foram quebradas e operar com a tendência. A segunda consistiria em utilizar apenas o rompimento das linhas de tendência para abrir trades na direção oposta. Ambos os tipos de linhas são importantes, por isso eles refletidos no indicador.

Abaixo é mostrada uma parte do código em que são formadas as linhas de resistência das tendências de baixo.

// Definição de linhas satisfaz nossos critérios, a seguir, preenchimento da matriz para a tendência de baixa.

   for(j=z-1; j>=0; j--)
     {
      if(mass[j].hpoint)
         for(i=j-1; i>=0; i--)
           {
            if(mass[i].hpoint)
               if(i<j)
                 {

                  a=mass[j].pos;
                  b=mass[i].pos;

                  double ratio=double((a-b)*100/a);       // Determinamos a correlação entre o comprimento do segmento AB e comprimento total AC

                  if(ratio>fibo && ratio<(100-fibo))      // Determinamos se é satisfeito o critério №1, relação entre as áreas AB e BC
                     if(b>Min_dist &&(a-b)>Min_dist)      // Determinamos se é satisfeito o critério №5, comprimento mínimo dos trechos AB e BC
                       {

                        ax=mass[j].price;
                        bx=mass[i].price;

                        coef=(ax-bx)/(a-b);

                        price=close[1];

                        deviation=(ax+coef*bx)-price;

                        cross_bc=0;
                        cross_ab=0;


                        if(MathAbs(deviation)<tolerance*_Point)   //  Determinamos se é satisfeito o critério №4 (distância entre C e o preço de fechamento da barra anterior)
                          {

                           // Número de cruzamentos entre os pontos a e b 
                           for(int n=a; n>b; n--)
                              if((close[n]-(ax+coef*(b-n)))>0)
                                 cross_ab++;
                           // Número de cruzamentos de b até ao ponto final  
                           for(int n=b-1; n>=0; n--)
                              if(close[n]>(bx+coef*(b-n)) && close[n+1]<(bx+coef*(b-n+1)))
                                 cross_bc++;

                           if(cross_bc<=Intersection_bc && cross_bc<=Intersection_ab)// Determinamos se são satisfeitos os critérios №2 e №3
                             {
                              // Preenchimento de matrizes para a tendência de baixa
                              ArrayResize(DownTrend,y+1);
                              DownTrend[y].a=a;
                              DownTrend[y].b=b;
                              DownTrend[y].ax=ax;
                              DownTrend[y].bx=bx;
                              DownTrend[y].dst=MathAbs(deviation);
                              DownTrend[y].coef=coef;

                              y++;

                             }
                          }
                       }
                 }
           }
     }

// No gráfico, exibimos as linhas descendentes de acordo com a matriz obtida

   for(j=0; j<ArraySize(DownTrend); j++)
     {

      a=DownTrend[j].a;
      b=DownTrend[j].b;
      ax=DownTrend[j].ax;
      bx=DownTrend[j].bx;
      coef=DownTrend[j].coef;

      if(a>0 && b>0 && MathAbs(a-b)>0)
        {
if(a>0 && b>0 && MathAbs(a-b)>0)
        {
         //--- criamos as linhas de tendência 
         TrendCreate(0,"DownTrend "+string(j),0,time[a],ax,time[b],bx,DColor,DStyle,DWidth,DBack,DSelection,DRayLeft,DRayRight,DHidden,DZOrder);
         ChartRedraw();
        }
     }

Exemplos de construção do indicador:


Uso de linhas de suporte e resistência na negociação

Relativamente aos níveis de suporte e resistência, o princípio básico do tranding consiste em comprar perto da linha de suporte, na tendência ascendente (e vender na descendente) ou durante a fase de correção. Usam-se alguns modelos gráficos (padrões).

Este tipo de estratégia de negociação permite tirar partido do movimento da tendência, mesmo quando o instrumento está numa fase de correção, ou quando o preço faz com que se forme certa figura. A tendência ajuda a determinar a direção em que você deseja abrir o trade. Por exemplo, se a tendência atual for descendente e, em seguida, mudar para uma fase de correção, é preferível abrir o trade de venda perto da linha de resistência, em vez de comprar no nível de suporte. O fato de a tendência ser descendente significa que os trades de venda são mais propensos a ter sucesso do que uma transação de compra. Se a tendência for ascendente e, em seguida, for formado um triângulo, será melhor abrir o trade de compra perto da linha de suporte desse triângulo.

Pode ser rentável abrir trades perto das linhas de suporte e resistência de acordo com a tendência, mas, muitas vezes, o preço rompe esses níveis. Por isso, é necessário esperar a confirmação da relevância do nível do instrumento financeiro em questão. Antes de comprar ou vender na linha, deve-se esperar a consolidação do preço ao lado dela. Alternativamente, pode-se esperar uma recuperação do nível de preços, e abrir o trade só depois disso.

Após abrir um trade de compra a partir da linha de suporte, é recomendável esperar a consolidação do preço ao lado dela, e, só depois, abrir uma ordem de compra, após o preço quebrar para acima o High desta zona de consolidação. Isso não só torna possível garantir que o nível realmente influencia o preço, mas também que este último se moverá na direção certa (para cima) a partir deste nível. Isso é exatamente o que precisamos para comprar. Algo semelhante acontece quado se abrem trades de venda a partir da linha de resistência, por isso, é necessário esperar uma consolidação perto da zona de resistência, e, só então, abrir o trade quando o preço cai abaixo do Low desta zona de consolidação.

Ao abrir um trade, é necessário prever com antecedência as condições para seu encerramento. Ao abrir um trade de compra a partir da linha de suporte, convém fechá-lo antes de o preço atingir a linha de resistência, com força. Algo semelhante acontece na abertura da trades de venda. Também é possível fechar trades nos níveis de suporte e resistência secundários. Ao comprar na linha de suporte, é preciso vender no nível de resistência dentro do canal de tendência ascendente. Mas também é possível tentar obter um maior lucro permitindo o preço quebrar o nível. Por exemplo, ao comprar a partir do nível de suporte no triângulo (com uma tendência de alta geral), pode-se manter a posição até o preço romper o triângulo e não continuar a subir. Depois disso, pode-se sair do trade, na próxima linha de resistência.

EA baseado no indicador

Abaixo está um EA com as seguintes função:

  • StopLoss e TakeProfit
  • Número máximo de ordens Buy/Sell
  • Trailing Stop
  • Função de break-even
  • Fechamento de trades opostos de acordo com os sinais do indicador
  • 4 filtros HTF (MACD, RSI, WPR, MA) com capacidade de seleção

O Advisor trabalha diretamente com as linhas de tendência criadas pelo indicador, por isso, para ele funcionar em tempo real, é preciso adicionar um indicador no gráfico com o EA estabelecido. Configurações que tenham a ver com o indicador devem ser definidas nele. No EA também existem configurações de indicador, mas elas são usadas ​​apenas durante o teste. Para se poder testar o EA, no código é criado um identificador para o indicador, identificador esse que é definido na inicialização do advisor.

Há 3 modos de trabalho com o EA:

  • from level - negociação com os preços refletidos sobre a linha de tendência. O trade é aberto quando: o preço mínimo ou máximo da barra atravessa o nível, o preço de fechamento não rompe a linha de tendência atual, bem como o preço da próxima barra está fechada sem ter quebrado a linha. Verifica-se se o preço rompeu a linha após tê-la tocado.
  • level breakdown - negociação quando o preço quebra a linha de tendência. O trade é aberto quando: o preço mínimo ou máximo da barra atravessa o nível, o preço de fechamento não rompe a linha de tendência atual, bem como o candle da próxima barra está fechado após quebrar a linha de tendência.
  • all - usam-se ambos os modos mencionados acima.

Abaixo é apresentada a função no código onde são formados os sinais de compra e venda:

//+------------------------------------------------------------------+
int signal()
  {
   int res=0;

   int macd=0;
   int rsi=0;
   int wpr=0;
   int ma=0;

   if(Use_macd==true)macd=macdS();
   if(Use_rsi==true)rsi=rsiS();
   if(Use_wpr==true)wpr=wprS();
   if(Use_ma==true)ma=maS();

   CopyOpen(NULL,0,1,3,O);
   CopyHigh(NULL,0,1,3,H);
   CopyLow(NULL,0,1,3,L);
   CopyClose(NULL,0,1,3,C);

   Signals=0;
   for(int i=0;i<ObjectsTotal(0,0,OBJ_TREND);i++)
     {
      string sName=ObjectName(0,i,0,OBJ_TREND);
      if(StringFind(sName,"UpTrend")==0 || StringFind(sName,"DownTrend")==0)
        {
         ax=ObjectGetDouble(0,sName,OBJPROP_PRICE,0);
         bx=ObjectGetDouble(0,sName,OBJPROP_PRICE,1);
         p1=(int)ObjectGetInteger(0,sName,OBJPROP_TIME,0);
         p2=(int)ObjectGetInteger(0,sName,OBJPROP_TIME,1);
         a=iBarShift(p1);
         b=iBarShift(p2);
         kkk=(bx-ax)/(a-b);
         lvl=bx+kkk*b;
         plvl=bx+kkk*(b-1);

         if(mode==0 || mode==2)
           {
            if(StringFind(sName,"UpTrend")==0 && L[1]<=plvl && C[1]>plvl && C[0]>lvl)Signals=1;
            if(StringFind(sName,"DownTrend")==0 && H[1]>=plvl && C[1]<plvl && C[0]<lvl)Signals=2;
           }

         if(mode==1 || mode==2)
           {
            if(StringFind(sName,"UpTrend")==0 && L[1]<=plvl && C[1]>plvl && C[0]<lvl)Signals=2;
            if(StringFind(sName,"DownTrend")==0 && H[1]>=plvl && C[1]<plvl && C[0]>lvl)Signals=1;
           }
        }
     }

   if(Signals==1
      &&(macd==1 || Use_macd==false)
      && (rsi==1 || Use_rsi==false)
      && (wpr==1 || Use_wpr==false)
      && (ma==1 || Use_ma==false))res=1;

   if(Signals==2
      &&(macd==2 || Use_macd==false)
      && (rsi==2 || Use_rsi==false)
      && (wpr==2 || Use_wpr==false)
      && (ma==2 || Use_ma==false))res=2;

   return(res);
  }
//+------------------------------------------------------------------+

Durante o teste, foi possível determinar que é menos rentável operar com a recuperação a partir da linha do que negociar com o rompimento de níveis.

Abaixo estão os gráficos de teste de três modos com os seguintes parâmetros de entrada:

input string s="-------------------------------------------"; // Main settings
input int Magic=12345;
input double LotSize=0.1;
input int Slippage=30; //Slippage, points 
input int StopLoss=0; //StopLoss, points 
input int TakeProfit=0; //TakeProfit, points
input int TrailingStart=0; //Trailing Start, points     
input int TrailingStop= 0; //Trailing Stop, points     
input int TrailingStep= 0; //Trailing Step, points
input int SL_prof=0; //Start BE, points
input int SL_lev=0; //BE level, points
input int Buy_max=1; //Max Buy orders
input int Sell_max=1; //Max Sell orders
input bool Sig_close=true; //Close counter transactions
input tip mode=0;
input string s0="-------------------------------------------"; // Indicators settings
input int _ExtDepth=12;
input int _ExtDeviation=5;
input int _ExtBackstep=3;

input int _Min_dist=0;                                  // Minimum distance
input int _fibo=30;                                     // Fibo ratio
input int _tolerance=200;                               // Tolerance
input int _Intersection_ab=1;                           // The allowed number of intersections from point a to point b
input int _Intersection_bc=1;                           // The allowed number of intersections from point b to point c

input string s1="-------------------------------------------";     // MACD settings
input ENUM_TIMEFRAMES macd_tf=PERIOD_CURRENT;                      // period
input int fast_ema_period=12;                                      // period of fast ma 
input int slow_ema_period=26;                                      // period of slow ma 
input int signal_period=9;                                         // period of averaging of difference 
input ENUM_APPLIED_PRICE applied_price=PRICE_CLOSE;                // type of price 

input string s2="-------------------------------------------";     // RSI settings
input ENUM_TIMEFRAMES rsi_tf=PERIOD_CURRENT;                       // period
input int rsi_period=14;                                           // period 
input ENUM_APPLIED_PRICE rsi_applied_price=PRICE_CLOSE;            // type of price
input double rsi_max_s=100;                                        // max price for Sell
input double rsi_min_s=70;                                         // min price for Sell
input double rsi_max_b=30;                                         // max price for Buy
input double rsi_min_b=0;                                          // min price for Buy

input string s3="-------------------------------------------";     // WPR settings
input ENUM_TIMEFRAMES wpr_tf=PERIOD_CURRENT;                       // period
input int calc_period=14;                                          // period  
input double wpr_max_s=0;                                          // max price for Sell
input double wpr_min_s=-20;                                        // min price for Sell
input double wpr_max_b=-80;                                        // max price for Buy
input double wpr_min_b=-100;                                       // min price for Buy

input string s4="-------------------------------------------";     // MA settings
input ENUM_TIMEFRAMES ma_tf=PERIOD_CURRENT;                        // period
input int ma_period=10;                                            // period of MA 
input int ma_shift=0;                                              // shift 
input ENUM_MA_METHOD ma_method=MODE_SMA;                           // type of smoothing 
input ENUM_APPLIED_PRICE ma_applied_price=PRICE_CLOSE;             // type of price 

input bool Use_macd=true;                                          // Use MACD as a filter
input bool Use_rsi=false;                                          // Use RSI as a filter
input bool Use_wpr=false;                                          // Use WPR as a filter
input bool Use_ma=false;                                           // Use MA as a filter

input int sbar=1;                                                  // Signal bar 0-current, 1-close

Durante o teste, foi aberto apenas um trade de 0,1 lotes, numa só direção. Com o sinal contrário, foi fechado o trade atual e aberto seu oposto. Foi usado o filtro do indicador MACD, neste caso, trades de compra foram abertos quando os valores do indicador eram inferiores a zero, enquanto, de venda - superiores a zero. O teste foi realizado num intervalo de tempo de 1 hora no EURUSD para 2015-2017.

Modo from level:


Modo level breakdown:

Abaixo estão os resultados do teste com as configurações padrão em vários pares de moedas.

Aqui, vê-se que os bons resultados só são mostrados no pares EURUSD e USDCHF. Isto é principalmente devido ao fato de que nem todas as linhas devem ser consideradas na negociação. Adicionalmente, é preciso levar em conta outros fatores listados anteriormente neste artigo.

Além disso, é necessário se lembrar sobre o impacto da análise fundamental, bem como o fato de as linhas de suporte/resistência, muitas vezes, ocorrerem após a publicação de notícias importantes.

Por isso, pode-se adiciona um filtro de notícias ao EA e, em seguida, testar o funcionamento apenas quando publicadas notícias ou proibido o trabalho após liberadas notícias. Como alternativa, este Advisor pode ser usado nos gráficos Renko. 

Otimização

Na minha opinião, originalmente, os primeiros sete parâmetros foram estabelecidos de forma ideal, no EA, portanto, eu não fiz sua posterior otimização. Mas os parâmetros do indicador de ZigZag, por sua vez, são definidos por padrão, e não nos serviam como estavam. Após a otimização, foi possível confirmar que, para todas as moedas previamente testadas, os seguintes parâmetros são os mais adequados:

  • _ExtDepth=24;
  • _ExtDeviation=55;
  • _ExtBackstep=9;

Durante a otimização, para abertura de trades, foi definido qual o modo de trabalho era mais adequado para um instrumento financeiro específico, bem como quanto afeta o resultado ao usar filtro. Só o indicador MACD foi usado como filtro. Mas, pode-se tentar trabalhar com quaisquer outros indicadores em diferentes intervalos de tempo.

A função de fechamento usando o sinal oposto foi utilizada para fechar tanto trades lucrativos como desfavoráveis. As funções de break-even e take-profit foram utilizadas para fixar o lucro e obter os melhores resultados. Foi durante o teste que se definiram os parâmetros ótimos, para cada moeda segundo estas funções.

Não foi usado stop-loss para fixar perdas, mas os trades desfavoráveis foram fechados apenas pelo sinal oposto.

O processo de otimização é exibido na tabela. Os testes foram realizados com um lote de 0,1, para 2017. Além disso, o número de trades de compra e venda abertos aumento até 10, todos os outros parâmetros foram definidos por padrão.

 Símbolo Modo
  Filtro MACD TakeProfit
Start BE
Lucro
 Profit Factor: Recovery Factor:
 Max DD,%
 Total Trades: Profit Trades,% 
EURUSD
level breakdown
false
0
25
117.20
1.88
1.65
0.69
79
73.42
USDCHF
level breakdown false 20
10
135.24
1.31
1.12
1.03
482
72.41
GBPCHF
from level
true
20
10
91.56
1.39
0.51
1.58
246
91.06
AUDUSD
level breakdown false 20
10
139.20
1.39
1.66
0.79
485
71.96
AUDCAD
level breakdown true 25
5
117.51
1.94
1.06
0.57
246
84.96
EURJPY
level breakdown false 20
5
128.90
1.60
0.98
1.26
341
78.89
GBPUSD
from level false 100
0
102.1
1.20
1.32
0.58
274
52.92
USDJPY
from level false 30
0
147.75
1.56
0.79
1.73
348
79.89
EURGBP
from level true 20
5
124.45
1.39
1.14
1.03
341
78.01
EURCHF
from level true 20
5
141.08
2.07
1.88
0.68
367
63.22
USDCAD
level breakdown false
100
25
142.57
1.46
0.45
1.22
248
78.87
NZDUSD
from level false 0
25
270.50
1.37
1.04
2.37
616
62.11
GBPJPY
level breakdown true 150
20
163.62
2.56
1.10
1.41
103
68.25

Fim do artigo

O artigo mostrou o princípio básico de construção automática de linhas de suporte e resistência. Com base nele, foi criado um EA e feita a otimização de parâmetros de entrada em 13 instrumentos financeiros. É necessário selecionar individualmente os parâmetros ideais do instrumento financeiro, a fim de obter os melhores resultados. Foi criado um EA com várias funções básicas e 4 filtros HTF, para encontrar os parâmetros ideais, automatizar a negociação e verificar o funcionamento das linas de suporte e resistência. No futuro, o indicador e o EA podem ser expandidos e atualizados, dependendo das necessidades específicas de cada trader.

Graças aos resultados do trabalho, foi possível determinar que é menos rentável operar com a recuperação do que com o rompimento de níveis. Isto sugere que a natureza do movimento de cada instrumento financeiro é diferente e, portanto, eles precisam de uma abordagem individual.


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

Arquivos anexados |
TrendlinesEA.mq5 (46.56 KB)
Trendlines.mq5 (30.79 KB)
Testador de estratégia personalizada com base em cálculos matemáticos rápido Testador de estratégia personalizada com base em cálculos matemáticos rápido

O artigo descreve como criar um testador de estratégias personalizado e um analisador de corridas de otimização próprio. Depois de lê-lo, você vai entender como funciona o modo de cálculos matemáticos e o mecanismo de quadros, como preparar e fazer upload de seus próprios dados para cálculos e usar algoritmos eficientes para comprimi-los. Além disso, este artigo será de interesse para quem deseje saber maneiras de armazenar informações personalizadas num EA.

Como reduzir os riscos trader Como reduzir os riscos trader

A negociação nos mercados financeiros está associada a um conjunto de riscos que deve ser considerado nos algoritmos dos sistemas de negociação. A redução desses riscos é uma tarefa importante, quando se quer tirar lucro da negociação.

LifeHack para traders: preparemos "fast-food" de indicadores LifeHack para traders: preparemos "fast-food" de indicadores

Se você estiver mudando para MQL5 agora, você vai precisar deste artigo, porque, por um lado, o acesso aos dados dos indicadores e às séries é realizado na nossa conhecida linguagem MQL4, por outro lado, toda a realização é escrita em MQL5. Todas as funções são o mais claras quanto possível e são perfeitamente adequadas para a depuração passo a passo.

O padrão Rompimento de Canal O padrão Rompimento de Canal

As tendências de preços formam canais de preços que podem ser observados nos gráficos dos instrumentos financeiros. O rompimento do canal atual é um forte sinal de reversão de tendência. Neste artigo, eu sugiro uma maneira de automatizar o processo de encontrar esses sinais e ver se o padrão de rompimento de canal pode ser usado para criar uma estratégia de negociação.