B [c@sdZddlmZmZddlmZddlmZmZm Z ddl m Z ddl m Z ddlmZddlmZmZdd lmZdd lmZdd lmZmZmZmZdd lmZdd lmZddl m!Z!ddl"m#Z#ddl$m%Z%m&Z&m'Z'ddl(m)Z)ddl*m+Z+m,Z,m-Z-ddl.m/Z/m0Z0ddl1m2Z2ddl3m4Z4ddl5m6Z6ddl7m8Z8dOddZ9ddZ:dPddZ;d d!Zd&d'Z?d(d)Z@d*d+ZAd,d-ZBd.d/ZCd0d1ZDd2d3ZEd4d5ZFd6d7ZGd8d9ZHd:d;ZIdd?ZKd@dAZLdQdBdCZMdDdEZNdRdHdIZOGdJdKdKe4ZPdSdMdNZQdLS)TzFormal Power Series)print_functiondivision) defaultdict)oozoonan)Expr)Add)Mul) DerivativeFunction)S)sympify)WildDummysymbolsSymbol)Eq)Rational)iterable)Interval)binomial factorialrf) Piecewise)floorfracceiling)MinMax)sequence) SeriesBase)Order)LimitFcCsddlm}m}ddlm}|}g} xt|dD]} | rH||}||rtj tj } } ||||d} | |r| } xt | D]}|\}}| |s| |7} qt|tr||}|d}||d}|\}}||\}}|s| |7} q|d|}|| }|||}d||t||d|t|||}| |7} qW| tj krtdS| |s| ts| ts| trdSxDt| D]8}| ||d} || |} | | | |d7} qW| ||| | | fS| |q4WdS)a?Rational algorithm for computing formula of coefficients of Formal Power Series of a function. Applicable when f(x) or some derivative of f(x) is a rational function in x. :func:`rational_algorithm` uses :func:`apart` function for partial fraction decomposition. :func:`apart` by default uses 'undetermined coefficients method'. By setting ``full=True``, 'Bronstein's algorithm' can be used instead. Looks for derivative of a function up to 4'th order (by default). This can be overridden using order option. Returns ======= formula : Expr ind : Expr Independent terms. order : int Examples ======== >>> from sympy import log, atan, I >>> from sympy.series.formal import rational_algorithm as ra >>> from sympy.abc import x, k >>> ra(1 / (1 - x), x, k) (1, 0, 0) >>> ra(log(1 + x), x, k) (-(-1)**(-k)/k, 0, 1) >>> ra(atan(x), x, k, full=True) ((-I*(-I)**(-k)/2 + I*I**(-k)/2)/k, 0, 1) Notes ===== By setting ``full=True``, range of admissible functions to be solved using ``rational_algorithm`` can be increased. This option should be used carefully as it can significantly slow down the computation as ``doit`` is performed on the :class:`RootSum` object returned by the ``apart`` function. Use ``full=False`` whenever possible. See Also ======== sympy.polys.partfrac.apart References ========== .. [1] Formal Power Series - Dominik Gruntz, Wolfram Koepf .. [2] Power Series in Computer Algebra - Wolfram Koepf r)RootSumapart) integrate)fullN) sympy.polysr%r&sympy.integralsr'rangediffis_rational_functionr ZerohasZdoitr make_argsas_numer_denom isinstancer as_independent as_base_expZ as_coeff_addcoeffrZrewriterrrrpoplimitsubsappend)fxkorderr)r%r&r'r.Zdsir7septermstZnumZdenindjaxtermZxcakrI2lib/python3.7/site-packages/sympy/series/formal.pyrational_algorithmsV;             "  $  rKc Cs|sgS|dd}xx|ddD]h}||d}xTt|D]>\}}||d}||}||r>|||7<Pq>W||q"W|S)aReturns a list of all the rationally independent terms. Examples ======== >>> from sympy import sin, cos >>> from sympy.series.formal import rational_independent >>> from sympy.abc import x >>> rational_independent([cos(x), sin(x)], x) [cos(x), sin(x)] >>> rational_independent([x**2, sin(x), x*sin(x), x**3], x) [x**3 + x**2, x*sin(x) + sin(x)] rr(N)r5 enumerateZcancelr/r;) rBr=rDrCnr@termdqrIrIrJrational_independents   rQc #sddlm}td|fdd}||\}}d}xtd|dD]} || \}}|}|} t| } |st| | krJtt dd || d | D} | rd }| | }| d}| tdd}|t| fVqJWd S) a^Generates simple DE. DE is of the form .. math:: f^k(x) + \sum\limits_{j=0}^{k-1} A_j f^j(x) = 0 where :math:`A_j` should be rational function in x. Generates DE's upto order 4 (default). DE's can also have free parameters. By increasing order, higher order DE's can be found. Yields a tuple of (DE, order). r)linsolveza:%dcsd|tfddtd|D}|tfddtd|D}||fS)Ncs g|]}||qSrI)r.).0r@)rFr<r=rIrJ sz-simpleDE.._makeDE..rcs$g|]}||qSrI)r.)rSr@)rFgr=rIrJrTs)r.r r-)r>eqDE)rFr<rUr=rIrJ_makeDEs,0zsimpleDE.._makeDEFr(css|]}|D] }|Vq qdS)NrI)rSsr@rIrIrJ szsimpleDE..NT)sympy.solvers.solvesetrRrr-expandZas_ordered_termsrQlendictzipr:r3factor as_coeff_mulr collect) r<r=rUr?rRrXrVrWfoundr>rBrDsolrI)rFr<rUr=rJsimpleDEs$     &  rec Cstj}|t}d}x^t|D]P}||\}}t|t rH|j } nd} |dks\| |kr`| }||||| 7}q$W|r| |||}|S)azConverts a DE with constant coefficients (explike) into a RE. Performs the substitution: .. math:: f^j(x) \to r(k + j) Normalises the terms so that lowest order of a term is always r(k). Examples ======== >>> from sympy import Function, Derivative >>> from sympy.series.formal import exp_re >>> from sympy.abc import x, k >>> f, r = Function('f'), Function('r') >>> exp_re(-f(x) + Derivative(f(x)), r, k) -r(k) + r(k + 1) >>> exp_re(Derivative(f(x), x) + Derivative(f(x), (x, 2)), r, k) r(k) + r(k + 1) See Also ======== sympy.series.formal.hyper_re Nr) r r0atomsr r8r r2r5r4r derivative_countr:) rWrr>RErUminirCr7rOrErIrIrJexp_res rkcCstj}|t}|t}d}xt|D]}| |\}} | |\} } | |d} t | t rv| j } nd} || t|d| | ||| | 7}|dks| | |kr6| | }q6W||||}td}||||S)a}Converts a DE into a RE. Performs the substitution: .. math:: x^l f^j(x) \to (k + 1 - l)_j . a_{k + j - l} Normalises the terms so that lowest order of a term is always r(k). Examples ======== >>> from sympy import Function, Derivative >>> from sympy.series.formal import hyper_re >>> from sympy.abc import x, k >>> f, r = Function('f'), Function('r') >>> hyper_re(-f(x) + Derivative(f(x)), r, k) (k + 1)*r(k + 1) - r(k) >>> hyper_re(-x*f(x) + Derivative(f(x), (x, 2)), r, k) (k + 2)*(k + 3)*r(k + 3) - r(k) See Also ======== sympy.series.formal.exp_re Nr(rm)r r0rfr r8rr r2r\r5Zas_coeff_exponentr4r rgrr:rrb)rWrhr>rirUr=rjrCr7rOcvlrErlrIrIrJhyper_res" * rpcCs:||| 9}||||}||||}||||fS)N)r:)r<r=PQr>rlshiftrIrIrJ_transformation_aHsrtcCsD||||}||||}||||}||9}||||fS)N)r:)r<r=rqrrr>rlscalerIrIrJ_transformation_cOs rvcCsJ||}|||d||d}|||d|d}||||fS)Nr()r.r:)r<r=rqrrr>rlrIrIrJ_transformation_eWs rwcsfdd|DS)Ncsg|]\}}||fqSrIrI)rSrescond)rsrIrJrT_sz _apply_shift..rI)rdrsrI)rsrJ _apply_shift^srzcsfdd|DS)Ncsg|]\}}||fqSrIrI)rSrxry)rurIrJrTcsz _apply_scale..rI)rdrurI)rurJ _apply_scalebsr{csfdd|DS)Ncs6g|].\}}||d|d|dfqS)r() as_coeff_Addr7)rSrxry)r>rIrJrTgsz$_apply_integrate..rI)rdr=r>rI)r>rJ_apply_integratefs r}cCs>ddlm}g}x&t|d||dD] } ||| |dt| } | tjkrXq*||| } | } ||| } ||| }| |d| |d}||d| |d}| | ||9} x.|| | D]\} }| t | ||9} qWx0||| D]\} }| t | ||} qW| | | fq*W|S)zComputes the formula for f.r)rootsr() r+r~r-r.r9rr r0r:Zleadtermitemsrr;)r<r=rqrrr>rlk_maxr~rdr@rhZktermrxprPZc1Zc2mulrIrIrJ_compute_formulaks&      rc Csnddlm}m}ddlm}||||||} } t| } | | |dd| D} t||||||| \}}}}|||} | rt | } nt j } | |}t |||||||\}}}}|||d}t|ts|dkrdS|||} | rt| }nt j }t j t }}xt||dD]}||||dt|}|jdkr|}t |||||||\}}}}t||||||\}}}}t||||||\}}}t|||}t||}|||}||||d7}|d7}|||fS|r(|||||7}t||| }||kr(|}q(W|||d| }t|||||||}t||}t|| }|||fS) zRecursive wrapper to rsolve_hypergeometric. Returns a Tuple of (formula, series independent terms, maximum power of x in independent terms) if successful otherwise ``None``. See :func:`rsolve_hypergeometric` for details. r)lcmr~)r'cSs"g|]\}}|jr|dqS)r()Z is_rationalr3)rSrhrCrIrIrJrTsz*_rsolve_hypergeometric..Nr(F)r+rr~r,r'r^updaterrvrkeysr r0rtr9r4r#rrr-r.rZ is_finiterw_rsolve_hypergeometricr}rzrr:rr{)r<r=rqrrr>rlrr~r'ZprootsZqrootsZ all_rootsruZk_minrsrorrDmpr@rhZold_frdpow_xrIrIrJrsX              rcCs`t||||||}|dkrdS|\}}} tdd} x~|D]v\} } | \} }||}| jdkrz| |t| 9} t| } | ||| |} t||| |} | | | 7<q:Wg}x"| D]\} } | | | fqW| t j dft |}| t krt j }n| jdkrt| }n| d}|dkrV|tt|||||df7}t j }|||fS) aSolves RE of hypergeometric type. Attempts to solve RE of the form Q(k)*a(k + m) - P(k)*a(k) Transformations that preserve Hypergeometric type: a. x**n*f(x): b(k + m) = R(k - n)*b(k) b. f(A*x): b(k + m) = A**m*R(k)*b(k) c. f(x**n): b(k + n*m) = R(k/n)*b(k) d. f(x**(1/m)): b(k + 1) = R(k*m)*b(k) e. f'(x): b(k + m) = ((k + m + 1)/(k + 1))*R(k + 1)*b(k) Some of these transformations have been used to solve the RE. Returns ======= formula : Expr ind : Expr Independent terms. order : int Examples ======== >>> from sympy import exp, ln, S >>> from sympy.series.formal import rsolve_hypergeometric as rh >>> from sympy.abc import x, k >>> rh(exp(x), x, -S.One, (k + 1), k, 1) (Piecewise((1/factorial(k), Eq(Mod(k, 1), 0)), (0, True)), 1, 1) >>> rh(ln(1 + x), x, k**2, k*(k + 1), k, 1) (Piecewise(((-1)**(k - 1)*factorial(k - 1)/RisingFactorial(2, k - 1), Eq(Mod(k, 1), 0)), (0, True)), x, 2) References ========== .. [1] Formal Power Series - Dominik Gruntz, Wolfram Koepf .. [2] Power Series in Computer Algebra - Wolfram Koepf NcSstjS)N)r r0rIrIrIrJsz'rsolve_hypergeometric..FTr(rr*)rrr|r7 is_integerrrr:rrr;r r0rrrsumr )r<r=rqrrr>rlresultZsol_listrDrZsol_dictrxryrEZmkrmrdrYrIrIrJrsolve_hypergeometrics8-          rc Cst|}t|dkr|t|t}t|j|\}}|djd|djd} | dkrj||}}t | } t |||||| SdS)z;See docstring of :func:`rsolve_hypergeometric` for details.r(rN) r r2r]listrfr mapr7argsabsr) r<r=rirUr>rBZgsrqrrrlrIrIrJ_solve_hyper_RE"s   rc Csddlm}x*t|D]}||\}}|jrdSqWt|||} i} xDttt| D].} | rn| |}| |d| || || <q\W|| ||| } | r| t |t jt jfSdS)z%Solves DE with constant coefficients.r)rsolveN) sympy.solversrr r2r5 free_symbolsrkr-r]r.r9r:rr r0) r<r=rWrUr>rrCr7rOriinitr@rdrIrIrJ_solve_explike_DE0s    rc Csddlm}t|||}i}xLttt|D]6}|rB||}||dt |||| ||<q0W|||||} | r| t j t j fSdS)z4Converts DE into RE and solves using :func:`rsolve`.r)rN) rrrpr-r]r r2r.r9rr:r r0) r<r=rWrUr>rrirr@rdrIrIrJ _solve_simpleGs   (rcCsddlm}g}|t||||}xVt|D]J}|t||||} | ||} xt| D]} | | qhWq0Wg} x2|D]&} | |rPq| t r| | qW| }|rt t |dd||t|D} | r|| }|tdd}|t||}|S)zDConverts DE with free parameters into DE with constant coefficients.r)rRcss|]}|D] }|Vq qdS)NrI)rSrYr@rIrIrJrZmsz(_transform_explike_DE..r()r[rRr7r r-r\rbr r2r;r1rr^r_rr:r`ra)rWrUr=r?symsrRrVZ highest_coeffr@r7rCtemperdrIrIrJ_transform_explike_DEYs,    " rc Csddlm}t|||}g}x.td|D] }||||} || q(Wtt|dd||t|D} | rt d} | | }| d ||| }||dd}x8t|D],}||||r|r| |||}PqW|S)z@Converts DE with free parameters into RE of hypergeometric type.r)rRr(css|]}|D] }|Vq qdS)NrI)rSrYr@rIrIrJrZsz#_transform_DE_RE..rl)r[rRrpr-r7r;r^r_rrr:r`r3rbra) rWrUr>r?rrRrirVr@r7rdrlrIrIrJ_transform_DE_REus"  " rc Csd}|j||h}|r*t|||||}n t|||}|j|hsTt|||||}|r\|S|rpt|||||}|j|hst|||||}|r|SdS)aSolves the DE. Tries to solve DE by either converting into a RE containing two terms or converting into a DE having constant coefficients. Returns ======= formula : Expr ind : Expr Independent terms. order : int Examples ======== >>> from sympy import Derivative as D, Function >>> from sympy import exp, ln >>> from sympy.series.formal import solve_de >>> from sympy.abc import x, k >>> f = Function('f') >>> solve_de(exp(x), x, D(f(x), x) - f(x), 1, f, k) (Piecewise((1/factorial(k), Eq(Mod(k, 1), 0)), (0, True)), 1, 1) >>> solve_de(ln(1 + x), x, (x + 1)*D(f(x), x, 2) + D(f(x)), 2, f, k) (Piecewise(((-1)**(k - 1)*factorial(k - 1)/RisingFactorial(2, k - 1), Eq(Mod(k, 1), 0)), (0, True)), x, 2) N)r differencerrprrr) r<r=rWr?rUr>rdrrirIrIrJsolve_des rc Cstd}g}d}xTt||||D]B\}}|dk rBt||||||}|rJ|S|j|hs ||q Wx$|D]}t|||||}|rl|SqlWdS)aHypergeometric algorithm for computing Formal Power Series. Steps: * Generates DE * Convert the DE into RE * Solves the RE Examples ======== >>> from sympy import exp, ln >>> from sympy.series.formal import hyper_algorithm >>> from sympy.abc import x, k >>> hyper_algorithm(exp(x), x, k) (Piecewise((1/factorial(k), Eq(Mod(k, 1), 0)), (0, True)), 1, 1) >>> hyper_algorithm(ln(1 + x), x, k) (Piecewise(((-1)**(k - 1)*factorial(k - 1)/RisingFactorial(2, k - 1), Eq(Mod(k, 1), 0)), (0, True)), x, 2) See Also ======== sympy.series.formal.simpleDE sympy.series.formal.solve_de rUN)r rerrrr;r) r<r=r>r?rUZdesrdrWr@rIrIrJhyper_algorithms rc Cs|tjtj gkr|tjkr"tjntj }||d|}t||d|||||} | dkr\dS| d| d|d|| d|d|fS|s|tj kr0|tj kr| |} | } |} n||} |} | } ||| }t||dtj||||} | dkrdS| d| d|| | | d|| | fS||r@dSt|tr\d} ttj dt f} tj d}}xt |D]}t||dtj||||}|r:| sd} |d}|dj | j kr| }| j |dj }}n|d}|dj | j }}tddt |d|||||D}| |d7} ||d|7}n||7}qxW| rX| ||fSdSd} td }|r~t|||||} | dkr|rt||||} | dkrdSt| d|| dt f} t|||dt f}| d}| ||fS) zPRecursive wrapper to compute fps. See :func:`compute_fps` for details. r(rNrFTcSsg|]}|d|dqS)rr(rI)rSzrIrIrJrT$sz _compute_fps..r>)r InfinityOner: _compute_fpsZ is_polynomialr4r r r0rr2startr_rrKr)r<r=x0dirhyperr?rationalr)rrZrepZrep2Zrep2brHrDxkrCrxseqrYsaver>rIrIrJrsr.       ,   rr(Tc Cst|}t|}||sdSt|}|dkr6tj}n6|dkrHtj }n$|tjtj gkrdtdnt|}t||||||||S)aComputes the formula for Formal Power Series of a function. Tries to compute the formula by applying the following techniques (in order): * rational_algorithm * Hypergeomitric algorithm Parameters ========== x : Symbol x0 : number, optional Point to perform series expansion about. Default is 0. dir : {1, -1, '+', '-'}, optional If dir is 1 or '+' the series is calculated from the right and for -1 or '-' the series is calculated from the left. For smooth functions this flag will not alter the results. Default is 1. hyper : {True, False}, optional Set hyper to False to skip the hypergeometric algorithm. By default it is set to False. order : int, optional Order of the derivative of ``f``, Default is 4. rational : {True, False}, optional Set rational to False to skip rational algorithm. By default it is set to True. full : {True, False}, optional Set full to True to increase the range of rational algorithm. See :func:`rational_algorithm` for details. By default it is set to False. Returns ======= ak : sequence Sequence of coefficients. xk : sequence Sequence of powers of x. ind : Expr Independent terms. mul : Pow Common terms. See Also ======== sympy.series.formal.rational_algorithm sympy.series.formal.hyper_algorithm N+-zDir must be '+' or '-')rr1r r ValueErrorr)r<r=rrrr?rr)rIrIrJ compute_fpsAs3   rc@s&eZdZdZddZeddZeddZedd Zed d Z ed d Z eddZ eddZ eddZ eddZeddZeddZeddZddZdd,d-Zd.d/Zd0d1Zd2d3Zd4d5Zd6d7Zd8d9Zd:d;Z d+S)?FormalPowerSeriesaRepresents Formal Power Series of a function. No computation is performed. This class should only to be used to represent a series. No checks are performed. For computing a series use :func:`fps`. See Also ======== sympy.series.formal.fps cGstt|}tj|f|S)N)rrr__new__)clsrrIrIrJrs zFormalPowerSeries.__new__cCs |jdS)Nr)r)selfrIrIrJfunctionszFormalPowerSeries.functioncCs |jdS)Nr()r)rrIrIrJr=szFormalPowerSeries.xcCs |jdS)Nr)r)rrIrIrJrszFormalPowerSeries.x0cCs |jdS)N)r)rrIrIrJrszFormalPowerSeries.dircCs|jddS)Nr$r)r)rrIrIrJrHszFormalPowerSeries.akcCs|jddS)Nr$r()r)rrIrIrJrszFormalPowerSeries.xkcCs|jddS)Nr$r)r)rrIrIrJrDszFormalPowerSeries.indcCs tdtS)Nr)rr)rrIrIrJintervalszFormalPowerSeries.intervalcCs|jjS)N)rinf)rrIrIrJrszFormalPowerSeries.startcCs|jjS)N)rZsup)rrIrIrJstopszFormalPowerSeries.stopcCstS)N)r)rrIrIrJlengthszFormalPowerSeries.lengthcCsJddlm}|j|j}}|jd}||j|j||j|jf}|j|S)z0Returns an infinite representation of the seriesr)Sum) Zsympy.concreterrHr variablesformularrrD)rrrHrr>Zinf_sumrIrIrJinfinites   zFormalPowerSeries.infinitecCs.||jd\}}||js*tjS|S)z!Returns the power of x in a term.r()r5r=r6r1r r0)rrNrGrrIrIrJ _get_pow_xs zFormalPowerSeries._get_pow_xcCsfg}xXt|D]L\}}||}||kr,Pq|jdkrF||dkrFPq|tjk r||qWt|S)zTruncated series as polynomial. Returns series sexpansion of ``f`` upto order ``O(x**n)`` as a polynomial(without ``O`` term). Tr()rLrrr r0r;r )rrMrBr@rCZxprIrIrJ polynomials  zFormalPowerSeries.polynomialcCsR|dkrt|S|j|j}}|j|}|tjkr:tj}||t |||fS)zTruncated series. Returns truncated series expansion of f upto order ``O(x**n)``. If n is ``None``, returns an infinite iterator. N) iterr=rrr7r ZNegativeInfinityrrr")rrMr=rpt_xkrIrIrJtruncates  zFormalPowerSeries.truncatecCsy |j|}|j|}Wntk r:tj}Yn X||}|jrtj}xTt |jD]D}| |}|dkr|dkr||7}q^||kr^||dkr^||7}q^W||7}| |j S)Nrr() rr7rHZsimplify IndexErrorr r0rDr r2rrbr=)rZptrZpt_akrNrDrCrrIrIrJ _eval_terms      zFormalPowerSeries._eval_termcCs|j}||r|SdS)N)r=r1)roldnewr=rIrIrJ _eval_subss zFormalPowerSeries._eval_subscCs x|D]}|tjk r|SqWdS)N)r r0)rr=rCrIrIrJ_eval_as_leading_terms  z'FormalPowerSeries._eval_as_leading_termc Cs|j|}|j|}||jj}|j}|jd}|j|rg}xV|jj D]J\}} t j } x,t |D]} || } | | || 7} qjW|| | fqPWt|}t|||d||jd|jf}n*t|j|||d||jd|jf}|||j|j|j||j|fS)Nrr()rr.rDrrrrHrr1rr r0r r2r;rr r:rrfuncr=rr) rr=r<rDpow_xkrHr>formrrmrrCrrIrIrJ_eval_derivatives$     &z"FormalPowerSeries._eval_derivativeNc Ksdddlm}|dkr|j}nt|r0||j|S||j|}||j|}||||d7}||jj }|j }|j d}|j |rg} xZ|j j D]N\} } tj} x0t| D]"} || }| | ||d7} qW| | | fqWt| } t| ||d||jd|jf}n.t|j |d||d||jd|jf}|||j|j|j||j|fS)aCIntegrate Formal Power Series. Examples ======== >>> from sympy import fps, sin, integrate >>> from sympy.abc import x >>> f = fps(sin(x)) >>> f.integrate(x).truncate() -1 + x**2/2 - x**4/24 + O(x**6) >>> integrate(f, (x, 0, 1)) -cos(1) + 1 r)r'Nr()r,r'r=rrrDr9rrrrHrr1rr r0r r2r;rr r:rrrrr)rr=kwargsr'r<rDrrHr>rrrmrrCrrIrIrJr'0s0      &zFormalPowerSeries.integratec Csht|}t|tr|j|jkr*tdn|j|jkr>td|j|j}}|j|j||}|j|j krp|S|j |j }|j j |j j kr|j }|j j |j j }}n|j }|j j |j j }}t ddt |d|||j||D} |j|j| } ||||j|j||j| fS||js^|j|}|j|} |||j|j|j|j |j| fSt ||S)Nz9Both series should be calculated from the same direction.z6Both series should be calculated about the same point.cSsg|]}|d|dqS)rr(rI)rSrrIrIrJrTtsz-FormalPowerSeries.__add__..r)rr4rrrrr=rr:rrHrr r_rrDrr1) rotherr=yr<rHrrYrrrDrIrIrJ__add__\s2      .  zFormalPowerSeries.__add__cCs ||S)N)r)rrrIrIrJ__radd__szFormalPowerSeries.__radd__c Cs,||j |j|j|j|j |j|j fS)N)rrr=rrrHrrD)rrIrIrJ__neg__szFormalPowerSeries.__neg__cCs || S)N)r)rrrIrIrJ__sub__szFormalPowerSeries.__sub__cCs | |S)N)r)rrrIrIrJ__rsub__szFormalPowerSeries.__rsub__c Cs^t|}||jrt||S|j|}|j|}|j|}|||j|j |j ||j |fS)N) rr1r=r rrHZ coeff_mulrDrrrr)rrr<rHrDrIrIrJ__mul__s     zFormalPowerSeries.__mul__cCs ||S)N)r)rrrIrIrJ__rmul__szFormalPowerSeries.__rmul__)r)r)N)!__name__ __module__ __qualname____doc__rpropertyrr=rrrHrrDrrrrrrrrrrrrr'rrrrrrrrIrIrIrJrs:                ,& rNc Csnt|}|dkr<|j}t|dkr,|}n|s4|Stdt||||||||} | dkr^|St||||| S)aCGenerates Formal Power Series of f. Returns the formal series expansion of ``f`` around ``x = x0`` with respect to ``x`` in the form of a ``FormalPowerSeries`` object. Formal Power Series is represented using an explicit formula computed using different algorithms. See :func:`compute_fps` for the more details regarding the computation of formula. Parameters ========== x : Symbol, optional If x is None and ``f`` is univariate, the univariate symbols will be supplied, otherwise an error will be raised. x0 : number, optional Point to perform series expansion about. Default is 0. dir : {1, -1, '+', '-'}, optional If dir is 1 or '+' the series is calculated from the right and for -1 or '-' the series is calculated from the left. For smooth functions this flag will not alter the results. Default is 1. hyper : {True, False}, optional Set hyper to False to skip the hypergeometric algorithm. By default it is set to False. order : int, optional Order of the derivative of ``f``, Default is 4. rational : {True, False}, optional Set rational to False to skip rational algorithm. By default it is set to True. full : {True, False}, optional Set full to True to increase the range of rational algorithm. See :func:`rational_algorithm` for details. By default it is set to False. Examples ======== >>> from sympy import fps, O, ln, atan >>> from sympy.abc import x Rational Functions >>> fps(ln(1 + x)).truncate() x - x**2/2 + x**3/3 - x**4/4 + x**5/5 + O(x**6) >>> fps(atan(x), full=True).truncate() x - x**3/3 + x**5/5 + O(x**6) See Also ======== sympy.series.formal.FormalPowerSeries sympy.series.formal.compute_fps Nr(z multivariate formal power series)rrr]r8NotImplementedErrorrr) r<r=rrrr?rr)ZfreerrIrIrJfpss9  r)r$F)r$)r$)rr(Tr$TF)Nrr(Tr$TF)RrZ __future__rr collectionsrZsympyrrrZsympy.core.exprrZsympy.core.addr Zsympy.core.mulr Zsympy.core.functionr r Zsympy.core.singletonr Zsympy.core.sympifyrZsympy.core.symbolrrrrZsympy.core.relationalrZsympy.core.numbersrZsympy.core.compatibilityrZsympy.sets.setsrZ(sympy.functions.combinatorial.factorialsrrrZ$sympy.functions.elementary.piecewiserZ#sympy.functions.elementary.integersrrrZ(sympy.functions.elementary.miscellaneousrrZsympy.series.sequencesr Zsympy.series.series_classr!Zsympy.series.orderr"Zsympy.series.limitsr#rKrQrerkrprtrvrwrzr{r}rrrrrrrrrrrrrrrIrIrIrJsd                |! +/4CW4 1P F