Vitesse d'exécution des fonctions ceil(),round(),floor() - page 2

Nouveau commentaire
 
pavlick_:

Pourquoi ne pas faire un lancer vers le long ? Bien que vous puissiez le déborder aussi, mais c'est beaucoup plus facile de déborder Int.


Bien sûr, vous pouvez faire un long lancer si vous en avez besoin.

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

x=3 ;

y=3 ; y=4 ;

 
Nikolai Semko:

Bien sûr, vous pouvez être long si vous en avez besoin.

Donc tu fais de la publicité pour un moyen, il sera copié bêtement. Généralement, vous ne pouvez pas faire ce genre de casting sans aucun contrôle, c'est UB :

Lorsqu'une valeur finie de type réel flottant est convertie en un type d'entier autre que _Bool, la partie fractionnaire est éliminée (c'est-à-dire que la valeur est tronquée vers zéro). Si la valeur de la partie intégrante ne peut pas être représentée par le type entier, le comportement est indéfini.
Peut-être qu'il va vendre le dépôt ou faire autre chose ;))
 
pavlick_ :

Donc vous faites de la publicité d'une manière, ce sera carrément copié. Tu ne peux pas lancer comme ça sans vérifier, c'est de l'UB :

Peut-être que le dépôt sera épuisé, et peut-être faire autre chose ;))).

Je ne fais pas de publicité pour quoi que ce soit. Je partage une idée. C'est à cela que sert ce forum et cette discussion.

 
Dmitry Fedoseev:

x=3 ;

y=3 ; y=4 ;


Bien ! Merci. Je vais devoir voir ce que je peux faire pour le plafond.

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

Dmitry Fedoseev:

x=3 ;

y=3 ; y=4 ;

comme option, bien que ce ne soit pas très joli, mais la vitesse est la même :

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

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

en option, bien que ce ne soit pas très joli, mais la vitesse est la même :

Dans ce cas, il serait probablement préférable d'utiliser la formule suivante : x + 1 - DBL_MIN. Ou x + 1 -DBL_EPSILON. Je ne l'ai pas vérifié, essayez-le.

Oh, et qu'en est-il des nombres négatifs ? Il devrait être différent pour le plafond et le plancher

 
Alexey Navoykov:

Dans ce cas, il serait probablement préférable d'utiliser la formule suivante : x + 1 - DBL_MIN. Ou x + 1 -DBL_EPSILON. Je ne l'ai pas vérifié, essayez-le.

Oh, et qu'en est-il des nombres négatifs ? Il doit être différent pour le plafond et le sol

DBL_MIN etDBL_EPSILON ne fonctionnent pas - ils sont trop petits. Il est peut-être judicieux de le laisser à 0,99999999999999999999 (16 neuf - le nombre maximal de décimales en double).

Oui, vous avez raison - il doit y avoir un algorithme différent pour les nombres négatifs. Merci ! Je vais faire un ajout dans le premier message.

Ceux qui sont intéressés peuvent réfléchir à la manière de résoudre le problème des nombres négatifs. Personnellement, je ne suis pas intéressé, car tous mes problèmes sont liés à des nombres positifs.

 
Nikolai Semko:

Il est probablement judicieux de laisser 0,9999999999999999999999 (16 neuf - le nombre maximal de décimales en double).

void OnStart()
{
        Print((int)(3.0 + 0.9999999999999999));
}
Avez-vous vérifié le résultat ?
 

A100:

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


Oui, mais si :

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

alors c'est bon. Les miracles du compilateur. :))

12345678
Nouveau commentaire
Raison: