wg. UddlmZddlmZddlmZmZmZmZm Z m Z m Z ddl m Z ddlmZddlmZmZddZdZd Zd Zd Zd Zd ZdZdZdZeeeeeeeedZded<y)) annotations)Callable)SAddExprBasicMulPowRational) fuzzy_not)Boolean)askQct|ts|S|js2|jDcgc]}t ||}}|j |}t |dr|j|}||S|jj}tj|d}||S|||}|||k(r|St|ts|St ||Scc}w)a# Simplify an expression using assumptions. Explanation =========== Unlike :func:`~.simplify()` which performs structural simplification without any assumption, this function transforms the expression into the form which is only valid under certain assumptions. Note that ``simplify()`` is generally not done in refining process. Refining boolean expression involves reducing it to ``S.true`` or ``S.false``. Unlike :func:`~.ask()`, the expression will not be reduced if the truth value cannot be determined. Examples ======== >>> from sympy import refine, sqrt, Q >>> from sympy.abc import x >>> refine(sqrt(x**2), Q.real(x)) Abs(x) >>> refine(sqrt(x**2), Q.positive(x)) x >>> refine(Q.real(x), Q.positive(x)) True >>> refine(Q.positive(x), Q.real(x)) Q.positive(x) See Also ======== sympy.simplify.simplify.simplify : Structural simplification without assumptions. sympy.assumptions.ask.ask : Query for boolean expressions using assumptions. _eval_refineN) isinstanceris_Atomargsrefinefunchasattrr __class____name__ handlers_dictgetr)expr assumptionsargrref_exprnamehandlernew_exprs ]/home/mcse/projects/flask/flask-venv/lib/python3.12/site-packages/sympy/assumptions/refine.pyrr sJ dE " <<48II>SsK(>>tyy$t^$$$[1  O >> " "Dd+G t[)Hdh. h % (K ((!?sCcBddlm}|jd}tt j ||r*t tt j||r|Stt j||r| St|tr|jDcgc]}tt||}}g}g}|D]>}t||r|j|jd.|j|@t||t|zSycc}w)aF Handler for the absolute value. Examples ======== >>> from sympy import Q, Abs >>> from sympy.assumptions.refine import refine_abs >>> from sympy.abc import x >>> refine_abs(Abs(x), Q.real(x)) >>> refine_abs(Abs(x), Q.positive(x)) x >>> refine_abs(Abs(x), Q.negative(x)) -x rAbsN) $sympy.functions.elementary.complexesr&rrrrealr negativerr rabsappend) rrr&rarnon_absin_absis r# refine_absr1Gs"9 ))A,C 166#; $ c!**S/;7 8  1::c?K(t #s25(( ;QVCFK ( ; ; "A!S! affQi(q!  " G}s3<000 ;sDc~ ddlm}ddlm}t |j |rt tj|j jd|rOt tj|j|r&|j jd|jzSt tj|j |r|j jrt tj|j|r"t|j |jzSt tj|j|r5||j t|j |jzzSt |jtr]t |j t rCt|j j |j j|jzzS|j t"j$ur|jj&r|}|jj)\}}t+|}t+}t+}t-|} |D]d} t tj| |r|j/| 4t tj| |sT|j/| f||z}t-|dzr||z}|t"j0zdz} n ||z}|dz} | |k7st-|| kr&|j/| |j t3|z}d|jz} t tj| |r| j5r| |j z} | j&r| j7\} }|j8r|j t"j$urt tj:|j|r| dzdz } t tj| |r|j |jzSt tj| |r|j |jdzzS|j |j| zzS||k7r|Syyyy)as Handler for instances of Pow. Examples ======== >>> from sympy import Q >>> from sympy.assumptions.refine import refine_Pow >>> from sympy.abc import x,y,z >>> refine_Pow((-1)**x, Q.real(x)) >>> refine_Pow((-1)**x, Q.even(x)) 1 >>> refine_Pow((-1)**x, Q.odd(x)) -1 For powers of -1, even parts of the exponent can be simplified: >>> refine_Pow((-1)**(x+y), Q.even(x)) (-1)**y >>> refine_Pow((-1)**(x+y+z), Q.odd(x) & Q.odd(z)) (-1)**y >>> refine_Pow((-1)**(x+y+2), Q.odd(x)) (-1)**(y + 1) >>> refine_Pow((-1)**(x+3), True) (-1)**(x + 1) rr%)signN)r'r&sympy.functionsr3rbaserrr(revenexp is_numberr*oddr r r NegativeOneis_Add as_coeff_addsetlenaddOnercould_extract_minus_sign as_two_termsis_Powinteger)rrr&r3oldcoeffterms even_terms odd_termsinitial_number_of_termst new_coeffe2r0ps r# refine_PowrQmsj89$$))S! qvvdiinnQ'(+ 6AFF488$k299>>!$0 0 166$)) k* 99  166$((#[1499~11155?K0DIITYY488)CCC dhh )$))S)499>>*tyy}}txx/GHH 99 %xx $xx446 uE  U E *-e*')A166!9k2"q)QUU1X{3! a( ) #y>A%Y&E!&! 3IY&E % I%U6M)MIIi(99sE{3DtxxZqvvbz;/224dii99??,DAqxxAFFamm$;qyy/=!"Q A"166!9k:'+yy!%%'7 7!$QUU1X{!;'+yy15519'= ='+yy15519'= =$;Kg &+c*ddlm}|j\}}tt j |t j |z|r |||z Stt j|t j|z|r|||z tjz Stt j |t j|z|r|||z tjzStt j|t j|z|rtjStt j |t j|z|rtjdz Stt j|t j|z|rtj dz Stt j|t j|z|rtjS|S)a Handler for the atan2 function. Examples ======== >>> from sympy import Q, atan2 >>> from sympy.assumptions.refine import refine_atan2 >>> from sympy.abc import x, y >>> refine_atan2(atan2(y,x), Q.real(y) & Q.positive(x)) atan(y/x) >>> refine_atan2(atan2(y,x), Q.negative(y) & Q.negative(x)) atan(y/x) - pi >>> refine_atan2(atan2(y,x), Q.positive(y) & Q.negative(x)) atan(y/x) + pi >>> refine_atan2(atan2(y,x), Q.zero(y) & Q.negative(x)) pi >>> refine_atan2(atan2(y,x), Q.positive(y) & Q.zero(x)) pi/2 >>> refine_atan2(atan2(y,x), Q.negative(y) & Q.zero(x)) -pi/2 >>> refine_atan2(atan2(y,x), Q.zero(y) & Q.zero(x)) nan r)atanr4) (sympy.functions.elementary.trigonometricrTrrrr(positiver)rPizeroNaN)rrrTyxs r# refine_atan2r\s\2> 99DAq 166!9qzz!} $k2AE{ QZZ]QZZ] *K 8AE{QTT!! QZZ]QZZ] *K 8AE{QTT!! QVVAYA & 4tt QZZ]QVVAY & 4ttAv QZZ]QVVAY & 4uQw QVVAY "K 0uu  rRc|jd}ttj||r|Sttj||rt j St||S)a  Handler for real part. Examples ======== >>> from sympy.assumptions.refine import refine_re >>> from sympy import Q, re >>> from sympy.abc import x >>> refine_re(re(x), Q.real(x)) x >>> refine_re(re(x), Q.imaginary(x)) 0 r)rrrr( imaginaryrZero _refine_reimrrrs r# refine_rerbsQ ))A,C 166#; $  1;;s [)vv k **rRc|jd}ttj||rtj Sttj ||rtj |zSt||S)a Handler for imaginary part. Explanation =========== >>> from sympy.assumptions.refine import refine_im >>> from sympy import Q, im >>> from sympy.abc import x >>> refine_im(im(x), Q.real(x)) 0 >>> refine_im(im(x), Q.imaginary(x)) -I*x r) rrrr(rr_r^ ImaginaryUnitr`ras r# refine_imres^ ))A,C 166#; $vv  1;;s [) 3&& k **rRc|jd}ttj||rtj Sttj ||rtjSy)a" Handler for complex argument Explanation =========== >>> from sympy.assumptions.refine import refine_arg >>> from sympy import Q, arg >>> from sympy.abc import x >>> refine_arg(arg(x), Q.positive(x)) 0 >>> refine_arg(arg(x), Q.negative(x)) pi rN)rrrrVrr_r)rW)rrrgs r# refine_argrh+sJ 1B 1::b>;'vv  1::b>;'tt rRcX|jd}||k7rt||}||k7r|Sy)NT)complex)expandr)rrexpandedrefineds r#r`r`Bs6{{T{*H4;/ h N rRc|jd}ttj||rtj Sttj |r^ttj||rtjSttj||rtjSttj|rr|j\}}ttj||rtjSttj||rtj S|S)a* Handler for sign. Examples ======== >>> from sympy.assumptions.refine import refine_sign >>> from sympy import Symbol, Q, sign, im >>> x = Symbol('x', real = True) >>> expr = sign(x) >>> refine_sign(expr, Q.positive(x) & Q.nonzero(x)) 1 >>> refine_sign(expr, Q.negative(x) & Q.nonzero(x)) -1 >>> refine_sign(expr, Q.zero(x)) 0 >>> y = Symbol('y', imaginary = True) >>> expr = sign(y) >>> refine_sign(expr, Q.positive(im(y))) I >>> refine_sign(expr, Q.negative(im(y))) -I r)rrrrXrr_r(rVrBr)r<r^ as_real_imagrd)rrrarg_rearg_ims r# refine_signrrMs0 ))A,C 166#; $vv  166#; qzz# ,55L qzz# ,==  1;;s ))+ qzz&!; /?? " qzz&!; /OO# # KrRcddlm}|j\}}}tt j ||r||z j r|S||||Sy)aU Handler for symmetric part. Examples ======== >>> from sympy.assumptions.refine import refine_matrixelement >>> from sympy import MatrixSymbol, Q >>> X = MatrixSymbol('X', 3, 3) >>> refine_matrixelement(X[0, 1], Q.symmetric(X)) X[0, 1] >>> refine_matrixelement(X[1, 0], Q.symmetric(X)) X[0, 1] r) MatrixElementN)"sympy.matrices.expressions.matexprrtrrr symmetricrC)rrrtmatrixr0js r#refine_matrixelementryvsSA99LFAq 1;;v  , E + + -KVQ**-rR)r&r atan2reimrr3rtz*dict[str, Callable[[Expr, Boolean], Expr]]rN)T) __future__rtypingr sympy.corerrrrr r r sympy.core.logicr sympy.logic.boolalgr sympy.assumptionsrrrr1rQr\rbrerhr`rrryr__annotations__rRr#rs~">>>&'$9)x#1La H*Z+.+,.&R+.       ) = 9 rR