11349295964

Committed 15 Oct 2024 03:25PM UTC coverage: 59.557% (+0.04%) from 59.518%

Build # 11349295964

Build Type

Pull #2110

github

Committed by

web-flow

Commit Message

Merge 7cabd1b63 into d39aa25cf

Pull Request Pull Request #2110: Add implementation of dpnp.ldexp

Run Details

3662 of 9408 branches covered (38.92%)

Branch coverage included in aggregate %.

45 of 54 new or added lines in 5 files covered. (83.33%)

7 existing lines in 2 files now uncovered.

13995 of 20239 relevant lines covered (69.15%)

16654.31 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.02

/dpnp/dpnp_algo/dpnp_elementwise_common.py

# -*- coding: utf-8 -*-
# *****************************************************************************
# Copyright (c) 2023-2024, Intel Corporation
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
# - Redistributions of source code must retain the above copyright notice,
#   this list of conditions and the following disclaimer.
# - Redistributions in binary form must reproduce the above copyright notice,
#   this list of conditions and the following disclaimer in the documentation
#   and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
# THE POSSIBILITY OF SUCH DAMAGE.
# *****************************************************************************

import dpctl.tensor as dpt
import dpctl.tensor._tensor_impl as dti
import dpctl.tensor._type_utils as dtu
import numpy
from dpctl.tensor._elementwise_common import (
    BinaryElementwiseFunc,
    UnaryElementwiseFunc,
)

import dpnp
import dpnp.backend.extensions.vm._vm_impl as vmi
from dpnp.dpnp_array import dpnp_array

__all__ = [
    "acceptance_fn_gcd_lcm",
    "acceptance_fn_negative",
    "acceptance_fn_positive",
    "acceptance_fn_sign",
    "acceptance_fn_subtract",
    "DPNPAngle",
    "DPNPBinaryFunc",
    "DPNPReal",
    "DPNPRound",
    "DPNPUnaryFunc",
    "resolve_weak_types_2nd_arg_int",
]


class DPNPUnaryFunc(UnaryElementwiseFunc):
    """
    Class that implements unary element-wise functions.

    Parameters
    ----------
    name : {str}
        Name of the unary function
    result_type_resovler_fn : {callable}
        Function that takes dtype of the input and returns the dtype of
        the result if the implementation functions supports it, or
        returns `None` otherwise.
    unary_dp_impl_fn : {callable}
        Data-parallel implementation function with signature
        `impl_fn(src: usm_ndarray, dst: usm_ndarray,
            sycl_queue: SyclQueue, depends: Optional[List[SyclEvent]])`
        where the `src` is the argument array, `dst` is the
        array to be populated with function values, effectively
        evaluating `dst = func(src)`.
        The `impl_fn` is expected to return a 2-tuple of `SyclEvent`s.
        The first event corresponds to data-management host tasks,
        including lifetime management of argument Python objects to ensure
        that their associated USM allocation is not freed before offloaded
        computational tasks complete execution, while the second event
        corresponds to computational tasks associated with function evaluation.
    docs : {str}
        Documentation string for the unary function.
    mkl_fn_to_call : {callable}
        Check input arguments to answer if function from OneMKL VM library
        can be used.
    mkl_impl_fn : {callable}
        Function from OneMKL VM library to call.
    acceptance_fn : {callable}, optional
        Function to influence type promotion behavior of this unary
        function. The function takes 4 arguments:
            arg_dtype - Data type of the first argument
            buf_dtype - Data type the argument would be cast to
            res_dtype - Data type of the output array with function values
            sycl_dev - The :class:`dpctl.SyclDevice` where the function
                evaluation is carried out.
        The function is invoked when the argument of the unary function
        requires casting, e.g. the argument of `dpctl.tensor.log` is an
        array with integral data type.
    """

    def __init__(
        self,
        name,
        result_type_resolver_fn,
        unary_dp_impl_fn,
        docs,
        mkl_fn_to_call=None,
        mkl_impl_fn=None,
        acceptance_fn=None,
    ):
        def _call_func(src, dst, sycl_queue, depends=None):
            """
            A callback to register in UnaryElementwiseFunc class of
            dpctl.tensor
            """

            if depends is None:
                depends = []

            if vmi._is_available() and mkl_fn_to_call is not None:
                if getattr(vmi, mkl_fn_to_call)(sycl_queue, src, dst):
                    # call pybind11 extension for unary function from OneMKL VM
                    return getattr(vmi, mkl_impl_fn)(
                        sycl_queue, src, dst, depends
                    )
            return unary_dp_impl_fn(src, dst, sycl_queue, depends)

        super().__init__(
            name,
            result_type_resolver_fn,
            _call_func,
            docs,
            acceptance_fn=acceptance_fn,
        )
        self.__name__ = "DPNPUnaryFunc"

    def __call__(
        self,
        x,
        out=None,
        where=True,
        order="K",
        dtype=None,
        subok=True,
        **kwargs,
    ):
        if kwargs:
            raise NotImplementedError(
                f"Requested function={self.name_} with kwargs={kwargs} "
                "isn't currently supported."
            )
        elif where is not True:
            raise NotImplementedError(
                f"Requested function={self.name_} with where={where} "
                "isn't currently supported."
            )
        elif subok is not True:
            raise NotImplementedError(
                f"Requested function={self.name_} with subok={subok} "
                "isn't currently supported."
            )
        elif not dpnp.is_supported_array_type(x):
            raise TypeError(
                "Input array must be any of supported type, "
                f"but got {type(x)}"
            )
        elif dtype is not None and out is not None:
            raise TypeError(
                f"Requested function={self.name_} only takes `out` or `dtype`"
                "as an argument, but both were provided."
            )

        if order is None:
            order = "K"
        elif order in "afkcAFKC":
            order = order.upper()
        else:
            raise ValueError(
                "order must be one of 'C', 'F', 'A', or 'K' " f"(got '{order}')"
            )

        x_usm = dpnp.get_usm_ndarray(x)
        if dtype is not None:
            x_usm = dpt.astype(x_usm, dtype, copy=False)

        out_usm = None if out is None else dpnp.get_usm_ndarray(out)
        res_usm = super().__call__(x_usm, out=out_usm, order=order)

        if out is not None and isinstance(out, dpnp_array):
            return out
        return dpnp_array._create_from_usm_ndarray(res_usm)


class DPNPBinaryFunc(BinaryElementwiseFunc):
    """
    Class that implements binary element-wise functions.

    Args:
    name : {str}
        Name of the unary function
    result_type_resovle_fn : {callable}
        Function that takes dtype of the input and returns the dtype of
        the result if the implementation functions supports it, or
        returns `None` otherwise..
    binary_dp_impl_fn : {callable}
        Data-parallel implementation function with signature
        `impl_fn(src1: usm_ndarray, src2: usm_ndarray, dst: usm_ndarray,
            sycl_queue: SyclQueue, depends: Optional[List[SyclEvent]])`
        where the `src1` and `src2` are the argument arrays, `dst` is the
        array to be populated with function values,
        i.e. `dst=func(src1, src2)`.
        The `impl_fn` is expected to return a 2-tuple of `SyclEvent`s.
        The first event corresponds to data-management host tasks,
        including lifetime management of argument Python objects to ensure
        that their associated USM allocation is not freed before offloaded
        computational tasks complete execution, while the second event
        corresponds to computational tasks associated with function
        evaluation.
    docs : {str}
        Documentation string for the unary function.
    mkl_fn_to_call : {callable}
        Check input arguments to answer if function from OneMKL VM library
        can be used.
    mkl_impl_fn : {callable}
        Function from OneMKL VM library to call.
    binary_inplace_fn : {callable}, optional
        Data-parallel implementation function with signature
        `impl_fn(src: usm_ndarray, dst: usm_ndarray,
            sycl_queue: SyclQueue, depends: Optional[List[SyclEvent]])`
        where the `src` is the argument array, `dst` is the
        array to be populated with function values,
        i.e. `dst=func(dst, src)`.
        The `impl_fn` is expected to return a 2-tuple of `SyclEvent`s.
        The first event corresponds to data-management host tasks,
        including async lifetime management of Python arguments,
        while the second event corresponds to computational tasks
        associated with function evaluation.
    acceptance_fn : {callable}, optional
        Function to influence type promotion behavior of this binary
        function. The function takes 6 arguments:
            arg1_dtype - Data type of the first argument
            arg2_dtype - Data type of the second argument
            ret_buf1_dtype - Data type the first argument would be cast to
            ret_buf2_dtype - Data type the second argument would be cast to
            res_dtype - Data type of the output array with function values
            sycl_dev - The :class:`dpctl.SyclDevice` where the function
                evaluation is carried out.
        The function is only called when both arguments of the binary
        function require casting, e.g. both arguments of
        `dpctl.tensor.logaddexp` are arrays with integral data type.
    weak_type_resolver : {callable}, optional
        Function to influence type promotion behavior for Python scalar types
        of this binary function. The function takes 3 arguments:
            o1_dtype - Data type or Python scalar type of the first argument
            o2_dtype - Data type or Python scalar type of of the second argument
            sycl_dev - The :class:`dpctl.SyclDevice` where the function
                evaluation is carried out.
        One of `o1_dtype` and `o2_dtype` must be a ``dtype`` instance.
    """

    def __init__(
        self,
        name,
        result_type_resolver_fn,
        binary_dp_impl_fn,
        docs,
        mkl_fn_to_call=None,
        mkl_impl_fn=None,
        binary_inplace_fn=None,
        acceptance_fn=None,
        weak_type_resolver=None,
    ):
        def _call_func(src1, src2, dst, sycl_queue, depends=None):
            """
            A callback to register in UnaryElementwiseFunc class of
            dpctl.tensor
            """

            if depends is None:
                depends = []

            if vmi._is_available() and mkl_fn_to_call is not None:
                if getattr(vmi, mkl_fn_to_call)(sycl_queue, src1, src2, dst):
                    # call pybind11 extension for binary function from OneMKL VM
                    return getattr(vmi, mkl_impl_fn)(
                        sycl_queue, src1, src2, dst, depends
                    )
            return binary_dp_impl_fn(src1, src2, dst, sycl_queue, depends)

        super().__init__(
            name,
            result_type_resolver_fn,
            _call_func,
            docs,
            binary_inplace_fn,
            acceptance_fn=acceptance_fn,
            weak_type_resolver=weak_type_resolver,
        )
        self.__name__ = "DPNPBinaryFunc"

    def __call__(
        self,
        x1,
        x2,
        out=None,
        where=True,
        order="K",
        dtype=None,
        subok=True,
        **kwargs,
    ):
        dpnp.check_supported_arrays_type(
            x1, x2, scalar_type=True, all_scalars=False
        )
        if kwargs:
            raise NotImplementedError(
                f"Requested function={self.name_} with kwargs={kwargs} "
                "isn't currently supported."
            )
        elif where is not True:
            raise NotImplementedError(
                f"Requested function={self.name_} with where={where} "
                "isn't currently supported."
            )
        elif subok is not True:
            raise NotImplementedError(
                f"Requested function={self.name_} with subok={subok} "
                "isn't currently supported."
            )
        elif dtype is not None and out is not None:
            raise TypeError(
                f"Requested function={self.name_} only takes `out` or `dtype`"
                "as an argument, but both were provided."
            )

        if order is None:
            order = "K"
        elif order in "afkcAFKC":
            order = order.upper()
        else:
            raise ValueError(
                "order must be one of 'C', 'F', 'A', or 'K' (got '{order}')"
            )

        x1_usm = dpnp.get_usm_ndarray_or_scalar(x1)
        x2_usm = dpnp.get_usm_ndarray_or_scalar(x2)

        if dtype is not None:
            if dpnp.isscalar(x1):
                x1_usm = dpt.asarray(
                    x1,
                    dtype=dtype,
                    sycl_queue=x2.sycl_queue,
                    usm_type=x2.usm_type,
                )
                x2_usm = dpt.astype(x2_usm, dtype, copy=False)
            elif dpnp.isscalar(x2):
                x1_usm = dpt.astype(x1_usm, dtype, copy=False)
                x2_usm = dpt.asarray(
                    x2,
                    dtype=dtype,
                    sycl_queue=x1.sycl_queue,
                    usm_type=x1.usm_type,
                )
            else:
                x1_usm = dpt.astype(x1_usm, dtype, copy=False)
                x2_usm = dpt.astype(x2_usm, dtype, copy=False)

        out_usm = None if out is None else dpnp.get_usm_ndarray(out)
        res_usm = super().__call__(x1_usm, x2_usm, out=out_usm, order=order)

        if out is not None and isinstance(out, dpnp_array):
            return out
        return dpnp_array._create_from_usm_ndarray(res_usm)

    def outer(
        self,
        x1,
        x2,
        out=None,
        where=True,
        order="K",
        dtype=None,
        subok=True,
        **kwargs,
    ):
        """
        Apply the ufunc op to all pairs (a, b) with a in A and b in B.

        Parameters
        ----------
        x1 : {dpnp.ndarray, usm_ndarray}
            First input array.
        x2 : {dpnp.ndarray, usm_ndarray}
            Second input array.
        out : {None, dpnp.ndarray, usm_ndarray}, optional
            Output array to populate.
            Array must have the correct shape and the expected data type.
        order : {None, "C", "F", "A", "K"}, optional
            Memory layout of the newly output array, Cannot be provided
            together with `out`. Default: ``"K"``.
        dtype : {None, dtype}, optional
            If provided, the destination array will have this dtype. Cannot be
            provided together with `out`. Default: ``None``.

        Returns
        -------
        out : dpnp.ndarray
            Output array. The data type of the returned array is determined by
            the Type Promotion Rules.

        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.outer` : A less powerful version of dpnp.multiply.outer
                            that ravels all inputs to 1D. This exists primarily
                            for compatibility with old code.

        :obj:`dpnp.tensordot` : dpnp.tensordot(a, b, axes=((), ())) and
                                dpnp.multiply.outer(a, b) behave same for all
                                dimensions of a and b.

        Examples
        --------
        >>> import dpnp as np
        >>> A = np.array([1, 2, 3])
        >>> B = np.array([4, 5, 6])
        >>> np.multiply.outer(A, B)
        array([[ 4,  5,  6],
               [ 8, 10, 12],
               [12, 15, 18]])

        A multi-dimensional example:
        >>> A = np.array([[1, 2, 3], [4, 5, 6]])
        >>> A.shape
        (2, 3)
        >>> B = np.array([[1, 2, 3, 4]])
        >>> B.shape
        (1, 4)
        >>> C = np.multiply.outer(A, B)
        >>> C.shape; C
        (2, 3, 1, 4)
        array([[[[ 1,  2,  3,  4]],
                [[ 2,  4,  6,  8]],
                [[ 3,  6,  9, 12]]],
               [[[ 4,  8, 12, 16]],
                [[ 5, 10, 15, 20]],
                [[ 6, 12, 18, 24]]]])

        """

        dpnp.check_supported_arrays_type(
            x1, x2, scalar_type=True, all_scalars=False
        )
        if dpnp.isscalar(x1) or dpnp.isscalar(x2):
            _x1 = x1
            _x2 = x2
        else:
            _x1 = x1[(Ellipsis,) + (None,) * x2.ndim]
            _x2 = x2[(None,) * x1.ndim + (Ellipsis,)]
        return self.__call__(
            _x1,
            _x2,
            out=out,
            where=where,
            order=order,
            dtype=dtype,
            subok=subok,
            **kwargs,
        )


class DPNPAngle(DPNPUnaryFunc):
    """Class that implements dpnp.angle 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, deg=False):
        res = super().__call__(x)
        if deg is True:
            res *= 180 / dpnp.pi
        return res


class DPNPReal(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):
        if numpy.iscomplexobj(x):
            return super().__call__(x)
        return x


class DPNPRound(DPNPUnaryFunc):
    """Class that implements dpnp.round unary element-wise functions."""

    def __init__(
        self,
        name,
        result_type_resolver_fn,
        unary_dp_impl_fn,
        docs,
        mkl_fn_to_call=None,
        mkl_impl_fn=None,
    ):
        super().__init__(
            name,
            result_type_resolver_fn,
            unary_dp_impl_fn,
            docs,
            mkl_fn_to_call=mkl_fn_to_call,
            mkl_impl_fn=mkl_impl_fn,
        )

    def __call__(self, x, decimals=0, out=None, dtype=None):
        if decimals != 0:
            x_usm = dpnp.get_usm_ndarray(x)
            if dpnp.issubdtype(x_usm.dtype, dpnp.integer) and dtype is None:
                dtype = x_usm.dtype

            out_usm = None if out is None else dpnp.get_usm_ndarray(out)
            x_usm = dpt.round(x_usm * 10**decimals, out=out_usm)
            res_usm = dpt.divide(x_usm, 10**decimals, out=out_usm)

            if dtype is not None:
                res_usm = dpt.astype(res_usm, dtype, copy=False)

            if out is not None and isinstance(out, dpnp_array):
                return out
            return dpnp_array._create_from_usm_ndarray(res_usm)
        else:
            return super().__call__(x, out=out, dtype=dtype)


def acceptance_fn_gcd_lcm(
    arg1_dtype, arg2_dtype, buf1_dt, buf2_dt, res_dt, sycl_dev
):
    # gcd/lcm are not defined for boolean data type
    if arg1_dtype.char == "?" and arg2_dtype.char == "?":
        raise ValueError(
            "The function is not supported for inputs of data type bool"
        )
    else:
        return True


def acceptance_fn_negative(arg_dtype, buf_dt, res_dt, sycl_dev):
    # negative is not defined for boolean data type
    if arg_dtype.char == "?":
        raise TypeError(
            "The `negative` function, the `-` operator, is not supported "
            "for inputs of data type bool, use the `~` operator or the "
            "`logical_not` function instead"
        )
    else:
        return True


def acceptance_fn_positive(arg_dtype, buf_dt, res_dt, sycl_dev):
    # positive is not defined for boolean data type
    if arg_dtype.char == "?":
        raise TypeError(
            "The `positive` function is not supported for inputs of data type "
            "bool"
        )
    else:
        return True


def acceptance_fn_sign(arg_dtype, buf_dt, res_dt, sycl_dev):
    # sign is not defined for boolean data type
    if arg_dtype.char == "?":
        raise TypeError(
            "The `sign` function is not supported for inputs of data type bool"
        )
    else:
        return True


def acceptance_fn_subtract(
    arg1_dtype, arg2_dtype, buf1_dt, buf2_dt, res_dt, sycl_dev
):
    # subtract is not defined for boolean data type
    if arg1_dtype.char == "?" and arg2_dtype.char == "?":
        raise TypeError(
            "The `subtract` function, the `-` operator, is not supported "
            "for inputs of data type bool, use the `^` operator,  the "
            "`bitwise_xor`, or the `logical_xor` function instead"
        )
    else:
        return True


def resolve_weak_types_2nd_arg_int(o1_dtype, o2_dtype, sycl_dev):
    """
    The second weak dtype has to be upcasting up to default integer dtype
    for a SYCL device where it is possible.
    For other cases the default weak types resolving will be applied.

    """

    if dtu._is_weak_dtype(o2_dtype):
        o1_kind_num = dtu._strong_dtype_num_kind(o1_dtype)
        o2_kind_num = dtu._weak_type_num_kind(o2_dtype)
        if o2_kind_num < o1_kind_num:
            if isinstance(
                o2_dtype, (dtu.WeakBooleanType, dtu.WeakIntegralType)
            ):
                return o1_dtype, dpt.dtype(
                    dti.default_device_int_type(sycl_dev)
                )
    return dtu._resolve_weak_types(o1_dtype, o2_dtype, sycl_dev)

1	# -- coding: utf-8 --
2	# *****************************************************************************
3	# Copyright (c) 2023-2024, Intel Corporation
4	# All rights reserved.
5	#
6	# Redistribution and use in source and binary forms, with or without
7	# modification, are permitted provided that the following conditions are met:
8	# - Redistributions of source code must retain the above copyright notice,
9	# this list of conditions and the following disclaimer.
10	# - Redistributions in binary form must reproduce the above copyright notice,
11	# this list of conditions and the following disclaimer in the documentation
12	# and/or other materials provided with the distribution.
13	#
14	# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
15	# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16	# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17	# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
18	# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
19	# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
20	# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
21	# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
22	# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
23	# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
24	# THE POSSIBILITY OF SUCH DAMAGE.
25	# *****************************************************************************
26
27	import dpctl.tensor as dpt	1✔
28	import dpctl.tensor._tensor_impl as dti	1✔
29	import dpctl.tensor._type_utils as dtu	1✔
30	import numpy	1✔
31	from dpctl.tensor._elementwise_common import (	1✔
32	BinaryElementwiseFunc,
33	UnaryElementwiseFunc,
34	)
35
36	import dpnp	1✔
37	import dpnp.backend.extensions.vm._vm_impl as vmi	1✔
38	from dpnp.dpnp_array import dpnp_array	1✔
39
40	__all__ = [	1✔
41	"acceptance_fn_gcd_lcm",
42	"acceptance_fn_negative",
43	"acceptance_fn_positive",
44	"acceptance_fn_sign",
45	"acceptance_fn_subtract",
46	"DPNPAngle",
47	"DPNPBinaryFunc",
48	"DPNPReal",
49	"DPNPRound",
50	"DPNPUnaryFunc",
51	"resolve_weak_types_2nd_arg_int",
52	]
53
54
55	class DPNPUnaryFunc(UnaryElementwiseFunc):	1✔
56	"""
57	Class that implements unary element-wise functions.
58
59	Parameters
60	----------
61	name : {str}
62	Name of the unary function
63	result_type_resovler_fn : {callable}
64	Function that takes dtype of the input and returns the dtype of
65	the result if the implementation functions supports it, or
66	returns `None` otherwise.
67	unary_dp_impl_fn : {callable}
68	Data-parallel implementation function with signature
69	`impl_fn(src: usm_ndarray, dst: usm_ndarray,
70	sycl_queue: SyclQueue, depends: Optional[List[SyclEvent]])`
71	where the `src` is the argument array, `dst` is the
72	array to be populated with function values, effectively
73	evaluating `dst = func(src)`.
74	The `impl_fn` is expected to return a 2-tuple of `SyclEvent`s.
75	The first event corresponds to data-management host tasks,
76	including lifetime management of argument Python objects to ensure
77	that their associated USM allocation is not freed before offloaded
78	computational tasks complete execution, while the second event
79	corresponds to computational tasks associated with function evaluation.
80	docs : {str}
81	Documentation string for the unary function.
82	mkl_fn_to_call : {callable}
83	Check input arguments to answer if function from OneMKL VM library
84	can be used.
85	mkl_impl_fn : {callable}
86	Function from OneMKL VM library to call.
87	acceptance_fn : {callable}, optional
88	Function to influence type promotion behavior of this unary
89	function. The function takes 4 arguments:
90	arg_dtype - Data type of the first argument
91	buf_dtype - Data type the argument would be cast to
92	res_dtype - Data type of the output array with function values
93	sycl_dev - The :class:`dpctl.SyclDevice` where the function
94	evaluation is carried out.
95	The function is invoked when the argument of the unary function
96	requires casting, e.g. the argument of `dpctl.tensor.log` is an
97	array with integral data type.
98	"""
99
100	def __init__(	1✔
101	self,
102	name,
103	result_type_resolver_fn,
104	unary_dp_impl_fn,
105	docs,
106	mkl_fn_to_call=None,
107	mkl_impl_fn=None,
108	acceptance_fn=None,
109	):
110	def _call_func(src, dst, sycl_queue, depends=None):	1✔
111	"""
112	A callback to register in UnaryElementwiseFunc class of
113	dpctl.tensor
114	"""
115
116	if depends is None:	1!
UNCOV 117	depends = []	×
118
119	if vmi._is_available() and mkl_fn_to_call is not None:	1✔
120	if getattr(vmi, mkl_fn_to_call)(sycl_queue, src, dst):	1✔
121	# call pybind11 extension for unary function from OneMKL VM
122	return getattr(vmi, mkl_impl_fn)(	1✔
123	sycl_queue, src, dst, depends
124	)
125	return unary_dp_impl_fn(src, dst, sycl_queue, depends)	1✔
126
127	super().__init__(	1✔
128	name,
129	result_type_resolver_fn,
130	_call_func,
131	docs,
132	acceptance_fn=acceptance_fn,
133	)
134	self.__name__ = "DPNPUnaryFunc"	1✔
135
136	def __call__(	1✔
137	self,
138	x,
139	out=None,
140	where=True,
141	order="K",
142	dtype=None,
143	subok=True,
144	**kwargs,
145	):
146	if kwargs:	1✔
147	raise NotImplementedError(	1✔
148	f"Requested function={self.name_} with kwargs={kwargs} "
149	"isn't currently supported."
150	)
151	elif where is not True:	1✔
152	raise NotImplementedError(	1✔
153	f"Requested function={self.name_} with where={where} "
154	"isn't currently supported."
155	)
156	elif subok is not True:	1✔
157	raise NotImplementedError(	1✔
158	f"Requested function={self.name_} with subok={subok} "
159	"isn't currently supported."
160	)
161	elif not dpnp.is_supported_array_type(x):	1✔
162	raise TypeError(	1✔
163	"Input array must be any of supported type, "
164	f"but got {type(x)}"
165	)
166	elif dtype is not None and out is not None:	1✔
167	raise TypeError(	1✔
168	f"Requested function={self.name_} only takes `out` or `dtype`"
169	"as an argument, but both were provided."
170	)
171
172	if order is None:	1✔
173	order = "K"	1✔
174	elif order in "afkcAFKC":	1✔
175	order = order.upper()	1✔
176	else:
177	raise ValueError(	1✔
178	"order must be one of 'C', 'F', 'A', or 'K' " f"(got '{order}')"
179	)
180
181	x_usm = dpnp.get_usm_ndarray(x)	1✔
182	if dtype is not None:	1✔
183	x_usm = dpt.astype(x_usm, dtype, copy=False)	1✔
184
185	out_usm = None if out is None else dpnp.get_usm_ndarray(out)	1✔
186	res_usm = super().__call__(x_usm, out=out_usm, order=order)	1✔
187
188	if out is not None and isinstance(out, dpnp_array):	1✔
189	return out	1✔
190	return dpnp_array._create_from_usm_ndarray(res_usm)	1✔
191
192
193	class DPNPBinaryFunc(BinaryElementwiseFunc):	1✔
194	"""
195	Class that implements binary element-wise functions.
196
197	Args:
198	name : {str}
199	Name of the unary function
200	result_type_resovle_fn : {callable}
201	Function that takes dtype of the input and returns the dtype of
202	the result if the implementation functions supports it, or
203	returns `None` otherwise..
204	binary_dp_impl_fn : {callable}
205	Data-parallel implementation function with signature
206	`impl_fn(src1: usm_ndarray, src2: usm_ndarray, dst: usm_ndarray,
207	sycl_queue: SyclQueue, depends: Optional[List[SyclEvent]])`
208	where the `src1` and `src2` are the argument arrays, `dst` is the
209	array to be populated with function values,
210	i.e. `dst=func(src1, src2)`.
211	The `impl_fn` is expected to return a 2-tuple of `SyclEvent`s.
212	The first event corresponds to data-management host tasks,
213	including lifetime management of argument Python objects to ensure
214	that their associated USM allocation is not freed before offloaded
215	computational tasks complete execution, while the second event
216	corresponds to computational tasks associated with function
217	evaluation.
218	docs : {str}
219	Documentation string for the unary function.
220	mkl_fn_to_call : {callable}
221	Check input arguments to answer if function from OneMKL VM library
222	can be used.
223	mkl_impl_fn : {callable}
224	Function from OneMKL VM library to call.
225	binary_inplace_fn : {callable}, optional
226	Data-parallel implementation function with signature
227	`impl_fn(src: usm_ndarray, dst: usm_ndarray,
228	sycl_queue: SyclQueue, depends: Optional[List[SyclEvent]])`
229	where the `src` is the argument array, `dst` is the
230	array to be populated with function values,
231	i.e. `dst=func(dst, src)`.
232	The `impl_fn` is expected to return a 2-tuple of `SyclEvent`s.
233	The first event corresponds to data-management host tasks,
234	including async lifetime management of Python arguments,
235	while the second event corresponds to computational tasks
236	associated with function evaluation.
237	acceptance_fn : {callable}, optional
238	Function to influence type promotion behavior of this binary
239	function. The function takes 6 arguments:
240	arg1_dtype - Data type of the first argument
241	arg2_dtype - Data type of the second argument
242	ret_buf1_dtype - Data type the first argument would be cast to
243	ret_buf2_dtype - Data type the second argument would be cast to
244	res_dtype - Data type of the output array with function values
245	sycl_dev - The :class:`dpctl.SyclDevice` where the function
246	evaluation is carried out.
247	The function is only called when both arguments of the binary
248	function require casting, e.g. both arguments of
249	`dpctl.tensor.logaddexp` are arrays with integral data type.
250	weak_type_resolver : {callable}, optional
251	Function to influence type promotion behavior for Python scalar types
252	of this binary function. The function takes 3 arguments:
253	o1_dtype - Data type or Python scalar type of the first argument
254	o2_dtype - Data type or Python scalar type of of the second argument
255	sycl_dev - The :class:`dpctl.SyclDevice` where the function
256	evaluation is carried out.
257	One of `o1_dtype` and `o2_dtype` must be a ``dtype`` instance.
258	"""
259
260	def __init__(	1✔
261	self,
262	name,
263	result_type_resolver_fn,
264	binary_dp_impl_fn,
265	docs,
266	mkl_fn_to_call=None,
267	mkl_impl_fn=None,
268	binary_inplace_fn=None,
269	acceptance_fn=None,
270	weak_type_resolver=None,
271	):
272	def _call_func(src1, src2, dst, sycl_queue, depends=None):	1✔
273	"""
274	A callback to register in UnaryElementwiseFunc class of
275	dpctl.tensor
276	"""
277
278	if depends is None:	1!
UNCOV 279	depends = []	×
280
281	if vmi._is_available() and mkl_fn_to_call is not None:	1✔
282	if getattr(vmi, mkl_fn_to_call)(sycl_queue, src1, src2, dst):	1✔
283	# call pybind11 extension for binary function from OneMKL VM
284	return getattr(vmi, mkl_impl_fn)(	1✔
285	sycl_queue, src1, src2, dst, depends
286	)
287	return binary_dp_impl_fn(src1, src2, dst, sycl_queue, depends)	1✔
288
289	super().__init__(	1✔
290	name,
291	result_type_resolver_fn,
292	_call_func,
293	docs,
294	binary_inplace_fn,
295	acceptance_fn=acceptance_fn,
296	weak_type_resolver=weak_type_resolver,
297	)
298	self.__name__ = "DPNPBinaryFunc"	1✔
299
300	def __call__(	1✔
301	self,
302	x1,
303	x2,
304	out=None,
305	where=True,
306	order="K",
307	dtype=None,
308	subok=True,
309	**kwargs,
310	):
311	dpnp.check_supported_arrays_type(	1✔
312	x1, x2, scalar_type=True, all_scalars=False
313	)
314	if kwargs:	1✔
315	raise NotImplementedError(	1✔
316	f"Requested function={self.name_} with kwargs={kwargs} "
317	"isn't currently supported."
318	)
319	elif where is not True:	1✔
320	raise NotImplementedError(	1✔
321	f"Requested function={self.name_} with where={where} "
322	"isn't currently supported."
323	)
324	elif subok is not True:	1✔
325	raise NotImplementedError(	1✔
326	f"Requested function={self.name_} with subok={subok} "
327	"isn't currently supported."
328	)
329	elif dtype is not None and out is not None:	1✔
330	raise TypeError(	1✔
331	f"Requested function={self.name_} only takes `out` or `dtype`"
332	"as an argument, but both were provided."
333	)
334
335	if order is None:	1✔
336	order = "K"	1✔
337	elif order in "afkcAFKC":	1✔
338	order = order.upper()	1✔
339	else:
340	raise ValueError(	1✔
341	"order must be one of 'C', 'F', 'A', or 'K' (got '{order}')"
342	)
343
344	x1_usm = dpnp.get_usm_ndarray_or_scalar(x1)	1✔
345	x2_usm = dpnp.get_usm_ndarray_or_scalar(x2)	1✔
346
347	if dtype is not None:	1✔
348	if dpnp.isscalar(x1):	1✔
349	x1_usm = dpt.asarray(	1✔
350	x1,
351	dtype=dtype,
352	sycl_queue=x2.sycl_queue,
353	usm_type=x2.usm_type,
354	)
355	x2_usm = dpt.astype(x2_usm, dtype, copy=False)	1✔
356	elif dpnp.isscalar(x2):	1✔
357	x1_usm = dpt.astype(x1_usm, dtype, copy=False)	1✔
358	x2_usm = dpt.asarray(	1✔
359	x2,
360	dtype=dtype,
361	sycl_queue=x1.sycl_queue,
362	usm_type=x1.usm_type,
363	)
364	else:
365	x1_usm = dpt.astype(x1_usm, dtype, copy=False)	1✔
366	x2_usm = dpt.astype(x2_usm, dtype, copy=False)	1✔
367
368	out_usm = None if out is None else dpnp.get_usm_ndarray(out)	1✔
369	res_usm = super().__call__(x1_usm, x2_usm, out=out_usm, order=order)	1✔
370
371	if out is not None and isinstance(out, dpnp_array):	1✔
372	return out	1✔
373	return dpnp_array._create_from_usm_ndarray(res_usm)	1✔
374
375	def outer(	1✔
376	self,
377	x1,
378	x2,
379	out=None,
380	where=True,
381	order="K",
382	dtype=None,
383	subok=True,
384	**kwargs,
385	):
386	"""
387	Apply the ufunc op to all pairs (a, b) with a in A and b in B.
388
389	Parameters
390	----------
391	x1 : {dpnp.ndarray, usm_ndarray}
392	First input array.
393	x2 : {dpnp.ndarray, usm_ndarray}
394	Second input array.
395	out : {None, dpnp.ndarray, usm_ndarray}, optional
396	Output array to populate.
397	Array must have the correct shape and the expected data type.
398	order : {None, "C", "F", "A", "K"}, optional
399	Memory layout of the newly output array, Cannot be provided
400	together with `out`. Default: ``"K"``.
401	dtype : {None, dtype}, optional
402	If provided, the destination array will have this dtype. Cannot be
403	provided together with `out`. Default: ``None``.
404
405	Returns
406	-------
407	out : dpnp.ndarray
408	Output array. The data type of the returned array is determined by
409	the Type Promotion Rules.
410
411	Limitations
412	-----------
413	Parameters `where` and `subok` are supported with their default values.
414	Keyword argument `kwargs` is currently unsupported.
415	Otherwise ``NotImplementedError`` exception will be raised.
416
417	See also
418	--------
419	:obj:`dpnp.outer` : A less powerful version of dpnp.multiply.outer
420	that ravels all inputs to 1D. This exists primarily
421	for compatibility with old code.
422
423	:obj:`dpnp.tensordot` : dpnp.tensordot(a, b, axes=((), ())) and
424	dpnp.multiply.outer(a, b) behave same for all
425	dimensions of a and b.
426
427	Examples
428	--------
429	>>> import dpnp as np
430	>>> A = np.array([1, 2, 3])
431	>>> B = np.array([4, 5, 6])
432	>>> np.multiply.outer(A, B)
433	array([[ 4, 5, 6],
434	[ 8, 10, 12],
435	[12, 15, 18]])
436
437	A multi-dimensional example:
438	>>> A = np.array([[1, 2, 3], [4, 5, 6]])
439	>>> A.shape
440	(2, 3)
441	>>> B = np.array([[1, 2, 3, 4]])
442	>>> B.shape
443	(1, 4)
444	>>> C = np.multiply.outer(A, B)
445	>>> C.shape; C
446	(2, 3, 1, 4)
447	array([[[[ 1, 2, 3, 4]],
448	[[ 2, 4, 6, 8]],
449	[[ 3, 6, 9, 12]]],
450	[[[ 4, 8, 12, 16]],
451	[[ 5, 10, 15, 20]],
452	[[ 6, 12, 18, 24]]]])
453
454	"""
455
456	dpnp.check_supported_arrays_type(	1✔
457	x1, x2, scalar_type=True, all_scalars=False
458	)
459	if dpnp.isscalar(x1) or dpnp.isscalar(x2):	1✔
460	_x1 = x1	1✔
461	_x2 = x2	1✔
462	else:
463	_x1 = x1[(Ellipsis,) + (None,) * x2.ndim]	1✔
464	_x2 = x2[(None,) * x1.ndim + (Ellipsis,)]	1✔
465	return self.__call__(	1✔
466	_x1,
467	_x2,
468	out=out,
469	where=where,
470	order=order,
471	dtype=dtype,
472	subok=subok,
473	**kwargs,
474	)
475
476
477	class DPNPAngle(DPNPUnaryFunc):	1✔
478	"""Class that implements dpnp.angle unary element-wise functions."""
479
480	def __init__(	1✔
481	self,
482	name,
483	result_type_resolver_fn,
484	unary_dp_impl_fn,
485	docs,
486	):
487	super().__init__(	1✔
488	name,
489	result_type_resolver_fn,
490	unary_dp_impl_fn,
491	docs,
492	)
493
494	def __call__(self, x, deg=False):	1✔
495	res = super().__call__(x)	1✔
496	if deg is True:	1✔
497	res *= 180 / dpnp.pi	1✔
498	return res	1✔
499
500
501	class DPNPReal(DPNPUnaryFunc):	1✔
502	"""Class that implements dpnp.real unary element-wise functions."""
503
504	def __init__(	1✔
505	self,
506	name,
507	result_type_resolver_fn,
508	unary_dp_impl_fn,
509	docs,
510	):
511	super().__init__(	1✔
512	name,
513	result_type_resolver_fn,
514	unary_dp_impl_fn,
515	docs,
516	)
517
518	def __call__(self, x):	1✔
519	if numpy.iscomplexobj(x):	1✔
520	return super().__call__(x)	1✔
521	return x	1✔
522
523
524	class DPNPRound(DPNPUnaryFunc):	1✔
525	"""Class that implements dpnp.round unary element-wise functions."""
526
527	def __init__(	1✔
528	self,
529	name,
530	result_type_resolver_fn,
531	unary_dp_impl_fn,
532	docs,
533	mkl_fn_to_call=None,
534	mkl_impl_fn=None,
535	):
536	super().__init__(	1✔
537	name,
538	result_type_resolver_fn,
539	unary_dp_impl_fn,
540	docs,
541	mkl_fn_to_call=mkl_fn_to_call,
542	mkl_impl_fn=mkl_impl_fn,
543	)
544
545	def __call__(self, x, decimals=0, out=None, dtype=None):	1✔
546	if decimals != 0:	1✔
547	x_usm = dpnp.get_usm_ndarray(x)	1✔
548	if dpnp.issubdtype(x_usm.dtype, dpnp.integer) and dtype is None:	1✔
549	dtype = x_usm.dtype	1✔
550
551	out_usm = None if out is None else dpnp.get_usm_ndarray(out)	1✔
552	x_usm = dpt.round(x_usm * 10**decimals, out=out_usm)	1✔
553	res_usm = dpt.divide(x_usm, 10**decimals, out=out_usm)	1✔
554
555	if dtype is not None:	1✔
556	res_usm = dpt.astype(res_usm, dtype, copy=False)	1✔
557
558	if out is not None and isinstance(out, dpnp_array):	1✔
559	return out	1✔
560	return dpnp_array._create_from_usm_ndarray(res_usm)	1✔
561	else:
562	return super().__call__(x, out=out, dtype=dtype)	1✔
563
564
565	def acceptance_fn_gcd_lcm(	1✔
566	arg1_dtype, arg2_dtype, buf1_dt, buf2_dt, res_dt, sycl_dev
567	):
568	# gcd/lcm are not defined for boolean data type
569	if arg1_dtype.char == "?" and arg2_dtype.char == "?":	1!
570	raise ValueError(	1✔
571	"The function is not supported for inputs of data type bool"
572	)
573	else:
UNCOV 574	return True	×
575
576
577	def acceptance_fn_negative(arg_dtype, buf_dt, res_dt, sycl_dev):	1✔
578	# negative is not defined for boolean data type
579	if arg_dtype.char == "?":	1!
580	raise TypeError(	1✔
581	"The `negative` function, the `-` operator, is not supported "
582	"for inputs of data type bool, use the `~` operator or the "
583	"`logical_not` function instead"
584	)
585	else:
UNCOV 586	return True	×
587
588
589	def acceptance_fn_positive(arg_dtype, buf_dt, res_dt, sycl_dev):	1✔
590	# positive is not defined for boolean data type
591	if arg_dtype.char == "?":	1!
592	raise TypeError(	1✔
593	"The `positive` function is not supported for inputs of data type "
594	"bool"
595	)
596	else:
UNCOV 597	return True	×
598
599
600	def acceptance_fn_sign(arg_dtype, buf_dt, res_dt, sycl_dev):	1✔
601	# sign is not defined for boolean data type
602	if arg_dtype.char == "?":	1!
603	raise TypeError(	1✔
604	"The `sign` function is not supported for inputs of data type bool"
605	)
606	else:
UNCOV 607	return True	×
608
609
610	def acceptance_fn_subtract(	1✔
611	arg1_dtype, arg2_dtype, buf1_dt, buf2_dt, res_dt, sycl_dev
612	):
613	# subtract is not defined for boolean data type
614	if arg1_dtype.char == "?" and arg2_dtype.char == "?":	1✔
615	raise TypeError(	1✔
616	"The `subtract` function, the `-` operator, is not supported "
617	"for inputs of data type bool, use the `^` operator, the "
618	"`bitwise_xor`, or the `logical_xor` function instead"
619	)
620	else:
621	return True	1✔
622
623
624	def resolve_weak_types_2nd_arg_int(o1_dtype, o2_dtype, sycl_dev):	1✔
625	"""
626	The second weak dtype has to be upcasting up to default integer dtype
627	for a SYCL device where it is possible.
628	For other cases the default weak types resolving will be applied.
629
630	"""
631
632	if dtu._is_weak_dtype(o2_dtype):	1✔
633	o1_kind_num = dtu._strong_dtype_num_kind(o1_dtype)	1✔
634	o2_kind_num = dtu._weak_type_num_kind(o2_dtype)	1✔
635	if o2_kind_num < o1_kind_num:	1!
636	if isinstance(	1!
637	o2_dtype, (dtu.WeakBooleanType, dtu.WeakIntegralType)
638	):
639	return o1_dtype, dpt.dtype(	1✔
640	dti.default_device_int_type(sycl_dev)
641	)
642	return dtu._resolve_weak_types(o1_dtype, o2_dtype, sycl_dev)	1✔

IntelPython / dpnp / 11349295964

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous