Fixed spelling issues and added 7 new words to known list

Author: antonwolfy

doc/known_words.txt

@@ -23,3 +23,10 @@ ufunc
 ufuncs
 usm
 Vandermonde
+signum
+Infs
+subclasses
+th
+prepend
+eps
+whitespace

dpnp/dpnp_array.py

@@ -54,7 +54,7 @@ class dpnp_array:
     Multi-dimensional array object.
 
     This is a wrapper around dpctl.tensor.usm_ndarray that provides
-    methods to be compliant with original Numpy.
+    methods to be compliant with original NumPy.
 
     """
 
@@ -137,15 +137,15 @@ def usm_type(self):
         return self._array_obj.usm_type
 
     def __abs__(self):
-        r"""Return \|self\|."""
+        r"""Return ``\|self\|``."""
         return dpnp.abs(self)
 
     def __add__(self, other):
-        """Return self+value."""
+        """Return ``self+value``."""
         return dpnp.add(self, other)
 
     def __and__(self, other):
-        """Return self&value."""
+        """Return ``self&value``."""
         return dpnp.bitwise_and(self, other)
 
     # '__array__',
@@ -197,7 +197,7 @@ def __float__(self):
         return self._array_obj.__float__()
 
     def __floordiv__(self, other):
-        """Return self//value."""
+        """Return ``self//value``."""
         return dpnp.floor_divide(self, other)
 
     # '__format__',
@@ -208,7 +208,7 @@ def __ge__(self, other):
     # '__getattribute__',
 
     def __getitem__(self, key):
-        """Return self[key]."""
+        """Return ``self[key]``."""
         key = _get_unwrapped_index_key(key)
 
         item = self._array_obj.__getitem__(key)
@@ -229,34 +229,34 @@ def __gt__(self, other):
     # '__hash__',
 
     def __iadd__(self, other):
-        """Return self+=value."""
+        """Return ``self+=value``."""
         dpnp.add(self, other, out=self)
         return self
 
     def __iand__(self, other):
-        """Return self&=value."""
+        """Return ``self&=value``."""
         dpnp.bitwise_and(self, other, out=self)
         return self
 
     def __ifloordiv__(self, other):
-        """Return self//=value."""
+        """Return ``self//=value``."""
         dpnp.floor_divide(self, other, out=self)
         return self
 
     def __ilshift__(self, other):
-        """Return self<<=value."""
+        """Return ``self<<=value``."""
         dpnp.left_shift(self, other, out=self)
         return self
 
     # '__imatmul__',
 
     def __imod__(self, other):
-        """Return self%=value."""
+        """Return ``self%=value``."""
         dpnp.remainder(self, other, out=self)
         return self
 
     def __imul__(self, other):
-        """Return self*=value."""
+        """Return ``self*=value``."""
         dpnp.multiply(self, other, out=self)
         return self
 
@@ -270,51 +270,51 @@ def __int__(self):
         return self._array_obj.__int__()
 
     def __invert__(self):
-        """Return ~self."""
+        """Return ``~self``."""
         return dpnp.invert(self)
 
     def __ior__(self, other):
-        """Return self|=value."""
+        """Return ``self|=value``."""
         dpnp.bitwise_or(self, other, out=self)
         return self
 
     def __ipow__(self, other):
-        """Return self**=value."""
+        """Return ``self**=value``."""
         dpnp.power(self, other, out=self)
         return self
 
     def __irshift__(self, other):
-        """Return self>>=value."""
+        """Return ``self>>=value``."""
         dpnp.right_shift(self, other, out=self)
         return self
 
     def __isub__(self, other):
-        """Return self-=value."""
+        """Return ``self-=value``."""
         dpnp.subtract(self, other, out=self)
         return self
 
     # '__iter__',
 
     def __itruediv__(self, other):
-        """Return self/=value."""
+        """Return ``self/=value``."""
         dpnp.true_divide(self, other, out=self)
         return self
 
     def __ixor__(self, other):
-        """Return self^=value."""
+        """Return ``self^=value``."""
         dpnp.bitwise_xor(self, other, out=self)
         return self
 
     def __le__(self, other):
         return dpnp.less_equal(self, other)
 
     def __len__(self):
-        """Return len(self)."""
+        """Return ``len(self)``."""
 
         return self._array_obj.__len__()
 
     def __lshift__(self, other):
-        """Return self<<value."""
+        """Return ``self<<value``."""
         return dpnp.left_shift(self, other)
 
     def __lt__(self, other):
@@ -324,32 +324,32 @@ def __matmul__(self, other):
         return dpnp.matmul(self, other)
 
     def __mod__(self, other):
-        """Return self%value."""
+        """Return ``self%value``."""
         return dpnp.remainder(self, other)
 
     def __mul__(self, other):
-        """Return self*value."""
+        """Return ``self*value``."""
         return dpnp.multiply(self, other)
 
     def __ne__(self, other):
         return dpnp.not_equal(self, other)
 
     def __neg__(self):
-        """Return -self."""
+        """Return ``-self``."""
         return dpnp.negative(self)
 
     # '__new__',
 
     def __or__(self, other):
-        """Return self|value."""
+        """Return ``self|value``."""
         return dpnp.bitwise_or(self, other)
 
     def __pos__(self):
-        """Return +self."""
+        """Return ``+self``."""
         return dpnp.positive(self)
 
     def __pow__(self, other):
-        """Return self**value."""
+        """Return ``self**value``."""
         return dpnp.power(self, other)
 
     def __radd__(self, other):
@@ -390,7 +390,7 @@ def __rrshift__(self, other):
         return dpnp.right_shift(other, self)
 
     def __rshift__(self, other):
-        """Return self>>value."""
+        """Return ``self>>value``."""
         return dpnp.right_shift(self, other)
 
     def __rsub__(self, other):
@@ -405,7 +405,7 @@ def __rxor__(self, other):
     # '__setattr__',
 
     def __setitem__(self, key, val):
-        """Set self[key] to value."""
+        """Set ``self[key]`` to value."""
         key = _get_unwrapped_index_key(key)
 
         if isinstance(val, dpnp_array):
@@ -432,17 +432,17 @@ def __str__(self):
         return self._array_obj.__str__()
 
     def __sub__(self, other):
-        """Return self-value."""
+        """Return ``self-value``."""
         return dpnp.subtract(self, other)
 
     # '__subclasshook__',
 
     def __truediv__(self, other):
-        """Return self/value."""
+        """Return ``self/value``."""
         return dpnp.true_divide(self, other)
 
     def __xor__(self, other):
-        """Return self^value."""
+        """Return ``self^value``."""
         return dpnp.bitwise_xor(self, other)
 
     @staticmethod
@@ -558,8 +558,10 @@ def astype(self, dtype, order="K", casting="unsafe", subok=True, copy=True):
             - 'unsafe' means any data conversions may be done.
 
         copy : bool, optional
-            By default, astype always returns a newly allocated array. If this is set to false, and the dtype,
-            order, and subok requirements are satisfied, the input array is returned instead of a copy.
+            By default, ``astype`` always returns a newly allocated array. If
+            this is set to ``False``, and the `dtype`, `order`, and `subok`
+            requirements are satisfied, the input array is returned instead of
+            a copy.
 
         Returns
         -------
@@ -1323,9 +1325,9 @@ def transpose(self, *axes):
         ----------
         axes : None, tuple or list of ints, n ints, optional
             * ``None`` or no argument: reverses the order of the axes.
-            * tuple or list of ints: `i` in the `j`-th place in the tuple/list
-              means that the array’s `i`-th axis becomes the transposed
-              array’s `j`-th axis.
+            * tuple or list of integers: `i` in the `j`-th place in the
+              tuple/list means that the array’s `i`-th axis becomes the
+              transposed array’s `j`-th axis.
             * n ints: same as an n-tuple/n-list of the same ints (this form is
               intended simply as a “convenience” alternative to the tuple form).
 

dpnp/dpnp_iface.py

@@ -207,8 +207,8 @@ def astype(x1, dtype, order="K", casting="unsafe", copy=True):
             - 'unsafe' means any data conversions may be done.
 
     copy : bool, optional
-        By default, astype always returns a newly allocated array. If this
-        is set to ``False``, and the dtype, order, and subok requirements
+        By default, ``astype`` always returns a newly allocated array. If this
+        is set to ``False``, and the `dtype`, `order`, and `subok` requirements
         are satisfied, the input array is returned instead of a copy.
 
     Returns

dpnp/dpnp_iface_arraycreation.py

@@ -640,7 +640,7 @@ def asfortranarray(
     a, dtype=None, *, like=None, device=None, usm_type=None, sycl_queue=None
 ):
     """
-    Return an array (ndim >= 1) laid out in Fortran order in memory.
+    Return an array ``(ndim >= 1)`` laid out in Fortran order in memory.
 
     For full documentation refer to :obj:`numpy.asfortranarray`.
 

dpnp/dpnp_iface_manipulation.py

@@ -790,7 +790,7 @@ def dstack(tup):
     :obj:`dpnp.hstack` : Stack arrays in sequence horizontally (column wise).
     :obj:`dpnp.column_stack` : Stack 1-D arrays as columns into a 2-D array.
     :obj:`dpnp.stack` : Join a sequence of arrays along a new axis.
-    :obj:`dpnp.block` : Assemble an nd-array from nested lists of blocks.
+    :obj:`dpnp.block` : Assemble an ndarray from nested lists of blocks.
     :obj:`dpnp.dsplit` : Split array along third axis.
 
     Examples
@@ -1114,7 +1114,7 @@ def hstack(tup, *, dtype=None, casting="same_kind"):
     :obj:`dpnp.dstack` : Stack arrays in sequence depth wise
                          (along third dimension).
     :obj:`dpnp.column_stack` : Stack 1-D arrays as columns into a 2-D array.
-    :obj:`dpnp.block` : Assemble an nd-array from nested lists of blocks.
+    :obj:`dpnp.block` : Assemble an ndarray from nested lists of blocks.
     :obj:`dpnp.split` : Split array into a list of multiple sub-arrays of equal
                         size.
 
@@ -1670,7 +1670,7 @@ def stack(arrays, /, *, axis=0, out=None, dtype=None, casting="same_kind"):
     :obj:`dpnp.dstack` : Stack arrays in sequence depth wise
                          (along third dimension).
     :obj:`dpnp.column_stack` : Stack 1-D arrays as columns into a 2-D array.
-    :obj:`dpnp.block` : Assemble an nd-array from nested lists of blocks.
+    :obj:`dpnp.block` : Assemble an ndarray from nested lists of blocks.
     :obj:`dpnp.split` : Split array into a list of multiple sub-arrays of equal
                         size.
 
@@ -1973,7 +1973,7 @@ def vstack(tup, *, dtype=None, casting="same_kind"):
     :obj:`dpnp.hstack` : Stack arrays in sequence horizontally (column wise).
     :obj:`dpnp.dstack` : Stack arrays in sequence depth wise (along third axis).
     :obj:`dpnp.column_stack` : Stack 1-D arrays as columns into a 2-D array.
-    :obj:`dpnp.block` : Assemble an nd-array from nested lists of blocks.
+    :obj:`dpnp.block` : Assemble an ndarray from nested lists of blocks.
     :obj:`dpnp.split` : Split array into a list of multiple sub-arrays of equal
                         size.
 

dpnp/dpnp_iface_mathematical.py

@@ -841,7 +841,7 @@ def cumsum(a, axis=None, dtype=None, out=None):
         Input array.
     axis : int, optional
         Axis along which the cumulative sum is computed. The default (``None``)
-        is to compute the cumsum over the flattened array.
+        is to compute the cumulative sum over the flattened array.
     dtype : dtype, optional
         Type of the returned array and of the accumulator in which the elements
         are summed. If `dtype` is not specified, it defaults to the dtype of
@@ -936,7 +936,7 @@ def diff(a, n=1, axis=-1, prepend=None, append=None):
     a : {dpnp.ndarray, usm_ndarray}
         Input array
     n : int, optional
-        The number of times values are differenced. If zero, the input
+        The number of times the values differ. If ``zero``, the input
         is returned as-is.
     axis : int, optional
         The axis along which the difference is taken, default is the

dpnp/dpnp_iface_sorting.py

@@ -100,8 +100,8 @@ def argsort(a, axis=-1, kind=None, order=None):
     :obj:`dpnp.sort` : Return a sorted copy of an array.
     :obj:`dpnp.lexsort` : Indirect stable sort with multiple keys.
     :obj:`dpnp.argpartition` : Indirect partial sort.
-    :obj:`dpnp.take_along_axis` : Apply ``index_array`` from argsort to
-                                  an array as if by calling sort.
+    :obj:`dpnp.take_along_axis` : Apply ``index_array`` from obj:`dpnp.argsort`
+                                  to an array as if by calling sort.
 
     Examples
     --------

dpnp/dpnp_iface_statistics.py

@@ -315,7 +315,7 @@ def average(a, axis=None, weights=None, returned=False, *, keepdims=False):
 
 def bincount(x1, weights=None, minlength=0):
     """
-    Count number of occurrences of each value in array of non-negative ints.
+    Count number of occurrences of each value in array of non-negative integers.
 
     For full documentation refer to :obj:`numpy.bincount`.
 

dpnp/linalg/dpnp_utils_linalg.py

@@ -1281,7 +1281,7 @@ def dpnp_matrix_rank(A, tol=None, hermitian=False):
         rtol = max(A.shape[-2:]) * dpnp.finfo(S.dtype).eps
         tol = S.max(axis=-1, keepdims=True) * rtol
     elif not dpnp.isscalar(tol):
-        # Add a new axis to match Numpy's output
+        # Add a new axis to match NumPy's output
         tol = tol[..., None]
 
     return dpnp.count_nonzero(S > tol, axis=-1)