code: def matrix_transpose(
      x: Union[ivy.Array, ivy.NativeArray],
      /,
      *,
      conjugate: bool = False,
      out: Optional[ivy.Array] = None,
  ) -> ivy.Array:
      """Transposes a matrix (or a stack of matrices) ``x``.
  
      Parameters
      ----------
      x
          input array having shape ``(..., M, N)`` and whose innermost two
          dimensions form ``MxN`` matrices.
      conjugate
          If True, takes the conjugate of the matrix.
      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 transpose for each matrix and having shape
          ``(..., N, M)``. The returned array must have the same data
          type as ``x``.
  
  
      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_transpose.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 :code: 'ivy.Array' inputs:
  
      >>> x = ivy.array([[0., 2.], [1., 3.]])
      >>> y = ivy.matrix_transpose(x)
      >>> print(y)
      ivy.array([[0., 1.],
                 [2., 3.]])
  
      >>> x = ivy.array([[1., 4.], [2., 5.], [3., 1.]])
      >>> y = ivy.zeros((2, 3))
      >>> ivy.matrix_transpose(x, out=y)
      ivy.array([[1., 2., 3.],
                 [4., 5., 1.]])
  
      >>> x = ivy.array([[2., 3.], [1., 2.]])
      >>> ivy.matrix_transpose(x, out=x)
      ivy.array([[2., 1.],
         [3., 2.]])
  
      >>> x = ivy.array([[0., 1., 2.], [1., 2., 3.]])
      >>> y = ivy.matrix_transpose(x)
      >>> print(y)
      ivy.array([[0., 1.],
                 [1., 2.],
                 [2., 3.]])
  
      With :code: 'ivy.Container' inputs:
  
      >>> x = ivy.Container(a=ivy.array([[0., 1.], [0., 2.]]), \
                            b=ivy.array([[3., 4.], [3., 5.]]))
      >>> y = ivy.matrix_transpose(x)
      >>> print(y)
      {
          a: ivy.array([[0., 0.],
                        [1., 2.]]),
          b: ivy.array([[3., 3.],
                        [4., 5.]])
      }
      """
      return current_backend(x).matrix_transpose(
          x, conjugate=conjugate, 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 14 for calling a global function with example usage: matrix_transpose() and returns: current_backend