Discussion :

[LinuxUser]

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]

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

[LinuxUser]

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]

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]

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]

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]

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.