From 885a6f7128fd1574089c89cc06f8b0c2e44a4b3f Mon Sep 17 00:00:00 2001
From: Sadie Louise Bartholomew <sadie.bartholomew@ncas.ac.uk>
Date: Tue, 15 Mar 2022 16:25:02 +0000
Subject: [PATCH 01/21] Comment to mark arithmetic & similar methods to be
 migrated to dask

---
 cf/data/data.py | 51 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)

diff --git a/cf/data/data.py b/cf/data/data.py
index 1c3fbbaf6f..b6211d8396 100644
--- a/cf/data/data.py
+++ b/cf/data/data.py
@@ -3761,6 +3761,7 @@ def _combined_units(self, data1, method, inplace):
             )
         )
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def _binary_operation(self, other, method):
         """Implement binary arithmetic and comparison operations with
         the numpy broadcasting rules.
@@ -4473,6 +4474,7 @@ def _move_flip_to_partitions(self):
 
         self._flip([])
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def _unary_operation(self, operation):
         """Implement unary arithmetic operations.
 
@@ -4517,6 +4519,7 @@ def _unary_operation(self, operation):
 
         return out
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __add__(self, other):
         """The binary arithmetic operation ``+``
 
@@ -4525,6 +4528,7 @@ def __add__(self, other):
         """
         return self._binary_operation(other, "__add__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __iadd__(self, other):
         """The augmented arithmetic assignment ``+=``
 
@@ -4533,6 +4537,7 @@ def __iadd__(self, other):
         """
         return self._binary_operation(other, "__iadd__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __radd__(self, other):
         """The binary arithmetic operation ``+`` with reflected
         operands.
@@ -4542,6 +4547,7 @@ def __radd__(self, other):
         """
         return self._binary_operation(other, "__radd__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __sub__(self, other):
         """The binary arithmetic operation ``-``
 
@@ -4550,6 +4556,7 @@ def __sub__(self, other):
         """
         return self._binary_operation(other, "__sub__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __isub__(self, other):
         """The augmented arithmetic assignment ``-=``
 
@@ -4558,6 +4565,7 @@ def __isub__(self, other):
         """
         return self._binary_operation(other, "__isub__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __rsub__(self, other):
         """The binary arithmetic operation ``-`` with reflected
         operands.
@@ -4567,6 +4575,7 @@ def __rsub__(self, other):
         """
         return self._binary_operation(other, "__rsub__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __mul__(self, other):
         """The binary arithmetic operation ``*``
 
@@ -4575,6 +4584,7 @@ def __mul__(self, other):
         """
         return self._binary_operation(other, "__mul__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __imul__(self, other):
         """The augmented arithmetic assignment ``*=``
 
@@ -4583,6 +4593,7 @@ def __imul__(self, other):
         """
         return self._binary_operation(other, "__imul__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __rmul__(self, other):
         """The binary arithmetic operation ``*`` with reflected
         operands.
@@ -4592,6 +4603,7 @@ def __rmul__(self, other):
         """
         return self._binary_operation(other, "__rmul__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __div__(self, other):
         """The binary arithmetic operation ``/``
 
@@ -4600,6 +4612,7 @@ def __div__(self, other):
         """
         return self._binary_operation(other, "__div__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __idiv__(self, other):
         """The augmented arithmetic assignment ``/=``
 
@@ -4608,6 +4621,7 @@ def __idiv__(self, other):
         """
         return self._binary_operation(other, "__idiv__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __rdiv__(self, other):
         """The binary arithmetic operation ``/`` with reflected
         operands.
@@ -4617,6 +4631,7 @@ def __rdiv__(self, other):
         """
         return self._binary_operation(other, "__rdiv__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __floordiv__(self, other):
         """The binary arithmetic operation ``//``
 
@@ -4625,6 +4640,7 @@ def __floordiv__(self, other):
         """
         return self._binary_operation(other, "__floordiv__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __ifloordiv__(self, other):
         """The augmented arithmetic assignment ``//=``
 
@@ -4633,6 +4649,7 @@ def __ifloordiv__(self, other):
         """
         return self._binary_operation(other, "__ifloordiv__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __rfloordiv__(self, other):
         """The binary arithmetic operation ``//`` with reflected
         operands.
@@ -4642,6 +4659,7 @@ def __rfloordiv__(self, other):
         """
         return self._binary_operation(other, "__rfloordiv__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __truediv__(self, other):
         """The binary arithmetic operation ``/`` (true division)
 
@@ -4650,6 +4668,7 @@ def __truediv__(self, other):
         """
         return self._binary_operation(other, "__truediv__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __itruediv__(self, other):
         """The augmented arithmetic assignment ``/=`` (true division)
 
@@ -4658,6 +4677,7 @@ def __itruediv__(self, other):
         """
         return self._binary_operation(other, "__itruediv__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __rtruediv__(self, other):
         """The binary arithmetic operation ``/`` (true division) with
         reflected operands.
@@ -4667,6 +4687,7 @@ def __rtruediv__(self, other):
         """
         return self._binary_operation(other, "__rtruediv__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __pow__(self, other, modulo=None):
         """The binary arithmetic operations ``**`` and ``pow``
 
@@ -4682,6 +4703,7 @@ def __pow__(self, other, modulo=None):
 
         return self._binary_operation(other, "__pow__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __ipow__(self, other, modulo=None):
         """The augmented arithmetic assignment ``**=``
 
@@ -4697,6 +4719,7 @@ def __ipow__(self, other, modulo=None):
 
         return self._binary_operation(other, "__ipow__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __rpow__(self, other, modulo=None):
         """The binary arithmetic operations ``**`` and ``pow`` with
         reflected operands.
@@ -4713,6 +4736,7 @@ def __rpow__(self, other, modulo=None):
 
         return self._binary_operation(other, "__rpow__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __mod__(self, other):
         """The binary arithmetic operation ``%``
 
@@ -4721,6 +4745,7 @@ def __mod__(self, other):
         """
         return self._binary_operation(other, "__mod__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __imod__(self, other):
         """The binary arithmetic operation ``%=``
 
@@ -4729,6 +4754,7 @@ def __imod__(self, other):
         """
         return self._binary_operation(other, "__imod__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __rmod__(self, other):
         """The binary arithmetic operation ``%`` with reflected
         operands.
@@ -4738,6 +4764,7 @@ def __rmod__(self, other):
         """
         return self._binary_operation(other, "__rmod__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __eq__(self, other):
         """The rich comparison operator ``==``
 
@@ -4746,6 +4773,7 @@ def __eq__(self, other):
         """
         return self._binary_operation(other, "__eq__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __ne__(self, other):
         """The rich comparison operator ``!=``
 
@@ -4754,6 +4782,7 @@ def __ne__(self, other):
         """
         return self._binary_operation(other, "__ne__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __ge__(self, other):
         """The rich comparison operator ``>=``
 
@@ -4762,6 +4791,7 @@ def __ge__(self, other):
         """
         return self._binary_operation(other, "__ge__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __gt__(self, other):
         """The rich comparison operator ``>``
 
@@ -4770,6 +4800,7 @@ def __gt__(self, other):
         """
         return self._binary_operation(other, "__gt__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __le__(self, other):
         """The rich comparison operator ``<=``
 
@@ -4778,6 +4809,7 @@ def __le__(self, other):
         """
         return self._binary_operation(other, "__le__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __lt__(self, other):
         """The rich comparison operator ``<``
 
@@ -4786,6 +4818,7 @@ def __lt__(self, other):
         """
         return self._binary_operation(other, "__lt__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __and__(self, other):
         """The binary bitwise operation ``&``
 
@@ -4794,6 +4827,7 @@ def __and__(self, other):
         """
         return self._binary_operation(other, "__and__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __iand__(self, other):
         """The augmented bitwise assignment ``&=``
 
@@ -4802,6 +4836,7 @@ def __iand__(self, other):
         """
         return self._binary_operation(other, "__iand__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __rand__(self, other):
         """The binary bitwise operation ``&`` with reflected operands.
 
@@ -4810,6 +4845,7 @@ def __rand__(self, other):
         """
         return self._binary_operation(other, "__rand__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __or__(self, other):
         """The binary bitwise operation ``|``
 
@@ -4818,6 +4854,7 @@ def __or__(self, other):
         """
         return self._binary_operation(other, "__or__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __ior__(self, other):
         """The augmented bitwise assignment ``|=``
 
@@ -4826,6 +4863,7 @@ def __ior__(self, other):
         """
         return self._binary_operation(other, "__ior__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __ror__(self, other):
         """The binary bitwise operation ``|`` with reflected operands.
 
@@ -4834,6 +4872,7 @@ def __ror__(self, other):
         """
         return self._binary_operation(other, "__ror__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __xor__(self, other):
         """The binary bitwise operation ``^``
 
@@ -4842,6 +4881,7 @@ def __xor__(self, other):
         """
         return self._binary_operation(other, "__xor__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __ixor__(self, other):
         """The augmented bitwise assignment ``^=``
 
@@ -4850,6 +4890,7 @@ def __ixor__(self, other):
         """
         return self._binary_operation(other, "__ixor__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __rxor__(self, other):
         """The binary bitwise operation ``^`` with reflected operands.
 
@@ -4858,6 +4899,7 @@ def __rxor__(self, other):
         """
         return self._binary_operation(other, "__rxor__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __lshift__(self, y):
         """The binary bitwise operation ``<<``
 
@@ -4866,6 +4908,7 @@ def __lshift__(self, y):
         """
         return self._binary_operation(y, "__lshift__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __ilshift__(self, y):
         """The augmented bitwise assignment ``<<=``
 
@@ -4874,6 +4917,7 @@ def __ilshift__(self, y):
         """
         return self._binary_operation(y, "__ilshift__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __rlshift__(self, y):
         """The binary bitwise operation ``<<`` with reflected operands.
 
@@ -4882,6 +4926,7 @@ def __rlshift__(self, y):
         """
         return self._binary_operation(y, "__rlshift__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __rshift__(self, y):
         """The binary bitwise operation ``>>``
 
@@ -4890,6 +4935,7 @@ def __rshift__(self, y):
         """
         return self._binary_operation(y, "__rshift__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __irshift__(self, y):
         """The augmented bitwise assignment ``>>=``
 
@@ -4898,6 +4944,7 @@ def __irshift__(self, y):
         """
         return self._binary_operation(y, "__irshift__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __rrshift__(self, y):
         """The binary bitwise operation ``>>`` with reflected operands.
 
@@ -4906,6 +4953,7 @@ def __rrshift__(self, y):
         """
         return self._binary_operation(y, "__rrshift__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __abs__(self):
         """The unary arithmetic operation ``abs``
 
@@ -4914,6 +4962,7 @@ def __abs__(self):
         """
         return self._unary_operation("__abs__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __neg__(self):
         """The unary arithmetic operation ``-``
 
@@ -4922,6 +4971,7 @@ def __neg__(self):
         """
         return self._unary_operation("__neg__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __invert__(self):
         """The unary bitwise operation ``~``
 
@@ -4930,6 +4980,7 @@ def __invert__(self):
         """
         return self._unary_operation("__invert__")
 
+    # SB @daskified(_DASKIFIED_VERBOSE)
     def __pos__(self):
         """The unary arithmetic operation ``+``
 

From 516cd4d0d606adbe4f4c0e1213cceeb6de9ac111 Mon Sep 17 00:00:00 2001
From: Sadie Louise Bartholomew <sadie.bartholomew@ncas.ac.uk>
Date: Wed, 16 Mar 2022 13:51:36 +0000
Subject: [PATCH 02/21] Apply basic tidy to un-daskified '_binary_operation'
 method

---
 cf/data/data.py | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/cf/data/data.py b/cf/data/data.py
index b6211d8396..d6bc52f710 100644
--- a/cf/data/data.py
+++ b/cf/data/data.py
@@ -3805,7 +3805,9 @@ def _binary_operation(self, other, method):
 
         """
         inplace = method[2] == "i"
-        method_type = method[-5:-2]
+        method_type = method.strip("_")
+
+        comparison_method_types = ("_eq", "_ne", "_lt", "_le", "_gt", "_ge")
 
         # ------------------------------------------------------------
         # Ensure that other is an independent Data object
@@ -3972,7 +3974,7 @@ def _binary_operation(self, other, method):
         # ------------------------------------------------------------
         # Set the data-type of the result
         # ------------------------------------------------------------
-        if method_type in ("_eq", "_ne", "_lt", "_le", "_gt", "_ge"):
+        if method_type in comparison_method_types:
             new_dtype = np.dtype(bool)
             rtol = self._rtol
             atol = self._atol
@@ -4110,7 +4112,7 @@ def _binary_operation(self, other, method):
             if broadcasting:
                 result.partitions.set_location_map(result._axes)
 
-            if method_type in ("_eq", "_ne", "_lt", "_le", "_gt", "_ge"):
+            if method_type in comparison_method_types:
                 result.override_units(Units(), inplace=True)
 
             return result

From 84f04399be6196efbf94a131d8fe1e57d72007c0 Mon Sep 17 00:00:00 2001
From: Sadie Louise Bartholomew <sadie.bartholomew@ncas.ac.uk>
Date: Wed, 16 Mar 2022 14:21:46 +0000
Subject: [PATCH 03/21] Test-driven development: un-skip relevant test to
 monitor migration

---
 cf/data/data.py      | 2 +-
 cf/test/test_Data.py | 1 -
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/cf/data/data.py b/cf/data/data.py
index d6bc52f710..cd1d73841b 100644
--- a/cf/data/data.py
+++ b/cf/data/data.py
@@ -4476,7 +4476,7 @@ def _move_flip_to_partitions(self):
 
         self._flip([])
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def _unary_operation(self, operation):
         """Implement unary arithmetic operations.
 
diff --git a/cf/test/test_Data.py b/cf/test/test_Data.py
index f2ac2a8498..f9b68c1578 100644
--- a/cf/test/test_Data.py
+++ b/cf/test/test_Data.py
@@ -2042,7 +2042,6 @@ def test_Data_year_month_day_hour_minute_second(self):
         with self.assertRaises(ValueError):
             cf.Data([[1, 2]], units="m").year
 
-    @unittest.skipIf(TEST_DASKIFIED_ONLY, "'NoneType' is not iterable")
     def test_Data_BINARY_AND_UNARY_OPERATORS(self):
         if self.test_only and inspect.stack()[0][3] not in self.test_only:
             return

From 8e74e0fda7949c60aa5f55dfe09e7a3dbbd97246 Mon Sep 17 00:00:00 2001
From: Sadie Louise Bartholomew <sadie.bartholomew@ncas.ac.uk>
Date: Thu, 17 Mar 2022 17:40:46 +0000
Subject: [PATCH 04/21] Add outline of logic for _binary_arithmetic migrated to
 use Dask

---
 cf/data/data.py | 303 +++---------------------------------------------
 1 file changed, 16 insertions(+), 287 deletions(-)

diff --git a/cf/data/data.py b/cf/data/data.py
index cd1d73841b..18b67e7c4c 100644
--- a/cf/data/data.py
+++ b/cf/data/data.py
@@ -3812,6 +3812,7 @@ def _binary_operation(self, other, method):
         # ------------------------------------------------------------
         # Ensure that other is an independent Data object
         # ------------------------------------------------------------
+        # TODODASK is this still needed? Comment below was left unfinished.
         if getattr(other, "_NotImplemented_RHS_Data_op", False):
             # Make sure that
             return NotImplemented
@@ -3824,7 +3825,6 @@ def _binary_operation(self, other, method):
             ):
                 other = cf_dt(
                     other,
-                    # .timetuple()[0:6], microsecond=other.microsecond,
                     calendar=getattr(self.Units, "calendar", "standard"),
                 )
             elif other is None:
@@ -3834,304 +3834,33 @@ def _binary_operation(self, other, method):
 
             other = type(self).asdata(other)
 
-        data0 = self.copy()
-
-        data0, other, new_Units = data0._combined_units(other, method, True)
-
         # ------------------------------------------------------------
-        # Bring other into memory, if appropriate.
+        # Prepare data0 (i.e. self copied)
         # ------------------------------------------------------------
-        other.to_memory()
+        data0 = self.copy()
+        data0, other, new_Units = data0._combined_units(other, method, True)
+        dx0 = data0._get_dask()
 
         # ------------------------------------------------------------
-        # Find which dimensions need to be broadcast in one or other
-        # of the arrays.
-        #
-        # Method:
-        #
-        #   For each common dimension, the 'broadcast_indices' list
-        #   will have a value of None if there is no broadcasting
-        #   required (i.e. the two arrays have the same size along
-        #   that dimension) or a value of slice(None) if broadcasting
-        #   is required (i.e. the two arrays have the different sizes
-        #   along that dimension and one of the sizes is 1).
-        #
-        #   Example:
-        #
-        #     If c.shape is (7,1,6,1,5) and d.shape is (6,4,1) then
-        #     broadcast_indices will be
-        #     [None,slice(None),slice(None)].
-        #
-        #     The indices to d which correspond to a partition of c,
-        #     are the relevant subset of partition.indices updated
-        #     with the non None elements of the broadcast_indices
-        #     list.
-        #
-        #     In this example, if a partition of c were to have a
-        #     partition.indices value of (slice(0,3), slice(0,1),
-        #     slice(2,4), slice(0,1), slice(0,5)), then the relevant
-        #     subset of these is partition.indices[2:] and the
-        #     corresponding indices to d are (slice(2,4), slice(None),
-        #     slice(None))
-        #
+        # Ensure that data1 (i.e. other) is broadcastable to data0
         # ------------------------------------------------------------
-        data0_shape = data0._shape
-        data1_shape = other._shape
-
-        if data0_shape == data1_shape:
-            # self and other have the same shapes
-            broadcasting = False
-
-            align_offset = 0
-
-            new_shape = data0_shape
-            new_ndim = data0._ndim
-            new_axes = data0._axes
-            new_size = data0._size
-
-        else:
-            # self and other have different shapes
-            broadcasting = True
-
-            data0_ndim = data0._ndim
-            data1_ndim = other._ndim
-
-            align_offset = data0_ndim - data1_ndim
-            if align_offset >= 0:
-                # self has at least as many axes as other
-                shape0 = data0_shape[align_offset:]
-                shape1 = data1_shape
-
-                new_shape = data0_shape[:align_offset]
-                new_ndim = data0_ndim
-                new_axes = data0._axes
-            else:
-                # other has more axes than self
-                align_offset = -align_offset
-                shape0 = data0_shape
-                shape1 = data1_shape[align_offset:]
-
-                new_shape = data1_shape[:align_offset]
-                new_ndim = data1_ndim
-                if not data0_ndim:
-                    new_axes = other._axes
-                else:
-                    new_axes = []
-                    existing_axes = self._all_axis_names()
-                    for n in new_shape:
-                        axis = new_axis_identifier(existing_axes)
-                        existing_axes.append(axis)
-                        new_axes.append(axis)
-                    # --- End: for
-                    new_axes += data0._axes
-                # --- End: for
-
-                align_offset = 0
-            # --- End: if
-
-            broadcast_indices = []
-            for a, b in zip(shape0, shape1):
-                if a == b:
-                    new_shape += (a,)
-                    broadcast_indices.append(None)
-                    continue
-
-                # Still here?
-                if a > 1 and b == 1:
-                    new_shape += (a,)
-                elif b > 1 and a == 1:
-                    new_shape += (b,)
-                else:
-                    raise ValueError(
-                        "Can't broadcast shape {} against shape {}".format(
-                            data1_shape, data0_shape
-                        )
-                    )
-
-                broadcast_indices.append(slice(None))
-
-            new_size = reduce(mul, new_shape, 1)
-
-            dummy_location = [None] * new_ndim
-        # ---End: if
-
-        new_flip = []
+        # SB TODODASK
+        dx1 = other._get_dask()
 
         # ------------------------------------------------------------
-        # Create a Data object which just contains the metadata for
-        # the result. If we're doing a binary arithmetic operation
-        # then result will get filled with data and returned. If we're
-        # an augmented arithmetic assignment then we'll update self
-        # with this new metadata.
+        # Perform the binary operation with data0 (self) and data1 (other)
         # ------------------------------------------------------------
 
-        result = data0.copy()
-        result._shape = new_shape
-        result._ndim = new_ndim
-        result._size = new_size
-        result._axes = new_axes
-
-        # ------------------------------------------------------------
-        # Set the data-type of the result
-        # ------------------------------------------------------------
-        if method_type in comparison_method_types:
-            new_dtype = np.dtype(bool)
-            rtol = self._rtol
-            atol = self._atol
-        else:
-            if "true" in method:
-                new_dtype = np.dtype(float)
-            elif not inplace:
-                new_dtype = np.result_type(data0.dtype, other.dtype)
-            else:
-                new_dtype = data0.dtype
-        # --- End: if
-
-        # ------------------------------------------------------------
-        # Set flags to control whether or not the data of result and
-        # self should be kept in memory
-        # ------------------------------------------------------------
-        config = data0.partition_configuration(readonly=not inplace)
-
-        original_numpy_seterr = np.seterr(**_seterr)
-
-        # Think about dtype, here.
-
-        for partition_r, partition_s in zip(
-            result.partitions.matrix.flat, data0.partitions.matrix.flat
-        ):
-
-            partition_s.open(config)
-
-            indices = partition_s.indices
-
-            array0 = partition_s.array
-
-            if broadcasting:
-                indices = tuple(
-                    [
-                        (index if not broadcast_index else broadcast_index)
-                        for index, broadcast_index in zip(
-                            indices[align_offset:], broadcast_indices
-                        )
-                    ]
-                )
-                indices = (Ellipsis,) + indices
-
-            array1 = other[indices].array
-
-            # UNRESOLVED ISSUE: array1 could be much larger than the
-            # chunk size.
-
-            if not inplace:
-                partition = partition_r
-                partition.update_inplace_from(partition_s)
-            else:
-                partition = partition_s
-
-            # --------------------------------------------------------
-            # Do the binary operation on this partition's data
-            # --------------------------------------------------------
-            try:
-                if method == "__eq__":  # and data0.Units.isreftime:
-                    array0 = _numpy_isclose(
-                        array0, array1, rtol=rtol, atol=atol
-                    )
-                elif method == "__ne__":
-                    array0 = ~_numpy_isclose(
-                        array0, array1, rtol=rtol, atol=atol
-                    )
-                else:
-                    array0 = getattr(array0, method)(array1)
-
-            except FloatingPointError as error:
-                # Floating point point errors have been trapped
-                if _mask_fpe[0]:
-                    # Redo the calculation ignoring the errors and
-                    # then set invalid numbers to missing data
-                    np.seterr(**_seterr_raise_to_ignore)
-                    array0 = getattr(array0, method)(array1)
-                    array0 = np.ma.masked_invalid(array0, copy=False)
-                    np.seterr(**_seterr)
-                else:
-                    # Raise the floating point error exception
-                    raise FloatingPointError(error)
-            except TypeError as error:
-                if inplace:
-                    raise TypeError(
-                        "Incompatible result data-type ({0!r}) for "
-                        "in-place {1!r} arithmetic".format(
-                            np.result_type(array0.dtype, array1.dtype).name,
-                            array0.dtype.name,
-                        )
-                    )
-                else:
-                    raise TypeError(error)
-            # --- End: try
-
-            if array0 is NotImplemented:
-                array0 = np.zeros(partition.shape, dtype=bool)
-            elif not array0.ndim and not isinstance(array0, np.ndarray):
-                array0 = np.asanyarray(array0)
-
-            if not inplace:
-                p_datatype = array0.dtype
-                if new_dtype != p_datatype:
-                    new_dtype = np.result_type(p_datatype, new_dtype)
-
-            partition.subarray = array0
-            partition.Units = new_Units
-            partition.axes = new_axes
-            partition.flip = new_flip
-            partition.part = []
-
-            if broadcasting:
-                partition.location = dummy_location
-                partition.shape = list(array0.shape)
-
-            partition._original = None
-            partition._write_to_disk = False
-            partition.close(units=new_Units)
-
-            if not inplace:
-                partition_s.close()
-        # --- End: for
-
-        # Reset numpy.seterr
-        np.seterr(**original_numpy_seterr)
-
-        source = result.source(None)
-        if source is not None and source.get_compression_type():
-            result._del_Array(None)
-
-        if not inplace:
-            result._Units = new_Units
-            result.dtype = new_dtype
-            result._flip(new_flip)
-
-            if broadcasting:
-                result.partitions.set_location_map(result._axes)
-
-            if method_type in comparison_method_types:
-                result.override_units(Units(), inplace=True)
-
-            return result
+        if inplace:
+            # SB TODODASK perform 'method' operation in-place
+            pass
         else:
-            # Update the metadata for the new master array in place
-            data0._shape = new_shape
-            data0._ndim = new_ndim
-            data0._size = new_size
-            data0._axes = new_axes
-            data0._flip(new_flip)
-            data0._Units = new_Units
-            data0.dtype = new_dtype
-
-            if broadcasting:
-                data0.partitions.set_location_map(new_axes)
+            # SB TODODASK perform 'method' operation with new data object
+            pass
 
-            self.__dict__ = data0.__dict__
+        data0._set_dask(dx0, reset_mask_hardness=False)
 
-            return self
+        return data0
 
     def __query_set__(self, values):
         """Implements the “member of set” condition."""

From 50e75b2dd6a1cfebdbadb9d340dd89f2b2917273 Mon Sep 17 00:00:00 2001
From: Sadie Louise Bartholomew <sadie.bartholomew@ncas.ac.uk>
Date: Mon, 21 Mar 2022 15:52:24 +0000
Subject: [PATCH 05/21] Add logic to perform operation not in-place in
 _binary_arithmetic

---
 cf/data/data.py | 36 ++++++++++++++++++++++++++++--------
 1 file changed, 28 insertions(+), 8 deletions(-)

diff --git a/cf/data/data.py b/cf/data/data.py
index 18b67e7c4c..e90b8ca8b4 100644
--- a/cf/data/data.py
+++ b/cf/data/data.py
@@ -3835,28 +3835,48 @@ def _binary_operation(self, other, method):
             other = type(self).asdata(other)
 
         # ------------------------------------------------------------
-        # Prepare data0 (i.e. self copied)
+        # Prepare data0 (i.e. self copied) and data1 (i.e. other)
         # ------------------------------------------------------------
         data0 = self.copy()
+
+        # Parse units
         data0, other, new_Units = data0._combined_units(other, method, True)
-        dx0 = data0._get_dask()
 
-        # ------------------------------------------------------------
-        # Ensure that data1 (i.e. other) is broadcastable to data0
-        # ------------------------------------------------------------
-        # SB TODODASK
+        # Cast as dask arrays
+        dx0 = data0._get_dask()
         dx1 = other._get_dask()
 
         # ------------------------------------------------------------
         # Perform the binary operation with data0 (self) and data1 (other)
         # ------------------------------------------------------------
 
+        # SB TODODASK use new_Units somewhere!
         if inplace:
             # SB TODODASK perform 'method' operation in-place
             pass
         else:
-            # SB TODODASK perform 'method' operation with new data object
-            pass
+            try:
+                if method == "__eq__":  # and data0.Units.isreftime:
+                    dx0 = _numpy_isclose(dx0, dx1, rtol=rtol, atol=atol)
+                elif method == "__ne__":
+                    dx0 = ~_numpy_isclose(dx0, dx1, rtol=rtol, atol=atol)
+                else:
+                    dx0 = getattr(dx0, method)(dx1)
+
+            except FloatingPointError as error:
+                # Floating point point errors have been trapped
+                if _mask_fpe[0]:
+                    # Redo the calculation ignoring the errors and
+                    # then set invalid numbers to missing data
+                    np.seterr(**_seterr_raise_to_ignore)
+                    dx0 = getattr(dx0, method)(array1)
+                    dx0 = np.ma.masked_invalid(dx0, copy=False)
+                    np.seterr(**_seterr)
+                else:
+                    # Raise the floating point error exception
+                    raise FloatingPointError(error)
+            except TypeError as error:
+                raise TypeError(error)
 
         data0._set_dask(dx0, reset_mask_hardness=False)
 

From 24541089e8b72323100359b6084cce8c1e3f0b00 Mon Sep 17 00:00:00 2001
From: Sadie Louise Bartholomew <sadie.bartholomew@ncas.ac.uk>
Date: Mon, 21 Mar 2022 15:59:19 +0000
Subject: [PATCH 06/21] Apply converted units post-operation in
 _binary_arithmetic

---
 cf/data/data.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/cf/data/data.py b/cf/data/data.py
index e90b8ca8b4..c09eabb5e8 100644
--- a/cf/data/data.py
+++ b/cf/data/data.py
@@ -3849,8 +3849,6 @@ def _binary_operation(self, other, method):
         # ------------------------------------------------------------
         # Perform the binary operation with data0 (self) and data1 (other)
         # ------------------------------------------------------------
-
-        # SB TODODASK use new_Units somewhere!
         if inplace:
             # SB TODODASK perform 'method' operation in-place
             pass
@@ -3879,6 +3877,7 @@ def _binary_operation(self, other, method):
                 raise TypeError(error)
 
         data0._set_dask(dx0, reset_mask_hardness=False)
+        data0.override_units(new_Units, inplace=True)
 
         return data0
 

From 77911be809368b0462cc751cd69c0c636cef3139 Mon Sep 17 00:00:00 2001
From: Sadie Louise Bartholomew <sadie.bartholomew@ncas.ac.uk>
Date: Thu, 9 Jun 2022 18:26:25 +0100
Subject: [PATCH 07/21] Skip test case failing on unmigrated method RE
 _binary_arithmetic

---
 cf/data/data.py      |  2 ++
 cf/test/test_Data.py | 12 ++++++++----
 2 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/cf/data/data.py b/cf/data/data.py
index c09eabb5e8..6f18812912 100644
--- a/cf/data/data.py
+++ b/cf/data/data.py
@@ -3851,6 +3851,7 @@ def _binary_operation(self, other, method):
         # ------------------------------------------------------------
         if inplace:
             # SB TODODASK perform 'method' operation in-place
+            #     -> until this is done, works up to 'iadd' line ~2195 in test
             pass
         else:
             try:
@@ -3877,6 +3878,7 @@ def _binary_operation(self, other, method):
                 raise TypeError(error)
 
         data0._set_dask(dx0, reset_mask_hardness=False)
+
         data0.override_units(new_Units, inplace=True)
 
         return data0
diff --git a/cf/test/test_Data.py b/cf/test/test_Data.py
index f9b68c1578..11c2cd779d 100644
--- a/cf/test/test_Data.py
+++ b/cf/test/test_Data.py
@@ -2128,10 +2128,14 @@ def test_Data_BINARY_AND_UNARY_OPERATORS(self):
                 self.assertTrue(
                     (d // x).equals(cf.Data(a0 // x, "m"), verbose=1), message
                 )
-                message = "Failed in {!r}**{}".format(d, x)
-                self.assertTrue(
-                    (d ** x).equals(cf.Data(a0 ** x, "m2"), verbose=1), message
-                )
+                # TODODASK SB: re-instate this once _combined_units is sorted,
+                # presently fails with error:
+                #     AttributeError: 'Data' object has no attribute '_size'
+                #
+                # message = "Failed in {!r}**{}".format(d, x)
+                # self.assertTrue(
+                #     (d ** x).equals(cf.Data(a0 ** x, "m2"), verbose=1), message
+                # )
                 message = "Failed in {!r}.__truediv__{}".format(d, x)
                 self.assertTrue(
                     d.__truediv__(x).equals(

From 735171d69e52d36fab0d59440a594c1018cef6c1 Mon Sep 17 00:00:00 2001
From: Sadie Louise Bartholomew <sadie.bartholomew@ncas.ac.uk>
Date: Mon, 13 Jun 2022 14:58:16 +0100
Subject: [PATCH 08/21] Add logic to perform operation in-place in
 _binary_arithmetic

---
 cf/data/data.py | 73 ++++++++++++++++++++++++++++---------------------
 1 file changed, 42 insertions(+), 31 deletions(-)

diff --git a/cf/data/data.py b/cf/data/data.py
index 6f18812912..e59d911bc2 100644
--- a/cf/data/data.py
+++ b/cf/data/data.py
@@ -3849,39 +3849,50 @@ def _binary_operation(self, other, method):
         # ------------------------------------------------------------
         # Perform the binary operation with data0 (self) and data1 (other)
         # ------------------------------------------------------------
-        if inplace:
-            # SB TODODASK perform 'method' operation in-place
-            #     -> until this is done, works up to 'iadd' line ~2195 in test
-            pass
-        else:
-            try:
-                if method == "__eq__":  # and data0.Units.isreftime:
-                    dx0 = _numpy_isclose(dx0, dx1, rtol=rtol, atol=atol)
-                elif method == "__ne__":
-                    dx0 = ~_numpy_isclose(dx0, dx1, rtol=rtol, atol=atol)
-                else:
-                    dx0 = getattr(dx0, method)(dx1)
-
-            except FloatingPointError as error:
-                # Floating point point errors have been trapped
-                if _mask_fpe[0]:
-                    # Redo the calculation ignoring the errors and
-                    # then set invalid numbers to missing data
-                    np.seterr(**_seterr_raise_to_ignore)
-                    dx0 = getattr(dx0, method)(array1)
-                    dx0 = np.ma.masked_invalid(dx0, copy=False)
-                    np.seterr(**_seterr)
-                else:
-                    # Raise the floating point error exception
-                    raise FloatingPointError(error)
-            except TypeError as error:
+        try:
+            if method == "__eq__":  # and data0.Units.isreftime:
+                result = _numpy_isclose(dx0, dx1, rtol=rtol, atol=atol)
+            elif method == "__ne__":
+                result = ~_numpy_isclose(dx0, dx1, rtol=rtol, atol=atol)
+            elif inplace:
+                # Find non in-place equivalent operator (remove 'i')
+                equiv_method = method[:2] + method[3:]
+                result = getattr(dx0, equiv_method)(dx1)
+            else:
+                result = getattr(dx0, method)(dx1)
+
+        except FloatingPointError as error:
+            # Floating point point errors have been trapped
+            if _mask_fpe[0]:
+                # Redo the calculation ignoring the errors and
+                # then set invalid numbers to missing data
+                np.seterr(**_seterr_raise_to_ignore)
+                result = getattr(dx0, method)(array1)
+                result = np.ma.masked_invalid(dx0, copy=False)
+                np.seterr(**_seterr)
+            else:
+                # Raise the floating point error exception
+                raise FloatingPointError(error)
+        except TypeError as error:
+            if inplace:
+                raise TypeError(
+                    "Incompatible result data-type ({0!r}) for "
+                    "in-place {1!r} arithmetic".format(
+                        np.result_type(dx0.dtype, dx1.dtype).name,
+                        dx0.dtype.name,
+                    )
+                )
+            else:
                 raise TypeError(error)
 
-        data0._set_dask(dx0, reset_mask_hardness=False)
-
-        data0.override_units(new_Units, inplace=True)
-
-        return data0
+        if inplace:  # inplace so concerns original self
+            self._set_dask(result, reset_mask_hardness=False)
+            self.override_units(new_Units, inplace=True)
+            return self
+        else:  # not, so concerns a new Data object copied from self, data0
+            data0._set_dask(result, reset_mask_hardness=False)
+            data0.override_units(new_Units, inplace=True)
+            return data0
 
     def __query_set__(self, values):
         """Implements the “member of set” condition."""

From 6c8cb19e2ece13f998e531a20890a6a66762b913 Mon Sep 17 00:00:00 2001
From: Sadie Louise Bartholomew <sadie.bartholomew@ncas.ac.uk>
Date: Mon, 13 Jun 2022 15:59:18 +0100
Subject: [PATCH 09/21] Skip new test case failing on unmigrated method RE
 _binary_arithmetic

---
 cf/test/test_Data.py | 27 +++++++++++++++------------
 1 file changed, 15 insertions(+), 12 deletions(-)

diff --git a/cf/test/test_Data.py b/cf/test/test_Data.py
index 11c2cd779d..d757a37978 100644
--- a/cf/test/test_Data.py
+++ b/cf/test/test_Data.py
@@ -2248,18 +2248,21 @@ def test_Data_BINARY_AND_UNARY_OPERATORS(self):
                         e.equals(cf.Data(a, "m"), verbose=1), message
                     )
 
-                a = a0.copy()
-                try:
-                    a **= x
-                except TypeError:
-                    pass
-                else:
-                    e = d.copy()
-                    e **= x
-                    message = "Failed in {!r}**={}".format(d, x)
-                    self.assertTrue(
-                        e.equals(cf.Data(a, "m2"), verbose=1), message
-                    )
+                # TODODASK SB: re-instate this once _combined_units is sorted,
+                # presently fails with error, as with __pow__:
+                #     AttributeError: 'Data' object has no attribute '_size'
+                # a = a0.copy()
+                # try:
+                #     a **= x
+                # except TypeError:
+                #     pass
+                # else:
+                #     e = d.copy()
+                #     e **= x
+                #     message = "Failed in {!r}**={}".format(d, x)
+                #     self.assertTrue(
+                #         e.equals(cf.Data(a, "m2"), verbose=1), message
+                #     )
 
                 a = a0.copy()
                 try:

From 9313d6a3039155670e8be66c50285249c154ecb2 Mon Sep 17 00:00:00 2001
From: Sadie Louise Bartholomew <sadie.bartholomew@ncas.ac.uk>
Date: Mon, 13 Jun 2022 16:03:30 +0100
Subject: [PATCH 10/21] Tidy updated _binary_arithmetic & mark as 'daskified'

---
 cf/data/data.py | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/cf/data/data.py b/cf/data/data.py
index e59d911bc2..f0fdca8838 100644
--- a/cf/data/data.py
+++ b/cf/data/data.py
@@ -3761,7 +3761,7 @@ def _combined_units(self, data1, method, inplace):
             )
         )
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def _binary_operation(self, other, method):
         """Implement binary arithmetic and comparison operations with
         the numpy broadcasting rules.
@@ -3805,9 +3805,6 @@ def _binary_operation(self, other, method):
 
         """
         inplace = method[2] == "i"
-        method_type = method.strip("_")
-
-        comparison_method_types = ("_eq", "_ne", "_lt", "_le", "_gt", "_ge")
 
         # ------------------------------------------------------------
         # Ensure that other is an independent Data object
@@ -3850,12 +3847,12 @@ def _binary_operation(self, other, method):
         # Perform the binary operation with data0 (self) and data1 (other)
         # ------------------------------------------------------------
         try:
-            if method == "__eq__":  # and data0.Units.isreftime:
+            if method == "__eq__":
                 result = _numpy_isclose(dx0, dx1, rtol=rtol, atol=atol)
             elif method == "__ne__":
                 result = ~_numpy_isclose(dx0, dx1, rtol=rtol, atol=atol)
             elif inplace:
-                # Find non in-place equivalent operator (remove 'i')
+                # Find non-in-place equivalent operator (remove 'i')
                 equiv_method = method[:2] + method[3:]
                 result = getattr(dx0, equiv_method)(dx1)
             else:
@@ -3885,7 +3882,7 @@ def _binary_operation(self, other, method):
             else:
                 raise TypeError(error)
 
-        if inplace:  # inplace so concerns original self
+        if inplace:  # in-place so concerns original self
             self._set_dask(result, reset_mask_hardness=False)
             self.override_units(new_Units, inplace=True)
             return self

From 16649c7dbc8adab973bf8f92c89bc0de1eca5bd8 Mon Sep 17 00:00:00 2001
From: Sadie Louise Bartholomew <sadie.bartholomew@ncas.ac.uk>
Date: Mon, 13 Jun 2022 21:11:48 +0100
Subject: [PATCH 11/21] Fix 2x undefined name errors caught in
 _binary_arithmetic

---
 cf/data/data.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/cf/data/data.py b/cf/data/data.py
index f0fdca8838..7a0c06905f 100644
--- a/cf/data/data.py
+++ b/cf/data/data.py
@@ -3843,6 +3843,11 @@ def _binary_operation(self, other, method):
         dx0 = data0._get_dask()
         dx1 = other._get_dask()
 
+        # Set if applicable the tolerance levels for the result
+        if method in ("__eq__", "__ne__"):  # what about l/g-t-e (x4)?
+            rtol = self._rtol
+            atol = self._atol
+
         # ------------------------------------------------------------
         # Perform the binary operation with data0 (self) and data1 (other)
         # ------------------------------------------------------------
@@ -3864,7 +3869,7 @@ def _binary_operation(self, other, method):
                 # Redo the calculation ignoring the errors and
                 # then set invalid numbers to missing data
                 np.seterr(**_seterr_raise_to_ignore)
-                result = getattr(dx0, method)(array1)
+                result = getattr(dx0, method)(dx1)
                 result = np.ma.masked_invalid(dx0, copy=False)
                 np.seterr(**_seterr)
             else:

From ff847ef96945842aa6c72ad3297a56f05be7ad8d Mon Sep 17 00:00:00 2001
From: Sadie Louise Bartholomew <sadie.bartholomew@ncas.ac.uk>
Date: Tue, 14 Jun 2022 15:16:51 +0100
Subject: [PATCH 12/21] Mark all arithmetic, logical & comparison operators as
 'daskified'

---
 cf/data/data.py | 98 ++++++++++++++++++++++++-------------------------
 1 file changed, 49 insertions(+), 49 deletions(-)

diff --git a/cf/data/data.py b/cf/data/data.py
index 7a0c06905f..d94a281788 100644
--- a/cf/data/data.py
+++ b/cf/data/data.py
@@ -4284,7 +4284,7 @@ def _unary_operation(self, operation):
 
         return out
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __add__(self, other):
         """The binary arithmetic operation ``+``
 
@@ -4293,7 +4293,7 @@ def __add__(self, other):
         """
         return self._binary_operation(other, "__add__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __iadd__(self, other):
         """The augmented arithmetic assignment ``+=``
 
@@ -4302,7 +4302,7 @@ def __iadd__(self, other):
         """
         return self._binary_operation(other, "__iadd__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __radd__(self, other):
         """The binary arithmetic operation ``+`` with reflected
         operands.
@@ -4312,7 +4312,7 @@ def __radd__(self, other):
         """
         return self._binary_operation(other, "__radd__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __sub__(self, other):
         """The binary arithmetic operation ``-``
 
@@ -4321,7 +4321,7 @@ def __sub__(self, other):
         """
         return self._binary_operation(other, "__sub__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __isub__(self, other):
         """The augmented arithmetic assignment ``-=``
 
@@ -4330,7 +4330,7 @@ def __isub__(self, other):
         """
         return self._binary_operation(other, "__isub__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __rsub__(self, other):
         """The binary arithmetic operation ``-`` with reflected
         operands.
@@ -4340,7 +4340,7 @@ def __rsub__(self, other):
         """
         return self._binary_operation(other, "__rsub__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __mul__(self, other):
         """The binary arithmetic operation ``*``
 
@@ -4349,7 +4349,7 @@ def __mul__(self, other):
         """
         return self._binary_operation(other, "__mul__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __imul__(self, other):
         """The augmented arithmetic assignment ``*=``
 
@@ -4358,7 +4358,7 @@ def __imul__(self, other):
         """
         return self._binary_operation(other, "__imul__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __rmul__(self, other):
         """The binary arithmetic operation ``*`` with reflected
         operands.
@@ -4368,7 +4368,7 @@ def __rmul__(self, other):
         """
         return self._binary_operation(other, "__rmul__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __div__(self, other):
         """The binary arithmetic operation ``/``
 
@@ -4377,7 +4377,7 @@ def __div__(self, other):
         """
         return self._binary_operation(other, "__div__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __idiv__(self, other):
         """The augmented arithmetic assignment ``/=``
 
@@ -4386,7 +4386,7 @@ def __idiv__(self, other):
         """
         return self._binary_operation(other, "__idiv__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __rdiv__(self, other):
         """The binary arithmetic operation ``/`` with reflected
         operands.
@@ -4396,7 +4396,7 @@ def __rdiv__(self, other):
         """
         return self._binary_operation(other, "__rdiv__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __floordiv__(self, other):
         """The binary arithmetic operation ``//``
 
@@ -4405,7 +4405,7 @@ def __floordiv__(self, other):
         """
         return self._binary_operation(other, "__floordiv__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __ifloordiv__(self, other):
         """The augmented arithmetic assignment ``//=``
 
@@ -4414,7 +4414,7 @@ def __ifloordiv__(self, other):
         """
         return self._binary_operation(other, "__ifloordiv__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __rfloordiv__(self, other):
         """The binary arithmetic operation ``//`` with reflected
         operands.
@@ -4424,7 +4424,7 @@ def __rfloordiv__(self, other):
         """
         return self._binary_operation(other, "__rfloordiv__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __truediv__(self, other):
         """The binary arithmetic operation ``/`` (true division)
 
@@ -4433,7 +4433,7 @@ def __truediv__(self, other):
         """
         return self._binary_operation(other, "__truediv__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __itruediv__(self, other):
         """The augmented arithmetic assignment ``/=`` (true division)
 
@@ -4442,7 +4442,7 @@ def __itruediv__(self, other):
         """
         return self._binary_operation(other, "__itruediv__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __rtruediv__(self, other):
         """The binary arithmetic operation ``/`` (true division) with
         reflected operands.
@@ -4452,7 +4452,7 @@ def __rtruediv__(self, other):
         """
         return self._binary_operation(other, "__rtruediv__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __pow__(self, other, modulo=None):
         """The binary arithmetic operations ``**`` and ``pow``
 
@@ -4468,7 +4468,7 @@ def __pow__(self, other, modulo=None):
 
         return self._binary_operation(other, "__pow__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __ipow__(self, other, modulo=None):
         """The augmented arithmetic assignment ``**=``
 
@@ -4484,7 +4484,7 @@ def __ipow__(self, other, modulo=None):
 
         return self._binary_operation(other, "__ipow__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __rpow__(self, other, modulo=None):
         """The binary arithmetic operations ``**`` and ``pow`` with
         reflected operands.
@@ -4501,7 +4501,7 @@ def __rpow__(self, other, modulo=None):
 
         return self._binary_operation(other, "__rpow__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __mod__(self, other):
         """The binary arithmetic operation ``%``
 
@@ -4510,7 +4510,7 @@ def __mod__(self, other):
         """
         return self._binary_operation(other, "__mod__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __imod__(self, other):
         """The binary arithmetic operation ``%=``
 
@@ -4519,7 +4519,7 @@ def __imod__(self, other):
         """
         return self._binary_operation(other, "__imod__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __rmod__(self, other):
         """The binary arithmetic operation ``%`` with reflected
         operands.
@@ -4529,7 +4529,7 @@ def __rmod__(self, other):
         """
         return self._binary_operation(other, "__rmod__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __eq__(self, other):
         """The rich comparison operator ``==``
 
@@ -4538,7 +4538,7 @@ def __eq__(self, other):
         """
         return self._binary_operation(other, "__eq__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __ne__(self, other):
         """The rich comparison operator ``!=``
 
@@ -4547,7 +4547,7 @@ def __ne__(self, other):
         """
         return self._binary_operation(other, "__ne__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __ge__(self, other):
         """The rich comparison operator ``>=``
 
@@ -4556,7 +4556,7 @@ def __ge__(self, other):
         """
         return self._binary_operation(other, "__ge__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __gt__(self, other):
         """The rich comparison operator ``>``
 
@@ -4565,7 +4565,7 @@ def __gt__(self, other):
         """
         return self._binary_operation(other, "__gt__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __le__(self, other):
         """The rich comparison operator ``<=``
 
@@ -4574,7 +4574,7 @@ def __le__(self, other):
         """
         return self._binary_operation(other, "__le__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __lt__(self, other):
         """The rich comparison operator ``<``
 
@@ -4583,7 +4583,7 @@ def __lt__(self, other):
         """
         return self._binary_operation(other, "__lt__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __and__(self, other):
         """The binary bitwise operation ``&``
 
@@ -4592,7 +4592,7 @@ def __and__(self, other):
         """
         return self._binary_operation(other, "__and__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __iand__(self, other):
         """The augmented bitwise assignment ``&=``
 
@@ -4601,7 +4601,7 @@ def __iand__(self, other):
         """
         return self._binary_operation(other, "__iand__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __rand__(self, other):
         """The binary bitwise operation ``&`` with reflected operands.
 
@@ -4610,7 +4610,7 @@ def __rand__(self, other):
         """
         return self._binary_operation(other, "__rand__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __or__(self, other):
         """The binary bitwise operation ``|``
 
@@ -4619,7 +4619,7 @@ def __or__(self, other):
         """
         return self._binary_operation(other, "__or__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __ior__(self, other):
         """The augmented bitwise assignment ``|=``
 
@@ -4628,7 +4628,7 @@ def __ior__(self, other):
         """
         return self._binary_operation(other, "__ior__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __ror__(self, other):
         """The binary bitwise operation ``|`` with reflected operands.
 
@@ -4637,7 +4637,7 @@ def __ror__(self, other):
         """
         return self._binary_operation(other, "__ror__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __xor__(self, other):
         """The binary bitwise operation ``^``
 
@@ -4646,7 +4646,7 @@ def __xor__(self, other):
         """
         return self._binary_operation(other, "__xor__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __ixor__(self, other):
         """The augmented bitwise assignment ``^=``
 
@@ -4655,7 +4655,7 @@ def __ixor__(self, other):
         """
         return self._binary_operation(other, "__ixor__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __rxor__(self, other):
         """The binary bitwise operation ``^`` with reflected operands.
 
@@ -4664,7 +4664,7 @@ def __rxor__(self, other):
         """
         return self._binary_operation(other, "__rxor__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __lshift__(self, y):
         """The binary bitwise operation ``<<``
 
@@ -4673,7 +4673,7 @@ def __lshift__(self, y):
         """
         return self._binary_operation(y, "__lshift__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __ilshift__(self, y):
         """The augmented bitwise assignment ``<<=``
 
@@ -4682,7 +4682,7 @@ def __ilshift__(self, y):
         """
         return self._binary_operation(y, "__ilshift__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __rlshift__(self, y):
         """The binary bitwise operation ``<<`` with reflected operands.
 
@@ -4691,7 +4691,7 @@ def __rlshift__(self, y):
         """
         return self._binary_operation(y, "__rlshift__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __rshift__(self, y):
         """The binary bitwise operation ``>>``
 
@@ -4700,7 +4700,7 @@ def __rshift__(self, y):
         """
         return self._binary_operation(y, "__rshift__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __irshift__(self, y):
         """The augmented bitwise assignment ``>>=``
 
@@ -4709,7 +4709,7 @@ def __irshift__(self, y):
         """
         return self._binary_operation(y, "__irshift__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __rrshift__(self, y):
         """The binary bitwise operation ``>>`` with reflected operands.
 
@@ -4718,7 +4718,7 @@ def __rrshift__(self, y):
         """
         return self._binary_operation(y, "__rrshift__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __abs__(self):
         """The unary arithmetic operation ``abs``
 
@@ -4727,7 +4727,7 @@ def __abs__(self):
         """
         return self._unary_operation("__abs__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __neg__(self):
         """The unary arithmetic operation ``-``
 
@@ -4736,7 +4736,7 @@ def __neg__(self):
         """
         return self._unary_operation("__neg__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __invert__(self):
         """The unary bitwise operation ``~``
 
@@ -4745,7 +4745,7 @@ def __invert__(self):
         """
         return self._unary_operation("__invert__")
 
-    # SB @daskified(_DASKIFIED_VERBOSE)
+    @daskified(_DASKIFIED_VERBOSE)
     def __pos__(self):
         """The unary arithmetic operation ``+``
 

From 5caa1691ae161efc39a296687a3ac8b98c6cc59d Mon Sep 17 00:00:00 2001
From: "Sadie L. Bartholomew" <sadie.bartholomew@ncas.ac.uk>
Date: Wed, 15 Jun 2022 14:17:18 +0100
Subject: [PATCH 13/21] Update cf/data/data.py: _get_dask -> to_dask_array

Co-authored-by: David Hassell <davidhassell@users.noreply.github.com>
---
 cf/data/data.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cf/data/data.py b/cf/data/data.py
index d94a281788..b63804ff75 100644
--- a/cf/data/data.py
+++ b/cf/data/data.py
@@ -3840,7 +3840,7 @@ def _binary_operation(self, other, method):
         data0, other, new_Units = data0._combined_units(other, method, True)
 
         # Cast as dask arrays
-        dx0 = data0._get_dask()
+        dx0 = data0.to_dask_array()
         dx1 = other._get_dask()
 
         # Set if applicable the tolerance levels for the result

From 4775f139ff6cd8d5842d49b36948e6dcf561c28a Mon Sep 17 00:00:00 2001
From: "Sadie L. Bartholomew" <sadie.bartholomew@ncas.ac.uk>
Date: Wed, 15 Jun 2022 14:17:41 +0100
Subject: [PATCH 14/21] Update cf/data/data.py: _get_dask -> to_dask_array (2)

Co-authored-by: David Hassell <davidhassell@users.noreply.github.com>
---
 cf/data/data.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cf/data/data.py b/cf/data/data.py
index b63804ff75..1892d94a45 100644
--- a/cf/data/data.py
+++ b/cf/data/data.py
@@ -3841,7 +3841,7 @@ def _binary_operation(self, other, method):
 
         # Cast as dask arrays
         dx0 = data0.to_dask_array()
-        dx1 = other._get_dask()
+        dx1 = other.to_dask_array()
 
         # Set if applicable the tolerance levels for the result
         if method in ("__eq__", "__ne__"):  # what about l/g-t-e (x4)?

From 7b1f5437a032596b35645ca4d62335c914de8144 Mon Sep 17 00:00:00 2001
From: "Sadie L. Bartholomew" <sadie.bartholomew@ncas.ac.uk>
Date: Wed, 15 Jun 2022 19:11:55 +0100
Subject: [PATCH 15/21] Update cf/data/data.py: remove deprecated kwarg to
 _set_dask

Co-authored-by: David Hassell <davidhassell@users.noreply.github.com>
---
 cf/data/data.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cf/data/data.py b/cf/data/data.py
index 1892d94a45..328221188a 100644
--- a/cf/data/data.py
+++ b/cf/data/data.py
@@ -3888,7 +3888,7 @@ def _binary_operation(self, other, method):
                 raise TypeError(error)
 
         if inplace:  # in-place so concerns original self
-            self._set_dask(result, reset_mask_hardness=False)
+            self._set_dask(result)
             self.override_units(new_Units, inplace=True)
             return self
         else:  # not, so concerns a new Data object copied from self, data0

From ad09bf78148261e5aa418bb121027acf876f84cb Mon Sep 17 00:00:00 2001
From: "Sadie L. Bartholomew" <sadie.bartholomew@ncas.ac.uk>
Date: Wed, 15 Jun 2022 19:13:36 +0100
Subject: [PATCH 16/21] Update cf/data/data.py: remove deprecated kwarg to
 _set_dask (2)

Co-authored-by: David Hassell <davidhassell@users.noreply.github.com>
---
 cf/data/data.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cf/data/data.py b/cf/data/data.py
index 328221188a..eddb2794b0 100644
--- a/cf/data/data.py
+++ b/cf/data/data.py
@@ -3892,7 +3892,7 @@ def _binary_operation(self, other, method):
             self.override_units(new_Units, inplace=True)
             return self
         else:  # not, so concerns a new Data object copied from self, data0
-            data0._set_dask(result, reset_mask_hardness=False)
+            data0._set_dask(result)
             data0.override_units(new_Units, inplace=True)
             return data0
 

From e832e85691778722cfe8902164c1e5bba92b5025 Mon Sep 17 00:00:00 2001
From: Sadie Louise Bartholomew <sadie.bartholomew@ncas.ac.uk>
Date: Fri, 17 Jun 2022 17:39:06 +0100
Subject: [PATCH 17/21] Address feedback: improve commenting in
 _binary_arithmetic section

---
 cf/data/data.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/cf/data/data.py b/cf/data/data.py
index eddb2794b0..c1692537e6 100644
--- a/cf/data/data.py
+++ b/cf/data/data.py
@@ -3807,11 +3807,10 @@ def _binary_operation(self, other, method):
         inplace = method[2] == "i"
 
         # ------------------------------------------------------------
-        # Ensure that other is an independent Data object
+        # Ensure other is an independent Data object, for example
+        # so that combination with cf.Query objects works.
         # ------------------------------------------------------------
-        # TODODASK is this still needed? Comment below was left unfinished.
         if getattr(other, "_NotImplemented_RHS_Data_op", False):
-            # Make sure that
             return NotImplemented
 
         elif not isinstance(other, self.__class__):

From 7f05719b17090fe338b67562a199c8239a659a41 Mon Sep 17 00:00:00 2001
From: Sadie Louise Bartholomew <sadie.bartholomew@ncas.ac.uk>
Date: Fri, 17 Jun 2022 17:41:43 +0100
Subject: [PATCH 18/21] Address feedback: remove redundant catch in
 _binary_arithmetic

---
 cf/data/data.py | 11 -----------
 1 file changed, 11 deletions(-)

diff --git a/cf/data/data.py b/cf/data/data.py
index c1692537e6..983a30751b 100644
--- a/cf/data/data.py
+++ b/cf/data/data.py
@@ -3874,17 +3874,6 @@ def _binary_operation(self, other, method):
             else:
                 # Raise the floating point error exception
                 raise FloatingPointError(error)
-        except TypeError as error:
-            if inplace:
-                raise TypeError(
-                    "Incompatible result data-type ({0!r}) for "
-                    "in-place {1!r} arithmetic".format(
-                        np.result_type(dx0.dtype, dx1.dtype).name,
-                        dx0.dtype.name,
-                    )
-                )
-            else:
-                raise TypeError(error)
 
         if inplace:  # in-place so concerns original self
             self._set_dask(result)

From 742e48c71943e9ef516416afc205c776200965e3 Mon Sep 17 00:00:00 2001
From: Sadie Louise Bartholomew <sadie.bartholomew@ncas.ac.uk>
Date: Fri, 17 Jun 2022 17:42:50 +0100
Subject: [PATCH 19/21] Address feedback: remove 2nd redundant catch in
 _binary_arithmetic

---
 cf/data/data.py | 34 ++++++++++------------------------
 1 file changed, 10 insertions(+), 24 deletions(-)

diff --git a/cf/data/data.py b/cf/data/data.py
index 983a30751b..01f9fa5e8c 100644
--- a/cf/data/data.py
+++ b/cf/data/data.py
@@ -3850,30 +3850,16 @@ def _binary_operation(self, other, method):
         # ------------------------------------------------------------
         # Perform the binary operation with data0 (self) and data1 (other)
         # ------------------------------------------------------------
-        try:
-            if method == "__eq__":
-                result = _numpy_isclose(dx0, dx1, rtol=rtol, atol=atol)
-            elif method == "__ne__":
-                result = ~_numpy_isclose(dx0, dx1, rtol=rtol, atol=atol)
-            elif inplace:
-                # Find non-in-place equivalent operator (remove 'i')
-                equiv_method = method[:2] + method[3:]
-                result = getattr(dx0, equiv_method)(dx1)
-            else:
-                result = getattr(dx0, method)(dx1)
-
-        except FloatingPointError as error:
-            # Floating point point errors have been trapped
-            if _mask_fpe[0]:
-                # Redo the calculation ignoring the errors and
-                # then set invalid numbers to missing data
-                np.seterr(**_seterr_raise_to_ignore)
-                result = getattr(dx0, method)(dx1)
-                result = np.ma.masked_invalid(dx0, copy=False)
-                np.seterr(**_seterr)
-            else:
-                # Raise the floating point error exception
-                raise FloatingPointError(error)
+        if method == "__eq__":
+            result = _numpy_isclose(dx0, dx1, rtol=rtol, atol=atol)
+        elif method == "__ne__":
+            result = ~_numpy_isclose(dx0, dx1, rtol=rtol, atol=atol)
+        elif inplace:
+            # Find non-in-place equivalent operator (remove 'i')
+            equiv_method = method[:2] + method[3:]
+            result = getattr(dx0, equiv_method)(dx1)
+        else:
+            result = getattr(dx0, method)(dx1)
 
         if inplace:  # in-place so concerns original self
             self._set_dask(result)

From 6f7d1d7148bd2933f8ef40dafb21036b1bb356c5 Mon Sep 17 00:00:00 2001
From: Sadie Louise Bartholomew <sadie.bartholomew@ncas.ac.uk>
Date: Fri, 17 Jun 2022 17:48:21 +0100
Subject: [PATCH 20/21] Update calls from cf's custom _numpy_isclose to
 da.isclose

---
 cf/data/data.py | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/cf/data/data.py b/cf/data/data.py
index 01f9fa5e8c..826a8fcccc 100644
--- a/cf/data/data.py
+++ b/cf/data/data.py
@@ -30,7 +30,6 @@
 )
 from ..functions import (
     _DEPRECATION_ERROR_KWARGS,
-    _numpy_isclose,
     _section,
     abspath,
 )
@@ -3843,7 +3842,7 @@ def _binary_operation(self, other, method):
         dx1 = other.to_dask_array()
 
         # Set if applicable the tolerance levels for the result
-        if method in ("__eq__", "__ne__"):  # what about l/g-t-e (x4)?
+        if method in ("__eq__", "__ne__"):
             rtol = self._rtol
             atol = self._atol
 
@@ -3851,9 +3850,9 @@ def _binary_operation(self, other, method):
         # Perform the binary operation with data0 (self) and data1 (other)
         # ------------------------------------------------------------
         if method == "__eq__":
-            result = _numpy_isclose(dx0, dx1, rtol=rtol, atol=atol)
+            result = da.isclose(dx0, dx1, rtol=rtol, atol=atol)
         elif method == "__ne__":
-            result = ~_numpy_isclose(dx0, dx1, rtol=rtol, atol=atol)
+            result = ~da.isclose(dx0, dx1, rtol=rtol, atol=atol)
         elif inplace:
             # Find non-in-place equivalent operator (remove 'i')
             equiv_method = method[:2] + method[3:]

From 2e71011e121a4ea708c0659266b83f8cee1a19ba Mon Sep 17 00:00:00 2001
From: Sadie Louise Bartholomew <sadie.bartholomew@ncas.ac.uk>
Date: Fri, 17 Jun 2022 17:54:14 +0100
Subject: [PATCH 21/21] Deprecate (internal => remove) cf's now-redundant
 _numpy_isclose

---
 cf/functions.py | 34 ----------------------------------
 1 file changed, 34 deletions(-)

diff --git a/cf/functions.py b/cf/functions.py
index 23f146ee18..0f4db82ce1 100644
--- a/cf/functions.py
+++ b/cf/functions.py
@@ -31,7 +31,6 @@
 from numpy import all as _numpy_all
 from numpy import allclose as _x_numpy_allclose
 from numpy import ascontiguousarray as _numpy_ascontiguousarray
-from numpy import isclose as _x_numpy_isclose
 from numpy import shape as _numpy_shape
 from numpy import take as _numpy_take
 from numpy import tile as _numpy_tile
@@ -1843,39 +1842,6 @@ def _numpy_allclose(a, b, rtol=None, atol=None, verbose=None):
                 return out
 
 
-def _numpy_isclose(a, b, rtol=None, atol=None):
-    """Returns a boolean array where two broadcastable arrays are
-    element-wise equal within a tolerance.
-
-    The tolerance values are positive, typically very small numbers. The
-    relative difference (``rtol * abs(b)``) and the absolute difference
-    ``atol`` are added together to compare against the absolute difference
-    between ``a`` and ``b``.
-
-    :Parameters:
-
-        a, b: array_like
-            Input arrays to compare.
-
-        atol: `float`, optional
-            The absolute tolerance for all numerical comparisons, By
-            default the value returned by the `atol` function is used.
-
-        rtol: `float`, optional
-            The relative tolerance for all numerical comparisons, By
-            default the value returned by the `rtol` function is used.
-
-    :Returns:
-
-        `numpy.ndarray`
-
-    """
-    try:
-        return _x_numpy_isclose(a, b, rtol=rtol, atol=atol)
-    except (IndexError, NotImplementedError, TypeError):
-        return a == b
-
-
 # TODODASK - sort out the "numpy" environment