+
    &i                     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   &N/var/www/html/photoedit/myenv/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    " bMDM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    " $rNDM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    Ttg..r   __ir   r   r   s   f& r   _inplace_binary_methodr'   %   s    /$rNDM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    bMDM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
 BGGT*FBMM40FBHHd+FBLL$/FBJJ-FB,,d3F #32665"AGXx"22;;"FGXx"22;;"FGXx+;
		8,(J[.>
	/#+K|1A
2%.L-"22<<"GGXx		84J*299h?K #3288U"CGXx+;
x,!(J[+;
,"(J["22>>5"IGXx"22>>5"IGXx/tDFGW BKK/GBKK/GBKK/Gryy(3Jr   N)rJ   numpy._corer   rL   __all__r	   r   r    r'   r)   r-   r   r$   r   r   <module>r      sA    $"
#1x4 x4r   