bonjour,
voila je fais une boucle ou j'incremente des float (0.00001), et je voudrais stopper ma boucle a chaque fois que je tombe sur une valeur exacte
ex : 1.0000
comment je peux faire ?
Merci
bonjour,
voila je fais une boucle ou j'incremente des float (0.00001), et je voudrais stopper ma boucle a chaque fois que je tombe sur une valeur exacte
ex : 1.0000
comment je peux faire ?
Merci
Pour commencer, as-tu lu la FAQ sur la comparaison de float ?
SVP, pas de questions techniques par MP. Surtout si je ne vous ai jamais parlé avant.
"Aw, come on, who would be so stupid as to insert a cast to make an error go away without actually fixing the error?"
Apparently everyone. -- Raymond Chen.
Traduction obligatoire: "Oh, voyons, qui serait assez stupide pour mettre un cast pour faire disparaitre un message d'erreur sans vraiment corriger l'erreur?" - Apparemment, tout le monde. -- Raymond Chen.
'flottants' et 'valeurs exactes' sont des mots qui ne vont pas ensemble...Envoyé par toultemps
Chez moi :
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 #include <stdio.h> #include <float.h> int main (void) { double n = 1; printf ("%.10f\n", n + (0 * DBL_EPSILON)); printf ("%.10f\n", n + (1E0 * DBL_EPSILON)); printf ("%.10f\n", n + (1E1 * DBL_EPSILON)); printf ("%.10f\n", n + (1E2 * DBL_EPSILON)); printf ("%.10f\n", n + (1E3 * DBL_EPSILON)); printf ("%.10f\n", n + (1E4 * DBL_EPSILON)); printf ("%.10f\n", n + (1E5 * DBL_EPSILON)); printf ("%.10f\n", n + (1E6 * DBL_EPSILON)); printf ("%.10f\n", n + (1E7 * DBL_EPSILON)); printf ("%.10f\n", n + (1E8 * DBL_EPSILON)); printf ("%.10f\n", n + (1E9 * DBL_EPSILON)); return 0; }
On peut faire des comparaisons avec FLT_EPSILON (<float.h>. D'ailleurs je recommande double pour une meilleur précision (DBL_EPSILON)...
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14 1.0000000000 1.0000000000 1.0000000000 1.0000000000 1.0000000000 1.0000000000 1.0000000000 1.0000000002 1.0000000022 1.0000000222 1.0000002220 Press ENTER to continue.
Mais tout ça restera approximatif.
Utilise plutôt des entiers pour la boucle, que tu convertis en float quand tu en a besoin :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9 #define UNITE 10000 float f; for(int i = 0; i < MAX; ++i) { f = i / (float)UNITE; /* code */ if (0 == i % UNITE) { /* ici f est un entier */ } }
Comme dit Emmanuel, il est toujours mieux de prendre des doubles pour les calculs en virgule flottante, ne serait-ce que par le fait que c'est le type naturel utilisé par C. Tout passage de paramètres float dans une fonction est automatiquement casté en double au passage, et re-casté en float à la sortie (ce qui d'ailleurs peut générer de graves problèmes).
D'autre part, pour la vérification d'une précision d'un nombre en virgule flottante, le mieux est de vérifier comme ceci :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4 if ( fabs(Valeur - Valeur_Reference) <= DBL_EPSILON ) { }![]()
Si le paramètre/retour est de type double... ou que c'est une fonction variadic. Sinon, les paramètres explicites de type float existent. Il y a des fonctions 'f' déclarées dans <math.h> de C99.Envoyé par souviron34
expf(), sqrtf() sinf() etc. On peu supposer que dans ce cas, les calculs sont fait en float...
Oui bien sûr...Envoyé par Emmanuel Delahaye
Mais remarque je ne sais pas comment ça fonctionne en interne...
Je sais par contre que, en dehors des fonctions de maths, pour des fonctions faites par toi, et dont les paramères sont float, (mais même ça a peut-être changé avec C99, je ne sais pas), mais le cast est fait automatiquement. Et passer des floats amène à très brève échance à des catastophes (du style variable de sortie n'ayant plus rien à voir avec la vraie valeur..)
En gros (en tous cas pré-99), utiliser des floats est quasi suicidaire sur un programme assez gros..
C'est peut-être la fonction floor() que tu cherches? C'est la fonction Partie Entière. Exemple floor(9.81) retourne 9.000000. x est donc un "entier" si fabs( x - floor(x) ) < DBL_EPSILON. Les fonctions floor() et fabs() sont déclarées dans math.hEnvoyé par toultemps
Envoyé par Melem
encore une fois tout faux......
Comme son nom l'indique, ceil (plafond en français) donne le nombre entier SUPERIEUR....
ceil(9.81) donne 10.0
alors que floor (plancher en français) donne le nombre entier INFERIEUR
floor(9.81) donne 9.0
Illustration :Envoyé par souviron34
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> int main (void) { double n = 1; while (n < 2.2) { printf ("%.2f %.2f %.2f \n", floor (n), n, ceil (n)); n += .1; } 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 1.00 1.00 1.00 1.00 1.10 2.00 1.00 1.20 2.00 1.00 1.30 2.00 1.00 1.40 2.00 1.00 1.50 2.00 1.00 1.60 2.00 1.00 1.70 2.00 1.00 1.80 2.00 1.00 1.90 2.00 2.00 2.00 3.00 2.00 2.10 3.00 Press ENTER to continue.
Cette ligne est due aux imprécisions ?2.00 2.00 3.00
SVP, pas de questions techniques par MP. Surtout si je ne vous ai jamais parlé avant.
"Aw, come on, who would be so stupid as to insert a cast to make an error go away without actually fixing the error?"
Apparently everyone. -- Raymond Chen.
Traduction obligatoire: "Oh, voyons, qui serait assez stupide pour mettre un cast pour faire disparaitre un message d'erreur sans vraiment corriger l'erreur?" - Apparemment, tout le monde. -- Raymond Chen.
Oui :Envoyé par Médinoc
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 1.00 1.0000000000000000 1.00 1.00 1.1000000000000001 2.00 1.00 1.2000000000000002 2.00 1.00 1.3000000000000003 2.00 1.00 1.4000000000000004 2.00 1.00 1.5000000000000004 2.00 1.00 1.6000000000000005 2.00 1.00 1.7000000000000006 2.00 1.00 1.8000000000000007 2.00 1.00 1.9000000000000008 2.00 2.00 2.0000000000000009 3.00 2.00 2.1000000000000010 3.00 Press ENTER to continue.
Désolé pour le post erroné de tout à l'heure. La fonction partie entière c'est floor() bien sur, c'était juste une grosse faute d'innattention c'est tout![]()
Partager