Floating-point is deterministic. The same floating-point operations, run on the same hardware, always produces the same result. There is no black magic, noise, randomness, fuzzing, or any of the other things that people commonly attribute to floating-point. The tooth fairy does not show up, take the low bits of your result, and leave a quarter … Read more
Using floating point numbers, 0.0 / 0.0 isn’t a “divide by zero” error; it results in NaN. This C program prints -nan: #include <stdio.h> int main() { float x = 0.0 / 0.0; printf(“%f\n”, x); return 0; } In terms what NaN looks like to the computer, two “invalid” numbers are reserved for “signaling” and … Read more
FWIW, with gcc-4.2 on MacOS X 10.6 and -O3 compiler flags, x = x * x; and y = pow(y, 2); result in the same assembly code: #include <cmath> void test(double& x, double& y) { x = x * x; y = pow(y, 2); } Assembles to: pushq %rbp movq %rsp, %rbp movsd (%rdi), %xmm0 … Read more
You can write assert(x*x >= 0.f) as a compile-time promise instead of a runtime check as follows in GNU C: #include <cmath> float test1 (float x) { float tmp = x*x; if (!(tmp >= 0.0f)) __builtin_unreachable(); return std::sqrt(tmp); } (related: What optimizations does __builtin_unreachable facilitate? You could also wrap if(!x)__builtin_unreachable() in a macro and call … Read more
In Java, when you type a decimal number as 3.6, its interpreted as a double. double is a 64-bit precision IEEE 754 floating point, while floatis a 32-bit precision IEEE 754 floating point. As a float is less precise than a double, the conversion cannot be performed implicitly. If you want to create a float, … Read more
This has to do with how is works. It checks for references instead of value. It returns True if either argument is assigned to the same object. In this case, they are different instances; float(0) and float(0) have the same value ==, but are distinct entities as far as Python is concerned. CPython implementation also … Read more
First, a paper you should consider reading, if you want to understand floating point foibles better: “What Every Computer Scientist Should Know About Floating Point Arithmetic,” http://www.validlab.com/goldberg/paper.pdf And now to some meat. The following code is bare bones, and attempts to produce an IEEE-754 single precision float from an unsigned int in the range 0 … Read more
I usually think about natural vs artificial quantities. Natural quantities are things like weight, height and time. These will never be measured absolutely accurately, and there’s rarely any idea of absolutely exact arithmetic on it: you shouldn’t generally be adding up heights and then making sure that the result is exactly as expected. Use double … Read more
dtoa.c contains two main functions: dtoa(), which converts a double to string, and strtod(), which converts a string to a double. It also contains a lot of support functions, most of which are for its own implementation of arbitrary-precision arithmetic. dtoa.c’s claim to fame is getting these conversions right, and that can only be done, … Read more
The other answers don’t exactly explain what’s going on here, so this is the basic problem: When you write blackKey.center.x, the blackKey.center and center.x both look like struct member accesses, but they’re actually completely different things. blackKey.center is a property access, which desugars to something like [blackKey center], which in turn desugars to something like … Read more