11410354829

Committed 18 Oct 2024 08:12PM UTC coverage: 64.131% (+0.01%) from 64.12%

Build # 11410354829

Build Type

Pull #2117

github

Committed by

web-flow

Commit Message

Merge ba2e4c87a into a37425872

Pull Request Pull Request #2117: implement `dpnp.median`

Run Details

3665 of 8268 branches covered (44.33%)

Branch coverage included in aggregate %.

47 of 47 new or added lines in 2 files covered. (100.0%)

21 existing lines in 4 files now uncovered.

13730 of 18856 relevant lines covered (72.82%)

17876.63 hits per line

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

93.51

/dpnp/dpnp_iface_sorting.py

# -*- coding: utf-8 -*-
# *****************************************************************************
# Copyright (c) 2016-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.
# *****************************************************************************

"""
Interface of the sorting function of the dpnp

Notes
-----
This module is a face or public interface file for the library
it contains:
 - Interface functions
 - documentation for the functions
 - The functions parameters check

"""


import dpctl.tensor as dpt
import numpy
from dpctl.tensor._numpy_helper import normalize_axis_index

import dpnp

# pylint: disable=no-name-in-module
from .dpnp_algo import (
    dpnp_partition,
)
from .dpnp_array import dpnp_array
from .dpnp_utils import (
    call_origin,
    map_dtype_to_device,
)

__all__ = ["argsort", "partition", "sort", "sort_complex"]


def _wrap_sort_argsort(
    a, _sorting_fn, axis=-1, kind=None, order=None, stable=True
):
    """Wrap a sorting call from dpctl.tensor interface."""

    if order is not None:
        raise NotImplementedError(
            "order keyword argument is only supported with its default value."
        )
    if kind is not None and kind != "stable":
        raise NotImplementedError(
            "kind keyword argument can only be None or 'stable'."
        )
    if stable is None or not stable:
        raise NotImplementedError(
            "stable keyword argument is only supported with its default value."
        )

    usm_a = dpnp.get_usm_ndarray(a)
    if axis is None:
        usm_a = dpt.reshape(usm_a, -1)
        axis = -1

    axis = normalize_axis_index(axis, ndim=usm_a.ndim)
    usm_res = _sorting_fn(usm_a, axis=axis, stable=stable)
    return dpnp_array._create_from_usm_ndarray(usm_res)


def argsort(a, axis=-1, kind=None, order=None, *, stable=True):
    """
    Returns the indices that would sort an array.

    For full documentation refer to :obj:`numpy.argsort`.

    Parameters
    ----------
    a : {dpnp.ndarray, usm_ndarray}
        Array to be sorted.
    axis : {None, int}, optional
        Axis along which to sort. If ``None``, the array is flattened before
        sorting. The default is ``-1``, which sorts along the last axis.
    kind : {None, "stable"}, optional
        Sorting algorithm. Default is ``None``, which is equivalent to
         ``"stable"``. Unlike NumPy, no other option is accepted here.

    Returns
    -------
    out : dpnp.ndarray
        Array of indices that sort `a` along the specified `axis`.
        If `a` is one-dimensional, ``a[index_array]`` yields a sorted `a`.
        More generally, ``dpnp.take_along_axis(a, index_array, axis=axis)``
        always yields the sorted `a`, irrespective of dimensionality.
        The return array has default array index data type.

    Notes
    -----
    For zero-dimensional arrays, if ``axis=None``, output is a one-dimensional
    array with a single zero element. Otherwise, an ``AxisError`` is raised.

    Limitations
    -----------
    Parameters `order` and `stable` are only supported with their default
    values. Parameter `kind` can only be ``None`` or ``"stable"`` which are
    equivalent. Otherwise ``NotImplementedError`` exception will be raised.
    See Also
    --------
    :obj:`dpnp.ndarray.argsort` : Equivalent method.
    :obj:`dpnp.sort` : Return a sorted copy of an array.
    :obj:`dpnp.lexsort` : Indirect stable sort with multiple keys.
    :obj:`dpnp.argpartition` : Indirect partial sort.
    :obj:`dpnp.take_along_axis` : Apply ``index_array`` from obj:`dpnp.argsort`
                                  to an array as if by calling sort.

    Examples
    --------
    >>> import dpnp as np
    >>> x = np.array([3, 1, 2])
    >>> np.argsort(x)
    array([1, 2, 0])

    >>> x = np.array([[0, 3], [2, 2]])
    >>> x
    array([[0, 3],
           [2, 2]])

    >>> ind = np.argsort(x, axis=0)  # sorts along first axis
    >>> ind
    array([[0, 1],
           [1, 0]])
    >>> np.take_along_axis(x, ind, axis=0)  # same as np.sort(x, axis=0)
    array([[0, 2],
           [2, 3]])

    >>> ind = np.argsort(x, axis=1)  # sorts along last axis
    >>> ind
    array([[0, 1],
           [0, 1]])
    >>> np.take_along_axis(x, ind, axis=1)  # same as np.sort(x, axis=1)
    array([[0, 3],
           [2, 2]])

    """

    return _wrap_sort_argsort(
        a, dpt.argsort, axis=axis, kind=kind, order=order, stable=stable
    )


def partition(x1, kth, axis=-1, kind="introselect", order=None):
    """
    Return a partitioned copy of an array.

    For full documentation refer to :obj:`numpy.partition`.

    Limitations
    -----------
    Input array is supported as :obj:`dpnp.ndarray`.
    Input `kth` is supported as :obj:`int`.
    Parameters `axis`, `kind` and `order` are supported only with default
    values.

    """

    x1_desc = dpnp.get_dpnp_descriptor(x1, copy_when_nondefault_queue=False)
    if x1_desc:
        if not isinstance(kth, int):
            pass
        elif x1_desc.ndim == 0:
            pass
        elif kth >= x1_desc.shape[x1_desc.ndim - 1] or x1_desc.ndim + kth < 0:
            pass
        elif axis != -1:
            pass
        elif kind != "introselect":
            pass
        elif order is not None:
            pass
        else:
            return dpnp_partition(x1_desc, kth, axis, kind, order).get_pyobj()

    return call_origin(numpy.partition, x1, kth, axis, kind, order)


def sort(a, axis=-1, kind=None, order=None, *, stable=True):
    """
    Return a sorted copy of an array.

    For full documentation refer to :obj:`numpy.sort`.

    Parameters
    ----------
    a : {dpnp.ndarray, usm_ndarray}
        Array to be sorted.
    axis : {None, int}, optional
        Axis along which to sort. If ``None``, the array is flattened before
        sorting. The default is ``-1``, which sorts along the last axis.
    kind : {None, "stable"}, optional
        Sorting algorithm. Default is ``None``, which is equivalent to
        ``"stable"``. Unlike NumPy, no other option is accepted here.

    Returns
    -------
    out : dpnp.ndarray
        Sorted array with the same type and shape as `a`.

    Notes
    -----
    For zero-dimensional arrays, if ``axis=None``, output is the input array
    returned as a one-dimensional array. Otherwise, an ``AxisError`` is raised.

    Limitations
    -----------
    Parameters `order` and `stable` are only supported with their default
    values. Parameter `kind` can only be ``None`` or ``"stable"`` which are
    equivalent. Otherwise ``NotImplementedError`` exception will be raised.

    See Also
    --------
    :obj:`dpnp.ndarray.sort` : Sort an array in-place.
    :obj:`dpnp.argsort` : Return the indices that would sort an array.
    :obj:`dpnp.lexsort` : Indirect stable sort on multiple keys.
    :obj:`dpnp.searchsorted` : Find elements in a sorted array.
    :obj:`dpnp.partition` : Partial sort.

    Examples
    --------
    >>> import dpnp as np
    >>> a = np.array([[1,4],[3,1]])
    >>> np.sort(a)                # sort along the last axis
    array([[1, 4],
           [1, 3]])
    >>> np.sort(a, axis=None)     # sort the flattened array
    array([1, 1, 3, 4])
    >>> np.sort(a, axis=0)        # sort along the first axis
    array([[1, 1],
           [3, 4]])

    """

    return _wrap_sort_argsort(
        a, dpt.sort, axis=axis, kind=kind, order=order, stable=stable
    )


def sort_complex(a):
    """
    Sort a complex array using the real part first, then the imaginary part.

    For full documentation refer to :obj:`numpy.sort_complex`.

    Parameters
    ----------
    a : {dpnp.ndarray, usm_ndarray}
        Input array.

    Returns
    -------
    out : dpnp.ndarray of complex dtype
        Always returns a sorted complex array.

    Examples
    --------
    >>> import dpnp as np
    >>> a = np.array([5, 3, 6, 2, 1])
    >>> np.sort_complex(a)
    array([1.+0.j, 2.+0.j, 3.+0.j, 5.+0.j, 6.+0.j])

    >>> a = np.array([1 + 2j, 2 - 1j, 3 - 2j, 3 - 3j, 3 + 5j])
    >>> np.sort_complex(a)
    array([1.+2.j, 2.-1.j, 3.-3.j, 3.-2.j, 3.+5.j])

    """

    b = dpnp.sort(a)
    if not dpnp.issubdtype(b.dtype, dpnp.complexfloating):
        if b.dtype.char in "bhBH":
            b_dt = dpnp.complex64
        else:
            b_dt = map_dtype_to_device(dpnp.complex128, b.sycl_device)
        return b.astype(b_dt)
    return b

1	# -- coding: utf-8 --
2	# *****************************************************************************
3	# Copyright (c) 2016-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	"""
28	Interface of the sorting function of the dpnp
29
30	Notes
31	-----
32	This module is a face or public interface file for the library
33	it contains:
34	- Interface functions
35	- documentation for the functions
36	- The functions parameters check
37
38	"""
39
40
41	import dpctl.tensor as dpt	1✔
42	import numpy	1✔
43	from dpctl.tensor._numpy_helper import normalize_axis_index	1✔
44
45	import dpnp	1✔
46
47	# pylint: disable=no-name-in-module
48	from .dpnp_algo import (	1✔
49	dpnp_partition,
50	)
51	from .dpnp_array import dpnp_array	1✔
52	from .dpnp_utils import (	1✔
53	call_origin,
54	map_dtype_to_device,
55	)
56
57	__all__ = ["argsort", "partition", "sort", "sort_complex"]	1✔
58
59
60	def _wrap_sort_argsort(	1✔
61	a, _sorting_fn, axis=-1, kind=None, order=None, stable=True
62	):
63	"""Wrap a sorting call from dpctl.tensor interface."""
64
65	if order is not None:	1✔
66	raise NotImplementedError(	1✔
67	"order keyword argument is only supported with its default value."
68	)
69	if kind is not None and kind != "stable":	1✔
70	raise NotImplementedError(	1✔
71	"kind keyword argument can only be None or 'stable'."
72	)
73	if stable is None or not stable:	1✔
74	raise NotImplementedError(	1✔
75	"stable keyword argument is only supported with its default value."
76	)
77
78	usm_a = dpnp.get_usm_ndarray(a)	1✔
79	if axis is None:	1✔
80	usm_a = dpt.reshape(usm_a, -1)	1✔
81	axis = -1	1✔
82
83	axis = normalize_axis_index(axis, ndim=usm_a.ndim)	1✔
84	usm_res = _sorting_fn(usm_a, axis=axis, stable=stable)	1✔
85	return dpnp_array._create_from_usm_ndarray(usm_res)	1✔
86
87
88	def argsort(a, axis=-1, kind=None, order=None, *, stable=True):	1✔
89	"""
90	Returns the indices that would sort an array.
91
92	For full documentation refer to :obj:`numpy.argsort`.
93
94	Parameters
95	----------
96	a : {dpnp.ndarray, usm_ndarray}
97	Array to be sorted.
98	axis : {None, int}, optional
99	Axis along which to sort. If ``None``, the array is flattened before
100	sorting. The default is ``-1``, which sorts along the last axis.
101	kind : {None, "stable"}, optional
102	Sorting algorithm. Default is ``None``, which is equivalent to
103	``"stable"``. Unlike NumPy, no other option is accepted here.
104
105	Returns
106	-------
107	out : dpnp.ndarray
108	Array of indices that sort `a` along the specified `axis`.
109	If `a` is one-dimensional, ``a[index_array]`` yields a sorted `a`.
110	More generally, ``dpnp.take_along_axis(a, index_array, axis=axis)``
111	always yields the sorted `a`, irrespective of dimensionality.
112	The return array has default array index data type.
113
114	Notes
115	-----
116	For zero-dimensional arrays, if ``axis=None``, output is a one-dimensional
117	array with a single zero element. Otherwise, an ``AxisError`` is raised.
118
119	Limitations
120	-----------
121	Parameters `order` and `stable` are only supported with their default
122	values. Parameter `kind` can only be ``None`` or ``"stable"`` which are
123	equivalent. Otherwise ``NotImplementedError`` exception will be raised.
124	See Also
125	--------
126	:obj:`dpnp.ndarray.argsort` : Equivalent method.
127	:obj:`dpnp.sort` : Return a sorted copy of an array.
128	:obj:`dpnp.lexsort` : Indirect stable sort with multiple keys.
129	:obj:`dpnp.argpartition` : Indirect partial sort.
130	:obj:`dpnp.take_along_axis` : Apply ``index_array`` from obj:`dpnp.argsort`
131	to an array as if by calling sort.
132
133	Examples
134	--------
135	>>> import dpnp as np
136	>>> x = np.array([3, 1, 2])
137	>>> np.argsort(x)
138	array([1, 2, 0])
139
140	>>> x = np.array([[0, 3], [2, 2]])
141	>>> x
142	array([[0, 3],
143	[2, 2]])
144
145	>>> ind = np.argsort(x, axis=0) # sorts along first axis
146	>>> ind
147	array([[0, 1],
148	[1, 0]])
149	>>> np.take_along_axis(x, ind, axis=0) # same as np.sort(x, axis=0)
150	array([[0, 2],
151	[2, 3]])
152
153	>>> ind = np.argsort(x, axis=1) # sorts along last axis
154	>>> ind
155	array([[0, 1],
156	[0, 1]])
157	>>> np.take_along_axis(x, ind, axis=1) # same as np.sort(x, axis=1)
158	array([[0, 3],
159	[2, 2]])
160
161	"""
162
163	return _wrap_sort_argsort(	1✔
164	a, dpt.argsort, axis=axis, kind=kind, order=order, stable=stable
165	)
166
167
168	def partition(x1, kth, axis=-1, kind="introselect", order=None):	1✔
169	"""
170	Return a partitioned copy of an array.
171
172	For full documentation refer to :obj:`numpy.partition`.
173
174	Limitations
175	-----------
176	Input array is supported as :obj:`dpnp.ndarray`.
177	Input `kth` is supported as :obj:`int`.
178	Parameters `axis`, `kind` and `order` are supported only with default
179	values.
180
181	"""
182
183	x1_desc = dpnp.get_dpnp_descriptor(x1, copy_when_nondefault_queue=False)	1✔
184	if x1_desc:	1!
185	if not isinstance(kth, int):	1✔
186	pass	1✔
187	elif x1_desc.ndim == 0:	1✔
188	pass	1✔
189	elif kth >= x1_desc.shape[x1_desc.ndim - 1] or x1_desc.ndim + kth < 0:	1✔
190	pass	1✔
191	elif axis != -1:	1✔
192	pass	1✔
193	elif kind != "introselect":	1!
UNCOV 194	pass	×
195	elif order is not None:	1!
UNCOV 196	pass	×
197	else:
198	return dpnp_partition(x1_desc, kth, axis, kind, order).get_pyobj()	1✔
199
200	return call_origin(numpy.partition, x1, kth, axis, kind, order)	1✔
201
202
203	def sort(a, axis=-1, kind=None, order=None, *, stable=True):	1✔
204	"""
205	Return a sorted copy of an array.
206
207	For full documentation refer to :obj:`numpy.sort`.
208
209	Parameters
210	----------
211	a : {dpnp.ndarray, usm_ndarray}
212	Array to be sorted.
213	axis : {None, int}, optional
214	Axis along which to sort. If ``None``, the array is flattened before
215	sorting. The default is ``-1``, which sorts along the last axis.
216	kind : {None, "stable"}, optional
217	Sorting algorithm. Default is ``None``, which is equivalent to
218	``"stable"``. Unlike NumPy, no other option is accepted here.
219
220	Returns
221	-------
222	out : dpnp.ndarray
223	Sorted array with the same type and shape as `a`.
224
225	Notes
226	-----
227	For zero-dimensional arrays, if ``axis=None``, output is the input array
228	returned as a one-dimensional array. Otherwise, an ``AxisError`` is raised.
229
230	Limitations
231	-----------
232	Parameters `order` and `stable` are only supported with their default
233	values. Parameter `kind` can only be ``None`` or ``"stable"`` which are
234	equivalent. Otherwise ``NotImplementedError`` exception will be raised.
235
236	See Also
237	--------
238	:obj:`dpnp.ndarray.sort` : Sort an array in-place.
239	:obj:`dpnp.argsort` : Return the indices that would sort an array.
240	:obj:`dpnp.lexsort` : Indirect stable sort on multiple keys.
241	:obj:`dpnp.searchsorted` : Find elements in a sorted array.
242	:obj:`dpnp.partition` : Partial sort.
243
244	Examples
245	--------
246	>>> import dpnp as np
247	>>> a = np.array([[1,4],[3,1]])
248	>>> np.sort(a) # sort along the last axis
249	array([[1, 4],
250	[1, 3]])
251	>>> np.sort(a, axis=None) # sort the flattened array
252	array([1, 1, 3, 4])
253	>>> np.sort(a, axis=0) # sort along the first axis
254	array([[1, 1],
255	[3, 4]])
256
257	"""
258
259	return _wrap_sort_argsort(	1✔
260	a, dpt.sort, axis=axis, kind=kind, order=order, stable=stable
261	)
262
263
264	def sort_complex(a):	1✔
265	"""
266	Sort a complex array using the real part first, then the imaginary part.
267
268	For full documentation refer to :obj:`numpy.sort_complex`.
269
270	Parameters
271	----------
272	a : {dpnp.ndarray, usm_ndarray}
273	Input array.
274
275	Returns
276	-------
277	out : dpnp.ndarray of complex dtype
278	Always returns a sorted complex array.
279
280	Examples
281	--------
282	>>> import dpnp as np
283	>>> a = np.array([5, 3, 6, 2, 1])
284	>>> np.sort_complex(a)
285	array([1.+0.j, 2.+0.j, 3.+0.j, 5.+0.j, 6.+0.j])
286
287	>>> a = np.array([1 + 2j, 2 - 1j, 3 - 2j, 3 - 3j, 3 + 5j])
288	>>> np.sort_complex(a)
289	array([1.+2.j, 2.-1.j, 3.-3.j, 3.-2.j, 3.+5.j])
290
291	"""
292
293	b = dpnp.sort(a)	1✔
294	if not dpnp.issubdtype(b.dtype, dpnp.complexfloating):	1✔
295	if b.dtype.char in "bhBH":	1✔
296	b_dt = dpnp.complex64	1✔
297	else:
298	b_dt = map_dtype_to_device(dpnp.complex128, b.sycl_device)	1✔
299	return b.astype(b_dt)	1✔
300	return b	1✔

IntelPython / dpnp / 11410354829

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