Partie décimale d'un float

Bonjour à tous!
Voila, pour un de mes codes j'ai besoin de récupérer la partie décimale d'un float et sans utiliser floor() (pour faire une soustraction ensuite) parce que je n'ai pas droit à la librairie math.h.
J'utilise donc un cast. J'ai un truc du genre:

Code:

---

1 2 3 4 5

float f=2.76578;   f-=(int)f; printf("%d",f);

---

Seulement, pour certaines valeures, les résultats sont différents: par exemple 2.876, au lieu que j'obtienne 0,876, j'ai 0.875999...
Je voudrais savoir pourquoi j'ai ce genre de résultat et savoir s'il y a un autre moyen de récupérer la prtie décimale.

Slt,

Pour la raison de ton problème de précision :
http://en.wikipedia.org/wiki/Floatin...uracy_problems
http://fr.wikipedia.org/wiki/Virgule_flottante

Personnellement j'évite le plus souvent l'utilisation des nombres à virgule flottante, surtout sur les systèmes embarqués.
Je préfère les entiers et adapter l'unité de mes variables.

Sinon, si tu souhaites seulement faire un printf, il faut lui préciser le format de sortie.
Un petit "man printf" dans google te donne :
http://www.linux-kheops.com/doc/man/...sprintf.3.html

Dans ton cas c'est :
printf( "%'.2f", ta_variable_float );

@+

Citation:

---

Envoyé par dré kam

Seulement, pour certaines valeures, les résultats sont différents: par exemple 2.876, au lieu que j'obtienne 0,876, j'ai 0.875999...
Je voudrais savoir pourquoi j'ai ce genre de résultat et savoir s'il y a un autre moyen de récupérer la prtie décimale.

---

C'est dû au fait que 2,876 n'est pas un nombre fini en binaire.

— What every computer scientist should know about floating point arithmetic ;
— http://www.developpez.net/forums/d10...obleme-malloc/

Dans le cas de 2,876, le nombre est arrondi par défaut ou par excès en atteignant la fin de la mantisse, et est arrondi par défaut à six chiffres après la virgule lorsque tu l'affiches en décimal.

Ici, quand tu soustrais la partie entière, tu gagnes exactement deux bits, et tu te retrouves avec deux bits à zéro insérés au bout de la mantisse. Dans le calcul, ça suffit à faire arrondir le nombre par défaut plutôt que par excès.

Le moyen le plus simple si tu ne veux pas utiliser de fonctions dédiés, dans ce cas, consiste à faire passer les décimales dans la partie entière, dans à multiplier par 1000 si tu veux garder trois décimales. Tu convertis le tout en entier, tu soustrais l'ex-partie entière elle-aussi multipliée par 1000, tu reconvertis en flottant et tu redivises par 1000.

Je ne veux pas juste les afficher mais connaitre la partie décimale. Autrement dit, je voudrais avoir par exemple 0.65 pour 2.65 et non 2.649999.

Citation:

---

Envoyé par Obsidian

C'est dû au fait que 2,876 n'est pas un nombre fini en binaire.

Le moyen le plus simple si tu ne veux pas utiliser de fonctions dédiés, dans ce cas, consiste à faire passer les décimales dans la partie entière, dans à multiplier par 1000 si tu veux garder trois décimales. Tu convertis le tout en entier, tu soustrais l'ex-partie entière elle-aussi multipliée par 1000, tu reconvertis en flottant et tu redivises par 1000.

---

Oui je comprends, ca marche. Mais je veux que ca marche avec n'importe quel float. Donc à combien de chiffres après la virgule s'arrète un float généralement? c'est-a-dire un %f avec printf.

Citation:

---

Envoyé par dré kam

Donc à combien de chiffres après la virgule s'arrète un float généralement? c'est-a-dire un %f avec printf.

---

C'est écrit dans mon précédent commentaire. ;)

La solution du coefficient multiplicateur fonctionne avec n'importe quel float. Tu dois juste définir dès le départ la précision que tu souhaites garder.

Sinon, une autre méthode consiste à garder ta variable décomposée en numérateur et dénominateur.
Du coup, les opérations mathématiques sur des entiers peuvent être réalisées sans aucune approximation et c'est seulement au moment de l'affichage que tu divises le numérateur par le dénominateur.

Une multiplication par un nombre devient la multiplication du numérateur par ce nombre.
Une division par un nombre devient la multiplication du dénominateur par ce nombre.
Une addition par un nombre devient l'addition au numérateur du nombre multiplié par le dénominateur.
Une soustraction par un nombre devient la soustraction au numérateur du nombre multiplié par le dénominateur.
Après chaque opération est fortement conseillé de réaliser une simplification des fractions.

Cette méthode permet la comparaison correct entre deux variables.

Cette complexité est le prix de la précision. Mais as-tu vraiment besoin d'une telle précision ?

En fait je veux juste pouvoir afficher un float, passé en paramètre, à l'écran un peu comme printf.
Ce matin j'ai encore essayé d'autres méthodes mais is se trouve que dés que je fais la moindre multiplication, la valeur est perdue (2.876*10=28.7599...).
Est ce qu'il est possible de travailler directement avec la mentisse et l'exposant?

Citation:

---

En fait je veux juste pouvoir afficher un float, passé en paramètre, à l'écran un peu comme printf.

---

C'est-à-dire ?

Citation:

---

Ce matin j'ai encore essayé d'autres méthodes mais is se trouve que dés que je fais la moindre multiplication, la valeur est perdue (2.876*10=28.7599...).

---

Détrompe-toi. La valeur est perdue dès le départ. C'est ce qui t'a été expliqué.
Il ne faut pas confondre la précision de l'affichage avec printf et la précision de l'encodage d'un nombre à virgule flottante.

Voilà ce que

Code:

---

1 2	float valeur = 2.876; printf("%20.30f\n" , valeur);

---

donne sur ma machine :

Citation:

---

2.875999927520752000000000000000

---

Et

Code:

---

1 2	double valeur = 2.876; printf("%20.30lf\n" , valeur);

---

donne :

Citation:

---

2.875999999999999900000000000000

---

C'est mieux, mais c'est pas encore ça.

Tout ceci est directement lié au problème de précision de l'encodage des nombres à virgule flottante. Le µprocesseur de Mr et Mme Toutlemonde utilise la norme IEEE754 pour l'encodage des nombres à virgule flottante, codés sur 32 et 64 bits : http://en.wikipedia.org/wiki/IEEE_754-1985
Même si tu travailles directement sur la mantisse, ça n'y changera rien puisque tu te heurtera au même problème. C'est propre à l'électronique.
De plus, quelle que soit la taille de la mantisse, elle ne sera jamais infinie, et par conséquent tu obtiendras souvent des problèmes de précision du même genre.

Alors comment je fais pour afficher 2,876 si on m'envoie cette valeur en paramètre sans utiliser printf (avec des write)?
A la limite je veux bien afficher 2.87600 (avec un nombre de chiffres après la virgule que je définis a l'avance et valable quelque soit la valeur reçue.)

Ben il faut arrondir, mais comme le nombre de départ est faussé, ça ne t'affichera pas quelque chose de précis par conséquent.
Comme je t'ai expliqué, la valeur passée (en float) ne sera pas 2.876 mais quelque chose comme 2.875999927520752.

Donc si tu veux par exemple afficher 6 chiffres après la virgule, tu peux utiliser printf comme ça :

Code:

---

printf("%.6f" , tavaleur);

---

Mais là, ce n'est que la précision de l'affichage. Ca ne règle pas le problème de précision du nombre en lui-même.

Citation:

---

Envoyé par jeroman

Donc si tu veux par exemple afficher 6 chiffres après la virgule, tu peux utiliser printf comme ça :

Code:

---

printf("%.6f" , tavaleur);

---

Mais là, ce n'est que la précision de l'affichage. Ca ne règle pas le problème de précision du nombre en lui-même.

---

Mais je ne dois pas utliser printf. Il me faut donc des write. Donc comment savoir quand arrondir dans le code? càd arrondir le 87599 en 876

Le mieux c'est que tu donnes l'intitulé exact de ton exo, car là on part un peu dans toutes les directions, sans savoir ce que tu dois réellement faire. Surtout depuis ton histoire de write (qui, à première vue, n'a pas gros rapport avec l'histoire (?)), j'avoue que... je ne pige plus rien à ton problème.

Citation:

---

Envoyé par jeroman

Le mieux c'est que tu donnes l'intitulé exact de ton exo, car là on part un peu dans toutes les directions, sans savoir ce que tu dois réellement faire. Surtout depuis ton histoire de write (qui, à première vue, n'a pas gros rapport avec l'histoire (?)), j'avoue que... je ne pige plus rien à ton problème.

---

C'est tout simple: je dois recoder printf.

Citation:

---

Envoyé par dré kam

C'est tout simple: je dois recoder printf.

---

Et tu ne pouvais pas commencer par là ?

Bon, comme on te le dit, c'est printf() qui fait la gestion de la précision des nombres à virgule flottante. Cette fonction ne s'appuie pas sur des fonctions d'affichage sous-jacentes qui feraient plus ou moins le même travail. Si tu dois réécrire printf(), tu dois apprendre comment on convertit des nombres binaires (à virgule) vers le décimal ou n'importe quelle autre base.

Lis cette discussion : http://www.developpez.net/forums/d10...e/#post6052599

L'idée générale est que tu vas afficher autant de décimales que tu le souhaites et, une fois cela fait, tu examines la décimale suivante. Tu fais ensuite un arrondi par défaut ou par excès selon que cette décimale soit comprise entre 0 et 4 ou entre 5 et 9.

Lorsque tu arrondis par excès, il faut incrémenter la dernière décimale, et la propager tant que cette décimale et les suivantes sont des 9.

Citation:

---

Envoyé par Obsidian

Et tu ne pouvais pas commencer par là ?
Lis cette discussion : http://www.developpez.net/forums/d10...e/#post6052599

L'idée générale est que tu vas afficher autant de décimales que tu le souhaites et, une fois cela fait, tu examines la décimale suivante. Tu fais ensuite un arrondi par défaut ou par excès selon que cette décimale soit comprise entre 0 et 4 ou entre 5 et 9.

Lorsque tu arrondis par excès, il faut incrémenter la dernière décimale, et la propager tant que cette décimale et les suivantes sont des 9.

---

J'ai pris le temps de lire mais je ne comprends pas grand chose. Cependant j'ai fait un cours d'architecture et quelques recherches sur le stockage des nombres à virgule flottante (mantisse, exposant). Comment utiliser tout ça alors?

Il faut apprendre à convertir un nombre vers la base de ton choix.

Si tu veux afficher un nombre entier en base 10, par exemple, tu procèdes chiffre par chiffre. Tu fais une boucle qui fait passer chaque chiffre « de l'autre côté de la virgule » en divisant le nombre par 10, et en examinant à chaque fois le reste de cette division. Tu obtiens tous les chiffres de la représentation du nombre en base dix, mais dans le sens inverse. À toi de les remettre dans l'ordre (en utilisant une pile, par exemple).

Lorsque que tu n'as que des chiffres après la virgule (donc « 0,xxxx »), tu procèdes de la même façon : tu multiplies par 10 pour faire, à chaque fois, passer un chiffre de l'autre côté de la virgule. Tu récupères à chaque tour la partie entière, et tu obtiens tous les chiffres, dans le bon ordre cette fois.

Donc, quand tu as un nombre à virgule flottante quelconque à traiter, tu commences par sa partie entière, et tu poursuis par sa partie rationnelle.

Citation:

---

Envoyé par Obsidian

Il faut apprendre à convertir un nombre vers la base de ton choix.

Si tu veux afficher un nombre entier en base 10, par exemple, tu procèdes chiffre par chiffre. Tu fais une boucle qui fait passer chaque chiffre « de l'autre côté de la virgule » en divisant le nombre par 10, et en examinant à chaque fois le reste de cette division. Tu obtiens tous les chiffres de la représentation du nombre en base dix, mais dans le sens inverse. À toi de les remettre dans l'ordre (en utilisant une pile, par exemple).

Lorsque que tu n'as que des chiffres après la virgule (donc « 0,xxxx »), tu procèdes de la même façon : tu multiplies par 10 pour faire, à chaque fois, passer un chiffre de l'autre côté de la virgule. Tu récupères à chaque tour la partie entière, et tu obtiens tous les chiffres, dans le bon ordre cette fois.

Donc, quand tu as un nombre à virgule flottante quelconque à traiter, tu commences par sa partie entière, et tu poursuis par sa partie rationnelle.

---

Je ne saisis pas très bien. Tu fais allusion à la mantisse? J'ai fait ce code mais je n'arrive pas à le terminer.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

void my_putfloat(float nbr) { int exp,e=0,manti; unsigned int n=nbr; char c;   c= n >>31; if(c==1) //Le signe au 1er bit printf("-"); exp=(((n)&(0x7FFFFFFF))>>23)-127; //L'exposant dans les 8 bits suivants while(exp!=1) { exp/=2; e++; } printf("exposant=%d\n",e); manti=(n)&(0x007FFFFF); //Je récupère la mantisse }

---

Comment afficher les valeurs maintenant?

Tu n'as pas besoin de manipuler directement les bits pour faire une conversion de base. C'est un problème purement algébrique. Je te donne un petit exemple, volontairement partiel, dont tu peux t'inspirer :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

#include <stdio.h>   int main (void) { int i = 43857;   do { putchar ('0'+(i % 10)); i /= 10; } while (i); puts ("");   return 0; }

---

Qu'obtiens-tu ?

Oui mais si les nombres sont en binaires (comme dans la mantisse) et qu'on veut les afficher en décimal?

Citation:

---

Envoyé par dré kam

Oui mais si les nombres sont en binaires (comme dans la mantisse) et qu'on veut les afficher en décimal?

---

As-tu essayé le code que je viens de te proposer ?

À ton avis, en quel format est codé le nombre i ?

J'obtiens 75834 soit le nombre à l'envers. Ce que je veux dire, c'est que depuis dans mon code je manipule directement les valeurs de la mantisse. Donc je n'aurais pas de chiffres supérieurs à 1 parce que je fais:

Code:

---

1 2	manti=(n)&(0x007FFFFF); //Je récupère la mantisse

---

Est ce que tu veux dire que c'est comme si ça s reconvertissait automatiquement?? Désolé je suis un peu perdu...

Citation:

---

Envoyé par Obsidian

Il faut apprendre à convertir un nombre vers la base de ton choix.

Si tu veux afficher un nombre entier en base 10, par exemple, tu procèdes chiffre par chiffre. Tu fais une boucle qui fait passer chaque chiffre « de l'autre côté de la virgule » en divisant le nombre par 10, et en examinant à chaque fois le reste de cette division. Tu obtiens tous les chiffres de la représentation du nombre en base dix, mais dans le sens inverse. À toi de les remettre dans l'ordre (en utilisant une pile, par exemple).

(...)

Donc, quand tu as un nombre à virgule flottante quelconque à traiter, tu commences par sa partie entière, et tu poursuis par sa partie rationnelle.

---

Tu peux donner un peu plus de détails ou un exemple stp? Je n'ai pas besoin de code, juste de la logique.
Parce que si comme tu le dis je n'ai pas besoin de travailler directement avec les bits, je n'aurais pas une valeur complètement différente si je récupère directement la mantisse, sans placer la virgule? Je pars du fait de la conversion du binaire en décimal. Avant et après la virgule, on a des règles différentes en convertissant manuellement.

Ce que je veux dire, c'est :

• Que « i » est une variable codée en binaire dans la mémoire de l'ordinateur, de la même façon que l'est ton float ;
• Qu'à aucun moment, je ne suis allé manipuler les bits directement ;
• Que j'ai quand même obtenu le résultat escompté à l'écran, sans utiliser printf (même s'il est écrit à l'envers).

Donc, étant donné que le problème est purement algébrique, comme dit plus haut, tu n'as aucun besoin d'aller extraire les champs de bit à la main comme tu le fais.

Le programme que je t'ai donné fait la moitié du travail. D'une manière générale, pour extraire des chiffres un par un, il faut les faire passer « de l'autre côté de la virgule », de manière à pouvoir le distinguer des autres. Si tes chiffres se trouvent à gauche de la virgule, tu divises par 10 (ou plus généralement, par la base de ton choix), pour en faire passer à droite et tu récupères sa valeur grâce au modulo 10.

Dans le même esprit, lorsqu'il ne tu n'as que des chiffres à droite de la virgule (donc « 0,xxxx » ), tu multiplies par 10 pour en faire passer à gauche, et tu récupère sa valeur en considérant la partie entière.

Ça signifie également que c'est par divisions ou multiplications successives que tu vas parvenir à tes fins. Donc, le contenu de ton float sera altéré à chaque itération et c'est normal.

Citation:

---

Envoyé par Obsidian

Ce que je veux dire, c'est :

Le programme que je t'ai donné fait la moitié du travail. D'une manière générale, pour extraire des chiffres un par un, il faut les faire passer « de l'autre côté de la virgule », de manière à pouvoir le distinguer des autres. Si tes chiffres se trouvent à gauche de la virgule, tu divises par 10 (ou plus généralement, par la base de ton choix), pour en faire passer à droite et tu récupères sa valeur grâce au modulo 10.

---

Donc j'ai un nombre en binaire interprété par la machine (disons 26539) qui n'a rien à voir avec la valeur de mon float. Qu'est ce que je dois faire passer de l'autre côté de la virgule??? SI j'ai un exposant égal à 3 par exemple, ça signifie que je dois faire 9%10 et ainsi de suite???

Citation:

---

Envoyé par dré kam

Donc j'ai un nombre en binaire interprété par la machine (disons 26539) qui n'a rien à voir avec la valeur de mon float. Qu'est ce que je dois faire passer de l'autre côté de la virgule???

---

Il faut absolument que tu y réfléchisses un peu par toi-même, parce que c'est le but de l'exercice. Le code qui va derrière, une fois compris le principe, n'a aucun intérêt en lui-même. Je t'ai expliqué deux fois ce qu'il fallait faire passer de l'autre côté de la virgule. Relis bien mes posts.

Pour te mettre sur la voie, voici un autre exemple. Imaginons que tu travailles sur papier et que tu n'aies pas du tout d'ordinateur (donc, on met de côté le langage C pour le moment). Tu n'as pas non plus de calculatrice. Juste du papier brouillon et un crayon en état de marche.

Tu me proposes le nombre 26539 en décimal (base 10). Quelle serait sa valeur en base 7 et comment t'y prendrais-tu pour la trouver ?

Citation:

---

SI j'ai un exposant égal à 3 par exemple, ça signifie que je dois faire 9%10 et ainsi de suite???

---

On s'en fiche, dans ce cas précis. C'est ta machine qui gère la valeur du nombre. Tu n'as pas besoin de manipuler directement ces exposants pour en faire la représentation en décimal, sauf si tu veux que cet exposant apparaisse à l'écran.

Il faut bien se souvenir que la base d'un nombre n'est qu'une manière de le représenter et que si tu changes cette base, tu ne changes pas la valeur du nombre lui-même. C'est un peu comme utiliser les chiffres romains : si j'écris « 6 » ou « VI », la valeur numérique reste rigoureusement identique.

Pour ce cas là je ferais comme d'habitude des divisions successives jusqu'à trouver zéro en examinant les restes. Mais dans mon cas, avec la mantisse, il s'agit d'un nombre réel, pas d'un entier, et sans la virgule en plus. Donc la valeur interprétée par la machine est différente de la valeur en base 10 réelle. C'est ta logique que je ne comprends pas, pas le code.
-Tu parles de conversion de bases, mais c'est de quelle base vers quelle base vu que la machine interprete le tout???
-Pourquoi fallait-il que je sache comment sont stockés les float en mémoire alors?
-Comment je peux savoir si c'est "a gauche" ou "à droite" de la virgule si je connais pas l'exposant? Dans mon code je trouve l'exposant cependant....

Tu veux afficher un nombre flottant F avec une précision de n chiffres après la virgule. Si ton exercice revient à simuler un printf(), on peut supposer que tu as déjà codé l'affichage d'un entier.
On peut partir sur le principe (à adapter pour tenir compte du cas des valeurs négatives) :

1- afficher la partie entière de F 
2- afficher le point décimal
3- prendre la partie fractionnaire de F et la multiplier n fois par 10
4- arrondir en ajoutant 0.5
5- afficher la partie entière du nombre obtenu

Exemple : F = 2.875999927520752

1- sortir 2
2- sortir .
3- Partie fractionnaire : 0.875999927520752
   pour n = 3 multiplier par 10^3 -> 875.999927520752
   pour n = 7 multiplier par 10^7 -> 8759999.27520752 
4- pour n = 3 -> 876.499927520752
   pour n = 7 -> 8759999.77520752
5- sortir pour n = 3 -> 876
   sortir pour n = 7 -> 8759999
Affichage
   pour n = 3 -> 2.876
   pour n = 7 -> 2.8759999

Citation:

---

Envoyé par diogene

Tu veux afficher un nombre flottant F avec une précision de n chiffres après la virgule. Si ton exercice revient à simuler un printf(), on peut supposer que tu as déjà codé l'affichage d'un entier.
On peut partir sur le principe (à adapter pour tenir compte du cas des valeurs négatives) :

1- afficher la partie entière de F 
2- afficher le point décimal
3- prendre la partie fractionnaire de F et la multiplier n fois par 10
4- arrondir en ajoutant 0.5
5- afficher la partie entière du nombre obtenu

Exemple : F = 2.875999927520752

1- sortir 2
2- sortir .
3- Partie fractionnaire : 0.875999927520752
   pour n = 3 multiplier par 10^3 -> 875.999927520752
   pour n = 7 multiplier par 10^7 -> 8759999.27520752 
4- pour n = 3 -> 876.499927520752
   pour n = 7 -> 8759999.77520752
5- sortir pour n = 3 -> 876
   sortir pour n = 7 -> 8759999
Affichage
   pour n = 3 -> 2.876
   pour n = 7 -> 2.8759999

---

Merci, merci énormement! C'est beaucoup plus clair ainsi. Je m'y mets ilico!

Cependant est-ce que ce serait possible, comme le printf original, d'afficher pour n=7 2.876000? C'est juste pour être aussi fidèle que possible.

Bien sûr. Ce sont des zéros non significatifs. Le plus « dur » est de les masquer. Une fois que tu as réussi à obtenir les trois premiers chiffres, rien ne t'empêche de combler le reste avec des zéros.

Oui mais je veux que ça marche aussi s'il y a 4 chiffres significatifs.
Par exemple pour 2.876, j'affiche 2,8760000 et pour 2.8765 2.8765000. Donc en gros, est-ce que c'est possible de trouver le nombre de chiffrs significatifs?
Je pensais pouvoir le faire en trouvant l'exposant mais ça complique tout et n'arrange pas grand chose.

Citation:

---

Envoyé par dré kam

Oui mais je veux que ça marche aussi s'il y a 4 chiffres significatifs.
Par exemple pour 2.876, j'affiche 2,8760000 et pour 2.8765 2.8765000. Donc en gros, est-ce que c'est possible de trouver le nombre de chiffrs significatifs?

---

Par de manière absolue pour les raisons que l'on a exposé au départ. Le nombre « 2.876 » ne pouvant être représenté de manière finie en binaire, la valeur approchée la plus proche qui va se trouver dans un double par exemple correspondra à « 2.875999999999999801048033987171947956085205078125 ». Donc rien ne te permet de savoir a priori s'il s'agit en fait de « 2.876 » ou si c'est ce nombre exact que tu as voulu coder.

Le seul moyen de s'en sortir est de fixer une précision arbitraire. Donc, par exemple, six chiffres après la virgule dans le cas qui nous intéresse.

Dans ce cas, tu vas obtenir « 2,785999 ». À ce stade, tu fais comme indiqué dans mes commentaires précédents : tu examines la décimale suivante et tu arrondis si nécessaire. Dans le cas présent, cette décimale suivante est encore un « 9 ».

Comme tu as multiplié par 10⁶ pour sortir tous les chiffres d'un coup, tu obtiens 2785999,9. Tu arrondis donc à 2786000 et tu ignores (ou pas) les zéros à l'affichage. Si tu avais obtenu « 2785999,1 » tu aurais arrondi par défaut et tu aurais gardé les « 9 ».

Merci pour tout!