code: def matrix_norm(
      x: Union[ivy.Array, ivy.NativeArray],
      /,
      *,
      ord: Union[int, float, Literal[inf, -inf, "fro", "nuc"]] = "fro",
      axis: Tuple[int, int] = (-2, -1),
      keepdims: bool = False,
      out: Optional[ivy.Array] = None,
  ) -> ivy.Array:
      """Compute the matrix p-norm.
  
      Parameters
      ----------
      x
          Input array having shape (..., M, N) and whose innermost two dimensions
          form MxN matrices. Should have a floating-point data type.
      ord
          order of the norm. The following mathematical norms must be supported:
  
          +------------------+---------------------------------+
          | ord              | description                     |
          +==================+=================================+
          | 'fro'            | Frobenius norm                  |
          +------------------+---------------------------------+
          | 'nuc'            | nuclear norm                    |
          +------------------+---------------------------------+
          | 1                | max(sum(abs(x), axis=0))        |
          +------------------+---------------------------------+
          | 2                | largest singular value          |
          +------------------+---------------------------------+
          | inf              | max(sum(abs(x), axis=1))        |
          +------------------+---------------------------------+
  
          The following non-mathematical "norms" must be supported:
  
          +------------------+---------------------------------+
          | ord              | description                     |
          +==================+=================================+
          | -1               | min(sum(abs(x), axis=0))        |
          +------------------+---------------------------------+
          | -2               | smallest singular value         |
          +------------------+---------------------------------+
          | -inf             | min(sum(abs(x), axis=1))        |
          +------------------+---------------------------------+
  
          If ``ord=1``, the norm corresponds to the induced matrix norm where
          ``p=1`` (i.e., the maximum absolute value column sum).
  
          If ``ord=2``, the norm corresponds to the induced matrix norm where
          ``p=inf`` (i.e., the maximum absolute value row sum).
  
          If ``ord=inf``, the norm corresponds to the induced matrix norm where
          ``p=2`` (i.e., the largest singular value).
  
          Default: "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``.
      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. If ``keepdims`` is ``False``, the
          returned array must have a rank which is two less than the ranl of ``x``.
          If ``x`` has a real-valued data type, the returned array must have a real-valued
          floating-point data type based on 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.matrix_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
      --------
      With :class:`ivy.Array` inputs:
  
      >>> x = ivy.array([[1., 2.], [3., 4.]])
      >>> y = ivy.matrix_norm(x)
      >>> print(y)
      ivy.array(5.47722558)
  
      >>> x = ivy.arange(8, dtype=float).reshape((2, 2, 2))
      >>> y = ivy.zeros(2)
      >>> ivy.matrix_norm(x, ord=1, out=y)
      >>> print(y)
      ivy.array([ 4., 12.])
  
      >>> x = ivy.arange(12, dtype=float).reshape((3, 2, 2))
      >>> y = ivy.zeros((3,))
      >>> ivy.matrix_norm(x, ord=ivy.inf, axis=(2, 1), out=y)
      >>> print(y)
      ivy.array([ 4., 12., 20.])
  
      >>> x = ivy.array([[1.1, 2.2], [3.3, 4.4], [5.5, 6.6]])
      >>> y = ivy.matrix_norm(x, ord='nuc', keepdims=True)
      >>> print(y)
      ivy.array([[11.]])
  
      >>> x = ivy.array([[[1.1, 2.2, 3.3], [4.4, 5.5, 6.6]],
      ...                 [[1., 0., 1.1], [1., 1., 0.]]])
      >>> y = ivy.zeros((2,))
      >>> ivy.matrix_norm(x, ord='fro', out=y)
      >>> print(y)
      ivy.array([10.5 ,  2.05])
  
      With :class:`ivy.Container` input:
  
      >>> x = ivy.Container(a=ivy.array([[0.666, 9.11],
      ...                                [42.69, 9.23]]),
      ...                   b=ivy.array([[1.1, 2.2, 3.3],
      ...                                [4.4, 5.5, 6.6]]))
      >>> y = ivy.matrix_norm(x, ord=-ivy.inf)
      >>> print(y)
      {
          a: ivy.array(9.776),
          b: ivy.array(6.6000004)
      }
  
      With multiple :class:`ivy:Container` inputs:
  
      >>> 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=1, b=float('inf'))
      >>> axis = ivy.Container(a=(1, 2), b=(2, 1))
      >>> k = ivy.Container(a=False, b=True)
      >>> y = ivy.matrix_norm(x, ord=ord, axis=axis, keepdims=k)
      >>> print(y)
      {
          a: ivy.array([4., 12., 20.]),
          b: ivy.array([[[4.]],
                        [[12.]]])
      }
      """
      return current_backend(x).matrix_norm(
          x, ord=ord, axis=axis, keepdims=keepdims, 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 11 for calling a global function with example usage: matrix_norm() and returns: current_backend