You’re overflowing the capacity of JavaScript’s number type, see ยง8.5 of the spec for details. Those IDs will need to be strings. IEEE-754 double-precision floating point (the kind of number JavaScript uses) can’t precisely represent all numbers (of course). Famously, 0.1 + 0.2 == 0.3 is false. That can affect whole numbers just like it … Read more
Because floating point arithmetic != real number arithmetic. An illustration of the difference due to imprecision is, for some floats a and b, (a+b)-b != a. This applies to any language using floats. Since floating point are binary numbers with finite precision, there’s a finite amount of representable numbers, which leads accuracy problems and surprises … Read more
Since C++11, you may use nextafter to get next representable value in given direction: std::nextafter(1., 0.); // 0.99999999999999989 std::nextafter(1., 2.); // 1.0000000000000002 Demo
From this post: How to deal with floating point number precision in JavaScript? You have a few options: Use a special datatype for decimals, like decimal.js Format your result to some fixed number of significant digits, like this: (Math.floor(y/x) * x).toFixed(2) Convert all your numbers to integers
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
In Java, a – b is never equal to 0 if a != b. This is because Java mandates IEEE 754 floating point operations which support denormalized numbers. From the spec: In particular, the Java programming language requires support of IEEE 754 denormalized floating-point numbers and gradual underflow, which make it easier to prove desirable … 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
the correct way to test floats for ‘equality’ is: if(Math.abs(sectionID – currentSectionID) < epsilon) where epsilon is a very small number like 0.00000001, depending on the desired precision.
General (language agnostic) reason Since not all numbers can be represented exactly in IEEE floating point arithmetic (the standard that almost all computers use to represent decimal numbers and do math with them), you will not always get what you expected. This is especially true because some values which are simple, finite decimals (such as … Read more
First of all, floating point values are not “random” in their behavior. Exact comparison can and does make sense in plenty of real-world usages. But if you’re going to use floating point you need to be aware of how it works. Erring on the side of assuming floating point works like real numbers will get … Read more