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.
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.
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ãoif(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 1if(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 2if(IS_PATTERN_USAGE(2) && ConditionForPattern2(idx)) result=m_pattern_2; // sinal número 2//--- retornar o resultadoreturn(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ãoif(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 1if(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 2if(IS_PATTERN_USAGE(2) && ConditionForPattern2(idx)) result=m_pattern_2; // sinal número 2//--- retornar o resultadoreturn(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
bool CExpertSignal::CheckOpenLong(...),
bool CExpertSignal::CheckOpenShort(...),
bool CExpertSignal::CheckCloseLong(...),
bool CExpertSignal::CheckCloseShort(...),
bool CExpertSignal::CheckReverseLong(...), e
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
int CExpertSignal::LongCondition(...),
int CExpertSignal::ShortCondition(...),
bool CExpertSignal::OpenLongParams(...),
bool CExpertSignal::OpenShortParams(...),
bool CExpertSignal::CloseLongParams(...), e
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
bool CExpertSignal::CheckOpenLong(...) e
bool CExpertSignal::CheckOpenShort(...)
de modo que o primeiro verifica
LongCondition()>m_threshold_open e o segundo verifica
ShortCondition()>m_threshold_open
em vez de
m_direction>=m_threshold_open e
-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
comprar na alta e vender na alta ou vender na baixa e comprar na baixa, bem como a alternativa
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.
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
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:
(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
int CExpertSignal::LongCondition(...),
int CExpertSignal::ShortCondition(...),
bool CExpertSignal::OpenLongParams(...),
bool CExpertSignal::OpenShortParams(...),
bool CExpertSignal::CloseLongParams(...), e
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?
Para login e uso do site MQL5.com, você deve ativar o uso de cookies.
Ative esta opção no seu navegador, caso contrário você não poderá fazer login.
Você entrou na conta. A autenticação de dois fatores foi desativada. Configure-a novamente e escaneie um novo código QR ou continue com a autenticação de dois fatores desativada.
Devo adicioná-lo manualmente em OnInit()? Então não posso fazer o que quero por meio do assistente?
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.
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.
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
e
Então, encontramos
cujo resultado é testado contra signal.m_threshold_open e signal.m_threshold_close em
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
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
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
de modo que o primeiro verifica
em vez de
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
fornecendo-as como padrões. Ficarei extremamente grato se me ajudarem a concluir essa abordagem.
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
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
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
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:
(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
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?
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
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
Aqui está!
Abraço, Zarik