clippy::float_cmp: strict comparison of `f32` or `f64`

warning: strict comparison of `f32` or `f64`
  --> main.rs:11:17
   |
11 | let are_equal = x == y;
   |                 ^^^^^^ help: consider comparing them within some margin of error: `(x - y).abs() < error_margin`
   |
   = help: for further information visit https://rust-lang.github.io/rust-clippy/stable/index.html#float_cmp
   = note: `-W clippy::float-cmp` implied by `-W clippy::pedantic`

let a: f64 = 1000.1;
let b: f64 = 0.2;
let x = a + b;
let y = 1000.3; // Expected value.

// Actual value: 1000.3000000000001
println!("{x}");

let are_equal = x == y;
println!("{are_equal}"); // false

let a: f64 = 1000.1;
let b: f64 = 0.2;
let x = a + b;
let y = 1000.3; // Expected value.

const ALLOWED_ERROR_VEHICLE_LENGTH_CM: f64 = 0.1;
let within_tolerance = (x - y).abs() < ALLOWED_ERROR_VEHICLE_LENGTH_CM;
println!("{within_tolerance}"); // true

[lints.clippy]
float_cmp = "warn"

#![warn(clippy::float_cmp)]

cargo clippy -- -W clippy::float-cmp

Clippy's own documentation

What it does

Checks for (in-)equality comparisons on floating-point values (apart from zero), except in functions called *eq* (which probably implement equality for a type involving floats).

Why is this bad?

Floating point calculations are usually imprecise, so asking if two values are exactly equal is asking for trouble because arriving at the same logical result via different routes (e.g. calculation versus constant) may yield different values.

Example

let a: f64 = 1000.1;
let b: f64 = 0.2;
let x = a + b;
let y = 1000.3; // Expected value.

// Actual value: 1000.3000000000001
println!("{x}");

let are_equal = x == y;
println!("{are_equal}"); // false

The correct way to compare floating point numbers is to define an allowed error margin. This may be challenging if there is no “natural” error margin to permit. Broadly speaking, there are two cases:

1. If your values are in a known range and you can define a threshold for “close enough to be equal”, it may be appropriate to define an absolute error margin. For example, if your data is “length of vehicle in centimeters”, you may consider 0.1 cm to be “close enough”.
2. If your code is more general and you do not know the range of values, you should use a relative error margin, accepting e.g. 0.1% of error regardless of specific values.

For the scenario where you can define a meaningful absolute error margin, consider using:

let a: f64 = 1000.1;
let b: f64 = 0.2;
let x = a + b;
let y = 1000.3; // Expected value.

const ALLOWED_ERROR_VEHICLE_LENGTH_CM: f64 = 0.1;
let within_tolerance = (x - y).abs() < ALLOWED_ERROR_VEHICLE_LENGTH_CM;
println!("{within_tolerance}"); // true

NOTE: Do not use f64::EPSILON - while the error margin is often called “epsilon”, this is a different use of the term that is not suitable for floating point equality comparison. Indeed, for the example above using f64::EPSILON as the allowed error would return false.

For the scenario where no meaningful absolute error can be defined, refer to the floating point guide for a reference implementation of relative error based comparison of floating point values. MIN_NORMAL in the reference implementation is equivalent to MIN_POSITIVE in Rust.

From the Clippy lint list (0.1.99), part of the Rust project, MIT or Apache-2.0. Official entry.

Related lints

• too_many_linesChecks for functions with a large amount of lines
• missing_errors_docChecks the doc comments of publicly visible functions that return a Result type and warns if there is no # Errors section
• must_use_candidateChecks for public functions that have no #[must_use] attribute, but return something not already marked must-use, have no mutable arg and mutate no statics
• explicit_iter_loopChecks for loops on x.iter() where &x will do, and suggests the latter
• filter_map_nextcalled `filter_map(..).next()` on an `Iterator`
• flat_map_optionused `flat_map` where `filter_map` could be used instead
• fn_params_excessive_boolsChecks for excessive use of bools in function declarations
• format_collectuse of `format!` to build up a string from an iterator
• format_push_string`format!(..)` appended to existing `String`

All 847 Clippy lints · Rust compiler errors · Cargo.toml checker