Velocidad de ejecución de las funciones ceil(),round(),floor() - página 2

Nuevo comentario
 
pavlick_:

¿Por qué no lanzas a lo largo? Aunque también se puede desbordar, pero es mucho más fácil desbordar el Int.


Por supuesto, puedes hacer un lanzamiento largo si lo necesitas.

  
y=ceil(x);  -> y=(int)(x+1);

x=3;

y=3; y=4;

 
Nikolai Semko:

Por supuesto, puedes ir a largo plazo si lo necesitas.

Así que estás anunciando una forma, será copiada estúpidamente. Generalmente, no puedes lanzar así sin ningún chequeo, es UB:

Cuando un valor finito de tipo real flotante se convierte a un tipo entero distinto de _Bool, la parte fraccionaria se descarta (es decir, el valor se trunca hacia cero). Si el valor de la parte integral no puede ser representado por el tipo entero, el comportamiento es indefinido.
Quizás venda el depósito o haga otra cosa ))
 
pavlick_ :

Así que estás anunciando una forma, será copiada sin rodeos. No se puede lanzar así sin comprobar, es UB:

Tal vez el depósito se agote, y tal vez haga algo más ))).

No estoy anunciando nada. Estoy compartiendo una idea. Para eso está este foro y la discusión.

 
Dmitry Fedoseev:

x=3;

y=3; y=4;


¡Cierto! Gracias. Tendré que ver qué puedo hacer con el techo.

  
y=ceil(x);  -> y=(int)(x+1);

Dmitry Fedoseev:

x=3;

y=3; y=4;

como opción, aunque no es muy bonita, pero la velocidad es la misma:

y=ceil(x);  -> y=(int)(x+0.999999999999999);
#define _ceil(x)  (int)((x)+0.999999999999999)

double x=3;
int y=_ceil(x);
 
Nikolai Semko:

como opción, aunque no es muy agradable, pero la velocidad es la misma:

Entonces probablemente sería mejor: x + 1 - DBL_MIN. O x + 1 -DBL_EPSILON. No lohe comprobado, pruébalo.

¿Y qué pasa con los números negativos? Debería ser diferente para el techo y el suelo

 
Alexey Navoykov:

Entonces probablemente sería mejor: x + 1 - DBL_MIN. O x + 1 -DBL_EPSILON. No lohe comprobado, pruébalo.

¿Y qué pasa con los números negativos? Debe ser diferente para el techo y el suelo

DBL_MIN yDBL_EPSILON no funcionan: son demasiado pequeños. Quizás tenga sentido dejarlo en 0,9999999999999999 (16 nueves - el número máximo de decimales en el doble)

Sí, tienes razón, debe haber un algoritmo diferente para los números negativos. Gracias. Haré un añadido en el primer post.

Quien esté interesado - puede pensar cómo resolver el problema con números negativos. A mí personalmente no me interesa, ya que todos mis problemas están relacionados con los números positivos.

 
Nikolai Semko:

Probablemente tenga sentido dejar 0,999999999999999999 (16 nueves - el número máximo de decimales en el doble)

void OnStart()
{
        Print((int)(3.0 + 0.9999999999999999));
}
¿Has comprobado el resultado?
 

A100:

void OnStart()
{
        Print( (int)(3 + 0.9999999999999999));
}


Sí, pero si:

x=3;
int Y=(int)ceil(x);
Print(Y);
Y=(int)(x+0.999999999999999);
Print(Y);

entonces está bien. Milagros del compilador. :))

12345678
Nuevo comentario