U 9%e\-@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)O/var/www/html/Darija-Ai-API/env/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'r0remguessexpshiftZxprevr1r)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)Zdeprecated_since_versionZactive_deprecations_target stacklevelFr3ZAccumulationBoundsr AccumBounds) exp_polar) factor_termsr)fraction)sign)rSim);revaluater relationalrJ isinstance TypeErrorr rtype__name__r ComplexInfinityNaNInfinityrOne NegativeOnerZero is_finite __class__Exp1!sympy.calculus.accumulationboundsrNrEminmax is_Symbol is_integer is_Integer is_numberis_Mul is_Numbercould_extract_minus_signis_evenis_oddr8 is_infinite&sympy.functions.elementary.exponentialrOZis_AtomZ exprtoolsrPrZsympy.simplify.radsimprR as_coeff_MulrHis_Add$sympy.functions.elementary.complexesrSrT ImaginaryUnitPi _eval_power__new__Z _exec_constructor_postprocessorsrG)clsrAr@rUrJargrNrOrPrrRcexnumZdenrSrTr(objr)r)r*rxs                           z Pow.__new__rcCs |jtjkrddlm}|SdSNrrQ)baser rcrqr)selfZargindexrr)r)r*inverse}s  z Pow.inverser )returncCs |jdS)NrrIrr)r)r*rszPow.basecCs |jdSNrrrr)r)r*r;szPow.expcCs|jjtkr|jjStSdSN)r;kindrrrrr)r)r*rs zPow.kindcCs dd|jfS)Nr")rZryr)r)r* class_keysz Pow.class_keycCsrddlm}m}|\}}||||rn|rn||||rPt| |S||||rnt| | SdS)Nr)askQ) Zsympy.assumptions.askrr as_base_expintegerrmZevenrEodd)rZ assumptionsrrrAr@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)rzrTrerSr;r)floorcSs6t|dddkrdS|\}}|jr2|dkr2dSdS)zZReturn True if the exponent has a literal 2 as the denominator, else None.qNr"T)getattras_numer_denomrh)r@r'rCr)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)evalfrlr )r@rvr)r)r*_n2s  zPow._eval_power.._n2r3TFr")rr r\rhis_polaris_extended_realrtrzrTrrSrqr;r#sympy.functions.elementary.integersr is_negativer_rErnr8 is_imaginaryruis_extended_nonnegativervHalfr )rotherrAr@r(rzrTrrSr;rrrrr)r)r*rwsd          "   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)totientPrKr)ModFrUN)rr;rh is_positiver r`Zsympy.ntheory.factor_rrir$r5IntegerpowmodrrWrErj) rrrr;rrAr@rDmbphirr5r)r)r* _eval_Mods,       z Pow._eval_ModcCs|jjr|jjr|jjSdSr)r;rhrrrnrr)r)r* _eval_is_even+szPow._eval_is_evencCst|}|dkr|jS|SNT)rE_eval_is_extended_negativera)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)NTFrKrrQ)rr;rris_realis_extended_negativernrois_zeroris_extended_nonpositiverrhrqr)rrDrr)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)rH is_rationalrhrr r_rrrarrrlfuncri)rrAr@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;Frrrz)!rr rcr;rrrurvrnrqrrrErrrhZis_extended_nonzerorr is_Rationalrrors as_coeff_AddriMulr_coeffr is_nonzerortrzr) rrr;Zreal_bZreal_eZim_bim_er{aokrzir)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 rcrr;rrallrH_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"TrrQr)rrGrr;rhror rcrvrurnrqrrrrrrtrz) rrfrZimlogratZhalfrzrZisoddr)r)r*_eval_is_imaginarysL        zPow._eval_is_imaginarycCs@|jjr<|jjr|jjS|jjr,|jjr,dS|jtjkr=2)-th power cannot be a prime. rFN)rrhr;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)rrhr;rrrnrr)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) NrrMrc 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)rh)rtermr)r)r*rqsz1Pow._eval_subs.._check..)FNNrr) rGrr#rrrrrWtuplerr?r) ct1ct2oldZcoeff1Zterms1Zcoeff2Zterms2rZcombinesrAr@ remainder remainder_powr)r)r*_checkMs8       zPow._eval_subs.._checkF)Zas_Addrr)rdrNrWr;rsubs__rpow__rrqrr rcZ is_Functionr_subsrlrErsZas_independentSymbolrZ as_coeff_mulrHappendrGrhAddis_Powrr)rrnewrNrAr@r;rrlrrrrrresultZoargZnew_lZo_alrZnewaexpor)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)rHrpr)rrAr@r)r)r*rs zPow.as_base_expcCsrddlm}|jj|jj}}|r2||j|jS|rF|j||jS|dkrn|dkrnt|}||krn||SdS)Nr)adjointF)rtrr;rhrrr )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)rtrr;rhrrr r)rr{rrrr)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) rtrrr rcrr;rhrrpr )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)rrr0rArr)r* sz.Pow._eval_expand_power_exp..cSs|jSrrFr0r)r)r*z,Pow._eval_expand_power_exp..Tbinarycsg|]}|qSr)rrrr)r*rs)rr;r rcZsympy.concrete.summationsrrWrGZsympy.concrete.productsrrfunctionZlimitsrsgetr_all_nonneg_or_nonpposrrHrr _from_args)rhintsr@rrr{ncr)rr*_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**nrF)Zsplit_1cs&g|]}t|dr|jfn|qS)_eval_expand_power_base)hasattrr rr)r r)r*r*sz/Pow._eval_expand_power_base..cSsg|] }|dqS)r3r)rr)r)r*r2sNr3rcSs |jdkSNF)rrr)r)r*r=rz-Pow._eval_expand_power_base..TrcSs4|tjkrtjS|j}|rdS|dkr0t|jSdSr)r rurrr)r0Zpolarr)r)r*pred?s z)Pow._eval_expand_power_base..predrKrrr"cSs|jo|jjo|jjSr)rr;rrrjrr)r)r*rscs g|]}|j|jqSr))rrHrrAr@rr)r*rscsg|]}j|ddqS)Frrrrr)r*rs)rrr;rkZargs_cncrirrrrr rulenrpopr^r_rhAssertionErrorrlextendr)rr rrAZcargsr rrZ maybe_realrZsiftedZnonnegnegimagIrZnonnor'Znpowr))r@r rr*r s  "                             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)rHrrg)rr)r*rsz0Pow._eval_expand_multinomial..cs g|]}jD] }||qqSr)rr multir)r*rscsg|] }|qSr)r))rrr"r)r*rsrN)"rHrrrsrirrrr_eval_expand_multinomialr make_argsrr$rGis_Orderrrrj as_real_imagr ruZsympy.ntheory.multinomialrZsympy.polys.polyutilsrrr8rlrrrrr)rr r;rr'radicalZexpanded_base_nrZ order_termsZ other_termsrArrr!rkr{rCrrrrZexpansion_dictrtailr))rr#r*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)rZaaZbbccrrAr)r*r/s cSs$g|]}|ddddkr|qS)rrrKr)rr)r)r*r1scs(g|] \\}}}|||qSr)r)r,r.r)r*r2s cSs$g|]}|ddddkr|qS)rrrKrr)rr)r)r*r3scs(g|] \\}}}|||qSr)r)r,r.r)r*r4s )atan2cossinr;)rTrFcomplexignore)!r;riZsympy.polys.polytoolsr+rr'r r`symbolsDummyrlrrutermsrr(sympy.functions.elementary.trigonometricr/r0r1rrrrrrrcrqexpandrtrTrr)rrr r+r;Zre_erexprmagrBZre_partZim_part1Zim_part3r/r0r1r1rptpr{r(rTrrr)r.r*r'sv      $  "  zPow.as_real_imagcCsFddlm}|j|}|j|}||||j||j|jSr)rqrrdiffr;)rr(rZdbaseZdexpr)r)r*_eval_derivativecs   zPow._eval_derivativecCs|\}}|tjkr6ddlm}||jdd|S||}|jsP||}|jr|j r|j dkr| || |}| }| || S| ||S)Nrr2Fr)rr rcrqr; _eval_evalfZ_evalfrirrjrrrr9)rprecrr;Z exp_functionr)r)r*r@is     zPow._eval_evalfcCsF|jj|rdS|jj|r>t|j|o:|jjo:|jdkSdSdS)NFrT)r;hasrr-_eval_is_polynomialrirZsymsr)r)r*rCxs  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;rhrrrrrrrrrrr is_irrationalr rcr)rrrAr@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#)r:r)r)r*_is_ones z'Pow._eval_is_algebraic.._is_oneTF)rrr rcrrHr;rZ is_algebraicrvrrurrrhrE)rrGr(r)r)r*_eval_is_algebraicsB        zPow._eval_is_algebraiccCs8|jj|rdS|jj|r0|j|o.|jjSdSdSr)r;rBr_eval_is_rational_functionrirDr)r)r*rIs   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;)rcombine) powdenest)_illegal)r)r'rXcdir)Wildzc, ex)ryexclude) polygammar") logcombinerXr]rXF)r9c Sstjtj}}t|D]`}||rp|\}}||krxz||WStk rl|tjfYSXq||9}q||fSr) r r^r`rr%rBrleadtermr#)rr0rr;factorrr)r)r* coeff_exps   z$Pow._eval_nseries..coeff_expcsNi}t||D]:\}}||}|kr||tj||||||<q|Sr)rrr r`)Zd1Zd2rese1e2r|Zmaxpowr)r*muls $zPow._eval_nseries..mul) nsimplify)ceiling) factorialffrTr3r=)Hrqr;rZsympy.series.limitsrTZsympy.series.orderrUZsympy.core.sympifyrWrr rcZnseriesr&ZremoveOrr]rangeZsympy.simplify.powsimprYr[numbersr\ZtrigsimprrBr _eval_nseriessymbolr^r5replaceZ'sympy.functions.special.gamma_functionsr`Z EulerGammar#rdNotImplementedErrorrfr\r[Zsympy.simplify.simplifyracancelrrjr_eval_as_leading_termas_leading_termr^rrZis_Floatr`rlrsimplifyr9rrmrr%r(sympy.functions.combinatorial.factorialsrnrortrTrhdirrOr)3rr0r'rXr]r;rrTrUrWZe_seriesZe0r1Z exp_seriesrrrYr[r\rAr@r^r{r|r`_rDrargrr!rBrfrkrCrlrmZgpolyZgtermsZco1rhr)r7ZtkrnrorrTndirZincoZinexr)rjr*rsTs                $            "     (  $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) NrrrcFzCannot expand %s around 0rbrpr3r=)rqr;rrr rcryrr\rTrprrBrtrTrhrr|rrrx)rr0rXr]r;rr@rArzZarg0ltrTrr~Z log_leadtermr)r)r*rxs8             zPow._eval_as_leading_termcGs$ddlm}||j||||S)Nr)binomial)r{rr;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 r`rr?rrrkrrr^)rr(rrAr@Zcepehr1Zcehr{rBZicehrDmer)r)r*r`s*+    $  zPow.as_content_primitivec Os|}|ddr|}|\}}|d}|rJ||}||krJ|S|j|}|j|} | r|rjdS|d}|dkrdSn | dkrdS|dS)NrzTrF)rrzrequals is_constant) rZwrtflagsr:rAr@ZbzrZeconZbconr)r)r*rs(      zPow.is_constantcCsF|j\}}||rB||sB||||}|||d|SdSr)rHrBr)rr'steprAr@Znew_er)r)r*_eval_difference_deltas zPow._eval_difference_delta)N)r)T)NF)r)Nr)FT)ArZ __module__ __qualname____doc__r __slots____annotations__r rxrpropertyrr;r classmethodrrrwrrrrrrrrrrrrrrrrrrrrr r r$r'r?r@rCrFrHrIrJrKrNrrPrsrxrrrrrrrrr __classcell__r)r)rr*rEs X b    T8D1   {z S ' % # " < "   QrEpower)r)r)rr)rr6r5N)H __future__rtypingrmathrr7rr% itertoolsrrWrcacher Z singletonr r:r rr rr rrrrZlogicrrrr parametersrrVrrrrrZsympy.external.gmpyrrZsympy.utilities.iterablesrZsympy.utilities.exceptionsrZsympy.utilities.miscrZsympy.multipledispatchr Z mpmath.libmpr!r4r+r&r.r>rEraddobjectrrrrrkrrrtrr6r5r)r)r)r*sX              +*7"