ó ¡¼™\c>@ s×ddlmZmZddlmZddlmZddlmZm Z ddl m Z m Z m Z mZmZmZddlmZddlmZddlmZmZdd lmZdd lmZdd lmZdd lmZm Z m!Z!m"Z"m#Z#m$Z$dd l%m&Z&de#fd„ƒYZ'de'fd„ƒYZ(de'fd„ƒYZ)de'fd„ƒYZ*d„Z+d„Z,de'fd„ƒYZ-de'fd„ƒYZ.de/fd„ƒYZ0defd„ƒYZ1e1ƒZ2e2d „Z3xÛe eej4e)ej4ƒƒfe&e e(ej5ƒeej6e(ej6ƒƒƒfe e e(ej7ƒej7ƒfe e e(ej8ƒej8ƒfe e e(ej7ƒej7ƒfe e e(ej9ƒej9ƒfe e e(ej:ƒej9ƒfe e0d!„ƒfe e0d"„ƒfe e0d#„ƒfe e0d$„ƒfee.ej;ƒfe e e(ej;ƒej;ƒfe e e(ej<ej:Bƒe e*ej<ƒej<ƒƒfe e e(ej:ƒej:ƒfe e e(ej:ƒej:ƒfe e e(ej:ƒe e*ej=ƒej=ƒƒfe e e(ej:ƒe e*ej=ƒej=ƒƒfe e e(ej>ƒej>ƒfe e e(ej>ƒej>ƒfeej?feee(ej4ƒej4ƒfe e e(ej@ƒee)ejAƒejAƒƒfee e(ejAƒejAƒfee e(ejBƒejBƒfe e e(ej@ƒej@ƒfe e e*ej@ƒej@ƒfe e e(ej@ƒej@ƒfe e e*ej>ƒej@ƒfee e(ej@ƒej@ƒfee-ej8ƒfee-ej4ƒfee-ej7ƒfee-ej?ƒfee-ejCƒfee-ejDƒfee-ej>ƒfee-ej=ƒfee-ejAƒfee-ejBƒfee-ej@ƒfee-ej<ƒfee-ej8ƒfee-ej4ƒfee-ej7ƒfee-ej?ƒfee-ejCƒfee-ejDƒfee-ej>ƒfee-ej=ƒfee-ej<ƒfee-ej8ƒfee-ej4ƒfee-ej7ƒfee-ej?ƒfee-ejCƒfee-ejDƒfee-ej>ƒfee-ej=ƒfee-ej<ƒfg<D]\ZEZFe3eEeFƒq¶Wd%S(&iÿÿÿÿ(tprint_functiontdivision(t defaultdict(tQ(t PredicatetAppliedPredicate(tAddtMultPowtIntegertNumbert NumberSymbol(tMutableMapping(t ImaginaryUnit(tfuzzy_ort fuzzy_and(t Transform(t_sympify(tAbs(t EquivalenttImpliestAndtOrtBooleanFunctiontNot(tMatMultUnevaluatedOnFreecB s eZdZd„Zd„ZRS(s Represents a Boolean function that remains unevaluated on free predicates This is intended to be a superclass of other classes, which define the behavior on singly applied predicates. A free predicate is a predicate that is not applied, or a combination thereof. For example, Q.zero or Or(Q.positive, Q.negative). A singly applied predicate is a free predicate applied everywhere to a single expression. For instance, Q.zero(x) and Or(Q.positive(x*y), Q.negative(x*y)) are singly applied, but Or(Q.positive(x), Q.negative(y)) and Or(Q.positive, Q.negative(y)) are not. The boolean literals True and False are considered to be both free and singly applied. This class raises ValueError unless the input is a free predicate or a singly applied predicate. On a free predicate, this class remains unevaluated. On a singly applied predicate, the method apply() is called and returned, or the original expression returned if apply() returns None. When apply() is called, self.expr is set to the unique expression that the predicates are applied at. self.pred is set to the free form of the predicate. The typical usage is to create this class with free predicates and evaluate it using .rcall(). cC st|ƒ}|jtƒ}|jtƒ}|rE|rEtdƒ‚n|sstj||ƒ}||_d|_ |Sd„|Dƒ}t |ƒdkr¤tdƒ‚ntj||ƒ}|j ƒ|_ |j t d„d„ƒƒ|_|jƒ}|dkr|S|S(Ns4arg must be either completely free or singly appliedcS sh|]}|jd’qS(i(targs(t.0tpred((s<lib/python2.7/site-packages/sympy/assumptions/sathandlers.pys @s isDThe AppliedPredicates in arg must be applied to a single expression.cS s|jS(N(tfunc(te((s<lib/python2.7/site-packages/sympy/assumptions/sathandlers.pytEtcS s t|tƒS(N(t isinstanceR(R((s<lib/python2.7/site-packages/sympy/assumptions/sathandlers.pyR Es(RtatomsRRt ValueErrorRt__new__RtNonetexprtlentpoptxreplaceRtapply(tclstargt predicatestapplied_predicatestobjtpredicate_argstapplied((s<lib/python2.7/site-packages/sympy/assumptions/sathandlers.pyR%4s(    !  cC sdS(N((tself((s<lib/python2.7/site-packages/sympy/assumptions/sathandlers.pyR+Ls(t__name__t __module__t__doc__R%R+(((s<lib/python2.7/site-packages/sympy/assumptions/sathandlers.pyRs tAllArgscB seZdZd„ZRS(sP Class representing vectorizing a predicate over all the .args of an expression See the docstring of UnevaluatedOnFree for more information on this class. The typical usage is to evaluate predicates with expressions using .rcall(). Example ======= >>> from sympy.assumptions.sathandlers import AllArgs >>> from sympy import symbols, Q >>> x, y = symbols('x y') >>> a = AllArgs(Q.positive | Q.negative) >>> a AllArgs(Q.negative | Q.positive) >>> a.rcall(x*y) (Q.negative(x) | Q.positive(x)) & (Q.negative(y) | Q.positive(y)) cC s/tg|jjD]}|jj|ƒ^qŒS(N(RR'RRtrcall(R3R-((s<lib/python2.7/site-packages/sympy/assumptions/sathandlers.pyR+gs(R4R5R6R+(((s<lib/python2.7/site-packages/sympy/assumptions/sathandlers.pyR7PstAnyArgscB seZdZd„ZRS(sT Class representing vectorizing a predicate over any of the .args of an expression. See the docstring of UnevaluatedOnFree for more information on this class. The typical usage is to evaluate predicates with expressions using .rcall(). Example ======= >>> from sympy.assumptions.sathandlers import AnyArgs >>> from sympy import symbols, Q >>> x, y = symbols('x y') >>> a = AnyArgs(Q.positive & Q.negative) >>> a AnyArgs(Q.negative & Q.positive) >>> a.rcall(x*y) (Q.negative(x) & Q.positive(x)) | (Q.negative(y) & Q.positive(y)) cC s/tg|jjD]}|jj|ƒ^qŒS(N(RR'RRR8(R3R-((s<lib/python2.7/site-packages/sympy/assumptions/sathandlers.pyR+‚s(R4R5R6R+(((s<lib/python2.7/site-packages/sympy/assumptions/sathandlers.pyR9kst ExactlyOneArgcB seZdZd„ZRS(sS Class representing a predicate holding on exactly one of the .args of an expression. See the docstring of UnevaluatedOnFree for more information on this class. The typical usage is to evaluate predicate with expressions using .rcall(). Example ======= >>> from sympy.assumptions.sathandlers import ExactlyOneArg >>> from sympy import symbols, Q >>> x, y = symbols('x y') >>> a = ExactlyOneArg(Q.positive) >>> a ExactlyOneArg(Q.positive) >>> a.rcall(x*y) (Q.positive(x) & ~Q.positive(y)) | (Q.positive(y) & ~Q.positive(x)) c C s†|j}|j}g|jD]}|j|ƒ^q}tgtt|ƒƒD]2}t||tt || ||dƒŒ^qMŒS(Ni( R'RRR8RtrangeR(RtmapR(R3R'RR-t pred_argsti((s<lib/python2.7/site-packages/sympy/assumptions/sathandlers.pyR+s   %(R4R5R6R+(((s<lib/python2.7/site-packages/sympy/assumptions/sathandlers.pyR:†scC st|tƒs|S|jd}d}|jtjkrSt|j|j gƒ}n|jtj krq|j }n|jtj kržt|j|j gƒ}n|jtjkrËt|j|jgƒ}n|jtjkrøt|j|jgƒ}n|jtjkr4tt|j |jgƒ|jgƒ}n|jtjkrR|j}n|jtjkrp|j}n|jtjkrŽ|j}n|jtjkr¬|j}n|jtjkrÊ|j}n|jtjkrè|j }n|jtj!kr|j"}n|dkr|S|S(Ni(#R"RRR&RRtpositiveRt is_finitet is_positivetzerotis_zerotnegativet is_negativet nonpositivetis_nonpositivetnonzerot is_nonzerot nonnegativeRtis_nonnegativetrationalt is_rationalt irrationalt is_irrationalteventis_eventoddtis_oddtintegert is_integert imaginaryt is_imaginaryt commutativetis_commutative(R0Rtret((s<lib/python2.7/site-packages/sympy/assumptions/sathandlers.pyt_old_assump_replacer®sD          cC s|jttƒƒS(sû Replace assumptions of expressions replaced with their values in the old assumptions (like Q.negative(-1) => True). Useful because some direct computations for numeric objects is defined most conveniently in the old assumptions. (R*RR[(R((s<lib/python2.7/site-packages/sympy/assumptions/sathandlers.pytevaluate_old_assumpÜstCheckOldAssumpcB seZd„ZRS(cC s!t|jdt|jdƒƒS(Ni(RRR\(R3((s<lib/python2.7/site-packages/sympy/assumptions/sathandlers.pyR+ès(R4R5R+(((s<lib/python2.7/site-packages/sympy/assumptions/sathandlers.pyR]çst CheckIsPrimecB seZd„ZRS(cC s-ddlm}t|jd||jƒƒS(Niÿÿÿÿ(tisprimei(tsympyR_RRR'(R3R_((s<lib/python2.7/site-packages/sympy/assumptions/sathandlers.pyR+ís(R4R5R+(((s<lib/python2.7/site-packages/sympy/assumptions/sathandlers.pyR^ìst CustomLambdacB s eZdZd„Zd„ZRS(sn Interface to lambda with rcall Workaround until we get a better way to represent certain facts. cC s ||_dS(N(tlamda(R3Rb((s<lib/python2.7/site-packages/sympy/assumptions/sathandlers.pyt__init__øscG s |j|ŒS(N(Rb(R3R((s<lib/python2.7/site-packages/sympy/assumptions/sathandlers.pyR8ûs(R4R5R6RcR8(((s<lib/python2.7/site-packages/sympy/assumptions/sathandlers.pyRaòs tClassFactRegistrycB sPeZdZdd„Zd„Zd„Zd„Zd„Zd„Z d„Z RS( sÐ Register handlers against classes ``registry[C] = handler`` registers ``handler`` for class ``C``. ``registry[C]`` returns a set of handlers for class ``C``, or any of its superclasses. cC s5|p i}tt|ƒ|_tt|ƒjƒdS(N(Rt frozensettdtsuperRdRc(R3Rf((s<lib/python2.7/site-packages/sympy/assumptions/sathandlers.pyRcs cC st|ƒ|j|s°..;( .  $  07!!  0  "