Discussion :

[Wachter]

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.

[droggo]

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 ...).

[Wachter]

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 :

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

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

[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.

[Wachter]

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 ?

[Iradrille]

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.

[droggo]

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 !

[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…

[white_tentacle]

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.

[Iradrille]

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 :

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

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...

[Wachter]

Bonjour,

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.

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 :

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
#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 :

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

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

Merci d'avance pour votre aide.

[Iradrille]

Code :

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

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 :

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
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

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 ^^).

[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.
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.

[Wachter]

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 ?

[droggo]

Bonjour,

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.

[jo_link_noir]

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

[Iradrille]

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).

[Wachter]

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 :

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

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

[Iradrille]

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

Code :

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

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

[koala01]

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 ) 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 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 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