DdR[ 5 5 5 5 5 5n#/ #/ #/ #/J 4T[= = = = = =| &.CK4T[ 0 2 ;T NA NA NA NA`-:-: -: -: -: -:^%:%: %: %: %: %:N .2&*Q> Q> Q> Q>f $ a a a aF $ i i i iVV V V Vp2 2 2 2 2 5 5 5 5 5 6 < D|J''Hl9%%G
\(
#
#Fl9%%G|J''H33444A [))I1 1 1 1 f
5
5
5
5 &< &< &< &">">r"BEKKKC ! )E s !A; ;:B87B8c 6 t j d S )Nr )r rj r s r rj z mvoid._data s ww}R r c | j }t || t r4t | j | || | j | | j S |t ur|| rt S | j | S )z!
Get the index.
)rm ro rM r ) rq r! r rx rj r r r rw )r} r r s r r zmvoid.__getitem__ s
J agw ' ' * Z%AdG +D1 .* * *
*
F??qw?Mz$ r c || j |< | j r&| j |xx t |dd z cc< d S t |dd | j |< d S )Nrq F)rj r rq r )r} r r- s r r zmvoid.__setitem__ sf
4 > > Jt w > > > &ugu = =DJt r c $ | j }|t u rt | j S t | j j d }t
j }| | }t || j t t | S )Nr )
rq r r+ rj r r r r r] r )r} r r data_arrrI r s r r z
mvoid.__str__ sq J ;;tz?? "&tz'7==77=oof%% sDJ0CDDD3xxr c # K | j | j }}|t u r
|E d{V dS t || D ]\ }}|r
t V |V dS )z Defines an iterator for mvoidN)rj rq r r= rw )r} rj rq r r s r r zmvoid.__iter__ s *dj F?? eU++
A LLLLGGGG
r c 4 | j S r )rj __len__r s r rJ z
mvoid.__len__ s z!!###r c R t | | d S )aA
Return a copy with masked fields filled with a given value.
Parameters
----------
fill_value : array_like, optional
The value to use for invalid entries. Can be scalar or
non-scalar. If latter is the case, the filled array should
be broadcastable over input array. Default is None, in
which case the `fill_value` attribute is used instead.
Returns
-------
filled_void
A `np.void` object
See Also
--------
MaskedArray.filled
r )r0 rN )r} rM s r rN z mvoid.filled s# , t}}##J//33r c 4 | j }|t u r| j S g }t | j | j D ]D\ }}|r| d | | Et | S )z
Transforms the mvoid object into a tuple.
Masked fields are replaced by None.
Returns
-------
returned_tuple
Tuple of fields
N)rq r rj r r= r" r? r )r} rq rU r r s r r z mvoid.tolist3 s
F??:$$&& &$*dj11 ( (FQ
(
d####
affhh''''V}} r r )r r r r r r r6 rj r r r r[ r rJ rN r r r s @r r r s "(t U$ ( ! ! ! ! X! ,> > > H
$ $ $4 4 4 40 r r c , t | t S )a
Test whether input is an instance of MaskedArray.
This function returns True if `x` is an instance of MaskedArray
and returns False otherwise. Any object is accepted as input.
Parameters
----------
x : object
Object to test.
Returns
-------
result : bool
True if `x` is a MaskedArray.
See Also
--------
isMA : Alias to isMaskedArray.
isarray : Alias to isMaskedArray.
Examples
--------
>>> import numpy.ma as ma
>>> a = np.eye(3, 3)
>>> a
array([[ 1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 1.]])
>>> m = ma.masked_values(a, 0)
>>> m
masked_array(
data=[[1.0, --, --],
[--, 1.0, --],
[--, --, 1.0]],
mask=[[False, True, True],
[ True, False, True],
[ True, True, False]],
fill_value=0.0)
>>> ma.isMaskedArray(a)
False
>>> ma.isMaskedArray(m)
True
>>> ma.isMaskedArray([0, 1, 2])
False
)r! r r s r re re P s ` a % %%r c e Zd ZdZed Zd Z fdZddZddZ d Z
d Z d Z d
Z
d ZexZxZxZxZxZZ[d Zd
Zd Z fdZ xZS )r` Nc @ | j d uot | j | u S r )_MaskedConstant__singletonr^ )re s r __has_singletonz MaskedConstant.__has_singleton s% d*KtCO/D/D/KKr c
| sit j d }t j d }d|j _ d|j _ t || | | _ | j S )Nr TFr ) _MaskedConstant__has_singletonr r r writeabler rl rQ )re rm ro s r r zMaskedConstant.__new__ su ""$$
E 8B<>D $)DJ #(DJ
*$T : : : ? ? D DCO r c | s!t | S | | j u rd S t | _ t | | d S r )rT r r rQ r r )r} r r s r r z!MaskedConstant.__array_finalize__ si ##%% 6 77--c22 2
T%
%
% D )DN * *4 5 5 5 5 5r c ^ | t || S r )rl r __array_prepare__r} r r s r rX z MaskedConstant.__array_prepare__ s$ yy%%77WEEEr c ^ | t || S r )rl r r rY s r r z MaskedConstant.__array_wrap__ s$ yy%%44S'BBBr c 4 t t j S r )r+ r rM r s r r zMaskedConstant.__str__ s &/000r c V | t j u rdS t | S )Nrw )r` rQ rJ r[ r s r r[ zMaskedConstant.__repr__ s) >- - -8 ??4(( (r c t | | S # t $ r: t j dt
d t | d cY S w xY w)NzjFormat strings passed to MaskedConstant are ignored, but in future may error or produce different behaviorr r r )rJ
__format__r r r
FutureWarning)r} format_specs r r^ zMaskedConstant.__format__ sy /$$T;77 7 / / / M6 !
$$T2.. . . . /s AA! A!c | j dfS )z.Override of MaskedArray's __reduce__.
r r r s r r zMaskedConstant.__reduce__ s ##r c | S r r rR s r __iop__zMaskedConstant.__iop__ r r c | S )z: Copy is a no-op on the maskedconstant, as it is a scalar r )r} r r s r r= zMaskedConstant.copy s r c | S r r r s r __copy__zMaskedConstant.__copy__ r r c | S r r )r} r* s r r- zMaskedConstant.__deepcopy__ r r c | s"t || S | | j u rt d| d t || S )Nzattributes of z are not writeable)rT r __setattr__rQ rk )r} attrr- r s r ri zMaskedConstant.__setattr__ s{ ##%% 477&&tU33 3
T%
%
% ;;;;= =
=
77&&tU33 3r r )r r r rQ classmethodrT r r rX r r r[ r^ r rc r r r r r r r= rf r- ri r r s @r r` r` s_ KL L [L
$ 6 6 6 6 6 F F F FC C C C1 1 1) ) )
/
/
/ $ $ $
H
4
4
4
4
4
4
4
4
4r r` c
6 t | |||| ||||
|| S )z~
Shortcut to MaskedArray.
The options are in a different order for convenience and backwards
compatibility.
)
ro r r= ri r r rM r r r )r ) rm r r= r ro rM r r r ri r s r r r s8 t$e$ "i!*z "6 @ @ @ @r c f t | }|t u rdS | rdS dS )a
Determine whether input has masked values.
Accepts any object as input, but always returns False unless the
input is a MaskedArray containing masked values.
Parameters
----------
x : array_like
Array to check for masked values.
Returns
-------
result : bool
True if `x` is a MaskedArray with masked values, False otherwise.
Examples
--------
>>> import numpy.ma as ma
>>> x = ma.masked_equal([0, 1, 0, 2, 3], 0)
>>> x
masked_array(data=[--, 1, --, 2, 3],
mask=[ True, False, True, False, False],
fill_value=0)
>>> ma.is_masked(x)
True
>>> x = ma.masked_equal([0, 1, 0, 2, 3], 42)
>>> x
masked_array(data=[0, 1, 0, 2, 3],
mask=False,
fill_value=42)
>>> ma.is_masked(x)
False
Always returns False if `x` isn't a MaskedArray.
>>> x = [False, True, False]
>>> ma.is_masked(x)
False
>>> x = 'a string'
>>> ma.is_masked(x)
False
FT)rY r r! )r r s r rg rg s8 Z
AF{{u
t 5r c B e Zd ZdZ fdZd Zej fdZd Z xZ
S )_extrema_operationz
Generic class for maximum/minimum functions.
.. note::
This is the base class for `_maximum_operation` and
`_minimum_operation`.
c f t | || _ || _ d S r )r r~ rH fill_value_func)r} r rH rM r s r r~ z_extrema_operation.__init__S s0
) r c L t | || || S )r )r rH r| s r r z_extrema_operation.__call__X s$ T\\!Q''A...r c t |dd }t | }|t j u r:|j dk r/t j d| j d| j dt d d
}|t j urt | }nt }|t u r | j j |fi |}n|
| | t! | } | j j |fi |}t# j j |fi |}t' |d r||_ n |rt* }|S )
z#Reduce target along the given axis.FTrh r z!In the future the default for ma.z:.reduce will be axis=0, not the current None, to match np.z;.reduce. Explicitly pass 0 or None to silence this warning.r r Nr rq )r rY r r
r r r r r r[ r r r rN rq rl r^ r ro r" rq rw )r} r r r r r s r r z_extrema_operation.reduce] st U$777 FOO 2; 6;?? MEDM E E59]E E E )Q
8
8
8
8
D r{ " "t___FFVVF ;;
f////AA]]$$V,,. ..2d4<<.@.@
f////A!(55f55Aq'""
r c t | }t | }|t u r|t u rt }n9t | }t | }t || }| j t
| t
| }t |t s| t }||_
|S )z$>> 74D999;CJ r c | j r t | }|d |c}|d< t | }| j }t t | |d }|t t | } ||g|R i |S r )r ru r/ r r r^ r )r} rS r rx marr method_namemethods r r z_frommethod.__call__ s = $::D a!JAtAw!}}m d[$77 > R--Fvd,T,,,V,,,r Nr. )r r r r r~ r r r r r r~ r~ sP ! ! ! !
- - - - -r r~ r r r! r8 )r rB rC r= rF r] r` r r r r r rE r r r r r r rA r c R t | } | |||| S )z
)r rt r )rx r )rS ra r rt r s r r r s) QA 66'#D6 9 99r c |t d t | }t | }t || }t | }t | }t | t
rt
| }nt
}t j dd 5 t j ||t j || | } ddd n # 1 swxY w Y |
| t j t j | t }
|t" ur(| j st& S t j ||
| _ |
r2| j st& S | j t" u r|
| _ | j | j |
< | S )a
Returns element-wise base array raised to power from second array.
This is the masked array version of `numpy.power`. For details see
`numpy.power`.
See Also
--------
numpy.power
Notes
-----
The *out* argument to `numpy.power` is not supported, `third` has to be
None.
Examples
--------
>>> import numpy.ma as ma
>>> x = [11.2, -3.973, 0.801, -1.41]
>>> mask = [0, 0, 0, 1]
>>> masked_x = ma.masked_array(x, mask)
>>> masked_x
masked_array(data=[11.2, -3.973, 0.801, --],
mask=[False, False, False, True],
fill_value=1e+20)
>>> ma.power(masked_x, 2)
masked_array(data=[125.43999999999998, 15.784728999999999,
0.6416010000000001, --],
mask=[False, False, False, True],
fill_value=1e+20)
>>> y = [-0.5, 2, 0, 17]
>>> masked_y = ma.masked_array(y, mask)
>>> masked_y
masked_array(data=[-0.5, 2.0, 0.0, --],
mask=[False, False, False, True],
fill_value=1e+20)
>>> ma.power(masked_x, masked_y)
masked_array(data=[0.29880715233359845, 15.784728999999999, 1.0, --],
mask=[False, False, False, True],
fill_value=1e+20)
Nz 3-argument power not supported.r r )r rY rv rX r! r r^ r r r r r rl r rp rp r r r rw rq rq r! rM rj ) rS r thirdr r r fafbr@ rU rr s r r r s V
9::: B BBA B B![!! 77 Hh 7 7 7 E E!RR!4!455::8DDE E E E E E E E E E E E E E E
nR[W)=)= > >??G{ M}Q00 {{}} 2{ #M
\V
#
#"FL & 1 W Ms =C))C-0C-r, r+ c t j | } |t j u rt | }t | t
r| ||||| S | ||| S )z)Function version of the eponymous method.r r( r r rM r )r r/ r
r r! r r- rS r r( r r rM s r r- r- T s
aA r{&q))![!! <yydU!(Z A A A yydUy;;;r r c t j | dd } || } d}t | t r| ||||| n| ||| | S )a
Return a sorted copy of the masked array.
Equivalent to creating a copy of the array
and applying the MaskedArray ``sort()`` method.
Refer to ``MaskedArray.sort`` for the full documentation
See Also
--------
MaskedArray.sort : equivalent method
Examples
--------
>>> import numpy.ma as ma
>>> x = [11.2, -3.973, 0.801, -1.41]
>>> mask = [0, 0, 0, 1]
>>> masked_x = ma.masked_array(x, mask)
>>> masked_x
masked_array(data=[11.2, -3.973, 0.801, --],
mask=[False, False, False, True],
fill_value=1e+20)
>>> ma.sort(masked_x)
masked_array(data=[-3.973, 0.801, 11.2, --],
mask=[False, False, False, True],
fill_value=1e+20)
Trh Nr r r )r r r r! r r r s r r r c s 8 T***A |
IIKK![!! 2 Dt5 : 7 7 7 7
Dt5111 Hr c D t | S )ag
Return all the non-masked data as a 1-D array.
This function is equivalent to calling the "compressed" method of a
`ma.MaskedArray`, see `ma.MaskedArray.compressed` for details.
See Also
--------
ma.MaskedArray.compressed : Equivalent method.
Examples
--------
Create an array with negative values masked:
>>> import numpy as np
>>> x = np.array([[1, -1, 0], [2, -1, 3], [7, 4, -1]])
>>> masked_x = np.ma.masked_array(x, mask=x < 0)
>>> masked_x
masked_array(
data=[[1, --, 0],
[2, --, 3],
[7, 4, --]],
mask=[[False, True, False],
[False, True, False],
[False, False, True]],
fill_value=999999)
Compress the masked array into a 1-D array of non-masked values:
>>> np.ma.compressed(masked_x)
array([1, 0, 2, 3, 7, 4])
)r/ r9 rN s r r9 r9 s F a== # # % %%r c X t j d | D | }t | }| | }| D ]}t | t
ur n|S t j d | D | }| |j }t | |_ |S )aI
Concatenate a sequence of arrays along the given axis.
Parameters
----------
arrays : sequence of array_like
The arrays must have the same shape, except in the dimension
corresponding to `axis` (the first, by default).
axis : int, optional
The axis along which the arrays will be joined. Default is 0.
Returns
-------
result : MaskedArray
The concatenated array with any masked entries preserved.
See Also
--------
numpy.concatenate : Equivalent function in the top-level NumPy module.
Examples
--------
>>> import numpy.ma as ma
>>> a = ma.arange(3)
>>> a[1] = ma.masked
>>> b = ma.arange(2, 5)
>>> a
masked_array(data=[0, --, 2],
mask=[False, True, False],
fill_value=999999)
>>> b
masked_array(data=[2, 3, 4],
mask=False,
fill_value=999999)
>>> ma.concatenate([a, b])
masked_array(data=[0, --, 2, 2, 3, 4],
mask=[False, True, False, False, False, False],
fill_value=999999)
c , g | ]}t | S r )rX r_ s r r z concatenate.. s 333q
333r c , g | ]}t | S r r r_ s r r z concatenate.. s 999Q a 999r )
r r: rf rl rY r r r r rq )rb r r rc rm r dms r r: r: s R 33F333T::A 'D 66$<>> import numpy as np
>>> x = np.array([[11.2, -3.973, 18], [0.801, -1.41, 12], [7, 33, -12]])
>>> masked_x = np.ma.masked_array(x, mask=x < 0)
>>> masked_x
masked_array(
data=[[11.2, --, 18.0],
[0.801, --, 12.0],
[7.0, 33.0, --]],
mask=[[False, True, False],
[False, True, False],
[False, False, True]],
fill_value=1e+20)
Isolate the main diagonal from the masked array:
>>> np.ma.diag(masked_x)
masked_array(data=[11.2, --, --],
mask=[False, True, True],
fill_value=1e+20)
Isolate the first diagonal below the main diagonal:
>>> np.ma.diag(masked_x, -1)
masked_array(data=[0.801, 33.0],
mask=[False, False],
fill_value=1e+20)
)r rE rl r rY r rq )r, r r3 s r rE rE sM X WQ]]
,
,Fqzz wqw** Mr c t | }|t u r1t j t | | }t | S t j t | d | }t || S )z
Shift the bits of an integer to the left.
This is the masked array version of `numpy.left_shift`, for details
see that function.
See Also
--------
numpy.left_shift
r r )rY r r ri rN rx rS r r r s r ri ri si
AF{{ VAYY * *A VAq\\1 - -AA&&&&r c t | }|t u r1t j t | | }t | S t j t | d | }t || S )a
Shift the bits of an integer to the right.
This is the masked array version of `numpy.right_shift`, for details
see that function.
See Also
--------
numpy.right_shift
Examples
--------
>>> import numpy.ma as ma
>>> x = [11, 3, 8, 1]
>>> mask = [0, 0, 0, 1]
>>> masked_x = ma.masked_array(x, mask)
>>> masked_x
masked_array(data=[11, 3, 8, --],
mask=[False, False, False, True],
fill_value=999999)
>>> ma.right_shift(masked_x,1)
masked_array(data=[5, 1, 4, --],
mask=[False, False, False, True],
fill_value=999999)
r r )rY r r r rN rx r s r r r 5 si 6
AF{{ fQii + +A fQllA . .AA&&&&r c | ||| S # t $ r* t | d ||| cY S w xY w)z
Set storage-indexed locations to corresponding values.
This function is equivalent to `MaskedArray.put`, see that method
for details.
See Also
--------
MaskedArray.put
r Fr )r rk r )rS ra r r s r r r Y sm EuuWf4u000 E E Eae$$$((&t(DDDDDEs 1A
Ac t | t s| t } t | t | }}t | t
u rL|t
urBd| _ t | j | j | _
t j | j
|| n| j
rJ|t
ur@| j
}t j ||| | xj |z c_ n4|t
u rt! | }t j | j
|| t j | j || dS )aQ
Changes elements of an array based on conditional and input values.
This is the masked array version of `numpy.putmask`, for details see
`numpy.putmask`.
See Also
--------
numpy.putmask
Notes
-----
Using a masked array as `values` will **not** transform a `ndarray` into
a `MaskedArray`.
Tr N)r! r rl rX rY r r ru r r rq r r r r= ro rZ rj )rS ro r valdatavalmaskr s r r r l s( $ a % %
FF; !&//76??gWqzzV & AM$QWag66AG Iagwd 3 3 3 3
0 & A Ia - - - -
FFaKFF f "6**G
!'7$////Iagwd++++
Fr c | | S # t $ r? t | d | t cY S w xY w)a
Permute the dimensions of an array.
This function is exactly equivalent to `numpy.transpose`.
See Also
--------
numpy.transpose : Equivalent function in top-level NumPy module.
Examples
--------
>>> import numpy.ma as ma
>>> x = ma.arange(4).reshape((2,2))
>>> x[1, 1] = ma.masked
>>> x
masked_array(
data=[[0, 1],
[2, --]],
mask=[[False, False],
[False, True]],
fill_value=999999)
>>> ma.transpose(x)
masked_array(
data=[[0, 2],
[1, --]],
mask=[[False, False],
[False, True]],
fill_value=999999)
Fr )r rk r rl r )rS r s r r r so @G{{4 G G Gae$$$..t4499+FFFFFGs AA A r c | || S # t $ rC t | d || }| t cY S w xY w)z
Returns an array containing the same data with a new shape.
Refer to `MaskedArray.reshape` for full documentation.
See Also
--------
MaskedArray.reshape : equivalent function
r Fr )r rk r rl r )rS new_shaper _tmps r r r su &yy%y000 & & &ae$$$,,Ye,DDyy%%%%%&s A
A&%A&c t | }|t urt j || }t j | | t | }|j r||_ |S )a
Return a new masked array with the specified size and shape.
This is the masked equivalent of the `numpy.resize` function. The new
array is filled with repeated copies of `x` (in the order that the
data are stored in memory). If `x` is masked, the new array will be
masked, and the new mask will be a repetition of the old one.
See Also
--------
numpy.resize : Equivalent function in the top level NumPy module.
Examples
--------
>>> import numpy.ma as ma
>>> a = ma.array([[1, 2] ,[3, 4]])
>>> a[0, 1] = ma.masked
>>> a
masked_array(
data=[[1, --],
[3, 4]],
mask=[[False, True],
[False, False]],
fill_value=999999)
>>> np.resize(a, (3, 3))
masked_array(
data=[[1, 2, 3],
[4, 1, 2],
[3, 4, 1]],
mask=False,
fill_value=999999)
>>> ma.resize(a, (3, 3))
masked_array(
data=[[1, --, 3],
[4, 1, --],
[3, 4, 1]],
mask=[[False, True, False],
[False, False, True],
[False, False, False]],
fill_value=999999)
A MaskedArray is always returned, regardless of the input type.
>>> a = np.array([[1, 2] ,[3, 4]])
>>> ma.resize(a, (3, 3))
masked_array(
data=[[1, 2, 3],
[4, 1, 2],
[3, 4, 1]],
mask=False,
fill_value=999999)
)rY r r r rl rf r rq )r r r rU s r r r sh n
A Ia # #
Yq)
$
$
)
)*=a*@*@
A
AF
{ Mr c D t j t | S )z5
maskedarray version of the numpy function.
)r r rX r# s r r r s
773<< r c D t j t | S *maskedarray version of the numpy function.)r r rX r# s r r r s
8GCLL ! !!r c F t j t | | S r )r r rX )r r s r r r s
773<< & &&r c |dk r| S |dk r t dt | z t j | } | j dk rt d g }|t j urzt j | }|j dk r;t | j }d||< t j |t | }| | | | |t j urzt j | }|j dk r;t | j }d||< t j |t | }| | t | dk r t j
|| } t j | || S )a
Calculate the n-th discrete difference along the given axis.
The first difference is given by ``out[i] = a[i+1] - a[i]`` along
the given axis, higher differences are calculated by using `diff`
recursively.
Preserves the input mask.
Parameters
----------
a : array_like
Input array
n : int, optional
The number of times values are differenced. If zero, the input
is returned as-is.
axis : int, optional
The axis along which the difference is taken, default is the
last axis.
prepend, append : array_like, optional
Values to prepend or append to `a` along axis prior to
performing the difference. Scalar values are expanded to
arrays with length 1 in the direction of axis and the shape
of the input array in along all other axes. Otherwise the
dimension and shape must match `a` except along axis.
Returns
-------
diff : MaskedArray
The n-th differences. The shape of the output is the same as `a`
except along `axis` where the dimension is smaller by `n`. The
type of the output is the same as the type of the difference
between any two elements of `a`. This is the same as the type of
`a` in most cases. A notable exception is `datetime64`, which
results in a `timedelta64` output array.
See Also
--------
numpy.diff : Equivalent function in the top-level NumPy module.
Notes
-----
Type is preserved for boolean arrays, so the result will contain
`False` when consecutive elements are the same and `True` when they
differ.
For unsigned integer arrays, the results will also be unsigned. This
should not be surprising, as the result is consistent with
calculating the difference directly:
>>> u8_arr = np.array([1, 0], dtype=np.uint8)
>>> np.ma.diff(u8_arr)
masked_array(data=[255],
mask=False,
fill_value=999999,
dtype=uint8)
>>> u8_arr[1,...] - u8_arr[0,...]
255
If this is not desirable, then the array should be cast to a larger
integer type first:
>>> i16_arr = u8_arr.astype(np.int16)
>>> np.ma.diff(i16_arr)
masked_array(data=[-1],
mask=False,
fill_value=999999,
dtype=int16)
Examples
--------
>>> a = np.array([1, 2, 3, 4, 7, 0, 2, 3])
>>> x = np.ma.masked_where(a < 2, a)
>>> np.ma.diff(x)
masked_array(data=[--, 1, 1, 3, --, --, 1],
mask=[ True, False, False, False, True, True, False],
fill_value=999999)
>>> np.ma.diff(x, n=2)
masked_array(data=[--, 0, 2, --, --, --],
mask=[ True, False, False, True, True, True],
fill_value=999999)
>>> a = np.array([[1, 3, 1, 5, 10], [0, 1, 5, 6, 8]])
>>> x = np.ma.masked_equal(a, value=1)
>>> np.ma.diff(x)
masked_array(
data=[[--, --, --, 5],
[--, --, 1, 2]],
mask=[[ True, True, True, False],
[ True, True, False, False]],
fill_value=1)
>>> np.ma.diff(x, axis=0)
masked_array(data=[[--, --, --, 1, -2]],
mask=[[ True, True, True, False, False]],
fill_value=1)
r z#order must be non-negative but got z4diff requires input that is at least one dimensionalr )rI r1 r r r/ r r
ru r rG r r" r< r: rG )rS r r prependr" combinedr s r rG rG " s D Avv1uu>aHIII
Av{{ B Hbk!!%""7++ <1 MMEE$KoguU||<>> x = np.ma.array(np.arange(9.).reshape(3, 3), mask=[[0, 1, 0],
... [1, 0, 1],
... [0, 1, 0]])
>>> x
masked_array(
data=[[0.0, --, 2.0],
[--, 4.0, --],
[6.0, --, 8.0]],
mask=[[False, True, False],
[ True, False, True],
[False, True, False]],
fill_value=1e+20)
>>> np.ma.where(x > 5, x, -3.1416)
masked_array(
data=[[-3.1416, --, -3.1416],
[--, -3.1416, --],
[6.0, --, 8.0]],
mask=[[False, True, False],
[ True, False, True],
[False, True, False]],
fill_value=1e+20)
Tr z)Must provide both 'x' and 'y' or neither.r Fr r r )r
rA rI r rN rX rZ rw r r r r r r rx ) r' r r missingr xdydcmxmymrm ro s r r r s p H}a8m,22488G!||DEEE!||y!!!
5 ! !B B B
i B a B a B F{{q
Xb
)
)
)
WR
)
)
)
f&
Xb
)
)
)
WR
)
)
)
8BB D
8BB D
8B$*555t < >> choice = np.array([[1,1,1], [2,2,2], [3,3,3]])
>>> a = np.array([2, 1, 0])
>>> np.ma.choose(a, choice)
masked_array(data=[3, 2, 1],
mask=False,
fill_value=999999)
c 6 | t u rdS t | S )z,Returns the filled array, or True if masked.T)rw rN rN s r fmaskzchoose..fmask6 s ;;4ayyr c 6 | t u rdS t | S )z:Returns the mask, True if ``masked``, False if ``nomask``.T)rw rY rN s r nmaskzchoose..nmask< s ;;4qzzr r c & g | ]
} | S r r )r r r s r r zchoose..D s! ' ' '!UU1XX ' ' 'r c & g | ]
} | S r r )r r r s r r zchoose..E s! & & &EE!HH & & &r r FTr )r rt )
rN r r5 rs rv rY rl r r! rw ) ra choicesrt r r masksrm
outputmaskr r r s @@r r5 r5 s Z wA ' ' ' 'w ' ' 'E & & & &g & & &D1e$///J7:ww/?/?@@ %d4 4 4J !T#...33K@@A
c; ' ' ( OOJ ' ' '
MM* Hr c |t j | || S t j t | || t |d rt | |_ |S )a
Return a copy of a, rounded to 'decimals' places.
When 'decimals' is negative, it specifies the number of positions
to the left of the decimal point. The real and imaginary parts of
complex numbers are rounded separately. Nothing is done if the
array is not of float type and 'decimals' is greater than or equal
to 0.
Parameters
----------
decimals : int
Number of decimals to round to. May be negative.
out : array_like
Existing array to use for output.
If not given, returns a default copy of a.
Notes
-----
If out is given and does not have a mask attribute, the mask of a
is lost!
Examples
--------
>>> import numpy.ma as ma
>>> x = [11.2, -3.973, 0.801, -1.41]
>>> mask = [0, 0, 0, 1]
>>> masked_x = ma.masked_array(x, mask)
>>> masked_x
masked_array(data=[11.2, -3.973, 0.801, --],
mask=[False, False, False, True],
fill_value=1e+20)
>>> ma.round_(masked_x)
masked_array(data=[11.0, -4.0, 1.0, --],
mask=[False, False, False, True],
fill_value=1e+20)
>>> ma.round(masked_x, decimals=1)
masked_array(data=[11.2, -4.0, 0.8, --],
mask=[False, False, False, True],
fill_value=1e+20)
>>> ma.round_(masked_x, decimals=-1)
masked_array(data=[10.0, -0.0, 0.0, --],
mask=[False, False, False, True],
fill_value=1e+20)
Nrq )r r rX r" rY rq )rS r rt s r r r T s\ \ {yHc***
'!**h,,, 3 #
CI
r c B t | d } t | }|t u s| r|| S | j | _ t
|| j }|D ]'}| xj | |d z c_ (| S )zH
Mask whole 1-d vectors of an array that contain masked values.
FrB NT)r r! )r rY r r! rq r= r r )rS r r r r s r _mask_propagater s au A
AF{{!%%''{T\gllnnAG af - -D 1 1 155b45000 Hr c : |du rt j | dk st j | dk rnl|j dk r1t | | j dz
} t ||j dz
}n0t | | j dz
} t ||j dz
}t | }t | }|t j t | d t |d }t j || }t j | dk rt j | }| t | | }| | |S t j t | d t |d |j
}|j j |j k r$t j
|j t |_ t j |||j t j |j |j |S )aU
Return the dot product of two arrays.
This function is the equivalent of `numpy.dot` that takes masked values
into account. Note that `strict` and `out` are in different position
than in the method version. In order to maintain compatibility with the
corresponding method, it is recommended that the optional arguments be
treated as keyword only. At some point that may be mandatory.
Parameters
----------
a, b : masked_array_like
Inputs arrays.
strict : bool, optional
Whether masked data are propagated (True) or set to 0 (False) for
the computation. Default is False. Propagating the mask means that
if a masked value appears in a row or column, the whole row or
column is considered masked.
out : masked_array, optional
Output argument. This must have the exact kind that would be returned
if it was not used. In particular, it must have the right type, must be
C-contiguous, and its dtype must be the dtype that would be returned
for `dot(a,b)`. This is a performance feature. Therefore, if these
conditions are not met, an exception is raised, instead of attempting
to be flexible.
.. versionadded:: 1.10.2
See Also
--------
numpy.dot : Equivalent function for ndarrays.
Examples
--------
>>> a = np.ma.array([[1, 2, 3], [4, 5, 6]], mask=[[1, 0, 0], [0, 0, 0]])
>>> b = np.ma.array([[1, 2], [3, 4], [5, 6]], mask=[[1, 0], [0, 0], [0, 0]])
>>> np.ma.dot(a, b)
masked_array(
data=[[21, 26],
[45, 64]],
mask=[[False, False],
[False, False]],
fill_value=999999)
>>> np.ma.dot(a, b, strict=True)
masked_array(
data=[[--, --],
[--, 64]],
mask=[[ True, True],
[ True, False]],
fill_value=999999)
Tr r r )r r r rZ r rN r0 rl rf rw rj ro r rI r rq rp ) rS r r rt ambmr r r s r r r s j ~~
71::??bgajjAoo
Vq[[ 16A:..A 16A:..AA 16A:..A 16A:..A
q// B
q// B
{ F6!Q<<1 . .
VB^^O
71::??
1
A
FF&q!,, - -
a F6!Q<<1 sy 9 9 8>QW $ $(33CI
r2sy!!!
sy#),,,
r c t | d }t |d }|j dk rd|_ |j dk rd|_ t j || t S )z
Returns the inner product of a and b for arrays of floating point types.
Like the generic NumPy equivalent the product sum is over the last dimension
of a and b. The first argument is not conjugated.
r r )rN r r r rb rl r )rS r r r s r rb rb sb
1 B 1 B w!|| w!||
8B - --r z Masked values are replaced by 0.c t | d }t |d }t j || }t | }t | }|t
u r|t
u rt
| S t | }t | }t dt j d|z
d|z
z
d }t
|| S )r r r Fr r ) rN r r r rY r rx rZ rs )rS r r r r r r r s r r r s 1 B 1 B
RA B B V||f A a B a B!bhq2vq2v...U;;;A " " ""r c : |r | t | t j t j | t | | t j t j | t t | | z } | t | t | | }nS | t | t | } | t
|d t
|d | }t || S )z:
Helper function for ma.correlate and ma.convolve
r r r r )rZ r r r r rX rN rx )r rS r, r propagate_maskro rm s r _convolve_or_correlater s
8
Al1oorwrx{{$ ? ? ?d K K K
Abgbhqkk... Qd K K K
L
qWQZZd333 <??"\!__$4555q1 va||$777 4 ( ( ((r validc < t t j | ||| S )a
Cross-correlation of two 1-dimensional sequences.
Parameters
----------
a, v : array_like
Input sequences.
mode : {'valid', 'same', 'full'}, optional
Refer to the `np.convolve` docstring. Note that the default
is 'valid', unlike `convolve`, which uses 'full'.
propagate_mask : bool
If True, then a result element is masked if any masked element contributes towards it.
If False, then a result element is only masked if no non-masked element
contribute towards it
Returns
-------
out : MaskedArray
Discrete cross-correlation of `a` and `v`.
See Also
--------
numpy.correlate : Equivalent function in the top-level NumPy module.
)r r r> rS r, r r s r r> r> ) s 2 "",1dN K KKr r c < t t j | ||| S )a
Returns the discrete, linear convolution of two one-dimensional sequences.
Parameters
----------
a, v : array_like
Input sequences.
mode : {'valid', 'same', 'full'}, optional
Refer to the `np.convolve` docstring.
propagate_mask : bool
If True, then if any masked element is included in the sum for a result
element, then the result is masked.
If False, then the result element is only masked if no non-masked cells
contribute towards it
Returns
-------
out : MaskedArray
Discrete, linear convolution of `a` and `v`.
See Also
--------
numpy.convolve : Equivalent function in the top-level NumPy module.
)r r r< r s r r< r< E s 2 ""+q!T> J JJr c t t | t | }|t u rGt | }t | }t j || }| S |rmt | }t | }t j || }t ||d }| d d S dS )a
Return True if all entries of a and b are equal, using
fill_value as a truth value where either or both are masked.
Parameters
----------
a, b : array_like
Input arrays to compare.
fill_value : bool, optional
Whether masked values in a or b are considered equal (True) or not
(False).
Returns
-------
y : bool
Returns True if the two arrays are equal within the given
tolerance, False otherwise. If either array contains NaN,
then False is returned.
See Also
--------
all, any
numpy.ma.allclose
Examples
--------
>>> a = np.ma.array([1e10, 1e-7, 42.0], mask=[0, 0, 1])
>>> a
masked_array(data=[10000000000.0, 1e-07, --],
mask=[False, False, True],
fill_value=1e+20)
>>> b = np.array([1e10, 1e-7, -42.0])
>>> b
array([ 1.00000000e+10, 1.00000000e-07, -4.20000000e+01])
>>> np.ma.allequal(a, b, fill_value=False)
False
>>> np.ma.allequal(a, b)
True
F)ro r= TN) rv rY r rX r rK r r rN )rS r rM r r r r r s r r r a s T
GAJJ''AF{{ AJJ AJJ K1 uuww AJJ AJJ K1
115
)
)
)yy""4(((ur c
t | d }t |d }|j j dk r2t j |d }|j |k rt ||d }t t
| t
| }t j t |d| d } t j | t t j | d k sdS t j
| sUt t t ||z
||t | z z | }
t j |
S t j t || || k | sdS || }|| }t t t ||z
||t | z z | }
t j |
S )aL
Returns True if two arrays are element-wise equal within a tolerance.
This function is equivalent to `allclose` except that masked values
are treated as equal (default) or unequal, depending on the `masked_equal`
argument.
Parameters
----------
a, b : array_like
Input arrays to compare.
masked_equal : bool, optional
Whether masked values in `a` and `b` are considered equal (True) or not
(False). They are considered equal by default.
rtol : float, optional
Relative tolerance. The relative difference is equal to ``rtol * b``.
Default is 1e-5.
atol : float, optional
Absolute tolerance. The absolute difference is equal to `atol`.
Default is 1e-8.
Returns
-------
y : bool
Returns True if the two arrays are equal within the given
tolerance, False otherwise. If either array contains NaN, then
False is returned.
See Also
--------
all, any
numpy.allclose : the non-masked `allclose`.
Notes
-----
If the following equation is element-wise True, then `allclose` returns
True::
absolute(`a` - `b`) <= (`atol` + `rtol` * absolute(`b`))
Return True if all elements of `a` and `b` are equal subject to
given tolerances.
Examples
--------
>>> a = np.ma.array([1e10, 1e-7, 42.0], mask=[0, 0, 1])
>>> a
masked_array(data=[10000000000.0, 1e-07, --],
mask=[False, False, True],
fill_value=1e+20)
>>> b = np.ma.array([1e10, 1e-8, -42.0], mask=[0, 0, 1])
>>> np.ma.allclose(a, b)
False
>>> a = np.ma.array([1e10, 1e-8, 42.0], mask=[0, 0, 1])
>>> b = np.ma.array([1.00001e10, 1e-9, -42.0], mask=[0, 0, 1])
>>> np.ma.allclose(a, b)
True
>>> np.ma.allclose(a, b, masked_equal=False)
False
Masked values are not compared directly.
>>> a = np.ma.array([1e10, 1e-8, 42.0], mask=[0, 0, 1])
>>> b = np.ma.array([1.00001e10, 1e-9, 42.0], mask=[0, 0, 1])
>>> np.ma.allclose(a, b)
True
>>> np.ma.allclose(a, b, masked_equal=False)
False
Fr r r )r r= )r= ro )
rx r r( r result_typerv rY isinfrN r r! rk r ) rS r ry rA r@ r r r r xinfr s r r r s P QU###AQU###A w|sq"%% 7e Qe%888A
GAJJ''A
8LQ777 8 8 ? ? F FD
6$&!e444 5 5 u
6$<< :hq1uootdXa[[6H/HII
!
!vayy
6&4AdG+\:: ; ; u 4%A 4%Az(1q5//4$!2D+DEE A 6!99r c 4 |pd}t | |ddd| S )a
Convert the input to a masked array of the given data-type.
No copy is performed if the input is already an `ndarray`. If `a` is
a subclass of `MaskedArray`, a base class `MaskedArray` is returned.
Parameters
----------
a : array_like
Input data, in any form that can be converted to a masked array. This
includes lists, lists of tuples, tuples, tuples of tuples, tuples
of lists, ndarrays and masked arrays.
dtype : dtype, optional
By default, the data-type is inferred from the input data.
order : {'C', 'F'}, optional
Whether to use row-major ('C') or column-major ('FORTRAN') memory
representation. Default is 'C'.
Returns
-------
out : MaskedArray
Masked array interpretation of `a`.
See Also
--------
asanyarray : Similar to `asarray`, but conserves subclasses.
Examples
--------
>>> x = np.arange(10.).reshape(2, 5)
>>> x
array([[0., 1., 2., 3., 4.],
[5., 6., 7., 8., 9.]])
>>> np.ma.asarray(x)
masked_array(
data=[[0., 1., 2., 3., 4.],
[5., 6., 7., 8., 9.]],
mask=False,
fill_value=1e+20)
>>> type(np.ma.asarray(x))
r FT)r r= r ri r rx )rS r r s r r0 r0 s2 X
LSE Ud #5 2 2 2 2r c r t | t r| || j k r| S t | |ddd S )ae
Convert the input to a masked array, conserving subclasses.
If `a` is a subclass of `MaskedArray`, its class is conserved.
No copy is performed if the input is already an `ndarray`.
Parameters
----------
a : array_like
Input data, in any form that can be converted to an array.
dtype : dtype, optional
By default, the data-type is inferred from the input data.
order : {'C', 'F'}, optional
Whether to use row-major ('C') or column-major ('FORTRAN') memory
representation. Default is 'C'.
Returns
-------
out : MaskedArray
MaskedArray interpretation of `a`.
See Also
--------
asarray : Similar to `asanyarray`, but does not conserve subclass.
Examples
--------
>>> x = np.arange(10.).reshape(2, 5)
>>> x
array([[0., 1., 2., 3., 4.],
[5., 6., 7., 8., 9.]])
>>> np.ma.asanyarray(x)
masked_array(
data=[[0., 1., 2., 3., 4.],
[5., 6., 7., 8., 9.]],
mask=False,
fill_value=1e+20)
>>> type(np.ma.asanyarray(x))
NFT)r r= r ri )r! r r rx )rS r s r r/ r/ 8 sE X ![!! u}8H8H Ud$ O O OOr r c t d )Nz1fromfile() not yet implemented for a MaskedArray.r )filer rA r s r fromfiler n s
; = = =r c < t | d | d S )a
Build a masked array from a suitable flexible-type array.
The input array has to have a data-type with ``_data`` and ``_mask``
fields. This type of array is output by `MaskedArray.toflex`.
Parameters
----------
fxarray : ndarray
The structured input array, containing ``_data`` and ``_mask``
fields. If present, other fields are discarded.
Returns
-------
result : MaskedArray
The constructed masked array.
See Also
--------
MaskedArray.toflex : Build a flexible-type array from a masked array.
Examples
--------
>>> x = np.ma.array(np.arange(9).reshape(3, 3), mask=[0] + [1, 0] * 4)
>>> rec = x.toflex()
>>> rec
array([[(0, False), (1, True), (2, False)],
[(3, True), (4, False), (5, True)],
[(6, False), (7, True), (8, False)]],
dtype=[('_data', '>> x2 = np.ma.fromflex(rec)
>>> x2
masked_array(
data=[[0, --, 2],
[--, 4, --],
[6, --, 8]],
mask=[[False, True, False],
[ True, False, True],
[False, True, False]],
fill_value=999999)
Extra fields can be present in the structured array but are discarded:
>>> dt = [('_data', '>> rec2 = np.zeros((2, 2), dtype=dt)
>>> rec2
array([[(0, False, 0.), (0, False, 0.)],
[(0, False, 0.), (0, False, 0.)]],
dtype=[('_data', '>> y = np.ma.fromflex(rec2)
>>> y
masked_array(
data=[[0, 0],
[0, 0]],
mask=[[False, False],
[False, False]],
fill_value=999999,
dtype=int32)
rj rq r r )fxarrays r rV rV s s" z (ww/? @ @ @@r c 0 e Zd ZdZdZddZd Zd Zd ZdS ) _convert2maz
Convert functions from numpy to numpy.ma.
Parameters
----------
_methodname : string
Name of the method to transform.
Nc t t | | _ | || | _ |pi | _ d S r )r r _funcr r _extras)r} ry np_ret np_ma_retrx s r r~ z_convert2ma.__init__ s7 R**
{{6955 | r c t | j dd }t | j }|r/| ||| }|r| j j |d}||z }|S )r r Nr" )r r r _replace_return_typer )r} r r r r s r r z_convert2ma.getdoc so dj)T22"4:.. ++CCCC
<"&*"5"5sss;)C
r c
||vr3t d| d| d| d| j j d| j j d | || S )a
Replace documentation of ``np`` function's return type.
Replaces it with the proper type for the ``np.ma`` function.
Parameters
----------
doc : str
The documentation of the ``np`` method.
np_ret : str
The return type string of the ``np`` method that we want to
replace. (e.g. "out : ndarray")
np_ma_ret : str
The return type string of the ``np.ma`` method.
(e.g. "out : MaskedArray")
zFailed to replace `z` with `z-`. The documentation string for return type, z(, is not found in the docstring for `np.z `. Fix the docstring for `np.z0` or update the expected string for return type.)r r r replace)r} r r r s r r z _convert2ma._replace_return_type s " >f > >i > >=C> >26*2E> > .2Z-@> > >
{{69---r c | | j }t | | }|D ]}| | ||< | j j |i | t }d|v r| dd |_ d|v r(t | dd |_ |S )NrM r r F) r set intersectionpopr r rl r r* rM r r )r} r rx r
common_paramsprU s r r z_convert2ma.__call__ s ,F 0099
' 'A A GAJJ$$d5f55::;GG = ( ( ' L$ ? ?F & & #GKK U$C$C D DF
r r )r r r r r~ r r r r r r r r sf G$ $ $ $
. . .8
r r r# )rM r zarange : ndarrayzarange : MaskedArray)rx r r r6 zclipped_array : ndarrayzclipped_array : MaskedArrayrI z
out : ndarrayzout : MaskedArrayrJ )r r rU zout: MaskedArrayrW zfromfunction : anyzfromfunction: MaskedArrayr_ ra z'grid : one ndarray or tuple of ndarraysz/grid : one MaskedArray or tuple of MaskedArraysr r r zsqueezed : ndarrayzsqueezed : MaskedArrayr r c & t | |g| S )a Append values to the end of an array.
.. versionadded:: 1.9.0
Parameters
----------
a : array_like
Values are appended to a copy of this array.
b : array_like
These values are appended to a copy of `a`. It must be of the
correct shape (the same shape as `a`, excluding `axis`). If `axis`
is not specified, `b` can be any shape and will be flattened
before use.
axis : int, optional
The axis along which `v` are appended. If `axis` is not given,
both `a` and `b` are flattened before use.
Returns
-------
append : MaskedArray
A copy of `a` with `b` appended to `axis`. Note that `append`
does not occur in-place: a new array is allocated and filled. If
`axis` is None, the result is a flattened array.
See Also
--------
numpy.append : Equivalent function in the top-level NumPy module.
Examples
--------
>>> import numpy.ma as ma
>>> a = ma.masked_values([1, 2, 3], 2)
>>> b = ma.masked_values([[4, 5, 6], [7, 8, 9]], 7)
>>> ma.append(a, b)
masked_array(data=[1, --, 3, 4, 5, 6, --, 8, 9],
mask=[False, True, False, False, False, False, True, False,
False],
fill_value=999999)
)r: )rS r r s r r" r" H! s P 1vt $ $$r r )T)FT)TT)r= r> TTr3 r2 r r1 r0 )Nr r )FN)r T)r T)Tr= r> r/ ( r rv r rC r textwrapr functoolsr numpyr numpy.core.umathr+ r numpy.core.numerictypes numerictypesr
numpy.corer r r r r r r r
r r numpy.lib.function_baser numpy.compatr
r r r r r numpy.core.numericr __all__r r r_ r r r r r r r r) r,
datetime64 timedelta64halfsingledouble
longdoublecsinglecdouble clongdoublefloat_types_list_minvalsr: r _maxvalsr7 r r$ rD r5 r r r> rP r rV r7 rN rf rX get_datarO rx r r rz r r r r r r r r rL r; r r? r( r' r r@ r r r rM r rR r4 r r. rp r rl rn rm r r& r$ r% r* r r r r) rK r rk r\ rj r[ ro r rq r rr r1 r2 r3 r^ rH r rS r rT r r r rt rY get_maskrZ rf r rs ru r rv rP r" r rz r{ r~ r r ry r| r r r r} rK r r] r[ dedentr. rf rQ r} r r r& r re rh rd r` rw r rx rg ro r r r r~ r r r r! r8 rB rC r= rF r] r` r r r r r r r r rE r r r r r r rA r r r, r+ r- r r9 r: rE ri r r r r r r r r r rG r r5 r r r rb rc r r r r> r< r r r0 r/ r r rV r r# r6 rI rJ rU rW r_ ra r r r r r r" r r r r sr , ( ( ( ( ( ( ( ( ( ' ' ' ' ' ' D D D D D D D D D D D D D D D D ! ! ! ! ! ! ) ) ) ) ) ) 3 3 3 3 3 3" " " H 8 ! } 8
>
>
> " i #
? ?A&3bmE1&=&=N519s?#&4bnUA&>&>N519s?##GRY 2=J
BN<
_
>>)9"1")=>>> ? ? ?
QQ;KBCC;PQQQ R R R
_
??*:2A2*>??? @ @ @
QQ;KBCC;PQQQ R R R *( ( (4< 4< 4 > > B
@6 6 6 6r 60 0 0 0f Td 8
8
8
8
t= = = ; ; ; ; ; ; ; ;2F F F F F F F F$K K K K K K K K*
<
<
<
<
<
<
<
<
6
6
6
6
6
6
6
6 - - - - - - - -G G G G G L G G G TP P P P P \ P P P hH H H H H | H H H X EI&& ! !%/ 2 2 EI&&EI&& u| , ,
.
. UZ(( UZ(( UZ((&&u~66 6h e$$ UZ(( 0 0 ek** UZ(( ry ) )##E$566 UZ 0 0 5 57 7EIs *N3 / /1 1 UZ +^C 0 02 2 ek3 ,nS 1 1 3 3EIs &Ju - -/ / u|S 3 3D# > >
@
@ u|S 3 3D# > >
@
@
s 3 3C 8 8 : :
s 4 4\; O O Q Q UY'' ! !%. 1 1 ! !%.!Q 7 7
S
9
9 u{++ " "5? 3 3
#
#E$4
5
5
&&u':;;
ej))
/
/$$U%677
!2Aq
9
9
@
#
#E$4
5
5
$$U%677 $$U%677
#
#E$4
5
5
$$U%677 u{++
" !%,0A0A0C0CQ J J&&u'8'8'8':':AqB B ''(:(9(9(;(;QC C $ $U_%6%6%8%8!Q
@
@
,=,=,?,?AFF uy*;*;*=*=q!DD @ C C C 3 3 3B8' 8' 8'v 2 2 2jA A AH D V V V Vr/ / / /d@ @ @5I 5I 5I 5Ip58 58 58p +-+ w w w wt9 9 9 94? ? ? ?46 6 6 64< < < <4; ; ; ;4 @%1 %1 %1 %1P%1 %1 %1 %1PAC AC AC ACHE E E EP! ! ! !P- - - - - - - -` )(.. $ $
X_
X_
ho
ho
+ D C C C 4 4 4n* * * *Zi i i i i i i iXn8 n8 n8 n8 n8' n8 n8 n8bqH H HD D D D D K D D D X0& 0& 0&f q4 q4 q4 q4 q4[ q4 q4 q4h +N , , , d$$$d!
@
@
@
@ $
2 2 2tA A A A A A A AF DTBK 6 6 6 6 o% DTBK 6 6 6 6 o% DTBK 6 6 6 6 o% &- &- &- &- &- &- &- &-R k% ;v&& & Dk% ;zD 1 1 1
+i
X {6 ;z " "k-(( k%
U]G5G
H
H{6
U]D2D
E
E
+i
{6
+f
G X k-(( k-(( k%k% ;z " " G k% G : : : :K K K KZ
X X Kd$QU < < < < %-&
&
&
&
R#& #& #&L9 9 9 9x/ / / /d' ' '*!' !' !'HE E E E&$ $ $ N#G #G #G #GL& & & &&= = =@! ! ! w " " "
' ' ' ' w R[ D D D D X 8 X) X) X) X)vH
H
H
H
V4 4 4 4j
$O O O Od. . . );= =
# # # );= =
) ) )&L L L L8K K K K87 7 7 7ti i i iX.2 .2 .2 .2b.P .P .P .Pl bb = = = =
=A =A =A@G G G G G G G GT
44% 0 0 0 $
{
44% 0 0 0 $+ 44% 0 0 0 ! [ !
[
{
(
; 44% 0 0 0 ! +
44% 0 0 0 4? {
44% 0 0 0 !
K !
+
44% 0 0 0 & 44% 0 0 0 ! [ !
(% (% (% (% (% (%r