Expert Advisor Universal: Modos de Negociação das Estratégias (Parte 1)

MetaTrader 5 — Exemplos | 19 julho 2016, 12:09

2 594

Vasiliy Sokolov

Conteúdo

Introdução

Várias tarefas podem surgir durante a implementação dos algoritmos das negociações automatizadas, incluindo a análise de ambiente para interpretar os sinais de entrada no mercado, e também fechamento de uma posição existente. Outra tarefa possível é o controle das operações do Expert Advisor e o tratamento adequado dos erros das negociações. Finalmente, é uma tarefa de acesso fácil e prática dos dados de mercado e posições de negociação do Expert Advisor. Todas estas tarefas são executadas diretamente no código-fonte do Expert Advisor.

Por outro lado, devemos separar a parte técnica do processo de negociação e a ideia implementada nos Expert Advisors customizados. Com a abordagem orientada a objetos, podemos separar estas duas tarefas essencialmente diferentes de negociação e confiar na implementação do processo de negociação para uma classe especial comum a todas as estratégias, que às vezes também é referida como motor de negociação.

Este é o primeiro artigo de umasérie de artigos que descrevem o funcionamento do motor de busca, o que podemos chamar de um Expert Advisor Universal. Este nome unifica um conjunto de classes que permitem fácilmente o desenvolvimento dos algoritmos de negociação por uma enumeração usual da entrada de uma posição e as condições de saída. Você não vai precisar adicionar dados necessários e lógicas de negociação ao Expert Advisor, por exemplo, pesquisa de posição - todos os procedimentos necessários são feitos pelo motor de negociação.

O material para o artigo proposto é grande, por conseguinte, é dividido em quatro partes. Aqui estão os detalhes dessas partes.

Parte 1. Modos de Negociação das estratégias, descritos neste artigo. A primeira parte descreve o conceito de gerenciamento da posição original baseada nos modos de negociação. Uma lógica de negociação do Expert Advisor pode ser facilmente definida usando os modos de negociação. Um Expert Advisor escrito neste estilo é fácil de depurar. A lógica destes EAs torna-se universal e igual, o que também facilita a gestão de tais estratégias. As ideias expressas neste material são universais e não necessitam de programação orientada a objetos adicionais. Isto significa que você usará o conjunto de bibliotecas oferecidos independentemente ou não, este material pode ser útil para você.

Parte 2. O Modelo de Evento e o Protótipo da Estratégia de Negociação. Esta seção descreve um modelo de evento original, baseado na manipulação de eventos centralizados. Isso significa que todos os eventos são "reunidos" num único lugar da lógica de negociação e processados pelo EA. Além disso, os eventos são multi moedas. Por exemplo, se um Expert Advisor está sendo executado no gráfico EURUSD, é possível receber um evento de um novo tick do GBPUSD. Este modelo de evento pode ser extremamente útil no desenvolvimento de Expert Advisors que negociam vários instrumentos financeiros. Nesta parte, nós também iremos descrever a classe base do motor de negociação do CStrategy e a classe CPositionMT5 que representa uma posição no MetaTrader 5.

Parte 3. Estratégias Personalizadas e Classes de Negociação Auxiliares. O material abrange o processo do desenvolvimento do Expert Advisor personalizado. A partir deste artigo você vai descobrir como criar um Expert Advisor por uma simples enumeração de entrada da posição e as condições de saída. Esta parte também descreve vários algoritmos auxiliares que podem simplificar muito o acesso à informação de negociação.

Parte 4. Negociação em Grupo e Gerenciamento de uma Carteira de Estratégias. Esta parte contém uma descrição dos algoritmos especiais para a integração de várias lógicas de negociação num único módulo ex5 executável. Também descreve mecanismos que podem ser utilizados para gerar um conjunto de estratégias personalizadas utilizando um ficheiro XML.

Métodos para Abertura de Novas Posições e Gerenciamento de Outras Existentes

Para entender a abordagem oferecida neste artigo, vamos primeiro tentar descrever um sistema de negociação clássico baseado em duas médias móveis, um dos quais tem um período médio de venda, e a segunda tem um período de compra. Assim, a média móvel com um período médio maior é mais lenta do que a média móvel com um período médio menor. Regras de negociação são simples: se a média móvel rápida é superior à lenta, o EA compra. Por outro lado, se a média móvel rápida é inferior a lenta, o EA vende. O gráfico a seguir mostra a nossa estratégia esquematicamente:

Fig. 1. O gráfico de um sistema de negociação baseado em duas médias móveis

A linha vermelha mostra a média móvel rápida, com um período igual a 50. A linha azul mostra a média móvel lenta, com um período igual a 120. Quando elas cruzam (cruzamentos são marcados com linhas pontilhadas azuis), a direção da posição do Expert Advisor é revertida. Do ponto de vista da abordagem não-algorítmica, a descrição é suficiente para qualquer trader entender como negociar usando esta estratégia. No entanto, esta descrição não é suficiente para a criação de um Expert Advisor com base nesta estratégia.

Vamos considerar as ações que seriam necessárias serem executadas pelo EA no momento que a MM rápida cruza a lenta de baixo para cima:

Se o EA tem uma posição aberta de venda quando as médias móveis se cruzam, esta posição deve ser fechada.
A existência de uma posição aberta de compra deve ser verificada. Se não houver uma posição comprada, uma deve ser aberta. Se uma posição comprada já existe, nada deve ser feito.

Para um cruzamento oposto quando o MA rápida cruza a lenta de cima para baixo, as ações opostas devem ser executadas:

Se o EA tem uma posição aberta de compra quando as MMs se cruzam, esta posição deve ser fechada.
A existência de uma posição aberta de venda deve ser verificada. Se não houver uma posição vendida, uma deve ser aberta. Se uma posição vendida já existe, nada deve ser feito.

Temos quatro ações para descrever o processo de negociação da estratégia. Duas ações de negociação descrevem a posição de abertura da compra e a manutenção das regras. Duas outras ações descrevem a posição de abertura da venda e a manutenção das regras. Pode parecer que uma sequência de quatro ação seja demais para a descrição deste processo simples de negociação. Na verdade, as entradas das posições compradas coincidem com a saida das posições vendidas com na nossa estratégia, portanto, não seria mais fácil combiná-las numa negociação ou, pelo menos, numa ação lógica? Não, não seria. Para provar isso, vamos mudar as condições de nossa estratégia inicial.

Agora nossa estratégia irá utilizar diferentes conjuntos de médias móveis para compra e venda. Por exemplo, uma posição comprada será aberta quando a Média Móvel rápida com um período igual a 50 cruza uma lenta, com um período igual a 120. E uma posição vendida será aberta quando a Média Móvel rápida com um período igual a 20 cruza uma lenta, com um período igual a 70. Agora os sinais de compra serão diferentes dos sinais de venda - isto irá ocorrer em diferentes momentos e em diferentes situações do mercado.

As regras propostas não foram bem pensadas. Estratégias costumam usar condições tipo "espelho" para entradas e saídas: entrar numa posição comprada significa sair de uma vendida e vice-versa. No entanto, outros casos também são possíveis, então se quisermos criar um protótipo universal de um Expert Advisor, precisamos levar isso em conta, por isso teremos quatro regras

Além disso, vamos considerar nossas ações a partir de um ângulo diferente. A tabela abaixo mostra o tipo de operação de negociação (Compra ou Venda) e o tipo de ação de negociação (aberta ou fechada). As células da tabela contém um conjunto específico de ações:

	Compra	Venda
Aberta	1. Se não houverem posições compradas e a MM rápida com um período igual a 50 estiver acima da MM lenta, com um período igual a 120, uma posição comprada deve ser aberta.	2. Se não houverem posições vendidas e uma MM rápida com um período igual a 20 estive abaixo do MM lenta, com um período igual a 70, uma posição vendida deve ser aberta.
Fechada	3. Se a MM rápida com período igual 50 está abaixo da MM lenta com período igual a 120, uma posição comprada deve ser fechada.	4. Se a MM rápida com período igual a 120 estiver acima da MM lenta com um período igual a 70, uma posição vendida deve ser fechad.a

Tabela 1. Configuração da ação de negociação

A partir de uma perspectiva de programação, esses "conjuntos de regras" ou blocos de tabela serão funções ou métodos que fazem parte da futura classe de estratégias universais. Vamos nomear esses quatro métodos da seguinte forma:

BuyInit — o método abre novas posições compradas se for a hora certa, de acordo com as condições enumeradas na mesma;
SellInit — o método abre novas posições vendidas se for a hora certa, de acordo com as condições enumeradas na mesma;
SupportBuy — o método recebe uma posição comprada como um parâmetro. Se a posição passada precisa ser fechada, o método deve executar a ação de negociação adequada.
SupportSell — o método recebe uma posição vendida como um parâmetro. Se a posição passada precisa ser fechada, o método deve executar a ação de negociação adequada.

O que temos a partir da abordagem proposta? Em primeiro lugar, temos classificados ações de negociação que o EA tem de realizar para a execução de uma tarefa de negociação. Todas as ações são divididas em blocos independentes, isto é, métodos de classe usual. Isto significa que não teremos de pensar onde devemos manipular diferentes partes da lógica de negociação no código. A tarefa de programação é reduzida pela descrição dos quatro métodos.

Em segundo lugar, se alguma vez houver a necessidade de alterar a lógica do Expert Advisor, vamos precisar apenas incluir condições adicionais para métodos apropriados. Em terceiro lugar, o acordo proposto da lógica de negociação apoiará modos de negociação de forma simples e natural para um Expert Advisor desenvolvido neste estilo.

Modos de Negociação de uma Estratégia

Muitas vezes, as ações de negociação de um Expert Advisor precisa ser limitada. O exemplo mais simples é a de impedir que o EA execute ofertas compradas ou vendidas. O terminal MetaTrader 4 fornece um interruptor normal para estes modos. Está localizado na guia propriedades da janela do EA que aparece ao ser anexado no gráfico:

Fig. 2. Modos de negociação no MetaTrader 4

No entanto, muito mais modos estão disponíveis. Então, precisaremos de instrumentos mais flexíveis para configurá-los. Por exemplo, alguns EAs precisam de uma pausa na negociação em certos momentos. Suponha-se que durante a sessão do Pacífico do mercado Forex, o EA deve ignorar novos sinais de entrada de posição. Esta abordagem é uma maneira clássica para restringir as negociações do EA durante os períodos de baixa volatilidade. Qual é a melhor forma de implementar este modo, fazendo dele opcional? Isto pode ser feito através de arranjo com os quatro blocos da lógica da negociação.

Operações de venda podem ser desativadas por algum tempo ao desabilitar as chamadas temporária do método SellInit, que contém regras para a abertura de posições vendidas. É porque todas as ações de negociação iniciam as operações de venda que serão realizadas dentro deste método. O mesmo se aplica para operações compradas: elas não serão abertas sem a chamada do método BuyInit. Assim, certas combinações de chamadas destes métodos serão adequadas aos modos de negociação do Expert Advisor. Descrever esses métodos na Tabela 2:

Modo de negociação	Descrição	Os métodos que são chamados	Os métodos cujas chamadas são ignoradas
Operações Compradas e Vendidas	Operações Compradas e Vendidas são permitidas. Sem negociações com ordens limitadas.	BuyInit SellInit BuySupport SellSupport
Apenas operações Compradas	É permitido apenas operações compradas. Nenhuma operação Vendida será realizada. Posições vendidas abertas anteriormente são geridas pelo modo normal até serem fechadas.	BuyInit BuySupport SellSupport	SellInit
Somente operações Vendidas	São permitidas apenas operações vendidas. Nenhuma operação comprada será executada. Posições compradas abertas anteriormente são geridas pelo modo normal até que sejam fechadas.	SellInit BuySupport SellSupport	BuyInit
Agora novas entradas	Novas negociações compradas e vendidas não são permitidas. Posições de venda abertas anteriormente são geridas pelo modo normal até que sejam fechadas por sinais de saída.	BuySupport SellSupport	BuyInit SellInit
Pausa	Posições anteriormente abertas não são gerenciadas. Inicialização de novas negociações compradas e vendidas estão paradas. Este modo é geralmente usado quando o mercado está fechado e ações de negociação não podem ser realizadas.		BuyInit SellInit BuySupport SellSupport
Stop	Todas as posições abertas anteriormente são fechadas. Operações Compradas e Vendidas não são inicializados.	Todas as posições são fechadas utilizando um método especial	BuyInit SellInit BuySupport SellSupport

Tabela 2. Modo de Negociação com Interruptor CTradeState

Todos os modos de negociação são através da aplicação prática em MQL usando uma estrutura especial: ENUM_TRADE_STATE. Aqui está sua descrição:

//+------------------------------------------------------------------+
//| Determina o estado de negociação do EA.                          |
//+------------------------------------------------------------------+
enum ENUM_TRADE_STATE
{
   TRADE_BUY_AND_SELL,              // Operações Compradas e Vendidas são permitidas.
   TRADE_BUY_ONLY,                  // Somente operações Compradas são permitidas. Operações vendidas não são permitidas.
   TRADE_SELL_ONLY,                 // Apenas as operações Vendidas são permitidas. Operações Compradas não são permitidas.
   TRADE_STOP,                      // Não são permitidas as negociações. Fecha todas as posições imediatamente. Não aceita novos sinais de entrada.
   TRADE_WAIT,                      // É perdido o controle sobre as posições abertas. Novos sinais são ignorados. Útil durante novos lançamentos.
   TRADE_NO_NEW_ENTRY               // Sinais de entrada são ignorados. No entanto, as posições abertas são mantidas de acordo com a lógica da negociação. 
};

Estes modos permitem que qualquer Expert Advisor desenvolvido sob a abordagem proposta possa ter a flexibilidade de conectar e desconectar os módulos de negociação, para assim ligá-lo dinamicamente a um ou outro modo de negociação.

Modo de Negociação com Interruptor CTradeState

Usando os modos de negociação, o Expert Advisor será sempre entendeár o momento de executar determinadas ações. No entanto, este ponto deve ser determinado individualmente em cada Expert Advisor. O controle do modo de negociação é particularmente necessário quando das operações na seção FORTS da MICEX. Negociação com FORTS tem várias características específicas, a principal é que a compensação realizada duas vezes por dia, das 14:00 as 14:03 (compensação média) e das 18:45 às 19:00 (compensação principal). É aconselhável não permitir a realização de operações de negociação com Expert Advisors durante a compensação.

Claro que, se um EA apenas realiza operações com a chegada de novos ticks ou formação de novas barras, não vai funcionar enquanto o mercado estiver fechado, porque novas cotações não serão recebidas. Mas muitos Expert Advisors operam em intervalos especificos (usando um timer). Para tais EAs, o controle sobre as ações de negociação é essencial. Além disso, algumas vezes as negociações podem ser realizadas nos fins de semana e feriados, e algumas corretoras do Forex as permitem. No entanto, devido à baixa volatilidade de tais dias, bem como a significativa baixa estatística, é melhor que este dias sejam ignorados.

De qualquer forma, o controle sobre os modos de negociação é um procedimento necessário para qualquer trader que usa algorítmo profissional. Esta tarefa pode ser confiada ao módulo especial CTradeState. Este módulo é implementado como uma classe MQL5, a sua tarefa é devolver o modo de negociação correspondente ao tempo corrente. Por exemplo, se o tempo atual corresponde ao horário da compensaçao, o módulo irá retornar ao estado TRADE_WAIT . Se é hora de fechar todas as posições, o módulo retornará TRADE_STOP. Vamos descrever abaixo seus métodos de operação e configuração com mais detalhes. Aqui é o cabeçalho desta classe:

//+------------------------------------------------------------------+
//|                                                  TimeControl.mqh |
//|                                 Copyright 2015, Vasiliy Sokolov. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2015, Vasiliy Sokolov."
#property link      "http://www.mql5.com"
#include "Strategy.mqh"
#define ALL_DAYS_OF_WEEK 7
//+------------------------------------------------------------------+
//| Módulo do estado de negociação TradeStation                      |
//+------------------------------------------------------------------+
class CTradeState
{
private:
   ENUM_TRADE_STATE  m_state[60*24*7];  // Máscara dos estados de negociação
public:
                     CTradeState(void);
                     CTradeState(ENUM_TRADE_STATE default_state);
   ENUM_TRADE_STATE  GetTradeState(void);
   ENUM_TRADE_STATE  GetTradeState(datetime time_current);
   void              SetTradeState(datetime time_begin, datetime time_end, int day_of_week, ENUM_TRADE_STATE state);
};

A principal tarefa desta classe é voltar ao modo atual da estratégia, onde é necessário chamar o método GetTradeState. Antes do módulo retornar o estado, ele deve ser adicionado usando o método SetTradeState.

O algoritmo de operação do módulo é semelhante a guia "Agenda" da aba do agente testador MetaTrader 5:

Fig. 3. A guia Agenda no agente de testador MetaTrader 5

Esta janela permite definir os dias da semana durante o qual o agente pode executar tarefas da Rede Nuvem MQL5. A classe CTradeState funciona de forma semelhante, mas permite que você defina um dos cinco valores do ENUM_TRADE_STATE para cada faixa.

Para entender melhor como usar CTradeState, vamos configurar o módulo dos estados de negociação. Para as operações diárias no mercado FORTS, o autor do artigo utiliza a seguinte configuração apresentada como uma tabela:

Timing	Modo	Descrição
10:00-10:01	TRADE_WAIT	Tempo de abertura do mercado. O momento de abertura é caracterizado por alta volatilidade e picos de preços. As atividades de negociação nestes momentos estão associadas a riscos elevados, por isso nos primeiros minutos após a abertura da sessão, é melhor se abster de negociar, o EA será definido no modo de espera.
14:00 - 14:03	TRADE_WAIT	Hora da Compensação Intermediária. Neste intervalo de tempo, o mercado não funciona, por isso também o EA deve ser definido para o modo TRADE_WAIT.
18:45 - 18:49	TRADE_WAIT	Hora da Compensação Principal Neste momento, o mercado também está fechado e a negociação está desativada. O modo TRADE_WAIT é ativado.
23:50 - 9:59	TRADE_WAIT	Mercado está fechado, a negociação está desativada. O modo do EA é TRADE_WAIT.
Sexta-feira, as 15:00	TRADE_NO_NEW_ENTRY	Sexta-feira — o último dia de negociação da semana. A fim de não deixar posições abertas no final de semana, elas precisam ser fechadas no último dia da negociação. Portanto, não há nenhum ponto de abertura para novas posições no último dia da negociação, somente para fechá-las algumas horas mais tarde. Por estas mesmas razões o método NO_NEW_ENTRY é usado. Toda sexta-feira, a partir das 15:00, novos sinais de entrada são ignorados. As posições existentes só pode ser fechadas.
Sexta-feira, 23:40-23:50	TRADE_STOP	O horário antes do fechamento do mercado. Este é o momento em que todas as posições devem ser fechadas. O interruptor do EA muda para o método TRADE_STOP às 23:40, fecha a sua posição e conecta o modo de espera.
Sábado, Domingo	TRADE_WAIT	A negociação não é realizada durante o final de semana. Devido à transferência de feriados, alguns sábados podem ter atividades de trabalho. A Bolsa estará trabalhando em tais dias. Este é um caso muito raro, tais dias de "trabalho" devem ser evitados devido à baixa volatilidade e incerteza das estatística. A negociação nestes dias devem ser desativadas, independentemente de se tratar de um dia de trabalho ou não.

Tabela 3. Modos de negociação, dependendo do horário

Como pode ser visto a partir na tabela, esta a configuração necessária é uma tarefa desafiadora, mas a classe CTradeState permite a criação de tais combinações de modos. Abaixo está o exemplo de um script que define os modos da tabela e, em seguida, solicita o método correspondente a um período de tempo em particular:

//+------------------------------------------------------------------+
//|                                               TestTradeState.mq5 |
//|                                 Copyright 2015, Vasiliy Sokolov. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2015, Vasiliy Sokolov."
#property link      "http://www.mql5.com"
#property version   "1.00"
#include <Strategy\TradeState.mqh>

CTradeState TradeState(TRADE_BUY_AND_SELL);  // Defina o modo padrão para Compra e Venda
//+------------------------------------------------------------------+
//| Função de início do programa script                              |
//+------------------------------------------------------------------+
void OnStart()
{
   TradeState.SetTradeState(D'15:00', D'23:39', FRIDAY, TRADE_NO_NEW_ENTRY);
   TradeState.SetTradeState(D'10:00', D'10:01', ALL_DAYS_OF_WEEK, TRADE_WAIT);
   TradeState.SetTradeState(D'14:00', D'14:03', ALL_DAYS_OF_WEEK, TRADE_WAIT);
   TradeState.SetTradeState(D'18:45', D'18:59', ALL_DAYS_OF_WEEK, TRADE_WAIT);
   TradeState.SetTradeState(D'23:50', D'23:59', ALL_DAYS_OF_WEEK, TRADE_WAIT);
   TradeState.SetTradeState(D'0:00',  D'9:59',  ALL_DAYS_OF_WEEK, TRADE_WAIT);
   TradeState.SetTradeState(D'23:40', D'23:49', FRIDAY, TRADE_STOP);
   TradeState.SetTradeState(D'00:00', D'23:59', SATURDAY, TRADE_WAIT);
   TradeState.SetTradeState(D'00:00', D'23:59', SUNDAY, TRADE_WAIT);
   
   printf("10:00 - " + EnumToString(TradeState.GetTradeState(D'10:00')));
   printf("14:01 - " + EnumToString(TradeState.GetTradeState(D'14:01')));
   printf("18:50 - " + EnumToString(TradeState.GetTradeState(D'18:50')));
   printf("23:50 - " + EnumToString(TradeState.GetTradeState(D'23:51')));
   printf("Friday, > 15:00 - " + EnumToString(TradeState.GetTradeState(D'2015.11.27 15:00')));
   printf("Saturday - " + EnumToString(TradeState.GetTradeState(D'2015.11.28')));
   printf("Sunday - " + EnumToString(TradeState.GetTradeState(D'2015.11.29')));
   printf("Default State - " + EnumToString(TradeState.GetTradeState(D'11:40')));
}
//+------------------------------------------------------------------+

A saída do script será parecido com isto:

Estado Padrão - TRADE_BUY_AND_SELL
Sábado - TRADE_WAIT
Domingo - TRADE_WAIT
Friday, > 15:00 - TRADE_NO_NEW_ENTRY
23:50 - TRADE_STOP
18:50 - TRADE_WAIT
14:01 - TRADE_WAIT
10:00 - TRADE_WAIT

Por favor, note como o formato dos modos de negociação são definidos. Eles não usam componentes de data, apenas as horas e minutos (D'15: 00 "ou D'18: 40 '). Se usar a data completa com o método, por exemplo:

TradeState.SetTradeState(D'2015.11.27 15:00', D'2015.11.27 23:39', FRIDAY, TRADE_NO_NEW_ENTRY);

o componente data ainda será ignorado.

O segundo ponto a ser observado é a seqüência de chamadas SetTradeState. A sequência importa! O módulo CTradeState armazena a máscara dos estados de negociação com o array ENUM_TRADE_STATE, onde o número de elementos é igual ao número de minutos na semana (10.080 elementos). Usando as datas anteriores, o método SetTradeState calcula o intervalo de elementos deste array e o preenche com o estado apropriado. Isto significa que o estado anterior é substituído por um novo. Assim, a última atualização é definida como o estado final. O código deste método é dado abaixo:

//+------------------------------------------------------------------+
//| Define o estado de negociação TradeStation                       |
//| INPUT:                                                           |
//| time_begin  - Tempo, a partir de qual o estado de negociação é   |
//|              válido.                                             |
//| time_end    - tempo em que o estado de negociação é válido       |
//| day_of_week - Dia da semana, a configuração do estado de         |
//|       de negociação é aplicado. Corresponde aos modificadores    |
//|               ENUM_DAY_OF_WEEK or the modifier ALL_DAYS_OF_WEEK  |
//| state       - O estado de negociação.                            |
//| Nota: componentes de data em time_begin e time_end são ignorados |
//+------------------------------------------------------------------+
void CTradeState::SetTradeState(datetime time_begin,datetime time_end, int day_of_week, ENUM_TRADE_STATE state)
{
   if(time_begin > time_end)
   {
      string sb = TimeToString(time_begin, TIME_MINUTES);
      string se = TimeToString(time_end, TIME_MINUTES);
      printf("Time " + sb + " must be more time " + se);
      return;
   }
   MqlDateTime btime, etime;
   TimeToStruct(time_begin, btime);
   TimeToStruct(time_end,  etime);
   for(int day = 0; day < ALL_DAYS_OF_WEEK; day++)
   {
      if(day != day_of_week && day_of_week != ALL_DAYS_OF_WEEK)
         continue;
      int i_day = day*60*24;
      int i_begin = i_day + (btime.hour*60) + btime.min;
      int i_end = i_day + (etime.hour*60) + etime.min;
      for(int i = i_begin; i <= i_end; i++)
         m_state[i] = state;
   }
}

O GetTradeState é facil de usar. Ele calcula o índice do elemento de array que corresponde ao horário solicitado, então retorna o valor do elemento:

//+------------------------------------------------------------------+
//| Retorna o estado de negociação previamente definido no tempo     |
//| passado.                                                         |
//+------------------------------------------------------------------+
ENUM_TRADE_STATE CTradeState::GetTradeState(datetime time_current)
{
   MqlDateTime dt;
   TimeToStruct(time_current, dt);
   int i_day = dt.day_of_week*60*24;
   int index = i_day + (dt.hour*60) + dt.min;
   return m_state[index];
}

O código-fonte completo da classe CTradeState está disponível no arquivo TradeState.mqh e o motor de negociação descrito está incluído no código fonte. Os próximos artigos vão demonstrar como esta classe trabalha o motor de negociação.

Conclusão

Nós descrevemos as quatro regras de negociação principal, com o qual você pode facilmente e rapidamente definir a lógica de quase todos os Expert Advisors. Cada regra de negociação é uma função separada ou um método de classe. Várias combinações de chamadas dos modos determinam o modo particular da estratégia. Assim, um sistema de gestão flexível de Expert Advisor é implementado, utilizando o mínimo de recursos.

Na próxima parte desta série, vamos discutir um modelo centralizado e eventos - o que faz os métodos básicos da lógica de negociação compreenderem o evento ocorrido. Também vamos discutir algoritmos de negociação auxiliares, que facilitam muito a obtenção de informações das negociações.

Você pode baixar e instalar o código completo da biblioteca "Expert Advisor Universal" para o seu computador. O código fonte da biblioteca está anexado a este artigo. Descrição de mais classes desta biblioteca serão dadas nos próximos artigos desta série.

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

Arquivos anexados |

Baixar como ZIP

strategyarticle.zip (100.09 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

Interfaces Gráficas I: Preparação da Estrutura da Biblioteca (Capítulo 1)

Este artigo é o começo de uma outra série sobre o desenvolvimento de interfaces gráficas. Atualmente, não há uma única biblioteca de código que permite a criação rápida e fácil de interfaces gráficas de alta qualidade dentro das aplicações em MQL. Me refiro as interfaces gráficas que estamos acostumados nos sistemas operacionais comuns.

Expert Advisor Universal: Estratégias Personalizadas e Classes Auxiliares de Negociação (Parte 3)

Neste artigo, vamos continuar a análise dos algoritmos do motor de negociação CStrategy. A terceira parte da série contém uma análise detalhada com exemplos de como desenvolver estratégias de negociação específicas usando esta abordagem. É dada uma atenção especial aos algoritmos auxiliares - sistema de registro Expert Advisor e acesso a dados usando um indexador convencional (Close[1], Open[0], etc).

Expert Advisor Universal: O Modelo de Evento e o Protótipo da Estratégia de Negociação (Parte 2)

Este artigo continua a série de publicações do modelo universal de um Expert Advisor. Esta parte descreve em detalhes o modelo de eventos original, baseado no processamento de dados centralizado e considera a estrutura da classe base CStrategy.

Guia Prático MQL5 - Programando os Canais Móveis

Este artigo apresenta um método de programação de um sistema de canais equidistantes. Alguns detalhes da construção de tais canais estarão sendo considerados aqui. É fornecido a tipificação do canal, propondo um método de canais móveis do tipo universal. Para implementar o código, foi utilizado a Programação Orientada a Objetos (POO).