[h،"SS\5r"SS\5r"SS\5r"SS\5r"SS \5r"S S \5r\S :XaS SKr\R"5 gg)c*\rSrSrSrSrSrSrSrg)InverseLaplaceTransforma Inverse Laplace transform methods are implemented using this class, in order to simplify the code and provide a common infrastructure. Implement a custom inverse Laplace transform algorithm by subclassing :class:`InverseLaplaceTransform` and implementing the appropriate methods. The subclass can then be used by :func:`~mpmath.invertlaplace` by passing it as the *method* argument. cXlgNctx)selfrs V/var/www/auris/envauris/lib/python3.13/site-packages/mpmath/calculus/inverselaplace.py__init__ InverseLaplaceTransform.__init__sc [e)z Determine the vector of Laplace parameter values needed for an algorithm, this will depend on the choice of algorithm (de Hoog is default), the algorithm-specific parameters passed (or default ones), and desired time. NotImplementedError)r tkwargss r calc_laplace_parameter.InverseLaplaceTransform.calc_laplace_parameter "!r c[e)z Compute the time domain solution, after computing the Laplace-space function evaluations at the abscissa required for the algorithm. Abscissa computed for one algorithm are typically not useful for another algorithm. r)r fps r calc_time_domain_solution1InverseLaplaceTransform.calc_time_domain_solutionrr rN) __name__ __module__ __qualname____firstlineno____doc__r rr__static_attributes__r r rrs ""r rc$\rSrSrSrSSjrSrg) FixedTalbot'c PURRU5UlURRURSUR55UlSU;aUSUlUR UlON[SURR-5Ul[S[SUR -55UlUR nURRUl UR URlURSURRSS5U-5Ul URRS URRUS -5UlURR!US 5UlS UR"S 'URR!US 5UlURUR$S '['S U5HtnURR)URU5UR"U'URURU-UR"US --UR$U'Mv URR!US 5UlUR$UR- Ulg )aThe "fixed" Talbot method deforms the Bromwich contour towards `-\infty` in the shape of a parabola. Traditionally the Talbot algorithm has adjustable parameters, but the "fixed" version does not. The `r` parameter could be passed in as a parameter, if you want to override the default given by (Abate & Valko, 2004). The Laplace parameter is sampled along a parabola opening along the negative imaginary axis, with the base of the parabola along the real axis at `p=\frac{r}{t_\mathrm{max}}`. As the number of terms used in the approximation (degree) grows, the abscissa required for function evaluation tend towards `-\infty`, requiring high precision to prevent overflow. If any poles, branch cuts or other singularities exist such that the deformed Bromwich contour lies to the left of the singularity, the method will fail. **Optional arguments** :class:`~mpmath.calculus.inverselaplace.FixedTalbot.calc_laplace_parameter` recognizes the following keywords *tmax* maximum time associated with vector of times (typically just the time requested) *degree* integer order of approximation (M = number of terms) *r* abscissa for `p_0` (otherwise computed using rule of thumb `2M/5`) The working precision will be increased according to a rule of thumb. If 'degree' is not specified, the working precision and degree are chosen to hopefully achieve the dps of the calling context. If 'degree' is specified, the working precision is chosen to achieve maximum resulting precision for the specified degree. .. math :: p_0=\frac{r}{t} .. math :: p_i=\frac{i r \pi}{Mt_\mathrm{max}}\left[\cot\left( \frac{i\pi}{M}\right) + j \right] \qquad 1\le i >!$$%&CF ""1a(s);;DFFB==DHHL{{r ) r;r&r<r1r5r?r)rr9r%NFrrrrrrrr r r r"r"'se&REr r"c*\rSrSrSrSrSSjrSrg)Stehfestc URRU5UlSU;a(USUl[ SUR-5UlOB[ SURR -5Ul[SUR 5UlURS-S:aU=RS- slURnURR UlUR URlUR5Ul URRURRSUS-55URR-UR- Ulg) a The Gaver-Stehfest method is a discrete approximation of the Widder-Post inversion algorithm, rather than a direct approximation of the Bromwich contour integral. The method abscissa along the real axis, and therefore has issues inverting oscillatory functions (which have poles in pairs away from the real axis). The working precision will be increased according to a rule of thumb. If 'degree' is not specified, the working precision and degree are chosen to hopefully achieve the dps of the calling context. If 'degree' is specified, the working precision is chosen to achieve maximum resulting precision for the specified degree. .. math :: p_k = \frac{k \log 2}{t} \qquad 1 \le k \le M r&r(gq= ףp@r*r-r,N)rr/rr&r2r1r3r4r5_coeffVr:arangeln2r?)r rrr@s r rStehfest.calc_laplace_parameters2!!!$ v  *DKT[[ 01DMTXX\\ 12DMb$--0DK ;;?Q  KK1 K KK   }} AaC!89$((,,FtvvMr cvURn[US- 5nURRUS5n[ SUS-5GHnnURR[ XB5S-S5n[ [US-S- 5[ XB5S-5HnURR Xb5URRSU-5-URRX&- 5URRU5-URRUS- 5-URRXF- 5-URRSU-U- 5-- XV'M URR SXB-5URRU5-X4S- 'GMq U$)ztSalzer summation weights (aka, "Stehfest coefficients") only depend on the approximation order (M) and the precisionr*r,) r&r2rr:r=minpowerfacrE)r r@M2rSkzjs r rRStehfest._coeffs[ KK 1X HHOOAq ! q!A#AA 1 a0A3!Qw<QA6q-dhhll1Q3.??bd+DHHLLO;ac*++/88<<+<=ac!e,-.7 XX^^B-dhhmmA.>>AcFr c2URRU5UlURRURU5URR -UR- nU(dUR URlUR$)asCompute time-domain Stehfest algorithm solution. .. math :: f(t,M) = \frac{\log 2}{t} \sum_{k=1}^{M} V_k \bar{f}\left( p_k \right) where .. math :: V_k = (-1)^{k + N/2} \sum^{\min(k,N/2)}_{i=\lfloor(k+1)/2 \rfloor} \frac{i^{\frac{N}{2}}(2i)!}{\left(\frac{N}{2}-i \right)! \, i! \, \left(i-1 \right)! \, \left(k-i\right)! \, \left(2i-k \right)!} As the degree increases, the abscissa (`p_k`) only increase linearly towards `\infty`, but the Stehfest coefficients (`V_k`) alternate in sign and increase rapidly in sign, requiring high precision to prevent overflow or loss of significance when evaluating the sum. **References** 1. Widder, D. (1941). *The Laplace Transform*. Princeton. 2. Stehfest, H. (1970). Algorithm 368: numerical inversion of Laplace transforms. *Communications of the ACM* 13(1):47-49, http://dx.doi.org/10.1145/361953.361969 ) rr/rfdotrSrUr5r3rF)r rrrGrIs r r"Stehfest.calc_time_domain_solution0sk@!!!$ tvvr*488<<7>==DHHL{{r )rSr&r1r5r?rNrK)rrrrrrRrrr r r rNrNs6Nt0-r rNc$\rSrSrSrSSjrSrg)deHoogibc URRU5UlURSUR5UlSU;a(USUl[ SUR -5UlOB[ URRS-5Ul[SUR5UlUR nURRSUR*5nURRURSU55Ul URRURSURS-55Ul S UR -S -Ul URRUlURURlURS S 5UlURRURS URUR-55UlURR#S U-S -S 5UlURURR'UR5URUR -- - UlUR(URR*URR#URR-UR55-UR - S --Ulg)athe de Hoog, Knight & Stokes algorithm is an accelerated form of the Fourier series numerical inverse Laplace transform algorithms. .. math :: p_k = \gamma + \frac{jk}{T} \qquad 0 \le k < 2M+1 where .. math :: \gamma = \alpha - \frac{\log \mathrm{tol}}{2T}, `j=\sqrt{-1}`, `T = 2t_\mathrm{max}` is a scaled time, `\alpha=10^{-\mathrm{dps\_goal}}` is the real part of the rightmost pole or singularity, which is chosen based on the desired accuracy (assuming the rightmost singularity is 0), and `\mathrm{tol}=10\alpha` is the desired tolerance, which is chosen in relation to `\alpha`.` When increasing the degree, the abscissa increase towards `j\infty`, but more slowly than the fixed Talbot algorithm. The de Hoog et al. algorithm typically does better with oscillatory functions of time, and less well-behaved functions. The method tends to be slower than the Talbot and Stehfest algorithsm, especially so at very high precision (e.g., `>500` digits precision). r%r&r(g(\? g$@alphatolr*r,scaleTr.N)rr/rr0r%r&r2r1r3r4rZrhrinpr5rjrkr:r?loggammar8rT)r rrr@tmps r rdeHoog.calc_laplace_parameterdsD!!!$JJvtvv. v  *DKT[[ 01DM T 12DMb$--0DK KKhhnnTDMM>2XX%%fjj#&>? 88##FJJudjjo$FGDKK-/   }} ZZ+ !!&**S$**TYY2F"GH1Q*ZZ$((,,txx"8$**TVV:K"LL **txx{{((//$((//$''":; <<@FF CCE FFr cURnURnURnURR U5UlURR XTS-5nURRSU-U5nURRUS5n URR US-S5n URRUS-S5n SUSS2S4'USUSS- - US'[SSU-5Hn XS-X- XS4'M [SUS-5Hn SXM- -S-nUSUS-2U S- 4USU2U S- 4- USUS-2U S- 4-USU2U 4'X:XaMGU S-nSXO- -S-S-n[U5H-n XS-US- 4X|S-US- 4-X|US- 4- XUS- 4'M/ M USS- U S'[SUS-5H%n USU S- 4*U SU -S- 'USU 4*U SU -'M' SU S'U SU S'SU SS&URRUR U- 5n[SSU-5H5n XXXS- -U--XS-'XXXS- -U--XS-'M7 SU SU-S- U SU-- U--S- nUURRSU SU-U-U- -URRSS55-nU SU-UU SU-S- --X'U SU-UU SU-S- --X'URRURUR -5U- XX- R-nU(dUR URlU$)aCalculate time-domain solution for de Hoog, Knight & Stokes algorithm. The un-accelerated Fourier series approach is: .. math :: f(t,2M+1) = \frac{e^{\gamma t}}{T} \sum_{k=0}^{2M}{}^{'} \Re\left[\bar{f}\left( p_k \right) e^{i\pi t/T} \right], where the prime on the summation indicates the first term is halved. This simplistic approach requires so many function evaluations that it is not practical. Non-linear acceleration is accomplished via Pade-approximation and an analytic expression for the remainder of the continued fraction. See the original paper (reference 2 below) a detailed description of the numerical approach. **References** 1. Davies, B. (2005). *Integral Transforms and their Applications*, Third Edition. Springer. 2. de Hoog, F., J. Knight, A. Stokes (1982). An improved method for numerical inversion of Laplace transforms. *SIAM Journal of Scientific and Statistical Computing* 3:357-366, http://dx.doi.org/10.1137/0903022 r,r*yNr-)r-r-y?)r&rlrkrr/rzerosr:onesr=expjpipowm1r6rDrnrFr5r3)r rrrGr@rlrkeqdABrAr)mrrqr^bremremrIs r r deHoog.calc_time_domain_solutions@ KK WW FF!!!$ HHNN2s # HHOOAaC # HHOOB " HHNN2a4 # HHMM"Q$ "!Q$Q%Aq/$q!A#A1gbemAdGq!A#AAC1B1RT61Q3;!AbD!A#I,61RT61Q3;GAadAgJ6qSXaZ!^rA!"Q319a!RT l!:11W:!EAAgJ#!uQw!q!A#A!QqS& zAac!eH!Q$xAacF !t!!A HHOODFF1H %q!A#ATADQ3KM)AcFTADQ3KM)AcF Qqs1uX!A#&))1,488>>!a!fQhtm"3"&(("3"3Aq"9;;!A#Qqs1uX%!A#Qqs1uX%djj/02AE!%K3E3EE==DHHL r ) rkrhr&r1r5rnrlr?rjrr%riNrKrLr r r rerebsLG`er rec$\rSrSrSrSSjrSrg)Cohenic 4URRU5UlSU;a(USUl[ SUR-5UlON[ URR S-5Ul[S[ SUR -55UlURS-nURR UlUR URlSUR-nURR URRS5-URRU5-nURRSS 5U-nURRURS U55Ul URU- nURRS -UR- nURRUS5UlX`RS '[!SU5HnXhU--URU'M g )aThe Cohen algorithm accelerates the convergence of the nearly alternating series resulting from the application of the trapezoidal rule to the Bromwich contour inversion integral. .. math :: p_k = \frac{\gamma}{2 t} + \frac{\pi i k}{t} \qquad 0 \le k < M where .. math :: \gamma = \frac{2}{3} (d + \log(10) + \log(2 t)), `d = \mathrm{dps\_goal}`, which is chosen based on the desired accuracy using the method developed in [1] to improve numerical stability. The Cohen algorithm shows robustness similar to the de Hoog et al. algorithm, but it is faster than the fixed Talbot algorithm. **Optional arguments** *degree* integer order of the approximation (M = number of terms) *alpha* abscissa for `p_0` (controls the discretization error) The working precision will be increased according to a rule of thumb. If 'degree' is not specified, the working precision and degree are chosen to hopefully achieve the dps of the calling context. If 'degree' is specified, the working precision is chosen to achieve maximum resulting precision for the specified degree. **References** 1. P. Glasserman, J. Ruiz-Mata (2006). Computing the credit loss distribution in the Gaussian copula model: a comparison of methods. *Journal of Credit Risk* 2(4):33-66, 10.21314/JCR.2006.057 r&g?gףp= ?g(\?r,r*rgrhr.r-N)rr/rr&r2r1r3r4r5rmr6r0rhr8r:r?r=) r rrr@ttworoa_tp_trAs r rCohen.calc_laplace_parameter sR!!!$ v  *DKdkk 12DM t 34DMb#dT]]&:";? jj4hhkkB'A&q q!A#g DFF1Ir cURRU5UlURnUS-nURR US5n[ U5HnXR Xg'M SURRS5-U-nUSU- -S- nURR*n U*n Sn [ U5HDn X- n XXlS---n SX--X- -U -SU -S-XRR--- n MF URRURS- 5UR- USS- X- - -n U(dURURl U $)a%Calculate time-domain solution for Cohen algorithm. The accelerated nearly alternating series is: .. math :: f(t, M) = \frac{e^{\gamma / 2}}{t} \left[\frac{1}{2} \Re\left(\bar{f}\left(\frac{\gamma}{2t}\right) \right) - \sum_{k=0}^{M-1}\frac{c_{M,k}}{d_M}\Re\left(\bar{f} \left(\frac{\gamma + 2(k+1) \pi i}{2t}\right)\right)\right], where coefficients `\frac{c_{M, k}}{d_M}` are described in [1]. 1. H. Cohen, F. Rodriguez Villegas, D. Zagier (2000). Convergence acceleration of alternating series. *Experiment. Math* 9(1):3-12 r,rr*r-) rr/rr&r:r=rFsqrtonerDrhr5r3)r rrrGnr@ryrArxbcsr]rIs r rCohen.calc_time_domain_solutionisR$!!!$ KK E HHOOAq !qA5::ADq! !a ' QY!O XX\\M B qAAa%L AQU qu%)a!eaiA >> from mpmath import * >>> mp.dps = 15; mp.pretty = True >>> tt = [0.001, 0.01, 0.1, 1, 10] >>> fp = lambda p: 1/(p+1)**2 >>> ft = lambda t: t*exp(-t) >>> ft(tt[0]),ft(tt[0])-invertlaplace(fp,tt[0],method='talbot') (0.000999000499833375, 8.57923043561212e-20) >>> ft(tt[1]),ft(tt[1])-invertlaplace(fp,tt[1],method='talbot') (0.00990049833749168, 3.27007646698047e-19) >>> ft(tt[2]),ft(tt[2])-invertlaplace(fp,tt[2],method='talbot') (0.090483741803596, -1.75215800052168e-18) >>> ft(tt[3]),ft(tt[3])-invertlaplace(fp,tt[3],method='talbot') (0.367879441171442, 1.2428864009344e-17) >>> ft(tt[4]),ft(tt[4])-invertlaplace(fp,tt[4],method='talbot') (0.000453999297624849, 4.04513489306658e-20) The methods also work for higher precision: >>> mp.dps = 100; mp.pretty = True >>> nstr(ft(tt[0]),15),nstr(ft(tt[0])-invertlaplace(fp,tt[0],method='talbot'),15) ('0.000999000499833375', '-4.96868310693356e-105') >>> nstr(ft(tt[1]),15),nstr(ft(tt[1])-invertlaplace(fp,tt[1],method='talbot'),15) ('0.00990049833749168', '1.23032291513122e-104') .. math :: \bar{f}(p) = \frac{1}{p^2+1} .. math :: f(t) = \mathrm{J}_0(t) >>> mp.dps = 15; mp.pretty = True >>> fp = lambda p: 1/sqrt(p*p + 1) >>> ft = lambda t: besselj(0,t) >>> ft(tt[0]),ft(tt[0])-invertlaplace(fp,tt[0],method='dehoog') (0.999999750000016, -6.09717765032273e-18) >>> ft(tt[1]),ft(tt[1])-invertlaplace(fp,tt[1],method='dehoog') (0.99997500015625, -5.61756281076169e-17) .. math :: \bar{f}(p) = \frac{\log p}{p} .. math :: f(t) = -\gamma -\log t >>> mp.dps = 15; mp.pretty = True >>> fp = lambda p: log(p)/p >>> ft = lambda t: -euler-log(t) >>> ft(tt[0]),ft(tt[0])-invertlaplace(fp,tt[0],method='stehfest') (6.3305396140806, -1.92126634837863e-16) >>> ft(tt[1]),ft(tt[1])-invertlaplace(fp,tt[1],method='stehfest') (4.02795452108656, -4.81486093200704e-16) **Options** :func:`~mpmath.invertlaplace` recognizes the following optional keywords valid for all methods: *method* Chooses numerical inverse Laplace transform algorithm (described below). *degree* Number of terms used in the approximation **Algorithms** Mpmath implements four numerical inverse Laplace transform algorithms, attributed to: Talbot, Stehfest, and de Hoog, Knight and Stokes. These can be selected by using *method='talbot'*, *method='stehfest'*, *method='dehoog'* or *method='cohen'* or by passing the classes *method=FixedTalbot*, *method=Stehfest*, *method=deHoog*, or *method=Cohen*. The functions :func:`~mpmath.invlaptalbot`, :func:`~mpmath.invlapstehfest`, :func:`~mpmath.invlapdehoog`, and :func:`~mpmath.invlapcohen` are also available as shortcuts. All four algorithms implement a heuristic balance between the requested precision and the precision used internally for the calculations. This has been tuned for a typical exponentially decaying function and precision up to few hundred decimal digits. The Laplace transform converts the variable time (i.e., along a line) into a parameter given by the right half of the complex `p`-plane. Singularities, poles, and branch cuts in the complex `p`-plane contain all the information regarding the time behavior of the corresponding function. Any numerical method must therefore sample `p`-plane "close enough" to the singularities to accurately characterize them, while not getting too close to have catastrophic cancellation, overflow, or underflow issues. Most significantly, if one or more of the singularities in the `p`-plane is not on the left side of the Bromwich contour, its effects will be left out of the computed solution, and the answer will be completely wrong. *Talbot* The fixed Talbot method is high accuracy and fast, but the method can catastrophically fail for certain classes of time-domain behavior, including a Heaviside step function for positive time (e.g., `H(t-2)`), or some oscillatory behaviors. The Talbot method usually has adjustable parameters, but the "fixed" variety implemented here does not. This method deforms the Bromwich integral contour in the shape of a parabola towards `-\infty`, which leads to problems when the solution has a decaying exponential in it (e.g., a Heaviside step function is equivalent to multiplying by a decaying exponential in Laplace space). *Stehfest* The Stehfest algorithm only uses abscissa along the real axis of the complex `p`-plane to estimate the time-domain function. Oscillatory time-domain functions have poles away from the real axis, so this method does not work well with oscillatory functions, especially high-frequency ones. This method also depends on summation of terms in a series that grows very large, and will have catastrophic cancellation during summation if the working precision is too low. *de Hoog et al.* The de Hoog, Knight, and Stokes method is essentially a Fourier-series quadrature-type approximation to the Bromwich contour integral, with non-linear series acceleration and an analytical expression for the remainder term. This method is typically one of the most robust. This method also involves the greatest amount of overhead, so it is typically the slowest of the four methods at high precision. *Cohen* The Cohen method is a trapezoidal rule approximation to the Bromwich contour integral, with linear acceleration for alternating series. This method is as robust as the de Hoog et al method and the fastest of the four methods at high precision, and is therefore the default method. **Singularities** All numerical inverse Laplace transform methods have problems at large time when the Laplace-space function has poles, singularities, or branch cuts to the right of the origin in the complex plane. For simple poles in `\bar{f}(p)` at the `p`-plane origin, the time function is constant in time (e.g., `\mathcal{L}\left\lbrace 1 \right\rbrace=1/p` has a pole at `p=0`). A pole in `\bar{f}(p)` to the left of the origin is a decreasing function of time (e.g., `\mathcal{L}\left\lbrace e^{-t/2} \right\rbrace=1/(p+1/2)` has a pole at `p=-1/2`), and a pole to the right of the origin leads to an increasing function in time (e.g., `\mathcal{L}\left\lbrace t e^{t/4} \right\rbrace = 1/(p-1/4)^2` has a pole at `p=1/4`). When singularities occur off the real `p` axis, the time-domain function is oscillatory. For example `\mathcal{L}\left\lbrace \mathrm{J}_0(t) \right\rbrace=1/\sqrt{p^2+1}` has a branch cut starting at `p=j=\sqrt{-1}` and is a decaying oscillatory function, This range of behaviors is illustrated in Duffy [3] Figure 4.10.4, p. 228. In general as `p \rightarrow \infty` `t \rightarrow 0` and vice-versa. All numerical inverse Laplace transform methods require their abscissa to shift closer to the origin for larger times. If the abscissa shift left of the rightmost singularity in the Laplace domain, the answer will be completely wrong (the effect of singularities to the right of the Bromwich contour are not included in the results). For example, the following exponentially growing function has a pole at `p=3`: .. math :: \bar{f}(p)=\frac{1}{p^2-9} .. math :: f(t)=\frac{1}{3}\sinh 3t >>> mp.dps = 15; mp.pretty = True >>> fp = lambda p: 1/(p*p-9) >>> ft = lambda t: sinh(3*t)/3 >>> tt = [0.01,0.1,1.0,10.0] >>> ft(tt[0]),invertlaplace(fp,tt[0],method='talbot') (0.0100015000675014, 0.0100015000675014) >>> ft(tt[1]),invertlaplace(fp,tt[1],method='talbot') (0.101506764482381, 0.101506764482381) >>> ft(tt[2]),invertlaplace(fp,tt[2],method='talbot') (3.33929164246997, 3.33929164246997) >>> ft(tt[3]),invertlaplace(fp,tt[3],method='talbot') (1781079096920.74, -1.61331069624091e-14) **References** 1. [DLMF]_ section 1.14 (http://dlmf.nist.gov/1.14T4) 2. Cohen, A.M. (2007). Numerical Methods for Laplace Transform Inversion, Springer. 3. Duffy, D.G. (1998). Advanced Engineering Mathematics, CRC Press. **Numerical Inverse Laplace Transform Reviews** 1. Bellman, R., R.E. Kalaba, J.A. Lockett (1966). *Numerical inversion of the Laplace transform: Applications to Biology, Economics, Engineering, and Physics*. Elsevier. 2. Davies, B., B. Martin (1979). Numerical inversion of the Laplace transform: a survey and comparison of methods. *Journal of Computational Physics* 33:1-32, http://dx.doi.org/10.1016/0021-9991(79)90025-1 3. Duffy, D.G. (1993). On the numerical inversion of Laplace transforms: Comparison of three new methods on characteristic problems from applications. *ACM Transactions on Mathematical Software* 19(3):333-359, http://dx.doi.org/10.1145/155743.155788 4. Kuhlman, K.L., (2013). Review of Inverse Laplace Transform Algorithms for Laplace-Space Numerical Approaches, *Numerical Algorithms*, 63(2):339-355. http://dx.doi.org/10.1007/s11075-012-9625-3 methodcohentalbotstehfestdehoogzunknown invlap algorithm: %s) r0typestrlowerrrrr ValueErrorrr?r)rfrrrulelruler?rs r invertlaplace.LaplaceTransformInversionMethods.invertlaplacesrzz(G, : JJLE ((*$}}("||zz !?$!FGG9D ##A00!FF #FqadF #--b44 $s8Cc0SUS'UR"U0UD6$)Nrrrrs r invlaptalbot-LaplaceTransformInversionMethods.invlaptalbot"#x  $1&11r c0SUS'UR"U0UD6$)Nrrrrs r invlapstehfest/LaplaceTransformInversionMethods.invlapstehfests"%x  $1&11r c0SUS'UR"U0UD6$)Nrrrrs r invlapdehoog-LaplaceTransformInversionMethods.invlapdehoogrr c0SUS'UR"U0UD6$)Nrrrrs r invlapcohen,LaplaceTransformInversionMethods.invlapcohens""x  $1&11r r N) rrrrr rrrrrrr r r rrs" S5l2222r r__main__r-N) objectrr"rNrerrrdoctesttestmodr r r rs} "f "Fp)pjA&ALw $wxx #xzk2vk2`  z OOr