§
    Ï! hRÙ  ã                  óH  — d dl mZ d dlmZmZmZmZmZ d dlZd dl	Z
d dlmZmZ d dlmZ d dlmZmZmZmZmZmZmZmZmZmZmZmZmZmZ d dl m!Z!m"Z" d dl#m$Z$ d d	l%m&Z& d d
l'm(Z( d dl)m*Z* d dl+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1 d dl2m3Z3 d dl4m5Z5m6Z6m7Z7m8Z8 d dl9m:Z;m<Z<mZm=Z=m>Z> d dl?m@Z@mAZAmBZBmCZCmDZD d dlEmFZFmGZG d dlHmIZI d dlJmKZK d dlLmMZM d dlNmOZO d dlPmQZRmSZSmTZT d dlUmVZV d dlWmXZX d dlYmZZZ er"d dl[m\Z\m]Z] d dl^m_Z_ d dl`maZa d dlmbZbmcZc d dl`mdZd d dlemfZg  G d „ d!eKeO¦  «        Zhd'd&„ZidS )(é    )Úannotations)ÚTYPE_CHECKINGÚAnyÚCallableÚLiteralÚoverloadN)ÚlibÚmissing)Úis_supported_dtype)Ú	ArrayLikeÚ	AstypeArgÚAxisIntÚDtypeObjÚFillnaOptionsÚInterpolateOptionsÚNpDtypeÚPositionalIndexerÚScalarÚScalarIndexerÚSelfÚSequenceIndexerÚShapeÚnpt)ÚIS64Úis_platform_windows©ÚAbstractMethodError)Údoc)Úvalidate_fillna_kwargs)ÚExtensionDtype)Úis_boolÚis_integer_dtypeÚis_list_likeÚ	is_scalarÚis_string_dtypeÚpandas_dtype)ÚBaseMaskedDtype)Úarray_equivalentÚis_valid_na_for_dtypeÚisnaÚnotna)Ú
algorithmsÚ	arrayliker
   ÚnanopsÚops)Úfactorize_arrayÚisinÚ	map_arrayÚmodeÚtake)Úmasked_accumulationsÚmasked_reductions)Úquantile_with_mask)ÚOpsMixin)Úto_numpy_dtype_inference)ÚExtensionArray)ÚarrayÚensure_wrapped_if_datetimelikeÚextract_array)Úcheck_array_indexer)Úinvalid_comparison)Ú
hash_array)ÚIteratorÚSequence)ÚSeries©ÚBooleanArray)ÚNumpySorterÚNumpyValueArrayLike©ÚFloatingArray)Úfunctionc                  óî  ‡ — e Zd ZU dZded<   ded<   ded<   eZeZedÁd„¦   «         Z		 dÂdÃd„Z
edddœdÄd„¦   «         Ze eej        ¦  «        dÅd„¦   «         ¦   «         ZdÂdÆd„ZedÇd„¦   «         ZedÈd"„¦   «         ZedÉd$„¦   «         ZdÊd'„Zddd(d)œdËd0„Z eej        ¦  «        	 dÌdÍd1„¦   «         Zedd2œdÎd5„¦   «         Zd6„ ZdÏd7„ZdÐˆ fd8„ZdÑd:„ZdÒd<„ZedÓd=„¦   «         ZedÒd>„¦   «         ZdÔd?„ZdÕdÖdC„ZdÔdD„Z dÔdE„Z!edÔdF„¦   «         Z"dÕd×dH„Z#dÔdI„Z$dÔdJ„Z%dÔdK„Z&dÔdL„Z'dØdM„Z(dde)j*        fdÙdQ„Z+ eej,        ¦  «        dR„ ¦   «         Z,edÚdÛdU„¦   «         Z-edÚdÜdW„¦   «         Z-edÚdÝdZ„¦   «         Z-dÞdÝd[„Z-d\Z.	 dßdàd_„Z/d`eda<   dáde„Z0dâdf„Z1edÐdg„¦   «         Z2dãdi„Z3dj„ Z4e4Z5dädl„Z6dådo„Z7dØdp„Z8edq„ ¦   «         Z9edÒdr„¦   «         Z:e	 dÕdædu„¦   «         Z;dçdz„Z<ddd@d{œdèd„Z=déd€„Z>dÔd�„Z? eej@        ¦  «        	 dêdëd…„¦   «         Z@dÔd†„ZA eejB        ¦  «        	 	 dìdíd�„¦   «         ZB eejC        ¦  «        	 dÞdîd’„¦   «         ZC eejD        ¦  «        dØd“„¦   «         ZDdÞdïd–„ZEdÞdðd—„ZF eejG        ¦  «        dÐd˜„¦   «         ZGdñdœ„ZHd(dd�œdòd¡„ZIdód¢„ZJd£„ ZKdód¤„ZLd(d@d@d¥œdôd¨„ZMd(d@d@d¥œdôd©„ZNd(d@dªœdõd«„ZOd(d@d¬d­œdöd¯„ZPd(d@d¬d­œdöd°„ZQd(d@dªœdõd±„ZRd(d@dªœdõd²„ZSdâd³„ZTd(d@dªœdõd´„ZUd(d@dªœdõdµ„ZVd÷d¸„ZWd(d¹œdødº„ZXdùdÀ„ZYˆ xZZS )úÚBaseMaskedArrayzf
    Base class for masked arrays (which use _data and _mask to store the data).

    numpy based
    r   Ú_internal_fill_valueú
np.ndarrayÚ_dataúnpt.NDArray[np.bool_]Ú_maskÚvaluesÚmaskÚreturnr   c                óV   — t                                | ¦  «        }||_        ||_        |S ©N)rL   Ú__new__rO   rQ   )ÚclsrR   rS   Úresults       úSc:\xampp_lite_8_4\www\timesheet\venv\Lib\site-packages\pandas/core/arrays/masked.pyÚ_simple_newzBaseMaskedArray._simple_new|   s(   € å ×(Ò(¨Ñ-Ô-ˆØˆŒØˆŒØˆó    FÚcopyÚboolÚNonec                ó0  — t          |t          j        ¦  «        r|j        t          j        k    st          d¦  «        ‚|j        |j        k    rt          d¦  «        ‚|r(|                     ¦   «         }|                     ¦   «         }|| _	        || _
        d S )NzGmask should be boolean numpy array. Use the 'pd.array' function insteadz"values.shape must match mask.shape)Ú
isinstanceÚnpÚndarrayÚdtypeÚbool_Ú	TypeErrorÚshapeÚ
ValueErrorr]   rO   rQ   )ÚselfrR   rS   r]   s       rZ   Ú__init__zBaseMaskedArray.__init__ƒ   s‘   € õ ˜4¥¤Ñ,Ô,ð 	°´½r¼xÒ1GÐ1GÝð2ñô ð ð Œ<˜4œ:Ò%Ð%ÝÐAÑBÔBÐBàð 	Ø—[’[‘]”]ˆFØ—9’9‘;”;ˆDàˆŒ
ØˆŒ
ˆ
ˆ
r\   N©rd   r]   c               óP   — |                       |||¬¦  «        \  }} | ||¦  «        S )Nrk   )Ú_coerce_to_array)rX   Úscalarsrd   r]   rR   rS   s         rZ   Ú_from_sequencezBaseMaskedArray._from_sequence–   s2   € à×+Ò+¨G¸5ÀtÐ+ÑLÔL‰ˆ�Øˆs�6˜4Ñ Ô Ð r\   rg   r   rd   r    c                ó  — t          j        ||j        ¬¦  «        }|                     | j        ¦  «         t          j        |t          ¬¦  «        } | ||¦  «        }t          || ¦  «        r||j        k    rt          d|› d�¦  «        ‚|S )N©rd   z5Default 'empty' implementation is invalid for dtype='ú')
rb   ÚemptyÚtypeÚfillrM   Úonesr^   ra   rd   ÚNotImplementedError)rX   rg   rd   rR   rS   rY   s         rZ   Ú_emptyzBaseMaskedArray._empty›   s™   € õ ”˜% u¤zÐ2Ñ2Ô2ˆØ�Š�CÔ,Ñ-Ô-Ð-ÝŒw�u¥DÐ)Ñ)Ô)ˆØ��V˜TÑ"Ô"ˆÝ˜& #Ñ&Ô&ð 	¨%°6´<Ò*?Ð*?Ý%ØPÈÐPÐPÐPñô ð ð ˆr\   ÚboxedúCallable[[Any], str | None]c                ó   — t           S rV   )Ústr)ri   ry   s     rZ   Ú
_formatterzBaseMaskedArray._formatter¨   s   € åˆ
r\   r'   c                ó    — t          | ¦  «        ‚rV   r   ©ri   s    rZ   rd   zBaseMaskedArray.dtype¬   s   € å! $Ñ'Ô'Ð'r\   Úitemr   r   c                ó   — d S rV   © ©ri   r€   s     rZ   Ú__getitem__zBaseMaskedArray.__getitem__°   ó   € àˆr\   r   c                ó   — d S rV   r‚   rƒ   s     rZ   r„   zBaseMaskedArray.__getitem__´   r…   r\   r   ú
Self | Anyc                óÒ   — t          | |¦  «        }| j        |         }t          |¦  «        r|r| j        j        S | j        |         S |                      | j        |         |¦  «        S rV   )r>   rQ   r!   rd   Úna_valuerO   r[   )ri   r€   Únewmasks      rZ   r„   zBaseMaskedArray.__getitem__¸   sj   € Ý" 4¨Ñ.Ô.ˆà”*˜TÔ"ˆÝ�7ÑÔð 	$àð +Ø”zÔ*Ð*Ø”:˜dÔ#Ð#à×Ò ¤
¨4Ô 0°'Ñ:Ô:Ð:r\   T)ÚlimitÚ
limit_arear]   Úmethodr   r‹   ú
int | NonerŒ   ú#Literal['inside', 'outside'] | Nonec               óH  — | j         }|                     ¦   «         �rlt          j        || j        ¬¦  «        }| j        j        }|j        }|r)|                     ¦   «         }|                     ¦   «         }n|�|                     ¦   «         } ||||¬¦  «         |�É|                     ¦   «         sµ|j        }| }	|	 	                    ¦   «         }
t          |	¦  «        |	d d d…          	                    ¦   «         z
  dz
  }|dk    r;|d |
…xx         |d |
…         z  cc<   ||dz   d …xx         ||dz   d …         z  cc<   n&|dk    r ||
dz   |…xx         ||
dz   |…         z  cc<   |r |                      |j        |j        ¦  «        S | S |r|                      ¦   «         }n| }|S )N©Úndim©r‹   rS   éÿÿÿÿé   ÚinsideÚoutside)rQ   Úanyr
   Úget_fill_funcr’   rO   ÚTr]   ÚallÚargmaxÚlenr[   )ri   r�   r‹   rŒ   r]   rS   ÚfuncÚnpvaluesÚnew_maskÚneg_maskÚfirstÚlastÚ
new_valuess                rZ   Ú_pad_or_backfillz BaseMaskedArray._pad_or_backfillÄ   sÙ  € ð Œzˆà�8Š8‰:Œ:ñ 	"ÝÔ(¨°d´iÐ@Ñ@Ô@ˆDà”z”|ˆHØ”vˆHØð #Ø#Ÿ=š=™?œ?�Ø#Ÿ=š=™?œ?��ØÐ'Ø—y’y‘{”{�ØˆD� ¨XÐ6Ñ6Ô6Ð6àÐ%¨d¯hªh©j¬jÐ%Ø”v�Ø ˜5�Ø ŸšÑ)Ô)�Ý˜8‘}”} x°°°"°¤~×'<Ò'<Ñ'>Ô'>Ñ>ÀÑB�Ø Ò)Ð)Ø˜V˜e˜VÐ$Ð$Ô$¨¨V¨e¨V¬Ñ4Ð$Ð$Ñ$Ø˜T A™X˜Z˜ZÐ(Ð(Ô(¨D°¸±°°Ô,<Ñ<Ð(Ð(Ñ(Ð(Ø 9Ò,Ð,Ø˜U Q™Y¨Ð-Ð.Ð.Ô.°$°u¸q±yÀ4Ð7GÔ2HÑHÐ.Ð.Ñ.àð Ø×'Ò'¨¬
°H´JÑ?Ô?Ð?à�àð "Ø!ŸYšY™[œ[�
�
à!�
ØÐr\   c                óH  — t          ||¦  «        \  }}| j        }t          j        ||t	          | ¦  «        ¦  «        }|                     ¦   «         r¯|�†t          j        || j        ¬¦  «        }| j        j	        }|j	        }|r(| 
                    ¦   «         }| 
                    ¦   «         } ||||¬¦  «         |                      |j	        |j	        ¦  «        S |r|  
                    ¦   «         }	n
| d d …         }	||	|<   n!|r|  
                    ¦   «         }	n
| d d …         }	|	S )Nr‘   r“   )r   rQ   r
   Úcheck_value_sizer�   r˜   r™   r’   rO   rš   r]   r[   )
ri   Úvaluer�   r‹   r]   rS   rž   rŸ   r    r¤   s
             rZ   ÚfillnazBaseMaskedArray.fillnað   s%  € õ /¨u°fÑ=Ô=‰ˆˆvàŒzˆåÔ(¨°µc¸$±i´iÑ@Ô@ˆà�8Š8‰:Œ:ð 	%ØÐ!ÝÔ,¨V¸$¼)ÐDÑDÔD�Øœ:œ<�Øœ6�Øð /Ø'Ÿ}š}™œ�HØ'Ÿ}š}™œ�HØ��X U°Ð:Ñ:Ô:Ð:Ø×'Ò'¨¬
°H´JÑ?Ô?Ð?ð ð )Ø!%§¢¡¤�J�Jà!% a a a¤�JØ#(�
˜4Ñ Ð àð %Ø!ŸYšY™[œ[�
�
à! ! ! !œW�
ØÐr\   ©r]   r   útuple[np.ndarray, np.ndarray]c               ó    — t          | ¦  «        ‚rV   r   )rX   rR   rd   r]   s       rZ   rm   z BaseMaskedArray._coerce_to_array  s   € õ " #Ñ&Ô&Ð&r\   c                ó€  — | j         j        }|dk    rt          j        |¦  «        r|S no|dk    r+t          j        |¦  «        st          j        |¦  «        r|S n>t          j        |¦  «        s(t          j        |¦  «        r|                     ¦   «         r|S t          dt          |¦  «        › d| j         › �¦  «        ‚)zy
        Check if we have a scalar that we can cast losslessly.

        Raises
        ------
        TypeError
        ÚbÚfzInvalid value 'z' for dtype )rd   Úkindr	   r!   Ú
is_integerÚis_floatrf   r|   )ri   r¨   r°   s      rZ   Ú_validate_setitem_valuez'BaseMaskedArray._validate_setitem_value  sÐ   € ð ŒzŒˆà�3Š;ˆ;ÝŒ{˜5Ñ!Ô!ð Ø�ðð �SŠ[ˆ[ÝŒ~˜eÑ$Ô$ð ­¬°UÑ(;Ô(;ð Ø�ðõ Œ~˜eÑ$Ô$ð ­¬°eÑ)<Ô)<ð À×AQÒAQÑASÔASð Ø�õ
 ÐN­#¨e©*¬*ÐNÐNÀ$Ä*ÐNÐNÑOÔOÐOr\   c                ó@  — t          | |¦  «        }t          |¦  «        rKt          || j        ¦  «        rd| j        |<   n)|                      |¦  «        }|| j        |<   d| j        |<   d S |                      || j        ¬¦  «        \  }}|| j        |<   || j        |<   d S )NTFrq   )r>   r$   r)   rd   rQ   r³   rO   rm   )ri   Úkeyr¨   rS   s       rZ   Ú__setitem__zBaseMaskedArray.__setitem__3  s¨   € Ý! $¨Ñ,Ô,ˆå�UÑÔð 	Ý$ U¨D¬JÑ7Ô7ð (Ø"&�”
˜3‘�à×4Ò4°UÑ;Ô;�Ø"'�”
˜3‘Ø"'�”
˜3‘ØˆFà×+Ò+¨E¸¼Ð+ÑDÔD‰ˆˆtàˆŒ
�3‰ØˆŒ
�3‰ˆˆr\   c                ón  •— t          |¦  «        rx|| j        j        urj| j        j        j        dk    rUt          j        |¦  «        rAt          t          j	        | j        ¦  «        | j
         z                       ¦   «         ¦  «        S t          t          ¦   «                              |¦  «        ¦  «        S )Nr¯   )r*   rd   r‰   rO   r°   r	   r²   r^   rb   ÚisnanrQ   r˜   ÚsuperÚ__contains__)ri   rµ   Ú	__class__s     €rZ   rº   zBaseMaskedArray.__contains__D  s’   ø€ Ý�‰9Œ9ð 	H˜ D¤JÔ$7Ð7Ð7àŒzÔÔ$¨Ò+Ð+µ´¸SÑ0AÔ0AÐ+Ý�RœX d¤jÑ1Ô1°T´Z°KÑ?×DÒDÑFÔFÑGÔGÐGå•E‘G”G×(Ò(¨Ñ-Ô-Ñ.Ô.Ð.r\   rA   c              #  ó  K  — | j         dk    rP| j        s| j        D ]}|V — Œd S | j        j        }t          | j        | j        ¦  «        D ]\  }}|r|V — Œ|V — Œd S t          t          | ¦  «        ¦  «        D ]}| |         V — Œd S )Nr•   )	r’   Ú_hasnarO   rd   r‰   ÚziprQ   Úranger�   )ri   Úvalr‰   Úisna_Úis        rZ   Ú__iter__zBaseMaskedArray.__iter__L  sÎ   è è € ØŒ9˜Š>ˆ>Ø”;ð 	"Øœ:ð ð �CØ�I�I�I�Iðð ð  œ:Ô.�Ý"% d¤j°$´*Ñ"=Ô"=ð "ð "‘J�E˜3Øð "Ø&˜˜˜˜à!˜	˜	˜	˜	ð	"ð "õ �3˜t™9œ9Ñ%Ô%ð ð �Ø˜1”g����ðð r\   Úintc                ó*   — t          | j        ¦  «        S rV   )r�   rO   r   s    rZ   Ú__len__zBaseMaskedArray.__len__\  s   € Ý�4”:‰ŒÐr\   c                ó   — | j         j        S rV   )rO   rg   r   s    rZ   rg   zBaseMaskedArray.shape_  s   € àŒzÔÐr\   c                ó   — | j         j        S rV   )rO   r’   r   s    rZ   r’   zBaseMaskedArray.ndimc  s   € àŒzŒÐr\   c                óš   — | j                              ||¦  «        }| j                             ||¦  «        }|                      ||¦  «        S rV   )rO   ÚswapaxesrQ   r[   )ri   Úaxis1Úaxis2ÚdatarS   s        rZ   rÊ   zBaseMaskedArray.swapaxesg  sF   € ØŒz×"Ò" 5¨%Ñ0Ô0ˆØŒz×"Ò" 5¨%Ñ0Ô0ˆØ×Ò  dÑ+Ô+Ð+r\   r   Úaxisr   c                óž   — t          j        | j        ||¬¦  «        }t          j        | j        ||¬¦  «        }|                      ||¦  «        S ©N©rÎ   )rb   ÚdeleterO   rQ   r[   )ri   ÚlocrÎ   rÍ   rS   s        rZ   rÒ   zBaseMaskedArray.deletel  sH   € ÝŒy˜œ S¨tÐ4Ñ4Ô4ˆÝŒy˜œ S¨tÐ4Ñ4Ô4ˆØ×Ò  dÑ+Ô+Ð+r\   c                óv   —  | j         j        |i |¤Ž} | j        j        |i |¤Ž}|                      ||¦  «        S rV   )rO   ÚreshaperQ   r[   ©ri   ÚargsÚkwargsrÍ   rS   s        rZ   rÕ   zBaseMaskedArray.reshapeq  sJ   € Ø!ˆtŒzÔ! 4Ð2¨6Ð2Ð2ˆØ!ˆtŒzÔ! 4Ð2¨6Ð2Ð2ˆØ×Ò  dÑ+Ô+Ð+r\   c                ó|   —  | j         j        |i |¤Ž} | j        j        |i |¤Ž} t          | ¦  «        ||¦  «        S rV   )rO   ÚravelrQ   rt   rÖ   s        rZ   rÚ   zBaseMaskedArray.ravelv  sL   € àˆtŒzÔ Ð0¨Ð0Ð0ˆØˆtŒzÔ Ð0¨Ð0Ð0ˆØ�t�D‰zŒz˜$ Ñ%Ô%Ð%r\   c                óV   — |                       | j        j        | j        j        ¦  «        S rV   )r[   rO   rš   rQ   r   s    rZ   rš   zBaseMaskedArray.T|  s    € à×Ò ¤
¤¨d¬j¬lÑ;Ô;Ð;r\   Údecimalsc                óÜ   — | j         j        dk    r| S t          j        ||¦  «         t	          j        | j        fd|i|¤Ž}|                      || j         	                    ¦   «         ¦  «        S )aó  
        Round each value in the array a to the given number of decimals.

        Parameters
        ----------
        decimals : int, default 0
            Number of decimal places to round to. If decimals is negative,
            it specifies the number of positions to the left of the decimal point.
        *args, **kwargs
            Additional arguments and keywords have no effect but might be
            accepted for compatibility with NumPy.

        Returns
        -------
        NumericArray
            Rounded values of the NumericArray.

        See Also
        --------
        numpy.around : Round values of an np.array.
        DataFrame.round : Round values of a DataFrame.
        Series.round : Round values of a Series.
        r®   rÜ   )
rd   r°   ÚnvÚvalidate_roundrb   ÚroundrO   Ú_maybe_mask_resultrQ   r]   )ri   rÜ   r×   rØ   rR   s        rZ   rà   zBaseMaskedArray.round€  sm   € ð0 Œ:Œ?˜cÒ!Ð!ØˆKÝ
Ô˜$ Ñ'Ô'Ð'Ý”˜$œ*ÐBÐB¨xÐB¸6ÐBÐBˆð ×&Ò& v¨t¬z¯ªÑ/@Ô/@ÑAÔAÐAr\   c                óh   — |                       | j         | j                             ¦   «         ¦  «        S rV   ©r[   rO   rQ   r]   r   s    rZ   Ú
__invert__zBaseMaskedArray.__invert__£  ó(   € Ø×Ò ¤ ¨T¬Z¯_ª_Ñ->Ô->Ñ?Ô?Ð?r\   c                óh   — |                       | j         | j                             ¦   «         ¦  «        S rV   rã   r   s    rZ   Ú__neg__zBaseMaskedArray.__neg__¦  rå   r\   c                ó*   — |                       ¦   «         S rV   rª   r   s    rZ   Ú__pos__zBaseMaskedArray.__pos__©  s   € Ø�yŠy‰{Œ{Ðr\   c                ó€   — |                       t          | j        ¦  «        | j                             ¦   «         ¦  «        S rV   )r[   ÚabsrO   rQ   r]   r   s    rZ   Ú__abs__zBaseMaskedArray.__abs__¬  s,   € Ø×Ò¥ D¤J¡¤°´·²Ñ1BÔ1BÑCÔCÐCr\   c                ó8   — t          j        | t          ¬¦  «        S )Nrq   )rb   ÚasarrayÚobjectr   s    rZ   Ú_values_for_jsonz BaseMaskedArray._values_for_json±  s   € ÝŒz˜$¥fÐ-Ñ-Ô-Ð-r\   únpt.DTypeLike | Noner‰   rï   c                ód  — | j         }t          | |||¦  «        \  }}|€t          }|r¦|t          k    r0t          |¦  «        s!|t          j        u rt          d|› d�¦  «        ‚t          j        ¦   «         5  t          j	        dt          ¬¦  «         | j                             |¦  «        }ddd¦  «         n# 1 swxY w Y   ||| j        <   nbt          j        ¦   «         5  t          j	        dt          ¬¦  «         | j                             ||¬¦  «        }ddd¦  «         n# 1 swxY w Y   |S )aF  
        Convert to a NumPy Array.

        By default converts to an object-dtype NumPy array. Specify the `dtype` and
        `na_value` keywords to customize the conversion.

        Parameters
        ----------
        dtype : dtype, default object
            The numpy dtype to convert to.
        copy : bool, default False
            Whether to ensure that the returned value is a not a view on
            the array. Note that ``copy=False`` does not *ensure* that
            ``to_numpy()`` is no-copy. Rather, ``copy=True`` ensure that
            a copy is made, even if not strictly necessary. This is typically
            only possible when no missing values are present and `dtype`
            is the equivalent numpy dtype.
        na_value : scalar, optional
             Scalar missing value indicator to use in numpy array. Defaults
             to the native missing value indicator of this array (pd.NA).

        Returns
        -------
        numpy.ndarray

        Examples
        --------
        An object-dtype is the default result

        >>> a = pd.array([True, False, pd.NA], dtype="boolean")
        >>> a.to_numpy()
        array([True, False, <NA>], dtype=object)

        When no missing values are present, an equivalent dtype can be used.

        >>> pd.array([True, False], dtype="boolean").to_numpy(dtype="bool")
        array([ True, False])
        >>> pd.array([1, 2], dtype="Int64").to_numpy("int64")
        array([1, 2])

        However, requesting such dtype will raise a ValueError if
        missing values are present and the default missing value :attr:`NA`
        is used.

        >>> a = pd.array([True, False, pd.NA], dtype="boolean")
        >>> a
        <BooleanArray>
        [True, False, <NA>]
        Length: 3, dtype: boolean

        >>> a.to_numpy(dtype="bool")
        Traceback (most recent call last):
        ...
        ValueError: cannot convert to bool numpy array in presence of missing values

        Specify a valid `na_value` instead

        >>> a.to_numpy(dtype="bool", na_value=False)
        array([ True, False, False])
        Nzcannot convert to 'zZ'-dtype NumPy array with missing values. Specify an appropriate 'na_value' for this dtype.Úignore©Úcategoryrª   )r½   r9   rï   r%   Ú
libmissingÚNArh   ÚwarningsÚcatch_warningsÚfilterwarningsÚRuntimeWarningrO   ÚastyperQ   )ri   rd   r]   r‰   ÚhasnarÍ   s         rZ   Úto_numpyzBaseMaskedArray.to_numpy´  sÀ  € ðD ”ˆÝ2°4¸ÀÈ%ÑPÔP‰ˆˆxØˆ=ÝˆEàð 	;à�’�Ý'¨Ñ.Ô.ð  à¥
¤Ð-Ð-å ð&¨%ð &ð &ð &ñô ð õ Ô(Ñ*Ô*ð 0ð 0ÝÔ'¨½>ÐJÑJÔJÐJØ”z×(Ò(¨Ñ/Ô/�ð0ð 0ð 0ñ 0ô 0ð 0ð 0ð 0ð 0ð 0ð 0øøøð 0ð 0ð 0ð 0ð  (ˆD�”ÑÐåÔ(Ñ*Ô*ð ;ð ;ÝÔ'¨½>ÐJÑJÔJÐJØ”z×(Ò(¨°TÐ(Ñ:Ô:�ð;ð ;ð ;ñ ;ô ;ð ;ð ;ð ;ð ;ð ;ð ;øøøð ;ð ;ð ;ð ;ð ˆs$   Á66B8Â8B<Â?B<Ã!8D%Ä%D)Ä,D)c                óÀ   — | j         dk    rd„ | D ¦   «         S | j        rd n| j        j        }|                      |t
          j        ¬¦  «                             ¦   «         S )Nr•   c                ó6   — g | ]}|                      ¦   «         ‘ŒS r‚   )Útolist©Ú.0Úxs     rZ   ú
<listcomp>z*BaseMaskedArray.tolist.<locals>.<listcomp>  s    € Ð-Ð-Ð- 1�A—H’H‘J”JÐ-Ð-Ð-r\   ©rd   r‰   )r’   r½   rO   rd   rþ   rö   r÷   r  )ri   rd   s     rZ   r  zBaseMaskedArray.tolist  sZ   € àŒ9�qŠ=ˆ=Ø-Ð-¨Ð-Ñ-Ô-Ð-ØœÐ9��¨¬Ô)9ˆØ�}Š} 5µ:´=ˆ}ÑAÔA×HÒHÑJÔJÐJr\   .únpt.DTypeLikec                ó   — d S rV   r‚   ©ri   rd   r]   s      rZ   rü   zBaseMaskedArray.astype  r…   r\   r:   c                ó   — d S rV   r‚   r	  s      rZ   rü   zBaseMaskedArray.astype  r…   r\   r   r   c                ó   — d S rV   r‚   r	  s      rZ   rü   zBaseMaskedArray.astype   r…   r\   c                ó²  — t          |¦  «        }|| j        k    r|r|                      ¦   «         S | S t          |t          ¦  «        r²t          j        ¦   «         5  t          j        dt          ¬¦  «         | j	         
                    |j        |¬¦  «        }d d d ¦  «         n# 1 swxY w Y   || j	        u r| j        n| j                             ¦   «         }|                     ¦   «         } |||d¬¦  «        S t          |t          ¦  «        r,|                     ¦   «         }|                     | ||¬¦  «        S |j        dk    rt"          j        }n,|j        dk    rt#          j        d¦  «        }nt(          j        }|j        d	v r| j        rt/          d
¦  «        ‚|j        dk    r| j        rt/          d¦  «        ‚|                      |||¬¦  «        }|S )Nró   rô   rª   Frk   r¯   ÚMÚNaTÚiuzcannot convert NA to integerr®   z cannot convert float NaN to bool)rd   r‰   r]   )r&   rd   r]   ra   r'   rø   rù   rú   rû   rO   rü   Únumpy_dtyperQ   Úconstruct_array_typer    ro   r°   rb   ÚnanÚ
datetime64r	   Ú
no_defaultr½   rh   rþ   )ri   rd   r]   rÍ   rS   rX   Úeaclsr‰   s           rZ   rü   zBaseMaskedArray.astype$  s   € Ý˜UÑ#Ô#ˆà�D”JÒÐØð #Ø—y’y‘{”{Ð"ØˆKõ �e�_Ñ-Ô-ð 
	/åÔ(Ñ*Ô*ð Gð GÝÔ'¨½>ÐJÑJÔJÐJà”z×(Ò(¨Ô):ÀÐ(ÑFÔF�ðGð Gð Gñ Gô Gð Gð Gð Gð Gð Gð Gøøøð Gð Gð Gð Gð "&¨¬Ð!3Ð!3�4”:�:¸¼¿ºÑ9JÔ9JˆDØ×,Ò,Ñ.Ô.ˆCØ�3�t˜T¨Ð.Ñ.Ô.Ð.å�e�^Ñ,Ô,ð 	FØ×.Ò.Ñ0Ô0ˆEØ×'Ò'¨°EÀÐ'ÑEÔEÐEð
 Œ:˜ÒÐå”vˆHˆHØŒZ˜3ÒÐÝ”} UÑ+Ô+ˆHˆHå”~ˆHð Œ:˜ÐÐ $¤+ÐÝÐ;Ñ<Ô<Ð<ØŒ:˜ÒÐ ¤ÐåÐ?Ñ@Ô@Ð@à�}Š} 5°8À$ˆ}ÑGÔGˆØˆs   Á=B$Â$B(Â+B(iè  úNpDtype | Noneúbool | Nonec                ó.   — |                       |¬¦  «        S )z|
        the array interface, return my values
        We return an object array here to preserve our scalar values
        rq   )rþ   r	  s      rZ   Ú	__array__zBaseMaskedArray.__array__T  s   € ð �}Š} 5ˆ}Ñ)Ô)Ð)r\   ztuple[type, ...]Ú_HANDLED_TYPESÚufuncúnp.ufuncr|   c                ó@  ‡	‡
— |                      dd¦  «        }||z   D ])}t          || j        t          fz   ¦  «        s	t          c S Œ*t          j        | ||g|¢R i |¤Ž}|t          ur|S d|v rt          j        | ||g|¢R i |¤ŽS |dk    r"t          j        | ||g|¢R i |¤Ž}|t          ur|S t          j
        t          | ¦  «        t          ¬¦  «        Š	g }|D ]Q}t          |t          ¦  «        r%‰	|j        z  Š	|                     |j        ¦  «         Œ<|                     |¦  «         ŒRd
ˆ	fd„Š
 t!          ||¦  «        |i |¤Ž}|j        dk    rt%          ˆ
fd	„|D ¦   «         ¦  «        S |dk    r"| j                             ¦   «         r| j        S |S  ‰
|¦  «        S )NÚoutr‚   Úreducerq   r  rN   c                ó¾  •— ddl m}m}m} | j        j        dk    r ‰                     ¦   «         } || |¦  «        S | j        j        dv r ‰                     ¦   «         } || |¦  «        S | j        j        dk    rT‰                     ¦   «         }| j        t          j        k    r|  	                    t          j
        ¦  «        }  || |¦  «        S t          j        | ‰<   | S )Nr   )rE   rI   ÚIntegerArrayr®   r  r¯   )Úpandas.core.arraysrE   rI   r!  rd   r°   r]   rb   Úfloat16rü   Úfloat32r  )r  rE   rI   r!  ÚmrS   s        €rZ   Úreconstructz4BaseMaskedArray.__array_ufunc__.<locals>.reconstruct†  sõ   ø€ ðð ð ð ð ð ð ð ð ð ð ŒwŒ|˜sÒ"Ð"Ø—I’I‘K”K�Ø#�| A qÑ)Ô)Ð)Ø”” Ð%Ð%Ø—I’I‘K”K�Ø#�| A qÑ)Ô)Ð)Ø”” Ò$Ð$Ø—I’I‘K”K�Ø”7�bœjÒ(Ð(ð Ÿš¥¤Ñ,Ô,�AØ$�} Q¨Ñ*Ô*Ð*åœ&��$‘ØˆHr\   r•   c              3  ó.   •K  — | ]} ‰|¦  «        V — Œd S rV   r‚   )r  r  r&  s     €rZ   ú	<genexpr>z2BaseMaskedArray.__array_ufunc__.<locals>.<genexpr>£  s+   øè è € Ð8Ð8¨A˜˜ Q™œÐ8Ð8Ð8Ð8Ð8Ð8r\   )r  rN   )Úgetra   r  rL   ÚNotImplementedr-   Ú!maybe_dispatch_ufunc_to_dunder_opÚdispatch_ufunc_with_outÚdispatch_reduction_ufuncrb   Úzerosr�   r^   rQ   ÚappendrO   ÚgetattrÚnoutÚtupler˜   Ú	_na_value)ri   r  r�   ÚinputsrØ   r  r  rY   Úinputs2rS   r&  s            @@rZ   Ú__array_ufunc__zBaseMaskedArray.__array_ufunc___  sQ  øø€ ð �jŠj˜ Ñ#Ô#ˆà˜#‘ð 	&ð 	&ˆAÝ˜a Ô!4½Ð7IÑ!IÑJÔJð &Ý%Ð%Ð%Ð%ð&õ Ô<Ø�%˜ð
Ø"(ð
ð 
ð 
Ø,2ð
ð 
ˆð �Ð'Ð'ØˆMà�Fˆ?ˆ?åÔ4Ø�e˜VðØ&,ðð ð Ø06ðð ð ð �XÒÐÝÔ7Ø�e˜VðØ&,ðð ð Ø06ðð ˆFð �^Ð+Ð+Ø�åŒx�˜D™	œ	­Ð.Ñ.Ô.ˆØˆØð 	"ð 	"ˆAÝ˜!�_Ñ-Ô-ð "Ø˜œ‘�Ø—’˜qœwÑ'Ô'Ð'Ð'à—’˜qÑ!Ô!Ð!Ð!ð	ð 	ð 	ð 	ð 	ð 	ð4 (•˜ Ñ'Ô'¨Ð;°FÐ;Ð;ˆØŒ:˜Š>ˆ>åÐ8Ð8Ð8Ð8°Ð8Ñ8Ô8Ñ8Ô8Ð8Ø�xÒÐàŒz�~Š~ÑÔð &Ø”~Ð%ØˆMà�;˜vÑ&Ô&Ð&r\   c                óN   — ddl }|                     | j        | j        |¬¦  «        S )z6
        Convert myself into a pyarrow Array.
        r   N)rS   rt   )Úpyarrowr;   rO   rQ   )ri   rt   Úpas      rZ   Ú__arrow_array__zBaseMaskedArray.__arrow_array__¬  s,   € ð 	ÐÐÐà�xŠx˜œ
¨¬¸$ˆxÑ?Ô?Ð?r\   c                ó4   — | j                              ¦   «         S rV   )rQ   r˜   r   s    rZ   r½   zBaseMaskedArray._hasna´  s   € ð Œz�~Š~ÑÔÐr\   únpt.NDArray[np.bool_] | Nonec                óü   — |€o| j                              ¦   «         }|t          j        u r|dz  }nLt	          |¦  «        r2t          |¦  «        t          |¦  «        k    r|t          |¦  «        z  }n
| j         |z  }|S )NT)rQ   r]   rö   r÷   r#   r�   r*   )ri   rS   Úothers      rZ   Ú_propagate_maskzBaseMaskedArray._propagate_mask½  s|   € ð ˆ<Ø”:—?’?Ñ$Ô$ˆDØ�
œÐ%Ð%à˜d‘{��Ý˜eÑ$Ô$ð *­¨U©¬µs¸4±y´yÒ)@Ð)@Ø�d 5™kœkÑ)�øà”: Ñ$ˆDð ˆr\   c                óÀ  — |j         }d }t          |d¦  «        sOt          |¦  «        r@t          |¦  «        t          | ¦  «        k    r t	          |¦  «        }t          |d¬¦  «        }t          |t          ¦  «        r|j        |j	        }}nRt          |¦  «        rCt          |t          ¦  «        st          j        |¦  «        }|j        dk    rt          d¦  «        ‚t          j        |t          | ¦  «        f¦  «        }t          j        |¦  «        }t%          |¦  «        }|dv r)t          |t          j        ¦  «        rt)          |¦  «        }|                      ||¦  «        }|t,          j        u r“t          j        | j        ¦  «        }| j        j        dk    r6|dv rt          d	|› d
�¦  «        ‚|dv rd}nd}|                     |¦  «        }n†d|v r/| j        j        dk    r|                     t          j        ¦  «        }nR| j        j        dv r|dv r|}t          j        d¬¦  «        5   || j        |¦  «        }d d d ¦  «         n# 1 swxY w Y   |dk    rrt          j        | j        dk    | j	         z  d|¦  «        }|�t          j        |dk    | z  d|¦  «        }n |t,          j        urt          j        |dk    d|¦  «        }nw|dk    rq|�t          j        |dk    | z  d|¦  «        }n(|t,          j        urt          j        |dk    d|¦  «        }t          j        | j        dk    | j	         z  d|¦  «        }|                      ||¦  «        S )Nrd   T)Úextract_numpyr•   ú(can only perform ops with 1-d structures>   ÚpowÚrpowr®   >   rC  rD  ÚtruedivÚfloordivÚrtruedivÚ	rfloordivz
operator 'z!' not implemented for bool dtypes>   ÚmodÚrmodÚint8r^   rE  r¯   r  )rF  rI  ró   )r›   rC  Fr   rD  ) Ú__name__Úhasattrr#   r�   Úpd_arrayr=   ra   rL   rO   rQ   r:   rb   rî   r’   rw   r/   Úmaybe_prepare_scalar_for_opÚget_array_opr<   re   r^   r?  rö   r÷   Ú	ones_likerd   r°   rü   Úfloat64ÚerrstateÚwhererá   )	ri   r>  ÚopÚop_nameÚomaskÚpd_oprS   rY   rd   s	            rZ   Ú_arith_methodzBaseMaskedArray._arith_methodÍ  s°  € Ø”+ˆØˆõ ˜˜wÑ'Ô'ð	=å˜UÑ#Ô#ð	=õ �E‘
”
�c $™iœiÒ'Ð'õ ˜U‘O”OˆEÝ! %°tÐ<Ñ<Ô<ˆEå�e�_Ñ-Ô-ð 	VØ œ;¨¬�5ˆEˆEå˜%Ñ Ô ð 	VÝ˜e¥^Ñ4Ô4ð *Ýœ
 5Ñ)Ô)�ØŒz˜AŠ~ˆ~Ý)Ð*TÑUÔUÐUõ Ô/°½¸D¹	¼	°|ÑDÔDˆÝÔ  Ñ$Ô$ˆÝ.¨uÑ5Ô5ˆà�oÐ%Ð%­*°U½B¼HÑ*EÔ*EÐ%õ ˜‘K”KˆEà×#Ò# E¨5Ñ1Ô1ˆà•J”MÐ!Ð!Ý”\ $¤*Ñ-Ô-ˆFØŒzŒ #Ò%Ð%Øð ð ð õ .ØO WÐOÐOÐOñô ð ð ˜oÐ-Ð-Ø"�E�Eà"�EØŸš uÑ-Ô-��Ø˜gÐ%Ð%¨$¬*¬/¸SÒ*@Ð*@ð  Ÿš¥r¤zÑ2Ô2�øð ŒzŒ $Ð&Ð&¨7Ð6IÐ+IÐ+Ið �å” Ð*Ñ*Ô*ð 2ð 2Ø˜˜tœz¨5Ñ1Ô1�ð2ð 2ð 2ñ 2ô 2ð 2ð 2ð 2ð 2ð 2ð 2øøøð 2ð 2ð 2ð 2ð �eÒÐå”8˜TœZ¨1š_°´°Ñ;¸UÀDÑIÔIˆDàÐ Ý”x ¨!¢°¨vÑ 5°u¸dÑCÔC��Ø�jœmÐ+Ð+Ý”x ¨¢
¨E°4Ñ8Ô8�øà˜ÒÐàÐ Ý”x ¨!¢°¨vÑ 5°u¸dÑCÔC��Ø�jœmÐ+Ð+Ý”x ¨¢
¨E°4Ñ8Ô8�å”8˜TœZ¨1š_°´°Ñ;¸UÀDÑIÔIˆDà×&Ò& v¨tÑ4Ô4Ð4s   È2IÉIÉIrE   c                ój  — ddl m} d }t          |t          ¦  «        r|j        |j        }}nlt          |¦  «        r]t          j        |¦  «        }|j	        dk    rt          d¦  «        ‚t          | ¦  «        t          |¦  «        k    rt          d¦  «        ‚|t          j        u rAt          j        | j        j        d¬¦  «        }t          j        | j        j        d¬¦  «        }n©t%          j        ¦   «         5  t%          j        dd	t*          ¦  «         t%          j        dd	t,          ¦  «         t/          | j        d
|j        › d
�¦  «        } ||¦  «        }|t2          u rt5          | j        ||¦  «        }d d d ¦  «         n# 1 swxY w Y   |                      ||¦  «        } |||d¬¦  «        S )Nr   rD   r•   rB  zLengths must match to comparer^   rq   ró   ÚelementwiseÚ__Frª   )r"  rE   ra   rL   rO   rQ   r#   rb   rî   r’   rw   r�   rh   rö   r÷   r.  rg   rv   rø   rù   rú   ÚFutureWarningÚDeprecationWarningr0  rL  r*  r?   r?  )ri   r>  rU  rE   rS   rY   r�   s          rZ   Ú_cmp_methodzBaseMaskedArray._cmp_method,  sø  € Ø3Ð3Ð3Ð3Ð3Ð3àˆå�e�_Ñ-Ô-ð 	BØœ+ u¤{�4ˆEˆEå˜%Ñ Ô ð 	BÝ”J˜uÑ%Ô%ˆEØŒz˜AŠ~ˆ~Ý)Ð*TÑUÔUÐUÝ�4‰yŒy�C ™JœJÒ&Ð&Ý Ð!@ÑAÔAÐAà•J”MÐ!Ð!õ
 ”X˜dœjÔ.°fÐ=Ñ=Ô=ˆFÝ”7˜4œ:Ô+°6Ð:Ñ:Ô:ˆDˆDåÔ(Ñ*Ô*ð Gð Gõ Ô'¨°-ÅÑOÔOÐOÝÔ'¨°-ÕASÑTÔTÐTÝ  ¤Ð-A°"´+Ð-AÐ-AÐ-AÑBÔB�Ø˜ ™œ�à�^Ð+Ð+Ý/°´
¸EÀ2ÑFÔF�FðGð Gð Gñ Gô Gð Gð Gð Gð Gð Gð Gøøøð Gð Gð Gð Gð ×#Ò# D¨%Ñ0Ô0ˆØˆ|˜F D¨uÐ5Ñ5Ô5Ð5s   Ã;A?FÆF
ÆF
rY   ú*np.ndarray | tuple[np.ndarray, np.ndarray]c                ó‚  — t          |t          ¦  «        r1|\  }}|                      ||¦  «        |                      ||¦  «        fS |j        j        dk    rddlm}  |||d¬¦  «        S |j        j        dk    rddlm}  |||d¬¦  «        S t          j	        |j        d¦  «        ret          |j        ¦  «        rQdd	lm} |j                             d
¦  «        ||<   t          ||¦  «        s|                     ||j        ¬¦  «        S |S |j        j        dv rddlm}  |||d¬¦  «        S t          j        ||<   |S )z
        Parameters
        ----------
        result : array-like or tuple[array-like]
        mask : array-like bool
        r¯   r   rH   Frª   r®   rD   r%  )ÚTimedeltaArrayr  rq   r  ©r!  )ra   r2  rá   rd   r°   r"  rI   rE   r	   Úis_np_dtyper   rb  rt   r[   r!  rb   r  )	ri   rY   rS   ÚdivrI  rI   rE   rb  r!  s	            rZ   rá   z"BaseMaskedArray._maybe_mask_resultT  s”  € õ �f�eÑ$Ô$ð 	à‰HˆC�à×'Ò'¨¨TÑ2Ô2Ø×'Ò'¨¨TÑ2Ô2ðð ð
 Œ<Ô Ò#Ð#Ø8Ð8Ð8Ð8Ð8Ð8à �= ¨°EÐ:Ñ:Ô:Ð:àŒ\Ô #Ò%Ð%Ø7Ð7Ð7Ð7Ð7Ð7à�< ¨°5Ð9Ñ9Ô9Ð9åŒ_˜Vœ\¨3Ñ/Ô/ð 	Õ4FÀvÄ|Ñ4TÔ4Tð 	à9Ð9Ð9Ð9Ð9Ð9à!œ<×,Ò,¨UÑ3Ô3ˆF�4‰Lå˜f nÑ5Ô5ð NØ%×1Ò1°&ÀÄÐ1ÑMÔMÐMàˆMàŒ\Ô $Ð&Ð&Ø7Ð7Ð7Ð7Ð7Ð7à�< ¨°5Ð9Ñ9Ô9Ð9õ œ6ˆF�4‰LØˆMr\   c                ó4   — | j                              ¦   «         S rV   )rQ   r]   r   s    rZ   r*   zBaseMaskedArray.isnaƒ  s   € ØŒz�ŠÑ Ô Ð r\   c                ó   — | j         j        S rV   r  r   s    rZ   r3  zBaseMaskedArray._na_value†  s   € àŒzÔ"Ð"r\   c                ó4   — | j         j        | j        j        z   S rV   )rO   ÚnbytesrQ   r   s    rZ   ri  zBaseMaskedArray.nbytesŠ  s   € àŒzÔ  4¤:Ô#4Ñ4Ð4r\   Ú	to_concatúSequence[Self]c                óš   — t          j        d„ |D ¦   «         |¬¦  «        }t          j        d„ |D ¦   «         |¬¦  «        } | ||¦  «        S )Nc                ó   — g | ]	}|j         ‘Œ
S r‚   ©rO   r  s     rZ   r  z5BaseMaskedArray._concat_same_type.<locals>.<listcomp>”  ó   € Ð:Ð:Ð:¨1˜qœwÐ:Ð:Ð:r\   rÑ   c                ó   — g | ]	}|j         ‘Œ
S r‚   )rQ   r  s     rZ   r  z5BaseMaskedArray._concat_same_type.<locals>.<listcomp>•  ro  r\   )rb   Úconcatenate)rX   rj  rÎ   rÍ   rS   s        rZ   Ú_concat_same_typez!BaseMaskedArray._concat_same_typeŽ  sZ   € õ Œ~Ð:Ð:°	Ð:Ñ:Ô:ÀÐFÑFÔFˆÝŒ~Ð:Ð:°	Ð:Ñ:Ô:ÀÐFÑFÔFˆØˆs�4˜‰ŒÐr\   ÚencodingÚhash_keyÚ
categorizeúnpt.NDArray[np.uint64]c               ó’   — t          | j        |||¬¦  «        }t          | j        j        ¦  «        ||                      ¦   «         <   |S )N)rs  rt  ru  )r@   rO   Úhashrd   r‰   r*   )ri   rs  rt  ru  Úhashed_arrays        rZ   Ú_hash_pandas_objectz#BaseMaskedArray._hash_pandas_object˜  sJ   € õ "ØŒJ °HÈð
ñ 
ô 
ˆõ %)¨¬Ô)<Ñ$=Ô$=ˆ�T—Y’Y‘[”[Ñ!ØÐr\   )Ú
allow_fillÚ
fill_valuerÎ   r{  r|  úScalar | Nonec               ó(  — t          |¦  «        r| j        n|}t          | j        ||||¬¦  «        }t          | j        |d||¬¦  «        }|r1t          |¦  «        r"t          j        |¦  «        dk    }|||<   ||z  }|                      ||¦  «        S )N)r|  r{  rÎ   Tr”   )	r*   rM   r4   rO   rQ   r+   rb   rî   r[   )	ri   Úindexerr{  r|  rÎ   Údata_fill_valuerY   rS   Ú	fill_masks	            rZ   r4   zBaseMaskedArray.take¡  s½   € õ 8<¸JÑ7GÔ7GÐW˜$Ô3Ð3ÈZˆÝØŒJØØ&Ø!Øð
ñ 
ô 
ˆõ ØŒJ˜¨D¸ZÈdð
ñ 
ô 
ˆð ð 	$�% 
Ñ+Ô+ð 	$Ýœ
 7Ñ+Ô+¨rÒ1ˆIØ *ˆF�9ÑØ˜)Ñ#ˆDà×Ò ¨Ñ-Ô-Ð-r\   c                ó@  ‡ — ddl m} t          j        |¦  «        }t	          ‰ j        |¦  «        }‰ j        r5|j        t          k    ot          ˆ fd„|D ¦   «         ¦  «        }||‰ j
        <   t          j        ‰ j        j        t          ¬¦  «        } |||d¬¦  «        S )Nr   rD   c              3  ó4   •K  — | ]}|‰j         j        u V — Œd S rV   r  )r  rÀ   ri   s     €rZ   r(  z'BaseMaskedArray.isin.<locals>.<genexpr>Î  sF   øè è € ð @ð @Ø/2��t”zÔ*Ð*ð@ð @ð @ð @ð @ð @r\   rq   Frª   )r"  rE   rb   rî   r1   rO   r½   rd   rï   r˜   rQ   r.  rg   r^   )ri   rR   rE   Ú
values_arrrY   Úvalues_have_NArS   s   `      rZ   r1   zBaseMaskedArray.isinÅ  sÊ   ø€ Ø3Ð3Ð3Ð3Ð3Ð3õ ”Z Ñ'Ô'ˆ
Ý�d”j *Ñ-Ô-ˆàŒ;ð 	0Ø'Ô-µÒ7ð ½Cð @ð @ð @ð @Ø6@ð@ñ @ô @ñ =ô =ˆNð "0ˆF�4”:ÑåŒx˜œ
Ô(µÐ5Ñ5Ô5ˆØˆ|˜F D¨uÐ5Ñ5Ô5Ð5r\   c                ó’   — | j                              ¦   «         }| j                             ¦   «         }|                      ||¦  «        S rV   )rO   r]   rQ   r[   )ri   rÍ   rS   s      rZ   r]   zBaseMaskedArray.copyÙ  s:   € ØŒz�ŠÑ Ô ˆØŒz�ŠÑ Ô ˆØ×Ò  dÑ+Ô+Ð+r\   r¢   ÚkeepúLiteral['first', 'last', False]c                óL   — | j         }| j        }t          j        |||¬¦  «        S )N)r‡  rS   )rO   rQ   ÚalgosÚ
duplicated)ri   r‡  rR   rS   s       rZ   r‹  zBaseMaskedArray.duplicatedÞ  s*   € ð ”ˆØŒzˆÝÔ ¨T¸Ð=Ñ=Ô=Ð=r\   c                ór   — t          j        | j        | j        ¦  «        \  }}|                      ||¦  «        S )z‚
        Compute the BaseMaskedArray of unique values.

        Returns
        -------
        uniques : BaseMaskedArray
        )rŠ  Úunique_with_maskrO   rQ   r[   )ri   ÚuniquesrS   s      rZ   ÚuniquezBaseMaskedArray.uniqueæ  s4   € õ Ô.¨t¬z¸4¼:ÑFÔF‰ˆ�Ø×Ò ¨Ñ.Ô.Ð.r\   Úleftr¨   ú$NumpyValueArrayLike | ExtensionArrayÚsideúLiteral['left', 'right']ÚsorterúNumpySorter | Noneúnpt.NDArray[np.intp] | np.intpc                óÆ   — | j         rt          d¦  «        ‚t          |t          ¦  «        r|                     t
          ¦  «        }| j                             |||¬¦  «        S )NzOsearchsorted requires array to be sorted, which is impossible with NAs present.)r’  r”  )r½   rh   ra   r:   rü   rï   rO   Úsearchsorted)ri   r¨   r’  r”  s       rZ   r˜  zBaseMaskedArray.searchsortedñ  sg   € ð Œ;ð 	Ýð$ñô ð õ �e�^Ñ,Ô,ð 	)Ø—L’L¥Ñ(Ô(ˆEàŒz×&Ò& u°4ÀÐ&ÑGÔGÐGr\   Úuse_na_sentinelú!tuple[np.ndarray, ExtensionArray]c                ó�  — | j         }| j        }t          |d|¬¦  «        \  }}|j        | j        j        k    sJ |j        | j        f¦   «         ‚|                     ¦   «         }|s|st          |¦  «        }nt          |¦  «        dz   }t          j        |t          ¬¦  «        }|sˆ|r†| 
                    ¦   «         }	|	dk    rt          j        d¦  «        }
n|d |	…                              ¦   «         dz   }
|||
k    xx         dz  cc<   |
||dk    <   t          j        ||
d¦  «        }d||
<   |                      ||¦  «        }||fS )NT)r™  rS   r•   rq   r   r”   )rO   rQ   r0   rd   r  r˜   r�   rb   r.  r^   rœ   ÚintpÚmaxÚinsertr[   )ri   r™  ÚarrrS   ÚcodesrŽ  Úhas_naÚsizeÚuniques_maskÚna_indexÚna_codeÚ
uniques_eas               rZ   Ú	factorizezBaseMaskedArray.factorize  se  € ð
 ŒjˆØŒzˆõ )¨¸dÈÐNÑNÔN‰ˆˆwð Œ} ¤
Ô 6Ò6Ð6Ð6¸¼ÈÌ
Ð8SÑ6Ô6Ð6à—’‘”ˆØð 	$ &ð 	$Ý�w‘<”<ˆDˆDõ �w‘<”< !Ñ#ˆDÝ”x ­DÐ1Ñ1Ô1ˆØð 	) 6ð 	)Ø—{’{‘}”}ˆHà˜1Š}ˆ}Ýœ' !™*œ*��à 	  	Ô*×.Ò.Ñ0Ô0°1Ñ4�Ø�%˜7Ò"Ð#Ð#Ô# qÑ(Ð#Ð#Ñ#Ø!(ˆE�%˜2’+Ñå”i ¨°!Ñ4Ô4ˆGØ$(ˆL˜Ñ!Ø×%Ò% g¨|Ñ<Ô<ˆ
à�jÐ Ð r\   c                ó   — | j         S rV   rn  r   s    rZ   Ú_values_for_argsortz#BaseMaskedArray._values_for_argsort'  s
   € àŒzÐr\   ÚdropnarC   c                ó�  — ddl m}m} ddlm} t          j        | j        || j        ¬¦  «        \  }}}t          j
        t          |¦  «        ft          j        ¬¦  «        }|                     ¦   «         }	|dk    rd|d<    |||	¦  «        }
 | | j                             ¦   «         ||¦  «        ¦  «        } ||
|dd	¬
¦  «        S )aA  
        Returns a Series containing counts of each unique value.

        Parameters
        ----------
        dropna : bool, default True
            Don't include counts of missing values.

        Returns
        -------
        counts : Series

        See Also
        --------
        Series.value_counts
        r   )ÚIndexrC   rc  ©rª  rS   rq   Tr”   ÚcountF)ÚindexÚnamer]   )Úpandasr¬  rC   Úpandas.arraysr!  rŠ  Úvalue_counts_arraylikerO   rQ   rb   r.  r�   re   r]   rd   r  )ri   rª  r¬  rC   r!  ÚkeysÚvalue_countsÚ
na_counterÚ
mask_indexrS   rŸ  r¯  s               rZ   rµ  zBaseMaskedArray.value_counts+  s
  € ð"	
ð 	
ð 	
ð 	
ð 	
ð 	
ð 	
ð 	
ð 	/Ð.Ð.Ð.Ð.Ð.å).Ô)EØŒJ˜v¨D¬Jð*
ñ *
ô *
Ñ&ˆˆl˜Jõ ”X�s <Ñ0Ô0Ð2½"¼(ÐCÑCÔCˆ
Ø�ŠÑ Ô ˆà˜Š>ˆ>Ø!ˆJ�r‰Nàˆl˜<¨Ñ.Ô.ˆØ�Ø-ˆDŒJ×+Ò+Ñ-Ô-Ø�jñô ñ
ô 
ˆð
 ˆv�c ¨W¸5ÐAÑAÔAÐAr\   c                ó.  — |rBt          | j        || j        ¬¦  «        }t          j        |j        t          j        ¬¦  «        }nt          | j        || j        ¬¦  «        \  }} t          | ¦  «        ||¦  «        }||                     ¦   «                  S )Nr­  rq   )	r3   rO   rQ   rb   r.  rg   re   rt   Úargsort)ri   rª  rY   Úres_masks       rZ   Ú_modezBaseMaskedArray._modeS  s†   € Øð 	PÝ˜$œ*¨V¸$¼*ÐEÑEÔEˆFÝ”x ¤µB´HÐ=Ñ=Ô=ˆHˆHå# D¤J°vÀDÄJÐOÑOÔOÑˆF�HØ•�d‘”˜F HÑ-Ô-ˆØ�f—n’nÑ&Ô&Ô'Ð'r\   c                ó  — t          | ¦  «        t          |¦  «        k    rdS |j        | j        k    rdS t          j        | j        |j        ¦  «        sdS | j        | j                  }|j        |j                  }t          ||dd¬¦  «        S )NFT)Ú
strict_nanÚdtype_equal)rt   rd   rb   Úarray_equalrQ   rO   r(   )ri   r>  r�  Úrights       rZ   ÚequalszBaseMaskedArray.equals\  sˆ   € å�‰:Œ:�˜e™œÒ$Ð$Ø�5ØŒ;˜$œ*Ò$Ð$Ø�5õ Œ~˜dœj¨%¬+Ñ6Ô6ð 	Ø�5àŒz˜4œ:˜+Ô&ˆØ”˜Uœ[˜LÔ)ˆÝ  e¸È$ÐOÑOÔOÐOr\   Úqsúnpt.NDArray[np.float64]Úinterpolationc                ó4  — t          | j        | j        t          j        ||¬¦  «        }| j        r³| j        dk    rt          ‚|                      ¦   «          	                    ¦   «         rZt          j
        |j        t          ¬¦  «        }t          | j        ¦  «        r%t          j        |j        | j        j        ¬¦  «        }nAt          j        |j        t          ¬¦  «        }n t          j        |j        t          ¬¦  «        }|                      ||¬¦  «        S )z½
        Dispatch to quantile_with_mask, needed because we do not have
        _from_factorized.

        Notes
        -----
        We assume that all impacted cases are 1D-only.
        )rS   r|  rÂ  rÄ  é   rq   ©rS   )r7   rO   rQ   rb   r  r½   r’   rw   r*   r›   rv   rg   r^   r"   rd   r.  r  rá   )ri   rÂ  rÄ  ÚresÚout_masks        rZ   Ú	_quantilezBaseMaskedArray._quantilel  sø   € õ !ØŒJØ”õ ”vØØ'ð
ñ 
ô 
ˆð Œ;ð 	7ð Œy˜AŠ~ˆ~õ *Ð)Ø�yŠy‰{Œ{�ŠÑ Ô ð ;Ýœ7 3¤9µDÐ9Ñ9Ô9�å# D¤JÑ/Ô/ð Lõ œ( 3¤9°D´JÔ4JÐKÑKÔK�Cøåœ8 C¤IµTÐ:Ñ:Ô:��å”x ¤	µÐ6Ñ6Ô6ˆHØ×&Ò& s°Ð&Ñ:Ô:Ð:r\   )ÚskipnaÚkeepdimsr°  rË  rÌ  c               óæ  — |dv r t          | |¦  «        dd|i|¤Ž}nI| j        }| j        }t          t          d|› �¦  «        }|                     dd ¦  «        }	 ||f|	||dœ|¤Ž}|rmt          |¦  «        r|                      |dd¬¦  «        S |                     d	¦  «        }t          j	        d	t          ¬
¦  «        }|                      ||¦  «        S t          |¦  «        rt          j        S |S )N>	   r›   r˜   r�  ÚminÚstdÚsumÚvarÚmeanÚprodrË  r  rÎ   )rÎ   rË  rS   r   )r•   )r°  rÎ   Ú	mask_sizer•   rq   r‚   )r0  rO   rQ   r.   Úpopr*   Ú_wrap_na_resultrÕ   rb   r.  r^   rá   rö   r÷   )
ri   r°  rË  rÌ  rØ   rY   rÍ   rS   rU  rÎ   s
             rZ   Ú_reducezBaseMaskedArray._reduce˜  s  € ð ÐTÐTÐTØ(•W˜T 4Ñ(Ô(ÐAÐA°ÐA¸&ÐAÐAˆFˆFð ”:ˆDØ”:ˆDÝ�  t  Ñ.Ô.ˆBØ—:’:˜f dÑ+Ô+ˆDØ�R˜ÐL 4°¸TÐLÐLÀVÐLÐLˆFàð 	=Ý�F‰|Œ|ð =Ø×+Ò+°¸AÈÐ+ÑNÔNÐNàŸš¨Ñ*Ô*�Ý”x ­Ð.Ñ.Ô.�Ø×.Ò.¨v°tÑ<Ô<Ð<å�‰<Œ<ð 	Ý”=Ð àˆMr\   c               óØ   — t          |t          j        ¦  «        rO|r| j                             |¬¦  «        }n| j                             |¬¦  «        }|                      ||¦  «        S |S rÐ   )ra   rb   rc   rQ   r›   r˜   rá   )ri   r°  rY   rË  rÎ   rS   s         rZ   Ú_wrap_reduction_resultz&BaseMaskedArray._wrap_reduction_result²  se   € Ý�f�bœjÑ)Ô)ð 	9Øð 1à”z—~’~¨4�~Ñ0Ô0��à”z—~’~¨4�~Ñ0Ô0�à×*Ò*¨6°4Ñ8Ô8Ð8Øˆr\   c               ó~  — t          j        |t          ¬¦  «        }| j        dk    rdnd}|dv r|}n_|dv s| j        j        dk    r| j        j        j        }n9t          ¦   «         pt           }|rdnd	}|rd
nd}	|||	|dœ| j        j	                 }t          j
        dg|¬¦  «        }
|                      |
|¬¦  «        S )Nrq   ÚFloat32r$  rR  )rÒ  ÚmedianrÑ  rÏ  ÚskewÚkurt)rÎ  r�  é   Úint32Úint64Úuint32Úuint64)r®   rÂ   Úur¯   r•   rÇ  )rb   rv   r^   rd   Úitemsizer  r°  r   r   r°   r;   rá   )ri   r°  rÎ   rÔ  rS   Ú
float_dtypÚnp_dtypeÚis_windows_or_32bitÚint_dtypÚ	uint_dtypr¨   s              rZ   rÖ  zBaseMaskedArray._wrap_na_result½  sä   € ÝŒw�y­Ð-Ñ-Ô-ˆà"&¤*°	Ò"9Ð"9�Y�Y¸yˆ
ØÐCÐCÐCØ!ˆHˆHØ�^Ð#Ð# t¤zÔ':¸aÒ'?Ð'?Ø”zÔ-Ô2ˆHˆHå"5Ñ"7Ô"7Ð"C½t¸8ÐØ"5ÐB�w�w¸7ˆHØ$7ÐE˜˜¸XˆIØ%¨H¸9È:ÐVÐVØ”
”ôˆHõ ”˜!˜ HÐ-Ñ-Ô-ˆØ×&Ò& u°4Ð&Ñ8Ô8Ð8r\   c               óÜ   — |dk    rNt          |t          j        ¦  «        r4|                      |t          j        |j        t          ¬¦  «        ¦  «        S |                      ||||¬¦  «        S )Nr   rq   ©rË  rÎ   )ra   rb   rc   rá   r.  rg   r^   rÙ  )ri   r°  rY   rË  Ú	min_countrÎ   s         rZ   Ú _wrap_min_count_reduction_resultz0BaseMaskedArray._wrap_min_count_reduction_resultÐ  sb   € ð ˜Š>ˆ>�j¨µ´Ñ<Ô<ˆ>Ø×*Ò*¨6µ2´8¸F¼LÕPTÐ3UÑ3UÔ3UÑVÔVÐVØ×*Ò*¨4°ÀÈTÐ*ÑRÔRÐRr\   ©rË  rí  rÎ   rí  úAxisInt | Nonec               ó¦   — t          j        d|¦  «         t          j        | j        | j        |||¬¦  «        }|                      d||||¬¦  «        S )Nr‚   rï  rÐ  )rÞ   Úvalidate_sumr6   rÐ  rO   rQ   rî  ©ri   rË  rí  rÎ   rØ   rY   s         rZ   rÐ  zBaseMaskedArray.sum×  sj   € õ 	Œ˜˜FÑ#Ô#Ð#å"Ô&ØŒJØŒJØØØð
ñ 
ô 
ˆð ×4Ò4Ø�6 &°IÀDð 5ñ 
ô 
ð 	
r\   c               ó¦   — t          j        d|¦  «         t          j        | j        | j        |||¬¦  «        }|                      d||||¬¦  «        S )Nr‚   rï  rÓ  )rÞ   Úvalidate_prodr6   rÓ  rO   rQ   rî  ró  s         rZ   rÓ  zBaseMaskedArray.prodì  sk   € õ 	Ô˜˜VÑ$Ô$Ð$å"Ô'ØŒJØŒJØØØð
ñ 
ô 
ˆð ×4Ò4Ø�F 6°YÀTð 5ñ 
ô 
ð 	
r\   rì  c               ó¢   — t          j        d|¦  «         t          j        | j        | j        ||¬¦  «        }|                      d|||¬¦  «        S )Nr‚   rì  rÒ  )rÞ   Úvalidate_meanr6   rÒ  rO   rQ   rÙ  ©ri   rË  rÎ   rØ   rY   s        rZ   rÒ  zBaseMaskedArray.mean  s[   € Ý
Ô˜˜VÑ$Ô$Ð$Ý"Ô'ØŒJØŒJØØð	
ñ 
ô 
ˆð ×*Ò*¨6°6À&ÈtÐ*ÑTÔTÐTr\   r•   ©rË  rÎ   Úddofrú  c               ó¨   — t          j        d|d¬¦  «         t          j        | j        | j        |||¬¦  «        }|                      d|||¬¦  «        S )Nr‚   rÑ  ©Úfnamerù  rì  )rÞ   Úvalidate_stat_ddof_funcr6   rÑ  rO   rQ   rÙ  ©ri   rË  rÎ   rú  rØ   rY   s         rZ   rÑ  zBaseMaskedArray.var  óe   € õ 	Ô" 2 v°UÐ;Ñ;Ô;Ð;Ý"Ô&ØŒJØŒJØØØð
ñ 
ô 
ˆð ×*Ò*¨5°&ÀÈdÐ*ÑSÔSÐSr\   c               ó¨   — t          j        d|d¬¦  «         t          j        | j        | j        |||¬¦  «        }|                      d|||¬¦  «        S )Nr‚   rÏ  rü  rù  rì  )rÞ   rþ  r6   rÏ  rO   rQ   rÙ  rÿ  s         rZ   rÏ  zBaseMaskedArray.std  r   r\   c               ó¢   — t          j        d|¦  «         t          j        | j        | j        ||¬¦  «        }|                      d|||¬¦  «        S )Nr‚   rì  rÎ  )rÞ   Úvalidate_minr6   rÎ  rO   rQ   rÙ  rø  s        rZ   rÎ  zBaseMaskedArray.min%  óZ   € Ý
Œ˜˜FÑ#Ô#Ð#Ý"Ô&ØŒJØŒJØØð	
ñ 
ô 
ˆð ×*Ò*¨5°&ÀÈdÐ*ÑSÔSÐSr\   c               ó¢   — t          j        d|¦  «         t          j        | j        | j        ||¬¦  «        }|                      d|||¬¦  «        S )Nr‚   rì  r�  )rÞ   Úvalidate_maxr6   r�  rO   rQ   rÙ  rø  s        rZ   r�  zBaseMaskedArray.max/  r  r\   c                óJ   — t          |                      ¦   «         ||¬¦  «        S )N)Ú	na_action)r2   rþ   )ri   Úmapperr  s      rZ   ÚmapzBaseMaskedArray.map9  s   € Ý˜Ÿš™œ¨&¸IÐFÑFÔFÐFr\   c               óF  — t          j        d|¦  «         | j                             ¦   «         }t	          j        || j        | j        ¦  «         |                     ¦   «         }|r|S |s,t          | ¦  «        dk    s| j                             ¦   «         s|S | j
        j        S )aY  
        Return whether any element is truthy.

        Returns False unless there is at least one element that is truthy.
        By default, NAs are skipped. If ``skipna=False`` is specified and
        missing values are present, similar :ref:`Kleene logic <boolean.kleene>`
        is used as for logical operations.

        .. versionchanged:: 1.4.0

        Parameters
        ----------
        skipna : bool, default True
            Exclude NA values. If the entire array is NA and `skipna` is
            True, then the result will be False, as for an empty array.
            If `skipna` is False, the result will still be True if there is
            at least one element that is truthy, otherwise NA will be returned
            if there are NA's present.
        axis : int, optional, default 0
        **kwargs : any, default None
            Additional keywords have no effect but might be accepted for
            compatibility with NumPy.

        Returns
        -------
        bool or :attr:`pandas.NA`

        See Also
        --------
        numpy.any : Numpy version of this method.
        BaseMaskedArray.all : Return whether all elements are truthy.

        Examples
        --------
        The result indicates whether any element is truthy (and by default
        skips NAs):

        >>> pd.array([True, False, True]).any()
        True
        >>> pd.array([True, False, pd.NA]).any()
        True
        >>> pd.array([False, False, pd.NA]).any()
        False
        >>> pd.array([], dtype="boolean").any()
        False
        >>> pd.array([pd.NA], dtype="boolean").any()
        False
        >>> pd.array([pd.NA], dtype="Float64").any()
        False

        With ``skipna=False``, the result can be NA if this is logically
        required (whether ``pd.NA`` is True or False influences the result):

        >>> pd.array([True, False, pd.NA]).any(skipna=False)
        True
        >>> pd.array([1, 0, pd.NA]).any(skipna=False)
        True
        >>> pd.array([False, False, pd.NA]).any(skipna=False)
        <NA>
        >>> pd.array([0, 0, pd.NA]).any(skipna=False)
        <NA>
        r‚   r   )rÞ   Úvalidate_anyrO   r]   rb   ÚputmaskrQ   Ú_falsey_valuer˜   r�   rd   r‰   ©ri   rË  rÎ   rØ   rR   rY   s         rZ   r˜   zBaseMaskedArray.any<  s“   € õ~ 	Œ˜˜FÑ#Ô#Ð#à”—’Ñ"Ô"ˆõ 	Œ
�6˜4œ: tÔ'9Ñ:Ô:Ð:Ø—’‘”ˆØð 	+ØˆMàð +�˜T™œ aš˜¨t¬z¯~ª~Ñ/?Ô/?˜Ø�à”zÔ*Ð*r\   c               óJ  — t          j        d|¦  «         | j                             ¦   «         }t	          j        || j        | j        ¦  «         |                     |¬¦  «        }|r|S |r,t          | ¦  «        dk    s| j         
                    ¦   «         s|S | j        j        S )aL  
        Return whether all elements are truthy.

        Returns True unless there is at least one element that is falsey.
        By default, NAs are skipped. If ``skipna=False`` is specified and
        missing values are present, similar :ref:`Kleene logic <boolean.kleene>`
        is used as for logical operations.

        .. versionchanged:: 1.4.0

        Parameters
        ----------
        skipna : bool, default True
            Exclude NA values. If the entire array is NA and `skipna` is
            True, then the result will be True, as for an empty array.
            If `skipna` is False, the result will still be False if there is
            at least one element that is falsey, otherwise NA will be returned
            if there are NA's present.
        axis : int, optional, default 0
        **kwargs : any, default None
            Additional keywords have no effect but might be accepted for
            compatibility with NumPy.

        Returns
        -------
        bool or :attr:`pandas.NA`

        See Also
        --------
        numpy.all : Numpy version of this method.
        BooleanArray.any : Return whether any element is truthy.

        Examples
        --------
        The result indicates whether all elements are truthy (and by default
        skips NAs):

        >>> pd.array([True, True, pd.NA]).all()
        True
        >>> pd.array([1, 1, pd.NA]).all()
        True
        >>> pd.array([True, False, pd.NA]).all()
        False
        >>> pd.array([], dtype="boolean").all()
        True
        >>> pd.array([pd.NA], dtype="boolean").all()
        True
        >>> pd.array([pd.NA], dtype="Float64").all()
        True

        With ``skipna=False``, the result can be NA if this is logically
        required (whether ``pd.NA`` is True or False influences the result):

        >>> pd.array([True, True, pd.NA]).all(skipna=False)
        <NA>
        >>> pd.array([1, 1, pd.NA]).all(skipna=False)
        <NA>
        >>> pd.array([True, False, pd.NA]).all(skipna=False)
        False
        >>> pd.array([1, 0, pd.NA]).all(skipna=False)
        False
        r‚   rÑ   r   )rÞ   Úvalidate_allrO   r]   rb   r  rQ   Ú_truthy_valuer›   r�   r˜   rd   r‰   r  s         rZ   r›   zBaseMaskedArray.all�  s™   € õ~ 	Œ˜˜FÑ#Ô#Ð#à”—’Ñ"Ô"ˆõ 	Œ
�6˜4œ: tÔ'9Ñ:Ô:Ð:Ø—’ �Ñ&Ô&ˆàð 	+ØˆMàð +�S ™YœY¨!š^˜^°4´:·>²>Ñ3CÔ3C˜^Ø�à”zÔ*Ð*r\   r   rI   c               ó0  — | j         j        dk    rD|r3| j                             ¦   «         }	| j                             ¦   «         }
nj| j        }	| j        }
n[| j         j        dv r6d}| j                             d¦  «        }	| j                             ¦   «         }
nt          d| j         › �¦  «        ‚t          j        |	f|d|||||
dœ|¤Ž |s| S | j         j        dk    r#t          | ¦  «         
                    |	|
¦  «        S ddlm}  |j
        |	|
¦  «        S )	z2
        See NDFrame.interpolate.__doc__.
        r¯   r  TÚf8z)interpolate is not implemented for dtype=r   )r�   rÎ   r¯  r‹   Úlimit_directionrŒ   rS   rH   )rd   r°   rO   r]   rQ   rü   rw   r
   Úinterpolate_2d_inplacert   r[   r"  rI   )ri   r�   rÎ   r¯  r‹   r  rŒ   r]   rØ   rÍ   rS   rI   s               rZ   ÚinterpolatezBaseMaskedArray.interpolateß  sN  € ð  Œ:Œ?˜cÒ!Ð!Øð "Ø”z—’Ñ(Ô(�Ø”z—’Ñ(Ô(��à”z�Ø”z��ØŒZŒ_ Ð$Ð$ØˆDØ”:×$Ò$ TÑ*Ô*ˆDØ”:—?’?Ñ$Ô$ˆDˆDå%ØH¸D¼JÐHÐHñô ð õ 	Ô&Øð
	
àØØØØ+Ø!Øð
	
ð 
	
ð ð
	
ð 
	
ð 
	
ð ð 	ØˆKØŒ:Œ?˜cÒ!Ð!Ý˜‘:”:×)Ò)¨$°Ñ5Ô5Ð5à8Ð8Ð8Ð8Ð8Ð8à,�=Ô,¨T°4Ñ8Ô8Ð8r\   )rË  c               ó’   — | j         }| j        }t          t          |¦  «        } |||fd|i|¤Ž\  }}|                      ||¦  «        S )NrË  )rO   rQ   r0  r5   r[   )ri   r°  rË  rØ   rÍ   rS   rU  s          rZ   Ú_accumulatezBaseMaskedArray._accumulate  sZ   € ð ŒzˆØŒzˆåÕ)¨4Ñ0Ô0ˆØ�R˜˜dÐ<Ð<¨6Ð<°VÐ<Ð<‰
ˆˆdà×Ò  dÑ+Ô+Ð+r\   ÚhowÚhas_dropped_naÚngroupsÚidsúnpt.NDArray[np.intp]c          	     ó"  — ddl m} |                     |¦  «        } ||||¬¦  «        }	| j        }
|	j        dk    r|
                     ¦   «         }nt          j        |t          ¬¦  «        }|dk    r| 	                    d¦  «        dv rd	|d d …<    |	j
        | j        f||||
|d
œ|¤Ž}|	j        dk    r<|	j         	                    |	j        d¦  «        }t          j        ||df¦  «        j        }|	j        dv r|S |                      ||¦  «        S )Nr   )ÚWrappedCythonOp)r  r°   r  Ú	aggregaterq   ÚrankÚ	na_option)ÚtopÚbottomF)rí  r  Úcomp_idsrS   Úresult_maskÚohlcr•   )ÚidxminÚidxmax)Úpandas.core.groupby.opsr   Úget_kind_from_howrQ   r°   r]   rb   r.  r^   r)  Ú_cython_op_ndim_compatrO   r  Ú_cython_arityÚtilerš   rá   )ri   r  r  rí  r  r  rØ   r   r°   rU  rS   r'  Ú
res_valuesÚaritys                 rZ   Ú_groupby_opzBaseMaskedArray._groupby_op!  sN  € ð 	<Ð;Ð;Ð;Ð;Ð;à×0Ò0°Ñ5Ô5ˆØˆ_ ¨4ÀÐOÑOÔOˆð ŒzˆØŒ7�kÒ!Ð!ØŸ)š)™+œ+ˆKˆKåœ( 7µ$Ð7Ñ7Ô7ˆKà�&Š=ˆ=˜VŸZšZ¨Ñ4Ô4Ð8IÐIÐIØ"ˆK˜˜˜‰Nà.�RÔ.ØŒJð
àØØØØ#ð
ð 
ð ð
ð 
ˆ
ð Œ6�VÒÐØÔ$×(Ò(¨¬°Ñ3Ô3ˆEÝœ' +°°q¨zÑ:Ô:Ô<ˆKàŒ6Ð)Ð)Ð)àÐð ×*Ò*¨:°{ÑCÔCÐCr\   )rR   rN   rS   rP   rT   r   )F)rR   rN   rS   rP   r]   r^   rT   r_   )r]   r^   rT   r   )rg   r   rd   r    )ry   r^   rT   rz   )rT   r'   )r€   r   rT   r   )r€   r   rT   r   )r€   r   rT   r‡   )
r�   r   r‹   rŽ   rŒ   r�   r]   r^   rT   r   )NNNT)r‹   rŽ   r]   r^   rT   r   )rd   r   r]   r^   rT   r«   )rT   r_   )rT   r^   )rT   rA   )rT   rÄ   )rT   r   )rT   r   )r   )rÎ   r   rT   r   )rÜ   rÄ   )rT   rN   )rd   rñ   r]   r^   r‰   rï   rT   rN   ).)rd   r  r]   r^   rT   rN   )rd   r    r]   r^   rT   r:   )rd   r   r]   r^   rT   r   )T)NN)rd   r  r]   r  rT   rN   )r  r  r�   r|   rV   )rS   r<  rT   rP   )rT   rE   )rY   r`  rS   rN   )rj  rk  rÎ   r   rT   r   )rs  r|   rt  r|   ru  r^   rT   rv  )r{  r^   r|  r}  rÎ   r   rT   r   )rR   r   rT   rE   )r¢   )r‡  rˆ  rT   rP   )r�  N)r¨   r‘  r’  r“  r”  r•  rT   r–  )r™  r^   rT   rš  )rª  r^   rT   rC   )rª  r^   rT   r   )rÂ  rÃ  rÄ  r|   rT   rL   )r°  r|   rË  r^   rÌ  r^   )r°  r|   )rË  r^   rí  rÄ   rÎ   rð  )rË  r^   rÎ   rð  )rË  r^   rÎ   rð  rú  rÄ   )r�   r   rÎ   rÄ   r]   r^   rT   rI   )r°  r|   rË  r^   rT   rL   )
r  r|   r  r^   rí  rÄ   r  rÄ   r  r  )[rL  Ú
__module__Ú__qualname__Ú__doc__Ú__annotations__r   r  r  Úclassmethodr[   rj   ro   r   r:   rx   r}   Úpropertyrd   r   r„   r¥   r©   rm   r³   r¶   rº   rÃ   rÆ   rg   r’   rÊ   rÒ   rÕ   rÚ   rš   rà   rä   rç   ré   rì   rð   r	   r  rþ   r  rü   Ú__array_priority__r  r6  r:  r½   r?  rY  Ú_logical_methodr_  rá   r*   r3  ri  rr  rz  r4   r1   r]   r‹  r�  r˜  r§  r©  rµ  r»  rÁ  rÊ  r×  rÙ  rÖ  rî  rÐ  rÓ  rÒ  rÑ  rÏ  rÎ  r�  r
  r˜   r›   r  r  r2  Ú__classcell__)r»   s   @rZ   rL   rL   k   s-
  ø€ € € € € € ðð ð !Ð Ð Ñ àÐÐÑØ Ð Ð Ñ ð €MØ€Màðð ð ñ „[ðð MRðð ð ð ð ð& Ø.2Àð !ð !ð !ð !ð !ñ „[ð!ð Ø€SˆÔ	ÑÔð	ð 	ð 	ñ  Ôñ „[ð	ðð ð ð ð ð ð(ð (ð (ñ „Xð(ð ðð ð ñ „Xðð ðð ð ñ „Xðð
;ð 
;ð 
;ð 
;ð  !Ø:>Øð*ð *ð *ð *ð *ð *ðX 	€SˆÔ	ÑÔàNRðð ð ð ñ  ÔððB à6;ð'ð 'ð 'ð 'ð 'ñ „[ð'ð
Pð Pð Pð6ð ð ð ð"/ð /ð /ð /ð /ð /ðð ð ð ð ð ð ð ð ð ð  ð  ñ „Xð ð ðð ð ñ „Xðð,ð ,ð ,ð ,ð
,ð ,ð ,ð ,ð ,ð
,ð ,ð ,ð ,ð
&ð &ð &ð &ð ð<ð <ð <ñ „Xð<ðBð Bð Bð Bð BðF@ð @ð @ð @ð@ð @ð @ð @ðð ð ð ðDð Dð Dð Dð
.ð .ð .ð .ð
 '+ØØœ>ð	[ð [ð [ð [ð [ðz 	€SˆÔ	ÑÔðKð Kñ  ÔðKð ðð ð ð ñ „Xðð ðð ð ð ñ „Xðð ðð ð ð ñ „Xðð,ð ,ð ,ð ,ð ,ð\ Ðð AEð*ð *ð *ð *ð *ð %Ð$Ð$Ñ$ðK'ð K'ð K'ð K'ðZ@ð @ð @ð @ð ð ð  ð  ñ „Xð ðð ð ð ð [5ð [5ð [5ðz $€Oð&6ð &6ð &6ð &6ðP-ð -ð -ð -ð^!ð !ð !ð !ð ð#ð #ñ „Xð#ð ð5ð 5ð 5ñ „Xð5ð ð ðð ð ð ñ „[ððð ð ð ð !Ø$(Øð .ð  .ð  .ð  .ð  .ð  .ðH6ð 6ð 6ð 6ð(,ð ,ð ,ð ,ð
 	€SˆÔ	"Ñ#Ô#à6=ð>ð >ð >ð >ñ $Ô#ð>ð	/ð 	/ð 	/ð 	/ð 	€SˆÔ	$Ñ%Ô%ð *0Ø%)ð	Hð Hð Hð Hñ &Ô%ðHð  	€SˆÔ	!Ñ"Ô"ð !%ð"!ð "!ð "!ð "!ñ #Ô"ð"!ðH 	€SˆÔ	+Ñ,Ô,ðð ð ñ -Ô,ðð&Bð &Bð &Bð &Bð &BðP(ð (ð (ð (ð (ð 	€SˆÔ	ÑÔðPð Pð Pñ  ÔðPð';ð ';ð ';ð ';ðZ ,0À%ðð ð ð ð ð ð4	ð 	ð 	ð 	ð9ð 9ð 9ð&Sð Sð Sð Sð ØØ ð
ð 
ð 
ð 
ð 
ð 
ð0 ØØ ð
ð 
ð 
ð 
ð 
ð 
ð* &*À!ð Uð Uð Uð Uð Uð Uð !%¸QÈAðTð Tð Tð Tð Tð Tð !%¸QÈAðTð Tð Tð Tð Tð Tð %)Àð Tð Tð Tð Tð Tð Tð %)Àð Tð Tð Tð Tð Tð TðGð Gð Gð Gð %)Àð O+ð O+ð O+ð O+ð O+ð O+ðb %)Àð P+ð P+ð P+ð P+ð P+ð P+ðd29ð 29ð 29ð 29ðj ,0ð	,ð 	,ð 	,ð 	,ð 	,ð 	,ð-Dð -Dð -Dð -Dð -Dð -Dð -Dð -Dr\   rL   Úmasked_arraysúSequence[BaseMaskedArray]rT   úlist[BaseMaskedArray]c                óF  — t          | ¦  «        } | d         j        }d„ | D ¦   «         }t          j        |dt          j        t          | ¦  «        t          | d         ¦  «        fd|j        ¬¦  «        ¬¦  «        }d„ | D ¦   «         }t          j        |dt          j        |t          ¬¦  «        ¬¦  «        }| 	                    ¦   «         }g }t          |j        d         ¦  «        D ]8} ||d	d	…|f         |d	d	…|f         ¬
¦  «        }	|                     |	¦  «         Œ9|S )zÖTranspose masked arrays in a list, but faster.

    Input should be a list of 1-dim masked arrays of equal length and all have the
    same dtype. The caller is responsible for ensuring validity of input data.
    r   c                óD   — g | ]}|j                              d d¦  «        ‘ŒS ©r•   r”   )rO   rÕ   ©r  rŸ  s     rZ   r  z7transpose_homogeneous_masked_arrays.<locals>.<listcomp>\  s*   € Ð@Ð@Ð@¨3ˆcŒi×Ò  2Ñ&Ô&Ð@Ð@Ð@r\   ÚF)Úorderrd   )rÎ   r  c                óD   — g | ]}|j                              d d¦  «        ‘ŒS rA  )rQ   rÕ   rB  s     rZ   r  z7transpose_homogeneous_masked_arrays.<locals>.<listcomp>g  s*   € Ð?Ð?Ð?¨#ˆSŒY×Ò˜q "Ñ%Ô%Ð?Ð?Ð?r\   rq   r•   NrÇ  )Úlistrd   rb   rq  rs   r�   r  Ú
empty_liker^   r  r¿   rg   r/  )
r<  rd   rR   Útransposed_valuesÚmasksÚtransposed_masksÚarr_typeÚtransposed_arraysrÂ   Útransposed_arrs
             rZ   Ú#transpose_homogeneous_masked_arraysrN  Q  sW  € õ ˜Ñ'Ô'€MØ˜!ÔÔ"€Eà@Ð@°-Ð@Ñ@Ô@€FÝœØØÝŒHÝ�ÑÔ¥ ]°1Ô%5Ñ!6Ô!6Ð7ØØÔ#ð
ñ 
ô 
ðñ ô Ðð @Ð?°Ð?Ñ?Ô?€EÝ”~Ø�A�2œ=Ð):Å$ÐGÑGÔGðñ ô Ðð ×)Ò)Ñ+Ô+€HØ/1ÐÝÐ$Ô*¨1Ô-Ñ.Ô.ð 1ð 1ˆØ!˜Ð"3°A°A°A°q°DÔ"9Ð@PÐQRÐQRÐQRÐTUÐQUÔ@VÐWÑWÔWˆØ× Ò  Ñ0Ô0Ð0Ð0àÐr\   )r<  r=  rT   r>  )jÚ
__future__r   Útypingr   r   r   r   r   rø   Únumpyrb   Úpandas._libsr	   r
   rö   Úpandas._libs.tslibsr   Úpandas._typingr   r   r   r   r   r   r   r   r   r   r   r   r   r   Úpandas.compatr   r   Úpandas.errorsr   Úpandas.util._decoratorsr   Úpandas.util._validatorsr   Úpandas.core.dtypes.baser    Úpandas.core.dtypes.commonr!   r"   r#   r$   r%   r&   Úpandas.core.dtypes.dtypesr'   Úpandas.core.dtypes.missingr(   r)   r*   r+   Úpandas.corer,   rŠ  r-   r.   r/   Úpandas.core.algorithmsr0   r1   r2   r3   r4   Úpandas.core.array_algosr5   r6   Ú pandas.core.array_algos.quantiler7   Úpandas.core.arrayliker8   Úpandas.core.arrays._utilsr9   Úpandas.core.arrays.baser:   Úpandas.core.constructionr;   rN  r<   r=   Úpandas.core.indexersr>   Úpandas.core.opsr?   Úpandas.core.util.hashingr@   Úcollections.abcrA   rB   r±  rC   r"  rE   rF   rG   rI   Úpandas.compat.numpyrJ   rÞ   rL   rN  r‚   r\   rZ   ú<module>rj     sÊ  ðØ "Ð "Ð "Ð "Ð "Ð "ðð ð ð ð ð ð ð ð ð ð ð ð ð ð €€€à Ð Ð Ð ðð ð ð ð ð ð ð ð 3Ð 2Ð 2Ð 2Ð 2Ð 2ðð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð .Ð -Ð -Ð -Ð -Ð -Ø 'Ð 'Ð 'Ð 'Ð 'Ð 'Ø :Ð :Ð :Ð :Ð :Ð :à 2Ð 2Ð 2Ð 2Ð 2Ð 2ðð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð 6Ð 5Ð 5Ð 5Ð 5Ð 5ðð ð ð ð ð ð ð ð ð ð ð ðð ð ð ð ð ð ð ð ð ð ð ð ð ðð ð ð ð ð ð ð ð ð ð ð ð ð ðð ð ð ð ð ð ð ð @Ð ?Ð ?Ð ?Ð ?Ð ?Ø *Ð *Ð *Ð *Ð *Ð *Ø >Ð >Ð >Ð >Ð >Ð >Ø 2Ð 2Ð 2Ð 2Ð 2Ð 2ðð ð ð ð ð ð ð ð ð ð
 5Ð 4Ð 4Ð 4Ð 4Ð 4Ø .Ð .Ð .Ð .Ð .Ð .Ø /Ð /Ð /Ð /Ð /Ð /àð 1ðð ð ð ð ð ð ð ð ÐÐÐÐÐØ/Ð/Ð/Ð/Ð/Ð/ðð ð ð ð ð ð ð ð 1Ð0Ð0Ð0Ð0Ð0à .Ð .Ð .Ð .Ð .Ð .ðcDð cDð cDð cDð cD�h ñ cDô cDð cDðL/!ð !ð !ð !ð !ð !r\   