Added missing docstrings to ndarray methods

Author: antonwolfy

doc/reference/ndarray.rst

@@ -231,9 +231,9 @@ Each of the arithmetic operations (``+``, ``-``, ``*``, ``/``, ``//``,
 ``%``, ``divmod()``, ``**`` or ``pow()``, ``<<``, ``>>``, ``&``,
 ``^``, ``|``, ``~``) and the comparisons (``==``, ``<``, ``>``,
 ``<=``, ``>=``, ``!=``) is equivalent to the corresponding
-universal function (or **ufunc** for short) in DPNP.  For
+:term:`universal function` (or :term:`ufunc` for short) in DPNP. For
 more information, see the section on :ref:`Universal Functions
-<ufunc>`.
+<ufuncs>`.
 
 
 Comparison operators:
@@ -249,6 +249,23 @@ Comparison operators:
    dpnp.ndarray.__eq__
    dpnp.ndarray.__ne__
 
+Truth value of an array (:func:`bool()`):
+
+.. autosummary::
+   :toctree: generated/
+
+   ndarray.__bool__
+
+.. note::
+
+   Truth-value testing of an array invokes
+   :meth:`ndarray.__bool__`, which raises an error if the number of
+   elements in the array is larger than 1, because the truth value
+   of such arrays is ambiguous. Use :meth:`.any() <ndarray.any>` and
+   :meth:`.all() <ndarray.all>` instead to be clear about what is meant
+   in such cases. (If the number of elements is 0, the array evaluates
+   to ``False``.)
+
 
 Unary operations:
 
@@ -303,6 +320,14 @@ Arithmetic, in-place:
    dpnp.ndarray.__ixor__
 
 
+Matrix Multiplication:
+
+.. autosummary::
+   :toctree: generated/
+
+   ndarray.__matmul__
+
+
 Special methods
 ---------------
 

dpnp/dpnp_array.py

@@ -159,6 +159,7 @@ def __and__(self, other):
     # '__array_wrap__',
 
     def __bool__(self):
+        """``True`` if self else ``False``."""
         return self._array_obj.__bool__()
 
     # '__class__',
@@ -185,12 +186,47 @@ def __copy__(self):
     # '__doc__',
 
     def __dlpack__(self, stream=None):
+        """
+        Produces DLPack capsule.
+
+        Parameters
+        ----------
+        stream : {:class:`dpctl.SyclQueue`, None}, optional
+            Execution queue to synchronize with. If ``None``,
+            synchronization is not performed.
+
+        Raises
+        ------
+        MemoryError
+            when host memory can not be allocated.
+        DLPackCreationError
+            when array is allocated on a partitioned
+            SYCL device, or with a non-default context.
+
+        """
+
         return self._array_obj.__dlpack__(stream=stream)
 
     def __dlpack_device__(self):
+        """
+        Gives a tuple (``device_type``, ``device_id``) corresponding to
+        ``DLDevice`` entry in ``DLTensor`` in DLPack protocol.
+
+        The tuple describes the non-partitioned device where the array has been
+        allocated, or the non-partitioned parent device of the allocation
+        device.
+
+        Raises
+        ------
+        DLPackCreationError:
+            when the ``device_id`` could not be determined.
+
+        """
+
         return self._array_obj.__dlpack_device__()
 
     def __eq__(self, other):
+        """Return ``self==value``."""
         return dpnp.equal(self, other)
 
     def __float__(self):
@@ -203,6 +239,7 @@ def __floordiv__(self, other):
     # '__format__',
 
     def __ge__(self, other):
+        """Return ``self>=value``."""
         return dpnp.greater_equal(self, other)
 
     # '__getattribute__',
@@ -224,6 +261,7 @@ def __getitem__(self, key):
         return res
 
     def __gt__(self, other):
+        """Return ``self>value``."""
         return dpnp.greater(self, other)
 
     # '__hash__',
@@ -306,21 +344,23 @@ def __ixor__(self, other):
         return self
 
     def __le__(self, other):
+        """Return ``self<=value``."""
         return dpnp.less_equal(self, other)
 
     def __len__(self):
         """Return ``len(self)``."""
-
         return self._array_obj.__len__()
 
     def __lshift__(self, other):
         """Return ``self<<value``."""
         return dpnp.left_shift(self, other)
 
     def __lt__(self, other):
+        """Return ``self<value``."""
         return dpnp.less(self, other)
 
     def __matmul__(self, other):
+        """Return ``self@value``."""
         return dpnp.matmul(self, other)
 
     def __mod__(self, other):
@@ -332,6 +372,7 @@ def __mul__(self, other):
         return dpnp.multiply(self, other)
 
     def __ne__(self, other):
+        """Return ``self!=value``."""
         return dpnp.not_equal(self, other)
 
     def __neg__(self):
@@ -363,6 +404,7 @@ def __rand__(self, other):
     # '__reduce_ex__',
 
     def __repr__(self):
+        """Return ``repr(self)``."""
         return dpt.usm_ndarray_repr(self._array_obj, prefix="array")
 
     def __rfloordiv__(self, other):
@@ -417,18 +459,7 @@ def __setitem__(self, key, val):
     # '__sizeof__',
 
     def __str__(self):
-        """
-        Output values from the array to standard output.
-
-        Examples
-        --------
-        >>> print(a)
-        [[ 136.  136.  136.]
-         [ 272.  272.  272.]
-         [ 408.  408.  408.]]
-
-        """
-
+        """Return ``str(self)``."""
         return self._array_obj.__str__()
 
     def __sub__(self, other):
@@ -1060,12 +1091,12 @@ def real(self):
         array([1.        , 0.70710677])
 
         """
+
         if dpnp.issubsctype(self.dtype, dpnp.complexfloating):
             return dpnp_array._create_from_usm_ndarray(
                 dpnp.get_usm_ndarray(self).real
             )
-        else:
-            return self
+        return self
 
     @real.setter
     def real(self, value):
@@ -1083,6 +1114,7 @@ def real(self, value):
         array([9.+2.j, 9.+4.j, 9.+6.j])
 
         """
+
         dpnp.copyto(self._array_obj.real, value)
 
     def repeat(self, repeats, axis=None):
@@ -1152,7 +1184,8 @@ def searchsorted(self, v, side="left", sorter=None):
 
     @property
     def shape(self):
-        """Lengths of axes. A tuple of numbers represents size of each dimension.
+        """
+        Lengths of axes. A tuple of numbers represents size of each dimension.
 
         Setter of this property involves reshaping without copy. If the array
         cannot be reshaped without copy, it raises an exception.
@@ -1181,7 +1214,6 @@ def shape(self, newshape):
     @property
     def size(self):
         """Number of elements in the array."""
-
         return self._array_obj.size
 
     def sort(self, axis=-1, kind=None, order=None):
@@ -1250,14 +1282,12 @@ def std(
     @property
     def strides(self):
         """
-        Get strides of an array.
-
         Returns memory displacement in array elements, upon unit
         change of respective index.
 
-        E.g. for strides (s1, s2, s3) and multi-index (i1, i2, i3)
-
-           a[i1, i2, i3] == (&a[0,0,0])[ s1*s1 + s2*i2 + s3*i3]
+        For example, for strides ``(s1, s2, s3)`` and multi-index
+        ``(i1, i2, i3)`` position of the respective element relative
+        to zero multi-index element is ``s1*s1 + s2*i2 + s3*i3``.
 
         """
 
@@ -1403,6 +1433,7 @@ def var(
         Refer to :obj:`dpnp.var` for full documentation.
 
         """
+
         return dpnp.var(self, axis, dtype, out, ddof, keepdims, where=where)
 
 

dpnp/dpnp_iface_arraycreation.py

@@ -2561,7 +2561,7 @@ def logspace(
         tuples of lists, and ndarrays. `base` ** `stop` is the final value of
         the sequence, unless `endpoint` is ``False``. In that case, ``num + 1``
         values are spaced over the interval in log-space, of which all but
-        the last (a sequence of length num) are returned.
+        the last (a sequence of length `num`) are returned.
     num : int, optional
         Number of samples to generate. Default is 50.
     device : {None, string, SyclDevice, SyclQueue}, optional

dpnp/dpnp_iface_manipulation.py

@@ -1556,7 +1556,7 @@ def shape(a):
 
     Returns
     -------
-    shape : tuple of ints
+    shape : tuple of integers
         The elements of the shape tuple give the lengths of the
         corresponding array dimensions.