You can use truncatingRemainder and 1 as the divider. Returns the remainder of this value divided by the given value using truncating division. Apple doc Example: let myDouble1: Double = 12.25 let myDouble2: Double = 12.5 let myDouble3: Double = 12.75 let remainder1 = myDouble1.truncatingRemainder(dividingBy: 1) let remainder2 = myDouble2.truncatingRemainder(dividingBy: 1) let remainder3 = myDouble3.truncatingRemainder(dividingBy: … 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.
From The Floating-Point Guide: This is a bad way to do it because a fixed epsilon chosen because it “looks small” could actually be way too large when the numbers being compared are very small as well. The comparison would return “true” for numbers that are quite different. And when the numbers are very large, … Read more
The simple answer is because 3*0.1 != 0.3 due to quantization (roundoff) error (whereas 4*0.1 == 0.4 because multiplying by a power of two is usually an “exact” operation). Python tries to find the shortest string that would round to the desired value, so it can display 4*0.1 as 0.4 as these are equal, but … Read more
This blogpost contains an example, fairly foolproof implementation, and detailed theory behind it 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 … 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
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