Características del lenguaje mql5, sutilezas y técnicas - página 237

Nuevo comentario
 
Alain Verleyen #:

Puede que me esté perdiendo algo, pero he utilizado su script para comprobar PeriodSeconds (solamente).


mis resultados de su prueba:

2023.11.15 00:26:58.896 DDD__ (EURUSD,M1)       контрольная сумма - 34192800000000, время выполнения 1 иттерации = 29.78 наносекунд - PeriodSecondsFastFXS
2023.11.15 00:26:59.056 DDD__ (EURUSD,M1)       контрольная сумма - 34192800000000, время выполнения 1 иттерации = 16.03 наносекунд - PeriodSecondsFast
2023.11.15 00:26:59.477 DDD__ (EURUSD,M1)       контрольная сумма - 34192800000000, время выполнения 1 иттерации = 42.08 наносекунд - Расчет через PeriodSeconds
2023.11.15 00:26:59.477 DDD__ (EURUSD,M1)       ========================================================================
2023.11.15 00:27:16.018 DDD__ (EURUSD,M1)       =====LOOP=10000000
2023.11.15 00:27:16.318 DDD__ (EURUSD,M1)       контрольная сумма - 34192800000000, время выполнения 1 иттерации = 29.99 наносекунд - PeriodSecondsFastFXS
2023.11.15 00:27:16.474 DDD__ (EURUSD,M1)       контрольная сумма - 34192800000000, время выполнения 1 иттерации = 15.59 наносекунд - PeriodSecondsFast
2023.11.15 00:27:16.901 DDD__ (EURUSD,M1)       контрольная сумма - 34192800000000, время выполнения 1 иттерации = 42.74 наносекунд - Расчет через PeriodSeconds
2023.11.15 00:27:16.901 DDD__ (EURUSD,M1)       ========================================================================
2023.11.15 00:27:25.206 DDD__ (EURUSD,M1)       =====LOOP=10000000
2023.11.15 00:27:25.508 DDD__ (EURUSD,M1)       контрольная сумма - 34192800000000, время выполнения 1 иттерации = 30.14 наносекунд - PeriodSecondsFastFXS
2023.11.15 00:27:25.666 DDD__ (EURUSD,M1)       контрольная сумма - 34192800000000, время выполнения 1 иттерации = 15.77 наносекунд - PeriodSecondsFast
2023.11.15 00:27:26.110 DDD__ (EURUSD,M1)       контрольная сумма - 34192800000000, время выполнения 1 иттерации = 44.47 наносекунд - Расчет через PeriodSeconds
2023.11.15 00:27:26.110 DDD__ (EURUSD,M1)       ========================================================================
2023.11.15 00:27:40.780 DDD__ (EURUSD,M1)       =====LOOP=10000000
2023.11.15 00:27:41.089 DDD__ (EURUSD,M1)       контрольная сумма - 34192800000000, время выполнения 1 иттерации = 30.90 наносекунд - PeriodSecondsFastFXS
2023.11.15 00:27:41.249 DDD__ (EURUSD,M1)       контрольная сумма - 34192800000000, время выполнения 1 иттерации = 15.98 наносекунд - PeriodSecondsFast
2023.11.15 00:27:41.676 DDD__ (EURUSD,M1)       контрольная сумма - 34192800000000, время выполнения 1 иттерации = 42.72 наносекунд - Расчет через PeriodSeconds
2023.11.15 00:27:41.676 DDD__ (EURUSD,M1)       ========================================================================


0 errors, 0 warnings, 234 msec elapsed, cpu='AVX2 + FMA3'              


No me gusta mucho la prueba en sí, porque en la prueba se realizan 10 millones de cálculos iguales. En este caso, no hay ninguna garantía de que el compilador no dé sorpresas en sus intentos de optimizar el código.
Y estos valores deben dividirse por 21 porque hay 21*10 000 000 iteraciones en total.

Sin embargo, esta prueba también confirma mis conclusiones, pero para mi procesador, que parece ser más fresco y, por lo tanto, utiliza al máximo las características de rendimiento modernas y, por lo tanto, es más objetivo porque está más actualizado.


Sería interesante ver los resultados de esta prueba para otros.

 
fxsaber #:

He mirado el formato.

Probablemente no lo acelere. Aunque he oído hablar de la milagrosa velocidad del cambio.

Un conmutador disperso no da una velocidad milagrosa.

La velocidad más maravillosa será en un conmutador con casos de cero a 255 en incrementos de 1

 
Slava #:

Un conmutador disperso no te da una velocidad maravillosa.

La velocidad más maravillosa será en un conmutador con casos de cero a 255 en incrementos de 1

Gracias.

 
Nikolai Semko # :

mis resultados de su prueba:


No me gusta mucho la prueba en sí, porque en la prueba se realizan 10 millones de cálculos iguales. En este caso, no hay ninguna garantía de que el compilador no dé sorpresas en sus intentos de optimizar el código.
Y estos valores deben dividirse por 21, porque hay 21*10 000 000 iteraciones en total.

Sin embargo, esta prueba también confirma mis conclusiones, pero para mi procesador, que parece ser más fresco y, por lo tanto, utiliza al máximo las características de rendimiento modernas y, por lo tanto, es más objetivo porque está más actualizado.


Sería interesante ver los resultados de esta prueba para otros.

Gracias.

Ayer ya era tarde cuando publiqué los resultados SIN optimización del compilador.

Aquí están los resultados con cpu='AVX2 + FMA3' y optimización máxima.


 
Nikolai Semko #:

La principal dificultad de este algoritmo es calcular la hora de inicio del mes (resaltada en verde).

Lo más interesante del código y que casi no se ha tocado en la discusión.

 
fxsaber #:

Lo más interesante del código y que casi no se ha tocado en el debate.

Allí el año comienza el 1 de marzo en lugar del 1 de enero.
Este es un consejo que vi en stackoverflow. Fue un buen consejo.
Tuve que escribir un script para encontrar el factor 30.68
 

Me encontré con la necesidad de guardar código muy corto (< 15 líneas) en forma de mqh-library.

template <typename T1, typename T2>
T1* New( const string &ClassName ) { return((typename(T2) == ClassName) ? new T2 : NULL); }

template <typename T1, typename T2>
T1* New( string ClassName, const T2 &FuncNew[] )
{  
  T1* Res = NULL;
  
#ifdef __MQL5__
  ClassName = "class " + ClassName;
#endif // #ifdef __MQL5__
  
  for (uint i = ArraySize(FuncNew); (Res == NULL) && (bool)i--;)
    Res = FuncNew[i](ClassName);  
    
  return(Res);
}

Es una medida forzada porque los punteros a funciones sólo son posibles para funciones del scopus global.

¿Qué bibliotecas cortas utilizas?

 
La firma de una función de plantilla puede depender de las ubicaciones de su llamada.

Foro sobre negociación, sistemas automatizados de negociación y prueba de estrategias de negociación

Errores, fallos, preguntas

fxsaber, 2023.11.26 23:26

template <typename T>
void Func( void ) { Print(__FUNCSIG__); }

void OnStart()
{
  Func<int>(); // void "void OnStart()"::Func<int>()
}
 

Si he entendido bien, en este caso el método A::f() está inlineado en g().

class A
{
  void f() {}
  void g() { this.f(); }
};


Y aquí no.

class A
{
  virtual void f() {}
  void g() { this.f(); }
};


¿Será A::f() inlineado por el compilador en el segundo caso, siempre que no se creen objetos descendientes de la clase A en ninguna parte del código?

 
A veces es necesario establecer un punto de interrupción en un lugar determinado del visualizador. Para ello utilizo una función de este tipo. 
bool IsManualChangeTester()
{
  static const bool IsVisual = MQLInfoInteger(MQL_VISUAL_MODE);
  static ENUM_CHART_MODE PrevChartMode = (ENUM_CHART_MODE)ChartGetInteger(0, CHART_MODE);  
  
  bool Res = false;
  
  if (IsVisual)
  {
    const ENUM_CHART_MODE ChartMode = (ENUM_CHART_MODE)ChartGetInteger(0, CHART_MODE);
      
    if (Res = (ChartMode != PrevChartMode))
      PrevChartMode = ChartMode;
  }
    
  return(Res);
}


Con esta aplicación.

if (IsManualChangeTester())
  DebugBreak();


Cuando necesito crear esta condición, simplemente cambio el modo de visualización del gráfico en el visualizador.

Y luego analizo el comportamiento del Asesor Experto en ME.

1...230231232233234235236237238239240241242243244...247
Nuevo comentario