Précision pour un double

Version imprimable

Bonjour j'ai un problème avec la précision d'un double. Il s'agit de regarder ce code. Pouvez-vous m'aider ??

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
int main(void)
{
double var;
double res;
 
var = 1111111111122;
res = var / pow(10,2);
 
printf("%lf",res);
// le resultat on obtient 11111111111.219999 Alors que j'aimerai obtenir 11111111111.220000
 
return 0;
}

Citation:
Envoyé par weis3r
Bonjour j'ai un problème avec la précision d'un double. Il s'agit de regarder ce code. Pouvez-vous m'aider ??
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 #include <stdio.h> #include <stdlib.h> #include <math.h> int main(void) { double var; double res; var = 1111111111122; res = var / pow(10,2); printf("%lf",res); // le resultat on obtient 11111111111.219999 Alors que j'aimerai obtenir 11111111111.220000 return 0; }
Les nombres réels sont codés en virgule flottante (signe+mantisse+exposant). ce sont des valeurs dont la précision n'est pas infinie. Il est normal que l'affichage montre les erreurs de précision.

Néanmoins, on peut jouer avec la précision de l'&ffichage qui fait des arrondis :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 #include <stdio.h> #include <math.h> int main (void) { double var = 1111111111122.; double res = var / pow (10, 2); printf ("%.2f\n", res); return 0; }
Code:

1 2 3 4 5 11111111111.22 Process returned 0 (0x0) execution time : 0.035 s Press any key to continue.

27/10/2008, 02h00
weis3r

Oui mais !

Je suis d'accord mais je veux récupérer cette valeur pour traitement avec une autre variable. Si je n'ai pas la valeur exacte ça ne fonctionnera pas. Il faut absolument que j'obtienne .22 à la fin. Ce qui est drôle c'est que dépendamment de la valeur qui est divisé des fois ça fonctionne et d'autres fois non.
27/10/2008, 02h09
Emmanuel Delahaye

Citation:

Envoyé par weis3r

Il faut absolument que j'obtienne .22 à la fin.

Ca n'existe pas avec les réels en C. Il faut revoir ta conception.
28/10/2008, 15h29
salseropom
Une idée consisterait peut être à travailler avec des exposants. Au lieu de
Code:

1 2 var = 1111111111122
tu mets
Code:

1 2 var = 1.111111111122e12
et quand tu veux diviser par 100 (pow(10,2)) tu modifies la valeur de l'exposant.
28/10/2008, 16h32
matafan
Citation:
Envoyé par salseropom

Une idée consisterait peut être à travailler avec des exposants. Au lieu de

Code:

1 2 var = 1111111111122

tu mets

Code:

1 2 var = 1.111111111122e12

et quand tu veux diviser par 100 (pow(10,2)) tu modifies la valeur de l'exposant.
Ca change quoi ? Comment est-ce que tu "modifies la valeur de l'exposant" ?
29/10/2008, 03h18
weis3r

Ok

Est-ce que tu peux préciser je ne comprends pas très bien ce que tu veux dire par modifier l'exposant.

Si je vous explique en gros c'est que j'ai un nombre à 12 digits du genre :

111222333444 je veux faire uniquement avec des opérations mathématiques sortir le chiffre à la position 1 ou 2 ou 3.... etc...

donc mon idée était que je voulais diviser ce nombre en le divisant par 10 autant de fois que la position du chiffre. Exemple :

Si je veux le premier 1 du nombre :

111222333444 / 100000000000

Ce qui me donne 1,1122333444 ce qui me permet donc avec la fonction floor() par la suite d'aller chercher mon chiffre. Mais malheureusement en divisant je perd énormément de précision pour une raison qui m'échappe. Ce n'est pas une question d'affichage. Car si vous essayer de diviser le nombre 1999999999999 / 1000000000000 ca va vous donner 2.00000

Mais je dois avoir absolument le chiffre avec toute la précision possible.

Des idées ?
29/10/2008, 08h23
matafan

Citation:

Envoyé par weis3r

Des idées ?

Oui, n'utilise pas de flottants (float ou double). Utilise des entiers.

Le "problème" avec les flottants c'est qu'en interne la mantisse et l'exposant ne sont pas en base 10, mais en base 2... Donc forcément un nombre "rond" en base 10 n'est pas forcément "rond" en base 2, et inversement.
29/10/2008, 12h29
3DArchi
Citation:

Envoyé par weis3r

111222333444 je veux faire uniquement avec des opérations mathématiques sortir le chiffre à la position 1 ou 2 ou 3.... etc...

donc mon idée était que je voulais diviser ce nombre en le divisant par 10 autant de fois que la position du chiffre.

L'idée était bonne. Mais son application trop 'mathématique'. En C, une division d'entier te donnera ta réponse:
((int)1234567890%(int)10^n)/(int)10^(n-1) avec n>0 te donnera le nième digit.

Le C n'étant pas du langage formel (float)1!=(int)1 (au sens de la représentation bien sûr). La représentation créé des imprécisions. A titre d'exemple, exécute le programme suivant:
Code:

1 2 3 4 5 6 7 8 9 int main(void) { float f = 1.0f; int *p_i; p_i=(int*)&f; int i = 1; printf("%x %x\n",i, *p_i); return 0; }
Tu verras que leur représentation en mémoire est différente
29/10/2008, 21h38
weis3r

probleme résolu

Au lieu de faire une division j'ai multiplié par une fraction et ça fonctionne.

res = 19999999999 * pow(0.1,2);

merci du coup de main !
29/10/2008, 23h21
matafan

A partir du moment où tu veux faire une division entière, c'est infiniment plus propre de diviser par un int que de multiplier par un double. Là tu fais une division flottante, dont le résultat est ensuite converti en entier.
30/10/2008, 14h46
Obsidian

Citation:

Envoyé par weis3r

Au lieu de faire une division j'ai multiplié par une fraction et ça fonctionne.

res = 19999999999 * pow(0.1,2);

merci du coup de main !

Oui, mais ça ne résout pas ton problème de fond, puisque les arguments que tu transmets à la fonction sont sujets aux mêmes imprécisions ! Au contraire, cela risque même d'introduire à terme des erreurs de calcul qui risquent d'être très difficiles à déceler.

Il faut absolument que tu te souviennes que le C sert à fabriquer des exécutables en langage machine mais qu'il n'est pas, en soi, un calculateur mathématique symbolique ! Il faut tenir compte des limitations des types de données proposées (et, pour cela, les connaître), ainsi que du coût de calcul qui les accompagne.

C'est évident, par exemple, lorsque l'on utilise une calculatrice 4 opérations. Le nombre de « digits » est limité et on sait que l'on aura des problèmes avec les grands nombres ou avec des termes d'ordre de grandeur très différents. Le problème est exactement le même en programmation même s'il est moins visible au premier abord.