Discussione sull’articolo "Il Wizard MQL5: Come creare un modulo di segnali di trading" - pagina 7

Nuovo commento
 
t101:
Devo aggiungerlo manualmente in OnInit()? Quindi non posso fare quello che voglio fare attraverso la procedura guidata?
Quali sono i problemi? Si sta introducendo una funzionalità aggiuntiva, quindi è necessario fare un po' di lavoro manuale.
 
Karputov Vladimir:
Qual è il problema? State introducendo una funzionalità aggiuntiva, quindi dovete fare un po' di lavoro manuale.

Nessun problema, ma non corrisponde al concetto che il Master fa tutto sulla base di moduli personalizzati per segnali, capitale, ecc. E l'articolo è obsoleto e non è vero:

Il metodo CheckCloseLong() genera un segnale di chiusura di una posizione long con la determinazione del livello di uscita. Viene chiamato dall'Expert Advisor per determinare la necessità di chiudere una posizione long. È necessario sovrascrivere il metodo nel caso in cui si intenda generare un segnale di chiusura di una posizione long. 

virtual bool CheckCloseLong(double& price);
In ogni caso, grazie per l'aiuto.
[Eliminato]  
Sono passati quasi 6 anni, l'articolo non è obsoleto? Non ne sono sicuro, dato che vedo il terminale aggiornato quasi ogni settimana.
 
yerlan Imangeldinov:
Sono passati quasi 6 anni e l'articolo non è obsoleto? Non ne sono sicuro, dato che vedo il terminale aggiornato quasi ogni settimana.
Esiste un articolo più recente sulla scrittura di moduli di segnali di trading:"Create a trading robot in six hours!".
 

Ciao a tutti,

Mi sto chiedendo come creare un discendente di CExpertSignal con i due pattern "break out" e "break in" rispetto a un trading range osservato, utilizzando l'approccio proposto qui e in Exploring Trading Strategy Classes della Standard Library - Customizing Strategie di Harvester. La mia percezione è che ogni classe di segnali potrebbe (dovrebbe) essere implementata sovraccaricando

//+------------------------------------------------------------------+
//| "Votando" che il prezzo crescerà.|
//| INPUT: no.|
//| OUTPUT: numero di "voti" che il prezzo aumenterà.
//| NOTA: no.|
//+------------------------------------------------------------------+
int CSignalBreakOutOrIn::LongCondition()
  {
   int result=0;
   int idx   =StartIndex();
//---
   //--- solo nel caso in cui si voglia una sorta di schema predefinito
   if(IS_PATTERN_USAGE(0)) result=m_pattern_0;                                   // segnale di "conferma" numero 0
   //--- se viene utilizzato il modello 1, verificare la condizione per il modello 1
   if(IS_PATTERN_USAGE(1) && ConditionForPattern1(idx)) result=m_pattern_1;      // segnale numero 1
   //--- se viene utilizzato il modello 2, verificare la condizione per il modello 2
   if(IS_PATTERN_USAGE(2) && ConditionForPattern2(idx)) result=m_pattern_2;      // segnale numero 2
//--- restituire il risultato
   return(result);
  }

e

//+------------------------------------------------------------------+
//| "Votando" che il prezzo scenderà.|
//| INPUT: no.|
//| OUTPUT: numero di "voti" che indicano che il prezzo scenderà.
//| NOTA: no.|
//+------------------------------------------------------------------+
int CSignalBreakOutOrIn::ShortCondition()
  {
   int result=0;
   int idx   =StartIndex();
//---
   //--- solo nel caso in cui si voglia una sorta di schema predefinito
   if(IS_PATTERN_USAGE(0)) result=m_pattern_0;                                   // segnale di "conferma" numero 0
   //--- se viene utilizzato il modello 1, verificare la condizione per il modello 1
   if(IS_PATTERN_USAGE(1) && ConditionForPattern1(idx)) result=m_pattern_1;      // segnale numero 1
   //--- se viene utilizzato il modello 2, verificare la condizione per il modello 2
   if(IS_PATTERN_USAGE(2) && ConditionForPattern2(idx)) result=m_pattern_2;      // segnale numero 2
//--- restituire il risultato
   return(result);
  }

Poi troviamo

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

il cui risultato viene testato rispetto a signal.m_threshold_open e signal.m_threshold_close in

  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(...).

I parametri che specificano i livelli di entrata nel mercato e l'impostazione dei prezzi di stop loss e take profit verrebbero restituiti da

//+------------------------------------------------------------------+
//| Rilevare i livelli per l'acquisto|
//+------------------------------------------------------------------+
bool CExpertSignal::OpenLongParams(double &price,double &sl,double &tp,datetime &expiration)
  {
  }
//+------------------------------------------------------------------+
//| Rilevamento dei livelli per la vendita|
//+------------------------------------------------------------------+
bool CExpertSignal::OpenShortParams(double &price,double &sl,double &tp,datetime &expiration)
  {
  }

che vengono invocati dall'implementazione standard di bool CExpertSignal::CheckOpenLong(...) e bool CExpertSignal::CheckOpenShort(...), come definiti nella classe base. Pertanto dovrebbe essere sufficiente sovraccaricare

  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(...)

per definire un nuovo segnale arbitrario. Si noti che CExpertTrade contiene il codice per rilevare se il prezzo di entrata desiderato è troppo lontano dal prezzo corrente per piazzare ordini di mercato e utilizza la scelta del prezzo di entrata per decidere automaticamente se piazzare un ordine stop o un ordine limite.

Tuttavia, se il trading range è definito come la regione compresa tra il massimo (HH) e il minimo (LL) delle ultime n barre, la condizione LL < prezzo < HH è sempre vera. Pertanto, sia l'int CExpertSignal::LongCondition(...) che l' int CExpertSignal::ShortCondition(...) dovrebbero sempre rilevare il pattern 0 "break out" e qualsiasi valore associamo a questo pattern la funzione int CExpertSignal::Direction() restituirà sempre zero!

L'approccio naturale consiste nel sovraccaricare

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

in modo che il primo controlli

  1. LongCondition()>m_threshold_open e che il secondo verifichi
  2. ShortCondition()>m_threshold_open

invece di

  1. m_direzione>=m_soglia_apertura e
  2. -m_direzione>=m_soglia_apertura

non ha ancora potuto essere trasformato in una versione di successo. Come sottolineato, sarebbe semplice far sì che bool CExpertSignal::OpenLongParams(...) restituisca il prezzo di entrata HH e che bool CExpertSignal::OpenShortParams(...)restituisca il prezzo di entrata LL per completare il segnale generando continuamente 2 ordini di stop.

A mio avviso è auspicabile avere un esempio che mostri come implementare questa strategia di break out standard in termini di libreria standard e che la renda sufficientemente flessibile fornendo il modello alternativo "break in" che risulta in ordini limite a LL e HH. Ovviamente, un segnale di questo tipo combinerebbe le strategie

  1. comprare alto e vendere più in alto o vendere basso e comprare più in basso, così come l'alternativa
  2. comprare basso e vendere alto o vendere alto e comprare basso.

fornendole come pattern. Vi sarò estremamente grato se mi aiutate a completare questo approccio.

 
AnonymousTrades:

Ciao a tutti,

Mi sto chiedendo come creare un discendente di CExpertSignal con i due pattern "break out" e "break in" rispetto a un trading range osservato utilizzando l'approccio proposto qui e in Exploring Trading Strategy Classes della Standard Library - Customizing Strategie di Harvester. La mia percezione è che ogni classe di segnali potrebbe (dovrebbe) essere implementata sovraccaricando le due funzioni

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); }

Si noti che CExpertTrade contiene il codice per rilevare se il prezzo di entrata desiderato è troppo lontano dal prezzo corrente per piazzare ordini di mercato e utilizza la scelta del prezzo di entrata per decidere automaticamente se piazzare un ordine stop o un ordine limite.

[...]

A mio avviso è auspicabile avere un esempio che mostri come implementare questa strategia di break out standard in termini di libreria standard e che la renda sufficientemente flessibile fornendo il pattern alternativo "break in" che risulta in ordini limite a LL e HH. Sarò estremamente grato per l'aiuto che mi verrà dato nel completare questo approccio.


Ho deciso di riformulare i miei dubbi per renderli più comprensibili possibile. A mio avviso i due articoli

  1. MQL5 Wizard: come creare un modulo di segnali di trading (questo) e
  2. Esplorare le classi di strategie di trading della libreria standard - Personalizzare le strategie di Harvester Trading

dimostrano in generale come scrivere le nostre classi di segnali nel modo più semplice possibile. Riassumerò di seguito questa mia percezione.

Tuttavia, ho ancora bisogno di un'idea per completare l'implementazione di un segnale che utilizzi questo approccio per proporre l'acquisto/la vendita quando il prezzo diventa più alto/basso del prezzo più alto/basso osservato durante gli ultimi n periodi. Questo dovrebbe portare a piazzare una coppia di ordini di stop al di sopra e al di sotto del prezzo corrente. Ho già provato a raggiungere questo obiettivo sostituendo la condizione

  • Direzione()>=m_soglia_apertura con
  • LongCondition()>=m_threshold_open, per esempio,

ma non sembra funzionare. Questo non ha senso perché ho sovraccaricato anche le funzioni OpenLongParams(...) e OpenShortParams(...). Esse determinano i livelli ai quali piazzare gli ordini di stop desiderati. Qualcuno che conosce meglio le idee degli sviluppatori di MetaQuotes potrebbe spiegare come avrebbero implementato questa strategia di break out di base?

Dal momento che il codice sorgente è spesso considerato la migliore documentazione di qualsiasi software, ho dedicato un po' di tempo all'analisi della classe CExpertSignal in MQL5\Include\Expert\ExpertSignal.mqh

Il risultato è che le funzioni che controllano le condizioni di trading si riducono essenzialmente a testare il valore della funzione Direction() { return(LongCondition()-ShortCondition()); } come segue:

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); }

(Ho tolto un po' di codice che sembra necessario solo per un'esecuzione stabile senza contribuire in alcun modo alla funzionalità).

Questo riassunto mostra che per qualsiasi classe di strategia personalizzata dovrebbe essere sufficiente sovraccaricare le funzioni

  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 l'articolo di Harvester 2. linkato sopra spiega come utilizzare la macro IS_PATTERN_USAGE(x) nei primi due in modo che il segnale risultante rilevi diversi pattern predefiniti.

Vedo questo problema: la condizione che il prezzo sia compreso tra il massimo e il minimo delle ultime n barre deve essere sempre vera. Pertanto, sia LongCondition(...) che ShortCondition(...) restituiscono lo stesso valore associato al pattern per il breakout trading e il valore di Direction() è necessariamente zero a meno che non vengano modificate le condizioni in CheckOpenLong(...) e CheckOpenShort(...).

Ma perché non è sufficiente utilizzare LongCondition()>=m_threshold_open e ShortCondition()>=m_threshold_open?

 
yankai0219:

Quando utilizzo il file che hai allegato all'articolo, c'è qualcosa che non va.

Trovo che il commento sul tipo dovrebbe essere il seguente:

//| Type=SignalAdvanced                                          |

Grazie per il messaggio. Il tuo messaggio ha risolto il mio problema. Grazie!

Giorgio

 

Ciao,

Quando ho compilato il codice, ho ricevuto tre avvertimenti

la dichiarazione di 'm_open' nasconde il membro samplesignal.mqh 42 23

la dichiarazione di 'm_close' nasconde il membro samplesignal.mqh 43 23

la dichiarazione di 'm_expiration' nasconde il membro samplesignal.mqh 52 23


m_open e m_close sono stati definiti in ExpertBase.mqh ma con un tipo diverso.

m_expiratin è stato definito in ExpertSignal.mqh.

Commentare le tre righe precedenti. Gli avvisi sono spariti.

Giorgio

 
Se è possibile riscrivere il codice esatto, completo ed eseguibile di questo programma, correggerne i bug e inserirlo qui
 
touhid Qolizadeh #:
Se è possibile riscrivere il codice esatto, completo ed eseguibile di questo programma e correggere i suoi bug e metterlo qui

Ecco a voi!

Saluti, Zarik

File:
SampleSignal.mqh  16 kb
12345678
Nuovo commento