o o h@sxdZddlmZmZddlmZmZmZddlm 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&ddZ'ddZ(ddZ)ddZ*ddZ+ddZ,ddZ-ddZ.ddZ/d d!Z0d"d#Z1d$d%Z2d&d'Z3d(d)Z4d*d+Z5d,d-Z6d.d/Z7dud1d2Z8d3d4Z9d5d6Z:d7d8Z;d9d:ZZ>d?d@Z?dAdBZ@dCdDZAdEdFZBdGdHZCdIdJZDdKdLZEdMdNZFdOdPZGdQdRZHdSdTZIdUdVZJdWdXZKdYdZZLd[d\ZMd]d^ZNd_d`ZOdadbZPdcddZQdedfZRdgdhZSdvdjdkZTdldmZUdVdXdHdRdBdnZVdodpZWdqdrZXdsdtZYd S)wa9Power 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_stepsNc Csbt|}||}|j}|j}|}|}t||D] \}}||||df<q!|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) p1termsdegRpcvmvmvicvir/k/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/sympy/polys/ring_series.py_invert_monoms;s r1cCs$td|}|ddkrdg|}|S)z8Return a list of precision steps for the Newton's methodrr)targetresr/r/r0 _giant_stepsZs   r5cCs@|j}|j}|j|}|D]}|||krq||||<q|S)a Truncate the series in the ``x`` variable with precision ``prec``, that is, modulo ``O(x**prec)`` Examples ======== >>> 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*iexp1r/r/r0rs_truncas  r<cCsN|jj|}|D]}||t||krdS||dkr$td|q dS)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)rr6r7int ValueError)r*r8r7kr/r/r0 rs_is_puiseux|s  r@c s|jj|d}|D]1}|}t|tr(|\}}t||t||}q |t|kr<|j}t||t||}q |dkrot ||} || |||} t d|t| t rgt fdd| D} | St | } | S||||} | 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 csg|]}t|qSr/)pow_xin).0rxr7n1r/r0 szrs_puiseux..) rr6r7 isinstanceras_numer_denomr=r denominatorrBrtuple) fr*r8r9nr?powernumdenr&rr/rEr0 rs_puiseuxs,        rRcCs|jj|}d}|D]-}||}t|tr&|\} } || t|| }q |t|kr8|j} || t|| }q |dkrYt |||} || ||||} t d|} t | || } | S|||||} | S)z Return the puiseux series for `f(p, q, x, prec)`. To be used when function ``f`` is implemented only for regular series. rA) rr6r7rHrrIrr=rJrBr)rLr*qr8r9r7rMr?rNrOrPr&rQrFr/r/r0 rs_puiseux2s&      rTcsD|j}|j}|j|jjks||jkrtd|j|t|ts%td||jkr|j}t | }|j fddd|j dkrn| D]&\}} |D]\} } |d| d} | |krk| f} || d| | || <qLqFn.|j } | D]&\}} |D]\} } || |kr| || } || d| | || <q{qu||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 |dSNrr/eivr/r0 zrs_mul..keyrAr)rr" __class__r>r6r7rHrgetrrr ngensr strip_zero)r&p2r8r9r)r*r`items2r;v1exp2v2rr r/rYr0rs_muls>         rhcs|j}|j}|j||j}t|}|jfddd|j}t t |D]0}||\} } t |D]#} || \} } | | |krW|| | }||d| | ||<q4q(| d}|j}|D]\}}d||kr|||}||d|d||<qe| |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 crUrVr/rWrYr/r0r[r\zrs_square..r]rr2) rr"r6r7r`rrr r rangelenimul_numrb)r&r8r9r)r*r`rr r:r;rejrfrgrexpvve2r/rYr0 rs_squares2        rpc Cs@|j}t|tr3t|j}t|j}|dkr*t||||}|dkr(t||||}|St||||}|St|}|dkrE|rA|dSt d|dkrWt|| ||}t |||S|dkrat |||S|dkrkt |||S|dkr|t |||}t ||||S|d} |d@rt || ||} |d8}|s | St |||}|d}q)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 rArz0**0 is undefinedr2)rrHrr=r*rS rs_nth_rootrs_powrr>rs_series_inversionr<rprh) r&rMr8r9r)npnqr4rcr*r/r/r0rs0sJ        rscCsj|j}|j}|d}t|D] }|j|||df<q|D] }|||||df<q|d} t|} | D]|} |d} t|D]i}| |} | dkrKq@|| f|vrt| d\}}|dkrq||f|vrqt|||f||||| f<n-|| df|vrt ||| df||df||||| f<nt ||df| ||||| f<t | ||| f||} q@| | || 7} q6| 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 rrAr2) rrarir6r7sortedkeysdivmodrprhrs)r*rulesr8r9r)radr:varr&p_keysrmrcrNrSrQr/r/r0rs_subsfs6(    r~cCsV|j}|j|}|j}dg|j}d||<t|}|D] }t|||kr(dSqdS)aF Check if ``p`` has a constant term in ``x`` Examples ======== >>> 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 rrATFrr6r7 zero_monomrarKr)r*r8r)rZzmamivrmr/r/r0_has_constant_terms  rc Csh|j}|j|}|j}dg|j}d||<t|}d}|D]}t|||kr1|||||i7}q|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. rrAr) r*r8r)r:rrrcrmr/r/r0_get_constant_terms  rcsB|jj|t|fddd}|dkrtd||fS)Nc|SNr/r?r7r/r0r[z#_check_series_var..r]rz7Asymptotic expansion of %s around [oo] not implemented.)rr6r7minr )r*r8namemr/rr0_check_series_varsrc Cst||r tt|||S|j}|j}||}|t|kr t|}||vr(tdt|||r3td|d}|jt ur>d}||krI|d|}n|d}t |D]}dt ||||} |t || ||}qQ|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 parametersrA) r@rR_series_inversion1rrr=r>rdomainrr5rh) r*r8r9r)rroner&precxtr/r/r0rs*    rcs|j}||jkr t|j}|j|t|fddd}|r,t|| }||}||vr4tdt ||||rAtdt |||}|dkrRt|| }|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) crrr/rrr/r0r[$rz%rs_series_inversion..r]rz>p - p[0] must not have a constant term in the series variablesr) rr"ZeroDivisionErrorrr6r7rmul_xinNotImplementedErrorrr)r*r8r9r)rrrQr/rr0rt s"   rtcCs^|\}}|j}dg|j}|||<t|}|d}|D]}|||kr,|||t||<q|S)z2Coefficient of `x_i**j` in p, where ``t`` = (i, j)r)rrarKr )r*rr:rlr)expv1r&rmr/r/r0_coefficient_t3s  rc Cst||rt|j}|j|}||}|j|}t||r#tdt||df}|j}||vr7t |dks9J||}||} t d|D]} t ||| i|| d} t| || f|| } | | |8} qF| 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 variablerAr2) r@rrr6r7rr>rrrjrir~) r*r8rMyr)nxnyrrrQr:spr/r/r0rs_series_reversion@s$ 4   rrAcCs, |j}t|}|s-|d}|d|}td|D]} t||||}||| |7}q|Stt|d} t|| \} } | rC| d7} |dg} |d}t|dkrgtd| D]} t||||}| |qWn%td| D]} | ddkrt | | d||}nt||||}| |qlt| d|||}|d}|d}t| dD]4}| |} || }td| D]}||| || |7}qt||||}||7}t||||}|snq| d}| |} | |kr|| |d}td| D]}| ||krn ||| || |7}qt||||}||7}|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 rArr2) rrjrirhr=mathsqrtryappendrp)r*rr8r9concurr)rMrSsr:JKrQaxpjbr?s1rlr/r/r0rs_series_from_listsf        rcCsn|j}|j|}|j}dg|j}d||<t|}|D]}||r4t||}|||||||<q|S)a Return partial derivative of ``p`` with respect to ``x``. Parameters ========== x : :class:`~.PolyElement` with respect to which ``p`` is differentiated. Examples ======== >>> 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 rrA)rr6r7r"rarKr domain_new)r*r8r)rMr&mnrmrXr/r/r0rs_diffs   rcCsj|j}|j}|j|}dg|j}d||<t|}|D]}t||}|||||d||<q|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 rrA)rr"r6r7rarKr r)r*r8r)r&rMrrmrXr/r/r0 rs_integrates    rcGs|j}td|j\}}t|d}|dd||f}|j}||vr/|||} |||} n|} |} t|tr@t| ||} n|| g|R} t| } dg|} | D] }|d| |dd<qUt | | |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 _xrNrrA) rrr=rrHstrgetattrrwrr)r*rLargs_RR1rhargs1rx1r&rSrrr8r/r/r0rs_fun!s&      rcCsH|j}|d}|D]\}}t|}|||7<||t|<q |S)zF Return `p*x_i**n`. `x\_i` is the ith variable in ``p``. rrrrrKr*r:rMr)rSr?rnk1r/r/r0rYsrcCsH|j}|d}|D]\}}t|}|||9<||t|<q |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 rrrr/r/r0rBgs rBc Cst||r tt||||S|j}|j}||vrtdt|}||dks'J|d}|dkr1|S|dkr9|dS|dkr?|S|dkrI| }d}nd}t|D]}t||d||} t | |||} |||| |7}qO|rp|St |||S)z_ Univariate series expansion of the nth root of ``p``. The Newton method is used. rrAr) r@rT _nth_root1rrrrr5rsrhr) r*rMr8r9r)rr&signrtmpr/r/r0rzs4   rc sf|dkr|dkr td|dS|dkrt|||S|j}|j|t|fddd}t|| }||8}t|d|r|j}||}|j t urZ| }|t d|} n7t |trzz| }||t d|} Wn"tyytdwz ||td|} Wn tytdwt|||||| } nt||||} |rt ||}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 expressionrAcrrr/rrr/r0r[rzrs_nth_root..r]3The given series cannot be expanded in this domain.)r>rr<r6r7rrrrrras_exprrrHrrrrrr) r*rMr8r9r)rrrc_exprconstr4r/rr0rrsF$         rrcCs*t||r tt|||S|j}|dkr|jSt||}|rd}|dkr$nV|}|jtur2t |}nHt |t rfz|t |}Wn:t ye| t |g}||}||}||}|t |}Ynwz|t |}Wn t yytdw||}t|t|||||d}t|||St)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) rArr)r@rRrs_logrr"rrrrrrHrr>add_gensset_ringrdiffrhrrr)r*r8r9r)rrrdlogr/r/r0rs@           rc Cst||r tt|||S|j}|d}t||rtd||jvrSt|D]+}t|||}t |||||}t ||d||}t |||}t ||||} || 8}q%|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 variablesrA) r@rR rs_LambertWrrrr6r5rs_exprhrt) r*r8r9r)r&rrXrcp3rr/r/r0r"s       rcCsF|j}|d}t|D]}|t|||}t||||}||7}q |S)zHelper function for `rs\_exp`. rA)rr5rrh)r*r8r9r)r&rptrr/r/r0_exp1Is  rc Cs^t||r tt|||S|j}t||}|r||jtur$|}t|}nLt |t r\z |}|t|}Wn:t y[| t|g}| |}| |}| |}|t|}Ynwz|t|}Wn t yotdw||}|t|||St|dkrt|||S|d}d} g}t|D]} ||| | d7} | | 9} qt||||} | 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 rrrA)r@rRrrrrrrrrHrr>rrrrjrrirr) r*r8r9r)rrrr&rrMr?rQr/r/r0rSsJ              rc Csl|j}|d}| g}t|||}td|D]}|||d|dqt||||}t||||}|S)zS Expansion using formula. Faster on very small and univariate series. rrAr2rrprirrrh) r*rZr9r)morrcr?rr/r/r0_atans rc Cst||r tt|||S|j}d}t||r\|j}||}|jtur+|}t |}n1t |t rHz |}|t |}Wnt yGt dwz|t |}Wn t y[t dw||}t||||d} t| ||d} t|| ||d} t| ||S)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 rrrA)r@rRrs_atanrrrrrrrrHrr>rrrprtrhr r*r8r9r)rrrrdpr&r/r/r0rs6        rc Cst||r tt|||St||rtd|j}||jvrzt|dkrIt||}dt |||d}t |d||d}t ||||d}t ||S|d}d|dg}t d|dD]}||dd|d||d|dqXt||||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 variablesrrArrrqr2)r@rRrs_asinrrrr6rjrrprrrhrrirr) r*r8r9r)rr&rrr?r/r/r0rs&       & rcCsR|j}|d}t|D]}|t|||}t|dt|||||}||7}q |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. rrA)rr5rrhrpr*r8r9r)r&rrr/r/r0_tan1   rc CsFt||rtt|||}|S|j}d}t||}|r|jtur(|}t|}nLt |t r`z |}|t|}Wn:t y_| t|g}| |}| |}| |}|t|}Ynwz|t|}Wn t ystdw||}t|||} td|| ||} t|| | ||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 rrrA)r@rRrs_tanrrrrrrrHrr>rrrrtrhrarr) r*r8r9rQr)rrrr&t2rr/r/r0rsB             rc Cst||rtt|||}|St||d\}}|d|}t|||\}}t||| }t|||}t||||} t| || } t| ||} | S)a Cotangent of a series Return the series expansion of the cot of ``p``, about 0. Examples ======== >>> 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 cotr2) r@rRrs_cotr rs_cos_sinrrtrhr<) r*r8r9rQr:rprec1rrr4r/r/r0rPs    rc Cst||r tt|||S|j}|s|dSt||}|r|jtur/|}t|t |}}ndt |t rxz|}|t||t |}}WnKt yw| t|t |g}||}||}||}|t||t |}}Ynwz|t||t |}}Wn t ytdw||}t||||t||||St|dkr|jdkrt|d||} t| ||}td|||}t|d| ||S|d} d} dg}td|ddD]} || | |d| | | d9} qt||||S)a# Sine of a series Return the series expansion of the sin of ``p``, about 0. Examples ======== >>> 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 rrrrAr2)r@rRrs_sinrrrrrrrrHrr>rrrrs_cosrjrarrprtrhrirr) r*r8r9r)rrt1rr&rrrMr?r/r/r0rtsR            rcCs$t||r tt|||S|j}t||}|r|jtur)|}t|t |}}nWt |t rez|}|t||t |}}Wn>t yd| t|t |g}||}||}||}Ynwz|t||t |}}Wn t ytdw||}t|||}t|||} ||j| j}||| ||t||t |} } || | | St|dkr|jdkrt|d||} t| ||} td| ||}t|d| ||S|d} d}g}td|ddD]}|| ||d|| |d9}qt||||S)a Cosine of a series Return the series expansion of the cos of ``p``, about 0. Examples ======== >>> 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 rrrAr2r)r@rRrrrrrrrrrHrr>rrrrcomposerjrarrprtrhrirr)r*r8r9r)rr_r&p_cosp_sinrrrrrMr?r/r/r0rsX              rcCsht||r tt|||St|d||}t|||}td|||}t|d|||t|d|||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 r2rA)r@rRrrrprtrh)r*r8r9rrr&r/r/r0rs  $rc Csf|j}|d}|g}t|||}td|D] }||d|dqt||||}t||||}|S)zR Expansion using formula Faster for very small and univariate series rAr2r) r*r8r9r)rrrcr?rr/r/r0_atanhs rc Cst||r tt|||S|j}d}t||r\|j}||}|jtur+|}t |}n1t |t rHz |}|t |}Wnt yGt dwz|t |}Wn t y[t dwt||}t||| d} t| ||d} t|| ||d} t| ||S)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 rrrA)r@rRrs_atanhrrrrrrrrHrr>rrrprtrhrrr/r/r0r s6        rcCs<t||r tt|||St|||}t|||}||dS)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 r2)r@rRrs_sinhrrtr*r8r9rrr/r/r0rV    rcCs<t||r tt|||St|||}t|||}||dS)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 r2)r@rRrs_coshrrtrr/r/r0rqrrcCsR|j}|d}t|D]}|t|||}t|dt|||||}||7}q |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 rrA)rr5rrhrprr/r/r0_tanhrrc Cst||r tt|||S|j}d}t||ry|j}||}|jtur+|}t |}n1t |t rHz |}|t |}Wnt yGt dwz|t |}Wn t y[t dw||}t|||} td|| ||} t|| | ||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 rrrA)r@rRrs_tanhrrrrrrrrHrr>rrtrhrarr) r*r8r9r)rrrrr&rrr/r/r0rs:          rcCs@|}t|}t|||}t|||||}|||}|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!r1rtrhr)r*r8r9r(r&rcrr4r/r/r0 rs_newtons   rFcCsz|j}|jtkr t|j}|s&|D]\}}|tt|d||<q|S|D]\}}|tt|d||<q*|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"rr=r )r&inverser)r*r;rer/r/r0rs_hadamard_exps rcCs|j}|jd}||d}t|||}t|}t|||}t|}t||||} t| d} | d| |} t| |} t| ||} t| } | d} ||| } | rc| || } | 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 rrAT)r) rr6r!rrrhrrr1 primitive)r&rcr)r8r9np1np1enp2np2enp3enp3np3arSrr/r/r0rs_compose_add s$        r)rrrrrcs`d}d}|dkrt||||}|d9}|dks|j}||}|j|t|fdddS)z=Find the minimum power of `a` in the series expansion of exprrr2crrr/)rr:r/r0r[Przrs_min_pow..r]) _rs_seriesrr6r7r)expr series_rsrseriesrMr)r/rr0 rs_min_powFs rcs|j}|jtdd|Ds|js|S||s|S|jrZ|d}t|dkr*tt|tddd\}}t ||||} | |j| }t t t|j|||}|S|jrt|} |D]}|jsvt|ddd\}} |qcttt|fd d |D|gt|} t| } d}t| D])} t || || ||| | | } |j| }| }||9}qt|||}|S|jrt|} d}t| D]#} t || || ||} |j| }| }||7}q|S|jr,t|jtddd\}} |t |j|j||}t||j|||St|trA|rAt|tddddSt) Ncss|]}|tVqdSr)hasrrCargr/r/r0 Zsz_rs_series..rrAFTrexpandr)rrcsg|]}|qSr/r/rr)r/r0rGsz_rs_series..) rrany is_Functionrrjrrrrrreval _convert_funcrfuncis_Mul is_Numberrmaprsumrir<is_Addis_PowbasersrrHr is_constant)rrrr9rrrr series_innerrMrmin_powssum_powsr:_seriesr/rr0rSst                rc CsRt|tddd\}}||jvr||g}||}t||||}|j}||}||d}||kr9t|||St ddD]Z}t|||||d}||j}||d} | |krt ||||| |} t|||| d}||d|krt|||| d}||j}| d9} ||d|kszn n t dt ||ft|||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 FTrrA )r9r2z#Could not calculate %s terms for %s) rrsymbolsrrrrr!r<rirr>r) rrr9r)rgenprec_gotmorer&new_precprec_dor/r/r0 rs_seriess<         r!)rA)F)Z__doc__sympy.polys.domainsrrsympy.polys.ringsrrrsympy.polys.polyerrorsrsympy.polys.monomialsrr r r mpmath.libmp.libintmathr sympy.corer rrsympy.core.numbersrsympy.core.intfuncrsympy.functionsrrrrrrrrrsympy.utilities.miscrrrr1r5r<r@rRrTrhrprsr~rrrrrtrrrrrrrrBrrrrrrrrrrrrrrrrrrrrrrrrrr rrr!r/r/r/r0s+    ,  '3(6D.& HY  8#L9' 96-<$FI 66 4 U