Formatting, documentation adjusted

Author: ndgrigorian

dpctl/tensor/_ctors.py

@@ -1036,6 +1036,7 @@ def linspace(
     hev.wait()
     return res
 
+
 def eye(
     n_rows,
     n_cols=None,
@@ -1047,61 +1048,73 @@ def eye(
     device=None,
     usm_type="device",
     sycl_queue=None
-    ):
-        """
-        eye(n_rows, n_cols = None, /, *, k = 0, dtype = None, \
-        device = None, usm_type="device", sycl_queue=None) -> usm_ndarray
+):
+    """
+    eye(n_rows, n_cols = None, /, *, k = 0, dtype = None, \
+    device = None, usm_type="device", sycl_queue=None) -> usm_ndarray
 
-        Creates `usm_ndarray` where the `k`th diagonal elements are one and others are zero.
+    Creates `usm_ndarray` with ones on the `k`th diagonal.
 
-        Args:
-            n_rows: number of rows in the output array.
-            n_cols (optional): number of columns in the output array. If None,
-            n_cols = n_rows. Default: `None`.
-            k: index of the diagonal, with 0 as the main diagonal. A positive value of k
-            is an upper diagonal, a negative value is a low diagonal. Default: `0`.
-            dtype (optional): data type of the array. Can be typestring,
-                a `numpy.dtype` object, `numpy` char string, or a numpy
-                scalar type. Default: None
-            order ("C" or F"): memory layout for the array. Default: "C"
-            device (optional): array API concept of device where the output array
-                is created. `device` can be `None`, a 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 returnedby
-                `dpctl.tensor.usm_array.device`. Default: `None`.
-            usm_type ("device"|"shared"|"host", optional): The type of SYCL USM
-                allocation for the output array. Default: `"device"`.
-            sycl_queue (:class:`dpctl.SyclQueue`, optional): The SYCL queue to use
-                for output array allocation and copying. `sycl_queue` and `device`
-                are exclusive keywords, i.e. use one or another. If both are
-                specified, a `TypeError` is raised unless both imply the same
-                underlying SYCL queue to be used. If both are `None`, the
-                `dpctl.SyclQueue()` is used for allocation and copying.
-                Default: `None`.
-        """
-        if n_cols is None:
-            n_cols = n_rows
-        #allocate a 1D array of zeros, length equal to n_cols * n_rows
-        k_dt = type(k)
-        if not np.issubdtype(k_dt, np.integer):
-            raise TypeError(
-                "k keyword must be an integer, got {type}".format(type=k_dt)
-            )
-        x = zeros((n_rows * n_cols,), dtype=dtype, order=order, device=device, usm_type=usm_type, sycl_queue=sycl_queue)
-        if k > -n_rows and k < n_cols:
-            #find the length of the diagonal
-            l = min(n_cols, n_rows, n_cols-k, n_rows+k)
-            #i is the first index of the diagonal in 1D index space, j is the last, s is the step size
-            if order == "C":
-                s = n_cols+1
-                i = k if k >= 0 else n_cols*-k
-            else:
-                s = n_rows+1
-                i = n_rows*k if k > 0 else -k
-            #last index + 1 prevents slice from excluding the last element
-            j = i+((l-1)*s)+1
-            x[i:j:s] = 1
-            #copy=False ensures no wasted memory copying the array
-            #and as the order parameter is the same, a copy should never be necessary
-        return dpt.reshape(x, (n_rows, n_cols), order=order, copy=False)
+    Args:
+        n_rows: number of rows in the output array.
+        n_cols (optional): number of columns in the output array. If None,
+        n_cols = n_rows. Default: `None`.
+        k: index of the diagonal, with 0 as the main diagonal.
+        A positive value of k is a superdiagonal, a negative value
+        is a subdiagonal.
+        Raises `TypeError` if k is not an integer.
+        Default: `0`.
+        dtype (optional): data type of the array. Can be typestring,
+            a `numpy.dtype` object, `numpy` char string, or a numpy
+            scalar type. Default: None
+        order ("C" or F"): memory layout for the array. Default: "C"
+        device (optional): array API concept of device where the output array
+            is created. `device` can be `None`, a 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 returnedby
+            `dpctl.tensor.usm_array.device`. Default: `None`.
+        usm_type ("device"|"shared"|"host", optional): The type of SYCL USM
+            allocation for the output array. Default: `"device"`.
+        sycl_queue (:class:`dpctl.SyclQueue`, optional): The SYCL queue to use
+            for output array allocation and copying. `sycl_queue` and `device`
+            are exclusive keywords, i.e. use one or another. If both are
+            specified, a `TypeError` is raised unless both imply the same
+            underlying SYCL queue to be used. If both are `None`, the
+            `dpctl.SyclQueue()` is used for allocation and copying.
+            Default: `None`.
+    """
+    if n_cols is None:
+        n_cols = n_rows
+    # allocate a 1D array of zeros, length equal to n_cols * n_rows
+    k_dt = type(k)
+    if not np.issubdtype(k_dt, np.integer):
+        raise TypeError(
+            "k keyword must be an integer, got {type}".format(type=k_dt)
+        )
+    x = zeros(
+        (n_rows * n_cols,),
+        dtype=dtype,
+        order=order,
+        device=device,
+        usm_type=usm_type,
+        sycl_queue=sycl_queue
+        )
+    if k > -n_rows and k < n_cols:
+        # find the length of the diagonal
+        L = min(
+            n_cols,
+            n_rows,
+            n_cols-k,
+            n_rows+k)
+        # i is the first index of diagonal, j is the last, s is the step size
+        if order == "C":
+            s = n_cols + 1
+            i = k if k >= 0 else n_cols*-k
+        else:
+            s = n_rows + 1
+            i = n_rows*k if k > 0 else -k
+        j = i + s*(L-1) + 1
+        x[i:j:s] = 1
+        # copy=False ensures no wasted memory copying the array
+    return dpt.reshape(x, (n_rows, n_cols), order=order, copy=False)

dpctl/tests/test_usm_ndarray_ctor.py

@@ -16,7 +16,6 @@
 
 import ctypes
 import numbers
-from typing import Type
 
 import numpy as np
 import pytest
@@ -1292,7 +1291,8 @@ def test_common_arg_validation():
     with pytest.raises(TypeError):
         dpt.eye(4, k=1.2)
 
-@pytest.mark.parametrize("shapes", [(0,), (1,), (7,), (6, 1), (3, 9), (10,5)])
+
+@pytest.mark.parametrize("shapes", [(0,), (1,), (7,), (6, 1), (3, 9), (10, 5)])
 @pytest.mark.parametrize("k", np.arange(-4, 5, 1))
 @pytest.mark.parametrize("orders", ["C", "F"])
 def test_eye(shapes, k, orders):