Pergunta para os mestres da MQL4. Novamente sobre Double Compare.

Novo comentário
 
Olá!
Como você sabe, não apenas a exatidão dos cálculos, mas também a confiabilidade do código escrito depende do estilo de programação e da limpeza do código.
Nós não escrevemos brinquedos, portanto, a confiabilidade do programa escrito é o primeiro requisito. A maioria dos cálculos é feita em rublos e uma comparação correta no código de
de dois números reais no código do programa requer uma certa abordagem e precisão.
Estou tentando descobrir o estilo de programação "certo", daí a pergunta:

Para uma expressão

duplo a;
duplo b;

if(a==b) ou if(a!=b)
{......} {......}

Os desenvolvedores recomendam isto
//+------------------------------------------------------------------+
//| Função de comparação de dois números reais. |
//+------------------------------------------------------------------+
bool CompareDuplo(duplo Número1, duplo Número2)
{
bool Compare = NormalizeDuplo(Number1 - Number2, 8) == 0;
retornar(Comparar);
}
//+------------------------------------------------------------------+


Este código está correto?

duplo a;
duplo b;

if(a>b) if(a<b)
{......} {......}


Muito provavelmente não no caso geral. Qual é a maneira correta de verificá-lo?
Em geral, que estilo de trabalho com rublos é mais apropriado?
Agradecemos antecipadamente a todos que responderem.
 

Prefiro usar os dígitos maiores e menores para comparação sempre que possível,

double a;
double b;
 
if(a>b)             if(a<b)
    {......}            {......}

para que eu não tenha que me preocupar muito em correr o dobro para um determinado dígito

Vol = 156.00000002; 
NormVol = NormalizeDouble(Vol,2); 
156.00

Se for necessário juntar os números 

if(a==b)    или         if(a!=b)
    {......}                    {......}

então primeiro converto ambos os números em um único dígito após o ponto

  a = NormalizeDouble(Vol1,2);
  b = NormalizeDouble(Vol2,2);
if(a==b)    или         if(a!=b)
    {......}                    {......}
 
xeon:

Primeiro converto os dois números para o mesmo dígito após o ponto

  a = NormalizeDouble(Vol1,2);
  b = NormalizeDouble(Vol2,2);
if(a==b)    или         if(a!=b)
    {......}                    {......} 
E ao calcular em indicadores, você usa a Normalizar e preparações similares?
Estou olhando através de muito código, estou aprendendo a programar e ele raramente é encontrado no código indicador. Essa é a questão - como fazer isso corretamente.
 
VBAG:
xeon:

Primeiro converto os dois números para o mesmo dígito após o ponto

  a = NormalizeDouble(Vol1,2);
  b = NormalizeDouble(Vol2,2);
if(a==b)    или         if(a!=b)
    {......}                    {......} 
Vocês utilizam preparações normalizadas e similares em seus cálculos de indicadores?
Estou olhando através de muito código, estou aprendendo a programar e ele raramente é encontrado no código indicador. Essa é a questão - como fazer isso corretamente.

Tento evitá-lo usando os sinaisNormalizeDouble ou "<" e ">", porque o indicador, roteiro ou Expert Advisor pode ter discrepâncias em dobro.
 
xeon ,
Obrigado por sua opinião.
 
Normalizar sempre e nunca haverá problema com dublagens! ;)
Em qualquer comparação, em qualquer tentativa e com uma precisão escolhida deliberadamente.

//--- NormalizeDouble
double nd( double value, int precision )
{
    return( NormalizeDouble( value, precision ) );
}
 
//--- MathAbs
double abs( double value )
{
    return( MathAbs( value ) );
}
 
//--- Если value1 равняется value2 до precision знака после запятой, возвращает true, иначе - false.
bool equal( double value1, double value2, int precision = 8 )
{
    return( nd( abs( nd( value1, precision ) - nd( value2, precision ) ), precision ) < nd( MathPow( 0.1, precision ), precision ) );
}

Preste atenção à função de igualdade - se alterada ligeiramente:
bool equal( double value1, double value2, int precision = 8 )
{
    return( nd( abs( value1 - value2 ), precision ) < nd( MathPow( 0.1, precision ), precision ) );
}
(remover a normalização de cada número antes da comparação), ele dará um resultado diferente.

Por exemplo, igual( 0,123456784, 0,123456776 ) retornará verdadeiro no primeiro caso, mas falso no segundo ;)
 
komposter:
Normalizar sempre e nunca haverá problema com dublagens! ;)
Mas haverá problemas de desempenho. O problema de comparar números com dupla precisão é rebuscado e vem do desconhecimento básico da matemática.
 
Irtron:
O problema de comparar números com dupla precisão é rebuscado e vem do desconhecimento básico da matemática.

Deixe-me explicar.

Obviamente, há uma confusão de noções. Há um tipo de número de ponto flutuante utilizado na arquitetura de informação para representar números de precisão fixa, que, em particular, incluem todos os valores do ambiente comercial, uma vez que o processador possui uma debulhadora especial para aritmética de ponto flutuante.

Na verdade, os números de precisão fixa diferem muito pouco dos números inteiros em termos de representação da máquina. A presença de uma casa decimal, neste caso, é condicional. Esta propriedade é amplamente utilizada em arquiteturas onde a aritmética de ponto flutuante não é suportada por hardware, como o ARM, que ganhou popularidade através de seu uso em PDAs e smartphones. A aritmética flutuante deve ser emulada com um código bastante pesado, que aquece o processador e assim desperdiça a bateria, sem mencionar a velocidade de execução do programa. Assim, sempre que não for possível fazer com inteiros, é utilizado um formato fixo. A precisão flutuante é utilizada nos casos mais extremos. Ou melhor, é claro, deveria ser.

Nada impede o uso de aritmética fixa (ou seja, inteira) para valores de mercado.

Isto não se aplica aos valores calculados dos indicadores. Uma comparação direta é bastante suficiente. Por que compará-las com qualquer precisão?
 
Graças à komposter e Irtron ! Já decidi que nada mais será escrito e sentei para inventar a mim mesmo e não vi seus postos.
Por favor, veja o que escrevi com minha própria mão astuta:
//+
+
bool EqualDouble(double dN1, double dN2,int Digit)
{
double d1 = NormalizeDouble(dN1,Digit);
double d2 = NormalizeDouble(dN2,Digit);
bool res=false; res=d1-d2 == 0.0;
return(res);
}
//+
+
bool LessDouble(double dN1, double dN2,int Digit) // If dN1<dN2
{
double d1 = NormalizeDouble(dN1,Digit);
double d2 = NormalizeDouble(dN2,Digit);
bool res=false;
res=d2-d1 > 0.0;
return(res); }
//+
+
bool MoreDouble(double dN1, double dN2,int Digit) // If dN1>dN2
{
double d1 = NormalizeDouble(dN2,Digit);
double d2 = NormalizeDouble(dN2,Digit);
bool res=false;
res=d1-d2 > 0.0;
return(res); }
//+------------------------------------------------------------------+
Покритикуйте, пожалуйста.
 
VBAG:
Por favor, veja o que eu rabisquei com minha mão descuidada:
Que valores você está tentando comparar? Preços, lotes ou valores indicadores?
 
Irtron:
VBAG:
Por favor, dê uma olhada no que eu rabisquei com minha mão descuidada:
Que valores você está tentando comparar? Preços, lotes ou valores indicadores?
Eu escrevi no início: "Tentando obter o estilo de programação 'certo'. "
Em essência, não faz diferença o que está nos rublos - apenas a precisão do arredondamento do dígito variará, dependendo das exigências da variável.
1234567891011
Novo comentário