Fehler, Irrtümer, Fragen - Seite 2164

[Andrey Khatimlianskii]

Vladimir Pastushak:

In den Produktbeschreibungen ist nur sehr wenig Platz vorhanden.

3600 Zeichen sind für umfangreiche und seriöse Programme extrem wenig.

Ich denke, viele Menschen werden mir zustimmen.

Für die Programmbeschreibung benötigen Sie mindestens 5000 bis 10000 Zeichen. Oder zumindest eine Registerkarte mit dem Namen der Programmeinstellungen

Ein Moderator kann jederzeit darum bitten, das Wasser zu entfernen.

Im Moment schreibe ich eine Beschreibung der Software, und ich habe alle 3600 Zeichen nur für die Beschreibung der Einstellungen verwendet, aber ich habe nicht einmal die Hälfte der Funktionen beschrieben...

Vladimir, haben Sie jemals etwas gekauft? Wie viel Zeit haben Sie mit dem Lesen des Handbuchs verbracht?

Niemand wird ein mehrbändiges Buch lesen, und niemand wird sich Videos ansehen, die länger als 3-5 Minuten dauern.
Die einzige Lösung besteht darin, Hinweise in die Schnittstelle des Programms einzufügen, wie es fast überall sonst auch geschieht. So etwas wie ein interaktives Tutorial. Detaillierte Anleitungen für fortgeschrittene Benutzer können in einem Blog oder auf ihrer Website veröffentlicht werden. Wer es will, findet es und lädt es herunter.

[Nikolai Semko]

Vladimir Pastushak:

In den Produktbeschreibungen ist nur sehr wenig Platz vorhanden.

3600 Zeichen sind für umfangreiche und seriöse Programme extrem wenig.

Ich denke, viele Menschen werden mir zustimmen.

Für die Programmbeschreibung benötigen Sie mindestens 5000 bis 10000 Zeichen. Oder zumindest eine Registerkarte mit dem Namen der Programmeinstellungen

Ein Moderator kann jederzeit darum bitten, das Wasser zu entfernen.

Im Moment schreibe ich eine Beschreibung des Programms, ich habe alle 3.600 Zeichen nur für die Beschreibung der Einstellungen verwendet und nicht einmal die Hälfte der Funktionen...

Dem stimme ich nicht zu. Knappheit ist die Schwester des Talents.

"Glaubt nicht, dass ihr mit euren vielen Worten gehört werdet".

Matthäus 6:7.

[Vladimir Pastushak]

Andrey Khatimlianskii:

Vladimir, haben Sie jemals etwas gekauft? Wie viel Zeit haben Sie mit dem Lesen der Anleitung verbracht?

Niemand liest ein mehrbändiges Buch, niemand schaut sich ein Video von 3 bis 5 Minuten Länge an.
Es gibt nur einen Ausweg: Hinweise in die Schnittstelle des Programms einbauen, wie es heute fast überall geschieht. So etwas wie ein interaktives Tutorial. Detaillierte Anleitungen für fortgeschrittene Benutzer können in einem Blog oder auf ihrer Website veröffentlicht werden. Wer es will, findet es und lädt es herunter.

Diejenigen, die nicht lesen und nicht kaufen, haben Sie schon viele Produkte gekauft, ohne zu verstehen, wofür das Produkt gedacht ist?

Sollten wir dann alles in Blogs veröffentlichen?

[Vladimir Pastushak]

Nikolai Semko:

Da bin ich anderer Meinung. Knappheit ist die Schwester des Talents.

"Glaubt nicht, dass ihr mit eurer Geschwätzigkeit gehört werdet".

Matthäus 6:7.

Ich stimme zu, aber selbst kurze 3600 sind nicht genug...

[Andrey Khatimlianskii]

Vladimir Pastushak:

Diejenigen, die nicht lesen und nicht kaufen, haben Sie schon viele Produkte gekauft, ohne zu verstehen, wofür das Produkt gedacht ist?

Sollten wir dann alles in Blogs veröffentlichen?

Verstehen Sie den Zweck des Produkts anhand des Handbuchs?

Das ist lächerlich. Ich werde die Demo herunterladen und ausprobieren.

[A100]

A100:

Dieser Code basiert auf einem Compilerfehler

Ergebnis: 1... Warum nicht 2?

Während C++ bei der Kompilierung einen Fehler meldet, weil beide Funktionen offensichtlich passen, und außerdem die Syntax keinen expliziten Aufruf der Funktion (2) erlaubt

Außerdem wäre es unter Berücksichtigung der Besonderheiten von MQL logischer, das Gegenteil zu tun - die Priorität der Übergabe des Parameters nicht durch den Wert (wie jetzt), sondern durch die Konst-Referenz festzulegen (deren Vorteile besonders im Beispiel der Strings deutlich werden).

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
//Примечание: * - неопределенность
}

Es ist unklar, warum man lange Zeichenketten als Wert übergibt (eigentlich kopiert), wenn man dies auch als Referenz tun kann.

[A100]

Kompilierungsfehler

#import  "Test.dll" //Error: '#import' - #import was not closed
#include "Test.h"
#import

//Test.h
void f();

Warum den Inhalt der .h-Datei manuell verschieben (zumal er sich von Zeit zu Zeit ändern kann), wenn man ihn einfach einbinden kann?

[Nextor]

Guten Tag, könnten Sie mir bitte einen Rat geben:

Wie schreibt mandie Optimierungsergebnisse in eine Datei, wenn man eine lokale Netzwerkfarm oder ein MQL5-Cloud-Netzwerk verwendet?

Es gibt eine Prozedur in OnTester(), die verwendet wird:

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);

Bei der Verwendung von lokalen Agenten wird die Datei mit den Optimierungsergebnissen im gemeinsamen Ordner erstellt, bei der Verwendung einer lokalen Netzwerkfarm oder eines MQL5-Cloud-Netzwerks gibt es keine Datei.

[Renat Fatkhullin]

Nikolai Semko: WAS IST FALSCH? WOHER KOMMT DIE VERLANGSAMUNG?

Eine Überprüfung ergab dies:

1. SQRT wird in direkten CPU-Anweisungen abgebildet
   
   
2. SQRT + mathematische Berechnungen kommen ohne Verzweigungen aus und eine Anweisung (128 Bit Daten) berechnet zwei Wurzeln auf einmal
   
   Dieser Code wird zu folgendem SSE-Assembler-Code:
   

            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

   Das ist wirklich ein Kunstwerk. 8 Wurzeln wurden in 4 Aufrufen einer Assembler-Anweisung berechnet. Zwei doppelte Zahlen werden in einem Aufruf ausgewertet.
   
   
3. Beim Operieren durch ein Array geht alles wie gewohnt mit Prüfungen, Verzweigungen und Verlusten bei der Umwandlung von Double -> Integer-Index.
   
   
4. Bei der Arbeit mit Arrays in diesem Beispiel kommt es zu einer ständigen Vermischung von FPU und ALU, was sehr schlecht für die Produktivität ist.
   
   
5. Die Optimierung des dynamischen Array-Zugriffs ist großartig - mehr als lobenswert. Aber das Mischen von FPU/ALU-Operationen + Double -> Integer + Verzweigung verschwendet Zeit
   
   

Die allgemeine Schlussfolgerung: Mathematik in MQL5 gewinnt durch perfekte Optimierung. Nicht die Arrays verlieren hier, sondern die Mathematik gewinnt.

[Renat Fatkhullin]

Und hier ist, was Pornographie auf den gleichen Code von Visual C++ 2017 x64 mit voller Optimierungen gemacht wurde:

; 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);

Ein unqualifiziertes Vielfaches des in MQL5 erzeugten Codes.

Überraschenderweise versucht MSVC nicht einmal zu optimieren - die gesamte Mathematik wird durch Bibliotheken gesteuert, als ob sie für einen 20 Jahre alten Prozessor geschrieben worden wäre. Und die Aktivierung des AVX-Befehlssatzes ändert das Verhalten des Compilers überhaupt nicht.

Test-C++-Datei im Anhang. Es gibt keinen Fehler im Testbeispiel, also äußern Sie nicht den Gedanken an "einen Fehler im Testbeispiel".