rbiDdZgdZddlZddlZddlZddlZddlmZm Z ddl m Z ddl m Z ddlmZmZdd lmZdd lmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'd Z(d>d Z)e*fd Z+dZ,dZ-e-dZ.e-dZ/e-dZ0e0ej1Z1e0ej2Z2e0ej3Z3e/ej4xZ4Z5e/ej6Z6e/ej7Z7e/ej8Z8e/ej9Z9e.ej:Z:e.ej;Z;dZe>jKej>jdej>j?d@dze>_d?ejAddZBd@dZCd?dZDd>dZEd>dZFdZGd ZHd>d!ZIejAfd"ZJejAfd#ZKdAd$ZLdBd%ZMdCd&ZNdCd'ZOdBd(ZPdBd)ZQd*ZRdCd+ZSdDd-ZTdEd.ZUdDd/ZVGd0d1e ZWGd2d3eWZXeXZYdFd4ZZd5Z[d>d6Z\d7Z]d>d8Z^d9Z_d:Z`d;Zad>d<Zbejcejbjebjeb_dGd=Zdejcejdjedjed_dS)Hz Masked arrays add-ons. A collection of utilities for `numpy.ma`. :author: Pierre Gerard-Marchant :contact: pierregm_at_uga_dot_edu ).apply_along_axisapply_over_axes atleast_1d atleast_2d atleast_3daverage clump_maskedclump_unmasked column_stack compress_cols compress_ndcompress_rowcols compress_rows count_maskedcorrcoefcovdiagflatdotdstackediff1dflatnotmasked_contiguousflatnotmasked_edgeshsplithstackisinin1d intersect1d mask_cols mask_rowcols mask_rows masked_allmasked_all_likemedianmr_ ndenumeratenotmasked_contiguousnotmasked_edgespolyfit row_stack setdiff1dsetxor1dstackuniqueunion1dvandervstackN)arrayndarray)_ureduce)AxisConcatenator)normalize_axis_indexnormalize_axis_tuple)core)MAError MaskedArrayaddr1asarray concatenatecountrfilledget_masked_subclassgetdatagetmask getmaskarraymake_mask_descrmask_ormasked masked_arraynomaskonessortzeroscFt|tttfS)z6 Is seq a sequence (ndarray, list or tuple)? ) isinstancer2tuplelist)seqs _/var/www/html/mdtn/previsions/meteo_cartes/venv/lib/python3.11/site-packages/numpy/ma/extras.py issequencerR:s cGUD1 2 22cJt|}||S)a Count the number of masked elements along the given axis. Parameters ---------- arr : array_like An array with (possibly) masked elements. axis : int, optional Axis along which to count. If None (default), a flattened version of the array is used. Returns ------- count : int, ndarray The total number of masked elements (axis=None) or the number of masked elements along each slice of the given axis. See Also -------- MaskedArray.count : Count non-masked elements. Examples -------- >>> import numpy as np >>> a = np.arange(9).reshape((3,3)) >>> a = np.ma.array(a) >>> a[1, 0] = np.ma.masked >>> a[1, 2] = np.ma.masked >>> a[2, 1] = np.ma.masked >>> a masked_array( data=[[0, 1, 2], [--, 4, --], [6, --, 8]], mask=[[False, False, False], [ True, False, True], [False, True, False]], fill_value=999999) >>> np.ma.count_masked(a) 3 When the `axis` keyword is used an array is returned. >>> np.ma.count_masked(a, axis=0) array([1, 1, 1]) >>> np.ma.count_masked(a, axis=1) array([0, 2, 1]) )rCsum)arraxisms rQrrBs"d SA 55;;rSc ttj||tj|t |}|S)a Empty masked array with all elements masked. Return an empty masked array of the given shape and dtype, where all the data are masked. Parameters ---------- shape : int or tuple of ints Shape of the required MaskedArray, e.g., ``(2, 3)`` or ``2``. dtype : dtype, optional Data type of the output. Returns ------- a : MaskedArray A masked array with all data masked. See Also -------- masked_all_like : Empty masked array modelled on an existing array. Notes ----- Unlike other masked array creation functions (e.g. `numpy.ma.zeros`, `numpy.ma.ones`, `numpy.ma.full`), `masked_all` does not initialize the values of the array, and may therefore be marginally faster. However, the values stored in the newly allocated array are arbitrary. For reproducible behavior, be sure to set each element of the array before reading. Examples -------- >>> import numpy as np >>> np.ma.masked_all((3, 3)) masked_array( data=[[--, --, --], [--, --, --], [--, --, --]], mask=[[ True, True, True], [ True, True, True], [ True, True, True]], fill_value=1e+20, dtype=float64) The `dtype` parameter defines the underlying data type. >>> a = np.ma.masked_all((3, 3)) >>> a.dtype dtype('float64') >>> a = np.ma.masked_all((3, 3), dtype=np.int32) >>> a.dtype dtype('int32') mask)rGnpemptyrIrD)shapedtypeas rQr r xsFp RXeU++'%)?)?@@ B B BA HrSctj|t}tj|jt |j|_|S)aG Empty masked array with the properties of an existing array. Return an empty masked array of the same shape and dtype as the array `arr`, where all the data are masked. Parameters ---------- arr : ndarray An array describing the shape and dtype of the required MaskedArray. Returns ------- a : MaskedArray A masked array with all data masked. Raises ------ AttributeError If `arr` doesn't have a shape attribute (i.e. not an ndarray) See Also -------- masked_all : Empty masked array with all elements masked. Notes ----- Unlike other masked array creation functions (e.g. `numpy.ma.zeros_like`, `numpy.ma.ones_like`, `numpy.ma.full_like`), `masked_all_like` does not initialize the values of the array, and may therefore be marginally faster. However, the values stored in the newly allocated array are arbitrary. For reproducible behavior, be sure to set each element of the array before reading. Examples -------- >>> import numpy as np >>> arr = np.zeros((2, 3), dtype=np.float32) >>> arr array([[0., 0., 0.], [0., 0., 0.]], dtype=float32) >>> np.ma.masked_all_like(arr) masked_array( data=[[--, --, --], [--, --, --]], mask=[[ True, True, True], [ True, True, True]], fill_value=np.float64(1e+20), dtype=float32) The dtype of the masked array matches the dtype of `arr`. >>> arr.dtype dtype('float32') >>> np.ma.masked_all_like(arr).dtype dtype('float32') r_) r\ empty_likeviewr:rIr^rDr__mask)rVr`s rQr!r!sIv c ,,Agag_QW%=%=>>>AG HrScfd}|S)a Decorator to wrap a "_fromnxfunction" function, wrapping a numpy function as a masked array function, with proper docstring and name. Parameters ---------- _fromnxfunction : ({params}) -> ndarray, {params}) -> masked_array Wrapper function that calls the wrapped numpy function Returns ------- decorator : (f: ({params}) -> ndarray) -> ({params}) -> masked_array Function that accepts a numpy function and returns a masked array function cfd}tj|dtjjd|_|S)Ncg|Ri|SN)argskwargs_fromnxfunctionnpfuncs rQwrapperz<_fromnxfunction_function..decorator..wrapper s#"?6;D;;;F;; ;rS)__name__ __qualname__)assignedzHThe function is applied to both the ``_data`` and the ``_mask``, if any.) functoolsupdate_wrappermadoc_note__doc__)rnrorms` rQ decoratorz+_fromnxfunction_function..decorator s_ < < < < < <  &;WXXXX+ N V  rSrj)rmrxs` rQ_fromnxfunction_functionrys$      rSct|tj|g|Ri||t|g|Ri|S)z Wraps a NumPy function that can be called with a single array argument followed by auxiliary args that are passed verbatim for both the data and mask calls. datar[rGr\r<rC)rnr`rkrls rQ_fromnxfunction_singler~sc  VBJqMM 3D 3 3 3F 3 3 VLOO 5d 5 5 5f 5 5   rSc t|td|Dg|Ri||td|Dg|Ri|S)z Wraps a NumPy function that can be called with a single sequence of arrays followed by auxiliary args that are passed verbatim for both the data and mask calls. c3>K|]}tj|VdSri)r\r<.0r`s rQ z&_fromnxfunction_seq..*s*66A"*Q--666666rSc34K|]}t|VdSri)rCrs rQrz&_fromnxfunction_seq..+s(88a,q//888888rSr{)rGrN)rnarysrkrls rQ_fromnxfunction_seqr#s  VE6666666 H H H H H H VE88488888 J4 J J J6 J J   rScxtfd|D}t|dkr|dn|S)a Wraps a NumPy function that can be called with multiple array arguments. All args are converted to arrays even if they are not so already. This makes it possible to process scalars as 1-D arrays. Only keyword arguments are passed through verbatim for the data and mask calls. Arrays arguments are processed independently and the results are returned in a list. If only one arg is present, the return value is just the processed array instead of a list. c 3K|]B}ttj|fit|fiVCdS)r{Nr})rr`rlrns rQrz*_fromnxfunction_allargs..9s   1 0000 Q22622   rSr7r0)rNlen)rnrrlouts` ` rQ_fromnxfunction_allargsr.s`     CXX]]3q66+rScd}|t|krTt||dr&|||||dz<t||d&|dz }|t|kT|S)zFlatten a sequence in place.r0__iter__r7)rhasattr)rPks rQflatten_inplacerTsz A C==c!fj)) $ VC1q5 Nc!fj)) $ Q C== JrSc t|dd}|j}t||}dg|dz z}tj|d}t t |}||tdd||<tj |j  |} | ||||t|g|Ri|} tj| } | s# t!| n#t"$rd} YnwxYwg} | ra| tj | jt | t(} | | t|<tj| }d}||kr|dxxdz cc<d}||| |krA|d|z kr8||dz xxdz cc<d||<|dz}||| |kr |d|z k8| ||||t|g|Ri|} | | t|<| t| j|dz }||kn7t| dd} |}tddg| jz||<| ||tj| }| }t |j } | j | |<| t| jt/| } t | t(} | | tt/|<d}||kr&|dxxdz cc<d}||||krA|d|z kr8||dz xxdz cc<d||<|dz}||||kr |d|z k8| ||| ||||t|g|Ri|} | | tt/|<| t| j|dz }||k&tjtj | }t3|d stj | | }n*t| | }t5j||_|S) z0 (This docstring should be overwritten) FT)copysubokr0r7ONrerb)r1ndimr5r\rKrOrangeremoveslicer<r^takeputrNtolistisscalarr TypeErrorappendr_objectprodrrmaxrrudefault_fill_value fill_value)func1drWrVrkrlndindiindlistoutshaperesasscalardtypesoutarrNtotrnj holdshape max_dtypesresults rQrr^sC %t , , ,C B b ) )D #a.C SA599ooG NN4D$AdGz#)$$))'22HEE'3 &U188::&&' 9$ 9 9 9& 9 9C{3H   HHHH   HHH  F. bjoo+,,,x(( uSzzwx   $hh GGGqLGGGAq6Xa[((qAF||AE a AQq6Xa[((qAF|| EE'3   &U188::../A$AAA&AAC!$F5::  MM'#,,, - - - FA$hhCe4000 FFHH$%%&1$ gswx    ?? gcll()))"8,,x((58u_QXXZZ00112 $hh GGGqLGGGAq6Yq\))QV AE a AQq6Yq\))QV  EE'3    EE'3   &U188::../A$AAA&AAC9>> import numpy as np >>> a = np.ma.arange(24).reshape(2,3,4) >>> a[:,0,1] = np.ma.masked >>> a[:,1,:] = np.ma.masked >>> a masked_array( data=[[[0, --, 2, 3], [--, --, --, --], [8, 9, 10, 11]], [[12, --, 14, 15], [--, --, --, --], [20, 21, 22, 23]]], mask=[[[False, True, False, False], [ True, True, True, True], [False, False, False, False]], [[False, True, False, False], [ True, True, True, True], [False, False, False, False]]], fill_value=999999) >>> np.ma.apply_over_axes(np.ma.sum, a, [0,2]) masked_array( data=[[[46], [--], [124]]], mask=[[[False], [ True], [False]]], fill_value=999999) Tuple axis arguments to ufuncs are equivalent: >>> np.ma.sum(a, axis=(0,2)).reshape((1,-1,1)) masked_array( data=[[[46], [--], [124]]], mask=[[[False], [ True], [False]]], fill_value=999999) F)keepdimsctt}tjd|tjuri}nd|i}|=jfi|}|j }nt|} tjjtj tj fr!t j j| jd} nt j j| j} j| jkrtd| jt!fdDkrt#d| t j} | t!fd t+jD} |t,ur | jz} | xjjzc_| jd | d |}t j| | jfi||z }|r@|j|jkr,t j||j}||fS|S) aK Return the weighted average of array over the given axis. Parameters ---------- a : array_like Data to be averaged. Masked entries are not taken into account in the computation. axis : None or int or tuple of ints, optional Axis or axes along which to average `a`. The default, `axis=None`, will average over all of the elements of the input array. If axis is a tuple of ints, averaging is performed on all of the axes specified in the tuple instead of a single axis or all the axes as before. weights : array_like, optional An array of weights associated with the values in `a`. Each value in `a` contributes to the average according to its associated weight. The array of weights must be the same shape as `a` if no axis is specified, otherwise the weights must have dimensions and shape consistent with `a` along the specified axis. If `weights=None`, then all data in `a` are assumed to have a weight equal to one. The calculation is:: avg = sum(a * weights) / sum(weights) where the sum is over all included elements. The only constraint on the values of `weights` is that `sum(weights)` must not be 0. returned : bool, optional Flag indicating whether a tuple ``(result, sum of weights)`` should be returned as output (True), or just the result (False). Default is False. 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 original `a`. *Note:* `keepdims` will not work with instances of `numpy.matrix` or other classes whose methods do not support `keepdims`. .. versionadded:: 1.23.0 Returns ------- average, [sum_of_weights] : (tuple of) scalar or MaskedArray The average along the specified axis. When returned is `True`, return a tuple with the average as the first element and the sum of the weights as the second element. The return type is `np.float64` if `a` is of integer type and floats smaller than `float64`, or the input data-type, otherwise. If returned, `sum_of_weights` is always `float64`. Raises ------ ZeroDivisionError When all weights along axis are zero. See `numpy.ma.average` for a version robust to this type of error. TypeError When `weights` does not have the same shape as `a`, and `axis=None`. ValueError When `weights` does not have dimensions and shape consistent with `a` along specified `axis`. Examples -------- >>> import numpy as np >>> a = np.ma.array([1., 2., 3., 4.], mask=[False, False, True, True]) >>> np.ma.average(a, weights=[3, 1, 0, 0]) 1.25 >>> x = np.ma.arange(6.).reshape(3, 2) >>> x masked_array( data=[[0., 1.], [2., 3.], [4., 5.]], mask=False, fill_value=1e+20) >>> data = np.arange(8).reshape((2, 2, 2)) >>> data array([[[0, 1], [2, 3]], [[4, 5], [6, 7]]]) >>> np.ma.average(data, axis=(0, 1), weights=[[1./4, 3./4], [1., 1./2]]) masked_array(data=[3.4, 4.4], mask=[False, False], fill_value=1e+20) >>> np.ma.average(data, axis=0, weights=[[1./4, 3./4], [1., 1./2]]) Traceback (most recent call last): ... ValueError: Shape of weights must be consistent with shape of a along specified axis. >>> avg, sumweights = np.ma.average(x, axis=0, weights=[1, 2, 3], ... returned=True) >>> avg masked_array(data=[2.6666666666666665, 3.6666666666666665], mask=[False, False], fill_value=1e+20) With ``keepdims=True``, the following result has shape (3, 1). >>> np.ma.average(x, axis=1, keepdims=True) masked_array( data=[[0.5], [2.5], [4.5]], mask=False, fill_value=1e+20) NrW)argnamerf8z;Axis must be specified when shapes of a and weights differ.c32K|]}j|VdSri)r^)raxr`s rQrzaverage..s)!=!="!'"+!=!=!=!=!=!=rSzIShape of weights must be consistent with shape of a along specified axis.c3.K|]\}}|vr|ndVdS)r7Nrj)rrsrWs rQrzaverage..sO$E$E(-A+-**QQ!$E$E$E$E$E$ErS)rWr_rbrj)r<rBr6rr\_NoValuemeanr_typer> issubclassintegerbool result_typer^rrNr transposeargsortreshape enumeraterHr[rUmultiply broadcast_tor) r`rWweightsreturnedrrX keepdims_kwavgsclwgt result_dtypes `` rQrrsb  A A #D!&&AAA2; !8, afT))[))innQWWT]]++g aglRZ$9 : : >>!'39dCCLL>!'39==L 7ci  |yE!=!=!=!=!=!=!===== 7888 -- 4 0 011C++e$E$E$E$E1:171C1C$E$E$EEEFFC F??!&/C HH HHcgC4|CC{CC2bk!S ,....1$GG:EGGILM 9 ! !/#sy116688CCx rSct|ds`tjt|d||||}t |tjrd|jkrt|dS|St|t||||S) a7 Compute the median along the specified axis. Returns the median of the array elements. Parameters ---------- a : array_like Input array or object that can be converted to an array. axis : int, optional Axis along which the medians are computed. The default (None) is to compute the median along a flattened version of the array. out : ndarray, 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. overwrite_input : bool, optional If True, then allow use of memory of input array (a) for calculations. The input array will be modified by the call to median. This will save memory when you do not need to preserve the contents of the input array. Treat the input as undefined, but it will probably be fully or partially sorted. Default is False. Note that, if `overwrite_input` is True, and the input is not already an `ndarray`, an error will be raised. 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 input array. Returns ------- median : ndarray A new array holding the result is returned unless out is specified, in which case a reference to out is returned. Return data-type is `float64` for integers and floats smaller than `float64`, or the input data-type, otherwise. See Also -------- mean Notes ----- Given a vector ``V`` with ``N`` non masked values, the median of ``V`` is the middle value of a sorted copy of ``V`` (``Vs``) - i.e. ``Vs[(N-1)/2]``, when ``N`` is odd, or ``{Vs[N/2 - 1] + Vs[N/2]}/2`` when ``N`` is even. Examples -------- >>> import numpy as np >>> x = np.ma.array(np.arange(8), mask=[0]*4 + [1]*4) >>> np.ma.median(x) 1.5 >>> x = np.ma.array(np.arange(10).reshape(2, 5), mask=[0]*6 + [1]*4) >>> np.ma.median(x) 2.5 >>> np.ma.median(x, axis=-1, overwrite_input=True) masked_array(data=[2.0, 5.0], mask=[False, False], fill_value=1e+20) r[Tr)rWroverwrite_inputrr7Fr)rrrWrr) rr\r"rArMr2rrGr3_median)r`rWrrrrXs rQr"r"sB 1f   Igat,,,4' ) ) ) a $ $ af... .H AGhTs$3 5 5 55rSctj|jtjr tj}nd}|rG+||n,|||nt ||dntjj dkrbtdgjz}tdd|<t|}tj ||Sjdkr(ttd\}}||zdz |dz}tjjtjrbjdkrW||} |stj| dd | } tjj| } n| |} tj | r8tjjstj S| Std } | dz} | dzdk}tj|| | dz } tj| | g } tj|  }fd}||tjjtjrktj ||} tj| jdd| j tjj| } n"tj ||} | S)N)r)rWrr0)rWrr7)rg@safe)castingrTrWrrWctj|rXtjjd|jz}tj|j|<d|j|<dSdS)NTrF)r\ru is_maskedallr[minimum_fill_valuer|)rrepasortedrWs rQreplace_maskedz_median..replace_masked1sq 5??1   F7sizerU true_dividelib _utils_impl_median_nancheckrrr[rwherer=take_along_axisr|)r`rWrrrindexeridxoddmidrcountshllhlow_highrrs ` @rQrrsL }QWbj))V  < <ggiiG LLJL / / / / FFF 4 4 4GGqt ;;; |#D',77}Ta;;-',.a  ..uzz''*3z???|q%..!,,ScCi!mC!G+, = 3 3 " q8H8HC  A CN1b&cBBB"33GQEEAAS!!A 5??1   5bfW\&:&: 55++G44 4 7 5 5 5F! A 1*/C aQA AT * * *B!'2D999H      N8 }W]BJ//5 EIIhTsI 3 3 qvr8@@@@ F  / /D A A EJJxdJ 4 4 HrSc \t|}t|}|"tt|j}nt ||j}|t us|s|jS| rtgS|j}|D]}ttt|tt|dz|jz}|tdf|z||fz}|S)a=Suppress slices from multiple dimensions which contain masked values. Parameters ---------- x : array_like, MaskedArray The array to operate on. If not a MaskedArray instance (or if no array elements are masked), `x` is interpreted as a MaskedArray with `mask` set to `nomask`. axis : tuple of ints or int, optional Which dimensions to suppress slices from can be configured with this parameter. - If axis is a tuple of ints, those are the axes to suppress slices from. - If axis is an int, then that is the only axis to suppress slices from. - If axis is None, all axis are selected. Returns ------- compress_array : ndarray The compressed array. Examples -------- >>> import numpy as np >>> arr = [[1, 2], [3, 4]] >>> mask = [[0, 1], [0, 0]] >>> x = np.ma.array(arr, mask=mask) >>> np.ma.compress_nd(x, axis=0) array([[3, 4]]) >>> np.ma.compress_nd(x, axis=1) array([[1], [3]]) >>> np.ma.compress_nd(x) array([[3]]) Nr7r) r<rBrNrrr6rHany_datarnxarrayrOr)xrWrXr|rrs rQr r IsH  A A |U16]]###D!&11 F{{!%%''{wuuwwr{{ 7D@@T%))__tE"q&!&,A,A'B'BBCCU4[[NR'AEEtE,<,<+<*>>? KrScrt|jdkrtdt||S)a Suppress the rows and/or columns of a 2-D array that contain masked values. The suppression behavior is selected with the `axis` parameter. - If axis is None, both rows and columns are suppressed. - If axis is 0, only rows are suppressed. - If axis is 1 or -1, only columns are suppressed. Parameters ---------- x : array_like, MaskedArray The array to operate on. If not a MaskedArray instance (or if no array elements are masked), `x` is interpreted as a MaskedArray with `mask` set to `nomask`. Must be a 2D array. axis : int, optional Axis along which to perform the operation. Default is None. Returns ------- compressed_array : ndarray The compressed array. Examples -------- >>> import numpy as np >>> x = np.ma.array(np.arange(9).reshape(3, 3), mask=[[1, 0, 0], ... [1, 0, 0], ... [0, 0, 0]]) >>> x masked_array( data=[[--, 1, 2], [--, 4, 5], [6, 7, 8]], mask=[[ True, False, False], [ True, False, False], [False, False, False]], fill_value=999999) >>> np.ma.compress_rowcols(x) array([[7, 8]]) >>> np.ma.compress_rowcols(x, 0) array([[6, 7, 8]]) >>> np.ma.compress_rowcols(x, 1) array([[1, 2], [4, 5], [7, 8]]) rz*compress_rowcols works for 2D arrays only.r)r<rNotImplementedErrorr )rrWs rQr r s:fqzz!!"NOOO qt $ $ $$rSctt|}|jdkrtdt|dS)ay Suppress whole rows of a 2-D array that contain masked values. This is equivalent to ``np.ma.compress_rowcols(a, 0)``, see `compress_rowcols` for details. Parameters ---------- x : array_like, MaskedArray The array to operate on. If not a MaskedArray instance (or if no array elements are masked), `x` is interpreted as a MaskedArray with `mask` set to `nomask`. Must be a 2D array. Returns ------- compressed_array : ndarray The compressed array. See Also -------- compress_rowcols Examples -------- >>> import numpy as np >>> a = np.ma.array(np.arange(9).reshape(3, 3), mask=[[1, 0, 0], ... [1, 0, 0], ... [0, 0, 0]]) >>> np.ma.compress_rows(a) array([[6, 7, 8]]) rz'compress_rows works for 2D arrays only.r0r<rrr r`s rQrrs:B  Av{{!"KLLL Aq ! !!rSctt|}|jdkrtdt|dS)a Suppress whole columns of a 2-D array that contain masked values. This is equivalent to ``np.ma.compress_rowcols(a, 1)``, see `compress_rowcols` for details. Parameters ---------- x : array_like, MaskedArray The array to operate on. If not a MaskedArray instance (or if no array elements are masked), `x` is interpreted as a MaskedArray with `mask` set to `nomask`. Must be a 2D array. Returns ------- compressed_array : ndarray The compressed array. See Also -------- compress_rowcols Examples -------- >>> import numpy as np >>> a = np.ma.array(np.arange(9).reshape(3, 3), mask=[[1, 0, 0], ... [1, 0, 0], ... [0, 0, 0]]) >>> np.ma.compress_cols(a) array([[1, 2], [4, 5], [7, 8]]) rz'compress_cols works for 2D arrays only.r7r r s rQr r s:F  Av{{!"KLLL Aq ! !!rSct|d}|jdkrtdt|}|tus|s|S|}|j|_|s"t|tj |d<|dvr&t|ddtj |df<|S) a Mask rows and/or columns of a 2D array that contain masked values. Mask whole rows and/or columns of a 2D array that contain masked values. The masking behavior is selected using the `axis` parameter. - If `axis` is None, rows *and* columns are masked. - If `axis` is 0, only rows are masked. - If `axis` is 1 or -1, only columns are masked. Parameters ---------- a : array_like, MaskedArray The array to mask. If not a MaskedArray instance (or if no array elements are masked), the result is a MaskedArray with `mask` set to `nomask` (False). Must be a 2D array. axis : int, optional Axis along which to perform the operation. If None, applies to a flattened version of the array. Returns ------- a : MaskedArray A modified version of the input array, masked depending on the value of the `axis` parameter. Raises ------ NotImplementedError If input array `a` is not 2D. See Also -------- mask_rows : Mask rows of a 2D array that contain masked values. mask_cols : Mask cols of a 2D array that contain masked values. masked_where : Mask where a condition is met. Notes ----- The input array's mask is modified by this function. Examples -------- >>> import numpy as np >>> a = np.zeros((3, 3), dtype=int) >>> a[1, 1] = 1 >>> a array([[0, 0, 0], [0, 1, 0], [0, 0, 0]]) >>> a = np.ma.masked_equal(a, 1) >>> a masked_array( data=[[0, 0, 0], [0, --, 0], [0, 0, 0]], mask=[[False, False, False], [False, True, False], [False, False, False]], fill_value=1) >>> np.ma.mask_rowcols(a) masked_array( data=[[0, --, 0], [--, --, --], [0, --, 0]], mask=[[False, True, False], [ True, True, True], [False, True, False]], fill_value=1) Frrz&mask_rowcols works for 2D arrays only.r0)Nr7rNr7) r1rrrBrHrnonzerorerrFr\r,)r`rWrX maskedvals rQrr sR auAv{{!"JKKK AF{{!%%''{ IgllnnAG ,%+")IaL ! !" }(.!!!RYy| $ $ $% HrScv|tjurtjdtdt |dS)a Mask rows of a 2D array that contain masked values. This function is a shortcut to ``mask_rowcols`` with `axis` equal to 0. See Also -------- mask_rowcols : Mask rows and/or columns of a 2D array. masked_where : Mask where a condition is met. Examples -------- >>> import numpy as np >>> a = np.zeros((3, 3), dtype=int) >>> a[1, 1] = 1 >>> a array([[0, 0, 0], [0, 1, 0], [0, 0, 0]]) >>> a = np.ma.masked_equal(a, 1) >>> a masked_array( data=[[0, 0, 0], [0, --, 0], [0, 0, 0]], mask=[[False, False, False], [False, True, False], [False, False, False]], fill_value=1) >>> np.ma.mask_rows(a) masked_array( data=[[0, 0, 0], [--, --, --], [0, 0, 0]], mask=[[False, False, False], [ True, True, True], [False, False, False]], fill_value=1) TThe axis argument has always been ignored, in future passing it will raise TypeErrorr stacklevelr0r\rwarningswarnDeprecationWarningrr`rWs rQrrdsMT 2;   #$61 F F F F 1  rScv|tjurtjdtdt |dS)a Mask columns of a 2D array that contain masked values. This function is a shortcut to ``mask_rowcols`` with `axis` equal to 1. See Also -------- mask_rowcols : Mask rows and/or columns of a 2D array. masked_where : Mask where a condition is met. Examples -------- >>> import numpy as np >>> a = np.zeros((3, 3), dtype=int) >>> a[1, 1] = 1 >>> a array([[0, 0, 0], [0, 1, 0], [0, 0, 0]]) >>> a = np.ma.masked_equal(a, 1) >>> a masked_array( data=[[0, 0, 0], [0, --, 0], [0, 0, 0]], mask=[[False, False, False], [False, True, False], [False, False, False]], fill_value=1) >>> np.ma.mask_cols(a) masked_array( data=[[0, --, 0], [0, --, 0], [0, --, 0]], mask=[[False, True, False], [False, True, False], [False, True, False]], fill_value=1) rrrr7rrs rQrrsMR 2;   #$61 F F F F 1  rSc tj|j}|dd|ddz }|g}||d||||t |dkrt |}|S)a Compute the differences between consecutive elements of an array. This function is the equivalent of `numpy.ediff1d` that takes masked values into account, see `numpy.ediff1d` for details. See Also -------- numpy.ediff1d : Equivalent function for ndarrays. Examples -------- >>> import numpy as np >>> arr = np.ma.array([1, 2, 4, 7, 0]) >>> np.ma.ediff1d(arr) masked_array(data=[ 1, 2, 3, -7], mask=False, fill_value=999999) r7Nrr0)ru asanyarrayflatinsertrrr)rVto_endto_beginedarrayss rQrrs* -   !C QRR3ss8 BTF a"""  f 6{{aF^^ IrSctj|||}t|trBt |}|dt |d<t|}n|t }|S)a: Finds the unique elements of an array. Masked values are considered the same element (masked). The output array is always a masked array. See `numpy.unique` for more details. See Also -------- numpy.unique : Equivalent function for ndarrays. Examples -------- >>> import numpy as np >>> a = [1, 2, 1000, 2, 3] >>> mask = [0, 0, 1, 0, 0] >>> masked_a = np.ma.masked_array(a, mask) >>> masked_a masked_array(data=[1, 2, --, 2, 3], mask=[False, False, True, False, False], fill_value=999999) >>> np.ma.unique(masked_a) masked_array(data=[1, 2, 3, --], mask=[False, False, False, True], fill_value=999999) >>> np.ma.unique(masked_a, return_index=True) (masked_array(data=[1, 2, 3, --], mask=[False, False, False, True], fill_value=999999), array([0, 1, 4, 2])) >>> np.ma.unique(masked_a, return_inverse=True) (masked_array(data=[1, 2, 3, --], mask=[False, False, False, True], fill_value=999999), array([0, 1, 3, 1, 2])) >>> np.ma.unique(masked_a, return_index=True, return_inverse=True) (masked_array(data=[1, 2, 3, --], mask=[False, False, False, True], fill_value=999999), array([0, 1, 4, 2]), array([0, 1, 3, 1, 2])) ) return_indexreturn_inverser0)r\r,rMrNrOrdr:)ar1r"r#outputs rQr,r,s~LYs$0&4666F&%  *f1INN;//q v[)) MrSc|rtj||f}n0tjt|t|f}||dd|dd|ddkS)aY Returns the unique elements common to both arrays. Masked values are considered equal one to the other. The output is always a masked array. See `numpy.intersect1d` for more details. See Also -------- numpy.intersect1d : Equivalent function for ndarrays. Examples -------- >>> import numpy as np >>> x = np.ma.array([1, 3, 3, 3], mask=[0, 0, 0, 1]) >>> y = np.ma.array([3, 1, 1, 1], mask=[0, 0, 0, 1]) >>> np.ma.intersect1d(x, y) masked_array(data=[1, 3, --], mask=[False, False, True], fill_value=999999) Nrr7)rur=r,rJ)r$ar2 assume_uniqueauxs rQrr%sx09nc3Z((nfSkk6#;;788HHJJJ ss8CGs3B3x' ((rScr|st|}t|}tj||fd}|jdkr|S||}tjdg|dd|ddkdgf}|dd|ddk}||S)a Set exclusive-or of 1-D arrays with unique elements. The output is always a masked array. See `numpy.setxor1d` for more details. See Also -------- numpy.setxor1d : Equivalent function for ndarrays. Examples -------- >>> import numpy as np >>> ar1 = np.ma.array([1, 2, 3, 2, 4]) >>> ar2 = np.ma.array([2, 3, 5, 7, 5]) >>> np.ma.setxor1d(ar1, ar2) masked_array(data=[1, 4, 5, 7], mask=False, fill_value=999999) Nrr0Tr7r)r,rur=rrJr?)r$r'r(r)auxfflagflag2s rQr*r*Fs* SkkSkk .#s$ / / /C x1}} HHJJJ ::<D6DHSbS $9TFC D DD !""Xcrc "E u:rSc|s#t|d\}}t|}tj||f}|d}||}|r|dd|ddk}n|dd|ddk}tj||gf} |ddt |} |r| | S| | |S)a3 Test whether each element of an array is also present in a second array. The output is always a masked array. We recommend using :func:`isin` instead of `in1d` for new code. See Also -------- isin : Version of this function that preserves the shape of ar1. Examples -------- >>> import numpy as np >>> ar1 = np.ma.array([0, 1, 2, 5, 0]) >>> ar2 = [0, 2] >>> np.ma.in1d(ar1, ar2) masked_array(data=[ True, False, True, False, True], mask=False, fill_value=True) T)r# mergesort)kindr7Nr)r,rur=rr) r$r'r(invertrev_idxarordersarbool_arr,indxs rQrrks0 c$777 WSkk c # #B JJKJ ( (E U)C (qrr7c#2#h&qrr7c#2#h& >7VH- . .D ==k= * *9CHH9 5D#DzDz'""rSctj|}t|||||jS)aw Calculates `element in test_elements`, broadcasting over `element` only. The output is always a masked array of the same shape as `element`. See `numpy.isin` for more details. See Also -------- in1d : Flattened version of this function. numpy.isin : Equivalent function for ndarrays. Examples -------- >>> import numpy as np >>> element = np.ma.array([1, 2, 3, 4, 5, 6]) >>> test_elements = [0, 2] >>> np.ma.isin(element, test_elements) masked_array(data=[False, True, False, False, False, False], mask=False, fill_value=True) r(r1)rur<rrr^)element test_elementsr(r1s rQrrsB0j!!G m   &ww}556rScLttj||fdS)a Union of two arrays. The output is always a masked array. See `numpy.union1d` for more details. See Also -------- numpy.union1d : Equivalent function for ndarrays. Examples -------- >>> import numpy as np >>> ar1 = np.ma.array([1, 2, 3, 4]) >>> ar2 = np.ma.array([3, 4, 5, 6]) >>> np.ma.union1d(ar1, ar2) masked_array(data=[1, 2, 3, 4, 5, 6], mask=False, fill_value=999999) Nr)r,rur=)r$r's rQr-r-s%* ".#s$777 8 88rSc|r'tj|}nt|}t|}|t ||ddS)a Set difference of 1D arrays with unique elements. The output is always a masked array. See `numpy.setdiff1d` for more details. See Also -------- numpy.setdiff1d : Equivalent function for ndarrays. Examples -------- >>> import numpy as np >>> x = np.ma.array([1, 2, 3, 4], mask=[0, 1, 0, 1]) >>> np.ma.setdiff1d(x, [1, 2]) masked_array(data=[3, --], mask=[False, True], fill_value=999999) Tr9)rur<rr,r)r$r'r(s rQr)r)sY*joo##%%SkkSkk tCD>>> ??rSTctj|ddt}tj|}|s#|rt d|jddkrd}tt|}d|z }|rtddf}ndtdf}|d|jddks|jddkr tj }n tj }tj ||}nUt|d dt }tj|} |s#| rt d|s| rN|j|jkr>tj|| } | t ur | x}x|_x|_} d |_d |_tj||f|}|jddks|jddkr tj }n tj }tj tj|| f||}||| |z}|||fS) z_ Private function for the computation of covariance and correlation coefficients. rT)ndminrr_zCannot process masked data.r0r7NiF)rr?r_r)rur1floatrCrrr^intrrr\float64float32 logical_notastype logical_orrHre _sharedmaskr=r) ryrowvar allow_maskedxmaskrWtup xnm_dtypexnotmaskymask common_masks rQ _covhelperrQsc !$e444A OA  E 8EIIKK86777wqzQ f  F v:D "T{{D!U4[[!y 71:  171:#7#7 II I>%((// :: !%q 6 6 6"" <  <:;; ; 99;; *%))++ *w!'!! mE599 f,,8CCECAGCag$)AM$)AM NAq64 ( ( 71:  171:#7#7 II I>".%"F"FGGNN   V  S !!A x  rSc|"|t|krtd||rd}nd}t||||\}}}|stj|j||z }tj|dt}tjdd5tjt|jdt| d|z } dddn #1swxYwYtj | | } ntj||j|z }tj|dt}tjdd5tjt|dt|j d|z } dddn #1swxYwYtj | | } | S) aA Estimate the covariance matrix. Except for the handling of missing data this function does the same as `numpy.cov`. For more details and examples, see `numpy.cov`. By default, masked values are recognized as such. If `x` and `y` have the same shape, a common mask is allocated: if ``x[i,j]`` is masked, then ``y[i,j]`` will also be masked. Setting `allow_masked` to False will raise an exception if values are missing in either of the input arrays. Parameters ---------- x : array_like A 1-D or 2-D array containing multiple variables and observations. Each row of `x` represents a variable, and each column a single observation of all those variables. Also see `rowvar` below. y : array_like, optional An additional set of variables and observations. `y` has the same shape as `x`. rowvar : bool, optional If `rowvar` is True (default), then each row represents a variable, with observations in the columns. Otherwise, the relationship is transposed: each column represents a variable, while the rows contain observations. bias : bool, optional Default normalization (False) is by ``(N-1)``, where ``N`` is the number of observations given (unbiased estimate). If `bias` is True, then normalization is by ``N``. This keyword can be overridden by the keyword ``ddof`` in numpy versions >= 1.5. allow_masked : bool, optional If True, masked values are propagated pair-wise: if a value is masked in `x`, the corresponding value is masked in `y`. If False, raises a `ValueError` exception when some values are missing. ddof : {None, int}, optional If not ``None`` normalization is by ``(N - ddof)``, where ``N`` is the number of observations; this overrides the value implied by ``bias``. The default value is ``None``. Raises ------ ValueError Raised if some values are missing and `allow_masked` is False. See Also -------- numpy.cov Examples -------- >>> import numpy as np >>> x = np.ma.array([[0, 1], [1, 1]], mask=[0, 1, 0, 1]) >>> y = np.ma.array([[1, 0], [0, 1]], mask=[0, 0, 1, 1]) >>> np.ma.cov(x, y) masked_array( data=[[--, --, --, --], [--, --, --, --], [--, --, --, --], [--, --, --, --]], mask=[[ True, True, True, True], [ True, True, True, True], [ True, True, True, True], [ True, True, True, True]], fill_value=1e+20, dtype=float64) Nzddof must be an integerr0r7rbignore)divideinvalidrZ)rArrQr\rT less_equalrerrstater?conjrur1squeeze) rrHrIbiasrJddofrNfactr[r|rs rQrr,sbL DCII--2333 |  DDD&q!V\BBQ&  5vhj(++d2}T1D111 [( ; ; ; F F6&a..&1*=*=>>ED F F F F F F F F F F F F F F F$T***2244vh ++d2}T1D111 [( ; ; ; F F6&A,,qsxxzz1(=(=>>ED F F F F F F F F F F F F F F F$T***2244 Ms&A C--C14C10A GG G ct||||} tjtj|}n##t$rtjcYSwxYw|tj||z}|S)an Return Pearson product-moment correlation coefficients. Except for the handling of missing data this function does the same as `numpy.corrcoef`. For more details and examples, see `numpy.corrcoef`. Parameters ---------- x : array_like A 1-D or 2-D array containing multiple variables and observations. Each row of `x` represents a variable, and each column a single observation of all those variables. Also see `rowvar` below. y : array_like, optional An additional set of variables and observations. `y` has the same shape as `x`. rowvar : bool, optional If `rowvar` is True (default), then each row represents a variable, with observations in the columns. Otherwise, the relationship is transposed: each column represents a variable, while the rows contain observations. allow_masked : bool, optional If True, masked values are propagated pair-wise: if a value is masked in `x`, the corresponding value is masked in `y`. If False, raises an exception. Because `bias` is deprecated, this argument needs to be treated as keyword only to avoid a warning. See Also -------- numpy.corrcoef : Equivalent function in top-level NumPy module. cov : Estimate the covariance matrix. Examples -------- >>> import numpy as np >>> x = np.ma.array([[0, 1], [1, 1]], mask=[0, 1, 0, 1]) >>> np.ma.corrcoef(x) masked_array( data=[[--, --], [--, --]], mask=[[ True, True], [ True, True]], fill_value=1e+20, dtype=float64) )rJ)rrusqrtdiagonalrMaskedConstantrouter)rrHrIrJcorrstds rQrrs` q!V, 7 7 7D#gbk$''(( ### """""#BK  c3 ' ''D Ks&<AAcVeZdZdZdZeeZefdZfdZ xZ S)MAxisConcatenatorz Translate slice objects to concatenation along an axis. For documentation on usage, see `mr_class`. See Also -------- mr_class rjct|jd}t||jS)NFrrZ)supermakematr|r1r[)clsrVr| __class__s rQrizMAxisConcatenator.makemats5 wwsxe44T))))rSct|trtdt|S)NzUnavailable for masked array.)rMstrr9rh __getitem__)selfkeyrks rQrnzMAxisConcatenator.__getitem__s< c3   ;9:: :ww""3'''rS) rp __module__rqrw __slots__ staticmethodr= classmethodrirn __classcell__)rks@rQrfrfs{  I,{++K****[*(((((((((rSrfceZdZdZdZdZdS)mr_classa~ Translate slice objects to concatenation along the first axis. This is the masked array version of `r_`. See Also -------- r_ Examples -------- >>> import numpy as np >>> np.ma.mr_[np.ma.array([1,2,3]), 0, 0, np.ma.array([4,5,6])] masked_array(data=[1, 2, 3, ..., 4, 5, 6], mask=False, fill_value=999999) rjc<t|ddS)Nr0)rf__init__)ros rQryzmr_class.__init__s""4+++++rSN)rprqrqrwrrryrjrSrQrwrws4$I,,,,,rSrwc#Kttj|t|jD]\}}|s|V |s|dt fV dS)a Multidimensional index iterator. Return an iterator yielding pairs of array coordinates and values, skipping elements that are masked. With `compressed=False`, `ma.masked` is yielded as the value of masked elements. This behavior differs from that of `numpy.ndenumerate`, which yields the value of the underlying data array. Notes ----- .. versionadded:: 1.23.0 Parameters ---------- a : array_like An array with (possibly) masked elements. compressed : bool, optional If True (default), masked elements are skipped. See Also -------- numpy.ndenumerate : Equivalent function ignoring any mask. Examples -------- >>> import numpy as np >>> a = np.ma.arange(9).reshape((3, 3)) >>> a[1, 0] = np.ma.masked >>> a[1, 2] = np.ma.masked >>> a[2, 1] = np.ma.masked >>> a masked_array( data=[[0, 1, 2], [--, 4, --], [6, --, 8]], mask=[[False, False, False], [ True, False, True], [False, True, False]], fill_value=999999) >>> for index, x in np.ma.ndenumerate(a): ... print(index, x) (0, 0) 0 (0, 1) 1 (0, 2) 2 (1, 1) 4 (2, 0) 6 (2, 2) 8 >>> for index, x in np.ma.ndenumerate(a, compressed=False): ... print(index, x) (0, 0) 0 (0, 1) 1 (0, 2) 2 (1, 0) -- (1, 1) 4 (1, 2) -- (2, 0) 6 (2, 1) -- (2, 2) 8 r0N)zipr\r$rCrrF)r` compresseditr[s rQr$r$ss|q))<??+?@@  D HHHH Q%-      rSct|}|tustj|stjd|jdz gStj|}t|dkr |ddgSdS)a Find the indices of the first and last unmasked values. Expects a 1-D `MaskedArray`, returns None if all values are masked. Parameters ---------- a : array_like Input 1-D `MaskedArray` Returns ------- edges : ndarray or None The indices of first and last non-masked value in the array. Returns None if all values are masked. See Also -------- flatnotmasked_contiguous, notmasked_contiguous, notmasked_edges clump_masked, clump_unmasked Notes ----- Only accepts 1-D arrays. Examples -------- >>> import numpy as np >>> a = np.ma.arange(10) >>> np.ma.flatnotmasked_edges(a) array([0, 9]) >>> mask = (a < 3) | (a > 8) | (a == 5) >>> a[mask] = np.ma.masked >>> np.array(a[~a.mask]) array([3, 4, 6, 7, 8]) >>> np.ma.flatnotmasked_edges(a) array([3, 8]) >>> a[:] = np.ma.masked >>> print(np.ma.flatnotmasked_edges(a)) None r0r7rN)rBrHr\rr1r flatnonzeror)r`rXunmaskeds rQrrMsu\  AF{{"&)){xAFQJ(((~qb!!H 8}}qB  trSct|} |jdkrt|St|}t t j|jt j|g|jztfdt|jDtfdt|jDgS)az Find the indices of the first and last unmasked values along an axis. If all values are masked, return None. Otherwise, return a list of two tuples, corresponding to the indices of the first and last unmasked values respectively. Parameters ---------- a : array_like The input array. axis : int, optional Axis along which to perform the operation. If None (default), applies to a flattened version of the array. Returns ------- edges : ndarray or list An array of start and end indexes if there are any masked data in the array. If there are no masked data in the array, `edges` is a list of the first and last index. See Also -------- flatnotmasked_contiguous, flatnotmasked_edges, notmasked_contiguous clump_masked, clump_unmasked Examples -------- >>> import numpy as np >>> a = np.arange(9).reshape((3, 3)) >>> m = np.zeros_like(a) >>> m[1:, 1:] = 1 >>> am = np.ma.array(a, mask=m) >>> np.array(am[~am.mask]) array([0, 1, 2, 3, 6]) >>> np.ma.notmasked_edges(am) array([0, 6]) Nr7rZc3rK|]1}|V2dSri)minr|rrrWrs rQrz"notmasked_edges..?GGA#a&**T""--//GGGGGGrSc3rK|]1}|V2dSri)rr|rs rQrz"notmasked_edges..rrS) r<rrrCr1r\indicesr^rNr)r`rWrXrs ` @rQr&r&sV  A |qv{{"1%%%QA  17##"*aS16\*B*B C C CC GGGGGqvGGG G G GGGGGqvGGG G G KKrScTt|}|turtd|jgSd}g}t j|D]N\}}tt|}|s&| t|||z||z }O|S)an Find contiguous unmasked data in a masked array. Parameters ---------- a : array_like The input array. Returns ------- slice_list : list A sorted sequence of `slice` objects (start index, end index). See Also -------- flatnotmasked_edges, notmasked_contiguous, notmasked_edges clump_masked, clump_unmasked Notes ----- Only accepts 2-D arrays at most. Examples -------- >>> import numpy as np >>> a = np.ma.arange(10) >>> np.ma.flatnotmasked_contiguous(a) [slice(0, 10, None)] >>> mask = (a < 3) | (a > 8) | (a == 5) >>> a[mask] = np.ma.masked >>> np.array(a[~a.mask]) array([3, 4, 6, 7, 8]) >>> np.ma.flatnotmasked_contiguous(a) [slice(3, 5, None), slice(6, 9, None)] >>> a[:] = np.ma.masked >>> np.ma.flatnotmasked_contiguous(a) [] r0) rBrHrr itertoolsgroupbyrrrOr)r`rXrrrgrs rQrrsT  AF{{a  !! A F#AGGII..A QLL + MM%1q5// * * * Q MrSc zt|}|j}|dkrtd||dkrt|Sg}|dzdz}ddg}t dd||<t |j|D]<}|||<|t|t|=|S)a Find contiguous unmasked data in a masked array along the given axis. Parameters ---------- a : array_like The input array. axis : int, optional Axis along which to perform the operation. If None (default), applies to a flattened version of the array, and this is the same as `flatnotmasked_contiguous`. Returns ------- endpoints : list A list of slices (start and end indexes) of unmasked indexes in the array. If the input is 2d and axis is specified, the result is a list of lists. See Also -------- flatnotmasked_edges, flatnotmasked_contiguous, notmasked_edges clump_masked, clump_unmasked Notes ----- Only accepts 2-D arrays at most. Examples -------- >>> import numpy as np >>> a = np.arange(12).reshape((3, 4)) >>> mask = np.zeros_like(a) >>> mask[1:, :-1] = 1; mask[0, 1] = 1; mask[-1, 0] = 0 >>> ma = np.ma.array(a, mask=mask) >>> ma masked_array( data=[[0, --, 2, 3], [--, --, --, 7], [8, --, --, 11]], mask=[[False, True, False, False], [ True, True, True, False], [False, True, True, False]], fill_value=999999) >>> np.array(ma[~ma.mask]) array([ 0, 2, 3, 7, 8, 11]) >>> np.ma.notmasked_contiguous(ma) [slice(0, 1, None), slice(2, 4, None), slice(7, 9, None), slice(11, 12, None)] >>> np.ma.notmasked_contiguous(ma, axis=0) [[slice(0, 1, None), slice(2, 3, None)], [], [slice(0, 1, None)], [slice(0, 3, None)]] >>> np.ma.notmasked_contiguous(ma, axis=1) [[slice(0, 1, None), slice(2, 4, None)], [slice(3, 4, None)], [slice(0, 1, None), slice(3, 4, None)]] rz&Currently limited to at most 2D array.Nr7r0) r<rrrrrr^rrN)r`rWrrotherrrs rQr%r%sv  A B Avv!"JKKK |rQww'*** F AXNE a&CdD!!CI 175> " "??E  .qs}==>>>> MrSc |jdkr|}|dd|ddz }|ddz}|drt|dkrt d|jgSt d|dg}|dt|ddd|dddDnAt|dkrgSdt|ddd|dddD}|dr.|t |d|j|S)zv Finds the clumps (groups of data with the same values) for a 1D bool array. Returns a series of slices. r7Nrr0c3<K|]\}}t||VdSrirrleftrights rQrz_ezclump..NsLBB!dEe$$BBBBBBrSrc4g|]\}}t||Srjrrs rQ z_ezclump..Ts& N N NKD%U4   N N NrS) rrr rrrextendr{r)r[rrs rQ_ezclumpr>sn  y1}}zz|| 8d3B3i  ( ( * *C a&1*C Aw O s88q==!TY''( ( 1c!f    BB%(Qr!Vc!$Q$i%@%@BBB C C C C s88q==I N N3s5Bq5z3qt!t93M3M N N N Bx, s2w **+++ HrSct|dt}|turtd|jgSt |S)a Return list of slices corresponding to the unmasked clumps of a 1-D array. (A "clump" is defined as a contiguous region of the array). Parameters ---------- a : ndarray A one-dimensional masked array. Returns ------- slices : list of slice The list of slices, one for each continuous region of unmasked elements in `a`. See Also -------- flatnotmasked_edges, flatnotmasked_contiguous, notmasked_edges notmasked_contiguous, clump_masked Examples -------- >>> import numpy as np >>> a = np.ma.masked_array(np.arange(10)) >>> a[[0, 1, 2, 6, 8, 9]] = np.ma.masked >>> np.ma.clump_unmasked(a) [slice(3, 6, None), slice(7, 8, None)] rer0)getattrrHrrrr`r[s rQr r [sA< 1gv & &D v~~a  !! TE??rSc^tj|}|turgSt|S)a Returns a list of slices corresponding to the masked clumps of a 1-D array. (A "clump" is defined as a contiguous region of the array). Parameters ---------- a : ndarray A one-dimensional masked array. Returns ------- slices : list of slice The list of slices, one for each continuous region of masked elements in `a`. See Also -------- flatnotmasked_edges, flatnotmasked_contiguous, notmasked_edges notmasked_contiguous, clump_unmasked Examples -------- >>> import numpy as np >>> a = np.ma.masked_array(np.arange(10)) >>> a[[0, 1, 2, 6, 8, 9]] = np.ma.masked >>> np.ma.clump_masked(a) [slice(0, 3, None), slice(6, 7, None), slice(8, 10, None)] )rurBrHrrs rQrrs+< :a==D v~~ D>>rScjtj||}t|}|turd||<|S)zD Masked values in the input array result in rows of zeros. r0)r\r.rBrH)rr_vanderrXs rQr.r.s5 i1ooG A NrSc t|}t|}t|}|jdkrt|t|}nZ|jdkr@tt |}|t urt||dddf}nt d|qt|}|jdkrt d|jd|jdkrt dt|t|}|t ur3|} ||| }tj || || |||||Stj |||||||S)zE Any masked values in x is propagated in y, and vice-versa. r7rNr0z Expected a 1D or 2D array for y!z expected a 1-d array for weightsz(expected w and y to have the same length) r<rBrrErrHrr^r\r') rrHdegrcondfullwrrXmynot_ms rQr'r's^  A A Av{{ Awqzz " " 1 Yq\\ " " V  2aaad8$$A:;;;} AJJ 6Q;;>?? ? 71: # #FGG G Awqzz " " =%Az!E(AeHc5$3GGGz!QUD!S999rSri)NNF)NNFF)NN)FF)F)NTT)NTFTN)T)NFNF)erw__all__rsrrnumpyr\r1rr2numpy.lib._function_base_implr3numpy.lib._index_tricks_implr4numpy.lib.array_utilsr5r6r8rur9r:r;r<r=r>rr?r@rArBrCrDrErFrGrHrIrJrKrRrr@r r!ryr~rrrrrr/r(rr rr+rrrrrfindrstriprrr"rr r rr rrrrr,rr*rrr-r)rQrrrfrwr#r$rr&rr%rr rr.rvr'rjrSrQrs   ++++++++222222999999LLLLLLLL23333333l": : : : z= = = H<,,,(% $R] 3 3 $ $R] 3 3 $ $R] 3 3 ((333  RY ' '""2?33  RY ' 'BH%%   * * ! !"+ . . OOOd.62& 081  # ( ( 1 11339688,.Obe[eeeeePK5K5K5K5\R R R R j7777t5%5%5%5%p$"$"$"N&"&"&"RV V V V rk0000fk////l####L////d))))B""""J,#,#,#,#^6666:9990@@@@D8!8!8!8!v\\\\~7777z(((((((((@,,,,, ,,,2hjjB B B B J555p1K1K1K1Kh444nKKKK\   :!!!H!!!R    RY.?? : : : :F"+bj0'/BBrS