ó ~9­\c@ s2dZddlmZmZddlmZmZddlmZddl m Z ddl m Z eddd d d d d ddddddddddddddddddd d!gƒZ e jjƒZejd"ƒeeƒZd#efd$„ƒYZd%„Zd&„Zd'„Zd(efd)„ƒYZd*S(+s& This module contains the machinery handling assumptions. All symbolic objects have assumption attributes that can be accessed via .is_ attribute. Assumptions determine certain properties of symbolic objects and can have 3 possible values: True, False, None. True is returned if the object has the property and False is returned if it doesn't or can't (i.e. doesn't make sense): >>> from sympy import I >>> I.is_algebraic True >>> I.is_real False >>> I.is_prime False When the property cannot be determined (or when a method is not implemented) None will be returned, e.g. a generic symbol, x, may or may not be positive so a value of None is returned for x.is_positive. By default, all symbolic values are in the largest set in the given context without specifying the property. For example, a symbol that has a property being integer, is also real, complex, etc. Here follows a list of possible assumption names: .. glossary:: commutative object commutes with any other object with respect to multiplication operation. complex object can have only values from the set of complex numbers. imaginary object value is a number that can be written as a real number multiplied by the imaginary unit ``I``. See [3]_. Please note, that ``0`` is not considered to be an imaginary number, see `issue #7649 `_. real object can have only values from the set of real numbers. integer object can have only values from the set of integers. odd even object can have only values from the set of odd (even) integers [2]_. prime object is a natural number greater than ``1`` that has no positive divisors other than ``1`` and itself. See [6]_. composite object is a positive integer that has at least one positive divisor other than ``1`` or the number itself. See [4]_. zero object has the value of ``0``. nonzero object is a real number that is not zero. rational object can have only values from the set of rationals. algebraic object can have only values from the set of algebraic numbers [11]_. transcendental object can have only values from the set of transcendental numbers [10]_. irrational object value cannot be represented exactly by Rational, see [5]_. finite infinite object absolute value is bounded (arbitrarily large). See [7]_, [8]_, [9]_. negative nonnegative object can have only negative (nonnegative) values [1]_. positive nonpositive object can have only positive (only nonpositive) values. hermitian antihermitian object belongs to the field of hermitian (antihermitian) operators. Examples ======== >>> from sympy import Symbol >>> x = Symbol('x', real=True); x x >>> x.is_real True >>> x.is_complex True See Also ======== .. seealso:: :py:class:`sympy.core.numbers.ImaginaryUnit` :py:class:`sympy.core.numbers.Zero` :py:class:`sympy.core.numbers.One` Notes ===== Assumption values are stored in obj._assumptions dictionary or are returned by getter methods (with property decorators) or are attributes of objects/classes. References ========== .. [1] https://en.wikipedia.org/wiki/Negative_number .. [2] https://en.wikipedia.org/wiki/Parity_%28mathematics%29 .. [3] https://en.wikipedia.org/wiki/Imaginary_number .. [4] https://en.wikipedia.org/wiki/Composite_number .. [5] https://en.wikipedia.org/wiki/Irrational_number .. [6] https://en.wikipedia.org/wiki/Prime_number .. [7] https://en.wikipedia.org/wiki/Finite .. [8] https://docs.python.org/3/library/math.html#math.isfinite .. [9] http://docs.scipy.org/doc/numpy/reference/generated/numpy.isfinite.html .. [10] https://en.wikipedia.org/wiki/Transcendental_number .. [11] https://en.wikipedia.org/wiki/Algebraic_number iÿÿÿÿ(tprint_functiontdivision(t FactRulestFactKB(t BasicMeta(t integer_types(tshufflesinteger -> rationalsrational -> realsrational -> algebraicsalgebraic -> complexsreal -> complexsreal -> hermitiansimaginary -> complexs imaginary -> antihermitianscomplex -> commutatives"odd == integer & !evens!even == integer & !odds-real == negative | zero | positives'transcendental == complex & !algebraics(negative == nonpositive & nonzeros(positive == nonnegative & nonzeros,zero == nonnegative & nonpositives#nonpositive == real & !positives#nonnegative == real & !negatives zero -> even & finites%prime -> integer & positives.composite -> integer & positive & !primes,!composite -> !positive | !even | primes#irrational == real & !rationalsimaginary -> !realsinfinite -> !finites"noninteger == real & !integersnonzero == real & !zerotpolart StdFactKBcB s8eZdZeZdd„Zd„Zed„ƒZ RS(stA FactKB specialised for the built-in rules This is the only kind of FactKB that Basic objects should use. cC sY|si|_n-t|tƒs3|jƒ|_n |j|_|rU|j|ƒndS(N(t _generatort isinstanceRtcopyt generatortdeduce_all_facts(tselftfacts((s5lib/python2.7/site-packages/sympy/core/assumptions.pyt__init__×s  cC s |j|ƒS(N(t __class__(R((s5lib/python2.7/site-packages/sympy/core/assumptions.pyR âscC s |jjƒS(N(R R (R((s5lib/python2.7/site-packages/sympy/core/assumptions.pyR åsN( t__name__t __module__t__doc__t _assume_rulestrulestNoneRR tpropertyR (((s5lib/python2.7/site-packages/sympy/core/assumptions.pyRÐs  cC sd|S(s=Convert a fact name to the name of the corresponding propertysis_%s((tfact((s5lib/python2.7/site-packages/sympy/core/assumptions.pyt as_propertyêsc s(‡fd†}tˆƒ|_t|ƒS(s6Create the automagic property corresponding to a fact.c sXy|jˆSWnBtk rS|j|jkrF|jjƒ|_ntˆ|ƒSXdS(N(t _assumptionstKeyErrortdefault_assumptionsR t_ask(R(R(s5lib/python2.7/site-packages/sympy/core/assumptions.pytgetitòs  (Rt func_nameR(RR((Rs5lib/python2.7/site-packages/sympy/core/assumptions.pyt make_propertyïsc C sõ|j}|j}|j|dƒy||}Wntk rCn3X||ƒ}|dk rv|j||ffƒ|Sttj|ƒ}t |ƒx[|D]S}||kr²qšn||kršt ||ƒ|j |ƒ}|dk rí|SqšqšWdS(s£ Find the truth value for a property of an object. This function is called when a request is made to see what a fact value is. For this we use several techniques: First, the fact-evaluation function is tried, if it exists (for example _eval_is_integer). Then we try related facts. For example rational --> integer another example is joined rule: integer & !odd --> even so in the latter case if we are looking at what 'even' value is, 'integer' and 'odd' facts will be asked. In all cases, when we settle on some fact value, its implications are deduced, and the result is cached in ._assumptions. N( Rt _prop_handlert_tellRRR tlistRtprereqRRtget( Rtobjt assumptionst handler_maptevaluatetaR%tpktret_val((s5lib/python2.7/site-packages/sympy/core/assumptions.pyRþs,            tManagedPropertiescB seZdZd„ZRS(s0Metaclass for classes with old-style assumptionscO sltj|||Ži}xutD]m}t|ƒ}|jj|dƒ}t|ttt dƒfƒr |dk r€t|ƒ}n|||˜sR      <