O preço da lata != preço ? - página 4

Novo comentário
 
rfb:
O mesmo que "intCheck", mas com valor atribuído antes da função, como outras vars.

Então isto vai funcionar ?

intCheck = 1.1000000000001 /point;
intRecord = 1.0999999999999 /point;

if (intRecord > intCheck) Print("Prices are the same.");
 
RaptorUK:

Então isto vai funcionar ?

É claro que NÃO, é apenas para cálculos simples de parices de mercado ou similares com menos dígitos. Nada funcionará se mais de 10 dígitos contarem em ambos os lados do ponto decimal juntos, limites. Apenas um brinquedo.
 
rfb:
É claro que NÃO, é apenas para cálculos simples de parices de mercado ou similares com menos dígitos. Nada funcionará se mais de 10 dígitos contarem em ambos os lados do ponto decimal juntos, limites. Apenas um brinquedo.
Meu código funciona muito bem.
 
WHRoeder:

Não complique demais as coisas

Se algo (ou alguma idéia) é complicado ou complexo é, creio eu, uma questão de interpretação individual.

Uma divisão flutuante, adição flutuante, conversão para int, chamada de função (cópia, salto, retorno = 3,) * 2 todas as vezes dois. (18) E isso supondo que a divisão e a conversão estão em pé de igualdade com as outras operações - não estão.

Eu nunca quis sugerir que a solução que eu criei e uso é a mais eficiente. Mas, o importante é (1) eu entendo (e, neste momento, posso tolerar) seus custos adicionais e computacionais e (2) resolve o problema (pelo menos para mim) de comparar dois preços que estão no formato de ponto flutuante de precisão dupla.

Em última análise, eu entendo o problema inerente de comparar para igualdade dois números reais que estão em formato de ponto flutuante de precisão dupla, mas acho que você e eu abordamos o problema de uma maneira ligeiramente diferente neste contexto. Você usa o que eu poderia chamar de "comparação epsilon" para determinar se duas duplas estão suficientemente próximas para serem entendidas como sendo iguais - ou seja, se a diferença entre duas duplas está dentro de seu desvio máximo (Ponto / 2.), então as duas duplas são iguais. Por outro lado, eu opto por transformar os preços em pontos para comparação, dividindo por Ponto, arredondando para o número inteiro mais próximo, salvar o resultado como um int, e então comparar os dois ints. Usei uma chamada de função, em vez de código em linha, porque é mais natural para mim - eu tendo a agrupar código em sub-rotinas/funções - e porque é potencialmente reutilizável (talvez daquela pequena parte de mim que pensa em termos de OOP). Tirei muito do que você disse em 16 de fevereiro de 2012:

O dobro do valor do corretor poderia ser de 1,234575000000000000 a 1,23458499999999999 e ainda ser considerado o mesmo preço de 1,23458.

É por isso que decidi arredondar para o número inteiro mais próximo em vez de truncar a parte decimal após dividir por ponto, mas antes de converter o dobro para um int.

Tudo isso não quer dizer que eu discordo do que você postou, mas sim que reconheço que revisei o que você postou e o guardarei para referência futura (e para uso potencial mais tarde, se necessário) :)

Como sempre, comentários instrutivos/construtivos são bem-vindos. :)

 
Thirteen:

Se algo (ou alguma idéia) é complicado ou complexo é, creio eu, uma questão de interpretação individual.

Eu nunca quis sugerir que a solução que eu criei e uso é a mais eficiente. Mas, o importante é (1) eu entendo (e, neste momento, posso tolerar) seus custos adicionais e computacionais e (2) resolve o problema (pelo menos para mim) de comparar dois preços que estão em formato de ponto flutuante de precisão dupla.


Eu concordo com você . . e também concordo com aWHRoeder

Meu código foi escrito com a necessidade de algo para se conectar ao código existente sem quebrá-lo ou ter que passar muitas horas encontrando bugs, de modo que atingiu seu objetivo. Eu também gostaria de levar em conta o queWHRoeder postou pelo menos em parte e chegar a uma versão melhor do que estou fazendo, mantendo-o ainda legível para meu uso. Se eu conseguir alguma dessas coisas, eu postarei neste tópico.

 
RaptorUK:

Se eu conseguir alguma dessas coisas, eu as coloco neste tópico.

Minha função Flat() era 17 vezes mais lenta que a soluçãodo WHRoeder, tenho uma proposta que acho que é mais legível e apenas 3 ou 4 vezes mais lenta, dependendo do tipo de comparação. 3 ou 4 vezes mais lenta não é uma coisa boa de se conseguir, mas comparada a 17 vezes mais lenta é uma grande melhoria. Eu a testei um pouco, ainda não extensivamente.

Uso:

bool Compare(double FirstPrice, int ComparisonType, double SecondPrice)


for example:

if(Compare(Bid, LT, Ask)) Print("Bid is less than Ask");

if(Compare(Price, EQ, Price)) Print("Price does equal Price");

Os tipos de comparação são, EQ para igual, NEQ para não igual, GT para maior que e LT para menor que.

#define LT    0
#define GT    1
#define EQ    2
#define NEQ   4


bool Compare(double FirstPrice, int ComparisonType, double SecondPrice)
   {
   double HalfAPoint = Point / 2.0;
   

   switch(ComparisonType)
      {
      case LT: if ( SecondPrice - FirstPrice > HalfAPoint)
                  return(true);
               else return(false); 
      
      case GT: if ( FirstPrice - SecondPrice > HalfAPoint)
                  return(true);
               else return(false); 
      
      case EQ: if (MathAbs(FirstPrice - SecondPrice) > HalfAPoint)
                  return(false);
               else return(true); 
      
      case NEQ: if (MathAbs(FirstPrice - SecondPrice) > HalfAPoint)
                  return(true);
               else return(false);
      }
   }
 
Simplesmente suas bools
case GT: if ( FirstPrice - SecondPrice > HalfAPoint)
                  return(true);
               else return(false); 
case GT: 
   return(FirstPrice - SecondPrice > HalfAPoint);
 
WHRoeder:
Simplesmente suas bools

Bem visto.

bool Compare(double FirstPrice, int ComparisonType, double SecondPrice)
   {
   double HalfAPoint = Point / 2.0;
   

   switch(ComparisonType)
      {
      case LT: return( SecondPrice - FirstPrice > HalfAPoint);
      
      case GT: return( FirstPrice - SecondPrice > HalfAPoint);
      
      case EQ: return(!MathAbs(FirstPrice - SecondPrice) > HalfAPoint);
      
      case NEQ: return(MathAbs(FirstPrice - SecondPrice) > HalfAPoint);
      
      }
   }

O desempenho não mudou significativamente.

  
  case EQ:  return(!MathAbs(FirstPrice - SecondPrice) > HalfAPoint); // Initially missed the !
  case NEQ: return( MathAbs(FirstPrice - SecondPrice) > HalfAPoint);
As regras de precedência Não (!) é quase a mais alta: quando primeiro != segundo exatamente, (!ABS(non-zero) > nz) == (0 > nz) == falso. Se f===s então (!0 > nz) == (1 > p/2) == verdadeiro se ponto < 1
 
WHRoeder:
As regras de precedência Não (!) é quase a mais alta: quando primeiro != segundo exatamente, (!ABS(non-zero) > nz) == (0 > nz) == falso. Se f===s então (!0 > nz) == (1 > p/2) == verdadeiro se ponto < 1

Sim, boa captura . . .

bool Compare(double FirstPrice, int ComparisonType, double SecondPrice)
   {
   double HalfAPoint = Point / 2.0;
   

   switch(ComparisonType)
      {
      case LT: return( SecondPrice - FirstPrice > HalfAPoint );
      
      case GT: return( FirstPrice - SecondPrice > HalfAPoint );
      
      case EQ: return(!( MathAbs(FirstPrice - SecondPrice) > HalfAPoint ) );
      
      case NEQ: return( MathAbs(FirstPrice - SecondPrice) > HalfAPoint );
      
      }
   }
12345678
Novo comentário