Khn %SrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKJ r SSK r SSK J s Jr SSKJ s Jr SSKJr SSK JrJrJrJrJrJrJr SSK JrJrJrJ r SSK!J"r" SSK#J$r$J%r% SS K&J'r' /S Qr(\ RRr*\*"S5r+"S S \,5r-S r.Sr/Sr0"SS\15r2"SS\25r3SSSSSSSSSS. r4SH;r5\ Rl"S\55\4S\5-S -'\ Rn"S\55\4S!\5-S -'M= \ Rp\ Rr\ Rt\ Rv\ Rx\ Rz\ R|/r?0r@\ \A\B4\CS"'0rD\ \A\B4\CS#'\RR5GH rG\ R"\G5rI\IRS$;a9\ R>"\ R5rL\LRS%-\LRsrOrPO\ R"\I\ R5(a,\ R>"\G5rL\LR\LRsrOrPOi\ R"\I\ R5(a,\ R@"\G5rL\LR\LRsrOrPO\IRS&:XaS'urOrPOS(urOrP\O\@\G'\P\D\G'GM# \@rT\TR\?SS)Vs/sHo\ R*4PM sn5 \TR\?S*SVs/sH#o\W"\ R*\ R*54PM% sn5 \DrX\XR\?SS)Vs/sHo\ R74PM sn5 \XR\?S*SVs/sH#o\W"\ R7\ R754PM% sn5 C?S+rYS,rZS-r[S.r\S/r]S0r^S1r_S2r`S3raS4rbS5rcSS6jrdS7reSS8jrf\frg\+SS4S9jrhS:ri0rj0rk"S;S<5rl"S=S>5rm"S?S@5rn"SASB5ro"SCSD5rp"SESF5rq"SGSH\q5rr"SISJ\q5rs"SKSL\q5rt\r"\R5ru\r"\R5rv\r"\R5rw\r"\R5rx\r"\R5ry\r"\R5rz\r"\R5r{\r"\R5r|\r"\R5r}\r"\R5=rr~\r"\5r\r"\GR5r\r"\GR5r\r"\GR5r\r"\GR5r\r"\ GR5r\r"\GR 5r\r"\GR SM\p"SM55r\r"\GRSN\o"SM55r\r"\GRSN\o"SM55r\r"\GRSN\o"SM55r\r"\GRSM\m"SO55r\r"\GRSM\l"SPSN55r\r"\GRSM\l"SPSN55r\r"\GRSN\p"SN55r\r"\GRSM\l"SQSR55r\s"\GR5r\s"\GR 5r\s"\GR"S%S%5r\s"\GR$SMSN5r\s"\GR&5rS\l\s"\GR*5rS\l\s"\GR,5rS\l\s"\GR.5rS\l\s"\GR05rS\l\s"\GR25rS\l\s"\GR45r\s"\GR4S%S%5GR(r\s"\GR85r\GR(r\s"\GR<5r\s"\GR>5r\s"\GR@5r\s"\GRB5r\s"\GRD5r\t"\GRF\n"5SS%5r\t"\GRH\n"5SS%5r\t"\GRJ\n"5SS%5r\t"\GRL\n"5SS%5r\t"\GRN\n"5SS%5r\t"\GRP\n"5SS%5rSSrSTrSUrSVr\rSWrSXrSYrSZS\*4S[jrSS\jrS]rSS^jrS_r\ R44S`jrSSajrSSbjrSScjrSSdjrSSejrSSfjrSSgjrSShjrSSijrSSjjrSSkjrSSljr"SmSn5r\"So5rSpr\"\GR"Sq5\GR"Sr5\GR"Ss5\GR"St5Su9rSvrSwrSSxjr"SySz5r\'"S{5"S|S}\55rS~r"SS\5rSr\r\r"SS\5r\"5=rr\rSSZS\+SSSZSSS4 Sjr\R\lSr"SS\q5rSSS\ R44SjrM\RR\MlSSS\ R44SjrN\RR\NlSSS\ R44Sjr\GRR\l"SS5r\"S5r\"S5=rr\"S5r\"SSS9r\"S5r\"S5r\"S5r\"S5r\"S5r\"S5r\"\GR\\^5r\"S5r\"\GR\\]5r\"S5r\"S5r\"S5r\"S5r\"S5r\"S5r\"S5r\"S5r\"S5r\"S5r\"S5r\"S5r\"S5rSSjrSSjr\"S5r\"S5r\ R4SSSS4SS.Sjjr\GRR\lSSS.SjjrSrSSjrSSjrSrSGrSSjGrSGrSSjGrSSjGrSGrSGr\ GR RG\lSGr\ GRRG\lSSjGr\ GRRG\lS%S\ R4\ R44SjGr \\4SjGr SSjGr SSjGr G\ Gr SGrSSjGrSGr\/"\ GR RS5G\lG\GrSGr\/"\ GR$RS5G\lG\GrSGrSSjGrSSjGrSSjGrSSjGrS(SjGrSSjGrG\SS4SjGrSGr"SS5GrG\"S\"SSZS9SSS9GrG\"S\"SSZS9SSS9Gr G\"S\"SSZS9SSS9Gr!G\"SSSS9Gr"G\"SSSS9Gr#G\"SSSS9Gr$G\"S\"SSZS9SSS9Gr%G\"S\"SSZS9SSS9Gr&G\"S\"SSZS9SSS9Gr'G\"SSSS9Gr(G\"S\"SSZS9SSS9Gr)G\"S\"SSZS9SSS9Gr*G\"SSSS9Gr+SSjGr,gs snfs snfs snfs snf)a numpy.ma : a package to handle missing or invalid values. This package was initially written for numarray by Paul F. Dubois at Lawrence Livermore National Laboratory. In 2006, the package was completely rewritten by Pierre Gerard-Marchant (University of Georgia) to make the MaskedArray class a subclass of ndarray, and to improve support of structured arrays. Copyright 1999, 2000, 2001 Regents of the University of California. Released for unlimited redistribution. * Adapted for numpy_core 2005 by Travis Oliphant and (mainly) Paul Dubois. * Subclassing of the base `ndarray` 2006 by Pierre Gerard-Marchant (pgmdevlist_AT_gmail_DOT_com) * Improvements suggested by Reggie Dugard (reggie_AT_merfinllc_DOT_com) .. moduleauthor:: Pierre Gerard-Marchant N)Dict) multiarray)ndarrayamaxamin iscomplexobjbool__NoValueangle)array expand_dimsiinfofinfo)normalize_axis_tuple) getargspec formatargspec) set_module)MAError MaskErrorMaskType MaskedArrayabsabsoluteaddallallcloseallequalalltruerrr anom anomaliesanyappendarangearccosarccosharcsinarcsinharctanarctan2arctanhargmaxargminargsortaroundr asanyarrayasarray bitwise_and bitwise_or bitwise_xorr ceilchooseclipcommon_fill_valuecompress compressed concatenate conjugateconvolvecopy correlatecoscoshcountcumprodcumsumdefault_fill_valuediagdiagonaldiffdivideempty empty_likeequalexpr fabsfilled fix_invalid flatten_maskflatten_structured_arrayfloor floor_dividefmod frombufferfromflex fromfunctiongetdatagetmask getmaskarraygreater greater_equal harden_maskhypotidentityidsindicesinner innerproductisMA isMaskedArrayis_mask is_maskedisarray left_shiftless less_equalloglog10log2 logical_and logical_not logical_or logical_xor make_maskmake_mask_descrmake_mask_nonemask_ormasked masked_array masked_equalmasked_greatermasked_greater_equal masked_insidemasked_invalid masked_lessmasked_less_equalmasked_not_equal masked_objectmasked_outsidemasked_print_optionmasked_singleton masked_values masked_wheremaxmaximummaximum_fill_valuemeanminminimumminimum_fill_valuemodmultiplymvoidndimnegativenomasknonzero not_equalones ones_likeouter outerproductpowerprodproductptpputputmaskravel remainderrepeatreshaperesize right_shiftroundround_set_fill_valueshapesinsinhsize soften_masksometruesortsqrtsqueezestdsubtractsumswapaxestaketantanhtrace transpose true_dividevarwherezeros zeros_likec\rSrSrSrg)MaskedArrayFutureWarningRN)__name__ __module__ __qualname____firstlineno____static_attributes__r?/var/www/html/env/lib/python3.13/site-packages/numpy/ma/core.pyrrRsrrcZURS::ag[R"S[SS9 g)a Adjust the axis passed to argsort, warning if necessary Parameters ---------- arr The array which argsort was called on np.ma.argsort has a long-term bug where the default of the axis argument is wrong (gh-8701), which now must be kept for backwards compatibility. Thankfully, this only makes a difference when arrays are 2- or more- dimensional, so we only need a warning then. zIn the future the default for argsort will be axis=-1, not the current None, to match its documentation and np.argsort. Explicitly pass -1 or None to silence this warning. stacklevelN)rwarningswarnr)arrs r_deprecate_argsort_axisrUs4 xx1}   B %  4 rcUcgUcU$[R"S[R"U55nS[R"U5-nSR USSU/-USS-5$)z1 Adds a Notes section to an existing docstring. Nz\n\s*?Notes\n\s*?-----z Notes ----- %s r)resplitinspectcleandocjoin) initialdocnote notesplitnotedocs rdoc_noterqsp  |2G4D4DZ4PQI&)9)9$)??G 779Ra=G9,y}< ==rcP[[U56nU$![a SnU$f=f)z Get the signature from obj r)rr TypeError)objsigs rget_object_signaturers7 Z_- J  Js  %%c\rSrSrSrSrg)rz) Class for masked array related errors. rNrrrr__doc__rrrrrr  rrc\rSrSrSrSrg)rz! Class for mask related errors. rNrrrrrrrrrTy@xDg@xDi?B?sN/As???zN/A) bcfiOSuVU) YMWDhmsmsusnspsfsasNaTzM8[]zm8[_minvals_maxvalsMmrr)rrNNc"^^TRb8[UU4SjTR55n[R"UTS9S$TR(a0TRup4[ UT5n[R "XE5$T"T5$)zJ Recursively produce a fill value for `dtype`, calling f on scalar dtypes c3j># UH(n[R"[TUT55v M* g7fN)npr _recursive_fill_value).0namedtypers r (_recursive_fill_value..s0)'D.uT{A>??'s03rr)namestuplerr subdtyperfull)rrvalssubtypersubvals`` rrrsz {{ )!KK))xxE*2.. &w2wwu%%xrc[U[R5(aU$[US5(a UR$[R"U5R$)z3Convert the argument for *_fill_value into a dtype r) isinstancerrhasattrr/rs r _get_dtype_ofr"sD#rxx   g  yy}}S!'''rc4Sn[U5n[X!5$)a Return the default fill value for the argument object. The default filling value depends on the datatype of the input array or the type of the input scalar: ======== ======== datatype default ======== ======== bool True int 999999 float 1.e20 complex 1.e20+0j object '?' string 'N/A' ======== ======== For structured types, a structured scalar is returned, with each field the default fill value for its type. For subarray types, the fill value is an array of the same size containing the default scalar fill value. Parameters ---------- obj : ndarray, dtype or scalar The array data-type or scalar for which the default fill value is returned. Returns ------- fill_value : scalar The default fill value. Examples -------- >>> import numpy as np >>> np.ma.default_fill_value(1) 999999 >>> np.ma.default_fill_value(np.array([1.1, 2., np.pi])) 1e+20 >>> np.ma.default_fill_value(np.dtype(complex)) (1e+20+0j) cURS;a#[RURSSS5$[RURS5$)Nrrr)kinddefault_fillergetstrrs r_scalar_fill_value.default_fill_value.._scalar_fill_value*sB :: !%%eiimS9 9!%%ejj#6 6rr"r)rr)rs rrDrDs\7 # E  ;;rc@^^UU4Sjn[U5n[XC5$)Ncn>TUR$![an[SUSTS35SeSnAff=f)NzUnsuitable type z for calculating .)typeKeyErrorr)reextremum extremum_names rr)0_extremum_fill_value.._scalar_fill_value6sJ EJJ' ' "5'):=/K  s 4/4r+)rr2r3r)rs `` r_extremum_fill_valuer54s # E  ;;rc$[U[S5$)a Return the maximum value that can be represented by the dtype of an object. This function is useful for calculating a fill value suitable for taking the minimum of an array with a given dtype. Parameters ---------- obj : ndarray, dtype or scalar An object that can be queried for it's numeric type. Returns ------- val : scalar The maximum representable value. Raises ------ TypeError If `obj` isn't a suitable numeric type. See Also -------- maximum_fill_value : The inverse function. set_fill_value : Set the filling value of a masked array. MaskedArray.fill_value : Return current fill value. Examples -------- >>> import numpy as np >>> import numpy.ma as ma >>> a = np.int8() >>> ma.minimum_fill_value(a) 127 >>> a = np.int32() >>> ma.minimum_fill_value(a) 2147483647 An array of numeric data can also be passed. >>> a = np.array([1, 2, 3], dtype=np.int8) >>> ma.minimum_fill_value(a) 127 >>> a = np.array([1, 2, 3], dtype=np.float32) >>> ma.minimum_fill_value(a) inf r)r5 min_fillerr!s rrrBb Z ;;rc$[U[S5$)a Return the minimum value that can be represented by the dtype of an object. This function is useful for calculating a fill value suitable for taking the maximum of an array with a given dtype. Parameters ---------- obj : ndarray, dtype or scalar An object that can be queried for it's numeric type. Returns ------- val : scalar The minimum representable value. Raises ------ TypeError If `obj` isn't a suitable numeric type. See Also -------- minimum_fill_value : The inverse function. set_fill_value : Set the filling value of a masked array. MaskedArray.fill_value : Return current fill value. Examples -------- >>> import numpy as np >>> import numpy.ma as ma >>> a = np.int8() >>> ma.maximum_fill_value(a) -128 >>> a = np.int32() >>> ma.maximum_fill_value(a) -2147483648 An array of numeric data can also be passed. >>> a = np.array([1, 2, 3], dtype=np.int8) >>> ma.maximum_fill_value(a) -128 >>> a = np.array([1, 2, 3], dtype=np.float32) >>> ma.maximum_fill_value(a) -inf r)r5 max_fillerr!s rrrvr8rc [R"U[UR55n/n[ XR5Hup4XnUR (aUR SnURb%UR [[X5555 M[UR [R"X5S9R55 M [U5$)a Create a fill value for a structured dtype. Parameters ---------- fillvalue : scalar or array_like Scalar or array representing the fill value. If it is of shorter length than the number of fields in dt, it will be resized. dt : dtype The structured dtype for which to create the fill value. Returns ------- val : tuple A tuple of values corresponding to the structured fill value. rr) rrlenrziprr"r_recursive_set_fill_valuer item) fillvaluedt output_valuefvalrcdtypes rr>r>s$ )S]3ILIxx0  ??__Q'F << #   &?&M N O    < A A C D1  rc[R"U5nUc2[U5nURS:Xa[R"U5nOUR bs[ U[[R45(a[R"XS9nO[R"U[S9n[R"[X5US9nOI[ U[5(aURS;aSn[!X1-5e[R"XS9n[R"U5$![anSn[X0U4-5UeSnAff=f!["[4anSn[!X0U4-5UeSnAff=f)z Private function validating the given `fill_value` for the given dtype. If fill_value is None, it is set to the default corresponding to the dtype. If fill_value is not None, its value is forced to the given dtype. The result is always a 0d array. Nrrz"Unable to transform %s to dtype %sOSVUz6Cannot set fill value of string with array of dtype %sz(Cannot convert fill_value %s to dtype %s)rrrDr%uintrrrvoidr0 ValueErrorobjectr r>r(charr OverflowError) fill_valuendtyper1err_msgs r_check_fill_valuerPsSXXf F'/  ;;# ,J  ! j7BGG"4 5 5 HZZ A Jf=J";J"O(.0J j# & &FKKv,ENGG,- - GZZ A  88J / H> +?!?@aG H"":. GEv*> >?QF  Gs0?D+E+ E 5EE E6E11E6cP[U[5(aURU5 g)a1 Set the filling value of a, if a is a masked array. This function changes the fill value of the masked array `a` in place. If `a` is not a masked array, the function returns silently, without doing anything. Parameters ---------- a : array_like Input array. fill_value : dtype Filling value. A consistency test is performed to make sure the value is compatible with the dtype of `a`. Returns ------- None Nothing returned by this function. See Also -------- maximum_fill_value : Return the default fill value for a dtype. MaskedArray.fill_value : Return current fill value. MaskedArray.set_fill_value : Equivalent method. Examples -------- >>> import numpy as np >>> import numpy.ma as ma >>> a = np.arange(5) >>> a array([0, 1, 2, 3, 4]) >>> a = ma.masked_where(a < 3, a) >>> a masked_array(data=[--, --, --, 3, 4], mask=[ True, True, True, False, False], fill_value=999999) >>> ma.set_fill_value(a, -999) >>> a masked_array(data=[--, --, --, 3, 4], mask=[ True, True, True, False, False], fill_value=-999) Nothing happens if `a` is not a masked array. >>> a = list(range(5)) >>> a [0, 1, 2, 3, 4] >>> ma.set_fill_value(a, 100) >>> a [0, 1, 2, 3, 4] >>> a = np.arange(5) >>> a array([0, 1, 2, 3, 4]) >>> ma.set_fill_value(a, 100) >>> a array([0, 1, 2, 3, 4]) N)rrrarMs rrrs#z![!! $ rcb[U[5(aURnU$[U5nU$)zf Return the filling value of a, if any. Otherwise, returns the default filling value for that type. )rrrMrD)rSresults rget_fill_valuerVBs2 ![!! M$A& Mrc>[U5n[U5nX#:XaU$g)a Return the common filling value of two masked arrays, if any. If ``a.fill_value == b.fill_value``, return the fill value, otherwise return None. Parameters ---------- a, b : MaskedArray The masked arrays for which to compare fill values. Returns ------- fill_value : scalar or None The common fill value, or None. Examples -------- >>> import numpy as np >>> x = np.ma.array([0, 1.], fill_value=3) >>> y = np.ma.array([0, 1.], fill_value=3) >>> np.ma.common_fill_value(x, y) 3.0 N)rV)rSrt1t2s rr7r7Os%4  B  B x rc[US5(aURU5$[U[5(aU$[U[5(a[ R "US5$[ R "U5$)a Return input as an `~numpy.ndarray`, with masked values replaced by `fill_value`. If `a` is not a `MaskedArray`, `a` itself is returned. If `a` is a `MaskedArray` with no masked values, then ``a.data`` is returned. If `a` is a `MaskedArray` and `fill_value` is None, `fill_value` is set to ``a.fill_value``. Parameters ---------- a : MaskedArray or array_like An input object. fill_value : array_like, optional. Can be scalar or non-scalar. If non-scalar, the resulting filled array should be broadcastable over input array. Default is None. Returns ------- a : ndarray The filled array. See Also -------- compressed Examples -------- >>> import numpy as np >>> import numpy.ma as ma >>> x = ma.array(np.arange(9).reshape(3, 3), mask=[[1, 0, 0], ... [1, 0, 0], ... [0, 0, 0]]) >>> x.filled() array([[999999, 1, 2], [999999, 4, 5], [ 6, 7, 8]]) >>> x.filled(fill_value=333) array([[333, 1, 2], [333, 4, 5], [ 6, 7, 8]]) >>> x.filled(fill_value=np.arange(3)) array([[0, 1, 2], [0, 4, 5], [6, 7, 8]]) rNr)r rNrrdictrr rRs rrNrNps_dq(xx ## Aw   At  xx3xx{rcj[U5S:Xa-USn[U[5(a [U5nOb[nO[UVs/sHn[U5PM nnUSn[ U[5(d[nUSSHn[ XR5(dMUnM UR S:Xa[$U$s snf)z Return the youngest subclass of MaskedArray from a list of (masked) arrays. In case of siblings, the first listed takes over. rrNMaskedConstant)r<rrr/ issubclassr)arraysrrclsrSarrclsclss rget_masked_subclassrcs 6{aQi c; ' '9DD#)*6a$q'6*ay$ ,,D!":C#$$ }}(( K+sB0cURnU(dUR [ 5$U$![a [R"USUS9nN@f=f)a Return the data of a masked array as an ndarray. Return the data of `a` (if any) as an ndarray if `a` is a ``MaskedArray``, else return `a` as a ndarray or subclass (depending on `subok`) if not. Parameters ---------- a : array_like Input ``MaskedArray``, alternatively a ndarray or a subclass thereof. subok : bool Whether to force the output to be a `pure` ndarray (False) or to return a subclass of ndarray if appropriate (True, default). See Also -------- getmask : Return the mask of a masked array, or nomask. getmaskarray : Return the mask of a masked array, or full array of False. Examples -------- >>> import numpy as np >>> import numpy.ma as ma >>> a = ma.masked_equal([[1,2],[3,4]], 2) >>> a masked_array( data=[[1, --], [3, 4]], mask=[[False, True], [False, False]], fill_value=2) >>> ma.getdata(a) array([[1, 2], [3, 4]]) Equivalently use the ``MaskedArray`` `data` attribute. >>> a.data array([[1, 2], [3, 4]]) Nr=subok)_dataAttributeErrorrr viewr)rSrfdatas rrXrXsMV3ww yy!! K 3xxE23s , AAc[XUSS9n[R"[R"UR55nUR 5(dU$U=R U-slUc URnX0RU'U$)a Return input with invalid data masked and replaced by a fill value. Invalid data means values of `nan`, `inf`, etc. Parameters ---------- a : array_like Input array, a (subclass of) ndarray. mask : sequence, optional Mask. Must be convertible to an array of booleans with the same shape as `data`. True indicates a masked (i.e. invalid) data. copy : bool, optional Whether to use a copy of `a` (True) or to fix `a` in place (False). Default is True. fill_value : scalar, optional Value used for fixing invalid data. Default is None, in which case the ``a.fill_value`` is used. Returns ------- b : MaskedArray The input array with invalid entries fixed. Notes ----- A copy is performed by default. Examples -------- >>> import numpy as np >>> x = np.ma.array([1., -1, np.nan, np.inf], mask=[1] + [0]*3) >>> x masked_array(data=[--, -1.0, nan, inf], mask=[ True, False, False, False], fill_value=1e+20) >>> np.ma.fix_invalid(x) masked_array(data=[--, -1.0, --, --], mask=[ True, False, True, True], fill_value=1e+20) >>> fixed = np.ma.fix_invalid(x) >>> fixed.data array([ 1.e+00, -1.e+00, 1.e+20, 1.e+20]) >>> x.data array([ 1., -1., nan, inf]) T)r=maskrf)rxrrpisfinitergr!_maskrM)rSrlr=rMinvalids rrOrOslb QD9AnnR[[12G ;;==GGwG\\ !GGG Hrc[U[5=(d= [U[5=(a& U=(a [R"SU55$)Nc3B# UHn[U[5v M g7fr)rr()rrs rr/is_string_or_list_of_strings..>s:c*Q,,cs)rr(listbuiltinsr)vals ris_string_or_list_of_stringsrv;s> sC  < T ";s; \\:c: :=rc$\rSrSrSrSrSrSrg)_DomainCheckIntervaliIzn Define a valid interval, so that : ``domain_check_interval(a,b)(x) == True`` where ``x < a`` or ``x > b``. c*X:aX!p!XlX lg)z9domain_check_interval(a,b)(x) = true where x < a or y > bNrSrselfrSrs r__init___DomainCheckInterval.__init__Rs 5rc[R"SS9 [R"[R"XR 5[R "XR55sSSS5 $!,(df  g=f)Execute the call behavior.ignoreroN)rerrstateumathrqr[rrjrSr|xs r__call___DomainCheckInterval.__call__YsI[[ *##EMM!VV$<$)JJq&&$9;+ * *s AA22 BrzNrrrrrr}rrrrrrxrxIs;rrxc$\rSrSrSrSrSrSrg) _DomainTanibzs Define a valid interval for the `tan` function, so that: ``domain_tan(eps) = True`` where ``abs(cos(x)) < eps`` cXlg)z/domain_tan(eps) = true where abs(cos(x)) < eps)Neps)r|rs rr}_DomainTan.__init__jsrc[R"SS9 [R"[R"[R "U55UR 5sSSS5 $!,(df  g=fExecutes the call behavior.rrN)rrrrjrr?rrs rr_DomainTan.__call__ns= [[ *::ennUYYq\:DHHE+ * *s A A(( A6rNrrrrrrbsFrrc(\rSrSrSrSSjrSrSrg)_DomainSafeDivideitz% Define a domain for safe division. NcXlgr tolerance)r|rs rr}_DomainSafeDivide.__init__zs"rcURc)[R"[5RUl[R "U5[R "U5p![R "SS9 [R"U5UR-[R"U5:sSSS5 $!,(df  g=f)Nr)r) rrrfloattinyr0rrrr{s rr_DomainSafeDivide.__call__}su >> !XXe_11DNzz!}bjjm1 [[X &>>!$t~~59JJ' & &s 6:B:: Crrrrrrrrts # Krrc$\rSrSrSrSrSrSrg)_DomainGreateriz, DomainGreater(v)(x) is True where x <= v. cXlg)z'DomainGreater(v)(x) = true where x <= vNcritical_valuer|rs rr}_DomainGreater.__init__,rc[R"SS9 [R"XR5sSSS5 $!,(df  g=fr)rrrrkrrs rr_DomainGreater.__call__s. [[ *##A':':;+ * * ? A rNrrrrrrs -[TU]U5 X lX0lU[U'U[ U'gr)superr}filldomain ufunc_domain ufunc_fills)r|mufuncrr __class__s rr}_MaskedUnaryOperation.__init__s.    % V" Frc[U5nURbm[R"SSS9 UR"U/UQ70UD6nSSS5 [ R "W5)nX`RU5-nU[U5-nO?[R"SSS9 UR"U/UQ70UD6nSSS5 [U5nWR(dU(a[$U$U[La[R"XTUS9 UR[U55nXglUR!U5 U$!,(df  N=f!,(df  N=f![a Naf=f) Execute the call behavior. NrrHror)rXrrrrrrmrYrrwrcopytorrircrn _update_from)r|rSargskwargsdrUr masked_results rr_MaskedUnaryOperation.__call__s2 AJ ;; "Hh?3D3F3@''A Q A OAHh?3D3F3@ A{{ M F?  &1- $7$:; ""1%G@?@?(  s)D7E/E7 E E E&%E&)rrrN rrrrrr}rr __classcell__rs@rrrs"#..rrcP^\rSrSrSrS U4SjjrSrS SjrSrS Sjr Sr U=r $) _MaskedBinaryOperationia Define masked version of binary operations, where invalid values are pre-masked. Parameters ---------- mbfunc : function The function for which to define a masked version. Made available as ``_MaskedBinaryOperation.f``. domain : class instance Default domain for the function. Should be one of the ``_Domain*`` classes. Default is None. fillx : scalar, optional Filling value for the first argument, default is 0. filly : scalar, optional Filling value for the second argument, default is 0. cb>[TU]U5 X lX0lS[U'X#4[ U'g)zZ abfunc(fillx, filly) must be defined. abfunc(x, filly) = x for all x to enable reduce. N)rr}fillxfillyrr)r|mbfuncrrrs rr}_MaskedBinaryOperation.__init__s2    # V$n Frc[U5[U5pe[R"5 [R"SSS9 UR"XV/UQ70UD6nSSS5 [ U5[ U5pU[ La1U [ La[ n Oa[R"[U5U 5n O@U [ La![R"U[U55n O[R"X5n WR(dU (a[$U$U [ La,U R5(a[R"XuSU S9 UR[!X55n Xl[%U[&5(aU R)U5 U $[%U[&5(aU R)U5 U $!,(df  GNc=f![a Nf=f)rrrNunsafecastingr)rXrrseterrrrYrrrqrZrrwr!r Exceptionrircrnrrr) r|rSrrrdadbrUmambrrs rr_MaskedBinaryOperation.__call__sj AJ R [[] IIXx 8VVB4T4V4FAJ R <V|$$\!_b9 6\  \!_5A  (A{{ M F?quuww  &ha@  $7$=>  a % %  & &q ); ' '  & &q )K]6  s,F3-G3 G GGc[U5n[U5n[XR5nURS:Xa+UR S5nU[ La[USS9nSUlU[ La"URRXb5n[ nO9URRXbUS9n[RRXR5nUR(dU(a[$U$URU5n XlU $)z* Reduce `target` along the given `axis`. rrTr=rr)rcrYrNrrrrrsrreducerrorwrirn) r|targetaxisrtclassrttrmr masked_trs rr_MaskedBinaryOperation.reduceNs %V, FO 6:: & 77b= ! Aad+ ;q'BBqe4B""))!2Bxx  GGFO rc [U5[U5pCURRX45n[U5n[U5nU[LaU[La[nO5[ U5n[ U5n[ RRXg5nUR(d U(a[$U[La[R"XSUS9 UR(dU$UR[X55n XlU $)z? Return the function applied to the outer product of a and b. r)rXrrrYrrZrrqrrwrrrrircrn) r|rSrrrrrrrmasked_ds rr_MaskedBinaryOperation.outerls AJ R FFLL  QZ QZ [TU]U5 X lX0lX@lU[ U'X44[ U'g)zWabfunc(fillx, filly) must be defined. abfunc(x, filly) = x for all x to enable reduce. N)rr}rrrrr)r|dbfuncrrrrs rr}!_DomainedBinaryOperation.__init__s7     % V$n Frcz[U5[U5pe[R"SSS9 UR"XV/UQ70UD6nSSS5 [R "W5)nU[ U5-nU[ U5-n[RURS5n U b X"XV5-nUR(dU(a[$U$[R"USSUS9 [R"X5n [R"U RURSS9(aXz- nUR![#X55n Xl['U[(5(aU R+U5 U $['U[(5(aU R+U5 U $!,(df  GN`=f![a Nf=f) rrrNrrrsafe)r)rXrrrrrmrYrr'rrwrrcan_castrrrircrnrrr) r|rSrrrrrrUrr masked_dars rr!_DomainedBinaryOperation.__call__smAJ R [[( ;VVB4T4V4F<^^F # # WQZ WQZ!!$&&$/    Avv    IIfa ;q-I{{9??FLL&I#  $7$=>  a % %  & &q ); ' '  & &q )G< ;2   sF A F- F*- F:9F:)rrrrrrs@rrrs( -((rr?gz8ggg?c[nURbm/nURHDnURUn[U5S:XaUSU4nUR XB"USU545 MF [ R "U5nOaUR(aN[UR5nU"URSU5US'[ R "[U55nOUnX`:XaUnU$)z=Private function allowing recursion in _replace_dtype_fields.rrr) _replace_dtype_fields_recursiverfieldsr<r"rrrrsr)rprimitive_dtype_recursedescrrfield new_dtypes rrr0s.H {{KKDLL&E5zQb 4( LL$q? CD E  HHUO  U^^$ENN1-?aHHU5\* $  rcp[R"U5n[R"U5n[X5$)z Construct a dtype description list from a given dtype. Returns a new dtype object, with all fields and subtypes in the given type recursively replaced with `primitive_dtype`. Arguments are coerced to dtypes first. )rrr)rrs r_replace_dtype_fieldsr Ps* HHUOEhh/O *5 BBrc"[U[5$)a Construct a dtype description list from a given dtype. Returns a new dtype object, with the type of all fields in `ndtype` to a boolean type. Field names are not altered. Parameters ---------- ndtype : dtype The dtype to convert. Returns ------- result : dtype A dtype that looks like `ndtype`, the type of all fields is boolean. Examples -------- >>> import numpy as np >>> import numpy.ma as ma >>> dtype = np.dtype({'names':['foo', 'bar'], ... 'formats':[np.float32, np.int64]}) >>> dtype dtype([('foo', '>> ma.make_mask_descr(dtype) dtype([('foo', '|b1'), ('bar', '|b1')]) >>> ma.make_mask_descr(np.float32) dtype('bool') )r r)rNs rrtrt^s> ! 22rc$[US[5$)av Return the mask of a masked array, or nomask. Return the mask of `a` as an ndarray if `a` is a `MaskedArray` and the mask is not `nomask`, else return `nomask`. To guarantee a full array of booleans of the same shape as a, use `getmaskarray`. Parameters ---------- a : array_like Input `MaskedArray` for which the mask is required. See Also -------- getdata : Return the data of a masked array as an ndarray. getmaskarray : Return the mask of a masked array, or full array of False. Examples -------- >>> import numpy as np >>> import numpy.ma as ma >>> a = ma.masked_equal([[1,2],[3,4]], 2) >>> a masked_array( data=[[1, --], [3, 4]], mask=[[False, True], [False, False]], fill_value=2) >>> ma.getmask(a) array([[False, True], [False, False]]) Equivalently use the `MaskedArray` `mask` attribute. >>> a.mask array([[False, True], [False, False]]) Result when mask == `nomask` >>> b = ma.masked_array([[1,2],[3,4]]) >>> b masked_array( data=[[1, 2], [3, 4]], mask=False, fill_value=999999) >>> ma.nomask False >>> ma.getmask(b) == ma.nomask True >>> b.mask == ma.nomask True rn)getattrr)rSs rrYrYsr 1gv &&rc[U5nU[La+[[R"U5[ USS55nU$)a Return the mask of a masked array, or full boolean array of False. Return the mask of `arr` as an ndarray if `arr` is a `MaskedArray` and the mask is not `nomask`, else return a full boolean array of False of the same shape as `arr`. Parameters ---------- arr : array_like Input `MaskedArray` for which the mask is required. See Also -------- getmask : Return the mask of a masked array, or nomask. getdata : Return the data of a masked array as an ndarray. Examples -------- >>> import numpy as np >>> import numpy.ma as ma >>> a = ma.masked_equal([[1,2],[3,4]], 2) >>> a masked_array( data=[[1, --], [3, 4]], mask=[[False, True], [False, False]], fill_value=2) >>> ma.getmaskarray(a) array([[False, True], [False, False]]) Result when mask == ``nomask`` >>> b = ma.masked_array([[1,2],[3,4]]) >>> b masked_array( data=[[1, 2], [3, 4]], mask=False, fill_value=999999) >>> ma.getmaskarray(b) array([[False, False], [False, False]]) rN)rYrrurrr)rrls rrZrZs7` 3>> import numpy as np >>> import numpy.ma as ma >>> m = ma.masked_equal([0, 1, 0, 2, 3], 0) >>> m masked_array(data=[--, 1, --, 2, 3], mask=[ True, False, True, False, False], fill_value=0) >>> ma.is_mask(m) False >>> ma.is_mask(m.mask) True Input must be an ndarray (or have similar attributes) for it to be considered a valid mask. >>> m = [False, True, False] >>> ma.is_mask(m) False >>> m = np.array([False, True, False]) >>> m array([False, True, False]) >>> ma.is_mask(m) True Arrays with complex dtypes don't return True. >>> dtype = np.dtype({'names':['monty', 'pithon'], ... 'formats':[bool, bool]}) >>> dtype dtype([('monty', '|b1'), ('pithon', '|b1')]) >>> m = np.array([(True, False), (False, True), (True, False)], ... dtype=dtype) >>> m array([( True, False), (False, True), ( True, False)], dtype=[('monty', '?'), ('pithon', '?')]) >>> ma.is_mask(m) False F)rr/rrhrs rrfrfs-~ww||x'' s  ++cjURRcUR5(d[$U$)z% Shrink a mask to nomask if possible )rrr!rrs r _shrink_maskr:s& ww}}QUUWW rFczU[La[$[U5n[U[5(aNURR (a3U[ R:Xa[ R"URUS9$U(dSOSn[ R"[US5XSS9nU(a [U5nU$)a Create a boolean mask from an array. Return `m` as a boolean mask, creating a copy if necessary or requested. The function can accept any sequence that is convertible to integers, or ``nomask``. Does not require that contents must be 0s and 1s, values of 0 are interpreted as False, everything else as True. Parameters ---------- m : array_like Potential mask. copy : bool, optional Whether to return a copy of `m` (True) or `m` itself (False). shrink : bool, optional Whether to shrink `m` to ``nomask`` if all its values are False. dtype : dtype, optional Data-type of the output mask. By default, the output mask has a dtype of MaskType (bool). If the dtype is flexible, each field has a boolean dtype. This is ignored when `m` is ``nomask``, in which case ``nomask`` is always returned. Returns ------- result : ndarray A boolean mask derived from `m`. Examples -------- >>> import numpy as np >>> import numpy.ma as ma >>> m = [True, False, True, True] >>> ma.make_mask(m) array([ True, False, True, True]) >>> m = [1, 0, 1, 1] >>> ma.make_mask(m) array([ True, False, True, True]) >>> m = [1, 0, 2, -3] >>> ma.make_mask(m) array([ True, False, True, True]) Effect of the `shrink` parameter. >>> m = np.zeros(4) >>> m array([0., 0., 0., 0.]) >>> ma.make_mask(m) False >>> ma.make_mask(m, shrink=False) array([False, False, False, False]) Using a flexible `dtype`. >>> m = [1, 0, 1, 1] >>> n = [0, 1, 0, 0] >>> arr = [] >>> for man, mouse in zip(m, n): ... arr.append((man, mouse)) >>> arr [(1, 0), (0, 1), (1, 0), (1, 0)] >>> dtype = np.dtype({'names':['man', 'mouse'], ... 'formats':[np.int64, np.int64]}) >>> arr = np.array(arr, dtype=dtype) >>> arr array([(1, 0), (0, 1), (1, 0), (1, 0)], dtype=[('man', '>> ma.make_mask(arr, dtype=dtype) array([(True, False), (False, True), (True, False), (True, False)], dtype=[('man', '|b1'), ('mouse', '|b1')]) rNT)r=rrf) rrtrrrrrboolrrr rNr)rr=shrinkrrUs rrsrsDsP F{  E "E!W!''..Ubgg5Ewwqwwe,,4D XXfQoDT JF f% Mrc~Uc"U[S9nU$[R"U[U5S9nU$)a Return a boolean mask of the given shape, filled with False. This function returns a boolean ndarray with all entries False, that can be used in common mask manipulations. If a complex dtype is specified, the type of each field is converted to a boolean type. Parameters ---------- newshape : tuple A tuple indicating the shape of the mask. dtype : {None, dtype}, optional If None, use a MaskType instance. Otherwise, use a new datatype with the same fields as `dtype`, converted to boolean types. Returns ------- result : ndarray An ndarray of appropriate shape and dtype, filled with False. See Also -------- make_mask : Create a boolean mask from an array. make_mask_descr : Construct a dtype description list from a given dtype. Examples -------- >>> import numpy as np >>> import numpy.ma as ma >>> ma.make_mask_none((3,)) array([False, False, False]) Defining a more complex dtype. >>> dtype = np.dtype({'names':['foo', 'bar'], ... 'formats':[np.float32, np.int64]}) >>> dtype dtype([('foo', '>> ma.make_mask_none((3,), dtype=dtype) array([(False, False), (False, False), (False, False)], dtype=[('foo', '|b1'), ('bar', '|b1')]) r)rrrrt)newshaperrUs rrurus=X }((3 M(/%*@A MrcURRnUHMnXnURRb[XQUX$5 M1[R"XQUX$5 MO gr)rr_recursive_mask_orrrq)m1m2newmaskrrcurrent1s rrrsV HHNNE8 >>   + xD7= A   X$x ? rc6U[LdUSLa[US[5n[XX4S9$U[LdUSLa[US[5n[XX4S9$XLa$[ U5(aU(a [ U5$U$[USS5[USS5peXV:wa[ SU<SU<S35eURbC[R"[R"X5RU5n[XU5 U$[[R"X5X#S9$) a4 Combine two masks with the ``logical_or`` operator. The result may be a view on `m1` or `m2` if the other is `nomask` (i.e. False). Parameters ---------- m1, m2 : array_like Input masks. copy : bool, optional If copy is False and one of the inputs is `nomask`, return a view of the other input mask. Defaults to False. shrink : bool, optional Whether to shrink the output to `nomask` if all its values are False. Defaults to True. Returns ------- mask : output mask The result masks values that are masked in either `m1` or `m2`. Raises ------ ValueError If `m1` and `m2` have different flexible dtypes. Examples -------- >>> import numpy as np >>> m1 = np.ma.make_mask([0, 1, 1, 0]) >>> m2 = np.ma.make_mask([1, 0, 0, 0]) >>> np.ma.mask_or(m1, m2) array([ True, True, True, False]) Fr)r=rrNzIncompatible dtypes 'z'<>''r=r)rrrrsrfrrIrrrI broadcastrrrrq)rrr=rrdtype1dtype2rs rrvrvsL f "+GX.vCC f "+GX.vCC xGBKK#)|B1r1GT2GB4NV VVLMM ||((2<</55v>27+ U%%b-D HHrc^SnU4Sjm[R"U5nT"U"U55n[R"[U5[S9$)a Returns a completely flattened version of the mask, where nested fields are collapsed. Parameters ---------- mask : array_like Input array, which will be interpreted as booleans. Returns ------- flattened_mask : ndarray of bools The flattened input. Examples -------- >>> import numpy as np >>> mask = np.array([0, 0, 1]) >>> np.ma.flatten_mask(mask) array([False, False, True]) >>> mask = np.array([(0, 0), (0, 1)], dtype=[('a', bool), ('b', bool)]) >>> np.ma.flatten_mask(mask) array([False, False, False, True]) >>> mdtype = [('a', bool), ('b', [('ba', bool), ('bb', bool)])] >>> mask = np.array([(0, (0, 0)), (0, (0, 1))], dtype=mdtype) >>> np.ma.flatten_mask(mask) array([False, False, False, False, False, True]) c~URRnUbUVs/sHn[X5PM sn$U$s snf)zCFlatten the mask and returns a (maybe nested) sequence of booleans.)rrrP)rlmnamesrs r _flatmaskflatten_mask.._flatmask6s>!!  9?@L,@ @KAs:c3># UH*n[US5(aT"U5ShvN M&Uv M, gN![a Uv gf=f7f)z.Generates a flattened version of the sequence.__iter__N)r r)sequenceelement _flatsequences rr0#flatten_mask.._flatsequence>sM #7J//,W555!M $5 N s1A !868A 8A A A  A r)rr0r rsr)rlr* flattenedr0s @rrPrPsAB  ::d Dio.I 88DO4 00rczU[RLa0OSU0nU[LaUR"SSU0UD6$[$)z:Check whether there are masked values along the given axiskeepdimsrr)rr rr)rlrr4rs r_check_mask_axisr5Ns=r{{*RX0FF 6xx,T,V,, Mrc[USS9n[R"XSS9nURURpTU(aXE:wa[ SU<SU<S35e[ US5(a![ X1R5n[U5nO[nURU5n[U5Ul U(dB[ US5(a1[U5[LaURR5UlU$) a Mask an array where a condition is met. Return `a` as an array masked where `condition` is True. Any masked values of `a` or `condition` are also masked in the output. Parameters ---------- condition : array_like Masking condition. When `condition` tests floating point values for equality, consider using ``masked_values`` instead. a : array_like Array to mask. copy : bool If True (default) make a copy of `a` in the result. If False modify `a` in place and return a view. Returns ------- result : MaskedArray The result of masking `a` where `condition` is True. See Also -------- masked_values : Mask using floating point equality. masked_equal : Mask where equal to a given value. masked_not_equal : Mask where *not* equal to a given value. masked_less_equal : Mask where less than or equal to a given value. masked_greater_equal : Mask where greater than or equal to a given value. masked_less : Mask where less than a given value. masked_greater : Mask where greater than a given value. masked_inside : Mask inside a given interval. masked_outside : Mask outside a given interval. masked_invalid : Mask invalid values (NaNs or infs). Examples -------- >>> import numpy as np >>> import numpy.ma as ma >>> a = np.arange(4) >>> a array([0, 1, 2, 3]) >>> ma.masked_where(a <= 2, a) masked_array(data=[--, --, --, 3], mask=[ True, True, True, False], fill_value=999999) Mask array `b` conditional on `a`. >>> b = ['a', 'b', 'c', 'd'] >>> ma.masked_where(a == 2, b) masked_array(data=['a', 'b', --, 'd'], mask=[False, False, True, False], fill_value='N/A', dtype='>> c = ma.masked_where(a <= 2, a) >>> c masked_array(data=[--, --, --, 3], mask=[ True, True, True, False], fill_value=999999) >>> c[0] = 99 >>> c masked_array(data=[99, --, --, 3], mask=[False, True, True, False], fill_value=999999) >>> a array([0, 1, 2, 3]) >>> c = ma.masked_where(a <= 2, a, copy=False) >>> c[0] = 99 >>> c masked_array(data=[99, --, --, 3], mask=[False, True, True, False], fill_value=999999) >>> a array([99, 1, 2, 3]) When `condition` or `a` contain masked values. >>> a = np.arange(4) >>> a = ma.masked_where(a == 2, a) >>> a masked_array(data=[0, 1, --, 3], mask=[False, False, True, False], fill_value=999999) >>> b = np.arange(4) >>> b = ma.masked_where(b == 0, b) >>> b masked_array(data=[--, 1, 2, 3], mask=[ True, False, False, False], fill_value=999999) >>> ma.masked_where(a == 3, b) masked_array(data=[--, 1, --, --], mask=[ True, False, True, True], fill_value=999999) FrTrez value). See Also -------- masked_where : Mask where a condition is met. Examples -------- >>> import numpy as np >>> import numpy.ma as ma >>> a = np.arange(4) >>> a array([0, 1, 2, 3]) >>> ma.masked_greater(a, 2) masked_array(data=[0, 1, 2, --], mask=[False, False, False, True], fill_value=999999) r)rr[rvaluer=s rrzrzs0 )1 88rc([[X5XS9$)a Mask an array where greater than or equal to a given value. This function is a shortcut to ``masked_where``, with `condition` = (x >= value). See Also -------- masked_where : Mask where a condition is met. Examples -------- >>> import numpy as np >>> import numpy.ma as ma >>> a = np.arange(4) >>> a array([0, 1, 2, 3]) >>> ma.masked_greater_equal(a, 2) masked_array(data=[0, 1, --, --], mask=[False, False, True, True], fill_value=999999) r)rr\r?s rr{r{s0  a/ >>rc([[X5XS9$)a Mask an array where less than a given value. This function is a shortcut to ``masked_where``, with `condition` = (x < value). See Also -------- masked_where : Mask where a condition is met. Examples -------- >>> import numpy as np >>> import numpy.ma as ma >>> a = np.arange(4) >>> a array([0, 1, 2, 3]) >>> ma.masked_less(a, 2) masked_array(data=[--, --, 2, 3], mask=[ True, True, False, False], fill_value=999999) r)rrjr?s rr~r~ s0 Q 55rc([[X5XS9$)a Mask an array where less than or equal to a given value. This function is a shortcut to ``masked_where``, with `condition` = (x <= value). See Also -------- masked_where : Mask where a condition is met. Examples -------- >>> import numpy as np >>> import numpy.ma as ma >>> a = np.arange(4) >>> a array([0, 1, 2, 3]) >>> ma.masked_less_equal(a, 2) masked_array(data=[--, --, --, 3], mask=[ True, True, True, False], fill_value=999999) r)rrkr?s rrr&s0  1,a ;;rc([[X5XS9$)a Mask an array where *not* equal to a given value. This function is a shortcut to ``masked_where``, with `condition` = (x != value). See Also -------- masked_where : Mask where a condition is met. Examples -------- >>> import numpy as np >>> import numpy.ma as ma >>> a = np.arange(4) >>> a array([0, 1, 2, 3]) >>> ma.masked_not_equal(a, 2) masked_array(data=[--, --, 2, --], mask=[ True, True, False, True], fill_value=999999) r)rrr?s rrrAs0  !+Q ::rc8[[X5XS9nXlU$)al Mask an array where equal to a given value. Return a MaskedArray, masked where the data in array `x` are equal to `value`. The fill_value of the returned MaskedArray is set to `value`. For floating point arrays, consider using ``masked_values(x, value)``. See Also -------- masked_where : Mask where a condition is met. masked_values : Mask using floating point equality. Examples -------- >>> import numpy as np >>> import numpy.ma as ma >>> a = np.arange(4) >>> a array([0, 1, 2, 3]) >>> ma.masked_equal(a, 2) masked_array(data=[0, 1, --, 3], mask=[False, False, True, False], fill_value=2) r)rrKrM)rr@r=outputs rryry\s8%/1 8F MrcLX!:aX!p![U5nXA:XB:*-n[XPUS9$)aJ Mask an array inside a given interval. Shortcut to ``masked_where``, where `condition` is True for `x` inside the interval [v1,v2] (v1 <= x <= v2). The boundaries `v1` and `v2` can be given in either order. See Also -------- masked_where : Mask where a condition is met. Notes ----- The array `x` is prefilled with its filling value. Examples -------- >>> import numpy as np >>> import numpy.ma as ma >>> x = [0.31, 1.2, 0.01, 0.2, -0.4, -1.1] >>> ma.masked_inside(x, -0.3, 0.3) masked_array(data=[0.31, 1.2, --, --, -0.4, -1.1], mask=[False, False, True, True, False, False], fill_value=1e+20) The order of `v1` and `v2` doesn't matter. >>> ma.masked_inside(x, 0.3, -0.3) masked_array(data=[0.31, 1.2, --, --, -0.4, -1.1], mask=[False, False, True, True, False, False], fill_value=1e+20) rrNrrv1v2r=xfr:s rr|r|}s3D wR Bbh'I  4 00rcLX!:aX!p![U5nXA:XB:-n[XPUS9$)aG Mask an array outside a given interval. Shortcut to ``masked_where``, where `condition` is True for `x` outside the interval [v1,v2] (x < v1)|(x > v2). The boundaries `v1` and `v2` can be given in either order. See Also -------- masked_where : Mask where a condition is met. Notes ----- The array `x` is prefilled with its filling value. Examples -------- >>> import numpy as np >>> import numpy.ma as ma >>> x = [0.31, 1.2, 0.01, 0.2, -0.4, -1.1] >>> ma.masked_outside(x, -0.3, 0.3) masked_array(data=[--, --, 0.01, 0.2, --, --], mask=[ True, True, False, False, True, True], fill_value=1e+20) The order of `v1` and `v2` doesn't matter. >>> ma.masked_outside(x, 0.3, -0.3) masked_array(data=[--, --, 0.01, 0.2, --, --], mask=[ True, True, False, False, True, True], fill_value=1e+20) rrHrIs rrrs3D wR BRW%I  4 00rc[U5(a.[R"URU5nURnO1[R"[ R "U5U5n[n[U[XCS95n[XX!S9$)a Mask the array `x` where the data are exactly equal to value. This function is similar to `masked_values`, but only suitable for object arrays: for floating point, use `masked_values` instead. Parameters ---------- x : array_like Array to mask value : object Comparison value copy : {True, False}, optional Whether to return a copy of `x`. shrink : {True, False}, optional Whether to collapse a mask full of False to nomask Returns ------- result : MaskedArray The result of masking `x` where equal to `value`. See Also -------- masked_where : Mask where a condition is met. masked_equal : Mask where equal to a given value (integers). masked_values : Mask using floating point equality. Examples -------- >>> import numpy as np >>> import numpy.ma as ma >>> food = np.array(['green_eggs', 'ham'], dtype=object) >>> # don't eat spoiled food >>> eat = ma.masked_object(food, 'green_eggs') >>> eat masked_array(data=[--, 'ham'], mask=[ True, False], fill_value='green_eggs', dtype=object) >>> # plain ol` ham is boring >>> fresh_food = np.array(['cheese', 'ham', 'pineapple'], dtype=object) >>> eat = ma.masked_object(fresh_food, 'green_eggs') >>> eat masked_array(data=['cheese', 'ham', 'pineapple'], mask=False, fill_value='green_eggs', dtype=object) Note that `mask` is set to ``nomask`` if possible. >>> eat masked_array(data=['cheese', 'ham', 'pineapple'], mask=False, fill_value='green_eggs', dtype=object) r7rlr=rM) rerrKrgrnrr0rrvrsrx)rr@r=rr:rls rrrshvQKK/ wwKK 1 u5  49< =D 4 BBrc[X5n[R"UR[R5(a[R "XaX2S9nO[ R"Xa5n[XgXAS9nU(aUR5 U$)aL Mask using floating point equality. Return a MaskedArray, masked where the data in array `x` are approximately equal to `value`, determined using `isclose`. The default tolerances for `masked_values` are the same as those for `isclose`. For integer types, exact equality is used, in the same way as `masked_equal`. The fill_value is set to `value` and the mask is set to ``nomask`` if possible. Parameters ---------- x : array_like Array to mask. value : float Masking value. rtol, atol : float, optional Tolerance parameters passed on to `isclose` copy : bool, optional Whether to return a copy of `x`. shrink : bool, optional Whether to collapse a mask full of False to ``nomask``. Returns ------- result : MaskedArray The result of masking `x` where approximately equal to `value`. See Also -------- masked_where : Mask where a condition is met. masked_equal : Mask where equal to a given value (integers). Examples -------- >>> import numpy as np >>> import numpy.ma as ma >>> x = np.array([1, 1.1, 2, 1.1, 3]) >>> ma.masked_values(x, 1.1) masked_array(data=[1.0, --, 2.0, --, 3.0], mask=[False, True, False, True, False], fill_value=1.1) Note that `mask` is set to ``nomask`` if possible. >>> ma.masked_values(x, 2.1) masked_array(data=[1. , 1.1, 2. , 1.1, 3. ], mask=False, fill_value=2.1) Unlike `masked_equal`, `masked_values` can perform approximate equalities. >>> ma.masked_values(x, 2.1, atol=1e-1) masked_array(data=[1.0, 1.1, --, 1.1, 3.0], mask=[False, False, True, False, False], fill_value=2.1) )atolrtolrO) rNr issubdtyperfloatingiscloserrKrx shrink_mask) rr@rRrQr=rxnewrlrets rrr sd| ! D }}TZZ--zz$D<{{4' tT DC   Jrc[R"USSS9n[[R"U5)XS9nUR[ La%[ URUR5UlU$)a Mask an array where invalid values occur (NaNs or infs). This function is a shortcut to ``masked_where``, with `condition` = ~(np.isfinite(a)). Any pre-existing mask is conserved. Only applies to arrays with a dtype where NaNs or infs make sense (i.e. floating point types), but accepts any array_like object. See Also -------- masked_where : Mask where a condition is met. Examples -------- >>> import numpy as np >>> import numpy.ma as ma >>> a = np.arange(5, dtype=float) >>> a[2] = np.nan >>> a[3] = np.inf >>> a array([ 0., 1., nan, inf, 4.]) >>> ma.masked_invalid(a) masked_array(data=[0.0, 1.0, --, --, 4.0], mask=[False, False, True, True, False], fill_value=1e+20) NTrer) rr rrmrnrrurr)rSr=ress rr}r}] sV8 T*A Q(! 7C yyF"399cii8 JrcD\rSrSrSrSrSrSrSrS Sjr Sr \ r S r g ) _MaskedPrintOptioni zF Handle the string used to represent missing data in a masked array. cXlSUlg)z) Create the masked_print_option object. TN_display_enabled)r|displays rr}_MaskedPrintOption.__init__ s   rcUR$)z1 Display the string to print for masked values. r_rs rra_MaskedPrintOption.display  }}rcXlg)z- Set the string to print for masked values. Nrd)r|rs r set_display_MaskedPrintOption.set_display s  rcUR$)z+ Is the use of the display value enabled? r`rs renabled_MaskedPrintOption.enabled rfrcXlg)z' Set the enabling shrink to `shrink`. Nrk)r|rs renable_MaskedPrintOption.enable s  rc,[UR5$r)r(r_rs rr_MaskedPrintOption.__str__ s4==!!rr^Nr) rrrrrr}rarhrlror__repr__rrrrr\r\ s, "Hrr\z--cURRnUbUHnXnXn[XVU5 M g[R"XUS9 g)z[ Puts printoptions in result where mask is True. Private function allowing for recursion Nr)rr_recursive_printoptionrr)rUrlprintoptrrcurdatacurmasks rruru sS LL  E DlGjG "7X >   &$/ rz masked_%(name)s(data = %(data)s, %(nlen)s mask = %(mask)s, %(nlen)s fill_value = %(fill)s) z masked_%(name)s(data = %(data)s, %(nlen)s mask = %(mask)s, %(nlen)s fill_value = %(fill)s, %(nlen)s dtype = %(dtype)s) z masked_%(name)s(data = %(data)s, %(nlen)s mask = %(mask)s, %(nlen)s fill_value = %(fill)s) z masked_%(name)s(data = %(data)s, %(nlen)s mask = %(mask)s, %(nlen)s fill_value = %(fill)s, %(nlen)s dtype = %(dtype)s) )long_stdlong_flx short_std short_flxcURRnUHKnXnURRb[XQUX$5 M1[R"XRUXS9 MM g)z* Recursively fill `a` with `fill_value`. Nr)rr_recursive_filledrr)rSrlrMrrcurrents rr~r~ sX GGMME' ==   * gDz:3C D IIg$/tz B rc 0^U4Sjm[R"U5nURnUR5n[ U[ 5(a[R "URVs/sH"n[T"UR555PM$ sn5nUR[ 5n[R "[U5Vs/sH"n[T"UR555PM$ sn5Ul OD[R "UVs/sH"n[T"UR555PM$ sn5n[U5S:a/[UR5nXS'[T"U55UlU$s snfs snfs snf)a Flatten a structured array. The data type of the output is chosen such that it can represent all of the (nested) fields. Parameters ---------- a : structured array Returns ------- output : masked array or ndarray A flattened masked array if the input is a masked array, otherwise a standard ndarray. Examples -------- >>> import numpy as np >>> ndtype = [('a', int), ('b', float)] >>> a = np.array([(1, 1), (2, 2)], dtype=ndtype) >>> np.ma.flatten_structured_array(a) array([[1., 1.], [2., 2.]]) c3># [U5H*n[US5(aT"U5ShvN M&Uv M, gN7f)z+ Flattens a compound of nested iterables. r-N)iterr )iterableelmflatten_sequences rr2flatten_structured_array..flatten_sequence s9 >CsJ''+C000 "0s+A>Arr)rr/rrrrr rgrr?rirZrnr<rs)rSinishaperoutrrs @rrQrQ s18  aAwwH  A![!!hh177K7a.qvvx897KLhh{#HH'3A8'6!$$4QVVX$>?'689 hh1E1a.qvvx891EF 8}q ? *845 JL8Fs-)F )F)Fc^^UU4Sjn[[TS5=(d [[TS5nUbURUlTUlU$)a Return a class method wrapper around a basic array method. Creates a class method which returns a masked array, where the new ``_data`` array is the output of the corresponding basic method called on the original ``_data``. If `onmask` is True, the new mask is the output of the method called on the initial mask. Otherwise, the new mask is just a reference to the initial mask. Parameters ---------- funcname : str Name of the function to apply on data. onmask : bool Whether the mask must be processed also (True) or left alone (False). Default is True. Make available as `_onmask` attribute. Returns ------- method : instancemethod Class method wrapper of the specified basic array method. c">[URT5"U0UD6nUR[U55nUR U5 UR nT(dUR U5 U$U[La[UT5"U0UD6UlU$r)rrgrir/rrn __setmask__r)r|rparamsrUrlfuncnameonmasks rwrapped_method$_arraymethod..wrapped_methodN sX.??T$Z(D!zz   t $  "42DCFCFL rN)rrrrr)rrrmethdocs`` r _arraymethodr3 sF6 gx.M'"h2MG!(&N rc6\rSrSrSrSrSrSrSrSr Sr g ) MaskedIteratori` a= Flat iterator object to iterate over masked arrays. A `MaskedIterator` iterator is returned by ``x.flat`` for any masked array `x`. It allows iterating over the array as if it were a 1-D array, either in a for-loop or by calling its `next` method. Iteration is done in C-contiguous style, with the last index varying the fastest. The iterator can also be indexed using basic slicing or advanced indexing. See Also -------- MaskedArray.flat : Return a flat iterator over an array. MaskedArray.flatten : Returns a flattened copy of an array. Notes ----- `MaskedIterator` is not exported by the `ma` module. Instead of instantiating a `MaskedIterator` directly, use `MaskedArray.flat`. Examples -------- >>> import numpy as np >>> x = np.ma.array(arange(6).reshape(2, 3)) >>> fl = x.flat >>> type(fl) >>> for item in fl: ... print(item) ... 0 1 2 3 4 5 Extracting more than a single element b indexing the `MaskedIterator` returns a masked array: >>> fl[2:4] masked_array(data = [2 3], mask = False, fill_value = 999999) cXlURRUlUR[ LaSUlgURRUlgr)rrgflatdataiterrnrmaskiter)r|rs rr}MaskedIterator.__init__ s8  88v  DMHHMMDMrcU$rrrs rr-MaskedIterator.__iter__  rcURRU5R[UR55nUR bUR RU5n[ U[5(aURUlX2l U$[ U[R5(a[X#URRS9$U(a[$U$)Nrlhardmask)r __getitem__rir/rrrrrrnrrHr _hardmaskrw)r|indxrUrns rrMaskedIterator.__getitem__ s**4055d477mD == $MM--d3E%))$ll $  E277++V$'':K:KLL  rc[U5URU'URb[U5URU'ggr)rXrrrZ)r|indexr@s r __setitem__MaskedIterator.__setitem__ s6&u~ e == $#/#6DMM%  %rc[UR5nURb_[UR5n[U[R 5(a[ XURRS9$U(a[$U$)z Return the next value, or raise StopIteration. Examples -------- >>> import numpy as np >>> x = np.ma.array([3, 2], mask=[0, 1]) >>> fl = x.flat >>> next(fl) 3 >>> next(fl) masked >>> next(fl) Traceback (most recent call last): ... StopIteration r) nextrrrrrHrrrrw)r|rrs r__next__MaskedIterator.__next__ s_&   == $T]]#A!RWW%%Q1B1BCC r)rrrN) rrrrrr}r-rrrrrrrrr` s!.`* 7 rrznumpy.mac ^\rSrSrSrSr\rSr\ r Sr Sr S\SSSS SSSSS4 S jr S rS rSS jrSSjrSr\R("SSS9S5r\U4Sj5r\R0U4Sj5r\U4Sj5r\R0U4Sj5rSSjr\r\S5r\R0S5r\S5r\R0S5rSrSr\S5r Sr!\S 5r"S!r#\S"5r$S#r%\"\%S$9r&\"\%S$9r'\S%5r(\(R0S&5r(\S'5r)\)R0SS(j5r)\)RTr+\)RXr-SS)jr.S*r/SS+jr0S,r1S-r2S.r3S/r4S0r5S1r6S2r7S3r8S4r9S5r:S6r;S7rS:r?S;r@S<rAS=rBS>rCS?rDS@rESArFSBrGSCrHSDrISErJSFrKSGrLSHrMSIrNSJrOSKrPSLrQ\SM5rR\RRTrS\SN5rT\TRTrUS\R4SOjrWSSPjrXSQrYSSRjrZSSSjr[STr\SUr]SS\R4SVjr^SS\R4SWjr_SXr`SU4SYjjra\ RR\alSSZjrbSSS\R4S[jrcSS\jrdSSS\R4S]jre\erfSS^jrgSSS\R4U4S_jjrhSS`jriSSSS \R\R4U4Sajjrj\RR\jlSSSS \R\R4SbjrkSScjrl\RSSSS4SSd.SejjrmS\RSf.SgjjrnS\RSf.ShjjroSSSd.SijjrpSSS\R4SjjrqSSS\R4SkjrrSSljrsU4SmjrtU4SnjruSSojrv\w"Sp5rx\w"Sq5ry\w"Sr5rz\w"Ss5r{\w"St5r|\w"Su5r}\"SvS$9r~\w"Sw5r\Sx5rSSyjrSSzjrSS{jrSS|jrS}r\rU4S~jrU4SjrSrSSjrSrU=r$)ri a= An array class with possibly masked values. Masked values of True exclude the corresponding element from any computation. Construction:: x = MaskedArray(data, mask=nomask, dtype=None, copy=False, subok=True, ndmin=0, fill_value=None, keep_mask=True, hard_mask=None, shrink=True, order=None) Parameters ---------- data : array_like Input data. mask : sequence, optional Mask. Must be convertible to an array of booleans with the same shape as `data`. True indicates a masked (i.e. invalid) data. dtype : dtype, optional Data type of the output. If `dtype` is None, the type of the data argument (``data.dtype``) is used. If `dtype` is not None and different from ``data.dtype``, a copy is performed. copy : bool, optional Whether to copy the input data (True), or to use a reference instead. Default is False. subok : bool, optional Whether to return a subclass of `MaskedArray` if possible (True) or a plain `MaskedArray`. Default is True. ndmin : int, optional Minimum number of dimensions. Default is 0. fill_value : scalar, optional Value used to fill in the masked values when necessary. If None, a default based on the data-type is used. keep_mask : bool, optional Whether to combine `mask` with the mask of the input data, if any (True), or to use only `mask` for the output (False). Default is True. hard_mask : bool, optional Whether to use a hard mask or not. With a hard mask, masked values cannot be unmasked. Default is False. shrink : bool, optional Whether to force compression of an empty mask. Default is True. order : {'C', 'F', 'A'}, optional Specify the order of the array. If order is 'C', then the array will be in C-contiguous order (last-index varies the fastest). If order is 'F', then the returned array will be in Fortran-contiguous order (first-index varies the fastest). If order is 'A' (default), then the returned array may be in any order (either C-, Fortran-contiguous, or even discontiguous), unless a copy is required, in which case it will be C-contiguous. Examples -------- >>> import numpy as np The ``mask`` can be initialized with an array of boolean values with the same shape as ``data``. >>> data = np.arange(6).reshape((2, 3)) >>> np.ma.MaskedArray(data, mask=[[False, True, False], ... [False, False, True]]) masked_array( data=[[0, --, 2], [3, 4, --]], mask=[[False, True, False], [False, False, True]], fill_value=999999) Alternatively, the ``mask`` can be initialized to homogeneous boolean array with the same shape as ``data`` by passing in a scalar boolean value: >>> np.ma.MaskedArray(data, mask=False) masked_array( data=[[0, 1, 2], [3, 4, 5]], mask=[[False, False, False], [False, False, False]], fill_value=999999) >>> np.ma.MaskedArray(data, mask=True) masked_array( data=[[--, --, --], [--, --, --]], mask=[[ True, True, True], [ True, True, True]], fill_value=999999, dtype=int64) .. note:: The recommended practice for initializing ``mask`` with a scalar boolean value is to use ``True``/``False`` rather than ``np.True_``/``np.False_``. The reason is :attr:`nomask` is represented internally as ``np.False_``. >>> np.False_ is np.ma.nomask True FdiNTrc  ^U(dSOSn[R"XUU SUS9n [US[U 55n [ U[ 5(aUR U R :waSn[ X5(a=U(a6[ U[5(d![R"U [U55n O[R"X5n [US5(a&[ U[5(dURU l [U R5nU[LGa[U(d:U (a [U l GO[R"U R US9U l GO[ U[ ["45(az[R"UVs/sH*n[%[R&"XRS95PM, snUS9nU[,:Xa"UR/5(a X,l SU lGO/U(+U lU(apU RR35U l [5U5[La?URR UR :waUR URlGOUcSnUSLa*U[,:Xa [R6"U R US9nOEUSLa*U[,:Xa [R"U R US9nO[R"X$US9nUR U R :wazU R:UR:nnUS :Xa![R<"X,R 5nO9UU:Xa![R>"X,R 5nOS n[AUUU4-5eSnU R[LaX,l U(+U lOwU(dX,l U(+U lO]U RRBbU4S jmT"U RU5 O%[RD"X,R5U l SU lUc [US S5nUb[GX|R5U l$U c[US S5U l%OXl%Xl&U $s snf![([*4a [nGNf=f![*aF [R"UVs/sHn[!U/[9U5-5PM Os snfsnUS9nGNf=f)zz Create a new masked array from scratch. Notes ----- A masked array can also be created by taking a .view(MaskedArray). NT)rr=orderrfndmin _baseclassrnrFr=rrz?Mask and data not compatible: data size is %i, mask size is %i.c>URRH/nXXpCURRb T"X45 M+X4-nM1 g)z'do a|=b on each field of a, recursivelyN)rr)rSrrafbf _recursive_ors rr*MaskedArray.__new__.._recursive_or s=() ,-GQWR#%88>>#=$1"$9$&HB )6r _fill_valuer)'rr rr/rrrr]rrir rnrtrrrrrsrZr/rIrrr! _sharedmaskr=rYrr<rrrrrrqrPrrr)rbrjrlrr=rfrrM keep_mask hard_maskrrrgrmdtyperndnmmsgrs @r__new__MaskedArray.__new__? s tT$D?T<e= dK ( (djjEKK.GD d U:dN3S3SLLT 3ELL,E 4 ! !*T7*C*C**EK!- 6>"(EK#%((5;;f"EEKD5$-00"88"&("&Q&bmmA[[&IJ"&(/57Dh&DHHJJ"&K(-E%(,H!"'++"2"2"4EKt}F2  ::++tzz9/3zzDJJ,|t|( 2wwu{{&96X#5xx 6:288D6BD zzU[[(!JJ R799T;;7D2X::dKK8D-C#C2r(N33{{f$" (,H! "&K,0E%{{((4-&ekk48&(mmD++&F (-E%   }d;J  ! 1*kk JE   %dK?EO'O% w("I."!D"L!288t$Lt!UA3V+<%=t$L*02D2sBR1Q;R$R;RRRS-;"S  S-,S-c  [U[5(a [U5nO[n0nUR[ US055 UR[ US055 [U[ 5(dUR[ US055 [ [ USS5[ USS5[ USS5[ US S5[ US U5UUS 9nURRU5 URRU5 g) z) Copies some attributes of obj to self. _optinfo _basedict__dict__rNrFr_isfieldr)rrrrrrr)rrr/updaterrr[r)r|rrr_dicts rrMaskedArray._update_from s c7 # #cJ JZ45["56#{++ OOGCR8 9mT!B&sK?!(mU!C%c:u= '\: F&' ) U# X&rcURU5 [U[5(aURRb [ U5nO [ U5nU[LaURSSURSS:waURUR:Xa URnO[UR5nURR(aSnO URR(aSnOSnURX45nOUR5nO[nX lUR[LaUR URlUR(b&[+UR(UR5UlgURRb[+SUR5Ulgg!["a [UlN~[$[&4a Nf=f)z Finalizes the masked array. NrjrCFK)rrrrrrZrYr__array_interface__rtflags c_contiguous f_contiguousastyperirnrrIrrhrrP)r|rrn _mask_dtypers r__array_finalize__MaskedArray.__array_finalize__ s #8 c7 # #yy*$S) V#(?(?(G(J//7:);::*"'++K"1$**"=K::**EZZ,,EE [8 E ::V # #'::      '01A1A4::ND  ZZ   )0tzzBD * $# ~.  sGG,G,+G,c jXLaUnO+UR[U55nURU5 UGb6URR 5UlUupVnUSUR n[ R"[UV s/sHn [U 5PM sn 5n [RU5n U b[R"SSS9 U "U6R[SS9n [!U S5n SSS5 W R#5(a2[$USn [R,"XMU S9 U [.LaU n OX-n X@LaUR0S :Xa U (a[2$XlSUlU$s sn f!,(df  N=f![&a [$Un N[(a UR*n Nf=f) zZ Special hook for ufuncs. Wraps the numpy array and sets the mask according to context. NrrFrTrrr)rir/rrnr=nin functoolsrrvrZrr'rrrrrNr!rrr0rMrrrrwr)r|rcontext return_scalarrUfuncrout_i input_argsargrrrrMs r__array_wrap__MaskedArray.__array_wrap__G s ;FXXd4j)F    %  !<<,,.FL ' DitxxJ   *S <+< *STA!%%d+F![[(C +224e2DAq$A D55775%0%6r%: IIf:F{U!fllb&8Q  %*" Q+T DC%7%0%6 #5%)__ 5s*E/ $E4 F4 FF2F21F2c*Uc1Uc[R"U5nOw[R"X5nO`UcF[U[5(a[R"X5nSnO.[R"X5nO[R"XU5n[ U5[ LaUR R5Ul[USS5bUcUcU$SUlU$X4l U$![a [R"X5nN|f=f)a Return a view of the MaskedArray data. Parameters ---------- dtype : data-type or ndarray sub-class, optional Data-type descriptor of the returned view, e.g., float32 or int16. The default, None, results in the view having the same data-type as `a`. As with ``ndarray.view``, dtype can also be specified as an ndarray sub-class, which then specifies the type of the returned object (this is equivalent to setting the ``type`` parameter). type : Python type, optional Type of the returned view, either ndarray or a subclass. The default None results in type preservation. fill_value : scalar, optional The value to use for invalid entries (None by default). If None, then this argument is inferred from the passed `dtype`, or in its absence the original array, as discussed in the notes below. See Also -------- numpy.ndarray.view : Equivalent method on ndarray object. Notes ----- ``a.view()`` is used two different ways: ``a.view(some_dtype)`` or ``a.view(dtype=some_dtype)`` constructs a view of the array's memory with a different data-type. This can cause a reinterpretation of the bytes of memory. ``a.view(ndarray_subclass)`` or ``a.view(type=ndarray_subclass)`` just returns an instance of `ndarray_subclass` that looks at the same array (same shape, dtype, etc.) This does not cause a reinterpretation of the memory. If `fill_value` is not specified, but `dtype` is specified (and is not an ndarray sub-class), the `fill_value` of the MaskedArray will be reset. If neither `fill_value` nor `dtype` are specified (or if `dtype` is an ndarray sub-class), then the fill value is preserved. Finally, if `fill_value` is specified, but `dtype` is not, the fill value is set to the specified value. For ``a.view(some_dtype)``, if ``some_dtype`` has a different number of bytes per entry than the previous dtype (for example, converting a regular array to a structured array), then the behavior of the view cannot be predicted just from the superficial appearance of ``a`` (shown by ``print(a)``). It also depends on exactly how ``a`` is stored in memory. Therefore if ``a`` is C-ordered versus fortran-ordered, versus defined as a slice or transpose, etc., the view may give different results. Nr) rrir^rrYrrnrrrM)r|rr/rMrFs rriMaskedArray.view sp =| d+ d1 \ 3eW--$\\$6F E$\\$6F\\$t4F 6?& (!<<,,.FL 6=$ / ;!=  *.F& %/! ) 3 d2 3s-C/'C// DDcURUnURnSnSnU[La X1nU"U5nO0[nU"URU5nUcU"[U5U5nU(a[ U[ R 5(a[X&URS9$URR[ RLa;[ U[ R5(aU[LaU(a [USS9$U$U(a[$U$UR[U55nUR!U5 [#U5(GaUR$bUR$UUl[ UR$[ R5(d ['S5eUR$R(S:aUR$UR$R*S:HR-5(d+[.R0"SU<S UR$S<S 3S S 9 UR$R*SS R3SS9UlSUlU[La![7XbR85UlSUlU$)zQ x.__getitem__(y) <==> x[y] Return the item described by i, as a masked array. c@[U[R5(+$r)rrrrs r _is_scalar+MaskedArray.__getitem__.._is_scalar s!!RZZ00 0rc[U[R5(dgURR[R LaURURLagg[ U5R [R :Xagg)z| Return whether `elem` is a scalar result of indexing `arr`, or None if undecidable without promoting nomask to a full mask TFN)rrrrr/object_r)relems r_scalar_heuristic2MaskedArray.__getitem__.._scalar_heuristic sm dBJJ//2::-99DJJ. /c&&'*=*==rrTrlzInternal NumPy error.rz&Upon accessing multidimensional field zi, need to keep dimensionality of fill_value at 0. Discarding heterogeneous fill_value and setting all to r.rrr)rjrnrrZrrrHrrrr/rrrwrrirrvr RuntimeErrorrrrrrrrrrr)r|rdoutrnrrmoutscalar_expecteds rrMaskedArray.__getitem__ s7yy  1 .  ;D(.OD/ 4@O&#-\$-?-E"F $((Tt~~FF**//RZZ/T2::..f$&t$77K!MK99T$Z(D   d #+D11##/'+'7'7'=D$&d&6&6 CC*+BCC'',,q0 $ 0 0 $ 0 0 5 5a 8!9:=#% @$MM H#'(+*+/*:*:1*=)@ !C ,- .,0+;+;+@+@1+E+M+MST+M+U( $ 6!$T::6 #'  rr)overrocU[La [S5eURnURn[ U[ 5(aBX#U'U[ La'[URUR5=Uln[U5XA'gURnU[La\U[ La[URU5=o@lURb%[S/[UR5-5XA'gSXA'g[USU5n[U5nURb+U[ La"[S/[UR5-5nU[ La.XcU'U[ La [URU5=o@lXtU'gUR(dC[ U[ 5(a$[ U[ 5(dXcUR"'gXcU'XtU'g[%US5(a2UR[&:XaU[(R*"U5-nXcU'gURb Sn[-U5e[/XAUSS9n URUn U R0S :a[2R4"XU )S 9 O U [ LaUn XU'XU'g) zk x.__setitem__(i, y) <==> x[i]=y Set item described by index. If value is masked, masks those locations. z Cannot alter the masked element.NTrgFrz,Flexible 'hard' masks are not yet supported.rrr)rwrrgrnrr(rrurrrYrrr<rrrxrjr rrrpNotImplementedErrorrvrrr) r|rr@rgrn_dtypedvalmvalrOmindxdindxs rrMaskedArray.__setitem__^ s@ 6>>? ?   dC $K%3DJJ %KK U!%.EK  F?%3DJJ%GG ||'#TFS->$>?  # ugu-u~ << #%3v||#445D F?$K6!%3DJJ%GG "d 0 /4.."5,77#'dii & ##d "d T7 # #x)?%++E22D$K ||'H)'22EKD9EJJt$EzzA~ %eV4&$K$Krc>[TU]$r)rrr|rs rrMaskedArray.dtype w}rc:>[[[U5]R X5 UR [ LaKUR R[U5[5UlURUR l gg![[4a gf=fr) rrr/r__set__rnrrirtrrrhr)r|rrs rrr sv k4:,44TA ::V #)?IDJ #'::  $ #I.  s*BBBc>[TU]$r)rrrs rrMaskedArray.shape rrc>[[[U5]R X5 [ U5[ LaURURlggr)rrr/rrrYrrn)r|rrs rrr s? k4:,44TA 4= &#zzDJJ  'rc URnURnU[LaSnU[La&U[Lag[ UR U5=o@lUR c^UR(aXA-nGOx[U[[[R[R45(aXS'GO9XlGO1URn[R"U5nUR (dfURR"S:Xa:[R$"['UR)5/[+U5-5US9nO3UR-U5nO!U(dSOSn[R$"XUS9nUR(a"UR HnXG==X-ss'M OD[U[[[R[R45(aXS'OXlUR (aUR Ulg![.aE [R$"UVs/sHn['U/[+U5-5PM Os snfsnUS9nNf=f)z Set the mask. TN.rrr)rrnrwrrurrrrintrrrnumberrr0rr%r rr?r<rr)r|rlr=idtype current_maskrrns rrMaskedArray.__setmask__ s zz 6>D 6 !v~(6tzz6(J JL: << ~~$ D3rww "BCC$(S!%)!"''F::d#D99::??c)88E499;-#f+*E$F*02D ;;v.D2'+4D88D6BD ~~A Otw.O& D3rww "BCC$(S!%)!   !%L %!288t$Lt!UA3V+<%=t$L*02D2s HI!0"I  I! I!c6URR5$)zCurrent mask. )rnrirs rrlMaskedArray.mask szz  rc&URU5 gr)r)r|r@s rrlrs rcURR[5nURRcU$[ R "[U5SS9$)a Get or set the mask of the array if it has no named fields. For structured arrays, returns a ndarray of booleans where entries are ``True`` if **all** the fields are masked, ``False`` otherwise: >>> x = np.ma.array([(1, 1), (2, 2), (3, 3), (4, 4), (5, 5)], ... mask=[(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)], ... dtype=[('a', int), ('b', int)]) >>> x.recordmask array([False, False, True, False, False]) rr)rnrirrrrrrQ)r|rns r recordmaskMaskedArray.recordmasksB ( ;;   $Lvv.u5B??rc[S5e)Nz*Coming soon: setting the mask per records!r)r|rls rrr*s!"NOOrcSUlU$)aM Force the mask to hard, preventing unmasking by assignment. Whether the mask of a masked array is hard or soft is determined by its `~ma.MaskedArray.hardmask` property. `harden_mask` sets `~ma.MaskedArray.hardmask` to ``True`` (and returns the modified self). See Also -------- ma.MaskedArray.hardmask ma.MaskedArray.soften_mask Trrs rr]MaskedArray.harden_mask.s rcSUlU$)aV Force the mask to soft (default), allowing unmasking by assignment. Whether the mask of a masked array is hard or soft is determined by its `~ma.MaskedArray.hardmask` property. `soften_mask` sets `~ma.MaskedArray.hardmask` to ``False`` (and returns the modified self). See Also -------- ma.MaskedArray.hardmask ma.MaskedArray.harden_mask Frrs rrMaskedArray.soften_mask@s rcUR$)a Specifies whether values can be unmasked through assignments. By default, assigning definite values to masked array entries will unmask them. When `hardmask` is ``True``, the mask will not change through assignments. See Also -------- ma.MaskedArray.harden_mask ma.MaskedArray.soften_mask Examples -------- >>> import numpy as np >>> x = np.arange(10) >>> m = np.ma.masked_array(x, x>5) >>> assert not m.hardmask Since `m` has a soft mask, assigning an element value unmasks that element: >>> m[8] = 42 >>> m masked_array(data=[0, 1, 2, 3, 4, 5, --, --, 42, --], mask=[False, False, False, False, False, False, True, True, False, True], fill_value=999999) After hardening, the mask is not affected by assignments: >>> hardened = np.ma.harden_mask(m) >>> assert m.hardmask and hardened is m >>> m[:] = 23 >>> m masked_array(data=[23, 23, 23, 23, 23, 23, --, --, 23, --], mask=[False, False, False, False, False, False, True, True, False, True], fill_value=999999) rrs rrMaskedArray.hardmaskRsV~~rctUR(a&URR5UlSUlU$)a Copy the mask and set the `sharedmask` flag to ``False``. Whether the mask is shared between masked arrays can be seen from the `sharedmask` property. `unshare_mask` ensures the mask is not shared. A copy of the mask is only made if it was shared. See Also -------- sharedmask F)rrnr=rs r unshare_maskMaskedArray.unshare_masks,   *DJ$D  rcUR$)z&Share status of the mask (read-only). )rrs r sharedmaskMaskedArray.sharedmasksrc:[UR5UlU$)ah Reduce a mask to nomask when possible. Parameters ---------- None Returns ------- None Examples -------- >>> import numpy as np >>> x = np.ma.array([[1,2 ], [3, 4]], mask=[0]*4) >>> x.mask array([[False, False], [False, False]]) >>> x.shrink_mask() masked_array( data=[[1, 2], [3, 4]], mask=False, fill_value=999999) >>> x.mask False )rrnrs rrVMaskedArray.shrink_masks:"$**-  rcUR$)z*Class of the underlying data (read-only). )rrs r baseclassMaskedArray.baseclasssrcB[R"XR5$)aZ Returns the underlying data, as a view of the masked array. If the underlying data is a subclass of :class:`numpy.ndarray`, it is returned as such. >>> x = np.ma.array(np.matrix([[1, 2], [3, 4]]), mask=[[0, 1], [1, 0]]) >>> x.data matrix([[1, 2], [3, 4]]) The type of the data can be accessed through the :attr:`baseclass` attribute. )rrirrs r _get_dataMaskedArray._get_datas||D//22r)fgetc[U5$)zEReturn a flat iterator, or set a flattened version of self to value. )rrs rrMaskedArray.flatsd##rc,UR5nXSS&gr)r)r|r@ys rrr-s JJL!rcURc[SUR5Ul[UR[5(aURS$UR$)aR The filling value of the masked array is a scalar. When setting, None will set to a default based on the data type. Examples -------- >>> import numpy as np >>> for dt in [np.int32, np.int64, np.float64, np.complex128]: ... np.ma.array([0, 1], dtype=dt).get_fill_value() ... np.int64(999999) np.int64(999999) np.float64(1e+20) np.complex128(1e+20+0j) >>> x = np.ma.array([0, 1.], fill_value=-np.inf) >>> x.fill_value np.float64(-inf) >>> x.fill_value = np.pi >>> x.fill_value np.float64(3.1415926535897931) Reset to default: >>> x.fill_value = None >>> x.fill_value np.float64(1e+20) Nr)rrPrrrrs rrMMaskedArray.fill_valuesU>    #0tzzBD  d&& 0 0##B' 'rc[XR5nURS:Xd[R"S[ SS9 UR nUcX lgX#S'g)NrzNon-scalar arrays for the fill value are deprecated. Use arrays with scalar values instead. The filled function still supports any array as `fill_value`.rrr)rPrrrrDeprecationWarningr)r|r@rrs rrMr1sV"5**5{{a MM<#q  2 &&  % %OrcdURnU[La UR$Uc URnO[ XR 5nU[ La[R"U5$UR Rb3URRS5n[X0RU5 U$UR5(d UR$URRS5n[R"X1US9 U$![[4a? [!U["S9nUR%["5n[R&"X$U45nU$[(aT URR*(aeU(a![R,"XR S9nU$URnU$f=f)a Return a copy of self, with masked values filled with a given value. **However**, if there are no masked values to fill, self will be returned instead as an ndarray. Parameters ---------- fill_value : array_like, optional The value to use for invalid entries. Can be scalar or non-scalar. If non-scalar, the resulting ndarray must be broadcastable over input array. Default is None, in which case, the `fill_value` attribute of the array is used instead. Returns ------- filled_array : ndarray A copy of ``self`` with invalid entries replaced by *fill_value* (be it the function argument or the attribute of ``self``), or ``self`` itself as an ndarray if there are no invalid entries to be replaced. Notes ----- The result is **not** a MaskedArray! Examples -------- >>> import numpy as np >>> x = np.ma.array([1,2,3,4,5], mask=[0,0,1,0,1], fill_value=-999) >>> x.filled() array([ 1, 2, -999, 4, -999]) >>> x.filled(fill_value=1000) array([ 1, 2, 1000, 4, 1000]) >>> type(x.filled()) Subclassing is preserved. This means that if, e.g., the data part of the masked array is a recarray, `filled` returns a recarray: >>> x = np.array([(-1, 2), (-3, 4)], dtype='i8,i8').view(np.recarray) >>> m = np.ma.array(x, mask=[(True, False), (False, True)]) >>> m.filled() rec.array([(999999, 2), ( -3, 999999)], dtype=[('f0', '>> import numpy as np >>> x = np.ma.array(np.arange(5), mask=[0]*2 + [1]*3) >>> x.compressed() array([0, 1]) >>> type(x.compressed()) N-D arrays are compressed to 1-D. >>> arr = [[1, 2], [3, 4]] >>> mask = [[1, 0], [0, 1]] >>> x = np.ma.array(arr, mask=mask) >>> x.compressed() array([2, 3]) )rrrgrnrr8rrp)r|rjs rr9MaskedArray.compressedksK>}}TZZ( ::V #== djj0I!JKD rc URURpT[R"U5nUR XUS9R [ U55nURU5 U[LaUR XS9UlU$)a Return `a` where condition is ``True``. If condition is a `~ma.MaskedArray`, missing values are considered as ``False``. Parameters ---------- condition : var Boolean 1-d array selecting which entries to return. If len(condition) is less than the size of a along the axis, then output is truncated to length of condition array. axis : {None, int}, optional Axis along which the operation must be performed. out : {None, ndarray}, optional Alternative output array in which to place the result. It must have the same shape as the expected output but the type will be cast if necessary. Returns ------- result : MaskedArray A :class:`~ma.MaskedArray` object. Notes ----- Please note the difference with :meth:`compressed` ! The output of :meth:`compress` has a mask, the output of :meth:`compressed` does not. Examples -------- >>> import numpy as np >>> x = np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0] + [1,0]*4) >>> x masked_array( data=[[1, --, 3], [--, 5, --], [7, --, 9]], mask=[[False, True, False], [ True, False, True], [False, True, False]], fill_value=999999) >>> x.compress([1, 0, 1]) masked_array(data=[1, 3], mask=[False, False], fill_value=999999) >>> x.compress([1, 0, 1], axis=1) masked_array( data=[[1, 3], [--, --], [7, 9]], mask=[[False, False], [ True, True], [False, False]], fill_value=999999) rrr) rgrnrr0r8rir/rr)r|r:rrrgrn_news rr8MaskedArray.compresssrz**djjJJy) ~~i~<AA$t*M $   =DJ rc[R5(Ga1URnU[LaURnU$URnUR S:a UR O URn[UR 5HnURUU:dMUS-n[R"X6U*4US9n[R"USUS4US9n[R"XU*4US9n[R"USUS4US9nM [URS5nURU5n[!X![5 U$UR#UR$5nU$)zY Replace masked values with masked_print_option, casting all innermost dtypes to object. rrrrr)rrlrnrrgr _print_width_print_width_1drangerrrr:r rrrurNrM) r|rlrZrj print_widthrindrrdtypes r_insert_masked_print MaskedArray._insert_masked_prints@  & & ( (::Dv~jj* %zz59IIMt00$($8$8!$)),Dzz$'+5)Q. hhtC4[tD!~~s1vs1v.>TJ hhtC4[tD!~~s1vs1v.>TJ -/tzz3?kk&)&s2EF ++doo.C rc4[UR55$r)r(rDrs rrMaskedArray.__str__s4,,.//rc ,^^UR[RLaSnOURRn[RR R 5S::aURS:n[US[U5-[U5[UR5[UR5[UR5S9n[URR5nSR!U(aSOSU(aS OS 5n["UU-$S US 3n[RR R%UR5(+=(d6 [R&"UR(5=(d UR*S :Hn/SQnU(aUR-S5 [.R&"SUR0SS55n Sn U (aR0mUTUS 'USSH<n [.R2"U [XhS -5[U 5- 5n SU -TU 'M> SnOUV s0sHoSU -_M sn mUS-n0m[R4"UR75STSS-SS9TS'[R4"URSTSS-SS9TS'UR8c UR UR8RR:S;a\URR:UR8RR::Xa$[=URR?55n OcUR8RUR:Xa*UR[@:Xd[UR5n O[=UR5n U TS'U(a6[RR RCUR5TS'SREUU4S jU55nXn-S!-$s sn f)"z! Literal string representation. r qr )rnlenrjrlrrz{}_{}longshortflxrmasked_(r)rjrlrMrc3*# UH oS:Hv M g7f)rNr)rdims rr'MaskedArray.__repr__..%s!Fos(osNrrr z, rjzdata=,) separatorprefixsuffixrlzmask=)rrrMz, c3V># UHnSRTUUTU5v M g7f)z{}{}={}N)format)rkindentsreprss rrrSWs2    WQZE!H 5 5s&)r8)#rrrr_core arrayprint_get_legacy_print_moderr[r<r(rnrMrrrrZ_legacy_print_templatesdtype_is_impliedrrlrr"rtrr array2stringrDrr%reprr?rJdtype_short_reprr)r|ris_long parameters is_structuredkeyrW dtype_neededkeys is_one_row min_indentr[r  fill_reprrUr\r]s @@rrsMaskedArray.__repr__sd ??bjj (D??++D 88   5 5 73 >ii!mG3t9_Y_)$**o J!!1!12M..!w&EC+3/*< <4&"##44TZZ@ @  FF499   IIN .  KK \\!Fdjj"o!FF  G%GDG !"XLLSq'1A-BSV-KL 1W F599Dq# **D9Gd]F  % % '6?W, f  JJ6?W, f    # OO    " " ' ': 5JJOOt'7'7'='='B'BBT__1134I    # #tzz 1$**:NDOO,IT__-I'l XX00AA$**ME'N   $$O:s?Pc[U[U55(ag[USS5nUSLa[USS5nURU:$USL$)NF__array_ufunc____array_priority__i)rr/rrr)r|other array_ufuncother_prioritys r_delegate_binopMaskedArray._delegate_binop]s\ eT$Z ( (e%6> % $U,@(KN**^; ;$& &rc[U5nURn[XCSS9n[U5nURR bU[ R[ R4;a[$[R"X5Rn[R"XSS9nXXlURU5n U[R "SUR5:HnU[R"La![R$"SUR5nO UR&n U"X5n [)U [R*[*45(aU(a[,$U $U[.LaU[ R[ R4;a[R0"XR"XC5U 5n URU R:wa.[R"XZR5R35nU R5[7U55n U R9U5 XZlU R:b+[=U R:[R*5n XlU $![>[@4a [=S[R*5n N4f=f)aCompare self with other using operator.eq or operator.ne. When either of the elements is masked, the result is masked as well, but the underlying boolean data are still set, with self and other considered equal if both are masked, and unequal otherwise. For structured arrays, all fields are combined, with masked values ignored. The result is masked if all fields were masked, with self and other considered equal only if both were fully masked. TrNrfr)!rYrlrvrXrroperatoreqneNotImplementedrr$r broadcast_tornrNrFalse_rrjrrrwrrr=rir/rrrPrrI) r|rscompareomasksmaskrlodatabroadcast_shape sbroadcastsdatacheckrs r _comparisonMaskedArray._comparisonks u$/ ::   'x{{HKK88%% !ll47==OdKJ# %%e,EBGGB 33D !U[[1IIE% ebggt_ - -!6 ,u , v 8;; 44 wu'>@ 4:& 4      ( 8():):BGGD!%  z* 8(rww7 8s,$I*JJcBURU[R5$)aCheck whether other equals self elementwise. When either of the elements is masked, the result is masked as well, but the underlying boolean data are still set, with self and other considered equal if both are masked, and unequal otherwise. For structured arrays, all fields are combined, with masked values ignored. The result is masked if all fields were masked, with self and other considered equal only if both were fully masked. )rrzr{r|rss r__eq__MaskedArray.__eq__x{{33rcBURU[R5$)aCheck whether other does not equal self elementwise. When either of the elements is masked, the result is masked as well, but the underlying boolean data are still set, with self and other considered equal if both are masked, and unequal otherwise. For structured arrays, all fields are combined, with masked values ignored. The result is masked if all fields were masked, with self and other considered equal only if both were fully masked. )rrzr|rs r__ne__MaskedArray.__ne__rrcBURU[R5$r)rrzlers r__le__MaskedArray.__le__x{{33rcBURU[R5$r)rrzltrs r__lt__MaskedArray.__lt__rrcBURU[R5$r)rrzgers r__ge__MaskedArray.__ge__rrcBURU[R5$r)rrzgtrs r__gt__MaskedArray.__gt__rrcPURU5(a[$[X5$)z4 Add self to other, and return a new masked array. )rvr}rrs r__add__MaskedArray.__add__s&    & &! !4rc[X5$)z4 Add other to self, and return a new masked array. )rrs r__radd__MaskedArray.__radd__s5rcPURU5(a[$[X5$)z; Subtract other from self, and return a new masked array. )rvr}rrs r__sub__MaskedArray.__sub__s&    & &! !$$rc[X5$)z; Subtract self from other, and return a new masked array. )rrs r__rsub__MaskedArray.__rsub__s $$rcPURU5(a[$[X5$)z6Multiply self by other, and return a new masked array.)rvr}rrs r__mul__MaskedArray.__mul__s$    & &! !$$rc[X5$)z9 Multiply other by self, and return a new masked array. )rrs r__rmul__MaskedArray.__rmul__s$$rcPURU5(a[$[X5$z9 Divide other into self, and return a new masked array. )rvr}rHrs r__div__MaskedArray.__div__ s&    & &! !d""rcPURU5(a[$[X5$r)rvr}rrs r __truediv__MaskedArray.__truediv__s&    & &! !4''rc[X5$z9 Divide self into other, and return a new masked array. )rrs r __rtruediv__MaskedArray.__rtruediv__s 5''rcPURU5(a[$[X5$r)rvr}rSrs r __floordiv__MaskedArray.__floordiv__&s&    & &! !D((rc[X5$r)rSrs r __rfloordiv__MaskedArray.__rfloordiv__/s E((rcPURU5(a[$[X5$)zA Raise self to the power other, masking the potential NaNs/Infs )rvr}rrs r__pow__MaskedArray.__pow__6s&    & &! !T!!rc[X5$)zA Raise other to the power self, masking the potential NaNs/Infs )rrs r__rpow__MaskedArray.__rpow__?s U!!rc[U5nUR[LaYU[LaOUR5(a:[ UR UR 5UlU=RU- slOU[LaU=RU- sl[U5n[R"URUR RS5U5nURRU5 U$)z Add other to self in-place. r) rYrnrr!rurrrXrrr/rg__iadd__r|rsr other_datas rrMaskedArray.__iadd__Fs EN :: 15577+DJJ C  a  a U^ XXdjj**:*:*?*?*BJO  J' rc[U5nUR[LaYU[LaOUR5(a:[ UR UR 5UlU=RU- slOU[LaU=RU- sl[U5n[R"URUR RS5U5nURRU5 U$)z% Subtract other from self in-place. r) rYrnrr!rurrrXrrr/rg__isub__rs rrMaskedArray.__isub__X EN :: 15577+DJJ C  a f_ JJ!OJU^ XXdjj**:*:*?*?*BJO  J' rc[U5nUR[LaYU[LaOUR5(a:[ UR UR 5UlU=RU- slOU[LaU=RU- sl[U5n[R"URUR RS5U5nURRU5 U$)z# Multiply self by other in-place. r) rYrnrr!rurrrXrrr/rg__imul__rs rrMaskedArray.__imul__irrc"[U5n[5RURU5n[ U5n[ XC5nUR 5(aI[[Rupg[R"X2RRU5U5nU=RU-sl [R"URURRS5U5nURRU5 U$)z! Divide self by other in-place. r)rXrrrgrYrvr!rrrHrrr/rn__idiv__r|rsrdom_mask other_masknew_mask_rCs rrMaskedArray.__idiv__zs U^ $&// JGU^ :0 <<>>#BII.IQ..33D9:GJ h XXdjj**:*:*?*?*BJO  J' rc"[U5n[5RURU5n[ U5n[ XC5nUR 5(aI[[Rupg[R"X2RRU5U5nU=RU-sl [R"URURRS5U5nURRU5 U$)z' Floor divide self by other in-place. r)rXrrrgrYrvr!rrrSrrr/rn __ifloordiv__rs rrMaskedArray.__ifloordiv__s U^ $&// JGU^ :0 <<>>#BOO4IQ..33D9:GJ h XXdjj**:*:*?*?*BJO    , rc"[U5n[5RURU5n[ U5n[ XC5nUR 5(aI[[Rupg[R"X2RRU5U5nU=RU-sl [R"URURRS5U5nURRU5 U$)z& True divide self by other in-place. r)rXrrrgrYrvr!rrrrrr/rn __itruediv__rs rrMaskedArray.__itruediv__s U^ $&// JGU^ :0 <<>>#BNN3IQ..33D9:GJ h XXdjj**:*:*?*?*BJO   + rc[U5n[R"URURR S5U5n[ U5n[R"SSS9 URRU5 SSS5 [R"[R"UR55nUR5(aYUR[LaU=RU-slOX@l[R"URURUS9 [!X45n[!URU5UlU$!,(df  N=f)z+ Raise self to the power other, in place. rrrNr)rXrrrnrr/rYrrg__ipow__rprmr!rrrMrv)r|rsrrrors rrMaskedArray.__ipow__s U^ XXdjj**:*:*?*?*BJO U^ [[( ; JJ   +<..TZZ!89 ;;==zz' g% $ IIdjj$// A:/TZZ2  < ;s 'E E#cURS:a [S5eUR(a%[R"SSS9 [ R $[UR55$)z Convert to float. r7Only length-1 arrays can be converted to Python scalarsz,Warning: converting a masked element to nan.rr) rrrnrrrnanrr?rs r __float__MaskedArray.__float__sR 99q=01 1 ZZ MMHUV W66MTYY[!!rcURS:a [S5eUR(a [S5e[ UR 55$)z Convert to int. rrz.Cannot convert masked element to a Python int.)rrrnrrr?rs r__int__MaskedArray.__int__sE 99q=01 1 ZZLM M499;rcURRR[U55nUR UR 5 U$)ai The imaginary part of the masked array. This property is a view on the imaginary part of this `MaskedArray`. See Also -------- real Examples -------- >>> import numpy as np >>> x = np.ma.array([1+1.j, -2j, 3.45+1.6j], mask=[False, True, False]) >>> x.imag masked_array(data=[1.0, --, 1.6], mask=[False, True, False], fill_value=1e+20) )rgimagrir/rrnr|rUs rrMaskedArray.imag7*%%d4j14::& rcURRR[U55nUR UR 5 U$)a` The real part of the masked array. This property is a view on the real part of this `MaskedArray`. See Also -------- imag Examples -------- >>> import numpy as np >>> x = np.ma.array([1+1.j, -2j, 3.45+1.6j], mask=[False, True, False]) >>> x.real masked_array(data=[1.0, --, 3.45], mask=[False, True, False], fill_value=1e+20) )rgrealrir/rrnrs rrMaskedArray.realrrcU[RLa0OSU0nURn[UR[R 5(aZU[ La-[R"UR[RS9nUR[UR55nU[ LGaZURS:Xa.US;a'[RRXRS9egUc[URSS5(a8[R "UR"[R$URS9$UR"$['XR5nSnUHnX`RU-nM URSS5(a#[)UR5nUHn SX'M O0[+UR5V V s/sHupX;dM U PM nn n [R,"X[R$S9$U[.Lag U)R0"SU[R$S .UD6$s sn n f) a Count the non-masked elements of the array along the given axis. Parameters ---------- axis : None or int or tuple of ints, optional Axis or axes along which the count is performed. The default, None, performs the count over all the dimensions of the input array. `axis` may be negative, in which case it counts from the last to the first axis. If this is a tuple of ints, the count is performed on multiple axes, instead of a single axis or all the axes as before. keepdims : bool, optional If this is set to True, the axes which are reduced are left in the result as dimensions with size one. With this option, the result will broadcast correctly against the array. Returns ------- result : ndarray or scalar An array with the same shape as the input array, with the specified axis removed. If the array is a 0-d array, or if `axis` is None, a scalar is returned. See Also -------- ma.count_masked : Count masked elements in array or along a given axis. Examples -------- >>> import numpy.ma as ma >>> a = ma.arange(6).reshape((2, 3)) >>> a[1, :] = ma.masked >>> a masked_array( data=[[0, 1, 2], [--, --, --]], mask=[[False, False, False], [ True, True, True]], fill_value=999999) >>> a.count() 3 When the `axis` keyword is specified an array of appropriate size is returned. >>> a.count(axis=0) array([1, 1, 1]) >>> a.count(axis=1) array([3, 0]) r4rrNr)rrrF)rrrrr)rr rnrrjmatrixrrrrrir/ exceptions AxisErrorrr'r rintprrs enumeraterrwr) r|rr4rraxesitemsaxout_dimsrSr rs rrAMaskedArray.countsj 2;;.Z4J JJ dii + +F{HHTZZrww7tDII'A ;zzRy(--11t))1LL::j%0088DIIRWWDIINNyy 'ii8DEB'zz*e,, +A"#HK+4DJJ*?.*?$! }*?.778"'': : 6>xx;T;F;;.s  H;!H;cUS;a)URRR(aSOSn[R"URUS9R [ U55nURU5 UR[La?[R"URUS9RUR5UlU$[UlU$)a= Returns a 1D version of self, as a view. Parameters ---------- order : {'C', 'F', 'A', 'K'}, optional The elements of `a` are read using this index order. 'C' means to index the elements in C-like order, with the last axis index changing fastest, back to the first axis index changing slowest. 'F' means to index the elements in Fortran-like index order, with the first index changing fastest, and the last index changing slowest. Note that the 'C' and 'F' options take no account of the memory layout of the underlying array, and only refer to the order of axis indexing. 'A' means to read the elements in Fortran-like index order if `m` is Fortran *contiguous* in memory, C-like order otherwise. 'K' means to read the elements in the order they occur in memory, except for reversing the data when strides are negative. By default, 'C' index order is used. (Masked arrays currently use 'A' on the data when 'K' is passed.) Returns ------- MaskedArray Output view is of shape ``(self.size,)`` (or ``(np.ma.product(self.shape),)``). Examples -------- >>> import numpy as np >>> x = np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0] + [1,0]*4) >>> x masked_array( data=[[1, --, 3], [--, 5, --], [7, --, 9]], mask=[[False, True, False], [ True, False, True], [False, True, False]], fill_value=999999) >>> x.ravel() masked_array(data=[1, --, 3, --, 5, --, 7, --, 9], mask=[False, True, False, True, False, True, False, True, False], fill_value=999999) kKaArrr) rgrfncrrrir/rrnrrr)r|rrs rrMaskedArray.ravelysh F?::++//CSE MM$**E 2 7 7T C t ::V #mmDJJe<DDQWWMAGAGrc&URURSS5S9 URR"U0UD6R [ U55nUR U5 URnU[LaUR"U0UD6UlU$)a^ Give a new shape to the array without changing its data. Returns a masked array containing the same data, but with a new shape. The result is a view on the original array; if this is not possible, a ValueError is raised. Parameters ---------- shape : int or tuple of ints The new shape should be compatible with the original shape. If an integer is supplied, then the result will be a 1-D array of that length. order : {'C', 'F'}, optional Determines whether the array data should be viewed as in C (row-major) or FORTRAN (column-major) order. Returns ------- reshaped_array : array A new view on the array. See Also -------- reshape : Equivalent function in the masked array module. numpy.ndarray.reshape : Equivalent method on ndarray object. numpy.reshape : Equivalent function in the NumPy module. Notes ----- The reshaping operation cannot guarantee that a copy will not be made, to modify the shape in place, use ``a.shape = s`` Examples -------- >>> import numpy as np >>> x = np.ma.array([[1,2],[3,4]], mask=[1,0,0,1]) >>> x masked_array( data=[[--, 2], [3, --]], mask=[[ True, False], [False, True]], fill_value=999999) >>> x = x.reshape((4,1)) >>> x masked_array( data=[[--], [2], [3], [--]], mask=[[ True], [False], [False], [ True]], fill_value=999999) rrr) rr'rgrrir/rrnr)r|rrrUrls rrMaskedArray.reshapesv  FJJw4 5##Q1&166tDzBD!zz v <<5f5FL rcSn[U5e)a> .. warning:: This method does nothing, except raise a ValueError exception. A masked array does not own its data and therefore cannot safely be resized in place. Use the `numpy.ma.resize` function instead. This method is difficult to implement safely and may be deprecated in future releases of NumPy. zoA masked array does not own its data and therefore cannot be resized. Use the numpy.ma.resize function instead.)rI)r|rrefcheckrerrmsgs rrMaskedArray.resizes=  rcUR(a\UR[LaIURUn[USS9n[USSS9nUR UR 5 X)nX$)nUR RXUS9 UR[La[U5[Lag[U5n[U5[LaURUSUS9 OURXRUS9 [USSS9nXPlg)a Set storage-indexed locations to corresponding values. Sets self._data.flat[n] = values[n] for each n in indices. If `values` is shorter than `indices` then it will repeat. If `values` has some masked values, the initial mask is updated in consequence, else the corresponding values are unmasked. Parameters ---------- indices : 1-D array_like Target indices, interpreted as integers. values : array_like Values to place in self._data copy at target indices. mode : {'raise', 'wrap', 'clip'}, optional Specifies how out-of-bounds indices will behave. 'raise' : raise an error. 'wrap' : wrap around. 'clip' : clip to the range. Notes ----- `values` can be a scalar or length 1 array. Examples -------- >>> import numpy as np >>> x = np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0] + [1,0]*4) >>> x masked_array( data=[[1, --, 3], [--, 5, --], [7, --, 9]], mask=[[False, True, False], [ True, False, True], [False, True, False]], fill_value=999999) >>> x.put([0,4,8],[10,20,30]) >>> x masked_array( data=[[10, --, 3], [--, 20, --], [7, --, 30]], mask=[[False, True, False], [ True, False, True], [False, True, False]], fill_value=999999) >>> x.put(4,999) >>> x masked_array( data=[[10, --, 3], [--, 999, --], [7, --, 30]], mask=[[False, True, False], [ True, False, True], [False, True, False]], fill_value=999999) NrTremodeFr#) rrnrr5rrrgrrYrZrs)r|ravaluesrrlrs rrMaskedArray.put s| >>djj6::g&DW40GFT:F MM'-- (enGE]F wT2 :: GFOv$=    6?f $ EE'5tE , EE'<>> import numpy as np >>> x = np.ma.array([1, 2, 3], mask=[0, 1, 1]) >>> x.ids() (166670640, 166659832) # may vary If the array has no mask, the address of `nomask` is returned. This address is typically not close to the data in memory: >>> x = np.ma.array([1, 2, 3]) >>> x.ids() (166691080, 3083169284) # may vary )rnrctypesrjidrs rr`MaskedArray.idscsN. :: KK$$bj1 1   $**"3"3"8"899rc URS$)a Return a boolean indicating whether the data is contiguous. Parameters ---------- None Examples -------- >>> import numpy as np >>> x = np.ma.array([1, 2, 3]) >>> x.iscontiguous() True `iscontiguous` returns one of the flags of the masked array: >>> x.flags C_CONTIGUOUS : True F_CONTIGUOUS : True OWNDATA : False WRITEABLE : True ALIGNED : True WRITEBACKIFCOPY : False CONTIGUOUS)rrs r iscontiguousMaskedArray.iscontiguous~s4zz,''rc U[RLa0OSU0n[URU40UD6nUcnUR S5R "SSU0UD6R [U55nUR(aURU5 U$U(a[$U$UR S5R "SXS.UD6 [U[5(a)UR(dU(aURU5 U$)a Returns True if all elements evaluate to True. The output array is masked where all the values along the given axis are masked: if the output would have been a scalar and that all the values are masked, then the output is `masked`. Refer to `numpy.all` for full documentation. See Also -------- numpy.ndarray.all : corresponding function for ndarrays numpy.all : equivalent function Examples -------- >>> import numpy as np >>> np.ma.array([1,2,3]).all() True >>> a = np.ma.array([1,2,3], mask=True) >>> (a.all() is np.ma.masked) True r4Trr:r) rr r5rnrNrrir/rrrwrrr|rrr4rrlrs rrMaskedArray.alls2 2;;.Z4J D;F; ; D!%%:4:6:??T KAvv d#H H D;4;F; c; ' 'xx4% rc U[RLa0OSU0n[URU40UD6nUcnUR S5R "SSU0UD6R [U55nUR(aURU5 U$U(a[nU$UR S5R "SXS.UD6 [U[5(a)UR(dU(aURU5 U$)a Returns True if any of the elements of `a` evaluate to True. Masked values are considered as False during computation. Refer to `numpy.any` for full documentation. See Also -------- numpy.ndarray.any : corresponding function for ndarrays numpy.any : equivalent function r4Frr:r) rr r5rnrNr!rir/rrrwrrr s rr!MaskedArray.anys 2;;.Z4J D;F; ; E"&&;D;F;@@dLAvv d#HH E>> import numpy as np >>> import numpy.ma as ma >>> x = ma.array(np.eye(3)) >>> x masked_array( data=[[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]], mask=False, fill_value=1e+20) >>> x.nonzero() (array([0, 1, 2]), array([0, 1, 2])) Masked elements are ignored. >>> x[1, 1] = ma.masked >>> x masked_array( data=[[1.0, 0.0, 0.0], [0.0, --, 0.0], [0.0, 0.0, 1.0]], mask=[[False, False, False], [False, True, False], [False, False, False]], fill_value=1e+20) >>> x.nonzero() (array([0, 2]), array([0, 2])) Indices can also be grouped by element. >>> np.transpose(x.nonzero()) array([[0, 0], [2, 2]]) A common use for ``nonzero`` is to find the indices of an array, where a condition is True. Given an array `a`, the condition `a` > 3 is a boolean array and since False is interpreted as 0, ma.nonzero(a > 3) yields the indices of the `a` where the condition is true. >>> a = ma.array([[1,2,3],[4,5,6],[7,8,9]]) >>> a > 3 masked_array( data=[[False, False, False], [ True, True, True], [ True, True, True]], mask=False, fill_value=True) >>> ma.nonzero(a > 3) (array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2])) The ``nonzero`` method of the condition array can also be called. >>> (a > 3).nonzero() (array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2])) r)rr0rNrrs rrMaskedArray.nonzeros%Bzz$++a.)1133rc>URnU[La [T U] XUUS9nUR U5$UR XUS9nUR U5R S5RSUS9$)z( (this docstring should be overwritten) )offsetaxis1axis2r)r'r(r)rrr:)rnrrrrrFrNr) r|r'r(r)rrrrUrrs rrMaskedArray.traceDsy JJ ;W]&U'*#,F==' ' V FA88E?))!,00bc0B Brc[XX#S9$)a` a.dot(b, out=None) Masked dot product of two arrays. Note that `out` and `strict` are located in different positions than in `ma.dot`. In order to maintain compatibility with the functional version, it is recommended that the optional arguments be treated as keyword only. At some point that may be mandatory. Parameters ---------- b : masked_array_like Inputs array. 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 `ma.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. 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. See Also -------- numpy.ma.dot : equivalent function )rstrict)dot)r|rrr,s rr-MaskedArray.dotSsB433rc2U[RLa0OSU0nURn[Xa40UD6nUctUR S5R "U4SU0UD6n[ USS5n U (a-UR[U55nURU5 U$U(a[nU$UR S5R "U4X#S.UD6n[U[5(a5[U5n U [La[UR 5=olXzlU$)an Return the sum of the array elements over the given axis. Masked elements are set to 0 internally. Refer to `numpy.sum` for full documentation. See Also -------- numpy.ndarray.sum : corresponding function for ndarrays numpy.sum : equivalent function Examples -------- >>> import numpy as np >>> x = np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0] + [1,0]*4) >>> x masked_array( data=[[1, --, 3], [--, 5, --], [7, --, 9]], mask=[[False, True, False], [ True, False, True], [False, True, False]], fill_value=999999) >>> x.sum() 25 >>> x.sum(axis=1) masked_array(data=[4, 5, 16], mask=[False, False, False], fill_value=999999) >>> x.sum(axis=0) masked_array(data=[8, 5, 12], mask=[False, False, False], fill_value=999999) >>> print(type(x.sum(axis=0, dtype=np.int64)[0])) r4rrrrr)rr rnr5rNrrrir/rrwrrrYrrurr r|rrrr4rrnrrUrndimoutmasks rrMaskedArray.sumvsP 2;;.Z4J "59&9 ;[[^''DEDVDFFFA.ET$Z0""7+MMQ##DII&I c; ' 'clG& &4SYY&??)"L rcURS5RXUS9nUb2[U[5(aUR UR 5 U$UR [U55nUR UR5 U$)aa Return the cumulative sum of the array elements over the given axis. Masked values are set to 0 internally during the computation. However, their position is saved, and the result will be masked at the same locations. Refer to `numpy.cumsum` for full documentation. Notes ----- The mask is lost if `out` is not a valid :class:`ma.MaskedArray` ! Arithmetic is modular when using integer types, and no error is raised on overflow. See Also -------- numpy.ndarray.cumsum : corresponding function for ndarrays numpy.cumsum : equivalent function Examples -------- >>> import numpy as np >>> marr = np.ma.array(np.arange(10), mask=[0,0,0,1,1,1,0,0,0,0]) >>> marr.cumsum() masked_array(data=[0, 1, 3, --, --, --, 9, 16, 24, 33], mask=[False, False, False, True, True, True, False, False, False, False], fill_value=999999) rrrr) rNrCrrrrlrir/rnr|rrrrUs rrCMaskedArray.cumsumsrBQ&&D3&G ?#{++ *JT$Z(4::& rc2U[RLa0OSU0nURn[Xa40UD6nUctUR S5R "U4SU0UD6n[ USS5n U (a-UR[U55nURU5 U$U(a[nU$UR S5R "U4X#S.UD6n[U[5(a5[U5n U [La[UR 5=olXzlU$)av Return the product of the array elements over the given axis. Masked elements are set to 1 internally for computation. Refer to `numpy.prod` for full documentation. Notes ----- Arithmetic is modular when using integer types, and no error is raised on overflow. See Also -------- numpy.ndarray.prod : corresponding function for ndarrays numpy.prod : equivalent function r4rrrrr0)rr rnr5rNrrrir/rrwrrrYrrurrr1s rrMaskedArray.prods$ 2;;.Z4J "59&9 ;[[^((EUEfEFFFA.ET$Z0""7+MMQ$$TJJ6J c; ' 'clG& &4SYY&??)"L rcURS5RXUS9nUb2[U[5(aUR UR 5 U$UR [U55nUR UR 5 U$)a Return the cumulative product of the array elements over the given axis. Masked values are set to 1 internally during the computation. However, their position is saved, and the result will be masked at the same locations. Refer to `numpy.cumprod` for full documentation. Notes ----- The mask is lost if `out` is not a valid MaskedArray ! Arithmetic is modular when using integer types, and no error is raised on overflow. See Also -------- numpy.ndarray.cumprod : corresponding function for ndarrays numpy.cumprod : equivalent function rr6)rNrBrrrrnrir/r7s rrBMaskedArray.cumprod sq,Q''TC'H ?#{++ +JT$Z(4::& rc>U[RLa0OSU0nUR[La[T U]"SXS.UD6SnGO SnUc[ URR[R[R45(a[R"S5nOK[ URR[R5(a[R"S5nSnUR"SXS.UD6nUR"SSU0UD6n U R S:Xa U S :Xa["nO1U(a"URRUS -U - 5nOUS -U - nUb\Xcl['U[(5(a?[+U5n U [La[-UR 5=ol[+U5U lU$U$) a/ Returns the average of the array elements along given axis. Masked entries are ignored, and result elements which are not finite will be masked. Refer to `numpy.mean` for full documentation. See Also -------- numpy.ndarray.mean : corresponding function for ndarrays numpy.mean : Equivalent function numpy.ma.average : Weighted average. Examples -------- >>> import numpy as np >>> a = np.ma.array([1,2,3], mask=[False, False, True]) >>> a masked_array(data=[1, 2, --], mask=[False, False, True], fill_value=999999) >>> a.mean() 1.5 r4rrFf8f4Trrr)rr rnrrrr^rr/ntypesintegerrmufloat16rrArrwrrrrYru) r|rrrr4rrUis_float16_resultdsumcntr3rs rrMaskedArray.mean(se6 2;;.Z4J :: W\CtCFCBGF % }djjoo /LMMHHTNE @@HHTNE(,%88==f=D**1$1&1CyyBC1H"S9S ?H#{++!#,f$*8*CCGi&v J rcVURX5nU(dX- $U[X15- $)a Compute the anomalies (deviations from the arithmetic mean) along the given axis. Returns an array of anomalies, with the same shape as the input and where the arithmetic mean is computed along the given axis. Parameters ---------- axis : int, optional Axis over which the anomalies are taken. The default is to use the mean of the flattened array as reference. dtype : dtype, optional Type to use in computing the variance. For arrays of integer type the default is float32; for arrays of float types it is the same as the array type. See Also -------- mean : Compute the mean of the array. Examples -------- >>> import numpy as np >>> a = np.ma.array([1,2,3]) >>> a.anom() masked_array(data=[-1., 0., 1.], mask=False, fill_value=1e+20) )rr )r|rrrs rrMaskedArray.anom`s-@ IId "8O+a.. .rc>0nU[RLaXWS'UR[La^U[RLaXgS'[T U]"SXX4S.UD6SnUb,[ U[5(aUR[5 U$U$UR"SSU0UD6U- n U[RLaX- n OXRXSS9- n [U5(a[R"U 5S-n OX-n [U R"U40UD6U 5R![#U55n U R$(aA['URR("U40UD6U S :*5U lU R+U5 O[-U 5(av[.n Ubm[ U[5(aS UlURS5 U$UR2R4S ;a S n [7U 5e[R8UlU$Ub8Xl[ U[5(aURU R:5 U$U $) a- Returns the variance of the array elements along given axis. Masked entries are ignored, and result elements which are not finite will be masked. Refer to `numpy.var` for full documentation. See Also -------- numpy.ndarray.var : corresponding function for ndarrays numpy.var : Equivalent function r4r)rrrddofrrTr4rrbiu>Masked data information would be lost in one or more location.)rr rnrrrrrrrArrrrrHrrir/rrvrrrYrwrrr%rrrl)r|rrrrKr4rrrXrFdanomdvarrrs rrMaskedArray.vars 2;; &!):  :: 2;;&!%v'+(4#( &((*,Cc;//OOF+ Jjj-d-f-4 r{{ "KE99T49@@E   NN5)Q.E NEeii//5::4:F 99 !?!?#(LDJ   d # T]]Dc;// CHOOD) YY^^u,.F#F++!vvCH ?H#{++ *J rcU[RLa0OSU0nUR"XX440UD6nU[La'Ub[R"USUSS9 U$[ U5nU$)z Returns the standard deviation of the array elements along given axis. Masked entries are ignored. Refer to `numpy.std` for full documentation. See Also -------- numpy.ndarray.std : corresponding function for ndarrays numpy.std : Equivalent function r4g?rrr)rr rrwrr) r|rrrrKr4rrrPs rrMaskedArray.stdsb 2;;.Z4JxxS9&9 v csH= :D rcfURRXS9R[U55nURS:a#UR UlUR U5 OUR (a[nUcU$[U[5(aURUR 5 U$)a Return each element rounded to the given number of decimals. Refer to `numpy.around` for full documentation. See Also -------- numpy.ndarray.round : corresponding function for ndarrays numpy.around : equivalent function Examples -------- >>> import numpy as np >>> import numpy.ma as ma >>> x = ma.array([1.35, 2.5, 1.5, 1.75, 2.25, 2.75], ... mask=[0, 0, 0, 1, 0, 0]) >>> ma.round(x) masked_array(data=[1.0, 2.0, 2.0, --, 2.0, 3.0], mask=[False, False, False, True, False, False], fill_value=1e+20) )decimalsrr) rgrrir/rrnrrwrrr)r|rVrrUs rrMaskedArray.rounds.!!8!=BB4:N ;;?::FL    % ZZF ;M c; ' ' OODJJ ' rstablecpU(a [S5eU[RLa [U5nUccU(aQ[R"UR [R 5(a[RnO[U5nO [U5nURU5nURXUS9$)a Return an ndarray of indices that sort the array along the specified axis. Masked values are filled beforehand to `fill_value`. Parameters ---------- axis : int, optional Axis along which to sort. If None, the default, the flattened array is used. kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional The sorting algorithm used. order : list, optional When `a` is an array with fields defined, this argument specifies which fields to compare first, second, etc. Not all fields need be specified. endwith : {True, False}, optional Whether missing values (if any) should be treated as the largest values (True) or the smallest values (False) When the array contains unmasked values at the same extremes of the datatype, the ordering of these values and the masked values is undefined. fill_value : scalar or None, optional Value used internally for the masked values. If ``fill_value`` is not None, it supersedes ``endwith``. stable : bool, optional Only for compatibility with ``np.argsort``. Ignored. Returns ------- index_array : ndarray, int Array of indices that sort `a` along the specified axis. In other words, ``a[index_array]`` yields a sorted `a`. See Also -------- ma.MaskedArray.sort : Describes sorting algorithms used. lexsort : Indirect stable sort with multiple keys. numpy.ndarray.sort : Inplace sort. Notes ----- See `sort` for notes on the different sorting algorithms. Examples -------- >>> import numpy as np >>> a = np.ma.array([3,2,1], mask=[False, False, True]) >>> a masked_array(data=[3, 2, --], mask=[False, False, True], fill_value=999999) >>> a.argsort() array([1, 0, 2]) 6`stable` parameter is not supported for masked arrays.rr%r) rIrr rrSrrTrrrrNr-)r|rr%rendwithrMrYrNs rr-MaskedArray.argsortst H  2;; *40D  ==R[[99!#J!3D!9J/5 Z(~~4%~@@rrLcUc [U5nURU5R[5nU[R LaSO [ U5nURXUS9$)aC Return array of indices to the minimum values along the given axis. Parameters ---------- axis : {None, integer} If None, the index is into the flattened array, otherwise along the specified axis fill_value : scalar or None, optional Value used to fill in the masked values. If None, the output of minimum_fill_value(self._data) is used instead. out : {None, array}, optional Array into which the result can be placed. Its type is preserved and it must be of the right shape to hold the output. Returns ------- ndarray or scalar If multi-dimension input, returns a new ndarray of indices to the minimum values along the given axis. Otherwise, returns a scalar of index to the minimum values along the given axis. Examples -------- >>> import numpy as np >>> x = np.ma.array(np.arange(4), mask=[1,1,0,0]) >>> x.shape = (2,2) >>> x masked_array( data=[[--, --], [2, 3]], mask=[[ True, True], [False, False]], fill_value=999999) >>> x.argmin(axis=0, fill_value=-1) array([0, 0]) >>> x.argmin(axis=0, fill_value=9) array([1, 1]) Frr4)rrNrirrr rr,r|rrMrr4rs rr,MaskedArray.argmin_sWT  +D1J KK # ( ( 1$ 35hxxx99rcUc[UR5nURU5R[5nU[ R LaSO [U5nURXUS9$)a Returns array of indices of the maximum values along the given axis. Masked values are treated as if they had the value fill_value. Parameters ---------- axis : {None, integer} If None, the index is into the flattened array, otherwise along the specified axis fill_value : scalar or None, optional Value used to fill in the masked values. If None, the output of maximum_fill_value(self._data) is used instead. out : {None, array}, optional Array into which the result can be placed. Its type is preserved and it must be of the right shape to hold the output. Returns ------- index_array : {integer_array} Examples -------- >>> import numpy as np >>> a = np.arange(6).reshape(2,3) >>> a.argmax() 5 >>> a.argmax(0) array([1, 1, 1]) >>> a.argmax(1) array([2, 2]) Fr`) rrgrNrirrr rr+ras rr+MaskedArray.argmaxs[D  +DJJ7J KK # ( ( 1$ 35hxxx99rcU(a [S5eUR[La[R"XX#S9 gU[ LagUR XUXTS9n[R"XUS9US'g)a Sort the array, in-place Parameters ---------- a : array_like Array to be sorted. axis : int, optional Axis along which to sort. If None, the array is flattened before sorting. The default is -1, which sorts along the last axis. kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional The sorting algorithm used. order : list, optional When `a` is a structured array, this argument specifies which fields to compare first, second, and so on. This list does not need to include all of the fields. endwith : {True, False}, optional Whether missing values (if any) should be treated as the largest values (True) or the smallest values (False) When the array contains unmasked values sorting at the same extremes of the datatype, the ordering of these values and the masked values is undefined. fill_value : scalar or None, optional Value used internally for the masked values. If ``fill_value`` is not None, it supersedes ``endwith``. stable : bool, optional Only for compatibility with ``np.sort``. Ignored. Returns ------- sorted_array : ndarray Array of the same type and shape as `a`. See Also -------- numpy.ndarray.sort : Method to sort an array in-place. argsort : Indirect sort. lexsort : Indirect stable sort on multiple keys. searchsorted : Find elements in a sorted array. Notes ----- See ``sort`` for notes on the different sorting algorithms. Examples -------- >>> import numpy as np >>> a = np.ma.array([1, 2, 5, 4, 3],mask=[0, 1, 0, 1, 0]) >>> # Default >>> a.sort() >>> a masked_array(data=[1, 3, 5, --, --], mask=[False, False, False, True, True], fill_value=999999) >>> a = np.ma.array([1, 2, 5, 4, 3],mask=[0, 1, 0, 1, 0]) >>> # Put missing values in the front >>> a.sort(endwith=False) >>> a masked_array(data=[--, --, 1, 3, 5], mask=[ True, True, False, False, False], fill_value=999999) >>> a = np.ma.array([1, 2, 5, 4, 3],mask=[0, 1, 0, 1, 0]) >>> # fill_value takes over endwith >>> a.sort(endwith=False, fill_value=3) >>> a masked_array(data=[1, --, --, 3, 5], mask=[False, True, True, False, False], fill_value=999999) r[r\N)rr%rrMr]r.) rIrnrrrrwr-rtake_along_axis)r|rr%rr]rMrYsidxs rrMaskedArray.sortstT H  ::  LLt A  6> ||'1D&&t=S rc:U[RLa0OSU0nURn[Xa40UD6nUc [ U5nUcUR U5R "SXS.UD6R[U55nUR(aCURU5 UR(a[R"XRUS9 U$U(a[nU$UR U5R "SXS.UD6 [U[5(a7[!U5n U ["La[%UR&5=olXylU$UR*R,S;a Sn [/U 5e[R"U[R0US9 U$)a Return the minimum along a given axis. Parameters ---------- axis : None or int or tuple of ints, optional Axis along which to operate. By default, ``axis`` is None and the flattened input is used. If this is a tuple of ints, the minimum is selected over multiple axes, instead of a single axis or all the axes as before. out : array_like, optional Alternative output array in which to place the result. Must be of the same shape and buffer length as the expected output. fill_value : scalar or None, optional Value used to fill in the masked values. If None, use the output of `minimum_fill_value`. keepdims : bool, optional If this is set to True, the axes which are reduced are left in the result as dimensions with size one. With this option, the result will broadcast correctly against the array. Returns ------- amin : array_like New array holding the result. If ``out`` was specified, ``out`` is returned. See Also -------- ma.minimum_fill_value Returns the minimum filling value for a given datatype. Examples -------- >>> import numpy.ma as ma >>> x = [[1., -2., 3.], [0.2, -0.7, 0.1]] >>> mask = [[1, 1, 0], [0, 0, 1]] >>> masked_x = ma.masked_array(x, mask) >>> masked_x masked_array( data=[[--, --, 3.0], [0.2, -0.7, --]], mask=[[ True, True, False], [False, False, True]], fill_value=1e+20) >>> ma.min(masked_x) -0.7 >>> ma.min(masked_x, axis=-1) masked_array(data=[3.0, -0.7], mask=[False, False], fill_value=1e+20) >>> ma.min(masked_x, axis=0, keepdims=True) masked_array(data=[[0.2, -0.7, 3.0]], mask=[[False, False, False]], fill_value=1e+20) >>> mask = [[1, 1, 1,], [1, 1, 1]] >>> masked_x = ma.masked_array(x, mask) >>> ma.min(masked_x, axis=0) masked_array(data=[--, --, --], mask=[ True, True, True], fill_value=1e+20, dtype=float64) r4r:rrMrNr)rr rnr5rrNrrir/rrrrMrwrrrYrrurrrr%rr r|rrrMr4rrnrrUr3rs rrMaskedArray.minsb@ 2;;.Z4J "59&9  +D1J ;[[,00..&,..2d4:.> {{""7+<<IIf&7&7wGMM J##AA&A c; ' 'clG& &4SYY&??)"L yy~~&&'' IIc266 1 rc:U[RLa0OSU0nURn[Xa40UD6nUc [ U5nUcUR U5R "SXS.UD6R[U55nUR(aCURU5 UR(a[R"XRUS9 U$U(a[nU$UR U5R "SXS.UD6 [U[5(a7[!U5n U ["La[%UR&5=olXylU$UR*R,S;a Sn [/U 5e[R"U[R0US9 U$)a Return the maximum along a given axis. Parameters ---------- axis : None or int or tuple of ints, optional Axis along which to operate. By default, ``axis`` is None and the flattened input is used. If this is a tuple of ints, the maximum is selected over multiple axes, instead of a single axis or all the axes as before. out : array_like, optional Alternative output array in which to place the result. Must be of the same shape and buffer length as the expected output. fill_value : scalar or None, optional Value used to fill in the masked values. If None, use the output of maximum_fill_value(). keepdims : bool, optional If this is set to True, the axes which are reduced are left in the result as dimensions with size one. With this option, the result will broadcast correctly against the array. Returns ------- amax : array_like New array holding the result. If ``out`` was specified, ``out`` is returned. See Also -------- ma.maximum_fill_value Returns the maximum filling value for a given datatype. Examples -------- >>> import numpy.ma as ma >>> x = [[-1., 2.5], [4., -2.], [3., 0.]] >>> mask = [[0, 0], [1, 0], [1, 0]] >>> masked_x = ma.masked_array(x, mask) >>> masked_x masked_array( data=[[-1.0, 2.5], [--, -2.0], [--, 0.0]], mask=[[False, False], [ True, False], [ True, False]], fill_value=1e+20) >>> ma.max(masked_x) 2.5 >>> ma.max(masked_x, axis=0) masked_array(data=[-1.0, 2.5], mask=[False, False], fill_value=1e+20) >>> ma.max(masked_x, axis=1, keepdims=True) masked_array( data=[[2.5], [-2.0], [0.0]], mask=[[False], [False], [False]], fill_value=1e+20) >>> mask = [[1, 1], [1, 1], [1, 1]] >>> masked_x = ma.masked_array(x, mask) >>> ma.max(masked_x, axis=1) masked_array(data=[--, --, --], mask=[ True, True, True], fill_value=1e+20, dtype=float64) r4r:rrMrNr)rr rnr5rrNrrir/rrrrMrwrrrYrrurrrr%rrrjs rrMaskedArray.maxtsbN 2;;.Z4J "59&9  +D1J ;[[,00..&,..2d4:.> {{""7+<<IIf&7&7wGMM J##AA&A c; ' 'clG& &4SYY&??)"L yy~~&&'' IIc266 1 rcUc$URXUS9nXPRXUS9-nU$URXUUS9UlURXUS9n[R"X&USS9 U$)a Return (maximum - minimum) along the given dimension (i.e. peak-to-peak value). .. warning:: `ptp` preserves the data type of the array. This means the return value for an input of signed integers with n bits (e.g. `np.int8`, `np.int16`, etc) is also a signed integer with n bits. In that case, peak-to-peak values greater than ``2**(n-1)-1`` will be returned as negative values. An example with a work-around is shown below. Parameters ---------- axis : {None, int}, optional Axis along which to find the peaks. If None (default) the flattened array is used. out : {None, array_like}, optional Alternative output array in which to place the result. It must have the same shape and buffer length as the expected output but the type will be cast if necessary. fill_value : scalar or None, optional Value used to fill in the masked values. keepdims : bool, optional If this is set to True, the axes which are reduced are left in the result as dimensions with size one. With this option, the result will broadcast correctly against the array. Returns ------- ptp : ndarray. A new array holding the result, unless ``out`` was specified, in which case a reference to ``out`` is returned. Examples -------- >>> import numpy as np >>> x = np.ma.MaskedArray([[4, 9, 2, 10], ... [6, 9, 7, 12]]) >>> x.ptp(axis=1) masked_array(data=[8, 6], mask=False, fill_value=999999) >>> x.ptp(axis=0) masked_array(data=[2, 0, 5, 2], mask=False, fill_value=999999) >>> x.ptp() 10 This example shows that a negative value can be returned when the input is an array of signed integers. >>> y = np.ma.MaskedArray([[1, 127], ... [0, 127], ... [-1, 127], ... [-2, 127]], dtype=np.int8) >>> y.ptp(axis=1) masked_array(data=[ 126, 127, -128, -127], mask=False, fill_value=np.int64(999999), dtype=int8) A work-around is to use the `view()` method to view the result as unsigned integers with the same bit width: >>> y.ptp(axis=1).view(np.uint8) masked_array(data=[126, 127, 128, 129], mask=False, fill_value=np.uint64(999999), dtype=uint8) )rrMr4)rrrMr4rrS)rrrrr)r|rrrMr4rU min_values rrMaskedArray.ptpsX ;XX4'/1F hhD(02 2FM88:%-/HH$&.0  CX> rc~>[R"SURRS3SS9 [TU]"U0UD6$)Nz3Warning: 'partition' will ignore the 'mask' of the r.rr)rrrrr partitionr|rrrs rrrMaskedArray.partition7sE  $ 7 78;!" $w $1&11rc~>[R"SURRS3SS9 [TU]"U0UD6$)Nz6Warning: 'argpartition' will ignore the 'mask' of the r.rr)rrrrr argpartitionrss rrvMaskedArray.argpartition=sE  $ 7 78;!" $w#T4V44rcURURpe[U5n[U5nU[LaUR S5nUc#UR XUS9SRU5nO[R "XQX$US9 [U[5(a1U[LaUn OUR XUS9n X-n URU 5 US$)aD Take elements from a masked array along an axis. This function does the same thing as "fancy" indexing (indexing arrays using arrays) for masked arrays. It can be easier to use if you need elements along a given axis. Parameters ---------- a : masked_array The source masked array. indices : array_like The indices of the values to extract. Also allow scalars for indices. axis : int, optional The axis over which to select values. By default, the flattened input array is used. out : MaskedArray, optional If provided, the result will be placed in this array. It should be of the appropriate shape and dtype. Note that `out` is always buffered if `mode='raise'`; use other modes for better performance. mode : {'raise', 'wrap', 'clip'}, optional Specifies how out-of-bounds indices will behave. * 'raise' -- raise an error (default) * 'wrap' -- wrap around * 'clip' -- clip to the range 'clip' mode means that all indices that are too large are replaced by the index that addresses the last element along that axis. Note that this disables indexing with negative numbers. Returns ------- out : MaskedArray The returned array has the same type as `a`. See Also -------- numpy.take : Equivalent function for ndarrays. compress : Take elements using a boolean mask. take_along_axis : Take elements by matching the array and the index arrays. Notes ----- This function behaves similarly to `numpy.take`, but it handles masked values. The mask is retained in the output array, and masked values in the input array remain masked in the output. Examples -------- >>> import numpy as np >>> a = np.ma.array([4, 3, 5, 7, 6, 8], mask=[0, 0, 1, 0, 1, 0]) >>> indices = [0, 1, 4] >>> np.ma.take(a, indices) masked_array(data=[4, 3, --], mask=[False, False, True], fill_value=999999) When `indices` is not one-dimensional, the output also has these dimensions: >>> np.ma.take(a, [[0, 1], [2, 3]]) masked_array(data=[[4, 3], [--, 7]], mask=[[False, False], [ True, False]], fill_value=999999) r)rr.)rrrr) rgrnr/rYrrNrrirrrr) r|rarrrrgrnrb maskindicesr3s rrMaskedArray.takeCsH**djj4jg& f $nnQ'G ;**Wd*;C@EEcJC GGEc B c; ' '%**Wd*C& OOG $2wrr=rFflattenrrrc"UR5$r)rrs rMaskedArray.s 4>>#3rrcURS:a [S5eUR[La[ UR R S9$[ URR URR S9$)a Return the matrix-transpose of the masked array. The matrix transpose is the transpose of the last two dimensions, even if the array is of higher dimension. .. versionadded:: 2.0 Returns ------- result: MaskedArray The masked array with the last two dimensions transposed Raises ------ ValueError If the array is of dimension less than 2. See Also -------- ndarray.mT: Equivalent method for arrays rz+matrix transpose with ndim < 2 is undefined)rj)rjrl) rrIrnrrxrgmTrjrlrs rrMaskedArray.mTsW4 99q=JK K :: TZZ]]3 3TYY\\ E ErcpURnU[LaURR5$UbUR U5R5$UR R nU(aSURRUVs/sH oD[4PM sn5nUH nSXVX&'M UR5$U[LaS/$URn[R"URR5[S9nSXRR5'Xul UR5$s snf)a Return the data portion of the masked array as a hierarchical Python list. Data items are converted to the nearest compatible Python type. Masked values are converted to `fill_value`. If `fill_value` is None, the corresponding entries in the output list will be ``None``. Parameters ---------- fill_value : scalar, optional The value to use for invalid entries. Default is None. Returns ------- result : list The Python list representation of the masked array. Examples -------- >>> import numpy as np >>> x = np.ma.array([[1,2,3], [4,5,6], [7,8,9]], mask=[0] + [1,0]*4) >>> x.tolist() [[1, None, 3], [None, 5, None], [7, None, 9]] >>> x.tolist(-999) [[1, -999, 3], [-999, 5, -999], [7, -999, 9]] Nr) rnrrgtolistrNrrrrJrrr r)r|rMrnrrrUr rs rrMaskedArray.tolists8  F?::$$& &  !;;z*113 3    ZZ&&U'CUF U'CDF&* %(#==? " F?6M::$****,F; ${{} }}(DsD3cT[R"S[SS9 URXS9$)z A compatibility alias for `tobytes`, with exactly the same behavior. Despite its name, it returns `bytes` not `str`\ s. .. deprecated:: 1.19.0 z0tostring() is deprecated. Use tobytes() instead.rrr)rrr3tobytesr|rMrs rtostringMaskedArray.tostrings+  > 1 .||J|44rc>URU5RUS9$)a Return the array data as a string containing the raw bytes in the array. The array is filled with a fill value before the string conversion. Parameters ---------- fill_value : scalar, optional Value used to fill in the masked values. Default is None, in which case `MaskedArray.fill_value` is used. order : {'C','F','A'}, optional Order of the data item in the copy. Default is 'C'. - 'C' -- C order (row major). - 'F' -- Fortran order (column major). - 'A' -- Any, current order of array. - None -- Same as 'A'. See Also -------- numpy.ndarray.tobytes tolist, tofile Notes ----- As for `ndarray.tobytes`, information about the shape, dtype, etc., but also about `fill_value`, will be lost. Examples -------- >>> import numpy as np >>> x = np.ma.array(np.array([[1, 2], [3, 4]]), mask=[[0, 1], [1, 0]]) >>> x.tobytes() b'\x01\x00\x00\x00\x00\x00\x00\x00?B\x0f\x00\x00\x00\x00\x00?B\x0f\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00' r)rNrrs rrMaskedArray.tobytess"J{{:&..U.;;rc[S5e)z Save a masked array to a file in binary format. .. warning:: This function is not implemented yet. Raises ------ NotImplementedError When `tofile` is called. z)MaskedArray.tofile() not implemented yet.r)r|fidseprZs rtofileMaskedArray.tofile5s""MNNrcURnURnUc[URU5nURRn[R "URSU4SU4/S9nUR US'URUS'U$)a Transforms a masked array into a flexible-type array. The flexible type array that is returned will have two fields: * the ``_data`` field stores the ``_data`` part of the array. * the ``_mask`` field stores the ``_mask`` part of the array. Parameters ---------- None Returns ------- record : ndarray A new flexible-type `ndarray` with two fields: the first element containing a value, the second element containing the corresponding mask boolean. The returned record shape matches self.shape. Notes ----- A side-effect of transforming a masked array into a flexible `ndarray` is that meta information (``fill_value``, ...) will be lost. Examples -------- >>> import numpy as np >>> x = np.ma.array([[1,2,3],[4,5,6],[7,8,9]], mask=[0] + [1,0]*4) >>> x masked_array( data=[[1, --, 3], [--, 5, --], [7, --, 9]], mask=[[False, True, False], [ True, False, True], [False, True, False]], fill_value=999999) >>> x.toflex() array([[(1, False), (2, True), (3, False)], [(4, True), (5, False), (6, True)], [(7, False), (8, True), (9, False)]], dtype=[('_data', 'SURRn[TU] 5SnU[ U5R U5UR 4-$)zGReturn the internal state of the masked array, for pickling purposes. CFr)rr r __reduce__rZrr)r|cf data_staters r __getstate__MaskedArray.__getstate__sO $**.. !W')!, \$/77;T=M=MNNNrc>Uup#pEpgn[T U]X4XV45 URRU[U5XW45 Xlg)a+Restore the internal state of the masked array, for pickling purposes. ``state`` is typically the output of the ``__getstate__`` output, and is a 5-tuple: - class name - a tuple giving the shape of the data - a typecode for the data - a binary string for the data - a binary string for the mask. N)r __setstate__rnrtrM) r|statershptypisfrawmskflvrs rrMaskedArray.__setstate__sH-2)3S c12 oc&:C EFrc`[URURSS4UR54$)z6Return a 3-tuple for pickling a MaskedArray. rr)_mareconstructrrrrs rrMaskedArray.__reduce__s1$=!!#% %rcVSSKJn [R[ U5USS9nUc0nX1[ U5'UR R5HupEU"XQ5UR U'M URR(aU"UR5URS'U$)Nr)deepcopyTr.) r=rrrr/rrrr hasobjectrg)r|memorcopiedr[vs r __deepcopy__MaskedArray.__deepcopy__s!$$T$ZD$A <DRXmm))+FQ!)!!2FOOA , ::   ( 6FLL  r)rrrnrrMNF)NNNFrr r)TFraise)rrrNNrrNNTN)NNNFNNr)Nr)rz%s)rrrrrrrr _defaultmask_defaulthardmaskrrr>r?rrrrrirrrrpropertyrsetterrr _set_maskrlrr]rrrr!rVr&r)rgrjrrMr+rVfsetrrNr9r8rDrrsrvrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrget_imagrget_realr rArrrrr`rrr!rrr-rrCrrrBrrrrrr-r,r+rrrrrrrvrrr=rFr{rrrTrrrrrrr torecordsrrrrrrrs@rrr scJLJLOV4e!t4Nb4[Cz:xXt|B[[h1C2CL \\   \\**DLI !! [[  @@$PP$$**X$  @3" ) $E  #D $$ [[' ' R%%& __N__NOb"HGR>0a%F 'HT 4 44444  %%% %#(())""$""&&&* "  2yyH 2yyH ^<@<~AF!$Tl:6(8 'R DdR[[6p$/L4T[[r{{IT&&..CK4T[[r{{0#J;;TtNA+0NA`.:.:`&:&:P<@Y>(-Y>v$`D$hTWr2 5 Yx  DJ'H9%G ( #F9%GJ'H34A[)I FFD2h 5% OOI( ;E OOGY0I JE ??7? GGrc^\rSrSrSr\SSSSS4Sjr\U4Sj5rSr S r U4S jr \ r S r S rSS jrSrSrU=r$)rizF Fake a 'void' object to use for masked array with structured dtypes. NFTcU(dSOSn[R"XXsS9nURU5nXXlU[LaB[ U[R 5(aX(lO[R "U5UlUbXHl U$![a* [U5n [R"X)S9SUlN>f=f)NT)r=rfrrr) rr rirrrrHrnrrtrM) r|rjrlrrMrr=rfrgrs rr mvoid.__new__stTC 4 " v $((" C"$''$-EK  !)  !C,U3F"$((4">r"BEKCs(B1CCc>[TU]S$)Nr)rrgrs rrg mvoid._datasw}R  rcURn[X![5(a2[URUX!UR UUR S9$U[LaX!(a[$URU$)z Get the index. )rjrlrMr) rnrrrxrgrrrrw)r|rrs rrmvoid.__getitem__sq JJ agw ' ' ZZ%AG++D1..* * F?qwMzz$rcX RU'UR(a#URU==[USS5-ss'g[USS5URU'g)NrnF)rgrrnr)r|rr@s rrmvoid.__setitem__sI 4 >> JJt w > > &ugu=DJJt rc>URnU[La[UR5$[ URR S5n[ TU] nURU5n[X@R[5 [U5$)Nr) rnrr(rgr rrrrur)r|rrCdata_arrrZrs rr mvoid.__str__sf JJ ;tzz? "&tzz'7'7=7=oof%sJJ0CD3xrc## URURp!U[La UShvN g[X5Hup4U(a [v MUv M gN/7f)zDefines an iterator for mvoidN)rgrnrr=rw)r|rgrnrrs rr-mvoid.__iter__sG**djj F?  e+ LG , s&AA0Ac6URR5$r)rg__len__rs rr mvoid.__len__szz!!##rc<[U5RU5S$)a 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)r0rN)r|rMs rrN mvoid.filleds,t}##J/33rc>URnU[LaURR5$/n[ URUR5H>up4U(aUR S5 MUR UR 55 M@ [U5$)z Transforms the mvoid object into a tuple. Masked fields are replaced by None. Returns ------- returned_tuple Tuple of fields N)rnrrgrr=r"r?r)r|rnrUrrs rr mvoid.tolist/sv  F?::$$& &$**djj1FQ d# affh' 2 V}rrr)rrrrrrrrrgrrrrsr-rrNrrrrs@rrrs`"(tU$*!! ,> H $40rrc"[U[5$)aq 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 as np >>> 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 )rrrs rrereLsb a %%rc^\rSrSrSr\S5rSrU4SjrSSjr Sr Sr S r S r S r\=r=r=r=r=rrCS rS rSrU4SjrSrU=r$)r]iNcZURSL=(a [UR5UL$r)_MaskedConstant__singletonr/)rbs r__has_singletonMaskedConstant.__has_singletons&d*KtCOO/D/KKrcUR5(dk[R"S5n[R"S5nSURlSURl[ XS9R U5UlUR$)NrTFr)_MaskedConstant__has_singletonrr r writeablerrir)rbrjrls rrMaskedConstant.__new__sj""$$88BD$)DJJ #(DJJ *$:??DCOrc>UR5(d[TU] U5$XRLag[Ul[RX5 gr)rrrrrr)r|rrs rr!MaskedConstant.__array_finalize__sJ##%%7-c2 2 %% % )DN  * *4 5rcJUR[5RX5$r)rirr)r|rrrs rrMaskedConstant.__array_wrap__syy%44SBBrc4[[R5$r)r(rr_rs rrMaskedConstant.__str__s&//00rcTU[RLag[RU5$)Nrw)r]rrJrsrs rrsMaskedConstant.__repr__s$ >-- -??4( (rc[RX5$![a3 [R"S[ SS9 [RUS5s$f=f)NzjFormat strings passed to MaskedConstant are ignored, but in future may error or produce different behaviorrrr)rJ __format__rrr FutureWarning)r| format_specs rrMaskedConstant.__format__sR /$$T7 7 / MM6!  $$T2. . /s:AAcURS4$)z.Override of MaskedArray's __reduce__. rrrs rrMaskedConstant.__reduce__s##rcU$rrrs r__iop__MaskedConstant.__iop__rrcU$)z9Copy is a no-op on the maskedconstant, as it is a scalar r)r|rrs rr=MaskedConstant.copys  rcU$rrrs r__copy__MaskedConstant.__copy__rrcU$rr)r|rs rrMaskedConstant.__deepcopy__rrc>UR5(d[TU] X5$XRLa[ SU<S35e[TU] X5$)Nzattributes of z are not writeable)rr __setattr__rrh)r|attrr@rs rrMaskedConstant.__setattr__sZ##%%7&t3 3 %% %  (:;= = 7&t3 3rrr)rrrrr classmethodrrrrrrsrrrrrrrrrr=rrrrrrs@rr]r]sKLL $ 6C1) /$  H     4 4rr]c [XXXXuXUS9 $)zn Shortcut to MaskedArray. The options are in a different order for convenience and backwards compatibility. ) rlrr=rfrrrMrrr)r) rjrr=rrlrMrrrrfrs rr r s" te"!*" @@rcZ[U5nU[LagUR5(agg)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 as np >>> 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)rYrr!)rrs rrgrg s)\  AF{  rcX^\rSrSrSrU4SjrSr\R4Sjr Sr Sr U=r $)_extrema_operationiEz Generic class for maximum/minimum functions. .. note:: This is the base class for `_maximum_operation` and `_minimum_operation`. c<>[TU]U5 X lX0lgr)rr}rfill_value_func)r|rrrMrs rr}_extrema_operation.__init__Ns  )rc8[URX5X5$)r)rrr{s rr_extrema_operation.__call__SsT\\!'..rc[USSS9n[U5nU[RLaGURS:a7[ R "SURSURS3[SS 9 SnU[RLa [US 9nO [5nU[LaURR"U40UD6nU$URURU55R[!U55nURR"U40UD6n["R$R"U40UD6n['US 5(aX5lU$U(a[*nU$) z#Reduce target along the given axis.NTrerz!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.rrrrn)r5rYrr rrrrrr[rrrrNr rir/rror rnrw)r|rrrrrs rr_extrema_operation.reduceXs:T6 FO 2;; 6;;? MM3DMM?C559]]ODEE)Q  8 D r{{ "t_FVF ; f//A]]$$V,..2d4<.@  f//A!!((5f5Aq'""rcv[U5n[U5nU[LaU[La[nO+[U5n[U5n[R X45nUR R [ U5[ U55n[U[5(dUR[5nXVl U$)z>  74D9;CJ rcUR(a[U5nUSUsoS'[U5nURn[ [ U5US5nUc[ [ U5nU"U/UQ70UD6$r)rrsr/rrr/r)r|rSrrmarr method_namemethods rr_frommethod.__call__sm ==:Da!JAAw!}mm d[$7 >R-Fd,T,V,,r)rrrrNr) rrrrrr}rrrrrrrrs!  -rrrrr!r8)rrBrCr=rFr]r`rrrrrrVrrrrrrrAc8[U5nURXX4S9$)z )rrr)rxr)rSrarrrs rrrs  QA 66'#6 99rc ~Ub [S5e[U5n[U5n[X45n[U5n[U5n[ U[ 5(a [ U5nO[ n[R"SSS9 [R"XV[R"Xg55RU5n SSS5 W RU5 [R"[R"U R[ 555n U["La2U R$(d[&$[R("XZ5U lU R-5(aIU R$(d[&$U R*["LaXlU R.U R0U 'U $!,(df  N=f)aR 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 as np >>> 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.2988071523335984, 15.784728999999999, 1.0, --], mask=[False, False, False, True], fill_value=1e+20) Nz3-argument power not supported.rr)rrYrvrXrrr/rrrrrrirrprmrrrrwrqrnr!rMrg) rSrthirdrrrfafbrrUros rrrs1X 9:: B BA B B![!!7 Hh 7!R!45::8D 8 nnR[[W)=>?G{{M}}Q0 {{}}{{M \\V #"L & 1 1 W M# 8 7s ;F.. F<r,r+rXc [R"U5nU[RLa [U5n[ U[ 5(aUR XX4USS9$UR XUSS9$)z)Function version of the eponymous method.Nrr%rr]rMrYrr%rrY)rr/r rrrr-rSrr%rr]rMrYs rr-r-Rsm aA r{{&q)![!!yydU$.t= =yydU4yHHrrc [R"USSS9nUcUR5nSn[U[5(aUR XX4XVS9 U$UR XX6S9 U$)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 as np >>> 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) Trerr1r2)rr r{rrrr3s rrrbsn< T*A | IIK![!! D5$  5 H D5@ Hrc4[U5R5$)a 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 -------- >>> import numpy as np 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/r9rs rr9r9sH a= # # %%rc[R"UVs/sHn[U5PM snU5n[U6nUR U5nUHn[ U5[ LdM O U$[R"UVs/sHn[U5PM snU5nURUR5n[U5Ul U$s snfs snf)a 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 as np >>> 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) ) rr:rXrcrirYrrZrrrrn)r_rrSrr`rjrdms rr:r:sT F3Fq F3T:A  'D 66$C c[R"X5R[5n[ U5[ La&[R"UR U5UlU$)a Extract a diagonal or construct a diagonal array. This function is the equivalent of `numpy.diag` that takes masked values into account, see `numpy.diag` for details. See Also -------- numpy.diag : Equivalent function for ndarrays. Examples -------- >>> import numpy as np Create an array with negative values masked: >>> 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) )rrErirrYrrn)rr[rFs rrErEsDZWWQ]   ,Fqzwwqww* Mrc[U5nU[La+[R"[ U5U5n[ U5$[R"[ US5U5n[ X2S9$)a 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 Examples -------- Shift with a masked array: >>> arr = np.ma.array([10, 20, 30], mask=[False, True, False]) >>> np.ma.left_shift(arr, 1) masked_array(data=[20, --, 60], mask=[False, True, False], fill_value=999999) Large shift: >>> np.ma.left_shift(10, 10) masked_array(data=10240, mask=False, fill_value=999999) Shift with a scalar and an array: >>> scalar = 10 >>> arr = np.ma.array([1, 2, 3], mask=[False, True, False]) >>> np.ma.left_shift(scalar, arr) masked_array(data=[20, --, 80], mask=[False, True, False], fill_value=999999) rr)rYrrrirNrxrSr rrs rriri$sXN  AF{   VAY *A   VAq\1 -A&&rc[U5nU[La+[R"[ U5U5n[ U5$[R"[ US5U5n[ X2S9$)aH 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 as np >>> 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) rr)rYrrrrNrxr:s rrrTsW8  AF{   fQi +A   fQlA .A&&rcURXUS9$![a' [R"U5RXUS9s$f=f)a Set storage-indexed locations to corresponding values. This function is equivalent to `MaskedArray.put`, see that method for details. See Also -------- MaskedArray.put Examples -------- Putting values in a masked array: >>> a = np.ma.array([1, 2, 3, 4], mask=[False, True, False, False]) >>> np.ma.put(a, [1, 3], [10, 30]) >>> a masked_array(data=[ 1, 10, 3, 30], mask=False, fill_value=999999) Using put with a 2D array: >>> b = np.ma.array([[1, 2], [3, 4]], mask=[[False, True], [False, False]]) >>> np.ma.put(b, [[0, 1], [1, 0]], [[10, 20], [30, 40]]) >>> b masked_array( data=[[40, 30], [ 3, 4]], mask=False, fill_value=999999) r)rrhrr0)rSrarrs rrrysHF=uuW4u00 =zz!}  t <<=s.AAc[U[5(dUR[5n[U5[ U5pC[ U5[ LaUU[ LaKSUl[URUR5Ul [R"URXAS9 OUR(aNU[ LaDURR5n[R"XTUS9 U=RU-slO3U[ La [!U5n[R"URXAS9 [R"UR"X1S9 g)ax 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`. Examples -------- >>> import numpy as np >>> arr = [[1, 2], [3, 4]] >>> mask = [[1, 0], [0, 0]] >>> x = np.ma.array(arr, mask=mask) >>> np.ma.putmask(x, x < 4, 10*x) >>> x masked_array( data=[[--, 20], [30, 4]], mask=[[ True, False], [False, False]], fill_value=999999) >>> x.data array([[10, 20], [30, 4]]) TrN)rrrirXrYrrrurrrnrrrr=rlrZrg)rSrlrvaldatavalmaskrs rrrsH a % % FF; !&/76?gqzV &  AM$QWWagg6AG IIaggw 3  &  A IIa - FFaKF f "6*G !''7/IIaggw+ rcURU5$![a; [R"U5RU5R [ 5s$f=f)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 as np >>> 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) )rrhrr0rir)rSrs rrrsJB?{{4  ?zz!}&&t,11+>>?sAAAcURXS9$![a; [R"U5RXS9nUR [ 5s$f=f)a Returns an array containing the same data with a new shape. Refer to `MaskedArray.reshape` for full documentation. See Also -------- MaskedArray.reshape : equivalent function Examples -------- Reshaping a 1-D array: >>> a = np.ma.array([1, 2, 3, 4]) >>> np.ma.reshape(a, (2, 2)) masked_array( data=[[1, 2], [3, 4]], mask=False, fill_value=999999) Reshaping a 2-D array: >>> b = np.ma.array([[1, 2], [3, 4]]) >>> np.ma.reshape(b, (1, 4)) masked_array(data=[[1, 2, 3, 4]], mask=False, fill_value=999999) Reshaping a 1-D array with a mask: >>> c = np.ma.array([1, 2, 3, 4], mask=[False, True, False, False]) >>> np.ma.reshape(c, (2, 2)) masked_array( data=[[1, --], [3, 4]], mask=[[False, True], [False, False]], fill_value=999999) r)rrhrr0rir)rS new_shaper_tmps rrrsRV&yyy00 &zz!}$$Y$<yy%%&sAAAc[U5nU[La[R"X!5n[R"X5R [ U55nUR (aX#lU$)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 as np >>> 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) )rYrrrrircrrn)rrBrrUs rrr4sSp  A IIa # YYq $ ) )*=a*@ AF {{ Mrc@[R"[U55$)z- maskedarray version of the numpy function. )rrrXr!s rrrus 7773<  rc@[R"[U55$*maskedarray version of the numpy function.)rrrXr!s rrrs 88GCL !!rcB[R"[U5U5$rG)rrrX)rrs rrrs 7773< &&rcUS:XaU$US:a[S[U5-5e[RR U5nUR S:Xa [S5e/nU[R Lay[RR U5nUR S:Xa9[UR5nSXb'[R"U[U55nURU5 URU5 U[R Lay[RR U5nUR S:Xa9[UR5nSXb'[R"U[U55nURU5 [U5S:a[RRXR5n[R"XU5$)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=np.uint64(999999), dtype=uint8) >>> u8_arr[1,...] - u8_arr[0,...] np.uint8(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=np.int64(999999), dtype=int16) Examples -------- >>> import numpy as np >>> 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) rz#order must be non-negative but got z4diff requires input that is at least one dimensionalr)rIrdrrr/rr rsrr~rr"r<r:rG)rSr rprependr"combinedrs rrGrGsbF Av1u>aHII Avv{ B Hbkk!%%""7+ <<1 MEEKooguU|[R"SURS9n[R"SURS9n [R"XEU5n [R"XHU 5n [R"U[R"SU RS9U 5n [U 5n [XS9$) a Return a masked array with elements from `x` or `y`, depending on condition. .. note:: When only `condition` is provided, this function is identical to `nonzero`. The rest of this documentation covers only the case where all three arguments are provided. Parameters ---------- condition : array_like, bool Where True, yield `x`, otherwise yield `y`. x, y : array_like, optional Values from which to choose. `x`, `y` and `condition` need to be broadcastable to some shape. Returns ------- out : MaskedArray An masked array with `masked` elements where the condition is masked, elements from `x` where `condition` is True, and elements from `y` elsewhere. See Also -------- numpy.where : Equivalent function in the top-level NumPy module. nonzero : The function that is called when x and y are omitted Examples -------- >>> import numpy as np >>> 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) Trz)Must provide both 'x' and 'y' or neither.rFrrr)r rArIrrNrXrZrwrrrrrrrx) r:rr/missingrxdydcmxmymrjrls rrrsIrH}a8m,2248G!|DEE!|y!!  5 !B B B i B aB aB F{q XXb ) WWR ) f& XXb ) WWR ) 88BB D 88BB D 88B$**5t >> import numpy as np >>> 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,U[Lag[U5$)z,Returns the filled array, or True if masked.T)rwrNrs rfmaskchoose..fmasks ;ayrc,U[Lag[U5$)z:Returns the mask, True if ``masked``, False if ``nomask``.T)rwrYrs rnmaskchoose..nmasks ;qzrrrFTr#)rr) rNrr5rsrvrYrirrr) rachoicesrrrVrYrrmasksrj outputmaskrs rr5r5ts\  wA& 'w!U1XwE '% &gE!HgD &1$/J7:ww/?@ %d4J !.33K@A  c; ' ' OOJ ' MM* H ( &s CCcUc[R"XU5$[R"[U5X5 [US5(a[ U5UlU$)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 as np >>> 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) rn)rrrXr rYrn)rSrVrs rrrsJ^ {xxS)) X+ 3  CI rc6[USS9n[U5nU[LdUR5(aUcU$URR 5Ul[ XR5nUH&nU=RURUSS9-slM( U$)z@ Mask whole 1-d vectors of an array that contain masked values. FryT)rr4)r rYrr!rnr=rr)rSrrrrs r_mask_propagater`s| auA AF{!%%''T\ggllnAG ff -D 155b4500 HrcpUSLa[R"U5S:Xd[R"U5S:XaOqURS:Xa1[XRS- 5n[XRS- 5nO0[XRS- 5n[XRS- 5n[U5)n[U5)nUc[R"[ US5[ US55n[R"XE5)n[R"U5S:Xa[R "U5nUR[X55nURU5 U$[R"[ US5[ US5UR5nURRUR:wa*[R"UR[5Ul[R"XEUR5 [R "URUR5 U$)a 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. See Also -------- numpy.dot : Equivalent function for ndarrays. Examples -------- >>> import numpy as np >>> 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) Trrr)rrr`rZr-rNr0rircrrgrlrrIrrnrp) rSrr,rambmrrr s rr-r- sh~ 771:?bggajAo  VVq[66A:.A66A:.A66A:.A66A:.A q/ B q/ B { FF6!Q<1 . VVB^O 771:? 1 A FF&q, - a FF6!Q<1syy 9 88>>QWW $(3CI rsyy! syy#)), rc[US5n[US5nURS:XaSUlURS:XaSUl[R"X#5R [ 5$)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. rr)rNrrrrbrir)rSrr.r/s rrbrb\ sX 1B 1B ww!| ww!| 88B   --rz Masked values are replaced by 0.c[US5R5n[US5R5n[R"X#5n[ U5n[ U5nU[ LaU[ La [ U5$[U5n[U5n[S[R"SU- SU- 5- SS9n[ XGS9$)rHrrFrr) rNrrrrYrrxrZrs)rSrr.r/rrrrs rrrp s 1   B 1   B A B B V|f A aB aB!bhhq2vq2v..U;A  ""rcU(aU"[U5[R"[R"U5[S9US9U"[R"[R"U5[S9[U5US9-nU"[ U5[ U5US9nO9U"[U5)[U5)US9)nU"[ US5[ US5US9n[XeS9$)z2 Helper function for ma.correlate and ma.convolve rrrr)rZrrrrrXrNrx)rrSrrpropagate_maskrlrjs r_convolve_or_correlaterh s l1orwwrxx{$?d K bggbhhqk. Qd K L WQZd3<?"\!_$44@@1va|$7  ((rc8[[RXX#5$)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. Examples -------- Basic correlation: >>> a = np.ma.array([1, 2, 3]) >>> v = np.ma.array([0, 1, 0]) >>> np.ma.correlate(a, v, mode='valid') masked_array(data=[2], mask=[False], fill_value=999999) Correlation with masked elements: >>> a = np.ma.array([1, 2, 3], mask=[False, True, False]) >>> v = np.ma.array([0, 1, 0]) >>> np.ma.correlate(a, v, mode='valid', propagate_mask=True) masked_array(data=[--], mask=[ True], fill_value=999999, dtype=int64) Correlation with different modes and mixed array types: >>> a = np.ma.array([1, 2, 3]) >>> v = np.ma.array([0, 1, 0]) >>> np.ma.correlate(a, v, mode='full') masked_array(data=[0, 1, 2, 3, 0], mask=[False, False, False, False, False], fill_value=999999) )rhrr>rSrrrgs rr>r> sp "",,d KKrc8[[RXX#5$)az 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. )rhrr<rjs rr<r< s2 ""++qT JJrc[[U5[U55nU[La<[U5n[U5n[R "XE5nUR 5$U(aV[U5n[U5n[R "XE5n[XcSS9nURS5R S5$g)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 -------- >>> import numpy as np >>> 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)rlr=TN) rvrYrrXrrKrr rN)rSrrMrrr/rr7s rrr sV  GAJ'AF{ AJ AJ KK uuw  AJ AJ KK  15 )yy""4((rc [USS9n[USS9nURRS:wa1[R"US5nURU:wa [XgSS9n[ [ U5[ U55n[R"[USUS95RS5n [R"U [[R"U5S5:H5(dg[R"U 5(dE[[[XV- 5XC[U5--5U5n [R"U 5$[R"[XYXi:HU55(dgXY)nXi)n[[[XV- 5XC[U5--5U5n [R"U 5$)a{ 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 -------- >>> import numpy as np >>> 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 Frrr)rr=)r=rl) rxrr%r result_typervrYisinfrNrr!rkr) rSrryrRrQrr/rrxinfrs rrr'!sbR QU#AQU#A ww||sq"% 77e Q%8A GAJ'A 88LQ7 8 ? ? FD 66$&!e44 5 5 66$<< :hquotXa[6H/HI !vvay 66&AG+\: ; ; %A %Az(15/4!2D+DE A 66!9rc 2U=(d Sn[XSSSUS9$)ao 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 -------- >>> import numpy as np >>> 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)) rFT)rr=rrfrrx)rSrrs rr0r0!s&Z LSE Ud#5 22rcl[U[5(aUbXR:XaU$[XSSSS9$)a 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 -------- >>> import numpy as np >>> 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)) FT)rr=rrf)rrrrx)rSrs rr/r/!s5Z![!!u}8H Ud$ OOrrc[S5e)Nz1fromfile() not yet implemented for a MaskedArray.r)filerrArs rfromfilerv!s ; ==rc"[USUSS9$)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 -------- >>> import numpy as np >>> 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=np.int64(999999), dtype=int32) rgrnrrr)fxarrays rrVrV"s| (ww/? @@rc8\rSrSrSrSrS SjrSrSrSrSr g) _convert2maiC"z Convert functions from numpy to numpy.ma. Parameters ---------- _methodname : string Name of the method to transform. Ncz[[U5UlURX#5UlU=(d 0Ulgr)rr_funcrr_extras)r|rnp_ret np_ma_retrs rr}_convert2ma.__init__P"s+R* {{65 | rc[URSS5n[UR5nU(a:URX1U5nU(aURR<U<S3nXC-nU$)r!rNrT)rr|r_replace_return_typer)r|r~rr$rs rr_convert2ma.getdocU"sZdjj)T2"4::. ++CCC"&**"5"5s;)C rc X!;aC[SUSUSUSURRSURRS3 5eURX#5$)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.)rr|rreplace)r|r$r~rs rr _convert2ma._replace_return_typea"sw"  %fXXi[A==CHE226**2E2E1FG--1ZZ-@-@,AB>> {{6--rcnURn[U5RU5nUHnURU5X5'M URR "U0UD6R [5nSU;aURSS5Ul SU;a [URSS55Ul U$)NrMrrF) r}set intersectionpopr|rrirr'rMrr)r|rrr} common_paramsprUs rr_convert2ma.__call__}"s,,F 009 AAGJ$$d5f5::;G = ( ' L$ ?F   &#GKK U$CDF  r)rr}r|r) rrrrrr}rrrrrrrrzrzC"s"G$ .8 rrzr#)rMrzarange : ndarrayzarange : MaskedArray)rr~rr6zclipped_array : ndarrayzclipped_array : MaskedArrayrIz out : ndarrayzout : MaskedArrayrJ)r~rrUzout: MaskedArrayrWzfromfunction : anyzfromfunction: MaskedArrayr_raz'grid : one ndarray or tuple of ndarraysz/grid : one MaskedArray or tuple of MaskedArraysrrrzsqueezed : ndarrayzsqueezed : MaskedArrayrrc[X/U5$)aAppend values to the end of an array. 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 as np >>> 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:)rSrrs rr"r""sN vt $$rr)T)FT)TT)h㈵>:0yE>TTrrrrr)Nrr)FN)validT)rT)Trr(-rrtrrrzrtextwraprtypingrnumpyrnumpy._core.umathr^rnumpy._core.numerictypes numerictypesr@ numpy._corerrBrrrrr r r r r5r rrnumpy._core.numericrnumpy._utils._inspectrr numpy._utilsr__all__rrrrrrrrrrrr&r datetime64 timedelta64halfsingledouble longdoublecsinglecdouble clongdoublefloat_types_listrr/r__annotations__r sctypeDictrsctyper scalar_dtyper%int64inforrmin_valmax_valrSrArTr:rinfcomplexr7rr"rDr5rrr>rPrrVr7rNrcrXget_datarOrvrrrxrrrrrrrrrLr;rr?r(r'rr@rrrrMrrRr4r.rprrlrnrmrr&r$r%r*rrrr)rKrrrkr\rjr[rorrqrrrr1r2r3r^rHrrSrrTrrr rtrYget_maskrZrfrrsrurrvrPr5rrzr{r~rrryr|rrrr}r\rrur[dedentrar~rQrrrrrrerhrdr]rwrrxrgrrrrr rr!r8rBrCr=rFr]r`rrrrrrrrrVrrrrrrrArrr,r+r-rr9r:rErirrrrrrrrrrGrr5rrr`r-rbrcrrrhr>r<rrr0r/rrvrVrzr#r6rIrJrUrWr_rarrrrrr")r[s0rrs, !!))(KKK<<4;#" H 77 ! } 8 > " i   #  A&(mmE1&=N519s?#&(nnUA&>N519s?#  GGRYY 2==JJ BNN<$tSy/$tSy/&&(F88F#LD xx!88a< |RZZ 0 0xx88TXX |R[[ 1 1xx88TXX   c !%HVHV%)( )9"1)=>)=Aw<)=>? ;KBC;PQ;Paww01;PQR  *:2A*>?*>Q=*>?@ ;KBC;PQ;Paww01;PQR*(5 @ u||S3D#> @  s 3C 8 :  s 4\; O QUYY' !%.. 1 !%..!Q 7 S 9u{{+ "5?? 3   #E$4$4 5  &u':':;  ejj)  /$U%6%67 !2!2Aq 9 @ @ #E$4$4 5   $U%6%67 $U%6%67 #E$4$4 5 $U%6%67 u{{+ "%,,0A0CQ J&u'8'8'8':AqB '(:(:(9(;QC $U__%6%8!Q @  ,=,?AFuyy*;*=q!D@ C3D9'x 3lBJDXv0f@6Ir61r+-++xv96?666<6;6B&1R&1RBCJFR"R--`). $ __  __  oo  oo  +D C5p*Zkk\ Jc;'c;c;LwHEKEZ1&h n4[n4b+,,  d$$$d! @$$ 3vAAFDTBKK 6oo%% DTBKK 6oo%% DTBKK6oo%% '-'-T%v&& D% zD 1 i  X 6 z "-( % U]]G5G H6 U]]D2D E i 6 f G X -( -( %% z "G%G:L\ X  X KKd$ I'+ I%%--( ( V$&N:z0f-'`"'J&=R6 r$?N/&d>B!ww "   'ww R[[EZ 8Y)xI X5l   $Nb.));=   #));=  )&8LvK88vjZ/2d/Pnbb= >ABGGT  4% 0 $    4% 0 $+   4% 0 !    !      (  4% 0 !    4% 0 4?    4% 0 !   !   4% 0 &    4% 0 !    ! '%IP?Q@Qs=w5.*w:3w?$*x