code: def __init__(self, op, dtypes):
      self._op = op
      self._name = "atomic" + op
      self._dtypes = dtypes
      doc = f"""Calls the ``{self._name}`` function to operate atomically on
          ``array[index]``. Please refer to `Atomic Functions`_ for detailed
          explanation.
  
          Args:
              array: A :class:`cupy.ndarray` to index over.
              index: A valid index such that the address to the corresponding
                  array element ``array[index]`` can be computed.
              value: Represent the value to use for the specified operation. For
                  the case of :obj:`atomic_cas`, this is the value for
                  ``array[index]`` to compare with.
              alt_value: Only used in :obj:`atomic_cas` to represent the value
                  to swap to.
  
          .. seealso:: `Numba's corresponding atomic functions`_
  
          .. _Atomic Functions:
              https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#atomic-functions
  
          .. _Numba's corresponding atomic functions:
              https://numba.readthedocs.io/en/stable/cuda-reference/kernel.html#synchronization-and-atomic-operations
          """
      self.__doc__ = doc
  
imports: from typing import Any, Mapping
  import warnings
  import cupy
  from cupy_backends.cuda.api import runtime
  from cupy.cuda import device
  from cupyx.jit import _cuda_types
  from cupyx.jit import _cuda_typerules
  from cupyx.jit._internal_types import BuiltinFunc
  from cupyx.jit._internal_types import Data
  from cupyx.jit._internal_types import Constant
  from cupyx.jit._internal_types import Range
  from cupyx.jit import _compile
  from functools import reduce
label_desc: Use image node_id 1 to create a new AtomicOp object from inherited base classes: BuiltinFunc with example: obj = AtomicOp(op, dtypes)