Ë
|
KñúhÈ ã óØ g d ¢Z ddlZddlZddlZddlmZ ddlmZ ddlm Z ddl
|
m Z m Z m Z ej e j d¬ « Zd
|
Z ee« d « Zd Z ee« d « Zd Z ee« d « Zd ZddddZ ee« dddd« Z ee« dddd« Zd(ddddZ ee« d)dddd« ZdddZ ee « ddd« Z e ej> dej> « Z e ejB dejB « Z" e ejF dejF « Z$d Z%g fd Z&d Z'd Z(d Z)d*d!Z*d*d"Z+d# Z, ee,« d$ « Z-d% Z.d& Z/d' Z0y)+)Ú
|
atleast_1dÚ
|
atleast_2dÚ
|
atleast_3dÚblockÚhstackÚstackÚunstackÚvstacké Né )Ú fromnumeric)Únumeric)Ú overrides)ÚarrayÚ
|
asanyarrayÚnormalize_axis_indexÚnumpy)Úmodulec ó | S ©N© ©Úaryss úIH:\Change_password\venv_build\Lib\site-packages\numpy/_core/shape_base.pyÚ_atleast_1d_dispatcherr ó Ø Kó c ó t | « dk( r0t | d « }|j dk( r|j d« }|S g }| D ]> }t |« }|j dk( r|j d« }|j |« @ t |« S )a7
|
Convert inputs to arrays with at least one dimension.
|
|
Scalar inputs are converted to 1-dimensional arrays, whilst
|
higher-dimensional inputs are preserved.
|
|
Parameters
|
----------
|
arys1, arys2, ... : array_like
|
One or more input arrays.
|
|
Returns
|
-------
|
ret : ndarray
|
An array, or tuple of arrays, each with ``a.ndim >= 1``.
|
Copies are made only if necessary.
|
|
See Also
|
--------
|
atleast_2d, atleast_3d
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> np.atleast_1d(1.0)
|
array([1.])
|
|
>>> x = np.arange(9.0).reshape(3,3)
|
>>> np.atleast_1d(x)
|
array([[0., 1., 2.],
|
[3., 4., 5.],
|
[6., 7., 8.]])
|
>>> np.atleast_1d(x) is x
|
True
|
|
>>> np.atleast_1d(1, [3, 4])
|
(array([1]), array([3, 4]))
|
|
r r
|
)Úlenr ÚndimÚreshapeÚappendÚtuple)r ÚresultÚresÚarys r r r s ôR 4yA~ÜD GÓ$Ø ;;!Ò Ø^^ AÓ&FØ Ø
|
CØò ÜC Ø ;;!Ò Ø^^ AÓ&FØ
|
|
6Õð ô
|
:Ðr c ó | S r r r s r Ú_atleast_2d_dispatcherr' L r r c ó g }| D ]i }t |« }|j dk( r|j dd« }n)|j dk( r|t j dd
f }n|}|j |« k t |« dk( r|d S t |« S )ax
|
View inputs as arrays with at least two dimensions.
|
|
Parameters
|
----------
|
arys1, arys2, ... : array_like
|
One or more array-like sequences. Non-array inputs are converted
|
to arrays. Arrays that already have two or more dimensions are
|
preserved.
|
|
Returns
|
-------
|
res, res2, ... : ndarray
|
An array, or tuple of arrays, each with ``a.ndim >= 2``.
|
Copies are avoided where possible, and views with two or more
|
dimensions are returned.
|
|
See Also
|
--------
|
atleast_1d, atleast_3d
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> np.atleast_2d(3.0)
|
array([[3.]])
|
|
>>> x = np.arange(3.0)
|
>>> np.atleast_2d(x)
|
array([[0., 1., 2.]])
|
>>> np.atleast_2d(x).base is x
|
True
|
|
>>> np.atleast_2d(1, [1, 2], [[1, 2]])
|
(array([[1]]), array([[1, 2]]), array([[1, 2]]))
|
|
r
|
r N©r r r Ú_nxÚnewaxisr! r r" ©r r$ r% r# s r r r P s ðN CØò ÜoØ 88q=Ø[[ AÓ&FØ XX]Ø¢a Ñ(FàFØ
|
|
6Õðô 3x1}Ø1v äSzÐr c ó | S r r r s r Ú_atleast_3d_dispatcherr. r r c ó g }| D ]£ }t |« }|j dk( r|j ddd« }nb|j dk( r'|t j dd
t j f }n,|j dk( r|dd
dd
t j f }n|}|j |« ¥ t |« dk( r|d S t |« S )a
|
View inputs as arrays with at least three dimensions.
|
|
Parameters
|
----------
|
arys1, arys2, ... : array_like
|
One or more array-like sequences. Non-array inputs are converted to
|
arrays. Arrays that already have three or more dimensions are
|
preserved.
|
|
Returns
|
-------
|
res1, res2, ... : ndarray
|
An array, or tuple of arrays, each with ``a.ndim >= 3``. Copies are
|
avoided where possible, and views with three or more dimensions are
|
returned. For example, a 1-D array of shape ``(N,)`` becomes a view
|
of shape ``(1, N, 1)``, and a 2-D array of shape ``(M, N)`` becomes a
|
view of shape ``(M, N, 1)``.
|
|
See Also
|
--------
|
atleast_1d, atleast_2d
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> np.atleast_3d(3.0)
|
array([[[3.]]])
|
|
>>> x = np.arange(3.0)
|
>>> np.atleast_3d(x).shape
|
(1, 3, 1)
|
|
>>> x = np.arange(12.0).reshape(4,3)
|
>>> np.atleast_3d(x).shape
|
(4, 3, 1)
|
>>> np.atleast_3d(x).base is x.base # x is a reshape, so not base itself
|
True
|
|
>>> for arr in np.atleast_3d([1, 2], [[1, 2]], [[[1, 2]]]):
|
... print(arr, arr.shape) # doctest: +SKIP
|
...
|
[[[1]
|
[2]]] (1, 2, 1)
|
[[[1]
|
[2]]] (1, 2, 1)
|
[[[1 2]]] (1, 1, 2)
|
|
r
|
r Né r) r, s r r r s´ ðf CØò
|
ÜoØ 88q=Ø[[ A qÓ)FØ XX]Ø¢a¬¯©Ð4Ñ5FØ XX]ØAs{{Ð*Ñ+FàFØ
|
|
6Õð
|
ô 3x1}Ø1v äSzÐr c óF t | d« s t d« t | « S )NÚ __getitem__zJarrays to stack must be passed as a "sequence" type such as list or tuple.)ÚhasattrÚ TypeErrorr" )Úarrayss r Ú _arrays_for_stack_dispatcherr6 Ð s* Ü 6=Ô )Üð 1ó 2ð 2ô =Ðr ©ÚdtypeÚcastingc ó t | « S r )r6 )Útupr8 r9 s r Ú_vhstack_dispatcherr< Ø s Ü '¨Ó ,Ð,r Ú same_kindc ój t | }t |t « s|f}t j |d||¬« S )a
|
Stack arrays in sequence vertically (row wise).
|
|
This is equivalent to concatenation along the first axis after 1-D arrays
|
of shape `(N,)` have been reshaped to `(1,N)`. Rebuilds arrays divided by
|
`vsplit`.
|
|
This function makes most sense for arrays with up to 3 dimensions. For
|
instance, for pixel-data with a height (first axis), width (second axis),
|
and r/g/b channels (third axis). The functions `concatenate`, `stack` and
|
`block` provide more general stacking and concatenation operations.
|
|
Parameters
|
----------
|
tup : sequence of ndarrays
|
The arrays must have the same shape along all but the first axis.
|
1-D arrays must have the same length. In the case of a single
|
array_like input, it will be treated as a sequence of arrays; i.e.,
|
each element along the zeroth axis is treated as a separate array.
|
|
dtype : str or dtype
|
If provided, the destination array will have this dtype. Cannot be
|
provided together with `out`.
|
|
.. versionadded:: 1.24
|
|
casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
|
Controls what kind of data casting may occur. Defaults to 'same_kind'.
|
|
.. versionadded:: 1.24
|
|
Returns
|
-------
|
stacked : ndarray
|
The array formed by stacking the given arrays, will be at least 2-D.
|
|
See Also
|
--------
|
concatenate : Join a sequence of arrays along an existing axis.
|
stack : Join a sequence of arrays along a new axis.
|
block : Assemble an nd-array from nested lists of blocks.
|
hstack : Stack arrays in sequence horizontally (column wise).
|
dstack : Stack arrays in sequence depth wise (along third axis).
|
column_stack : Stack 1-D arrays as columns into a 2-D array.
|
vsplit : Split an array into multiple sub-arrays vertically (row-wise).
|
unstack : Split an array into a tuple of sub-arrays along an axis.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> a = np.array([1, 2, 3])
|
>>> b = np.array([4, 5, 6])
|
>>> np.vstack((a,b))
|
array([[1, 2, 3],
|
[4, 5, 6]])
|
|
>>> a = np.array([[1], [2], [3]])
|
>>> b = np.array([[4], [5], [6]])
|
>>> np.vstack((a,b))
|
array([[1],
|
[2],
|
[3],
|
[4],
|
[5],
|
[6]])
|
|
r
|
r7 )r Ú
|
isinstancer" r* Ú concatenate©r; r8 r9 Úarrss r r r Ü s5 ôJ sÐ DÜ dEÔ "ØwÜ ??4 ¨%¸Ô AÐAr c óÄ t | }t |t « s|f}|r+|d j dk( rt j
|
|d||¬« S t j
|
|d||¬« S )aÒ
|
Stack arrays in sequence horizontally (column wise).
|
|
This is equivalent to concatenation along the second axis, except for 1-D
|
arrays where it concatenates along the first axis. Rebuilds arrays divided
|
by `hsplit`.
|
|
This function makes most sense for arrays with up to 3 dimensions. For
|
instance, for pixel-data with a height (first axis), width (second axis),
|
and r/g/b channels (third axis). The functions `concatenate`, `stack` and
|
`block` provide more general stacking and concatenation operations.
|
|
Parameters
|
----------
|
tup : sequence of ndarrays
|
The arrays must have the same shape along all but the second axis,
|
except 1-D arrays which can be any length. In the case of a single
|
array_like input, it will be treated as a sequence of arrays; i.e.,
|
each element along the zeroth axis is treated as a separate array.
|
|
dtype : str or dtype
|
If provided, the destination array will have this dtype. Cannot be
|
provided together with `out`.
|
|
.. versionadded:: 1.24
|
|
casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
|
Controls what kind of data casting may occur. Defaults to 'same_kind'.
|
|
.. versionadded:: 1.24
|
|
Returns
|
-------
|
stacked : ndarray
|
The array formed by stacking the given arrays.
|
|
See Also
|
--------
|
concatenate : Join a sequence of arrays along an existing axis.
|
stack : Join a sequence of arrays along a new axis.
|
block : Assemble an nd-array from nested lists of blocks.
|
vstack : Stack arrays in sequence vertically (row wise).
|
dstack : Stack arrays in sequence depth wise (along third axis).
|
column_stack : Stack 1-D arrays as columns into a 2-D array.
|
hsplit : Split an array into multiple sub-arrays
|
horizontally (column-wise).
|
unstack : Split an array into a tuple of sub-arrays along an axis.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> a = np.array((1,2,3))
|
>>> b = np.array((4,5,6))
|
>>> np.hstack((a,b))
|
array([1, 2, 3, 4, 5, 6])
|
>>> a = np.array([[1],[2],[3]])
|
>>> b = np.array([[4],[5],[6]])
|
>>> np.hstack((a,b))
|
array([[1, 4],
|
[2, 5],
|
[3, 6]])
|
|
r
|
r r7 )r r? r" r r* r@ rA s r r r ' s\ ôB sÐ DÜ dEÔ "Øwá Q Ò!Üt Q¨e¸WÔEÐEät Q¨e¸WÔEÐEr c óX t | « } | t | « } | j |« | S r )r6 Úlistr! )r5 ÚaxisÚoutr8 r9 s r Ú_stack_dispatcherrH r s+ ä )¨&Ó 1FØ
|
äf Ø cÔØ Mr c ó¤ | D cg c] }t |« } }| s t d« | D ch c] }|j }}t |« dk7 r t d« | d j dz }t ||« }t d« f|z t j fz }| D cg c] }|| } }t j | ||||¬« S c c}w c c}w c c}w )a
|
Join a sequence of arrays along a new axis.
|
|
The ``axis`` parameter specifies the index of the new axis in the
|
dimensions of the result. For example, if ``axis=0`` it will be the first
|
dimension and if ``axis=-1`` it will be the last dimension.
|
|
Parameters
|
----------
|
arrays : sequence of ndarrays
|
Each array must have the same shape. In the case of a single ndarray
|
array_like input, it will be treated as a sequence of arrays; i.e.,
|
each element along the zeroth axis is treated as a separate array.
|
|
axis : int, optional
|
The axis in the result array along which the input arrays are stacked.
|
|
out : ndarray, optional
|
If provided, the destination to place the result. The shape must be
|
correct, matching that of what stack would have returned if no
|
out argument were specified.
|
|
dtype : str or dtype
|
If provided, the destination array will have this dtype. Cannot be
|
provided together with `out`.
|
|
.. versionadded:: 1.24
|
|
casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
|
Controls what kind of data casting may occur. Defaults to 'same_kind'.
|
|
.. versionadded:: 1.24
|
|
|
Returns
|
-------
|
stacked : ndarray
|
The stacked array has one more dimension than the input arrays.
|
|
See Also
|
--------
|
concatenate : Join a sequence of arrays along an existing axis.
|
block : Assemble an nd-array from nested lists of blocks.
|
split : Split array into a list of multiple sub-arrays of equal size.
|
unstack : Split an array into a tuple of sub-arrays along an axis.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> rng = np.random.default_rng()
|
>>> arrays = [rng.normal(size=(3,4)) for _ in range(10)]
|
>>> np.stack(arrays, axis=0).shape
|
(10, 3, 4)
|
|
>>> np.stack(arrays, axis=1).shape
|
(3, 10, 4)
|
|
>>> np.stack(arrays, axis=2).shape
|
(3, 4, 10)
|
|
>>> a = np.array([1, 2, 3])
|
>>> b = np.array([4, 5, 6])
|
>>> np.stack((a, b))
|
array([[1, 2, 3],
|
[4, 5, 6]])
|
|
>>> np.stack((a, b), axis=-1)
|
array([[1, 4],
|
[2, 5],
|
[3, 6]])
|
|
z need at least one array to stackr z)all input arrays must have the same shaper
|
N)rF rG r8 r9 )
|
r Ú
|
ValueErrorÚshaper r r Úslicer* r+ r@ )
|
r5 rF rG r8 r9 ÚarrÚshapesÚ result_ndimÚslÚexpanded_arrayss
|
r r r | sÕ ðT *0Ö 0 #joÐ 0FÐ 0Ù ÜÐ;Ó<Ð<à#)Ö *CciiÐ *FÐ *Ü
|
6{aÒÜÐDÓEÐEà).. 1Ñ$KÜ kÓ 2Dä
|
+ $Ñ ¤#§+¡+ Ñ /BØ*0Ö1 3s2wÐ1OÐ1Ü ???°¸3Ø!&°ô 9ð 9ùò 1ùò +ùò 2s
CªCÂ C ©rF c ó | fS r r ©ÚxrF s r Ú_unstack_dispatcherrV Ö s Ø 4Kr c óv | j dk( r t d« t t j | |d« « S )a5
|
Split an array into a sequence of arrays along the given axis.
|
|
The ``axis`` parameter specifies the dimension along which the array will
|
be split. For example, if ``axis=0`` (the default) it will be the first
|
dimension and if ``axis=-1`` it will be the last dimension.
|
|
The result is a tuple of arrays split along ``axis``.
|
|
.. versionadded:: 2.1.0
|
|
Parameters
|
----------
|
x : ndarray
|
The array to be unstacked.
|
axis : int, optional
|
Axis along which the array will be split. Default: ``0``.
|
|
Returns
|
-------
|
unstacked : tuple of ndarrays
|
The unstacked arrays.
|
|
See Also
|
--------
|
stack : Join a sequence of arrays along a new axis.
|
concatenate : Join a sequence of arrays along an existing axis.
|
block : Assemble an nd-array from nested lists of blocks.
|
split : Split array into a list of multiple sub-arrays of equal size.
|
|
Notes
|
-----
|
``unstack`` serves as the reverse operation of :py:func:`stack`, i.e.,
|
``stack(unstack(x, axis=axis), axis=axis) == x``.
|
|
This function is equivalent to ``tuple(np.moveaxis(x, axis, 0))``, since
|
iterating on an array iterates along the first axis.
|
|
Examples
|
--------
|
>>> arr = np.arange(24).reshape((2, 3, 4))
|
>>> np.unstack(arr)
|
(array([[ 0, 1, 2, 3],
|
[ 4, 5, 6, 7],
|
[ 8, 9, 10, 11]]),
|
array([[12, 13, 14, 15],
|
[16, 17, 18, 19],
|
[20, 21, 22, 23]]))
|
>>> np.unstack(arr, axis=1)
|
(array([[ 0, 1, 2, 3],
|
[12, 13, 14, 15]]),
|
array([[ 4, 5, 6, 7],
|
[16, 17, 18, 19]]),
|
array([[ 8, 9, 10, 11],
|
[20, 21, 22, 23]]))
|
>>> arr2 = np.stack(np.unstack(arr, axis=1), axis=1)
|
>>> arr2.shape
|
(2, 3, 4)
|
>>> np.all(arr == arr2)
|
np.True_
|
|
r
|
z!Input array must be at least 1-d.)r rJ r" r* ÚmoveaxisrT s r r r Ù s4 ð@ vv{ÜÐ<Ó=Ð=Ü a qÓ)Ó *Ð*r Ú __wrapped__c ó< dj d | D « « }d|z S )zM
|
Convert a list of indices ``[0, 1, 2]`` into ``"arrays[0][1][2]"``.
|
Ú c 3 ó. K | ] }|d| d y w)Nú[ú]r )Ú.0Úis r ú <genexpr>z&_block_format_index.<locals>.<genexpr>+ s è ø Ò? 1°± !AhÑ?ùs r5 )Újoin)ÚindexÚidx_strs r Ú_block_format_indexre ' s# ð ggÑ?¨Ô?Ó?GØ gÑ Ð r c ó* t | t « rt t « d« t | t « rt | « dkD rfdt | « D « }t |« \ }}}|D ]a \ }}}||z }||kD r|}t |« t |« k7 r0t dt |« dt |« dt |« d« |d `|}c |||fS t | t « rt | « dk( r d gz ddfS t | « }t | « |fS )
|
a
|
Recursive function checking that the depths of nested lists in `arrays`
|
all match. Mismatch raises a ValueError as described in the block
|
docstring below.
|
|
The entire index (rather than just the depth) needs to be calculated
|
for each innermost list, in case an error needs to be raised, so that
|
the index of the offending list can be printed as part of the error.
|
|
Parameters
|
----------
|
arrays : nested list of arrays
|
The arrays to check
|
parent_index : list of int
|
The full index of `arrays` within the nested lists passed to
|
`_block_check_depths_match` at the top of the recursion.
|
|
Returns
|
-------
|
first_index : list of int
|
The full index of an element from the bottom of the nesting in
|
`arrays`. If any element at the bottom is an empty list, this will
|
refer to it, and the last index along the empty axis will be None.
|
max_arr_ndim : int
|
The maximum of the ndims of the arrays nested in `arrays`.
|
final_size: int
|
The number of elements in the final array. This is used the motivate
|
the choice of algorithm used using benchmarking wisdom.
|
|
z} is a tuple. Only lists can be used to arrange blocks, and np.block does not allow implicit conversion from tuple to ndarray.r
|
c 3 óD K | ] \ }}t ||gz « y wr )Ú_block_check_depths_match)r_ r` rM Ú parent_indexs r ra z,_block_check_depths_match.<locals>.<genexpr>Z s+ øè ø ò 7Ù !Sô 0°°\ÀQÀCÑ5G×Hñ 7ùs z7List depths are mismatched. First element was at depth z#, but there is an element at depth z (ú)éÿÿÿÿN) r? r" r4 re rE r Ú enumerateÚnextrJ Ú_sizeÚ_ndim) r5 ri Ú
|
idxs_ndimsÚ first_indexÚ max_arr_ndimÚ
|
final_sizerc r Úsizes ` r rh rh / sU ø ô> &%Ô ô Ü" <Ó0Ð1ð 2Cð Có
|
ð
|
ô
|
|
FDÔ !¤c¨&£k°A¢oó7Ü$-¨fÓ$5ô7
|
ô 15°ZÓ0@Ñ- \ :Ø!+ò $Ñ E4Ø $Ñ JØlÒ"Ø # Ü5zS Ó -Ò-Ü ð Ü Ó -Ð .ð / Ü ZL¨Ô+>¸uÓ+EÐ*FÀaðIóð ð RyÑ Ø # ð $ð L¨*Ð4Ð4Ü FDÔ !¤c¨&£k°QÒ&6àtfÑ$ a¨Ð*Ð*ô V}ØU 6]¨DÐ0Ð0r c ó t | |d d¬« S )NT)ÚndminÚcopyÚsubok)r )Úar s r Ú _atleast_ndrz v s ô $ T°Ô 6Ð6r c ó> t t j | « « S r )rE Ú itertoolsÚ
|
accumulate)Úvaluess r Ú _accumulater | s Ü ×$Ñ$ VÓ,Ó -Ð-r c óX
|
| D cg c] }| }}| d }|d
|
|dz d t
|
fd| D « « rt d d«
|
t |« fz |dz d z }t |« }t dg|z |« D cg c] \ }}t ||« f }}}||fS c c}w c c}}w )aë Given array shapes, return the resulting shape and slices prefixes.
|
|
These help in nested concatenation.
|
|
Returns
|
-------
|
shape: tuple of int
|
This tuple satisfies::
|
|
shape, _ = _concatenate_shapes([arr.shape for shape in arrs], axis)
|
shape == concatenate(arrs, axis).shape
|
|
slice_prefixes: tuple of (slice(start, end), )
|
For a list of arrays being concatenated, this returns the slice
|
in the larger array at axis that needs to be sliced into.
|
|
For example, the following holds::
|
|
ret = concatenate([a, b, c], axis)
|
_, (sl_a, sl_b, sl_c) = concatenate_slices([a, b, c], axis)
|
|
ret[(slice(None),) * axis + sl_a] == a
|
ret[(slice(None),) * axis + sl_b] == b
|
ret[(slice(None),) * axis + sl_c] == c
|
|
These are called slice prefixes since they are used in the recursive
|
blocking algorithm to compute the left-most slices during the
|
recursion. Therefore, they must be prepended to rest of the slice
|
that was computed deeper in the recursion.
|
|
These are returned as tuples to ensure that they can quickly be added
|
to existing slice tuple without creating a new tuple every time.
|
|
r
|
Nr c 3 óH K | ] }|d k7 xs |dz d k7 y w)Nr r )r_ rK rF Úfirst_shape_postÚfirst_shape_pres r ra z&_concatenate_shapes.<locals>.<genexpr>« sD øè ø ò EØ49ð $<?Ñ *ò 0Ø Ð Ð /Ñ /ó 0ñ Eùs "z,Mismatched array shapes in block along axis ú.)ÚanyrJ Úsumr ÚziprL ) rN rF rK Ú shape_at_axisÚ first_shapeÚoffsets_at_axisÚstartÚendÚslice_prefixesr r s ` @@r Ú_concatenate_shapesr sù ú ðH /5Ö5 UU4[Ð5MÐ5ð )KØ! % 4Ð(OØ" 4¨!¡8 9Ð-Ðä
|
õ EØ=Cô Eô EäØ:¸4¸&ÀÐ BóDð Dð ¤ MÓ 2Ð 4Ñ 4°{À4È!Á8À9Ð7MÑ MEä! -Ó0Oä(+¨Q¨C°/Ñ,AØ,;ó)=÷>Ù$% ô U CÓ(Ò*ð >Nñ >ð .Ð Ð ùò% 6ùó >s B!ÂB&c ó ||k rt | D cg c] }t ||||dz « c} \ }}} ||z
|
|z }t ||« \ }} t | |« D
|
cg c] \ }
|
} | D ] } |
|
| z }} }
|
} t j t
|
j | « } ||| fS t | |« }|j dg|gfS c c}w c c} } }
|
w )a
|
Returns the shape of the final array, along with a list
|
of slices and a list of arrays that can be used for assignment inside the
|
new array
|
|
Parameters
|
----------
|
arrays : nested list of arrays
|
The arrays to check
|
max_depth : list of int
|
The number of nested lists
|
result_ndim : int
|
The number of dimensions in thefinal array.
|
|
Returns
|
-------
|
shape : tuple of int
|
The shape that the final array will take on.
|
slices: list of tuple of slices
|
The slices into the full array required for assignment. These are
|
required to be prepended with ``(Ellipsis, )`` to obtain to correct
|
final index.
|
arrays: list of ndarray
|
The data to assign to each slice of the full array
|
|
r r ) r Ú_block_info_recursionr Ú functoolsÚreduceÚoperatorÚaddrz rK ) r5 Ú max_depthrO ÚdepthrM rN ÚslicesrF rK r Ú slice_prefixÚ inner_slicesÚ the_slices r r r ¹ sý ð6 yÒÜ!$à ö!Øô $ C¨°KÀÈÁÕKò !ð""Ñ ð YÑ&¨Ñ.Ü 3°F¸DÓ AÑ ~ô 58¸ÈÓ4O÷1ð 1Ù0l LØ#/ò1à ð Ó*ð 1Ð*ð 1ò 1ô
|
×!Ñ!¤(§,¡,°Ó7àffÐ$Ð$ô & +Ó.Øyy2$ Ð%Ð%ùò+!ùô1s B6ÁB;c
|
ó ||k r/| D cg c] }t ||||dz « }}t |||z
|
¬« S t | |« S c c}w )aZ
|
Internal implementation of block based on repeated concatenation.
|
`arrays` is the argument passed to
|
block. `max_depth` is the depth of nested lists within `arrays` and
|
`result_ndim` is the greatest of the dimensions of the arrays in
|
`arrays` and the depth of the lists in `arrays` (see block docstring
|
for details).
|
r rR )Ú_blockÚ _concatenaterz )r5 r rO r rM rB s r r r î sa ð yÒà!ö#Øô sI {°E¸A±IÕ>ð #ð #äD¨°UÑ):Ð';Ô<Ð<ô 6 ;Ó/Ð/ùò #s Ac # ón K t | t « r| D ] }t |« E d { y | y 7 wr )r? rE Ú_block_dispatcher)r5 Ú subarrayss r r r s; è ø ô &$Ô Ø ò 4IÜ(¨Ó3× 3Ñ 3ñ 4ð ð 4ús $5¦3§ 5c óf t | « \ } }}}||z dkD r t | ||« S t | ||« S )a¶
|
Assemble an nd-array from nested lists of blocks.
|
|
Blocks in the innermost lists are concatenated (see `concatenate`) along
|
the last dimension (-1), then these are concatenated along the
|
second-last dimension (-2), and so on until the outermost list is reached.
|
|
Blocks can be of any dimension, but will not be broadcasted using
|
the normal rules. Instead, leading axes of size 1 are inserted,
|
to make ``block.ndim`` the same for all blocks. This is primarily useful
|
for working with scalars, and means that code like ``np.block([v, 1])``
|
is valid, where ``v.ndim == 1``.
|
|
When the nested list is two levels deep, this allows block matrices to be
|
constructed from their components.
|
|
Parameters
|
----------
|
arrays : nested list of array_like or scalars (but not tuples)
|
If passed a single ndarray or scalar (a nested list of depth 0), this
|
is returned unmodified (and not copied).
|
|
Elements shapes must match along the appropriate axes (without
|
broadcasting), but leading 1s will be prepended to the shape as
|
necessary to make the dimensions match.
|
|
Returns
|
-------
|
block_array : ndarray
|
The array assembled from the given blocks.
|
|
The dimensionality of the output is equal to the greatest of:
|
|
* the dimensionality of all the inputs
|
* the depth to which the input list is nested
|
|
Raises
|
------
|
ValueError
|
* If list depths are mismatched - for instance, ``[[a, b], c]`` is
|
illegal, and should be spelt ``[[a, b], [c]]``
|
* If lists are empty - for instance, ``[[a, b], []]``
|
|
See Also
|
--------
|
concatenate : Join a sequence of arrays along an existing axis.
|
stack : Join a sequence of arrays along a new axis.
|
vstack : Stack arrays in sequence vertically (row wise).
|
hstack : Stack arrays in sequence horizontally (column wise).
|
dstack : Stack arrays in sequence depth wise (along third axis).
|
column_stack : Stack 1-D arrays as columns into a 2-D array.
|
vsplit : Split an array into multiple sub-arrays vertically (row-wise).
|
unstack : Split an array into a tuple of sub-arrays along an axis.
|
|
Notes
|
-----
|
When called with only scalars, ``np.block`` is equivalent to an ndarray
|
call. So ``np.block([[1, 2], [3, 4]])`` is equivalent to
|
``np.array([[1, 2], [3, 4]])``.
|
|
This function does not enforce that the blocks lie on a fixed grid.
|
``np.block([[a, b], [c, d]])`` is not restricted to arrays of the form::
|
|
AAAbb
|
AAAbb
|
cccDD
|
|
But is also allowed to produce, for some ``a, b, c, d``::
|
|
AAAbb
|
AAAbb
|
cDDDD
|
|
Since concatenation happens along the last axis first, `block` is *not*
|
capable of producing the following directly::
|
|
AAAbb
|
cccbb
|
cccDD
|
|
Matlab's "square bracket stacking", ``[A, B, ...; p, q, ...]``, is
|
equivalent to ``np.block([[A, B, ...], [p, q, ...]])``.
|
|
Examples
|
--------
|
The most common use of this function is to build a block matrix:
|
|
>>> import numpy as np
|
>>> A = np.eye(2) * 2
|
>>> B = np.eye(3) * 3
|
>>> np.block([
|
... [A, np.zeros((2, 3))],
|
... [np.ones((3, 2)), B ]
|
... ])
|
array([[2., 0., 0., 0., 0.],
|
[0., 2., 0., 0., 0.],
|
[1., 1., 3., 0., 0.],
|
[1., 1., 0., 3., 0.],
|
[1., 1., 0., 0., 3.]])
|
|
With a list of depth 1, `block` can be used as `hstack`:
|
|
>>> np.block([1, 2, 3]) # hstack([1, 2, 3])
|
array([1, 2, 3])
|
|
>>> a = np.array([1, 2, 3])
|
>>> b = np.array([4, 5, 6])
|
>>> np.block([a, b, 10]) # hstack([a, b, 10])
|
array([ 1, 2, 3, 4, 5, 6, 10])
|
|
>>> A = np.ones((2, 2), int)
|
>>> B = 2 * A
|
>>> np.block([A, B]) # hstack([A, B])
|
array([[1, 1, 2, 2],
|
[1, 1, 2, 2]])
|
|
With a list of depth 2, `block` can be used in place of `vstack`:
|
|
>>> a = np.array([1, 2, 3])
|
>>> b = np.array([4, 5, 6])
|
>>> np.block([[a], [b]]) # vstack([a, b])
|
array([[1, 2, 3],
|
[4, 5, 6]])
|
|
>>> A = np.ones((2, 2), int)
|
>>> B = 2 * A
|
>>> np.block([[A], [B]]) # vstack([A, B])
|
array([[1, 1],
|
[1, 1],
|
[2, 2],
|
[2, 2]])
|
|
It can also be used in place of `atleast_1d` and `atleast_2d`:
|
|
>>> a = np.array(0)
|
>>> b = np.array([1])
|
>>> np.block([a]) # atleast_1d(a)
|
array([0])
|
>>> np.block([b]) # atleast_1d(b)
|
array([1])
|
|
>>> np.block([[a]]) # atleast_2d(a)
|
array([[0]])
|
>>> np.block([[b]]) # atleast_2d(b)
|
array([[1]])
|
|
|
i )Ú _block_setupÚ_block_slicingÚ_block_concatenate)r5 Ú list_ndimrO rs s r r r sE ôl 2>¸fÓ1EÑ.FI{ Jð :Ñ Ò/Ü f i°Ó=Ð=ä! &¨)°[ÓAÐAr c ó t | « \ }}}t |« }|r |d t dt |« d« t ||« }| |||fS )zD
|
Returns
|
(`arrays`, list_ndim, result_ndim, final_size)
|
rk zList at z cannot be empty)rh r rJ re Úmax)r5 Ú bottom_indexÚarr_ndimrs r¥ rO s r r¢ r¢ ¼ sk ô
|
*CÀ6Ó)JÑ&L(JÜLÓ!IÙ RÑ(Ð0ÜØÔ*¨<Ó8Ð9Ð9IÐ Jó
|
ð
|
ô h Ó*KØ 9k¨:Ð 5Ð5r c óP t | ||« \ }}} t j | D cg c] }|j c} }t d | D « « }t d | D « « }|r|sdnd} t j
|
||| ¬« }
|
t || « D ] \ } }||
|
t f| z < |
|
S c c}w )Nc 3 ó: K | ] }|j d yw)Ú F_CONTIGUOUSN©Úflags©r_ rM s r ra z!_block_slicing.<locals>.<genexpr>Ñ ó è ø Ò>°#))NÕ+Ñ>ùó c 3 ó: K | ] }|j d yw)Ú C_CONTIGUOUSNr r¯ s r ra z!_block_slicing.<locals>.<genexpr>Ò r° r± ÚFÚC)rK r8 Úorder)r r* Ú result_typer8 ÚallÚemptyr ÚEllipsis) r5 r¥ rO rK r rM r8 ÚF_orderÚC_orderr¶ r# r s r r£ r£ Ë s Ü 1Ø ;ó (ÑE66ä OO°6Ö :¨CciiÒ :Ð ;Eô Ñ>°vÔ>Ó>GÜÑ>°vÔ>Ó>GÙ¡7C°EÜ YYU¨%°uÔ =Fô
|
f fÓ-ò . 3Ø*-{YÑ&Ò'ð.à Mùò ;s ¥B#c óJ t | ||« }|dk( r|j « }|S )Nr
|
)r rw )r5 r¥ rO r# s r r¤ r¤ Þ s) Ü FI {Ó 3FØA~ð
|
Ø Mr )NN)r
|
N)r
|
)1Ú__all__r r| r r[ r Ú_from_nxr r* r Ú
|
multiarrayr r r ÚpartialÚarray_function_dispatchr r r' r r. r r6 r< r r rH r rV r Úgetattrrt rn r ro r@ r re rh rz r r r r r r r¢ r£ r¤ r r r ú<module>rÄ s ðò )ó Û Û å %Ý Ý ß ?Ñ ?à+)×+Ñ+Ø ×%Ñ%¨gô7Ð òñ Ð/Ó0ñ3ó 1ð3òlñ Ð/Ó0ñ3ó 1ð3òlñ Ð/Ó0ñAó 1ðAòHð '+°Dô -ñ Ð,Ó-Ø {ó GBó .ðGBñT Ð,Ó-Ø {ó GFó .ðGFðTØ ¨$ôñ Ð*Ó+ðW9¨T¸;ó W9ó ,ðW9ðr '+ô ñ Ð,Ó-Øó A+ó .ðA+ñN }¨h¯m©mÓ<Ù }¨h¯m©mÓ<Ùx×+Ñ+Ø$ h×&:Ñ&:ó< ò ð 46ó D1òN7ò .ò6!ór2&ój0ò&ñ Ð*Ó+ñhBó ,ðhBò^ 6ò ó&r
|
