U
|
P ±dL ã @ s` d Z ddlZddlZddlmZ ejejddZdddd d
|
d d d gZd.ddZ ee d/ddZ
|
dd Z d0ddddZ ee d1dddd Z d2ddddZd3dd Zeed4d dZd5d d Zeed6d dZd7dd!d"d#Zeed8dd!d$d Zd9dd!d%d&Zeed:dd!d'd Zd(d) Zeed*d Zd;d+d,Zeed<d-d
|
ZdS )=a~
|
Set operations for arrays based on sorting.
|
|
Notes
|
-----
|
|
For floating point arrays, inaccurate results may appear due to usual round-off
|
and floating point comparison issues.
|
|
Speed could be gained in some operations by an implementation of
|
`numpy.sort`, that can provide directly the permutation vectors, thus avoiding
|
calls to `numpy.argsort`.
|
|
Original author: Robert Cimrman
|
|
é N)Ú overridesÚnumpy)ÚmoduleÚediff1dÚ intersect1dÚsetxor1dÚunion1dÚ setdiff1dÚuniqueÚin1dÚisinc C s
|
| ||fS ©N© )ÚaryÚto_endÚto_beginr r úLd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\numpy/lib/arraysetops.pyÚ_ediff1d_dispatcher! s r c C sN t | ¡ ¡ } | j}|dkr<|dkr<| dd
| dd
S |dkrJd}n2t |¡}t j||ddsltd| ¡ }t|}|dkrd}n2t |¡}t j||dds¬td| ¡ }t|}tt| d d}t j|| | | jd }| |¡}|dkr||d|
< |dkr |||| d
< t
|
| dd
| dd
||||
¡ |S )
|
a?
|
The differences between consecutive elements of an array.
|
|
Parameters
|
----------
|
ary : array_like
|
If necessary, will be flattened before the differences are taken.
|
to_end : array_like, optional
|
Number(s) to append at the end of the returned differences.
|
to_begin : array_like, optional
|
Number(s) to prepend at the beginning of the returned differences.
|
|
Returns
|
-------
|
ediff1d : ndarray
|
The differences. Loosely, this is ``ary.flat[1:] - ary.flat[:-1]``.
|
|
See Also
|
--------
|
diff, gradient
|
|
Notes
|
-----
|
When applied to masked arrays, this function drops the mask information
|
if the `to_begin` and/or `to_end` parameters are used.
|
|
Examples
|
--------
|
>>> x = np.array([1, 2, 4, 7, 0])
|
>>> np.ediff1d(x)
|
array([ 1, 2, 3, -7])
|
|
>>> np.ediff1d(x, to_begin=-99, to_end=np.array([88, 99]))
|
array([-99, 1, 2, ..., -7, 88, 99])
|
|
The returned array is always 1D.
|
|
>>> y = [[1, 2, 4], [1, 6, 24]]
|
>>> np.ediff1d(y)
|
array([ 1, 2, -3, 5, 18])
|
|
Né éÿÿÿÿr Z same_kind)ZcastingzSdtype of `to_begin` must be compatible with input `ary` under the `same_kind` rule.zQdtype of `to_end` must be compatible with input `ary` under the `same_kind` rule.©Údtype) ÚnpÚ
|
asanyarrayÚravelr Zcan_castÚ TypeErrorÚlenÚmaxÚemptyZ__array_wrap__Úsubtract)r r r Z dtype_reqZl_beginZl_endZl_diffÚresultr r r r % s6 -
|
|
|
|
|
*c C s t | dkr| d S | S dS )z5 Unpacks one-element tuples for use as return values r r N)r )Úxr r r Ú _unpack_tuple} s r" ©Ú equal_nanc C s | fS r r )ÚarÚ return_indexÚreturn_inverseÚ return_countsÚaxisr$ r r r Ú_unique_dispatcher
s r* FTc
|
sp t ¡ dkr,t ||||d}t|S zt d¡ W n& t jk
|
rd t j¡dY nX j j d t j
|
dd
t j d¡ t ¡ fddt jd D }z0 jd dkrÚ |¡}nt jt |d}W n< tk
|
r* } z d}
|
t|
|
j jd | W 5 d} ~ X Y nX fd
|
d } t|||||d} | | d f| dd
} t| S ) ag
|
Find the unique elements of an array.
|
|
Returns the sorted unique elements of an array. There are three optional
|
outputs in addition to the unique elements:
|
|
* the indices of the input array that give the unique values
|
* the indices of the unique array that reconstruct the input array
|
* the number of times each unique value comes up in the input array
|
|
Parameters
|
----------
|
ar : array_like
|
Input array. Unless `axis` is specified, this will be flattened if it
|
is not already 1-D.
|
return_index : bool, optional
|
If True, also return the indices of `ar` (along the specified axis,
|
if provided, or in the flattened array) that result in the unique array.
|
return_inverse : bool, optional
|
If True, also return the indices of the unique array (for the specified
|
axis, if provided) that can be used to reconstruct `ar`.
|
return_counts : bool, optional
|
If True, also return the number of times each unique item appears
|
in `ar`.
|
axis : int or None, optional
|
The axis to operate on. If None, `ar` will be flattened. If an integer,
|
the subarrays indexed by the given axis will be flattened and treated
|
as the elements of a 1-D array with the dimension of the given axis,
|
see the notes for more details. Object arrays or structured arrays
|
that contain objects are not supported if the `axis` kwarg is used. The
|
default is None.
|
|
.. versionadded:: 1.13.0
|
|
equal_nan : bool, optional
|
If True, collapses multiple NaN values in the return array into one.
|
|
.. versionadded:: 1.24
|
|
Returns
|
-------
|
unique : ndarray
|
The sorted unique values.
|
unique_indices : ndarray, optional
|
The indices of the first occurrences of the unique values in the
|
original array. Only provided if `return_index` is True.
|
unique_inverse : ndarray, optional
|
The indices to reconstruct the original array from the
|
unique array. Only provided if `return_inverse` is True.
|
unique_counts : ndarray, optional
|
The number of times each of the unique values comes up in the
|
original array. Only provided if `return_counts` is True.
|
|
.. versionadded:: 1.9.0
|
|
See Also
|
--------
|
numpy.lib.arraysetops : Module with a number of other functions for
|
performing set operations on arrays.
|
repeat : Repeat elements of an array.
|
|
Notes
|
-----
|
When an axis is specified the subarrays indexed by the axis are sorted.
|
This is done by making the specified axis the first dimension of the array
|
(move the axis to the first dimension to keep the order of the other axes)
|
and then flattening the subarrays in C order. The flattened subarrays are
|
then viewed as a structured type with each element given a label, with the
|
effect that we end up with a 1-D array of structured types that can be
|
treated in the same way as any other 1-D array. The result is that the
|
flattened subarrays are sorted in lexicographic order starting with the
|
first element.
|
|
.. versionchanged: NumPy 1.21
|
If nan values are in the input array, a single nan is put
|
to the end of the sorted unique values.
|
|
Also for complex arrays all NaN values are considered equivalent
|
(no matter whether the NaN is in the real or imaginary part).
|
As the representant for the returned array the smallest one in the
|
lexicographical order is chosen - see np.sort for how the lexicographical
|
order is defined for complex arrays.
|
|
Examples
|
--------
|
>>> np.unique([1, 1, 2, 2, 3, 3])
|
array([1, 2, 3])
|
>>> a = np.array([[1, 1], [2, 3]])
|
>>> np.unique(a)
|
array([1, 2, 3])
|
|
Return the unique rows of a 2D array
|
|
>>> a = np.array([[1, 0, 0], [1, 0, 0], [2, 3, 4]])
|
>>> np.unique(a, axis=0)
|
array([[1, 0, 0], [2, 3, 4]])
|
|
Return the indices of the original array that give the unique values:
|
|
>>> a = np.array(['a', 'b', 'b', 'c', 'a'])
|
>>> u, indices = np.unique(a, return_index=True)
|
>>> u
|
array(['a', 'b', 'c'], dtype='<U1')
|
>>> indices
|
array([0, 1, 3])
|
>>> a[indices]
|
array(['a', 'b', 'c'], dtype='<U1')
|
|
Reconstruct the input array from the unique values and inverse:
|
|
>>> a = np.array([1, 2, 6, 4, 2, 3, 2])
|
>>> u, indices = np.unique(a, return_inverse=True)
|
>>> u
|
array([1, 2, 3, 4, 6])
|
>>> indices
|
array([0, 1, 4, 3, 1, 2, 1])
|
>>> u[indices]
|
array([1, 2, 6, 4, 2, 3, 2])
|
|
Reconstruct the input values from the unique values and counts:
|
|
>>> a = np.array([1, 2, 6, 4, 2, 3, 2])
|
>>> values, counts = np.unique(a, return_counts=True)
|
>>> values
|
array([1, 2, 3, 4, 6])
|
>>> counts
|
array([1, 3, 1, 1, 1])
|
>>> np.repeat(values, counts)
|
array([1, 2, 2, 2, 3, 4, 6]) # original order not preserved
|
|
Nr# r r r c s g | ]}d j |d jfqS )zf{i})Úi)Úformatr )Ú.0r+ )r% r r Ú
|
<listcomp>! s zunique.<locals>.<listcomp>z;The axis argument to unique is not supported for dtype {dt})Údtc s< t | }| ¡} | j|fdd
} t | d ¡} | S )Nr r )r ÚviewÚreshaper Úmoveaxis)ZuniqÚn)r) Ú
|
orig_dtypeÚ
|
orig_shaper r Ú reshape_uniq6 s
|
|
z unique.<locals>.reshape_uniq)r r Ú _unique1dr" r2 Z AxisErrorÚndimÚshaper r1 ÚprodÚintpZascontiguousarrayÚranger0 r r r r, ) r% r& r' r( r) r$ Úretr Z consolidatedÚeÚmsgr6 Úoutputr )r% r) r4 r5 r r
|
s<
|
|
ÿ$
|
& ÿc C s¾ t | ¡ ¡ } |p|}|r8| j|r&dndd}| | }n | ¡ | }t j|jt jd}d|dd
< |r|jd dkr|jj d krt
|
|d
|
¡r|jj d krºt j t
|
|¡dd d } nt j ||d
|
d d } | dkrú|d|
|d| d
k|d|
< d|| < d|| d d
< n |dd
|dd
|
k|dd
< || f}
|
|rR|
|
|| f7 }
|
|rt |¡d } t j|jt j d} | | |< |
|
| f7 }
|
|rºt t |¡|jgf ¡} |
|
t | ¡f7 }
|
|
|
S )z?
|
Find the unique elements of an array, ignoring shape.
|
Ú mergesortZ quicksort©Úkindr TNr r ZcfmMr ÚcÚleft)ZsideF)r r ÚflattenÚargsortÚsortr r9 Zbool_r rC ÚisnanZ searchsortedZcumsumr; Ú concatenateZnonzeroÚsizeZdiff)r% r& r' r( r$ Zoptional_indicesÚpermÚauxÚmaskZ aux_firstnanr= ZimaskZinv_idxÚidxr r r r7 C sB
|
$ ÿ ÿ
|
|
|
r7 c C s | |fS r r )Úar1Úar2Ú assume_uniqueÚreturn_indicesr r r Ú_intersect1d_dispatcherp s rT c C s t | ¡} t |¡}|sP|r>t| dd\} }t|dd\}}q`t| } t|}n| ¡ } | ¡ }t | |f¡}|rt j|dd}|| }n| ¡ |dd
|dd
k}|dd
| } |r|dd
| }
|
|dd
| | j } |sú||
|
}
|
|| } | |
|
| fS | S dS )aã
|
Find the intersection of two arrays.
|
|
Return the sorted, unique values that are in both of the input arrays.
|
|
Parameters
|
----------
|
ar1, ar2 : array_like
|
Input arrays. Will be flattened if not already 1D.
|
assume_unique : bool
|
If True, the input arrays are both assumed to be unique, which
|
can speed up the calculation. If True but ``ar1`` or ``ar2`` are not
|
unique, incorrect results and out-of-bounds indices could result.
|
Default is False.
|
return_indices : bool
|
If True, the indices which correspond to the intersection of the two
|
arrays are returned. The first instance of a value is used if there are
|
multiple. Default is False.
|
|
.. versionadded:: 1.15.0
|
|
Returns
|
-------
|
intersect1d : ndarray
|
Sorted 1D array of common and unique elements.
|
comm1 : ndarray
|
The indices of the first occurrences of the common values in `ar1`.
|
Only provided if `return_indices` is True.
|
comm2 : ndarray
|
The indices of the first occurrences of the common values in `ar2`.
|
Only provided if `return_indices` is True.
|
|
|
See Also
|
--------
|
numpy.lib.arraysetops : Module with a number of other functions for
|
performing set operations on arrays.
|
|
Examples
|
--------
|
>>> np.intersect1d([1, 3, 4, 3], [3, 1, 2, 1])
|
array([1, 3])
|
|
To intersect more than two arrays, use functools.reduce:
|
|
>>> from functools import reduce
|
>>> reduce(np.intersect1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2]))
|
array([3])
|
|
To return the indices of the values common to the input arrays
|
along with the intersected values:
|
|
>>> x = np.array([1, 1, 2, 3, 4])
|
>>> y = np.array([2, 1, 4, 6])
|
>>> xy, x_ind, y_ind = np.intersect1d(x, y, return_indices=True)
|
>>> x_ind, y_ind
|
(array([0, 2, 4]), array([1, 0, 2]))
|
>>> xy, x[x_ind], y[y_ind]
|
(array([1, 2, 4]), array([1, 2, 4]), array([1, 2, 4]))
|
|
T)r& rA rB r Nr )r r r
|
r rJ rG rH rK ) rP rQ rR rS Zind1Zind2rM Zaux_sort_indicesrN Zint1dZ ar1_indicesZ ar2_indicesr r r r u s2 ?
|
|
|
|
|
c C s | |fS r r ©rP rQ rR r r r Ú_setxor1d_dispatcherØ s rV c C s| |st | } t |}t | |f¡}|jdkr0|S | ¡ t dg|dd
|dd
kdgf¡}||dd
|dd
@ S )a
|
Find the set exclusive-or of two arrays.
|
|
Return the sorted, unique values that are in only one (not both) of the
|
input arrays.
|
|
Parameters
|
----------
|
ar1, ar2 : array_like
|
Input arrays.
|
assume_unique : bool
|
If True, the input arrays are both assumed to be unique, which
|
can speed up the calculation. Default is False.
|
|
Returns
|
-------
|
setxor1d : ndarray
|
Sorted 1D array of unique values that are in only one of the input
|
arrays.
|
|
Examples
|
--------
|
>>> a = np.array([1, 2, 3, 2, 4])
|
>>> b = np.array([2, 3, 5, 7, 5])
|
>>> np.setxor1d(a,b)
|
array([1, 4, 5, 7])
|
|
r Tr Nr )r
|
r rJ rK rH )rP rQ rR rM Úflagr r r r Ü s
|
(rB c C s | |fS r r )rP rQ rR ÚinvertrC r r r Ú_in1d_dispatcher s rY c C s¶ t | ¡ ¡ } t |¡ ¡ }|jtkr2| dd¡}|dkrJtd| dtdd | |fD }|oj|dk}|rL|jd kr|rt j | t
|
d
|
S t j | t
|
d
|
S | jt
|
kr²| t j ¡} |jt
|
krÈ| t j ¡}t |¡}t |¡}t|t| } | d | j|j k}
|
| t |j¡jk} | jd krt | ¡} t | ¡} tt| t|}tt| t|}| t|t| t | j¡jk|t| t | j¡jkfM } | r8|
|
s¨|d kr8|r¾t j | t
|
d
|
}nt j | t
|
d
|
}|ròt j| d t
|
d
|
}d ||| < n t j| d t
|
d
|
}d||| < | |k| |k@ }|| | | ||< |S |d kr^td n|d kr^td| jjpn|jj}t|dt| d k s|rð|rÂt jt| t
|
d
|
}|D ]}|| |kM }q¬n*t jt| t
|
d
|
}|D ]}|| |kO }qØ|S |st j| dd\} }t |¡}t | |f¡}|jdd}|| }|rT|dd
|dd
k}n|dd
|dd
k}t ||gf¡}t j|jt
|
d
|
} || |< |rª| dt|
S | | S dS )a¸
|
Test whether each element of a 1-D array is also present in a second array.
|
|
Returns a boolean array the same length as `ar1` that is True
|
where an element of `ar1` is in `ar2` and False otherwise.
|
|
We recommend using :func:`isin` instead of `in1d` for new code.
|
|
Parameters
|
----------
|
ar1 : (M,) array_like
|
Input array.
|
ar2 : array_like
|
The values against which to test each value of `ar1`.
|
assume_unique : bool, optional
|
If True, the input arrays are both assumed to be unique, which
|
can speed up the calculation. Default is False.
|
invert : bool, optional
|
If True, the values in the returned array are inverted (that is,
|
False where an element of `ar1` is in `ar2` and True otherwise).
|
Default is False. ``np.in1d(a, b, invert=True)`` is equivalent
|
to (but is faster than) ``np.invert(in1d(a, b))``.
|
kind : {None, 'sort', 'table'}, optional
|
The algorithm to use. This will not affect the final result,
|
but will affect the speed and memory use. The default, None,
|
will select automatically based on memory considerations.
|
|
* If 'sort', will use a mergesort-based approach. This will have
|
a memory usage of roughly 6 times the sum of the sizes of
|
`ar1` and `ar2`, not accounting for size of dtypes.
|
* If 'table', will use a lookup table approach similar
|
to a counting sort. This is only available for boolean and
|
integer arrays. This will have a memory usage of the
|
size of `ar1` plus the max-min value of `ar2`. `assume_unique`
|
has no effect when the 'table' option is used.
|
* If None, will automatically choose 'table' if
|
the required memory allocation is less than or equal to
|
6 times the sum of the sizes of `ar1` and `ar2`,
|
otherwise will use 'sort'. This is done to not use
|
a large amount of memory by default, even though
|
'table' may be faster in most cases. If 'table' is chosen,
|
`assume_unique` will have no effect.
|
|
.. versionadded:: 1.8.0
|
|
Returns
|
-------
|
in1d : (M,) ndarray, bool
|
The values `ar1[in1d]` are in `ar2`.
|
|
See Also
|
--------
|
isin : Version of this function that preserves the
|
shape of ar1.
|
numpy.lib.arraysetops : Module with a number of other functions for
|
performing set operations on arrays.
|
|
Notes
|
-----
|
`in1d` can be considered as an element-wise function version of the
|
python keyword `in`, for 1-D sequences. ``in1d(a, b)`` is roughly
|
equivalent to ``np.array([item in b for item in a])``.
|
However, this idea fails if `ar2` is a set, or similar (non-sequence)
|
container: As ``ar2`` is converted to an array, in those cases
|
``asarray(ar2)`` is an object array rather than the expected array of
|
contained values.
|
|
Using ``kind='table'`` tends to be faster than `kind='sort'` if the
|
following relationship is true:
|
``log10(len(ar2)) > (log10(max(ar2)-min(ar2)) - 2.27) / 0.927``,
|
but may use greater memory. The default value for `kind` will
|
be automatically selected based only on memory usage, so one may
|
manually set ``kind='table'`` if memory constraints can be relaxed.
|
|
.. versionadded:: 1.4.0
|
|
Examples
|
--------
|
>>> test = np.array([0, 1, 2, 5, 0])
|
>>> states = [0, 2]
|
>>> mask = np.in1d(test, states)
|
>>> mask
|
array([ True, False, True, False, True])
|
>>> test[mask]
|
array([0, 2, 0])
|
>>> mask = np.in1d(test, states, invert=True)
|
>>> mask
|
array([False, True, False, True, False])
|
>>> test[mask]
|
array([1, 5])
|
r r > NÚtablerH zInvalid kind: 'z&'. Please use None, 'sort' or 'table'.c s s | ]}|j jd kV qdS ))Úur+ ÚbN)r rC )r- r% r r r Ú <genexpr>v s zin1d.<locals>.<genexpr>> NrZ r r é rZ zYou have specified kind='table', but the range of values in `ar2` or `ar1` exceed the maximum integer of the datatype. Please set `kind` to None or 'sort'.zjThe 'table' method is only supported for boolean or integer arrays. Please select 'sort' or None for kind.é
|
gÂõ(\Â?T)r' rA rB N) r Úasarrayr r Úobjectr1 Ú
|
ValueErrorÚallrK Z ones_likeÚboolZ
|
zeros_likeZastypeZuint8Úminr ÚintZiinfoZonesÚzerosÚ RuntimeErrorZ hasobjectr r
|
rJ rG r r9 ) rP rQ rR rX rC Z is_int_arraysZuse_table_methodZar2_minZar2_maxZ ar2_rangeZbelow_memory_constraintZrange_safe_from_overflowZar1_minZar1_maxZ ar1_upperZ ar1_lowerZoutgoing_arrayZisin_helper_arZ
|
basic_maskZcontains_objectrN ÚaZrev_idxr% ÚorderZsarZbool_arrW r= r r r r sª ^
|
|
ÿ
|
|
|
|
|
|
|
þÿþþ ÿ
|
|
ÿ
|
ÿ
|
c C s | |fS r r ©ÚelementZ test_elementsrR rX rC r r r Ú_isin_dispatcherù s rm c C s$ t | ¡} t| ||||d | j¡S )a6
|
Calculates ``element in test_elements``, broadcasting over `element` only.
|
Returns a boolean array of the same shape as `element` that is True
|
where an element of `element` is in `test_elements` and False otherwise.
|
|
Parameters
|
----------
|
element : array_like
|
Input array.
|
test_elements : array_like
|
The values against which to test each value of `element`.
|
This argument is flattened if it is an array or array_like.
|
See notes for behavior with non-array-like parameters.
|
assume_unique : bool, optional
|
If True, the input arrays are both assumed to be unique, which
|
can speed up the calculation. Default is False.
|
invert : bool, optional
|
If True, the values in the returned array are inverted, as if
|
calculating `element not in test_elements`. Default is False.
|
``np.isin(a, b, invert=True)`` is equivalent to (but faster
|
than) ``np.invert(np.isin(a, b))``.
|
kind : {None, 'sort', 'table'}, optional
|
The algorithm to use. This will not affect the final result,
|
but will affect the speed and memory use. The default, None,
|
will select automatically based on memory considerations.
|
|
* If 'sort', will use a mergesort-based approach. This will have
|
a memory usage of roughly 6 times the sum of the sizes of
|
`ar1` and `ar2`, not accounting for size of dtypes.
|
* If 'table', will use a lookup table approach similar
|
to a counting sort. This is only available for boolean and
|
integer arrays. This will have a memory usage of the
|
size of `ar1` plus the max-min value of `ar2`. `assume_unique`
|
has no effect when the 'table' option is used.
|
* If None, will automatically choose 'table' if
|
the required memory allocation is less than or equal to
|
6 times the sum of the sizes of `ar1` and `ar2`,
|
otherwise will use 'sort'. This is done to not use
|
a large amount of memory by default, even though
|
'table' may be faster in most cases. If 'table' is chosen,
|
`assume_unique` will have no effect.
|
|
|
Returns
|
-------
|
isin : ndarray, bool
|
Has the same shape as `element`. The values `element[isin]`
|
are in `test_elements`.
|
|
See Also
|
--------
|
in1d : Flattened version of this function.
|
numpy.lib.arraysetops : Module with a number of other functions for
|
performing set operations on arrays.
|
|
Notes
|
-----
|
|
`isin` is an element-wise function version of the python keyword `in`.
|
``isin(a, b)`` is roughly equivalent to
|
``np.array([item in b for item in a])`` if `a` and `b` are 1-D sequences.
|
|
`element` and `test_elements` are converted to arrays if they are not
|
already. If `test_elements` is a set (or other non-sequence collection)
|
it will be converted to an object array with one element, rather than an
|
array of the values contained in `test_elements`. This is a consequence
|
of the `array` constructor's way of handling non-sequence collections.
|
Converting the set to a list usually gives the desired behavior.
|
|
Using ``kind='table'`` tends to be faster than `kind='sort'` if the
|
following relationship is true:
|
``log10(len(ar2)) > (log10(max(ar2)-min(ar2)) - 2.27) / 0.927``,
|
but may use greater memory. The default value for `kind` will
|
be automatically selected based only on memory usage, so one may
|
manually set ``kind='table'`` if memory constraints can be relaxed.
|
|
.. versionadded:: 1.13.0
|
|
Examples
|
--------
|
>>> element = 2*np.arange(4).reshape((2, 2))
|
>>> element
|
array([[0, 2],
|
[4, 6]])
|
>>> test_elements = [1, 2, 4, 8]
|
>>> mask = np.isin(element, test_elements)
|
>>> mask
|
array([[False, True],
|
[ True, False]])
|
>>> element[mask]
|
array([2, 4])
|
|
The indices of the matched values can be obtained with `nonzero`:
|
|
>>> np.nonzero(mask)
|
(array([0, 1]), array([1, 0]))
|
|
The test can also be inverted:
|
|
>>> mask = np.isin(element, test_elements, invert=True)
|
>>> mask
|
array([[ True, False],
|
[False, True]])
|
>>> element[mask]
|
array([0, 6])
|
|
Because of how `array` handles sets, the following does not
|
work as expected:
|
|
>>> test_set = {1, 2, 4, 8}
|
>>> np.isin(element, test_set)
|
array([[False, False],
|
[False, False]])
|
|
Casting the set to a list gives the expected result:
|
|
>>> np.isin(element, list(test_set))
|
array([[False, True],
|
[ True, False]])
|
)rR rX rC )r r` r r1 r9 rk r r r r þ s {
|
ÿÿc C s | |fS r r ©rP rQ r r r Ú_union1d_dispatcher~ s ro c C s t tj| |fddS )a=
|
Find the union of two arrays.
|
|
Return the unique, sorted array of values that are in either of the two
|
input arrays.
|
|
Parameters
|
----------
|
ar1, ar2 : array_like
|
Input arrays. They are flattened if they are not already 1D.
|
|
Returns
|
-------
|
union1d : ndarray
|
Unique, sorted union of the input arrays.
|
|
See Also
|
--------
|
numpy.lib.arraysetops : Module with a number of other functions for
|
performing set operations on arrays.
|
|
Examples
|
--------
|
>>> np.union1d([-1, 0, 1], [-2, 0, 2])
|
array([-2, -1, 0, 1, 2])
|
|
To find the union of more than two arrays, use functools.reduce:
|
|
>>> from functools import reduce
|
>>> reduce(np.union1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2]))
|
array([1, 2, 3, 4, 6])
|
N)r) )r
|
r rJ rn r r r r s "c C s | |fS r r rU r r r Ú_setdiff1d_dispatcher§ s rp c C s8 |rt | ¡ ¡ } nt| } t|}| t| |ddd S )a
|
Find the set difference of two arrays.
|
|
Return the unique values in `ar1` that are not in `ar2`.
|
|
Parameters
|
----------
|
ar1 : array_like
|
Input array.
|
ar2 : array_like
|
Input comparison array.
|
assume_unique : bool
|
If True, the input arrays are both assumed to be unique, which
|
can speed up the calculation. Default is False.
|
|
Returns
|
-------
|
setdiff1d : ndarray
|
1D array of values in `ar1` that are not in `ar2`. The result
|
is sorted when `assume_unique=False`, but otherwise only sorted
|
if the input is sorted.
|
|
See Also
|
--------
|
numpy.lib.arraysetops : Module with a number of other functions for
|
performing set operations on arrays.
|
|
Examples
|
--------
|
>>> a = np.array([1, 2, 3, 2, 4, 1])
|
>>> b = np.array([3, 4, 5, 6])
|
>>> np.setdiff1d(a, b)
|
array([1, 2])
|
|
T)rR rX )r r` r r
|
r rU r r r r « s
|
%)NN)NN)NNNN)FFFN)FFF)NN)FF)N)F)NN)FF)NN)FF)N)F)Ú__doc__Ú functoolsr r Z
|
numpy.corer ÚpartialZarray_function_dispatchÚ__all__r r r" r* r
|
r7 rT r rV r rY r rm r ro r rp r r r r r Ú<module> s ÿ þ
|
W ÿÿ ÿÿ 9 ÿÿ . ÿ
|
b
|
*ÿ mÿ ÿ
|
$
|
|
