Add tests to cover frexp and new class

Author: antonwolfy

dpnp/dpnp_algo/dpnp_elementwise_common.py

@@ -179,7 +179,7 @@ def __call__(
             )
         elif dtype is not None and out is not None:
             raise TypeError(
-                f"Requested function={self.name_} only takes `out` or `dtype`"
+                f"Requested function={self.name_} only takes `out` or `dtype` "
                 "as an argument, but both were provided."
             )
 
@@ -356,6 +356,12 @@ def __call__(
 
             res_dt = res_dts[i]
             if res_dt != res.dtype:
+                if not dpnp.can_cast(res_dt, res.dtype, casting="same_kind"):
+                    raise TypeError(
+                        f"Cannot cast ufunc '{self.name_}' output {i + 1} from "
+                        f"{res_dt} to {res.dtype} with casting rule 'same_kind'"
+                    )
+
                 # Allocate a temporary buffer with the required dtype
                 out[i] = dpt.empty_like(res, dtype=res_dt)
             elif (
@@ -564,7 +570,7 @@ def __call__(
             )
         elif dtype is not None and out is not None:
             raise TypeError(
-                f"Requested function={self.name_} only takes `out` or `dtype`"
+                f"Requested function={self.name_} only takes `out` or `dtype` "
                 "as an argument, but both were provided."
             )
 

dpnp/tests/test_mathematical.py

@@ -710,6 +710,112 @@ def test_errors(self):
         assert_raises(ExecutionPlacementError, dpnp.ediff1d, ia, to_end=to_end)
 
 
+class TestFrexp:
+    ALL_DTYPES = get_all_dtypes(no_none=True)
+    ALL_DTYPES_NO_COMPLEX = get_all_dtypes(
+        no_none=True, no_float16=False, no_complex=True
+    )
+
+    @pytest.mark.parametrize("dt", ALL_DTYPES_NO_COMPLEX)
+    def test_basic(self, dt):
+        a = numpy.array([-2, 5, 1, 4, 3], dtype=dt)
+        ia = dpnp.array(a)
+
+        res1, res2 = dpnp.frexp(ia)
+        exp1, exp2 = numpy.frexp(a)
+        assert_array_equal(res1, exp1)
+        assert_array_equal(res2, exp2)
+
+    def test_out(self):
+        a = numpy.array(5.7)
+        ia = dpnp.array(a)
+
+        out1 = numpy.empty(())
+        out2 = numpy.empty((), dtype=numpy.int32)
+        iout1, iout2 = dpnp.array(out1), dpnp.array(out2)
+
+        res1, res2 = dpnp.frexp(ia, iout1)
+        exp1, exp2 = numpy.frexp(a, out1)
+        assert_array_equal(res1, exp1)
+        assert_array_equal(res2, exp2)
+        assert res1 is iout1
+
+        res1, res2 = dpnp.frexp(ia, None, iout2)
+        exp1, exp2 = numpy.frexp(a, None, out2)
+        assert_array_equal(res1, exp1)
+        assert_array_equal(res2, exp2)
+        assert res2 is iout2
+
+        res1, res2 = dpnp.frexp(ia, iout1, iout2)
+        exp1, exp2 = numpy.frexp(a, out1, out2)
+        assert_array_equal(res1, exp1)
+        assert_array_equal(res2, exp2)
+        assert res1 is iout1
+        assert res2 is iout2
+
+    @pytest.mark.parametrize("dt", ALL_DTYPES_NO_COMPLEX)
+    @pytest.mark.parametrize("out1_dt", ALL_DTYPES)
+    @pytest.mark.parametrize("out2_dt", ALL_DTYPES)
+    def test_out_all_dtypes(self, dt, out1_dt, out2_dt):
+        a = numpy.ones(9, dtype=dt)
+        ia = dpnp.array(a)
+
+        out1 = numpy.zeros(9, dtype=out1_dt)
+        out2 = numpy.zeros(9, dtype=out2_dt)
+        iout1, iout2 = dpnp.array(out1), dpnp.array(out2)
+
+        try:
+            res1, res2 = dpnp.frexp(ia, out=(iout1, iout2))
+        except TypeError:
+            # expect numpy to fail with the same reason
+            with pytest.raises(TypeError):
+                _ = numpy.frexp(a, out=(out1, out2))
+        else:
+            exp1, exp2 = numpy.frexp(a, out=(out1, out2))
+            assert_array_equal(res1, exp1)
+            assert_array_equal(res2, exp2)
+            assert res1 is iout1
+            assert res2 is iout2
+
+    @pytest.mark.parametrize("stride", [-4, -2, -1, 1, 2, 4])
+    @pytest.mark.parametrize("dt", get_float_dtypes())
+    def test_strides_out(self, stride, dt):
+        a = numpy.array(
+            [numpy.nan, numpy.nan, numpy.inf, -numpy.inf, 0.0, -0.0, 1.0, -1.0],
+            dtype=dt,
+        )
+        ia = dpnp.array(a)
+
+        out_mant = numpy.ones(8, dtype=dt)
+        out_exp = 2 * numpy.ones(8, dtype="i")
+        iout_mant, iout_exp = dpnp.array(out_mant), dpnp.array(out_exp)
+
+        res1, res2 = dpnp.frexp(
+            ia[::stride], out=(iout_mant[::stride], iout_exp[::stride])
+        )
+        exp1, exp2 = numpy.frexp(
+            a[::stride], out=(out_mant[::stride], out_exp[::stride])
+        )
+        assert_array_equal(res1, exp1)
+        assert_array_equal(res2, exp2)
+
+        assert_array_equal(iout_mant, out_mant)
+        assert_array_equal(iout_exp, out_exp)
+
+    @pytest.mark.parametrize("xp", [numpy, dpnp])
+    def test_out_wrong_type(self, xp):
+        a = xp.array(0.5)
+        with pytest.raises(TypeError, match="'out' must be a tuple of arrays"):
+            _ = xp.frexp(a, out=xp.empty(()))
+
+    @pytest.mark.parametrize("xp", [numpy, dpnp])
+    @pytest.mark.parametrize("dt", get_complex_dtypes())
+    def test_complex_dtype(self, xp, dt):
+        a = xp.array([-2, 5, 1, 4, 3], dtype=dt)
+        with pytest.raises((TypeError, ValueError)):
+            _ = xp.frexp(a)
+
+
 class TestGradient:
     @pytest.mark.parametrize("dt", get_all_dtypes(no_none=True, no_bool=True))
     def test_basic(self, dt):
@@ -1925,6 +2031,110 @@ def test_ndim(self):
         assert_dtype_allclose(result, expected)
 
 
+class TestUfunc:
+    @pytest.mark.parametrize(
+        "func, nin, nout",
+        [
+            pytest.param("abs", 1, 1, id="DPNPUnaryFunc"),
+            pytest.param("frexp", 1, 2, id="DPNPUnaryTwoOutputsFunc"),
+            pytest.param("add", 2, 1, id="DPNPBinaryFunc"),
+        ],
+    )
+    def test_nin_nout(self, func, nin, nout):
+        assert getattr(dpnp, func).nin == nin
+        assert getattr(dpnp, func).nout == nout
+
+    @pytest.mark.parametrize(
+        "func, kwargs",
+        [
+            pytest.param(
+                "abs",
+                {"unknown_kwarg": 1, "where": False, "subok": False},
+                id="DPNPUnaryFunc",
+            ),
+            pytest.param(
+                "frexp",
+                {
+                    "unknown_kwarg": 1,
+                    "where": False,
+                    "dtype": "?",
+                    "subok": False,
+                },
+                id="DPNPUnaryTwoOutputsFunc",
+            ),
+            pytest.param(
+                "add",
+                {"unknown_kwarg": 1, "where": False, "subok": False},
+                id="DPNPBinaryFunc",
+            ),
+        ],
+    )
+    def test_not_supported_kwargs(self, func, kwargs):
+        x = dpnp.array([1, 2, 3])
+
+        fn = getattr(dpnp, func)
+        args = [x] * fn.nin
+        for key, val in kwargs.items():
+            with pytest.raises(NotImplementedError):
+                fn(*args, **{key: val})
+
+    @pytest.mark.parametrize("func", ["abs", "frexp", "add"])
+    @pytest.mark.parametrize("x", [1, [1, 2], numpy.ones(5)])
+    def test_wrong_input(self, func, x):
+        fn = getattr(dpnp, func)
+        args = [x] * fn.nin
+        with pytest.raises(TypeError):
+            fn(*args)
+
+    @pytest.mark.parametrize("func", ["add"])
+    def test_binary_wrong_input(self, func):
+        x = dpnp.array([1, 2, 3])
+        with pytest.raises(TypeError):
+            getattr(dpnp, func)(x, [1, 2])
+        with pytest.raises(TypeError):
+            getattr(dpnp, func)([1, 2], x)
+
+    @pytest.mark.parametrize("func", ["abs", "frexp", "add"])
+    def test_wrong_order(self, func):
+        x = dpnp.array([1, 2, 3])
+
+        fn = getattr(dpnp, func)
+        args = [x] * fn.nin
+        with pytest.raises(ValueError, match="order must be one of"):
+            fn(*args, order="H")
+
+    @pytest.mark.parametrize("func", ["abs", "add"])
+    def test_out_dtype(self, func):
+        x = dpnp.array([1, 2, 3])
+        out = dpnp.array([1, 2, 3])
+
+        fn = getattr(dpnp, func)
+        args = [x] * fn.nin
+        with pytest.raises(
+            TypeError, match="only takes `out` or `dtype` as an argument"
+        ):
+            fn(*args, out=out, dtype="f4")
+
+    @pytest.mark.parametrize("func", ["abs", "frexp", "add"])
+    def test_order_none(self, func):
+        a = numpy.array([1, 2, 3])
+        ia = dpnp.array(a)
+
+        fn = getattr(numpy, func)
+        ifn = getattr(dpnp, func)
+
+        args = [a] * fn.nin
+        iargs = [ia] * ifn.nin
+
+        result = ifn(*iargs, order=None)
+        expected = fn(*args, order=None)
+        if fn.nout == 1:
+            assert_dtype_allclose(result, expected)
+        else:
+            for i in range(fn.nout):
+                assert_dtype_allclose(result[i], expected[i])
+
+
 class TestUnwrap:
     @pytest.mark.parametrize("dt", get_float_dtypes())
     def test_basic(self, dt):
@@ -2568,66 +2778,6 @@ def test_inplace_floor_divide(dtype):
     assert_allclose(ia, a)
 
 
-def test_elemenwise_nin_nout():
-    assert dpnp.abs.nin == 1
-    assert dpnp.add.nin == 2
-
-    assert dpnp.abs.nout == 1
-    assert dpnp.add.nout == 1
-
-
-def test_elemenwise_error():
-    x = dpnp.array([1, 2, 3])
-    out = dpnp.array([1, 2, 3])
-
-    with pytest.raises(NotImplementedError):
-        dpnp.abs(x, unknown_kwarg=1)
-    with pytest.raises(NotImplementedError):
-        dpnp.abs(x, where=False)
-    with pytest.raises(NotImplementedError):
-        dpnp.abs(x, subok=False)
-    with pytest.raises(TypeError):
-        dpnp.abs(1)
-    with pytest.raises(TypeError):
-        dpnp.abs([1, 2])
-    with pytest.raises(TypeError):
-        dpnp.abs(x, out=out, dtype="f4")
-    with pytest.raises(ValueError):
-        dpnp.abs(x, order="H")
-
-    with pytest.raises(NotImplementedError):
-        dpnp.add(x, x, unknown_kwarg=1)
-    with pytest.raises(NotImplementedError):
-        dpnp.add(x, x, where=False)
-    with pytest.raises(NotImplementedError):
-        dpnp.add(x, x, subok=False)
-    with pytest.raises(TypeError):
-        dpnp.add(1, 2)
-    with pytest.raises(TypeError):
-        dpnp.add([1, 2], [1, 2])
-    with pytest.raises(TypeError):
-        dpnp.add(x, [1, 2])
-    with pytest.raises(TypeError):
-        dpnp.add([1, 2], x)
-    with pytest.raises(TypeError):
-        dpnp.add(x, x, out=out, dtype="f4")
-    with pytest.raises(ValueError):
-        dpnp.add(x, x, order="H")
-
-
-def test_elemenwise_order_none():
-    x_np = numpy.array([1, 2, 3])
-    x = dpnp.array([1, 2, 3])
-
-    result = dpnp.abs(x, order=None)
-    expected = numpy.abs(x_np, order=None)
-    assert_dtype_allclose(result, expected)
-
-    result = dpnp.add(x, x, order=None)
-    expected = numpy.add(x_np, x_np, order=None)
-    assert_dtype_allclose(result, expected)
-
-
 def test_bitwise_1array_input():
     x = dpnp.array([1, 2, 3])
     x_np = numpy.array([1, 2, 3])