make changes on python-side only

Author: Vahid Tavanashad

dpnp/backend/extensions/ufunc/elementwise_functions/fix.cpp

@@ -60,15 +60,7 @@ template <typename T>
 struct OutputType
 {
     using value_type =
-        typename std::disjunction<td_ns::TypeMapResultEntry<T, std::uint8_t>,
-                                  td_ns::TypeMapResultEntry<T, std::uint16_t>,
-                                  td_ns::TypeMapResultEntry<T, std::uint32_t>,
-                                  td_ns::TypeMapResultEntry<T, std::uint64_t>,
-                                  td_ns::TypeMapResultEntry<T, std::int8_t>,
-                                  td_ns::TypeMapResultEntry<T, std::int16_t>,
-                                  td_ns::TypeMapResultEntry<T, std::int32_t>,
-                                  td_ns::TypeMapResultEntry<T, std::int64_t>,
-                                  td_ns::TypeMapResultEntry<T, sycl::half>,
+        typename std::disjunction<td_ns::TypeMapResultEntry<T, sycl::half>,
                                   td_ns::TypeMapResultEntry<T, float>,
                                   td_ns::TypeMapResultEntry<T, double>,
                                   td_ns::DefaultResultEntry<void>>::result_type;

dpnp/backend/kernels/elementwise_functions/fix.hpp

@@ -43,12 +43,7 @@ struct FixFunctor
 
     resT operator()(const argT &x) const
     {
-        if constexpr (std::is_integral_v<argT>) {
-            return x;
-        }
-        else {
-            return (x >= 0.0) ? sycl::floor(x) : sycl::ceil(x);
-        }
+        return (x >= 0.0) ? sycl::floor(x) : sycl::ceil(x);
     }
 };
 } // namespace dpnp::kernels::fix

dpnp/dpnp_algo/dpnp_elementwise_common.py

@@ -41,6 +41,7 @@
     "DPNPI0",
     "DPNPAngle",
     "DPNPBinaryFunc",
+    "DPNPFix",
     "DPNPImag",
     "DPNPReal",
     "DPNPRound",
@@ -511,6 +512,45 @@ def __call__(self, x, deg=False, out=None, order="K"):
         return res
 
 
+class DPNPFix(DPNPUnaryFunc):
+    """Class that implements dpnp.real unary element-wise functions."""
+
+    def __init__(
+        self,
+        name,
+        result_type_resolver_fn,
+        unary_dp_impl_fn,
+        docs,
+    ):
+        super().__init__(
+            name,
+            result_type_resolver_fn,
+            unary_dp_impl_fn,
+            docs,
+        )
+
+    def __call__(self, x, out=None, order="K"):
+        if not dpnp.is_supported_array_type(x):
+            pass  # pass to raise error in main implementation
+        elif dpnp.issubdtype(x.dtype, dpnp.inexact):
+            pass  # for inexact types, pass to calculate in the backend
+        elif out is not None and (
+            not dpnp.is_supported_array_type(out) or out.dtype != x.dtype
+        ):
+            pass  # pass to raise error in main implementation
+        else:
+            # for exact types, return the input
+            if out is None:
+                return dpnp.asarray(x, copy=True)
+
+            if isinstance(out, dpt.usm_ndarray):
+                out = dpnp_array._create_from_usm_ndarray(out)
+            out[...] = x
+            return out
+
+        return super().__call__(x, out=out, order=order)
+
+
 class DPNPI0(DPNPUnaryFunc):
     """Class that implements dpnp.i0 unary element-wise functions."""
 

dpnp/dpnp_iface_mathematical.py

@@ -63,6 +63,7 @@
     DPNPI0,
     DPNPAngle,
     DPNPBinaryFunc,
+    DPNPFix,
     DPNPImag,
     DPNPReal,
     DPNPRound,
@@ -1755,12 +1756,6 @@ def ediff1d(ary, to_end=None, to_begin=None):
     Otherwise the result is stored there and the return value `out` is
     a reference to that array.
 
-Limitations
------------
-Parameters `where` and `subok` are supported with their default values.
-Keyword argument `kwargs` is currently unsupported.
-Otherwise ``NotImplementedError`` exception will be raised.
-
 See Also
 --------
 :obj:`dpnp.round` : Round to given number of decimals.
@@ -1781,7 +1776,7 @@ def ediff1d(ary, to_end=None, to_begin=None):
 array([ 2.,  2., -2., -2.])
 """
 
-fix = DPNPUnaryFunc(
+fix = DPNPFix(
     "fix",
     ufi._fix_result_type,
     ufi._fix,
@@ -1933,8 +1928,10 @@ def ediff1d(ary, to_end=None, to_begin=None):
 
 Notes
 -----
-Some spreadsheet programs calculate the "floor-towards-zero", in other words floor(-2.5) == -2.
-DPNP instead uses the definition of floor where floor(-2.5) == -3.
+Some spreadsheet programs calculate the "floor-towards-zero", where
+``floor(-2.5) == -2``. DPNP instead uses the definition of :obj:`dpnp.floor`
+where ``floor(-2.5) == -3``. The "floor-towards-zero" function is called
+:obj:`dpnp.fix` in DPNP.
 
 Examples
 --------

dpnp/tests/test_mathematical.py

@@ -2231,6 +2231,7 @@ def test_complex(self, func, xp, dt):
     )
     def test_out(self, func, dt):
         a = generate_random_numpy_array(10, dt)
+        # TODO: use dt_out = dt when dpctl#2030 is fixed
         dt_out = numpy.int8 if dt == dpnp.bool else dt
         out = numpy.empty(a.shape, dtype=dt_out)
         ia, iout = dpnp.array(a), dpnp.array(out)