I know `UIKit`

uses `CGFloat`

because of the resolution independent coordinate system.

But every time I want to check if for example `frame.origin.x`

is `0`

it makes me feel sick:

```
if (theView.frame.origin.x == 0) {
// do important operation
}
```

Isn't `CGFloat`

vulnerable to false positives when comparing with `==`

, `<=`

, `>=`

, `<`

, `>`

?

It is a floating point and they have unprecision problems: `0.0000000000041`

for example.

Is `Objective-C`

handling this internally when comparing or can it happen that a `origin.x`

which reads as zero does not compare to `0`

as true?

## Best Solution

First of all, floating point values are not "random" in their behavior. Exact comparison can and does make sense in plenty of real-world usages. But if you're going to use floating point you need to be aware of how it works. Erring on the side of assuming floating point works like real numbers will get you code that quickly breaks. Erring on the side of assuming floating point results have large random fuzz associated with them (like most of the answers here suggest) will get you code that appears to work at first but ends up having large-magnitude errors and broken corner cases.

First of all, if you want to program with floating point, you should read this:

What Every Computer Scientist Should Know About Floating-Point Arithmetic

Yes, read all of it. If that's too much of a burden, you should use integers/fixed point for your calculations until you have time to read it. :-)

Now, with that said, the biggest issues with exact floating point comparisons come down to:

The fact that lots of values you may write in the source, or read in with

`scanf`

or`strtod`

,do not existas floating point values and get silently converted to the nearest approximation. This is what demon9733's answer was talking about.The fact that many results get rounded due to not having enough precision to represent the actual result. An easy example where you can see this is adding

`x = 0x1fffffe`

and`y = 1`

as floats. Here,`x`

has 24 bits of precision in the mantissa (ok) and`y`

has just 1 bit, but when you add them, their bits are not in overlapping places, and the result would need 25 bits of precision. Instead, it gets rounded (to`0x2000000`

in the default rounding mode).The fact that many results get rounded due to needing infinitely many places for the correct value. This includes both rational results like 1/3 (which you're familiar with from decimal where it takes infinitely many places) but also 1/10 (which also takes infinitely many places in binary, since 5 is not a power of 2), as well as irrational results like the square root of anything that's not a perfect square.

Double rounding. On some systems (particularly x86), floating point expressions are evaluated in higher precision than their nominal types. This means that when one of the above types of rounding happens, you'll get two rounding steps, first a rounding of the result to the higher-precision type, then a rounding to the final type. As an example, consider what happens in decimal if you round 1.49 to an integer (1), versus what happens if you first round it to one decimal place (1.5) then round that result to an integer (2). This is actually one of the nastiest areas to deal with in floating point, since the behaviour of the compiler (especially for buggy, non-conforming compilers like GCC) is unpredictable.

Transcendental functions (

`trig`

,`exp`

,`log`

, etc.) are not specified to have correctly rounded results; the result is just specified to be correct within one unit in the last place of precision (usually referred to as1ulp).When you're writing floating point code, you need to keep in mind what you're doing with the numbers that could cause the results to be inexact, and make comparisons accordingly. Often times it will make sense to compare with an "epsilon", but that epsilon should be based on the

magnitude of the numbers you are comparing, not an absolute constant. (In cases where an absolute constant epsilon would work, that's strongly indicative that fixed point, not floating point, is the right tool for the job!)Edit:In particular, a magnitude-relative epsilon check should look something like:Where

`FLT_EPSILON`

is the constant from`float.h`

(replace it with`DBL_EPSILON`

for`double`

s or`LDBL_EPSILON`

for`long double`

s) and`K`

is a constant you choose such that the accumulated error of your computations is definitely bounded by`K`

units in the last place (and if you're not sure you got the error bound calculation right, make`K`

a few times bigger than what your calculations say it should be).Finally, note that if you use this, some special care may be needed near zero, since

`FLT_EPSILON`

does not make sense for denormals. A quick fix would be to make it:and likewise substitute

`DBL_MIN`

if using doubles.