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

**LinuxUser** · 11/12/2012, 13h24

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 :

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

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

Code :

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

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 :

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

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

Et cela:

Code :

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

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 :

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

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.

**r0d** · 11/12/2012, 13h38

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

**LinuxUser** · 11/12/2012, 13h41

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

Code :

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

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 :

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

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

**ternel** · 11/12/2012, 13h44

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

**r0d** · 11/12/2012, 13h48

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

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

**LinuxUser** · 11/12/2012, 13h50

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 :

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

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 :

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

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

**LinuxUser** · 11/12/2012, 13h53

r0d:
Essaye une fois avec:

Code :

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

1
2
3
x = 343.41000000000002501110429875552654;
y =  23.70134488207620293565014435444027;
value = 33.92;

S'il te plait.

**r0d** · 11/12/2012, 14h03

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

**Bousk** · 11/12/2012, 14h04

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

**LinuxUser** · 11/12/2012, 14h06

Code :

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

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

Code :

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

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.

**LinuxUser** · 11/12/2012, 14h19

r0d:
En reprenant ton 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
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 :

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

1
2
	 res1 = 0.98512178574018849364080097075203
	 res2 = 0.98512178574018838261849850823637

**ternel** · 11/12/2012, 14h20

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

**LinuxUser** · 11/12/2012, 14h23

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.

**r0d** · 11/12/2012, 14h26

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.

**LinuxUser** · 11/12/2012, 14h32

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 :

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

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.

**ternel** · 11/12/2012, 14h42

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

**gbdivers** · 11/12/2012, 14h46

Sur gcc ubuntu

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

**gbdivers** · 11/12/2012, 14h51

Au fait, sur quelle machine tu fais tourner ?

**LinuxUser** · 11/12/2012, 14h53

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

Code :

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

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.