# Python numpy.sort_complex() 使用实例

The following are code examples for showing how to use . They are extracted from open source Python projects. You can vote up the examples you like or vote down the exmaples you don’t like. You can also save this page to your account.

Example 1

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

Parameters
----------
a : array_like
Input array

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

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

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

"""
b = array(a, copy=True)
b.sort()
if not issubclass(b.dtype.type, _nx.complexfloating):
if b.dtype.char in 'bhBH':
return b.astype('F')
elif b.dtype.char == 'g':
return b.astype('G')
else:
return b.astype('D')
else:
return b ```

Example 2

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

Parameters
----------
a : array_like
Input array

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

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

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

"""
b = array(a, copy=True)
b.sort()
if not issubclass(b.dtype.type, _nx.complexfloating):
if b.dtype.char in 'bhBH':
return b.astype('F')
elif b.dtype.char == 'g':
return b.astype('G')
else:
return b.astype('D')
else:
return b ```

Example 3

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

Parameters
----------
a : array_like
Input array

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

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

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

"""
b = array(a, copy=True)
b.sort()
if not issubclass(b.dtype.type, _nx.complexfloating):
if b.dtype.char in 'bhBH':
return b.astype('F')
elif b.dtype.char == 'g':
return b.astype('G')
else:
return b.astype('D')
else:
return b ```

Example 4

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

Parameters
----------
a : array_like
Input array

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

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

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

"""
b = array(a, copy=True)
b.sort()
if not issubclass(b.dtype.type, _nx.complexfloating):
if b.dtype.char in 'bhBH':
return b.astype('F')
elif b.dtype.char == 'g':
return b.astype('G')
else:
return b.astype('D')
else:
return b ```

Example 5

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

Parameters
----------
a : array_like
Input array

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

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

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

"""
b = array(a, copy=True)
b.sort()
if not issubclass(b.dtype.type, _nx.complexfloating):
if b.dtype.char in 'bhBH':
return b.astype('F')
elif b.dtype.char == 'g':
return b.astype('G')
else:
return b.astype('D')
else:
return b ```

Example 6

```def edist(p0, p1 = V(0, 0), sqpow = 0.5):
(x1, y1, x2, y2) = (p0[0], p0[1], p1[0], p1[1]);
return ( ((x1 - x2) ** 2) + ((y1 - y2) ** 2) ) ** sqpow;
##def

## sort_points_complex
# Sorts a list of 2D points, or tuples, using the numpy sort_complex routine
# @param points_list A list of 2D points
# @return            A sorted list containing the original points
#                    sorted first with respect to the first coordinates, then
#                    with respect to the second
## ```

Example 7

```def sort_points_complex(points_list):

complex_points = [];
for p in points_list:
x, y = p[0], p[1];
cp = np.complex(x, y);
complex_points.append(cp);
## for

complex_points = list(np.sort_complex(complex_points));

points_list = [];
for cp in complex_points:
re, im = real_part(cp), imag_part(cp);
points_list.append(vector([re, im]));
## for
return points_list;

## def

## sort_points_1D
# Sorts a list of one-dimensional (i.e., no tuples) elements
# @param points_list     A list of 1D elements to be sorted
# @param sort_by_ycoords Always ignored
# @return                A sorted list of the elements
## ```

Example 8

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

Parameters
----------
a : array_like
Input array

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

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

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

"""
b = array(a, copy=True)
b.sort()
if not issubclass(b.dtype.type, _nx.complexfloating):
if b.dtype.char in 'bhBH':
return b.astype('F')
elif b.dtype.char == 'g':
return b.astype('G')
else:
return b.astype('D')
else:
return b ```