update dpnp.inner implementation (#1726)

* update dpnp.inner

* address comments

* fix typo

---------

Co-authored-by: Anton <100830759+antonwolfy@users.noreply.github.com>

Author: vtavana

dpnp/dpnp_algo/dpnp_algo_linearalgebra.pxi

@@ -36,7 +36,6 @@ and the rest of the library
 # NO IMPORTs here. All imports must be placed into main "dpnp_algo.pyx" file
 
 __all__ += [
-    "dpnp_inner",
     "dpnp_kron",
 ]
 
@@ -48,80 +47,6 @@ ctypedef c_dpctl.DPCTLSyclEventRef(*fptr_2in_1out_shapes_t)(c_dpctl.DPCTLSyclQue
                                                             const c_dpctl.DPCTLEventVectorRef)
 
 
-cpdef utils.dpnp_descriptor dpnp_inner(dpnp_descriptor array1, dpnp_descriptor array2):
-    result_type = numpy.promote_types(array1.dtype, array1.dtype)
-
-    assert(len(array1.shape) == len(array2.shape))
-
-    cdef shape_type_c array1_no_last_axes = array1.shape[:-1]
-    cdef shape_type_c array2_no_last_axes = array2.shape[:-1]
-
-    cdef shape_type_c result_shape = array1_no_last_axes
-    result_shape.insert(result_shape.end(), array2_no_last_axes.begin(), array2_no_last_axes.end())
-
-    result_sycl_device, result_usm_type, result_sycl_queue = utils.get_common_usm_allocation(array1, array2)
-
-    # create result array with type given by FPTR data
-    cdef utils.dpnp_descriptor result = utils_py.create_output_descriptor_py(result_shape,
-                                                                             result_type,
-                                                                             None,
-                                                                             device=result_sycl_device,
-                                                                             usm_type=result_usm_type,
-                                                                             sycl_queue=result_sycl_queue)
-
-    # calculate input arrays offsets
-    cdef shape_type_c array1_offsets = [1] * len(array1.shape)
-    cdef shape_type_c array2_offsets = [1] * len(array2.shape)
-    cdef size_t acc1 = 1
-    cdef size_t acc2 = 1
-    for axis in range(len(array1.shape) - 1, -1, -1):
-        array1_offsets[axis] = acc1
-        array2_offsets[axis] = acc2
-        acc1 *= array1.shape[axis]
-        acc2 *= array2.shape[axis]
-
-    cdef shape_type_c result_shape_offsets = [1] * len(result.shape)
-    acc = 1
-    for i in range(len(result.shape) - 1, -1, -1):
-        result_shape_offsets[i] = acc
-        acc *= result.shape[i]
-
-    cdef shape_type_c xyz
-    cdef size_t array1_lin_index_base
-    cdef size_t array2_lin_index_base
-    cdef size_t axis2
-    cdef long remainder
-    cdef long quotient
-
-    result_flatiter = result.get_pyobj().flat
-    array1_flatiter = array1.get_pyobj().flat
-    array2_flatiter = array2.get_pyobj().flat
-
-    for idx1 in range(result.size):
-        # reconstruct x,y,z from linear index
-        xyz.clear()
-        remainder = idx1
-        for i in result_shape_offsets:
-            quotient, remainder = divmod(remainder, i)
-            xyz.push_back(quotient)
-
-        # calculate linear base input index
-        array1_lin_index_base = 0
-        array2_lin_index_base = 0
-        for axis in range(len(array1_offsets) - 1):
-            axis2 = axis + (len(xyz) / 2)
-            array1_lin_index_base += array1_offsets[axis] * xyz[axis]
-            array2_lin_index_base += array2_offsets[axis] * xyz[axis2]
-
-        # do inner product
-        result_flatiter[idx1] = 0
-        for idx2 in range(array1.shape[-1]):
-            result_flatiter[idx1] += array1_flatiter[array1_lin_index_base + idx2] * \
-                array2_flatiter[array2_lin_index_base + idx2]
-
-    return result
-
-
 cpdef utils.dpnp_descriptor dpnp_kron(dpnp_descriptor in_array1, dpnp_descriptor in_array2):
     cdef size_t ndim = max(in_array1.ndim, in_array2.ndim)
 

dpnp/dpnp_iface_linearalgebra.py

@@ -45,7 +45,6 @@
 
 # pylint: disable=no-name-in-module
 from .dpnp_algo import (
-    dpnp_inner,
     dpnp_kron,
 )
 from .dpnp_utils import (
@@ -218,43 +217,92 @@ def einsum_path(*args, **kwargs):
     return call_origin(numpy.einsum_path, *args, **kwargs)
 
 
-def inner(x1, x2, **kwargs):
+def inner(a, b):
     """
     Returns the inner product of two arrays.
 
     For full documentation refer to :obj:`numpy.inner`.
 
-    Limitations
-    -----------
-    Parameters `x1` and `x2` are supported as :obj:`dpnp.ndarray`.
-    Keyword argument `kwargs` is currently unsupported.
-    Otherwise the functions will be executed sequentially on CPU.
+    Parameters
+    ----------
+    a : {dpnp.ndarray, usm_ndarray, scalar}
+        First input array. Both inputs `a` and `b` can not be scalars
+        at the same time.
+    b : {dpnp.ndarray, usm_ndarray, scalar}
+        Second input array. Both inputs `a` and `b` can not be scalars
+        at the same time.
+
+    Returns
+    -------
+    out : dpnp.ndarray
+        If either `a` or `b` is a scalar, the shape of the returned arrays
+        matches that of the array between `a` and `b`, whichever is an array.
+        If `a` and `b` are both 1-D arrays then a 0-d array is returned;
+        otherwise an array with a shape as
+        ``out.shape = (*a.shape[:-1], *b.shape[:-1])`` is returned.
+
 
     See Also
     --------
-    :obj:`dpnp.einsum` : Evaluates the Einstein summation convention
-                         on the operands.
-    :obj:`dpnp.dot` : Returns the dot product of two arrays.
-    :obj:`dpnp.tensordot` : Compute tensor dot product along specified axes.
-    Input array data types are limited by supported DPNP :ref:`Data types`.
+    :obj:`dpnp.einsum` : Einstein summation convention..
+    :obj:`dpnp.dot` : Generalised matrix product,
+                      using second last dimension of `b`.
+    :obj:`dpnp.tensordot` : Sum products over arbitrary axes.
 
     Examples
     --------
+    # Ordinary inner product for vectors
+
     >>> import dpnp as np
-    >>> a = np.array([1,2,3])
+    >>> a = np.array([1, 2, 3])
     >>> b = np.array([0, 1, 0])
-    >>> result = np.inner(a, b)
-    >>> [x for x in result]
-    [2]
+    >>> np.inner(a, b)
+    array(2)
+
+    # Some multidimensional examples
+
+    >>> a = np.arange(24).reshape((2,3,4))
+    >>> b = np.arange(4)
+    >>> c = np.inner(a, b)
+    >>> c.shape
+    (2, 3)
+    >>> c
+    array([[ 14,  38,  62],
+           [86, 110, 134]])
+
+    >>> a = np.arange(2).reshape((1,1,2))
+    >>> b = np.arange(6).reshape((3,2))
+    >>> c = np.inner(a, b)
+    >>> c.shape
+    (1, 1, 3)
+    >>> c
+    array([[[1, 3, 5]]])
+
+    An example where `b` is a scalar
+
+    >>> np.inner(np.eye(2), 7)
+    array([[7., 0.],
+           [0., 7.]])
 
     """
 
-    x1_desc = dpnp.get_dpnp_descriptor(x1, copy_when_nondefault_queue=False)
-    x2_desc = dpnp.get_dpnp_descriptor(x2, copy_when_nondefault_queue=False)
-    if x1_desc and x2_desc and not kwargs:
-        return dpnp_inner(x1_desc, x2_desc).get_pyobj()
+    dpnp.check_supported_arrays_type(a, b, scalar_type=True)
+
+    if dpnp.isscalar(a) or dpnp.isscalar(b):
+        return dpnp.multiply(a, b)
+
+    if a.ndim == 0 or b.ndim == 0:
+        return dpnp.multiply(a, b)
+
+    if a.shape[-1] != b.shape[-1]:
+        raise ValueError(
+            "shape of input arrays is not similar at the last axis."
+        )
+
+    if a.ndim == 1 and b.ndim == 1:
+        return dpnp_dot(a, b)
 
-    return call_origin(numpy.inner, x1, x2, **kwargs)
+    return dpnp.tensordot(a, b, axes=(-1, -1))
 
 
 def kron(x1, x2):
@@ -567,16 +615,20 @@ def tensordot(a, b, axes=2):
 
     dpnp.check_supported_arrays_type(a, b, scalar_type=True)
 
-    if dpnp.isscalar(a):
-        a = dpnp.array(a, sycl_queue=b.sycl_queue, usm_type=b.usm_type)
-    elif dpnp.isscalar(b):
-        b = dpnp.array(b, sycl_queue=a.sycl_queue, usm_type=a.usm_type)
+    if dpnp.isscalar(a) or dpnp.isscalar(b):
+        if not isinstance(axes, int) or axes != 0:
+            raise ValueError(
+                "One of the inputs is scalar, axes should be zero."
+            )
+        return dpnp.multiply(a, b)
 
     try:
         iter(axes)
     except Exception as e:  # pylint: disable=broad-exception-caught
         if not isinstance(axes, int):
             raise TypeError("Axes must be an integer.") from e
+        if axes < 0:
+            raise ValueError("Axes must be a nonnegative integer.") from e
         axes_a = tuple(range(-axes, 0))
         axes_b = tuple(range(0, axes))
     else:
@@ -590,6 +642,15 @@ def tensordot(a, b, axes=2):
         if len(axes_a) != len(axes_b):
             raise ValueError("Axes length mismatch.")
 
+    # Make the axes non-negative
+    a_ndim = a.ndim
+    b_ndim = b.ndim
+    axes_a = normalize_axis_tuple(axes_a, a_ndim, "axis_a")
+    axes_b = normalize_axis_tuple(axes_b, b_ndim, "axis_b")
+
+    if a.ndim == 0 or b.ndim == 0:
+        return dpnp.multiply(a, b)
+
     a_shape = a.shape
     b_shape = b.shape
     for axis_a, axis_b in zip(axes_a, axes_b):
@@ -598,12 +659,6 @@ def tensordot(a, b, axes=2):
                 "shape of input arrays is not similar at requested axes."
             )
 
-    # Make the axes non-negative
-    a_ndim = a.ndim
-    b_ndim = b.ndim
-    axes_a = normalize_axis_tuple(axes_a, a_ndim, "axis")
-    axes_b = normalize_axis_tuple(axes_b, b_ndim, "axis")
-
     # Move the axes to sum over, to the end of "a"
     notin = tuple(k for k in range(a_ndim) if k not in axes_a)
     newaxes_a = notin + axes_a

dpnp/dpnp_iface_mathematical.py

@@ -770,6 +770,10 @@ def cross(a, b, axisa=-1, axisb=-1, axisc=-1, axis=None):
             raise TypeError(f"axis should be an integer but got, {type(axis)}.")
         axisa, axisb, axisc = (axis,) * 3
     dpnp.check_supported_arrays_type(a, b)
+    if a.dtype == dpnp.bool and b.dtype == dpnp.bool:
+        raise TypeError(
+            "Input arrays with boolean data type are not supported."
+        )
     # Check axisa and axisb are within bounds
     axisa = normalize_axis_index(axisa, a.ndim, msg_prefix="axisa")
     axisb = normalize_axis_index(axisb, b.ndim, msg_prefix="axisb")