Add a space after comma

Author: antonwolfy

dpnp/backend/extensions/lapack/gesvd.cpp

@@ -95,12 +95,12 @@ static sycl::event gesvd_impl(sycl::queue &exec_q,
             exec_q,
             jobu,  // Character specifying how to compute the matrix U:
                    // 'A' computes all columns of U,
-                   // 'S' computes the first min(m,n) columns of U,
+                   // 'S' computes the first min(m, n) columns of U,
                    // 'O' overwrites A with the columns of U,
                    // 'N' does not compute U.
             jobvt, // Character specifying how to compute the matrix VT:
                    // 'A' computes all rows of VT,
-                   // 'S' computes the first min(m,n) rows of VT,
+                   // 'S' computes the first min(m, n) rows of VT,
                    // 'O' overwrites A with the rows of VT,
                    // 'N' does not compute VT.
             m,     // The number of rows in the input matrix A (0 <= m).

dpnp/backend/extensions/lapack/gesvd_batch.cpp

@@ -147,12 +147,12 @@ static sycl::event gesvd_batch_impl(sycl::queue &exec_q,
                 exec_q,
                 jobu,  // Character specifying how to compute the matrix U:
                        // 'A' computes all columns of U,
-                       // 'S' computes the first min(m,n) columns of U,
+                       // 'S' computes the first min(m, n) columns of U,
                        // 'O' overwrites A with the columns of U,
                        // 'N' does not compute U.
                 jobvt, // Character specifying how to compute the matrix VT:
                        // 'A' computes all rows of VT,
-                       // 'S' computes the first min(m,n) rows of VT,
+                       // 'S' computes the first min(m, n) rows of VT,
                        // 'O' overwrites A with the rows of VT,
                        // 'N' does not compute VT.
                 m, // The number of rows in the input batch matrix A (0 <= m).

dpnp/dpnp_array.py

@@ -1029,7 +1029,7 @@ def diagonal(self, offset=0, axis1=0, axis2=1):
         Examples
         --------
         >>> import dpnp as np
-        >>> a = np.arange(4).reshape(2,2)
+        >>> a = np.arange(4).reshape(2, 2)
         >>> a.diagonal()
         array([0, 3])
 

dpnp/dpnp_iface_arraycreation.py

@@ -3127,7 +3127,7 @@ def meshgrid(*xi, copy=True, sparse=False, indexing="xy"):
     >>> y = np.arange(-5, 5, 0.1)
     >>> xx, yy = np.meshgrid(x, y, sparse=True)
     >>> z = np.sin(xx**2 + yy**2) / (xx**2 + yy**2)
-    >>> h = plt.contourf(x,y,z)
+    >>> h = plt.contourf(x, y, z)
     >>> plt.show()
 
     """
@@ -3202,7 +3202,7 @@ class MGridClass:
     Examples
     --------
     >>> import dpnp as np
-    >>> np.mgrid[0:5,0:5]
+    >>> np.mgrid[0:5, 0:5]
     array([[[0, 0, 0, 0, 0],
             [1, 1, 1, 1, 1],
             [2, 2, 2, 2, 2],

dpnp/dpnp_iface_histograms.py

@@ -803,7 +803,7 @@ def histogram2d(x, y, bins=10, range=None, density=None, weights=None):
           is the number of bins and array is the bin edges.
 
         Default: ``10``.
-    range : {None, dpnp.ndarray, usm_ndarray} of shape (2,2), optional
+    range : {None, dpnp.ndarray, usm_ndarray} of shape (2, 2), optional
         The leftmost and rightmost edges of the bins along each dimension
         If ``None`` the ranges are
         ``[[x.min(), x.max()], [y.min(), y.max()]]``. All values outside

dpnp/dpnp_iface_indexing.py

@@ -665,7 +665,7 @@ def diagonal(a, offset=0, axis1=0, axis2=1):
     Examples
     --------
     >>> import dpnp as np
-    >>> a = np.arange(4).reshape(2,2)
+    >>> a = np.arange(4).reshape(2, 2)
     >>> a
     array([[0, 1],
            [2, 3]])
@@ -676,7 +676,7 @@ def diagonal(a, offset=0, axis1=0, axis2=1):
 
     A 3-D example:
 
-    >>> a = np.arange(8).reshape(2,2,2)
+    >>> a = np.arange(8).reshape(2, 2, 2)
     >>> a
     array([[[0, 1],
             [2, 3]],
@@ -1234,8 +1234,8 @@ def ix_(*args):
     N dimensions.
 
     Using :obj:`dpnp.ix_` one can quickly construct index arrays that will
-    index the cross product. ``a[dpnp.ix_([1,3],[2,5])]`` returns the array
-    ``[[a[1,2] a[1,5]], [a[3,2] a[3,5]]]``.
+    index the cross product. ``a[dpnp.ix_([1, 3],[2, 5])]`` returns the array
+    ``[[a[1, 2] a[1, 5]], [a[3, 2] a[3, 5]]]``.
 
     Parameters
     ----------

dpnp/dpnp_iface_manipulation.py

@@ -944,7 +944,7 @@ def atleast_1d(*arys):
     >>> np.atleast_1d(x, y)
     [array([1.]), array([3, 4])]
 
-    >>> x = np.arange(9.0).reshape(3,3)
+    >>> x = np.arange(9.0).reshape(3, 3)
     >>> np.atleast_1d(x)
     array([[0., 1., 2.],
            [3., 4., 5.],
@@ -3342,7 +3342,7 @@ def rollaxis(x, axis, start=0):
     Examples
     --------
     >>> import dpnp as np
-    >>> a = np.ones((3,4,5,6))
+    >>> a = np.ones((3, 4, 5, 6))
     >>> np.rollaxis(a, 3, 1).shape
     (3, 6, 4, 5)
     >>> np.rollaxis(a, 2).shape
@@ -3405,11 +3405,11 @@ def rot90(m, k=1, axes=(0, 1)):
 
     Notes
     -----
-    ``rot90(m, k=1, axes=(1,0))`` is the reverse of
-    ``rot90(m, k=1, axes=(0,1))``.
+    ``rot90(m, k=1, axes=(1, 0))`` is the reverse of
+    ``rot90(m, k=1, axes=(0, 1))``.
 
-    ``rot90(m, k=1, axes=(1,0))`` is equivalent to
-    ``rot90(m, k=-1, axes=(0,1))``.
+    ``rot90(m, k=1, axes=(1, 0))`` is equivalent to
+    ``rot90(m, k=-1, axes=(0, 1))``.
 
     Examples
     --------
@@ -3837,13 +3837,13 @@ def swapaxes(a, axis1, axis2):
            [2],
            [3]])
 
-    >>> x = np.array([[[0,1],[2,3]],[[4,5],[6,7]]])
+    >>> x = np.array([[[0, 1],[2, 3]],[[4, 5],[6, 7]]])
     >>> x
     array([[[0, 1],
             [2, 3]],
            [[4, 5],
             [6, 7]]])
-    >>> np.swapaxes(x,0,2)
+    >>> np.swapaxes(x, 0, 2)
     array([[[0, 4],
             [2, 6]],
            [[1, 5],

dpnp/dpnp_iface_statistics.py

@@ -472,7 +472,7 @@ def corrcoef(x, y=None, rowvar=True, *, dtype=None):
     out /= stddev[None, :]
 
     # Clip real and imaginary parts to [-1, 1]. This does not guarantee
-    # abs(a[i,j]) <= 1 for complex arrays, but is the best we can do without
+    # abs(a[i, j]) <= 1 for complex arrays, but is the best we can do without
     # excessive work.
     dpnp.clip(out.real, -1, 1, out=out.real)
     if dpnp.iscomplexobj(out):
@@ -851,7 +851,7 @@ def cov(
     array([[ 1., -1.],
            [-1.,  1.]])
 
-    Note that element :math:`C_{0,1}`, which shows the correlation between
+    Note that element :math:`C_{0, 1}`, which shows the correlation between
     :math:`x_0` and :math:`x_1`, is negative.
 
     Further, note how `x` and `y` are combined:
@@ -974,7 +974,7 @@ def max(a, axis=None, out=None, keepdims=False, initial=None, where=True):
     Examples
     --------
     >>> import dpnp as np
-    >>> a = np.arange(4).reshape((2,2))
+    >>> a = np.arange(4).reshape((2, 2))
     >>> a
     array([[0, 1],
            [2, 3]])
@@ -1251,7 +1251,7 @@ def min(a, axis=None, out=None, keepdims=False, initial=None, where=True):
     Examples
     --------
     >>> import dpnp as np
-    >>> a = np.arange(4).reshape((2,2))
+    >>> a = np.arange(4).reshape((2, 2))
     >>> a
     array([[0, 1],
            [2, 3]])

dpnp/linalg/dpnp_iface_linalg.py

@@ -364,7 +364,7 @@ def diagonal(x, /, *, offset=0):
 
     Parameters
     ----------
-    x : (...,M,N) {dpnp.ndarray, usm_ndarray}
+    x : (..., M, N) {dpnp.ndarray, usm_ndarray}
         Input array having shape (..., M, N) and whose innermost two
         dimensions form ``MxN`` matrices.
     offset : int, optional
@@ -379,7 +379,7 @@ def diagonal(x, /, *, offset=0):
 
     Returns
     -------
-    out : (...,min(N,M)) dpnp.ndarray
+    out : (...,min(N, M)) dpnp.ndarray
         An array containing the diagonals and whose shape is determined by
         removing the last two dimensions and appending a dimension equal to
         the size of the resulting diagonals. The returned array must have
@@ -393,15 +393,15 @@ def diagonal(x, /, *, offset=0):
     Examples
     --------
     >>> import dpnp as np
-    >>> a = np.arange(4).reshape(2,2); a
+    >>> a = np.arange(4).reshape(2, 2); a
     array([[0, 1],
            [2, 3]])
     >>> np.linalg.diagonal(a)
     array([0, 3])
 
     A 3-D example:
 
-    >>> a = np.arange(8).reshape(2,2,2); a
+    >>> a = np.arange(8).reshape(2, 2, 2); a
     array([[[0, 1],
             [2, 3]],
            [[4, 5],
@@ -673,7 +673,7 @@ def eigvals(a):
     Now multiply a diagonal matrix by ``Q`` on one side and by ``Q.T`` on the
     other:
 
-    >>> D = np.diag((-1,1))
+    >>> D = np.diag((-1, 1))
     >>> LA.eigvals(D)
     array([-1.,  1.])
     >>> A = np.dot(Q, D)
@@ -929,7 +929,7 @@ def matmul(x1, x2, /):
 
     >>> a = np.arange(2 * 2 * 4).reshape((2, 2, 4))
     >>> b = np.arange(2 * 2 * 4).reshape((2, 4, 2))
-    >>> np.linalg.matmul(a,b).shape
+    >>> np.linalg.matmul(a, b).shape
     (2, 2, 2)
     >>> np.linalg.matmul(a, b)[0, 1, 1]
     array(98)
@@ -1333,7 +1333,7 @@ def norm(x, ord=None, axis=None, keepdims=False):
 
     The Frobenius norm is given by [1]_:
 
-    :math:`||A||_F = [\sum_{i,j} abs(a_{i,j})^2]^{1/2}`
+    :math:`||A||_F = [\sum_{i, j} abs(a_{i, j})^2]^{1/2}`
 
     The nuclear norm is the sum of the singular values.
 
@@ -1407,8 +1407,8 @@ def norm(x, ord=None, axis=None, keepdims=False):
 
     Using the `axis` argument to compute matrix norms:
 
-    >>> m = np.arange(8).reshape(2,2,2)
-    >>> np.linalg.norm(m, axis=(1,2))
+    >>> m = np.arange(8).reshape(2, 2, 2)
+    >>> np.linalg.norm(m, axis=(1, 2))
     array([  3.74165739,  11.22497216])
     >>> np.linalg.norm(m[0, :, :]), np.linalg.norm(m[1, :, :])
     (array(3.74165739), array(11.22497216))
@@ -2004,9 +2004,9 @@ def tensordot(a, b, /, *, axes=2):
     >>> np.linalg.tensordot(a, b, axes=1)
     array([14, 32, 50])
 
-    >>> a = np.arange(60.).reshape(3,4,5)
-    >>> b = np.arange(24.).reshape(4,3,2)
-    >>> c = np.linalg.tensordot(a,b, axes=([1,0],[0,1]))
+    >>> a = np.arange(60.).reshape(3, 4, 5)
+    >>> b = np.arange(24.).reshape(4, 3, 2)
+    >>> c = np.linalg.tensordot(a, b, axes=([1, 0], [0, 1]))
     >>> c.shape
     (5, 2)
     >>> c
@@ -2018,12 +2018,12 @@ def tensordot(a, b, /, *, axes=2):
 
     A slower but equivalent way of computing the same...
 
-    >>> d = np.zeros((5,2))
+    >>> d = np.zeros((5, 2))
     >>> for i in range(5):
     ...   for j in range(2):
     ...     for k in range(3):
     ...       for n in range(4):
-    ...         d[i,j] += a[k,n,i] * b[n,k,j]
+    ...         d[i, j] += a[k, n, i] * b[n, k, j]
     >>> c == d
     array([[ True,  True],
            [ True,  True],
@@ -2183,7 +2183,7 @@ def trace(x, /, *, offset=0, dtype=None):
 
     Parameters
     ----------
-    x : (...,M,N) {dpnp.ndarray, usm_ndarray}
+    x : (..., M, N) {dpnp.ndarray, usm_ndarray}
         Input array having shape (..., M, N) and whose innermost two
         dimensions form ``MxN`` matrices.
     offset : int, optional

dpnp/linalg/dpnp_utils_linalg.py

@@ -1109,7 +1109,7 @@ def _multi_dot_matrix_chain_order(n, arrays, return_costs=False):
         else [arrays[-1].shape[0], arrays[-1].shape[1]]
     )
     # m is a matrix of costs of the subproblems
-    # m[i,j]: min number of scalar multiplications needed to compute A_{i..j}
+    # m[i, j]: min number of scalar multiplications needed to compute A_{i..j}
     m = dpnp.zeros((n, n), usm_type=usm_type, sycl_queue=exec_q)
     # s is the actual ordering
     # s[i, j] is the value of k at which we split the product A_i..A_j

dpnp/random/dpnp_iface_random.py

@@ -242,7 +242,7 @@ def chisquare(df, size=None):
 
     Examples
     --------
-    >>> dpnp.random.chisquare(2,4)
+    >>> dpnp.random.chisquare(2, 4)
     array([ 1.89920014,  9.00867716,  3.13710533,  5.62318272]) # random
 
     """

dpnp/tests/test_arraycreation.py

@@ -533,7 +533,7 @@ def test_triu_size_null(k):
 def test_vander(array, dtype, n, increase):
     if dtype in [dpnp.complex64, dpnp.complex128] and array == [0, 3, 5]:
         pytest.skip(
-            "per array API dpnp.power(complex(0,0)), 0) returns nan+nanj while NumPy returns 1+0j"
+            "per array API dpnp.power(complex(0, 0)), 0) returns nan+nanj while NumPy returns 1+0j"
         )
     vander_func = lambda xp, x: xp.vander(x, N=n, increasing=increase)