very weird php type casting bug

[edrugtrader]

$i = 0;
$i += .3;
$i += .6;
$i += .1;

if($i == 1) {
	echo "i is 1!";
} else {
	echo "i is not 1! it's value is $i<br />";
}

if($i == 1.0) {
	echo "i is 1!";
} else {
	echo "i is not 1.0! it's value is $i<br />";
}

if($i === 1) {
	echo "i is 1!";
} else {
	echo "i is not EXACTLY 1! it's value is $i<br />";
}

if($i === 1.0) {
	echo "i is 1!";
} else {
	echo "i is not EXACTLY 1.0! it's value is $i<br />";
}

the results:
i is not 1! it's value is 1
i is not 1.0! it's value is 1
i is not EXACTLY 1! it's value is 1
i is not EXACTLY 1.0! it's value is 1

wha???

[edrugtrader]

doing number_format($i) == 1 works, but i shouldn't have to do that.

[Weedpacket]

Probably because in floating-point binary a number like 0.1 can't be represented exactly;

You'll note that it works if you initialise with
$i = 0;
$i += 0.5;
$i += 0.5;
because 0.5 can be precisely represented in floating point.

PHP's default configuraition displays numbers only to 14 digits of precision. Try bumping that up to 24, say,

ini_set('precision',24);

and trying again.

[edrugtrader]

yeah, it just doesn't make sense that it would output the value as "1" but not return true when you say if($i==1).

if it returned 1.000000001 or .99999999999 i would understand, but it isn't doing that.

[ahundiak]

$i = 0;
$i += .3;
$i += .6;
$i += .1;
echo number_format($i,30);

Yields:
0.999999999999999822364316059975

The manual warns about using the equality operator with floats.
http://www.php.net/manual/en/language.types.float.php

[edrugtrader]

ok, so in that case, the bug in question is why does it echo "1" if the value is really .9999999999999xxxxxxxxx?

[ahundiak]

echo 1.0/3.0 . "\n"
yields
0.333333333333

Default precision is 12 characters.

[Weedpacket]

Originally posted by edrugtrader
ok, so in that case, the bug in question is why does it echo "1" if the value is really .9999999999999xxxxxxxxx?

It's called "rounding off". I can't be bothered explaining in detail how that's done right now - you calculate one more digit than you're planning to display, and round the bit you're planning to display up or down depending on whether that extra digit is at least 5 or not. If the number is 0.99999999999 and the extra digit is '9', then the number gets rounded up for display.

[laserlight]

You can always test within a range, for floating point variables.

$i = 0;
$i += .3;
$i += .6;
$i += .1;

$epsilon = 0.001;

if ($i < (1.0 + $epsilon) && $i > (1.0 - $epsilon)) {
    echo "i is 1!";
} else {
    echo "i is not 1.0! it's value is $i<br />";
}

[edrugtrader]

Originally posted by Weedpacket
It's called "rounding off". I can't be bothered explaining in detail how that's done right now - you calculate one more digit than you're planning to display, and round the bit you're planning to display up or down depending on whether that extra digit is at least 5 or not. If the number is 0.99999999999 and the extra digit is '9', then the number gets rounded up for display.

well, php should do the same "rounding off" during comparison...

if it will echo "1", then it should return true for == 1.

[ahundiak]

This is kind of fun. So now you want php to say something is equal to 1 even though it's not? Sounds like some sort of new age math to me.

[edrugtrader]

no, what i want is that if the echo command yields one value, then the comparison command should yield the same value.

for php to say, "uh, don't use == on floats" is just irresponsible.

if you're going to 24 digits of precision, then echo .999999999999...

don't round up for display but not round during comparison... this is REQUIRED if you are going to write a loose typed language.

first check if the float values are the same, if they aren't, then check if the string values are the same...

this seems obvious to me.

php should never say "1 is not equal to 1, but it's value is 1"... that is what is going on here.

[Weedpacket]

Originally posted by edrugtrader
php should never say "1 is not equal to 1, but it's value is 1"... that is what is going on here.

Okay, so it's PHP's fault that floating point binary can't represent one-tenth exactly? (One-tenth's binary expansion is 0.00011001100110011.... and is nonterminating, so only a finite portion of that can be stored - that's where the inaccuracy comes from in the first place)

If a number evaluates in floating-point arithmetic as 0.999999999999999999999999 and you're only allowing 14 digits of precision to be displayed (note: that's purely for display and nothing to do with its internal value) what do you want to see? 0.99999999999999 or 1? (Hint: the latter is more accurate).

I suppose you could insist that if the language only displays floats to 14 digits of precision then it should only store 14 digits of precision internally; fine: the only drawback to that would be that floating point arithmetic would be even less accurate. Or maybe the display precision (in decimal) should match the internal precision (in binary). But then what about numbers that can't be represented exactly in the 64 bits of a floating-point double?

This has always been an issue with floating point arithmetic. PHP has it, Javascript has it, C has it, even Mathematica has it and it's designed specifically for mathematics. If you're going to go around comparing floats to ints, you have to expect problems. Doesn't matter if the language is loosely-typed or not.

Something on comp.lang.java once:

forget everything from school -- you are programmer,
and here 2.13.6=7.559995
but sometimes (2.13.6==7.559995)!=true
this is the world with no rules after point -- this is computer.