code: def vecdot(
      x1: Union[ivy.Array, ivy.NativeArray],
      x2: Union[ivy.Array, ivy.NativeArray],
      /,
      *,
      axis: int = -1,
      out: Optional[ivy.Array] = None,
  ) -> ivy.Array:
      """Compute the (vector) dot product of two arrays.
  
      Parameters
      ----------
      x1
          first input array. Should have a numeric data type.
      x2
          second input array. Must be compatible with ``x1`` (see :ref:`broadcasting`).
          Should have a numeric data type.
      axis
          axis over which to compute the dot product. Must be an integer on the interval
          ``[-N, N)``, where ``N`` is the rank (number of dimensions) of the shape
          determined according to :ref:`broadcasting`. If specified as a negative integer,
          the function must determine the axis along which to compute the dot product by
          counting backward from the last dimension (where ``-1`` refers to the last
          dimension). By default, the function must compute the dot product over the last
          axis. Default: ``-1``.
      out
          optional output array, for writing the result to. It must have a shape that the
          inputs broadcast to.
  
      Returns
      -------
      ret
          if ``x1`` and ``x2`` are both one-dimensional arrays, a zero-dimensional
          containing the dot product; otherwise, a non-zero-dimensional array containing
          the dot products and having rank ``N-1``, where ``N`` is the rank (number of
          dimensions) of the shape determined according to :ref:`broadcasting`. The
          returned array must have a data type determined by :ref:`type-promotion`.
  
  
      **Raises**
  
          -   if provided an invalid ``axis``.
  
          -   if the size of the axis over which to compute the dot product is not
              the same for both ``x1`` and ``x2``.
  
  
  
      This function conforms to the `Array API Standard
      <https://data-apis.org/array-api/latest/>`_. This docstring is an extension of the
      `docstring <https://data-apis.org/array-api/latest/
      extensions/generated/array_api.linalg.vecdot.html>`_
      in the standard.
  
      Both the description and the type hints above assumes an array input for simplicity,
      but this function is *nestable*, and therefore also accepts :class:`ivy.Container`
      instances in place of any of the arguments.
  
      Examples
      --------
      With :class:`ivy.Array` input:
  
      >>> x1 = ivy.array([1., 2., 3.])
      >>> x2 = ivy.array([4., 5., 6.])
      >>> dot_product = ivy.vecdot(x1, x2)
      >>> print(dot_product)
      ivy.array(32.)
  
      >>> x1 = ivy.array([1., 2., 3.])
      >>> x2 = ivy.array([1., .8, 4.])
      >>> y = ivy.zeros(1)
      >>> ivy.vecdot(x1, x2, out=y)
      ivy.array(14.60000038)
  
      With :class:`ivy.Container` input:
  
      >>> x1 = ivy.array([1., 2., 3.])
      >>> x2 = ivy.Container(a=ivy.array([7., 8., 9.]), b=ivy.array([10., 11., 12.]))
      >>> dot_product = ivy.vecdot(x1, x2, axis=0)
      >>> print(dot_product)
      {
          a: ivy.array(50.),
          b: ivy.array(68.)
      }
      """
      return current_backend(x1).vecdot(x1, x2, axis=axis, out=out)
  
imports: from typing import Union, Optional, Tuple, Literal, List, Sequence
  import ivy
  from ivy.utils.backend import current_backend
  from ivy.func_wrapper import handle_array_function, to_native_arrays_and_back, handle_out_argument, handle_nestable, handle_array_like_without_promotion, handle_device, handle_backend_invalid
  from ivy.utils.exceptions import handle_exceptions
label_desc: Use image node_id 24 for calling a global function with example usage: vecdot() and returns: current_backend