Leverage dpctl.tensor.iinfo() and dpctl.tensor.finfo() implementation.

dpnp/dpnp_iface_types.py

@@ -34,8 +34,11 @@
 This module provides public type interface file for the library
 """
 
+import dpctl.tensor as dpt
 import numpy
 
+from dpnp.dpnp_array import dpnp_array
+
 __all__ = [
  "bool",
  "bool_",
@@ -50,12 +53,14 @@
  "dtype",
  "e",
  "euler_gamma",
+ "finfo",
  "float",
  "float_",
  "float16",
  "float32",
  "float64",
  "floating",
+ "iinfo",
  "inexact",
  "Inf",
  "inf",
@@ -140,6 +145,85 @@
 PZERO = numpy.PZERO
 
 
+def finfo(dtype):
+ """
+ Returns machine limits for floating-point data types.
+
+ For full documentation refer to :obj:`numpy.finfo`.
+
+ Parameters
+ ----------
+ dtype : dtype, dpnp_array
+ Floating-point dtype or an array with floating point data type.
+ If complex, the information is about its component data type.
+
+ Returns
+ -------
+ out : finfo_object
+ An object have the following attributes
+ * bits: int
+ number of bits occupied by dtype.
+ * dtype: dtype
+ real-valued floating-point data type.
+ * eps: float
+ difference between 1.0 and the next smallest representable
+ real-valued floating-point number larger than 1.0 according
+ to the IEEE-754 standard.
+ * epsneg: float
+ difference between 1.0 and the next smallest representable real-valued
+ floating-point number smaller than 1.0 according to the IEEE-754
+ standard.
+ * max: float
+ largest representable real-valued number.
+ * min: float
+ smallest representable real-valued number.
+ * precision: float
+ the approximate number of decimal digits to which this kind of
+ floating point type is precise.
+ * resolution: float
+ the approximate decimal resolution of this type.
+ * tiny: float
+ an alias for `smallest_normal`
+ * smallest_normal: float
+ smallest positive real-valued floating-point number with
+ full precision.
+
+ """
+ if isinstance(dtype, dpnp_array):
+ dtype = dtype.dtype
+ return dpt.finfo(dtype)
+
+
+def iinfo(dtype):
+ """
+ Returns machine limits for integer data types.
+
+ For full documentation refer to :obj:`numpy.iinfo`.
+
+ Parameters
+ ----------
+ dtype : dtype, dpnp_array
+ Integer dtype or an array with integer dtype.
+
+ Returns
+ -------
+ out : iinfo_object
+ An object with the following attributes
+ * bits: int
+ number of bits occupied by the data type
+ * dtype: dtype
+ integer data type.
+ * max: int
+ largest representable number.
+ * min: int
+ smallest representable number.
+
+ """
+ if isinstance(dtype, dpnp_array):
+ dtype = dtype.dtype
+ return dpt.iinfo(dtype)
+
+
 def isscalar(obj):
  """
  Returns True if the type of `obj` is a scalar type.

dpnp/random/dpnp_algo_random.pyx

@@ -462,7 +462,7 @@ cdef class MT19937(_Engine):
  if value < 0:
  return False
 
- max_val = numpy.iinfo(numpy.uint32).max
+ max_val = dpnp.iinfo(numpy.uint32).max
  if isinstance(value, dpnp_array):
  max_val = dpnp.array(max_val, dtype=numpy.uint32)
  return value <= max_val
@@ -499,7 +499,7 @@ cdef class MCG59(_Engine):
  if value < 0:
  return False
 
- max_val = numpy.iinfo(numpy.uint64).max
+ max_val = dpnp.iinfo(numpy.uint64).max
  if isinstance(value, dpnp_array):
  max_val = dpnp.array(max_val, dtype=numpy.uint64)
  return value <= max_val
@@ -1052,7 +1052,7 @@ cpdef utils.dpnp_descriptor dpnp_rng_negative_binomial(double a, double p, size)
 
  result_shape = utils._object_to_tuple(size)
  if p == 0.0:
- filled_val = numpy.iinfo(dtype).min
+ filled_val = dpnp.iinfo(dtype).min
  return utils.dpnp_descriptor(dpnp.full(result_shape, filled_val, dtype=dtype))
  elif p == 1.0:
  return utils.dpnp_descriptor(dpnp.full(result_shape, 0, dtype=dtype))

dpnp/random/dpnp_iface_random.py

@@ -675,7 +675,7 @@ def multinomial(n, pvals, size=None):
  d = len(pvals)
  if n < 0:
  pass
- elif n > numpy.iinfo(dpnp.int32).max:
+ elif n > dpnp.iinfo(dpnp.int32).max:
  pass
  elif pvals_sum > 1.0:
  pass

dpnp/random/dpnp_random_state.py

@@ -81,7 +81,7 @@ def __init__(self, seed=None, device=None, sycl_queue=None):
  is_cpu = self._sycl_device.is_cpu
  if seed is None:
  low = 0
- high = numpy.iinfo(numpy.int32).max + 1
+ high = dpnp.iinfo(numpy.int32).max + 1
 
  if is_cpu:
  # ask NumPy to generate an array of three random integers as default seed value
@@ -237,8 +237,8 @@ def normal(
  dtype = self._validate_float_dtype(
  dtype, (dpnp.float32, dpnp.float64)
  )
- min_floating = numpy.finfo(dtype).min
- max_floating = numpy.finfo(dtype).max
+ min_floating = dpnp.finfo(dtype).min
+ max_floating = dpnp.finfo(dtype).max
 
  if (
  loc >= max_floating or loc <= min_floating
@@ -371,8 +371,8 @@ def randint(self, low, high=None, size=None, dtype=int, usm_type="device"):
  high = low
  low = 0
 
- min_int = numpy.iinfo("int32").min
- max_int = numpy.iinfo("int32").max
+ min_int = dpnp.iinfo("int32").min
+ max_int = dpnp.iinfo("int32").max
 
  if (
  not self._is_finite_scalar(low)
@@ -587,8 +587,8 @@ def uniform(
  elif not dpnp.isscalar(high):
  pass
  else:
- min_double = numpy.finfo("double").min
- max_double = numpy.finfo("double").max
+ min_double = dpnp.finfo("double").min
+ max_double = dpnp.finfo("double").max
 
  if (
  not self._is_finite_scalar(low)

tests/helper.py

@@ -18,7 +18,7 @@ def assert_dtype_allclose(dpnp_arr, numpy_arr, check_type=True):
  is_inexact = lambda x: dpnp.issubdtype(x.dtype, dpnp.inexact)
  if is_inexact(dpnp_arr) or is_inexact(numpy_arr):
  tol = 8 * max(
-numpy.finfo(dpnp_arr.dtype).resolution,
+dpnp.finfo(dpnp_arr).resolution,
  numpy.finfo(numpy_arr.dtype).resolution,
  )
  assert_allclose(dpnp_arr.asnumpy(), numpy_arr, atol=tol, rtol=tol)

tests/test_random.py

@@ -674,10 +674,10 @@ def test_extreme_value(self):
  )
  n = 5
  p = 0.0
- res = dpnp.asnumpy(dpnp.random.negative_binomial(n=n, p=p, size=10))
- check_val = numpy.iinfo(res.dtype).min
- assert len(numpy.unique(res)) == 1
- assert numpy.unique(res)[0] == check_val
+ res = dpnp.random.negative_binomial(n=n, p=p, size=10)
+ check_val = dpnp.iinfo(res).min
+ assert len(dpnp.unique(res)) == 1
+ assert dpnp.unique(res)[0] == check_val
 
  def test_invalid_args(self):
  n = 10 # parameter `n`, OK