Defined finfo_object to not derive from numpy object

Added tests to cover each property.

Author: oleksandr-pavlyk

dpctl/tensor/_manipulation_functions.py

@@ -31,27 +31,91 @@
 )
 
 
-class finfo_object(np.finfo):
+class finfo_object:
     """
     `numpy.finfo` subclass which returns Python floating-point scalars for
     `eps`, `max`, `min`, and `smallest_normal` attributes.
     """
 
     def __init__(self, dtype):
         _supported_dtype([dpt.dtype(dtype)])
-        super().__init__()
+        self._finfo = np.finfo(dtype)
 
-        self.eps = float(self.eps)
-        self.max = float(self.max)
-        self.min = float(self.min)
+    @property
+    def bits(self):
+        """
+        number of bits occupied by the real-valued floating-point data type.
+        """
+        return int(self._finfo.bits)
 
     @property
     def smallest_normal(self):
-        return float(super().smallest_normal)
+        """
+        smallest positive real-valued floating-point number with full
+        precision.
+        """
+        return float(self._finfo.smallest_normal)
 
     @property
     def tiny(self):
-        return float(super().tiny)
+        """an alias for `smallest_normal`"""
+        return float(self._finfo.tiny)
+
+    @property
+    def eps(self):
+        """
+        difference between 1.0 and the next smallest representable real-valued
+        floating-point number larger than 1.0 according to the IEEE-754
+        standard.
+        """
+        return float(self._finfo.eps)
+
+    @property
+    def epsneg(self):
+        """
+        difference between 1.0 and the next smallest representable real-valued
+        floating-point number smaller than 1.0 according to the IEEE-754
+        standard.
+        """
+        return float(self._finfo.epsneg)
+
+    @property
+    def min(self):
+        """smallest representable real-valued number."""
+        return float(self._finfo.min)
+
+    @property
+    def max(self):
+        "largest representable real-valued number."
+        return float(self._finfo.max)
+
+    @property
+    def resolution(self):
+        "the approximate decimal resolution of this type."
+        return float(self._finfo.resolution)
+
+    @property
+    def precision(self):
+        """
+        the approximate number of decimal digits to which this kind of
+        floating point type is precise.
+        """
+        return float(self._finfo.precision)
+
+    @property
+    def dtype(self):
+        """
+        the dtype for which finfo returns information. For complex input, the
+        returned dtype is the associated floating point dtype for its real and
+        complex components.
+        """
+        return self._finfo.dtype
+
+    def __str__(self):
+        return self._finfo.__str__()
+
+    def __repr__(self):
+        return self._finfo.__repr__()
 
 
 def _broadcast_strides(X_shape, X_strides, res_ndim):

dpctl/tests/test_usm_ndarray_manipulation.py

@@ -84,13 +84,9 @@ def test_permute_dims_2d_3d(shapes):
 
 
 def test_expand_dims_incorrect_type():
-    X_list = list([1, 2, 3, 4, 5])
-    X_tuple = tuple(X_list)
-    Xnp = np.array(X_list)
-
-    pytest.raises(TypeError, dpt.permute_dims, X_list, 1)
-    pytest.raises(TypeError, dpt.permute_dims, X_tuple, 1)
-    pytest.raises(TypeError, dpt.permute_dims, Xnp, 1)
+    X_list = [1, 2, 3, 4, 5]
+    with pytest.raises(TypeError):
+        dpt.permute_dims(X_list, 1)
 
 
 def test_expand_dims_0d():
@@ -143,22 +139,20 @@ def test_expand_dims_tuple(axes):
 
 
 def test_expand_dims_incorrect_tuple():
-
     X = dpt.empty((3, 3, 3), dtype="i4")
-    pytest.raises(np.AxisError, dpt.expand_dims, X, (0, -6))
-    pytest.raises(np.AxisError, dpt.expand_dims, X, (0, 5))
+    with pytest.raises(np.AxisError):
+        dpt.expand_dims(X, (0, -6))
+    with pytest.raises(np.AxisError):
+        dpt.expand_dims(X, (0, 5))
 
-    pytest.raises(ValueError, dpt.expand_dims, X, (1, 1))
+    with pytest.raises(ValueError):
+        dpt.expand_dims(X, (1, 1))
 
 
 def test_squeeze_incorrect_type():
-    X_list = list([1, 2, 3, 4, 5])
-    X_tuple = tuple(X_list)
-    Xnp = np.array(X_list)
-
-    pytest.raises(TypeError, dpt.permute_dims, X_list, 1)
-    pytest.raises(TypeError, dpt.permute_dims, X_tuple, 1)
-    pytest.raises(TypeError, dpt.permute_dims, Xnp, 1)
+    X_list = [1, 2, 3, 4, 5]
+    with pytest.raises(TypeError):
+        dpt.permute_dims(X_list, 1)
 
 
 def test_squeeze_0d():
@@ -1077,3 +1071,19 @@ def test_unstack_axis2():
     assert_array_equal(dpt.asnumpy(y[:, :, 0, ...]), dpt.asnumpy(res[0]))
     assert_array_equal(dpt.asnumpy(y[:, :, 1, ...]), dpt.asnumpy(res[1]))
     assert_array_equal(dpt.asnumpy(y[:, :, 2, ...]), dpt.asnumpy(res[2]))
+
+
+def test_finfo_object():
+    fi = dpt.finfo(dpt.float32)
+    assert isinstance(fi.bits, int)
+    assert isinstance(fi.max, float)
+    assert isinstance(fi.min, float)
+    assert isinstance(fi.eps, float)
+    assert isinstance(fi.epsneg, float)
+    assert isinstance(fi.smallest_normal, float)
+    assert isinstance(fi.tiny, float)
+    assert isinstance(fi.precision, float)
+    assert isinstance(fi.resolution, float)
+    assert isinstance(fi.dtype, dpt.dtype)
+    assert isinstance(str(fi), str)
+    assert isinstance(repr(fi), str)