np.in1d support tolerance parameter for float comparisons

I would like to add a tolerance parameter to np.in1d to support robust float comparisons.

Original function: https://github.com/numpy/numpy/blob/master/numpy/lib/arraysetops.py#L305

Here is one example that would require an error-tolerant comparison:

a = np.array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7 ], dtype=np.float32)
b = np.array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7 ], dtype=np.float64)
print(np.in1d(a.astype(np.float64), b))
#array([False, False, False, False,  True, False, False], dtype=bool)

What do you guys think of this suggestion?

[jaimefrio]

This seems to work:

import numpy as np

def in1d(a, b, tol=1e-6):
    a = np.unique(a)
    intervals = np.empty(2*a.size, float)
    intervals[::2] = a - tol
    intervals[1::2] = a + tol
    overlaps = intervals[:-1] >= intervals[1:]
    overlaps[1:] = overlaps[1:] | overlaps[:-1]
    keep = np.concatenate((~overlaps, [True]))
    intervals = intervals[keep]
    return np.searchsorted(intervals, b, side='right') & 1 == 1

a = np.array([1, 1.1, 1.3, 1.6, 2.0, 2.5, 3, 3.4, 3.8])
b = np.linspace(0, 10, 101)
c = (((b >= 0.8) & (b < 2.2)) |
     ((b >= 2.3) & (b < 2.7)) |
     ((b >= 2.8) & (b < 4.0)))
assert np.all(in1d(a, b, tol=0.2) == c)

It defines inclusion as being in [a[i] - tol, a[i] + tol), to get the interval to be closed (or open) on both ends you would need to either make two calls to np.searchsorted with different side kwargs or do something (untested!!!) like:

indices = np.searchsorted(intervals, b)
ret = indices & 1 == 1
missed_ret = b[~ret] == a[indices[~ret]]
ret[~ret] |= missed_ret
return ret

[mhvk]

I’m not sure the other functions are all that ambiguous. One more general approach might be to have the ability to pass in a function that is used to assert equality. It might be __eq__ by default, but could then be set to np.isclose (possibly with partial with different absolute and relative tolerances).