docstr: ivy.Container instance method variant of ivy.matrix_norm. This
  method simply wraps the function, and so the docstring for
  ivy.matrix_norm also applies to this method with minimal changes.
  
  Parameters
  ----------
  self
      Container having shape (..., M, N) and whose innermost two dimensions
      form MxN matrices. Should have a floating-point data type.
  ord
      Order of the norm. Default is "fro".
  axis
      specifies the axes that hold 2-D matrices. Default: (-2, -1).
  keepdims
      If this is set to True, the axes which are normed over are left in the
      result as dimensions with size one. With this option the result will
      broadcast correctly against the original x. Default is ``False``.
  key_chains
      The key-chains to apply or not apply the method to. Default is ``None``.
  to_apply
      If True, the method will be applied to key_chains, otherwise key_chains
      will be skipped. Default is ``True``.
  prune_unapplied
      Whether to prune key_chains for which the function was not applied.
      Default is ``False``.
  map_sequences
      Whether to also map method to sequences (lists, tuples).
      Default is ``False``.
  out
      optional output array, for writing the result to. It must have a shape that
      the inputs broadcast to.
  
  Returns
  -------
  ret
      Matrix norm of the array at specified axes.
  
  Examples
  --------
  >>> x = ivy.Container(a=ivy.array([[1.1, 2.2], [1., 2.]]),                               b=ivy.array([[1., 2.], [3., 4.]]))
  >>> y = x.matrix_norm(ord=1)
  >>> print(y)
  {
      a: ivy.array(4.2),
      b: ivy.array(6.)
  }
  
  >>> x = ivy.Container(a=ivy.arange(12, dtype=float).reshape((3, 2, 2)),                               b=ivy.arange(8, dtype=float).reshape((2, 2, 2)))
  >>> ord = ivy.Container(a="nuc", b=ivy.inf)
  >>> axis = ivy.Container(a=(1, 2), b=(2, 1))
  >>> k = ivy.Container(a=True, b=False)
  >>> y = x.matrix_norm(ord=ord, axis=axis, keepdims=k)
  >>> print(y)
  {
      a: ivy.array([[[4.24]],
                   [[11.4]],
                   [[19.2]]]),
      b: ivy.array([4., 12.])
  }
code: def matrix_norm(
      self: ivy.Container,
      /,
      *,
      ord: Union[
          int, float, Literal[inf, -inf, "fro", "nuc"], ivy.Container
      ] = "fro",
      axis: Tuple[int, int, ivy.Container] = (-2, -1),
      keepdims: Union[bool, ivy.Container] = False,
      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 instance method variant of ivy.matrix_norm. This
          method simply wraps the function, and so the docstring for
          ivy.matrix_norm also applies to this method with minimal changes.
  
          Parameters
          ----------
          self
              Container having shape (..., M, N) and whose innermost two dimensions
              form MxN matrices. Should have a floating-point data type.
          ord
              Order of the norm. Default is "fro".
          axis
              specifies the axes that hold 2-D matrices. Default: (-2, -1).
          keepdims
              If this is set to True, the axes which are normed over are left in the
              result as dimensions with size one. With this option the result will
              broadcast correctly against the original x. Default is ``False``.
          key_chains
              The key-chains to apply or not apply the method to. Default is ``None``.
          to_apply
              If True, the method will be applied to key_chains, otherwise key_chains
              will be skipped. Default is ``True``.
          prune_unapplied
              Whether to prune key_chains for which the function was not applied.
              Default is ``False``.
          map_sequences
              Whether to also map method to sequences (lists, tuples).
              Default is ``False``.
          out
              optional output array, for writing the result to. It must have a shape that
              the inputs broadcast to.
  
          Returns
          -------
          ret
              Matrix norm of the array at specified axes.
  
          Examples
          --------
          >>> x = ivy.Container(a=ivy.array([[1.1, 2.2], [1., 2.]]), \
                                b=ivy.array([[1., 2.], [3., 4.]]))
          >>> y = x.matrix_norm(ord=1)
          >>> print(y)
          {
              a: ivy.array(4.2),
              b: ivy.array(6.)
          }
  
          >>> x = ivy.Container(a=ivy.arange(12, dtype=float).reshape((3, 2, 2)), \
                                b=ivy.arange(8, dtype=float).reshape((2, 2, 2)))
          >>> ord = ivy.Container(a="nuc", b=ivy.inf)
          >>> axis = ivy.Container(a=(1, 2), b=(2, 1))
          >>> k = ivy.Container(a=True, b=False)
          >>> y = x.matrix_norm(ord=ord, axis=axis, keepdims=k)
          >>> print(y)
          {
              a: ivy.array([[[4.24]],
                           [[11.4]],
                           [[19.2]]]),
              b: ivy.array([4., 12.])
          }
          """
      return self._static_matrix_norm(
          self,
          ord=ord,
          axis=axis,
          keepdims=keepdims,
          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 24 for calling the _ContainerWithLinearAlgebra obj's underlying member method code with example usage: obj.matrix_norm() and returns: self