Double-You Tee Eff! (Question Mark) Is this a known bug?

[audiohominis]

It's certainly new to me?

PHP Code:

trace(1*.1);//0.1
trace(2*.1);//0.2
trace(3*.1);//0.30000000000000004
trace(4*.1);//0.4
trace(5*.1);//0.5
trace(6*.1);//0.6000000000000001
trace(7*.1);//0.4
trace(8*.1);//0.5
trace(9*.1);//0.6000000000000001 


Double-You Tee Eff indeed.

F.P.10

[Shaedo]

I get

0.1
0.2
0.30000000000000004
0.4
0.5
0.6000000000000001
0.7000000000000001
0.8
0.9

but I see your point (I think)
EDIT and this
trace(1*.1*10);//1
trace(2*.1*10);//2
trace(3*.1*10);//3.0000000000000004
trace(4*.1*10);//4
trace(5*.1*10);//5
trace(6*.1*10);//6.000000000000001
trace(7*.1*10);//7.000000000000001
trace(8*.1*10);//8
trace(9*.1*10);//9

[Krilnon]

It's not a bug, it's just what you get when using floating point numbers: http://en.wikipedia.org/wiki/Floatin...uracy_problems

[Scythe]

Getting .4 when you multiply 7 by .1 would be a bug, but I assume that's a typo on the OP's part.

Observation: none of the four posters in this thread have signatures.

[BeerOclock]

When you're checking to see if one Number equals another Number, its common practice to use a range, instead of a strict equals.

Using the results you found, the following would print "WTF"

var n1:Number = 0.6;
var n2:Number = 6 * 0.1;

if (n1 == n2) {
   trace ("floating point numbers play nicely");
} else {
   trace ("WTF");
}

A common solution is to do something like this:

const EPSILLON:Number = 0.000001;

var n1:Number = 0.6;
var n2:Number = 6 * 0.1;

if ( Math.abs(n1-n2) > EPSILLON) {
   trace ("floating point numbers play nicely");
} else {
   trace ("WTF");
}

In this case, the first statement is printed. Youre basically saying "If n1 is equal to, or reaaaaaally close to n2..."

[Scythe]

I believe you mean

if ( Math.abs(n1-n2) < EPSILLON)

and not

if ( Math.abs(n1-n2) > EPSILLON)

[BeerOclock]

I believe you're right.

[audiohominis]

I have a follow-up question then.
I learned that division by 10, in contrast, does not produce funny numbers. Then again, my understanding is that division is not as efficient as multiplication, so which way would you go?
Thanks.

Originally Posted by Scythe

Observation: none of the four posters in this thread have signatures

Though one of them has a particularly delicious handle, you feel me?

[sekasi]

Division does not make this problem go away, it just manifests in different ways. As above posters have already mentioned this is a problem in all Floating point systems. Since they aren't 'real' numbers, this is the downside.

Most of the time you can ease the pain of the results by some overhead. If there are any particular scenarios where this is breaking your applications, feel free to post the relevant code and I'm sure you'll get a good answer.