U ;qLe\-@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)sqrtremcCsb|dkrtdt|}|dkrTtt|}d|||krLd|krTnn|St|ddS)z9Return the largest integer less than or equal to sqrt(n).rzn must be nonnegativel) ValueErrorint_sqrtinteger_nthroot)nsr)g/home/p21-0144/sympy/latex2sympy2solve-back-end/sympyEq/lib/python3.8/site-packages/sympy/core/power.pyisqrts $r+cCst|t|}}|dkr"td|dkr2tdtrx|dkrxtdkrXt||\}}nt||\}}t|t|fSt||S)a@ Return a tuple containing x = floor(y**(1/n)) and a boolean indicating whether the result is exact (that is, whether x**n == y). Examples ======== >>> 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#rrZirootrootbool_integer_nthroot_python)yr'xtr)r)r*r&.s r&c Csv|dkr|dfS|dkr |dfS|dkrBt|\}}t|| fS||krRdSzt|d|d}Wn\tk rt|d|}|dkrt|d}td ||d|>}n td |}YnX|d krd |}}||d}||d||||}}t||dkrܐq"qn|}||}||krH|d7}||}q*||krf|d8}||}qHt|||kfS) N)rrTrr")rFg?g?5g@l )mpmath_sqrtremr$ bit_length OverflowError_logabs) r/r'r0remZguessexpshiftZxprevr1r)r)r*r.Ys@          r.c Cs"|dkrtd|dkr td|dkrTt|}t|}|d}||||kfS|dkrt|dkrj|n| | \}}||ot|dkr|dn|d fSt|}t|}d}}||kr |}d}||krt||\}}|p|}||7}||kr||9}|d9}qq||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$rr5 integer_logr-divmod) r/r0er'brdmr9r)r)r*r=s4 &  r=cseZdZUdZdZdZded<ded<edydd Zdzd d Z e d dddZ e d dddZ 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}dcddZ5d~dedfZ6edgdhZ7fdidjZ8dkdlZ9dmdnZ:dodpZ;dqdrZdwdxZ?Z@S)Powa% 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/Zero_to_the_power_of_zero .. [3] https://en.wikipedia.org/wiki/Indeterminate_forms Tis_commutativeztuple[Expr, Expr]args_argsNcCs^|dkrtj}t|}t|}ddlm}t||s>t||rFtd||fD],}t|tsNtdt |j ddddd qN|r"|t j krt j S|t jkrt|t jrt jSt|t jrt|t jrt jSt|t jr|jrt j S|jd krt j S|t jkrt jS|t jkr|S|d kr,|s,t j S|jj d krn|t jkrd dlm}|t||jt||jSn`|jr~|js|jr|jr|j s|j!r|"r|j#r| }n|j$rt| | St j ||fkrt j S|t jkrt%|j&rt j St jSd dl'm(}|j)s |t jk r t||s ddl*m+}d dl'm,} d dl-m.} ||d d/\} } | | \} }t|| r|j0d |krt j| | S|j1r d dl2m3}m4}|||}|j!r |r || ||d d |t j5t j6kr t j| | S|7|}|dk r"|St8|||}|9|}t|tsJ|S|j:oV|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 stacklevelFr3ZAccumulationBoundsr AccumBounds) exp_polar) factor_termsr)fraction)sign)rTim);revaluater relationalrI isinstance TypeErrorr rtype__name__r ComplexInfinityNaNInfinityrOne NegativeOnerZero is_finite __class__Exp1!sympy.calculus.accumulationboundsrOrDminmax is_Symbol is_integer is_Integer is_numberis_Mul is_Numbercould_extract_minus_signis_evenis_oddr8 is_infinite&sympy.functions.elementary.exponentialrPis_Atom exprtoolsrQrsympy.simplify.radsimprS as_coeff_MulrGis_Add$sympy.functions.elementary.complexesrTrU ImaginaryUnitPi _eval_power__new__ _exec_constructor_postprocessorsrF)clsr@r?rVrIargrOrPrQrrScexnumdenrTrUr(objr)r)r*r|s                           z Pow.__new__rcCs |jtjkrddlm}|SdSNrrR)baser rdrrr)selfZargindexrr)r)r*inverse}s  z Pow.inverser )returncCs |jdS)NrrHrr)r)r*rszPow.basecCs |jdSNrrrr)r)r*r:szPow.expcCs|jjtkr|jjStSdSN)r:kindrrrrr)r)r*rs zPow.kindcCs dd|jfS)Nr")r[r~r)r)r* class_keysz Pow.class_keycCsrddlm}m}|\}}||||rn|rn||||rPt| |S||||rnt| | SdS)Nr)askQ) Zsympy.assumptions.askrr as_base_expintegerrnevenrDodd)r assumptionsrrr@r?r)r)r* _eval_refines  zPow._eval_refinecCs|\}}|tjkr"|||Sd}|jr4d}n.|jrBd}n |jdk rbddlm}m}m }m }ddl m } m } ddlm} dd} dd } |jr|d kr| |r|jd krtj|t| ||S|jd krt|| Sn0|jr|jrt|}|jrt||tj}t|dkd ks2|dkr8d}n|jrFd}n||jrjt|d kd krjd}nn| |rb| d tjtj|| tj|||d tj}|jr| |||dkr||}nd}nzl| d tjtj|| tj||| |d tj}|jr@| |||dkr@||}nd}Wntk r`d}YnX|dk r~|t|||SdS)Nrr)rrUrerTr:r)floorcSs6t|dddkrdS|\}}|jr2|dkr2dSdS)zZReturn True if the exponent has a literal 2 as the denominator, else None.qNr"T)getattras_numer_denomri)r?r'rBr)r)r*_halfs  zPow._eval_power.._halfcSs8z|jddd}|jr|WSWntk r2YnXdS)zXReturn ``e`` evaluated to a Number with 2 significant digits, else None.r"TstrictN)evalfrmr )r?rvr)r)r*_n2s  zPow._eval_power.._n2r3TFr")rr r]riis_polaris_extended_realrxrrUrrTrrr:r#sympy.functions.elementary.integersr is_negativer`rDror8 is_imaginaryryis_extended_nonnegativerzHalfr )rotherr@r?r(rrUrrTr:rrrrr)r)r*r{sd          "   zPow._eval_powerc Csr|j|j}}|jrn|jrn|jr6||dkr6tjSddlm}|jr|jr|jrt |t |t |}}}| }|dkr||kr| d|krt ||} t t || || |St t |||Sddl m} t|tr|jr|jr| ||}| t||dd|St|trn|jrn|jrnt | } | dkrn||} | | || }| t||dd|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)totientPrJr)ModFrVN)rr:ri is_positiver rasympy.ntheory.factor_rrjr$r5IntegerpowmodrrXrDrk) rrrr:rr@r?rCZmbphirr5r)r)r* _eval_Mods,       z Pow._eval_ModcCs|jjr|jjr|jjSdSr)r:rirrrorr)r)r* _eval_is_even+szPow._eval_is_evencCst|}|dkr|jS|SNT)rD_eval_is_extended_negativerb)rZext_negr)r)r*_eval_is_negative/s zPow._eval_is_negativecCs|j|jkr|jjrdSn|jjr0|jjrdSn|jjrR|jjrDdS|jjrdSn|jjrl|jj r|jjSnn|jj r|jjrdSnX|jj r|jj r|jd}|jrdS|j r|jdkrdS|jj rddl m}||jj SdS)NTFrJrrR)rr:rris_realis_extended_negativerorpis_zeroris_extended_nonpositiverrirrr)rrCrr)r)r*_eval_is_extended_positive5s6    zPow._eval_is_extended_positivecCs|jtjkr |jjs|jjr dS|jjrJ|jjr<|jjrdS|jsJ|jrNdS|jr|jr|jsf|jrt |dj rt |dj rdS|j r|j r|j |j}|j S|jr|jr|djrdS|jr|jr|djrdSdS)NFTr)rG is_rationalrirr r`rrrbrrrmfuncrj)rr@r?checkr)r)r*_eval_is_integers&      zPow._eval_is_integerc Cs|jtjkr8|jjrdS|jjr8dtj|jtjjSddl m }m}|jj}|dkr|jj |krv|jjjrv|jjS|jj t kr|jjtjkr|jjjr|jjSdS|jj}|dkrdS|r.|r.|jj rdS|jjr|jjrdS|jjr|jjrdS|jjr|jjrdS|jjr.|jjr.dS|r^|jjr^|jjdkr^t |j|j jS|jj}|jj}|r$|jjr|jjrdS|jjr$dSn|r||jjrdS|jjr|j\}}|r$|jr$t|j||j|ddjSn,|jtj tjfkr$|jdjdkr$dS|r|r|jtjkrBdS|jtj}|r|jjr|jr|jjr|jdjr|jrdS|||jtjj} | dk r| S|dkr|rddlm} | |j|jtj} | j r| jSdS) NTr"r)rr:Frrr)!rr rdr:rrryrzrorrrrrDrrriis_extended_nonzerorr is_Rationalrrprw as_coeff_AddrjMulr`coeffr is_nonzerorxrr) rrr:Zreal_bZreal_eZim_bim_eraokrir)r)r*_eval_is_extended_reals $            zPow._eval_is_extended_realcCsD|jtjkr t|jj|jjgStdd|jDr@| r@dSdS)Ncss|] }|jVqdSr)r).0rr)r)r* sz'Pow._eval_is_complex..T) rr rdrr:rrallrG_eval_is_finiterr)r)r*_eval_is_complexs zPow._eval_is_complexc Cs>|jjdkrdS|jjr8|jjr8|jj}|dk r4|SdS|jtjkrrd|jtjtj }|j rddS|jrndSdS|jjrddl m }||jj}|dk rdS|jj r|jj r|jjrdS|jj}|s|S|jjrdSd|jj}|r|jjS|S|jj dkr:ddlm}||j|jtj}d|j} | dk r:| SdS)NFr"TrrRr)rrFrr:rirpr rdrzryrorrrrrrrrxr) rrfrZimlograthalfrrZisoddr)r)r*_eval_is_imaginarysL        zPow._eval_is_imaginarycCs@|jjr<|jjr|jjS|jjr,|jjr,dS|jtjkr=2)-th power cannot be a prime. rFN)rrir:rrr)r)r*_eval_is_prime.szPow._eval_is_primecCsL|jjrH|jjrH|jdjr(|jdjsD|jdjrH|jjrH|jjrHdSdS)zS A power is composite if both base and exponent are greater than 1 rTN)rrir:rrrorr)r)r*_eval_is_composite5s   zPow._eval_is_compositecCs|jjSr)rrrr)r)r*_eval_is_polar>szPow._eval_is_polarcCsddlm}t|j|rT|j||}|j||}t||rH||S|||Sddlm}m }dd}||jks||kr|jt j kr|j rt|t r||j||S||j||St||jr|j|jkr||j|j} | jrt|| St||jrZ|j|jkrZ|jjdkr|jjtdd} |jjtdd} || | |\} } }| rZ||| }|dk r~t|t|j|}|Sn|j}g}g}|} |jjD]z}|||}|} || | |\} } }| r||| |dk r||qn|js|jsdS||q|rZt|}||dkrJt|j|dd n|jt|St||s||jr|jt j kr|jjr|jjr|jjtdd} |j||jjtdd} || | |\} } }| r||| }|dk rt|t|j|}|SdS) NrrNrc Ss$|\}}|\}}||kr |jr||}zt|ddd}Wn8tk rt|\} } | jrd| jpn| jon| j}YnX||dfSt|ts|f}t dd|DsdSzbt t|t|\}} |dkr| dkr|d 7}| t|8} | dkrd} nt | f|} d|| fWStk rYnXdS) 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. FrTNcss|] }|jVqdSr)ri)rtermr)r)r*rqsz1Pow._eval_subs.._check..)FNNrr) rFrr#rrrrrXtuplerr>r) ct1ct2oldZcoeff1Zterms1Zcoeff2Zterms2rZcombinesr@r? remainder remainder_powr)r)r*_checkMs8       zPow._eval_subs.._checkF)as_Addrr)rerOrXr:rsubs__rpow__rrrrr rd is_Functionr_subsrmrDrwas_independentSymbolr as_coeff_mulrGappendrFriAddis_Powrr)rrnewrOr@r?r:rrlrrrrrresultZoargZnew_lZo_alrnewaexpor)r)r* _eval_subsAsv     :       &6  zPow._eval_subscCs<|j\}}|jr4|j|jkr4|jdkr4d|| fS||fS)aReturn base and exp of self. Explanation =========== If base a Rational less than 1, then return 1/Rational, -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) >>> p.base, p.exp (1/2, 2) rr)rGrpr)rr@r?r)r)r*rs zPow.as_base_expcCsrddlm}|jj|jj}}|r2||j|jS|rF|j||jS|dkrn|dkrnt|}||krn||SdS)Nr)adjointF)rxrr:rirrr )rrrrexpandedr)r)r* _eval_adjoints zPow._eval_adjointcCs|ddlm}|jj|jj}}|r2||j|jS|rF|j||jS|dkrn|dkrnt|}||krn||S|jrx|SdS)Nr) conjugateF)rxrr:rirrr r)rrrrrr)r)r*_eval_conjugates zPow._eval_conjugatecCsddlm}|jtjkr,|tj|jS|jj|jjp@|jj }}|rV|j|jS|rj||j|jS|dkr|dkrt |}||kr||SdS)Nr) transposeF) rxrrr rdrr:rirrqr )rrrrrr)r)r*_eval_transposes   zPow._eval_transposec sjj}tjkrXddlm}t||rX|jrXddlm }| |j f|j S|j r|dds|jdks||r|jrtfdd|jDSjrt|jdd d d \}}|rtfd d|Dt|SS) za**(n + m) -> a**n*a**mr)Sum)ProductforceFcsg|]}|qSr)rrr0r@rr)r* sz.Pow._eval_expand_power_exp..cSs|jSrrEr0r)r)r*z,Pow._eval_expand_power_exp..Tbinarycsg|]}|qSr)r r r r)r*rs)rr:r rdsympy.concrete.summationsrrXrFsympy.concrete.productsr rfunctionlimitsrwgetr_all_nonneg_or_nonpposrrGrr _from_args)rhintsr?rr rncr)r r*_eval_expand_power_exps*    zPow._eval_expand_power_expc sTdd}j}j|js"S|jdd\}}|rfdd|D}jrjrbt|}n"tdd|dddD }|r|t|9}|S|sjt|dd St|g}t |d d d d \}}dd} t || } | d } || d7}| d} | t j } | rt j }t | d}|dkr0n|dkrF| |n~|dkr| rx|  }|t jk r| |n | t jn>| r|  }|t jk r| |n | t j| |~ |sԈjr| | |}|}njrtt | dkrjt j}|s&| djr&|| d9}t | dr:| }| D]}| | q>|t jk r| |n\| r|r| djr| dt jk r| t j| | d n || n || ~ | }||7}t j}|r2jrt |dd d d \}}tfdd|D}|tfdd|D9}|rP|jt|dd 9}|S)z(a*b)**n -> a**n * b**nr F)split_1cs&g|]}t|dr|jfn|qS)_eval_expand_power_base)hasattrrrr)rr)r*r*sz/Pow._eval_expand_power_base..cSsg|] }|dqS)r3r)r!r)r)r*r2sNr3rcSs |jdkSNF)rrr)r)r*r=rz-Pow._eval_expand_power_base..TrcSs4|tjkrtjS|j}|rdS|dkr0t|jSdSr)r ryrrr)r0polarr)r)r*pred?s z)Pow._eval_expand_power_base..predrJrrr"cSs|jo|jjo|jjSr)rr:rrrkrr)r)r*rscs g|]}|j|jqSr))rrGrr@r?rr)r*rscsg|]}j|ddqS)Frr r%r&r)r*rs)rrr:rlargs_cncrjrrrrr rylenrpopr_r`riAssertionErrorrmextendr)rrr r@cargsrrrZ maybe_realr$ZsiftedZnonnegnegimagIrZnonnor'Znpowr))r?rrr*rs  "                             zPow._eval_expand_power_basec s2|j\}|}|jrX|jdkrXjrX|jst|j|j}|sH|S|||g}}||}|jrx| }t |D]}| ||qt |St |}jrgg}} jD] } | jr| | q| | q|rLt | } t |} |dkrt| |dd|| | St| |ddd} t| | dd|| | Sjr\}} |jr| jr|js| js||j| j|}|j| j|j| j}} n ||j|}|j|j| }} n.| js|| j|}|| j| j}} nd}t |t | ddf\}} }}|r|d@rV||| || |||}}|d8}||| | d|| }} |d}qtj}|dkr|||St|||||S| }ddlm}ddlm}|t||}||f|S|dkrt fdd jDS|d jr>t fd d jDSt fd d jDSn|jr|jdkrjrt|j|jkrd||  S|jr*jr*|d dsЈjdks|r*gg}}|jD],}|jr| ||n | |qt ||t !|gS|Sd S)zA(a + b + ..)**n -> a**n + n*a**(n-1)*b + .., n is nonzero integerrr"Fdeepr)multinomial_coefficients)basic_from_dictcs g|]}jD] }||qqSr)rGrrg)rr)r*rsz0Pow._eval_expand_multinomial..cs g|]}jD] }||qqSr)r5r6multir)r*rscsg|] }|qSr)r))rrr8r)r*rsr N)"rGrrrwrjrrrr_eval_expand_multinomialr make_argsrr$rFis_Orderrrrk as_real_imagr rysympy.ntheory.multinomialr3Zsympy.polys.polyutilsr4r(r8rmrrrrr)rrr:rr'radicalZexpanded_base_nrZ order_termsZ other_termsr@rr0r7rkrrBr/rr3r4Zexpansion_dictrtailr))rr9r*r:s         "        zPow._eval_expand_multinomialc sb|jjrddlm}|j}|jj|d\}}|s<|tjfStdt d\|dkr|j r~|j r~t |j|}||kr~|S||}nj|d|d}||| |}}|j r|j rt ||tj | }||kr|S|| }dd| D} tfd d| D} d d| D} tfd d| D} d d| D} tfd d| D} | |tj |i| ||i| || ifSddlm} m}m}|jjr|jj|d\}}|jr*|jtjkr*|jr|tjfS|jr*tj|j |jfS|||d||dtj} | ||}|| |j||j}}||||||fS|jtjkrddlm}|j\}}|r|j|f|}|j|f|}||||}}||||||fSddlm}m}|rNd|d<|j|f|}| d|kr.cs(g|] \\}}}|||qSr)r)raabbccrr@r)r*r/s cSs$g|]}|ddddkr|qS)rrrJr)r!r)r)r*r1scs(g|] \\}}}|||qSr)r)rCrGr)r*r2s cSs$g|]}|ddddkr|qS)rrrJrr)r!r)r)r*r3scs(g|] \\}}}|||qSr)r)rCrGr)r*r4s )atan2cossinr:)rUrFcomplexignore)!r:rjsympy.polys.polytoolsrBrr=r rasymbolsDummyrmrrytermsrr(sympy.functions.elementary.trigonometricrHrIrJrrrrrrrdrrexpandrxrUrr)rr2rrBr:Zre_erexprmagrAZre_partZim_part1Zim_part3rHrIrJr1rptprr(rUrrr)rGr*r=sv      $  "  zPow.as_real_imagcCsFddlm}|j|}|j|}||||j||j|jSr)rrrrdiffr:)rr(rZdbaseZdexpr)r)r*_eval_derivativecs   zPow._eval_derivativecCs|\}}|tjkr6ddlm}||jdd|S||}|jsP||}|jr|j r|j dkr| || |}| }| || S| ||S)NrrKFr)rr rdrrr: _eval_evalf_evalfrjrrkrrrrS)rprecrr:Z exp_functionr)r)r*rZis     zPow._eval_evalfcCsF|jj|rdS|jj|r>t|j|o:|jjo:|jdkSdSdS)NFrT)r:hasrr-_eval_is_polynomialrjrsymsr)r)r*r^xs  zPow._eval_is_polynomialcCs|jjr,|jjr,tt|jj|jjgr,dS|j| }|j sF|jS| \}}|j rb|j rbdS|jr|jrt|js~|j rdS||krdSn |j r|jS|tjkr|jr|jrdSdS)NTF)r:rirrrrrrrrrrr is_irrationalr rdr)rrr@r?r)r)r*_eval_is_rationals*    zPow._eval_is_rationalcCs6dd}|jjs||jrdS|jtjkr|j|j}|j|jkr|jjr|jjrVdS|jtj j rhdS|jtj tj j rdSn|jSn|jj r|jjdkr|jjS|jjdkr|jjr|jjS|jjrdS|jj r|jjSnR|jjr2|jjr2t |jjrt ||js*|jjdks*|jjr2|jj SdS)NcSs(z |djWStk r"YdSXdS)NrF)rr#)rTr)r)r*_is_ones z'Pow._eval_is_algebraic.._is_oneTF)rrr rdrrGr:r is_algebraicrzrryrrrira)rrcr(r)r)r*_eval_is_algebraicsB        zPow._eval_is_algebraiccCs8|jj|rdS|jj|r0|j|o.|jjSdSdSr)r:r]r_eval_is_rational_functionrjr_r)r)r*rfs   zPow._eval_is_rational_functionc Cs|j||}|jj}|r|S|j||}|dkr@|rddl m!}||t j"r|dk rt#|$|\}}Wn^t#t%tfk r|j|t&d|||d}|t j't j(rpt%|$|\}}YnX||rddl)m*}||+}|j,s|j-r|j.s||j/|||dkr||||j||||d}|||||kr|S|S|j0||d}||t j1j+dd}|j-sDt%|||t2rd| |j3r~|||||S|j,r||}||kr|||||7}|Sdd} fdd}!z|j$||d\}}"WnVt#t%fk r.||||ddkr$||||||YSt%YnX|j4rf|"t j5krfddl)m6}#|#|j$||d\}}"|"j7s|8}|j,r||S|j$||d\}}"|"j7s|||9}|j$||d\}}"|"j7st%ddl:m;}$|j||$||d}%i}&t<=|%D]*}| ||\}'}(|&>|(t j5|'|&|(<qt j1})t j5t j1i}*|&}+dd l?m@},mA}-|)|"j3r|-||)|,|)}.|+D]$}|*>|t j5|.|+||*|<q||!|+|&}+|)t j17})qVdd!lBmC}/|jDsb|j,rb|j3rb||E||}0|/|0j3r| ||d"d#||\}1}2nF|/|0j,rN| ||||j0|||d|\}1}2n| |||\}1}2n| |||\}1}2t j5}|*D]&}(|(|2}||*|(|1||7}q~|jDr|j7r||"|jFr|tG|ks z|||||7}Wn4t%k r||||j||||dYSX|S)$Nrr)limit)Ordersympify)r'logxr)powsimpTr:)r2combine) powdenest)_illegal)r )r'rycdir)Wildzc, ex)r~exclude) polygammar") logcombineryr~ryF)rSc Sstjtj}}t|D]`}||rp|\}}||krxz||WStk rl|tjfYSXq||9}q||fSr) r r_rarr;r]rleadtermr#)rr0rr:factorrr)r)r* coeff_exps   z$Pow._eval_nseries..coeff_expcsNi}t||D]:\}}||}|kr||tj||||||<q|Sr)rrr ra)d1d2rese1e2rZmaxpowr)r*muls $zPow._eval_nseries..mul) nsimplify)ceiling) factorialffrUr3r<)Hrrr:rsympy.series.limitsrusympy.series.orderrvsympy.core.sympifyrxrr rdnseriesr<removeOrr^rangesympy.simplify.powsimprzr|numbersr}trigsimprr]r _eval_nseriessymbolrrOreplaceZ'sympy.functions.special.gamma_functionsr EulerGammar#rNotImplementedErrorrgr]r\sympy.simplify.simplifyrcancelrrkr_eval_as_leading_termas_leading_termr_rris_FloatrarrsimplifyrSrrrr;r(sympy.functions.combinatorial.factorialsrrrxrUridirrmr)3rr0r'ryr~r:rrurvrxZe_seriese0r1Z exp_seriesrrrzr|r}r@r?rrrr_rCrrrr7rArrrBrrZgpolyZgtermsZco1rr@rQZtkrrrrUndirZincoZinexr)rr*rTs                $            "     (  $zPow._eval_nseriescCsxddlm}m}|j}|j}|jtjkr||j||d}||d} | tjkrX| |d} | j dkrltj| St d|n| |r||||} | j|||dSddl m} z|j|||d} Wnt k r|YSX|jsh| jrh| |sh|| ||} | | jr0|| |dd |S| | jrh||j|||d}|j dkrh|||S|| |SdS) NrrrFzCannot expand %s around 0rrr3r<)rrr:rrr rdrrr]rurqrr]rxrUrirrrrr)rr0ryr~r:rr?r@rarg0ltrUrrZ log_leadtermr)r)r*rs8             zPow._eval_as_leading_termcGs$ddlm}||j||||S)Nr)binomial)rrr:r)rr'r0previous_termsrr)r)r* _taylor_term1s zPow._taylor_termcs|jtjk r tj||f|S|dkr.tjS|dkr|\}}t|j||d}|j||d\}}|jr|\}}|jr|tjkr||} ||| } tj} | jst| j | j \} } ||| } | ||t||| || j fSt||}|jr,|j r,|j||d\}}||| \} } | \} }| tj ks||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 rarr>rrrlrvr_)rr?rr@r?cepehr1ZcehrrAZicehrCmer)r)r*r`s*+    $  zPow.as_content_primitivec Os|}|ddr|}|\}}|d}|rJ||}||krJ|S|j|}|j|} | r|rjdS|d}|dkrdSn | dkrdS|dS)NrTrF)rrrequals is_constant) rwrtflagsrTr@r?ZbzrZeconZbconr)r)r*rs(      zPow.is_constantcCsF|j\}}||rB||sB||||}|||d|SdSr)rGr]r)rr'stepr@r?Znew_er)r)r*_eval_difference_deltas zPow._eval_difference_delta)N)r)T)NF)r)Nr)FT)Ar[ __module__ __qualname____doc__r __slots____annotations__r r|rpropertyrr:r classmethodrrr{rrrrrrrrrrrrrrrrrrrrrrr:r=rYrZr^rbrerfrgrhrlrrorrrrrrrrrrr __classcell__r)r)rr*rDs X b    T8D1   {z S ' % # " < "   QrDpower)r)r)rr)rrPrON)H __future__rtypingrmathrr7rr% itertoolsrrxrcacher singletonr rTr rr rr rrrrlogicrrrr parametersrrWrrrrrsympy.external.gmpyrrsympy.utilities.iterablesrsympy.utilities.exceptionsrsympy.utilities.miscrsympy.multipledispatchr mpmath.libmpr!r4r+r&r.r=rDraddobjectrrrrrrrrrPrOr)r)r)r*sX              +*7"