U
|
P ±dï} ã @ s¬ d Z ddlZddlmZ ddlmZ dgZdd Zdd Z d
|
d Z
|
d#d d Z dd Z dd Z dd Zdd Zd$ddZdd Zd%dd Zd&d d Zeed d d'd"dZdS )(zl
|
The arraypad module contains a group of functions to pad values onto the edges
|
of an n-dimensional array.
|
|
é N)Úarray_function_dispatch)ÚndindexÚpadc C s t |t j¡r| j| d dS )zÁ
|
Rounds arr inplace if destination dtype is integer.
|
|
Parameters
|
----------
|
arr : ndarray
|
Input array.
|
dtype : dtype
|
The dtype of the destination array.
|
)ÚoutN)ÚnpZ
|
issubdtypeÚintegerÚround)ZarrÚdtype© r
|
úId:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\numpy/lib/arraypad.pyÚ_round_if_needed s r c C s t df| | f d S )aÿ
|
Construct tuple of slices to slice an array in the given dimension.
|
|
Parameters
|
----------
|
sl : slice
|
The slice for the given dimension.
|
axis : int
|
The axis to which `sl` is applied. All other dimensions are left
|
"unsliced".
|
|
Returns
|
-------
|
sl : tuple of slices
|
A tuple with slices matching `shape` in length.
|
|
Examples
|
--------
|
>>> _slice_at_axis(slice(None, 3, -1), 1)
|
(slice(None, None, None), slice(None, 3, -1), (...,))
|
N).©Úslice)ÚslÚaxisr
|
r
|
r Ú_slice_at_axis! s r c C s* |d7 }t df| ||d
}| | S )aÈ
|
Get a view of the current region of interest during iterative padding.
|
|
When padding multiple dimensions iteratively corner values are
|
unnecessarily overwritten multiple times. This function reduces the
|
working area for the first dimensions so that corners are excluded.
|
|
Parameters
|
----------
|
array : ndarray
|
The array with the region of interest.
|
original_area_slice : tuple of slices
|
Denotes the area with original values of the unpadded array.
|
axis : int
|
The currently padded dimension assuming that `axis` is padded before
|
`axis` + 1.
|
|
Returns
|
-------
|
roi : ndarray
|
The region of interest of the original `array`.
|
é Nr )ÚarrayÚoriginal_area_slicer r r
|
r
|
r Ú _view_roi: s r c C sx t dd t| j|D }| jjr&dnd}tj|| j|d}|dk rN| |¡ t dd t| j|D }| ||< ||fS )a©
|
Pad array on all sides with either a single value or undefined values.
|
|
Parameters
|
----------
|
array : ndarray
|
Array to grow.
|
pad_width : sequence of tuple[int, int]
|
Pad width on both sides for each dimension in `arr`.
|
fill_value : scalar, optional
|
If provided the padded area is filled with this value, otherwise
|
the pad area left undefined.
|
|
Returns
|
-------
|
padded : ndarray
|
The padded array with the same dtype as`array`. Its order will default
|
to C-style if `array` is not F-contiguous.
|
original_area_slice : tuple
|
A tuple of slices pointing to the area of the original array.
|
c s s" | ]\}\}}|| | V qd S ©Nr
|
©Ú.0ÚsizeÚleftÚrightr
|
r
|
r Ú <genexpr>m s
|
ÿz _pad_simple.<locals>.<genexpr>ÚFÚC)r ÚorderNc s s$ | ] \}\}}t ||| V qd S r r r r
|
r
|
r r x s
|
ÿ) ÚtupleÚzipÚshapeÚflagsZfncr Úemptyr Úfill)r Ú pad_widthÚ
|
fill_valueZ new_shaper Úpaddedr r
|
r
|
r Ú _pad_simpleV s
|
þ
|
|
þr) c C sN t td|d |}|d | |< t t| j| |d d|}|d | |< dS )aü
|
Set empty-padded area in given dimension.
|
|
Parameters
|
----------
|
padded : ndarray
|
Array with the pad area which is modified inplace.
|
axis : int
|
Dimension with the pad area to set.
|
width_pair : (int, int)
|
Pair of widths that mark the pad area on both sides in the given
|
dimension.
|
value_pair : tuple of scalars or ndarrays
|
Values inserted into the pad area on each side. It must match or be
|
broadcastable to the shape of `arr`.
|
Nr r ©r r r" )r( r Ú
|
width_pairÚ
|
value_pairÚ
|
left_sliceÚ right_slicer
|
r
|
r Ú _set_pad_area s ÿr/ c C sZ |d }t t||d |}| | }| j| |d }t t|d ||}| | }||fS )aZ
|
Retrieve edge values from empty-padded array in given dimension.
|
|
Parameters
|
----------
|
padded : ndarray
|
Empty-padded array.
|
axis : int
|
Dimension in which the edges are considered.
|
width_pair : (int, int)
|
Pair of widths that mark the pad area on both sides in the given
|
dimension.
|
|
Returns
|
-------
|
left_edge, right_edge : ndarray
|
Edge values of the valid area in `padded` in the given dimension. Its
|
shape will always match `padded` except for the dimension given by
|
`axis` which will have a length of 1.
|
r r r* ) r( r r+ Ú
|
left_indexr- Z left_edgeÚ right_indexr. Z
|
right_edger
|
r
|
r Ú
|
_get_edges s r2 c sJ t |} fddt|||D \}}|ttddd }||fS )a
|
Construct linear ramps for empty-padded array in given dimension.
|
|
Parameters
|
----------
|
padded : ndarray
|
Empty-padded array.
|
axis : int
|
Dimension in which the ramps are constructed.
|
width_pair : (int, int)
|
Pair of widths that mark the pad area on both sides in the given
|
dimension.
|
end_value_pair : (scalar, scalar)
|
End values for the linear ramps which form the edge of the fully padded
|
array. These values are included in the linear ramps.
|
|
Returns
|
-------
|
left_ramp, right_ramp : ndarray
|
Linear ramps to set on both sides of `padded`.
|
c 3 s2 | ]*\}}}t j|| ¡|d j dV qdS )F)ÚstartÚstopÚnumZendpointr r N)r ZlinspaceZsqueezer )r Ú end_valueÚedgeÚwidth©r r( r
|
r r Ò s øúz$_get_linear_ramps.<locals>.<genexpr>Néÿÿÿÿ)r2 r! r r )r( r r+ Zend_value_pairÚ edge_pairZ left_rampZ
|
right_rampr
|
r9 r Ú_get_linear_rampsº s ÿ÷
|
r< c C s |d }| j | |d }|| }|\}} |dks:||k r>|}| dksN|| k rR|} |dksb| dkrz|tjtjhkrztdtt||| |}
|
| |
|
} || |dd} t| | j || krÄ|krÐn n| | fS tt|| ||} | | }|||dd}t|| j | |fS )al
|
Calculate statistic for the empty-padded array in given dimension.
|
|
Parameters
|
----------
|
padded : ndarray
|
Empty-padded array.
|
axis : int
|
Dimension in which the statistic is calculated.
|
width_pair : (int, int)
|
Pair of widths that mark the pad area on both sides in the given
|
dimension.
|
length_pair : 2-element sequence of None or int
|
Gives the number of values in valid area from each side that is
|
taken into account when calculating the statistic. If None the entire
|
valid area in `padded` is considered.
|
stat_func : function
|
Function to compute statistic. The expected signature is
|
``stat_func(x: ndarray, axis: int, keepdims: bool) -> ndarray``.
|
|
Returns
|
-------
|
left_stat, right_stat : ndarray
|
Calculated statistic for both sides of `padded`.
|
r r Nz,stat_length of 0 yields no value for paddingT)r Zkeepdims) r" r ÚamaxÚaminÚ
|
ValueErrorr r r r )r( r r+ Ú length_pairÚ stat_funcr0 r1 Ú
|
max_lengthZ left_lengthZ right_lengthr- Ú
|
left_chunkZ left_statr. Ú right_chunkZ
|
right_statr
|
r
|
r Ú
|
_get_statsæ s: ÿ ÿ ÿ rE Fc C sx |\}}| j | | | }|r$d}n d}|d8 }|dkrÄt||} || }
|
|
|
| } tt| |
|
d|} | | } |dkrtt||d |}d| | | } || } |}
|
tt| |
|
|}| | |< || 8 }|dkrpt||} | | d } | | }
|
tt| |
|
d|}| | }|dkr:tt| d | |}d| | | }| j | | } | | }
|
tt| |
|
|}|| |< || 8 }||fS )aç
|
Pad `axis` of `arr` with reflection.
|
|
Parameters
|
----------
|
padded : ndarray
|
Input array of arbitrary shape.
|
axis : int
|
Axis along which to pad `arr`.
|
width_pair : (int, int)
|
Pair of widths that mark the pad area on both sides in the given
|
dimension.
|
method : str
|
Controls method of reflection; options are 'even' or 'odd'.
|
include_edge : bool
|
If true, edge value is included in reflection, otherwise the edge
|
value forms the symmetric axis to the reflection.
|
|
Returns
|
-------
|
pad_amt : tuple of ints, length 2
|
New index positions of padding to do along the `axis`. If these are
|
both 0, padding is done in this dimension.
|
r r r: Zoddé )r" Úminr r )r( r r+ ÚmethodÚ include_edgeÚleft_padÚ right_padZ
|
old_lengthZ edge_offsetZ chunk_lengthr4 r3 r- rC Z
|
edge_sliceÚpad_arear. rD r
|
r
|
r Ú_set_reflect_both( sL
|
|
|
|
ÿrM c C s |\}}| j | | | }d}d}|dkrtt| t|| |dkrJ| nd|}| | } ||krtt|| ||}
|
|| }nttd||}
|
| | |
|
< |dkr
|
tt||t|| |} | | } ||krðtt| | | |}
|
|| }ntt| d|}
|
| | |
|
< ||fS )aú
|
Pad `axis` of `arr` with wrapped values.
|
|
Parameters
|
----------
|
padded : ndarray
|
Input array of arbitrary shape.
|
axis : int
|
Axis along which to pad `arr`.
|
width_pair : (int, int)
|
Pair of widths that mark the pad area on both sides in the given
|
dimension.
|
|
Returns
|
-------
|
pad_amt : tuple of ints, length 2
|
New index positions of padding to do along the `axis`. If these are
|
both 0, padding is done in this dimension.
|
r N)r" r r rG ) r( r r+ rJ rK ZperiodZ new_left_padZ new_right_padr. rD rL r- rC r
|
r
|
r Ú_set_wrap_both} s@ ÿý
|
|
ÿ ÿ
|
rN c C sü | dkrd| S t | ¡} |r4t | ¡jt jdd} | jdk rÐ| jdkrz| ¡ } |rd| dk rdtd| d | d ff| S | jd krÐ| j d
|
krÐ| ¡ } |rº| d dk s²| d dk rºtd| d | d ff| S |rè|
|
¡ dk rètdt | |d f¡ ¡ S ) a8
|
Broadcast `x` to an array with the shape (`ndim`, 2).
|
|
A helper function for `pad` that prepares and validates arguments like
|
`pad_width` for iteration in pairs.
|
|
Parameters
|
----------
|
x : {None, scalar, array-like}
|
The object to broadcast to the shape (`ndim`, 2).
|
ndim : int
|
Number of pairs the broadcasted `x` will have.
|
as_index : bool, optional
|
If `x` is not None, try to round each element of `x` to an integer
|
(dtype `np.intp`) and ensure every element is positive.
|
|
Returns
|
-------
|
pairs : nested iterables, shape (`ndim`, 2)
|
The broadcasted version of `x`.
|
|
Raises
|
------
|
ValueError
|
If `as_index` is True and `x` contains negative elements.
|
Or if `x` is not broadcastable to the shape (`ndim`, 2).
|
N))NNF)Úcopyé r r z#index can't contain negative valuesrF )rF r ) r r r ZastypeZintpÚndimr Zravelr? r" rG Z broadcast_toÚtolist)ÚxrQ Úas_indexr
|
r
|
r Ú _as_pairsÆ s&
|
|
|
rU c K s | fS r r
|
)r r& ÚmodeÚkwargsr
|
r
|
r Ú_pad_dispatcher s rX Únumpy)ÚmoduleÚconstantc K sp t | ¡} t |¡}|jjdks(tdt|| jdd}t|r¸|}t| |dd\}}t |jD ]R}t
|
||d¡}t |j dd
} d d
|
| D } | D ]}
|
|||
|
|| || qq`|S g g g d gd gd gd gd gd gdgdgd } zt |t | | } W n& tk
|
r" td |¡dY nX | r:td || ¡t jt jt jt jd} t| |\}}t |j}|dkrÂ| d d¡}t||j}t|||D ]&\}}}t|||}t|||| qnª|dkrÐn| jdkr t||D ]2\}}| j | dkræt|rætd |¡qænN|dkrht||D ]0\}}t|||}t|||}t|||| q2n|dkrÐ| d d¡}t||j}t|||D ]4\}}}t|||}t ||||}t|||| qn|| krF| | }| d d¡}t||jdd}t|||D ]6\}}}t|||}t |||||}t|||| q
|
n&|dkr| dd¡}|dkrjdnd} t||D ]\}\} } | j | d krÎ| dks¨| dkrÎt||| | f}t||| | f| qxt|||}| dksî| dkrxt ||| | f|| \} } qÚqxn\|d krlt||D ]F\}\} } t|||}| dksP| dkr$t ||| | f\} } q<q$|S ) aâ
|
Pad an array.
|
|
Parameters
|
----------
|
array : array_like of rank N
|
The array to pad.
|
pad_width : {sequence, array_like, int}
|
Number of values padded to the edges of each axis.
|
``((before_1, after_1), ... (before_N, after_N))`` unique pad widths
|
for each axis.
|
``(before, after)`` or ``((before, after),)`` yields same before
|
and after pad for each axis.
|
``(pad,)`` or ``int`` is a shortcut for before = after = pad width
|
for all axes.
|
mode : str or function, optional
|
One of the following string values or a user supplied function.
|
|
'constant' (default)
|
Pads with a constant value.
|
'edge'
|
Pads with the edge values of array.
|
'linear_ramp'
|
Pads with the linear ramp between end_value and the
|
array edge value.
|
'maximum'
|
Pads with the maximum value of all or part of the
|
vector along each axis.
|
'mean'
|
Pads with the mean value of all or part of the
|
vector along each axis.
|
'median'
|
Pads with the median value of all or part of the
|
vector along each axis.
|
'minimum'
|
Pads with the minimum value of all or part of the
|
vector along each axis.
|
'reflect'
|
Pads with the reflection of the vector mirrored on
|
the first and last values of the vector along each
|
axis.
|
'symmetric'
|
Pads with the reflection of the vector mirrored
|
along the edge of the array.
|
'wrap'
|
Pads with the wrap of the vector along the axis.
|
The first values are used to pad the end and the
|
end values are used to pad the beginning.
|
'empty'
|
Pads with undefined values.
|
|
.. versionadded:: 1.17
|
|
<function>
|
Padding function, see Notes.
|
stat_length : sequence or int, optional
|
Used in 'maximum', 'mean', 'median', and 'minimum'. Number of
|
values at edge of each axis used to calculate the statistic value.
|
|
``((before_1, after_1), ... (before_N, after_N))`` unique statistic
|
lengths for each axis.
|
|
``(before, after)`` or ``((before, after),)`` yields same before
|
and after statistic lengths for each axis.
|
|
``(stat_length,)`` or ``int`` is a shortcut for
|
``before = after = statistic`` length for all axes.
|
|
Default is ``None``, to use the entire axis.
|
constant_values : sequence or scalar, optional
|
Used in 'constant'. The values to set the padded values for each
|
axis.
|
|
``((before_1, after_1), ... (before_N, after_N))`` unique pad constants
|
for each axis.
|
|
``(before, after)`` or ``((before, after),)`` yields same before
|
and after constants for each axis.
|
|
``(constant,)`` or ``constant`` is a shortcut for
|
``before = after = constant`` for all axes.
|
|
Default is 0.
|
end_values : sequence or scalar, optional
|
Used in 'linear_ramp'. The values used for the ending value of the
|
linear_ramp and that will form the edge of the padded array.
|
|
``((before_1, after_1), ... (before_N, after_N))`` unique end values
|
for each axis.
|
|
``(before, after)`` or ``((before, after),)`` yields same before
|
and after end values for each axis.
|
|
``(constant,)`` or ``constant`` is a shortcut for
|
``before = after = constant`` for all axes.
|
|
Default is 0.
|
reflect_type : {'even', 'odd'}, optional
|
Used in 'reflect', and 'symmetric'. The 'even' style is the
|
default with an unaltered reflection around the edge value. For
|
the 'odd' style, the extended part of the array is created by
|
subtracting the reflected values from two times the edge value.
|
|
Returns
|
-------
|
pad : ndarray
|
Padded array of rank equal to `array` with shape increased
|
according to `pad_width`.
|
|
Notes
|
-----
|
.. versionadded:: 1.7.0
|
|
For an array with rank greater than 1, some of the padding of later
|
axes is calculated from padding of previous axes. This is easiest to
|
think about with a rank 2 array where the corners of the padded array
|
are calculated by using padded values from the first axis.
|
|
The padding function, if used, should modify a rank 1 array in-place. It
|
has the following signature::
|
|
padding_func(vector, iaxis_pad_width, iaxis, kwargs)
|
|
where
|
|
vector : ndarray
|
A rank 1 array already padded with zeros. Padded values are
|
vector[:iaxis_pad_width[0]] and vector[-iaxis_pad_width[1]:].
|
iaxis_pad_width : tuple
|
A 2-tuple of ints, iaxis_pad_width[0] represents the number of
|
values padded at the beginning of vector where
|
iaxis_pad_width[1] represents the number of values padded at
|
the end of vector.
|
iaxis : int
|
The axis currently being calculated.
|
kwargs : dict
|
Any keyword arguments the function requires.
|
|
Examples
|
--------
|
>>> a = [1, 2, 3, 4, 5]
|
>>> np.pad(a, (2, 3), 'constant', constant_values=(4, 6))
|
array([4, 4, 1, ..., 6, 6, 6])
|
|
>>> np.pad(a, (2, 3), 'edge')
|
array([1, 1, 1, ..., 5, 5, 5])
|
|
>>> np.pad(a, (2, 3), 'linear_ramp', end_values=(5, -4))
|
array([ 5, 3, 1, 2, 3, 4, 5, 2, -1, -4])
|
|
>>> np.pad(a, (2,), 'maximum')
|
array([5, 5, 1, 2, 3, 4, 5, 5, 5])
|
|
>>> np.pad(a, (2,), 'mean')
|
array([3, 3, 1, 2, 3, 4, 5, 3, 3])
|
|
>>> np.pad(a, (2,), 'median')
|
array([3, 3, 1, 2, 3, 4, 5, 3, 3])
|
|
>>> a = [[1, 2], [3, 4]]
|
>>> np.pad(a, ((3, 2), (2, 3)), 'minimum')
|
array([[1, 1, 1, 2, 1, 1, 1],
|
[1, 1, 1, 2, 1, 1, 1],
|
[1, 1, 1, 2, 1, 1, 1],
|
[1, 1, 1, 2, 1, 1, 1],
|
[3, 3, 3, 4, 3, 3, 3],
|
[1, 1, 1, 2, 1, 1, 1],
|
[1, 1, 1, 2, 1, 1, 1]])
|
|
>>> a = [1, 2, 3, 4, 5]
|
>>> np.pad(a, (2, 3), 'reflect')
|
array([3, 2, 1, 2, 3, 4, 5, 4, 3, 2])
|
|
>>> np.pad(a, (2, 3), 'reflect', reflect_type='odd')
|
array([-1, 0, 1, 2, 3, 4, 5, 6, 7, 8])
|
|
>>> np.pad(a, (2, 3), 'symmetric')
|
array([2, 1, 1, 2, 3, 4, 5, 5, 4, 3])
|
|
>>> np.pad(a, (2, 3), 'symmetric', reflect_type='odd')
|
array([0, 1, 1, 2, 3, 4, 5, 5, 6, 7])
|
|
>>> np.pad(a, (2, 3), 'wrap')
|
array([4, 5, 1, 2, 3, 4, 5, 1, 2, 3])
|
|
>>> def pad_with(vector, pad_width, iaxis, kwargs):
|
... pad_value = kwargs.get('padder', 10)
|
... vector[:pad_width[0]] = pad_value
|
... vector[-pad_width[1]:] = pad_value
|
>>> a = np.arange(6)
|
>>> a = a.reshape((2, 3))
|
>>> np.pad(a, 2, pad_with)
|
array([[10, 10, 10, 10, 10, 10, 10],
|
[10, 10, 10, 10, 10, 10, 10],
|
[10, 10, 0, 1, 2, 10, 10],
|
[10, 10, 3, 4, 5, 10, 10],
|
[10, 10, 10, 10, 10, 10, 10],
|
[10, 10, 10, 10, 10, 10, 10]])
|
>>> np.pad(a, 2, pad_with, padder=100)
|
array([[100, 100, 100, 100, 100, 100, 100],
|
[100, 100, 100, 100, 100, 100, 100],
|
[100, 100, 0, 1, 2, 100, 100],
|
[100, 100, 3, 4, 5, 100, 100],
|
[100, 100, 100, 100, 100, 100, 100],
|
[100, 100, 100, 100, 100, 100, 100]])
|
Úiz%`pad_width` must be of integral type.T)rT r )r' r: Nc s s | ]}|t f V qd S r )ÚEllipsis)r Úindr
|
r
|
r r û s zpad.<locals>.<genexpr>Zconstant_valuesÚ
|
end_valuesZ stat_lengthZ reflect_type) r$ r7 Úwrapr[ Ú linear_rampÚmaximumÚmeanÚmedianÚminimumÚreflectÚ symmetriczmode '{}' is not supportedz/unsupported keyword arguments for mode '{}': {})rb re rc rd r[ r$ zGcan't extend empty axis {} using modes other than 'constant' or 'empty'r7 ra > rg rf Zevenrg Fr r` ) r Zasarrayr ÚkindÚ TypeErrorrU rQ Úcallabler) ÚrangeZmoveaxisr r" ÚsetÚKeyErrorr? Úformatr= r> rc rd Úgetr! r r/ r Úanyr2 r< rE rM rN ) r r& rV rW Úfunctionr( Ú_r ÚviewZindsr^ Zallowed_kwargsZunsupported_kwargsZstat_functionsr ZaxesÚvaluesr+ r, Zroir; r_ Z ramp_pairÚfuncÚlengthr@ Z stat_pairrH rI r0 r1 r
|
r
|
r r sÞ Q
|
|
÷ ÿ ÿ
|
|
|
ÿÿ
|
|
|
|
$ ÿ þ
|
ÿ)N)F)F)N)r[ )Ú__doc__rY r Znumpy.core.overridesr Znumpy.lib.index_tricksr Ú__all__r r r r) r/ r2 r< rE rM rN rU rX r r
|
r
|
r
|
r Ú<module> s$
|
+ ,B
|
UI
|
C
|
|
|
