Erreurs, bugs, questions - page 2164

Nouveau commentaire
 
Vladimir Pastushak:

Il y a très peu d'espace dans les descriptions de produits.

3600 caractères, c'est extrêmement court pour des programmes importants et sérieux.

Je pense que beaucoup de gens seront d'accord avec moi.

Il ne faut pas moins de 5000 à 10000 caractères pour décrire les programmes. Ou au moins un onglet avec le nom des paramètres du programme.

Un modérateur peut toujours demander de retirer l'eau.

En ce moment, je suis en train d'écrire une description du programme, j'ai utilisé les 3 600 caractères juste pour décrire les paramètres et même pas la moitié des fonctionnalités...

Je ne suis pas d'accord. La brièveté est la sœur du talent.

"Ne pensez pas qu'avec vos nombreuses paroles vous serez entendus."

Matthieu 6:7.

 
Andrey Khatimlianskii:

Vladimir, tu as déjà acheté quelque chose ? Combien de temps avez-vous passé à lire les instructions ?

Personne ne lira un livre en plusieurs volumes, ils ne regarderont même pas une vidéo de 3 à 5 minutes.
Il n'y a qu'une seule solution : ajouter des conseils dans l'interface du programme, comme cela se fait presque partout aujourd'hui. Quelque chose comme un tutoriel interactif. Et les instructions détaillées destinées aux utilisateurs avancés peuvent être placées dans un blog ou sur leur site. Ceux qui le veulent le trouveront et le téléchargeront.

Pour ceux qui ne lisent pas et n'achètent pas, avez-vous acheté de nombreux produits sans comprendre à quoi ils servent ?

Devrions-nous alors tout publier sur les blogs ?

 
Nikolai Semko:

Je ne suis pas d'accord. La brièveté est la sœur du talent.

"Ne pensez pas qu'avec votre verbiage, vous serez entendu."

Matthieu 6:7.

Je suis d'accord, mais même bref 3600 n'est pas suffisant...

 
Vladimir Pastushak:

Pour ceux qui ne lisent pas et n'achètent pas, avez-vous acheté de nombreux produits sans comprendre à quoi ils servent ?

Devrions-nous alors tout publier sur les blogs ?

Comprendre l'utilité du produit à partir du manuel ?

C'est idiot. Je vais télécharger et sentir la démo.

 
A100:

Ce code est basé sur un défaut du compilateur

Résultat : 1... Pourquoi pas 2 ?

Alors que le C++ signale une erreur lors de la compilation, parce que les deux fonctions correspondent manifestement, et qu'en outre, la syntaxe ne permet pas d'appeler explicitement la fonction (2)

En outre, compte tenu des caractéristiques spécifiques de MQL, il serait plus logique de faire l'inverse - de fixer la priorité de passer le paramètre non pas par valeur (comme maintenant), mais par référence à une constante (dont les avantages sont particulièrement évidents dans l'exemple des chaînes de caractères).

void f(       string  ) { Print( __FUNCSIG__ ); } //1
void f( const string& ) { Print( __FUNCSIG__ ); } //2
string g() { return "ABCDEF4"; }
void OnStart()
{
          string text1 = "ABCDEF1";
    const string text2 = "ABCDEF2";
//  вызываемая функция: сейчас  предлагается
    f( text1 );     //    1       2               
    f( text2 );     //    *       2 потому что const или оставить *
    f( "ABCDEF3" ); //    1       1
    f( g());        //    1       1
//Примечание: * - неопределенность
}

Il n'est pas clair pourquoi passer (en fait copier) des chaînes longues par valeur quand cela peut être fait par référence.

 

Erreur de compilation

#import  "Test.dll" //Error: '#import' - #import was not closed
#include "Test.h"
#import
//Test.h
void f();

Pourquoi déplacer manuellement le contenu du fichier .h (d'autant plus qu'il peut changer de temps en temps) quand on peut simplement l'inclure ?

 

Bonjour, pourriez-vous me conseiller ?

Comment écrireles résultats de l'optimisation dans un fichier en utilisant la ferme du réseau local ou le réseau cloud de MQL5 ?

Il y a une procédure dans OnTester(), utilise :

string toWrite = "test";
fileHandle=FileOpen(fileName,FILE_CSV|FILE_READ|FILE_WRITE|FILE_ANSI|FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_COMMON,",");
FileWrite(fileHandle,toWrite);
FileClose(fileHandle);

Lors de l'utilisation des agents locaux, le fichier contenant les résultats de l'optimisation est créé dans le dossier partagé, lors de l'utilisation de la ferme du réseau local ou du réseau cloud MQL5, il n'y a pas de fichier.

Тестирование стратегий - Алгоритмический трейдинг, торговые роботы - MetaTrader 5
Тестирование стратегий - Алгоритмический трейдинг, торговые роботы - MetaTrader 5
  • www.metatrader5.com
Тестер стратегий позволяет тестировать и оптимизировать торговые стратегии (советники) перед началом использования их в реальной торговле. При тестировании советника происходит его однократная прогонка с начальными параметрами на исторических данных. При оптимизации торговая стратегия прогоняется несколько раз с различным набором параметров...
 
Nikolai Semko: QU'EST-CE QUI NE VA PAS ? D'OÙ VIENT LE RALENTISSEMENT ?

Une vérification a révélé que :

  1. mappages SQRT en instructions directes du CPU

  2. SQRT + les calculs mathématiques se font sans branchements et une instruction (128 bits de données) calcule deux racines à la fois

    Ce code se transforme en code assembleur SSE suivant :
             D1=sqrt((X1-X)*(X1-X)+(Y1-Y)*(Y1-Y));
         D2=sqrt((X2-X)*(X2-X)+(Y2-Y)*(Y2-Y));
         D3=sqrt((X3-X)*(X3-X)+(Y3-Y)*(Y3-Y));
         D4=sqrt((X4-X)*(X4-X)+(Y4-Y)*(Y4-Y));
         D5=sqrt((X5-X)*(X5-X)+(Y5-Y)*(Y5-Y));
         D6=sqrt((X6-X)*(X6-X)+(Y6-Y)*(Y6-Y));
         D7=sqrt((X7-X)*(X7-X)+(Y7-Y)*(Y7-Y));
         D8=sqrt((X8-X)*(X8-X)+(Y8-Y)*(Y8-Y));
            ...
        sqrtsd  xmm1, xmm1
        unpcklpd        xmm4, xmm4
        movapd  xmm3, xmmword ptr [rsp + 432]
        unpcklpd        xmm3, xmmword ptr [rsp + 384]
        subpd   xmm3, xmm4
        mulpd   xmm3, xmm3
        unpcklpd        xmm0, xmm0
        movapd  xmm5, xmmword ptr [rsp + 416]
        unpcklpd        xmm5, xmmword ptr [rsp + 400]
        subpd   xmm5, xmm0
        mulpd   xmm5, xmm5
        addpd   xmm5, xmm3
        sqrtpd  xmm8, xmm5
        movapd  xmm5, xmmword ptr [rsp + 464]
        subpd   xmm5, xmm4
        mulpd   xmm5, xmm5
        movapd  xmm7, xmm9
        subpd   xmm7, xmm0
        mulpd   xmm7, xmm7
        addpd   xmm7, xmm5
        movapd  xmm6, xmm10
        unpcklpd        xmm6, xmm11
        subpd   xmm6, xmm4
        movapd  xmm3, xmmword ptr [rsp + 368]
        unpcklpd        xmm3, xmmword ptr [rsp + 352]
        subpd   xmm3, xmm0
        movapd  xmm4, xmm8
        shufpd  xmm4, xmm4, 1
        sqrtpd  xmm5, xmm7
        mulpd   xmm6, xmm6
        mulpd   xmm3, xmm3
        addpd   xmm3, xmm6
        sqrtpd  xmm15, xmm3
        movapd  xmm0, xmm14
        unpcklpd        xmm0, xmmword ptr [rsp + 336]
        subpd   xmm0, xmm2
        mulpd   xmm0, xmm0
        movapd  xmm2, xmm0
        shufpd  xmm2, xmm2, 1
        addsd   xmm2, xmm0
        movapd  xmm0, xmm15
        shufpd  xmm0, xmm0, 1
        sqrtsd  xmm12, xmm2
    C'est une œuvre d'art en fait. 8 racines ont été calculées en 4 appels d'une instruction assembleur. Deux nombres doubles sont évalués en un seul appel.

  3. Lorsque l'on opère dans un tableau, tout se passe comme d'habitude avec des contrôles, des branchements et des pertes lors de la conversion de l'index double -> entier.

  4. En travaillant avec des tableaux dans cet exemple, il y a un mélange constant de FPU/ALU, ce qui est très mauvais pour la productivité.

  5. L'optimisation de l'accès dynamique aux tableaux est formidable - au-delà des éloges. Mais mélanger les opérations FPU/ALU + double -> entier + branchement fait perdre du temps.

La conclusion générale : les mathématiques dans MQL5 gagnent grâce à une optimisation parfaite. Ce ne sont pas les tableaux qui perdent ici, mais les mathématiques qui gagnent.

 

Et voici la pornographie réalisée sur le même code par Visual C++ 2017 x64 avec des optimisations complètes : 

; 52   :       int X=pos%Width;
; 53   :       int Y=int(pos/Width);
; 54   :       
; 55   :       D1=sqrt((X1-X)*(X1-X)+(Y1-Y)*(Y1-Y));

  0046 f 0 f 28 c8         movaps  xmm1, xmm0
  00472 8 b c3            mov     eax, ebx
  00474 99               cdq
  00475 45 0 f 57 db      xorps   xmm11, xmm11
  00479 f7 ff            idiv    edi
  0047 b 0 f 57 f6         xorps   xmm6, xmm6
  0047 e 41 0 f 28 c4      movaps  xmm0, xmm12
  00482 f2 44 0 f 2 a d8   cvtsi2sd xmm11, eax
  00487 f2 0 f 2 a f2      cvtsi2sd xmm6, edx
  0048 b f2 41 0 f 5 c cb   subsd   xmm1, xmm11
  00490 f2 0 f 5 c c6      subsd   xmm0, xmm6
  00494 f2 0 f 59 c9      mulsd   xmm1, xmm1
  00498 f2 0 f 59 c0      mulsd   xmm0, xmm0
  0049 c f2 0 f 58 c1      addsd   xmm0, xmm1
  004 a0 e8 00 00 00 00   call    sqrt

; 56   :       D2=sqrt((X2-X)*(X2-X)+(Y2-Y)*(Y2-Y));
; 57   :       D3=sqrt((X3-X)*(X3-X)+(Y3-Y)*(Y3-Y));

  004 a5 41 0 f 28 cf      movaps  xmm1, xmm15
  004 a9 41 0 f 28 c6      movaps  xmm0, xmm14
  004 ad f2 0 f 5 c c6      subsd   xmm0, xmm6
  004 b1 f2 41 0 f 5 c cb   subsd   xmm1, xmm11
  004 b6 f2 0 f 59 c0      mulsd   xmm0, xmm0
  004 ba f2 0 f 59 c9      mulsd   xmm1, xmm1
  004 be f2 0 f 58 c1      addsd   xmm0, xmm1
  004 c2 e8 00 00 00 00   call    sqrt

; 58   :       D4=sqrt((X4-X)*(X4-X)+(Y4-Y)*(Y4-Y));

  004 c7 f2 0 f 10 8 c 24
        90 01 00 00      movsd   xmm1, QWORD PTR Y4$1$[rsp]
  004 d0 f2 0 f 10 84 24
        98 01 00 00      movsd   xmm0, QWORD PTR X4$1$[rsp]
  004 d9 f2 41 0 f 5 c cb   subsd   xmm1, xmm11
  004 de f2 0 f 5 c c6      subsd   xmm0, xmm6
  004 e2 f2 0 f 59 c9      mulsd   xmm1, xmm1
  004 e6 f2 0 f 59 c0      mulsd   xmm0, xmm0
  004 ea f2 0 f 58 c1      addsd   xmm0, xmm1
  004 ee e8 00 00 00 00   call    sqrt

; 59   :       D5=sqrt((X5-X)*(X5-X)+(Y5-Y)*(Y5-Y));
; 60   :       D6=sqrt((X6-X)*(X6-X)+(Y6-Y)*(Y6-Y));
; 61   :       D7=sqrt((X7-X)*(X7-X)+(Y7-Y)*(Y7-Y));
; 62   :       D8=sqrt((X8-X)*(X8-X)+(Y8-Y)*(Y8-Y));

  004 f3 f2 0 f 10 44 24
        20               movsd   xmm0, QWORD PTR X8$1$[rsp]
  004 f9 41 0 f 28 c8      movaps  xmm1, xmm8
  004 fd f2 0 f 5 c c6      subsd   xmm0, xmm6
  00501 f2 41 0 f 5 c cb   subsd   xmm1, xmm11
  00506 f2 0 f 59 c0      mulsd   xmm0, xmm0
  0050 a f2 0 f 59 c9      mulsd   xmm1, xmm1
  0050 e f2 0 f 58 c1      addsd   xmm0, xmm1
  00512 e8 00 00 00 00   call    sqrt
  00517 f2 0 f 10 4 c 24
        28               movsd   xmm1, QWORD PTR Y2$1$[rsp]
  0051 d 41 0 f 28 c5      movaps  xmm0, xmm13
  00521 f2 44 0 f 10 44
        24 30            movsd   xmm8, QWORD PTR Y5$1$[rsp]
  00528 f2 41 0 f 5 c cb   subsd   xmm1, xmm11
  0052 d f2 44 0 f 10 54
        24 40            movsd   xmm10, QWORD PTR Y6$1$[rsp]
  00534 f2 0 f 5 c c6      subsd   xmm0, xmm6
  00538 f2 44 0 f 10 64
        24 50            movsd   xmm12, QWORD PTR Y7$1$[rsp]
  0053 f f2 45 0 f 5 c c3   subsd   xmm8, xmm11
  00544 f2 0 f 10 7 c 24
        38               movsd   xmm7, QWORD PTR X5$1$[rsp]
  0054 a f2 45 0 f 5 c d3   subsd   xmm10, xmm11
  0054 f f2 44 0 f 10 4 c
        24 48            movsd   xmm9, QWORD PTR X6$1$[rsp]
  00556 f2 45 0 f 5 c e3   subsd   xmm12, xmm11
  0055 b f2 44 0 f 10 5 c
        24 58            movsd   xmm11, QWORD PTR X7$1$[rsp]
  00562 f2 0 f 5 c fe      subsd   xmm7, xmm6
  00566 f2 0 f 59 c0      mulsd   xmm0, xmm0
  0056 a f2 44 0 f 5 c ce   subsd   xmm9, xmm6
  0056 f f2 0 f 59 c9      mulsd   xmm1, xmm1
  00573 f2 44 0 f 5 c de   subsd   xmm11, xmm6
  00578 f2 0 f 58 c1      addsd   xmm0, xmm1
  0057 c e8 00 00 00 00   call    sqrt
  00581 f2 0 f 59 ff      mulsd   xmm7, xmm7
  00585 f2 45 0 f 59 c0   mulsd   xmm8, xmm8
  0058 a f2 41 0 f 58 f8   addsd   xmm7, xmm8
  0058 f 0 f 28 c7         movaps  xmm0, xmm7
  00592 e8 00 00 00 00   call    sqrt
  00597 f2 45 0 f 59 c9   mulsd   xmm9, xmm9
  0059 c f2 45 0 f 59 d2   mulsd   xmm10, xmm10
  005 a1 f2 45 0 f 58 ca   addsd   xmm9, xmm10
  005 a6 41 0 f 28 c1      movaps  xmm0, xmm9
  005 aa e8 00 00 00 00   call    sqrt
  005 af f2 45 0 f 59 db   mulsd   xmm11, xmm11
  005 b4 f2 45 0 f 59 e4   mulsd   xmm12, xmm12
  005 b9 f2 45 0 f 58 dc   addsd   xmm11, xmm12
  005 be 41 0 f 28 c3      movaps  xmm0, xmm11
  005 c2 e8 00 00 00 00   call    sqrt
  005 c7 f2 0 f 10 84 24
        88 01 00 00      movsd   xmm0, QWORD PTR Y1$1$[rsp]

; 63   : 
; 64   :       double d=fabs(D1+D3+D4+D8)/(D1+D2+D3+D4+D5+D6+D7+D8);

Un multiple non qualifié du code généré dans MQL5.

Étonnamment, MSVC n'essaie même pas d'optimiser - toutes les mathématiques passent par des bibliothèques comme si elles avaient été écrites pour un processeur vieux de 20 ans. Et l'activation de l'ensemble des commandes AVX ne change pas du tout le comportement du compilateur.

Fichier de test C++ joint. Il n'y a pas d'erreur dans l'exemple de test, alors n'exprimez pas la pensée d'une "erreur dans l'exemple de test".

Dossiers :
Test.cpp.zip  1 kb
 

Je n'obtiens pas de graphique d'optimisation pour les valeurs négatives.

Les données sont disponibles dans les résultats de l'optimisation.

Essayez de définir des valeurs négatives dans vos EAs. Les valeurs peuvent être * -1 pour vérifier.

1...215721582159216021612162216321642165216621672168216921702171...3184
Nouveau commentaire