Ë
|
Kñúh'¦ ã óà d Z ddlZddlZddlmZ ddlZddlmZ ddl m
|
Z
|
m Z ej ej d¬« Z g d¢Zd.d Z e e« d.d
|
« Zd Z d/dd d dZ e e« d0d d d d« Z d1d ddd ddZ G d de« Z G d de« Z G d de« Zd Z e e« d « Zd Z e e« d « Zd Z e e « d « Z d Z e e « d « Z d.d Z e e « d2d!« Z!d3d"Z" e e"« d4d#« Z#d.dd$d%Z$ e e$« d2dd$d&« Z%d2dd$d'Z&d.dd$d(Z' e e'« d2dd$d)« Z(d* Z) e e)« d+ « Z*d3d,Z+ e e+« d4d-« Z,y)5a~
|
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)Ú
|
NamedTuple)Ú overrides)Ú_array_converterÚ _unique_hashÚnumpy)Úmodule) Úediff1dÚin1dÚ intersect1dÚisinÚ setdiff1dÚsetxor1dÚunion1dÚuniqueÚ
|
unique_allÚ unique_countsÚunique_inverseÚ unique_valuesc ó | ||fS ©N© )ÚaryÚto_endÚto_begins úNH:\Change_password\venv_build\Lib\site-packages\numpy/lib/_arraysetops_impl.pyÚ_ediff1d_dispatcherr $ s Ø Ð "Ð"ó c óÔ t | « }|d j « } | j }| | | dd | dd z
|
S |d}nSt j |« }t j
|
||d¬« s t d« |j « }t |« }|d}nSt j |« }t j
|
||d¬« s t d« |j « }t |« }t t | « dz
|
d« }t j | ||z |z ¬ « }|dkD r||d| |dkD r||||z d t j | dd | dd ||||z « |j |« S )
|
aZ
|
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
|
--------
|
>>> import numpy as np
|
>>> 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])
|
|
r Né éÿÿÿÿÚ same_kind)ÚcastingzSdtype 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.)Úshape) r ÚravelÚdtypeÚnpÚ
|
asanyarrayÚcan_castÚ TypeErrorÚlenÚmaxÚ
|
empty_likeÚsubtractÚwrap) r r r ÚconvÚ dtype_reqÚl_beginÚl_endÚl_diffÚresults r r r ( s ôZ CÓ Dà
|
q'--/Cð Ið ÐFNØ12wSbÑ!Ð!àÐØä== Ó*Ü{{8 Y¸ ÕDÜð Kó Lð Lð >>Ó#Üh-à ~Øä vÓ&Ü{{6 9°kÕBÜð Kó Lð Lð ÜF ô SA qÓ !FÜ ]]3 f¨wÑ&6¸Ñ&>Ô ?Fà{Ø#xÐØ qyØ$*wÑ Ð Ð!ÜKKABSb 6¨'°'¸FÑ2BÐ#CÔDà 99VÓ Ð r c ó, t | « dk( r| d S | S )z5 Unpacks one-element tuples for use as return values r r )r* ©Úxs r Ú _unpack_tupler8 s ä
|
1v{Øt àr T)Ú equal_nanÚsortedc ó | fS r r )ÚarÚ return_indexÚreturn_inverseÚ return_countsÚaxisr9 r: s r Ú_unique_dispatcherrA s ð 5Lr c
|
ó@ t j | « } (t | ||||| j d|¬« }t |« S t j
|
| d« } dg| j z }| j d |< | j | j c| j d t j dd t j ¬« « } t j | « } t | j d « D cg c] } d| | j f }
|
} | j d dkD r| j |
|
« } n t j t# | « |
|
¬« } fd }t | ||||||¬« } ||d « f|dd z }t |« S # t j j $ r, t j j | j « dw xY wc c} w # t$ $ r-} d} t% | j' | j ¬« « | d} ~ ww xY w)
|
a
|
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.
|
|
equal_nan : bool, optional
|
If True, collapses multiple NaN values in the return array into one.
|
|
.. versionadded:: 1.24
|
|
sorted : bool, optional
|
If True, the unique elements are sorted. Elements may be sorted in
|
practice even if ``sorted=False``, but this could change without
|
notice.
|
|
.. versionadded:: 2.3
|
|
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.
|
|
See Also
|
--------
|
repeat : Repeat elements of an array.
|
sort : Return a sorted copy 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:: 1.21
|
Like np.sort, NaN will sort to the end of the values.
|
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.
|
|
.. versionchanged:: 2.0
|
For multi-dimensional inputs, ``unique_inverse`` is reshaped
|
such that the input can be reconstructed using
|
``np.take(unique, unique_inverse, axis=axis)``. The result is
|
now not 1-dimensional when ``axis=None``.
|
|
Note that in NumPy 2.0.0 a higher dimensional array was returned also
|
when ``axis`` was not ``None``. This was reverted, but
|
``inverse.reshape(-1)`` can be used to ensure compatibility with both
|
versions.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> 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
|
|
N©r9 Ú inverse_shaper@ r: r r ©r% Úfz;The axis argument to unique is not supported for dtype {dt})Údtc ó t | « }| j « } | j |gdd ¢ } t j | d« } | S )Nr r )r* ÚviewÚreshaper& Úmoveaxis)ÚuniqÚnr@ Ú
|
orig_dtypeÚ
|
orig_shapes r Ú reshape_uniqz unique.<locals>.reshape_uniqM sL ø Ü IØyyÓ$Øt||AÐ/
|
¨1¨2 Ò/Ü{{4 DÓ)Ø r )r& r' Ú _unique1dr# r8 rK Ú
|
exceptionsÚ AxisErrorÚndimr% rJ ÚprodÚintpÚascontiguousarrayÚrangerI Úemptyr* r) Úformat)r< r= r> r? r@ r9 r: ÚretrD Úir% Ú consolidatedÚeÚmsgrP ÚoutputrN rO s ` @@r r r sò ú ôf
|
rÓ BØ |ÜL¨.¸-Ø"+¸2¿8¹8È$Ø %ô'ô SÓ!Ð!ð?Ü [[T 1Ó %ð C"''MMØ (( 1+M$Ñð XX r§x¡xÐJ
|
Ø JqM¤2§7¡7¨:°a°b¨>ÄÇÁÔ#IÓ JBÜ × Ñ bÓ !BÜ*/°·±¸± Ó*<Ö = Q!grxxÒ Ð =EÐ =ð 8Ø 88A;?Ø 77 5>Lô 88¤C¨£G°5Ô9Lö ô | \Ø% }Ø!*¸-Ø ¨ô1Fñ 6 !9Ó%Ð '¨&°°¨*Ñ 4FÜ Ó Ð øôW ==× "Ñ "ò ?ämm×%Ñ% d¨B¯G©GÓ4¸$Ð>ð?üò >øô ò 8àKÜ
|
|
b§h¡h
|
Ó/Ó0°aÐ7ûð8ús, ÁF Ä G"ÄAG' ÆA G Ç' H Ç0(HÈH rC c ó¨ t j | « j « } t | j « dk7 r#t j
|
| « j « } |xs |}|sg|set j j | « sFt | « } | \ }
|
t |
|
« x} t ur$|r| j « | j | « fS |r | j |rdnd¬« } | | } n| j « | } t j | j t j ¬« }d|dd |rÆ| j d dkD r´| j j" d v rt j$ | d
|
« r| j j" d k( r,t j& t j$ | « dd ¬ « }nt j& | | d
|
d ¬ « }|dkD r| d| | d|dz
|
k7 |d| d||< d||dz d n| dd | dd
|
k7 |dd | | f}|r | | fz }|ret j( |« dz
|
}t j |j t j* ¬« }|| < |||j- |« n|fz }|rPt j. t j0 |« |j2 gfz « }|t j4 |« fz }|S )z
|
Find the unique elements of an array, ignoring shape.
|
|
Uses a hash table to find the unique elements if possible.
|
r Ú mergesortÚ quicksort©ÚkindrE TNr ÚcfmMr ÚcÚleft)ÚsideF)r& r' Úflattenr* r# ÚasarrayÚmaÚ is_maskedr r ÚNotImplementedÚsortr. ÚargsortrY Úboolr% re ÚisnanÚ searchsortedÚcumsumrV rJ Ú concatenateÚnonzeroÚsizeÚdiff)r< r= r> r? r9 rD r@ r: Úoptional_indicesr/ Úar_Ú hash_uniqueÚpermÚauxÚmaskÚ aux_firstnanr[ ÚimaskÚinv_idxÚidxs r rQ rQ \ s ô
|
rÓ × "Ñ "Ó $BÜ
|
288}Òô ZZ^× #Ñ #Ó %à#Ò5 ~Ðñ ¡M¼"¿%¹%¿/¹/È"Ô:Mô Ó#Øä'¨Ó,Ð ,K´^Ñ CÙØ× Ñ Ô"àIIkÓ*Ð,Ð ,ñ Øzz©l{À zÓLØhà
|
ØÜ 88CII¤R§W¡WÔ -DØD!HÙcii l QÒ&¨3¯9©9¯>©>¸VÑ+CÜ HHSWÔ Ø 99>>SÒ Ü ??¬2¯8©8°C«=¸$ÀVÔLLä ??¨3°°B±¸fÔELØ !Ò àAlÐ# sÐ+<¨L¸1Ñ,<Ð'=Ñ=ð <Ð à !\ÑØ"'\AÑ Ð Ñ àqr7c # 2hÑ&QRà t9,CÙØ T
|
}Ñ ÙÜ $ !Ñ#Ü((4::¬R¯W©WÔ5Ø Ø °$°, Ô.ÀGÐMÑMÙÜnnRZZ¨Ó -°$·)±)°°Ñ >Ó?Ø Ñ Ø Jr c ó e Zd ZU ej ed< ej ed< ej ed< ej ed< y)ÚUniqueAllResultÚvaluesÚindicesÚinverse_indicesÚcountsN©Ú__name__Ú
|
__module__Ú __qualname__r& ÚndarrayÚ__annotations__r r r r r s*
Ø JJÓØ ZZÓØZZÓ Ø JJÔr r c óJ e Zd ZU ej ed< ej ed< y)ÚUniqueCountsResultr
r Nr r r r r r § s
Ø JJÓØ JJÔr r c óJ e Zd ZU ej ed< ej ed< y)ÚUniqueInverseResultr
r Nr r r r r r ¬ s
Ø JJÓØZZÔ r r c ó | fS r r r6 s r Ú_unique_all_dispatcherr ± ó Ø 4Kr c ó2 t | dddd¬« }t | S )a4
|
Find the unique elements of an array, and counts, inverse, and indices.
|
|
This function is an Array API compatible alternative to::
|
|
np.unique(x, return_index=True, return_inverse=True,
|
return_counts=True, equal_nan=False, sorted=False)
|
|
but returns a namedtuple for easier access to each output.
|
|
.. note::
|
This function currently always returns a sorted result, however,
|
this could change in any NumPy minor release.
|
|
Parameters
|
----------
|
x : array_like
|
Input array. It will be flattened if it is not already 1-D.
|
|
Returns
|
-------
|
out : namedtuple
|
The result containing:
|
|
* values - The unique elements of an input array.
|
* indices - The first occurring indices for each unique element.
|
* inverse_indices - The indices from the set of unique elements
|
that reconstruct `x`.
|
* counts - The corresponding counts for each unique element.
|
|
See Also
|
--------
|
unique : Find the unique elements of an array.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> x = [1, 1, 2]
|
>>> uniq = np.unique_all(x)
|
>>> uniq.values
|
array([1, 2])
|
>>> uniq.indices
|
array([0, 2])
|
>>> uniq.inverse_indices
|
array([0, 0, 1])
|
>>> uniq.counts
|
array([2, 1])
|
TF©r= r> r? r9 )r r ©r7 r4 s r r r µ s+ ôd Ø ØØØØô Fô FÐ #Ð#r c ó | fS r r r6 s r Ú_unique_counts_dispatcherr ñ r r c ó2 t | dddd¬« }t | S )aæ
|
Find the unique elements and counts of an input array `x`.
|
|
This function is an Array API compatible alternative to::
|
|
np.unique(x, return_counts=True, equal_nan=False, sorted=False)
|
|
but returns a namedtuple for easier access to each output.
|
|
.. note::
|
This function currently always returns a sorted result, however,
|
this could change in any NumPy minor release.
|
|
Parameters
|
----------
|
x : array_like
|
Input array. It will be flattened if it is not already 1-D.
|
|
Returns
|
-------
|
out : namedtuple
|
The result containing:
|
|
* values - The unique elements of an input array.
|
* counts - The corresponding counts for each unique element.
|
|
See Also
|
--------
|
unique : Find the unique elements of an array.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> x = [1, 1, 2]
|
>>> uniq = np.unique_counts(x)
|
>>> uniq.values
|
array([1, 2])
|
>>> uniq.counts
|
array([2, 1])
|
FTr )r r r s r r r õ s+ ôT Ø ØØ ØØô Fô vÐ &Ð&r c ó | fS r r r6 s r Ú_unique_inverse_dispatcherr ) r r c ó2 t | dddd¬« }t | S )a
|
Find the unique elements of `x` and indices to reconstruct `x`.
|
|
This function is an Array API compatible alternative to::
|
|
np.unique(x, return_inverse=True, equal_nan=False, sorted=False)
|
|
but returns a namedtuple for easier access to each output.
|
|
.. note::
|
This function currently always returns a sorted result, however,
|
this could change in any NumPy minor release.
|
|
Parameters
|
----------
|
x : array_like
|
Input array. It will be flattened if it is not already 1-D.
|
|
Returns
|
-------
|
out : namedtuple
|
The result containing:
|
|
* values - The unique elements of an input array.
|
* inverse_indices - The indices from the set of unique elements
|
that reconstruct `x`.
|
|
See Also
|
--------
|
unique : Find the unique elements of an array.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> x = [1, 1, 2]
|
>>> uniq = np.unique_inverse(x)
|
>>> uniq.values
|
array([1, 2])
|
>>> uniq.inverse_indices
|
array([0, 0, 1])
|
FTr )r r r s r r r - s+ ôV Ø ØØØØô Fô Ð 'Ð'r c ó | fS r r r6 s r Ú_unique_values_dispatcherr b r r c ó$ t | ddddd¬« S )aò
|
Returns the unique elements of an input array `x`.
|
|
This function is an Array API compatible alternative to::
|
|
np.unique(x, equal_nan=False, sorted=False)
|
|
.. versionchanged:: 2.3
|
The algorithm was changed to a faster one that does not rely on
|
sorting, and hence the results are no longer implicitly sorted.
|
|
Parameters
|
----------
|
x : array_like
|
Input array. It will be flattened if it is not already 1-D.
|
|
Returns
|
-------
|
out : ndarray
|
The unique elements of an input array.
|
|
See Also
|
--------
|
unique : Find the unique elements of an array.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> np.unique_values([1, 1, 2])
|
array([1, 2]) # may vary
|
|
F)r= r> r? r9 r: )r r6 s r r r f s$ ôD Ø ØØ ØØØô ð r c ó
|
| |fS r r )Úar1Úar2Ú assume_uniqueÚreturn_indicess r Ú_intersect1d_dispatcherr§ ó à :Ðr c ó$ t j | « } t j |« }|s:|r!t | d¬« \ } }t |d¬« \ }}n7t | « } t |« }n | j « } |j « }t j | |f« }|r t j
|
|d¬« }|| }n|j « |dd |dd k( }|dd | } |r.dd | }
|
|dd | | j z
|
} |s
|
|
|
}
|
| } | |
|
| fS | S )a7
|
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.
|
|
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.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> 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= rb rd r Nr )r& r' r r$ ru rp ro rw ) r£ r¤ r¥ r¦ Úind1Úind2r} Úaux_sort_indicesr~ Úint1dÚ ar1_indicesÚ ar2_indicess r r r s% ôp --Ó
|
CÜ
|
--Ó
|
Cá Ù Ü s°Ô6ICÜ s°Ô6ICä+CÜ+CàiikØiikä
|
..#sÓ
|
$CÙÜ :: c° Ô<ÐØÐ"Ñ#à
|
à qr7c#2hÑ DØ HTNEáØ& s¨Ð+¨DÑ1 Ø& q rÐ*¨4Ñ0°3·8±8Ñ; Ù Ø {Ñ+KØ {Ñ+Kàk ;Ð.Ð.à r c ó
|
| |fS r r ©r£ r¤ r¥ s r Ú_setxor1d_dispatcherr² ó ó Ø :Ðr c ó |st | « } t |« }t j | |fd¬« }|j dk( r|S |j « t j dg|dd |dd k7 dgf« }||dd |dd z 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
|
--------
|
>>> import numpy as np
|
>>> 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])
|
|
N©r@ r Tr r )r r& ru rw ro )r£ r¤ r¥ r} Úflags r r r ÷ s ñ> ÜSkÜSkä
|
..#s¨$Ô
|
/CØ
|
xx1}Ø
|
àHHJÜ >>D6 3 q r 7¨c°#°2¨hÑ#6¸¸Ð?Ó @DØ tABx$s )Ñ#Ñ $Ð$r rd c ó
|
| |fS r r ©r£ r¤ r¥ Úinvertre s r Ú_in1d_dispatcherrº # r¨ r c óZ t j dt d¬« t | ||||¬« S )a
|
Test whether each element of a 1-D array is also present in a second array.
|
|
.. deprecated:: 2.0
|
Use :func:`isin` instead of `in1d` for new code.
|
|
Returns a boolean array the same length as `ar1` that is True
|
where an element of `ar1` is in `ar2` and False otherwise.
|
|
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.
|
|
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.
|
|
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.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> 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])
|
z,`in1d` is deprecated. Use `np.isin` instead.é )Ú
|
stacklevelrd )ÚwarningsÚwarnÚDeprecationWarningÚ_in1dr¸ s r r
|
r
|
( s/ ôv MMØ6ÜØõô c=¨&°tÔ <Ð<r c ó t j | « j « } t j |« j « }|j t k( r|j dd« }|dvrt d| d« t d | |fD « « }|xr |dv }|rx|j dk( r8|rt j | t ¬ « S t j | t ¬ « S | j t k( r | j t j « } |j t k( r |j t j « }t t j |« « }t t j |« « }||z
|
} | d
|
| j |j z z k }
|
| t j" |j « j k } | r.|
|
s|d k( r&|r t j | t ¬ « } nt j | t ¬ « } |r't j$ | dz t ¬ « } d| ||z
|
< n&t j& | dz t ¬ « } d| ||z
|
< | |k | |k\ z }| | }|j dk( r| S t j( |t j* ¬ « }t j* }t j. |t j* ¬ « }| t j0 ||||d ¬ « | |< | S |d k( rt3 d« |d k( r t d« | j j4 xs |j j4 }t7 |« dt7 | « dz z k s|rl|r5t j$ t7 | « t ¬ « }|D ]
|
}|| |k7 z } |S t j& t7 | « t ¬ « }|D ]
|
}|| |k( z } |S |s/t j8 | d¬« \ } }t j8 |« }t j: | |f« }|j= d¬« }|| }|r |dd |d d k7 }n |dd |d d k( }t j: ||gf« }t j> |j@ t ¬ « }|||< |r|d t7 | « S | S # t, $ r |j }Y w xY w)Nr r > Nro ÚtablezInvalid kind: 'z&'. Please use None, 'sort' or 'table'.c 3 óL K | ] }|j j d v yw))Úur\ ÚbN)r% re )Ú.0r< s r ú <genexpr>z_in1d.<locals>.<genexpr> s è ø ÒN¸R ¨ Ô8ÑNùs "$> Nrà r rE é rà Úunsafe)r% Úoutr" 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> rb rd )!r& rk r$ r% ÚobjectrJ Ú
|
ValueErrorÚallrw Ú ones_likerq Ú
|
zeros_likeÚastypeÚuint8ÚintÚminr+ ÚiinfoÚonesÚzerosÚarrayrV Ú OverflowErrorr, r- Ú RuntimeErrorÚ hasobjectr* r ru rp rY r# ) r£ r¤ r¥ r¹ re Ú is_int_arraysÚuse_table_methodÚar2_minÚar2_maxÚ ar2_rangeÚbelow_memory_constraintÚrange_safe_from_overflowÚoutgoing_arrayÚisin_helper_arÚ
|
basic_maskÚ in_range_ar1r% rË Úcontains_objectr~ ÚaÚrev_idxr< ÚorderÚsarÚbool_arr¶ r[ s r rÁ rÁ sW ä
|
**S/×
|
Ñ
|
Ó
|
!CÜ
|
**S/×
|
Ñ
|
Ó
|
!Cð yyFÒØkk"aÓ à Ð*Ñ*ÜØ dVÐ#IÐ JóLð Lô ÑNÀCÈÀ:ÔNÓNMØ$Ò@¨° Ð)@ÐâØ 88q=ÙÜ|| C¬tÔ4Ð4ä}} S´Ô5Ð5ð 99Ò Ø**RXXÓ&CØ 99Ò Ø**RXXÓ&CäbffSkÓ"ÜbffSkÓ"àgÑ% ð #,¨q°C·H±H¸s¿x¹xÑ4GÑ/HÑ"HÐ à#,´·±¸¿¹Ó0C×0GÑ0GÑ#GÐ ò %Ù $¨°«ñ Ü!#§ ¡ ¨c¼Ô!>ä!#§ ¡ ¨s¼$Ô!?ñ Ü!#§¡¨°Q© ¼dÔ!CØ01s W}Ò-ä!#§¡¨)°a©-¼tÔ!DØ01s W}Ñ-ð .¨S°G©^Ñ<JØ z?LØ× Ñ AÒ%à%Ð%ð "Ü (( 7´"·'±'Ô:Üô -- ´B·G±GÔ<CØ)7ÜKK ¨g¸UØ$'°ô;ñ*<N:Ñ &ð "Ð !Ø W_Ü ð7óð ð
|
Üð 5ó
|
ð
|
ð ii×)Ñ)Ò@¨S¯Y©Y×-@Ñ-@Oô 3x"s3x 5Ñ(Ñ(Ò(©OÙ Ü773s8¬4Ô0DØò #Ø Ñ"ð #ð ô 88C H¬DÔ1DØò #Ø Ñ"ð #à ñ Üyy °TÔ: WÜiinä c
|
Ó #Bð JJKJÓ (EØ
|
U)CÙ Øqr7c # 2hÑ&àqr7c # 2hÑ&Ü >>7 V HÐ-Ó .DÜ
|
((288¤4Ô
|
(CØCJáØ9CH~Ð à7|Ðøô !ò "Ø ð "ús Ê
|
5R. Ò.SÓSc ó
|
| |fS r r ©ÚelementÚ test_elementsr¥ r¹ re s r Ú_isin_dispatcherrò s à ]Ð #Ð#r c ó~ t j | « } t | ||||¬« j | j « S )a
|
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
|
`element` and `test_elements`, 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 `element` plus the max-min value of `test_elements`.
|
`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 `element` and `test_elements`,
|
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`.
|
|
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(test_elements)) >
|
(log10(max(test_elements)-min(test_elements)) - 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.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> 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]])
|
)r¥ r¹ re )r& rk rÁ rJ r# rï s r r r $ s: ôh jjÓ!GÜ -°}Ø Tô +ß+2©7°7·=±=Ó+AðBr c ó
|
| |fS r r ©r£ r¤ s r Ú_union1d_dispatcherrö r³ r c óF t t j | |fd¬« « S )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.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> 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])
|
Nrµ )r r& ru rõ s r r r ¡ s ô< ".. # s °$Ô7Ó 8Ð8r c ó
|
| |fS r r r± s r Ú_setdiff1d_dispatcherrù  r³ r c ó |r$t j | « j « } nt | « } t |« }| t | |dd¬« 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.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> a = np.array([1, 2, 3, 2, 4, 1])
|
>>> b = np.array([3, 4, 5, 6])
|
>>> np.setdiff1d(a, b)
|
array([1, 2])
|
|
T)r¥ r¹ )r& rk r$ r rÁ r± s r r r Æ sF ñB Üjjo×#Ñ#Ó%äSkÜSkØ uS#¨T¸$Ô?Ñ @Ð@r )NN)NNNN)FFFN)FFF)FFr )F)-Ú__doc__Ú functoolsr¾ Útypingr r r& Ú numpy._corer Ú numpy._core._multiarray_umathr r ÚpartialÚarray_function_dispatchÚ__all__r r r8 rA r rQ r r r r r r r r r r r r§ r r² r rº r
|
rÁ rò r rö r rù r r r r ú<module>r sr ðñó Û Ý ã Ý !ß Hà+)×+Ñ+Ø ×%Ñ%¨gô7Ð ò ó#ñ Ð,Ó-òW ó .ðW òtð >BØ04ðØCGØ "ôñ Ð+Ó,Ø27Ø%)ðG!Ø8<ØóG!ó -ðG!ðT 6;Ø !ð?Ø04ÀDØ ô?ôHjô ôô ô
|
*ô ò
|
ñ Ð/Ó0ñ8$ó 1ð8$òvñ Ð2Ó3ñ0'ó 4ð0'òfñ Ð3Ó4ñ1(ó 5ð1(òhñ Ð2Ó3ñ(ó 4ð(ðX 6:óñ
|
Ð0Ó1òXó 2ðXóvñ Ð-Ó.ò(%ó /ð(%ðVØ ôñ
|
Ð)Ó*ð`=¸dó `=ó +ð`=ðFP ¸tô P ðf$Ø !ô$ñ
|
Ð)Ó*ðuBØóuBó +ðuBòpñ Ð,Ó-ñ 9ó .ð 9ó@ñ Ð.Ó/ò%Aó 0ñ%Ar
|
