# Copyright 2022-2023 XProbe Inc.
# derived from copyright 1999-2021 Alibaba Group Holding Ltd.
#
# 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.
from .sort import TensorSort, _validate_sort_arguments
[docs]def argsort(a, axis=-1, kind=None, parallel_kind=None, psrs_kinds=None, order=None):
"""
Returns the indices that would sort a tensor.
Perform an indirect sort along the given axis using the algorithm specified
by the `kind` keyword. It returns a tensor of indices of the same shape as
`a` that index data along the given axis in sorted order.
Parameters
----------
a : array_like
Tensor to sort.
axis : int or None, optional
Axis along which to sort. The default is -1 (the last axis). If None,
the flattened tensor is used.
kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional
Sorting algorithm. The default is 'quicksort'. Note that both 'stable'
and 'mergesort' use timsort under the covers and, in general, the
actual implementation will vary with data type. The 'mergesort' option
is retained for backwards compatibility.
.. versionchanged:: 1.15.0.
The 'stable' option was added.
order : str or list of str, optional
When `a` is a tensor with fields defined, this argument specifies
which fields to compare first, second, etc. A single field can
be specified as a string, and not all fields need be specified,
but unspecified fields will still be used, in the order in which
they come up in the dtype, to break ties.
Returns
-------
index_tensor : Tensor, int
Tensor of indices that sort `a` along the specified `axis`.
If `a` is one-dimensional, ``a[index_tensor]`` yields a sorted `a`.
More generally, ``np.take_along_axis(a, index_tensor, axis=axis)``
always yields the sorted `a`, irrespective of dimensionality.
See Also
--------
sort : Describes sorting algorithms used.
lexsort : Indirect stable sort with multiple keys.
Tensor.sort : Inplace sort.
argpartition : Indirect partial sort.
Notes
-----
See `sort` for notes on the different sorting algorithms.
Examples
--------
One dimensional tensor:
>>> import mars.tensor as mt
>>> x = mt.array([3, 1, 2])
>>> mt.argsort(x).execute()
array([1, 2, 0])
Two-dimensional tensor:
>>> x = mt.array([[0, 3], [2, 2]])
>>> x.execute()
array([[0, 3],
[2, 2]])
>>> ind = mt.argsort(x, axis=0) # sorts along first axis (down)
>>> ind.execute()
array([[0, 1],
[1, 0]])
#>>> mt.take_along_axis(x, ind, axis=0).execute() # same as np.sort(x, axis=0)
#array([[0, 2],
# [2, 3]])
>>> ind = mt.argsort(x, axis=1) # sorts along last axis (across)
>>> ind.execute()
array([[0, 1],
[0, 1]])
#>>> mt.take_along_axis(x, ind, axis=1).execute() # same as np.sort(x, axis=1)
#array([[0, 3],
# [2, 2]])
Indices of the sorted elements of a N-dimensional array:
>>> ind = mt.unravel_index(mt.argsort(x, axis=None), x.shape)
>>> ind.execute9)
(array([0, 1, 1, 0]), array([0, 0, 1, 1]))
>>> x[ind].execute() # same as np.sort(x, axis=None)
array([0, 2, 2, 3])
Sorting with keys:
>>> x = mt.array([(1, 0), (0, 1)], dtype=[('x', '<i4'), ('y', '<i4')])
>>> x.execute()
array([(1, 0), (0, 1)],
dtype=[('x', '<i4'), ('y', '<i4')])
>>> mt.argsort(x, order=('x','y')).execute()
array([1, 0])
>>> mt.argsort(x, order=('y','x')).execute()
array([0, 1])
"""
a, axis, kind, parallel_kind, psrs_kinds, order = _validate_sort_arguments(
a, axis, kind, parallel_kind, psrs_kinds, order
)
op = TensorSort(
axis=axis,
kind=kind,
parallel_kind=parallel_kind,
order=order,
psrs_kinds=psrs_kinds,
return_value=False,
return_indices=True,
dtype=a.dtype,
gpu=a.op.gpu,
)
return op(a)