Connaitre le nombre après la virgule

Bonjour,je voudrais créer une classe(ou type) fixed_32_t(en C++)mais pour ça je besoin de connaitre le nombre de chiffre après la virgule du float.
Quelqu'un peut m'aider svp?

Kamoulox.
Ou bien 42 ?
La question ne veut rien dire.

j'ai peut-etre mal posé ma question,mais pour creer une classe virgule_fixe j'ai besoi de connaitre grace a un std::string le nombre de chiffre apres la virgule(si float vaut 5.xyz [le nombre de chiffre après virgule donc ici 3,pas la valeur])et le mettre dans un int ,donc je vous demande comment connaitre le nombre de chiffre après la virgule ?
vous pouvait m'aider svp?

float représente les entiers relatifs, noté R en mathématiques et ces chiffres ont une infinité de chiffres après la virgule.
Le format binaire ne permet pas ça mais ne permet pas non plus d'avoir une valeur précise pour l'immense majorité des valeurs possibles.
Si tu veux afficher X chiffres après la virgule tu utilises la syntaxe de formatage d'affichage de std::ostream ou printf.
Si tu veux stocker des valeurs à virgule fixe, je l'ai fait ici https://bousk.developpez.com/cours/s...n-avancee/#LII
Si tu veux juste prendre 3 chiffres après la virgule, il suffit de multiplier par 1000 :calim2:

J'ai regardé vite fait :mrgreen: mais je pense que c'est 1 truc impossible.
Tu peux le savoir avec les nombres appartenant à D, mais pas à R (et sûrement 1 partie de Z) - lien wiki sur les nombres décimaux en français
:mrgreen: c'est à dire tous les nombres ayant 1 nombre fini de chiffres après la virgule et pas infini comme pi ou 1/3.

Il faut prendre la mantisse/ la significande d'1 nombre flottant et chercher le dernier bit mis à 1 (le plus à droite) - le nombre de chiffres après la virgule est la différence entre le nombre de chiffres exposant et cet index.

Rappel :whistle:, d'après la norme IEEE 754, un nombre flottant est de la forme signe (1 ou -1) * base (2) ^ (exposant - biais) * 1,{mantisse/ significande}

bonjour a tous svp en voyant ce sujet jai essayer moi aussi d’aider mai je suis tomber face a un petit problème:aie::

jai réussi a créer un code qui donnait le nombre de chiffre après la virgule mais ne pouvait pas donner plus de 6 est ce un problème de surcharge:calim2:

Code:

---

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

int apres_virgule( double a) { //on creer dabord une chaine caractere elle conservera le nombre apres la virgule std::ostringstream chaine(""); //on cree un variable qui tranformeraa en entier de tel sorte que quon ai uniquement la partie entiere int b =a; //on cree une autre variable en faisant a-b il nous reste que le nombre decimal apresla virgule float c=a-b; // on cree un variable nombre qui retournera le nombre de chriffre apres la virgule a la fin dela fontion int nombre; //on transforme le nombre decimal stocke dans c en chaine chaine<<c; //on compte le nombre de lettre dans cette meme chaine nombre=(chaine.str().size())-2; //on retourne le nombre de lettre return nombre;     }

---

Bonjour,

Avant de rechercher les chiffres après la virgule, il faut comprendre ce que sont les types float et double.

Quand on dit nombre, on pense souvent aux nombres dits réels. Ça inclut par exemple 42, 1/8, 1.1875, 2/3, 0.1, pi, racineCarrée(2). Les float et double ne peuvent pas stocker certains de ces nombres, ils peuvent mémoriser la valeur exacte de 42, 1/8, 1.1875, mais seulement une valeur approchée de 2/3, 0.1, pi, racineCarrée(2).
Un sous-ensemble des réels est l'ensemble des rationnels. Il inclut 42, 1/8, 1.1875, 2/3, 0.1 mais pas pi, racineCarrée(2). Les deux derniers ne peuvent pas écrits sous forme de fraction.
Un sous ensemble des rationnels est l'ensembles des décimaux, il correspond au cas où le diviseur est une puissance de dix. Il inclut 42=42/1, 1/8=125/1000, 1.1875=11875/10000, 0.1=1/10. Il n'a pas 2/3, pi, racineCarrée(2). Et les float et double ne peuvent pas stocker tous les décimaux, il manque par exemple le 0.1. Oui, un nombre aussi simple que 0.1 ne peut être stocké que par une valeur proche comme 2/3 et pi!
Il existe un autre sous ensemble des rationnels, ce sont les fractions dyadiques. il correspond au cas où le diviseur est une puissance de 2. Les dyadiques de ma liste exemple sont 42=42/1, 1/8=1/8, 1.1875=19/16. Tiens cette fois la liste correspond exactement à ce que peuvent stocker les float et double.
Les float et double ne peuvent stocker exactement que les fractions dyadique (mais pas toutes!)

Revenons sur le nombre 0.1. Comment est-ce possible, un nombre aussi simple ne peut pas être stocké exactement? Pourtant si j'écris :

Code:

---

1 2 3 4

float x = 2./3.; // 2/3 est converti en float std::cout << x << std::endl; // ça affiche une approximation 0.666667 float y = 0.1; // 0.1 décimal est converti en float std::cout << y << std::endl; // ça affiche bien 0.1

---

Car les fonctions d'affichage et de conversion des float et double veulent les rendre lisibles pour les humains et donc les fournissent en base 10 et donnent une valeur arrondies (par défaut std::cout cherche les 6 premiers chiffres décimaux arrondis.)
On va demander d'afficher les même nombres en forçant une précision de 60 chiffres

Code:

---

1 2 3 4 5 6

float x = 2./3.; // 2/3 est converti en float std::cout << std::setprecision(60) << x << std::endl; // ça affiche 0.666666686534881591796875 float y = 0.1; // 0.1 décimal est converti en float std::cout << y << std::endl; // ça affiche 0.100000001490116119384765625 float u = 123456789; // 123456789 décimal est converti en float std::cout << u << std::endl; // ça affiche 123456792

---

Eh oui, le 0.1 est connu comme une approximation ayant 27 chiffres! Eh oui, 12345689 est devenu 123456792
Le point commun visible est que les 7 ou 8 premiers chiffres sont bons mais au delà ça semble être n'importe quoi.
Les nombres sont mémorisés en binaire. Par exemple le 0.1 est mémorisé comme la formule binaire :
0.000110011001100110011001101

Donc un nombre float ne peut stocker qu'une approximation qui a un peu plus de 6 chiffres significatifs.
Les double ont le même problème mais ont beaucoup plus de chiffres décimaux (53 au lieu de 23), donc un nombre double stocker une approximation qui a un peu plus de 15 chiffres significatifs.
On ne pourra donc jamais compter sur le 7^ième chiffre d'un float et sur le 16^ième chiffre d'un double.

On ne doit normalement pas utiliser le type float car on perd beaucoup en précision, on gagne un peu en taille mais très souvent il est en plus plus lent que le type double. Il faut donc une très bonne radine raison pour utiliser des float.

merci :mouarf: :D

Même si je ne comprend pas l'utilité de ce que vous voulez faire, la réponse me semble assez simple :
- vous créez une chaine avec :printf(tp, %f, votre variable)
- vous récupérez un pointeur sur le séparateur décimal (normalement une ',' n'en déplaise aux thuriféraires de l’américanisation .. je sais printf ...)
- vous avancez votre pointeur d'un caractère
- vous appelez strlen(lePointeur) et vous avez le nombre de décimales - qui ne vous sert à rien.

Ceci doit être adapté si votre système utilise UTF16.