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

Nouveau commentaire
 
Nikolai Semko:

Oui, mais si :

alors c'est bon.

Il reste à voir si c'est OK pour tout nombre x
 

A100:

void OnStart()
{
        Print( (int)(3.0001 + 0.999999999999999)); //все равно 4
        Print( floor(3.00001));                    //3
}




Je ne comprends pas. Quel est le problème ?

 
A100:
Il reste à voir si cela sera OK pour tout nombre x

Bien sûr, ça ne sera pas le cas...

Après tout, si ça arrive :

double x=3;
x=x+0.1;
x=x+0.1;
x=x+0.1;
x=x+0.1;
if (x!=3.4) Print("oppps..."); // oppps...

alors, les questions ne sont ni pour moi ni pour cette idée.

 
Nikolai Semko:
Quel est le problème ?
void OnStart()
{
        double d =  16 + 0.999999999999999;
        Print( (int)(d + 0.999999999999999)); //18
        Print( (int)ceil( d ));               //17
}
 
A100:

voir mon message précédent

 
Nikolai Semko:
alors, les questions ne sont ni pour moi, ni pour cette idée.
floor(), ceil(), round() sont là pour éviter les questions.
 

Je pense que tous ces défauts ci-dessus dépassent le cadre de l'utilisation pratique de cette solution pour accélérer l'arrondi des entiers positifs, car peu de gens ont besoin d'une précision à 16 chiffres. Et ces bogues proviennent de toutes sortes de débordements aux niveaux des points du compilateur lui-même.

 
A100:
Floor(), ceil(), round() sont là pour ça - donc il n'y a pas de questions.

Je ne t'interdis pas de les utiliser. Vous êtes les bienvenus pour les utiliser. Je les utiliserai moi-même. Mais si je crée un algorithme où la vitesse est importante, j'utiliserai cette variante d'arrondi en tenant compte de toutes les nuances de cette méthode. Je pense qu'il serait utile pour les autres programmeurs de connaître l'existence de cette alternative. La discussion est exactement ce que nous devons savoir sur les nuances de cette méthode d'arrondi. Merci beaucoup à tous pour cela. N'ai-je pas raison ?

 
Nikolai Semko:

DBL_MIN etDBL_EPSILON ne fonctionnent pas - trop petits. Il est peut-être judicieux de laisser 0,999999999999999999 (16 neuf - le nombre maximum de chiffres après la virgule dans le double).

Ainsi, DBL_EPSILON a 16 décimales :2,2204460492503131e-016.

Dans votre cas, vous en obtenez effectivement un, car la différence n'est que de 1e-16, soit 2 fois moins qu'epsilon.

 
Alexey Navoykov:

Donc DBL_EPSILON a 16 décimales :2.2204460492503131e-016

Et dans votre cas, vous en obtenez effectivement un, puisque la différence n'est que de 1e-16, soit 2 fois moins qu'epsilon.


Oui, j'ai compris, mais ça ne marche pas. Il s'avère que cela ne fonctionne pas non plus avec 16 neuf (étrange, cela semblait fonctionner avant). Cela ne fonctionne qu'avec 15 neuf.

double x=3;
int Y=(int)ceil(x);
Print(Y);                         // 3
Y=(int)(x+0.999999999999999); 
Print(Y);                         // 3  (15 9-ток)
Y=(int)(x+0.9999999999999999);
Print(Y);                         // 4  (16 9-ток)
Y=(int)(x+1-DBL_EPSILON);
Print(Y);                         // 4
12345678
Nouveau commentaire