Added CFD tests

Author: antonwolfy

dpnp/dpnp_iface_histograms.py

@@ -59,6 +59,7 @@ def _ravel_check_a_and_weights(a, weights):
 
     # ensure that `a` array has supported type
     dpnp.check_supported_arrays_type(a)
+    usm_type = a.usm_type
 
     # ensure that the array is a "subtractable" dtype
     if a.dtype == dpnp.bool:
@@ -73,6 +74,7 @@ def _ravel_check_a_and_weights(a, weights):
     if weights is not None:
         # check that `weights` array has supported type
         dpnp.check_supported_arrays_type(weights)
+        usm_type = dpu.get_coerced_usm_type([usm_type, weights.usm_type])
 
         # check that arrays have the same allocation queue
         if dpu.get_execution_queue([a.sycl_queue, weights.sycl_queue]) is None:
@@ -84,7 +86,7 @@ def _ravel_check_a_and_weights(a, weights):
             raise ValueError("weights should have the same shape as a.")
         weights = weights.ravel()
     a = a.ravel()
-    return a, weights
+    return a, weights, usm_type
 
 
 def _get_outer_edges(a, range):
@@ -124,12 +126,13 @@ def _get_outer_edges(a, range):
     return first_edge, last_edge
 
 
-def _get_bin_edges(a, bins, range):
+def _get_bin_edges(a, bins, range, usm_type):
     """Computes the bins used internally by `histogram`."""
 
     # parse the overloaded bins argument
     n_equal_bins = None
     bin_edges = None
+    sycl_queue = a.sycl_queue
 
     if isinstance(bins, str):
         raise NotImplementedError("only integer and array bins are implemented")
@@ -154,7 +157,7 @@ def _get_bin_edges(a, bins, range):
             bin_edges = bins
         else:
             bin_edges = dpnp.asarray(
-                bins, sycl_queue=a.sycl_queue, usm_type=a.usm_type
+                bins, sycl_queue=sycl_queue, usm_type=usm_type
             )
 
         if dpnp.any(bin_edges[:-1] > bin_edges[1:]):
@@ -172,7 +175,7 @@ def _get_bin_edges(a, bins, range):
         bin_type = dpnp.result_type(first_edge, last_edge, a)
         if dpnp.issubdtype(bin_type, dpnp.integer):
             bin_type = dpnp.result_type(
-                bin_type, dpnp.default_float_type(sycl_queue=a.sycl_queue), a
+                bin_type, dpnp.default_float_type(sycl_queue=sycl_queue), a
             )
 
         # bin edges must be computed
@@ -182,8 +185,8 @@ def _get_bin_edges(a, bins, range):
             n_equal_bins + 1,
             endpoint=True,
             dtype=bin_type,
-            sycl_queue=a.sycl_queue,
-            usm_type=a.usm_type,
+            sycl_queue=sycl_queue,
+            usm_type=usm_type,
         )
         return bin_edges, (first_edge, last_edge, n_equal_bins)
     return bin_edges, None
@@ -285,9 +288,9 @@ def histogram(a, bins=10, range=None, density=None, weights=None):
 
     """
 
-    a, weights = _ravel_check_a_and_weights(a, weights)
+    a, weights, usm_type = _ravel_check_a_and_weights(a, weights)
 
-    bin_edges, uniform_bins = _get_bin_edges(a, bins, range)
+    bin_edges, uniform_bins = _get_bin_edges(a, bins, range, usm_type)
 
     # Histogram is an integer or a float array depending on the weights.
     if weights is None:
@@ -320,7 +323,9 @@ def histogram(a, bins=10, range=None, density=None, weights=None):
                 sa = dpnp.sort(a[i : i + block_size])
                 cum_n += _search_sorted_inclusive(sa, bin_edges)
         else:
-            zero = dpnp.zeros(1, dtype=ntype)
+            zero = dpnp.zeros(
+                1, dtype=ntype, sycl_queue=a.sycl_queue, usm_type=a.usm_type
+            )
             for i in _range(0, len(a), block_size):
                 tmp_a = a[i : i + block_size]
                 tmp_w = weights[i : i + block_size]

tests/test_sycl_queue.py

@@ -2022,3 +2022,27 @@ def test_tensorsolve(device):
     result_queue = result.sycl_queue
 
     assert_sycl_queue_equal(result_queue, a_dp.sycl_queue)
+
+
+@pytest.mark.parametrize("weights", [None, numpy.arange(7, 12)])
+@pytest.mark.parametrize(
+    "device",
+    valid_devices,
+    ids=[device.filter_string for device in valid_devices],
+)
+def test_histogram(weights, device):
+    v = numpy.arange(5)
+    w = weights
+
+    iv = dpnp.array(v, device=device)
+    iw = None if weights is None else dpnp.array(w, sycl_queue=iv.sycl_queue)
+
+    expected_hist, expected_edges = numpy.histogram(v, weights=w)
+    result_hist, result_edges = dpnp.histogram(iv, weights=iw)
+    assert_array_equal(result_hist, expected_hist)
+    assert_dtype_allclose(result_edges, expected_edges)
+
+    hist_queue = result_hist.sycl_queue
+    edges_queue = result_edges.sycl_queue
+    assert_sycl_queue_equal(hist_queue, iv.sycl_queue)
+    assert_sycl_queue_equal(edges_queue, iv.sycl_queue)

tests/test_usm_type.py

@@ -1170,3 +1170,16 @@ def test_tensorsolve(usm_type_a, usm_type_b):
     assert a.usm_type == usm_type_a
     assert b.usm_type == usm_type_b
     assert result.usm_type == du.get_coerced_usm_type([usm_type_a, usm_type_b])
+
+
+@pytest.mark.parametrize("usm_type_v", list_of_usm_types, ids=list_of_usm_types)
+@pytest.mark.parametrize("usm_type_w", list_of_usm_types, ids=list_of_usm_types)
+def test_histogram(usm_type_v, usm_type_w):
+    v = dp.arange(5, usm_type=usm_type_v)
+    w = dp.arange(7, 12, usm_type=usm_type_w)
+
+    hist, edges = dp.histogram(v, weights=w)
+    assert v.usm_type == usm_type_v
+    assert w.usm_type == usm_type_w
+    assert hist.usm_type == du.get_coerced_usm_type([usm_type_v, usm_type_w])
+    assert edges.usm_type == du.get_coerced_usm_type([usm_type_v, usm_type_w])