Errores, fallos, preguntas - página 2164

Nuevo comentario
 
Vladimir Pastushak:

Hay muy poco espacio en las descripciones de los productos.

3600 caracteres es muy poco para programas grandes y serios.

Creo que muchos estarán de acuerdo conmigo.

Necesita no menos de 5000 - 10000 caracteres para describir los programas. O al menos una pestaña con el nombre de la configuración del programa

Un moderador siempre puede pedir que se elimine el agua.

Ahora mismo estoy escribiendo una descripción del programa, y he utilizado los 3.600 caracteres sólo para describir los escenarios, pero ni siquiera he descrito la mitad de las características...

Vladimir, ¿alguna vez has comprado algo? ¿Cuánto tiempo has dedicado a leer el manual?

Nadie va a leer un libro de varios volúmenes, y ni siquiera va a ver vídeos de más de 3-5 minutos.
Sólo hay una solución: información sobre herramientas en la interfaz del programa, como hacen casi todos los demás. Algo así como un tutorial interactivo. Y las instrucciones detalladas para los usuarios avanzados pueden colocarse en un blog o en su sitio. Quien lo quiera lo encontrará y lo descargará.

 
Vladimir Pastushak:

Hay muy poco espacio en las descripciones de los productos.

3600 caracteres es muy poco para programas grandes y serios.

Creo que muchos estarán de acuerdo conmigo.

Necesita no menos de 5000 - 10000 caracteres para describir los programas. O al menos una pestaña con el nombre de la configuración del programa

Un moderador siempre puede pedir que se elimine el agua.

Ahora mismo estoy escribiendo una descripción del programa, he utilizado los 3.600 caracteres sólo para describir los escenarios y ni siquiera la mitad de las características...

No estoy de acuerdo. La brevedad es la hermana del talento.

"No pienses que con tus muchas palabras serás escuchado".

Mateo 6:7.

 
Andrey Khatimlianskii:

Vladimir, ¿alguna vez has comprado algo? ¿Cuánto tiempo ha dedicado a leer las instrucciones?

Nadie leerá un libro de varios volúmenes, ni siquiera verá un vídeo de 3 a 5 minutos.
Sólo hay una salida: añadir pistas en la interfaz del programa, como se hace ahora en casi todas partes. Algo así como un tutorial interactivo. Y las instrucciones detalladas para los usuarios avanzados pueden colocarse en un blog o en su sitio. Quien lo quiera lo encontrará y lo descargará.

Los que no leen y no compran, ¿han comprado muchos productos sin entender para qué sirve el producto?

¿Debemos entonces publicar todo en los blogs?

 
Nikolai Semko:

No estoy de acuerdo. La brevedad es la hermana del talento.

"No creas que con tu verborrea serás escuchado".

Mateo 6:7.

Estoy de acuerdo, pero incluso el breve 3600 no es suficiente...

 
Vladimir Pastushak:

Los que no leen y no compran, ¿han comprado muchos productos sin entender para qué sirve el producto?

¿Debemos entonces publicar todo en los blogs?

¿Comprender la finalidad del producto a partir del manual?

Eso es una tontería. Voy a descargar y sentir la demo.

 
A100:

Este código se basa en un defecto del compilador

Resultado: 1... ¿Por qué no 2?

Mientras que C++ informa de un error durante la compilación, porque ambas funciones encajan obviamente, y además, la sintaxis no permite llamar explícitamente a la función (2)

Además, teniendo en cuenta las características específicas de MQL, sería más lógico hacer lo contrario: establecer la prioridad de pasar el parámetro no por valor (como ahora), sino por referencia const (cuyas ventajas son especialmente evidentes en el ejemplo de las cadenas).

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

No está claro por qué pasar (en realidad copiar) cadenas largas por valor cuando se puede hacer por referencia.

 

Error de compilación

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

¿Por qué mover manualmente el contenido del archivo .h (sobre todo porque puede cambiar de vez en cuando) cuando puedes simplemente incluirlo?

 

Buenas tardes, ¿podrían aconsejarme?

¿Cómo escribirlos resultados de la optimización en un archivo utilizando la granja de red local o la red en la nube MQL5?

Hay un procedimiento en OnTester(), utiliza:

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

Cuando se utilizan agentes locales, el archivo con los resultados de la optimización se crea en la carpeta compartida, cuando se utiliza Local Network Farm o MQL5 Cloud Network, no hay ningún archivo.

Тестирование стратегий - Алгоритмический трейдинг, торговые роботы - MetaTrader 5
Тестирование стратегий - Алгоритмический трейдинг, торговые роботы - MetaTrader 5
  • www.metatrader5.com
Тестер стратегий позволяет тестировать и оптимизировать торговые стратегии (советники) перед началом использования их в реальной торговле. При тестировании советника происходит его однократная прогонка с начальными параметрами на исторических данных. При оптимизации торговая стратегия прогоняется несколько раз с различным набором параметров...
 
Nikolai Semko:¿QUÉ ES LO QUE FALTA? ¿DE DÓNDE VIENE LA DESACELERACIÓN?

Una comprobación reveló que:

  1. SQRT se mapea en instrucciones directas de la CPU

  2. SQRT + los cálculos matemáticos van sin ramas y una instrucción (128 bits de datos) calcula dos raíces a la vez

    Este código se convierte en el siguiente código SSE en ensamblador:
             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
    Esto es una obra de arte en realidad. Se calcularon 8 raíces en 4 llamadas de una instrucción de ensamblador. Se evalúan dos números dobles en una sola llamada.

  3. Cuando se opera a través de un array, todo va como de costumbre con comprobaciones, bifurcaciones y pérdidas al convertir el índice doble -> entero.

  4. Al trabajar con arrays en este ejemplo hay una mezcla constante de FPU/ALU que es muy mala para la productividad

  5. La optimización del acceso a las matrices dinámicas es genial, más allá de los elogios. Pero la mezcla de operaciones FPU/ALU + doble -> entero + bifurcación hace perder tiempo.

La conclusión general: las matemáticas en MQL5 ganan gracias a la optimización perfecta. Aquí no pierden las matrices, sino que ganan las matemáticas.

 

Y aquí está lo que la pornografía se hizo en el mismo código por Visual C ++ 2017 x64 con optimizaciones completas: 

; 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 múltiplo no calificado del código generado en MQL5.

Sorprendentemente MSVC ni siquiera trata de optimizar - toda la matemática es conducida a través de bibliotecas como si fuera escrita para un procesador de hace 20 años. Y la activación del conjunto de comandos AVX no cambia en absoluto el comportamiento del compilador.

Se adjunta el archivo C++ de prueba. No es necesario expresar la idea de "un error en el ejemplo de prueba", no hay ningún error.

Archivos adjuntos:
Test.cpp.zip  1 kb
1...215721582159216021612162216321642165216621672168216921702171...3187
Nuevo comentario
Razón de la queja: