floating-accuracy

I encountered negative zero in output from python; it's created for example as follows: k = 0.0 print(-k) The output will be -0.0 . However, when I compare the -k to 0.0 for equality, it yields True. Is there any difference between 0.0 and -0.0 (I don't care that they presumably have different internal representation; I only care about their behavior in a program.) Is there any hidden traps I should be aware of? Check out : −0 (number) in Wikipedia Basically IEEE does actually define a negative zero And by this definition for all purposes : -0.0 == +0.0 == 0 I agree with aaronasterling that -0

My code: a = '2.3' I wanted to display a as a floating point value. Since a is a string, I tried: float(a) The result I got was : 2.2999999999999998 I want a solution for this problem. Please, kindly help me. I was following this tutorial . Jon Skeet I think it reflects more on your understanding of floating point types than on Python. See my article about floating point numbers (.NET-based, but still relevant) for the reasons behind this "inaccuracy". If you need to keep the exact decimal representation, you should use the decimal module . This is not a drawback of python, rather, it is a

Possible Duplicate: Why are these numbers not equal? The below expression, which evaluates to 0.1, is considered larger than 0.1. > round(1740/600,0) - 1740/600 [1] 0.1 > (round(1740/600,0) - 1740/600) <= 0.1 [1] FALSE //???!!??? > (round(1740/600,0) - 1740/600) <= 0.1000000000000000000000000000000000000001 [1] TRUE Thinking that the issue might be due to rounding I tried this with the same result: > 3 - 2.9 [1] 0.1 > (3 - 2.9) <=0.1 [1] FALSE So, what gives and how do I fix it without fudging the cutoff? Michael Borgwardt From the Floating-Point Guide : Why don’t my numbers, like 0.1 + 0.2

In my course, I am told: Continuous values are represented approximately in memory, and therefore computing with floats involves rounding errors. These are tiny discrepancies in bit patterns; thus the test e==f is unsafe if e and f are floats. Referring to Java. Is this true? I've used comparison statements with double s and float s and have never had rounding issues. Never have I read in a textbook something similar. Surely the virtual machine accounts for this? It is true. It is an inherent limitation of how floating point values are represented in memory in a finite number of bits. This

Comparing two floating point number by something like a_float == b_float is looking for trouble since a_float / 3.0 * 3.0 might not be equal to a_float due to round off error. What one normally does is something like fabs(a_float - b_float) < tol . How does one calculate tol ? Ideally tolerance should be just larger than the value of one or two of the least significant figures. So if the single precision floating point number is use tol = 10E-6 should be about right. However this does not work well for the general case where a_float might be very small or might be very large. How does one

In Java the floating point arithmetic is not represented precisely. For example this java code: float a = 1.2; float b= 3.0; float c = a * b; if(c == 3.6){ System.out.println("c is 3.6"); } else { System.out.println("c is not 3.6"); } Prints "c is not 3.6". I'm not interested in precision beyond 3 decimals (#.###). How can I deal with this problem to multiply floats and compare them reliably? bobah It's a general rule that floating point number should never be compared like (a==b) , but rather like (Math.abs(a-b) < delta) where delta is a small number. A floating point value having fixed