Problème d'arrondis de float

Version imprimable

Bonjour,

En fait j'ai des valeurs issues de calculs flottants qui sont très proches mais tout de même différentes (car provenant du CPU d'une part et du GPU d'autre part).
Ce que je souhaiterais, c'est trouver une manière d'arrondir au même entier des deux côtés et cela quelque soit le cas de figure, c'est à dire :
Code:

1 2 3 4 5 6 7 8 9 10 11 1er cas: CPU : 40.0000000001 GPU : 39.9999999999 Même entier : 40 Solution 1 : utiliser rintf() 2eme cas: CPU : 171.4999999 GPU : 171.5000000 Même entier : 172 Solution 2 : faire + 0.5 puis rintf()
J'ai ensuite appliqué la solution 1 ou 2 en fonction de la partie décimal
Code:

1 2 3 4 5 if(part_decim > 0.0 && part-decim <= 0.5) Solution 2 else Solution 1
Malgré cela je n'arrive pas à m'en sortir, je tombe toujours dans un cas de figure on l'on arrondi pas au même entier des deux.

Si quelqu'un connaît une méthode simple, ou peux corriger celle-ci.
Merci de votre aide , en espérant avoir était claire.

Yop,

as tu regardé floor et ceil ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/* ceil example */
#include <stdio.h>
#include <math.h>
 
int main ()
{
  printf ("ceil of 2.3 is %.1lf\n", ceil (2.3) );
  printf ("ceil of 3.8 is %.1lf\n", ceil (3.8) );
  printf ("ceil of -2.3 is %.1lf\n", ceil (-2.3) );
  printf ("ceil of -3.8 is %.1lf\n", ceil (-3.8) );
  printf ("floor of 2.3 is %.1lf\n", floor (2.3) );
  printf ("floor of 3.8 is %.1lf\n", floor (3.8) );
  printf ("floor of -2.3 is %.1lf\n", floor (-2.3) );
  printf ("floor of -3.8 is %.1lf\n", floor (-3.8) );
 
  return 0;
}

cdlt,

Fiki

Oui je connais floor() et ceil() mais le problème est que ça ne résout pas tous les cas de figure.

Exemple :
Code:

1 2 3 CPU : 30.999 ---> ceil() ---> 31 GPU : 31.001 ---> floor() ---> 31
Mais si le coup suivant on a :
Code:

1 2 3 CPU : 32.5000 ---> ceil() ---> 33 GPU : 32.4999 ---> floor() ---> 32

29/09/2011, 16h59
6-MarViN

Principe des arrondis en maths, >= 0.5 arrondi à la valeur du dessus, < 0.5 arrondi à la valeur du dessous.

après ce que tu pourrait peut-être faire (je ne garanti pas que ce soit une solution valable), c'est faire la moyenne des nombres que u veux arrondir et arrondir cette moyenne pour ensuite l'assigner à chaque nombres
29/09/2011, 18h01
diogene

Citation:

Ce que je souhaiterais, c'est trouver une manière d'arrondir au même entier des deux côtés et cela quelque soit le cas de figure, c'est à dire :....

Le premier cas est non ambigu : tu veux arrondir à l'entier le plus proche pour les deux calculs.
Le deuxième cas n'est pas clair : pourquoi décider d'avoir 172 ? L'entier le plus proche de CPU est 171. La seule raison d'utiliser 172 est liée à la valeur obtenue par le GPU (et d'ailleurs, on pourrait décider pour celui-ci d'avoir 171 comme pour le CPU).
Autrement dit, ton critère doit tenir compte simultanément des deux valeurs obtenues. Il n'y a pas, à mon avis, de solutions qui s'appliqueraient indépendamment à chaque résultat pour donner le même entier à tout coups.
30/09/2011, 10h43
LinuxUser

Je vais poser le problème autrement :

Soient C et G deux vecteurs de variables (float) tels que:

Code:

pour tout i de 0 à 1000000 et epsilon=10^-3, abs(Ci - Gi) < espilon

Comment arrondir (de manière indépendante, sans pouvoir les comparer directement) C et G et obtenir le vecteur I d'entier sachant que dans certains cas Ci > Gi et d'autres cas Gi > Ci (à 10^-3 près).

D'où l'exemple 2 où l'on arrondi au même entier pour que les résultats coïncident car dans cette exemple 171.5000 et 171.4999 sont différents (à cause de l'évaluation flottantes différentes sur CPU et GPU) mais c'est la même valeur, d'où l'arrondi "contre nature" de 171.4999 à 172 au lieu de 171.
30/09/2011, 13h09
diogene

Citation:

Comment arrondir (de manière indépendante, sans pouvoir les comparer directement) C et G

je me répète, ce n'est pas possible puisque dans ton exemple 2 l'arrondi de 171.4999 à 172 n'est fait que parce que l'arrondi de 171.5000 est fait à 172. Il y a donc, dans ce choix, interaction des deux valeurs et la décision ne peut être prise sans considérer simultanément les deux valeurs lorsqu'une des valeurs (et donc l'autre) est très proche de n,5 .

Citation:

d'où l'arrondi "contre nature" de 171.4999 à 172 au lieu de 171.

y a t-il une des deux valeurs qui emporte la décision en cas d'ambiguité ? Si c'est la première (171.4999) on doit avoir 171 et si c'est la seconde (171.5000) 172.
30/09/2011, 16h36
LinuxUser

Oui la valeur GPU, ici 171.5.
02/10/2011, 14h46
loupium

Tu pourrais par exemple pratiquer des arrondis successifs.
Par exemple avec 2 passes :
2eme cas:
CPU : 171.4999999
GPU : 171.5000000

Premier arrondi au dixième (première passe) :
2eme cas:
CPU : 171.5
GPU : 171.5

Deuxième arrondi aux unités (deuxième passe) :
2eme cas:
CPU : 172
GPU : 172

L'inconvénient est qu'il faut autant de passe que la précision souhaité.
02/10/2011, 16h46
diogene

Ne marche pas : avec
CPU : 171.4999999
GPU : 171.4999999
on obtient encore
CPU : 172
GPU : 172
au lieu de
CPU : 171
GPU : 171
02/10/2011, 17h15
loupium

Mais au moins les deux résultats sont identiques.
Tout dépend si l'erreur de 0,0000001 est supportable.
De toute façon en utilisant des float, il y aura forcément introduction d'erreur.