Précision des nombres à virgule

Bonjour,

Je cherche à encoder et à manipuler des nombres de cette précision (30 chiffres environ après la virgule) :
A = 0,84965724432017509411832466764058
B = 0,34929922307744668373624877606906
C = 1,6013793132890827397668320682411

J'utilise le type long double, je réalise plusieurs multiplications et divisions sur des nombres d'une même précision. Au bout de quelques itérations, les résultats sont faussés à cause des valeurs tronquées à mon avis...

Le type long double a une précision de 15 chiffres je crois. Ma question est de savoir quel type utiliser pour gérer cette grande précision.

Bonjour,

La bibliothèque GMP, plus connue pour les calculs sur des entiers de longueur quelconque, comprend également une section pour les calculs sur les nombres flottants.

%Ais quoi qu'il en soit, ne te fait pas d'illusion, les arrondis, et donc les erreurs, sont inévitables, et finiront par te rattraper, même si on peut repousser la limite (mais c'est au prix du temps de calcul ...).

:)

Merci pour ta réponse. J'espère que l'utilisation de cette bibliothèque n'est pas très compliquée...

Par ailleurs, je récupère le nombre en question à partir d'un TEdit en utilisant la fonction StrToFloat. Je me pose aussi la question si cette fonction de conversion ne pose pas de problème de précision...

Code:

---

long double nombre = StrToFloat(EditNombre->Text);

---

Si surement, vu qu'il n'y a que certains chiffres qui sont exactement représentables, et ils sont en nombre finis et loin de représenter tout ton ensemble.
Si tu travailles sur des valeurs fixes de digits après la virgule, travaille en entier et fais une division finale. Ou mieux, garde tout en entier et représente-les juste à virgule à la fin si/quand nécessaire.

Tu as raison, je vais opter pour cette solution : travailler sur des entiers et afficher le résultat en nombre flottant à la fin. Je dois conserver au moins 21 chiffres après la virgule.

Juste une dernière question : vu qu'il y a une interface utilisateur, je dois récupérer le nombre flottant saisi par l'utilisateur sous la forme d'une chaîne de caractères (1,123456789123456789123, par exemple). Le fait de convertir la chaîne avec StrToFloat tronque-t-il la valeur exacte du nombre de départ ?

Citation:

---

Envoyé par Wachter

Juste une dernière question : vu qu'il y a une interface utilisateur, je dois récupérer le nombre flottant saisi par l'utilisateur sous la forme d'une chaîne de caractères (1,123456789123456789123, par exemple). Le fait de convertir la chaîne avec StrToFloat tronque-t-il la valeur exacte du nombre de départ ?

---

Si StrToFloat retourne un float sur moins de ~128bits oui. Et vu que les float128 ne sont pas standards, il est plus que probable que tu perde de la précision ici. (Et je suis même pas sur qu'un float128 puisse fournir cette précision).
Fait la conversion à la main. :)

Bonjour,

Oui, les float (4 octets) ne garantissent que 5 à 6 chiffres significatifs, les double 15 à 16.

Tu n'as donc pas le choix, il faut utiliser la bibliothèque en question, y compris ses fonctions de conversion !

Comme son nom ne l'indique pas, la fonction StrToFloat renvoie un Extended : l'équivalent de long double en C++ (3.4 x 10⁴⁹³² avec 17 chiffres significatifs). La précision des long double est finalement insuffisante dans mon projet de calcul.

Je testerai dans un premier la manipulation exclusive des entiers en optant pour le type long double ou simplement double (1.7 x 10³⁰⁸). Je me tournerai ensuite vers la bibliothèque GMP si j'ai des problèmes avec la division euclidienne…

Citation:

---

Envoyé par Wachter

Comme son nom ne l'indique pas, la fonction StrToFloat renvoie un Extended : l'équivalent de long double en C++ (3.4 x 10⁴⁹³² avec 17 chiffres significatifs). La précision des long double est finalement insuffisante dans mon projet de calcul.

Je testerai dans un premier la manipulation exclusive des entiers en optant pour le type long double ou simplement double (1.7 x 10³⁰⁸). Je me tournerai ensuite vers la bibliothèque GMP si j'ai des problèmes avec la division euclidienne…

---

Si tu utilises des doubles pour représenter tes entiers, tu auras le même problème de chiffres significatifs. L’idée est d’utiliser de vrais entiers.

Citation:

---

Envoyé par Wachter

Je testerai dans un premier la manipulation exclusive des entiers en optant pour le type long double ou simplement double (1.7 x 10³⁰⁸). Je me tournerai ensuite vers la bibliothèque GMP si j'ai des problèmes avec la division euclidienne…

---

Code:

---

1 2 3 4 5 6 7

#include <iostream> #include <limits>   int main(int, char**) { std::cout << std::numeric_limits<unsigned long long>::digits10 << std::endl; return 0; }

---

Résultat : 19

Si tu as besoin de 21+ chiffres significatifs, il faut plus grand (des entiers 128 bits donc); mais regarde du coté des libs qui gèrent ça : GMP / boost / etc...

Bonjour,

Citation:

---

Envoyé par Bousk

Si surement, vu qu'il n'y a que certains chiffres qui sont exactement représentables, et ils sont en nombre finis et loin de représenter tout ton ensemble.
Si tu travailles sur des valeurs fixes de digits après la virgule, travaille en entier et fais une division finale. Ou mieux, garde tout en entier et représente-les juste à virgule à la fin si/quand nécessaire.

---

J'ai exactement 24 chiffres significatifs. Je ne vois pas comment je pourrais travailler sur des entiers naturels. :roll:

Je suis en train de tester la bibliothèque GMP et j'avoue que je rencontre plein de soucis. J'aimerais pouvoir compiler ce programme minimaliste :

Code:

---

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

#include <vcl.h> #pragma hdrstop   #include "Unit1.h" #include <gmp.h> //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource "*.dfm" TForm1 *Form1; //--------------------------------------------------------------------------- void __fastcall TForm1::ButtonCalculationClick(TObject *Sender) { mpf_t nb, res; mpf_init2 (nb, 128); mpf_init2 (res, 128); nb = StrToFloat(EditInput->Text); // Je n'ai pas trouvé de fonction GMP équivalente à StrToFloat()... mpf_div (res, nb, 0.123456789123456789123456); EditOutput->Text = FloatToStr(res); // Je n'ai pas trouvé de fonction GMP équivalente à FloatToStr()... }

---

Sinon, j'aimerais bien avoir une bibliothèque de fonctions manipulant des chaînes de caractères : additionner/soustraire/multiplier/diviser deux nombres réels correspondant aux deux chaînes de caractères.

Code:

---

1 2	Lire(ch1, ch2); // ch1 = "0,12345" ch2 = "1,45678" chRes = diviser(ch1, ch2); // chRes = "0,0847416905778498"

---

Merci d'avance pour votre aide.

Citation:

---

Envoyé par Wachter

Code:

---

1 2 3 4 5 6 7 8 9

void __fastcall TForm1::ButtonCalculationClick(TObject *Sender) { mpf_t nb, res; mpf_init2 (nb, 128); mpf_init2 (res, 128); nb = StrToFloat(EditInput->Text); // tu perds tout l'intérêt de GMP, vu que tu perds ta précision ici mpf_div (res, nb, 0.123456789123456789123456); EditOutput->Text = FloatToStr(res); // et si jamais tu l'avais pas perdu avant, tu perds ta précision ici }

---

---

Fais tes conversions à la main si les fonctions n'existent pas.

Un exemple qui ne compilera pas, mais l'idée devrait être bonne (à une ou deux éventuelles erreurs de calculs et un paquet de copies inutiles près)

Code:

---

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

gmp_number myStrToFloat(std::string str) { while(!str.empty() && str[0] == '0') { // on vire les 0 au début str.erase(0, 1); } auto point = str.find('.'); bool hasPoint = point != str.npos();   if(hasPoint) { while(!str.empty() && str[str.size()-1] == '0') { // on vire les 0 non significatifs à la fin str.erase(str.end()-1, str.end()); } str.erase(str.begin() + point, 1); // on vire le point si présent }   auto pwr = hasPoint ? point: str.size(); // position du point, str.size() si non trouvé gmp_number div = gmp_power(10, str.size() - pwr); // dénominateur   gmp_number num = 0; // numérateur for(auto c: str) { num *= 10; num += (c - '0'); } return gmp_number(num, div); }

---

Exemple, pour '00.0100', après avoir virer les 0 inutiles on a '01' avec un point -> num == 1; den == 10^(2-0) == 100 -> résultat = 1/100
pour '100', après avoir virer les 0 inutiles on a '100' sans point -> num == 100; den == 10^(3-3) == 1 -> résultat = 100/1
pour '100.0', après avoir virer les 0 inutiles on a '100' avec un point -> num == 100; den == 10^(3-3) == 1 -> résultat = 100/1

Mais, ya probablement plus simple :aie:

Dans tous les cas ici tes numérateurs et dénominateurs seraient des entiers naturels.
Si tu sais que ton dénominateur sera toujours le même tu n'as même pas besoin de t'en occuper (à par pour l'affichage ^^).

La solution de Bousk est la plus simple, utilise des nombres entiers pour tout ce qui est manipulation tant que tu connais combien de chiffres apres la virgule tu as besoin.
GMP (https://gmplib.org/) peut etre utilisée si ton projet accepte la license GPLv2 ou LGPLv3 (mais ça c'est un autre sujet de discussion).
Une autre solution, bien moins elegante est de convertir en string et definir tes operations, c'est tres laborieux speciallement si tu dois supporter modulo, multiplication, etc.

Citation:

---

Envoyé par Jerome2568

La solution de Bousk est la plus simple, utilise des nombres entiers pour tout ce qui est manipulation tant que tu connais combien de chiffres apres la virgule tu as besoin.

---

J'ai 24 chiffres après la virgule ; comment les stocker dans un int / long int ?

Bonjour,

Citation:

---

Envoyé par Wachter

J'ai 24 chiffres après la virgule ; comment les stocker dans un int / long int ?

---

Tu tournes en rond avec le même problème : tes exigences dépassent la capacité des types standards, tu n'échapperas pas à une bibliothèque spécialisée. :)

int128_t, certain compilateur le supporte (tous ?). Sinon, des bibliothèques comme boost.cpp_int.

Citation:

---

Envoyé par Wachter

J'ai 24 chiffres après la virgule ; comment les stocker dans un int / long int ?

---

La question n'a pas de sens, c'est comme demander "J'utilise des nombres de 0 à 152, comment je stocke ça dans un bool ?" Tu peux essayer tout ce que tu veux, ça rentre pas.

C'est pareil ici, 24 chiffres significatifs ça rentre pas dans des float / double / long double / int / long long.
Il faut plus gros (int128 ou float128).

Je répondais à la personne qui m'avait proposé de manipuler des entiers...

Mon programme compile une fois sur deux avec Code::Blocks. Le type float128 n'est finalement pas précis. :?

Code:

---

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

#include <iostream> #include <boost/multiprecision/float128.hpp>   int main() { boost::multiprecision::float128 nb;   nb = 0.34929922307744668373624877606906; nb = nb * 125; std::cout << std::setprecision(32) << nb << std::endl;   return 0; }

---

Affiche : 43,662402884680838466291419308618

Avec ma calculatrice j'obtiens : 43,662402884680835467031097008633

Toujours le même problème, tu perds ta précision quelque part. Ici tu la perds lors de la construction de nb.

Code:

---

1 2 3 4 5 6

boost::multiprecision::float128 nb;   nb = 0.34929922307744668373624877606906; // 0.349... est un double -> perte de précision   nb = boost::multiprecision::float128("0.34929922307744668373624877606906"); // ok, construction depuis un string nb = 0.34929922307744668373624877606906Q; // ok, 0.349... est un float128

---

Salut,

Il ne faut pas oublier que la résistance maximale d'une chaîne n'est jamais supérieure à celle de son maillon le plus faible. Dans le cas présent, tu pourrais choisir n'importe quel type "float_xxx" que tu pourrais imaginer (même un float_512, si tu voulais), la meilleure précision que tu pourrais obtenir serait celle du type de la donnée qui te permet de définir la valeur de ta variable.

Ainsi, le code foat_512 = 3.1415926754264420356841664523; (si tant est que le type existe, ce qui n'est normalement pas encore le cas) essayerait, au mieux, de fournir une valeur sous la forme d'un... double (c'est comme cela: si l'on ne précise pas le type à utiliser pour la représentation de valeurs littérales, le compilateur choisi un type bien particulier :P) qui aura, forcément, une précision moindre que ton float_512.

Et, à partir de là, la messe est dite : tu pourras danser sur ta tête, la meilleure précision que tu pourras espérer avec ton flot_512 (s'il existait) ne dépasserait pas celle que tu peux obtenir ... avec un double.

Si tu veux pouvoir profiter d'une meilleure précision, tu n'as pas d'autre choix que de... renforcer le maillon le plus faible en t'assurant que la représentation de base de ta valeur ne soit pas "bêtement limitée" à la précision d'un double.

Une représentation sous la forme d'une chaine de caractères peut te permettre de gagner en précision, vu qu'elle ne subit pas les contraintes du nombre de bits permettant de représenter la mantisse et l'exposant d'un nombre à virgule flottante. GMP et MPFR sont des bibliothèques qui permettent de faciliter le travail avec des valeurs importantes.

Mais, quoi qu'il en soit, les types primitifs sont définis par le nombre de bits qui permet la représentation d'un intervalle de valeurs données et, ce nombre de bits étant clairement défini (enfin, aussi clairement défini que possible), il leur est totalement impossible de représenter une valeur de 18000 si le nombre de bits qui les composent ne permettent de représenter que des valeurs comprises entre... 0 et 255.

Une fois que tu auras assimilé cela, tu pourras commencer à réfléchir à la meilleure manière d'obtenir ce que tu souhaites.

NOTA : De manière générale, es-tu vraiment sur qu'une précision de l'ordre de 24 chiffres significatifs est absolument nécessaire :question: L'un dans l'autre, cela revient à vouloir représenter la vitesse de la lumière avec une précision de l'ordre de quoi? un yoctomètre :question: est-ce que cette précision fera une si grosse différence dans le calcul de la distance entre la Terre et Alpha du Centaure :question:

Citation:

---

Envoyé par koala01

NOTA : De manière générale, es-tu vraiment sur qu'une précision de l'ordre de 24 chiffres significatifs est absolument nécessaire :question: L'un dans l'autre, cela revient à vouloir représenter la vitesse de la lumière avec une précision de l'ordre de quoi? un yoctomètre :question:

---

Par curiosité, ça donnerait quoi ?

Une distance précise à 10^-23 m près ? (Erreur de 10^-24 sur 2 dimensions ?)

Avec des valeurs plus petites : 1m/s; 4 chiffres significatifs
Au minimum : 1 m en 1.00099.. sec : ~0.999m/s
Au maximum : 1.00099.. m en 1 sec : ~1.001m/s
-> Erreur de +/- 0.001