Discussão do artigo "Assistente MQL5: Como criar um módulo de sinais de comércio" - página 7

Novo comentário
 
t101:
Devo adicioná-lo manualmente em OnInit()? Então não posso fazer o que quero por meio do assistente?
Quais são os problemas? Você está introduzindo uma funcionalidade adicional, portanto, precisa fazer um pouco de trabalho manual.
 
Karputov Vladimir:
Qual é o problema? Você está introduzindo uma funcionalidade adicional, portanto, precisa fazer um pouco de trabalho manual.

Não há problema algum, mas isso não corresponde ao conceito de que o Master faz tudo com base em módulos personalizados para sinais, capital etc. E o artigo está desatualizado e não é verdade:

O método CheckCloseLong() gera um sinal para fechar uma posição longa com a determinação do nível de saída. Ele é chamado pelo Expert Advisor para determinar a necessidade de fechar uma posição longa. É necessário substituir o método caso se pretenda gerar um sinal para fechar uma posição longa. 

virtual bool CheckCloseLong(double& price);
De qualquer forma, obrigado por sua ajuda.
[Excluído]  
Quase 6 anos se passaram, o artigo não está desatualizado? Não tenho certeza, pois vejo o terminal atualizado quase toda semana.
 
yerlan Imangeldinov:
Já se passaram quase 6 anos e o artigo não está desatualizado? Não tenho certeza, pois vejo o terminal atualizado quase toda semana.
Há um artigo mais recente sobre como escrever módulos de sinais de negociação:"Create a trading robot in six hours!".
 

Olá a todos,

Gostaria de saber como criar um descendente de CExpertSignal com os dois padrões "break out" e "break in" em uma faixa de negociação observada usando a abordagem proposta aqui e também em Exploring Trading Strategy Classes of the Standard Library - Customizing Strategie by Harvester. Minha percepção é que toda classe de sinal poderia (deveria) ser implementada por meio da sobrecarga de

//+------------------------------------------------------------------+
//| "Votando" que o preço crescerá.|
//| INPUT: não.|
//| RESULTADO: número de "votos" para que o preço cresça.
//| OBSERVAÇÃO: não.|
//+------------------------------------------------------------------+
int CSignalBreakOutOrIn::LongCondition()
  {
   int result=0;
   int idx   =StartIndex();
//---
   //--- apenas no caso de querermos algum tipo de padrão padrão
   if(IS_PATTERN_USAGE(0)) result=m_pattern_0;                                   // sinal de "confirmação" número 0
   //--- se o modelo 1 for usado, verifique a condição do padrão 1
   if(IS_PATTERN_USAGE(1) && ConditionForPattern1(idx)) result=m_pattern_1;      // sinal número 1
   //--- se o modelo 2 for usado, verifique a condição para o padrão 2
   if(IS_PATTERN_USAGE(2) && ConditionForPattern2(idx)) result=m_pattern_2;      // sinal número 2
//--- retornar o resultado
   return(result);
  }

e

//+------------------------------------------------------------------+
//| "Votando" que o preço cairá.|
//| INPUT: não.|
//| RESULTADO: número de "votos" de que o preço cairá.
//| OBSERVAÇÃO: não.|
//+------------------------------------------------------------------+
int CSignalBreakOutOrIn::ShortCondition()
  {
   int result=0;
   int idx   =StartIndex();
//---
   //--- apenas no caso de querermos algum tipo de padrão padrão
   if(IS_PATTERN_USAGE(0)) result=m_pattern_0;                                   // sinal de "confirmação" número 0
   //--- se o modelo 1 for usado, verifique a condição do padrão 1
   if(IS_PATTERN_USAGE(1) && ConditionForPattern1(idx)) result=m_pattern_1;      // sinal número 1
   //--- se o modelo 2 for usado, verifique a condição para o padrão 2
   if(IS_PATTERN_USAGE(2) && ConditionForPattern2(idx)) result=m_pattern_2;      // sinal número 2
//--- retornar o resultado
   return(result);
  }

Então, encontramos

int CExpertSignal::Direction()
  {
   ...
   int result=LongCondition()-ShortCondition();
   ...
  }

cujo resultado é testado contra signal.m_threshold_open e signal.m_threshold_close em

  1. bool CExpertSignal::CheckOpenLong(...),
  2. bool CExpertSignal::CheckOpenShort(...),
  3. bool CExpertSignal::CheckCloseLong(...),
  4. bool CExpertSignal::CheckCloseShort(...),
  5. bool CExpertSignal::CheckReverseLong(...), e
  6. bool CExpertSignal::CheckReverseShort(...).

Os parâmetros que especificam os níveis para entrar no mercado e definir os preços de stop loss e take profit seriam então retornados por

//+------------------------------------------------------------------+
//| Detectando os níveis para compra|
//+------------------------------------------------------------------+
bool CExpertSignal::OpenLongParams(double &price,double &sl,double &tp,datetime &expiration)
  {
  }
//+------------------------------------------------------------------+
//| Detecção dos níveis de venda|
//+------------------------------------------------------------------+
bool CExpertSignal::OpenShortParams(double &price,double &sl,double &tp,datetime &expiration)
  {
  }

que são invocados pela implementação padrão de bool CExpertSignal::CheckOpenLong(...) e bool CExpertSignal::CheckOpenShort(...), conforme definido na classe base. Portanto, deve ser suficiente sobrecarregar

  1. int CExpertSignal::LongCondition(...),
  2. int CExpertSignal::ShortCondition(...),
  3. bool CExpertSignal::OpenLongParams(...),
  4. bool CExpertSignal::OpenShortParams(...),
  5. bool CExpertSignal::CloseLongParams(...), e
  6. bool CExpertSignal::CloseShortParams(...)

para definir um novo sinal arbitrário. Observe que o CExpertTrade contém o código para detectar se o preço de entrada desejado está muito distante do preço atual para a colocação de ordens a mercado e usa a escolha do preço de entrada para decidir automaticamente se deve ser colocada uma ordem stop ou limit.

No entanto, se a faixa de negociação for definida como a região entre a máxima mais alta (HH) e a mínima mais baixa (LL) das últimas n barras, então a condição LL < preço < HH é sempre verdadeira. Portanto, tanto o int CExpertSignal::LongCondition(...) quanto o int CExpertSignal::ShortCondition(...) devem sempre detectar o padrão 0 "break out" e, independentemente do valor que associarmos a esse padrão, a função int CExpertSignal::Direction() sempre retornará zero!

A abordagem natural de sobrecarregar

  1. bool CExpertSignal::CheckOpenLong(...) e
  2. bool CExpertSignal::CheckOpenShort(...)

de modo que o primeiro verifica

  1. LongCondition()>m_threshold_open e o segundo verifica
  2. ShortCondition()>m_threshold_open

em vez de

  1. m_direction>=m_threshold_open e
  2. -m_direction>=m_threshold_open

ainda não pôde ser transformado em uma versão bem-sucedida. Conforme apontado, seria simples fazer com que o bool CExpertSignal::OpenLongParams(...) retornasse o preço de entrada HH e que o bool CExpertSignal::OpenShortParams(...)retornasse o preço de entrada LL para completar o sinal gerando continuamente duas ordens stop.

Na minha opinião, é desejável ter um exemplo que mostre como implementar essa estratégia de break out padrão em termos da biblioteca padrão e torná-la flexível o suficiente, fornecendo o padrão alternativo "break in" que resulta em ordens limitadas em LL e HH. Obviamente, esse sinal combinaria as estratégias

  1. comprar na alta e vender na alta ou vender na baixa e comprar na baixa, bem como a alternativa
  2. comprar na baixa e vender na alta ou vender na alta e comprar na baixa.

fornecendo-as como padrões. Ficarei extremamente grato se me ajudarem a concluir essa abordagem.

 
AnonymousTrades:

Olá a todos,

Gostaria de saber como criar um descendente de CExpertSignal com os dois padrões "break out" e "break in" em uma faixa de negociação observada usando a abordagem proposta aqui e também em Exploring Trading Strategy Classes of the Standard Library - Customizing Strategie by Harvester. Minha percepção é que toda classe de sinal poderia (deveria) ser implementada por meio da sobrecarga das duas funções

int CSignalBreakOutOrIn::LongCondition()  { if(IS_PATTERN_USAGE(X) && LongConditionForPatternX(idx)) return(m_pattern_X); }
int CSignalBreakOutOrIn::ShortCondition() { if(IS_PATTERN_USAGE(X) && ShortConditionForPatternX(idx)) return(m_pattern_X); }

Observe que a CExpertTrade contém o código para detectar se o preço de entrada desejado está muito distante do preço atual para a colocação de ordens a mercado e usa a escolha do preço de entrada para decidir automaticamente se deve ser colocada uma ordem stop ou uma ordem limite.

[...]

Em minha opinião, é desejável ter um exemplo que mostre como implementar essa estratégia de break out padrão em termos da biblioteca padrão e torná-la flexível o suficiente, fornecendo o padrão alternativo "break in" que resulta em ordens de limite em LL e HH.


Decidi reformular minhas preocupações para que sejam compreendidas da forma mais fácil possível. Em minha opinião, os dois artigos

  1. MQL5 Wizard: Como criar um módulo de sinais de negociação (este) e
  2. Explorando as classes de estratégia de negociação da biblioteca padrão - Personalizando estratégias da Harvester Trading

demonstram , em geral, como escrever nossas próprias classes de sinais da maneira mais simples possível. Vou resumir essa minha percepção abaixo.

No entanto, ainda preciso de uma ideia para concluir a implementação de um sinal usando essa abordagem para propor a compra/venda quando o preço ficar mais alto/baixo do que o preço mais alto/baixo observado durante os últimos n períodos. Isso deve resultar na colocação de um par de ordens stop acima e abaixo do preço atual. Já tentei fazer isso substituindo a condição

  • Direction()>=m_threshold_open por
  • LongCondition()>=m_threshold_open, por exemplo,

mas parece que ainda não está funcionando. Isso não faz sentido para mim porque eu também sobrecarreguei as funções OpenLongParams(...) e OpenShortParams(...). Elas determinam os níveis nos quais colocar as ordens stop desejadas. Alguém com mais conhecimento sobre as ideias dos desenvolvedores da MetaQuotes poderia explicar como eles teriam implementado essa estratégia mais básica de break out?

Como o código-fonte costuma ser visto como a melhor documentação de qualquer software, passei algum tempo analisando a classe CExpertSignal em MQL5\Include\Expert\ExpertSignal.mqh

Meu resultado foi que as funções que verificam as condições de negociação se reduzem essencialmente a testar o valor da função Direction() { return(LongCondition()-ShortCondition()); } da seguinte forma:

bool CExpertSignal::CheckOpenLong(...)     { if(Direction()>=m_threshold_open && OpenLongParams(price,sl,tp,expiration)) return(true); return(false); }
bool CExpertSignal::CheckOpenShort(...)    { if(-Direction()>=m_threshold_open && OpenShortParams(price,sl,tp,expiration)) return(true); return(false); }
bool CExpertSignal::CheckCloseLong(...)    { if(-Direction()>=m_threshold_close && CloseLongParams(price,sl,tp,expiration)) return(true); return(false); }
bool CExpertSignal::CheckCloseShort(...)   { if(Direction()>=m_threshold_close && CloseShortParams(price,sl,tp,expiration)) return(true); return(false); }
bool CExpertSignal::CheckReverseLong(...)  { if(!CheckCloseLong(c_price) || !CheckOpenShort(price,sl,tp,expiration)) return(false); return(true); }
bool CExpertSignal::CheckReverseShort(...) { if(!CheckCloseShort(c_price) || !CheckOpenLong(price,sl,tp,expiration)) return(false); return(true); }

(Removi alguns códigos que parecem necessários apenas para uma execução estável, sem contribuir de forma alguma para a funcionalidade).

Esse resumo mostra que, para qualquer classe de estratégia personalizada, deve ser suficiente sobrecarregar as funções

  1. int CExpertSignal::LongCondition(...),
  2. int CExpertSignal::ShortCondition(...),
  3. bool CExpertSignal::OpenLongParams(...),
  4. bool CExpertSignal::OpenShortParams(...),
  5. bool CExpertSignal::CloseLongParams(...), e
  6. bool CExpertSignal::CloseShortParams(...)

e o artigo 2. do Harvester, cujo link está acima, explica como usar a macro IS_PATTERN_USAGE(x) nos dois primeiros, de modo que o sinal resultante detecte vários padrões predefinidos.

Vejo o seguinte problema: a condição que determina se o preço está entre a máxima mais alta e a mínima mais baixa das últimas n barras deve ser sempre verdadeira. Portanto, tanto LongCondition(...) quanto ShortCondition(...) retornam o mesmo valor associado ao padrão de negociação breakout e o valor de Direction() é necessariamente zero, a menos que as condições em CheckOpenLong(...) e CheckOpenShort(...) sejam alteradas.

Mas por que não é suficiente usar LongCondition()>=m_threshold_open e ShortCondition()>=m_threshold_open?

 
yankai0219:

Quando uso o arquivo que você anexou ao artigo, há algo errado.

Acho que o comentário sobre Type deveria ser o seguinte:

//| Type=SignalAdvanced                                          |

Obrigado por sua mensagem. Sua mensagem resolveu meu problema. Parabéns!

George

 

Hi,

Quando compilei o código, recebi três avisos

A declaração de 'm_open' oculta o membro samplesignal.mqh 42 23

A declaração de 'm_close' oculta o membro samplesignal.mqh 43 23

A declaração de 'm_expiration' oculta o membro samplesignal.mqh 52 23


m_open e m_close foram definidos em ExpertBase.mqh, mas com tipos diferentes.

m_expiratin foi definido em ExpertSignal.mqh.

Comente as três linhas acima. Os avisos desapareceram.

George

 
Se for possível reescrever o código exato, completo e executável desse programa, corrigir seus erros e colocá-lo aqui
 
touhid Qolizadeh #:
Se for possível reescrever o código exato, completo e executável desse programa, corrigir seus erros e colocá-lo aqui

Aqui está!

Abraço, Zarik

Arquivos anexados:
SampleSignal.mqh  16 kb
12345678
Novo comentário