Ë
    u™ãj“K  ã                  óÚ   — d Z ddlmZ ddlZddlmZmZ ddl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 dd
lmZ ddlmZ dddddœZ G d„ d«      Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zy)zn
Methods that can be shared by many array-like classes or subclasses:
    Series
    Index
    ExtensionArray
é    )ÚannotationsN)ÚAnyÚSelf)Úlib)Ú!maybe_dispatch_ufunc_to_dunder_op)Ú
ABCNDFrame)Ú	roperator©Úextract_array)Úunpack_zerodim_and_defer)Ú#disallow_datetimelike_logical_ufuncÚmaxÚminÚsumÚprod)ÚmaximumÚminimumÚaddÚmultiplyc                  óf  — e Zd Zd„ Z ed«      d=d„«       Z ed«      d=d„«       Z ed«      d=d„«       Z ed«      d=d	„«       Z ed
«      d=d„«       Z	 ed«      d=d„«       Z
d„ Z ed«      d=d„«       Z ed«      d=d„«       Z ed«      d=d„«       Z ed«      d=d„«       Z ed«      d=d„«       Z ed«      d=d„«       Zd„ Z ed«      d=d„«       Z ed«      d=d„«       Z ed «      d=d!„«       Z ed"«      d=d#„«       Z ed$«      d=d%„«       Z ed&«      d=d'„«       Z ed(«      d=d)„«       Z ed*«      d=d+„«       Z ed,«      d=d-„«       Z ed.«      d=d/„«       Z ed0«      d=d1„«       Z ed2«      d=d3„«       Z ed4«      d>d5„«       Z ed6«      d>d7„«       Z  ed8«      d=d9„«       Z! ed:«      d=d;„«       Z"y<)?ÚOpsMixinc                ó   — t         S ©N©ÚNotImplemented©ÚselfÚotherÚops      ú`/var/www/html/python-recuperauto-other/env/lib/python3.12/site-packages/pandas/core/arraylike.pyÚ_cmp_methodzOpsMixin._cmp_method(   ó   € ÜÐó    Ú__eq__c                óB   — | j                  |t        j                  «      S r   )r!   ÚoperatorÚeq©r   r   s     r    r$   zOpsMixin.__eq__+   ó   € à×Ñ ¤x§{¡{Ó3Ð3r#   Ú__ne__c                óB   — | j                  |t        j                  «      S r   )r!   r&   Úner(   s     r    r*   zOpsMixin.__ne__/   r)   r#   Ú__lt__c                óB   — | j                  |t        j                  «      S r   )r!   r&   Últr(   s     r    r-   zOpsMixin.__lt__3   r)   r#   Ú__le__c                óB   — | j                  |t        j                  «      S r   )r!   r&   Úler(   s     r    r0   zOpsMixin.__le__7   r)   r#   Ú__gt__c                óB   — | j                  |t        j                  «      S r   )r!   r&   Úgtr(   s     r    r3   zOpsMixin.__gt__;   r)   r#   Ú__ge__c                óB   — | j                  |t        j                  «      S r   )r!   r&   Úger(   s     r    r6   zOpsMixin.__ge__?   r)   r#   c                ó   — t         S r   r   r   s      r    Ú_logical_methodzOpsMixin._logical_methodF   r"   r#   Ú__and__c                óB   — | j                  |t        j                  «      S )zƒ
        Return elementwise ``self & other``.

        Logical AND for boolean operands, bitwise AND for integer operands.
        )r:   r&   Úand_r(   s     r    r;   zOpsMixin.__and__I   s   € ð ×#Ñ# E¬8¯=©=Ó9Ð9r#   Ú__rand__c                óB   — | j                  |t        j                  «      S )z$Return elementwise ``other & self``.)r:   r	   Úrand_r(   s     r    r>   zOpsMixin.__rand__R   s   € ð ×#Ñ# E¬9¯?©?Ó;Ð;r#   Ú__or__c                óB   — | j                  |t        j                  «      S )z�
        Return elementwise ``self | other``.

        Logical OR for boolean operands, bitwise OR for integer operands.
        )r:   r&   Úor_r(   s     r    rA   zOpsMixin.__or__W   ó   € ð ×#Ñ# E¬8¯<©<Ó8Ð8r#   Ú__ror__c                óB   — | j                  |t        j                  «      S )z$Return elementwise ``other | self``.)r:   r	   Úror_r(   s     r    rE   zOpsMixin.__ror__`   ó   € ð ×#Ñ# E¬9¯>©>Ó:Ð:r#   Ú__xor__c                óB   — | j                  |t        j                  «      S )zƒ
        Return elementwise ``self ^ other``.

        Logical XOR for boolean operands, bitwise XOR for integer operands.
        )r:   r&   Úxorr(   s     r    rI   zOpsMixin.__xor__e   rD   r#   Ú__rxor__c                óB   — | j                  |t        j                  «      S )z$Return elementwise ``other ^ self``.)r:   r	   Úrxorr(   s     r    rL   zOpsMixin.__rxor__n   rH   r#   c                ó   — t         S r   r   r   s      r    Ú_arith_methodzOpsMixin._arith_methodv   r"   r#   Ú__add__c                óB   — | j                  |t        j                  «      S )a,  
        Get Addition of DataFrame and other, column-wise.

        Equivalent to ``DataFrame.add(other)``.

        Parameters
        ----------
        other : scalar, sequence, Series, dict or DataFrame
            Object to be added to the DataFrame.

        Returns
        -------
        DataFrame
            The result of adding ``other`` to DataFrame.

        See Also
        --------
        DataFrame.add : Add a DataFrame and another object, with option for index-
            or column-oriented addition.

        Examples
        --------
        >>> df = pd.DataFrame(
        ...     {"height": [1.5, 2.6], "weight": [500, 800]}, index=["elk", "moose"]
        ... )
        >>> df
               height  weight
        elk       1.5     500
        moose     2.6     800

        Adding a scalar affects all rows and columns.

        >>> df[["height", "weight"]] + 1.5
               height  weight
        elk       3.0   501.5
        moose     4.1   801.5

        Each element of a list is added to a column of the DataFrame, in order.

        >>> df[["height", "weight"]] + [0.5, 1.5]
               height  weight
        elk       2.0   501.5
        moose     3.1   801.5

        Keys of a dictionary are aligned to the DataFrame, based on column names;
        each value in the dictionary is added to the corresponding column.

        >>> df[["height", "weight"]] + {"height": 0.5, "weight": 1.5}
               height  weight
        elk       2.0   501.5
        moose     3.1   801.5

        When `other` is a :class:`Series`, the index of `other` is aligned with the
        columns of the DataFrame.

        >>> s1 = pd.Series([0.5, 1.5], index=["weight", "height"])
        >>> df[["height", "weight"]] + s1
               height  weight
        elk       3.0   500.5
        moose     4.1   800.5

        Even when the index of `other` is the same as the index of the DataFrame,
        the :class:`Series` will not be reoriented. If index-wise alignment is desired,
        :meth:`DataFrame.add` should be used with `axis='index'`.

        >>> s2 = pd.Series([0.5, 1.5], index=["elk", "moose"])
        >>> df[["height", "weight"]] + s2
               elk  height  moose  weight
        elk    NaN     NaN    NaN     NaN
        moose  NaN     NaN    NaN     NaN

        >>> df[["height", "weight"]].add(s2, axis="index")
               height  weight
        elk       2.0   500.5
        moose     4.1   801.5

        When `other` is a :class:`DataFrame`, both columns names and the
        index are aligned.

        >>> other = pd.DataFrame(
        ...     {"height": [0.2, 0.4, 0.6]}, index=["elk", "moose", "deer"]
        ... )
        >>> df[["height", "weight"]] + other
               height  weight
        deer      NaN     NaN
        elk       1.7     NaN
        moose     3.0     NaN
        )rP   r&   r   r(   s     r    rQ   zOpsMixin.__add__y   s   € ðt ×!Ñ! %¬¯©Ó6Ð6r#   Ú__radd__c                óB   — | j                  |t        j                  «      S r   )rP   r	   Úraddr(   s     r    rS   zOpsMixin.__radd__Õ   ó   € à×!Ñ! %¬¯©Ó8Ð8r#   Ú__sub__c                óB   — | j                  |t        j                  «      S r   )rP   r&   Úsubr(   s     r    rW   zOpsMixin.__sub__Ù   ó   € à×!Ñ! %¬¯©Ó6Ð6r#   Ú__rsub__c                óB   — | j                  |t        j                  «      S r   )rP   r	   Úrsubr(   s     r    r[   zOpsMixin.__rsub__Ý   rV   r#   Ú__mul__c                óB   — | j                  |t        j                  «      S r   )rP   r&   Úmulr(   s     r    r^   zOpsMixin.__mul__á   rZ   r#   Ú__rmul__c                óB   — | j                  |t        j                  «      S r   )rP   r	   Úrmulr(   s     r    ra   zOpsMixin.__rmul__å   rV   r#   Ú__truediv__c                óB   — | j                  |t        j                  «      S r   )rP   r&   Útruedivr(   s     r    rd   zOpsMixin.__truediv__é   s   € à×!Ñ! %¬×)9Ñ)9Ó:Ð:r#   Ú__rtruediv__c                óB   — | j                  |t        j                  «      S r   )rP   r	   Úrtruedivr(   s     r    rg   zOpsMixin.__rtruediv__í   s   € à×!Ñ! %¬×);Ñ);Ó<Ð<r#   Ú__floordiv__c                óB   — | j                  |t        j                  «      S r   )rP   r&   Úfloordivr(   s     r    rj   zOpsMixin.__floordiv__ñ   s   € à×!Ñ! %¬×):Ñ):Ó;Ð;r#   Ú__rfloordivc                óB   — | j                  |t        j                  «      S r   )rP   r	   Ú	rfloordivr(   s     r    Ú__rfloordiv__zOpsMixin.__rfloordiv__õ   s   € à×!Ñ! %¬×)<Ñ)<Ó=Ð=r#   Ú__mod__c                óB   — | j                  |t        j                  «      S r   )rP   r&   Úmodr(   s     r    rq   zOpsMixin.__mod__ù   rZ   r#   Ú__rmod__c                óB   — | j                  |t        j                  «      S r   )rP   r	   Úrmodr(   s     r    rt   zOpsMixin.__rmod__ý   rV   r#   Ú
__divmod__c                ó.   — | j                  |t        «      S r   )rP   Údivmodr(   s     r    rw   zOpsMixin.__divmod__  s   € à×!Ñ! %¬Ó0Ð0r#   Ú__rdivmod__c                óB   — | j                  |t        j                  «      S r   )rP   r	   Úrdivmodr(   s     r    rz   zOpsMixin.__rdivmod__  s   € à×!Ñ! %¬×):Ñ):Ó;Ð;r#   Ú__pow__c                óB   — | j                  |t        j                  «      S r   )rP   r&   Úpowr(   s     r    r}   zOpsMixin.__pow__	  rZ   r#   Ú__rpow__c                óB   — | j                  |t        j                  «      S r   )rP   r	   Úrpowr(   s     r    r€   zOpsMixin.__rpow__  rV   r#   N)Úreturnr   )rƒ   ztuple[Self, Self])#Ú__name__Ú
__module__Ú__qualname__r!   r   r$   r*   r-   r0   r3   r6   r:   r;   r>   rA   rE   rI   rL   rP   rQ   rS   rW   r[   r^   ra   rd   rg   rj   rp   rq   rt   rw   rz   r}   r€   © r#   r    r   r   $   sÐ  „ òñ ˜hÓ'ò4ó (ð4ñ ˜hÓ'ò4ó (ð4ñ ˜hÓ'ò4ó (ð4ñ ˜hÓ'ò4ó (ð4ñ ˜hÓ'ò4ó (ð4ñ ˜hÓ'ò4ó (ð4òñ ˜iÓ(ò:ó )ð:ñ ˜jÓ)ò<ó *ð<ñ ˜hÓ'ò9ó (ð9ñ ˜iÓ(ò;ó )ð;ñ ˜iÓ(ò9ó )ð9ñ ˜jÓ)ò;ó *ð;òñ ˜iÓ(òY7ó )ðY7ñv ˜jÓ)ò9ó *ð9ñ ˜iÓ(ò7ó )ð7ñ ˜jÓ)ò9ó *ð9ñ ˜iÓ(ò7ó )ð7ñ ˜jÓ)ò9ó *ð9ñ ˜mÓ,ò;ó -ð;ñ ˜nÓ-ò=ó .ð=ñ ˜nÓ-ò<ó .ð<ñ ˜mÓ,ò>ó -ð>ñ ˜iÓ(ò7ó )ð7ñ ˜jÓ)ò9ó *ð9ñ ˜lÓ+ò1ó ,ð1ñ ˜mÓ,ò<ó -ð<ñ ˜iÓ(ò7ó )ð7ñ ˜jÓ)ò9ó *ñ9r#   r   c                óp  ‡ ‡‡‡‡‡‡‡‡ ‡!‡"— ddl m}m} ddlmŠ ddlmŠ t        ‰ «      }t        ‰|«       t        di |¤Ž}t        ‰ ‰‰g|¢­i |¤Ž}|t        ur|S t        j                  j                  |j                  f}	|D ]s  }
t        |
d«      xr |
j                   ‰ j                   kD  }t        |
d«      xr0 t        |
«      j                  |	vxr t#        |
‰ j$                  «       }|s|sŒmt        c S  t'        d„ |D «       «      }t)        ||d¬	«      D ��cg c]  \  }}t+        |‰«      sŒ|‘Œ c}}Št-        ‰«      d
kD  �r:t/        |«      }t-        |«      d
kD  r"||hj1                  |«      rt3        d‰› d�«      ‚t-        ‰«      dk(  rW‰d   j5                  ‰d
   d¬«      \  }}t7        ||g«      Št'        ˆˆfd„t)        ||d¬	«      D «       «      }|j8                  Š nx‰ j8                  Š ‰d
d D ]B  }t;        t)        ‰ |j8                  d¬	«      «      D ]  \  }\  }}|j=                  |«      ‰ |<   Œ ŒD t'        ˆˆ ˆ fd„t)        ||d¬	«      D «       «      }t?        t)        ‰ j@                  ‰ d¬	«      «      Š!n+t?        t)        ‰ j@                  ‰ j8                  d¬	«      «      Š!‰ jB                  d
k(  rK|D �ch c]  }t        |d«      sŒ|jD                  ’Œ }}t-        |«      d
k(  r|jG                  «       nd}d|iŠ"ni Š"ˆˆfd„}ˆˆˆˆ!ˆ"ˆ fd„Šd|v rtI        ‰ ‰‰g|¢­i |¤Ž} ||«      S ‰dk(  rtK        ‰ ‰‰g|¢­i |¤Ž}|t        ur|S ‰ jB                  d
kD  rBt-        |«      d
kD  s‰jL                  d
kD  r%t'        d„ |D «       «      } tO        ‰‰«      |i |¤Ž}nz‰ jB                  d
k(  r%t'        d„ |D «       «      } tO        ‰‰«      |i |¤Ž}nF‰dk(  r-|s+|d   jP                  }|jS                  tO        ‰‰«      «      }ntU        |d   ‰‰g|¢­i |¤Ž} ||«      }|S c c}}w c c}w )z˜
    Compatibility with numpy ufuncs.

    See also
    --------
    numpy.org/doc/stable/reference/arrays.classes.html#numpy.class.__array_ufunc__
    r   )Ú	DataFrameÚSeries)ÚNDFrame)ÚBlockManagerÚ__array_priority__Ú__array_ufunc__c              3  ó2   K  — | ]  }t        |«      –— Œ y ­wr   )Útype©Ú.0Úxs     r    ú	<genexpr>zarray_ufunc.<locals>.<genexpr>D  s   è ø€ Ò*˜a”$�q—'Ñ*ùs   ‚T©Ústricté   zCannot apply ufunc z& to mixed DataFrame and Series inputs.é   Úouter)Újoinc              3  óV   •K  — | ]   \  }}t        |‰«      rt        ‰«      n|–— Œ" y ­wr   )Ú
issubclassÚnext)r’   r“   Útr‹   Úaligneds      €€r    r”   zarray_ufunc.<locals>.<genexpr>[  s/   øè ø€ ò á�A�qô ",¨A¨wÔ!7”�W”¸QÓ>ñùs   ƒ&)Nc              3  ó¢   •K  — | ]F  \  }}t        |‰«      r1 |j                  di t        t        ‰j                  ‰d ¬«      «      ¤Žn|–— ŒH y­w)Tr•   Nr‡   )rœ   ÚreindexÚdictÚzipÚ_AXIS_ORDERS)r’   r“   rž   r‹   Úaxesr   s      €€€r    r”   zarray_ufunc.<locals>.<genexpr>g  sU   øè ø€ ò ñ �A�qô ˜a Ô)ð �—	‘	ÑLœD¤ T×%6Ñ%6¸ÀTÔ!JÓKÒLàóñùs   ƒAAÚnamec                óZ   •— ‰j                   dkD  rt        ˆfd„| D «       «      S  ‰| «      S )Nr—   c              3  ó.   •K  — | ]  } ‰|«      –— Œ y ­wr   r‡   )r’   r“   Ú_reconstructs     €r    r”   z3array_ufunc.<locals>.reconstruct.<locals>.<genexpr>|  s   øè ø€ Ò9¨Q™ aŸÑ9ùs   ƒ)ÚnoutÚtuple)Úresultr©   Úufuncs    €€r    Úreconstructz array_ufunc.<locals>.reconstructy  s*   ø€ Ø�:‰:˜Š>äÓ9°&Ô9Ó9Ð9á˜FÓ#Ð#r#   c                óF  •— t        j                  | «      r| S | j                  ‰j                  k7  r‰dk(  rt        ‚| S t	        | ‰«      r‰j                  | | j                  ¬«      } n ‰j                  | fi ‰¤‰¤ddi¤Ž} t        ‰«      dk(  r| j                  ‰«      } | S )Nr™   )r¥   ÚcopyFr—   )
r   Ú	is_scalarÚndimÚNotImplementedErrorÚ
isinstanceÚ_constructor_from_mgrr¥   Ú_constructorÚlenÚ__finalize__)r¬   rŒ   Ú	alignableÚmethodÚreconstruct_axesÚreconstruct_kwargsr   s    €€€€€€r    r©   z!array_ufunc.<locals>._reconstruct€  s¬   ø€ Ü�=‰=˜Ô ØˆMà�;‰;˜$Ÿ)™)Ò#Ø˜Ò Ü)Ð)ØˆMÜ�f˜lÔ+à×/Ñ/°¸V¿[¹[Ð/ÓI‰Fð '�T×&Ñ&ØñØ*ðØ.@ñØGLòˆFô ˆy‹>˜QÒØ×(Ñ(¨Ó.ˆFØˆr#   ÚoutÚreducec              3  óF   K  — | ]  }t        j                  |«      –— Œ y ­wr   )ÚnpÚasarrayr‘   s     r    r”   zarray_ufunc.<locals>.<genexpr>¯  s   è ø€ Ò5¨”r—z‘z !—}Ñ5ùs   ‚!c              3  ó6   K  — | ]  }t        |d ¬«      –— Œ y­w)T)Úextract_numpyNr
   r‘   s     r    r”   zarray_ufunc.<locals>.<genexpr>µ  s   è ø€ ÒLÀ”} Q°d×;Ð;ÑLùs   ‚Ú__call__r‡   )+Úpandas.core.framer‰   rŠ   Úpandas.core.genericr‹   Úpandas.core.internalsrŒ   r�   r   Ú_standardize_out_kwargr   r   rÀ   ÚndarrayrŽ   Úhasattrr�   r´   Ú_HANDLED_TYPESr«   r£   rœ   r·   ÚsetÚissubsetr³   ÚalignÚiterr¥   Ú	enumerateÚunionr¢   r¤   r²   r¦   ÚpopÚdispatch_ufunc_with_outÚdispatch_reduction_ufuncrª   ÚgetattrÚ_mgrÚapplyÚdefault_array_ufunc)#r   r­   rº   ÚinputsÚkwargsr‰   rŠ   Úclsr¬   Úno_deferÚitemÚhigher_priorityÚhas_array_ufuncÚtypesr“   rž   Ú	set_typesÚleftÚrightÚobjÚiÚax1Úax2Únamesr¦   r®   ÚmgrrŒ   r‹   r©   r¹   rŸ   r¥   r»   r¼   s#   ```                        @@@@@@@@r    Úarray_ufuncrê     sU  ÿú€ ÷õ ,Ý2ä
ˆt‹*€Cä'¨¨vÔ6ä#Ñ- fÑ-€Fô /¨t°U¸FÐVÀVÒVÈvÑV€FØ”^Ñ#Øˆô 	�
‰
×"Ñ"Ø×Ñð€Hð
 ò "ˆä�DÐ.Ó/ò BØ×'Ñ'¨$×*AÑ*AÑAð 	ô
 �DÐ+Ó,ò :Ü�T“
×*Ñ*°(Ð:ò:ä˜t T×%8Ñ%8Ó9Ð9ð 	ñ
 šoÜ!Ò!ð"ô Ñ* 6Ô*Ó*€Eä˜& %°Ô5÷Ùˆa�¼ÀAÀwÕ9OŠó€Iô ˆ9ƒ~˜Óô
 ˜“Jˆ	Üˆy‹>˜AÒ 9¨fÐ"5×">Ñ">¸yÔ"Iô &Ø% e WÐ,RÐSóð ô ˆy‹>˜QÒð $ A™,×,Ñ,¨Y°q©\ÀÐ,ÓH‰KˆD�%Ü˜D %˜=Ó)ˆGÜô ä ¨°dÔ;ôó ˆFð —9‘9‰Dà—9‘9ˆDØ   �}ò -�ô &/¬s°4¸¿¹È$Ô/OÓ%Pò -‘M�A‘z˜˜SØ!Ÿi™i¨›n�D˜’Gñ-ð-ô
 õ ô   ¨°dÔ;ô	ó ˆFô  ¤ D×$5Ñ$5°tÀDÔ IÓJÑä¤ D×$5Ñ$5°t·y±yÈÔ NÓOÐà‡y�y�A‚~Ø!'Ö>˜A¬7°1°fÕ+=�—“Ð>ˆÐ>Ü! %›j¨Ašoˆu�y‰yŒ{°4ˆØ$ d˜^ÑàÐõ$÷ñ ð0 ��ä(¨¨u°fÐP¸vÒPÈÑPˆÙ˜6Ó"Ð"à�Òä)¨$°°vÐQÀÒQÈ&ÑQˆØœÑ'ØˆMð
 ‡y�y�1‚}œ#˜f›+¨š/¨U¯Z©Z¸!ª^ô Ñ5¨fÔ5Ó5ˆð (”˜ Ó'¨Ð:°6Ñ:‰Ø	�‰�aŠäÑLÀVÔLÓLˆØ'”˜ Ó'¨Ð:°6Ñ:‰à	�:Ò	¡fð �Q‰i�n‰nˆØ—‘œ7 5¨&Ó1Ó2‰ô % V¨A¡Y°°vÐQÀÒQÈ&ÑQˆñ ˜Ó €FØ€MùóAùò\ ?s   ÄP-Ä3P-ËP3ËP3c                 ót   — d| vr3d| v r/d| v r+| j                  d«      }| j                  d«      }||f}|| d<   | S )z²
    If kwargs contain "out1" and "out2", replace that with a tuple "out"

    np.divmod, np.modf, np.frexp can have either `out=(out1, out2)` or
    `out1=out1, out2=out2)`
    r½   Úout1Úout2)rÒ   )rÚ   rì   rí   r½   s       r    rÈ   rÈ   È  sM   € ð �FÑ˜v¨Ñ/°F¸fÑ4DØ�z‰z˜&Ó!ˆØ�z‰z˜&Ó!ˆØ�TˆlˆØˆˆu‰Ø€Mr#   c                ó¾  — |j                  d«      }|j                  dd«      } t        ||«      |i |¤Ž}|t        u rt        S t        |t        «      rRt        |t        «      rt        |«      t        |«      k7  rt        ‚t        ||d¬«      D ]  \  }}	t        ||	|«       Œ |S t        |t        «      rt        |«      dk(  r|d   }nt        ‚t        |||«       |S )zz
    If we have an `out` keyword, then call the ufunc without `out` and then
    set the result into the given `out`.
    r½   ÚwhereNTr•   r—   r   )	rÒ   rÕ   r   r´   r«   r·   r³   r£   Ú_assign_where)
r   r­   rº   rÙ   rÚ   r½   rï   r¬   ÚarrÚress
             r    rÓ   rÓ   ×  sÕ   € ð �*‰*�UÓ
€CØ�J‰J�w Ó%€Eà#ŒW�U˜FÓ# VÐ6¨vÑ6€Fà”ÑÜÐä�&œ%Ô ä˜#œuÔ%¬¨S«´S¸³[Ò)@Ü%Ð%ä˜C °Ô5ò 	+‰HˆC�Ü˜#˜s EÕ*ð	+ð ˆ
ä�#”uÔÜˆs‹8�qŠ=Ø�a‘&‰Cä%Ð%ä�#�v˜uÔ%Ø€Jr#   c                óB   — |€|| dd yt        j                  | ||«       y)zV
    Set a ufunc result into 'out', masking with a 'where' argument if necessary.
    N)rÀ   Úputmask)r½   r¬   rï   s      r    rð   rð   ú  s"   € ð €}àˆ‰A‰ä
�
‰
�3˜˜vÕ&r#   c                ó¶   ‡ — t        ˆ fd„|D «       «      st        ‚|D �cg c]  }|‰ ur|nt        j                  |«      ‘Œ }} t	        ||«      |i |¤ŽS c c}w )z�
    Fallback to the behavior we would get if we did not define __array_ufunc__.

    Notes
    -----
    We are assuming that `self` is among `inputs`.
    c              3  ó&   •K  — | ]  }|‰u –— Œ
 y ­wr   r‡   )r’   r“   r   s     €r    r”   z&default_array_ufunc.<locals>.<genexpr>  s   øè ø€ Ò)˜Qˆq�DŒyÑ)ùs   ƒ)Úanyr³   rÀ   rÁ   rÕ   )r   r­   rº   rÙ   rÚ   r“   Ú
new_inputss   `      r    rØ   rØ     s^   ø€ ô Ó) &Ô)Ô)Ü!Ð!àAGÖH¸A�q ‘}‘!¬"¯*©*°Q«-Ñ7ÐH€JÐHà!Œ7�5˜&Ó! :Ð8°Ñ8Ð8ùò Is    "Ac                óB  — |dk(  sJ ‚t        |«      dk7  s|d   | urt        S |j                  t        vrt        S t        |j                     }t	        | |«      st        S | j
                  dkD  rt        | t        «      rd|d<   d|vrd|d<    t        | |«      dddi|¤ŽS )	z@
    Dispatch ufunc reductions to self's reduction methods.
    r¾   r—   r   FÚnumeric_onlyÚaxisÚskipnar‡   )	r·   r   r„   ÚREDUCTION_ALIASESrÊ   r²   r´   r   rÕ   )r   r­   rº   rÙ   rÚ   Úmethod_names         r    rÔ   rÔ     s²   € ð �XÒÐÐä
ˆ6ƒ{�aÒ˜6 !™9¨DÑ0ÜÐà‡~�~Ô.Ñ.ÜÐä# E§N¡NÑ3€Kô �4˜Ô%ÜÐà‡y�y�1‚}Ü�dœJÔ'à%*ˆF�>Ñ"à˜Ñð ˆF�6‰Nð &Œ7�4˜Ó%Ñ=¨UÐ=°fÑ=Ð=r#   )r­   únp.ufuncrº   ÚstrrÙ   r   rÚ   r   )rƒ   zdict[str, Any])r­   rÿ   rº   r   )rƒ   ÚNone)Ú__doc__Ú
__future__r   r&   Útypingr   r   ÚnumpyrÀ   Úpandas._libsr   Úpandas._libs.ops_dispatchr   Úpandas.core.dtypes.genericr   Úpandas.corer	   Úpandas.core.constructionr   Úpandas.core.ops.commonr   Úpandas.core.ops.invalidr   rý   r   rê   rÈ   rÓ   rð   rØ   rÔ   r‡   r#   r    ú<module>r     su   ðñõ #ã ÷ó
 å Ý Gå 1å !Ý 2Ý ;Ý Gð ØØØñ	Ð ÷k9ñ k9ódoódó óF'ó9ô #>r#   