add cupy.setxor1d api

cupy/__init__.py

@@ -506,6 +506,7 @@ def base_repr(number, base=2, padding=0):  # NOQA (needed to avoid redefinition
 from cupy._logic.truth import intersect1d  # NOQA
 from cupy._logic.truth import isin  # NOQA
 from cupy._logic.truth import setdiff1d  # NOQA
+from cupy._logic.truth import setxor1d  # NOQA
 from cupy._logic.truth import union1d  # NOQA
 
 

cupy/_logic/truth.py

@@ -4,6 +4,14 @@
 from cupy import _util
 
 
+_setxorkernel = cupy._core.ElementwiseKernel(
+    'raw T X, int64 len',
+    'bool z',
+    'z = (i == 0 || X[i] != X[i-1]) && (i == len - 1 || X[i] != X[i+1])',
+    'setxorkernel'
+)
+
+
 def all(a, axis=None, out=None, keepdims=False):
     """Tests whether all array elements along a given axis evaluate to True.
 
@@ -255,6 +263,43 @@ def setdiff1d(ar1, ar2, assume_unique=False):
     return ar1[in1d(ar1, ar2, assume_unique=True, invert=True)]
 
 
+def setxor1d(ar1, ar2, assume_unique=False):
+    """Find the set exclusive-or of two arrays.
+
+    Parameters
+    ----------
+    ar1, ar2 : cupy.ndarray
+        Input arrays. They are flattend if they are not already 1-D.
+    assume_unique : bool
+        By default, False, i.e. input arrays are not unique.
+        If True, input arrays are assumed to be unique. This can
+        speed up the calculation.
+
+    Returns
+    -------
+    setxor1d : cupy.ndarray
+        Return the sorted, unique values that are in only one
+        (not both) of the input arrays.
+
+    See Also
+    --------
+    numpy.setxor1d
+
+    """
+    if not assume_unique:
+        ar1 = cupy.unique(ar1)
+        ar2 = cupy.unique(ar2)
+
+    aux = cupy.concatenate((ar1, ar2), axis=None)
+    if aux.size == 0:
+        return aux
+
+    aux.sort()
+
+    return aux[_setxorkernel(aux, aux.size,
+                             cupy.zeros(aux.size, dtype=cupy.bool_))]
+
+
 def union1d(arr1, arr2):
     """Find the union of two arrays.
 

docs/source/reference/set.rst

@@ -24,3 +24,4 @@ Boolean operations
    intersect1d
    isin
    setdiff1d
+   setxor1d

tests/cupy_tests/logic_tests/test_truth.py

@@ -183,6 +183,64 @@ def test_setdiff1d_bool_val(self, xp):
         return xp.setdiff1d(x, y)
 
 
+class TestSetxor1d:
+
+    @testing.for_all_dtypes()
+    @testing.numpy_cupy_array_equal()
+    def test_setxor1d_same_arrays(self, xp, dtype):
+        x = xp.array([1, 2, 3, 4, 5], dtype=dtype)
+        y = xp.array([1, 2, 3, 4, 5], dtype=dtype)
+        return xp.setxor1d(x, y, assume_unique=True)
+
+    @testing.for_all_dtypes()
+    @testing.numpy_cupy_array_equal()
+    def test_setxor1d_diff_size_arr_inputs(self, xp, dtype):
+        x = xp.array([3, 4, 9, 1, 5, 4], dtype=dtype)
+        y = xp.array([8, 7, 3, 9, 0], dtype=dtype)
+        return xp.setxor1d(x, y)
+
+    @testing.for_all_dtypes()
+    @testing.numpy_cupy_array_equal()
+    def test_setxor1d_diff_elements(self, xp, dtype):
+        x = xp.array([3, 4, 9, 1, 5, 4], dtype=dtype)
+        y = xp.array([8, 7, 3, 9, 0], dtype=dtype)
+        return xp.setxor1d(x, y, assume_unique=True)
+
+    @testing.for_all_dtypes()
+    @testing.numpy_cupy_array_equal()
+    def test_setxor1d_with_2d(self, xp, dtype):
+        x = testing.shaped_random((2, 3), xp, dtype=dtype)
+        y = testing.shaped_random((3, 5), xp, dtype=dtype)
+        return xp.setxor1d(x, y)
+
+    @testing.for_all_dtypes()
+    @testing.numpy_cupy_array_equal()
+    def test_setxor1d_with_duplicate_elements(self, xp, dtype):
+        x = xp.array([1, 2, 3, 2, 2, 6], dtype=dtype)
+        y = xp.array([3, 4, 2, 1, 1, 9], dtype=dtype)
+        return xp.setxor1d(x, y)
+
+    @testing.for_all_dtypes()
+    @testing.numpy_cupy_array_equal()
+    def test_setxor1d_empty_arr(self, xp, dtype):
+        x = xp.array([], dtype=dtype)
+        y = xp.array([], dtype=dtype)
+        return xp.setxor1d(x, y)
+
+    @testing.for_all_dtypes()
+    @testing.numpy_cupy_array_equal()
+    def test_setxor1d_more_dim(self, xp, dtype):
+        x = testing.shaped_arange((2, 3, 4, 8), xp, dtype=dtype)
+        y = testing.shaped_arange((5, 4, 2), xp, dtype=dtype)
+        return xp.setxor1d(x, y)
+
+    @testing.numpy_cupy_array_equal()
+    def test_setxor1d_bool_val(self, xp):
+        x = xp.array([True, False, True])
+        y = xp.array([False])
+        return xp.setxor1d(x, y)
+
+
 class TestIntersect1d:
 
     @testing.for_all_dtypes(no_bool=True)