code: def inner(a, b):
      """
      inner(a, b, /)
  
      Inner product of two arrays.
  
      Ordinary inner product of vectors for 1-D arrays (without complex
      conjugation), in higher dimensions a sum product over the last axes.
  
      Parameters
      ----------
      a, b : array_like
          If `a` and `b` are nonscalar, their last dimensions must match.
  
      Returns
      -------
      out : ndarray
          If `a` and `b` are both
          scalars or both 1-D arrays then a scalar is returned; otherwise
          an array is returned.
          ``out.shape = (*a.shape[:-1], *b.shape[:-1])``
  
      Raises
      ------
      ValueError
          If both `a` and `b` are nonscalar and their last dimensions have
          different sizes.
  
      See Also
      --------
      tensordot : Sum products over arbitrary axes.
      dot : Generalised matrix product, using second last dimension of `b`.
      einsum : Einstein summation convention.
  
      Notes
      -----
      For vectors (1-D arrays) it computes the ordinary inner-product::
  
          np.inner(a, b) = sum(a[:]*b[:])
  
      More generally, if ``ndim(a) = r > 0`` and ``ndim(b) = s > 0``::
  
          np.inner(a, b) = np.tensordot(a, b, axes=(-1,-1))
  
      or explicitly::
  
          np.inner(a, b)[i0,...,ir-2,j0,...,js-2]
               = sum(a[i0,...,ir-2,:]*b[j0,...,js-2,:])
  
      In addition `a` or `b` may be scalars, in which case::
  
         np.inner(a,b) = a*b
  
      Examples
      --------
      Ordinary inner product for vectors:
  
      >>> a = np.array([1,2,3])
      >>> b = np.array([0,1,0])
      >>> np.inner(a, b)
      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.]])
  
      """
      return (a, b)
  
imports: import functools
  from .None import overrides
  from .None import _multiarray_umath
  from ._multiarray_umath import *
  from ._multiarray_umath import _flagdict, from_dlpack, _place, _reconstruct, _vec_string, _ARRAY_API, _monotonicity, _get_ndarray_c_version, _get_madvise_hugepage, _set_madvise_hugepage, _get_promotion_state, _set_promotion_state
label_desc: Use image node_id 3 for calling a global function with example usage: inner(a, b) and returns: a,  b