Merge pull request #1182 from IntelPython/fix-gh-1178

Use normalize_axis_tuple to normalize axis for all functions but expand_dims

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):
@@ -137,14 +201,12 @@ def permute_dims(X, axes):
     """
     if not isinstance(X, dpt.usm_ndarray):
         raise TypeError(f"Expected usm_ndarray type, got {type(X)}.")
-    if not isinstance(axes, (tuple, list)):
-        axes = (axes,)
+    axes = normalize_axis_tuple(axes, X.ndim, "axes")
     if not X.ndim == len(axes):
         raise ValueError(
             "The length of the passed axes does not match "
             "to the number of usm_ndarray dimensions."
         )
-    axes = normalize_axis_tuple(axes, X.ndim, "axes")
     newstrides = tuple(X.strides[i] for i in axes)
     newshape = tuple(X.shape[i] for i in axes)
     return dpt.usm_ndarray(
@@ -187,7 +249,8 @@ def expand_dims(X, axis):
     """
     if not isinstance(X, dpt.usm_ndarray):
         raise TypeError(f"Expected usm_ndarray type, got {type(X)}.")
-    if not isinstance(axis, (tuple, list)):
+
+    if type(axis) not in (tuple, list):
         axis = (axis,)
 
     out_ndim = len(axis) + X.ndim
@@ -224,8 +287,6 @@ def squeeze(X, axis=None):
         raise TypeError(f"Expected usm_ndarray type, got {type(X)}.")
     X_shape = X.shape
     if axis is not None:
-        if not isinstance(axis, (tuple, list)):
-            axis = (axis,)
         axis = normalize_axis_tuple(axis, X.ndim if X.ndim != 0 else X.ndim + 1)
         new_shape = []
         for i, x in enumerate(X_shape):
@@ -819,12 +880,6 @@ def moveaxis(X, source, destination):
     if not isinstance(X, dpt.usm_ndarray):
         raise TypeError(f"Expected usm_ndarray type, got {type(X)}.")
 
-    if not isinstance(source, (tuple, list)):
-        source = (source,)
-
-    if not isinstance(destination, (tuple, list)):
-        destination = (destination,)
-
     source = normalize_axis_tuple(source, X.ndim, "source")
     destination = normalize_axis_tuple(destination, X.ndim, "destination")