I believe __STDC_IEC_559__ relies on some library features and can’t be defined solely by the compiler. See this post for some information. This is not uncommon for C — the compiler and the C library must sometimes cooperate in order to implement the entire standard. What you’re asking depends on the compiler. I think you … Read more
Just to make sure we’re on the same page, G is the most significant bit of the three, R comes next and S can be thought of as the least significant bit because its value partially represents the even less significant bits that have been truncated in the calculations. These three bits are only used … Read more
It is a general rule how 64-bit floating point numbers are compared according to IEEE 754 (not Scala or even Java related, see NaN): double n1 = Double.NaN; double n2 = Double.NaN; System.out.println(n1 == n2); //false The idea is that NaN is a marker value for unknown or indeterminate. Comparing two unknown values should always … Read more
I am going to assume IEEE 754 binary floating point arithmetic, with float 32 bit and double 64 bit. In general, there is no advantage to doing the calculation in double, and in some cases it may make things worse through doing two rounding steps. Conversion from float to double is exact. For the infinite, … Read more
Actually you have an easier way to achieve this in C++. From the C++ standard 18.2.1.1 the class numeric_limits exists within std. In order to access said static member you simply do this: std::numeric_limits<double>::is_iec559; Or: std::numeric_limits<float>::is_iec559; Which should return true if IEEE 754 is in use, false otherwise. As an alternative method, the second part … Read more
Check out the article on “What every computer scientist should know about floating point arithmetic”
You don’t even need to assume IEEE. C89 says in 3.1.2.5: The set of values of the type float is a subset of the set of values of the type double And every other C and C++ standard says equivalent things. As far as I know, NaNs and infinities are “values of the type float“, … Read more
A NaN is returned (under IEEE 754) in order to continue a computation when a truly undefined (intermediate) result has been obtained. An infinity is returned in order to continue a computation after an overflow has occurred. Thus the behaviour Math.sqrt(Double.NEGATIVE_INFINITY); // NaN is specified because it is known (easily and quickly) that an undefined … Read more
You can Use Float.intBitsToFloat() and Float.floatToIntBits() to convert them to and from primitive float values. If you can live with truncated precision (as opposed to rounding) the conversion should be possible to implement with just a few bit shifts. I have now put a little more effort into it and it turned out not quite … Read more
No, an IEEE 754 double-precision floating point number is always 64 bits. Similarly, a single-precision float is always 32 bits. If your question is about C# and/or .NET specifically (as your tag would indicate), all of the data type sizes are fixed, independent of your system architecture. This is the same as Java, but different … Read more