This blogpost contains an example, fairly foolproof implementation, and detailed theory behind it http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/ it is also one of a series, so you can always read more. In short: use ULP for most numbers, use epsilon for numbers near zero, but there are still caveats. If you want to be sure about your floating point … Read more
There are R functions that automatically take sensible approaches to the “equality problem”: > (3 – 2.9) <=0.1 #[1] FALSE > all.equal( (3 – 2.9) , 0.1) #[1] TRUE It uses the sqrt of R’s smallest positive floating point number as its default threshold, so it handles multiplications and division propagated errors. Ends up being … Read more
It’s a general rule that floating point number should never be compared like (a==b), but rather like (Math.abs(a-b) < delta) where delta is a small number. A floating point value having fixed number of digits in decimal form does not necessary have fixed number of digits in binary form. Addition for clarity: Though strict == … Read more
Check out −0 (number) in Wikipedia Basically IEEE does actually define a negative zero. And by this definition for all purposes: -0.0 == +0.0 == 0 I agree with aaronasterling that -0.0 and +0.0 are different objects. Making them equal (equality operator) makes sure that subtle bugs are not introduced in the code. Think of … Read more
Dogbert’s answer is good, but if your code might have to deal with negative numbers, Math.floor by itself may give unexpected results. E.g. Math.floor(4.3) = 4, but Math.floor(-4.3) = -5 Use a helper function like this one instead to get consistent results: truncateDecimals = function (number) { return Math[number < 0 ? ‘ceil’ : ‘floor’](number); … Read more
If you are on a recent-ish x86 or x86-64 platform (and you probably are), use the bsr instruction which will return the position of the highest set bit in an unsigned integer. It turns out that this is exactly the same as log2(). Here is a short C or C++ function that invokes bsr using … Read more
To get the correct results, don’t set precision greater than available for this numeric type: #include <iostream> #include <limits> int main() { double a = 0.3; std::cout.precision(std::numeric_limits<double>::digits10); std::cout << a << std::endl; double b = 0; for (char i = 1; i <= 50; i++) { b = b + a; }; std::cout.precision(std::numeric_limits<double>::digits10); std::cout << … Read more
Picture is worth a thousand words – try to draw equation f(k) : and you will get such XY graph (X and Y are in logarithmic scale). If computer could represent 32-bit floats without rounding error then for every k we should get zero. But instead error increases with bigger values of k because of … Read more
str(0.47000000000000003) give ‘0.47’ and float(‘0.47’) can be 0.46999999999999997. This is due to the way floating point number are represented (see this wikipedia article) Note: float(repr(0.47000000000000003)) or eval(repr(0.47000000000000003)) will give you the expected result, but you should use Decimal if you need precision.
When you use floating point arithmetic strict equality is almost meaningless. You usually want to compare with a range of acceptable values. Note that some values can not be represented exactly as floating point vlues. See What Every Computer Scientist Should Know About Floating-Point Arithmetic and Comparing floating point numbers.