# Crate float_cmp [−] [src]

float-cmp defines traits for approximate comparison of floating point types which have fallen
away from exact equality due to rounding and inaccuracies within the floating point unit of your
computer's processor. Implementations of these traits are provided for `f32`

and `f64`

types.

Two methods of comparison are provided. The first, `ApproxEqUlps`

and `ApproxOrdUlps`

, consider
two comparands equal if the number of representable floating point numbers between them is
below a specified bound. This works well in most cases.

The second method of comparison, `ApproxEqRatio`

, considers two comparands equal if the ratio of
the difference between them to the larger is below some specified bound. This handles many of
the cases that the former type of comparison doesn't handle well.

To help choose which comparison method to use, and to learn many suprising facts and oddities about floating point numbers, please refer to the following excellent website: https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/

The trait `Ulps`

is also defined as a prerequisite for `ApproxEqUlps`

and `ApproxOrdUlps`

.

Floating point operations must round answers to the nearest representable number. Multiple operations may result in an answer different from what you expect. In the following example, the assert will fail, even though the printed output says "0.45 == 0.45":

```
let a = 0.15_f32 + 0.15_f32 + 0.15_f32;
let b = 0.1_f32 + 0.1_f32 + 0.25_f32;
println!("{} == {}", a, b);
assert!(a==b) // Fails, because they are not exactly equal
```

This fails due to rounding and inaccuracies within the floating point unit of your processor.
With `ApproxEqUlps`

, we can get the answer we intend:

let a = 0.15_f32 + 0.15_f32 + 0.15_f32; let b = 0.1_f32 + 0.1_f32 + 0.25_f32; println!("{} == {}", a, b); assert!(a.approx_eq_ulps(&b,2)) // They are equal, within 2 ulps

We use the term ULP (units of least precision, or units in the last place) to mean the difference between two adjacent floating point representations (adjacent meaning that there is no floating point number between them). The size of an ULP (measured as a float) varies depending on the exponents of the floating point numbers in question, but this is quite useful, for it is the non-variation of a fixed epsilon (e.g. 0.0000001) which causes epsilon-based comparisons to so often fail with more extreme floating point values.

Fixed epsilon systems of comparison tend to work well only on numbers within certain ranges. It may seem reasonable to expect numbers that differ by less than 0.000001 to be equal, but this does not always work well (consider comparing -0.0000000028 to +0.00000097).

## Traits

ApproxEqRatio |
ApproxEqRatio is a trait for approximate equality comparisons bounding the ratio of the difference to the larger. |

ApproxEqUlps |
ApproxEqUlps is a trait for approximate equality comparisons, and is defined only for floating point types. |

ApproxOrdUlps |
ApproxOrdUlps is for sorting floating point values where approximate equality is considered equal. |

Ulps |
A trait for floating point numbers which computes the number of representable values or ULPs (Units of Least Precision) that separate the two given values. |