Erros, bugs, perguntas - página 107

[[Excluído]]

Yedelkin:
Simpleton, eu segui o mesmo caminho, mas usei conversão explícita para int tipo. Assumi que o tamanho máximo possível do lote será limitado, quer pelo corretor/negociante, quer pelo tamanho dos meus próprios fundos. Assim, a utilização de int deve ser suficiente. Acha que existem algumas armadilhas nesta abordagem (arredondamento a partir do fundo usando int)?

Para um comércio real, provavelmente, sim, int/uint é suficiente.

Mas se o testarmos, pode não ser suficiente para algumas experiências.

Não há armadilhas, além de possíveis próximas falhas na implementação do MQL5, quando se utiliza int, se pudermos garantir que o N inteiro da fórmula se enquadrará no intervalo 0...INT_MAX e, portanto, não iremos transbordar. Ou seja, substituir o cheque

tmp < ULONG_MAX * stepvol

para

tmp < INT_MAX * stepvol

Na realidade, o tipo int é assinado e metade dos seus valores possíveis encontra-se dentro da área dos números negativos, enquanto aqui serão sempre não-negativos. É irracional usar int quando há um uint não assinado que tem o mesmo tamanho mas o dobro do intervalo na área não-negativa. Portanto, se vamos usar int/uint, é melhor usar uint e substituir o cheque por uint, respectivamente:

tmp < UINT_MAX * stepvol

[[Excluído]]

gumgum:

#property script_show_inputs

Obrigado pela dica.

[Yedelkin]

simpleton:

Para um comércio real, muito provavelmente sim, int/uint é suficiente.

.. Na verdade, o tipo int é assinado, metade dos seus valores possíveis encontram-se na área dos números negativos, e aqui será sempre não-negativo. É irracional usar int, quando há um uint não assinado que tem o mesmo tamanho mas o dobro do intervalo na área não-negativa. Portanto, se vamos usar int/uint, é melhor usar uint e substituir o cheque por uint, respectivamente:

Sim, já está, obrigado!

[Николай]

Não é um insecto, mas uma observação interessante sobre tipos

O que pensa que é 2 vezes 2, ou seja, 2*2?

pensa 4 talvez tenha razão!

OK, que tal isto
duzentos mil vezes duzentos mil

200000 * 200000

Qualquer aluno pode multiplicar dois e quatro e adicionar zeros e obter...

40000000000.

Agora vamos escrever um código simples na língua da máquina.

lotes longos = 200000*200000;

notar que o tipo de hospedeiro da variável é longo, ou seja
O valor mínimo é -9 223 372 036 854 775 808; o valor máximo é 9 223 372 036 854 775 807.

Imprima o total e obtém

lotes = 1345294336
isso é muito diferente de duas vezes duas e terá duas.

Releio a secção de ajuda sobre tipos e conversões de tipos.
Não encontrei nenhuma informação de que os números regulares devem ser explicitamente lançados para o tipo certo

portanto, é assim que deve ser

lotes longos = (longo) 200000 * (longo) 200000;

em alternativa, pode utilizar variáveis auxiliares adicionais.

[Николай]

Há mais.

Se quiser recuperar e multiplicar por grandes números algumas propriedades....

Aqui está o código

long A = AccountInfoInteger(ACCOUNT_LOGIN);  // 661701
long B = A;
long C = 661701;
Print(" A=",A,"  B=",B,"  C=",C);
long X =10000;

long L1 = A*X;
long L2 = B*X;
long L3 = C*X;

Print(" L1=",L1,"   L2=",L2,"   L3=",L3);

E aqui está o resultado

L1=2322042704   L2=2322042704   L3=6617010000
A =661701        B =661701      C =661701

as entradas são as mesmas, mas o resultado é diferente

[[Excluído]]

SHOOTER777:

E agora um código simples em linguagem de máquina

lotes longos = 200000*200000;

Note-se que o tipo de variável longa receptora é longa, ou seja
O valor mínimo é -9 223 372 036 854 775 808, o valor máximo é 9 223 372 036 854 775 807.

Imprima o total e obtenha

lotes = 1345294336
isso é muito diferente de duas vezes duas e terá duas.

Releio a secção de ajuda sobre tipos e conversões de tipos.
Não encontrei qualquer informação que deva lançar explicitamente números regulares para um determinado tipo.

portanto, é assim que deve ser

lotes longos = (longo) 200000 * (longo) 200000;

Alternativamente, também pode utilizar variáveis auxiliares.

Os "números normais" são expressões constantes que também têm um tipo. Neste caso, é o tipo int.

A expressão que consiste na multiplicação de duas subexpressões, sendo cada uma delas do tipo int, é também do tipo int. É aqui que o transbordo ocorre.

E só então a conversão implícita do tipo de expressão int para tipo longo ocorre quando se inicializa uma variável de tipo longo.

Aqui tudo é claro. A propósito, neste caso, cada um dos operandos não precisa de ser moldado ao tipo longo. É suficiente lançar um, e o segundo será lançado implicitamente.

[[Excluído]]

SHOOTER777:

Há mais.

Se quiser recuperar e multiplicar por grandes números algumas propriedades....

Aqui está o código

E aqui está o resultado.

Os dados de origem são os mesmos, mas o resultado é diferente

Parece que o diário de bordo e o código estão misturados. O código acima funciona "limpo". E, para obter tal registo, tive de fazer variáveis A e B de tipo int ou uint, e variável X de tipo uint:

void OnStart()
{
int A = 661701;
int B = A;
long C = 661701;
Print(" A=",A,"  B=",B,"  C=",C);
uint X =10000;

long L1 = A*X;
long L2 = B*X;
long L3 = C*X;

Print(" L1=",L1,"   L2=",L2,"   L3=",L3);
}

/* Вывод в лог (хронология - сверху вниз):
KO      0       1 (EURUSD,M15)  00:46:28         A=661701  B=661701  C=661701
OE      0       1 (EURUSD,M15)  00:46:28         L1=2322042704   L2=2322042704   L3=6617010000
*/

E aqui está como funciona o código original:

void OnStart()
{
long A = 661701;
long B = A;
long C = 661701;
Print(" A=",A,"  B=",B,"  C=",C);
long X =10000;

long L1 = A*X;
long L2 = B*X;
long L3 = C*X;

Print(" L1=",L1,"   L2=",L2,"   L3=",L3);
}

/* Вывод в лог (хронология сверху вниз):
DL      0       1 (EURUSD,M15)  00:49:13         A=661701  B=661701  C=661701
HG      0       1 (EURUSD,M15)  00:49:13         L1=6617010000   L2=6617010000   L3=6617010000
*/

Construir 314 (20 Ago 2010).

[Дмитрий]

Pode dizer-me, por exemplo, se eu quiser obter o valor de algum indicador. Costumava obtê-lo com precisão e garantia usando a função incorporada. Agora tenho de ser eu a escrevê-lo usando um monte de códigos, amortecedores, pegas, etc. Mas não é essa a questão. O principal para mim é que o código se torna literalmente defeituoso em cada linha, porque tenho de verificar isto em cada linha de código para ter a certeza de que não ocorreu nenhum erro... Em geral, pensava que todas estas complexidades, classes e coisas que eram elementares mas que se tornaram incómodas e inconvenientes eram feitas para aumentar a velocidade, fiabilidade, etc... Li um artigo sobre 20 sinais... diz:

"Não é possível aceder aos dados indicadores logo após a sua criação, pois leva algum tempo a calcular os valores dos indicadores, por isso, é melhor criar manipulações de indicadores no OnInit()".

Depois há verificações para cada linha

"Vamos verificá-los: se houver menos dados do que os necessários, significa que ocorreu um erro de cópia e que um maior acesso à matriz, onde os dados devem ser armazenados, levará a um erro. Para descartar esta possibilidade, abandonaremos a função".

Portanto, em vez de acelerar, tenho de fazer um loop (quantas vezes?) através desta função para obter um resultado no final... E se eu precisar de valores individuais de linhas separadas de diferentes indicadores periodicamente... Esta é uma função separada para cada valor... Isso são muitas variáveis e códigos extras...

Em suma, explique-me, dê-me uma ligação, quero compreender o significado de tudo isto, porque é tão e não tão fiável...

E seria bom que as respostas a tais perguntas pudessem ser colocadas na secção de migração de µl4 para µl5 ajuda ou criar uma secção relevante no fórum, sem qualquer discussão, especificamente uma pergunta e resposta, com uma explicação do porquê disso... por exemplo, o período é explicado aqui de uma forma muito acessível, e da mesma forma gostaríamos de ter respostas a perguntas elementares

[[Excluído]]

Dmitriy2:

Pode dizer-me, por exemplo, se eu quiser obter o valor de algum indicador. Costumava obtê-lo de forma exacta e segura usando a função incorporada. Agora tenho de ser eu a escrevê-lo usando um monte de códigos, amortecedores, pegas, etc. Mas não é essa a questão. O principal para mim é que o código se torna literalmente defeituoso em cada linha, porque tenho de verificar isto em cada linha de código para ter a certeza de que não ocorreu nenhum erro... Em geral, pensava que todas estas complexidades, classes e coisas que eram elementares mas que se tornaram incómodas e inconvenientes eram feitas para aumentar a velocidade, fiabilidade, etc... Li um artigo sobre 20 sinais... diz:

"Não é possível aceder aos dados indicadores logo após a sua criação, pois leva algum tempo a calcular os valores dos indicadores, por isso, é melhor criar manipulações de indicadores no OnInit()".

Depois há verificações para cada linha

"Vamos verificá-los: se houver menos dados do que os necessários, significa que ocorreu um erro de cópia e que um maior acesso à matriz, onde os dados devem ser armazenados, levará a um erro. Para descartar esta possibilidade, abandonaremos a função".

Portanto, em vez de acelerar, tenho de fazer um loop (quantas vezes?) através desta função para obter um resultado no final... E se eu precisar de valores individuais de linhas separadas de diferentes indicadores periodicamente... Esta é uma função separada para cada valor... Isso são muitas variáveis e códigos extras...

Em suma, explique-me, dê-me uma ligação, quero compreender o significado de tudo isto, porque é tão e não tão fiável...

E seria bom que as respostas a tais perguntas pudessem ser colocadas na secção de migração de µl4 para µl5 ajuda ou criar uma secção relevante no fórum, sem qualquer discussão, especificamente uma pergunta e resposta, com uma explicação do porquê disso... por exemplo, o período é explicado aqui de uma forma muito acessível, por isso seria bom ter respostas às perguntas elementares da mesma forma

É mais fiável? Porque é que não é fiável obter pegas na inicialização? Porque não é fiável verificar a disponibilidade dos dados necessários? E além disso, porque é que não é fiável ter controlos em vigor?

Pode não ser tão fácil para os principiantes, mas com o tempo tornar-se-á claro...

[Sergey Gritsay]

Interesting:

Mais fiável? Porque é que não é fiável obter pegas na inicialização? Porque é que não é fiável verificar os dados necessários? E mais ainda, porque é que não é fiável ter controlos?

Pode não ser tão simples para os novatos, mas tornar-se-á claro com o tempo...

A verificação dos dados não degrada a velocidade do programa como um todo, talvez apenas em 0,01%, eu não fiz esta verificação, e o facto de os dados deverem ser verificados antes da sua utilização é apenas para a estabilidade de todo o sistema, caso contrário podem haver consequências imprevisíveis, até à queda do terminal como um todo.