![Programando os Modos do EA Usando a Abordagem Orientada a Objetos](https://c.mql5.com/i/articles/overlay.png)
Programando os Modos do EA Usando a Abordagem Orientada a Objetos
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
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
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:
- Modos que exigem o arquivo de código-fonte e o arquivo executável;
- 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.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:
- Abertura pelo sinal se não houver nenhuma posição em aberto;
- Fechamento pelo sinal se houver uma posição em aberto;
- 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
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
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
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
![Florestas Aleatórias na Previsão das Tendências](https://c.mql5.com/2/11/Random_Forest_MetaTrader5.png)
![Ideias de Negociação Baseada na Direção dos Preços e na Velocidade do Movimento](https://c.mql5.com/2/18/zbm4cy.png)
![Redes Neurais de Terceira Geração: Redes Profundas](https://c.mql5.com/2/12/Deep_neural_network_MetaTrader5__2.png)
![Os Erros Mais Comuns nos Programas MQL4 e Como Evitá-los](https://c.mql5.com/2/13/1152_84.png)
![MQL5 - Linguagem para estratégias de negociação inseridas no terminal do cliente MetaTrader 5](https://c.mql5.com/i/registerlandings/logo-2.png)
- Aplicativos de negociação gratuitos
- 8 000+ sinais para cópia
- Notícias econômicas para análise dos mercados financeiros
Você concorda com a política do site e com os termos de uso