>>rune at zedeler dot dk
>>05-Mar-2007 06:44
>>Comparing infinite values gives REALLY STRANGE results.
>>INF<INF is true
>>INF>INF is true
>>INF==INF is false
>>INF===INF is true
>>So if someone tells you that $a==$b implies $a===$b then you can tell them no, $a=$b=INF is a counterexample. :-/
The above is incorrect.
You have to remember, that INF is not a discrete value, it is more or less a flag indicating a state: "Infinity" does not necessarily mean that the result is actually infinite. It simply means "too large to represent"(From Wikipedia). Moreover, INF cannot ever be equal to INF, as the following example shows:
(+INF) + (+7) = (+INF)
For INF==INF to be true, (INF + 7)==INF would also have to be true due to the above; it is not, again, because INF is not a value, it is a state.
Furthermore, logically, $a=$b=INF is not a counterexample; it would be if INF==INF was true but INF===INF was false(or if you had said $a===$b implies $a==$b), but this is not the case, as implication is not a two-way street. Following is a truth table for p => q:
p q p=>q
F F T
F T T
T F F
T T T
So we have:
INF==INF (implies) INF===INF
False (implies) True
True (from the truth table above)
thus, $a=$b=INF is not a counterexample, since the system remains logically consistant.
浮点型
浮点数（也叫浮点数，双精度数或实数）可以用以下任何语法定义：
形式上：
LNUM [0-9]+ |
add a note
User Contributed Notes
chrisgbk at hotmail dot com
14-May-2007 01:17
14-May-2007 01:17
rune at zedeler dot dk
05-Mar-2007 11:44
05-Mar-2007 11:44
Comparing infinite values gives REALLY STRANGE results.
INF<INF is true
INF>INF is true
INF==INF is false
INF===INF is true
So if someone tells you that $a==$b implies $a===$b then you can tell them no, $a=$b=INF is a counterexample. :-/
duc at vtechmate dot com
21-Dec-2006 07:00
21-Dec-2006 07:00
A tip for vic@liveforspeed.net.
You can use the function unpack(). For example,
$f = chr (0xb1).chr (0x5c).chr (0xbc).chr (0x41);
$val = unpack("f*0", $f);
print_r($val);
will give
Array
(
[01] => 23.545259475708
)
sinuhet
14-Nov-2006 04:04
14-Nov-2006 04:04
<?php
define('EPSILON', 1.0e-8);
function real_cmp($r1, $r2)
{
$diff = $r1 - $r2;
if( abs($diff) < EPSILON )
return 0;
else
return $diff < 0 ? -1 : 1;
}
function real_lt($r1, $r2)
{
return real_cmp($r1, $r2) < 0;
}
echo "raw compare\n";
$n = 0;
for($i = 0.1; $i < 1.0; $i += 0.1) {
$n++;
echo "$i\t$n\n";
}
echo "\nepsilon compare\n";
$n = 0;
for($i = 0.1; real_lt($i, 1.0); $i += 0.1) {
$n++;
echo "$i\t$n\n";
}
/*
Outputs:
raw compare
0.1 1
0.2 2
0.3 3
0.4 4
0.5 5
0.6 6
0.7 7
0.8 8
0.9 9
1 10
epsilon compare
0.1 1
0.2 2
0.3 3
0.4 4
0.5 5
0.6 6
0.7 7
0.8 8
0.9 9
*/
?>
So moral of this program? "Never compare floating point numbers for equality" solves only half of the problem. As seen above, even raw comparing of floats for less than (or grater than) is dangerous and epsilon (round, etc.) must be used.
TAS
27-Jul-2006 11:02
27-Jul-2006 11:02
An update regarding the james dot cridland at virginradio dot co dot uk note below, I recently tried his formula using PHP 5 and it is necessary to specify the integer precision when using the round function, otherwise the output will be 0.
<? echo round((69.1-floor(69.1))); ?> // prints 0
<? echo round((69.1-floor(69.1)), 1); ?> // prints 0.1
Also, it appears that "small numbers" include everything up to 64.0. So that
<? echo (63.1-floor(63.1)); ?>
will print 0.1 and
<? echo (64.0-floor(64.0)); ?>
will print 0, but
<? echo round(64.1-floor(64.1)); ?>
will print 0.099999999999994.
david at davidmosesNO dot SPAM dot ca
25-Mar-2006 09:48
25-Mar-2006 09:48
Re: rick at ninjafoo dot com
There is no need to always use the BCMath functions. We just need to heed the documentation and never compare floating point numbers for equality.
The reason (19.6*100) !== (double)1960, is because inside a computer they are not equal.
Try this:
<?php
printf("%.15f", (19.6*100));
?>
Outputs: 1960.000000000000227 (not 1960 as somewhat expected)
If comparison is required a few options come to mind (other than BCMath):
1) Round numbers before comparison:
<?php
$sig_figs = 5;
echo (round((19.6*100), $sig_figs) !== round((double)1960, $sig_figs)) ? 'not equal' : 'equal';
?>
Outputs: equal
2) Another method is to use a tolerance value, and consider numbers equal if their difference is less than the tolerance.
justin at jennnixon dot com
22-Nov-2005 12:00
22-Nov-2005 12:00
I was playing around with a benchmark script:
<?php
$st = array_sum (explode (' ', microtime ()));
ob_start ();
for ($i = 1; $i < 10000; $i++) {
echo "<!-- Hello, World! " . ($i % round(sqrt($i*2))) ^ $i . " -->\n";
}
ob_end_flush ();
echo round ((array_sum (explode (' ',microtime ())) - $st), 5) . "\n";
?>
Be careful with numbers, they can print out inpredictable things. (For example, this printed out [uncommented])...
ᤊ ੯ഘഀᄋ ୯ഐഀጋ ୯ഒഀᔋ ୯ഔഀᜋ ୯ഖഀᤋ ୯ഘഀᄄ ѯഐഀጄ ѯഒഀᔄ ѯഔഀᜄ ѯഖഀᤄ ѯഘഀᄅ կഐഀጅ կഒഀᔅ կഔഀᜅ կഖഀᤅ ...
Luzian
17-Nov-2005 08:03
17-Nov-2005 08:03
Be careful when using float values in strings that are used as code later, for example when generating JavaScript code or SQL statements. The float is actually formatted according to the browser's locale setting, which means that "0.23" will result in "0,23". Imagine something like this:
$x = 0.23;
$js = "var foo = doBar($x);";
print $js;
This would result in a different result for users with some locales. On most systems, this would print:
var foo = doBar(0.23);
but when for example a user from Germany arrives, it would be different:
var foo = doBar(0,23);
which is obviously a different call to the function. JavaScript won't state an error, additional arguments are discarded without notice, but the function doBar(a) would get 0 as parameter. Similar problems could arise anywhere else (SQL, any string used as code somewhere else). The problem persists, if you use the "." operator instead of evaluating the variable in the string.
So if you REALLY need to be sure to have the string correctly formatted, use number_format() to do it!
TRI0N
24-Sep-2005 02:01
24-Sep-2005 02:01
Here is a simple formula to break down a number and get rid of the decimal values. I built this to take a number in seconds and convert it to a readable value for Server Uptimes.
<?php
$day = floor(($uptime / 86400)*1.0) ;
$calc1 = $day * 86400 ;
$calc2 = $uptime - $calc1 ;
$hour = floor(($calc2 / 3600)*1.0) ;
if ($hour < 10) {
$hour = "0".$hour ;
}
$calc3 = $hour * 3600 ;
$calc4 = $calc2 - $calc3 ;
$min = floor(($calc4 / 60)*1.0) ;
if ($min < 10) {
$min = "0".$min ;
}
$calc5 = $min * 60 ;
$sec = floor(($calc4 - $calc5)*1.0) ;
if ($min < 10) {
$sec = "0".$sec ;
}
$uptime2 = $day." Days, ".$hour.":".$min.":".$sec ;
?>
Place this where you want the results to be seen:
<?php echo $uptime2 ; ?>
For a Value of 1455587 seconds the results will show as followed:
16 Days, 20:19:47
Enjoy
rick at ninjafoo dot com
06-Jul-2005 08:04
06-Jul-2005 08:04
Concider the following:
(19.6*100) != 1960
echo gettype(19.6*100) returns 'double', However even .....
(19.6*100) !== (double)1960
19.6*100 cannot be compaired to anything without manually
casting it as something else first.
(string)(19.6*100) == 1960
Rule of thumb, if it has a decimal point, use the BCMath functions.
vic at liveforspeed dot net
25-Mar-2005 08:48
25-Mar-2005 08:48
I couldn't find any function to read a float from a file written by C++ (PC?) for example. This format has reversed byte order compared to PHP and in addition, there is just no bin2float function afaik, so I wrote my own binary float 2 usable php float import function.
It does not support SNaN and QNaN values though (didn't need to check for them for my purpose).
Hope it'll be to some use for some:
<?
// $bin must be 4 bytes, MSB first (Most Significant Byte)
function bin2float ($bin) {
$float = (float) 0;
// Read Exponent and Sign (+/-)
$exponent = ord ($bin{3});
if ($sign = $exponent & 128) $exponent -= 128;
$exponent <<= 1;
// Read the remaining bit for Exponent and loop through Mantissa, calculating the Fraction
$fraction = (float) 1;
$div = 1;
for ($x=2; $x>=0; $x--) {
$byte = ord ($bin{$x});
for ($y=7; $y>=0; $y--) {
if ($x==2 && $y==7) {
if ($byte & (1 << $y)) $exponent += 1;
} else {
$div *= 0.5;
if ($byte & (1 << $y)) $fraction += $div;
}
}
}
// 0 value check
if (!$exponent && $fraction == 1) return 0;
// Final calc, returning the converted float
$exponent -= 127;
$float = pow (2, $exponent) * $fraction;
if ($sign) $float = -($float);
return $float;
}
echo bin2float (chr (0xb1).chr (0x5c).chr (0xbc).chr (0x41))."\n";
echo bin2float (chr (0x00).chr (0x18).chr (0x5c).chr (0x3f))."\n";
echo bin2float (chr (0).chr (0).chr (160).chr (193))."\n";
echo bin2float (chr (0).chr (0).chr (0).chr (0));
?>
returns:
23.5452594757
0.859741210938
-20
0
(to understand the workings of floats better, I found http://www.randelshofer.ch/fhw/gri/float.html to be a good reference)
edsko at edsko dot net
17-Feb-2005 12:31
17-Feb-2005 12:31
The formal specification of the floating point numbers as specified above is not complete. For one thing, it is not immediately obvious which of the three rules describes "floating point numbers" (in general). The disjunction of all three perhaps? My interpretation is that a floating point number is either a DNUM or an EXPONENT_DNUM.
Moreover, the specification as stated does not allow for signs (+ or -). Yet, PHP does actually allow for signs in the specification of floating point numbers (as one would expect):
<?php
$f = (float) "-0.5";
var_dump($f); // outputs "float(-0.5)"
?>
Thus, the following specification is more complete:
FLOAT [+-]?({DNUM}|{EXPONENT_DNUM})
LNUM [0-9]+
DNUM ([0-9]*[\.]{LNUM}) | ({LNUM}[\.][0-9]*)
EXPONENT_DNUM ( ({LNUM} | {DNUM}) [eE][+-]? {LNUM})
feline at NOSPAM dot penguin dot servehttp dot com
13-Aug-2004 01:36
13-Aug-2004 01:36
General computing hint: If you're keeping track of money, do yourself and your users the favor of handling everything internally in cents and do as much math as you can in integers. Store values in cents if at all possible. Add and subtract in cents. At every operation that wii involve floats, ask yourself "what will happen in the real world if I get a fraction of a cent here" and if the answer is that this operation will generate a transaction in integer cents, do not try to carry fictional fractional accuracy that will only screw things up later.
gallico_ at hotmail dot com
07-Sep-2003 03:34
07-Sep-2003 03:34
To complete the thread about testing two floating point numbers for equality, here's the way it works for *every* programming language:
<?php
// two fp numbers should be considered equal if their absolute
// difference does not exceed a certain value epsilon:
$epsilon = 0.0001; // this defines the precision of your comparision
// check their absolute difference
if (abs($one_float - $another_float) < $epsilon)
// what to be done in case the numbers are equal goes here
?>
james dot cridland at virginradio dot co dot uk
28-Apr-2003 02:44
28-Apr-2003 02:44
The 'floating point precision' box in practice means:
<? echo (69.1-floor(69.1)); ?>
Think this'll return 0.1?
It doesn't - it returns 0.099999999999994
<? echo round((69.1-floor(69.1))); ?>
This returns 0.1 and is the workaround we use.
Note that
<? echo (4.1-floor(4.1)); ?>
*does* return 0.1 - so if you, like us, test this with low numbers, you won't, like us, understand why all of a sudden your script stops working, until you spend a lot of time, like us, debugging it.
So, that's all lovely then.
dev at maintainfit dot com
15-Apr-2003 06:27
15-Apr-2003 06:27
I was programming an accounting application in MySql that required me to sum a collection of floats and ensure that they equal zero before commiting a transaction, but as seen above a sum of floats cannot always be trusted (as was my case). I kept getting a very small remainder (like 1.4512431231e-14). Since I had used number_format(num,2) to set the precision of the numbers in the database to only two (2) decimal places, when the time comes to calculate the sum I simply multiply every number by ten (10), therby eliminating and decimal places and leaving me with integers to preform my sum. This worked great.
01-Apr-2003 10:20
In response to "...the author probably knows what they are talking about..." above:
Of course the author knows what they're talking about. The previous poster missunderstood the semantics of the author's example of the decimal representation of 1/3. The author is not suggesting that some property of decimal numbers causes the behaviour, but that the property of finite binary representations of real numbers which does cause the problem is shared by finite decimal representations. To paraphrase, the author is saying "10*(0.1+0.7) gives 7.99999... because of the binary equivalent of the fact that 1/3+2/3 gives 0.99999... when using finite decimal representations (where 1/3 == 0.33333... and 2/3 == 0.66666..., so 1/3+2/3 == (0.33333...)+(0.66666...) == 0.99999... instead of 1)."
The problem occurs with finite representations of real numbers, regardless of base of the number system used.
Theo Diem
26-Mar-2003 06:35
26-Mar-2003 06:35
Just to mention ....
$something = "12.20";
$value = (float) $something;
Depending you locale settings (see setlocale) this will return a float number 12.2 or 12 (without decimal part, if you locale uses another symbol than dot for decimal part)
Be aware if u are working with PHP using one locale setting (by setlocale) and a SQL database with other locale ....
Julian Suggate
10-Mar-2003 02:22
10-Mar-2003 02:22
Never never never compare floats for equality! Even a >= is asking too much of any binary computer (that's pretty much all of them ;-). It will sometimes work, but the best you can hope for is a subtle bug that will occasionally cause non-deterministic behaviour.
Floats must only ever be used for proper inequalities.
backov at spotbrokers-nospamplz dot com
05-Mar-2003 09:16
05-Mar-2003 09:16
I'd like to point out a "feature" of PHP's floating point support that isn't made clear anywhere here, and was driving me insane.
This test (where var_dump says that $a=0.1 and $b=0.1)
if ($a>=$b) then echo "blah!";
Will fail in some cases due to hidden precision (standard C problem, that PHP docs make no mention of, so I assumed they had gotten rid of it). I should point out that I originally thought this was an issue with the floats being stored as strings, so I forced them to be floats and they still didn't get evaluated properly (probably 2 different problems there).
To fix, I had to do this horrible kludge (the equivelant of anyway):
if (round($a,3)>=round($b,3)) then echo "blah!";
THIS works. Obviously even though var_dump says the variables are identical, and they SHOULD BE identical (started at 0.01 and added 0.001 repeatedly), they're not. There's some hidden precision there that was making me tear my hair out. Perhaps this should be added to the documentation?
www.sarioz.com
05-Feb-2003 06:49
05-Feb-2003 06:49
just a comment on something the "Floating point precision" inset, which goes: "This is related to .... 0.3333333."
While the author probably knows what they are talking about, this loss of precision has nothing to do with decimal notation, it has to do with representation as a floating-point binary in a finite register, such as while 0.8 terminates in decimal, it is the repeating 0.110011001100... in binary, which is truncated. 0.1 and 0.7 are also non-terminating in binary, so they are also truncated, and the sum of these truncated numbers does not add up to the truncated binary representation of 0.8 (which is why (floor)(0.8*10) yields a different, more intuitive, result). However, since 2 is a factor of 10, any number that terminates in binary also terminates in decimal.
27-Sep-2002 06:45
much easier:
e.g. round(3.1415927,2) => 3.14
round(1092,-2) => 1100
jeroen at php dot net
24-May-2001 02:13
24-May-2001 02:13
If you want to round a floating point number to the nearest multiple of some number n, use the following trick:
$rounded = round($number / n) * n
For example, to round 12874.49 to the nearest 100-multiple (i.e. 12900), use
$rounded = round($number / 100) * 100
Use ceil() or floor() if you want to round down/up.