gdZddlmZmZddlmZmZmZddlm Z ddl m Z m Z m Z mZddlmZddlmZmZmZddlmZdd lmZdd lmZmZmZmZmZmZm Z m!Z!m"Z"dd l#m$Z$dd lm%Z%dd l&Z&dZ'dZ(dZ)dZ*dZ+dZ,dZ-dZ.dZ/dZ0dZ1dZ2dZ3dZ4dZ5dZ6dZ7dHd Z8d!Z9d"Z:d#Z;d$Zd'Z?d(Z@d)ZAd*ZBd+ZCd,ZDd-ZEd.ZFd/ZGd0ZHd1ZId2ZJd3ZKd4ZLd5ZMd6ZNd7ZOd8ZPd9ZQd:ZRd;ZSdId=ZTd>ZUd?d@dAdBdCdDZVdEZWdFZXdGZYd S)Ja9Power series evaluation and manipulation using sparse Polynomials Implementing a new function --------------------------- There are a few things to be kept in mind when adding a new function here:: - The implementation should work on all possible input domains/rings. Special cases include the ``EX`` ring and a constant term in the series to be expanded. There can be two types of constant terms in the series: + A constant value or symbol. + A term of a multivariate series not involving the generator, with respect to which the series is to expanded. Strictly speaking, a generator of a ring should not be considered a constant. However, for series expansion both the cases need similar treatment (as the user does not care about inner details), i.e, use an addition formula to separate the constant part and the variable part (see rs_sin for reference). - All the algorithms used here are primarily designed to work for Taylor series (number of iterations in the algo equals the required order). Hence, it becomes tricky to get the series of the right order if a Puiseux series is input. Use rs_puiseux? in your function if your algorithm is not designed to handle fractional powers. Extending rs_series ------------------- To make a function work with rs_series you need to do two things:: - Many sure it works with a constant term (as explained above). - If the series contains constant terms, you might need to extend its ring. You do so by adding the new terms to the rings as generators. ``PolyRing.compose`` and ``PolyRing.add_gens`` are two functions that do so and need to be called every time you expand a series containing a constant term. Look at rs_sin and rs_series for further reference. )QQEX) PolyElementringsring) DomainError) monomial_min monomial_mul monomial_div monomial_ldiv)ifac) PoleErrorFunctionExpr)Rational)igcd) sincostanatanexpatanhtanhlogceiling)as_int giant_stepsNcNt|}||}|j}|j}|}|}t||D]\}}||||dz f<|S)a Compute ``x**n * p1(1/x)`` for a univariate polynomial ``p1`` in ``x``. Examples ======== >>> from sympy.polys.domains import ZZ >>> from sympy.polys.rings import ring >>> from sympy.polys.ring_series import _invert_monoms >>> R, x = ring('x', ZZ) >>> p = x**2 + 2*x + 3 >>> _invert_monoms(p) 3*x**2 + 2*x + 1 See Also ======== sympy.polys.densebasic.dup_reverse r) listitemssortdegreerzero listcoeffs listmonomszip) p1termsdegRpcvmvmvicvis M/granary/edev/quantum/lib/python3.11/site-packages/sympy/polys/ring_series.py_invert_monomsr2;s(   E JJLLL ))++C A A B BBKK!!S 3Q>> from sympy.polys.domains import QQ >>> from sympy.polys.rings import ring >>> from sympy.polys.ring_series import rs_trunc >>> R, x = ring('x', QQ) >>> p = x**10 + x**5 + x + 1 >>> rs_trunc(p, x, 12) x**10 + x**5 + x + 1 >>> rs_trunc(p, x, 10) x**5 + x + 1 )rr$gensindex)r(xprecr+r,iexp1s r1rs_truncr@asV$ A A  QA 7d?? T($ Hr3c|jj|}|D]B}||t||krdS||dkrt d|zCdS)a Test if ``p`` is Puiseux series in ``x``. Raise an exception if it has a negative power in ``x``. Examples ======== >>> from sympy.polys.domains import QQ >>> from sympy.polys.rings import ring >>> from sympy.polys.ring_series import rs_is_puiseux >>> R, x = ring('x', QQ) >>> p = x**QQ(2,5) + x**QQ(2,3) + x >>> rs_is_puiseux(p, x) True TrzThe series is not regular in %sF)rr:r;int ValueError)r,r<r;ks r1 rs_is_puiseuxrE|sw" FK  a E DD U8s1U8}} $ $44 U8a<<>BCC C  5r3c |jj| d}|D]}| }t|tr;|\}}t ||zt||z}Z|t |kr*|j}t ||zt||z}|dkrut| |} || |||z} td| t| trt fd| D} nt| } n ||||} | S)a Return the puiseux series for `f(p, x, prec)`. To be used when function ``f`` is implemented only for regular series. Examples ======== >>> from sympy.polys.domains import QQ >>> from sympy.polys.rings import ring >>> from sympy.polys.ring_series import rs_puiseux, rs_exp >>> R, x = ring('x', QQ) >>> p = x**QQ(2,5) + x**QQ(2,3) + x >>> rs_puiseux(rs_exp,p, x, 1) 1/2*x**(4/5) + x**(2/3) + x**(2/5) + 1 c2g|]}t|S)pow_xin).0rxr;n1s r1 zrs_puiseux..s%:::"wr5"--:::r3) rr:r; isinstanceras_numer_denomrBr denominatorrJrtuple) fr,r<r=nrDpowernumdenr(rr;rMs @@r1 rs_puiseuxrYsY" FK  a E A ++% eX & & +++--HCAcET!S\\)**AA c%jj #CAcET!S\\)**AAvv Qq ! ! Ab!T!V   1XX a   &::::::::;;AA5"%%AA AaDMM Hr3c|jj|}d}|D]}}||}t|tr.|\} } || zt || z}M|t|kr|j} || zt || z}~|dkrDt|||} || ||||z} td|} t| || } n|||||} | S)z Return the puiseux series for `f(p, q, x, prec)`. To be used when function ``f`` is implemented only for regular series. rG) rr:r;rOrrPrrBrQrJr)rSr,qr<r=r;rTrDrUrVrWr(rXrMs r1 rs_puiseux2r\s FK  a E A &&% eX & & &++--HC#a%AA c%jj #C#a%AAvv Qq ! ! Ab!QQ   1XX Aub ! ! AaAt   Hr3c:|j}|j}|j|jjks ||jkrtd|j|t |tstd||jkr|j}t| }| fd|j dkrS| D]=\}} |D]5\} } |d| dz} | |kr| f} || d| | zz|| <5>n`|j } | D]D\}} |D]<\} } || z|kr"| || } || d| | zz|| <<E||S)a Return the product of the given two series, modulo ``O(x**prec)``. ``x`` is the series variable or its position in the generators. Examples ======== >>> from sympy.polys.domains import QQ >>> from sympy.polys.rings import ring >>> from sympy.polys.ring_series import rs_mul >>> R, x = ring('x', QQ) >>> p1 = x**2 + 2*x + 1 >>> p2 = x + 1 >>> rs_mul(p1, p2, x, 3) 3*x**2 + 3*x + 1 z!p1 and p2 must have the same ringzp2 must be a polynomialc |dSNrrIeivs r1zrs_mul..s!A$r(r3keyrGr)rr$ __class__rCr:r;rOrgetr r!r"ngensr strip_zero)r(p2r<r=r+r,rgitems2r?v1exp2v2rr rbs @r1rs_mulros$ A A{bg'''1<<<=== aB b+ & &42333BG||ebhhjj!! **** +++ 7a<<HHJJ  b &HD"q'DG+CTzz"g!$S!r"u!4# >LHHJJ  b &HD"Bx$r(*T11*l466!$S!r"u!4#LLNNN Hr3c|j}|j}|j||j}t |}|fd|j}tt|D]a}||\} } t|D]D} || \} } | | z|kr"|| | }||d| | zz||<Db| d}|j}|D]5\}}d|z|kr!|||}||d|dzz||<6| |S)aA Square the series modulo ``O(x**prec)`` Examples ======== >>> from sympy.polys.domains import QQ >>> from sympy.polys.rings import ring >>> from sympy.polys.ring_series import rs_square >>> R, x = ring('x', QQ) >>> p = x**2 + 2*x + 1 >>> rs_square(p, x, 3) 6*x**2 + 4*x + 1 c |dSr_rIr`s r1rczrs_square..sQqT"Xr3rdrr5) rr$r:r;rgr r!r"r rangelenimul_numri)r(r<r=r+r,rgr!r r>r?rljrmrnrexpvve2rbs @r1 rs_squarerys A A aB %C   E JJ%%%%J&&&>L 3u::  8bq  AQxHD"Bx$r("T))"l4..S!r"u,# 1 A %C88::&&a T"X:  dD))BCAJJA%AbELLNNN Hr3c|j}t|trmt|j}t|j}|dkr+t ||||}|dkrt||||}nt||||}|St|}|dkr|r |dStd|dkr$t|| ||}t|||S|dkrt|||S|dkrt|||S|dkr#t|||}t||||S|d} |dzrt|| ||} |dz}|snt|||}|dz}6| S)a4 Return ``p1**n`` modulo ``O(x**prec)`` Examples ======== >>> from sympy.polys.domains import QQ >>> from sympy.polys.rings import ring >>> from sympy.polys.ring_series import rs_pow >>> R, x = ring('x', QQ) >>> p = x + 1 >>> rs_pow(p, 4, x, 3) 6*x**2 + 4*x + 1 rGrz0**0 is undefinedr5)rrOrrBr,r[ rs_nth_rootrs_powrrCrs_series_inversionr@ryro) r(rTr<r=r+npnqr7rjr,s r1r}r}0s A!X  XX XX 77b"a..CQwwS"a..RD))C q AAvv  21Q44K011 11uu BAt $ $"2q$///AvvAt$$$AvvQ%%%Avv r1d # #b"a&&& !A q5 r1a&&A FA  r1d # # F Hr3c|j}|j}|d}t|D]}|j|||df<|D]"}|||||df<#|d} t |} | D]} |d} t|D]}| |} | dkr|| f|vrt| d\}}|dkr%||f|vrt|||f||||| f<nS|| dz f|vr+t||| dz f||df||||| f<nt||df| ||||| f<t| ||| f||} | | || zz } | S)a Substitution with truncation according to the mapping in ``rules``. Return a series with precision ``prec`` in the generator ``x`` Note that substitutions are not done one after the other >>> from sympy.polys.domains import QQ >>> from sympy.polys.rings import ring >>> from sympy.polys.ring_series import rs_subs >>> R, x, y = ring('x, y', QQ) >>> p = x**2 + y**2 >>> rs_subs(p, {x: x+ y, y: x+ 2*y}, x, 3) 2*x**2 + 6*x*y + 5*y**2 >>> (x + y)**2 + (x + 2*y)**2 2*x**2 + 6*x*y + 5*y**2 which differs from >>> rs_subs(rs_subs(p, {x: x+ y}, x, 3), {y: x+ 2*y}, x, 3) 5*x**2 + 12*x*y + 8*y**2 Parameters ---------- p : :class:`~.PolyElement` Input series. rules : ``dict`` with substitution mappings. x : :class:`~.PolyElement` in which the series truncation is to be done. prec : :class:`~.Integer` order of the series after truncation. Examples ======== >>> from sympy.polys.domains import QQ >>> from sympy.polys.rings import ring >>> from sympy.polys.ring_series import rs_subs >>> R, x, y = ring('x, y', QQ) >>> rs_subs(x**2+y**2, {y: (x+y)**2}, x, 3) 6*x**2*y**2 + x**2 + 4*x*y**3 + y**4 rrGr5) rrhrrr:r;sortedkeysdivmodryror})r,rulesr<r=r+rhdr>varr(p_keysrvrjrUr[rXs r1rs_subsrfsP A GE !A 5\\F1I1a& **$Sz1773<<  1B AFFHH  F QqTTu 4 4AGEzz5z""eQ''166q!fkk$-aAiD$A$AAq%jMM^q(($*1a^+>> from sympy.polys.domains import QQ >>> from sympy.polys.rings import ring >>> from sympy.polys.ring_series import _has_constant_term >>> R, x = ring('x', QQ) >>> p = x**2 + x + 1 >>> _has_constant_term(p, x) True rrGTFrr:r; zero_monomrhrRr )r,r<r+rbzmamivrvs r1_has_constant_termrsy A aB B AG A AbE ((C c " "b ( (44 ) 5r3c|j}|j|}|j}dg|jz}d||<t |}d}|D],}t |||kr|||||iz }-|S)zReturn constant term in p with respect to x Note that it is not simply `p[R.zero_monom]` as there might be multiple generators in the ring R. We want the `x`-free term which can contain other generators. rrGr) r,r<r+r>rrrcrvs r1_get_constant_termrs A  QA B AG A AaD ((C A$$ c " "b ( ( D!D'?## #A Hr3c|jj|t|fd}|dkrt d|z|fS)Nc|SNrIrDr;s r1rcz#_check_series_var.. QuXr3rdrz7Asymptotic expansion of %s around [oo] not implemented.)rr:r;minr)r,r<namemr;s @r1_check_series_varrsl FK  a E A%%%%&&&u-A1uu')-.// / !8Or3ct||rtt|||S|j}|j}||}|t |krt |}||vrt dt||z |rt d|d}|jturd}||kr|d|z }n |d}t|D],}dt||||z } |t|| ||z}-|S)a Univariate series inversion ``1/p`` modulo ``O(x**prec)``. The Newton method is used. Examples ======== >>> from sympy.polys.domains import QQ >>> from sympy.polys.rings import ring >>> from sympy.polys.ring_series import _series_inversion1 >>> R, x = ring('x', QQ) >>> p = x + 1 >>> _series_inversion1(p, x, 4) -x**3 + x**2 - x + 1 No constant term in seriesz8p cannot contain a constant term depending on parametersrG) rErY_series_inversion1rrrBrCrdomainrr8ro) r,r<r=r+rroner(precxts r1rrs9"Q:,aD999 A B "A s4yy4yy {{5666!a%##'&'' ' !A$$Cx2~~Cxx QqTT!V QqTTd##** r1a'' ' &Q5)) ) Ir3c|j}||jkrt|j}|j|t |fd}|rt|| }||z}||vrtdt|||z |rtdt|||}|dkrt|| }|S)a Multivariate series inversion ``1/p`` modulo ``O(x**prec)``. Examples ======== >>> from sympy.polys.domains import QQ >>> from sympy.polys.rings import ring >>> from sympy.polys.ring_series import rs_series_inversion >>> R, x, y = ring('x, y', QQ) >>> rs_series_inversion(1 + x*y**2, x, 4) -x**3*y**6 + x**2*y**4 - x*y**2 + 1 >>> rs_series_inversion(1 + x*y**2, y, 4) -x*y**2 + 1 >>> rs_series_inversion(x + x**2, x, 4) x**3 - x**2 + x - 1 + x**(-1) c|SrrIrs r1rcz%rs_series_inversion..$rr3rdrz>p - p[0] must not have a constant term in the series variablesr) rr$ZeroDivisionErrorrr:r;rmul_xinNotImplementedErrorrr)r,r<r=r+rrrXr;s @r1r~r~ s$ AAF{{ B FLLOOE A%%%%&&&u-A Auqb ! !ax {{!">???!ae)Q'':!#9:: :1a&&AAvv Auqb ! ! Hr3c|\}}|j}dg|jz}|||<t|}|d}|D]'}|||kr|||t||<(|S)z2Coefficient of `x_i**j` in p, where ``t`` = (i, j)r)rrhrRr )r,rr>rur+expv1r(rvs r1_coefficient_tr3sz DAq A CKEE!H %LLE 1B44 7a<<,-dGB|D%(( ) Ir3ct||rt|j}|j|}||}|j|}t ||rt dt||df}|j}||vrt|dksJ||}||z } td|D]9} t||| i|| dz} t| || f|| zz} | | |z z} :| S)ab Reversion of a series. ``p`` is a series with ``O(x**n)`` of the form $p = ax + f(x)$ where $a$ is a number different from 0. $f(x) = \sum_{k=2}^{n-1} a_kx_k$ Parameters ========== a_k : Can depend polynomially on other variables, not indicated. x : Variable with name x. y : Variable with name y. Returns ======= Solve $p = y$, that is, given $ax + f(x) - y = 0$, find the solution $x = r(y)$ up to $O(y^n)$. Algorithm ========= If $r_i$ is the solution at order $i$, then: $ar_i + f(r_i) - y = O\left(y^{i + 1}\right)$ and if $r_{i + 1}$ is the solution at order $i + 1$, then: $ar_{i + 1} + f(r_{i + 1}) - y = O\left(y^{i + 2}\right)$ We have, $r_{i + 1} = r_i + e$, such that, $ae + f(r_i) = O\left(y^{i + 2}\right)$ or $e = -f(r_i)/a$ So we use the recursion relation: $r_{i + 1} = r_i - f(r_i)/a$ with the boundary condition: $r_1 = y$ Examples ======== >>> from sympy.polys.domains import QQ >>> from sympy.polys.rings import ring >>> from sympy.polys.ring_series import rs_series_reversion, rs_trunc >>> R, x, y, a, b = ring('x, y, a, b', QQ) >>> p = x - x**2 - 2*b*x**2 + 2*a*b*x**2 >>> p1 = rs_series_reversion(p, x, 3, y); p1 -2*y**2*a*b + 2*y**2*b + y**2 + y >>> rs_trunc(p.compose(x, p1), y, 3) y z9p must not contain a constant term in the series variablerGr5) rErrr:r;rrCrrrsrrr) r,r<rTyr+nxnyrrrXr>sps r1rs_series_reversionr@s%hQ"!! A aB !A aB!Q%$%% %q2q'""A B 77s1vv{{{{ "A !A 1a[[ QA1q5 ) ) BQ ( (A - RT  Hr3rGc |j}t|}|sK|d}|d|z}td|D]"} t||||}||| |zz }#|St t j|dz} t|| \} } | r| dz } |dg} |d}t|dkr;td| D])} t||||}| |*n^td| D]M} | dzdkrt| | dz||}nt||||}| |Nt| d|||}|d}|d}t| dz D]f}| |z} || }td| D]}||| |z| |zz }t||||}||z }t||||}|sng| dz }| |z} | |kr`|| |dz}td| D]$}| |z|krn||| |z| |zz }%t||||}||z }|S)a Return a series `sum c[n]*p**n` modulo `O(x**prec)`. It reduces the number of multiplications by summing concurrently. `ax = [1, p, p**2, .., p**(J - 1)]` `s = sum(c[i]*ax[i]` for i in `range(r, (r + 1)*J))*p**((K - 1)*J)` with `K >= (n + 1)/J` Examples ======== >>> from sympy.polys.domains import QQ >>> from sympy.polys.rings import ring >>> from sympy.polys.ring_series import rs_series_from_list, rs_trunc >>> R, x = ring('x', QQ) >>> p = x**2 + x + 1 >>> c = [1, 2, 3] >>> rs_series_from_list(p, c, x, 4) 6*x**3 + 11*x**2 + 8*x + 6 >>> rs_trunc(1 + 2*p + 3*p**2, x, 4) 6*x**3 + 11*x**2 + 8*x + 6 >>> pc = R.from_list(list(reversed(c))) >>> rs_trunc(pc.compose(x, p), x, 4) 6*x**3 + 11*x**2 + 8*x + 6 rGrr5) rrsrrrorBmathsqrtrappendry)r,rr<r=concurr+rTr[sr>JKrXaxpjbrDs1rus r1rs_series_from_listrs< A AA  AaDD aDFq!  Aq!Q%%A 1aKAA DIaLL1 A !Q<>> from sympy.polys.domains import QQ >>> from sympy.polys.rings import ring >>> from sympy.polys.ring_series import rs_diff >>> R, x, y = ring('x, y', QQ) >>> p = x + x**2*y**3 >>> rs_diff(p, x) 2*x*y**3 + 1 rrG)rr:r;r$rhrRr domain_new)r,r<r+rTr(mnrvras r1rs_diffrs( A  QA B QWB BqE rB22 7 2dB''ALL4a11BqE Ir3c|j}|j}|j|}dg|jz}d||<t |}|D]<}t ||}|||||dzz ||<=|S)a Integrate ``p`` with respect to ``x``. Parameters ========== x : :class:`~.PolyElement` with respect to which ``p`` is integrated. Examples ======== >>> from sympy.polys.domains import QQ >>> from sympy.polys.rings import ring >>> from sympy.polys.ring_series import rs_integrate >>> R, x, y = ring('x, y', QQ) >>> p = x + x**2*y**3 >>> rs_integrate(p, x) 1/3*x**3*y**3 + 1/2*x**2 rrG)rr$r:r;rhrRr r)r,r<r+r(rTrrvras r1 rs_integraters( A B  QA QWB BqE rB44 r " " QtWd1gk2331 Ir3c|j}td|j\}}t|d}|dd||fz}|j}||vr|||z} |||z } n|} |} t |t rt | ||} n || g|R} t| } dg|z} | D]}|d| |dd<t| | |d|d} | S)a  Function of a multivariate series computed by substitution. The case with f method name is used to compute `rs\_tan` and `rs\_nth\_root` of a multivariate series: `rs\_fun(p, tan, iv, prec)` tan series is first computed for a dummy variable _x, i.e, `rs\_tan(\_x, iv, prec)`. Then we substitute _x with p to get the desired series Parameters ========== p : :class:`~.PolyElement` The multivariate series to be expanded. f : `ring\_series` function to be applied on `p`. args[-2] : :class:`~.PolyElement` with respect to which, the series is to be expanded. args[-1] : Required order of the expanded series. Examples ======== >>> from sympy.polys.domains import QQ >>> from sympy.polys.rings import ring >>> from sympy.polys.ring_series import rs_fun, _tan1 >>> R, x, y = ring('x, y', QQ) >>> p = x + x*y + x**2*y + x**3*y**2 >>> rs_fun(p, _tan1, x, 4) 1/3*x**3*y**3 + 2*x**3*y**2 + x**3*y + 1/3*x**3 + x**2*y + x*y + x _xrNrrG) rrrBrrOstrgetattrrr!r)r,rSargs_RR1rhargs1rx1r(r[rrr<s r1rs_funr!s@ B $ " "FB DH A "IQ E B Qww !B%Z 2Y  !S GBNNE " AbM5MMMqwwyyA AA qT!A$q' RDHd2h 7 7B Ir3c|j}|d}|D]6\}}t|}||xx|z cc<||t|<7|S)zF Return `p*x_i**n`. `x\_i` is the ith variable in ``p``. rrr!r rRr,r>rTr+r[rDrwk1s r1rrYsi A !A 1 !WW 1 %)) Hr3c|j}|d}|D]6\}}t|}||xx|zcc<||t|<7|S)a6 >>> from sympy.polys.domains import QQ >>> from sympy.polys.rings import ring >>> from sympy.polys.ring_series import pow_xin >>> R, x, y = ring('x, y', QQ) >>> p = x**QQ(2,5) + x + x**QQ(2,3) >>> index = p.ring.gens.index(x) >>> pow_xin(p, index, 15) x**15 + x**10 + x**6 rrrs r1rJrJgsi A !A 1 !WW 1 %)) Hr3ct||rtt||||S|j}|j}||vrt dt |}||dksJ|d}|dkr|S|dkr |dS|dkr|S|dkr| }d}nd}t|D]7}t||dz||} t| |||} |||z | |z z z }8|r|St|||S)z_ Univariate series expansion of the nth root of ``p``. The Newton method is used. rrGr) rEr\ _nth_root1rrrrr8r}ror) r,rTr<r=r+rr(signrtmps r1rrzsA Q6:q!Q555 A B {{!">???q A R5A:::: 1BAvvAvvqtt Avv1uu Bd##RQ5))S!Q&& bdSUl / !"a...r3c |dkr*|dkrtd|dS|dkrt|||S|j}|j| t | fd }t | | }||z}t|dz |r|j}||}|j tur(| }|td|z} nt|trO | }||td|z} nX#t$rtdwxYw ||t!d|z} n#t$rtdwxYwt#||z |||| z} nt%||||} |r!t||}t | |} | S)a Multivariate series expansion of the nth root of ``p``. Parameters ========== p : Expr The polynomial to computer the root of. n : integer The order of the root to be computed. x : :class:`~.PolyElement` prec : integer Order of the expanded series. Notes ===== The result of this function is dependent on the ring over which the polynomial has been defined. If the answer involves a root of a constant, make sure that the polynomial is over a real field. It cannot yet handle roots of symbols. Examples ======== >>> from sympy.polys.domains import QQ, RR >>> from sympy.polys.rings import ring >>> from sympy.polys.ring_series import rs_nth_root >>> R, x, y = ring('x, y', QQ) >>> rs_nth_root(1 + x + x*y, -3, x, 3) 2/9*x**2*y**2 + 4/9*x**2*y + 2/9*x**2 - 1/3*x*y - 1/3*x + 1 >>> R, x, y = ring('x, y', RR) >>> rs_nth_root(3 + x + x*y, 3, x, 2) 0.160249952256379*x*y + 0.160249952256379*x + 1.44224957030741 rz0**0 expressionrGc|SrrIrs r1rczrs_nth_root..rr3rd3The given series cannot be expanded in this domain.)rCrr@r:r;rrrrrras_exprrrOrrrr|r) r,rTr<r=r+rrrc_exprconstr7r;s @r1r|r|s H Avv 66.// /66!99 Avv1d### A FLLOOE A%%%%&&&u-A51"AAID!a%##( \ bE 8r>>YY[[FBq!HH$EE ; ' ' $ $&2a88,-- $ $ $!##$$$ $ $!Xa^^+,, $ $ $!##$$$ $!A#q!T**50Aq$''% q!HHc5!$$ Js 0D::EE55Fct||rtt|||S|j}|dkr|jSt ||}|rxd}|dkrn"|}|jturt|}nt|tr |t|}n#t$r}| t|g}||}||}||}|t|}Yn;wxYw |t|}n#t$rtdwxYw||}t#|t%|||||dz }t'|||zSt()a The Logarithm of ``p`` modulo ``O(x**prec)``. Notes ===== Truncation of ``integral dx p**-1*d p/dx`` is used. Examples ======== >>> from sympy.polys.domains import QQ >>> from sympy.polys.rings import ring >>> from sympy.polys.ring_series import rs_log >>> R, x = ring('x', QQ) >>> rs_log(1 + x, x, 8) 1/7*x**7 - 1/6*x**6 + 1/5*x**5 - 1/4*x**4 + 1/3*x**3 - 1/2*x**2 + x >>> rs_log(x**QQ(3, 2) + 1, x, 5) 1/3*x**(9/2) - 1/2*x**3 + x**(3/2) rGrr)rErYrs_logrr$rrrrrrOrrCadd_gensset_ringrdiffrorrr)r,r<r=r+rrrdlogs r1rrs*Q.&!Q--- AAvvv 1a  A" 66 YY[[Fx2~~F A{++ (+Ac&kkNNEE!+++ CKK=11A 1 A 1 A 1 AAc&kkNNEEE +(Ac!ffIIEE!(((%''((((vvayyd.q!T::AtaxHHD!$$u,,!!s!B::BEEEE8ct||rtt|||S|j}|d}t ||rt d||jvrwt|D]e}t|||}t|||||z }t||dz||}t|||}t||||} || z}f|St )a Calculate the series expansion of the principal branch of the Lambert W function. Examples ======== >>> from sympy.polys.domains import QQ >>> from sympy.polys.rings import ring >>> from sympy.polys.ring_series import rs_LambertW >>> R, x, y = ring('x, y', QQ) >>> rs_LambertW(x + x*y, x, 3) -x**2*y**2 - 2*x**2*y - x**2 + x*y + x See Also ======== LambertW rz>Polynomial must not have constant term in the series variablesrG) rErY rs_LambertWrrrr:r8rs_expror~) r,r<r=r+r(rrarjp3rs r1rr"s(Q3+q!T222 A 1B!Q:!#9:: :AF{{!$''  Er1e$$A2q%((1,B261e,,B$RE22BRE**C #IBB !!r3c|j}|d}t|D]-}|t|||z }t||||}||z }.|S)zHelper function for `rs\_exp`. rG)rr8rro)r,r<r=r+r(rptrs r1_exp1rIsf A 1Bd## Au%% %RQ&& c  Ir3ct||rtt|||S|j}t ||}|rP|jt ur%|}t|}nt|tr |}|t|}n#t$r}| t|g}| |}| |}| |}|t|}Yn;wxYw |t|}n#t$rtdwxYw||z }|t|||zSt|dkrt!|||S|d}d} g}t#|D]$} ||| z | dz } | | z} %t'||||} | S)a: Exponentiation of a series modulo ``O(x**prec)`` Examples ======== >>> from sympy.polys.domains import QQ >>> from sympy.polys.rings import ring >>> from sympy.polys.ring_series import rs_exp >>> R, x = ring('x', QQ) >>> rs_exp(x**2, x, 7) 1/6*x**6 + 1/2*x**4 + x**2 + 1 rrrG)rErYrrrrrrrrOrrCrrrrsrrrrr) r,r<r=r+rrrr(rrTrDrXs r1rrSsQ.&!Q--- A1a  A) 8r>>YY[[FKKEE ; ' ' $ '#f++ ' ' 'JJF }--JJqMMJJqMMJJqMM#f++  ' $#a&&  $ $ $!##$$$ $UVB4(((( 1vv{{Q4   !A$$C A A 4[[ Q Q QAq!T**A Hs ,B88BD?>D?EE6c|j}|d}| g}t|||}td|D]#}|||zd|zdzz $t ||||}t ||||}|S)zS Expansion using formula. Faster on very small and univariate series. rrGr5rryrrrrro) r,rbr=r+morrjrDrs r1_atanrs A 2B A 1b$  B 1d^^"" Q!a!!!!B2t,,Aq!RA Hr3ct||rtt|||S|j}d}t ||r|j}||}|jtur$|}t|}nt|trK |}|t|}nT#t$rtdwxYw |t|}n#t$rtdwxYw||}t||||dz} t!| ||dz } t#|| ||dz } t%| ||zS)a The arctangent of a series Return the series expansion of the atan of ``p``, about 0. Examples ======== >>> from sympy.polys.domains import QQ >>> from sympy.polys.rings import ring >>> from sympy.polys.ring_series import rs_atan >>> R, x, y = ring('x, y', QQ) >>> rs_atan(x + x*y, x, 4) -1/3*x**3*y**3 - x**3*y**2 - x**3*y - 1/3*x**3 + x*y + x See Also ======== atan rrrG)rErYrs_atanrrrrrrrrOrrCrrryr~ror r,r<r=r+rrrrdpr(s r1rrs*Q/'1a... A E!Q$ \ bE 8r>>YY[[FLLEE ; ' ' $ $$v,, $ $ $!##$$$ $ $$q''  $ $ $!##$$$ $ B 1a  1 %B RD1H - -B B4!8 $ $B A   &&,CC#C<<Dct||rtt|||St||rt d|j}||jvrt|dkrat||}dt|||dz z }t|d||dz }t||||dz }t||S|d}d|dg}td|dD]D}||dz dz|dz||dz zz |dEt||||St)a Arcsine of a series Return the series expansion of the asin of ``p``, about 0. Examples ======== >>> from sympy.polys.domains import QQ >>> from sympy.polys.rings import ring >>> from sympy.polys.ring_series import rs_asin >>> R, x, y = ring('x, y', QQ) >>> rs_asin(x, x, 8) 5/112*x**7 + 3/40*x**5 + 1/6*x**3 + x See Also ======== asin z:Polynomial must not have constant term in series variablesrrGrrr{r5)rErYrs_asinrrrr:rsrryr|rorrrrr) r,r<r=r+rr(rrrDs r1rrsi*Q/'1a...!Q6!#566 6 AAF{{ q66B;;ABYq!TAX...BRQq11BB4!8,,BA&& &add QKq$""  A HHa!eaZ"%q!a%y1 2 2 2 HHQKKKK"1aD111"!r3c |j}|d}t|D]?}|t|||z }t|dt |||z||}||z }@|S)a Helper function of :func:`rs_tan`. Return the series expansion of tan of a univariate series using Newton's method. It takes advantage of the fact that series expansion of atan is easier than that of tan. Consider `f(x) = y - \arctan(x)` Let r be a root of f(x) found using Newton's method. Then `f(r) = 0` Or `y = \arctan(x)` where `x = \tan(y)` as required. rrG)rr8rroryr,r<r=r+r(rrs r1_tan1rsy A 1Bd##'"a'''S!iAu555q%@@ c  Ir3ct||rtt|||}|S|j}d}t ||}|ry|jt ur%|}t|}nt|tr |}|t|}n#t$r}| t|g}| |}| |}| |}|t|}Yn;wxYw |t|}n#t$rtdwxYw||z }t|||} td|| zz ||} t!|| z| ||S|jdkrt%|||St'|t||S)a Tangent of a series. Return the series expansion of the tan of ``p``, about 0. Examples ======== >>> from sympy.polys.domains import QQ >>> from sympy.polys.rings import ring >>> from sympy.polys.ring_series import rs_tan >>> R, x, y = ring('x, y', QQ) >>> rs_tan(x + x*y, x, 4) 1/3*x**3*y**3 + x**3*y**2 + x**3*y + 1/3*x**3 + x*y + x See Also ======== _tan1, tan rrrG)rErYrs_tanrrrrrrrOrrCrrrr~rorhrr) r,r<r=rXr+rrrr(t2rs r1rrs*Q vq!T * * A E1a  A. 8r>>YY[[FKKEE ; ' ' $ '#f++ ' ' 'JJF //JJqMMJJqMMJJqMM#f++  ' $#a&&  $ $ $!##$$$ $UB4  E"H a 6 6ebj!Q---w!||Q4   aD)))s,B<>> from sympy.polys.domains import QQ >>> from sympy.polys.rings import ring >>> from sympy.polys.ring_series import rs_cot >>> R, x, y = ring('x, y', QQ) >>> rs_cot(x, x, 6) -2/945*x**5 - 1/45*x**3 - 1/3*x + x**(-1) See Also ======== cot cotr5) rErYrs_cotr rs_cos_sinrr~ror@) r,r<r=rXr>rprec1rrr7s r1rrPs.Q vq!T * * Q5 ) )DAq 1Q3JE aE " "DAq1qbAAq%((A Aq% C #q1"  C 34 C Jr3ct||rtt|||S|j}|s |dSt ||}|r|jt ur4|}t|t|}}nZt|tr |}|t||t|}}n#t$r| t|t|g}||}||}||}|t||t|}}YnSwxYw |t||t|}}n#t$rtdwxYw||z }t||||zt!||||zzSt#|dkrY|jdkrNt'|dz ||} t)| ||}t+d|z||}t-|d| z||S|d} d} dg}t/d|dzdD];} || | z |d| | | dzzz} >> from sympy.polys.domains import QQ >>> from sympy.polys.rings import ring >>> from sympy.polys.ring_series import rs_sin >>> R, x, y = ring('x, y', QQ) >>> rs_sin(x + x*y, x, 4) -1/6*x**3*y**3 - 1/2*x**3*y**2 - 1/2*x**3*y - 1/6*x**3 + x*y + x >>> rs_sin(x**QQ(3, 2) + x*y**QQ(7, 5), x, 4) -1/2*x**(7/2)*y**(14/5) - 1/6*x**3*y**(21/5) + x**(3/2) + x*y**(7/5) See Also ======== sin rrrrGr5)rErYrs_sinrrrrrrrrOrrCrrrrs_cosrsrhrryr~rorrrr) r,r<r=r+rrt1rr(rrrTrDs r1rrts.Q.&!Q--- A qtt 1a  A? 8r>>YY[[F[[#f++BB ; ' ' $ 83v;;3v;;B 8 8 8JJF S[[9::JJqMMJJqMMJJqMM3v;;3v;;B  8 $3q66AAc!ffIIB $ $ $!##$$$ $Ub!T""2%r1d(;(;B(>>> 1vv{{qw!|| 1Q34  q!T " " RD 1 1b!A#q$''' !A$$C A A 1dQh " " Q   aRQZ q!Q - --s 'AC,,B*FF0GG(ct||rtt|||S|j}t ||}|r*|jt ur4|}t|t|}}n*t|tr |}|t||t|}}n#t$rs| t|t|g}||}||}||}YnSwxYw |t||t|}}n#t$rtdwxYw||z }t|||}t!|||} ||j| j}||| ||t||t|} } || z| | zz St%|dkrY|jdkrNt)|dz ||} t+| ||} t-d| z||}t/|d| z ||S|d} d}g}t1d|dzdD];}|| |z |d|| |dz zz}>> from sympy.polys.domains import QQ >>> from sympy.polys.rings import ring >>> from sympy.polys.ring_series import rs_cos >>> R, x, y = ring('x, y', QQ) >>> rs_cos(x + x*y, x, 4) -1/2*x**2*y**2 - x**2*y - 1/2*x**2 + 1 >>> rs_cos(x + x*y, x, 4)/x**QQ(7, 5) -1/2*x**(3/5)*y**2 - x**(3/5)*y - 1/2*x**(3/5) + x**(-7/5) See Also ======== cos rrrGr5r)rErYrrrrrrrrrOrrCrrrrcomposersrhrryr~rorrrr)r,r<r=r+rr_r(p_cosp_sinr rrrrTrDs r1rrs+.Q.&!Q--- A1a  A# 8r>>YY[[Fv;;F qAA ; ' ' $ "qV~~qqV~~1 " " "JJF S[[9::JJqMMJJqMMJJqMM  "  $qQyy!!CFF))1 $ $ $!##$$$ $Ur1d##r1d## IIej ! ! ) )%* 5 5 q q3v;;3v;;BRx%("" 1vv{{qw!|| 1Q34  q!T " " 2q$ / /b!b&!T*** !A$$C A A 1dQh " " Q   aRQZ q!Q - --s ACA:EE 0FF+ct||rtt|||St|dz ||}t |||}t d|z||}t |d|z ||t |d|z||fS)z Return the tuple ``(rs_cos(p, x, prec)`, `rs_sin(p, x, prec))``. Is faster than calling rs_cos and rs_sin separately r5rG)rErYrrryr~ro)r,r<r=rrr(s r1rrs Q2*aD111qsAtA 1a  B QVQ - -B 2q2vq$ ' 'AaCD)A)A BBr3c|j}|d}|g}t|||}td|D] }||d|zdzz !t ||||}t ||||}|S)zR Expansion using formula Faster for very small and univariate series rGr5r) r,r<r=r+rrrjrDrs r1_atanhrs A !A$$C A 1a  B 1d^^   acAgB1d++Aq!QA Hr3ct||rtt|||S|j}d}t ||r|j}||}|jtur$|}t|}nt|trK |}|t|}nT#t$rtdwxYw |t|}n#t$rtdwxYwt||}t||| dz} t!| ||dz } t#|| ||dz } t%| ||zS)a Hyperbolic arctangent of a series Return the series expansion of the atanh of ``p``, about 0. Examples ======== >>> from sympy.polys.domains import QQ >>> from sympy.polys.rings import ring >>> from sympy.polys.ring_series import rs_atanh >>> R, x, y = ring('x, y', QQ) >>> rs_atanh(x + x*y, x, 4) 1/3*x**3*y**3 + x**3*y**2 + x**3*y + 1/3*x**3 + x*y + x See Also ======== atanh rrrG)rErYrs_atanhrrrrrrrrOrrCrrryr~rorrs r1rr s*Q0(Aq$/// A E!Q$ \ bE 8r>>YY[[F&MMEE ; ' ' $ $%--(( $ $ $!##$$$ $ $%((  $ $ $!##$$$ $ AB Q4 1 $B RD1H - -B B4!8 $ $B A   &&rct||rtt|||St|||}t |||}||z dz S)a Hyperbolic sine of a series Return the series expansion of the sinh of ``p``, about 0. Examples ======== >>> from sympy.polys.domains import QQ >>> from sympy.polys.rings import ring >>> from sympy.polys.ring_series import rs_sinh >>> R, x, y = ring('x, y', QQ) >>> rs_sinh(x + x*y, x, 4) 1/6*x**3*y**3 + 1/2*x**3*y**2 + 1/2*x**3*y + 1/6*x**3 + x*y + x See Also ======== sinh r5)rErYrs_sinhrr~r,r<r=rr s r1rrVZ*Q/'1a...q!TA Q4 ( (B FA:r3ct||rtt|||St|||}t |||}||zdz S)a Hyperbolic cosine of a series Return the series expansion of the cosh of ``p``, about 0. Examples ======== >>> from sympy.polys.domains import QQ >>> from sympy.polys.rings import ring >>> from sympy.polys.ring_series import rs_cosh >>> R, x, y = ring('x, y', QQ) >>> rs_cosh(x + x*y, x, 4) 1/2*x**2*y**2 + x**2*y + 1/2*x**2 + 1 See Also ======== cosh r5)rErYrs_coshrr~rs r1rrqrr3c |j}|d}t|D]?}|t|||z }t|dt |||z ||}||z }@|S)a  Helper function of :func:`rs_tanh` Return the series expansion of tanh of a univariate series using Newton's method. It takes advantage of the fact that series expansion of atanh is easier than that of tanh. See Also ======== _tanh rrG)rr8rroryrs r1_tanhrsy A 1Bd##(2q%(((S!iAt444a?? c  Ir3ct||rtt|||S|j}d}t ||r|j}||}|jtur$|}t|}nt|trK |}|t|}nT#t$rtdwxYw |t|}n#t$rtdwxYw||z }t|||} td|| zz||} t|| z| ||S|jdkrt#|||St%|t"||S)a Hyperbolic tangent of a series Return the series expansion of the tanh of ``p``, about 0. Examples ======== >>> from sympy.polys.domains import QQ >>> from sympy.polys.rings import ring >>> from sympy.polys.ring_series import rs_tanh >>> R, x, y = ring('x, y', QQ) >>> rs_tanh(x + x*y, x, 4) -1/3*x**3*y**3 - x**3*y**2 - x**3*y - 1/3*x**3 + x*y + x See Also ======== tanh rrrG)rErYrs_tanhrrrrrrrrOrrCrr~rorhrr) r,r<r=r+rrrrr(r rs r1rrs*Q/'1a... A E!Q. \ bE 8r>>YY[[FLLEE ; ' ' $ $$v,, $ $ $!##$$$ $ $$q''  $ $ $!##$$$ $U RD ! ! E"H a 6 6ebj!Q---w!||Q4   a4(((s,CC $C==Dc|}t|}t|||}t|||||}|||zz }|S)aO Compute the truncated Newton sum of the polynomial ``p`` Examples ======== >>> from sympy.polys.domains import QQ >>> from sympy.polys.rings import ring >>> from sympy.polys.ring_series import rs_newton >>> R, x = ring('x', QQ) >>> p = x**2 - 2 >>> rs_newton(p, x, 5) 8*x**4 + 4*x**2 + 2 )r#r2r~ror)r,r<r=r*r(rjrr7s r1 rs_newtonrs^ ((**C   B RD ) )B  B4 ( (B 1*C Jr3Fc^|j}|jtkrt|j}|sC|D]-\}}|t t|dz ||<.nB|D]-\}}|t t|dz||<.|S)a Return ``sum f_i/i!*x**i`` from ``sum f_i*x**i``, where ``x`` is the first variable. If ``invers=True`` return ``sum f_i*i!*x**i`` Examples ======== >>> from sympy.polys.domains import QQ >>> from sympy.polys.rings import ring >>> from sympy.polys.ring_series import rs_hadamard_exp >>> R, x = ring('x', QQ) >>> p = 1 + x + x**2 + x**3 >>> rs_hadamard_exp(p) 1/6*x**3 + 1/2*x**2 + x + 1 r)rrrrr$r!rBr )r(inverser+r,r?rls r1rs_hadamard_expr"s$ Ax2~~!! A ,  , ,HD"T$q']]+++AdGG ,  , ,HD"T$q']]+++AdGG Hr3c|j}|jd}||zdz}t|||}t |}t|||}t |}t ||||} t | d} | d| z |z } t | |} t| ||} t| } | d} ||z| z } | r| || zz} | S)a} compute the composed sum ``prod(p2(x - beta) for beta root of p1)`` Examples ======== >>> from sympy.polys.domains import QQ >>> from sympy.polys.rings import ring >>> from sympy.polys.ring_series import rs_compose_add >>> R, x = ring('x', QQ) >>> f = x**2 - 2 >>> g = x**2 - 3 >>> rs_compose_add(f, g) x**4 - 10*x**2 + 1 References ========== .. [1] A. Bostan, P. Flajolet, B. Salvy and E. Schost "Fast Computation with Two Algebraic Numbers", (2002) Research Report 4579, Institut National de Recherche en Informatique et en Automatique rrGT)r) rr:r#rr"rorrr2 primitive)r(rjr+r<r=np1np1enp2np2enp3enp3np3ar[rs r1rs_compose_addr, s'0 A q A 99;;ryy{{ "Q &D B4 C 3  D B4 C 3  D $a & &D $ % %C IOQ DT1Aq!TAqA aA RYY[[ 188:: -B  aeG Hr3rrrrr)rrrrrcd}d}|dkrt||||}|dz}|dk|j}||}|j|t |fdS)z=Find the minimum power of `a` in the series expansion of exprrr5c|SrrI)rr>s r1rczrs_min_pow..Ps QqTr3rd) _rs_seriesrr:r;r)expr series_rsrseriesrTr+r>s @r1 rs_min_powr3Fs F A A++D)Q22 Q A++  A !A  QA v>>>> * * *1 --r3c |j}|jtd|Ds |js|S||s|S|jr|d}t |dkrt t|tdd\}}t||||} | |j| }ttt|j|||}|S|jrJt |} |D]3}|js*t|dd\}}  |4t%t't(|fd|D|gt |z} t+| } d}t-| D]~} t|| || ||| z | | z} |j| }| }||z}t/|||}|S|jrt |} d}t-| D]r} t|| || ||} |j| }| }||z }s|S|jrt|jtdd\}}  |t|j|j||}t7||j|||St;|t<r2|rt|tdddSt ) Nc3JK|]}|tVdSr)hasr)rKargs r1 z_rs_series..Zs.11Sswwx  111111r3rrGFTrexpandr2)r:r2c&g|] }|SrIrI)rKr7r+s r1rNz_rs_series..s!.F.F.F#qqvv.F.F.Fr3) rrany is_Functionr6rsrrrr/r reval _convert_funcrfuncis_Mul is_Numberr mapr3sumrrr@is_Addis_Powbaser}rrOr is_constant)r0r1rr=rr7rr2 series_innerrTr min_powssum_powsr>_seriesr+s @r1r/r/Ss 9DA 11D111 1 1$:J 88A;;I" F"1g t99q==% %3r%EEE F!#vq$77  IIbMM ! !,"3 4 4#,,Q// 4mC NN344\ AaDD$ ," II " "C= "c%===AIIbMMJ.F.F.F.F.F.F.F CD Mx==1q  A a!!DG**a :G ',''A&&q))G__Q''F g FF&!!A$$-- " II1q  A a!!DG**a>>G ',''A&&q))G__Q''F g FF  "di5FFFA IIbMM!$)QQty\\1dCC lDHl.?.?.B.BDIII D$  "D$4$4$6$6"T"U4@@@CC"!r3ct|tdd\}}||jvr||g}||}t ||||}|j}||}||dz}||krt|||StddD]}t |||||z}||j}||dz} | |krt|||z |z| |z z z} t |||| }||dz|krNt |||| }||j}| dz} ||dz|kNn$n"tdt|d |t|||S) a+Return the series expansion of an expression about 0. Parameters ========== expr : :class:`Expr` a : :class:`Symbol` with respect to which expr is to be expanded prec : order of the series expansion Currently supports multivariate Taylor series expansion. This is much faster that SymPy's series method as it uses sparse polynomial operations. It automatically creates the simplest ring required to represent the series expansion through repeated calls to sring. Examples ======== >>> from sympy.polys.ring_series import rs_series >>> from sympy import sin, cos, exp, tan, symbols, QQ >>> a, b, c = symbols('a, b, c') >>> rs_series(sin(a) + exp(a), a, 5) 1/24*a**4 + 1/2*a**2 + 2*a + 1 >>> series = rs_series(tan(a + b)*cos(a + c), a, 2) >>> series.as_expr() -a*sin(c)*tan(b) + a*cos(c)*tan(b)**2 + a*cos(c) + cos(c)*tan(b) >>> series = rs_series(exp(a**QQ(1,3) + a**QQ(2, 5)), a, 1) >>> series.as_expr() a**(11/15) + a**(4/5)/2 + a**(2/5) + a**(2/3)/2 + a**(1/3) + 1 FTr9rG )r=r5zCould not calculate z terms for ) rrsymbolsrrr/rr#r@rrrrCr) r0rr=r+r2genprec_gotmorer(new_precprec_dos r1 rs_seriesrUs@d2eDAAAIAv  JJu   __Q  F fa . .F A !A$$C}}S!!A%H4T*** !QKK 2 2DD&!$+>>>B,,rw''Cyy~~)H8##!$$/4)?B*#fag>>>iinnq(4//#D&!'BBBB,,rw//CqLGiinnq(4//* #D 44122 2C&&&r3)rG)F)Z__doc__sympy.polys.domainsrrsympy.polys.ringsrrrsympy.polys.polyerrorsrsympy.polys.monomialsr r r r mpmath.libmp.libintmathr sympy.corerrrsympy.core.numbersrsympy.core.intfuncrsympy.functionsrrrrrrrrrsympy.utilities.miscrrrr2r8r@rErYr\roryr}rrrrrr~rrrrrrrrJrr|rrrrrrrrrrrrrrrrrrrrr"r,r?r3r/rUrIr3r1ras))V'&&&&&&&6666666666......222222222222((((((0000000000''''''######OOOOOOOOOOOOOOOOOOOOOO''''''//////    >   62% % % N   21 1 1 f& & & P4 4 4 lBBBH4   &,,,\$ $ $ L   F F F PW W W W r@@666p       &!/!/!/FJJJX7"7"7"r%"%"%"N7 7 7 r   4'4'4'l+"+"+"Z*:*:*:*x"""HD.D.D.LG.G.G.R C C C   4'4'4'l66*4)4)4)l,    <0 0 0 h    . . .S"S"S"jB'B'B'B'B'r3