Métodos para medir a velocidade do movimento de preços

22 julho 2019, 08:18
Alexander Fedosov
0
2 068

Sumário

Introdução

Existem diferentes abordagens para estudar e analisar o mercado, mas, há dois principais, nomeadamente a técnica e a fundamental. No primeiro caso, acontece a coleta, o processamento e o estudo de quaisquer dados numéricos e de características relacionadas ao mercado: preços, volumes e assim por diante. No segundo caso, acorre a análise de eventos e de notícias que, por sua vez, afetam direta ou indiretamente os mercados. No caso da análise fundamental há questão principal é interpretar um evento em relação ao seu impacto no mercado. Tal interpretação pode ser influenciada pelas opiniões e expectativas do profissional. Pelo contrário, no caso da análise técnica, os dados geralmente não dão origem a várias interpretações. No entanto, o fator humano está presente na avaliação dos resultados da análise técnica.


Problema de percepção

Ao falarmos sobre a análise técnica dos mercados, queremos dizer o uso de qualquer sistema de avaliação tomado dos diversos campos das ciências exatas, seja matemática ou física. Quanto à matemática, é óbvio, pois na análise técnica é necessária sua aplicação. Já o uso dos diversos fenômenos físicos em relação aos mercados é mais interessante. Por essa razão, nesse artigo, consideraremos a velocidade, um fenômeno físico bem conhecido. Para os mercados de moedas e outros, em qualquer gráfico, especialmente durante períodos de alta volatilidade, pode ser vista a olho nu não só a direção da mudança do preço, mas também a velocidade com que isso acontece. Qualquer um pode estudar visualmente o gráfico e avaliar se o preço mudará rapidamente ou não. Mas chegar a uma conclusão unânime sobre a velocidade do movimento com apenas uma observação não será possível devido à diferença na percepção das pessoas.

Como exemplo simples da vida real, imagine o engano visual em que um pequeno veículo aparentemente se move a uma velocidade mais lenta, enquanto um grande caminhão parece se mover a uma maior velocidade. Essa questão é resolvida por medidores de velocidade mostrando tudo em números. Assim, os valores numéricos são absolutamente os mesmos para qualquer pessoa.

Métodos para medir a velocidade do movimento de preços

Antes de considerarmos as diferentes abordagens para medir a velocidade do movimento de preços e sua avaliação, lembremos o que é velocidade.

Definição da velocidade segundo Wikipedia:

"Na física, velocidade relaciona a variação da posição no espaço em relação ao tempo, ou seja, qual a distância percorrida por um corpo num determinado intervalo temporal." 

Como aplicar essa característica aos mercados de moedas? A maneira mais simples é substituir um objeto por um preço e definir o tempo, dentro do qual é formado um candle ou uma barra, como um sistema de referência. Do ponto de vista do gráfico de preços, é assim:

Fig.1 Exibindo o preço na forma de um candle japonês no período gráfico horário.

Nesse caso, abaixo é mostrada uma simples medição de velocidade:

Velocidade média = (Preço de fechamento - Preço de abertura) / Hora

Observações e conclusões que podemos retirar sobre o movimento de preços ao longo do tempo:

  • Determinamos o número médio de pontos que o preço percorre por hora. No entanto, a medição ocorre dentro de um candle só e não obtemos uma imagem geral da tendência nesse período.
  • Porém, se convertermos a velocidade de pontos por hora em pontos por minuto, 5 minutos, etc, obtemos dados mais valiosos sobre o movimento de preços dentro desse candle horário.
  • Portanto, os dois passos a seguir são óbvios: determinar a velocidade em períodos gráficos mais pequenos é mais conveniente do que em os maiores. Se você medir a velocidade média no período gráfico atual, medindo o movimento do preço, faça-o considerando vários candles.
Finalmente, o mais importante ao medir a velocidade dessa forma tão simples é que ela não fornece dados em profundidade sobre a dinâmica de preços dentro do candle, exibindo apenas o resultado médio final. Por exemplo, conhecendo a velocidade média de um candle horário, somos incapazes de definir que o preço inicialmente era alto e diminuiu consideravelmente no final da hora.

Para maior clareza, vou dar um exemplo que descreve perfeitamente as teses mencionadas acima. A figura 2 mostra o candle horário e abaixo é calculada sua velocidade média por minuto com a ajuda do indicador Average Speed. Nesse caso, é igual a 2,53 pontos por minuto.

Fig. 2 Calculando a velocidade média do par EURUSD no período gráfico horário

Agora vamos dar uma olhada no mesmo candle no período gráfico de 15 minutos.


Fig. 3 Calculando a velocidade média do par EURUSD no período gráfico de 15 minutos

A Fig. 3 mostra que o movimento foi muito forte nos primeiros 15 minutos da hora selecionada (Average speed foi de 6,93), diminuindo significativamente depois disso. É claro que, se somarmos todos os 4 valores da velocidade média, obtemos os mesmos 2,53 pontos por minuto a partir do período gráfico horário. Assim, após dividir o candle em componentes nos permite descobrir muitos dados sobre sua dinâmica.

Depois de dividir esse período de tempo em intervalos de minutos, veremos uma imagem ainda mais detalhada.

Fig. 4 Calculando a velocidade média para o par de moedas EURUSD do período gráfico de minuto

Há ainda outro método de medição ao considerar opções para calcular a velocidade de movimento em pontos para o período gráfico M1.

Envolve a velocidade instantânea do preço (atual). Por um lado, seus valores são sempre tão relevantes quanto possível. Por outro lado, um exemplo de indicador que funciona com as alterações no preço no nível do tick é assim:

Fig.5 Indicador da velocidade instantânea do movimento do preço

Aparentemente, a avaliação de dados caóticos desse tipo (embora relevantes) para seu uso subsequente no mercado de moedas é uma tarefa bastante desafiadora.

Como sabemos, a esmagadora maioria dos indicadores são preços derivados ou seus analisadores. Esses são alguns indicadores bem conhecidos que trabalham com a velocidade do preço:

  • O indicador Momentum mede quanto muda de preço durante um certo período. Valores de Momentum extremamente altos ou baixos sugerem a continuação da tendência atual. Isso significa que grandes desvios do indicador representam a alta velocidade atual do preço em uma determinada direção.
  • Indicador de tendência ADX. O Índice de Movimento Direcional Médio (Average Directional Movement Index) mostra a força da tendência atual. Na verdade, ele exibe a velocidade média atual.

Criando estratégias de negociação baseadas em métodos de medição

Por essa razão, o propósito de testar várias medidas da velocidade de movimento de preços será basicamente dividido em três grupos:

  • Medição padrão direta da velocidade média como uma relação de pontos passados por unidade de tempo.
  • Medição da velocidade usando os ticks como uma relação entre o número de pontos transcorridos e o número de ticks.
  • Medição de velocidade indireta usando indicadores de tendência e outros.

Estratégia de negociação №1

Para testar o primeiro método baseado na medição de velocidade como um número de pontos transcorridos por unidade de tempo usando o indicador Average Speed, à estratégia testada deve ser adicionado um filtro que mostre a direção da tendência, uma vez que o indicador mostra o número de pontos por unidade de tempo, independentemente da direção da tendência.

Decidi usar o indicador Coordinated ADX and MACD (CAM) como esse filtro. A estratégia de negociação ficará assim:

Parâmetros Descrição
Indicador utilizado Average Speed
Indicador utilizado Coordinated ADX and MACD (CAM) 
Timeframe Qualquer um 
Condições de compra Candle colorido em verde, enquanto o valor Average Speed está acima do limite (predefinido nos parâmetros)
Condições de venda Candle colorido em vermelho, enquanto o valor Average Speed está acima do limite (predefinido nos parâmetros)
Condições de saída   Take-Profit/Stop-Loss

A figura 6 abaixo mostra a situação ao abrir posições de compra e venda:

Fig.6 Condições de entrada da estratégia de negociação.

A implementação dessa estratégia é a seguinte:

//+------------------------------------------------------------------+
//| Parâmetros de entrada do Expert Advisor                          |
//+------------------------------------------------------------------+
input string               InpEaComment         =  "Strategy #1"; // EA Comment
input int                  InpMagicNum          =  1111;          // Magic number
input double               InpLot               =  0.1;           // Lots
input uint                 InpStopLoss          =  400;           // StopLoss in points
input uint                 InpTakeProfit        =  500;           // TakeProfit in points
input uint                 InpSlippage          =  0;             // Slippage in points
input ENUM_TIMEFRAMES      InpInd_Timeframe     =  PERIOD_H1;     // Timeframe for the calculation
//--- Parâmetros do indicador Average Speed
input int                  InpBars              =  1;             // Days
input ENUM_APPLIED_PRICE   InpPrice             =  PRICE_CLOSE;   // Applied price
input double               InpTrendLev          =  2;             // Trend Level
//--- Parâmetros do indicador CAM
input uint                 InpPeriodADX         =  10;            // ADX period
input uint                 InpPeriodFast        =  12;            // MACD Fast EMA period
input uint                 InpPeriodSlow        =  26;            // MACD Slow EMA period
//---
CEngine        engine;
CTrade         trade;
//--- Declaração de variáveis e de identificadores de indicadores
double         lot;
ulong          magic_number;
uint           stoploss;
uint           takeprofit;
uint           slippage;
int            InpInd_Handle1,InpInd_Handle2;
double         avr_speed[],cam_up[],cam_dn[];
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- Verificações iniciais
   if(!TerminalInfoInteger(TERMINAL_TRADE_ALLOWED))
     {
      Print(InpEaComment,": Trade is not allowed!");
      return(INIT_FAILED);
     }
   if(!TerminalInfoInteger(TERMINAL_CONNECTED))
     {
      Print(InpEaComment,": No Connection!");
      return(INIT_FAILED);
     }
//--- Obtendo o identificador do indicador Average Speed
   InpInd_Handle1=iCustom(Symbol(),InpInd_Timeframe,"Speed Price\\average_speed",
                          InpBars,
                          InpPrice
                          );
   if(InpInd_Handle1==INVALID_HANDLE)
     {
      Print(InpEaComment,": Failed to get average_speed handle");
      Print("Handle = ",InpInd_Handle1,"  error = ",GetLastError());
      return(INIT_FAILED);
     }
//--- Obtendo o identificador do indicador CAM
   InpInd_Handle2=iCustom(Symbol(),InpInd_Timeframe,"Speed Price\\CAM",
                          InpPeriodADX,
                          InpPeriodFast,
                          InpPeriodSlow
                          );
   if(InpInd_Handle2==INVALID_HANDLE)
     {
      Print(InpEaComment,": Failed to get average_speed handle");
      Print("Handle = ",InpInd_Handle2,"  error = ",GetLastError());
      return(INIT_FAILED);
     }
//---
   ArrayInitialize(avr_speed,0.0);
   ArrayInitialize(cam_up,0.0);
   ArrayInitialize(cam_dn,0.0);
   ArraySetAsSeries(avr_speed,true);
   ArraySetAsSeries(cam_up,true);
   ArraySetAsSeries(cam_dn,true);
//--- setting trade parameters
   lot=NormalizeLot(Symbol(),fmax(InpLot,MinimumLots(Symbol())));
   magic_number=InpMagicNum;
   stoploss=InpStopLoss;
   takeprofit=InpTakeProfit;
   slippage=InpSlippage;
//--- 
   trade.SetDeviationInPoints(slippage);
   trade.SetExpertMagicNumber(magic_number);
   trade.SetTypeFillingBySymbol(Symbol());
   trade.SetMarginMode();
   trade.LogLevel(LOG_LEVEL_NO);
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Timer function                                                   |
//+------------------------------------------------------------------+
void OnTimer()
  {
   if(!MQLInfoInteger(MQL_TESTER))
      engine.OnTimer();
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- Se houver trabalho no testador
   if(MQLInfoInteger(MQL_TESTER))
      engine.OnTimer();

   if(!IsOpenedByMagic(InpMagicNum))
     {
      //--- Obtenção de dados para cálculo
      if(!GetIndValue())
         return;
      //---
      if(BuySignal())
        {
         //--- Obtemos os preços corretos de StopLoss e de TakeProfit em relação ao nível StopLevel
         double sl=CorrectStopLoss(Symbol(),ORDER_TYPE_BUY,0,stoploss);
         double tp=CorrectTakeProfit(Symbol(),ORDER_TYPE_BUY,0,takeprofit);
         //--- Abrimos a posição Buy
         trade.Buy(lot,Symbol(),0,sl,tp);
        }
      else if(SellSignal())
        {
         //--- Obtemos os preços corretos de StopLoss e de TakeProfit em relação ao nível StopLevel
         double sl=CorrectStopLoss(Symbol(),ORDER_TYPE_SELL,0,stoploss);
         double tp=CorrectTakeProfit(Symbol(),ORDER_TYPE_SELL,0,takeprofit);
         //--- Abrimos a posição Sell
         trade.Sell(lot,Symbol(),0,sl,tp);
        }
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool BuySignal()
  {
   return(avr_speed[0]>=InpTrendLev && cam_up[0]!=EMPTY_VALUE)?true:false;
  }
//+------------------------------------------------------------------+
bool SellSignal()
  {
   return(avr_speed[0]>=InpTrendLev && cam_dn[0]!=EMPTY_VALUE)?true:false;
  }
//+------------------------------------------------------------------+
//| Obtenção dos valores atuais dos indicadores                      |
//+------------------------------------------------------------------+
bool GetIndValue()
  {
   return(CopyBuffer(InpInd_Handle2,0,0,1,cam_up)<1 ||
          CopyBuffer(InpInd_Handle2,1,0,1,cam_dn)<1 || 
          CopyBuffer(InpInd_Handle1,0,0,1,avr_speed)<1
          )?false:true;
  }
//+------------------------------------------------------------------+
//| Verificando se a posição está aberta com o magic                 |
//+------------------------------------------------------------------+
bool IsOpenedByMagic(int MagicNumber)
  {
   int pos=0;
   uint total=PositionsTotal();
//---
   for(uint i=0; i<total; i++)
     {
      if(SelectByIndex(i))
         if(PositionGetInteger(POSITION_MAGIC)==MagicNumber)
            pos++;
     }
   return((pos>0)?true:false);
  }
//+------------------------------------------------------------------+
//| Select a position on the index                                   |
//+------------------------------------------------------------------+
bool SelectByIndex(const int index)
  {
   ENUM_ACCOUNT_MARGIN_MODE margin_mode=(ENUM_ACCOUNT_MARGIN_MODE)AccountInfoInteger(ACCOUNT_MARGIN_MODE);
//---
   if(margin_mode==ACCOUNT_MARGIN_MODE_RETAIL_HEDGING)
     {
      ulong ticket=PositionGetTicket(index);
      if(ticket==0)
         return(false);
     }
   else
     {
      string name=PositionGetSymbol(index);
      if(name=="")
         return(false);
     }
//---
   return(true);
  }
//+------------------------------------------------------------------+

Estratégia de negociação №2

A ideia implementar essa estratégia de negociação foi tomada do EA . Basicamente, ela consiste em abrir posições de negociação quando o preço muda um certo número de pontos, levando em conta o número especificado de ticks gastos nisso. 

Parâmetros Descrição
Timeframe Qualquer um 
Condições de compra Número de pontos de preço transcorridos durante um certo número de ticks.
Condições de venda Número de pontos de preço transcorridos durante um certo número de ticks.
Condições de saída   Take-Profit/Stop-Loss

A implementação dessa estratégia está na listagem abaixo. Como você pode ver, existem dois parâmetros nas configurações que são responsáveis por estimar a velocidade de movimento do preço:

//+------------------------------------------------------------------+
//| Parâmetros de entrada do Expert Advisor                          |
//+------------------------------------------------------------------+
input string               InpEaComment         =  "Strategy #2"; // EA Comment
input int                  InpMagicNum          =  1111;          // Magic number
input double               InpLots              =  0.1;           // Lots
input uint                 InpStopLoss          =  400;           // StopLoss in points
input uint                 InpTakeProfit        =  500;           // TakeProfit in points
input ENUM_COPY_TICKS      tick_flags           =  TICKS_INFO;    // Ticks chamados por alterações do Bid e/ou do Ask
input int                  InpPoints            =  15;            // O preço deve percorrer NNN pontos
input uchar                InpTicks             =  15;            // após XXX ticks

//--- arrays para recepção de ticks
MqlTick        tick_array_curr[];            // array de ticks obtido no tick atual
MqlTick        tick_array_prev[];            // array de ticks obtido no tick anterior
ulong          tick_from=0;                  // se o parâmetro tick_from=0, são dados os últimos ticks do tick_count
uint           tick_count=15;                // número de ticks que é necessário obter
//---
double         ExtStopLoss=0.0;
double         ExtTakeProfit=0.0;
double         ExtPoints=0.0;
bool           first_start=false;
long           last_trade_time=0;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   if(!m_symbol.Name(Symbol()))              // sets symbol name
      return(INIT_FAILED);

   tick_count+=InpTicks;                     // solicitamos "tick_count" + "após XXX ticks"
   ExtStopLoss=InpStopLoss*Point();
   ExtTakeProfit=InpTakeProfit*Point();
   ExtPoints=InpPoints*Point();
   first_start=false;
//--- solicitamos ticks (primeiro preenchimento)
   int copied=CopyTicks(Symbol(),tick_array_curr,tick_flags,tick_from,tick_count);
   if(copied!=tick_count)
      first_start=false;
   else
     {
      first_start=true;
      ArrayCopy(tick_array_prev,tick_array_curr);
     }
   m_trade.SetExpertMagicNumber(InpMagicNum);
   m_trade.SetTypeFillingBySymbol(Symbol());
   m_trade.SetMarginMode();
   m_trade.LogLevel(LOG_LEVEL_NO);
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- verificando a primeira inicialização
   int copied=-1;
   if(!first_start)
     {
      copied=CopyTicks(Symbol(),tick_array_curr,tick_flags,tick_from,tick_count);
      if(copied!=tick_count)
         first_start=false;
      else
        {
         first_start=true;
         ArrayCopy(tick_array_prev,tick_array_curr);
        }
     }
//--- solicitamos ticks
   copied=CopyTicks(Symbol(),tick_array_curr,tick_flags,tick_from,tick_count);
   if(copied!=tick_count)
      return;
   int index_new=-1;
   long last_time_msc=tick_array_prev[tick_count-1].time_msc;
   for(int i=(int)tick_count-1;i>=0;i--)
     {
      if(last_time_msc==tick_array_curr[i].time_msc)
        {
         index_new=i;
         break;
        }
     }
//---
   if(index_new!=-1 && !IsOpenedByMagic(InpMagicNum))
     {
      int shift=(int)tick_count-1-index_new-InpTicks;   // deslocamento de ticks no array atual
      shift=(shift<0)?0:shift;
      if(tick_array_curr[tick_count-1].ask-tick_array_curr[shift].ask>ExtPoints)
        {
         //--- abrimos BUY
         double sl=(InpStopLoss==0)?0.0:tick_array_curr[tick_count-1].ask-ExtStopLoss;
         double tp=(InpTakeProfit==0)?0.0:tick_array_curr[tick_count-1].ask+ExtTakeProfit;
         m_trade.Buy(InpLots,m_symbol.Name(),tick_array_curr[tick_count-1].ask,
                     m_symbol.NormalizePrice(sl),
                     m_symbol.NormalizePrice(tp));
         last_trade_time=tick_array_curr[tick_count-1].time_msc;
        }
      else if(tick_array_curr[shift].bid-tick_array_curr[tick_count-1].bid>ExtPoints)
        {
         //--- abrimos SELL
         double sl=(InpStopLoss==0)?0.0:tick_array_curr[tick_count-1].bid-ExtStopLoss;
         double tp=(InpTakeProfit==0)?0.0:tick_array_curr[tick_count-1].bid+ExtTakeProfit;
         m_trade.Sell(InpLots,m_symbol.Name(),tick_array_curr[tick_count-1].bid,
                      m_symbol.NormalizePrice(sl),
                      m_symbol.NormalizePrice(tp));
         last_trade_time=tick_array_curr[tick_count-1].time_msc;
        }
     }
   ArrayCopy(tick_array_prev,tick_array_curr);
//---
  }
//+------------------------------------------------------------------+
//| Verificando se a posição está aberta com o magic                 |
//+------------------------------------------------------------------+
bool IsOpenedByMagic(int MagicNumber)
  {
   int pos=0;
   uint total=PositionsTotal();
//---
   for(uint i=0; i<total; i++)
     {
      if(SelectByIndex(i))
         if(PositionGetInteger(POSITION_MAGIC)==MagicNumber)
            pos++;
     }
   return((pos>0)?true:false);
  }
//+------------------------------------------------------------------+
//| Select a position on the index                                   |
//+------------------------------------------------------------------+
bool SelectByIndex(const int index)
  {
   ENUM_ACCOUNT_MARGIN_MODE margin_mode=(ENUM_ACCOUNT_MARGIN_MODE)AccountInfoInteger(ACCOUNT_MARGIN_MODE);
//---
   if(margin_mode==ACCOUNT_MARGIN_MODE_RETAIL_HEDGING)
     {
      ulong ticket=PositionGetTicket(index);
      if(ticket==0)
         return(false);
     }
   else
     {
      string name=PositionGetSymbol(index);
      if(name=="")
         return(false);
     }
//---
   return(true);
  }
//+------------------------------------------------------------------+

Estratégia de negociação №3

Para criar uma estratégia de negociação que meça indiretamente a velocidade de movimentação de preços, é necessário selecionar um indicador de tendência, bem como um filtro que confirme seus possíveis sinais. Para fazer isso, foi decidido escolher o indicador de tendência Trend direction and force, e como filtro foi tomada a média móvel Hull . A figura 7 abaixo mostra os sinais de entrada para a compra e para venda.

Fig.7 Condições de entrada da estratégia de negociação

Parâmetros Descrição
Indicador utilizado Trend direction and force
Indicador utilizado
Timeframe M30 e superior
Condições de compra A valor do 'Trend direction and fast' está acima do limite (a linha é colorida em azul), enquanto a média móvel Hull cresce e fica azul.
Condições de venda A valor do 'Trend direction and fast' está abaixo do limite (a linha é colorida em vermelho), enquanto a média móvel Hull cai e fica vermelha.
Condições de saída   Take-Profit/Stop-Loss


Teste de métodos para medir a velocidade do movimento de preços

Para testar as três estratégias selecionadas, é preciso decidir sob quais sobre as condições serão testadas. 

  • Intervalo: Último ano (no momento da escrita desse artigo, 01/01/2019 — 26/05/2019)
  • Par de moedas: EURUSD.
  • Execução: Sem latência (as estratégias apresentadas não estão relacionadas às de alta frequência, de modo que o impacto do atraso é muito pequeno). 
  • Teste: OHLC em M1 (os testes preliminares em ticks reais resultaram quase indistinguíveis em relação a esse modo). 
  • Depósito inicial: 1000 USD.
  • Alavancagem: 1:500.
  • Servidor: MetaQuotes-Demo.
  • Cotações: de 5 dígitos.

O objetivo do teste não será encontrar o melhor ajuste com base no histórico, mas, sim, descobrir a tendência geral e o êxito de diferentes abordagens no cálculo e no processamento da velocidade de movimento do preço. Por isso, para cada uma das estratégias de negociação, serão fornecidos os melhores resultados de otimização e sua avaliação usando os parâmetros do relatório. 

Estratégia de negociação №1.

Após testar a primeira estratégia baseada na medição clássica de velocidade de preço, obtivemos os seguintes resultados, dos quais eu selecionei o melhor top 20:

Fig. 8. Os vinte melhores resultados de otimização da estratégia de negociação №1

A partir desses resultados, podemos concluir que, sob essas condições de teste, a estratégia de negociação mostra os melhores resultados em pequenos períodos gráficos com pequenos valores de take-profit e stop-loss. Ou seja, quando um sinal é encontrado, seu potencial de movimento é pequeno. O valor do índice de Sharpe (sobre ele e outros indicadores pode ser encontrado no artigo Matemática em trading. Como estimar resultados de trading) é baixo, o que não é muito bom. Em seguida, iniciei no testador o melhor resultado e obtive esse relatório.


Fig.9 Resultado do teste do melhor resultado de otimização para a estratégia de negociação №1

Durante o teste com um lote constante de 0.1, pode ser visto que o aumento é de quase 100%, no entanto, o coeficiente de Sharpe é apenas 0.33 e o valor do Z-Score é igual a -0.16, o que significa que não há equilíbrio na negociação e que ela, no teste atual, foi mais aleatória do que ajustada à abordagem proposta. 

Estratégia de negociação №2.

Para testar a seguinte estratégia, devido às suas peculiaridades, é necessário alterar uma condição de teste:

  • Teste: substituir OHLC em M1 (os testes preliminares em ticks reais resultaram quase indistinguíveis em relação a esse modo) por Todos os ticks baseados em ticks reais.

Assim, as vinte principais opções para otimizar essa estratégia são as seguintes:

Fig. 10. Os vinte melhores resultados de otimização da estratégia de negociação №2

Aqui, em média, os valores do índice de Sharpe são superiores que os da primeira estratégia, enquanto os melhores resultados são obtidos com um número moderado de pontos para o número mínimo de ticks. Também é perceptível que o sistema foi bastante seletivo, como indicado pelo pequeno número de transações. Vamos testar o melhor resultado de otimização e ver seu relatório.


Fig.11 Resultado do teste do melhor resultado de otimização para a estratégia de negociação №2

Sim, nesse caso, há um bom índice de Sharpe, porque em apenas 10 transações foi alcançado mais de 30% do lucro. 

Estratégia de negociação №3. 

Nessa estratégia, voltaremos para as condições iniciais de teste. Aqui vamos verificar a negociação usando indicadores que indiretamente determinam o movimento do preço e sua velocidade.

Também veremos as melhores opções para otimizar a estratégia atual:

Fig. 12. Os vinte melhores resultados de otimização da estratégia de negociação №3

A maioria dos resultados é muito semelhante entre si, isso sugere que os dois últimos parâmetros de otimização não desempenham um grande papel no resultado final. Além disso, o valor médio do índice de Sharpe está na faixa de 0.2, o que não é uma grande leitura. É Claro, o melhor resultado de otimização está fora da ordem geral, mas, como nas estratégias de negociação anteriores, faremos o backtest nelas.


Fig.13 Resultado do teste do melhor resultado de otimização para a estratégia de negociação №3

Apesar do aumento de quase 100% no depósito e no índice de Sharpe (isso ainda é evidente pelo fato de que foram necessárias 52 transações para alcançar o nível atual de lucro, e os resultados mais próximos são quase duas vezes menores) e Z-Score mostra uma relação negativa entre transações. Isso significa que uma transação lucrativa provavelmente será seguida por uma com prejuízo e vice-versa. 

Conclusões

Após testar as três abordagens para medir a velocidade do movimento de preços e após examinar os resultados de backtesting dos melhores resultados, bem como os de outras otimizações, verificou-se que, no primeiro método, o melhor resultado de otimização não mostrou equilíbrio na estratégia de negociação. Enquanto os outros dois métodos, apresentaram os melhores resultados: um maior índice de Sharpe, assim como a presença de um relacionamento negativo entre as transações. Obviamente, as estratégias de teste não cobrem toda a variedade de métodos ou abordagens para medir a velocidade do preço, mas este artigo deu alguns dos métodos de negociação mais óbvios e fáceis de entender para usar idéia próprias de análise técnica.

Fim do artigo

No final do artigo é anexado um arquivo com todos os arquivos listados, classificados por pastas. Portanto, para trabalhar corretamente, basta colocar a pasta MQL5 na raiz do terminal. Para encontrar a raiz do terminal no qual está localizada a pasta MQL5, você precisa pressionar a combinação de teclas no MetaTarder 5 Ctrl+Shift+D ou use o menu de contexto, como mostrado na Figura 14 abaixo.


Fig.14 Busca da pasta MQL5 na raiz do terminal MetaTrader 5

Programas utilizados no artigo:

#
 Nome
Tipo
Descrição
1
Strategy_1.mq5 Expert Advisor  EA da estratégia de negociação №1
2 Strategy_2.mq5 Expert Advisor  EA da estratégia de negociação №2
3 Strategy_3.mq5 Expert Advisor   EA da estratégia de negociação №3
4 Engine.mqh Biblioteca  Biblioteca de funções de negociação.
 5 Average Speed  Indicador   Usado na estratégia de negociação №1
 6 CAM  Indicador    Usado na estratégia de negociação №1
 7 Trend direction and force  Indicador    Usado na estratégia de negociação №3
 8 HMA_color  Indicador   Usado na estratégia de negociação №3


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

Arquivos anexados |
MQL5.zip (734.69 KB)
Estimando o índice de funcionalidade, o expoente de Hurst e a possibilidade de prever séries temporais financeiras Estimando o índice de funcionalidade, o expoente de Hurst e a possibilidade de prever séries temporais financeiras

A busca e o estudo do comportamento fractal de dados financeiros implica que, por trás do comportamento aparentemente caótico de séries temporais econômicas, estão ocultos e operam mecanismos estáveis que governam a conduta coletiva dos participantes. Na bolsa de valores, essa mecânica pode levar ao surgimento de uma dinâmica de preços que determina e descreve as propriedades específicas das séries de preços. Na negociação, seria interessante ter indicadores que pudessem estimar os parâmetros de fractalidade de maneira efetiva e estável, numa escala e num intervalo de tempo que fossem uteis na prática.

Biblioteca para desenvolvimento fácil e rápido de programas para a MetaTrader (parte V): Classes e coleções de eventos de negociação, envio de eventos para o programa Biblioteca para desenvolvimento fácil e rápido de programas para a MetaTrader (parte V): Classes e coleções de eventos de negociação, envio de eventos para o programa

Nos artigos anteriores, nós começamos a criar uma grande biblioteca multi-plataforma, simplificando o desenvolvimento de programas para as plataformas MetaTrader 5 e MetaTrader 4. Na quarta parte, nós testamos o monitoramento de eventos de negociação na conta. Neste artigo, nós vamos desenvolver classes de eventos de negociação e colocá-los nas coleções de eventos. A partir daí, eles serão enviados ao objeto base da biblioteca Engine e ao gráfico do programa de controle.

Criando um EA gradador multiplataforma (Parte II): grade dentro de uma faixa na direção da tendência Criando um EA gradador multiplataforma (Parte II): grade dentro de uma faixa na direção da tendência

Hoje vamos tentar desenvolver um EA de grade para trabalhar dentro de um intervalo na direção da tendência, para instrumentos de Forex ou para mercados de commodities. Como mostraram os testes, nosso gradador tem sido lucrativo desde 2018. No entanto, de 2014 a 2018, houve uma perda constante do depósito.

Arranquemos o lucro até o último pip Arranquemos o lucro até o último pip

Este artigo tenta combinar teoria com prática no campo da negociação algorítmica. A maior parte da conversa sobre a criação de sistemas de negociação está associada ao uso de barras históricas de preços e vários indicadores. Este é um campo bem desgastado que não tocaremos. As barras são uma entidade completamente artificial, por isso, vamos dar algo mais próximo a protoinformações - ticks.