10185378158

Committed 31 Jul 2024 06:08PM UTC coverage: 87.704% (+0.1%) from 87.609%

Build # 10185378158

Build Type

Pull #1732

github

Committed by

web-flow

Commit Message

Merge ea67b5a4a into 1462d8c4f

Pull Request Pull Request #1732: Implements `dpctl.tensor.count_nonzero` and `dpctl.tensor.diff`

Run Details

3413 of 3939 branches covered (86.65%)

Branch coverage included in aggregate %.

212 of 230 new or added lines in 5 files covered. (92.17%)

1 existing line in 1 file now uncovered.

11416 of 12969 relevant lines covered (88.03%)

7293.06 hits per line

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

88.24

/dpctl/tensor/_array_api.py

#                       Data Parallel Control (dpctl)
#
#  Copyright 2020-2024 Intel Corporation
#
#  Licensed under the Apache License, Version 2.0 (the "License");
#  you may not use this file except in compliance with the License.
#  You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the License is distributed on an "AS IS" BASIS,
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#  See the License for the specific language governing permissions and
#  limitations under the License.

import dpctl
import dpctl.tensor as dpt
from dpctl.tensor._tensor_impl import (
    default_device_complex_type,
    default_device_fp_type,
    default_device_index_type,
    default_device_int_type,
)


def _isdtype_impl(dtype, kind):
    if isinstance(kind, str):
        if kind == "bool":
            return dtype.kind == "b"
        elif kind == "signed integer":
            return dtype.kind == "i"
        elif kind == "unsigned integer":
            return dtype.kind == "u"
        elif kind == "integral":
            return dtype.kind in "iu"
        elif kind == "real floating":
            return dtype.kind == "f"
        elif kind == "complex floating":
            return dtype.kind == "c"
        elif kind == "numeric":
            return dtype.kind in "iufc"
        else:
            raise ValueError(f"Unrecognized data type kind: {kind}")

    elif isinstance(kind, tuple):
        return any(_isdtype_impl(dtype, k) for k in kind)
    else:
        raise TypeError(f"Unsupported data type kind: {kind}")


__array_api_version__ = "2023.12"


class Info:
    """
    namespace returned by ``__array_namespace_info__()``
    """

    def __init__(self):
        self._capabilities = {
            "boolean indexing": True,
            "data-dependent shapes": True,
            "max dimensions": 64,
        }
        self._all_dtypes = {
            "bool": dpt.bool,
            "float32": dpt.float32,
            "float64": dpt.float64,
            "complex64": dpt.complex64,
            "complex128": dpt.complex128,
            "int8": dpt.int8,
            "int16": dpt.int16,
            "int32": dpt.int32,
            "int64": dpt.int64,
            "uint8": dpt.uint8,
            "uint16": dpt.uint16,
            "uint32": dpt.uint32,
            "uint64": dpt.uint64,
        }

    def capabilities(self):
        """
        capabilities()

        Returns a dictionary of ``dpctl``'s capabilities.

        The dictionary contains the following keys:
            ``"boolean indexing"``:
                boolean indicating ``dpctl``'s support of boolean indexing.
                Value: ``True``
            ``"data-dependent shapes"``:
                boolean indicating ``dpctl``'s support of data-dependent shapes.
                Value: ``True``
            ``max dimensions``:
                integer indication the maximum array dimension supported by ``dpctl``.
                Value: ``64``

        Returns:
            dict:
                dictionary of ``dpctl``'s capabilities
        """
        return self._capabilities.copy()

    def default_device(self):
        """
        default_device()

        Returns the default SYCL device.
        """
        return dpctl.select_default_device()

    def default_dtypes(self, *, device=None):
        """
        default_dtypes(*, device=None)

        Returns a dictionary of default data types for ``device``.

        Args:
            device (Optional[:class:`dpctl.SyclDevice`, :class:`dpctl.SyclQueue`, :class:`dpctl.tensor.Device`]):
                array API concept of device used in getting default data types.
                ``device`` can be ``None`` (in which case the default device
                is used), an instance of :class:`dpctl.SyclDevice` corresponding
                to a non-partitioned SYCL device, an instance of
                :class:`dpctl.SyclQueue`, or a :class:`dpctl.tensor.Device`
                object returned by :attr:`dpctl.tensor.usm_ndarray.device`.
                Default: ``None``.

        Returns:
            dict:
                a dictionary of default data types for ``device``:

                    - ``"real floating"``: dtype
                    - ``"complex floating"``: dtype
                    - ``"integral"``: dtype
                    - ``"indexing"``: dtype
        """
        if device is None:
            device = dpctl.select_default_device()
        elif isinstance(device, dpt.Device):
            device = device.sycl_device
        return {
            "real floating": dpt.dtype(default_device_fp_type(device)),
            "complex floating": dpt.dtype(default_device_complex_type(device)),
            "integral": dpt.dtype(default_device_int_type(device)),
            "indexing": dpt.dtype(default_device_index_type(device)),
        }

    def dtypes(self, *, device=None, kind=None):
        """
        dtypes(*, device=None, kind=None)

        Returns a dictionary of all Array API data types of a specified
        ``kind`` supported by ``device``.

        This dictionary only includes data types supported by the
        `Python Array API <https://data-apis.org/array-api/latest/>`_
        specification.

        Args:
            device (Optional[:class:`dpctl.SyclDevice`, :class:`dpctl.SyclQueue`, :class:`dpctl.tensor.Device`, str]):
                array API concept of device used in getting default data types.
                ``device`` can be ``None`` (in which case the default device is
                used), an instance of :class:`dpctl.SyclDevice` corresponding
                to a non-partitioned SYCL device, an instance of
                :class:`dpctl.SyclQueue`, or a :class:`dpctl.tensor.Device`
                object returned by :attr:`dpctl.tensor.usm_ndarray.device`.
                Default: ``None``.

            kind (Optional[str, Tuple[str, ...]]):
                data type kind.

                - if ``kind`` is ``None``, returns a dictionary of all data
                  types supported by `device`
                - if ``kind`` is a string, returns a dictionary containing the
                  data types belonging to the data type kind specified.

                  Supports:

                  * ``"bool"``
                  * ``"signed integer"``
                  * ``"unsigned integer"``
                  * ``"integral"``
                  * ``"real floating"``
                  * ``"complex floating"``
                  * ``"numeric"``

                - if ``kind`` is a tuple, the tuple represents a union of
                  ``kind`` strings, and returns a dictionary containing data
                  types corresponding to the-specified union.

                Default: ``None``.

        Returns:
            dict:
                a dictionary of the supported data types of the specified
                ``kind``
        """
        if device is None:
            device = dpctl.select_default_device()
        elif isinstance(device, dpt.Device):
            device = device.sycl_device
        _fp64 = device.has_aspect_fp64
        if kind is None:
            return {
                key: val
                for key, val in self._all_dtypes.items()
                if (key != "float64" or _fp64)
            }
        else:
            return {
                key: val
                for key, val in self._all_dtypes.items()
                if (key != "float64" or _fp64) and _isdtype_impl(val, kind)
            }

    def devices(self):
        """
        devices()

        Returns a list of supported devices.
        """
        return dpctl.get_devices()


def __array_namespace_info__():
    """
    __array_namespace_info__()

    Returns a namespace with Array API namespace inspection utilities.

    """
    return Info()

1	# Data Parallel Control (dpctl)
2	#
3	# Copyright 2020-2024 Intel Corporation
4	#
5	# Licensed under the Apache License, Version 2.0 (the "License");
6	# you may not use this file except in compliance with the License.
7	# You may obtain a copy of the License at
8	#
9	# http://www.apache.org/licenses/LICENSE-2.0
10	#
11	# Unless required by applicable law or agreed to in writing, software
12	# distributed under the License is distributed on an "AS IS" BASIS,
13	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14	# See the License for the specific language governing permissions and
15	# limitations under the License.
16
17	import dpctl	1✔
18	import dpctl.tensor as dpt	1✔
19	from dpctl.tensor._tensor_impl import (	1✔
20	default_device_complex_type,
21	default_device_fp_type,
22	default_device_index_type,
23	default_device_int_type,
24	)
25
26
27	def _isdtype_impl(dtype, kind):	1✔
28	if isinstance(kind, str):	1✔
29	if kind == "bool":	1✔
30	return dtype.kind == "b"	1✔
31	elif kind == "signed integer":	1✔
32	return dtype.kind == "i"	1✔
33	elif kind == "unsigned integer":	1✔
34	return dtype.kind == "u"	1✔
35	elif kind == "integral":	1✔
36	return dtype.kind in "iu"	1✔
37	elif kind == "real floating":	1✔
38	return dtype.kind == "f"	1✔
39	elif kind == "complex floating":	1!
40	return dtype.kind == "c"	1✔
41	elif kind == "numeric":	×
42	return dtype.kind in "iufc"	×
43	else:
44	raise ValueError(f"Unrecognized data type kind: {kind}")	×
45
46	elif isinstance(kind, tuple):	1!
47	return any(_isdtype_impl(dtype, k) for k in kind)	1✔
48	else:
49	raise TypeError(f"Unsupported data type kind: {kind}")	×
50
51
52	__array_api_version__ = "2023.12"	1✔
53
54
55	class Info:	1✔
56	"""
57	namespace returned by ``__array_namespace_info__()``
58	"""
59
60	def __init__(self):	1✔
61	self._capabilities = {	1✔
62	"boolean indexing": True,
63	"data-dependent shapes": True,
64	"max dimensions": 64,
65	}
66	self._all_dtypes = {	1✔
67	"bool": dpt.bool,
68	"float32": dpt.float32,
69	"float64": dpt.float64,
70	"complex64": dpt.complex64,
71	"complex128": dpt.complex128,
72	"int8": dpt.int8,
73	"int16": dpt.int16,
74	"int32": dpt.int32,
75	"int64": dpt.int64,
76	"uint8": dpt.uint8,
77	"uint16": dpt.uint16,
78	"uint32": dpt.uint32,
79	"uint64": dpt.uint64,
80	}
81
82	def capabilities(self):	1✔
83	"""
84	capabilities()
85
86	Returns a dictionary of ``dpctl``'s capabilities.
87
88	The dictionary contains the following keys:
89	``"boolean indexing"``:
90	boolean indicating ``dpctl``'s support of boolean indexing.
91	Value: ``True``
92	``"data-dependent shapes"``:
93	boolean indicating ``dpctl``'s support of data-dependent shapes.
94	Value: ``True``
95	``max dimensions``:
96	integer indication the maximum array dimension supported by ``dpctl``.
97	Value: ``64``
98
99	Returns:
100	dict:
101	dictionary of ``dpctl``'s capabilities
102	"""
103	return self._capabilities.copy()	1✔
104
105	def default_device(self):	1✔
106	"""
107	default_device()
108
109	Returns the default SYCL device.
110	"""
111	return dpctl.select_default_device()	1✔
112
113	def default_dtypes(self, *, device=None):	1✔
114	"""
115	default_dtypes(*, device=None)
116
117	Returns a dictionary of default data types for ``device``.
118
119	Args:
120	device (Optional[:class:`dpctl.SyclDevice`, :class:`dpctl.SyclQueue`, :class:`dpctl.tensor.Device`]):
121	array API concept of device used in getting default data types.
122	``device`` can be ``None`` (in which case the default device
123	is used), an instance of :class:`dpctl.SyclDevice` corresponding
124	to a non-partitioned SYCL device, an instance of
125	:class:`dpctl.SyclQueue`, or a :class:`dpctl.tensor.Device`
126	object returned by :attr:`dpctl.tensor.usm_ndarray.device`.
127	Default: ``None``.
128
129	Returns:
130	dict:
131	a dictionary of default data types for ``device``:
132
133	- ``"real floating"``: dtype
134	- ``"complex floating"``: dtype
135	- ``"integral"``: dtype
136	- ``"indexing"``: dtype
137	"""
138	if device is None:	1✔
139	device = dpctl.select_default_device()	1✔
140	elif isinstance(device, dpt.Device):	1✔
141	device = device.sycl_device	1✔
142	return {	1✔
143	"real floating": dpt.dtype(default_device_fp_type(device)),
144	"complex floating": dpt.dtype(default_device_complex_type(device)),
145	"integral": dpt.dtype(default_device_int_type(device)),
146	"indexing": dpt.dtype(default_device_index_type(device)),
147	}
148
149	def dtypes(self, *, device=None, kind=None):	1✔
150	"""
151	dtypes(*, device=None, kind=None)
152
153	Returns a dictionary of all Array API data types of a specified
154	``kind`` supported by ``device``.
155
156	This dictionary only includes data types supported by the
157	`Python Array API <https://data-apis.org/array-api/latest/>`_
158	specification.
159
160	Args:
161	device (Optional[:class:`dpctl.SyclDevice`, :class:`dpctl.SyclQueue`, :class:`dpctl.tensor.Device`, str]):
162	array API concept of device used in getting default data types.
163	``device`` can be ``None`` (in which case the default device is
164	used), an instance of :class:`dpctl.SyclDevice` corresponding
165	to a non-partitioned SYCL device, an instance of
166	:class:`dpctl.SyclQueue`, or a :class:`dpctl.tensor.Device`
167	object returned by :attr:`dpctl.tensor.usm_ndarray.device`.
168	Default: ``None``.
169
170	kind (Optional[str, Tuple[str, ...]]):
171	data type kind.
172
173	- if ``kind`` is ``None``, returns a dictionary of all data
174	types supported by `device`
175	- if ``kind`` is a string, returns a dictionary containing the
176	data types belonging to the data type kind specified.
177
178	Supports:
179
180	* ``"bool"``
181	* ``"signed integer"``
182	* ``"unsigned integer"``
183	* ``"integral"``
184	* ``"real floating"``
185	* ``"complex floating"``
186	* ``"numeric"``
187
188	- if ``kind`` is a tuple, the tuple represents a union of
189	``kind`` strings, and returns a dictionary containing data
190	types corresponding to the-specified union.
191
192	Default: ``None``.
193
194	Returns:
195	dict:
196	a dictionary of the supported data types of the specified
197	``kind``
198	"""
199	if device is None:	1✔
200	device = dpctl.select_default_device()	1✔
201	elif isinstance(device, dpt.Device):	1!
UNCOV 202	device = device.sycl_device	×
203	_fp64 = device.has_aspect_fp64	1✔
204	if kind is None:	1✔
205	return {	1✔
206	key: val
207	for key, val in self._all_dtypes.items()
208	if (key != "float64" or _fp64)
209	}
210	else:
211	return {	1✔
212	key: val
213	for key, val in self._all_dtypes.items()
214	if (key != "float64" or _fp64) and _isdtype_impl(val, kind)
215	}
216
217	def devices(self):	1✔
218	"""
219	devices()
220
221	Returns a list of supported devices.
222	"""
223	return dpctl.get_devices()	1✔
224
225
226	def __array_namespace_info__():	1✔
227	"""
228	__array_namespace_info__()
229
230	Returns a namespace with Array API namespace inspection utilities.
231
232	"""
233	return Info()	1✔

IntelPython / dpctl / 10185378158

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