
    \h%                     <    S r SSKJr  SSKJr  SSKJr  S rSS jrg)	aB  
Convergence acceleration / extrapolation methods for series and
sequences.

References:
Carl M. Bender & Steven A. Orszag, "Advanced Mathematical Methods for
Scientists and Engineers: Asymptotic Methods and Perturbation Theory",
Springer 1999. (Shanks transformation: pp. 368-375, Richardson
extrapolation: pp. 375-377.)
    )Integer)S)	factorialc           	         [         R                  n[        SUS-   5       Hh  nX@R                  U[	        X%-   5      5      R                  5       X%-   U-  -  [         R                  XS-   -  -  [        U5      [        X5-
  5      -  -  -  nMj     U$ )a7  
Calculate an approximation for lim k->oo A(k) using Richardson
extrapolation with the terms A(n), A(n+1), ..., A(n+N+1).
Choosing N ~= 2*n often gives good results.

Examples
========

A simple example is to calculate exp(1) using the limit definition.
This limit converges slowly; n = 100 only produces two accurate
digits:

    >>> from sympy.abc import n
    >>> e = (1 + 1/n)**n
    >>> print(round(e.subs(n, 100).evalf(), 10))
    2.7048138294

Richardson extrapolation with 11 appropriately chosen terms gives
a value that is accurate to the indicated precision:

    >>> from sympy import E
    >>> from sympy.series.acceleration import richardson
    >>> print(round(richardson(e, n, 10, 20).evalf(), 10))
    2.7182818285
    >>> print(round(E.evalf(), 10))
    2.7182818285

Another useful application is to speed up convergence of series.
Computing 100 terms of the zeta(2) series 1/k**2 yields only
two accurate digits:

    >>> from sympy.abc import k, n
    >>> from sympy import Sum
    >>> A = Sum(k**-2, (k, 1, n))
    >>> print(round(A.subs(n, 100).evalf(), 10))
    1.6349839002

Richardson extrapolation performs much better:

    >>> from sympy import pi
    >>> print(round(richardson(A, n, 10, 20).evalf(), 10))
    1.6449340668
    >>> print(round(((pi**2)/6).evalf(), 10))     # Exact value
    1.6449340668

r      )r   Zerorangesubsr   doitNegativeOner   )AknNsjs         Q/var/www/auris/envauris/lib/python3.13/site-packages/sympy/series/acceleration.py
richardsonr      s    ^ 	
A1a!e_	ffQ',,.!%!;mmae$%(1!y7G(GI 	J  H    c           	         [        X#-   S-   5       Vs/ s H+  o@R                  U[        U5      5      R                  5       PM-     nnUR	                  5       n[        SUS-   5       HS  n[        XrU-   S-   5       H+  nXTS-
     XT   XTS-      pnX-  U	S-  -
  X-   SU	-  -
  -  Xd'   M-     UR	                  5       nMU     XR   $ s  snf )a  
Calculate an approximation for lim k->oo A(k) using the n-term Shanks
transformation S(A)(n). With m > 1, calculate the m-fold recursive
Shanks transformation S(S(...S(A)...))(n).

The Shanks transformation is useful for summing Taylor series that
converge slowly near a pole or singularity, e.g. for log(2):

    >>> from sympy.abc import k, n
    >>> from sympy import Sum, Integer
    >>> from sympy.series.acceleration import shanks
    >>> A = Sum(Integer(-1)**(k+1) / k, (k, 1, n))
    >>> print(round(A.subs(n, 100).doit().evalf(), 10))
    0.6881721793
    >>> print(round(shanks(A, n, 25).evalf(), 10))
    0.6931396564
    >>> print(round(shanks(A, n, 25, 5).evalf(), 10))
    0.6931471806

The correct value is 0.6931471805599453094172321215.
   r   )r	   r
   r   r   copy)r   r   r   mr   tabletable2ixyzs              r   shanksr    G   s    , 493CD3CaVVAwqz"'')3CEDZZ\F1a!e_qa%!)$AElEHeEl!Aq!t!4FI % 	 
 8O Es   2CN)r   )	__doc__sympy.core.numbersr   sympy.core.singletonr   (sympy.functions.combinatorial.factorialsr   r   r     r   r   <module>r&      s    	 ' " >3lr   