Erros, bugs, perguntas - página 2164

 
Vladimir Pastushak:

Há muito pouco espaço nas descrições dos produtos.

3600 caracteres é extremamente curto para programas grandes e sérios.

Penso que muitas pessoas estarão de acordo comigo.

Não precisa de menos de 5000 - 10000 caracteres para descrever programas. Ou pelo menos um separador com o nome das definições do programa

Um moderador pode sempre pedir para remover a água.

Neste momento estou a escrever uma descrição do programa, e já usei os 3.600 caracteres só para descrever as configurações, mas ainda nem sequer descrevi metade das características...

Vladimir, já alguma vez comprou alguma coisa? Quanto tempo passou a ler o manual?

Ninguém vai ler um livro multi-volume, e nem sequer vão ver vídeos durante mais de 3-5 minutos.
Existe apenas uma solução: Pontas de ferramentas na interface do programa, como em quase todos os outros lugares. Algo como um tutorial interactivo. E instruções detalhadas para utilizadores avançados podem ser colocadas num blogue ou no seu site. Quem quer que o queira, irá encontrá-lo e descarregá-lo.

 
Vladimir Pastushak:

Há muito pouco espaço nas descrições dos produtos.

3600 caracteres é extremamente curto para programas grandes e sérios.

Penso que muitas pessoas estarão de acordo comigo.

Não precisa de menos de 5000 - 10000 caracteres para descrever programas. Ou pelo menos um separador com o nome das definições do programa

Um moderador pode sempre pedir para remover a água.

Neste momento estou a escrever uma descrição do programa, usei todos os 3.600 caracteres apenas para descrever as configurações e nem sequer metade das características...

Não estou de acordo. A Brevity é a irmã do talento.

"Não penses que nas tuas muitas palavras serás ouvido".

Mateus 6:7.

 
Andrey Khatimlianskii:

Vladimir, já alguma vez comprou alguma coisa? Quanto tempo passou a ler as instruções?

Ninguém lerá um livro de vários volumes, nem sequer verá um vídeo de 3 a 5 minutos de duração.
Só há uma saída - acrescentar pistas na interface do programa, como é feito em quase todo o lado agora. Algo como um tutorial interactivo. E instruções detalhadas para utilizadores avançados podem ser colocadas num blogue ou no seu site. Quem quer que o queira, irá encontrá-lo e descarregá-lo.

Quem não lê e não compra, já comprou muitos produtos sem compreender para que serve o produto?

Deveríamos então publicar tudo nos blogs?

 
Nikolai Semko:

Não estou de acordo. A Brevity é a irmã do talento.

"Não penses que na tua verbosidade serás ouvido".

Mateus 6:7.

Concordo, mas mesmo um breve 3600 não é suficiente...

 
Vladimir Pastushak:

Quem não lê e não compra, já comprou muitos produtos sem compreender para que serve o produto?

Deveríamos então publicar tudo nos blogs?

Compreender o objectivo do produto a partir do manual?

Que tolice. Vou descarregar e sentir a demonstração.

 
A100:

Este código é baseado num defeito do compilador

Resultado: 1... Porque não 2 ?

Enquanto C++ reporta um erro durante a compilação, porque ambas as funções encaixam obviamente, e além disso, a sintaxe não permite chamar explicitamente a função (2)

Além disso, tendo em conta as características específicas do MQL, seria mais lógico fazer o contrário - estabelecer a prioridade de passar o parâmetro não por valor (como agora), mas por referência constante (cujos benefícios são especialmente evidentes no exemplo das cordas).

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

Não é claro porquê passar (copiar de facto) cordas longas por valor quando pode ser feito por referência.

 

Erro de compilação

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

Porquê mover manualmente o conteúdo do ficheiro .h (especialmente porque pode mudar de vez em quando) quando pode simplesmente incluí-lo?

 

Boa tarde, poderia por favor aconselhar:

Como escreveros resultados da optimização num ficheiro usando a Rede Local Farm ou MQL5 Cloud Network ?

Há um procedimento em OnTester(), utilizações:

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

Quando se utilizam agentes locais, o ficheiro com resultados de optimização é criado na pasta partilhada, quando se utiliza a Local Network Farm ou MQL5 Cloud Network, não há ficheiro.

Тестирование стратегий - Алгоритмический трейдинг, торговые роботы - MetaTrader 5
Тестирование стратегий - Алгоритмический трейдинг, торговые роботы - MetaTrader 5
  • www.metatrader5.com
Тестер стратегий позволяет тестировать и оптимизировать торговые стратегии (советники) перед началом использования их в реальной торговле. При тестировании советника происходит его однократная прогонка с начальными параметрами на исторических данных. При оптимизации торговая стратегия прогоняется несколько раз с различным набором параметров...
 
Nikolai Semko: O QUE É ERRADO? DE ONDE VEM A DESACELERAÇÃO?

Uma verificação revelou que:

  1. O SQRT é mapeado em instruções directas da CPU

  2. O SQRT + cálculos matemáticos passam sem ramos e uma instrução (128 bits de dados) calcula duas raízes ao mesmo tempo

    Este código transforma-se no seguinte código SSE do assembler:
             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
    Esta é uma obra de arte, na verdade. 8 raízes foram calculadas em 4 chamadas de uma instrução de assembler. Dois números duplos são avaliados numa chamada.

  3. Quando se opera através de uma matriz, tudo corre como habitualmente com verificações, ramificações e perdas na conversão do índice duplo -> inteiro.

  4. Quando se trabalha com matrizes neste exemplo, há uma mistura constante FPU/ALU que é muito má para a produtividade

  5. A optimização do acesso à matriz dinâmica é óptima - para além dos elogios. Mas a mistura de operações de FPU/ALU + duplo -> inteiro + ramificação desperdiça tempo.

A conclusão geral: a matemática em MQL5 ganha devido a uma optimização perfeita. Não são as arrays que perdem aqui, mas a matemática ganha.

 

E eis o que a pornografia foi feita no mesmo código pelo Visual C++ 2017 x64 com optimizações totais:

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

Um múltiplo não qualificado do código gerado em MQL5.

Surpreendentemente, MSVC nem sequer tenta optimizar - toda a matemática é conduzida através de bibliotecas como se fosse escrita para um processador com 20 anos de idade. E permitir o conjunto de comandos AVX não altera em nada o comportamento do compilador.

Ficheiro de teste C++ em anexo. Não há erro no exemplo de teste, por isso não exprima a ideia de "um erro no exemplo de teste".

Arquivos anexados:
Test.cpp.zip  1 kb
Razão: