ieee-754

In C++, I have a bigint class that can hold an integer of arbitrary size. I'd like to convert large float or double numbers to bigint. I have a working method, but it's a bit of a hack. I used IEEE 754 number specification to get the binary sign, mantissa and exponent of the input number. Here is the code (Sign is ignored here, that's not important): float input = 77e12; bigint result; // extract sign, exponent and mantissa, // according to IEEE 754 single precision number format unsigned int *raw = reinterpret_cast<unsigned int *>(&input); unsigned int sign = *raw >> 31; unsigned int exponent

This question already has an answer here: Is floating point math broken? 31 answers I never understand exactly what's going on with JavaScript when I do mathematical operations on floating point numbers. I've been down-right fearful of using decimals, to the point where I just avoid them when at all possible. However, if I knew what was going on behind the scenes when it comes to the IEEE 754 standard, then I would be able to predict what would happen; with predictability, I'll be more confident and less fearful. Could someone give me a simple explanation ( as simple as explaining binary

I'd like to play with those traps for educational purpose. A common problem with the default behavior in numerical calculus is that we "miss" the Nan (or +-inf) that appeared in a wrong operation. Default behavior is propagation through the computation, but some operation (like comparisons) break the chain and loose the Nan, and the rest of the treatment continue without acknowledging the singularity in previous steps of the algorithm. Sometimes we have ways to react to this kind of event : prolongating a function ("0/0 = 12 in my case"), or in time-domain simulation throwing the step away and

I'm interested if Java is using IEEE 754 standard for implementing its floating point arithmetic. Here I saw this kind of thing in documentation: operation defined in IEEE 754-2008 As I understand positive side of IEEE 754 is to increase precision of floating point arithmetics so if I'll use double or float in Java would presision of computations be same as in BigDecimal ? And if not than what's the point of using IEEE 754 standard in Math class? I'm interested if Java is using IEEE 754 standard for implementing it's floating point arithmetic. IEEE-754 defines standards for multiple floating

What are some good do-s and don't-s for floating point arithmetic (IEEE754 in case there's confusion) to ensure good numerical stability and high accuracy in your results? I know a few like don't subtract quantities of similar magnitude, but I'm curious what other good rules are out there. First, enter with the notion that floating point numbers do NOT necessarily follow the same rules as real numbers... once you have accepted this, you will understand most of the pitfalls. Here's some rules/tips that I've always followed: NEVER compare a floating point number to zero or anything else for that

The following C function is from fastapprox project. static inline float fasterlog2 (float x) { union { float f; uint32_t i; } vx = { x }; float y = vx.i; y *= 1.1920928955078125e-7f; return y - 126.94269504f; } Could some experts here explain why the exponent bias used in the above code is 126.94269504 instead of 127? Is it more accurate bias value? In the project you linked, they included a Mathematica notebook with an explanation of their algorithms, which includes the "mysterious" -126.94269 value. If you need a viewer, you can get one from the Mathematica website for free. Edit: Since I'm

I am looking for a reference implementation of IEEE-754 operations. Is there such a thing? I believe the C libraries SoftFloat and fdlibm are suitable for what you are looking for. Others include Linux (GNU libc, glibc ) or *BSD libc's math functions . Finally, CRlibm should also be of interest to you. Ulrich Drepper has a interesting look at different math libraries , that might be also worth reading through. I must disappoint you: There is practically none. While technically there are IEEE-754 compliant systems because they do not implement non-required features described in the standard, a