Discusión sobre el artículo "LifeHack para tráders: preparando "comida rápida" a partir de indicadores" - página 12

Nuevo comentario
 
fxsaber:

Los indicadores estándar (son los únicos que se tratan en el artículo) se almacenan en caché de forma elemental. Porque todos los parámetros de entrada son conocidos.

Es difícil sólo para escribir una función hash universal. Pero no era necesario en el artículo. Se trata del caso más simple. E incluso para ello no hay función hash.

MACD Muestra 4 a 5 MQL4 style.mq5


Sin caché

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


Con caché estúpido

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% más rápido si no se hace ninguna estupidez (de frente). La crítica de "ineficiencia" del enfoque presentado está justificada.

 
¿Puede enseñarme el código?
 
Rashid Umarov:
¿Puede mostrar el código?
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));
  }  
};

// Variante MT5 de 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));
}            

// Variante MT5 de 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));
}            


En IndicatorsMQL4.mqh añadir el código anterior y hacer los siguientes cambios

   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:
Me gustaría un enfoque de este tipo - tomamos OnCalculate fuera del indicador, modificarlo ligeramente bajo un nuevo nombre, añadirlo al código del indicador y ahora podemos tirar de esta función como una función bibilio, pasando parámetros desde el Asesor de Expertos a la misma. ¿Verdad?

Creo que podemos hacer que el código fuente de cualquier indicador se conecte al Asesor Experto a través de un enclode. Y luego trabajar con ellos como con una función.

Hay que trastear un poco con macros y otras peculiaridades. Esta solución no cubrirá todos los indicadores. Pero debería cubrir la mayoría de ellos.

 

Intento de recuperación:

Voy a publicar mi versión de la medición. MACD Muestra Un valor en un 5 se tomó como la versión básica del Asesor de Expertos. Se hicieron pequeños cambios en él. Dado que todos los valores de los indicadores se recogen en un solo lugar, no fue difícil hacer una simple sustitución de macros: Creo que las conclusiones son obvias: al llamar a los indicadores en el modo MQL4, la velocidad es menor en un 40%.

Archivos adjuntos:
MACD_Sample_One_value_at_a_time.mq5  20 kb
 
Yuriy Koptsev:


mire /results/... open - stop is set, then the trawl pulls it over.


aquí está una sección de la carta. y el informe en este lugar. ¿cómo puede establecer una parada de 150 pips para casi todos los lotes con ATR * 0,5 (ATR = 80pp)? con tal configuración, la parada NUNCA debe ser más allá de unos 40 pips desde el precio de apertura del lote.... y sólo cuando se pone por encima de este nivel, se negociará en él ya.
Archivos adjuntos:
IndicatorsMQL4.mqh  55 kb
 
No tuve oportunidad de leerlo.
 
Actualizado, man....
 
 
Vasiliy Sokolov:

Intento de recuperación:

Voy a publicar mi versión de la medición. MACD Muestra Un valor en un 5 se tomó como la versión básica del Asesor de Expertos. Se hicieron pequeños cambios en él. Dado que todos los valores de los indicadores se recogen en un solo lugar, no fue difícil hacer una simple sustitución de macros: Creo que las conclusiones son obvias: al llamar a los indicadores en el modo MQL4, la velocidad es menor en un 40%.

Puedes restaurar (editar) tu post:

llamar a los indicadores en el modo MQL4, la velocidad es 40% más lento.


- Usted tenía un hermoso código y la descripción de los resultados de la medición.

1...5678910111213
Nuevo comentario