Ë
    HU h   ã                   óF   — d Z dgZd„ Zd„ Zd„ Zd„ Zd„ Zd„ Z G d„ d«      Zy	)
zG
Mixin classes for custom array types that don't inherit from ndarray.
ÚNDArrayOperatorsMixinc                 ó>   — 	 | j                   du S # t        $ r Y yw xY w)z)True when __array_ufunc__ is set to None.NF)Ú__array_ufunc__ÚAttributeError)Úobjs    úH/var/www/timesheet/venv/lib/python3.12/site-packages/numpy/lib/mixins.pyÚ_disables_array_ufuncr      s*   € ðØ×"Ñ" dÐ*Ð*øÜò Ùðús   ‚ �	›c                 ó(   ‡ — ˆ fd„}d|› d�|_         |S )z>Implement a forward binary method with a ufunc, e.g., __add__.c                 ó8   •— t        |«      rt        S  ‰| |«      S ©N©r   ÚNotImplemented©ÚselfÚotherÚufuncs     €r   Úfuncz_binary_method.<locals>.func   s   ø€ Ü  Ô'Ü!Ð!Ù�T˜5Ó!Ð!ó    Ú__©Ú__name__©r   Únamer   s   `  r   Ú_binary_methodr      s   ø€ ô"ð ˜˜˜b�M€D„MØ€Kr   c                 ó(   ‡ — ˆ fd„}d|› d�|_         |S )zAImplement a reflected binary method with a ufunc, e.g., __radd__.c                 ó8   •— t        |«      rt        S  ‰|| «      S r   r   r   s     €r   r   z&_reflected_binary_method.<locals>.func   s   ø€ Ü  Ô'Ü!Ð!Ù�U˜DÓ!Ð!r   Ú__rr   r   r   s   `  r   Ú_reflected_binary_methodr      s   ø€ ô"ð ˜$˜˜r�N€D„MØ€Kr   c                 ó(   ‡ — ˆ fd„}d|› d�|_         |S )zAImplement an in-place binary method with a ufunc, e.g., __iadd__.c                 ó   •—  ‰| || f¬«      S )N)Úout© r   s     €r   r   z$_inplace_binary_method.<locals>.func&   s   ø€ Ù�T˜5 t gÔ.Ð.r   Ú__ir   r   r   s   `  r   Ú_inplace_binary_methodr#   $   s   ø€ ô/à˜$˜˜r�N€D„MØ€Kr   c                 óH   — t        | |«      t        | |«      t        | |«      fS )zEImplement forward, reflected and inplace binary methods with a ufunc.)r   r   r#   )r   r   s     r   Ú_numeric_methodsr%   ,   s*   € ä˜5 $Ó'Ü$ U¨DÓ1Ü" 5¨$Ó/ð1ð 1r   c                 ó(   ‡ — ˆ fd„}d|› d�|_         |S )z.Implement a unary special method with a ufunc.c                 ó   •—  ‰| «      S r   r!   )r   r   s    €r   r   z_unary_method.<locals>.func5   s   ø€ Ù�T‹{Ðr   r   r   r   s   `  r   Ú_unary_methodr(   3   s   ø€ ôà˜˜˜b�M€D„MØ€Kr   c                   ó>  — e Zd ZdZddlmZ dZ eej                  d«      Z
 eej                  d«      Z eej                  d«      Z eej                  d«      Z eej"                  d	«      Z eej&                  d
«      Z eej,                  d«      \  ZZZ eej4                  d«      \  ZZZ eej<                  d«      \  ZZ Z! eejD                  d«      \  Z#Z$Z% eejL                  d«      \  Z'Z(Z) eejT                  d«      \  Z+Z,Z- eej\                  d«      \  Z/Z0Z1 eejd                  d«      Z3 e4ejd                  d«      Z5 eejl                  d«      \  Z7Z8Z9 eejt                  d«      \  Z;Z<Z= eej|                  d«      \  Z?Z@ZA eej„                  d«      \  ZCZDZE eejŒ                  d«      \  ZGZHZI eej”                  d«      \  ZKZLZM eNejž                  d«      ZP eNej¢                  d«      ZR eNej¦                  d«      ZT eNejª                  d«      ZVy)r   aî  Mixin defining all operator special methods using __array_ufunc__.

    This class implements the special methods for almost all of Python's
    builtin operators defined in the `operator` module, including comparisons
    (``==``, ``>``, etc.) and arithmetic (``+``, ``*``, ``-``, etc.), by
    deferring to the ``__array_ufunc__`` method, which subclasses must
    implement.

    It is useful for writing classes that do not inherit from `numpy.ndarray`,
    but that should support arithmetic and numpy universal functions like
    arrays as described in :external+neps:doc:`nep-0013-ufunc-overrides`.

    As an trivial example, consider this implementation of an ``ArrayLike``
    class that simply wraps a NumPy array and ensures that the result of any
    arithmetic operation is also an ``ArrayLike`` object:

        >>> import numbers
        >>> class ArrayLike(np.lib.mixins.NDArrayOperatorsMixin):
        ...     def __init__(self, value):
        ...         self.value = np.asarray(value)
        ...
        ...     # One might also consider adding the built-in list type to this
        ...     # list, to support operations like np.add(array_like, list)
        ...     _HANDLED_TYPES = (np.ndarray, numbers.Number)
        ...
        ...     def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
        ...         out = kwargs.get('out', ())
        ...         for x in inputs + out:
        ...             # Only support operations with instances of
        ...             # _HANDLED_TYPES. Use ArrayLike instead of type(self)
        ...             # for isinstance to allow subclasses that don't
        ...             # override __array_ufunc__ to handle ArrayLike objects.
        ...             if not isinstance(
        ...                 x, self._HANDLED_TYPES + (ArrayLike,)
        ...             ):
        ...                 return NotImplemented
        ...
        ...         # Defer to the implementation of the ufunc
        ...         # on unwrapped values.
        ...         inputs = tuple(x.value if isinstance(x, ArrayLike) else x
        ...                     for x in inputs)
        ...         if out:
        ...             kwargs['out'] = tuple(
        ...                 x.value if isinstance(x, ArrayLike) else x
        ...                 for x in out)
        ...         result = getattr(ufunc, method)(*inputs, **kwargs)
        ...
        ...         if type(result) is tuple:
        ...             # multiple return values
        ...             return tuple(type(self)(x) for x in result)
        ...         elif method == 'at':
        ...             # no return value
        ...             return None
        ...         else:
        ...             # one return value
        ...             return type(self)(result)
        ...
        ...     def __repr__(self):
        ...         return '%s(%r)' % (type(self).__name__, self.value)

    In interactions between ``ArrayLike`` objects and numbers or numpy arrays,
    the result is always another ``ArrayLike``:

        >>> x = ArrayLike([1, 2, 3])
        >>> x - 1
        ArrayLike(array([0, 1, 2]))
        >>> 1 - x
        ArrayLike(array([ 0, -1, -2]))
        >>> np.arange(3) - x
        ArrayLike(array([-1, -1, -1]))
        >>> x - np.arange(3)
        ArrayLike(array([1, 1, 1]))

    Note that unlike ``numpy.ndarray``, ``ArrayLike`` does not allow operations
    with arbitrary, unrecognized types. This ensures that interactions with
    ArrayLike preserve a well-defined casting hierarchy.

    é    )Úumathr!   ÚltÚleÚeqÚneÚgtÚgeÚaddÚsubÚmulÚmatmulÚtruedivÚfloordivÚmodÚdivmodÚpowÚlshiftÚrshiftÚandÚxorÚorÚnegÚposÚabsÚinvertN)Wr   Ú
__module__Ú__qualname__Ú__doc__Únumpy._corer+   ÚumÚ	__slots__r   ÚlessÚ__lt__Ú
less_equalÚ__le__ÚequalÚ__eq__Ú	not_equalÚ__ne__ÚgreaterÚ__gt__Úgreater_equalÚ__ge__r%   r2   Ú__add__Ú__radd__Ú__iadd__ÚsubtractÚ__sub__Ú__rsub__Ú__isub__ÚmultiplyÚ__mul__Ú__rmul__Ú__imul__r5   Ú
__matmul__Ú__rmatmul__Ú__imatmul__Útrue_divideÚ__truediv__Ú__rtruediv__Ú__itruediv__Úfloor_divideÚ__floordiv__Ú__rfloordiv__Ú__ifloordiv__Ú	remainderÚ__mod__Ú__rmod__Ú__imod__r9   Ú
__divmod__r   Ú__rdivmod__ÚpowerÚ__pow__Ú__rpow__Ú__ipow__Ú
left_shiftÚ
__lshift__Ú__rlshift__Ú__ilshift__Úright_shiftÚ
__rshift__Ú__rrshift__Ú__irshift__Úbitwise_andÚ__and__Ú__rand__Ú__iand__Úbitwise_xorÚ__xor__Ú__rxor__Ú__ixor__Ú
bitwise_orÚ__or__Ú__ror__Ú__ior__r(   ÚnegativeÚ__neg__ÚpositiveÚ__pos__ÚabsoluteÚ__abs__rC   Ú
__invert__r!   r   r   r   r   ;   s  „ ñMõ\ (à€Iñ
 ˜BŸG™G TÓ*€FÙ˜BŸM™M¨4Ó0€FÙ˜BŸH™H dÓ+€FÙ˜BŸL™L¨$Ó/€FÙ˜BŸJ™J¨Ó-€FÙ˜B×,Ñ,¨dÓ3€Fñ #3°2·6±6¸5Ó"AÑ€GˆX�xÙ"2°2·;±;ÀÓ"FÑ€GˆX�xÙ"2°2·;±;ÀÓ"FÑ€GˆX�xÙ+;Ø
�	‰	�8ó,Ñ(€J�˜[á.>Ø
�‰˜	ó/#Ñ+€K�˜|á1AØ
�‰˜ó2%Ñ.€L�- á"2°2·<±<ÀÓ"GÑ€GˆX�xÙ §	¡	¨8Ó4€JÙ*¨2¯9©9°hÓ?€Kñ #3°2·8±8¸UÓ"CÑ€GˆX�xÙ+;Ø
�‰�xó,!Ñ(€J�˜[á+;Ø
�‰˜ó,"Ñ(€J�˜[á"2°2·>±>À5Ó"IÑ€GˆX�xÙ"2°2·>±>À5Ó"IÑ€GˆX�xÙ/°·±¸tÓDÑ€FˆG�Wñ ˜BŸK™K¨Ó/€GÙ˜BŸK™K¨Ó/€GÙ˜BŸK™K¨Ó/€GÙ˜rŸy™y¨(Ó3�Jr   N)	rF   Ú__all__r   r   r   r#   r%   r(   r   r!   r   r   ú<module>r’      s>   ðñð #Ð
#€òòòòò1ò÷y4ò y4r   