Unfortunately, bc doesn’t support scientific notation. However, it can be translated into a format that bc can handle, using extended regex as per POSIX in sed: sed -E ‘s/([+-]?[0-9.]+)[eE]\+?(-?)([0-9]+)/(\1*10^\2\3)/g’ <<<“$value” you can replace the “e” (or “e+”, if the exponent is positive) with “*10^”, which bc will promptly understand. This works even if the exponent … Read more
I suspect you’re using 32-bit x86, the only common architecture subject to excess precision. In C, expressions of type float and double are actually evaluated as float_t or double_t, whose relationships to float and double are reflected in the FLT_EVAL_METHOD macro. In the case of x86, both are defined as long double because the fpu … Read more
Short version: The reason it’s different is because pandas uses bottleneck (if it’s installed) when calling the mean operation, as opposed to just relying on numpy. bottleneck is presumably used since it appears to be faster than numpy (at least on my machine), but at the cost of precision. They happen to match for the … Read more
Floating point numbers can’t handle decimals correctly in all cases. Check out http://en.wikipedia.org/wiki/Floating-point_number#Accuracy_problems http://www.mredkj.com/javascript/nfbasic2.html
IEEE floating point is binary, not decimal. There is no fixed length binary fraction that is exactly 0.1, or any multiple thereof. It is a repeating fraction, like 1/3 in decimal. Please read What Every Computer Scientist Should Know About Floating-Point Arithmetic Other options besides a Decimal class are using Common Lisp or Python 2.6 … Read more
Binary floating point math is like this. In most programming languages, it is based on the IEEE 754 standard. The crux of the problem is that numbers are represented in this format as a whole number times a power of two; rational numbers (such as 0.1, which is 1/10) whose denominator is not a power … Read more
It is true. It is an inherent limitation of how floating point values are represented in memory in a finite number of bits. This program, for instance, prints “false”: public class Main { public static void main(String[] args) { double a = 0.7; double b = 0.9; double x = a + 0.1; double y … Read more
The simple answer is because 3*0.1 != 0.3 due to quantization (roundoff) error (whereas 4*0.1 == 0.4 because multiplying by a power of two is usually an “exact” operation). Python tries to find the shortest string that would round to the desired value, so it can display 4*0.1 as 0.4 as these are equal, but … Read more
From The Floating-Point Guide: This is a bad way to do it because a fixed epsilon chosen because it “looks small” could actually be way too large when the numbers being compared are very small as well. The comparison would return “true” for numbers that are quite different. And when the numbers are very large, … Read more
This is very similiar to: SELECT SUM(…) is non-deterministic when adding the column-values of datatype float. The problem is that with inaccurate datatype (FLOAT/REAL) the order of of arithmetic operations on floating point matters. Demo from connect: DECLARE @fl FLOAT = 100000000000000000000 DECLARE @i SMALLINT = 0 WHILE (@i < 100) BEGIN SET @fl = … Read more