Diskussion zum Artikel "LifeHack für Händler: Fast-Food aus Indikatoren" - Seite 12

Neuer Kommentar
 
fxsaber:

Standardindikatoren (sie sind die einzigen, die in diesem Artikel behandelt werden) werden auf elementare Weise zwischengespeichert! Denn alle Eingabeparameter sind bekannt.

Es ist nur schwierig, eine universelle Hash-Funktion zu schreiben. Aber das war in diesem Artikel nicht erforderlich. Er befasst sich mit dem einfachsten Fall. Und selbst für diesen gibt es keine Hash-Funktion.

MACD Beispiel 4 bis 5 MQL4 style.mq5


Ohne Zwischenspeicherung

i = 0 Pass = 0 OnTester = 15.070 s.: Count = 9753093, 647186.0 unit/sec, Agent = C:\Program Files\Alpari Limited MT5\Tester\Agent-127.0.0.1-3000 build = 1755
i = 1 Pass = 1 OnTester = 14.969 s.: Count = 9753093, 651552.7 unit/sec, Agent = C:\Program Files\Alpari Limited MT5\Tester\Agent-127.0.0.1-3000 build = 1755


Mit dummem Caching

i = 0 Pass = 0 OnTester = 11.073 s.: Count = 9753093, 880799.5 unit/sec, Agent = C:\Program Files\Alpari Limited MT5\Tester\Agent-127.0.0.1-3000 build = 1755
i = 1 Pass = 1 OnTester = 11.007 s.: Count = 9753093, 886080.9 unit/sec, Agent = C:\Program Files\Alpari Limited MT5\Tester\Agent-127.0.0.1-3000 build = 1755


25 % schneller, wenn man keinen Blödsinn macht (frontal). Die Kritik an der "Ineffizienz" des vorgestellten Ansatzes ist berechtigt.

 
Können Sie mir den Code zeigen?
 
Rashid Umarov:
Können Sie den Code zeigen?
template <typename T>
struct HANDLE
{
private:  
  int Handle;
  
  T Inputs;

public:  
  HANDLE() : Handle(INVALID_HANDLE)
  {
  }
  
  bool operator ==( const T &Inputs2 ) const
  {
    return(this.Inputs == Inputs2);
  }
  
  void operator =( const T &Inputs2 )
  {
    this.Inputs = Inputs2;
  }
  
  int GetHandle()
  {
    return((this.Handle != INVALID_HANDLE) ? this.Handle : (this.Handle = this.Inputs.GetHandle()));
  }
};

template <typename T>
int GetHandle( HANDLE<T> &Handles[], const T &Inputs )
{
  const int Size = ArraySize(Handles);
  
  for (int i = 0; i < Size; i++)
    if (Handles[i] == Inputs)
      return(Handles[i].GetHandle());

  ArrayResize(Handles, Size + 1);
  Handles[Size] = Inputs;
  
  return(Handles[Size].GetHandle());
}

struct MACD
{
  string             symbol;
  ENUM_TIMEFRAMES    period;
  int                fast_ema_period;
  int                slow_ema_period;
  int                signal_period;
  ENUM_APPLIED_PRICE applied_price;
  
  MACD( void )
  {
  }
  
  MACD( const string             &isymbol,
        const ENUM_TIMEFRAMES    &iperiod,
        const int                &ifast_ema_period,
        const int                &islow_ema_period,
        const int                &isignal_period,
        const ENUM_APPLIED_PRICE &iapplied_price ) : 
        symbol((isymbol == NULL) || (isymbol == "") ? _Symbol : isymbol),
        period(iperiod == PERIOD_CURRENT ? ::Period() : iperiod),
        fast_ema_period(ifast_ema_period),
        slow_ema_period(islow_ema_period),
        signal_period(isignal_period),
        applied_price(iapplied_price)     
  {
  }
  
  int GetHandle( void ) const
  {
    return(::iMACD(this.symbol, this.period, this.fast_ema_period, this.slow_ema_period, this.signal_period, this.applied_price));
  }
  
  bool operator ==( const MACD &Inputs ) const
  {
    return((this.symbol == Inputs.symbol) &&
           (this.period == Inputs.period) &&
           (this.fast_ema_period == Inputs.fast_ema_period) &&
           (this.slow_ema_period == Inputs.slow_ema_period) &&
           (this.signal_period == Inputs.signal_period) &&
           (this.applied_price == Inputs.applied_price));
  }  
};

struct MA
{
  string             symbol;
  ENUM_TIMEFRAMES    period;
  int                ma_period;
  int                ma_shift;
  ENUM_MA_METHOD     ma_method;
  ENUM_APPLIED_PRICE applied_price;
  
  MA( void )
  {
  }
  
  MA( const string             &isymbol,
      const ENUM_TIMEFRAMES    &iperiod,
      const int                &ima_period,
      const int                &ima_shift,
      const ENUM_MA_METHOD     &ima_method,
      const ENUM_APPLIED_PRICE &iapplied_price ) :
      symbol((isymbol == NULL) || (isymbol == "") ? _Symbol : isymbol),
      period(iperiod == PERIOD_CURRENT ? ::Period() : iperiod),
      ma_period(ima_period),
      ma_shift(ima_shift),
      ma_method(ima_method),
      applied_price(iapplied_price)
  {
  }
  
  int GetHandle( void ) const
  {
    return(::iMA(this.symbol, this.period, this.ma_period, this.ma_shift, this.ma_method, this.applied_price));
  }
  
  bool operator ==( const MA &Inputs ) const
  {
    return((this.symbol == Inputs.symbol) &&
           (this.period == Inputs.period) &&
           (this.ma_period == Inputs.ma_period) &&
           (this.ma_shift == Inputs.ma_shift) &&
           (this.ma_method == Inputs.ma_method) &&
           (this.applied_price == Inputs.applied_price));
  }  
};

// MT5-Variante von iMACD.
int iMACD2( const string             symbol,
            const ENUM_TIMEFRAMES    period,
            const int                fast_ema_period,
            const int                slow_ema_period,
            const int                signal_period,
            const ENUM_APPLIED_PRICE applied_price )
{
  static HANDLE<MACD> Handles[];  
  const MACD Inputs(symbol, period, fast_ema_period, slow_ema_period, signal_period, applied_price);
  
  return(GetHandle(Handles, Inputs));
}            

// MT5-Variante von iMA.
int iMA2( const string             symbol,
          const ENUM_TIMEFRAMES    period,
          const int                ma_period,
          const int                ma_shift,
          const ENUM_MA_METHOD     ma_method,
          const ENUM_APPLIED_PRICE applied_price )
{
  static HANDLE<MA> Handles[];  
  const MA Inputs(symbol, period, ma_period, ma_shift, ma_method, applied_price);
  
  return(GetHandle(Handles, Inputs));
}            


Fügen Sie in IndicatorsMQL4.mqh den obigen Code ein und nehmen Sie die folgenden Änderungen vor

   int handle=iMACD2(symbol,timeframe,fast_ema_period,slow_ema_period,signal_period,applied_price);
//...
   int handle=iMA2(symbol,timeframe,ma_period,ma_shift,ma_method,applied_price);
 
Rashid Umarov:
Ich möchte einen Ansatz dieser Art - wir nehmen OnCalculate aus dem Indikator, modifizieren es leicht unter einem neuen Namen, fügen es dem Indikatorcode hinzu und jetzt können wir diese Funktion als Bibilio-Funktion nutzen und ihr Parameter aus dem Expert Advisor übergeben. Richtig?

Ich denke, wir können den Quellcode eines jeden Indikators über eine Enklode mit dem Expert Advisor verbinden. Und dann mit ihnen wie mit einer Funktion arbeiten.

Wir müssen ein wenig mit Makros und anderen Besonderheiten herumfummeln. Diese Lösung wird nicht alle Indikatoren abdecken. Aber sie sollte die meisten von ihnen abdecken.

 

Versuchte Wiederherstellung:

Ich poste hier meine Version der Messung. MACD Sample Ein Wert bei 5 wurde als Basisversion des Expert Advisors genommen. Daran wurden kleine Änderungen vorgenommen. Da alle Indikatorwerte an einem Ort gesammelt werden, war es nicht schwierig, eine einfache Makro-Substitution zu machen: Ich denke, die Schlussfolgerungen sind offensichtlich: beim Aufruf von Indikatoren im MQL4-Modus, ist die Geschwindigkeit um 40% niedriger.

 
Yuriy Koptsev:


Schauen Sie sich /results/ an... open - stop wird gesetzt, dann zieht das trawl es rüber.


hier ist ein ausschnitt aus dem chart. und der report an dieser stelle. wie kann es einen stop von 150 pips für fast alle lots mit ATR * 0.5 (ATR = 80pp) setzen? bei einem solchen setup sollte der stop NIEMALS weiter als etwa 40 pips vom eröffnungskurs des lots entfernt sein.... und erst wenn er über dieses Niveau steigt, wird er bereits gehandelt.
Dateien:
IndicatorsMQL4.mqh  55 kb
 
Ich hatte keine Gelegenheit, es zu lesen.
 
Aktualisiert, man....
 
 
Vasiliy Sokolov:

Versuch der Wiederherstellung:

Ich poste hier meine Version der Messung. MACD Sample Ein Wert bei einer 5 wurde als Basisversion des Expert Advisors genommen. Darin wurden kleine Änderungen vorgenommen. Da alle Indikatorwerte an einem Ort gesammelt werden, war es nicht schwierig, eine einfache Makro-Substitution zu machen: Ich denke, die Schlussfolgerungen sind offensichtlich: beim Aufruf von Indikatoren im MQL4-Modus, ist die Geschwindigkeit um 40% niedriger.

Sie können Ihren Beitrag wiederherstellen (bearbeiten):

Aufruf von Indikatoren im MQL4-Modus, ist die Geschwindigkeit 40% langsamer.


- Sie hatten einen schönen Code und eine Beschreibung der Messergebnisse.

1...5678910111213
Neuer Kommentar