Testing floating point equality

Question

Is there a function to test floating point approximate equality in python? Something like,

 def approx_equal(a, b, tol):      return abs(a - b) < tol 

My use case is similar to how Google's C++ testing library, gtest.h, defines EXPECT_NEAR.

Here is an example:

def bernoulli_fraction_to_angle(fraction):     return math.asin(sqrt(fraction)) def bernoulli_angle_to_fraction(angle):     return math.sin(angle) ** 2 def test_bernoulli_conversions():     assert(approx_equal(bernoulli_angle_to_fraction(pi / 4), 0.5, 1e-4))     assert(approx_equal(               bernoulli_fraction_to_angle(bernoulli_angle_to_fraction(0.1)),                 0.1, 1e-4)) 

Answer 1

• For comparing numbers, there is math.isclose.
• For comparing numbers or arrays, there is numpy.allclose.
• For testing numbers or arrays, there is numpy.testing.assert_allclose

Answer 2

Another approach is to compute the relative change (or relative difference) of the two numbers, which is "used to compare two quantities while taking into account the 'sizes' of the things being compared". The two formulas mentioned in the Wikipedia article could be used in comparisons like the following in Python, which also handle cases where one or both of the values being compared are zero:

def approx_equal(a, b, tol):     return abs(a-b) <= max(abs(a), abs(b)) * tol  def approx_equal(a, b, tol):     return abs(a-b) <= (abs(a)+abs(b))/2 * tol 

The calculated value in either case is a unitless fraction. In the first case the baseline value is the maximum absolute value of the two numbers and in the second it's their mean absolute value. The article discusses each in more detail as well as their pros and cons. The latter can turned into a percentage difference if multiplied by 100 before the comparison (with tol becoming a percentage value). Note that the article suggests that if the changing value "is a percentage itself, it is better to talk about its change by using percentage points" — i.e. absolute change.

Both of these methods (obviously) require a little more computation than simply taking the absolute value of the difference of the two numbers, which might be a consideration.