code: def pinv(
      x: Union[ivy.Array, ivy.NativeArray],
      /,
      *,
      rtol: Optional[Union[float, Tuple[float]]] = None,
      out: Optional[ivy.Array] = None,
  ) -> ivy.Array:
      """Return the (Moore-Penrose) pseudo-inverse of a matrix (or a stack of
      matrices) ``x``.
  
      Parameters
      ----------
      x
          input array having shape ``(..., M, N)`` and whose innermost two dimensions form
          ``MxN`` matrices. Should have a floating-point data type.
      rtol
          relative tolerance for small singular values. Singular values approximately less
          than or equal to ``rtol * largest_singular_value`` are set to zero. If a
          ``float``, the value is equivalent to a zero-dimensional array having a
          floating-point data type determined by :ref:`type-promotion` (as applied to
          ``x``) and must be broadcast against each matrix. If an ``array``, must have a
          floating-point data type and must be compatible with ``shape(x)[:-2]``
          (see :ref:`broadcasting`). If ``None``, the default value is
          ``max(M, N) * eps``, where ``eps`` must be the machine epsilon associated with
          the floating-point data type determined by :ref:`type-promotion` (as applied to
          ``x``). Default: ``None``.
      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 pseudo-inverses. The returned array must have a
          floating-point data type determined by :ref:`type-promotion` and must have shape
          ``(..., N, M)`` (i.e., must have the same shape as ``x``, except the innermost
          two dimensions must be transposed).
  
  
      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.pinv.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
      --------
      >>> x = ivy.array([[1., 2.],[3., 4.]])
      >>> y = ivy.pinv(x)
      >>> print(y)
      ivy.array([[-1.99999988,  1.        ],
             [ 1.5       , -0.5       ]])
  
      >>> x = ivy.array([[1., 2.],[3., 4.]])
      >>> out = ivy.zeros(x.shape)
      >>> ivy.pinv(x, out=out)
      >>> print(out)
      ivy.array([[-1.99999988,  1.        ],
             [ 1.5       , -0.5       ]])
      """
      return current_backend(x).pinv(x, rtol=rtol, 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 16 for calling a global function with example usage: pinv() and returns: current_backend