Ë
|
Kñúh¢ ã ó¢ d Z ddlZddlmZ ddlmZ dgZd Zd Z d Z
|
dd Z d
|
Z d Z d Zd Z ddZd ZddZddZ eed¬« dd« Zy)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 ór t j |t j « r| j | ¬« yy)zÁ
|
Rounds arr inplace if destination dtype is integer.
|
|
Parameters
|
----------
|
arr : ndarray
|
Input array.
|
dtype : dtype
|
The dtype of the destination array.
|
)ÚoutN)ÚnpÚ
|
issubdtypeÚintegerÚround)ÚarrÚdtypes úKH:\Change_password\venv_build\Lib\site-packages\numpy/lib/_arraypad_impl.pyÚ_round_if_neededr s) ô
|
}}UBJJÔ'Ø c Õð (ó c ó. t d« f|z | fz dz 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
|
--------
|
>>> np._slice_at_axis(slice(None, 3, -1), 1)
|
(slice(None, None, None), slice(None, 3, -1), (...,))
|
N).©Úslice)ÚslÚaxiss r Ú_slice_at_axisr s! ô, $K>DÑ B 5Ñ (¨6Ñ 1Ð1r c ó@ |dz }t d« f|z ||d z }| | 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 s r Ú _view_roir 9 s4 ð. AIDÜ
|
+ $Ñ Ð!4°T°UÐ!;Ñ ;BØ 9Ðr c óJ t d t | j |« D « « }| j j rdnd}t j || j |¬« }||j |« t d 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 3 ó8 K | ] \ }\ }}||z |z y w©N© ©Ú.0ÚsizeÚleftÚrights r ú <genexpr>z _pad_simple.<locals>.<genexpr>l s) è ø ò á D-4ð t eÕñùs ÚFÚC)r Úorderc 3 óF K | ] \ }\ }}t |||z « y wr r r s r r% z _pad_simple.<locals>.<genexpr>w s+ è ø ò á D-4ô dD4K× ñ ùs !) ÚtupleÚzipÚshapeÚflagsÚfncr Úemptyr Úfill)r Ú pad_widthÚ
|
fill_valueÚ new_shaper( Úpaddedr s r Ú _pad_simpler5 U s ô. ñ ä#& u§{¡{°IÓ#>ôó Ið ;;??C¨EÜ XXi u§{¡{¸%Ô @FàÐ Ø JÔ ô ñ ä#& u§{¡{°IÓ#>ô ó Ðð #(FÐ Ñ à Ð&Ð &Ð&r c ó¨ t t d|d « |« }|d | |< t t | j | |d z
|
d« |« }|d | |< y)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, )r4 r Ú
|
width_pairÚ
|
value_pairÚ
|
left_sliceÚ right_slices r Ú _set_pad_arear< s_ ô" ¤ d¨J°q©MÓ :¸DÓAJØ# A F:Ñä Ü fll4Ñ :¨a¡=Ñ0°$Ó7¸ó?Kà$ Q-F;Òr c ó¶ |d }t t ||dz « |« }| | }| j | |d z
|
}t t |dz
|
|« |« }| | }||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 r7 ) r4 r r8 Ú
|
left_indexr: Ú left_edgeÚ right_indexr; Ú
|
right_edges r Ú
|
_get_edgesrB sq ð* A JÜ ¤ j°*¸q±.Ó AÀ4ÓHJØzÑ"Ià,,tÑ$ z°!¡}Ñ4KÜ ¤ {°Q¡¸ Ó!DÀdÓKKØ Ñ$Jà jÐ Ð r c ó t |« } fdt |||« D « \ }}|t t ddd« « }||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 ó K | ]< \ }}}t j ||j « |d j ¬« > yw)F)ÚstartÚstopÚnumÚendpointr r N)r ÚlinspaceÚsqueezer )r! Ú end_valueÚedgeÚwidthr r4 s r r% z$_get_linear_ramps.<locals>.<genexpr>Ñ sN øè ø ò ñ #ItUô ØØ dÓ#ØØØ,,Ø÷
|
ð
|
ñ ùs AANéÿÿÿÿ)rB r+ r r )r4 r r8 Úend_value_pairÚ edge_pairÚ left_rampÚ
|
right_ramps `` r Ú_get_linear_rampsrS ¹ s\ ù ô, 6 4¨Ó4Iô ô '*Ø I zó'
|
ô ÑIzð N¬5°°t¸RÓ+@À$Ó GÑHJà jÐ Ð r c ó |d }| j | |d z
|
}||z
|
}|\ }} |||k r|}| || k r|} |dk( s| dk( r-|t j t j hv r t d« t t |||z « |« }
|
| |
|
} || |d¬« } t | | j « || cxk( r|k( r| | fS t t || z
|
|« |« } | | } |||d¬« }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 z,stat_length of 0 yields no value for paddingT)r Úkeepdims) r, r ÚamaxÚaminÚ
|
ValueErrorr r r r )r4 r r8 Ú length_pairÚ stat_funcr> r@ Ú
|
max_lengthÚ left_lengthÚ right_lengthr: Ú
|
left_chunkÚ left_statr; Ú right_chunkÚ
|
right_stats r Ú
|
_get_statsrb å s> ð6 A JØ,,tÑ$ z°!¡}Ñ4Kà zÑ)Jð !,Ñ K ØÐj¨;Ò 6Ø ØÐz¨LÒ 8Ø! àqÒL¨AÒ -Øbgg¤r§w¡wÐ /Ñ/ô ÐGÓHÐHô Ü j* {Ñ2Ó3°Tó;Jà
|
Ñ#JÙ*¨4¸$Ô?IÜY § ¡ Ô-àlÔ0 jÒ0à)Ð#Ð#ð 1ô
|
!Ü kLÑ(¨+Ó6¸ó>KàÑ%KÙ;¨T¸DÔAJÜZ § ¡ Ô.à jÐ Ð r c óÖ |\ }}| j | |z
|
|z
|
}|r ||z |z }d} n|dz
|
|dz
|
z |dz
|
z dz }d} |dz }|dkD rt ||« }
|
|| z
|
} | |
|
z } t t | | d« |« } | | }|dk( r$t t ||dz « |« }d| | z |z
|
}||
|
z
|
} |} t t | | « |« }|| |< ||
|
z }|dkD rt ||« }
|
| | z dz
|
} | |
|
z
|
} t t | | d« |« }| | }|dk( r&t t | dz
|
| « |« }d| | z |z
|
}| j | |z
|
} | |
|
z } t t | | « |« }|| |< ||
|
z }||fS )a5
|
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'.
|
original_period : int
|
Original length of data on `axis` of `arr`.
|
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 rN Úoddé ©r, Úminr r )r4 r r8 ÚmethodÚoriginal_periodÚ include_edgeÚleft_padÚ right_padÚ
|
old_lengthÚ edge_offsetÚ chunk_lengthrF rE r: r^ Ú
|
edge_sliceÚpad_arear; r` s r Ú_set_reflect_bothrr ' s ð8 %ÑHiØ dÑ# iÑ/°(Ñ:Jáð ?Ñ2°_ÑD
|
à ð
|
" A~¨?¸QÑ+>Ñ?Ø Ñ"ñ$Ø&'ñ(
|
à Øa
|
à!|ô : xÓ0 à+Ñ%Ø|Ñ#Ü#¤E¨%°°rÓ$:¸DÓA
|
ØJÑ'
|
à U?ä'¬¨h¸À1¹ Ó(EÀtÓLJØV JÑ /Ñ/°*Ñ<Jð <Ñ'ØÜ!¤%¨¨tÓ"4°dÓ;Ø%xÑàLÑ à1}ô : yÓ1 à
|
[Ñ(¨1Ñ,Ø|Ñ#Ü$¤U¨5°$¸Ó%;¸TÓB Ø [Ñ) à U?ä'Üyj 1n y jÓ1°4ó9Jàf ZÑ 0Ñ0°;Ñ>Kð TÑ" YÑ.Ø|Ñ#Ü!¤%¨¨tÓ"4°dÓ;Ø&xÑà\Ñ! à YÐ Ð r c ó* |\ }}| j | |z
|
|z
|
}||z |z }d}d}|dkD rn||z } | t ||« z
|
}
|
t t |
|
| « |« } | | } ||kD r t t ||z
|
|« |« } ||z
|
}nt t d|« |« } | | | < |dkD rr| |z
|
}
|
|
|
t ||« z } t t |
|
| « |« }| | }||kD r!t t | | |z « |« } ||z
|
}nt t | d« |« } || | < ||fS )aH
|
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.
|
original_period : int
|
Original length of data on `axis` of `arr`.
|
|
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 Nrf )r4 r r8 ri rk rl ÚperiodÚ new_left_padÚ new_right_padÚ slice_endÚ slice_startr; r` rq r: r^ s r Ú_set_wrap_bothry sm ð, %ÑHiØ \\$Ñ )Ñ +¨hÑ 6Fð Ñ &¨ Ñ 8Fð LØMà!|ð
|
vÑ% Ø ¤# f¨hÓ"7Ñ7 Ü$¤U¨;¸ Ó%BÀDÓI Ø [Ñ) à fÒ ä%¤e¨H°vÑ,=¸xÓ&HÈ$ÓOHØ# fÑ,Lô &¤e¨D°(Ó&;¸TÓBHØ&xÑà1}ð
|
!j 6Ñ) Ø ¤# f¨iÓ"8Ñ8 Ü#¤E¨+°yÓ$AÀ4ÓH
|
ØJÑ'
|
à vÒ ä%Üyj 9 *¨vÑ"5Ó6¸ó>Hà %¨Ñ .Mô &¤e¨Y¨J¸Ó&=¸tÓDHØ%xÑà Ð &Ð&r c ó | d|z S t j | « } |r4t j | « j t j d¬« } | j
|
dk r| j dk( r0| j « } |r| dk r t d« | d | d ff|z S | j dk( rJ| j d k7 r;| j « } |r| d dk s| d dk r t d« | d | d ff|z S |r | j « dk r t d« t j | |df« j « 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).
|
))NNF)Úcopyé r r z#index can't contain negative valuesre )re r ) r r r ÚastypeÚintpÚndimr" ÚravelrX r, rg Ú broadcast_toÚtolist)Úxr Úas_indexs r Ú _as_pairsr
Õ s2 ð8 yð Ñ%Ð%ä
|
AÙÜ HHQK× Ñ rww¨UÐ Ó 3àvvzð
|
66Q;à AÙA EÜ Ð!FÓGÐGØqT1Q4L? TÑ)Ð )à 66Q;177 fÒ,ð
|
AÙQqT AX¨¨1©°ªÜ Ð!FÓGÐGØqT1Q4L? TÑ)Ð )áAEEGaKÜÐ>Ó?Ð?ô ??1t QiÓ (× /Ñ /Ó 1Ð1r c ó | fS r r )r r1 ÚmodeÚkwargss r Ú_pad_dispatcherr s Ø 8Or Únumpy)Úmodulec óh t j | « } t j |« }|j j dk( s t d« t || j d¬« }t |« r|}t | |d¬« \ }}t |j « D ]R }t j ||d« }t |j dd « } d | D « } | D ] }
|
|||
|
|| ||« T |S g g g d
|
gd gd gd gd gd gd gd gd } t |« t | | « z
|
} | rt d| d| « t j t j" t j$ t j& d} t | |« \ }}t |j « }|dk( r[|j) d
|
d« }t ||j « }t+ |||« D ]! \ }}}t- |||« }t/ ||||« # |S |dk( r |S | j0 dk( rCt+ ||« D ]2 \ }}| j | dk( st3 |« s%t d| d« |S |dk( r>t+ ||« D ]- \ }}t- |||« }t5 |||« }t/ ||||« / |S |dk( ri|j) d d« }t ||j « }t+ |||« D ]/ \ }}}t- |||« }t7 ||||« }t/ ||||« 1 |S || v rp| | }|j) d « }t ||j d¬« }t+ |||« D ]0 \ }}}t- |||« }t9 |||||« }t/ ||||« 2 |S |dv r²|j) d d« }|d k( } t+ ||« D ] \ }\ } } | j | d k( r*| dkD s| dkD r t5 ||| | f« }t/ ||| | f|« Et- |||« }| dkD s| dkD s]t; ||| | f|| j | | « \ } } | dkD r(| dkD r. |S |d k( rct+ ||« D ]T \ }\ } } t- |||« }|j | | z
|
| z
|
} | dkD s| dkD s6t= ||| | f| « \ } } | dkD r| dkD r V |S # t $ r t d| d« dw xY w) 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.
|
|
<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
|
-----
|
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
|
--------
|
>>> import numpy as np
|
>>> 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)r r )r2 rN Nc 3 ó0 K | ] }|t fz y wr )ÚEllipsis)r! Úinds r r% zpad.<locals>.<genexpr> s è ø Ò6¨#C8+Õ%Ñ6ùs Úconstant_valuesÚ
|
end_valuesÚ stat_lengthÚ reflect_type) r/ rL ÚwrapÚconstantÚ linear_rampÚmaximumÚmeanÚmedianÚminimumÚreflectÚ symmetriczmode 'z' is not supportedz(unsupported keyword arguments for mode 'z': )r r r r r r/ zcan't extend empty axis z- using modes other than 'constant' or 'empty'rL r > r r Úevenr r r ) r Úasarrayr ÚkindÚ TypeErrorr
r Úcallabler5 ÚrangeÚmoveaxisr r, ÚsetÚKeyErrorrX rV rW r r Úgetr+ r r< r" ÚanyrB rS rb rr ry ) r r1 r r Úfunctionr4 Ú_r ÚviewÚindsr Úallowed_kwargsÚunsupported_kwargsÚstat_functionsr ÚaxesÚvaluesr8 r9 ÚroirP r Ú ramp_pairÚfuncÚlengthrY Ú stat_pairrh rj r> r@ ri s r r r s¶ ôZ JJuÓ EÜ
|
|
9Ó%Ià ??× Ñ 3Ò &ÜÐ?Ó@Ð@ô ) U§Z¡Z¸$Ô?Iä~àä y¸QÔ? ô &++Ó&ò CDô
|
;;v t¨RÓ0Dô 4:: c r?Ó+DÙ6°Ô6DØò CÙc I¨d¡O°T¸6ÕBñ Cð Cð ð R¨Ø&Ð'Ø$~Ø!?Ø Ø /Ø!?Ø"Ð#Ø$Ð%ñ
|
NðFÜ [¬3¨~¸dÑ/CÓ+DÑ DÐñ Üð Ø !F #Ð&8Ð%9ð;ó <ð <ô "$§¡´R·W±WÜ gg´·±ñ<Nô
|
#.¨e°YÓ"?Ñ FÐ ô Ó Dà zÒØÐ -¨qÓ1Ü6 6§;¡;Ó/Ü,/°°iÀÓ,Hò =Ñ (D*jÜFÐ$7¸Ó>CÜ #t Z°Õ <ð =ðX MðQ
|
Ø ðN MðK
|
q ô !$ D¨)Ó 4ò Ñ D*Ø{{4Ñ AÓ%¬#¨j/Ü Ø.¨t¨fð 5,ð ,óð ð ðB Mðq
|
Ü # D¨)Ó 4ò <Ñ D*ÜFÐ$7¸Ó>CÜ" 3¨¨jÓ9IÜ #t Z°Õ ;ð <ðn Mðe
|
Ò ØZZ ¨aÓ0
|
Ü z¨6¯;©;Ó7
|
Ü,/°°iÀÓ,Lò <Ñ (D*jÜFÐ$7¸Ó>CÜ)¨#¨t°ZÀÓLIÜ #t Z°Õ ;ð <ð^ MðU
|
Ñ Ø dÑ#ØMÓ*Ü6 6§;¡;¸Ô>Ü-0°°yÀ&Ó-Iò <Ñ )D*kÜFÐ$7¸Ó>CÜ" 3¨¨j¸+ÀtÓLIÜ #t Z°Õ ;ð <ðL MðC
|
Ð)Ñ )ØN¨FÓ3Ø{Ñ* Ü/2°4¸Ó/Cò Ñ +DÑ+:{Ø{{4Ñ AÒ%¨:¸ª>¸[È1º_ô ' v¨t°jÀ+Ð5NÓ O Ü ØD :¨{Ð";¸YôHàäFÐ$7¸Ó>CØ q. K°!£Oô +<Ø
|
¨KÐ 8ØEKK¨Ñ -¨|ó+Ñ'
|
Kð q. K°!¤Oð ð< Mð
|
Ü/2°4¸Ó/Cò KÑ +DÑ+:{ÜFÐ$7¸Ó>CØ $ll¨4Ñ 0°;Ñ >ÀÑ KOØ q. K°!£Oô +9Ø
|
¨KÐ 8¸/ó+KÑ'
|
Kð q. K°!¤Oð Kð Møô ò FÜ6 $ Ð'9Ð:Ó;ÀÐEðFús ÄR ÒR1r )F)r )Ú__doc__r r Únumpy._core.overridesr Ú numpy.lib._index_tricks_implr Ú__all__r r r r5 r< rB rS rb rr ry r
r r r r r ú<module>r» s ðñó
|
Ý 9Ý 0à 'ò ò 2ò2ó8('òV(ò2 !ò@)!òX?!ðF 5:ó^ òBJ'óZ@2óFñ °Ô9òYó :ñYr
|
