o
    oÇh:  ã                   @   sf   d Z ddlmZmZ ddlmZ ddlmZ dd„ ZG dd„ deƒZ	dd
d„Z
ddd„Zddd„Zd	S )a1  
Functions and wrapper object to call assumption property and predicate
query with same syntax.

In SymPy, there are two assumption systems. Old assumption system is
defined in sympy/core/assumptions, and it can be accessed by attribute
such as ``x.is_even``. New assumption system is defined in
sympy/assumptions, and it can be accessed by predicates such as
``Q.even(x)``.

Old assumption is fast, while new assumptions can freely take local facts.
In general, old assumption is used in evaluation method and new assumption
is used in refinement method.

In most cases, both evaluation and refinement follow the same process, and
the only difference is which assumption system is used. This module provides
``is_[...]()`` functions and ``AssumptionsWrapper()`` class which allows
using two systems with same syntax so that parallel code implementation can be
avoided.

Examples
========

For multiple use, use ``AssumptionsWrapper()``.

>>> from sympy import Q, Symbol
>>> from sympy.assumptions.wrapper import AssumptionsWrapper
>>> x = Symbol('x')
>>> _x = AssumptionsWrapper(x, Q.even(x))
>>> _x.is_integer
True
>>> _x.is_odd
False

For single use, use ``is_[...]()`` functions.

>>> from sympy.assumptions.wrapper import is_infinite
>>> a = Symbol('a')
>>> print(is_infinite(a))
None
>>> is_infinite(a, Q.finite(a))
False

é    )ÚaskÚQ)ÚBasic)Ú_sympifyc                    s   ‡ fdd„}|S )Nc                    s    t tˆ ƒ}t|| jƒ| jƒ}|S ©N)Úgetattrr   r   ÚexprÚassumptions)ÚselfÚpredÚret©Úfact© úm/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/sympy/assumptions/wrapper.pyÚgetit4   s   
zmake_eval_method.<locals>.getitr   )r   r   r   r   r   Úmake_eval_method3   s   r   c                       s  e Zd ZdZd$‡ fdd„	ZedƒZedƒZedƒZedƒZ	ed	ƒZ
ed
ƒZedƒZedƒZedƒZedƒZedƒZedƒZedƒZedƒZedƒZedƒZedƒZedƒZedƒZedƒZedƒZedƒZedƒZedƒZedƒZedƒZedƒZ ed ƒZ!ed!ƒZ"ed"ƒZ#ed#ƒZ$‡  Z%S )%ÚAssumptionsWrappera„  
    Wrapper over ``Basic`` instances to call predicate query by
    ``.is_[...]`` property

    Parameters
    ==========

    expr : Basic

    assumptions : Boolean, optional

    Examples
    ========

    >>> from sympy import Q, Symbol
    >>> from sympy.assumptions.wrapper import AssumptionsWrapper
    >>> x = Symbol('x', even=True)
    >>> AssumptionsWrapper(x).is_integer
    True
    >>> y = Symbol('y')
    >>> AssumptionsWrapper(y, Q.even(y)).is_integer
    True

    With ``AssumptionsWrapper``, both evaluation and refinement can be supported
    by single implementation.

    >>> from sympy import Function
    >>> class MyAbs(Function):
    ...     @classmethod
    ...     def eval(cls, x, assumptions=True):
    ...         _x = AssumptionsWrapper(x, assumptions)
    ...         if _x.is_nonnegative:
    ...             return x
    ...         if _x.is_negative:
    ...             return -x
    ...     def _eval_refine(self, assumptions):
    ...         return MyAbs.eval(self.args[0], assumptions)
    >>> MyAbs(x)
    MyAbs(x)
    >>> MyAbs(x).refine(Q.positive(x))
    x
    >>> MyAbs(Symbol('y', negative=True))
    -y

    Nc                    s0   |d u r|S t ƒ  | |t|ƒ¡}||_||_|S r   )ÚsuperÚ__new__r   r   r	   )Úclsr   r	   Úobj©Ú	__class__r   r   r   j   s   zAssumptionsWrapper.__new__Ú	algebraicÚantihermitianÚcommutativeÚcomplexÚ	compositeÚevenÚextended_negativeÚextended_nonnegativeÚextended_nonpositiveÚextended_nonzeroÚextended_positiveÚextended_realÚfiniteÚ	hermitianÚ	imaginaryÚinfiniteÚintegerÚ
irrationalÚnegativeÚ
nonintegerÚnonnegativeÚnonpositiveÚnonzeroÚoddÚpolarÚpositiveÚprimeÚrationalÚrealÚtranscendentalÚzeror   )&Ú__name__Ú
__module__Ú__qualname__Ú__doc__r   r   Ú_eval_is_algebraicÚ_eval_is_antihermitianÚ_eval_is_commutativeÚ_eval_is_complexÚ_eval_is_compositeÚ_eval_is_evenÚ_eval_is_extended_negativeÚ_eval_is_extended_nonnegativeÚ_eval_is_extended_nonpositiveÚ_eval_is_extended_nonzeroÚ_eval_is_extended_positiveÚ_eval_is_extended_realÚ_eval_is_finiteÚ_eval_is_hermitianÚ_eval_is_imaginaryÚ_eval_is_infiniteÚ_eval_is_integerÚ_eval_is_irrationalÚ_eval_is_negativeÚ_eval_is_nonintegerÚ_eval_is_nonnegativeÚ_eval_is_nonpositiveÚ_eval_is_nonzeroÚ_eval_is_oddÚ_eval_is_polarÚ_eval_is_positiveÚ_eval_is_primeÚ_eval_is_rationalÚ_eval_is_realÚ_eval_is_transcendentalÚ_eval_is_zeroÚ__classcell__r   r   r   r   r   <   sD    -r   Nc                 C   ó   |d u r| j S tt | ¡|ƒS r   )Úis_infiniter   r   r)   ©r   r	   r   r   r   r^   •   ó   r^   c                 C   r]   r   )Úis_extended_realr   r   r%   r_   r   r   r   ra   ›   r`   ra   c                 C   r]   r   )Úis_extended_nonnegativer   r   r!   r_   r   r   r   rb   ¡   r`   rb   r   )r<   Úsympy.assumptionsr   r   Úsympy.core.basicr   Úsympy.core.sympifyr   r   r   r^   ra   rb   r   r   r   r   Ú<module>   s    -	
Y
