double

[Peter Ramsebner]

Is there an explication why it's executed the then path?

Dim a As Double = 10
Dim b As Double = 3
Dim c As Double = 3
Dim x As Double
Dim y As Double = 10
x = a / b
x *= c
If x = y Then
Debug.Print("x" )
End If

Peter

[Andrew Morton]

Peter Ramsebner wrote:

Is there an explication why it's executed the then path?

Dim a As Double = 10
Dim b As Double = 3
Dim c As Double = 3
Dim x As Double
Dim y As Double = 10
x = a / b
x *= c
If x = y Then
Debug.Print("x" )
End If

Your Debug.Print should be outputting x.ToString and y.ToString.

Andrew

[Patrice]

Floating point calculations are sometimes wrong. Not always ;-)

Is this because of floating point calculations that you expected different
values for x and y ?

--
Patrice

"Peter Ramsebner" <pe************ *@pr.ata écrit dans le message de groupe
de discussion : OW************* *@TK2MSFTNGP05. phx.gbl...

Is there an explication why it's executed the then path?

Dim a As Double = 10
Dim b As Double = 3
Dim c As Double = 3
Dim x As Double
Dim y As Double = 10
x = a / b
x *= c
If x = y Then
Debug.Print("x" )
End If

Peter

[Peter Ramsebner]

Your Debug.Print should be outputting x.ToString and y.ToString.

Forget the output, the question is how it is possible that x=y?

[Patrice]

For now I don't understand what makes you think it shouldn't... x is 10/3*3
so x is 10 and y is 10... This is mathematically correct.

I would assume this is because the intermediate is likely not stored with
full accuracy but basically floating point values are always approched
values. So even a truncated result could give the expected result just by
"chance"...

For example try after the x = a / b line :

Debug.Print(x.T oString("r")) ' This format allows to see the "real" value
stored
Debug.Print(x.T oString)
Debug.Print(3.3 333333333333335 * 3) ' Which is 10
Else please be explicit about the problem to avoid wasting our time to
guess...

--
Patrice

"Peter Ramsebner" <pe************ *@pr.ata écrit dans le message de groupe
de discussion : ug************* *@TK2MSFTNGP02. phx.gbl...

>Your Debug.Print should be outputting x.ToString and y.ToString.

Forget the output, the question is how it is possible that x=y?

[Peter Ramsebner]

Debug.Print(3.3 333333333333335 * 3) ' Which is 10

>

it's not 10! It's 10,0000000005

[Andrew Morton]

Peter Ramsebner wrote:

> Debug.Print(3.3 333333333333335 * 3) ' Which is 10

it's not 10! It's 10,0000000005

= does not mean exact equality for floating point numbers.

It means abs(a-b)<epsilon, where epsilon is some small positive number.

For more words on the subject, see, e.g, section III of
http://www.cprogramming.com/tutorial...sentation.html

Andrew

[Patrice]

Don't you see 10 if you run the code ?

The key point to remember is that floating point arithmetic uses *approched*
values because it has to be a compromise between the range and precision
(for example values that are not a power of two have even no exact
representation) .

You'll find tons of articles about that on the web but basically my
understanding is :
- floating points values are kept as an approched value
- they are displayed using less significant digits than stored (to increase
the precision and likely not confuse users with visible approximations) .
This what the "r" format does. It shows the actual underlying value.

So in most cases those approximations are not visible.

In this particular case :

- 10/3 is stored as a value that multiplied by 3 (and possibly truncated for
user display will give back 10) because the representation of the result of
10/3 is not the same than 9.999 as you have some additional digits resulting
from the calculation that are not shown...

- If you take the visible value and multiple by 3 you won't have 10 but
9.999 etc...

- if you take the actual underlying value and multiply by 3 you'll have back
10 (perhaps 10.00000000005 and possible right digits are either not stored
or truncated for user display giving finally 10)

I'm not sure if this is really something you would like to fix (generally
one complain when the result is not mathematically correct).

If you want to guarantee the precision you could use the Decimal type
instead. If you want to have 9.999999 you'll have to truncate the value to a
fixed size explictely.

As a side note you generally compare floating point values by checking that
the absolute difference is less than a threshold to take into account those
possible approximations. ..

Hope it helps.

--
Patrice

"Peter Ramsebner" <pe************ *@pr.ata écrit dans le message de groupe
de discussion : ue************* *@TK2MSFTNGP06. phx.gbl...

> Debug.Print(3.3 333333333333335 * 3) ' Which is 10

it's not 10! It's 10,0000000005

[=?ISO-8859-1?Q?G=F6ran_Andersson?=]

Peter Ramsebner wrote:

> Debug.Print(3.3 333333333333335 * 3) ' Which is 10

it's not 10! It's 10,0000000005

Which probably 10 is also.

Most numbers can't be represented exactly as a decimal. There is really
no reason why 10 or 3 would be one of them.

--
Göran Andersson
_____
http://www.guffa.com