MetaTrader 5 / Exemplos
English Русский 中文 Español Deutsch 日本語 한국어 Français Italiano Türkçe
Programando os Modos do EA Usando a Abordagem Orientada a Objetos

Programando os Modos do EA Usando a Abordagem Orientada a Objetos

MetaTrader 5 — Exemplos | 17 julho 2015, 13:45
2 329 0
Denis Kirichenko
Denis Kirichenko

Introdução

Neste artigo vamos discutir os modos de programação, em que um EA em MQL5 pode trabalhar. O objetivo deste artigo é descrever a idéia de que "cada modo é implementado em sua própria maneira". O autor acredita que esta abordagem permite a conclusão de tarefas em diferentes estágios de desenvolvimento de uma EA de forma mais eficiente.

Em primeiro lugar, nós consideramos quais os estágios de desenvolvimento que uma EA consiste. Em seguida, são explorados os modos em que um EA pode trabalhar no MetaTrader 5 e as suas aplicações de ajuda. O artigo chega ao fim no desenvolvimento da hierarquia de classes para implementar a idéia acima.


1. Etapas de Desenvolvimento

O desenvolvimento de um robô de negociação (EA) é um processo multi-aspecto. Os blocos-chave aqui são a algoritmização da idéia e do teste. Notavelmente, ambos a lógica de negociação do EA e o algoritmo de código são testados.

Como um esquema, as fases deste processo podem ser representados do seguinte modo (Fig.1).

Fig.1. Fases de desenvolvimento e implementação de uma EA

Fig.1. Fases de desenvolvimento e implementação de uma EA

A quinta etapa "Negociação Algorítmica" mostra o trabalho dos desenvolvedores, programadores, analistas e outros especialistas envolvidos. Muitas vezes acontece de todos esses papéis serem desempenhados por uma pessoa. Vamos supor, que ele é um trader-programador.

Este esquema pode ser atualizado e ampliado. Na minha opinião, ele ilustra os pontos mais importantes no desenvolvimento de uma EA. O padrão cíclico deste esquema permite melhorar e modificar o código do EA através de sua vida.

Deve-se notar que cada etapa requer certas ferramentas, conhecimentos e habilidades.

Na minha opinião, o desenvolvedor se depara com a seguinte matriz variante simples (figura 2).

Fig.2. Matriz variante

Fig.2. Matriz variante

Claramente, somente a implementação de um robô com uma estratégia de negociação vencedora e com um código de alta qualidade é que chegamos ao quinto estágio "Negociação Algorítmica".


2. O Modos do Expert Advisor em MQL5

O ambiente MQL5 permite trabalhar com um EA em diferentes modos. Há sete deles. Nós vamos considerar cada um deles mais abaixo.

Do ponto de vista do tipo de arquivo do programa, dois grupos podem ser distinguidos:

  1. Modos que exigem o arquivo de código-fonte e o arquivo executável;
  2. Modos que exigem apenas o arquivo executável.

Modos de depuração e profiling pertencem ao primeiro grupo.

Outro critério de classificação é o modo de trabalho de um EA em um fluxo de cotações reais ou históricos. Todos os modos de teste são conectados com cotações históricas.

6 modos são definidos pela programação. A conclusão, se um EA está trabalhando em um modo padrão (release) ou não, ela pode ser feita com base nos resultados. Um programa pronto (arquivo com a extensão *.ex5), que foi codificado para o trabalhar em mercados financeiros, é para trabalhar supostamente neste mesmo modo. Ao mesmo tempo, um programa feito permite que seja usando outros modos no testador de estratégia também.

Vamos criar uma enumeração dos modos operacionais do programa em MQL chamado de ENUM_MQL_MODE:

//+------------------------------------------------------------------+
//| Modos MQL                                                        |
//+------------------------------------------------------------------+
enum ENUM_MQL_MODE
  {
   MQL_MODE_RELEASE=0,       // Normal
   MQL_MODE_DEBUG=1,         // Depuração
   MQL_MODE_PROFILER=2,      // Profiling  
   MQL_MODE_TESTER=3,        // Teste
   MQL_MODE_OPTIMIZATION=4,  // Otimização
   MQL_MODE_VISUAL=5,        // Teste visual 
   MQL_MODE_FRAME=6,         // Coletando quadros
  };

Mais tarde, isto será necessário para o reconhecimento do tipo do modo no qual um EA está trabalhando.


2.1. Função de Identificação e a Verificação do Modo

Escreva uma função simples que irá iterar sobre todos os modos e imprimir as informações no Diário.

//+------------------------------------------------------------------+
//| Verificação de todos os modos MQL                                |
//+------------------------------------------------------------------+
void CheckMqlModes(void)
  {
//--- Se está no modo de depuração
   if(MQLInfoInteger(MQL_DEBUG))
      Print("Debug mode: yes");
   else
      Print("Debug mode: no");
//--- Se está no modo de perfilar o código
   if(MQLInfoInteger(MQL_PROFILER))
      Print("Profile mode: yes");
   else
      Print("Profile mode: no");
//--- Se está no modo de teste
   if(MQLInfoInteger(MQL_TESTER))
      Print("Tester mode: yes");
   else
      Print("Tester mode: no");
//--- Se está no modo de otimização
   if(MQLInfoInteger(MQL_OPTIMIZATION))
      Print("Optimization mode: yes");
   else
      Print("Optimization mode: no");
//--- Se está no modo de teste visual
   if(MQLInfoInteger(MQL_VISUAL_MODE))
      Print("Visual mode: yes");
   else
      Print("Visual mode: no");
//--- Se está no modo de coleta dos resultados da otimização dos quadros
   if(MQLInfoInteger(MQL_FRAME_MODE))
      Print("Frame mode: yes");
   else
      Print("Frame mode: no");
  }

O trabalho desta função em cada modo será verificado. Ele pode ser chamado no manipulador de eventos da OnInit().

Para o objetivo do teste, deixe-nos criar um modelo de EA chamado Test1_Modes_EA.mq5.

Uma opção para especificar o modo em que o EA está trabalhando está habilitado nos parâmetros de entrada. É importante certificar-se de que o modo correto é chamado, se não as informações serão imprecisas. Isso foi o que aconteceu.

Abaixo está o modo liberado.

CL      0       17:20:38.932    Test1_Modes_EA (EURUSD.e,H1)     Current mode: MQL_MODE_RELEASE
QD      0       17:20:38.932    Test1_Modes_EA (EURUSD.e,H1)     Debug mode: no
KM      0       17:20:38.932    Test1_Modes_EA (EURUSD.e,H1)     Profile mode: no
EK      0       17:20:38.932    Test1_Modes_EA (EURUSD.e,H1)     Tester mode: no
CS      0       17:20:38.932    Test1_Modes_EA (EURUSD.e,H1)     Optimization mode: no
RJ      0       17:20:38.932    Test1_Modes_EA (EURUSD.e,H1)     Visual mode: no
GL      0       17:20:38.932    Test1_Modes_EA (EURUSD.e,H1)     Frame mode: no

Para o modo de liberado, as sinalizações de todos os outros modos foram zeradas. Assim, a função identificada que não era nem o modo de depuração (Debug mode: no), nem profilação (Profile mode: no) etc. Utilizando o método da negação, chegamos à conclusão de que estamos trabalhando no modo normal.

Agora vamos ver como o modo de depuração foi identificado.

HG      0       17:27:47.709    Test1_Modes_EA (EURUSD.e,H1)     Current mode: MQL_MODE_DEBUG
LD      0       17:27:47.710    Test1_Modes_EA (EURUSD.e,H1)     Debug mode: yes
RS      0       17:27:47.710    Test1_Modes_EA (EURUSD.e,H1)     Profile mode: no
HE      0       17:27:47.710    Test1_Modes_EA (EURUSD.e,H1)     Tester mode: no
NJ      0       17:27:47.710    Test1_Modes_EA (EURUSD.e,H1)     Optimization mode: no
KD      0       17:27:47.710    Test1_Modes_EA (EURUSD.e,H1)     Visual mode: no
RR      0       17:27:47.710    Test1_Modes_EA (EURUSD.e,H1)     Frame mode: no

O Modo de depuração foi reconhecido corretamente.

Qualquer manual de programação contém informações que facilita a depuração de busca e localização de erros no código. Ele também destaca as peculiaridades do programa. Mais detalhes sobre a depuração no ambiente MQL5 pode ser encontrado no artigo "Depuração dos Programas do MQL5".

Este modo é mais comumente usado nas fases de formalização e construção do algoritmo de uma idéia de negociação.

Na programação, a depuração está habilitado ou usadando a macro IS_DEBUG_MODE ou a função MQLInfoInteger() com o identificador MQL_DEBUG.

Estamos passando para o modo de profilação.

GS      0       17:30:53.879    Test1_Modes_EA (EURUSD.e,H1)     Current mode: MQL_MODE_PROFILER
OR      0       17:30:53.879    Test1_Modes_EA (EURUSD.e,H1)     Debug mode: no
GE      0       17:30:53.879    Test1_Modes_EA (EURUSD.e,H1)     Profile mode: yes
QM      0       17:30:53.879    Test1_Modes_EA (EURUSD.e,H1)     Tester mode: no
CE      0       17:30:53.879    Test1_Modes_EA (EURUSD.e,H1)     Optimization mode: no
FM      0       17:30:53.879    Test1_Modes_EA (EURUSD.e,H1)     Visual mode: no
GJ      0       17:30:53.879    Test1_Modes_EA (EURUSD.e,H1)     Frame mode: no

A função corretamente estimou que o Profiler estava envolvido.

Neste modo pode ser verificado a rapidez com que o programa funciona. O Profiler passa as informações sobre o tempo dos blocos do programa. Supõe-se que este instrumento aponte gargalos de um algoritmo. Eles nem sempre são possíveis de se livrar, mas, no entanto, esta informação pode ser útil.

Profiling pode ser ativado através da macro IS_PROFILE_MODE ou da função MQLInfoInteger() com o identificador MQL_PROFILER.

Agora vamos dar uma olhada no modo de teste. Esta informação aparecerá na aba "Diário" do Strategy Tester.

EG      0       17:35:25.397    Core 1  2014.11.03 00:00:00   Current mode: MQL_MODE_TESTER
OS      0       17:35:25.397    Core 1  2014.11.03 00:00:00   Debug mode: no
GJ      0       17:35:25.397    Core 1  2014.11.03 00:00:00   Profile mode: no
ER      0       17:35:25.397    Core 1  2014.11.03 00:00:00   Tester mode: yes
ED      0       17:35:25.397    Core 1  2014.11.03 00:00:00   Optimization mode: no
NL      0       17:35:25.397    Core 1  2014.11.03 00:00:00   Visual mode: no
EJ      0       17:35:25.397    Core 1  2014.11.03 00:00:00   Frame mode: no

O modo de teste foi identificado corretamente.

Este é o modo padrão do EA quando o Strategy Tester fica aberto.

Não há macros para este modo e, portanto, só podemos determinar-lo em MQL5 usando a função MQLInfoInteger() com o identificador MQL_TESTER.

Agora estamos nos movendo para a otimização. O diário com os registros serão armazenados na pasta do agente. No meu caso, o caminho é o seguinte: %Program Files\MetaTrader5\tester\Agent-127.0.0.1-3000\logs

OH      0       17:48:14.010    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Current mode: MQL_MODE_OPTIMIZATION
KJ      0       17:48:14.010    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Debug mode: no
NO      0       17:48:14.010    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Profile mode: no
FI      0       17:48:14.010    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Tester mode: yes
KE      0       17:48:14.010    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Optimization mode: yes
LS      0       17:48:14.010    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Visual mode: no
QE      0       17:48:14.010    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Frame mode: no

Se o modo de otimização está ativo, o modo de teste é ativado por padrão.

O modo de otimização é ativo no Strategy Tester se o campo "Otimização" não está desativado na guia "Configurações".

Para saber se o EA está sendo testado no modo de otimização em MQL5, chame a função MQLInfoInteger() com o identificador MQL_OPTIMIZATION.

Estamos avançando para o modo de visualização.

JQ      0       17:53:51.485    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Current mode: MQL_MODE_VISUAL
JK      0       17:53:51.485    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Debug mode: no
KF      0       17:53:51.485    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Profile mode: no
CP      0       17:53:51.485    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Tester mode: yes
HJ      0       17:53:51.485    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Optimization mode: no
LK      0       17:53:51.485    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Visual mode: yes
KS      0       17:53:51.485    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Frame mode: no

Aqui podemos ver que o modo visual de teste e o modo de teste padrão estão envolvidos.

O EA trabalha neste modo no Strategy Tester se o campo "Visualização" na guia "Configurações" é sinalizado.

Para estabelecer o fato de que o programa de teste em MQL5 está no modo visual de teste, utilizamos a função MQLInfoInteger() com o identificador MQL_VISUAL_MODE.

O último modo é o modo de lidar com os quadros.

HI      0       17:59:10.177    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Current mode: MQL_MODE_FRAME
GR      0       17:59:10.177    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Debug mode: no
JR      0       17:59:10.177    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Profile mode: no
JG      0       17:59:10.177    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Tester mode: yes
GM      0       17:59:10.177    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Optimization mode: yes
HR      0       17:59:10.177    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Visual mode: no
MI      0       17:59:10.177    Test1_Modes_EA (EURUSD.e,H1)     2014.11.03 00:00:00   Frame mode: no

Curiosamente, a função reconheceu apenas os modos de teste e a otimização enquanto a sinalização de quadros estava zerada. Se a chamada da função é transferida para o manipulador OnTesterInit(), a aba "Experts" vai conter as seguintes entradas:

IO      0       18:04:27.663    Test1_Modes_EA (EURUSD.e,H1)     Current mode: MQL_MODE_FRAME
GE      0       18:04:27.663    Test1_Modes_EA (EURUSD.e,H1)     Debug mode: no
ML      0       18:04:27.663    Test1_Modes_EA (EURUSD.e,H1)     Profile mode: no
CJ      0       18:04:27.663    Test1_Modes_EA (EURUSD.e,H1)     Tester mode: no
QR      0       18:04:27.663    Test1_Modes_EA (EURUSD.e,H1)     Optimization mode: no
PL      0       18:04:27.663    Test1_Modes_EA (EURUSD.e,H1)     Visual mode: no
GS      0       18:04:27.663    Test1_Modes_EA (EURUSD.e,H1)     Frame mode: yes

Efetivamente, agora só o modo de coleta de quadros foi detectado.

Este modo é usado no Strategy Tester se o campo "Otimização" na guia "Configurações" não estiver desativado. Como a experiência demonstrou, este modo é definido no corpo dos manipuladores OnTesterInit(), OnTesterPass() e OnTesterDeinit().

A função MQLInfoInteger() com o identificador MQL_FRAME_MODE pode facilitar a identificação do fato de testar um EA no modo de coleta de quadros.

Abaixo está o código da função de serviço MqlMode(), que especifica automaticamente o modo em que o EA está a trabalhar.

//+------------------------------------------------------------------+
//| Identificando o modo MQL atual                                   |
//+------------------------------------------------------------------+
ENUM_MQL_MODE MqlMode(void)
  {
   ENUM_MQL_MODE curr_mode=WRONG_VALUE;

//--- Se está no modo de depuração
   if(MQLInfoInteger(MQL_DEBUG))
      curr_mode=MQL_MODE_DEBUG;
//--- Se está no modo de perfilar o código
   else if(MQLInfoInteger(MQL_PROFILER))
      curr_mode=MQL_MODE_PROFILER;
//--- Se está no modo de teste visual
   else if(MQLInfoInteger(MQL_VISUAL_MODE))
      curr_mode=MQL_MODE_VISUAL;
//--- Se está no modo de otimização
   else if(MQLInfoInteger(MQL_OPTIMIZATION))
      curr_mode=MQL_MODE_OPTIMIZATION;
//--- Se está no modo de teste
   else if(MQLInfoInteger(MQL_TESTER))
      curr_mode=MQL_MODE_TESTER;
//--- Se está no modo de coleta dos resultados da otimização dos quadros
   else if(MQLInfoInteger(MQL_FRAME_MODE))
      curr_mode=MQL_MODE_FRAME;
//--- Se o modo está liberado
   else
      curr_mode=MQL_MODE_RELEASE;
//---
   return curr_mode;
  }

Já que o teste padrão é identificado no modo de otimização e no de teste visual, em seguida, o modo normal de teste deve ser verificado após o modo de otimização e visualização.

Se dermos uma olhada no trabalho da função no segundo modelo do EA Test2_Modes_EA.mq5, podemos ver que uma nova entrada foi publicada no registro quando o modelo for lançado. Por exemplo, para o modo de profiling foi feita a seguinte entrada:

HG      0       11:23:52.992    Test2_Modes_EA (EURUSD.e,H1)    Current mode: MQL_MODE_PROFILER

Nós discutimos os detalhes dos modos operacionais do Expert MQL5 para a criação de modelos de classe correspondentes a um modo especificado. Nós estamos indo para a implementação na próxima parte do artigo.


3. Modelo do EA Projetado para Funcionar em Diferentes Modos

Eu sugiro ir ao longo dos estágios de desenvolvimento de um EA novamente.

Na fase de algoritmização, um programador na maioria das vezes faz a depuração e o profiling. Para testar os dados históricos, eles tentam todos os modos do Strategy Tester. O modo final (modo normal) é utilizado na negociação on-line.

Na minha opinião, um EA deve ser multifacetado no sentido de que a exigência dos estágios de desenvolvimento e de teste tem que ser refletido em seu código.

Com isso, o algoritmo principal será preservado e, após isso, o EA vai ter um comportamento diferente nos modos diferentes. O conjunto de ferramentas da programação orientada a objeto adequa-se perfeitamente para a implementação desta ideia.

Fig.2 Hierarquia de classes para o EA projetado funcionar em diferentes modos

Fig.3. Hierarquia de classes para o EA projetado funcionar em diferentes modos

A hierarquia de classes com a implementação do modos diferentes é representada na figura 3.

A classe base CModeBase encapsulando todas as coisas comuns terá dois descendentes diretos: as classes CModeRelease e CModeTester. O primeiro será pai para as classes de depuração e a segunda para as classes relacionadas com a teste do EA em dados históricos.

Deixe-nos desenvolver a idéia de combinar uma abordagem processual e modular no desenvolvimento dos métodos de classe no contexto de modos. Como exemplo, vamos considerar a seguinte lógica de negociação:

  1. Abertura pelo sinal se não houver nenhuma posição em aberto;
  2. Fechamento pelo sinal se houver uma posição em aberto;
  3. Stop Móvel se houver uma posição em aberto.

O sinal de negociação é detectado pelo indicador padrão MACD quando uma nova barra aparecer.

Um sinal de compra é exibido quando a linha principal está indo para cima e cruzando o sinal de uma zona negativa do indicador MACD (Fig.4).

Fig.4 Sinal para comprar

Fig.4. Sinal para comprar

Um sinal de vender aparece quando a linha principal vai para baixo, e o sinal cruza ela na zona positiva do indicador (Fig. 5).

Fig.5 Sinal para vender

Fig.5. Sinal para vender

A posição é fechada, quando o sinal oposto aparecer ou pelo Stop loss, que é colocado no caso do modo de uma posição de suporte estiver ativada.

Em seguida, a definição da classe básica CModeBase é a seguinte:

//+------------------------------------------------------------------+
//| Classe CModeBase                                                 |
//| Objetivo: uma classe base para os modos MQL                      |            
//+------------------------------------------------------------------+
class CModeBase
  {
//--- === Os membros de dados === --- 
private:
   //--- Um objeto e valores macd
   CiMACD            m_macd_obj;
   double            m_macd_main_vals[2];
   double            m_macd_sig_vals[2];

protected:
   long              m_pos_id;
   bool              m_is_new_bar;
   uint              m_trailing_stop;
   uint              m_trail_step;
   //--- Objetos de negociação
   CSymbolInfo       m_symbol_info;
   CTrade            m_trade;
   CPositionInfo     m_pos_info;
   CDealInfo         m_deal_info;
   //--- Modo MQL
   ENUM_MQL_MODE     m_mql_mode;

   //--- Um objeto new bar
   CisNewBar         m_new_bar;
   //--- Sinalização do sinal de tick atual
   bool              m_is_curr_tick_signal;
   //--- tipo da ordem de fechamento
   ENUM_ORDER_TYPE   m_close_ord_type;
   
//--- === Métodos === --- 
public:
   //--- Construtor/destrutor
   void              CModeBase();
   void             ~CModeBase(void){};
   //--- Inicialização
   virtual bool      Init(int _fast_ema,int slow_ema,int _sig,ENUM_APPLIED_PRICE _app_price);
   virtual void      Deinit(void){};

   //--- Módulos
   virtual void      Main(void){};

   //--- Procedimentos
   virtual void      Open(void){};
   virtual void      Close(void){};
   virtual void      Trail(void){};

   //--- Serviço
   static ENUM_MQL_MODE CheckMqlMode(void);
   ENUM_MQL_MODE     GetMqlMode(void);
   void              SetMqlMode(const ENUM_MQL_MODE _mode);
   void              SetTrailing(const uint _trailing,const uint _trail_step);

protected:
   //--- Funções
   ENUM_ORDER_TYPE   CheckOpenSignal(const ENUM_ORDER_TYPE _open_sig);
   ENUM_ORDER_TYPE   CheckCloseSignal(const ENUM_ORDER_TYPE _close_sig);
   ENUM_ORDER_TYPE   CheckTrailSignal(const ENUM_ORDER_TYPE _trail_sig,double &_sl_pr);
   //---
   double            GetMacdVal(const int _idx,const bool _is_main=true);

private:
   //--- Macros
   bool              RefreshIndicatorData(void);
   //--- Normalização
   double            NormalPrice(double d);
   double            NormalDbl(double d,int n=-1);
   double            NormalSL(const ENUM_ORDER_TYPE _ord_type,double op,double pr,
                              uint SL,double stop);
   double            NormalTP(const ENUM_ORDER_TYPE _ord_type,double op,double pr,
                              uint _TP,double stop);
   double            NormalLot(const double _lot);
  };

Tudo pode ser incluído em uma classe de base, desde que ela seja usada nas classes herdada.

Os dados do MACD não estarão disponíveis para os descendentes já que eles são representados pelos membros privados.

Deve-se notar que entre esses métodos há alguns virtuais: Main(), Open(), Close(), Trail(). A sua aplicação vai depender muito sobre o modo em que o EA está trabalhando no momento. Esses métodos vão ficar vazios para a classe de base.

Além disso, a classe de base compreende os métodos que têm a mesma lógica de negociação para todos os modos MQL. Todos os métodos de sinalização pertencem a eles:

  • CModeBase::CheckOpenSignal(),
  • CModeBase::CheckCloseSignal(),
  • CModeBase::CheckTrailSignal().

Deve-se ter em mente, que este artigo não se destina a escrever o código para todos os tipos de modo MQL. Os testes visuais e o padrão vão servir de exemplo.


3.1. Modo Teste

Depois que o algoritmo foi codificado e compilado, eu costumo testar a estratégia nos dados históricos do Strategy Tester para verificar se ele funciona como projetado.

Na maioria das vezes ele é obrigado a verificar a precisão com o qual o sistema implementa os sinais de negociação. Em qualquer caso, o objetivo fundamental nesta fase para o EA é ser lançado e negociar.

A classe CModeTester para testes regulares pode ser implementada como se segue:

//+------------------------------------------------------------------+
//| Classe CModeTester                                               |
//| Objetivo: uma classe para o modo de teste                        |            
//| Deriva da classe CModeBase.                                      |
//+------------------------------------------------------------------+
class CModeTester : public CModeBase
  {
//--- === Métodos === --- 
public:
   //--- Construtor/destrutor
   void              CModeTester(void){};
   void             ~CModeTester(void){};

   //--- Módulos
   virtual void      Main(void);

   //--- Procedimentos
   virtual void      Open(void);
   virtual void      Close(void);
   virtual void      Trail(void);
  };

O módulo principal é implementado como:

//+------------------------------------------------------------------+
//| Módulo principal                                                 |
//+------------------------------------------------------------------+
void CModeTester::Main(void)
  {
//--- 1) Encerramento
   this.Close();
//--- 2) Abertura
   this.Open();
//--- 3) Stop móvel
   this.Trail();
  }

Para o modo de testes regulares, cria uma oportunidade para imprimir as informações sobre os sinais de negociação no registro.

Adiciona strings contendo valores dos indicadores que são considerados a fonte do sinal de negociação.

Abaixo está um extrato do registro sobre um sinal que abre uma posição seguido por um sinal para fechar.

HE      0       13:34:04.118    Core 1  2014.11.14 22:15:00   ---=== Signal to open: SELL===---
FI      0       13:34:04.118    Core 1  2014.11.14 22:15:00   A bar before the last one, main: 0.002117; signal: 0.002109
DL      0       13:34:04.118    Core 1  2014.11.14 22:15:00   The last bar, main: 0.002001; signal: 0.002118
LO      0       13:34:04.118    Core 1  2014.11.14 22:15:00   market sell 0.03 EURUSD.e (1.25242 / 1.25251 / 1.25242)
KH      0       13:34:04.118    Core 1  2014.11.14 22:15:00   deal #660 sell 0.03 EURUSD.e at 1.25242 done (based on order #660)
GE      0       13:34:04.118    Core 1  2014.11.14 22:15:00   deal performed [#660 sell 0.03 EURUSD.e at 1.25242]
OD      0       13:34:04.118    Core 1  2014.11.14 22:15:00   order performed sell 0.03 at 1.25242 [#660 sell 0.03 EURUSD.e at 1.25242]
IK      0       13:34:04.118    Core 1  2014.11.14 22:15:00   CTrade::OrderSend: market sell 0.03 EURUSD.e [done at 1.25242]
IL      0       13:34:04.118    Core 1  2014.11.17 13:30:20   
CJ      0       13:34:04.118    Core 1  2014.11.17 13:30:20   ---=== Signal to close: SELL===---
GN      0       13:34:04.118    Core 1  2014.11.17 13:30:20   A bar before the last one, main: -0.001218; signal: -0.001148
QL      0       13:34:04.118    Core 1  2014.11.17 13:30:20   The last bar, main: -0.001123; signal: -0.001189
EP      0       13:34:04.118    Core 1  2014.11.17 13:30:20   market buy 0.03 EURUSD.e (1.25039 / 1.25047 / 1.25039)
FG      0       13:34:04.118    Core 1  2014.11.17 13:30:20   deal #661 buy 0.03 EURUSD.e at 1.25047 done (based on order #661)
OJ      0       13:34:04.118    Core 1  2014.11.17 13:30:20   deal performed [#661 buy 0.03 EURUSD.e at 1.25047]
PD      0       13:34:04.118    Core 1  2014.11.17 13:30:20   order performed buy 0.03 at 1.25047 [#661 buy 0.03 EURUSD.e at 1.25047]
HE      0       13:34:04.118    Core 1  2014.11.17 13:30:20   CTrade::OrderSend: market buy 0.03 EURUSD.e [done at 1.25047]

Por favor, note que não há registros "Experts" no Strategy Tester. Todas as informações podem ser encontradas na guia "Diário", que contém registros sobre as ações executadas pelo Strategy Tester durante os testes e otimização.

É por isso que a pessoa tem que procurar as strings necessárias. Se a informação de entrada precisa ser separada, ela pode ser gravada em um arquivo.

A estratégia para o teste padrão é implementado no código do EA TestMode_tester.mq5.


3.2. Modo de Teste Visual

Às vezes é necessário se referir a um gráfico ao vivo e ver como o EA está lidando com a situação atual.

A visualização simples permite não só ver como o sistema de negociação está reagindo aos ticks, mas também para comparar os modelos de preços semelhantes no final do teste.

A definição da classe de teste visual CModeVisual é a seguinte:

//+------------------------------------------------------------------+
//| Classe CModeVisual                                               |
//| Objetivo: uma classe para o modo de teste                        |            
//| Derivada da classe CModeBase.                                    |
//+------------------------------------------------------------------+
class CModeVisual : public CModeTester
  {
//--- === Os membros de dados === --- 
private:
   CArrayObj         m_objects_arr;
   double            m_subwindow_max;
   double            m_subwindow_min;
   
//--- === Métodos === --- 
public:
   //--- Construtor/destrutor
   void              CModeVisual(void);
   void             ~CModeVisual(void);

   //--- Procedimentos
   virtual void      Open(void);
   virtual void      Close(void);

private:
   bool              CreateSignalLine(const bool _is_open_sig,const bool _is_new_bar=true);
   bool              CreateRectangle(const ENUM_ORDER_TYPE _signal);
   void              RefreshRectangles(void);
  };

A classe contém membros ocultos. Um membro da classe m_objects_arr implementa um array dinâmico do tipo CArrayObj. Objetos gráficos, por exemplo, linhas e retângulos, pertencem aqui. Dois outros membros da classe (m_subwindow_max, m_subwindow_min) controlam o tamanho máximo e mínimoo da sub-janela do indicador.

Métodos privados são responsáveis ​​por trabalhar com objetos gráficos.

Esta classe não contém os métods Main() e Trail(). Seus análogos parentais CModeTester::Main () e CModeTester::Trail () serão chamados respectivamente.

Objectos gráficos podem ser criados no modo de teste visual. Isto não pode ser feito em outros modos do Strategy Tester.

Deixe uma linha vertical vermelha ser desenhada no gráfico quando um sinal de entrada aparecer e uma linha vertical azul quando um sinal de fechamento é recebido. Preencha o espaço entre os pontos de entrada e de saída com um retângulo da cor relevante na sub-janela do indicador.

Se é uma posição comprada, em seguida, o retângulo é azul claro. Se a posição é vendida, o retângulo é rosa (Fig.6).

Fig.6. Objetos gráficos no modo visual de teste

Fig.6. Objetos gráficos no modo visual de teste

A altura do retângulo depende dos valores da máxima e mínima da sub-janela do gráfico no momento da criação. Para fazer com que todos os retângulos sejam iguais em tamanho, um bloco de mudança de coordenadas do retângulo deve ser adicionado ao código, caso as coordenadas do gráfico da sub-janela mudem.

Assim, na sub-janela do indicador MACD temos as seguintes áreas: sem cor (sem posição), rosa (posição vendida), azul claro (posição comprada).

Estratégia para o modo de teste visual é implementado no código do EA TestMode_visual_tester.mq5.


Conclusão

Neste artigo eu tentei ilustrar os recursos do modos do terminal MetaTrader 5 e a linguagem MQL5. Tem que ser dito que uma abordagem multi-modo para a programação de um algoritmo de negociação envolve mais custos, por um lado e, por outro lado, há uma oportunidade para considerar cada fase de desenvolvimento, um após o outro. A programação orientada a objeto é um auxílio engenhoso para um programador, neste caso.

Os modos da otimização e da coleta de quadro serão destacados em artigos futuros sobre as propriedades estatísticas de um sistema de negociação.


Traduzido do russo pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/ru/articles/1246

Arquivos anexados |
Baixar como ZIP
cisnewbar.mqh (13.74 KB)
modes.mqh (62.77 KB)
test1_modes_ea.mq5 (9.43 KB)
test2_modes_ea.mq5 (10.01 KB)
testmode_tester.mq5 (6.12 KB)
testmode_visual_tester.mq5 (6.32 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
Florestas Aleatórias na Previsão das Tendências Florestas Aleatórias na Previsão das Tendências
Este artigo considera o uso do pacote Rattle na busca automática de padrões para prever as posições compradas ou vendidas dos pares de moedas no Forex. Este artigo pode ser útil tanto para novatos quanto para profissionais experientes.
Ideias de Negociação Baseada na Direção dos Preços e na Velocidade do Movimento Ideias de Negociação Baseada na Direção dos Preços e na Velocidade do Movimento
O artigo fornece uma revisão de uma idéia com base na análise da direção do movimento dos preços e sua velocidade. Nós efetuamos a sua formalização na linguagem MQL4 apresentando-o como um Expert Advisor para explorar a viabilidade da estratégia que está em consideração. Nós também determinamos os melhores parâmetros por meio da verificação, examinação e da otimização de um exemplo dado no artigo.
Redes Neurais de Terceira Geração: Redes Profundas Redes Neurais de Terceira Geração: Redes Profundas
Este artigo é dedicado a uma nova perspectiva na direção da aprendizagem de máquina - o aprendizado profundo ou, para ser mais preciso, redes neurais profundas. Esta é uma breve revisão das redes neurais de segunda geração, a arquitetura de suas conexões e tipos principais, os métodos e regras de aprendizagem e suas principais desvantagens seguido pela história do desenvolvimento da rede neural de terceira geração, os seus principais tipos, peculiaridades e métodos de treinamento. Conduzida por experimentos práticos sobre a construção e treinamento de uma rede neural profunda, iniciada pelos pesos de uma pilha de autoencoders (Stacked Autoencoders) contendo dados reais. Todas as etapas, desde a seleção dos dados de entrada até a derivação métrica, serão discutidas em detalhe. A última parte do artigo contém uma implementação de um programa de rede neural profunda em um Expert Advisor com um indicador embutido, baseado em MQL4/R.
Os Erros Mais Comuns nos Programas MQL4 e Como Evitá-los Os Erros Mais Comuns nos Programas MQL4 e Como Evitá-los
Para evitar o término dos programas por erros críticos, a versão anterior do compilador tratava muitos erros no ambiente de tempo de execução. Por exemplo, a divisão por zero ou o array fora do intervalo são erros críticos e geralmente levam a uma pane do programa. O novo compilador pode detectar a origem real ou potencial dos erros e melhorar a qualidade do código. Neste artigo, nós discutimos os possíveis erros que podem ser detectados durante a compilação de programas antigos e ver como corrigi-los.