working

Author: TomAugspurger

doc/source/user_guide/boolean.rst

@@ -22,7 +22,8 @@ Kleene Logic
 :class:`arrays.BooleanArray` implements Kleene logic (sometimes called three-value logic) for
 logical operations like ``&`` (and), ``|`` (or) and ``^`` (exclusive-or).
 
-Here's a table for ``and``.
+This table demonstrates the results for every combination. These operations are symmetrical,
+so flipping the left- and right-hand side makes no difference in the result.
 
 ================= =========
 Expression        Result

pandas/core/arrays/boolean.py

@@ -562,13 +562,13 @@ def logical_method(self, other):
                 # Rely on pandas to unbox and dispatch to us.
                 return NotImplemented
 
+            assert op.__name__ in {"or_", "ror_", "and_", "rand_", "xor", "rxor"}
             other = lib.item_from_zerodim(other)
-            omask = mask = None
             other_is_booleanarray = isinstance(other, BooleanArray)
+            mask = None
 
             if other_is_booleanarray:
-                other, omask = other._data, other._mask
-                mask = omask
+                other, mask = other._data, other._mask
             elif is_list_like(other):
                 other = np.asarray(other, dtype="bool")
                 if other.ndim > 1:
@@ -579,41 +579,15 @@ def logical_method(self, other):
                     raise ValueError("Lengths must match to compare")
                 other, mask = coerce_to_array(other, copy=False)
 
-            # numpy will show a DeprecationWarning on invalid elementwise
-            # comparisons, this will raise in the future
-            if lib.is_scalar(other) and np.isnan(
-                other
-            ):  # TODO(NA): change to libmissing.NA:
-                result = self._data
-                mask = True
-            else:
-                with warnings.catch_warnings():
-                    warnings.filterwarnings("ignore", "elementwise", FutureWarning)
-                    with np.errstate(all="ignore"):
-                        result = op(self._data, other)
-
-            # nans propagate
-            if mask is None:
-                mask = self._mask
-            else:
-                mask = self._mask | mask
-
-            # Kleene-logic adjustments to the mask.
             if op.__name__ in {"or_", "ror_"}:
-                mask[result] = False
+                result, mask = kleene_or(self._data, other, self._mask, mask)
+                return BooleanArray(result, mask)
             elif op.__name__ in {"and_", "rand_"}:
-                mask[~self._data & ~self._mask] = False
-                if other_is_booleanarray:
-                    mask[~other & ~omask] = False
-                elif lib.is_scalar(other) and np.isnan(other):  # TODO(NA): change to NA
-                    mask[:] = True
-                # Do we ever assume that masked values are False?
-                result[mask] = False
+                result, mask = kleene_and(self._data, other, self._mask, mask)
+                return BooleanArray(result, mask)
             elif op.__name__ in {"xor", "rxor"}:
-                # Do we ever assume that masked values are False?
-                result[mask] = False
-
-            return BooleanArray(result, mask)
+                result, mask = kleene_xor(self._data, other, self._mask, mask)
+                return BooleanArray(result, mask)
 
         name = "__{name}__".format(name=op.__name__)
         return set_function_name(logical_method, name, cls)
@@ -766,6 +740,91 @@ def boolean_arithmetic_method(self, other):
         return set_function_name(boolean_arithmetic_method, name, cls)
 
 
+def kleene_or(left, right, left_mask, right_mask):
+    if left_mask is None:
+        return kleene_or(right, left, right_mask, left_mask)
+
+    assert left_mask is not None
+    assert isinstance(left, np.ndarray)
+    assert isinstance(left_mask, np.ndarray)
+
+    mask = left_mask
+
+    if right_mask is not None:
+        mask = mask | right_mask
+    else:
+        mask = mask.copy()
+
+    # handle scalars:
+    if lib.is_scalar(right) and np.isnan(right):
+        result = left.copy()
+        mask = left_mask.copy()
+        mask[~result] = True
+        return result, mask
+
+    # XXX: this implicitly relies on masked values being False!
+    result = left | right
+    mask[result] = False
+
+    # update
+    return result, mask
+
+
+def kleene_xor(left, right, left_mask, right_mask):
+    if left_mask is None:
+        return kleene_xor(right, left, right_mask, left_mask)
+
+    result, mask = kleene_or(left, right, left_mask, right_mask)
+    #
+    # if lib.is_scalar(right):
+    #     if right is True:
+    #         result[result] = False
+    #     result[left & right] = False
+
+    if lib.is_scalar(right) and right is np.nan:
+        mask[result] = True
+    else:
+        # assumes masked values are False
+        result[left & right] = False
+        mask[right & left_mask] = True
+        if right_mask is not None:
+            mask[left & right_mask] = True
+
+    result[mask] = False
+    return result, mask
+
+
+def kleene_and(left, right, left_mask, right_mask):
+    if left_mask is None:
+        return kleene_and(right, left, right_mask, left_mask)
+
+    mask = left_mask
+
+    if right_mask is not None:
+        mask = mask | right_mask
+    else:
+        mask = mask.copy()
+
+    if lib.is_scalar(right):
+        result = left.copy()
+        mask = left_mask.copy()
+        if np.isnan(right):
+            mask[result] = True
+        else:
+            result = result & right  # already copied.
+            if right is False:
+                # unmask everything
+                mask[:] = False
+    else:
+        result = left & right
+        # unmask where either left or right is False
+        mask[~left & ~left_mask] = False
+        mask[~right & ~right_mask] = False
+
+    result[mask] = False
+    return result, mask
+
+
 BooleanArray._add_logical_ops()
 BooleanArray._add_comparison_ops()
 BooleanArray._add_arithmetic_ops()

pandas/tests/arrays/test_boolean.py

@@ -413,13 +413,22 @@ def test_kleene_or(self):
         result = b | a
         tm.assert_extension_array_equal(result, expected)
 
-    def test_kleene_or_scalar(self):
+    @pytest.mark.parametrize(
+        "other, expected",
+        [
+            (np.nan, [True, None, None]),
+            (True, [True, True, True]),
+            (False, [True, False, None]),
+        ],
+    )
+    def test_kleene_or_scalar(self, other, expected):
+        # TODO: test True & False
         a = pd.array([True, False, None], dtype="boolean")
-        result = a | np.nan  # TODO: pd.NA
-        expected = pd.array([True, None, None], dtype="boolean")
+        result = a | other
+        expected = pd.array(expected, dtype="boolean")
         tm.assert_extension_array_equal(result, expected)
 
-        result = np.nan | a  # TODO: pd.NA
+        result = other | a
         tm.assert_extension_array_equal(result, expected)
 
     @pytest.mark.parametrize(
@@ -456,13 +465,21 @@ def test_kleene_and(self):
         result = b & a
         tm.assert_extension_array_equal(result, expected)
 
-    def test_kleene_and_scalar(self):
+    @pytest.mark.parametrize(
+        "other, expected",
+        [
+            (np.nan, [None, False, None]),
+            (True, [True, False, None]),
+            (False, [False, False, False]),
+        ],
+    )
+    def test_kleene_and_scalar(self, other, expected):
         a = pd.array([True, False, None], dtype="boolean")
-        result = a & np.nan  # TODO: pd.NA
-        expected = pd.array([None, None, None], dtype="boolean")
+        result = a & other
+        expected = pd.array(expected, dtype="boolean")
         tm.assert_extension_array_equal(result, expected)
 
-        result = np.nan & a  # TODO: pd.na
+        result = other & a
         tm.assert_extension_array_equal(result, expected)
 
     def test_kleene_xor(self):
@@ -477,13 +494,21 @@ def test_kleene_xor(self):
         result = b ^ a
         tm.assert_extension_array_equal(result, expected)
 
-    def test_kleene_scalar(self):
+    @pytest.mark.parametrize(
+        "other, expected",
+        [
+            (np.nan, [None, None, None]),
+            (True, [False, True, None]),
+            (False, [True, False, None]),
+        ],
+    )
+    def test_kleene_xor_scalar(self, other, expected):
         a = pd.array([True, False, None], dtype="boolean")
-        result = a ^ np.nan  # TODO: pd.NA
-        expected = pd.array([None, None, None], dtype="boolean")
+        result = a ^ other
+        expected = pd.array(expected, dtype="boolean")
         tm.assert_extension_array_equal(result, expected)
 
-        result = np.nan ^ a  # TODO: pd.NA
+        result = other ^ a
         tm.assert_extension_array_equal(result, expected)