+
    X°³j  ã                   óT   € R t ^ RIHt R.tR tR tR tR tR t	R t
 ! R	 R4      tR
# )zG
Mixin classes for custom array types that don't inherit from ndarray.
)ÚumathÚNDArrayOperatorsMixinc                óD   €  V P                   RJ #   \         d     R# i ; i)z)True when __array_ufunc__ is set to None.NF)Ú__array_ufunc__ÚAttributeError)Úobjs   &ÚQ/home/luca/screen-checking/.venv/lib/python3.14/site-packages/numpy/lib/mixins.pyÚ_disables_array_ufuncr	   	   s*   € ðØ×"Ñ" dÐ*Ð*øÜô Úðús   ‚ �žc                ó*   a € V 3R lpRV R2Vn         V# )z>Implement a forward binary method with a ufunc, e.g., __add__.c                 óB   <€ \        V4      '       d   \        # S! W4      # ©N©r	   ÚNotImplemented©ÚselfÚotherÚufuncs   &&€r   ÚfuncÚ_binary_method.<locals>.func   s   ø€ Ü  ×'Ò'Ü!Ð!Ù�TÓ!Ð!ó    Ú__©Ú__name__©r   Únamer   s   f& r   Ú_binary_methodr      s   ø€ õ"ð ˜˜˜b�M€D„MØ€Kr   c                ó*   a € V 3R lpRV R2Vn         V# )zAImplement a reflected binary method with a ufunc, e.g., __radd__.c                 óB   <€ \        V4      '       d   \        # S! W4      # r   r   r   s   &&€r   r   Ú&_reflected_binary_method.<locals>.func   s   ø€ Ü  ×'Ò'Ü!Ð!Ù�UÓ!Ð!r   Ú__rr   r   r   s   f& r   Ú_reflected_binary_methodr       s   ø€ õ"ð ˜$˜˜r�N€D„MØ€Kr   c                ó*   a € V 3R lpRV R2Vn         V# )zAImplement an in-place binary method with a ufunc, e.g., __iadd__.c                 ó   <€ S! WV 3R 7      # ))Úout© r   s   &&€r   r   Ú$_inplace_binary_method.<locals>.func'   s   ø€ Ù�T t gÔ.Ð.r   Ú__ir   r   r   s   f& r   Ú_inplace_binary_methodr'   %   s   ø€ õ/à˜$˜˜r�N€D„MØ€Kr   c                óB   € \        W4      \        W4      \        W4      3# )zEImplement forward, reflected and inplace binary methods with a ufunc.)r   r    r'   )r   r   s   &&r   Ú_numeric_methodsr)   -   s$   € ä˜5Ó'Ü$ UÓ1Ü" 5Ó/ð1ð 1r   c                ó*   a € V 3R lpRV R2Vn         V# )z.Implement a unary special method with a ufunc.c                 ó   <€ S! V 4      # r   r$   )r   r   s   &€r   r   Ú_unary_method.<locals>.func6   s   ø€ Ù�T‹{Ðr   r   r   r   s   f& r   Ú_unary_methodr-   4   s   ø€ õà˜˜˜b�M€D„MØ€Kr   c                   ó<  € ] tR t^<tRtRt]! ]P                  R4      t	]! ]P                  R4      t]! ]P                  R4      t]! ]P                  R4      t]! ]P                   R4      t]! ]P$                  R4      t]! ]P*                  R4      w  ttt]! ]P2                  R	4      w  ttt]! ]P:                  R
4      w  ttt ]! ]PB                  R4      w  t"t#t$]! ]PJ                  R4      w  t&t't(]! ]PR                  R4      w  t*t+t,]! ]PZ                  R4      w  t.t/t0]! ]Pb                  R4      t2]3! ]Pb                  R4      t4]! ]Pj                  R4      w  t6t7t8]! ]Pr                  R4      w  t:t;t<]! ]Pz                  R4      w  t>t?t@]! ]P‚                  R4      w  tBtCtD]! ]PŠ                  R4      w  tFtGtH]! ]P’                  R4      w  tJtKtL]M! ]Pœ                  R4      tO]M! ]P                   R4      tQ]M! ]P¤                  R4      tS]M! ]P¨                  R4      tURtVR# )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 a 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.

ÚltÚleÚeqÚneÚgtÚgeÚaddÚsubÚmulÚmatmulÚtruedivÚfloordivÚmodÚdivmodÚpowÚlshiftÚrshiftÚandÚxorÚorÚnegÚposÚabsÚinvertr$   N)Wr   Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__Ú	__slots__r   ÚumÚlessÚ__lt__Ú
less_equalÚ__le__ÚequalÚ__eq__Ú	not_equalÚ__ne__ÚgreaterÚ__gt__Úgreater_equalÚ__ge__r)   r5   Ú__add__Ú__radd__Ú__iadd__ÚsubtractÚ__sub__Ú__rsub__Ú__isub__ÚmultiplyÚ__mul__Ú__rmul__Ú__imul__r8   Ú
__matmul__Ú__rmatmul__Ú__imatmul__Útrue_divideÚ__truediv__Ú__rtruediv__Ú__itruediv__Úfloor_divideÚ__floordiv__Ú__rfloordiv__Ú__ifloordiv__Ú	remainderÚ__mod__Ú__rmod__Ú__imod__r<   Ú
__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__rF   Ú
__invert__Ú__static_attributes__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)rJ   Únumpy._corer   rL   Ú__all__r	   r   r    r'   r)   r-   r   r$   r   r   Ú<module>r—      sA   ðñõ $à"Ð
#€òòòòò1ò÷x4ó x4r   