code: def nonzero(
      x: Union[ivy.Array, ivy.NativeArray],
      /,
      *,
      as_tuple: bool = True,
      size: Optional[int] = None,
      fill_value: Number = 0,
  ) -> Union[Tuple[ivy.Array], ivy.Array]:
      """Return the indices of the array elements which are non-zero.
  
      .. note::
          If ``x`` has a complex floating-point data type, non-zero elements
          are those elements having at least one component (real or imaginary)
          which is non-zero.
  
      .. note::
          If ``x`` has a boolean data type, non-zeroelements are those elements
          which are equal to ``True``.
  
      Parameters
      ----------
      x
          input array. Must have a positive rank. If `x` is zero-dimensional, the function
          must raise an exception.
      as_tuple
          if True, the output is returned as a tuple of indices, one for each
          dimension of the input, containing the indices of the true elements in that
          dimension. If False, the coordinates are returned in a (N, ndim) array,
          where N is the number of true elements. Default = True.
      size
          if specified, the function will return an array of shape (size, ndim).
          If the number of non-zero elements is fewer than size, the remaining elements
          will be filled with fill_value. Default = None.
      fill_value
          when size is specified and there are fewer than size number of elements,
          the remaining elements in the output array will be filled with fill_value.
          Default = 0.
  
      Returns
      -------
      ret
          a tuple of `k` arrays, one for each dimension of `x` and each of size `n`
          (where `n` is the total number of non-zero elements), containing the indices of
          the non-zero elements in that dimension. The indices must be returned in
          row-major, C-style order. The returned array must have the default array index
          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/
      API_specification/generated/array_api.nonzero.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` input:
  
      >>> x = ivy.array([0, 10, 15, 20, -50, 0])
      >>> y = ivy.nonzero(x)
      >>> print(y)
      (ivy.array([1, 2, 3, 4]),)
  
      >>> x = ivy.array([[1, 2], [-1, -2]])
      >>> y = ivy.nonzero(x)
      >>> print(y)
      (ivy.array([0, 0, 1, 1]), ivy.array([0, 1, 0, 1]))
  
      >>> x = ivy.array([[0, 2], [-1, -2]])
      >>> y = ivy.nonzero(x, as_tuple=False)
      >>> print(y)
      ivy.array([[0, 1], [1, 0], [1, 1]])
  
      >>> x = ivy.array([0, 1])
      >>> y = ivy.nonzero(x, size=2, fill_value=4)
      >>> print(y)
      (ivy.array([1, 4]),)
  
      With :class:`ivy.NativeArray` input:
  
      >>> x = ivy.native_array([[10, 20], [10, 0], [0, 0]])
      >>> y = ivy.nonzero(x)
      >>> print(y)
      (ivy.array([0, 0, 1]), ivy.array([0, 1, 0]))
  
      >>> x = ivy.native_array([[0], [1], [1], [0], [1]])
      >>> y = ivy.nonzero(x)
      >>> print(y)
      (ivy.array([1, 2, 4]), ivy.array([0, 0, 0]))
  
      With :class:`ivy.Container` input:
  
      >>> x = ivy.Container(a=ivy.array([0,1,2,3,0]), b=ivy.array([1,1, 0,0]))
      >>> y = ivy.nonzero(x)
      >>> print(y)
      [{
          a: ivy.array([1, 2, 3]),
          b: ivy.array([0, 1])
      }]
  
      Instance Method Examples
      ~~~~~~~~~~~~~~~~~~~~~~~~
      With :class:`ivy.Array` instance method:
  
      >>> x = ivy.array([0,0,0,1,1,1])
      >>> y = x.nonzero()
      >>> print(y)
      (ivy.array([3, 4, 5]),)
  
      With :class:`ivy.Container` instance method:
  
      >>> x = ivy.Container(a=ivy.array([1,1,1]), b=ivy.native_array([0]))
      >>> y = x.nonzero()
      >>> print(y)
      [{
          a: ivy.array([0, 1, 2]),
          b: ivy.array([])
      }]
      """
      return current_backend(x).nonzero(
          x, as_tuple=as_tuple, size=size, fill_value=fill_value
      )
  
file_path: ivy/ivy/functional/ivy/searching.py
imports: from numbers import Number
  from typing import Union, Optional, Tuple
  import ivy
  from ivy.utils.backend import current_backend
  from ivy.utils.exceptions import handle_exceptions
  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
label_desc: Use image node_id 3 for calling a global function with example usage: nonzero() and returns: current_backend