code: def argmin(
      x: Union[ivy.Array, ivy.NativeArray],
      /,
      *,
      axis: Optional[int] = None,
      keepdims: bool = False,
      dtype: Optional[Union[ivy.Dtype, ivy.NativeDtype]] = None,
      select_last_index: bool = False,
      out: Optional[ivy.Array] = None,
  ) -> ivy.Array:
      """Return the indices of the minimum values along a specified axis. When
      the minimum value occurs multiple times, only the indices corresponding to
      the first occurrence are returned.
  
      Parameters
      ----------
      x
          input array. Should have a numeric data type.
      axis
          axis along which to search. If None, the function must return the index of the
          minimum value of the flattened array. Default = None.
      keepdims
          if True, the reduced axes (dimensions) must be included in the result as
          singleton dimensions, and, accordingly, the result must be compatible with the
          input array (see Broadcasting). Otherwise, if False, the reduced axes
          (dimensions) must not be included in the result. Default = False.
      dtype
          An optional output_dtype from: int32, int64. Defaults to int64.
      select_last_index
          If this is set to True, the index corresponding to the
          last occurrence of the maximum value will be returned.
      out
          if axis is None, a zero-dimensional array containing the index of the first
          occurrence of the minimum value; otherwise, a non-zero-dimensional array
          containing the indices of the minimum values. The returned array must have the
          default array index data type.
  
      Returns
      -------
      ret
          Array containing the indices of the minimum values across the specified axis.
  
  
      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.argmin.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., 1., -1.])
      >>> y = ivy.argmin(x)
      >>> print(y)
      ivy.array(2)
  
  
      >>> x = ivy.array([[0., 1., -1.],[-2., 1., 2.]])
      >>> y = ivy.argmin(x, axis=1)
      >>> print(y)
      ivy.array([2, 0])
  
      >>> x = ivy.array([[0., 1., -1.],[-2., 1., 2.]])
      >>> y = ivy.argmin(x, axis=1, keepdims=True)
      >>> print(y)
      ivy.array([[2],
             [0]])
  
      >>> x = ivy.array([[0., 1., -1.],[-2., 1., 2.],[1., -2., 0.]])
      >>> y= ivy.zeros((3,1), dtype=ivy.int64)
      >>> ivy.argmin(x, axis=1, keepdims=True, out=y)
      >>> print(y)
      ivy.array([[2],
             [0],
             [1]])
  
      With :class:`ivy.Container` input:
  
      >>> x = ivy.Container(a=ivy.array([0., -1., 2.]), b=ivy.array([3., 4., 5.]))
      >>> y = ivy.argmin(x)
      >>> print(y)
      {
          a: ivy.array(1),
          b: ivy.array(0)
      }
      """
      return current_backend(x).argmin(
          x,
          axis=axis,
          keepdims=keepdims,
          dtype=dtype,
          select_last_index=select_last_index,
          out=out,
      )
  
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 2 for calling a global function with example usage: argmin() and returns: current_backend