Différence bizarre d'un calcul avec variables intermédiares

Version imprimable

Voir 40 message(s) de cette discussion en une page

Bonjour,
J' ai un phénomène très bizarre que j'explique pas, à vous de juger.

On a deux objets, Foo et Bar :
Code:

1 2 3 4 5 6 7 8 9 10 11 class Foo { double getX() { return (m_X); } double getY() { return (m_Y); } };
Code:

1 2 3 4 5 6 7 class Bar { double getValue() { return (m_value); } };
Maintenant, ce qu'il y a de bizarre, c'est qu'en faisait cela:
Code:

1 2 result = (Foo.getX() - Bar.getValue()/2 + Foo.getY()/2)/Foo.getX(); // result = 0.17271511157289223814537137968728
Et cela:
Code:

1 2 3 4 5 double x = Foo.getX(); double value = Bar.getValue(); double y = Foo.getY(); result = (x - value/2 + y/2)/x; // result = 0.17271511157289287652361053915229
On obtient pas le même resultat comme vous pouvez le voir.
Code:

1 2 // result = 0.17271511157289223814537137968728 // result = 0.17271511157289287652361053915229
Je ne comprends vraiment pas car les getters() ne font que renvoyer la valeurs et rien de plus.
Si quelqu'un à une explication, je suis preneur.

Merci de votre aide.

11/12/2012, 13h38
r0d

Est-ce que les variables membre m_x, m_y et m_value sont de type double?

Oui, désolé de ne pas avoir précisé cela.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Foo
{
  double getX()
  {
    return (m_X);
  }
  double getY()
  {
    return (m_Y);
  }
private:
  double m_X;
  double m_Y;
};

Code:

1
2
3
4
5
6
7
8
9
class Bar
{
  double getValue()
  {
    return (m_value);
  }
private:
  double m_value;
};

11/12/2012, 13h44
ternel

double

Tout est dit.

Tu es, toi aussi, victime de l'approximation flottante.

Certaines corrections anti-erreurs sont applicables sur le cas des variables locales, ce qui n'est pas forcément le cas avec les appels de fonctions.
Ou le contraire

C'est tout de même bizarre. Je viens de faire le test avec le code suivant:

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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
struct Foo
{
	Foo(double x, double y) : m_X(x), m_Y(y) {}
 
	double getX()
	{
		return (m_X);
	}
 
	double getY()
	{
		return (m_Y);
	}
 
	double m_X, m_Y;
};
 
struct Bar
{
	Bar(double value) : m_value(value) {}
 
	double getValue()
	{
		return (m_value);
	}
 
	double m_value;
};
 
int main(int argc, char* argv[])
{
	Foo foo(2.3, 3.2);
	Bar bar(5.4);
	double result1 = (foo.getX() - bar.getValue()/2 + foo.getY()/2)/foo.getX();
 
	double x = foo.getX();
	double value = bar.getValue();
	double y =  foo.getY();
	double result2 = (x - value/2 + y/2)/x;
 
	getchar();
	return 0;
}

et dans mon test, result1 et result2 sont exactement égaux, avec une visualisation à 17 chiffres après la virgule (je ne sais pas comment en voir plus). Windows 7, visual c++ 2010.

11/12/2012, 13h50
LinuxUser
Je connais le problème de l'approximation flottante (due à la manière de representer les flottants) mais là j'ai du mal à accepter la différence de resultat.

Si je t'avais dit:
Code:

1 2 3 4 5 6 7 8 9 10 11 double x = 3.0; if((1./3.)==(1./x)) { // } else { // approximation flottante } // La OK, je comprends
Mais là tu es entrain de me dire que
Code:

1 2 3 4 5 double x = getX(); if(x != getX()) { // tout est normal: approximation flottante }

r0d:
Essaye une fois avec:
Code:

1 2 3 x = 343.41000000000002501110429875552654; y = 23.70134488207620293565014435444027; value = 33.92;
S'il te plait.

11/12/2012, 14h03
r0d

J'obtiens:
result1 0.98512178574018849
result2 0.98512178574018849

Je ne sais pas comment avoir plus de précision avec vc2010.
Quel est ton environnement de dev (os, compilateur)?
11/12/2012, 14h04
Bousk

Je pense que ça vient du fait que dans le second cas tu passes par des variables intermédiaires. Donc arrondies une fois supplémentaire. Puis le calcul se fait sur les valeurs arrondies, alors que dans le premier il doit pouvoir utiliser des valeurs plus "exacts".
11/12/2012, 14h06
LinuxUser

Code:

Linux xubuntu 3.5.0-18-generic #29-Ubuntu SMP Fri Oct 19 10:27:31 UTC 2012 i686 i686 i686 GNU/Linux

Code:

gcc (Ubuntu/Linaro 4.7.2-2ubuntu1) 4.7.2

Je suis tenté de dire : "peut importe l'environnement", car il s'agit du même code executé dans le même envirronement qui produit deux résultats différents selon que je passe par des variables intermédiares ou pas.

r0d:
En reprenant ton code:

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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include <iostream>
 
struct Foo
{
	Foo(double x, double y) : m_X(x), m_Y(y) {}
 
	double getX()
	{
		return (m_X);
	}
 
	double getY()
	{
		return (m_Y);
	}
 
	double m_X, m_Y;
};
 
struct Bar
{
	Bar(double value) : m_value(value) {}
 
	double getValue()
	{
		return (m_value);
	}
 
	double m_value;
};
 
int main(int argc, char* argv[])
{
    	std::cout.setf(std::ios::fixed, std::ios::floatfield);
	std::cout.precision(32);
	Foo foo(343.41000000000002501110429875552654, 23.70134488207620293565014435444027);
	Bar bar(33.92);
	double result1 = (foo.getX() - bar.getValue()/2 + foo.getY()/2)/foo.getX();
 
	double x = foo.getX();
	double value = bar.getValue();
	double y =  foo.getY();
	double result2 = (x - value/2 + y/2)/x;
 
	std::cout<<"\n\t res1 = "<<result1<<"\n\t res2 = "<<result2<<"\n";
 
	return 0;
}

Voilà ce que j'obtiens:

Code:

1
2
	 res1 = 0.98512178574018849364080097075203
	 res2 = 0.98512178574018838261849850823637

11/12/2012, 14h20
ternel

Juste pour l'expérience, essaie avec des méthodes retournant des "const double&", vu que tu as les membres.
11/12/2012, 14h23
LinuxUser

Citation:

Envoyé par leternel

Juste pour l'expérience, essaie avec des méthodes retournant des "const double&", vu que tu as les membres.

Ca ne change rien, j'obtiens la même différence.
11/12/2012, 14h26
r0d

Citation:

Envoyé par LinuxUser

Je suis tenté de dire : "peut importe l'environnement",

Je demandais ça parce qu'en fait, ta compilation peut être customisée, notamment en ce qui concerne la gestion des flottants. Et je voulais savoir si tu utilisais visual, car dans ce cas j'aurais pu te donner quelques tips. En revanche, je ne connais pas assez gcc pour t'aider sur ce point.
11/12/2012, 14h32
LinuxUser

Citation:

Envoyé par r0d

Je demandais ça parce qu'en fait, ta compilation peut être customisée, notamment en ce qui concerne la gestion des flottants. Et je voulais savoir si tu utilisais visual, car dans ce cas j'aurais pu te donner quelques tips. En revanche, je ne connais pas assez gcc pour t'aider sur ce point.

Maintenant que tu me le dis, en effet j'utilise une option d'optimisation

Code:

gcc -Os

qui optimise la taille.

Mais pour tester ton exemple, j'ai compilé sans option et la différence est tout de même apparue.
11/12/2012, 14h42
ternel

Personnellement, je me base sur le principe de base suivant:
"deux flottants ne sont jamais égaux"

Du coup, je ne me pose pas trop la question.
Le jour où je veux plus d'exactitude … n'est pas encore arrivé.
11/12/2012, 14h46
gbdivers

Sur gcc ubuntu

Citation:

res1 = 0.98512178574018849364080097075203
res2 = 0.98512178574018849364080097075203

Peux tu donner le code asm ? (ajoute -S à la compilation)

@Leternel
C'est un peu strict comme règle. Oui, on doit faire attention en utilisant les réels. Mais 2 calculs identiques doivent donner le même résultat
11/12/2012, 14h51
gbdivers

Au fait, sur quelle machine tu fais tourner ?

En compilant avec -S, j'obtiens à l'execution:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
./main: ligne 1: .file : commande introuvable
./main: ligne 2: .section : commande introuvable
./main: ligne 3: .weak : commande introuvable
./main: ligne 4: .type : commande introuvable
./main: ligne 5: _ZStanSt13_Ios_FmtflagsS_: : commande introuvable
./main: ligne 6: .LFB585: : commande introuvable
./main: ligne 7: .cfi_startproc : commande introuvable
./main: ligne 8: pushl : commande introuvable
./main: ligne 9: .cfi_def_cfa_offset : commande introuvable
./main: ligne 10: .cfi_offset : commande introuvable
./main: ligne 11: movl : commande introuvable
./main: ligne 12: .cfi_def_cfa_register : commande introuvable
./main: ligne 13: Erreur de syntaxe près du symbole inattendu « ( »
./main: ligne 13: `	movl	8(%ebp), %edx'

Ce qui est bizarre, c'est qu'il n'y a pas d'affichage des resultats.

11/12/2012, 14h54
gbdivers

Normal, ça génère le code asm dans le fichier .o et ensuite gcc essaie de continuer la compilation comme si le .o contenait vraiment... un .o :)
Il faut ouvrir le .o avec un éditeur de text

Voir 40 message(s) de cette discussion en une page