DŽgF*dZddlZddlmZddlmZmZgdZGddZ dZ ed dd Z dddd d Z ee d dd d d dZ dZddZeedddZdZeddZdddZeedd ddZy)z Utilities that manipulate strides to achieve desirable effects. An explanation of strides can be found in the :ref:`arrays.ndarray`. Functions --------- .. autosummary:: :toctree: generated/ N)normalize_axis_tuple)array_function_dispatch set_module) broadcast_tobroadcast_arraysbroadcast_shapesceZdZdZddZy) DummyArrayzDummy object that just exists to hang __array_interface__ dictionaries and possibly keep alive a reference to a base array. Nc ||_||_yN)__array_interface__base)self interfacers e/home/mcse/projects/flask_80/flask-venv/lib/python3.12/site-packages/numpy/lib/_stride_tricks_impl.py__init__zDummyArray.__init__s#,  r )__name__ __module__ __qualname____doc__rrrr r s rr ct|t|ur8|jt|}|jr|j||S)N)type)rview__array_finalize__)original_array new_arrays r_maybe_view_as_subclassrsI 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 -------- >>> 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.c3<K|]}j|ywr )r%).0axr.s r z&sliding_window_view..Os#AbAIIbM#Az4window shape cannot be larger than input array shape)r%r$r#r-)r&iterabler)r'any ValueErrorrangendimlenrr%listr$zipr/) r.r1r2r#r-window_shape_array out_stridesx_shape_trimmedr:dim out_shapes ` rsliding_window_viewrKsn{{<0,'& U+A,/ vv 1$%HII |U166]# | D ) $$' $5#67001xq:; ; $D!&&$G | D ) **-l*;)<=--0YKHI I))e#AD#AAAK177mOt\*'C 2  $FH HsQw& ' o&5I aI!Y 88rctj|r t|n|f}tj|d|}|s|jr t dt d|Dr t dg}tj|fgd|zdg|d}|5|jd }dddt|}|s8|jjr"d |j_ d |j_ |S#1swYQxYw) Nr!z/cannot broadcast a non-scalar to a scalar arrayc3&K|] }|dk yw)rNr)r9sizes rr;z _broadcast_to..bs &4!8 &sz4all elements of broadcast shape must be non-negative) multi_indexrefs_ok zerosize_okreadonlyC)r,op_flags itershapeorderrT)r&r>r)r'r$r@r?nditeritviewsrr,_writeable_no_warnr-_warn_on_write)r'r$r#rRextrasit broadcastresults r _broadcast_tor_]sKK.E%LUHE HHUU 3E U[[JKK & &&$% % F  AFJc ;B "JJqM "%UI 6F  66!% &* # M""s C77Dc|fSr rr'r$r#s r_broadcast_to_dispatcherrbts 8Ornumpyc t|||dS)aaBroadcast 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 Notes ----- .. versionadded:: 1.10.0 Examples -------- >>> x = np.array([1, 2, 3]) >>> np.broadcast_to(x, (3, 3)) array([[1, 2, 3], [1, 2, 3], [1, 2, 3]]) Tr#rRr_ras rrrxs\ UT BBrctj|dd}tdt|dD]4}t d|j }tj|g|||dz}6|j S)ztReturns the shape of the arrays that would result from broadcasting the supplied arrays against each other. N r)r&r]rArCrr$)argsbposs r_broadcast_shapermso d3Bi ARTB'3 AGG $ LL 2T#sRx1 2 3 77Nrcd|Dcgc]}tj|g}}t|Scc}w)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) )r+)r&emptyrm)rjr.arrayss rrrs3N.2 2bhhq# 2F 2 V $$3s-)r#c|Sr r)r#rjs r_broadcast_arrays_dispatcherrrs Krctfd|D}t|tfd|Dr|Stfd|DS)aJ 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 : tuple 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]])] c3NK|]}tj|dyw)Nr!)r&r')r9_mr#s rr;z#broadcast_arrays..%s!E""4u55Es"%c3<K|]}|jk(ywr )r$)r9r'r$s rr;z#broadcast_arrays..)s 2E5;;%  2r<c3<K|]}t|dyw)FreNrf)r9r'r$r#s rr;z#broadcast_arrays..-s'$ue55II$r<)r)rmall)r#rjr$s` @rrrsMx EE ED d #E 2T 22 $"$ $$r)NNFTr )F)rrcr&numpy._core.numericrnumpy._core.overridesrr__all__r rr/r3rKr_rbrrmrrrrrrrr|s 4E B  %&M'M`*.$ #,EV8#uV8V8r.1'B-CC-C`" G'%'%T/35gF"'D$GD$r