docstr: ivy.Container instance method variant of ivy.vector_norm. This
  method simply wraps the function, and so the docstring for
  ivy.vector_norm also applies to this method with minimal changes.
  
  Parameters
  ----------
  self
      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 must
      be 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 must be supported:
  
      +------------------+----------------------------+
      | ord              | description                |
      +==================+============================+
      | 1                | L1-norm (Manhattan)        |
      +------------------+----------------------------+
      | 2                | L2-norm (Euclidean)        |
      +------------------+----------------------------+
      | inf              | infinity norm              |
      +------------------+----------------------------+
      | (int,float >= 1) | p-norm                     |
      +------------------+----------------------------+
  
      The following non-mathematical "norms" must be supported:
  
      +------------------+--------------------------------+
      | ord              | description                    |
      +==================+================================+
      | 0                | sum(a != 0)                    |
      +------------------+--------------------------------+
      | -1               | 1./sum(1./abs(a))              |
      +------------------+--------------------------------+
      | -2               | 1./sqrt(sum(1./abs(a)/*/*2))   | # noqa
      +------------------+--------------------------------+
      | -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`.
  
  Examples
  --------
  >>> x = ivy.Container(a = [1., 2., 3.], b = [-2., 0., 3.2])
  >>> y = x.vector_norm()
  >>> print(y)
  {
      a: ivy.array([3.7416575]),
      b: ivy.array([3.77359247])
  }
code: def vector_norm(
      self: ivy.Container,
      /,
      *,
      axis: Optional[Union[int, Sequence[int], ivy.Container]] = None,
      keepdims: Union[bool, ivy.Container] = False,
      ord: Union[int, float, Literal[inf, -inf], ivy.Container] = 2,
      dtype: Optional[
          Union[ivy.Dtype, ivy.NativeDtype, ivy.Container]
      ] = None,
      key_chains: Optional[
          Union[List[str], Dict[str, str], ivy.Container]
      ] = None,
      to_apply: Union[bool, ivy.Container] = True,
      prune_unapplied: Union[bool, ivy.Container] = False,
      map_sequences: Union[bool, ivy.Container] = False,
      out: Optional[ivy.Container] = None,
  ) -> ivy.Container:
      r"""ivy.Container instance method variant of ivy.vector_norm. This
      method simply wraps the function, and so the docstring for
      ivy.vector_norm also applies to this method with minimal changes.
  
      Parameters
      ----------
      self
          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 must
          be 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 must be supported:
  
          +------------------+----------------------------+
          | ord              | description                |
          +==================+============================+
          | 1                | L1-norm (Manhattan)        |
          +------------------+----------------------------+
          | 2                | L2-norm (Euclidean)        |
          +------------------+----------------------------+
          | inf              | infinity norm              |
          +------------------+----------------------------+
          | (int,float >= 1) | p-norm                     |
          +------------------+----------------------------+
  
          The following non-mathematical "norms" must be supported:
  
          +------------------+--------------------------------+
          | ord              | description                    |
          +==================+================================+
          | 0                | sum(a != 0)                    |
          +------------------+--------------------------------+
          | -1               | 1./sum(1./abs(a))              |
          +------------------+--------------------------------+
          | -2               | 1./sqrt(sum(1./abs(a)/*/*2))   | # noqa
          +------------------+--------------------------------+
          | -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`.
  
      Examples
      --------
      >>> x = ivy.Container(a = [1., 2., 3.], b = [-2., 0., 3.2])
      >>> y = x.vector_norm()
      >>> print(y)
      {
          a: ivy.array([3.7416575]),
          b: ivy.array([3.77359247])
      }
      """
      return self._static_vector_norm(
          self,
          axis=axis,
          keepdims=keepdims,
          ord=ord,
          dtype=dtype,
          key_chains=key_chains,
          to_apply=to_apply,
          prune_unapplied=prune_unapplied,
          map_sequences=map_sequences,
          out=out,
      )
  
imports: from typing import Union, Optional, Tuple, Literal, List, Dict, Sequence
  from ivy.data_classes.container.base import ContainerBase
  import ivy
label_desc: Use image node_id 52 for calling the _ContainerWithLinearAlgebra obj's underlying member method code with example usage: obj.vector_norm() and returns: self