IEEE 754 basics First let’s review the basics of IEEE 754 numbers are organized. We’ll focus on single precision (32-bit), but everything can be immediately generalized to other precisions. The format is: 1 bit: sign 8 bits: exponent 23 bits: fraction Or if you like pictures: Source. The sign is simple: 0 is positive, and … 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.
Other than flawed Pentiums, any x86 or x64-based CPU is using IEEE 754 as their floating-point arithmetic standard. Here are a brief overview of the FPA standards and their adoptions. IEEE 754: Intel x86, and all RISC systems (IBM Power and PowerPC, Compaq/DEC Alpha, HP PA-RISC, Motorola 68xxx and 88xxx, SGI (MIPS) R-xxxx, Sun SPARC, … Read more
The problem is that .NET will always round a double to 15 significant decimal digits before applying your formatting, regardless of the precision requested by your format and regardless of the exact decimal value of the binary number. I’d guess that the Visual Studio debugger has its own format/display routines that directly access the internal … Read more
The MSDN documentation is nonsensical and wrong. Bad concept. Binary-floating-point format does not have any precision in decimal digits because it has no decimal digits at all. It represents numbers with a sign, a fixed number of binary digits (bits), and an exponent for a power of two. Wrong on the high end. The floating-point … Read more
Just what is this “hint” to the runtime? As you conjecture, the compiler tracks whether a conversion to double or float was actually present in the source code, and if it was, it always inserts the appropriate conv opcode. Does the C# spec stipulate that an explicit cast to float causes the insertion of a … Read more
An IEEE double has 53 significant bits (that’s the value of DBL_MANT_DIG in <cfloat>). That’s approximately 15.95 decimal digits (log10(253)); the implementation sets DBL_DIG to 15, not 16, because it has to round down. So you have nearly an extra decimal digit of precision (beyond what’s implied by DBL_DIG==15) because of that. The nextafter() function … Read more
The accepted answer is 100% without question WRONG. Not halfway wrong or even slightly wrong. I fear this issue is going to confuse and mislead programmers for a long time to come when this question pops up in searches. NaN is designed to propagate through all calculations, infecting them like a virus, so if somewhere … Read more
The Wikipedia page on it is a good place to start. To sum up: float is represented in 32 bits, with 1 sign bit, 8 bits of exponent, and 23 bits of the significand (or what follows from a scientific-notation number: 2.33728*1012; 33728 is the significand). double is represented in 64 bits, with 1 sign … Read more
I know of no way to way to make normal floating points deterministic in .net. The JITter is allowed to create code that behaves differently on different platforms(or between different versions of .net). So using normal floats in deterministic .net code is not possible. The workarounds I considered: Implement FixedPoint32 in C#. While this is … Read more