KhiFNSrSSKrSSKJr SSKJrJr /SQr"SS5r Sr \"S 5SS j5r SSSS .S jjr \"\ S S9SS S S .Sjj5r SrSSjr\"\SS9SSj5rSr\R$"/5r\"S5S5rSS.Sjr\"\SS9S S.Sj5rg)z Utilities that manipulate strides to achieve desirable effects. An explanation of strides can be found in the :ref:`arrays.ndarray`. N)normalize_axis_tuple)array_function_dispatch set_module) broadcast_tobroadcast_arraysbroadcast_shapesc"\rSrSrSrSSjrSrg) DummyArrayz|Dummy object that just exists to hang __array_interface__ dictionaries and possibly keep alive a reference to a base array. NcXlX lgN__array_interface__base)self interfacers O/var/www/html/env/lib/python3.13/site-packages/numpy/lib/_stride_tricks_impl.py__init__DummyArray.__init__s #,  rr )__name__ __module__ __qualname____firstlineno____doc__r__static_attributes__rrr r s rr c[U5[U5La:UR[U5S9nUR(aURU5 U$)N)type)rview__array_finalize__)original_array new_arrays r_maybe_view_as_subclassr$sI N4 ?2NN^(`_. 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 -------- >>> import numpy as np >>> from numpy.lib.stride_tricks import sliding_window_view >>> 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). Nr&rz-`window_shape` cannot contain negative valueszOSince 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.c3B># UHnTRUv M g7fr )r*).0axr3s r &sliding_window_view..Fs#ADbAIIbMDsz4window shape cannot be larger than input array shape)r*r)r(r2)r+iterabler.r,any ValueErrorrangendimlenrr*listr)zipr4) r3r6r7r(r2window_shape_array out_stridesx_shape_trimmedr?dim out_shapes ` rsliding_window_viewrPwsp{{<00,'& U+A,/ vv 1$%%HII |U166]# | D ) $$' $5#67001xq:; ; * $D!&&$G | D ) **-l*;)<=--0YKHI I))e#AD#AAAK177mOt*   $FH HsQw& + o&5I a! 88rcF[R"U5(a [U5OU4n[R"USUS9nU(dUR(a [ S5e[ SU55(a [ S5e/n[R"U4/SQU-S/USS9nU URS nSSS5 [UW5nU(d=URR(a"S URl S URl U$!,(df  N`=f) Nr&z/cannot broadcast a non-scalar to a scalar arrayc3*# UH oS:v M g7f)rNr)r>sizes rr@ _broadcast_to..Ys &!8sz4all elements of broadcast shape must be non-negative) multi_indexrefs_ok zerosize_okreadonlyC)r1op_flags itershapeorderrT)r+rCr.r,r)rErDnditeritviewsr$r1_writeable_no_warnr2_warn_on_write)r,r)r(rXextrasit broadcastresults r _broadcast_toreTsKK..E%LUHE HHUU 3E U[[JKK & &&&$% % F  AFJc ;B JJqM  %UI 6F  66!% &* # M s (D D cU4$r rr,r)r(s r_broadcast_to_dispatcherrhks 8Ornumpyc[XUSS9$)aBroadcast an array to a new shape. Parameters ---------- array : array_like The array to broadcast. shape : tuple or int The shape of the desired array. A single integer ``i`` is interpreted as ``(i,)``. subok : bool, optional If True, then sub-classes will be passed-through, otherwise the returned array will be forced to be a base-class array (default). Returns ------- broadcast : array A readonly view on the original array with the given shape. It is typically not contiguous. Furthermore, more than one element of a broadcasted array may refer to a single memory location. Raises ------ ValueError If the array is not compatible with the new shape according to NumPy's broadcasting rules. See Also -------- broadcast broadcast_arrays broadcast_shapes Examples -------- >>> import numpy as np >>> x = np.array([1, 2, 3]) >>> np.broadcast_to(x, (3, 3)) array([[1, 2, 3], [1, 2, 3], [1, 2, 3]]) Tr(rX)rergs rrrosV UT BBrc[R"USS6n[S[U5S5H5n[ SUR 5n[R"U/XUS-Q76nM7 UR $)zlReturns the shape of the arrays that would result from broadcasting the supplied arrays against each other. N r)r+rcrFrHrr))argsbposs r_broadcast_shaperrsh d3Bi ARTB' AGG $ LL 2TsRx1 2 ( 77NrcnUVs/sHn[R"U[S9PM nn[U6$s snf)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 -------- >>> import numpy as np >>> 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) )r0)r+empty _size0_dtyperr)ror3arrayss rrrs4P8< >> import numpy as np >>> 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]])] Nr&Frk)r+r,rrr)rer.)r(ro_mr)r,rds rrrsz<@ @4RBHHRd% 04D @ d #E,01+/%{{e+e UUKL+/ 1 = A1s A''A,)NNFTr )F)rrir+numpy._core.numericrnumpy._core.overridesrr__all__r r$r4r8rPrerhrrrr0rurrxrrrrr~s 4E B  %&I'IX*.$ #,EW8#uW8W8t.1'B*CC*CZ"xx|  G(%(%V/35gF"'CGCr