class_docstr: A Column object for Numeric types.
  
  Parameters
  ----------
  data : Buffer
  dtype : np.dtype
      The dtype associated with the data Buffer
  mask : Buffer, optional
class_docstr_tok: ["A","Column","object","for","Numeric","types",".","Parameters","--","--","--","--","--","data",":","Buffer","dtype",":","np.dtype","The","dtype","associated","with","the","data","Buffer","mask",":","Buffer",",","optional"]
code: def _binaryop(
      self, other: ColumnBinaryOperand, op: str
  ) -> ColumnBase:
      int_float_dtype_mapping = {
          np.int8: np.float32,
          np.int16: np.float32,
          np.int32: np.float32,
          np.int64: np.float64,
          np.uint8: np.float32,
          np.uint16: np.float32,
          np.uint32: np.float64,
          np.uint64: np.float64,
          np.bool_: np.float32,
      }
  
      if op in {"__truediv__", "__rtruediv__"}:
          # Division with integer types results in a suitable float.
          if truediv_type := int_float_dtype_mapping.get(
              self.dtype.type
          ):
              return self.astype(truediv_type)._binaryop(other, op)
  
      reflect, op = self._check_reflected_op(op)
      if (
          other := self._wrap_binop_normalization(other)
      ) is NotImplemented:
          return NotImplemented
      out_dtype = self.dtype
      if other is not None:
          out_dtype = np.result_type(self.dtype, other.dtype)
          if op in {"__mod__", "__floordiv__"}:
              tmp = self if reflect else other
              # Guard against division by zero for integers.
              if (
                  (tmp.dtype.type in int_float_dtype_mapping)
                  and (tmp.dtype.type != np.bool_)
                  and (
                      (
                          (
                              np.isscalar(tmp)
                              or (
                                  isinstance(tmp, cudf.Scalar)
                                  # host to device copy
                                  and tmp.is_valid()
                              )
                          )
                          and (0 == tmp)
                      )
                      or (
                          (isinstance(tmp, NumericalColumn))
                          and (0 in tmp)
                      )
                  )
              ):
                  out_dtype = cudf.dtype("float64")
  
      if op in {
          "__lt__",
          "__gt__",
          "__le__",
          "__ge__",
          "__eq__",
          "__ne__",
          "NULL_EQUALS",
      }:
          out_dtype = "bool"
  
      if op in {"__and__", "__or__", "__xor__"}:
          if is_float_dtype(self.dtype) or is_float_dtype(other.dtype):
              raise TypeError(
                  f"Operation 'bitwise {op[2:-2]}' not supported between "
                  f"{self.dtype.type.__name__} and "
                  f"{other.dtype.type.__name__}"
              )
          if is_bool_dtype(self.dtype) or is_bool_dtype(other.dtype):
              out_dtype = "bool"
  
      if (
          op == "__pow__"
          and is_integer_dtype(self.dtype)
          and (is_integer(other) or is_integer_dtype(other.dtype))
      ):
          op = "INT_POW"
  
      lhs, rhs = (other, self) if reflect else (self, other)
  
      return libcudf.binaryop.binaryop(lhs, rhs, op, out_dtype)
  
imports: from __future__ import annotations
  from typing import Any, Callable, Mapping, Optional, Sequence, Tuple, Union, cast
  import cupy
  import numpy
  import pandas
  from typing_extensions import Self
  import cudf
  from cudf import _lib
  from cudf._lib.types import size_type_dtype
  from cudf._typing import ColumnBinaryOperand, ColumnLike, Dtype, DtypeObj, ScalarLike
  from cudf.api.types import is_bool_dtype, is_float_dtype, is_integer, is_integer_dtype, is_scalar
  from cudf.core.buffer import Buffer, cuda_array_interface_wrapper
  from cudf.core.column import ColumnBase, as_column, build_column, column, full, string
  from cudf.core.dtypes import CategoricalDtype
  from cudf.core.mixins import BinaryOperand
  from cudf.utils.dtypes import NUMERIC_TYPES, min_column_type, min_signed_type, np_dtypes_to_pandas_dtypes, numeric_normalize_types
  from .numerical_base import NumericalBaseColumn
label_desc: Use image node_id 9 for calling the NumericalColumn obj's underlying member method code with example usage: obj._binaryop(other, op) and returns: libcudf, NotImplemented, self