Discussion :

[YuGiOhJCJ]

Bonjour,

Voici le code :

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
#include <stdio.h> /* for printf */
#include <math.h> /* for pow */
#include <errno.h> /* for errno */
int main()
{
	double res = -1;
	/* first calcul */
	errno = 0;
	res = pow(2, 54);
	printf("errno = %d\n", errno);
	printf("res = %f\n", res);
	/* second calcul */
	errno = 0;
	res = pow(2, 54) - 1;
	printf("errno = %d\n", errno);
	printf("res = %f\n", res);
	return 0;
}

Voici le résultat espéré :

Code :

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

1
2
3
4
5
$ ./main.out 
errno = 0
res = 18014398509481984.000000
errno = 0
res = 18014398509481983.000000

Voici le résultat obtenu :

Code :

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

1
2
3
4
5
$ ./main.out 
errno = 0
res = 18014398509481984.000000
errno = 0
res = 18014398509481984.000000

Remarque : en Python ça fonctionne bien

Code :

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

1
2
3
4
5
6
7
8
9
$ python
Python 2.7.14 (default, Jan 22 2018, 12:57:03) 
[GCC 7.1.0] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> 2 ** 54
18014398509481984
>>> (2 ** 54) - 1
18014398509481983
>>> quit()

Je ne comprends pas pourquoi pow(2, 54) et pow(2, 54) - 1 donnent le même résultat.
Une explication s'il vous plaît ?

Merci.
Cordialement.

[wolinn]

Erreur d'arrondi.
Le type 'double' a 16 chiffres significatifs en décimal.

[sambia39]

Bonjour,

Erreur d'arrondi.
Le type 'double' a 16 chiffres significatifs en décimal.

Ce n’est pas vraiment une question de précision/arrondi, mais plutôt une question d’interprétations des données en clair le résultat de pow(2,54)-1) donne un long double et non un double donc il faut utiliser une autre fonction de puissance qui manipule les long double qui est powl(2,54).
exemples simples.

Code C :

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
 
#include <stdio.h>
#include <math.h>
 
int main(int argc, char *argv[]){
 
		double res = -1;
		res = pow(2, 54) - 1;
		printf("res = %f\n", res);
 
		long double res_a = ((powl(2, 54)) - 1);
		printf("res = %Lf\n", res_a);
 
 
		/*	la plus simple et direct	*/
		printf("res = %Lf\n", (powl(2,54)-1) );
		return 0;
}

à bientôt

[wolinn]

Bonjour,
...donc il faut utiliser une autre fonction de puissance qui manipule les long double qui est powl(2,54).

Donc c'est un bien un problème de précision/arrondi, qui se résout ici en utilisant le type 'long double', qui a quelques chiffres significatifs en plus.

[kwariz]

Sur une architecture x86_64, les long double sont en général des format réels étendus : 80 bits utilisés pour 63 bits de mantisse. Ce qui fait qu'ils sont capables de représenter les entiers 64bit exactement. Mis bon si tu travailles sur les entiers autant prendre un int64_t …
Sinon il y a les bibliothèques pour travailler en précision arbitraire comme GMP mais ça a un coût mémoire et temps.

[sambia39]

Donc c'est un bien un problème de précision/arrondi, qui se résout ici en utilisant le type 'long double', qui a quelques chiffres significatifs en plus.

Non ce n'est pas dû au nombre significatif, précision ou arrondi, mais à la taille mémoire nécessaire au stockage du résultat de pow(2,54); . Je m’explique. En langage de programmation C, toute variable est typée explicitement et le fait qu’une variable soit typée permet à votre ordinateur de connaître la taille mémoire nécessaire au stockage de l’information, mais aussi comment il faut interpréter la suite des bits qui composent cette information. La mémoire d’un ordinateur étant une mémoire finit, les types que l’on utilise dépendants donc de l’architecture machine et du compilateur que l’on utilise.
Plus en détail et de façon simple. Un double est un float plus longs et un long double est un double plus longs ont a donc ici deux tailles mémoire qui ne sont pas équivalents . Le fait d'utiliser long double a l’avantage de stockers beaucoups plus d'informations, car il manipule 10 bytes ce qui permet d’avoir une précision de 19 contrairement à double qui en manipule que 8 bytes avec une précision de 15.

à bientôt.

[Sve@r]

Bonjour

Non ce n'est pas dû au nombre significatif, précision ou arrondi, mais à la taille mémoire nécessaire au stockage du résultat de pow(2,54);.

Ben oui mais c'est la taille mémoire qui influe sur l'imprécision de la partie décimale d'un nombre...
Exemple: prenons pi= 3,1415 9265 3589 793. Sur un float, on aura 3.1416. Sur un double on aura 3.1415 9265 et sur un long double on aura 3.1415 9265 3590 (ces précisions à 4, 8 et 12 décimales sont inventées pour illustrer l'exemple et ne correspondent pas forcément à la réalité). Donc c'est bien le type utilisé qui amène alors à plus ou moins de précision non ?
Surtout que le calcul des puissances passe probablement par une méthode à base de logarithmes qui est alors plus rapide mais qui amène à des calculs en flottant (même pour calculer 3²)...

Remarque : en Python ça fonctionne bien

Oui, parce que Python possède un type spécial nommé "long" qui n'existe pas en C (et qui ne correspond donc pas au long du C) et qui adapte automatiquement sa taille à l'espace nécessaire pour le nombre à manipuler. Les calculs sont plus longs avec un long (promis après j'arrête ce genre de jeu de mots débiles) mais il n'y a aucune perte d'information ni arrondi.