Added tests for full() and full_like() functions

Author: npolina4

dpnp/backend/include/dpnp_iface_fptr.hpp

@@ -179,7 +179,6 @@ enum class DPNPFuncName : size_t
     DPNP_FN_FMOD_EXT,                     /**< Used in numpy.fmod() impl, requires extra parameters  */
     DPNP_FN_FULL,                         /**< Used in numpy.full() impl  */
     DPNP_FN_FULL_LIKE,                    /**< Used in numpy.full_like() impl  */
-    DPNP_FN_FULL_LIKE_EXT,                /**< Used in numpy.full_like() impl, requires extra parameters  */
     DPNP_FN_HYPOT,                        /**< Used in numpy.hypot() impl  */
     DPNP_FN_HYPOT_EXT,                    /**< Used in numpy.hypot() impl, requires extra parameters  */
     DPNP_FN_IDENTITY,                     /**< Used in numpy.identity() impl  */

dpnp/backend/kernels/dpnp_krnl_arraycreation.cpp

@@ -346,13 +346,6 @@ void dpnp_full_like_c(void* array_in, void* result, const size_t size)
 template <typename _DataType>
 void (*dpnp_full_like_default_c)(void*, void*, const size_t) = dpnp_full_like_c<_DataType>;
 
-template <typename _DataType>
-DPCTLSyclEventRef (*dpnp_full_like_ext_c)(DPCTLSyclQueueRef,
-                                          void*,
-                                          void*,
-                                          const size_t,
-                                          const DPCTLEventVectorRef) = dpnp_full_like_c<_DataType>;
-
 template <typename _KernelNameSpecialization>
 class dpnp_identity_c_kernel;
 
@@ -1341,14 +1334,6 @@ void func_map_init_arraycreation(func_map_t& fmap)
     fmap[DPNPFuncName::DPNP_FN_FULL_LIKE][eft_C128][eft_C128] = {
         eft_C128, (void*)dpnp_full_like_default_c<std::complex<double>>};
 
-    fmap[DPNPFuncName::DPNP_FN_FULL_LIKE_EXT][eft_INT][eft_INT] = {eft_INT, (void*)dpnp_full_like_ext_c<int32_t>};
-    fmap[DPNPFuncName::DPNP_FN_FULL_LIKE_EXT][eft_LNG][eft_LNG] = {eft_LNG, (void*)dpnp_full_like_ext_c<int64_t>};
-    fmap[DPNPFuncName::DPNP_FN_FULL_LIKE_EXT][eft_FLT][eft_FLT] = {eft_FLT, (void*)dpnp_full_like_ext_c<float>};
-    fmap[DPNPFuncName::DPNP_FN_FULL_LIKE_EXT][eft_DBL][eft_DBL] = {eft_DBL, (void*)dpnp_full_like_ext_c<double>};
-    fmap[DPNPFuncName::DPNP_FN_FULL_LIKE_EXT][eft_BLN][eft_BLN] = {eft_BLN, (void*)dpnp_full_like_ext_c<bool>};
-    fmap[DPNPFuncName::DPNP_FN_FULL_LIKE_EXT][eft_C128][eft_C128] = {
-        eft_C128, (void*)dpnp_full_like_ext_c<std::complex<double>>};
-
     fmap[DPNPFuncName::DPNP_FN_IDENTITY][eft_INT][eft_INT] = {eft_INT, (void*)dpnp_identity_default_c<int32_t>};
     fmap[DPNPFuncName::DPNP_FN_IDENTITY][eft_LNG][eft_LNG] = {eft_LNG, (void*)dpnp_identity_default_c<int64_t>};
     fmap[DPNPFuncName::DPNP_FN_IDENTITY][eft_FLT][eft_FLT] = {eft_FLT, (void*)dpnp_identity_default_c<float>};

dpnp/dpnp_algo/dpnp_algo.pxd

@@ -155,7 +155,6 @@ cdef extern from "dpnp_iface_fptr.hpp" namespace "DPNPFuncName":  # need this na
         DPNP_FN_FMOD_EXT
         DPNP_FN_FULL
         DPNP_FN_FULL_LIKE
-        DPNP_FN_FULL_LIKE_EXT
         DPNP_FN_HYPOT
         DPNP_FN_HYPOT_EXT
         DPNP_FN_IDENTITY

dpnp/dpnp_algo/dpnp_algo_arraycreation.pyx

@@ -1,7 +1,7 @@
 # cython: language_level=3
 # -*- coding: utf-8 -*-
 # *****************************************************************************
-# Copyright (c) 2016-2020, Intel Corporation
+# Copyright (c) 2016-2022, Intel Corporation
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without

dpnp/dpnp_container.py

@@ -124,12 +124,9 @@ def full(shape,
          sycl_queue=None):
     """Validate input parameters before passing them into `dpctl.tensor` module"""
     dpu.validate_usm_type(usm_type, allow_none=True)
-    if sycl_queue is None and device is None:
-        sycl_queue_normalized = None
-    else:
-        sycl_queue_normalized = dpnp.get_normalized_queue_device(sycl_queue=sycl_queue, device=device)
+    sycl_queue_normalized = dpnp.get_normalized_queue_device(fill_value, sycl_queue=sycl_queue, device=device)
 
-    if isinstance(fill_value, dpnp.ndarray):
+    if isinstance(fill_value, dpnp_array):
         fill_value = fill_value.get_array()
 
     """Creates `dpnp_array` where every element is equal to fill_value."""

dpnp/dpnp_iface_arraycreation.py

@@ -697,12 +697,13 @@ def full(shape,
     """
     if like is not None:
         pass
-    elif order not in "cCfF":
+    elif not isinstance(order, str) or len(order) != 1 or order not in "CcFf":
         pass
     else:
         return dpnp_container.full(shape,
                                    fill_value,
                                    dtype=dtype,
+                                   order=order,
                                    device=device,
                                    usm_type=usm_type,
                                    sycl_queue=sycl_queue)
@@ -711,6 +712,7 @@ def full(shape,
 
 
 def full_like(x1,
+              /,
               fill_value,
               *,
               dtype=None,
@@ -729,6 +731,7 @@ def full_like(x1,
     -----------
     Parameter ``order`` is supported only with values ``"C"`` and ``"F"``.
     Parameter ``subok`` is supported only with default value ``False``.
+    Otherwise the function will be executed sequentially on CPU.
 
     See Also
     --------
@@ -746,20 +749,24 @@ def full_like(x1,
     [1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
 
     """
-    if order not in "cCfF":
+    if not isinstance(x1, dpnp.ndarray):
+        pass
+    elif not isinstance(order, str) or len(order) != 1 or order not in "CcFf":
         pass
-    elif subok is True:
+    elif subok is not False:
         pass
     else:
         _shape = shape if shape is not None else x1.shape
         _dtype = dtype if dtype is not None else x1.dtype
         _usm_type = usm_type if usm_type is not None else x1.usm_type
-        if sycl_queue is None and device is None:
-            _sycl_queue = x1.sycl_queue
-        else:
-            _sycl_queue = dpnp.get_normalized_queue_device(sycl_queue=sycl_queue, device=device)
+        _sycl_queue = dpnp.get_normalized_queue_device(x1, sycl_queue=sycl_queue, device=device)
 
-        return full(_shape, fill_value, dtype=_dtype, usm_type=_usm_type, sycl_queue=_sycl_queue)
+        return dpnp_container.full(_shape,
+                                   fill_value,
+                                   dtype=_dtype,
+                                   order=order,
+                                   usm_type=_usm_type,
+                                   sycl_queue=_sycl_queue)
     return numpy.full_like(x1, fill_value, dtype, order, subok, shape)
 
 

tests/skipped_tests.tbl

@@ -289,9 +289,6 @@ tests/third_party/cupy/creation_tests/test_basic.py::TestBasic::test_empty_int
 tests/third_party/cupy/creation_tests/test_basic.py::TestBasic::test_empty_like
 tests/third_party/cupy/creation_tests/test_basic.py::TestBasic::test_empty_like_contiguity
 tests/third_party/cupy/creation_tests/test_basic.py::TestBasic::test_empty_scalar
-tests/third_party/cupy/creation_tests/test_basic.py::TestBasic::test_full
-tests/third_party/cupy/creation_tests/test_basic.py::TestBasic::test_full_default_dtype_cpu_input
-tests/third_party/cupy/creation_tests/test_basic.py::TestBasic::test_full_like
 tests/third_party/cupy/creation_tests/test_basic.py::TestBasic::test_zeros_scalar
 tests/third_party/cupy/creation_tests/test_basic.py::TestBasicReshape_param_0_{shape=4}::test_empty_like_reshape
 tests/third_party/cupy/creation_tests/test_basic.py::TestBasicReshape_param_0_{shape=4}::test_empty_like_reshape_contiguity
@@ -364,7 +361,6 @@ tests/third_party/cupy/creation_tests/test_basic.py::TestBasic::test_empty_like_
 tests/third_party/cupy/creation_tests/test_basic.py::TestBasic::test_empty_like_subok
 tests/third_party/cupy/creation_tests/test_basic.py::TestBasic::test_empty_zero_sized_array_strides
 tests/third_party/cupy/creation_tests/test_basic.py::TestBasic::test_eye
-tests/third_party/cupy/creation_tests/test_basic.py::TestBasic::test_full_default_dtype
 tests/third_party/cupy/creation_tests/test_basic.py::TestBasic::test_full_like_subok
 tests/third_party/cupy/creation_tests/test_basic.py::TestBasic::test_ones_like_subok
 tests/third_party/cupy/creation_tests/test_basic.py::TestBasic::test_zeros_like_subok

tests/test_arraycreation.py

@@ -350,24 +350,42 @@ def test_vander(array, type, n, increase):
     numpy.testing.assert_array_equal(expected, result)
 
 
-def test_full_compute_follows_data():
-    q1 = dpnp.dpnp_queue_initialize()
-    q2 = dpnp.dpnp_queue_initialize()
+@pytest.mark.parametrize("shape",
+                         [(), 0, (0,), (2, 0, 3), (3, 2)],
+                         ids=['()', '0', '(0,)', '(2, 0, 3)', '(1, 2)'])
+@pytest.mark.parametrize("fill_value",
+                         [1.5, 2, 1.5+0.j],
+                         ids=['1.5', '2', '1.5+0.j'])
+@pytest.mark.parametrize("dtype",
+                         [numpy.complex128, numpy.complex64, numpy.float64, numpy.float32, numpy.float16, numpy.int64, numpy.int32],
+                         ids=['complex128', 'complex64', 'float64', 'float32', 'float16', 'int64', 'int32'])
+def test_full(shape, fill_value, dtype):
+    expected = numpy.full(shape, fill_value, dtype=dtype)
+    result = dpnp.full(shape, fill_value, dtype=dtype)
 
-    X = dpnp.full(10, 3, dtype="i4", sycl_queue=q1, usm_type="shared")
-    Y = dpnp.full(10, X[3])
+    assert expected.dtype == result.dtype
+    numpy.testing.assert_array_equal(expected, result)
 
-    assert Y.dtype == X.dtype
-    assert Y.usm_type == X.usm_type
-    assert Y.sycl_queue.__eq__(X.sycl_queue)
-    assert numpy.array_equal(dpnp.asnumpy(Y), numpy.full(10, 3, dtype="i4"))
 
-    Y = dpnp.full(10, X[3], dtype="f4", sycl_queue=q2, usm_type="host")
+@pytest.mark.parametrize("array",
+                         [[], 0,  [1, 2, 3], [[1, 2], [3, 4]]],
+                         ids=['[]', '0',  '[1, 2, 3]', '[[1, 2], [3, 4]]'])
+@pytest.mark.parametrize("fill_value",
+                         [1.5, 2, 1.5+0.j],
+                         ids=['1.5', '2', '1.5+0.j'])
+@pytest.mark.parametrize("dtype",
+                         [numpy.complex128, numpy.complex64, numpy.float64, numpy.float32, numpy.float16, numpy.int64, numpy.int32],
+                         ids=['complex128', 'complex64', 'float64', 'float32', 'float16', 'int64', 'int32'])
+def test_full_like(array, fill_value, dtype):
+    a = numpy.array(array)
+    ia = dpnp.array(array)
+
+    expected = numpy.full_like(a, fill_value, dtype=dtype)
+    result = dpnp.full_like(ia, fill_value, dtype=dtype)
 
-    assert Y.dtype == dpnp.dtype("f4")
-    assert Y.usm_type == "host"
-    assert Y.sycl_queue.__eq__(dpnp.empty(0, sycl_queue=q2).sycl_queue)
-    assert numpy.array_equal(dpnp.asnumpy(Y), numpy.full(10, 3, dtype="f4"))
+    assert expected.shape == result.shape
+    assert expected.dtype == result.dtype
+    numpy.testing.assert_array_equal(expected, result)
 
 
 @pytest.mark.skip(reason="dpnp.ndarray.flags are not implemented")
@@ -378,32 +396,29 @@ def test_full_compute_follows_data():
                          ["F", "C"],
                          ids=['F', 'C'])
 def test_full_order(order1, order2):
-    Xnp = numpy.array([1, 2, 3], order=order1)
-    Ynp = numpy.full((3, 3), Xnp, order=order2)
-    Y = dpnp.full((3, 3), Xnp, order=order2)
+    array = numpy.array([1, 2, 3], order=order1)
+    a = numpy.full((3, 3), array, order=order2)
+    ia = dpnp.full((3, 3), array, order=order2)
 
-    assert Y.flags.c_contiguous == Ynp.flags.c_contiguous
-    assert Y.flags.f_contiguous == Ynp.flags.f_contiguous
-    assert numpy.array_equal(dpnp.asnumpy(Y), Ynp)
+    assert ia.flags.c_contiguous == a.flags.c_contiguous
+    assert ia.flags.f_contiguous == a.flags.f_contiguous
+    assert numpy.array_equal(dpnp.asnumpy(ia), a)
 
 
 def test_full_strides():
-    X = dpnp.full((3, 3), dpnp.arange(3, dtype="i4"))
-    Xnp = numpy.full((3, 3), numpy.arange(3, dtype="i4"))
-    assert X.strides == tuple(el // Xnp.itemsize for el in Xnp.strides)
-    assert numpy.array_equal(dpnp.asnumpy(X), Xnp)
-
-    X = dpnp.full((3, 3), dpnp.arange(6, dtype="i4")[::2])
-    Xnp = numpy.full((3, 3), numpy.arange(6, dtype="i4")[::2])
-    assert X.strides == tuple(el // Xnp.itemsize for el in Xnp.strides)
-    assert numpy.array_equal(dpnp.asnumpy(X), Xnp)
-
-
-def test_full_like_compute_follows_data():
-    X = dpnp.full(10, 3, dtype="i4", usm_type="shared")
-    Y = dpnp.full_like(X, 4, shape=(8))
-
-    assert Y.dtype == X.dtype
-    assert Y.usm_type == X.usm_type
-    assert Y.sycl_queue.__eq__(X.sycl_queue)
-    assert numpy.array_equal(dpnp.asnumpy(Y), numpy.full(8, 4, dtype="i4"))
+    a = numpy.full((3, 3), numpy.arange(3, dtype="i4"))
+    ia = dpnp.full((3, 3), dpnp.arange(3, dtype="i4"))
+    assert ia.strides == tuple(el // a.itemsize for el in a.strides)
+    assert numpy.array_equal(dpnp.asnumpy(ia), a)
+
+    a = numpy.full((3, 3), numpy.arange(6, dtype="i4")[::2])
+    ia = dpnp.full((3, 3), dpnp.arange(6, dtype="i4")[::2])
+    assert ia.strides == tuple(el // a.itemsize for el in a.strides)
+    assert numpy.array_equal(dpnp.asnumpy(ia), a)
+
+
+def test_full_invalid_fill_value():
+    with pytest.raises(ValueError):
+        dpnp.full(10, [])
+    with pytest.raises(ValueError):
+        dpnp.full(10, dpnp.full(0, 0))

tests/test_sycl_queue.py

@@ -77,7 +77,10 @@ def vvsort(val, vec, size, xp):
     [
         pytest.param("arange",
                      -25.7,
-                     {'stop': 10**8, 'step': 15})
+                     {'stop': 10**8, 'step': 15}),
+        pytest.param("full",
+                     (2,2),
+                     {'fill_value': 5})
     ])
 @pytest.mark.parametrize("device",
                           valid_devices,
@@ -93,6 +96,36 @@ def test_array_creation(func, arg, kwargs, device):
     assert dpnp_array.sycl_device == device
 
 
+@pytest.mark.parametrize(
+    "func, kwargs",
+    [
+        pytest.param("full_like",
+                     {'fill_value': 5})
+    ])
+@pytest.mark.parametrize("device_x",
+                          valid_devices,
+                          ids=[device.filter_string for device in valid_devices])
+@pytest.mark.parametrize("device_y",
+                          valid_devices,
+                          ids=[device.filter_string for device in valid_devices])
+def test_array_creation_like(func, kwargs, device_x, device_y):
+    x_orig = numpy.ndarray([1, 2, 3])
+    y_orig = getattr(numpy, func)(x_orig, **kwargs)
+
+    x = dpnp.ndarray([1, 2, 3], device=device_x)
+
+    y = getattr(dpnp, func)(x, **kwargs)
+    numpy.testing.assert_array_equal(y_orig, y)
+    assert y.sycl_device == device_x
+
+    dpnp_kwargs = dict(kwargs)
+    dpnp_kwargs['device'] = device_y
+    
+    y = getattr(dpnp, func)(x, **dpnp_kwargs)
+    numpy.testing.assert_array_equal(y_orig, y)
+    assert y.sycl_device == device_y
+
+
 @pytest.mark.usefixtures("allow_fall_back_on_numpy")
 @pytest.mark.parametrize(
     "func,data",

tests/test_usm_type.py

@@ -34,3 +34,19 @@ def test_coerced_usm_types_mul(usm_type_x, usm_type_y):
     assert x.usm_type == usm_type_x
     assert y.usm_type == usm_type_y
     assert z.usm_type == du.get_coerced_usm_type([usm_type_x, usm_type_y])
+
+
+@pytest.mark.parametrize("usm_type_x", list_of_usm_types, ids=list_of_usm_types)
+@pytest.mark.parametrize("usm_type_y", list_of_usm_types, ids=list_of_usm_types)
+def test_array_creation(usm_type_x, usm_type_y):
+    x0 = dp.full(10, 3, usm_type=usm_type_x)
+
+    x = dp.full(10, x0[3])
+    y = dp.full(10, x0[3], usm_type=usm_type_y)
+    assert x.usm_type == usm_type_x
+    assert y.usm_type == usm_type_y
+
+    x = dp.full_like(x0, 4)
+    y = dp.full_like(x0, 4, usm_type=usm_type_y)
+    assert x.usm_type == usm_type_x
+    assert y.usm_type == usm_type_y

tests/third_party/cupy/core_tests/test_ndarray_conversion.py

@@ -18,7 +18,7 @@ class TestNdarrayItem(unittest.TestCase):
     @testing.for_all_dtypes()
     @testing.numpy_cupy_equal()
     def test_item(self, xp, dtype):
-        a = xp.full(self.shape, 3, dtype)
+        a = xp.full(self.shape, 3, dtype=dtype)
         return a.item()