floating-point-precision

In JavaScript, I have a number which is 21 digits, and I want to parse it. Does a parseDouble method exist in JavaScript? user2864740 It's not possible to natively deal with a 21-digit precision number in JavaScript. JavaScript only has one kind of number: "number", which is a IEEE-754 Double Precision ("double") value. As such, parseFloat in JavaScript is the equivalent of a "parse double" in other languages. However, a number/"double" only provides 16 significant digits (decimal) of precision and so reading in a number with 21-digits will lose the 5 least significant digits 1 . For more

In C++ (and C), a floating point literal without suffix defaults to double , while the suffix f implies a float . But what is the suffix to get a long double ? Without knowing, I would define, say, const long double x = 3.14159265358979323846264338328; But my worry is that the variable x contains fewer significant bits of 3.14159265358979323846264338328 than 64, because this is a double literal. Is this worry justified? Vlad from Moscow From the C++ Standard The type of a floating literal is double unless explicitly specified by a suffix. The suffixes f and F specify float, the suffixes l and

I have proceeded to state when I need to turn IEEE-754 single and double precision numbers into strings with base 10 . There is FXTRACT instruction available, but it provides only exponent and mantissa for base 2, as the number calculation formula is: value = (-1)^sign * 1.(mantissa) * 2^(exponent-bias) If I had some logarithmic instructions for specific bases, I would be able to change base of 2 exponent - bias part in expression, but currently I don't know what to do. I was also thinking of using standard rounded conversion into integer, but it seems to be unusable as it doesn't offer

I am doing high precision scientific computations. In looking for the best representation of various effects, I keep coming up with reasons to want to get the next higher (or lower) double precision number available. Essentially, what I want to do is add one to the least significant bit in the internal representation of a double. The difficulty is that the IEEE format is not totally uniform. If one were to use low-level code and actually add one to the least significant bit, the resulting format might not be the next available double. It might, for instance, be a special case number such as

I've come across two different precision formulas for floating-point numbers. ⌊(N-1) log 10 (2)⌋ = 6 decimal digits (Single-precision) and N log 10 (2) ≈ 7.225 decimal digits (Single-precision) Where N = 24 Significant bits (Single-precision) The first formula is found at the top of page 4 of " IEEE Standard 754 for Binary Floating-Point Arithmetic " written by, Professor W. Kahan . The second formula is found on the Wikipedia article " Single-precision floating-point format " under section IEEE 754 single-precision binary floating-point format: binary32 . For the first formula, Professor W.

What's going on here: #include <stdio.h> #include <math.h> int main(void) { printf("17^12 = %lf\n", pow(17, 12)); printf("17^13 = %lf\n", pow(17, 13)); printf("17^14 = %lf\n", pow(17, 14)); } I get this output: 17^12 = 582622237229761.000000 17^13 = 9904578032905936.000000 17^14 = 168377826559400928.000000 13 and 14 do not match with wolfram alpa cf: 12: 582622237229761.000000 582622237229761 13: 9904578032905936.000000 9904578032905937 14: 168377826559400928.000000 168377826559400929 Moreover, it's not wrong by some strange fraction - it's wrong by exactly one! If this is down to me reaching