docstr: ivy.Container static 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
  ----------
  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 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 = ivy.Container.static_vector_norm(x)
  >>> print(y)
  {
      a: ivy.array([3.7416575]),
      b: ivy.array([3.77359247])
  }
code: def _static_vector_norm(
      x: Union[ivy.Array, ivy.NativeArray, 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:
      """ivy.Container static 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
      ----------
      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 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 = ivy.Container.static_vector_norm(x)
      >>> print(y)
      {
          a: ivy.array([3.7416575]),
          b: ivy.array([3.77359247])
      }
      """
      return ContainerBase.cont_multi_map_in_function(
          "vector_norm",
          x,
          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 51 for calling the _ContainerWithLinearAlgebra obj's underlying member method code with example usage: obj._static_vector_norm() and returns: ContainerBase