code: def vector_norm(
      x: Union[ivy.Array, ivy.NativeArray],
      /,
      *,
      axis: Optional[Union[int, Sequence[int]]] = None,
      keepdims: bool = False,
      ord: Union[int, float, Literal[inf, -inf]] = 2,
      dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None,
      out: Optional[ivy.Array] = None,
  ) -> ivy.Array:
      r"""Compute the vector norm of a vector (or batch of vectors) ``x``.
  
      Parameters
      ----------
      x
          input array. Should have a floating-point data type.
      axis
          If an integer, ``axis`` specifies the axis (dimension) along which to compute
          vector norms. If an n-tuple, ``axis`` specifies the axes (dimensions) along
          which to compute batched vector norms. If ``None``, the vector norm must be
          computed over all array values (i.e., equivalent to computing the vector norm of
          a flattened array). Negative indices are also supported. Default: ``None``.
      keepdims
          If ``True``, the axes (dimensions) specified by ``axis`` must be included in the
          result as singleton dimensions, and, accordingly, the result must be compatible
          with the input array (see :ref:`broadcasting`). Otherwise, if ``False``, the
          axes (dimensions) specified by ``axis`` must not be included in the result.
          Default: ``False``.
      ord
          order of the norm. The following mathematical norms are supported:
  
          +------------------+----------------------------+
          | ord              | description                |
          +==================+============================+
          | 1                | L1-norm (Manhattan)        |
          +------------------+----------------------------+
          | 2                | L2-norm (Euclidean)        |
          +------------------+----------------------------+
          | inf              | infinity norm              |
          +------------------+----------------------------+
          | (int,float >= 1) | p-norm                     |
          +------------------+----------------------------+
  
          The following non-mathematical "norms" are also supported:
  
          +------------------+--------------------------------+
          | ord              | description                    |
          +==================+================================+
          | 0                | sum(a != 0)                    |
          +------------------+--------------------------------+
          | -inf             | min(abs(a))                    |
          +------------------+--------------------------------+
          | (int,float < 1)  | sum(abs(a)\*\*ord)\*\*(1./ord) |
          +------------------+--------------------------------+
  
          Default: ``2``.
      dtype
          data type that may be used to perform the computation more precisely. The input
          array ``x`` gets cast to ``dtype`` before the function's computations.
      out
          optional output array, for writing the result to. It must have a shape that the
          inputs broadcast to.
  
      Returns
      -------
      ret
          an array containing the vector norms. If ``axis`` is ``None``, the returned
          array must be a zero-dimensional array containing a vector norm. If ``axis`` is
          a scalar value (``int`` or ``float``), the returned array must have a rank which
          is one less than the rank of ``x``. If ``axis`` is a ``n``-tuple, the returned
          array must have a rank which is ``n`` less than the rank of ``x``. The returned
          array must have a floating-point data type determined by :ref:`type-promotion`.
          If ``x`` has a complex-valued data type, the returned array must have a
          real-valued floating-point data type whose precision matches the precision
          of ``x`` (e.g., if ``x`` is ``complex128``, then the returned array must have
          a ``float64`` data type).
  
  
      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.vector_norm.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
      --------
      >>> x = ivy.array([1., 2., 3.])
      >>> y = ivy.vector_norm(x)
      >>> print(y)
      ivy.array([3.7416575])
  
      >>> x = ivy.array([[1, 2, 3], [1.3, 2.4, -1.2]])
      >>> y = ivy.vector_norm(x, axis = 1, ord = 1, dtype = ivy.float32)
      >>> print(y)
      ivy.array([6., 4.9000001])
  
      >>> x = ivy.array([[1, 2, 3], [1.3, 2.4, -1.2]])
      >>> y = ivy.vector_norm(x, axis = 0, keepdims = True,  ord = float("inf"))
      >>> print(y)
  
      ivy.array([[1.3, 2.4, 3.]])
  
      >>> x = ivy.native_array([1, 2, 3, 4], dtype = ivy.float32)
      >>> y = ivy.vector_norm(x, ord = 3.)
      >>> print(y)
  
      ivy.array([4.64158917])
  
      >>> x = ivy.array([1,2,3,4], dtype = ivy.float16)
      >>> z = ivy.empty(shape = 1)
      >>> y = ivy.vector_norm(x, ord = 0, out = z)
      >>> print(y)
      ivy.array(4.)
  
      >>> x = ivy.arange(8).reshape((2,2,2))
      >>> y = ivy.vector_norm(x, axis = (0,1), ord = float("-inf"))
      >>> print(y)
      ivy.array([0, 1])
  
      >>> x = ivy.Container(a = [-1., 1., -2., 2.], b = [0., 1.2, 2.3, -3.1])
      >>> y = ivy.vector_norm(x, ord = -1)
      >>> print(y)
      {
          a: ivy.array([0.33333334]),
          b: ivy.array([0.])
      }
      """
      return current_backend(x).vector_norm(
          x, axis=axis, keepdims=keepdims, ord=ord, dtype=dtype, 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 25 for calling a global function with example usage: vector_norm() and returns: current_backend