�
H�g، � �� � G d � de � � Z G d� de� � Z G d� de� � Z G d� de� � Z G d� d e� � Z G d
� d e � � Zed k rd
dlZ ej � � dS dS )c �$ � e Zd ZdZd� Zd� Zd� ZdS )�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.
c � � || _ d S �N)�ctx)�selfr s �n/home/asafur/pinokio/api/open-webui.git/app/env/lib/python3.11/site-packages/mpmath/calculus/inverselaplace.py�__init__z InverseLaplaceTransform.__init__ s
� ������ c � � t �)a
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 �t�kwargss r �calc_laplace_parameterz.InverseLaplaceTransform.calc_laplace_parameter �
� � "�!r
c � � t �)a
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_solutionz1InverseLaplaceTransform.calc_time_domain_solution r r
N)�__name__�
__module__� __qualname__�__doc__r r r � r
r r r sK � � � � � �
�
�� � �"� "� "�"� "� "� "� "r
r c � � e Zd Zd� Zdd�ZdS )� FixedTalbotc � � | j � |� � | _ | j � |� d| j � � � � | _ d|v r|d | _ | j | _ nKt d| j j z � � | _ t dt d| j z � � � � | _ | j }| j j | _
| j | j _ |� d| j � dd� � |z � � | _ | j �
d | j j |d
z � � | _ | j � |d
� � | _ d | j d < | j � |d
� � | _ | j | j d < t' d
|� � D ]]}| j � | j | � � | j |< | j | j | z | j | d z z | j |< �^| j � |d
� � | _ | j | j z | _ d
S )a+ The "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 <M
where `j=\sqrt{-1}`, `r=2M/5`, and `t_\mathrm{max}` is the
maximum specified time.
�tmax�degreeg��Q� ��?� ��G�z�?�r� � g � � � �?N)r �convertr �getr r �dps_goal�int�dps�max�dps_orig�fractionr! �linspace�pi�theta�matrix� cot_theta�delta�range�cot�p)r r r �M�is r r z"FixedTalbot.calc_laplace_parameter) s� � �r ��!�!�!�$�$��� �H�$�$�V�Z�Z����%?�%?�@�@�� � �v� � � ��*�D�K� �K�D�M�M� ��T�X�\� 1� 2� 2�D�M� �b�#�d�4�=�&8�"9�"9�:�:�D�K� �K��
�� ��
��}��� � ���C���!2�!2�1�a�!8�!8��!:�;�;����X�&�&�s�D�H�K��1��=�=��
� �� � ��A�.�.��� ���q�� �X�_�_�Q��*�*��
� ���
�1�
��q�!��� J� J�A� $�� � �T�Z��]� ;� ;�D�N�1� � �F�4�:�a�=� 0�$�.��2C�b�2H� I�D�J�q�M�M��� � ��A�&�&�����D�I�%����r
Fc � � | j � |� � | _ | j }| j }| j }| j }| j }| j � |d� � } | j � |d � � |d z dz | d< t d|� � D ]b}
| j � ||
� � ||
z dd||
z d| j |
dz z z z d| j |
z z
z | |
< �c| j � dd� � | j �
| � � z | j z } |s| j | j _ | j S )a� The fixed Talbot time-domain solution is computed from the
Laplace-space function evaluations using
.. math ::
f(t,M)=\frac{2}{5t}\sum_{k=0}^{M-1}\Re \left[
\gamma_k \bar{f}(p_k)\right]
where
.. math ::
\gamma_0 = \frac{1}{2}e^{r}\bar{f}(p_0)
.. math ::
\gamma_k = e^{tp_k}\left\lbrace 1 + \frac{jk\pi}{M}\left[1 +
\cot \left( \frac{k \pi}{M} \right)^2 \right] - j\cot\left(
\frac{k \pi}{M}\right)\right \rbrace \qquad 1\le k<M.
Again, `j=\sqrt{-1}`.
Before calling this function, call
:class:`~mpmath.calculus.inverselaplace.FixedTalbot.calc_laplace_parameter`
to set the parameters and compute the required coefficients.
**References**
1. Abate, J., P. Valko (2004). Multi-precision Laplace
transform inversion. *International Journal for Numerical
Methods in Engineering* 60:979-993,
http://dx.doi.org/10.1002/nme.995
2. Talbot, A. (1979). The accurate numerical inversion of
Laplace transforms. *IMA Journal of Applied Mathematics*
23(1):97, http://dx.doi.org/10.1093/imamat/23.1.97
r$ r% r" r& r# )r r' r r1 r4 r r7 r! r2 �expr5 r3 r. �fsumr- r+ �real) r r r � manual_precr1 r4 r8 r7 r! �ansr9 �results r r z%FixedTalbot.calc_time_domain_solution� sK � �P ��!�!�!�$�$��� �
���
�� �K�� �F�� �F���h�o�o�a��#�#���� � �e�A�h�'�'��1��-�a�/��A���q�!��� &� &�A��X�\�\�%��(�+�+�B�q�E�1��B�u�Q�x�K��T�^�A�%6��%9�!9�:�:��4�>�!�$�$�%�&�C��F�F� ��"�"�1�a�(�(��� � �s�);�);�;�D�F�B�� � )� �=�D�H�L��{�r
N�F�r r r r r r r
r r r ' sA � � � � � �e&� e&� e&�RE� E� E� E� E� Er
r c �" � e Zd Zd� Zd� Zdd�ZdS )�Stehfestc �v � | j � |� � | _ d|v r*|d | _ t d| j z � � | _ n;t d| j j z � � | _ t d| j � � | _ | j dz dk r| xj dz
c_ | j }| j j | _ | j | j _ | � � � | _
| j � | j � d|dz � � � � | j j
z | j z | _ dS ) a4
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)r r' r r r* r) r+ r, r- �_coeff�Vr2 �arange�ln2r7 )r r r r8 s r r z Stehfest.calc_laplace_parameter� s � �2 ��!�!�!�$�$��� �v� � � ��*�D�K� ��T�[� 0� 1� 1�D�M�M� ��T�X�\� 1� 2� 2�D�M� �b�$�-�0�0�D�K� �;��?�Q� � � �K�K�1� �K�K� �K��
�� ��
��}��� ���� � ����� � ��� � ��A�a�C�!8�!8�9�9�$�(�,�F�t�v�M����r
c � � | j }t |dz � � }| j � |d� � }t d|dz � � D �]w}| j � t ||� � dz d� � }t t |dz dz � � t ||� � dz � � D ]�}| j � ||� � | j � d|z � � z | j � ||z
� � | j � |� � z | j � |dz
� � z | j � ||z
� � z | j � d|z |z
� � z z ||< ��| j � d||z � � | j � |� � z ||dz
< ��y|S )z|Salzer summation weights (aka, "Stehfest coefficients")
only depend on the approximation order (M) and the precisionr" r$ �����) r r* r r2 r5 �min�power�facr< )r r8 �M2rH �k�z�js r rG zStehfest._coeff s� � �
�K��
��1��X�X�� �H�O�O�A�q� !� !�� �q�!�A�#� � � ?� ?�A������A�r�
�
�1� �a�0�0�A��3��!��Q�w�<�<��Q����A� �6�6�
/�
/�� ����q�"�-�-�d�h�l�l�1�Q�3�.?�.?�?� �� � �b��d�+�+�D�H�L�L��O�O�;� �� � �a��c�*�*�+�+/�8�<�<��!��+<�+<�=� �� � �a��c�!�e�,�,�-�.��!��� �X�^�^�B��"��-�-�d�h�m�m�A�.>�.>�>�A�a��c�F�F��r
Fc �� � | j � |� � | _ | j � | j |� � | j j z | j z }|s| j | j _ |j S )a Compute 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
) r r' r �fdotrH rJ r- r+ r= )r r r r> r@ s r r z"Stehfest.calc_time_domain_solution0 sd � �@ ��!�!�!�$�$��� �� � �t�v�r�*�*�4�8�<�7���>�� � )� �=�D�H�L� �{�r
NrA )r r r r rG r r r
r rD rD � sJ � � � � � �6N� 6N� 6N�t� � �0-� -� -� -� -� -r
rD c � � e Zd Zd� Zdd�ZdS )�deHoogc � � | j � |� � | _ |� d| j � � | _ d|v r*|d | _ t
d| j z � � | _ n;t
| j j dz � � | _ t d| j � � | _ | j }| j �
d| j � � }| j � |� d|� � � � | _ | j � |� d| j dz � � � � | _ d | j z d
z | _
| j j | _ | j | j _ |� d d � � | _ | j � |� d | j | j z � � � � | _ | j � d |z d
z d
� � | _ | j | j � | j � � | j | j z z z
| _ | j | j j | j � | j � | j
� � � � z | j z d
z z | _ dS )a~ the 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 $@�alpha�tolr" r$ �scale�Tr& N)r r' r r( r r r* r) r+ r, rN rZ r[ �npr- r\ r] r2 r7 �log�gammar0 rI )r r r r8 �tmps r r z deHoog.calc_laplace_parameterd s � �D ��!�!�!�$�$��� �J�J�v�t�v�.�.�� � �v� � � ��*�D�K� ��T�[� 0� 1� 1�D�M�M� ��� �T� 1� 2� 2�D�M� �b�$�-�0�0�D�K�
�K�� �h�n�n�T�D�M�>�2�2���X�%�%�f�j�j��#�&>�&>�?�?��
� �8�#�#�F�J�J�u�d�j��o�$F�$F�G�G����D�K�-��/���
�� ��
��}��� � �Z�Z���+�+��
���!�!�&�*�*�S�$�*�T�Y�2F�"G�"G�H�H����� � ��1��Q���*�*����Z�$�(�,�,�t�x�"8�"8�$�*�T�V�:K�"L�L��
��*�t�x�{��(�/�/�$�(�/�/�$�'�":�":�;�;� <�<@�F� C�CE� F� F����r
Fc �~ � | j }| j }| j }| j � |� � | _ | j � ||dz � � }| j � d|z |� � }| j � |d� � } | j � |dz d� � }
| j � |dz d� � } d|dd�df< |d |d dz z |d< t dd|z � � D ]} || dz || z || df< � t d|dz � � D ]�}
d||
z
z dz }|d|dz �|
dz
f |d|�|
dz
f z
|d|dz �|
dz
f z |d|�|
f< |
|k s\|
dz }d||z
z dz dz }t |� � D ]9} || dz |dz
f || dz |dz
f z || |dz
f z || |dz
f< �:��|d dz | d< t d|dz � � D ]*}
|d|
dz
f | d|
z dz
< |d|
f | d|
z < �+d|
d< | d |
d< d| dd�< | j �
| j |z � � }t dd|z � � D ]N} |
| | | |
| dz
z |z z |
| dz < | | | | | | dz
z |z z | | dz < �Od| d|z dz
| d|z z
|z z dz }|| j � d| d|z |z |z z | j � dd� � � � z }|
d|z ||
d|z dz
z z |
|< | d|z || d|z dz
z z | |< | j �
| j | j z � � |z |
| | | z j z }|s| j | j _ |S )a| Calculate 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" y Nr% )r% r% y �? )r r^ r] r r' r �zerosr2 �onesr5 �expjpi�powm1r. r; r` r= r- r+ )r r r r> r8 r^ r] �e�q�d�A�Br9 r! �mr�rqrR �brem�remr@ s r r z deHoog.calc_time_domain_solution� sL � �@
�K��
�W�� �F����!�!�!�$�$���
�H�N�N�2�q��s� #� #�� �H�O�O�A�a�C�� #� #�� �H�O�O�B�� "� "�� �H�N�N�2�a�4�� #� #�� �H�M�M�"�Q�$�� "� "�� ��!�!�!�Q�$���Q�%��A��q��/��$���q�!�A�#� � � $� $�A���1��g�b��e�m�A�a��d�G�G� �q�!�A�#� � � F� F�A��A�a�C��1��B��1�R��T�6�1�Q�3�;� �!�A�b�D�!�A�#�I�,�6��1�R��T�6�1�Q�3�;� �G�A�a��d�A�g�J���6�6��q�S����"��X�a�Z�!�^�� �r��� F� F�A�!"�1�Q�3��1��9� �a��!��R��T� �l�!:�1�Q��1��W�:�!E�A�a��A��g�J�J�� �!�u�Q�w��!���q�!�A�#� � � � �A��!�Q�q�S�&� �z�A�a��c�!�e�H��!�Q�$��x�A�a��c�F�F� ��!����t��!����!�A�#��
�H�O�O�D�F�1�H� %� %�� �q�!�A�#� � � *� *�A��q�T�A�a�D��1�Q�3��K��M�)�A�a��c�F��q�T�A�a�D��1�Q�3��K��M�)�A�a��c�F�F� �Q�q��s�1�u�X��!�A�#��&��)�)�1�,���4�8�>�>�!�a��!��f�Q�h�t�m�"3�"&�(�"3�"3�A�q�"9�"9�;� ;� ;�� �!�A�#���Q�q��s�1�u�X� �%��"���!�A�#���Q�q��s�1�u�X� �%��"�� �� � �d�j��� /�0�0��2�A�b�E�!�B�%�K�3E�E�� � )� �=�D�H�L��
r
NrA rB r r
r rW rW b sD � � � � � �LG� LG� LG�`e� e� e� e� e� er
rW c � � e Zd Zd� Zdd�ZdS )�Cohenc � � | j � |� � | _ d|v r*|d | _ t d| j z � � | _ nKt | j j dz � � | _ t dt d| j z � � � � | _ | j dz }| j j | _ | j | j _ d| j z }| j j | j � d� � z | j � |� � z }| j �
dd � � |z }| j � |� d
|� � � � | _ | j |z }| j j
d z | j z }| j � |d� � | _ || j d < t! d|� � D ]}|||z z | j |< �d
S )a� The 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" rY � rZ r& r% N)r r' r r r* r) r+ r, r- r_ r. r( rZ r0 r2 r7 r5 ) r r r r8 �ttwora �a_t�p_tr9 s r r z Cohen.calc_laplace_parameter s� � �R ��!�!�!�$�$��� �v� � � ��*�D�K� ��d�k� 1� 2� 2�D�M�M� ��� �t� 3� 4� 4�D�M� �b�#�d�T�]�&:�";�";�<�<�D�K� �K�!�O��
�� ��
��}��� ��4�6�z���h�l�T�X�\�\�"� -� -�-��� � �T�0B�0B�B���h� � ��1�%�%��+���X�%�%�f�j�j��#�&>�&>�?�?��
� �j�4� ���h�k�B� ���'���� � ��A�&�&������q� ��q�!��� &� &�A��a�#�g�
�D�F�1�I�I� &� &r
Fc � � | j � |� � | _ | j }|dz }| j � |d� � }t |� � D ]}|| j ||< �d| j � d� � z |z }|d|z z dz }| j j } | }
d} t |� � D ]B} | |
z
}
| |
|| dz z z } d| |z z | |z
z | z d| z dz | | j j z z z } �C| j � | j
dz � � | j z |d dz | |z z
z }
|s| j | j _ |
S )au 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$ rt � r" r% )
r r' r r r2 r5 r= �sqrt�oner; rZ r- r+ )r r r r> �nr8 rj r9 ri �b�c�srQ r@ s r r z Cohen.calc_time_domain_solutioni si � �$ ��!�!�!�$�$��� �K��
��E�� �H�O�O�A�q� !� !���q��� � �A��a�5�:�A�a�D�D�
��� � �q�!�!�
!�a� '��
��Q��Y�!�O��
�X�\�M��
�B��
���q��� O� O�A��A��A��A��!�a�%��L� �A��Q��U� �q�1�u�%��)�a�!�e�a�i�A��� �<L�-M�N�A�A��� � �d�j�1�n�-�-���6�!�A�$��(�Q��U�:J�K�� � )� �=�D�H�L��
r
NrA rB r r
r rq rq s; � � � � � �G&� G&� G&�R-� -� -� -� -� -r
rq c �2 � e Zd Zd� Zd� Zd� Zd� Zd� Zd� ZdS )� LaplaceTransformInversionMethodsc � � t | � � | _ t | � � | _ t | � � | _ t
| � � | _ d S r )r �
_fixed_talbotrD � _stehfestrW �_de_hoogrq �_cohen�r �argsr s r r z)LaplaceTransformInversionMethods.__init__� s= � � '�� ,� ,��� ��
�
��
� �c�{�{�� ��3�Z�Z��
�
�
r
c � �� |� dd� � }t |� � t u r^|� � � }|dk r| j }nG|dk r| j }n9|dk r| j }n+|dk r| j }n t d|z � � � || � � } |j |fi |�� �fd�|j
D � � }|� ||� � S )a�* Computes the numerical inverse Laplace transform for a
Laplace-space function at a given time. The function being
evaluated is assumed to be a real-valued function of time.
The user must supply a Laplace-space function `\bar{f}(p)`,
and a desired time at which to estimate the time-domain
solution `f(t)`.
A few basic examples of Laplace-space functions with known
inverses (see references [1,2]) :
.. math ::
\mathcal{L}\left\lbrace f(t) \right\rbrace=\bar{f}(p)
.. math ::
\mathcal{L}^{-1}\left\lbrace \bar{f}(p) \right\rbrace = f(t)
.. math ::
\bar{f}(p) = \frac{1}{(p+1)^2}
.. math ::
f(t) = t e^{-t}
>>> 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
�method�cohen�talbot�stehfest�dehoogz unknown invlap algorithm: %sc �& �� g | ]
} �|� � ��S r r )�.0r7 �fs �r �
<listcomp>zBLaplaceTransformInversionMethods.invertlaplace.<locals>.<listcomp>� s! �� �
#�
#�
#�q�a�a��d�d�
#�
#�
#r
) r( �type�str�lowerr� r� r� r� �
ValueErrorr r7 r )r r� r r �rule�lruler s ` r �
invertlaplacez.LaplaceTransformInversionMethods.invertlaplace� s� �� �r �z�z�(�G�,�,�� ��:�:�� � ��J�J�L�L�E��� � ��(����*�$�$��}����(�"�"��|����� � ��z��� �!?�$�!F�G�G�G��4��9�9�D� $��#�A�0�0��0�0�0� $�
#�
#�
#�D�F�
#�
#�
#�� �-�-�b�!�4�4�4r
c �& � d|d< | j |i |��S )Nr� r� �r� r� s r � invlaptalbotz-LaplaceTransformInversionMethods.invlaptalbot� �$ � �#��x�� �s� �$�1�&�1�1�1r
c �& � d|d< | j |i |��S )Nr� r� r� r� s r �invlapstehfestz/LaplaceTransformInversionMethods.invlapstehfest� s$ � �%��x�� �s� �$�1�&�1�1�1r
c �& � d|d< | j |i |��S )Nr� r� r� r� s r � invlapdehoogz-LaplaceTransformInversionMethods.invlapdehoog� r� r
c �& � d|d< | j |i |��S )Nr� r� r� r� s r � invlapcohenz,LaplaceTransformInversionMethods.invlapcohen� s$ � �"��x�� �s� �$�1�&�1�1�1r
N) r r r r r� r� r� r� r� r r
r r� r� � sr � � � � � � � � � S5� S5� S5�l2� 2� 2�2� 2� 2�2� 2� 2�2� 2� 2� 2� 2r
r� �__main__r% N)
�objectr r rD rW rq r� r �doctest�testmodr r
r �<module>r� sg �� "� "� "� "� "�f� "� "� "�Fp� p� p� p� p�)� p� p� p�jA� A� A� A� A�&� A� A� A�Lw� w� w� w� w�
$� w� w� w�xx� x� x� x� x� #� x� x� x�zk2� k2� k2� k2� k2�v� k2� k2� k2�` �z����N�N�N��G�O������ �r