Equality operators for floats that are almost equal. Smooths out rounding errors and floating point precision issues.

import Equalish

# As a macro
assert is_eq_ish(0.5, 0.50000001)
#=> true

# As a guard
def foo(a, b) when is_eq_ish(a, b) do
  ...
end

Tolerance

Two numbers are considered equal if they are no further apart than the tolerance. The default tolerance is 1.0e-5.

You can change this in your config file with:

config :equalish,
  tolerance: 1.0e-5 # <- Change this

This is a compile-time setting, because guards cannot read config while your program runs:

• Set it in config/config.exs (or an env-specific config), not in config/runtime.exs. Changing it there recompiles everything that uses these guards.
• A different value in runtime.exs is ignored by mix run and iex -S mix, and makes a release fail to boot.

You can always pass a tolerance as the third argument instead.

The tolerance is a fixed amount, not a percentage. This works well for numbers of everyday size, but not for very large or very small ones:

• is_eq_ish(1.0e12 + 0.1 + 0.2, 1.0e12 + 0.3) is false, because rounding errors at that size are bigger than 1.0e-5.
• is_eq_ish(1.0e-9, 9.0e-6) is true, even though one is 9000 times the other.

Examples below sometimes use the following tolerances as an example:

@lax 0.1
@strict 0.000000000000001

These are not built into the library, and you must define them yourself.