Discussion :

[fregate]

Salut,


Je bosse sur un projet Unix, et j'utilise cygwin pour tester un peu chez moi. sauf que en gros j'ai une fonction qui fait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
float a=0;
...
 
while(1){
a=a+0.1;
printf("%f",a);
}

et printf m'affiche : 0 0.1 ... 1.5 1.6 1.69999 1.79999 ... 2.49998 ... bref, je comprend pas car il perd de la précision ! (ce qui est fou). Il y a une explication logique ?

[mathk]

oui car quand tu ecrit un floatant c'est avec un precicsion donner donc on per tjr de la precision.

Si tu veut vraiment comprendre ce qu'il se passe cherche sous google sous IEE 754

@+ et jouyeuses fêtes

[fregate]

alors, question bete, je fait comment pour ne pas perdre de précision ? je change de type ? je met quoi ?

[mathk]

oui change de type est divise par 10 a la fin...

met toi en int

[fregate]

agh.... Si c'etait si facile ! je m'en sert partout de cette variable ! j'ai 20Ko de code moi ! Enfin merci pour l'explication.

[mathk]

tu peut tjr prendre une variable temporaire qui prent a*10 et puis tu refait une convertion dans l'autre sens a la fin.

Ce sera tjr moin pire

[Emmanuel Delahaye]

alors, question bete, je fait comment pour ne pas perdre de précision ? je change de type ? je met quoi ?

Déjà tu commences par utiliser double au lieu de float.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
#include <stdio.h>
 
int main (void)
{
   int i;
   float a = 0;
 
   for (i = 0; i < 100; i++)
   {
      a = a + 0.1;
      printf ("%f\n", a);
   }
 
   return 0;
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
<...>
8.099995
8.199995
8.299995
8.399996
8.499996
8.599997
8.699997
8.799997
8.899998
8.999998
9.099998
9.199999
9.299999
9.400000
9.500000
9.600000
9.700001
9.800001
9.900002
10.000002

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
   double a = 0;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
<...>
8.100000
8.200000
8.300000
8.400000
8.500000
8.600000
8.700000
8.800000
8.900000
9.000000
9.100000
9.200000
9.300000
9.400000
9.500000
9.600000
9.700000
9.800000
9.900000
10.000000

Ensuite, il faut savoir que le codage des nombres à virgule flottante n'est qu'une approximation. C'est tout.

[mathk]

Double ou Float depend surtout de ce que tu fait car un double ca prend du temps a traiter.

[gege2061]

Double ou Float depend surtout de ce que tu fait car un double ca prend du temps a traiter.

Pas si sûr :

La vitesse de traitement d'un double n'est pas forcément plus longue qu'un float, cela dépend du compilateur (de ses options) et du processeur. Ainsi avec l'exemple suivant, en remplaçant le typedef par float ou double, on s'aperçoit que sur un Pentium ou un PowerPC, le double est plus rapide à calculer que le float tout en ayant une précision plus grande.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
    #include <stdio.h>
    #include <math.h>
 
    typedef float reel;     /* float ou double */
 
    int main(void) {
        long i ;
        reel d = 3.0 ;
 
        for (i = 0; i < 100000000; i++) {
            d = cos(d) ;
        }
 
        (void)printf("%f\n", d);
        return 0;
    }

Le C comprend des instructions mathématiques pour traiter les float directement au lieu de toujours passer par des double depuis la dernière norme (C99). Par exemple il existe cosf() en plus de cos(). En faisant des essais on s'aperçoit que dans notre exemple, le cosf() appliqué à un float devient aussi rapide que le cos() appliqué à un double.

En conclusion, nous pouvons dire qu'il est préférable d'utiliser des double à la place des float, sauf lorsque la place mémoire devient critique.

[mathk]

a oui c'est interessant mais sa depend de bcp de parametre je pense

(compilateur
processeur
ram
...)

alors soyont pragmatique

[Emmanuel Delahaye]

alors soyont pragmatique

... et utilisons les double au maximum.

Toutes les conversions implicites impliquant des flottants se font en double. De même, les paramètres des fonctions mathématiques sont en double (sauf nouveautés de C99).

Traiter des float implique non seulement une perte de précision mais en plus des conversions supplémentaires, donc du temps en plus. Le seul avantage des float est le gain de place. C'est utilisé pour stocker de grosses listes de valeurs.