($+Ǔ H d Z ddlZddlmZ ddlmZmZ g dZ G d d Z d Z
dd Z dddd d
Z ee dd d d d Z
d ZddZ eed dd Zd Z ed d ZdddZ eed d dd ZdS ) z
Utilities that manipulate strides to achieve desirable effects.
An explanation of strides can be found in the "ndarray.rst" file in the
NumPy reference guide.
N)normalize_axis_tuple)array_function_dispatch
set_module) broadcast_tobroadcast_arraysbroadcast_shapesc e Zd ZdZddZdS )
DummyArrayzDummy object that just exists to hang __array_interface__ dictionaries
and possibly keep alive a reference to a base array.
Nc " || _ || _ d S N)__array_interface__base)self interfacer s k/builddir/build/BUILD/cloudlinux-venv-1.0.10/venv/lib64/python3.11/site-packages/numpy/lib/stride_tricks.py__init__zDummyArray.__init__ s #, r )__name__
__module__ __qualname____doc__r r r r
r
s2 r r
c t | t | ur?| t | }|j r| | |S )N)type)r view__array_finalize__)original_array new_arrays r _maybe_view_as_subclassr s_ N4 ??22 NN^(<(`_.
As a rough estimate, a sliding window approach with an input size of `N`
and a window size of `W` will scale as `O(N*W)` where frequently a special
algorithm can achieve `O(N)`. That means that the sliding window variant
for a window size of 100 can be a 100 times slower than a more specialized
version.
Nevertheless, for small window sizes, when no custom algorithm exists, or
as a prototyping and developing tool, this function can be a good solution.
Examples
--------
>>> x = np.arange(6)
>>> x.shape
(6,)
>>> v = sliding_window_view(x, 3)
>>> v.shape
(4, 3)
>>> v
array([[0, 1, 2],
[1, 2, 3],
[2, 3, 4],
[3, 4, 5]])
This also works in more dimensions, e.g.
>>> i, j = np.ogrid[:3, :4]
>>> x = 10*i + j
>>> x.shape
(3, 4)
>>> x
array([[ 0, 1, 2, 3],
[10, 11, 12, 13],
[20, 21, 22, 23]])
>>> shape = (2,2)
>>> v = sliding_window_view(x, shape)
>>> v.shape
(2, 3, 2, 2)
>>> v
array([[[[ 0, 1],
[10, 11]],
[[ 1, 2],
[11, 12]],
[[ 2, 3],
[12, 13]]],
[[[10, 11],
[20, 21]],
[[11, 12],
[21, 22]],
[[12, 13],
[22, 23]]]])
The axis can be specified explicitly:
>>> v = sliding_window_view(x, 3, 0)
>>> v.shape
(1, 4, 3)
>>> v
array([[[ 0, 10, 20],
[ 1, 11, 21],
[ 2, 12, 22],
[ 3, 13, 23]]])
The same axis can be used several times. In that case, every use reduces
the corresponding original dimension:
>>> v = sliding_window_view(x, (2, 3), (1, 1))
>>> v.shape
(3, 1, 2, 3)
>>> v
array([[[[ 0, 1, 2],
[ 1, 2, 3]]],
[[[10, 11, 12],
[11, 12, 13]]],
[[[20, 21, 22],
[21, 22, 23]]]])
Combining with stepped slicing (`::step`), this can be used to take sliding
views which skip elements:
>>> x = np.arange(7)
>>> sliding_window_view(x, 5)[:, ::2]
array([[0, 2, 4],
[1, 3, 5],
[2, 4, 6]])
or views which move by multiple elements
>>> x = np.arange(7)
>>> sliding_window_view(x, 3)[::2, :]
array([[0, 1, 2],
[2, 3, 4],
[4, 5, 6]])
A common application of `sliding_window_view` is the calculation of running
statistics. The simplest example is the
`moving average `_:
>>> x = np.arange(6)
>>> x.shape
(6,)
>>> v = sliding_window_view(x, 3)
>>> v.shape
(4, 3)
>>> v
array([[0, 1, 2],
[1, 2, 3],
[2, 3, 4],
[3, 4, 5]])
>>> moving_average = v.mean(axis=-1)
>>> moving_average
array([1., 2., 3., 4.])
Note that a sliding window approach is often **not** optimal (see Notes).
Fr! r z-`window_shape` cannot contain negative valuesNzOSince axis is `None`, must provide window_shape for all dimensions of `x`; got z' window_shape elements and `x.ndim` is .T)allow_duplicatez8Must provide matching length window_shape and axis; got z window_shape elements and z axes elements.c 3 2 K | ]}j | V d S r )r% ).0axr. s r z&sliding_window_view..F s) #A#AbAIbM#A#A#A#A#A#Ar z4window shape cannot be larger than input array shape )r% r$ r# r- )r& iterabler) r' any
ValueErrorrangendimlenr r% listr$ zipr/ ) r. r1 r2 r# r- window_shape_array out_stridesx_shape_trimmedr9 dim out_shapes ` r sliding_window_viewrI { sM h {<00)E,'''& e,,,A,// v 1$%% JHIII |U16]]## | D ) ) :$' $5$5 : : 12 : : : ; ;
; * $D!&$GGG | D ) ) H*-l*;*; H H-0YY H H H I I
I )e#A#A#A#AD#A#A#A A AAK 17mmOt\** ' 'C 2 $ $ FH H
HsQw&o&& 5I aI !Y 8 8 8 8r c t j | rt | n|f}t j | d| } |s| j rt d t
d |D rt d g }t j | fg d|z dg|d }|5 |j d
}d d d n # 1 swxY w Y t | | }|s$| j
j rd |j
_ d |j
_
|S ) NFr! z/cannot broadcast a non-scalar to a scalar arrayc 3 " K | ]
}|d k V dS )r Nr )r8 sizes r r: z _broadcast_to..Y s&
&
&4!8
&
&
&
&
&
&r z4all elements of broadcast shape must be non-negative) multi_indexrefs_ok zerosize_okreadonlyC)r, op_flags itershapeorderr T)r& r< r) r' r$ r> r= nditeritviewsr r, _writeable_no_warnr- _warn_on_write)r' r$ r# rP extrasit broadcastresults r
_broadcast_tor] T sm K . . >> x = np.array([1, 2, 3])
>>> np.broadcast_to(x, (3, 3))
array([[1, 2, 3],
[1, 2, 3],
[1, 2, 3]])
Tr# rP r] r_ s r r r o s \ UT B B BBr c t j | dd }t dt | d D ]4}t d|j }t j |g| ||dz R }5|j S )ztReturns the shape of the arrays that would result from broadcasting the
supplied arrays against each other.
N r )r& r[ r? rA r r$ )argsbposs r _broadcast_shaperl sy d3B3i ARTB'' 3 3
AG $ $ L 2T#sRx. 1 2 2 2 7Nr c , d | D }t | S )a
Broadcast the input shapes into a single shape.
:ref:`Learn more about broadcasting here `.
.. versionadded:: 1.20.0
Parameters
----------
`*args` : tuples of ints, or ints
The shapes to be broadcast against each other.
Returns
-------
tuple
Broadcasted shape.
Raises
------
ValueError
If the shapes are not compatible and cannot be broadcast according
to NumPy's broadcasting rules.
See Also
--------
broadcast
broadcast_arrays
broadcast_to
Examples
--------
>>> np.broadcast_shapes((1, 2), (3, 1), (3, 2))
(3, 2)
>>> np.broadcast_shapes((6, 7), (5, 6, 1), (7,), (5, 1, 7))
(5, 6, 7)
c : g | ]}t j |g S ))r+ )r& empty)r8 r. s r
z$broadcast_shapes.. s'
2
2
2bhq###
2
2
2r )rl )ri arrayss r r r s# N 3
2T
2
2
2F V $$r )r# c |S r r )r# ri s r _broadcast_arrays_dispatcherrs s Kr c fd|D }t | t fd|D r|S fd|D S )a=
Broadcast any number of arrays against each other.
Parameters
----------
`*args` : array_likes
The arrays to broadcast.
subok : bool, optional
If True, then sub-classes will be passed-through, otherwise
the returned arrays will be forced to be a base-class array (default).
Returns
-------
broadcasted : list of arrays
These arrays are views on the original arrays. They are typically
not contiguous. Furthermore, more than one element of a
broadcasted array may refer to a single memory location. If you need
to write to the arrays, make copies first. While you can set the
``writable`` flag True, writing to a single output value may end up
changing more than one location in the output array.
.. deprecated:: 1.17
The output is currently marked so that if written to, a deprecation
warning will be emitted. A future version will set the
``writable`` flag False so writing to it will raise an error.
See Also
--------
broadcast
broadcast_to
broadcast_shapes
Examples
--------
>>> x = np.array([[1,2,3]])
>>> y = np.array([[4],[5]])
>>> np.broadcast_arrays(x, y)
[array([[1, 2, 3],
[1, 2, 3]]), array([[4, 4, 4],
[5, 5, 5]])]
Here is a useful idiom for getting contiguous copies instead of
non-contiguous views.
>>> [np.array(a) for a in np.broadcast_arrays(x, y)]
[array([[1, 2, 3],
[1, 2, 3]]), array([[4, 4, 4],
[5, 5, 5]])]
c > g | ]}t j |d S )Fr! )r& r' )r8 _mr# s r rp z$broadcast_arrays.. s* A A AbBHRe5 1 1 1 A A Ar c 3 . K | ]}|j k V d S r )r$ )r8 r' r$ s r r: z#broadcast_arrays.. s*
2
2E5;%
2
2
2
2
2
2r c 6 g | ]}t |d S )Frd re )r8 r' r$ r# s r rp z$broadcast_arrays.." s:
%ee D D D r )rl all)r# ri r$ s ` @r r r s t B A A AD A A AD d #E
2
2
2
2T
2
2
222 r )NNFTr )F)r ra r& numpy.core.numericr numpy.core.overridesr r __all__r
r r/ r3 rI r] r` r rl r rs r r r r r} s 3 3 3 3 3 3 D D D D D D D D
B
B
B
M M M M`*.$
899U8 #uU8 U8 U8 U8 :9U8p . 1'BBB-C -C -C CB-C` " G'% '% '%T /3 5gFFF"' B B B B GFB B B r