Discussion :

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

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
#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;
}

[Emmanuel Delahaye]

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 :

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

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

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 :

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

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

[weis3r]

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.

[Emmanuel Delahaye]

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

Ca n'existe pas avec les réels en C. Il faut revoir ta conception.

[salseropom]

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

Code :

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

1
2
 
var = 1111111111122

tu mets

Code :

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

1
2
 
var = 1.111111111122e12

et quand tu veux diviser par 100 (pow(10,2)) tu modifies la valeur de l'exposant.

[matafan]

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

Code :

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

1
2
 
var = 1111111111122

tu mets

Code :

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

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

[weis3r]

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 ?

[matafan]

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.

[3DArchi]

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 :

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

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

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

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

[Obsidian]

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.