Otj[dZddlmZddlmZmZmZmZddlm Z ddl m Z ddl m Z ddlmZmZddlmZmZdd lmZdd lmZmZmZdd lmZdd lmZdd l m!Z!e!dZ"dZ#Gdde$Z%edZ&dZ'dZ(ee e"dZee"e dZ)dZ*dZ+ee"e dZ,dZ-ee"dZ.ddZ/dS) aS Limits ====== Implemented according to the PhD thesis https://www.cybertester.com/data/gruntz.pdf, which contains very thorough descriptions of the algorithm including many examples. We summarize here the gist of it. All functions are sorted according to how rapidly varying they are at infinity using the following rules. Any two functions f and g can be compared using the properties of L: L=lim log|f(x)| / log|g(x)| (for x -> oo) We define >, < ~ according to:: 1. f > g .... L=+-oo we say that: - f is greater than any power of g - f is more rapidly varying than g - f goes to infinity/zero faster than g 2. f < g .... L=0 we say that: - f is lower than any power of g 3. f ~ g .... L!=0, +-oo we say that: - both f and g are bounded from above and below by suitable integral powers of the other Examples ======== :: 2 < x < exp(x) < exp(x**2) < exp(exp(x)) 2 ~ 3 ~ -5 x ~ x**2 ~ x**3 ~ 1/x ~ x**m ~ -x exp(x) ~ exp(-x) ~ exp(2x) ~ exp(x)**2 ~ exp(x+exp(-x)) f ~ 1/f So we can divide all the functions into comparability classes (x and x^2 belong to one class, exp(x) and exp(-x) belong to some other class). In principle, we could compare any two functions, but in our algorithm, we do not compare anything below the class 2~3~-5 (for example log(x) is below this), so we set 2~3~-5 as the lowest comparability class. Given the function f, we find the list of most rapidly varying (mrv set) subexpressions of it. This list belongs to the same comparability class. Let's say it is {exp(x), exp(2x)}. Using the rule f ~ 1/f we find an element "w" (either from the list or a new one) from the same comparability class which goes to zero at infinity. In our example we set w=exp(-x) (but we could also set w=exp(-2x) or w=exp(-3x) ...). We rewrite the mrv set using w, in our case {1/w, 1/w^2}, and substitute it into f. Then we expand f into a series in w:: f = c0*w^e0 + c1*w^e1 + ... + O(w^en), where e0oo, lim f = lim c0*w^e0, because all the other terms go to zero, because w goes to zero faster than the ci and ei. So:: for e0>0, lim f = 0 for e0<0, lim f = +-oo (the sign depends on the sign of c0) for e0=0, lim f = lim c0 We need to recursively compute limits at several places of the algorithm, but as is shown in the PhD thesis, it always finishes. Important functions from the implementation: compare(a, b, x) compares "a" and "b" by computing the limit L. mrv(e, x) returns list of most rapidly varying (mrv) subexpressions of "e" rewrite(e, Omega, x, wsym) rewrites "e" in terms of w leadterm(f, x) returns the lowest power term in the series of f mrv_leadterm(e, x) returns the lead term (c0, e0) for e limitinf(e, x) computes lim e (for x->oo) limit(e, z, z0) computes any limit by converting it to the case x->oo All the functions are really simple and straightforward except rewrite(), which is the most difficult/complex part of the algorithm. When the algorithm fails, the bugs are usually in the series expansion (i.e. in SymPy) or in rewrite. This code is almost exact rewrite of the Maple code inside the Gruntz thesis. Debugging --------- Because the gruntz algorithm is highly recursive, it's difficult to figure out what went wrong inside a debugger. Instead, turn on nice debug prints by defining the environment variable SYMPY_DEBUG. For example: [user@localhost]: SYMPY_DEBUG=True ./bin/isympy In [1]: limit(sin(x)/x, x, 0) limitinf(_x*sin(1/_x), _x) = 1 +-mrv_leadterm(_x*sin(1/_x), _x) = (1, 0) | +-mrv(_x*sin(1/_x), _x) = set([_x]) | | +-mrv(_x, _x) = set([_x]) | | +-mrv(sin(1/_x), _x) = set([_x]) | | +-mrv(1/_x, _x) = set([_x]) | | +-mrv(_x, _x) = set([_x]) | +-mrv_leadterm(exp(_x)*sin(exp(-_x)), _x, set([exp(_x)])) = (1, 0) | +-rewrite(exp(_x)*sin(exp(-_x)), set([exp(_x)]), _x, _w) = (1/_w*sin(_w), -_x) | +-sign(_x, _x) = 1 | +-mrv_leadterm(1, _x) = (1, 0) +-sign(0, _x) = 0 +-limitinf(1, _x) = 1 And check manually which line is wrong. Then go to the source code and debug this function to figure out the exact problem. )reduce)BasicSMul PoleError)cacheit) AppliedUndef)ilcm)Ioo)DummyWild) bottom_up)logexpsign)Order)debug_decorator)timethisgruntzct|t|}}t|tr8t|ts|jr|jt jkr|j}t|tr8t|ts|jr|jt jkr|j}t||z |}|dkrdS|j rdSdS)z/Returns "<" if a" for a>br<>=) r isinstancerris_PowbaserExp1limitinf is_infinite)abxlalbcs Q/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/sympy/series/gruntz.pycomparer(sVVSVVB!UAs!3!3QVqvEUEU U!UAs!3!3QVqvEUEU UBAAvvs sscHeZdZdZdZfdZdZdZdZd dZ d Z xZ S) SubsSeta~ Stores (expr, dummy) pairs, and how to rewrite expr-s. Explanation =========== The gruntz algorithm needs to rewrite certain expressions in term of a new variable w. We cannot use subs, because it is just too smart for us. For example:: > Omega=[exp(exp(_p - exp(-_p))/(1 - 1/_p)), exp(exp(_p))] > O2=[exp(-exp(_p) + exp(-exp(-_p))*exp(_p)/(1 - 1/_p))/_w, 1/_w] > e = exp(exp(_p - exp(-_p))/(1 - 1/_p)) - exp(exp(_p)) > e.subs(Omega[0],O2[0]).subs(Omega[1],O2[1]) -1/w + exp(exp(p)*exp(-exp(-p))/(1 - 1/p)) is really not what we want! So we do it the hard way and keep track of all the things we potentially want to substitute by dummy variables. Consider the expression:: exp(x - exp(-x)) + exp(x) + x. The mrv set is {exp(x), exp(-x), exp(x - exp(-x))}. We introduce corresponding dummy variables d1, d2, d3 and rewrite:: d3 + d1 + x. This class first of all keeps track of the mapping expr->variable, i.e. will at this stage be a dictionary:: {exp(x): d1, exp(-x): d2, exp(x - exp(-x)): d3}. [It turns out to be more convenient this way round.] But sometimes expressions in the mrv set have other expressions from the mrv set as subexpressions, and we need to keep track of that as well. In this case, d3 is really exp(x - d2), so rewrites at this stage is:: {d3: exp(x-d2)}. The function rewrite uses all this information to correctly rewrite our expression in terms of w. In this case w can be chosen to be exp(-x), i.e. d2. The correct rewriting then is:: exp(-w)/w + 1/w + x. ci|_dSN)rewritesselfs r'__init__zSubsSet.__init__s  r)c~tdz|jzS)Nz, )super__repr__r.)r0 __class__s r'r4zSubsSet.__repr__s1ww!!D(4=+A+A+C+CCCr)cb||vrt||<t||Sr-)r dict __getitem__)r0keys r'r8zSubsSet.__getitem__s. d??DIc***r)ch|D]\}}|||i}|S)z)Substitute the variables with expressions)itemsxreplace)r0eexprvars r'do_subszSubsSet.do_subss9 ( (ID# C;''AAr)ct|t|tkS)z;Tell whether or not self and s2 have non-empty intersection)setkeys intersectionlist)r0s2s r'meetsz SubsSet.meetss=499;;,,T"''))__==FFr)NcJ|}i}|D]9\}}||vr+|r||||i}||||<4|||<:|jD]"\}}|||j|<#||fS)z0Compute the union of self and s2, adjusting exps)copyr;r<r.)r0rFexpsrestrr>r?rewrs r'unionz SubsSet.unionsiikk   ID#t||;==#s4y)9::Dd)3D **,, 2 2IC $ b 1 1CL  Dyr)ct}|j|_|D] \}}|||< |S)z Create a shallow copy of SubsSet)r+r.rIr;)r0rr>r?s r'rIz SubsSet.copysK II]''))   ID#AdGGr)r-) __name__ __module__ __qualname____doc__r1r4r8r@rGrNrI __classcell__)r5s@r'r+r+s--\DDDDD+++  GGG    r)r+c ddlm}||dd}t|tst d|st |fS|krt }||fS|js|jr| \}}|j |j kr+t|\}}|| ||fS| \}}t|\} } t|\} } t| | | || | S|jr|jt jkrt j} |jr|j} | |jz} | }|j| dkrt | fS| r-tt'| t)| zSt| \}}||| zfSt|t(r/t|jd\}}|t)|fSt|t&s|jr;|jt jkr%t|jt(r t|jjdSt-|j}t/dt1j|Drt } | |} t|j\} } | | d}t'| |j| <t9| | | t'| || St|j\}}|t'|fSt|t:rt=d |jrrfd |jD}d |D}tA|dkrtCd |dt c}fd |D}||j |fS|j"rtCdtCd|z)zoReturns a SubsSet of most rapidly varying (mrv) subexpressions of 'e', and e rewritten in terms of theserpowsimpTrdeepcombine e should be an instance of Basicc3$K|] }|jV dSr-)r ).0_s r' zmrv..&s$88q}888888r)z8MRV set computation for UndefinedFunction is not allowedc0g|]}t|S)mrv)r_r!r#s r' zmrv..3s! ' ' '1SAYY ' ' 'r)c<g|]\}}|tk|Src)r+)r_sr`s r'rezmrv..4s% 2 2 2FQ1 >>a>>>r)zGMRV set computation for functions in several variables not implemented.cFg|]}|dS)r])r@)r_r#sss r'rezmrv..:s),,,Q 1Q4  ,,,r)z8MRV set computation for derivatives not implemented yet.z+Don't know how to calculate the mrv of '%s')#sympy.simplify.powsimprXrr TypeErrorhasr+is_Mulis_Addas_independentfuncrd as_two_termsmrv_max1rrrrOnerrargsranyr make_argsrNr.mrv_max3r ValueError is_FunctionlenNotImplementedError is_Derivative)r=r#rXrgidr>r!r"s1e1rFe2b1lisull2rtris ` @r'rdrdsU/.....e,,,A a  <:;;; 5588?;yy!| a II!A$w :;QX:;""1 6QV  !QiiGAtaffQoo% %~~1QBQBBq"b 1 11555 1;af&& Uh B !%KBAh  7799b= 66!99 s2c"gg:** *"ajjGAtdBh;  As  $;afQi##4#d))| As  !;!;QVqv-=-= aeS ! ! )quz!}a(( (aeQ   88cmB&7&7888 8 8 BAB]]FB"aB!"ggBKOBBBR;; ;!%mmGAtc$ii<  A| $ $;STTT  ; ' ' ' ' ' ' ' 2 2a 2 2 2 r77a<<%'LMM M1wyy2,,,,!,,,&!&$- ;!#:;; ; 59 ; ;;r)c,t|tstdt|tstd|tkr||fS|tkr||fS||r||fSt t |dt |d|}|dkr||fS|dkr||fS|dkrtd||fS)a) Computes the maximum of two sets of expressions f and g, which are in the same comparability class, i.e. max() compares (two elements of) f and g and returns either (f, expsf) [if f is larger], (g, expsg) [if g is larger] or (union, expsboth) [if f, g are of the same class]. z"f should be an instance of SubsSetz"g should be an instance of SubsSetrrrrz c should be =)rr+rkrGr(rErCrx)fexpsfgexpsgrNexpsbothr#r&s r'rwrwCs  a ! !><=== a ! !><===GII~~%x gii%x hQVVXXq!4>>!#4a88ACxx%x c%x 88_-- -hr)c |||\}}t|||||||||S)agComputes the maximum of two sets of expressions f and g, which are in the same comparability class, i.e. mrv_max1() compares (two elements of) f and g and returns the set, which is in the higher comparability class of the union of both, if they have the same order of variation. Also returns exps, with the appropriate substitutions made. )rNrwr@)rrrJr#ur"s r'rrrr`sP 771d  DAq Aqyy199T??q!  r)c&t|tstd|jrdS|jrdS|jrdS||s ddlm}||}t|S||krdS|j r>| \}}t||}|sdS|t||zSt|trdS|jrK|jt jkrdSt|j|}|dkrdS|j jr ||j zSnEt|t&r0|jdjrt|jddz |St+||\}}t||S)a Returns a sign of an expression e(x) for x->oo. :: e > 0 for x sufficiently large ... 1 e == 0 for x sufficiently large ... 0 e < 0 for x sufficiently large ... -1 The result of this function is currently undefined if e changes sign arbitrarily often for arbitrarily large x (e.g. sin(x)). Note that this returns zero only if e is *constantly* zero for x sufficiently large. [If e is constant, of course, this is just the same thing as the sign of e.] r\r]r) logcombine)rrrk is_positive is_negativeis_zerorlsympy.simplifyr_signrmrqrrrrrr is_Integerrrt mrv_leadterm) r=r#rr!r"sargc0e0s r'rrls( a  <:;;;}&q &r &q UU1XX&------ JqMMQxx aq &~~1 !QZZ 1DAJJ As   &q  & 6QV  1 OO 661 5  ae8O  As  &q 5&AF1IM1%%%!Q  FB A;;r)c(|}||s|Sddlm}ddlm}|t r&|}|jr|j r)tdd}| ||}|}| dd|}||}t||rLt|j|t|j|krt"t|j|\}}nt||\}}t%||}|d kr t&jS|d krk|t,t/d t,g zr |t0zSt%||} | dkrt3d | t0zS|dkr*||kr|}t7||St3d|)zLimit e(x) for x-> oo.r) powdenest AccumBoundspTpositive tractable)rZlimitvarr]rr!)excludezLeading term should not be 0z{} could not be evaluated)rlrjrsympy.calculus.utilrrexpandremoveOr is_integerr subsrewriterrminmaxr{rrZeromatchr rr rxcancelrformat) r=r#oldrrrrrsigrgs r'rrs C 5588000000//////uuU||! HHJJ    =AL # % % % FF1aLL  +D1 55A ! A![!!$ q ! !\!%%;%; ; ;% %aeQ''BBa##B r1++C axxv  88Ad3,,,, - - b5L QKK 66;<< <t  99BA4;;C@@AAAr)c Pt}|D],\}}||||t|i<-|jD]<\}}|j||t|i|j|<=|Sr-)r+r;r<rr.)rgr#rPr>r?s r'moveup2rs AWWYY,, c(+$--CFF $ $%%Z%%''@@ T*S/22As1vv;?? 3 Hr)c fd|DS)NcXg|]&}|ti'Src)r<r)r_r=r#s r'rezmoveup..s/ / / /AJJ3q66{ # # / / /r)rc)rr#s `r'moveuprs / / / /Q / / //r)ct}|s|tjfS|tkrt |\}}|s|tjfS|vr+t |}t |gd}|}|}tdd}t|||\}}| fdd} | ||} nR#tttf$r7d} td} tj} | jr'||| | z| } | d z} | j'| } | ||} n#tttf$r||} | d|r]|d|}|d}|d|z|d|zf} YnwxYwYnwxYw| dt/||| dfS) zReturns (c0, e0) for e.rwTrc<|jo|Sr-)rrl)rr#s r'zmrv_leadterm..sAH1qr)cTtt|j|jzSr-)rrr)rs r'rzmrv_leadterm..sSQVQUAR=S=Sr))logxr])nr)r+rlrrrdrrr rreplaceleadtermr{rrxrrsis_Order _eval_nseriesrras_coeff_exponent as_base_exprr)r=r#OmegarJOmega_upexps_uprrlogwltn0_seriesincrseriesrexs ` r'rrst IIE 558816{  !Qii t QV|Ezz5!$$$##A& cD!!!AdE1a((GAt 11113S3STTA/ ZZZ % % J 7/// ((u ooa2d7o>>G AID !!))++ /..BB#Y ; / / /$$Q''B!uyy|| /}}q);;A>>]]__Q'1grk472:.  // qEJJs1vvt $ $be ,,s8C11B I;FIB$H:7I9H::I?Ic Gdd}i}|D]"\}}|}||_||_|||<#|D]V\}}||vrM||}||}|D]:\}} || r |j|| ;W|S)a Helper function for rewrite. We need to sort Omega (mrv set) so that we replace an expression before we replace any expression in terms of which it has to be rewritten:: e1 ---> e2 ---> e3 \ -> e4 Here we can do e1, e2, e3, e4 or e1, e2, e4, e3. To do this we assemble the nodes into a tree, and sort them by height. This function builds the tree, rewrites then sorts the nodes. ceZdZdZdZdS)#build_expression_tree..Nodec0g|_d|_d|_dSr-)beforer>r?r/s r'r1z,build_expression_tree..Node.__init__,sDKDIDHHHr)cDtdd|jDdS)Nc ||zSr-rc)r#ys r'rz8build_expression_tree..Node.ht..1s q1ur)c6g|]}|Srcht)r_r#s r'rez:build_expression_tree..Node.ht..2s 777a14466777r)r])rrr/s r'rz&build_expression_tree..Node.ht0s/,,774;777<< rlrappend) rr.rnodesr>vrr`rPv2s r'build_expression_treers<<<<<<<< Ea DFFa//1 ==aA A / /25599/HOOE"I... Lr)c Rddlm}t|tst dt |dkrt d|D]&}t|tst d'|j }t| }t||| fdd|D]M\}}t|j|} | d kr-| d kr'| |st!d | zN| d krd |z }g} g} |D]\} } t#| j|jz |}|jr| |j| j}| |vr=t|| tst d|| jd}| | t|||jzz ||zzfdd lm}||dd } | D]\}}| ||i} |D]\}} | | rJ|j}| d kr| }t3t4| d }| |||zi} ||z}t9| d} | |fS)ze(x) ... the function Omega ... the mrv set wsym ... the symbol which is going to be used for w Returns the rewritten e in terms of w and log(w). See test_rewrite1() for examples and correct results. rrz&Omega should be an instance of SubsSetzLength cannot be 0zValue should be expcD|dS)Nr]r)r#rs r'rzrewrite..\sU1Q4[^^--r)T)r9reverser]rz Result depends on the sign of %srWrrYc<tdfdS)NnormalcSr-rcrsr'rz+rewrite....sAr))getattrrs`r'rzrewrite..s">wq(IIII>>@@r))sympyrrr+rkrzrxrCrr.rEr;rsortrrlr{r is_RationalrqrtrjrXr<rr rr)r=rr#wsymrtr.rr`rO2 denominatorsrr?r&argrXr!r"rexponentrs @r'rrDs "!!!!! eW % %B@AAA 5zzQ-... ZZ\\44!S!! 4233 3 4~H   E !% 2 2E JJ----tJ<<<PP115!nn !88r #''+*>*> %&H3&NOO O axxv BL 7 73 QU15[! $ $ = %    $ $ $e (??hsmS11 8 !67773-$Q'C 3S1QU7],,T1W456666/.....e,,,A1 JJ1v  355::~ 5D axxudL!,,H dHn%&&AHD !@@AAA d7Nr)+c|jstdd}|tttzfvr|}n|t t tzfvr||| }not |dkr|||d|z z }n?t |dkr|||d|z z}ntdt ||}|dd S) ac Compute the limit of e(z) at the point z0 using the Gruntz algorithm. Explanation =========== ``z0`` can be any expression, including oo and -oo. For ``dir="+"`` (default) it calculates the limit from the right (z->z0+) and for ``dir="-"`` the limit from the left (z->z0-). For infinite z0 (oo or -oo), the dir argument does not matter. This algorithm is fully described in the module docstring in the gruntz.py file. It relies heavily on the series expansion. Most frequently, gruntz() is only used if the faster limit() function (which uses heuristics) fails. z Second argument must be a SymbolN-r]rzdir must be '+' or '-' intractableT)rZ) is_symbolr{r r rstrrr)r=zz0dirrPrs r'rrs" ;F!"DEEE A b!B$Z  aRU|   VVAr]] s88s??2!8$$BB XX__2!8$$BB%&>?? ?QA 99]9 . ..r)N)r)0rT functoolsr sympy.corerrrrsympy.core.cachersympy.core.functionr sympy.core.intfuncr sympy.core.numbersr r sympy.core.symbolr rsympy.core.traversalrsympy.functionsrrrrsympy.series.orderrsympy.utilities.miscrdebugsympy.utilities.timeutilsrtimeitr(r7r+rdrwrrrrrrrrrrcr)r'r suul////////////$$$$$$,,,,,,######$$$$$$$$))))))))******3333333333$$$$$$999999...... (  $YYYYYdYYYxH;H;H;V:   66 6r*B*B *BZ   0001-1- 1-h%%%PLLL^(/(/(/(/(/(/r)