def inverse_pade(f, x0, m, n): """ Padé approximant coefficients of the inverse of f. Given a callable f, and a point x0, find the Padé approximant of degree (m, n) of the inverse of f at x0. If y0 = f(x0), and if the inverse of f is g, this function returns the Padé approximant coefficients of g(y) at y0. f'(x0) must be nonzero. Examples -------- >>> import mpmath >>> mpmath.mp.dps = 40 Compute the Padé approximant to the inverse of sin(x) at x=1. >>> inverse_pade(mpmath.sin, 1, 5, 4) ([mpf('1.0'), mpf('-5.428836087225345782152614868037223199487785'), mpf('-14.59025586448337482707922792297134121701713'), mpf('76.66727054306441691994858675947043862200347'), mpf('20.92630843471146736348587129663693571301545'), mpf('-91.95538065543221755259217919809770565490541')], [mpf('1.0'), mpf('-7.279651804906271400064368109435873392958164'), mpf('-3.784426620962357975179374311522526358975659'), mpf('94.34419434777145262733458338059694153109452'), mpf('-114.4848137234397209897780633142520390436954')]) Compare that to computing the Padé approximant of the arcsine function directly. >>> c = mpmath.taylor(mpmath.asin, mpmath.sin(1), 10) >>> mpmath.pade(c, 5, 4) ([mpf('1.0'), mpf('-5.428836087225345782152614868037223199022362'), mpf('-14.59025586448337482707922792297134122127003'), mpf('76.66727054306441691994858675947043863057723'), mpf('20.92630843471146736348587129663693571903839'), mpf('-91.95538065543221755259217919809770566742443')], [mpf('1.0'), mpf('-7.279651804906271400064368109435873392492793'), mpf('-3.784426620962357975179374311522526364090111'), mpf('94.34419434777145262733458338059694154789217'), mpf('-114.4848137234397209897780633142520390591904')]) """ d = m + n + 1 c = inverse_taylor(f, x0, d) pc, qc = mpmath.pade(c, m, n) return pc, qc
def pade(t, n): """ pade approximation of a time delay, as per mathworks' controls toolkit. supports arbitrary precision mathematics via mpmath and sympy" for more information, see: * http://home.hit.no/~hansha/documents/control/theory/pade_approximation.pdf * http://www.mathworks.com/help/control/ref/pade.html """ # e**(s*t) -> laplace transform of a time delay with 't' duration # e**x -> taylor series taylor = mpmath.taylor(sympy.exp, 0, n * 2) (num, den) = mpmath.pade(taylor, n, n) num = sum([x * (-t * s)**y for y, x in enumerate(num[::-1])]) den = sum([x * (-t * s)**y for y, x in enumerate(den[::-1])]) return num / den
def pade_coefs(*, pade_order, k0, dx, alpha=0): mpmath.mp.dps = 63 if alpha == 0: def sqrt_1plus(x): return mpmath.mp.sqrt(1 + x) else: a_n, b_n = pade_sqrt_coefs(pade_order[1]) def sqrt_1plus(x): return pade_sqrt(x, a_n, b_n, alpha) def propagator_func(s): return mpmath.mp.exp(1j * k0 * dx * (sqrt_1plus(s) - 1)) t = mpmath.taylor(propagator_func, 0, pade_order[0] + pade_order[1] + 20) p, q = mpmath.pade(t, pade_order[0], pade_order[1]) num_coefs = np.array([complex(v) for v in p]) den_coefs = np.array([complex(v) for v in q]) return num_coefs[::-1], den_coefs[::-1]
def __init__(self, n): self.n = n mpmath.mp.dps = 100 def func(x): return mpmath.exp(-x) * mpmath.besseli(0, x) t = mpmath.taylor(func, 0, 2 * n + 1) self.p, self.q = mpmath.pade(t, n, n) # self.pade_coefs = list(zip_longest([-1 / complex(v) for v in mpmath.polyroots(p[::-1], maxsteps=2000)], # [-1 / complex(v) for v in mpmath.polyroots(q[::-1], maxsteps=2000)], # fillvalue=0.0j)) #self.pade_roots_num = [complex(v) for v in mpmath.polyroots(self.p[::-1], maxsteps=5000)] #self.pade_roots_den = [complex(v) for v in mpmath.polyroots(self.q[::-1], maxsteps=5000)] self.pade_coefs_num = [complex(v) for v in self.p] self.pade_coefs_den = [complex(v) for v in self.q] self.taylor_coefs = [complex(v) for v in t] a = [self.q[-1]] + [b + c for b, c in zip(self.q[:-1:], self.p)] self.a_roots = [ complex(v) for v in mpmath.polyroots(a[::-1], maxsteps=5000) ]
def pade_propagator_coefs(*, pade_order, diff2, k0, dx, spe=False, alpha=0): """ :param pade_order: order of Pade approximation, tuple, for ex (7, 8) :param diff2: :param k0: :param dx: :param spe: :param alpha: rotation angle, see F. A. Milinazzo et. al. Rational square-root approximations for parabolic equation algorithms. 1997. Acoustical Society of America. :return: """ mpmath.mp.dps = 63 if spe: def sqrt_1plus(x): return 1 + x / 2 elif alpha == 0: def sqrt_1plus(x): return mpmath.mp.sqrt(1 + x) else: a_n, b_n = pade_sqrt_coefs(pade_order[1]) def sqrt_1plus(x): return pade_sqrt(x, a_n, b_n, alpha) def propagator_func(s): return mpmath.mp.exp(1j * k0 * dx * (sqrt_1plus(diff2(s)) - 1)) t = mpmath.taylor(propagator_func, 0, pade_order[0] + pade_order[1] + 2) p, q = mpmath.pade(t, pade_order[0], pade_order[1]) pade_coefs = list( zip_longest([ -1 / complex(v) for v in mpmath.polyroots(p[::-1], maxsteps=2000) ], [-1 / complex(v) for v in mpmath.polyroots(q[::-1], maxsteps=2000)], fillvalue=0.0j)) return pade_coefs
def lambertw_pade(): derivs = [mpmath.diff(mpmath.lambertw, 0, n=n) for n in range(6)] p, q = mpmath.pade(derivs, 3, 2) return p, q
def lambertw_pade(): derivs = [] for n in range(6): derivs.append(mpmath.diff(mpmath.lambertw, 0, n=n)) p, q = mpmath.pade(derivs, 3, 2) return p, q
def lambertw_pade(): derivs = [] for n in range(6): derivs.append(mpmath.diff(mpmath.lambertw, 0, n=n)) p, q = mpmath.pade(derivs, 3, 2) return p, q
def lambertw_pade(): derivs = [mpmath.diff(mpmath.lambertw, 0, n=n) for n in range(6)] p, q = mpmath.pade(derivs, 3, 2) return p, q
import mpmath def f(x): return (mpmath.pi + x + mpmath.sin(x)) / (2*mpmath.pi) # Note: 40 digits might be overkill; a few more digits than the default # might be sufficient. mpmath.mp.dps = 40 ts = mpmath.taylor(f, -mpmath.pi, 20) p, q = mpmath.pade(ts, 9, 10) p = [float(c) for c in p] q = [float(c) for c in q] print('p =', p) print('q =', q)