o *ήc%@sddlmZddlmZddlmZmZddl m Z ddl m Z ddl mZddlmZdd lmZdd lmZdd lmZmZmZmZmZdd lmZmZmZmZdd l m!Z!ddl"m#Z#m$Z$ddl%m&Z&m'Z'ddl(m)Z)m*Z*ddl+m,Z,ddl-m.Z.ddl/m0Z0ddl1m2Z2ddl3m4Z5ddZ6ddZ7ddZ8ddZ9GdddeZ:e2d Z;e;Z>dd"l?m@Z@dd#lAmBZBmCZCdd$lDmEZEmFZFmGZGd%S)&) annotations)Callable)logsqrt)product)_sympify)cacheit)S)Expr)PrecisionExhausted)expand_complexexpand_multinomial expand_mul_mexpand PoleError) fuzzy_bool fuzzy_not fuzzy_andfuzzy_or)global_parameters)is_gtis_lt) NumberKind UndefinedKind)HAS_GMPYgmpy)sift)sympy_deprecation_warning)as_int) Dispatcher)sqrtremcCs^|dkrtdt|}|dkr(tt|}d|||kr'd|kr(|St|ddS)z9Return the largest integer less than or equal to sqrt(n).rzn must be nonnegativel) ValueErrorint_sqrtinteger_nthroot)nsr)7/tmp/pip-target-vg8gfxp4/lib/python/sympy/core/power.pyisqrts r+cCst|t|}}|dkrtd|dkrtdtr<|dkr>> from sympy import integer_nthroot >>> integer_nthroot(16, 2) (4, True) >>> integer_nthroot(26, 2) (5, False) To simply determine if a number is a perfect square, the is_square function should be used: >>> from sympy.ntheory.primetest import is_square >>> is_square(26) False See Also ======== sympy.ntheory.primetest.is_square integer_log rzy must be nonnegativerzn must be positivelr")rr#rrirootrootbool_integer_nthroot_python)yr'xtr)r)r*r&.s  r&c Csv|dvr|dfS|dkr|dfS|dkr!t|\}}t|| fS||kr)dSz t|d|d}Wn-tybt|d|}|dkrZt|d}td ||d|>}ntd |}Ynw|d krd |}} ||d}||d||||}}t||dkrnqmn|}||}||kr|d7}||}||ks||kr|d8}||}||kst|||kfS) N)rrTrr")rFg?g?5g@l )mpmath_sqrtremr$ bit_length OverflowError_logabs) r0r'r1remguessexpshiftxprevr2r)r)r*r/YsN       r/c Cs*|dkrtd|dkrtd|dvr*t|}t|}|d}||||kfS|dkrPt|dkr5|n| | \}}||oNt|dkrI|dn|d fSt|}t|}d}}||kr|}d}||krt||\}}|pr|}||7}||kr||9}|d9}||ksh||ks`||dko|dkfS)a  Returns ``(e, bool)`` where e is the largest nonnegative integer such that :math:`|y| \geq |x^e|` and ``bool`` is True if $y = x^e$. Examples ======== >>> from sympy import integer_log >>> integer_log(125, 5) (3, True) >>> integer_log(17, 9) (1, False) >>> integer_log(4, -2) (2, True) >>> integer_log(-125,-5) (3, True) See Also ======== integer_nthroot sympy.ntheory.primetest.is_square sympy.ntheory.factor_.multiplicity sympy.ntheory.factor_.perfect_power rzx cannot take value as 1rzy cannot take value as 0)r"r")r#r$rr6 integer_logr.divmod) r0r1er'brdmr:r)r)r*r@s8 & r@cs eZdZUdZdZdZded<ded<edydd Zdzd d Z e d{ddZ e d{ddZ e ddZ eddZddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4Zd5d6Zd7d8Z d9d:Z!d;d<Z"d=d>Z#d?d@Z$dAdBZ%dCdDZ&dEdFZ'dGdHZ(d|dIdJZ)dKdLZ*dMdNZ+dOdPZ,dQdRZ-dSdTZ.dUdVZ/dWdXZ0dYdZZ1d[d\Z2d]d^Z3d}d`daZ4d~dcddZ5ddedfZ6edgdhZ7fdidjZ8dkdlZ9dmdnZ:dodpZ;dqdrZdwdxZ?Z@S)Powa4 Defines the expression x**y as "x raised to a power y" .. deprecated:: 1.7 Using arguments that aren't subclasses of :class:`~.Expr` in core operators (:class:`~.Mul`, :class:`~.Add`, and :class:`~.Pow`) is deprecated. See :ref:`non-expr-args-deprecated` for details. Singleton definitions involving (0, 1, -1, oo, -oo, I, -I): +--------------+---------+-----------------------------------------------+ | expr | value | reason | +==============+=========+===============================================+ | z**0 | 1 | Although arguments over 0**0 exist, see [2]. | +--------------+---------+-----------------------------------------------+ | z**1 | z | | +--------------+---------+-----------------------------------------------+ | (-oo)**(-1) | 0 | | +--------------+---------+-----------------------------------------------+ | (-1)**-1 | -1 | | +--------------+---------+-----------------------------------------------+ | S.Zero**-1 | zoo | This is not strictly true, as 0**-1 may be | | | | undefined, but is convenient in some contexts | | | | where the base is assumed to be positive. | +--------------+---------+-----------------------------------------------+ | 1**-1 | 1 | | +--------------+---------+-----------------------------------------------+ | oo**-1 | 0 | | +--------------+---------+-----------------------------------------------+ | 0**oo | 0 | Because for all complex numbers z near | | | | 0, z**oo -> 0. | +--------------+---------+-----------------------------------------------+ | 0**-oo | zoo | This is not strictly true, as 0**oo may be | | | | oscillating between positive and negative | | | | values or rotating in the complex plane. | | | | It is convenient, however, when the base | | | | is positive. | +--------------+---------+-----------------------------------------------+ | 1**oo | nan | Because there are various cases where | | 1**-oo | | lim(x(t),t)=1, lim(y(t),t)=oo (or -oo), | | | | but lim( x(t)**y(t), t) != 1. See [3]. | +--------------+---------+-----------------------------------------------+ | b**zoo | nan | Because b**z has no limit as z -> zoo | +--------------+---------+-----------------------------------------------+ | (-1)**oo | nan | Because of oscillations in the limit. | | (-1)**(-oo) | | | +--------------+---------+-----------------------------------------------+ | oo**oo | oo | | +--------------+---------+-----------------------------------------------+ | oo**-oo | 0 | | +--------------+---------+-----------------------------------------------+ | (-oo)**oo | nan | | | (-oo)**-oo | | | +--------------+---------+-----------------------------------------------+ | oo**I | nan | oo**e could probably be best thought of as | | (-oo)**I | | the limit of x**e for real x as x tends to | | | | oo. If e is I, then the limit does not exist | | | | and nan is used to indicate that. | +--------------+---------+-----------------------------------------------+ | oo**(1+I) | zoo | If the real part of e is positive, then the | | (-oo)**(1+I) | | limit of abs(x**e) is oo. So the limit value | | | | is zoo. | +--------------+---------+-----------------------------------------------+ | oo**(-1+I) | 0 | If the real part of e is negative, then the | | -oo**(-1+I) | | limit is 0. | +--------------+---------+-----------------------------------------------+ Because symbolic computations are more flexible than floating point calculations and we prefer to never return an incorrect answer, we choose not to conform to all IEEE 754 conventions. This helps us avoid extra test-case code in the calculation of limits. See Also ======== sympy.core.numbers.Infinity sympy.core.numbers.NegativeInfinity sympy.core.numbers.NaN References ========== .. [1] https://en.wikipedia.org/wiki/Exponentiation .. [2] https://en.wikipedia.org/wiki/Exponentiation#Zero_to_the_power_of_zero .. [3] https://en.wikipedia.org/wiki/Indeterminate_forms T)is_commutativeztuple[Expr, Expr]args_argsNcCs:|durtj}t|}t|}ddlm}t||st||r#td||fD]}t|ts=tdt |j ddddd q'|r|t j urIt j S|t jurzt|t jrWt jSt|t jrft|t jrft jSt|t jrz|jrrt j S|jd urzt j S|t jurt jS|t jur|S|d kr|st j S|jj d kr|t jkrd dlm}|t||jt||jSn'|jr|js|jr|jr|j s|j!r|"r|j#r| }n |j$rt| | St j ||fvrt j S|t jurt%|j&rt j St jSd dl'm(}|j)ss|t jurst||ssddl*m+}d dl'm,} d dl-m.} ||d d/\} } | | \} }t|| r?|j0d |kr?t j| | S|j1rsd dl2m3}m4}|||}|j!rs|rs|| ||d d |t j5t j6krst j| | S|7|}|dur|St8|||}|9|}t|ts|S|j:o|j:|_:|S)Nr) Relationalz Relational cannot be used in Powzf Using non-Expr arguments in Pow is deprecated (in this case, one of the arguments is of type zf). If you really did intend to construct a power with this base, use the ** operator instead.z1.7znon-expr-args-deprecated)deprecated_since_versionactive_deprecations_target stacklevelFr4AccumulationBoundsr AccumBounds) exp_polar) factor_termsr)fraction)sign)rWim);revaluater relationalrK isinstance TypeErrorr rtype__name__r ComplexInfinityNaNInfinityrOne NegativeOnerZero is_finite __class__Exp1!sympy.calculus.accumulationboundsrRrGminmax is_Symbol is_integer is_Integer is_numberis_Mul is_Numbercould_extract_minus_signis_evenis_oddr9 is_infinite&sympy.functions.elementary.exponentialrSis_Atom exprtoolsrTrsympy.simplify.radsimprV as_coeff_MulrIis_Add$sympy.functions.elementary.complexesrWrX ImaginaryUnitPi _eval_power__new__ _exec_constructor_postprocessorsrH)clsrCrBrYrKargrRrSrTrrVcexnumdenrWrXr(objr)r)r*rs                             z Pow.__new__rcCs |jtjkrddlm}|SdSNrrU)baser rgrur)selfargindexrr)r)r*inverse}s  z Pow.inversereturnr cC |jdSNrrJrr)r)r*r zPow.basecCrNrrrr)r)r*r<rzPow.expcCs|jjtur |jjStSN)r<kindrrrrr)r)r*rs zPow.kindcCs dd|jfS)Nr")r^rr)r)r* class_keys z Pow.class_keycCszddlm}m}|\}}||||r7|r9||||r(t| |S||||r;t| | SdSdSdS)Nr)askQ) sympy.assumptions.askrr as_base_expintegerrqevenrGodd)r assumptionsrrrCrBr)r)r* _eval_refines  zPow._eval_refinecCsj|\}}|tjur|||Sd}|jrd}n |jr!d}n|jdur%ddlm}m}m }m }ddl m } m } ddlm} dd} dd } |jr|d krr| |rq|jd urftj|t| ||S|jd urqt|| Sn|jr|jr|t|}|jrt||tj}t|dkd ks|dkrd}n|jrd}n||jrt|d kd krd}nx| |r| d tjtj|| tj|||d tj}|jr| |||dkr||}nFd}nCz6| d tjtj|| tj||| |d tj}|jr| |||dkr||}nd}Wn ty$d}Ynw|dur3|t|||SdS)Nrr)rrXrerWr<r)floorcSs:t|dddkr dS|\}}|jr|dkrdSdSdS)zZReturn True if the exponent has a literal 2 as the denominator, else None.qNr"T)getattras_numer_denomrl)rBr'rEr)r)r*_halfs  zPow._eval_power.._halfcSs6z|jddd}|jr|WSWdStyYdSw)zXReturn ``e`` evaluated to a Number with 2 significant digits, else None.r"TstrictN)evalfrpr )rBrvr)r)r*_n2s zPow._eval_power.._n2r4TFr")rr r`rlis_polaris_extended_realr{rrXrrWrur<r#sympy.functions.elementary.integersr is_negativercrGrrr9 is_imaginaryr|is_extended_nonnegativer}Halfr )rotherrCrBr(rrXrrWr<rrrrr)r)r*r~sn          "  zPow._eval_powerc Cst|j|j}}|jr|jr|jr||dkrtjSddlm}|jrd|jrd|jrdt |t |t |}}}| }|dkr\||kr\| d|kr\t ||} t t || || |St t |||Sddl m} t|tr|jr|jr| ||}| t||dd|St|tr|jr|jrt | } | dkr||} | | || }| t||dd|Sd Sd Sd Sd Sd Sd S) aOA dispatched function to compute `b^e \bmod q`, dispatched by ``Mod``. Notes ===== Algorithms: 1. For unevaluated integer power, use built-in ``pow`` function with 3 arguments, if powers are not too large wrt base. 2. For very large powers, use totient reduction if $e \ge \log(m)$. Bound on m, is for safe factorization memory wise i.e. $m^{1/4}$. For pollard-rho to be faster than built-in pow $\log(e) > m^{1/4}$ check is added. 3. For any unevaluated power found in `b` or `e`, the step 2 will be recursed down to the base and the exponent such that the $b \bmod q$ becomes the new base and $\phi(q) + e \bmod \phi(q)$ becomes the new exponent, and then the computation for the reduced expression can be done. r)totientPrLr)ModFrYN)rr<rl is_positiver rdsympy.ntheory.factor_rrmr$r6Integerpowmodrr[rGrn) rrrr<rrCrBrFmbphirr6r)r)r* _eval_Mods2        z Pow._eval_ModcCs |jjr |jjr|jjSdSdSr)r<rlrrrrrr)r)r* _eval_is_even+szPow._eval_is_evencCst|}|dur |jS|SNT)rG_eval_is_extended_negativere)rext_negr)r)r*_eval_is_negative/s zPow._eval_is_negativecCs|j|jkr|jjr dSdS|jjr|jjrdSdS|jjr,|jjr$dS|jjr*dSdS|jjr:|jj r8|jjSdS|jj rF|jjrDdSdS|jj rr|jj rb|jd}|jrXdS|j rb|jdurbdS|jj rtddl m}||jj SdSdS)NTFrLrrU)rr<rris_realis_extended_negativerrrsis_zeroris_extended_nonpositiverrlrur)rrFrr)r)r*_eval_is_extended_positive5sD    zPow._eval_is_extended_positivecCs|jtjur|jjs|jjrdS|jjr&|jjr|jjrdS|jj r$dSdS|jj r2|jjr0dSdS|jj r>|jjrz'Pow._eval_is_complex..T) rr rgrr<rrallrI_eval_is_finiterr)r)r*_eval_is_complexs zPow._eval_is_complexc Cs>|jjdurdS|jjr|jjr|jj}|dur|SdS|jtjkr9d|jtjtj }|j r2dS|jr7dSdS|jjrOddl m }||jj}|durOdS|jj ry|jj ry|jjr]dS|jj}|se|S|jjrkdSd|jj}|rw|jjS|S|jj durddlm}||j|jtj}d|j} | dur| SdSdS)NFr"TrrUr)rrHrr<rlrsr rgr}r|rrrurrrrrr{r) rrfrimlograthalfrrisoddr)r)r*_eval_is_imaginarysP        zPow._eval_is_imaginarycCsD|jjr|jjr |jjS|jjr|jjrdS|jtjur dSdSdSr)r<rlrrrsrr rcrr)r)r* _eval_is_odds zPow._eval_is_oddcCs||jjr|jjr dS|jjs|jjrdS|jj}|durdS|jj}|dur(dS|r8|r:|jjs6t|jjr=2)-th power cannot be a prime. rFN)rrlr<rrr)r)r*_eval_is_prime.s zPow._eval_is_primecCs\|jjr$|jjr&|jdjr|jdjs"|jdjr(|jjr*|jjr,dSdSdSdSdSdS)zS A power is composite if both base and exponent are greater than 1 rTN)rrlr<rrrrrr)r)r*_eval_is_composite5s   zPow._eval_is_compositecCs|jjSr)rrrr)r)r*_eval_is_polar>szPow._eval_is_polarcCsddlm}t|j|r*|j||}|j||}t||r$||S|||Sddlm}m }dd}||jksE||kr_|jt j kr_|j rVt|t rV||j||S||j||St||jrz|j|jkrz||j|j} | jrzt|| St||jr#|j|jkr#|jjdur|jjtdd} |jjtdd} || | |\} } }| r||| }|durt|t|j|}|Snd|j}g}g}|} |jjD]6}|||}|} || | |\} } }| r||| |dur||q|js|jsdS||q|r#t|}||dkrt|j|dd n|jt|St||s4|jrw|jt j ury|jjru|jjr{|jjtdd} |j||jjtdd} || | |\} } }| r}||| }|durst|t|j|}|SdSdSdSdSdS) NrrQrc Ss |\}}|\}}||kr|jr>||}z t|ddd}Wnty8|\} } | jr0| jp5| jo5| j}Ynw||dfSt|tsF|f}t dd|DsQdSz2t t|t|\}} |dkro| dkro|d 7}| t|8} | dkrvd} nt | g|R} d|| fWStyYdSwdS) a*Return (bool, pow, remainder_pow) where, if bool is True, then the exponent of Pow `old` will combine with `pow` so the substitution is valid, otherwise bool will be False. For noncommutative objects, `pow` will be an integer, and a factor `Pow(old.base, remainder_pow)` needs to be included. If there is no such factor, None is returned. For commutative objects, remainder_pow is always None. cti are the coefficient and terms of an exponent of self or old In this _eval_subs routine a change like (b**(2*x)).subs(b**x, y) will give y**2 since (b**x)**2 == b**(2*x); if that equality does not hold then the substitution should not occur so `bool` will be False. FrTNcsrr)rl)rtermr)r)r*rqrz1Pow._eval_subs.._check..)FNNrr) rHrr#rrrrr[tuplerrAr) ct1ct2oldcoeff1terms1coeff2terms2rcombinesrCrB remainder remainder_powr)r)r*_checkMs>        zPow._eval_subs.._checkF)as_Addrr)rhrRr[r<rsubs__rpow__rrurr rg is_Functionr_subsrprGrzas_independentSymbolr as_coeff_mulrIappendrHrlAddis_Powrr)rrnewrRrCrBr<rrlrrrrrresultoargnew_lo_alrnewaexpor)r)r* _eval_subsAsz     :        &6  zPow._eval_subscCs<|j\}}|jr|jdkr|jdkrt|j| fS||fS)aReturn base and exp of self. Explanation =========== If base is 1/Integer, then return Integer, -exp. If this extra processing is not needed, the base and exp properties will give the raw arguments Examples ======== >>> from sympy import Pow, S >>> p = Pow(S.Half, 2, evaluate=False) >>> p.as_base_exp() (2, -2) >>> p.args (1/2, 2) r)rIrprr)rrCrBr)r)r*rs zPow.as_base_expcCszddlm}|jj|jj}}|r||j|jS|r#|j||jS|dur7|dur9t|}||kr;||SdSdSdS)Nr)adjointF)r{rr<rlrrr )rrrrexpandedr)r)r* _eval_adjoints zPow._eval_adjointcCs|ddlm}|jj|jj}}|r||j|jS|r#|j||jS|dur7|dur7t|}||kr7||S|jr<|SdS)Nr) conjugateF)r{rr<rlrrr r)rrrrrr)r)r*_eval_conjugates zPow._eval_conjugatecCsddlm}|jtjkr|tj|jS|jj|jjp |jj }}|r+|j|jS|r5||j|jS|durI|durKt |}||krM||SdSdSdS)Nr) transposeF) r{rrr rgrr<rlrrtr )rrrrrr)r)r*_eval_transposes   zPow._eval_transposec sjj}tjkr-ddlm}t||r-|jr-ddlm }| |j g|j RS|j r@|jr@tfdd|jDS |S)za**(n + m) -> a**n*a**mr)Sum)Productcsg|]}|qSr)r)rr1rCrr)r* sz.Pow._eval_expand_power_exp..)rr<r rgsympy.concrete.summationsr!r[rHsympy.concrete.productsr"rfunctionlimitsrzrrI)rhintsrBr!r"r)r$r*_eval_expand_power_exps     zPow._eval_expand_power_expc s>dd}j}j|jsS|jdd\}}|r_fdd|D}jrNjr1t|}ntdd|dddD }|rL|t|9}|S|sZjt|dd St|g}t |d d d d \}}dd} t || } | d } || d7}| d} | t j } | rt j }t | d}|dkrnD|dkr| |n:|dkr| r|  }|t jur| |n$| t jn| r|  }|t jur| |n| t j| |~ |sjr| | |}|}nvjrJt | dkr*t j}|s| djr|| d9}t | dr| }| D] }| | q|t jur)| |n.| rS|rS| djrM| dt jurM| t j| | d n || n|| ~ | }||7}t j}|rjrt |dd d d \}}tfdd|D}|tfdd|D9}|r|jt|dd 9}|S)z(a*b)**n -> a**n * b**nforceF)split_1cs*g|]}t|dr|jdin|qS)_eval_expand_power_baser))hasattrr.rr)r*r)r*r%!s z/Pow._eval_expand_power_base..cSsg|]}|dqS)r4r)r0r)r)r*r%)Nr4rcSs |jduSNF)rr1r)r)r*4s z-Pow._eval_expand_power_base..T)binarycSs4|tjurtjS|j}|rdS|durt|jSdSr)r r|rrr)r1polarr)r)r*pred6s  z)Pow._eval_expand_power_base..predrLrrr"cSs|jo |jjo |jjSr)rr<rrrnr3r)r)r*r4scs g|] }|j|jqSr))rrIrrCrBrr)r*r% csg|] }j|ddqS)Frr#r8r9r)r*r%s)getrr<roargs_cncrmrrrrr r|lenr poprbrcrlrpextendr)rr*r,rCcargsncrr maybe_realr7siftednonnegnegimagIrnonnor'npowr))rBr*rr*r.s  "                           zPow._eval_expand_power_basec s|j\}|}|jr|jdkrjr|jsOt|j|j}|s$|S|||g}}||}|jr<| }t |D] }| ||qAt |St |}jrsgg}} jD]} | jrj| | q_| | q_|rt | } t |} |dkrt| |dd|| | St| |ddd} t| | dd|| | SjrV\}} |jrV| jrV|js| js||j| j|}|j| j|j| j}} n'||j|}|j|j| }} n| js|| j|}|| j| j}} nd}t |t | ddf\}} }}|r<|d@r&||| || |||}}|d8}||| | d|| }} |d}|s tj}|dkrJ|||St|||||S| }ddlm}ddlm}|t||}||g|RS|dkrt fdd jDS|d jrt fd d jDSt fd d jDS|jr|jdkrʈjrt|j|jkrd||  S|jrjrtjtj}}|jD]}|jr|||9}q||7}q|||S|S) zA(a + b + ..)**n -> a**n + n*a**(n-1)*b + .., n is nonzero integerrr"Fdeepr)multinomial_coefficients)basic_from_dictc g|] }jD]}||qqSr)rIrrg)rr)r*r%r:z0Pow._eval_expand_multinomial..crOr)rPrQmultir)r*r%s csg|]}|qSr)r))rrrSr)r*r%r1)rIrrrzrmrrrr_eval_expand_multinomialr make_argsr r$rHis_Orderrrrn as_real_imagr r|sympy.ntheory.multinomialrMsympy.polys.polyutilsrNr=r9rprbrd)rr*r<rr'radicalexpanded_base_nr order_terms other_termsrCrrIrRrkrrErGrrMrNexpansion_dictrtailr))rrTr*rUs        "       zPow._eval_expand_multinomialc sf|jjrddlm}|j}|jj|d\}}|s|tjfStdt d\|dkrG|j r>|j r>t |j|}||kr>|S||}n5|d|d}||| |}}|j rs|j rst ||tj | }||krs|S|| }dd| D} tfd d| D} d d| D} tfd d| D} d d| D} tfd d| D} | |tj |i| ||i| || ifSddlm} m}m}|jjrC|jj|d\}}|jr|jtjur|jr|tjfS|jrtj|j |jfS|||d||dtj} | ||}|| |j||j}}||||||fS|jtjurddlm}|j\}}|rl|j|fi|}|j|fi|}||||}}||||||fSddlm}m}|rd|d<|j|fi|}| d|krdS||||fS||||fS)Nr)polyrKza brr"cSs g|] }|ddds|qS)rrr"r)r0r)r)r*r%%r:z$Pow.as_real_imag..c(g|]\\}}}|||qSr)r)raabbccrrCr)r*r%&(cSs$g|]}|ddddkr|qS)rrrLr)r0r)r)r*r%($crcr)r)rdrhr)r*r%)ricSs$g|]}|ddddkr|qS)rrrLrr)r0r)r)r*r%*rjcrcr)r)rdrhr)r*r%+ri)atan2cossinr<)rXrFcomplexignore)!r<rmsympy.polys.polytoolsrbrrXr rdsymbolsDummyrprr|termsrr(sympy.functions.elementary.trigonometricrkrlrmrrrrrrrgruexpandr{rXrr;)rrLr*rbr<re_erexprmagrDre_partim_part1im_part3rkrlrmr2rptprr(rXrrr)rhr*rXsv     $  "  zPow.as_real_imagcCsFddlm}|j|}|j|}||||j||j|jSr)rurrdiffr<)rr(rdbasedexpr)r)r*_eval_derivativeZs   "zPow._eval_derivativecCs|\}}|tjkrddlm}||jdd|S||}|js(||}|jrK|j rK|j durK| || |}| }| || S| ||S)NrrnFr)rr rgrur< _eval_evalf_evalfrmrrnrrrrv)rprecrr< exp_functionr)r)r*r`s      zPow._eval_evalfcCsB|jj|rdS|jj|rt|j|o|jjo|jdkSdS)NFrT)r<hasrr._eval_is_polynomialrmrsymsr)r)r*ros  zPow._eval_is_polynomialcCs|jjr|jjrtt|jj|jjgrdS|j| }|j s#|jS| \}}|j r1|j r1dS|jrN|jrHt|js?|j rAdS||krGdSn|j rN|jS|tjur[|jr]|jr_dSdSdSdS)NTF)r<rlrrrrrrrrrrr is_irrationalr rgr)rrrCrBr)r)r*_eval_is_rationalys0    zPow._eval_is_rationalcCs8dd}|jjs ||jrdS|jtjurG|j|j}|j|jkrD|jjr@|jjr+dS|jtj j r4dS|jtj tj j rBdSdSdS|jS|jj rs|jjdurU|jjS|jjduri|jjrc|jjS|jjridS|jj rq|jjSdS|jjr|jjrt |jjrt ||js|jjdus|jjr|jj SdSdSdS)NcSs"z|djWStyYdSw)NrF)rr#)rxr)r)r*_is_ones   z'Pow._eval_is_algebraic.._is_oneTF)rrr rgrrIr<r is_algebraicr}rr|rrrlr)rrr(r)r)r*_eval_is_algebraicsL        zPow._eval_is_algebraiccC4|jj|rdS|jj|r|j|o|jjSdSr)r<rr_eval_is_rational_functionrmrr)r)r*r   zPow._eval_is_rational_functionc Cs|j||}|jj}|r|S|j||}|dur |rdSdS|dur&dS|j||}|j}|r5d}n t|jt|f}|durD|S|durJdS|sN|S|j||jSr2) r_eval_is_meromorphicr<rmrrrrer) rr1r base_merom exp_integer exp_meromrCb_zero log_definedr)r)r*rs* zPow._eval_is_meromorphiccCrr)r<rr_eval_is_algebraic_exprrrr)r)r*rrzPow._eval_is_algebraic_exprcKsddlm}m}|js||s||r||S|tr=tjr0tt j ||||tdS|||||tdSddl m }m }||||t j|||S)Nrrr)rAbs)rur<rrrr r exp_is_powrGr rgr{rrr|)rrrkwargsr<rrrr)r)r*_eval_rewrite_as_exps "zPow._eval_rewrite_as_expcCs |js|tjfS|\}}|\}}|j}|jr#|s#|js#|}|j }|j s0|s0|}tj}|j }|r=| | }}n |durH|sH|}tj}|rR||}}| }|j ry|tjurg|tjurg|| ||fS|tjury|tjury| |||fS| ||| ||fSr)rHr rbrrrrorrqrlris_nonpositivertr)rrr<r'rEneg_expint_expdnonposr)r)r*rs4      zPow.as_numer_denomFc Cst|}|dur i}|tjur|jtj|}|dur|St|ts$dS|\}}|\}}|j rO|j rO|rO|j rE|||||S||d||S| }|j ||}|dur`dS|j|||}|durut|||S|Sr)rr rbr<matchesrdr[r rrkrmrcopyrxreplace) rrx repl_dictrrErCrBsbser)r)r*r)s.    z Pow.matchesrc0 s<ddlm}m}ddlm}ddlm}|jtj ur|jj |||d} | j r*d| S|| |d} | tj ur>||||S| tjurE|S| | } || } } td|D]}| | |9} | j |||d} | | 7} qT| || ||7} ddlm}|| dd d Sdd lm}dd lm}||dd }|\}}|j|rt||r||||j||||dS|dur||rddlm}td||gd\}}|||||||||}||}| }zddlm}||tj r|durt!|"|\}}Wn.t!t#tfy3|j|t$d|||d }|tj%tj&r*t#|"|\}}Ynw||rFddl'm(}||)}|j*sp|j+rR|j,sp||||j||||d}|||||urn|S|S|j-||d}||tj.j)dd}|j+st#|||j/r|||||S|j*r||}||kr|||||7}|Sdd}fdd} z |j"||d\}}!Wn(t!t#fy||||ddkr||||||YSt#w|!j0s'|1}|j*r||S|j"||d\}}!|!j0s'|||2}|j"||d\}}!|!j0s't#ddl3m4}"|j||"||d }#i}$t56|#D]} || |\}%}&|$7|&tj8|%|$|&<qAtj.}'tj8tj.i}(|$})ddl9m:}*m;}+|'|!j/r|+||'|*|'},|)D]}|(7|tj8|,|)||(|<q}| |)|$})|'tj.7}'|'|!j/srddls|j*r|j,r|j/r|-||?||j/r||||d|tj@tjA|\}.}/n ||||\}.}/tj8}|(D]}&|&|/}||(|&|.||7}q|j>r|j0r||!|jBr|tC|ks|||||7}|S) Nrr)limit)Order)r'logxr)powsimpTr<)rLcombine) powdenest)_illegal)r,)r'rcdir)Wildzc, ex)rexclude) polygammar") logcombinerF)rvc Sstjtj}}t|D]/}||r7|\}}||kr6z||WSty5|tjfYSwq ||9}q ||fSr) r rbrdrrVrrleadtermr#)rr1rr<factorrr)r)r* coeff_exps    z$Pow._eval_nseries..coeff_expcsNi}t||D]\}}||}|kr$||tj||||||<q|Sr)rr;r rd)d1d2rese1e2rmaxpowr)r*muls"zPow._eval_nseries..mul)ceiling) factorialffrXr?)Drur<rsympy.series.limitsrsympy.series.orderrrr rgnseriesrWremoveOrrarangesympy.simplify.powsimprrnumbersrtrigsimprrr _eval_nseriessymbolrrrreplace'sympy.functions.special.gamma_functionsr EulerGammar#rNotImplementedErrorrjr`r_sympy.simplify.simplifyrcancelrrnras_leading_termrbrrsimplifyrvrrrrVr;rd(sympy.functions.combinatorial.factorialsrrr{rXrldirr}r|rr)0rr1r'rrr<rrre_seriese0r2 exp_seriesrrrrrrCrBrrrr_rFrrrrRrDrrrErgpolygtermsco1rr_rttkrrrrXincoinexr)rr*rKs               $         "   ,  zPow._eval_nseriesc Cs:ddlm}m}|j}|j}|jtjur<|j||d}||d} | tjur,| |d} | j dur6tj| St d|| |rQ||||} | j|||dSddl m} z |j|||d} Wn t yl|YSw|js| r| jr| jr| || ||jr|| ||d|tjtjS|| |S) NrrrFzCannot expand %s around 0)rrrr?)rur<rrr rgrrr`rrtrrr{rXrl is_constantrrrrr}r|) rr1rrr<rrBrCrarg0ltrXrr)r)r*_eval_as_leading_terms6          $ zPow._eval_as_leading_termcGs$ddlm}||j||||S)Nr)binomial)rrr<r)rr'r1previous_termsrr)r)r* _taylor_terms zPow._taylor_termcs|jtjurtj||g|RS|dkrtjS|dkrtjSddlm}||}|r9|d}|dur9|||Sddlm }||||S)Nrr)sympifyr4)r) rr rgsuper taylor_termrdrbrrr)rr'r1rrrrrfr)r*rs    zPow.taylor_termcCsL|jtjur$ddlm}|tj|jtjdtj|tj|jSdS)Nr)rmr")rr rgrurmr|r<r})rrr<rmr)r)r*_eval_rewrite_as_sin#  0zPow._eval_rewrite_as_sincCsL|jtjur$ddlm}|tj|jtj|tj|jtjdSdS)Nr)rlr")rr rgrurlr|r<r})rrr<rlr)r)r*_eval_rewrite_as_cos(rzPow._eval_rewrite_as_coscCs@|jtjurddlm}d||jdd||jdSdS)Nr)tanhrr")rr rg%sympy.functions.elementary.hyperbolicrr<)rrr<rr)r)r*_eval_rewrite_as_tanh-s  $zPow._eval_rewrite_as_tanhc Ksddlm}m}|tjurdS|jr@|tjtj}|rB|j rD|tj||tj|}}t ||sFt ||sH|tj|SdSdSdSdSdS)Nr)rmrl) rurmrlr rgrorr}r|rnr[) rrr<rrmrlrcosinesiner)r)r*_eval_rewrite_as_sqrt2s  zPow._eval_rewrite_as_sqrtc Cs6|\}}t|j||d}|j||d\}}|jrZ|\}}|jrZ|tjkrZ||} ||| } tj} | jsHt| j | j \} } ||| } | ||t||| || j fSt||}|jr|j r|j||d\}}||| \} } | \} }| tj us||kr| |t| ||fStj |||fS)aReturn the tuple (R, self/R) where R is the positive Rational extracted from self. Examples ======== >>> from sympy import sqrt >>> sqrt(4 + 4*sqrt(2)).as_content_primitive() (2, sqrt(1 + sqrt(2))) >>> sqrt(3 + 3*sqrt(2)).as_content_primitive() (1, sqrt(3)*sqrt(1 + sqrt(2))) >>> from sympy import expand_power_base, powsimp, Mul >>> from sympy.abc import x, y >>> ((2*x + 2)**2).as_content_primitive() (4, (x + 1)**2) >>> (4**((1 + y)/2)).as_content_primitive() (2, 4**(y/2)) >>> (3**((1 + y)/2)).as_content_primitive() (1, 3**((y + 1)/2)) >>> (3**((5 + y)/2)).as_content_primitive() (9, 3**((y + 1)/2)) >>> eq = 3**(2 + 2*x) >>> powsimp(eq) == eq True >>> eq.as_content_primitive() (9, 3**(2*x)) >>> powsimp(Mul(*_)) 3**(2*x + 2) >>> eq = (2 + 2*x)**y >>> s = expand_power_base(eq); s.is_Mul, s (False, (2*x + 2)**y) >>> eq.as_content_primitive() (1, (2*(x + 1))**y) >>> s = expand_power_base(_[1]); s.is_Mul, s (True, 2**y*(x + 1)**y) See docstring of Expr.as_content_primitive for more examples. )r[clear)r _keep_coeffas_content_primitiverrr rdrrArrroryrb)rr[rrCrBcepehr2cehrrDicehrFmer)r)r*r=s* +   $   zPow.as_content_primitivec Os|}|ddr |}|\}}|d}|r%||}||kr%|S|j|}|j|} | rA|r5dS|d}|dur@dSn| durGdS|dS)NrTrF)r;rrequalsr) rwrtflagsrxrCrBbzreconbconr)r)r*rs*       zPow.is_constantcCsJ|j\}}||r!||s#||||}|||d|SdSdSr)rIrr)rr'steprCrBnew_er)r)r*_eval_difference_deltas zPow._eval_difference_deltar)r)rr )Tr2)rr)FT)Ar^ __module__ __qualname____doc__r __slots____annotations__r rrpropertyrr<r classmethodrrr~rrrrrrrrrrrrrrrrrrrr r+r.rUrXrrrrrrrrrrrrrrrrrrrrrr __classcell__r)r)rr*rGs X  b     T8D1    { zS ' %  # " *   QrGpower)r)r)rr)r rsrrN)H __future__rtypingrmathrr8rr% itertoolsrrrcacher singletonr rxr rr r(r rrrrlogicrrrr parametersrrZrrrrrsympy.external.gmpyrrsympy.utilities.iterablesrsympy.utilities.exceptionsrsympy.utilities.miscrsympy.multipledispatchr mpmath.libmpr!r5r+r&r/r@rGraddobjectrrrrrrrr rsrrr)r)r)r*sX             +*7~