Caractéristiques du langage mql5, subtilités et techniques - page 237

Nouveau commentaire
 
Alain Verleyen #:

J'ai peut-être oublié quelque chose, mais j'ai utilisé votre script pour vérifier PeriodSeconds (uniquement).


Mes résultats correspondent à ceux de votre test :

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'              


Je n'aime pas beaucoup le test lui-même, car 10 millions de calculs identiques ont lieu dans le test. Dans ce cas, il n'y a aucune garantie que le compilateur n'aura pas de surprises dans ses tentatives d'optimisation du code.
Et ces valeurs doivent être divisées par 21 car il y a 21*10 000 000 itérations au total.

Cependant, ce test confirme également mes conclusions, mais pour mon processeur, qui semble plus frais et, par conséquent, utilise au maximum les performances modernes et, donc, est plus objectif parce que plus récent.


Il serait intéressant de voir les résultats de ce test pour d'autres.

 
fxsaber #:

J'ai regardé le format.

Il ne l'accélérera probablement pas. Mais j'ai entendu parler de la vitesse miraculeuse du changement.

Un commutateur peu dense ne permet pas d'obtenir une vitesse miraculeuse.

La vitesse la plus merveilleuse sera celle d'un commutateur dont les cases vont de zéro à 255 par incréments de 1.

 
Slava #:

Un commutateur clairsemé ne permet pas d'obtenir une vitesse extraordinaire.

La vitesse la plus merveilleuse sera celle d'un commutateur dont les cas vont de zéro à 255 par incréments de 1.

Nous vous remercions.

 
Nikolai Semko # :

mes résultats de votre test :


Je n'aime pas beaucoup le test lui-même, parce que 10 millions de calculs identiques ont lieu dans le test. Dans ce cas, il n'y a aucune garantie que le compilateur n'aura pas de surprises dans ses tentatives d'optimisation du code.
Et ces valeurs doivent être divisées par 21, car il y a 21*10 000 000 itérations au total.

Cependant, ce test confirme également mes conclusions, mais pour mon processeur, qui semble plus frais et, par conséquent, utilise au maximum les caractéristiques de performance modernes et, par conséquent, est plus objectif parce qu'il est plus récent.


Il serait intéressant de voir les résultats de ce test pour d'autres.

Merci.

Il était tard hier lorsque j'ai posté les résultats SANS optimisation du compilateur.

Voici les résultats avec cpu='AVX2 + FMA3' et optimisation maximale.


 
Nikolai Semko #:

La principale difficulté de cet algorithme réside dans le calcul de l'heure de début du mois (surlignée en vert).

C'est l'élément le plus intéressant du code et il n'a pratiquement pas été abordé au cours de la discussion.

 
fxsaber #:

La chose la plus intéressante dans le code et qui n'a pratiquement pas été abordée dans la discussion.

Ici, l'année commence le 1er mars au lieu du 1er janvier.
C'est une astuce que j'ai vue sur stackoverflow. C'était un bon conseil.
J'ai dû écrire un script pour trouver le facteur 30.68
 

J'ai été confronté à la nécessité de sauvegarder du code très court (< 15 lignes) sous la forme 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);
}

C'est une mesure forcée car les pointeurs vers les fonctions ne sont possibles que pour les fonctions du scopus global.

Quelles sont les bibliothèques courtes que vous utilisez ?

 
La signature d'une fonction modèle peut dépendre de l'emplacement de son appel.

Forum sur le trading, les systèmes de trading automatisés et les tests de stratégies de trading

Erreurs, bugs, questions

fxsaber, 2023.11.26 23:26

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

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

Si je comprends bien, dans ce cas, la méthode A::f() est intégrée dans g().

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


Et ici, elle ne l'est pas.

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


A::f() sera-t-elle intégrée par le compilateur dans le second cas, à condition qu'aucun objet descendant de la classe A ne soit créé dans le code ?

 
Il est parfois nécessaire de créer un point d'arrêt à un certain endroit du Visualiseur. J'utilise une telle fonction à cette fin. 
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);
}


Avec cette application.

if (IsManualChangeTester())
  DebugBreak();


Lorsque j'ai besoin de créer cette condition, je change simplement le mode d'affichage du graphique dans le visualiseur.

Ensuite, j'analyse le comportement du conseiller expert dans ME.

1...230231232233234235236237238239240241242243244...247
Nouveau commentaire