code: def conj(
      x: Union[ivy.Array, ivy.NativeArray],
      /,
      *,
      out: Optional[ivy.Array] = None,
  ) -> ivy.Array:
      """Return the complex conjugate for each element ``x_i`` of the input array
      ``x``.
  
      For complex number of the form
  
      .. math::
          a + bj
  
      the complex conjugate is defined as
  
      .. math::
          a - bj
  
      Hence, the returned conjugates must be computed by negating
      the imaginary component of each element ``x_i``
  
      This method 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/
      API_specification/generated/array_api.conj.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.
  
      Parameters
      ----------
      x
          input array.
      out
          optional output array, for writing the result to.
          It must have a shape that the inputs broadcast to.
  
      Returns
      -------
      ret
          an array of the same dtype as the input array with
          the complex conjugates of the complex values present
          in the input array. If x is a scalar then a scalar
          will be returned.
  
      The descriptions above assume an array input for simplicity, but
      the method also accepts :class:`ivy.Container` instances
      in place of: class:`ivy.Array` or :class:`ivy.NativeArray`
      instances, as shown in the type hints and also the examples below.
  
  
      Examples
      --------
      With :class:`ivy.Array` inputs:
      >>> x = ivy.array([4.2-0j, 3j, 7+5j])
      >>> z = ivy.conj(x)
      >>> print(z)
      ivy.array([4.2-0.j, 0. -3.j, 7. -5.j])
  
      With :class:`ivy.Container` input:
      >>> x = ivy.Container(a=ivy.array([-6.7-7j, 0.314+0.355j, 1.23]),
      ...                   b=ivy.array([5j, 5.32-6.55j, 3.001]))
      >>> z = ivy.conj(x)
      >>> print(z)
      {
          a: ivy.array([-6.7+7.j, 0.314-0.355j, 1.23-0.j]),
          b: ivy.array([0.-5.j, 5.32+6.55j, 3.001-0.j])
      }
      """
      return ivy.current_backend(x).conj(x, out=out)
  
imports: from typing import Optional, Union, Tuple, List, Sequence
  from numbers import Number
  import ivy
  from ivy.func_wrapper import handle_out_argument, to_native_arrays_and_back, handle_nestable, handle_partial_mixed_function, handle_array_like_without_promotion, inputs_to_ivy_arrays, handle_array_function, infer_dtype, handle_device, handle_backend_invalid
  from ivy.utils.exceptions import handle_exceptions
label_desc: Use image node_id 21 for calling a global function with example usage: conj() and returns: ivy