On 27 January 2015 at 13:08, Steven D'Aprano <steve@pearwood.info> wrote:
Symmetry and asymmetry of "close to" is a side-effect of the way you calculate the fuzzy comparison. In real life, "close to" is always symmetric because distance is the same whether you measure from A to B or from B to A. The distance between two numbers is their difference, which is another way of saying the error between them:
delta = abs(x - y)
(delta being the traditional name for this quantity in mathematics), and obviously delta doesn't depend on the order of x and y.
Asymmetry is bad, because it is rather surprising and counter-intuitive
that "x is close to y", but "y is not close to x". It may also be bad in a practical sense, because people will forget which order they need to give x and y and will give them in the wrong order. I started off with an approx_equal function in test_statistics that was symmetric, and I could never remember which way the arguments went.
Time permitting, over the next day or so I'll draw up some diagrams to
show how each of these tactics change what counts as close or not close.
If you consider the comparsion to be: abs(x-y) <= rel_tol * ref where "ref" is your "reference" value, then all of these are questions about what "ref" is. Possibilities include: * ref = abs(x) (asymmetric version, useful for comparing against a known figure) * ref = max(abs(x),abs(y)) (symmetric version) * ref = abs(x)+abs(y) or (abs(x)+abs(y))/2 (alternate symmetric version) * ref = zero_tol / rel_tol (for comparisons against zero) * ref = abs_tol/rel_tol (for completeness) If you're saying:
z = 1.0 - sum([0.1]*10) >>> z == 0 False is_close(0.0, z) True
your "reference" value is probably really "1.0" or "0.1" since those are the values you're working with, but neither of those values are derivable from the arguments provided to is_close(). Assuming x,y are non-negative and is_close(x,y,rel_tol=r): ref = x: -rx <= y-x <= rx ref = max(x,y): -rx <= y-x <= ry ref = (x+y)/2: -r*(x+y)/2 <= y-x <= r*(x+y)/2 If you set r and x as a constant, then the amounts y can be (below, above) x for the cases above are: rx, rx rx, rx/(1-r) rx/(1+r/2), rx/(1-r/2) Since r>0, 1-r != 1, and 1+r/2 != 1-r/2, so these each give slightly different ranges for a valid y. They're pretty trivial differences though; eg r=1e-8 and x=10 gives: rx = 1e-7 rx/(1-r) = 1.00000001e-07 rx/(1-r/2) = 1.000000005e-07 rx/(1+r/2) = 0.999999995e-07 If you're looking at 10% margins for a nominally 100 Ohm resistor (r=0.1, x=100), that'd translate to deltas of: rx = 10.0 rx/(1-r) = 11.11 rx/(1-r/2) = 10.526 rx/(1+r/2) = 9.524 Having an implementation like: def is_close(a, b=None, tol=1e-8, ref=None): assert (a != 0 and b != 0) or ref is not None if b is None: assert ref is not None b = ref if ref is None: ref = abs(a)+abs(b) return abs(a-b) <= tol*ref might give you the best of all worlds -- it would let you say things like:
is_close(1.0, sum([0.1]*10)) True
is_close(11, ref=10, tol=0.1) True
n = 26e10 a = n - sum([n/6]*6) b = n - sum([n/7]*7) a, b (-3.0517578125e-05, 0.0) is_close(a, b, ref=n) True is_close(a, b, ref=1) False is_close(a, b) AssertionError
and get reasonable looking results, I think? (If you want to use an absolute tolerance, you just specify ref=1, tol=abs_tol). An alternative thought: rather than a single "is_close" function, maybe it would make sense for is_close to always be relative, and just provide a separate function for absolute comparisons, ie: def is_close(a, b, tol=1e-8): assert a != 0 and b != 0 # or assert (a==0) == (b==0) return abs(a-b) <= tol*(a+b) def is_close_abs(a,b, tol=1e-8): return abs(a-b) <= tol def is_near_zero(a, tol=1e-8): return abs(a) <= tol Then you'd use is_close() when you wanted something symmetric and easy, and were mopre interested in rough accuracy than absolute precision, and if you wanted to do a 10% resistor check you'd either say: is_close_abs(r, 100, tol=10) or is_near_zero(a-100, tol=10) If you had a sequence of numbers and wanted to do both relative comparisons (first n significant digits match) and absolute comparisons you'd just have to say: for a in nums: assert is_close(a, b) or is_close_abs(a, b) which doesn't seem that onerous. Cheers, aj -- Anthony Towns <aj@erisian.com.au>