¿Puede el precio != el precio ? - página 4

Nuevo comentario
 
rfb:
Igual que "intCheck", pero asignando el valor antes de la función, como otras vars.

¿Entonces esto funcionará?

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

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

¿Así que esto funcionará?

Por supuesto que NO, es sólo para los cálculos simples para parices de mercado o similares con menos dígitos. Nada funcionará si más de 10 dígitos contados en ambos lados del punto decimal juntos, límites. Solo es un juguete.
 
rfb:
Por supuesto que NO, es sólo para cálculos simples para parices de mercado o similares con menos dígitos. Nada funcionará si se cuentan más de 10 dígitos a ambos lados del punto decimal juntos, límites. Solo es un juguete.
Mi código funciona bien.
 
WHRoeder:

No hay que complicar demasiado las cosas

Que algo (o alguna idea) sea complicado o complejo es, creo, una cuestión de interpretación individual.

Una división flotante, una adición flotante, una conversión a int, una llamada a una función (copia, salto, retorno = 3,) * 2 todo por dos. (18) Y eso suponiendo que la división y la conversión estén a la par con las otras operaciones - no lo están.

Nunca quise sugerir que la solución que creé y utilizo es la más eficiente - me doy cuenta de que puede no serlo. Pero, lo importante es (1) que entiendo (y, en este momento, puedo tolerar) su sobrecarga y costo computacional adicional y (2) resuelve el problema (al menos para mí) de comparar dos precios que están en formato de punto flotante de doble precisión.

En última instancia, entiendo el problema inherente a la comparación para la igualdad de dos números reales que están en un formato de punto flotante de doble precisión, pero creo que usted y yo hemos abordado el problema de una manera ligeramente diferente en este contexto. Usted utiliza lo que yo podría llamar una "comparación épsilon" para determinar si dos dobles están lo suficientemente cerca como para ser entendido como ser igual - es decir, si la diferencia entre dos dobles está dentro de su desviación máxima (Punto / 2.), entonces los dos dobles son iguales. Por otro lado, elijo convertir los precios en ints para la comparación dividiendo por Point, redondear al número entero más cercano, guardar el resultado como un int, y luego comparar los dos ints. Utilicé una llamada a una función, en lugar de código inline, porque es más natural para mí - tiendo a agrupar el código en subrutinas/funciones - y porque es potencialmente reutilizable (tal vez desde esa pequeña parte de mí que piensa en términos de POO). Tomé mucho de lo que dijiste el 16 de febrero de 2012:

El valor doble del corredor podría ser en cualquier lugar de 1,23457500000000 a 1,234584999999999 y todavía ser considerado el mismo precio de 1,23458.

Por eso decidí redondear al número entero más cercano en lugar de truncar la parte decimal después de dividir por Punto pero antes de convertir el doble en un int.

Todo esto no quiere decir que esté en desacuerdo con lo que has posteado, sino que es un reconocimiento de que he revisado lo que has posteado y lo guardaré para futuras referencias (y para un posible uso más adelante, si es necesario) :)

Como siempre, los comentarios instructivos/constructivos son bienvenidos. :)

 
Thirteen:

Si algo (o alguna idea) es complicado o complejo es, creo, una cuestión de interpretación individual.

Nunca quise sugerir que la solución que creé y uso es la más eficiente - me doy cuenta de que puede no serlo. Pero, lo importante es (1) que entiendo (y, en este momento, puedo tolerar) su sobrecarga y costo computacional adicional y (2) que resuelve el problema (al menos para mí) de comparar dos precios que están en formato de punto flotante de doble precisión.


Estoy de acuerdo con usted . . y también estoy de acuerdo conWHRoeder

Mi código fue escrito con una necesidad de algo para conectar con el código existente sin romperlo o tener que pasar muchas horas de búsqueda de errores, por lo que logró su objetivo. También me gustaría tener en cuenta lo queWHRoeder ha publicado, al menos en parte, y llegar a una mejor versión de lo que estoy haciendo, mientras que sigue siendo legible para mi uso. Si me las arreglo algo de esto voy a publicar en este hilo.

 
RaptorUK:

Si consigo algo de esto lo publicaré en este hilo.

Mi función Flat() era 17 veces más lenta quela soluciónde WHRoeder, tengo una propuesta que creo que es más legible y sólo 3 o 4 veces más lenta, dependiendo del tipo de comparación. 3 o 4 veces más lenta no es una gran cosa para lograr, pero en comparación con 17 veces más lenta es una gran mejora. Lo he probado un poco, no extensivamente todavía.

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

Los tipos de comparación son , EQ para igual, NEQ para no igual, GT para mayor que y 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);
      }
   }
 
Simplemente sus bools
case GT: if ( FirstPrice - SecondPrice > HalfAPoint)
                  return(true);
               else return(false); 
case GT: 
   return(FirstPrice - SecondPrice > HalfAPoint);
 
WHRoeder:
Simplemente sus bools

Buen punto.

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

El rendimiento no ha cambiado significativamente.

  
  case EQ:  return(!MathAbs(FirstPrice - SecondPrice) > HalfAPoint); // Initially missed the !
  case NEQ: return( MathAbs(FirstPrice - SecondPrice) > HalfAPoint);
Reglas de precedencia No (!) es casi la más alta: cuando primero != segundo exactamente, (!ABS(no cero) > nz) == (0 > nz) == falso . Si f==s entonces (!0 > nz) == (1 > p/2) == verdadero si punto < 1
 
WHRoeder:
Reglas de precedencia No (!) es casi la más alta: cuando primero != segundo exactamente, (!ABS(no cero) > nz) == (0 > nz) == falso . Si f==s entonces (!0 > nz) == (1 > p/2) == true si punto < 1

Sí, buena 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
Nuevo comentario