U
|
O ±d9 ã Z @ s d dl Z d dlZd dlZd dlZd dlZd dlZd dlZddlm Z ddl m
|
Z
|
m Z m Z m Z mZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m Z m Z m Z m Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z: ddlm;Z; ddlm<Z< ddlm=Z= ddl;m>Z>m?Z? dd l<m@Z@mAZAmBZBmCZCmDZD dd
|
lmEZE dd lEmFZFmGZGmHZHmIZImJZJmKZK dd lLmMZMmNZN dd lOmPZPmQZQ eAZReSeBZTdZUe jVe;jWddZWddddddddddddd d d d d d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;d<d=d>d?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOdPdQdRdSdTdUdVdWdXdYdZd[d\d]d^d_d`dadbdcdddedfdgdhdigZZXe?dG djd^ d^eYZZdÍdkdlZ[eWe[dÎdod2Z\dÏddpdqdrZ]e>e?ddÐddpdtdIZ^eWe]dndue^Z_dÑdvdwZ`eWe`dÒdxd3ZadÓddpdydzZbe>e?ddÔddpd{d_ZceWebdnduecZddÕd|d}ZeeWeedÖd~d`Zfd×ddddZgeWegdØdddd Zhe?ddd0 Zid
d ZjeWejdd& Zkdd ZleWelddN ZmdÙddZneWendÚdd4ZodÛddZpeWepdÜdd5ZqdÝddZreWerdÞdd8ZsdßddZteWetdàdd>ZudáddZveWevdâdd:ZwdãddZxeWexdädd;Zydådd Zzd¡d¢ Z{eWe{d£d< Z|dæd¤d¥Z}eWe}dçd§d=Z~ejd¨kZe?dedfd©dCZdddªd«d¬Ze>e?deddªddDZ
eWedndue
Zd®d¯ Ze?dd°dF Ze?ddèd±dGZe?ddéd²dHZd³d´ Zdêddpdµd¶Ze>e?ddëddpd·dJZeWedndueZdìd¸d¹ZeWedíd¼dKZdîd½d¾ZeWedïd¿dEZdðdÀdÁZeWedñdÂdAZdÃdÄ ZeWedÅdB ZeC Z Z ZZeD ZZeKdZeKdnZdÆdÇ ZddÈl<T ddÈlET ddÉlm Z ddÈl T ddÊlm¡Z¡ ddÈl¡T ddËlm¢Z¢ ddÈl¢T ddÌlmOZO ddÈlOT ee ee< eeE ee¡ ee¢ eeO dS )òé Né )Ú
|
multiarray)1ÚfastCopyAndTransposeÚ ALLOW_THREADSÚBUFSIZEÚCLIPÚMAXDIMSÚMAY_SHARE_BOUNDSÚMAY_SHARE_EXACTÚRAISEÚWRAPÚarangeÚarrayÚasarrayÚ
|
asanyarrayÚascontiguousarrayÚasfortranarrayÚ broadcastÚcan_castÚcompare_chararraysÚ concatenateÚcopytoÚdotÚdtypeÚemptyÚ
|
empty_likeÚflatiterÚ
|
frombufferÚ from_dlpackÚfromfileÚfromiterÚ
|
fromstringÚinnerÚlexsortÚmatmulÚmay_share_memoryÚmin_scalar_typeÚndarrayÚnditerÚ nested_itersÚ promote_typesÚputmaskÚ result_typeÚset_numeric_opsÚ shares_memoryÚvdotÚwhereÚzerosÚnormalize_axis_indexÚ_get_promotion_stateÚ_set_promotion_state)Ú overrides)Úumath)Ú
|
shape_base)Úset_array_function_like_docÚ
|
set_module)ÚmultiplyÚinvertÚsinÚPINFÚNAN)Ú numerictypes)ÚlonglongÚintcÚint_Úfloat_Úcomplex_Úbool_)Ú TooHardErrorÚ AxisError)ÚerrstateÚ_no_nep50_warningÚnumpy)ÚmoduleÚnewaxisr' r r( r) Úufuncr r r r r r r1 Ú count_nonzeror r r r! r r r r0 Úargwherer r r r# r- r r* r& r, Ú isfortranr Ú
|
zeros_likeÚ ones_likeÚ correlateÚconvolver" r Úouterr/ ÚrollÚrollaxisÚmoveaxisÚcrossÚ tensordotÚ little_endianr Ú array_equalÚ array_equivÚindicesÚ fromfunctionÚiscloseÚisscalarÚ binary_reprÚ base_reprÚonesÚidentityÚallcloser r+ Ú flatnonzeroÚInfÚinfÚinftyÚInfinityÚnanÚNaNÚFalse_ÚTrue_Ú bitwise_notr r r r r r ÚComplexWarningÚfullÚ full_liker$ r. r% r r
|
rF rG r3 r4 c @ s e Zd ZdZdS )rq zß
|
The warning raised when casting a complex dtype to a real dtype.
|
|
As implemented, casting a complex number to a real discards its imaginary
|
part, but this behavior may not be what the user actually wants.
|
|
N)Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__© rx rx úId:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\numpy/core/numeric.pyrq = s c C s | fS ©Nrx ©Úar ÚorderÚsubokÚshaperx rx ry Ú_zeros_like_dispatcherI s r ÚKTc C s4 t | ||||d}td|jd}tj||dd |S )a
|
Return an array of zeros with the same shape and type as a given array.
|
|
Parameters
|
----------
|
a : array_like
|
The shape and data-type of `a` define these same attributes of
|
the returned array.
|
dtype : data-type, optional
|
Overrides the data type of the result.
|
|
.. versionadded:: 1.6.0
|
order : {'C', 'F', 'A', or 'K'}, optional
|
Overrides the memory layout of the result. 'C' means C-order,
|
'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
|
'C' otherwise. 'K' means match the layout of `a` as closely
|
as possible.
|
|
.. versionadded:: 1.6.0
|
subok : bool, optional.
|
If True, then the newly created array will use the sub-class
|
type of `a`, otherwise it will be a base-class array. Defaults
|
to True.
|
shape : int or sequence of ints, optional.
|
Overrides the shape of the result. If order='K' and the number of
|
dimensions is unchanged, will try to keep order, otherwise,
|
order='C' is implied.
|
|
.. versionadded:: 1.17.0
|
|
Returns
|
-------
|
out : ndarray
|
Array of zeros with the same shape and type as `a`.
|
|
See Also
|
--------
|
empty_like : Return an empty array with shape and type of input.
|
ones_like : Return an array of ones with shape and type of input.
|
full_like : Return a new array with shape of input filled with value.
|
zeros : Return a new array setting values to zero.
|
|
Examples
|
--------
|
>>> x = np.arange(6)
|
>>> x = x.reshape((2, 3))
|
>>> x
|
array([[0, 1, 2],
|
[3, 4, 5]])
|
>>> np.zeros_like(x)
|
array([[0, 0, 0],
|
[0, 0, 0]])
|
|
>>> y = np.arange(3, dtype=float)
|
>>> y
|
array([0., 1., 2.])
|
>>> np.zeros_like(y)
|
array([0., 0., 0.])
|
|
©r r} r~ r r ©r Úunsafe©Zcasting)r r1 r r r )r| r r} r~ r ÚresÚzrx rx ry rQ M s >)Úlikec C s |fS rz rx )r r r} r rx rx ry Ú_ones_dispatcher s r ÚCc C s8 |dk rt | |||dS t| ||}tj|ddd |S )aÈ
|
Return a new array of given shape and type, filled with ones.
|
|
Parameters
|
----------
|
shape : int or sequence of ints
|
Shape of the new array, e.g., ``(2, 3)`` or ``2``.
|
dtype : data-type, optional
|
The desired data-type for the array, e.g., `numpy.int8`. Default is
|
`numpy.float64`.
|
order : {'C', 'F'}, optional, default: C
|
Whether to store multi-dimensional data in row-major
|
(C-style) or column-major (Fortran-style) order in
|
memory.
|
${ARRAY_FUNCTION_LIKE}
|
|
.. versionadded:: 1.20.0
|
|
Returns
|
-------
|
out : ndarray
|
Array of ones with the given shape, dtype, and order.
|
|
See Also
|
--------
|
ones_like : Return an array of ones with shape and type of input.
|
empty : Return a new uninitialized array.
|
zeros : Return a new array setting values to zero.
|
full : Return a new array of given shape filled with value.
|
|
|
Examples
|
--------
|
>>> np.ones(5)
|
array([1., 1., 1., 1., 1.])
|
|
>>> np.ones((5,), dtype=int)
|
array([1, 1, 1, 1, 1])
|
|
>>> np.ones((2, 1))
|
array([[1.],
|
[1.]])
|
|
>>> s = (2,2)
|
>>> np.ones(s)
|
array([[1., 1.],
|
[1., 1.]])
|
|
N©r r} r r r r
)Ú_ones_with_liker r r )r r r} r r| rx rx ry rd s
|
4 )Zuse_likec C s | fS rz rx r{ rx rx ry Ú_ones_like_dispatcher× s r c C s& t | ||||d}tj|ddd |S )a
|
Return an array of ones with the same shape and type as a given array.
|
|
Parameters
|
----------
|
a : array_like
|
The shape and data-type of `a` define these same attributes of
|
the returned array.
|
dtype : data-type, optional
|
Overrides the data type of the result.
|
|
.. versionadded:: 1.6.0
|
order : {'C', 'F', 'A', or 'K'}, optional
|
Overrides the memory layout of the result. 'C' means C-order,
|
'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
|
'C' otherwise. 'K' means match the layout of `a` as closely
|
as possible.
|
|
.. versionadded:: 1.6.0
|
subok : bool, optional.
|
If True, then the newly created array will use the sub-class
|
type of `a`, otherwise it will be a base-class array. Defaults
|
to True.
|
shape : int or sequence of ints, optional.
|
Overrides the shape of the result. If order='K' and the number of
|
dimensions is unchanged, will try to keep order, otherwise,
|
order='C' is implied.
|
|
.. versionadded:: 1.17.0
|
|
Returns
|
-------
|
out : ndarray
|
Array of ones with the same shape and type as `a`.
|
|
See Also
|
--------
|
empty_like : Return an empty array with shape and type of input.
|
zeros_like : Return an array of zeros with shape and type of input.
|
full_like : Return a new array with shape of input filled with value.
|
ones : Return a new array setting values to one.
|
|
Examples
|
--------
|
>>> x = np.arange(6)
|
>>> x = x.reshape((2, 3))
|
>>> x
|
array([[0, 1, 2],
|
[3, 4, 5]])
|
>>> np.ones_like(x)
|
array([[1, 1, 1],
|
[1, 1, 1]])
|
|
>>> y = np.arange(3, dtype=float)
|
>>> y
|
array([0., 1., 2.])
|
>>> np.ones_like(y)
|
array([1., 1., 1.])
|
|
r r r r
©r r r )r| r r} r~ r r rx rx ry rR Û s >c C s |fS rz rx )r Ú
|
fill_valuer r} r rx rx ry Ú_full_dispatcher s r c C sP |dk rt | ||||dS |dkr0t|}|j}t| ||}tj||dd |S )aØ
|
Return a new array of given shape and type, filled with `fill_value`.
|
|
Parameters
|
----------
|
shape : int or sequence of ints
|
Shape of the new array, e.g., ``(2, 3)`` or ``2``.
|
fill_value : scalar or array_like
|
Fill value.
|
dtype : data-type, optional
|
The desired data-type for the array The default, None, means
|
``np.array(fill_value).dtype``.
|
order : {'C', 'F'}, optional
|
Whether to store multidimensional data in C- or Fortran-contiguous
|
(row- or column-wise) order in memory.
|
${ARRAY_FUNCTION_LIKE}
|
|
.. versionadded:: 1.20.0
|
|
Returns
|
-------
|
out : ndarray
|
Array of `fill_value` with the given shape, dtype, and order.
|
|
See Also
|
--------
|
full_like : Return a new array with shape of input filled with value.
|
empty : Return a new uninitialized array.
|
ones : Return a new array setting values to one.
|
zeros : Return a new array setting values to zero.
|
|
Examples
|
--------
|
>>> np.full((2, 2), np.inf)
|
array([[inf, inf],
|
[inf, inf]])
|
>>> np.full((2, 2), 10)
|
array([[10, 10],
|
[10, 10]])
|
|
>>> np.full((2, 2), [1, 2])
|
array([[1, 2],
|
[1, 2]])
|
|
Nr r r
)Ú_full_with_liker r r r r )r r r r} r r| rx rx ry rr " s 0 c C s | fS rz rx )r| r r r} r~ r rx rx ry Ú_full_like_dispatcherb s r c C s& t | ||||d}tj||dd |S )af
|
Return a full array with the same shape and type as a given array.
|
|
Parameters
|
----------
|
a : array_like
|
The shape and data-type of `a` define these same attributes of
|
the returned array.
|
fill_value : array_like
|
Fill value.
|
dtype : data-type, optional
|
Overrides the data type of the result.
|
order : {'C', 'F', 'A', or 'K'}, optional
|
Overrides the memory layout of the result. 'C' means C-order,
|
'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
|
'C' otherwise. 'K' means match the layout of `a` as closely
|
as possible.
|
subok : bool, optional.
|
If True, then the newly created array will use the sub-class
|
type of `a`, otherwise it will be a base-class array. Defaults
|
to True.
|
shape : int or sequence of ints, optional.
|
Overrides the shape of the result. If order='K' and the number of
|
dimensions is unchanged, will try to keep order, otherwise,
|
order='C' is implied.
|
|
.. versionadded:: 1.17.0
|
|
Returns
|
-------
|
out : ndarray
|
Array of `fill_value` with the same shape and type as `a`.
|
|
See Also
|
--------
|
empty_like : Return an empty array with shape and type of input.
|
ones_like : Return an array of ones with shape and type of input.
|
zeros_like : Return an array of zeros with shape and type of input.
|
full : Return a new array of given shape filled with value.
|
|
Examples
|
--------
|
>>> x = np.arange(6, dtype=int)
|
>>> np.full_like(x, 1)
|
array([1, 1, 1, 1, 1, 1])
|
>>> np.full_like(x, 0.1)
|
array([0, 0, 0, 0, 0, 0])
|
>>> np.full_like(x, 0.1, dtype=np.double)
|
array([0.1, 0.1, 0.1, 0.1, 0.1, 0.1])
|
>>> np.full_like(x, np.nan, dtype=np.double)
|
array([nan, nan, nan, nan, nan, nan])
|
|
>>> y = np.arange(6, dtype=np.double)
|
>>> np.full_like(y, 0.1)
|
array([0.1, 0.1, 0.1, 0.1, 0.1, 0.1])
|
|
>>> y = np.zeros([2, 2, 3], dtype=int)
|
>>> np.full_like(y, [0, 0, 255])
|
array([[[ 0, 0, 255],
|
[ 0, 0, 255]],
|
[[ 0, 0, 255],
|
[ 0, 0, 255]]])
|
r r r
r )r| r r r} r~ r r rx rx ry rs f s A)Úkeepdimsc C s | fS rz rx )r| Úaxisr rx rx ry Ú_count_nonzero_dispatcher¬ s r Fc C s` |dkr|st | ¡S t| } t | jtj¡r>| | j ¡ k}n| jtj dd}|j
|
|tj |dS )a\
|
Counts the number of non-zero values in the array ``a``.
|
|
The word "non-zero" is in reference to the Python 2.x
|
built-in method ``__nonzero__()`` (renamed ``__bool__()``
|
in Python 3.x) of Python objects that tests an object's
|
"truthfulness". For example, any number is considered
|
truthful if it is nonzero, whereas any string is considered
|
truthful if it is not the empty string. Thus, this function
|
(recursively) counts how many elements in ``a`` (and in
|
sub-arrays thereof) have their ``__nonzero__()`` or ``__bool__()``
|
method evaluated to ``True``.
|
|
Parameters
|
----------
|
a : array_like
|
The array for which to count non-zeros.
|
axis : int or tuple, optional
|
Axis or tuple of axes along which to count non-zeros.
|
Default is None, meaning that non-zeros will be counted
|
along a flattened version of ``a``.
|
|
.. versionadded:: 1.12.0
|
|
keepdims : bool, optional
|
If this is set to True, the axes that are counted are left
|
in the result as dimensions with size one. With this option,
|
the result will broadcast correctly against the input array.
|
|
.. versionadded:: 1.19.0
|
|
Returns
|
-------
|
count : int or array of int
|
Number of non-zero values in the array along a given axis.
|
Otherwise, the total number of non-zero values in the array
|
is returned.
|
|
See Also
|
--------
|
nonzero : Return the coordinates of all the non-zero values.
|
|
Examples
|
--------
|
>>> np.count_nonzero(np.eye(4))
|
4
|
>>> a = np.array([[0, 1, 7, 0],
|
... [3, 0, 2, 19]])
|
>>> np.count_nonzero(a)
|
5
|
>>> np.count_nonzero(a, axis=0)
|
array([1, 1, 2, 1])
|
>>> np.count_nonzero(a, axis=1)
|
array([2, 3])
|
>>> np.count_nonzero(a, axis=1, keepdims=True)
|
array([[2],
|
[3]])
|
NF)Úcopy)r r r ) r rN r ÚnpZ
|
issubdtyper Ú characterÚtypeÚastyperE ÚsumZintp)r| r r Za_boolrx rx ry rN ° s <
|
c C s | j jS )a
|
Check if the array is Fortran contiguous but *not* C contiguous.
|
|
This function is obsolete and, because of changes due to relaxed stride
|
checking, its return value for the same array may differ for versions
|
of NumPy >= 1.10.0 and previous versions. If you only want to check if an
|
array is Fortran contiguous use ``a.flags.f_contiguous`` instead.
|
|
Parameters
|
----------
|
a : ndarray
|
Input array.
|
|
Returns
|
-------
|
isfortran : bool
|
Returns True if the array is Fortran contiguous but *not* C contiguous.
|
|
|
Examples
|
--------
|
|
np.array allows to specify whether the array is written in C-contiguous
|
order (last index varies the fastest), or FORTRAN-contiguous order in
|
memory (first index varies the fastest).
|
|
>>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C')
|
>>> a
|
array([[1, 2, 3],
|
[4, 5, 6]])
|
>>> np.isfortran(a)
|
False
|
|
>>> b = np.array([[1, 2, 3], [4, 5, 6]], order='F')
|
>>> b
|
array([[1, 2, 3],
|
[4, 5, 6]])
|
>>> np.isfortran(b)
|
True
|
|
|
The transpose of a C-ordered array is a FORTRAN-ordered array.
|
|
>>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C')
|
>>> a
|
array([[1, 2, 3],
|
[4, 5, 6]])
|
>>> np.isfortran(a)
|
False
|
>>> b = a.T
|
>>> b
|
array([[1, 4],
|
[2, 5],
|
[3, 6]])
|
>>> np.isfortran(b)
|
True
|
|
C-ordered arrays evaluate as False even if they are also FORTRAN-ordered.
|
|
>>> np.isfortran(np.array([1, 2], order='F'))
|
False
|
|
)ÚflagsZfnc©r| rx rx ry rP ú s Ac C s | fS rz rx r rx rx ry Ú_argwhere_dispatcher> s r c C s< t | ¡dkr0t | ¡} t| dd
dd
f S tt| S )a´
|
Find the indices of array elements that are non-zero, grouped by element.
|
|
Parameters
|
----------
|
a : array_like
|
Input data.
|
|
Returns
|
-------
|
index_array : (N, a.ndim) ndarray
|
Indices of elements that are non-zero. Indices are grouped by element.
|
This array will have shape ``(N, a.ndim)`` where ``N`` is the number of
|
non-zero items.
|
|
See Also
|
--------
|
where, nonzero
|
|
Notes
|
-----
|
``np.argwhere(a)`` is almost the same as ``np.transpose(np.nonzero(a))``,
|
but produces a result of the correct shape for a 0D array.
|
|
The output of ``argwhere`` is not suitable for indexing arrays.
|
For this purpose use ``nonzero(a)`` instead.
|
|
Examples
|
--------
|
>>> x = np.arange(6).reshape(2,3)
|
>>> x
|
array([[0, 1, 2],
|
[3, 4, 5]])
|
>>> np.argwhere(x>1)
|
array([[0, 2],
|
[1, 0],
|
[1, 1],
|
[1, 2]])
|
|
r N)r Úndimr7 Z
|
atleast_1drO Ú transposeÚnonzeror rx rx ry rO B s +
|
c C s | fS rz rx r rx rx ry Ú_flatnonzero_dispatchert s r¢ c C s t t | ¡¡d S )aH
|
Return indices that are non-zero in the flattened version of a.
|
|
This is equivalent to ``np.nonzero(np.ravel(a))[0]``.
|
|
Parameters
|
----------
|
a : array_like
|
Input data.
|
|
Returns
|
-------
|
res : ndarray
|
Output array, containing the indices of the elements of ``a.ravel()``
|
that are non-zero.
|
|
See Also
|
--------
|
nonzero : Return the indices of the non-zero elements of the input array.
|
ravel : Return a 1-D array containing the elements of the input array.
|
|
Examples
|
--------
|
>>> x = np.arange(-2, 3)
|
>>> x
|
array([-2, -1, 0, 1, 2])
|
>>> np.flatnonzero(x)
|
array([0, 1, 3, 4])
|
|
Use the indices of the non-zero elements as an index array to extract
|
these elements:
|
|
>>> x.ravel()[np.flatnonzero(x)]
|
array([-2, -1, 1, 2])
|
|
r )r r¡ Úravelr rx rx ry rg x s &c C s | |fS rz rx ©r| ÚvÚmoderx rx ry Ú_correlate_dispatcher¡ s r§ Úvalidc C s t | ||¡S )aå
|
Cross-correlation of two 1-dimensional sequences.
|
|
This function computes the correlation as generally defined in signal
|
processing texts:
|
|
.. math:: c_k = \sum_n a_{n+k} \cdot \overline{v}_n
|
|
with a and v sequences being zero-padded where necessary and
|
:math:`\overline x` denoting complex conjugation.
|
|
Parameters
|
----------
|
a, v : array_like
|
Input sequences.
|
mode : {'valid', 'same', 'full'}, optional
|
Refer to the `convolve` docstring. Note that the default
|
is 'valid', unlike `convolve`, which uses 'full'.
|
old_behavior : bool
|
`old_behavior` was removed in NumPy 1.10. If you need the old
|
behavior, use `multiarray.correlate`.
|
|
Returns
|
-------
|
out : ndarray
|
Discrete cross-correlation of `a` and `v`.
|
|
See Also
|
--------
|
convolve : Discrete, linear convolution of two one-dimensional sequences.
|
multiarray.correlate : Old, no conjugate, version of correlate.
|
scipy.signal.correlate : uses FFT which has superior performance on large arrays.
|
|
Notes
|
-----
|
The definition of correlation above is not unique and sometimes correlation
|
may be defined differently. Another common definition is:
|
|
.. math:: c'_k = \sum_n a_{n} \cdot \overline{v_{n+k}}
|
|
which is related to :math:`c_k` by :math:`c'_k = c_{-k}`.
|
|
`numpy.correlate` may perform slowly in large arrays (i.e. n = 1e5) because it does
|
not use the FFT to compute the convolution; in that case, `scipy.signal.correlate` might
|
be preferable.
|
|
|
Examples
|
--------
|
>>> np.correlate([1, 2, 3], [0, 1, 0.5])
|
array([3.5])
|
>>> np.correlate([1, 2, 3], [0, 1, 0.5], "same")
|
array([2. , 3.5, 3. ])
|
>>> np.correlate([1, 2, 3], [0, 1, 0.5], "full")
|
array([0.5, 2. , 3.5, 3. , 0. ])
|
|
Using complex sequences:
|
|
>>> np.correlate([1+1j, 2, 3-1j], [0, 1, 0.5j], 'full')
|
array([ 0.5-0.5j, 1.0+0.j , 1.5-1.5j, 3.0-1.j , 0.0+0.j ])
|
|
Note that you get the time reversed, complex conjugated result
|
(:math:`\overline{c_{-k}}`) when the two input sequences a and v change
|
places:
|
|
>>> np.correlate([0, 1, 0.5j], [1+1j, 2, 3-1j], 'full')
|
array([ 0.0+0.j , 3.0+1.j , 1.5+1.5j, 1.0+0.j , 0.5+0.5j])
|
|
)r Z
|
correlate2r¤ rx rx ry rS ¥ s Gc C s | |fS rz rx r¤ rx rx ry Ú_convolve_dispatcherï s r© c C sx t | dddt |ddd } }t|t| kr8|| } }t| dkrLtdt|dkr`tdt | |ddd
|¡S ) a
|
Returns the discrete, linear convolution of two one-dimensional sequences.
|
|
The convolution operator is often seen in signal processing, where it
|
models the effect of a linear time-invariant system on a signal [1]_. In
|
probability theory, the sum of two independent random variables is
|
distributed according to the convolution of their individual
|
distributions.
|
|
If `v` is longer than `a`, the arrays are swapped before computation.
|
|
Parameters
|
----------
|
a : (N,) array_like
|
First one-dimensional input array.
|
v : (M,) array_like
|
Second one-dimensional input array.
|
mode : {'full', 'valid', 'same'}, optional
|
'full':
|
By default, mode is 'full'. This returns the convolution
|
at each point of overlap, with an output shape of (N+M-1,). At
|
the end-points of the convolution, the signals do not overlap
|
completely, and boundary effects may be seen.
|
|
'same':
|
Mode 'same' returns output of length ``max(M, N)``. Boundary
|
effects are still visible.
|
|
'valid':
|
Mode 'valid' returns output of length
|
``max(M, N) - min(M, N) + 1``. The convolution product is only given
|
for points where the signals overlap completely. Values outside
|
the signal boundary have no effect.
|
|
Returns
|
-------
|
out : ndarray
|
Discrete, linear convolution of `a` and `v`.
|
|
See Also
|
--------
|
scipy.signal.fftconvolve : Convolve two arrays using the Fast Fourier
|
Transform.
|
scipy.linalg.toeplitz : Used to construct the convolution operator.
|
polymul : Polynomial multiplication. Same output as convolve, but also
|
accepts poly1d objects as input.
|
|
Notes
|
-----
|
The discrete convolution operation is defined as
|
|
.. math:: (a * v)_n = \sum_{m = -\infty}^{\infty} a_m v_{n - m}
|
|
It can be shown that a convolution :math:`x(t) * y(t)` in time/space
|
is equivalent to the multiplication :math:`X(f) Y(f)` in the Fourier
|
domain, after appropriate padding (padding is necessary to prevent
|
circular convolution). Since multiplication is more efficient (faster)
|
than convolution, the function `scipy.signal.fftconvolve` exploits the
|
FFT to calculate the convolution of large data-sets.
|
|
References
|
----------
|
.. [1] Wikipedia, "Convolution",
|
https://en.wikipedia.org/wiki/Convolution
|
|
Examples
|
--------
|
Note how the convolution operator flips the second array
|
before "sliding" the two across one another:
|
|
>>> np.convolve([1, 2, 3], [0, 1, 0.5])
|
array([0. , 1. , 2.5, 4. , 1.5])
|
|
Only return the middle values of the convolution.
|
Contains boundary effects, where zeros are taken
|
into account:
|
|
>>> np.convolve([1,2,3],[0,1,0.5], 'same')
|
array([1. , 2.5, 4. ])
|
|
The two arrays are of the same length, so there
|
is only one position where they completely overlap:
|
|
>>> np.convolve([1,2,3],[0,1,0.5], 'valid')
|
array([2.5])
|
|
Fr )r Zndminr za cannot be emptyzv cannot be emptyNéÿÿÿÿ)r ÚlenÚ
|
ValueErrorr rS r¤ rx rx ry rT ó s Y
|
c C s
|
| ||fS rz rx ©r| ÚbÚoutrx rx ry Ú_outer_dispatcherV s r° c C s< t | } t |}t| ¡ dd
tf | ¡ tdd
f |S )a
|
|
Compute the outer product of two vectors.
|
|
Given two vectors, ``a = [a0, a1, ..., aM]`` and
|
``b = [b0, b1, ..., bN]``,
|
the outer product [1]_ is::
|
|
[[a0*b0 a0*b1 ... a0*bN ]
|
[a1*b0 .
|
[ ... .
|
[aM*b0 aM*bN ]]
|
|
Parameters
|
----------
|
a : (M,) array_like
|
First input vector. Input is flattened if
|
not already 1-dimensional.
|
b : (N,) array_like
|
Second input vector. Input is flattened if
|
not already 1-dimensional.
|
out : (M, N) ndarray, optional
|
A location where the result is stored
|
|
.. versionadded:: 1.9.0
|
|
Returns
|
-------
|
out : (M, N) ndarray
|
``out[i, j] = a[i] * b[j]``
|
|
See also
|
--------
|
inner
|
einsum : ``einsum('i,j->ij', a.ravel(), b.ravel())`` is the equivalent.
|
ufunc.outer : A generalization to dimensions other than 1D and other
|
operations. ``np.multiply.outer(a.ravel(), b.ravel())``
|
is the equivalent.
|
tensordot : ``np.tensordot(a.ravel(), b.ravel(), axes=((), ()))``
|
is the equivalent.
|
|
References
|
----------
|
.. [1] : G. H. Golub and C. F. Van Loan, *Matrix Computations*, 3rd
|
ed., Baltimore, MD, Johns Hopkins University Press, 1996,
|
pg. 8.
|
|
Examples
|
--------
|
Make a (*very* coarse) grid for computing a Mandelbrot set:
|
|
>>> rl = np.outer(np.ones((5,)), np.linspace(-2, 2, 5))
|
>>> rl
|
array([[-2., -1., 0., 1., 2.],
|
[-2., -1., 0., 1., 2.],
|
[-2., -1., 0., 1., 2.],
|
[-2., -1., 0., 1., 2.],
|
[-2., -1., 0., 1., 2.]])
|
>>> im = np.outer(1j*np.linspace(2, -2, 5), np.ones((5,)))
|
>>> im
|
array([[0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j],
|
[0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j],
|
[0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
|
[0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j],
|
[0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j]])
|
>>> grid = rl + im
|
>>> grid
|
array([[-2.+2.j, -1.+2.j, 0.+2.j, 1.+2.j, 2.+2.j],
|
[-2.+1.j, -1.+1.j, 0.+1.j, 1.+1.j, 2.+1.j],
|
[-2.+0.j, -1.+0.j, 0.+0.j, 1.+0.j, 2.+0.j],
|
[-2.-1.j, -1.-1.j, 0.-1.j, 1.-1.j, 2.-1.j],
|
[-2.-2.j, -1.-2.j, 0.-2.j, 1.-2.j, 2.-2.j]])
|
|
An example using a "vector" of letters:
|
|
>>> x = np.array(['a', 'b', 'c'], dtype=object)
|
>>> np.outer(x, [1, 2, 3])
|
array([['a', 'aa', 'aaa'],
|
['b', 'bb', 'bbb'],
|
['c', 'cc', 'ccc']], dtype=object)
|
|
N)r r: r£ rL r rx rx ry rU Z s Sc C s | |fS rz rx )r| r® Úaxesrx rx ry Ú_tensordot_dispatcher² s r² é c sv z t | W n2 tk
|
r> tt| dttd|Y n
|
X |\zt}tW n tk
|
rz gd}Y nX zt}tW n tk
|
r® gd}Y nX t| t| } }| j | j}|j|j}d}||krìd}nlt|D ]b} | | kr d} qX| dk r:| |7 < | dk rô| |7 < qô|sft dfddt|D } | }
|
d} D ]} | | 9 } qt
|
t fdd| D ¡| f} fd d| D }fd
|
dt|D } | }d} D ]} | | 9 } qø| t
|
t fd d| D ¡f}fd d| D }| |
|
¡ | ¡}| |¡ |¡}t||}| || ¡S ) a«
|
Compute tensor dot product along specified axes.
|
|
Given two tensors, `a` and `b`, and an array_like object containing
|
two array_like objects, ``(a_axes, b_axes)``, sum the products of
|
`a`'s and `b`'s elements (components) over the axes specified by
|
``a_axes`` and ``b_axes``. The third argument can be a single non-negative
|
integer_like scalar, ``N``; if it is such, then the last ``N`` dimensions
|
of `a` and the first ``N`` dimensions of `b` are summed over.
|
|
Parameters
|
----------
|
a, b : array_like
|
Tensors to "dot".
|
|
axes : int or (2,) array_like
|
* integer_like
|
If an int N, sum over the last N axes of `a` and the first N axes
|
of `b` in order. The sizes of the corresponding axes must match.
|
* (2,) array_like
|
Or, a list of axes to be summed over, first sequence applying to `a`,
|
second to `b`. Both elements array_like must be of the same length.
|
|
Returns
|
-------
|
output : ndarray
|
The tensor dot product of the input.
|
|
See Also
|
--------
|
dot, einsum
|
|
Notes
|
-----
|
Three common use cases are:
|
* ``axes = 0`` : tensor product :math:`a\otimes b`
|
* ``axes = 1`` : tensor dot product :math:`a\cdot b`
|
* ``axes = 2`` : (default) tensor double contraction :math:`a:b`
|
|
When `axes` is integer_like, the sequence for evaluation will be: first
|
the -Nth axis in `a` and 0th axis in `b`, and the -1th axis in `a` and
|
Nth axis in `b` last.
|
|
When there is more than one axis to sum over - and they are not the last
|
(first) axes of `a` (`b`) - the argument `axes` should consist of
|
two sequences of the same length, with the first axis to sum over given
|
first in both sequences, the second axis second, and so forth.
|
|
The shape of the result consists of the non-contracted axes of the
|
first tensor, followed by the non-contracted axes of the second.
|
|
Examples
|
--------
|
A "traditional" example:
|
|
>>> a = np.arange(60.).reshape(3,4,5)
|
>>> b = np.arange(24.).reshape(4,3,2)
|
>>> c = np.tensordot(a,b, axes=([1,0],[0,1]))
|
>>> c.shape
|
(5, 2)
|
>>> c
|
array([[4400., 4730.],
|
[4532., 4874.],
|
[4664., 5018.],
|
[4796., 5162.],
|
[4928., 5306.]])
|
>>> # A slower but equivalent way of computing the same...
|
>>> d = np.zeros((5,2))
|
>>> for i in range(5):
|
... for j in range(2):
|
... for k in range(3):
|
... for n in range(4):
|
... d[i,j] += a[k,n,i] * b[n,k,j]
|
>>> c == d
|
array([[ True, True],
|
[ True, True],
|
[ True, True],
|
[ True, True],
|
[ True, True]])
|
|
An extended example taking advantage of the overloading of + and \*:
|
|
>>> a = np.array(range(1, 9))
|
>>> a.shape = (2, 2, 2)
|
>>> A = np.array(('a', 'b', 'c', 'd'), dtype=object)
|
>>> A.shape = (2, 2)
|
>>> a; A
|
array([[[1, 2],
|
[3, 4]],
|
[[5, 6],
|
[7, 8]]])
|
array([['a', 'b'],
|
['c', 'd']], dtype=object)
|
|
>>> np.tensordot(a, A) # third argument default is 2 for double-contraction
|
array(['abbcccdddd', 'aaaaabbbbbbcccccccdddddddd'], dtype=object)
|
|
>>> np.tensordot(a, A, 1)
|
array([[['acc', 'bdd'],
|
['aaacccc', 'bbbdddd']],
|
[['aaaaacccccc', 'bbbbbdddddd'],
|
['aaaaaaacccccccc', 'bbbbbbbdddddddd']]], dtype=object)
|
|
>>> np.tensordot(a, A, 0) # tensor product (result too long to incl.)
|
array([[[[['a', 'b'],
|
['c', 'd']],
|
...
|
|
>>> np.tensordot(a, A, (0, 1))
|
array([[['abbbbb', 'cddddd'],
|
['aabbbbbb', 'ccdddddd']],
|
[['aaabbbbbbb', 'cccddddddd'],
|
['aaaabbbbbbbb', 'ccccdddddddd']]], dtype=object)
|
|
>>> np.tensordot(a, A, (2, 1))
|
array([[['abb', 'cdd'],
|
['aaabbbb', 'cccdddd']],
|
[['aaaaabbbbbb', 'cccccdddddd'],
|
['aaaaaaabbbbbbbb', 'cccccccdddddddd']]], dtype=object)
|
|
>>> np.tensordot(a, A, ((0, 1), (0, 1)))
|
array(['abbbcccccddddddd', 'aabbbbccccccdddddddd'], dtype=object)
|
|
>>> np.tensordot(a, A, ((2, 1), (1, 0)))
|
array(['acccbbdddd', 'aaaaacccccccbbbbbbdddddddd'], dtype=object)
|
|
r r TFzshape-mismatch for sumc s g | ]}| kr|qS rx rx ©Ú.0Úk)Úaxes_arx ry Ú
|
<listcomp>a s z tensordot.<locals>.<listcomp>c s g | ] } | qS rx rx ©rµ Úax©Úas_rx ry r¸ f s c s g | ] } | qS rx rx ©rµ r r» rx ry r¸ g s c s g | ]}| kr|qS rx rx r´ )Úaxes_brx ry r¸ i s c s g | ] } | qS rx rx r¹ ©Úbsrx ry r¸ n s c s g | ] } | qS rx rx r½ r¿ rx ry r¸ o s )ÚiterÚ ExceptionÚlistÚranger« Ú TypeErrorr r r r¬ Úintr: Úreducer Úreshaper )r| r® r± ÚnaÚnbZndaZndbÚequalr¶ ÚnotinZ newaxes_aZN2r Z
|
newshape_aZoldaZ newaxes_bZ
|
newshape_bZoldbÚatZbtr rx )r¼ r· r¾ rÀ ry rZ ¶ sn
|
|
|
c C s | fS rz rx )r| Úshiftr rx rx ry Ú_roll_dispatcherw s rÏ c C s2 t | } |dkr(t| ¡ |d | j¡S t|| jdd}t||}|jdkrTtddd t | jD }|D ]\}}|| |7 < qlt
|
dt
|
dffg| j }| ¡ D ]N\}}|| j| p¾d; }|r¨t
|
d| t
|
|dft
|
| dt
|
d|ff||< q¨t | } t j| D ] }
|
t|
|
\} } | | | | < q
|
| S dS ) a)
|
Roll array elements along a given axis.
|
|
Elements that roll beyond the last position are re-introduced at
|
the first.
|
|
Parameters
|
----------
|
a : array_like
|
Input array.
|
shift : int or tuple of ints
|
The number of places by which elements are shifted. If a tuple,
|
then `axis` must be a tuple of the same size, and each of the
|
given axes is shifted by the corresponding number. If an int
|
while `axis` is a tuple of ints, then the same value is used for
|
all given axes.
|
axis : int or tuple of ints, optional
|
Axis or axes along which elements are shifted. By default, the
|
array is flattened before shifting, after which the original
|
shape is restored.
|
|
Returns
|
-------
|
res : ndarray
|
Output array, with the same shape as `a`.
|
|
See Also
|
--------
|
rollaxis : Roll the specified axis backwards, until it lies in a
|
given position.
|
|
Notes
|
-----
|
.. versionadded:: 1.12.0
|
|
Supports rolling over multiple dimensions simultaneously.
|
|
Examples
|
--------
|
>>> x = np.arange(10)
|
>>> np.roll(x, 2)
|
array([8, 9, 0, 1, 2, 3, 4, 5, 6, 7])
|
>>> np.roll(x, -2)
|
array([2, 3, 4, 5, 6, 7, 8, 9, 0, 1])
|
|
>>> x2 = np.reshape(x, (2, 5))
|
>>> x2
|
array([[0, 1, 2, 3, 4],
|
[5, 6, 7, 8, 9]])
|
>>> np.roll(x2, 1)
|
array([[9, 0, 1, 2, 3],
|
[4, 5, 6, 7, 8]])
|
>>> np.roll(x2, -1)
|
array([[1, 2, 3, 4, 5],
|
[6, 7, 8, 9, 0]])
|
>>> np.roll(x2, 1, axis=0)
|
array([[5, 6, 7, 8, 9],
|
[0, 1, 2, 3, 4]])
|
>>> np.roll(x2, -1, axis=0)
|
array([[5, 6, 7, 8, 9],
|
[0, 1, 2, 3, 4]])
|
>>> np.roll(x2, 1, axis=1)
|
array([[4, 0, 1, 2, 3],
|
[9, 5, 6, 7, 8]])
|
>>> np.roll(x2, -1, axis=1)
|
array([[1, 2, 3, 4, 0],
|
[6, 7, 8, 9, 5]])
|
>>> np.roll(x2, (1, 1), axis=(1, 0))
|
array([[9, 5, 6, 7, 8],
|
[4, 0, 1, 2, 3]])
|
>>> np.roll(x2, (2, 1), axis=(1, 0))
|
array([[8, 9, 5, 6, 7],
|
[3, 4, 0, 1, 2]])
|
|
Nr T)Úallow_duplicater z4'shift' and 'axis' should be scalars or 1D sequencesc S s i | ]
|
}|d qS ©r rx r¹ rx rx ry Ú
|
<dictcomp>Ò s zroll.<locals>.<dictcomp>)r rV r£ rÈ r Únormalize_axis_tupler r r¬ rÄ ÚsliceÚitemsr Ú itertoolsÚproductÚzip) r| rÎ r Z broadcastedZshiftsÚshrº ZrollsÚoffsetÚresultr^ Z arr_indexZ res_indexrx rx ry rV { s0 M
|
|
ÿ ÿ
|
c C s | fS rz rx )r| r Ústartrx rx ry Ú_rollaxis_dispatcheræ s rÝ c C s¨ | j }t||}|dk r ||7 }d}d| kr<|d k sZn t|d| d|d |f ||k rj|d8 }||krz| d S ttd|}| |¡ | ||¡ | |¡S )a+
|
|
Roll the specified axis backwards, until it lies in a given position.
|
|
This function continues to be supported for backward compatibility, but you
|
should prefer `moveaxis`. The `moveaxis` function was added in NumPy
|
1.11.
|
|
Parameters
|
----------
|
a : ndarray
|
Input array.
|
axis : int
|
The axis to be rolled. The positions of the other axes do not
|
change relative to one another.
|
start : int, optional
|
When ``start <= axis``, the axis is rolled back until it lies in
|
this position. When ``start > axis``, the axis is rolled until it
|
lies before this position. The default, 0, results in a "complete"
|
roll. The following table describes how negative values of ``start``
|
are interpreted:
|
|
.. table::
|
:align: left
|
|
+-------------------+----------------------+
|
| ``start`` | Normalized ``start`` |
|
+===================+======================+
|
| ``-(arr.ndim+1)`` | raise ``AxisError`` |
|
+-------------------+----------------------+
|
| ``-arr.ndim`` | 0 |
|
+-------------------+----------------------+
|
| |vdots| | |vdots| |
|
+-------------------+----------------------+
|
| ``-1`` | ``arr.ndim-1`` |
|
+-------------------+----------------------+
|
| ``0`` | ``0`` |
|
+-------------------+----------------------+
|
| |vdots| | |vdots| |
|
+-------------------+----------------------+
|
| ``arr.ndim`` | ``arr.ndim`` |
|
+-------------------+----------------------+
|
| ``arr.ndim + 1`` | raise ``AxisError`` |
|
+-------------------+----------------------+
|
|
.. |vdots| unicode:: U+22EE .. Vertical Ellipsis
|
|
Returns
|
-------
|
res : ndarray
|
For NumPy >= 1.10.0 a view of `a` is always returned. For earlier
|
NumPy versions a view of `a` is returned only if the order of the
|
axes is changed, otherwise the input array is returned.
|
|
See Also
|
--------
|
moveaxis : Move array axes to new positions.
|
roll : Roll the elements of an array by a number of positions along a
|
given axis.
|
|
Examples
|
--------
|
>>> a = np.ones((3,4,5,6))
|
>>> np.rollaxis(a, 3, 1).shape
|
(3, 6, 4, 5)
|
>>> np.rollaxis(a, 2).shape
|
(5, 3, 4, 6)
|
>>> np.rollaxis(a, 1, 4).shape
|
(3, 5, 6, 4)
|
|
r z5'%s' arg requires %d <= %s < %d, but %d was passed inr rÜ .)r r2 rG rà rÄ ÚremoveÚinsertr )r| r rÜ ÚnÚmsgr± rx rx ry rW ê s H
|
|
c s t | ttfkr6zt | ¡g} W n tk
|
r4 Y nX t fdd| D } |stt| t| kr rztd ¡ntd| S )aÄ
|
Normalizes an axis argument into a tuple of non-negative integer axes.
|
|
This handles shorthands such as ``1`` and converts them to ``(1,)``,
|
as well as performing the handling of negative indices covered by
|
`normalize_axis_index`.
|
|
By default, this forbids axes from being specified multiple times.
|
|
Used internally by multi-axis-checking logic.
|
|
.. versionadded:: 1.13.0
|
|
Parameters
|
----------
|
axis : int, iterable of int
|
The un-normalized index or indices of the axis.
|
ndim : int
|
The number of dimensions of the array that `axis` should be normalized
|
against.
|
argname : str, optional
|
A prefix to put before the error message, typically the name of the
|
argument.
|
allow_duplicate : bool, optional
|
If False, the default, disallow an axis from being specified twice.
|
|
Returns
|
-------
|
normalized_axes : tuple of int
|
The normalized axis index, such that `0 <= normalized_axis < ndim`
|
|
Raises
|
------
|
AxisError
|
If any axis provided is out of range
|
ValueError
|
If an axis is repeated
|
|
See also
|
--------
|
normalize_axis_index : normalizing a single scalar axis
|
c s g | ]}t | qS rx )r2 r¹ ©Úargnamer rx ry r¸ v s z(normalize_axis_tuple.<locals>.<listcomp>z repeated axis in `{}` argumentz repeated axis)
|
r Útuplerà ÚoperatorÚindexrÅ r« Úsetr¬ Úformat)r r rã rÐ rx râ ry rÓ D s ,rÓ c C s | fS rz rx )r| ÚsourceÚ destinationrx rx ry Ú_moveaxis_dispatcher s rë c sª z
|
| j }W n" tk
|
r, t| } | j }Y nX t | jd t|| jd}t t|krbtd fddt| jD }tt | D ]\}}|
|
||¡ q||}|S )aw
|
Move axes of an array to new positions.
|
|
Other axes remain in their original order.
|
|
.. versionadded:: 1.11.0
|
|
Parameters
|
----------
|
a : np.ndarray
|
The array whose axes should be reordered.
|
source : int or sequence of int
|
Original positions of the axes to move. These must be unique.
|
destination : int or sequence of int
|
Destination positions for each of the original axes. These must also be
|
unique.
|
|
Returns
|
-------
|
result : np.ndarray
|
Array with moved axes. This array is a view of the input array.
|
|
See Also
|
--------
|
transpose : Permute the dimensions of an array.
|
swapaxes : Interchange two axes of an array.
|
|
Examples
|
--------
|
>>> x = np.zeros((3, 4, 5))
|
>>> np.moveaxis(x, 0, -1).shape
|
(4, 5, 3)
|
>>> np.moveaxis(x, -1, 0).shape
|
(5, 3, 4)
|
|
These all achieve the same result:
|
|
>>> np.transpose(x).shape
|
(5, 4, 3)
|
>>> np.swapaxes(x, 0, -1).shape
|
(5, 4, 3)
|
>>> np.moveaxis(x, [0, 1], [-1, -2]).shape
|
(5, 4, 3)
|
>>> np.moveaxis(x, [0, 1, 2], [-1, -2, -3]).shape
|
(5, 4, 3)
|
|
ré rê zJ`source` and `destination` arguments must have the same number of elementsc s g | ]}| kr|qS rx rx )rµ rà ©ré rx ry r¸ Á s z moveaxis.<locals>.<listcomp>) r ÚAttributeErrorr rÓ r r« r¬ rÄ ÚsortedrØ rß )r| ré rê r r} ÚdestÚsrcrÛ rx rì ry rX s 1
|
c C s | |fS rz rx )r| r® ÚaxisaÚaxisbÚaxiscr rx rx ry Ú_cross_dispatcherÊ s rô rª c C s
|
|dk r|fd \}}}t | } t |}t|| jdd}t||jdd}t| |d} t||d}d}| jd dks|jd dkrt|t| d |d j}| jd dks¸|jd dkrÒ|d
|
7 }t|t|d d}t| j |j }t
|
||} | |¡} | |¡}| d }
|
| d } | jd dkr&| d } |d } |d }|jd dkrN|d }| jdkr| jd dkr| d }| d }| d }| jd dkr|jd dkrÀt |
|
|| d | | | 8 } | S |jd dksÔt t | ||d t |
|
||d t||d t |
|
||d || | 8 }næ| jd dks,t |jd dkr¨t | ||d t| | }||8 }t | | |d t |
|
||d ||8 }t |
|
||d t | | |d ||8 }nV|jd dks¼t t | ||d t||d t | | |d t |
|
||d || | 8 }t| d|S )a
|
Return the cross product of two (arrays of) vectors.
|
|
The cross product of `a` and `b` in :math:`R^3` is a vector perpendicular
|
to both `a` and `b`. If `a` and `b` are arrays of vectors, the vectors
|
are defined by the last axis of `a` and `b` by default, and these axes
|
can have dimensions 2 or 3. Where the dimension of either `a` or `b` is
|
2, the third component of the input vector is assumed to be zero and the
|
cross product calculated accordingly. In cases where both input vectors
|
have dimension 2, the z-component of the cross product is returned.
|
|
Parameters
|
----------
|
a : array_like
|
Components of the first vector(s).
|
b : array_like
|
Components of the second vector(s).
|
axisa : int, optional
|
Axis of `a` that defines the vector(s). By default, the last axis.
|
axisb : int, optional
|
Axis of `b` that defines the vector(s). By default, the last axis.
|
axisc : int, optional
|
Axis of `c` containing the cross product vector(s). Ignored if
|
both input vectors have dimension 2, as the return is scalar.
|
By default, the last axis.
|
axis : int, optional
|
If defined, the axis of `a`, `b` and `c` that defines the vector(s)
|
and cross product(s). Overrides `axisa`, `axisb` and `axisc`.
|
|
Returns
|
-------
|
c : ndarray
|
Vector cross product(s).
|
|
Raises
|
------
|
ValueError
|
When the dimension of the vector(s) in `a` and/or `b` does not
|
equal 2 or 3.
|
|
See Also
|
--------
|
inner : Inner product
|
outer : Outer product.
|
ix_ : Construct index arrays.
|
|
Notes
|
-----
|
.. versionadded:: 1.9.0
|
|
Supports full broadcasting of the inputs.
|
|
Examples
|
--------
|
Vector cross-product.
|
|
>>> x = [1, 2, 3]
|
>>> y = [4, 5, 6]
|
>>> np.cross(x, y)
|
array([-3, 6, -3])
|
|
One vector with dimension 2.
|
|
>>> x = [1, 2]
|
>>> y = [4, 5, 6]
|
>>> np.cross(x, y)
|
array([12, -6, -3])
|
|
Equivalently:
|
|
>>> x = [1, 2, 0]
|
>>> y = [4, 5, 6]
|
>>> np.cross(x, y)
|
array([12, -6, -3])
|
|
Both vectors with dimension 2.
|
|
>>> x = [1,2]
|
>>> y = [4,5]
|
>>> np.cross(x, y)
|
array(-3)
|
|
Multiple vector cross-products. Note that the direction of the cross
|
product vector is defined by the *right-hand rule*.
|
|
>>> x = np.array([[1,2,3], [4,5,6]])
|
>>> y = np.array([[4,5,6], [1,2,3]])
|
>>> np.cross(x, y)
|
array([[-3, 6, -3],
|
[ 3, -6, 3]])
|
|
The orientation of `c` can be changed using the `axisc` keyword.
|
|
>>> np.cross(x, y, axisc=0)
|
array([[-3, 3],
|
[ 6, -6],
|
[-3, 3]])
|
|
Change the vector definition of `x` and `y` using `axisa` and `axisb`.
|
|
>>> x = np.array([[1,2,3], [4,5,6], [7, 8, 9]])
|
>>> y = np.array([[7, 8, 9], [4,5,6], [1,2,3]])
|
>>> np.cross(x, y)
|
array([[ -6, 12, -6],
|
[ 0, 0, 0],
|
[ 6, -12, 6]])
|
>>> np.cross(x, y, axisa=0, axisb=0)
|
array([[-24, 48, -24],
|
[-30, 60, -30],
|
[-36, 72, -36]])
|
|
Né rñ )Z
|
msg_prefixrò rª zDincompatible dimensions for cross product
|
(dimension must be 2 or 3))r³ rõ ).r )rõ ró ).r ).r³ r r³ )r¯ )r r2 r rX r r¬ r r« r* r r r r: ÚAssertionErrorÚnegativer )r| r® rñ rò ró r rá r r ÚcpZa0Úa1Úa2Zb0Zb1Zb2Zcp0Zcp1Zcp2Útmprx rx ry rY Î sx r
|
|
|
|
Úlittlec C s t | } t| }d| }|r$t }nt|f| |d}t| D ]P\}}t||d |d|
|f ||d d
¡}|r||f }q>|||< q>|S )aû
|
Return an array representing the indices of a grid.
|
|
Compute an array where the subarrays contain index values 0, 1, ...
|
varying only along the corresponding axis.
|
|
Parameters
|
----------
|
dimensions : sequence of ints
|
The shape of the grid.
|
dtype : dtype, optional
|
Data type of the result.
|
sparse : boolean, optional
|
Return a sparse representation of the grid instead of a dense
|
representation. Default is False.
|
|
.. versionadded:: 1.17
|
|
Returns
|
-------
|
grid : one ndarray or tuple of ndarrays
|
If sparse is False:
|
Returns one array of grid indices,
|
``grid.shape = (len(dimensions),) + tuple(dimensions)``.
|
If sparse is True:
|
Returns a tuple of arrays, with
|
``grid[i].shape = (1, ..., 1, dimensions[i], 1, ..., 1)`` with
|
dimensions[i] in the ith place
|
|
See Also
|
--------
|
mgrid, ogrid, meshgrid
|
|
Notes
|
-----
|
The output shape in the dense case is obtained by prepending the number
|
of dimensions in front of the tuple of dimensions, i.e. if `dimensions`
|
is a tuple ``(r0, ..., rN-1)`` of length ``N``, the output shape is
|
``(N, r0, ..., rN-1)``.
|
|
The subarrays ``grid[k]`` contains the N-D array of indices along the
|
``k-th`` axis. Explicitly::
|
|
grid[k, i0, i1, ..., iN-1] = ik
|
|
Examples
|
--------
|
>>> grid = np.indices((2, 3))
|
>>> grid.shape
|
(2, 2, 3)
|
>>> grid[0] # row indices
|
array([[0, 0, 0],
|
[1, 1, 1]])
|
>>> grid[1] # column indices
|
array([[0, 1, 2],
|
[0, 1, 2]])
|
|
The indices can be used as an index into an array.
|
|
>>> x = np.arange(20).reshape(5, 4)
|
>>> row, col = np.indices((2, 3))
|
>>> x[row, col]
|
array([[0, 1, 2],
|
[4, 5, 6]])
|
|
Note that it would be more straightforward in the above example to
|
extract the required elements directly with ``x[:2, :3]``.
|
|
If sparse is set to true, the grid will be returned in a sparse
|
representation.
|
|
>>> i, j = np.indices((2, 3), sparse=True)
|
>>> i.shape
|
(2, 1)
|
>>> j.shape
|
(1, 3)
|
>>> i # row indices
|
array([[0],
|
[1]])
|
>>> j # column indices
|
array([[0, 1, 2]])
|
|
)r r Nr )rä r« r Ú enumerater rÈ ) Z
|
dimensionsr ÚsparseÚNr r ÚiZdimÚidxrx rx ry r^ s U ÿ
|
©r r c K s |fS rz rx )Úfunctionr r r Úkwargsrx rx ry Ú_fromfunction_dispatcher s r c K s6 |dk r t | |f||d|S t||d}| ||S )a
|
Construct an array by executing a function over each coordinate.
|
|
The resulting array therefore has a value ``fn(x, y, z)`` at
|
coordinate ``(x, y, z)``.
|
|
Parameters
|
----------
|
function : callable
|
The function is called with N parameters, where N is the rank of
|
`shape`. Each parameter represents the coordinates of the array
|
varying along a specific axis. For example, if `shape`
|
were ``(2, 2)``, then the parameters would be
|
``array([[0, 0], [1, 1]])`` and ``array([[0, 1], [0, 1]])``
|
shape : (N,) tuple of ints
|
Shape of the output array, which also determines the shape of
|
the coordinate arrays passed to `function`.
|
dtype : data-type, optional
|
Data-type of the coordinate arrays passed to `function`.
|
By default, `dtype` is float.
|
${ARRAY_FUNCTION_LIKE}
|
|
.. versionadded:: 1.20.0
|
|
Returns
|
-------
|
fromfunction : any
|
The result of the call to `function` is passed back directly.
|
Therefore the shape of `fromfunction` is completely determined by
|
`function`. If `function` returns a scalar value, the shape of
|
`fromfunction` would not match the `shape` parameter.
|
|
See Also
|
--------
|
indices, meshgrid
|
|
Notes
|
-----
|
Keywords other than `dtype` and `like` are passed to `function`.
|
|
Examples
|
--------
|
>>> np.fromfunction(lambda i, j: i, (2, 2), dtype=float)
|
array([[0., 0.],
|
[1., 1.]])
|
|
>>> np.fromfunction(lambda i, j: j, (2, 2), dtype=float)
|
array([[0., 1.],
|
[0., 1.]])
|
|
>>> np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int)
|
array([[ True, False, False],
|
[False, True, False],
|
[False, False, True]])
|
|
>>> np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int)
|
array([[0, 1, 2],
|
[1, 2, 3],
|
[2, 3, 4]])
|
|
Nr r )Ú_fromfunction_with_liker^ )r r r r r Úargsrx rx ry r_ s @ c C s t | |dj||dS )Nr )r} )r rÈ )Úbufr r r} rx rx ry Ú _frombufferR s r c C s" t | tp t| tkp t | tjS )aè
|
Returns True if the type of `element` is a scalar type.
|
|
Parameters
|
----------
|
element : any
|
Input argument, can be of any type and shape.
|
|
Returns
|
-------
|
val : bool
|
True if `element` is a scalar type, False if it is not.
|
|
See Also
|
--------
|
ndim : Get the number of dimensions of an array
|
|
Notes
|
-----
|
If you need a stricter way to identify a *numerical* scalar, use
|
``isinstance(x, numbers.Number)``, as that returns ``False`` for most
|
non-numerical elements such as strings.
|
|
In most cases ``np.ndim(x) == 0`` should be used instead of this function,
|
as that will also return true for 0d arrays. This is how numpy overloads
|
functions in the style of the ``dx`` arguments to `gradient` and the ``bins``
|
argument to `histogram`. Some key differences:
|
|
+--------------------------------------+---------------+-------------------+
|
| x |``isscalar(x)``|``np.ndim(x) == 0``|
|
+======================================+===============+===================+
|
| PEP 3141 numeric objects (including | ``True`` | ``True`` |
|
| builtins) | | |
|
+--------------------------------------+---------------+-------------------+
|
| builtin string and buffer objects | ``True`` | ``True`` |
|
+--------------------------------------+---------------+-------------------+
|
| other builtin objects, like | ``False`` | ``True`` |
|
| `pathlib.Path`, `Exception`, | | |
|
| the result of `re.compile` | | |
|
+--------------------------------------+---------------+-------------------+
|
| third-party objects like | ``False`` | ``True`` |
|
| `matplotlib.figure.Figure` | | |
|
+--------------------------------------+---------------+-------------------+
|
| zero-dimensional numpy arrays | ``False`` | ``True`` |
|
+--------------------------------------+---------------+-------------------+
|
| other numpy arrays | ``False`` | ``False`` |
|
+--------------------------------------+---------------+-------------------+
|
| `list`, `tuple`, and other sequence | ``False`` | ``False`` |
|
| objects | | |
|
+--------------------------------------+---------------+-------------------+
|
|
Examples
|
--------
|
>>> np.isscalar(3.1)
|
True
|
>>> np.isscalar(np.array(3.1))
|
False
|
>>> np.isscalar([3.1])
|
False
|
>>> np.isscalar(False)
|
True
|
>>> np.isscalar('numpy')
|
True
|
|
NumPy supports PEP 3141 numbers:
|
|
>>> from fractions import Fraction
|
>>> np.isscalar(Fraction(5, 17))
|
True
|
>>> from numbers import Number
|
>>> np.isscalar(Number())
|
True
|
|
)Ú
|
isinstanceZgenericr Z
|
ScalarTypeÚnumbersÚNumber)Úelementrx rx ry ra V s
|
L
|
|
ÿ
|
þc C s dd }t | ¡} | dkr&d|p"d S | dkrpt| dd
}t|}|dkrR|nt||}||| | |¡S |dkrdt| dd
S tt| dd
}d|d | kr¾|d8 }d|d | }t|dd
}t|}t||}||| d || | S dS )
|
aÆ
|
Return the binary representation of the input number as a string.
|
|
For negative numbers, if width is not given, a minus sign is added to the
|
front. If width is given, the two's complement of the number is
|
returned, with respect to that width.
|
|
In a two's-complement system negative numbers are represented by the two's
|
complement of the absolute value. This is the most common method of
|
representing signed integers on computers [1]_. A N-bit two's-complement
|
system can represent every integer in the range
|
:math:`-2^{N-1}` to :math:`+2^{N-1}-1`.
|
|
Parameters
|
----------
|
num : int
|
Only an integer decimal number can be used.
|
width : int, optional
|
The length of the returned string if `num` is positive, or the length
|
of the two's complement if `num` is negative, provided that `width` is
|
at least a sufficient number of bits for `num` to be represented in the
|
designated form.
|
|
If the `width` value is insufficient, it will be ignored, and `num` will
|
be returned in binary (`num` > 0) or two's complement (`num` < 0) form
|
with its width equal to the minimum number of bits needed to represent
|
the number in the designated form. This behavior is deprecated and will
|
later raise an error.
|
|
.. deprecated:: 1.12.0
|
|
Returns
|
-------
|
bin : str
|
Binary representation of `num` or two's complement of `num`.
|
|
See Also
|
--------
|
base_repr: Return a string representation of a number in the given base
|
system.
|
bin: Python's built-in binary representation generator of an integer.
|
|
Notes
|
-----
|
`binary_repr` is equivalent to using `base_repr` with base 2, but about 25x
|
faster.
|
|
References
|
----------
|
.. [1] Wikipedia, "Two's complement",
|
https://en.wikipedia.org/wiki/Two's_complement
|
|
Examples
|
--------
|
>>> np.binary_repr(3)
|
'11'
|
>>> np.binary_repr(-3)
|
'-11'
|
>>> np.binary_repr(3, width=4)
|
'0011'
|
|
The two's complement is returned when the input number is negative and
|
width is specified:
|
|
>>> np.binary_repr(-3, width=3)
|
'101'
|
>>> np.binary_repr(-3, width=5)
|
'11101'
|
|
c S s$ | d k r | |k r t jdtdd d S )NzQInsufficient bit width provided. This behavior will raise an error in the future.rõ )Ú
|
stacklevel)ÚwarningsÚwarnÚDeprecationWarning)ÚwidthÚbinwidthrx rx ry Úwarn_if_insufficientï s ýz)binary_repr.<locals>.warn_if_insufficientr Ú0r r³ Nú-Ú1)rå ræ Úbinr« ÚmaxÚzfill)Únumr r Úbinaryr ZoutwidthZposwidthZtwocomprx rx ry rb § s. H
|
ÿ
|
|
|
|
c C s d}|t |krtdn|dk r*tdt| }g }|rV| ||| ¡ || }q6|rh| d| ¡ | dk rz| d¡ d t|pd¡S ) aZ
|
Return a string representation of a number in the given base system.
|
|
Parameters
|
----------
|
number : int
|
The value to convert. Positive and negative values are handled.
|
base : int, optional
|
Convert `number` to the `base` number system. The valid range is 2-36,
|
the default value is 2.
|
padding : int, optional
|
Number of zeros padded on the left. Default is 0 (no padding).
|
|
Returns
|
-------
|
out : str
|
String representation of `number` in `base` system.
|
|
See Also
|
--------
|
binary_repr : Faster version of `base_repr` for base 2.
|
|
Examples
|
--------
|
>>> np.base_repr(5)
|
'101'
|
>>> np.base_repr(6, 5)
|
'11'
|
>>> np.base_repr(7, base=5, padding=3)
|
'00012'
|
|
>>> np.base_repr(10, base=16)
|
'A'
|
>>> np.base_repr(32, base=16)
|
'20'
|
|
Z$0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZz/Bases greater than 36 not handled in base_repr.r³ z+Bases less than 2 not handled in base_repr.r r r Ú )r« r¬ ÚabsÚappendÚjoinÚreversed)ÚnumberÚbaseÚpaddingÚdigitsr r rx rx ry rc s '
|
|
|
c s< t | }|j d krS fdd|jD }t|S d S )Nc s g | ]}t | d qS rÑ )Ú_maketup)rµ Úname©ÚfieldsÚvalrx ry r¸ ^ s z _maketup.<locals>.<listcomp>)r r) Únamesrä )Údescrr* Údtr rx r( ry r& W s r& c C s |fS rz rx )rà r r rx rx ry Ú_identity_dispatcherb s r. c C s0 |dk rt | ||dS ddlm} || ||dS )az
|
Return the identity array.
|
|
The identity array is a square array with ones on
|
the main diagonal.
|
|
Parameters
|
----------
|
n : int
|
Number of rows (and columns) in `n` x `n` output.
|
dtype : data-type, optional
|
Data-type of the output. Defaults to ``float``.
|
${ARRAY_FUNCTION_LIKE}
|
|
.. versionadded:: 1.20.0
|
|
Returns
|
-------
|
out : ndarray
|
`n` x `n` array with its main diagonal set to one,
|
and all other elements 0.
|
|
Examples
|
--------
|
>>> np.identity(3)
|
array([[1., 0., 0.],
|
[0., 1., 0.],
|
[0., 0., 1.]])
|
|
Nr r )Úeye)Ú_identity_with_likerJ r/ )rà r r r/ rx rx ry re f s ! c C s | |fS rz rx ©r| r® ÚrtolÚatolÚ equal_nanrx rx ry Ú_allclose_dispatcher s r5 çñhãµøä>ç:0âyE>c C s t t| ||||d}t|S )aw
|
Returns True if two arrays are element-wise equal within a tolerance.
|
|
The tolerance values are positive, typically very small numbers. The
|
relative difference (`rtol` * abs(`b`)) and the absolute difference
|
`atol` are added together to compare against the absolute difference
|
between `a` and `b`.
|
|
NaNs are treated as equal if they are in the same place and if
|
``equal_nan=True``. Infs are treated as equal if they are in the same
|
place and of the same sign in both arrays.
|
|
Parameters
|
----------
|
a, b : array_like
|
Input arrays to compare.
|
rtol : float
|
The relative tolerance parameter (see Notes).
|
atol : float
|
The absolute tolerance parameter (see Notes).
|
equal_nan : bool
|
Whether to compare NaN's as equal. If True, NaN's in `a` will be
|
considered equal to NaN's in `b` in the output array.
|
|
.. versionadded:: 1.10.0
|
|
Returns
|
-------
|
allclose : bool
|
Returns True if the two arrays are equal within the given
|
tolerance; False otherwise.
|
|
See Also
|
--------
|
isclose, all, any, equal
|
|
Notes
|
-----
|
If the following equation is element-wise True, then allclose returns
|
True.
|
|
absolute(`a` - `b`) <= (`atol` + `rtol` * absolute(`b`))
|
|
The above equation is not symmetric in `a` and `b`, so that
|
``allclose(a, b)`` might be different from ``allclose(b, a)`` in
|
some rare cases.
|
|
The comparison of `a` and `b` uses standard broadcasting, which
|
means that `a` and `b` need not have the same shape in order for
|
``allclose(a, b)`` to evaluate to True. The same is true for
|
`equal` but not `array_equal`.
|
|
`allclose` is not defined for non-numeric data types.
|
`bool` is considered a numeric data-type for this purpose.
|
|
Examples
|
--------
|
>>> np.allclose([1e10,1e-7], [1.00001e10,1e-8])
|
False
|
>>> np.allclose([1e10,1e-8], [1.00001e10,1e-9])
|
True
|
>>> np.allclose([1e10,1e-8], [1.0001e10,1e-9])
|
False
|
>>> np.allclose([1.0, np.nan], [1.0, np.nan])
|
False
|
>>> np.allclose([1.0, np.nan], [1.0, np.nan], equal_nan=True)
|
True
|
|
)r2 r3 r4 )Úallr` Úbool)r| r® r2 r3 r4 r rx rx ry rf s Gc C s | |fS rz rx r1 rx rx ry Ú_isclose_dispatcherâ s r: c C sö dd }t | }t |}|jjdkr<t |d¡}t ||d}t|} t|}
|
t| rjt|
|
rj|||||S | |
|
@ } t| dd} |t| }|t| }||| || ||| | < || || k| | < |rêt |t |@ } | | | | < | d S d S )
|
aW
|
Returns a boolean array where two arrays are element-wise equal within a
|
tolerance.
|
|
The tolerance values are positive, typically very small numbers. The
|
relative difference (`rtol` * abs(`b`)) and the absolute difference
|
`atol` are added together to compare against the absolute difference
|
between `a` and `b`.
|
|
.. warning:: The default `atol` is not appropriate for comparing numbers
|
that are much smaller than one (see Notes).
|
|
Parameters
|
----------
|
a, b : array_like
|
Input arrays to compare.
|
rtol : float
|
The relative tolerance parameter (see Notes).
|
atol : float
|
The absolute tolerance parameter (see Notes).
|
equal_nan : bool
|
Whether to compare NaN's as equal. If True, NaN's in `a` will be
|
considered equal to NaN's in `b` in the output array.
|
|
Returns
|
-------
|
y : array_like
|
Returns a boolean array of where `a` and `b` are equal within the
|
given tolerance. If both `a` and `b` are scalars, returns a single
|
boolean value.
|
|
See Also
|
--------
|
allclose
|
math.isclose
|
|
Notes
|
-----
|
.. versionadded:: 1.7.0
|
|
For finite values, isclose uses the following equation to test whether
|
two floating point values are equivalent.
|
|
absolute(`a` - `b`) <= (`atol` + `rtol` * absolute(`b`))
|
|
Unlike the built-in `math.isclose`, the above equation is not symmetric
|
in `a` and `b` -- it assumes `b` is the reference value -- so that
|
`isclose(a, b)` might be different from `isclose(b, a)`. Furthermore,
|
the default value of atol is not zero, and is used to determine what
|
small values should be considered close to zero. The default value is
|
appropriate for expected values of order unity: if the expected values
|
are significantly smaller than one, it can result in false positives.
|
`atol` should be carefully selected for the use case at hand. A zero value
|
for `atol` will result in `False` if either `a` or `b` is zero.
|
|
`isclose` is not defined for non-numeric data types.
|
`bool` is considered a numeric data-type for this purpose.
|
|
Examples
|
--------
|
>>> np.isclose([1e10,1e-7], [1.00001e10,1e-8])
|
array([ True, False])
|
>>> np.isclose([1e10,1e-8], [1.00001e10,1e-9])
|
array([ True, True])
|
>>> np.isclose([1e10,1e-8], [1.0001e10,1e-9])
|
array([False, True])
|
>>> np.isclose([1.0, np.nan], [1.0, np.nan])
|
array([ True, False])
|
>>> np.isclose([1.0, np.nan], [1.0, np.nan], equal_nan=True)
|
array([ True, True])
|
>>> np.isclose([1e-8, 1e-7], [0.0, 0.0])
|
array([ True, False])
|
>>> np.isclose([1e-100, 1e-7], [0.0, 0.0], atol=0.0)
|
array([False, False])
|
>>> np.isclose([1e-10, 1e-10], [1e-20, 0.0])
|
array([ True, True])
|
>>> np.isclose([1e-10, 1e-10], [1e-20, 0.999999e-10], atol=0.0)
|
array([False, True])
|
c S s^ t ddJ t 8 tt| | ||t| W 5 Q R £ W 5 Q R £ S Q R X W 5 Q R X d S )NÚignore)Úinvalid)rH rI Z
|
less_equalr )ÚxÚyr3 r2 rx rx ry Ú
|
within_tol7 s zisclose.<locals>.within_tolÚmg ð?r T)r~ rx N)
|
r r Úkindr r, Úisfiniter8 rQ rR Úisnan)r| r® r2 r3 r4 r? r= r> r- ZxfinZyfinZfiniteZcondZboth_nanrx rx ry r` æ s( Q c C s | |fS rz rx )rù rú r4 rx rx ry Ú_array_equal_dispatcherc s rD c C s zt | t | } }W n tk
|
r, Y dS X | j|jkr>dS |sVtt | |k ¡ S t| t| }}||k ¡ sxdS tt | | || k ¡ S )a
|
True if two arrays have the same shape and elements, False otherwise.
|
|
Parameters
|
----------
|
a1, a2 : array_like
|
Input arrays.
|
equal_nan : bool
|
Whether to compare NaN's as equal. If the dtype of a1 and a2 is
|
complex, values will be considered equal if either the real or the
|
imaginary component of a given value is ``nan``.
|
|
.. versionadded:: 1.19.0
|
|
Returns
|
-------
|
b : bool
|
Returns True if the arrays are equal.
|
|
See Also
|
--------
|
allclose: Returns True if two arrays are element-wise equal within a
|
tolerance.
|
array_equiv: Returns True if input arrays are shape consistent and all
|
elements equal.
|
|
Examples
|
--------
|
>>> np.array_equal([1, 2], [1, 2])
|
True
|
>>> np.array_equal(np.array([1, 2]), np.array([1, 2]))
|
True
|
>>> np.array_equal([1, 2], [1, 2, 3])
|
False
|
>>> np.array_equal([1, 2], [1, 4])
|
False
|
>>> a = np.array([1, np.nan])
|
>>> np.array_equal(a, a)
|
False
|
>>> np.array_equal(a, a, equal_nan=True)
|
True
|
|
When ``equal_nan`` is True, complex values with nan components are
|
considered equal if either the real *or* the imaginary components are nan.
|
|
>>> a = np.array([1 + 1j])
|
>>> b = a.copy()
|
>>> a.real = np.nan
|
>>> b.imag = np.nan
|
>>> np.array_equal(a, b, equal_nan=True)
|
True
|
F)r r r r9 r8 rC )rù rú r4 Za1nanZa2nanrx rx ry r\ g s 6 c C s | |fS rz rx ©rù rú rx rx ry Ú_array_equiv_dispatcher® s rF c C sj zt | t | } }W n tk
|
r, Y dS X zt | |¡ W n tk
|
rT Y dS X tt | |k ¡ S )aå
|
Returns True if input arrays are shape consistent and all elements equal.
|
|
Shape consistent means they are either the same shape, or one input array
|
can be broadcasted to create the same shape as the other one.
|
|
Parameters
|
----------
|
a1, a2 : array_like
|
Input arrays.
|
|
Returns
|
-------
|
out : bool
|
True if equivalent, False otherwise.
|
|
Examples
|
--------
|
>>> np.array_equiv([1, 2], [1, 2])
|
True
|
>>> np.array_equiv([1, 2], [1, 3])
|
False
|
|
Showing the shape equivalence:
|
|
>>> np.array_equiv([1, 2], [[1, 2], [1, 2]])
|
True
|
>>> np.array_equiv([1, 2], [[1, 2, 1, 2], [1, 2, 1, 2]])
|
False
|
|
>>> np.array_equiv([1, 2], [[1, 2], [1, 3]])
|
False
|
|
F)r r r r r9 r8 rE rx rx ry r] ² s $c C s2 t t}t| d}|D ]}||krt |¡ qd S )NÚ__all__)rç rG Úgetattrr )rK ÚexistingZmallr| rx rx ry Ú
|
extend_allè s
|
|
rJ )Ú*)Ú fromnumeric)Ú
|
arrayprint)Ú_asarray)Ú _ufunc_config)NNNN)Nr TN)NN)Nr )NNNN)Nr TN)NN)Nr )NNNN)Nr TN)N)N)N)r¨ )N)rr )N)N)N)r³ )N)N)N)r )NF)NNNN)rª rª rª N)N)r³ r )N)N)NNN)r6 r7 F)NNN)r6 r7 F)N)F)£Ú functoolsrÖ rå Úsysr r rJ 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 r r r r r r! r" r# r$ r% r& r' r( r) r* r+ r, r- r. r/ r0 r1 r2 r3 r4 r5 r6 r7 r8 r9 r: r; r< r= r> r? r@ rA rB rC rD rE Ú _exceptionsrF rG rO rH rI rp r rM rL ÚpartialZarray_function_dispatchrG ÚRuntimeWarningrq r rQ r rd r r rR r rr r r rs r rN rP r rO r¢ rg r§ rS r© rT r° rU r² rZ rÏ rV rÝ rW rÓ rë rX rô rY Ú byteorderr[ rÆ r^ r Úfloatr_ r r ra rb rc r& r. re r0 r5 rf r: r` rD r\ rF r] rh ri rj rk rl rm rn ro rJ rL rM rN rx rx rx ry Ú<module> sð Ì ÿ î
|
D: ÿþ
|
B9 ÿþ
|
EI
|
C
|
1
|
(
|
I
|
b
|
W
|
A
|
j
|
Y
|
;
|
F
|
J
|
fE ÿþ
|
P r < & ÿþ
|
J
|
|
|
F
|
/
|
