Merge 517710c into 4e02172

Author: antonwolfy

dpnp/dpnp_array.py

@@ -150,7 +150,7 @@ def mT(self):
         if self.ndim < 2:
             raise ValueError("matrix transpose with ndim < 2 is undefined")
 
-        return self._array_obj.mT
+        return dpnp_array._create_from_usm_ndarray(self._array_obj.mT)
 
     def to_device(self, target_device):
         """Transfer array to target device."""

dpnp/random/dpnp_iface_random.py

@@ -1022,25 +1022,31 @@ def power(a, size=None):
     return call_origin(numpy.random.power, a, size)
 
 
-def rand(d0, *dn, device=None, usm_type="device", sycl_queue=None):
+def rand(*args, device=None, usm_type="device", sycl_queue=None):
     """
     Random values in a given shape.
 
-    Create an array of the given shape and populate it with random samples
-    from a uniform distribution over [0, 1).
+    Create an array of the given shape and populate it with random samples from
+    a uniform distribution over ``[0, 1)``.
 
     For full documentation refer to :obj:`numpy.random.rand`.
 
     Parameters
     ----------
+    d0, d1, ..., dn : int, optional
+        The dimensions of the returned array, must be non-negative.
+        If no argument is given a single Python float is returned.
     device : {None, string, SyclDevice, SyclQueue}, optional
         An array API concept of device where the output array is created.
-        The `device` can be ``None`` (the default), an OneAPI filter selector string,
-        an instance of :class:`dpctl.SyclDevice` corresponding to a non-partitioned SYCL device,
-        an instance of :class:`dpctl.SyclQueue`, or a `Device` object returned by
+        The `device` can be ``None`` (the default), an OneAPI filter selector
+        string, an instance of :class:`dpctl.SyclDevice` corresponding to
+        a non-partitioned SYCL device, an instance of :class:`dpctl.SyclQueue`,
+        or a `Device` object returned by
         :obj:`dpnp.dpnp_array.dpnp_array.device` property.
+        Default: ``None``.
     usm_type : {"device", "shared", "host"}, optional
         The type of SYCL USM allocation for the output array.
+        Default: ``"device"``.
     sycl_queue : {None, SyclQueue}, optional
         A SYCL queue to use for output array allocation and copying. The
         `sycl_queue` can be passed as ``None`` (the default), which means
@@ -1051,23 +1057,27 @@ def rand(d0, *dn, device=None, usm_type="device", sycl_queue=None):
     Returns
     -------
     out : dpnp.ndarray
-        Random values in a given shape.
-        Output array data type is :obj:`dpnp.float64` if device supports it, or :obj:`dpnp.float32` otherwise.
+        Random values in a given shape ``(d0, d1, ..., dn)``.
+        Output array data type is :obj:`dpnp.float64` if a device supports it,
+        or :obj:`dpnp.float32` type otherwise.
 
-    Examples
+    See Also
     --------
-    >>> s = dpnp.random.rand(3, 2)
+    :obj:`dpnp.random.random` : Return random floats in the half-open interval
+                                ``[0.0, 1.0)``.
+    :obj:`dpnp.random.random_sample` : Return random floats in the half-open
+                                       interval ``[0.0, 1.0)``.
+    :obj:`dpnp.random.uniform` : Draw samples from a uniform distribution.
 
-    See Also
+    Examples
     --------
-    :obj:`dpnp.random.random`
-    :obj:`dpnp.random.random_sample`
-    :obj:`dpnp.random.uniform`
+    >>> import dpnp as np
+    >>> s = np.random.rand(3, 2)
 
     """
 
     rs = _get_random_state(device=device, sycl_queue=sycl_queue)
-    return rs.rand(d0, *dn, usm_type=usm_type)
+    return rs.rand(*args, usm_type=usm_type)
 
 
 def randint(

dpnp/tests/skipped_tests.tbl

@@ -1078,24 +1078,27 @@ def test_vecdot(device, shape_pair):
 
 
 @pytest.mark.parametrize(
-    "func, kwargs",
+    "func, args, kwargs",
     [
-        pytest.param("normal", {"loc": 1.0, "scale": 3.4, "size": (5, 12)}),
-        pytest.param("rand", {"d0": 20}),
+        pytest.param("normal", [], {"loc": 1.0, "scale": 3.4, "size": (5, 12)}),
+        pytest.param("rand", [20], {}),
         pytest.param(
             "randint",
+            [],
             {"low": 2, "high": 15, "size": (4, 8, 16), "dtype": dpnp.int32},
         ),
-        pytest.param("randn", {"d0": 20}),
-        pytest.param("random", {"size": (35, 45)}),
+        pytest.param("randn", [], {"d0": 20}),
+        pytest.param("random", [], {"size": (35, 45)}),
+        pytest.param(
+            "random_integers", [], {"low": -17, "high": 3, "size": (12, 16)}
+        ),
+        pytest.param("random_sample", [], {"size": (7, 7)}),
+        pytest.param("ranf", [], {"size": (10, 7, 12)}),
+        pytest.param("sample", [], {"size": (7, 9)}),
+        pytest.param("standard_normal", [], {"size": (4, 4, 8)}),
         pytest.param(
-            "random_integers", {"low": -17, "high": 3, "size": (12, 16)}
+            "uniform", [], {"low": 1.0, "high": 2.0, "size": (4, 2, 5)}
         ),
-        pytest.param("random_sample", {"size": (7, 7)}),
-        pytest.param("ranf", {"size": (10, 7, 12)}),
-        pytest.param("sample", {"size": (7, 9)}),
-        pytest.param("standard_normal", {"size": (4, 4, 8)}),
-        pytest.param("uniform", {"low": 1.0, "high": 2.0, "size": (4, 2, 5)}),
     ],
 )
 @pytest.mark.parametrize(
@@ -1104,11 +1107,11 @@ def test_vecdot(device, shape_pair):
     ids=[device.filter_string for device in valid_devices],
 )
 @pytest.mark.parametrize("usm_type", ["host", "device", "shared"])
-def test_random(func, kwargs, device, usm_type):
+def test_random(func, args, kwargs, device, usm_type):
     kwargs = {**kwargs, "device": device, "usm_type": usm_type}
 
     # test with default SYCL queue per a device
-    res_array = getattr(dpnp.random, func)(**kwargs)
+    res_array = getattr(dpnp.random, func)(*args, **kwargs)
     assert device == res_array.sycl_device
     assert usm_type == res_array.usm_type
 
@@ -1120,7 +1123,7 @@ def test_random(func, kwargs, device, usm_type):
     kwargs["sycl_queue"] = sycl_queue
 
     # test with in-order SYCL queue per a device and passed as argument
-    res_array = getattr(dpnp.random, func)(**kwargs)
+    res_array = getattr(dpnp.random, func)(*args, **kwargs)
     assert usm_type == res_array.usm_type
     assert_sycl_queue_equal(res_array.sycl_queue, sycl_queue)