�
H�g�� � �� � d dl Z ddlmZ G d� de� � Z G d� de� � Z G d� d e� � Z G d
� d e� � Zed k rd dl Z e j
� � dS dS )
� N� )�xrangec �R � e Zd ZdZd� Zd� Zd
d�Zd
d�Zd
d�Zd� Z d � Z
d
d
�Z d
d �Z d S )�QuadratureRuleaN
Quadrature rules are implemented using this class, in order to
simplify the code and provide a common infrastructure
for tasks such as error estimation and node caching.
You can implement a custom quadrature rule by subclassing
:class:`QuadratureRule` and implementing the appropriate
methods. The subclass can then be used by :func:`~mpmath.quad` by
passing it as the *method* argument.
:class:`QuadratureRule` instances are supposed to be singletons.
:class:`QuadratureRule` therefore implements instance caching
in :func:`~mpmath.__new__`.
c �> � || _ i | _ i | _ i | _ d S �N)�ctx�standard_cache�transformed_cache�interval_count)�selfr s �j/home/asafur/pinokio/api/open-webui.git/app/env/lib/python3.11/site-packages/mpmath/calculus/quadrature.py�__init__zQuadratureRule.__init__ s' � ���� ���!#�� � ����� c �0 � i | _ i | _ i | _ dS )z*
Delete cached node data.
N)r
r r )r
s r �clearzQuadratureRule.clear s" � � !���!#�� � ����r Fc � � t �)z�
Compute nodes for the standard interval `[-1, 1]`. Subclasses
should probably implement only this method, and use
:func:`~mpmath.get_nodes` method to retrieve the nodes.
)�NotImplementedError)r
�degree�prec�verboses r �
calc_nodeszQuadratureRule.calc_nodes# s
� � "�!r c � � ||||f}|| j v r
| j | S | j j } |dz | j _ ||f| j v r| j ||f }n#| � |||� � }|| j ||f< | � ||||� � }|| j v r || j |< n
d| j |< || j _ n# || j _ w xY w|S )a�
Return nodes for given interval, degree and precision. The
nodes are retrieved from a cache if already computed;
otherwise they are computed by calling :func:`~mpmath.calc_nodes`
and are then cached.
Subclasses should probably not implement this method,
but just implement :func:`~mpmath.calc_nodes` for the actual
node computation.
� T)r r r r
r �transform_nodesr ) r
�a�br r r �key�orig�nodess r � get_nodeszQuadratureRule.get_nodes+ s� � � �!�V�T�"�� �$�(� (� (��)�#�.� .��x�}�� !� ��G�D�H�M���~��!4�4�4� �+�F�D�L�9��� �����g�>�>��49��#�F�D�L�1��(�(���1�g�>�>�E��d�)�)�)�.3��&�s�+�+�+/��#�C�(� �D�H�M�M��D�D�H�M� � � � �� s �BB: �:Cc �� � | j }|� |� � }|� |� � }|j }||f| |fk r|S |� d� � }g }|� |� � s|� |� � �r#||f|j |j fk r@| } |D ]8\ }
} |
|
z } || z
}
|
| z }|
|z }
| ||
z z } |� |
| f� � �9�n||j k r=|dz }|D ]4\ }
} d|
|z z }||z
}
| ||dz z z } |� |
| f� � �5n�||j k r=|dz
}|D ]4\ }
} d|
|z z }||z }
| ||dz z z } |� |
| f� � �5nw||j k s ||j k r"d� | � ||||� � D � � S t �||z
dz }||z dz }|D ]%\ }
} |� |||
z z || z f� � �&|S )a�
Rescale standardized nodes (for `[-1, 1]`) to a general
interval `[a, b]`. For a finite interval, a simple linear
change of variables is used. Otherwise, the following
transformations are used:
.. math ::
\lbrack a, \infty \rbrack : t = \frac{1}{x} + (a-1)
\lbrack -\infty, b \rbrack : t = (b+1) - \frac{1}{x}
\lbrack -\infty, \infty \rbrack : t = \frac{x}{\sqrt{1-x^2}}
� �?� r c � � g | ]
\ }}|| f�� S � r& )�.0�x�ws r �
<listcomp>z2QuadratureRule.transform_nodes.<locals>.<listcomp>} s" � �W�W�W�5�A�a��A�2��W�W�Wr )
r �convert�one�mpf�isinf�ninf�inf�appendr r )r
r r r r r r, �half� new_nodes�p05r( r) �x2�px1�spx1�b1�u�a1�C�Ds r r z QuadratureRule.transform_nodesL s� � � �h�� �K�K��N�N�� �K�K��N�N���g��
�q�6�s�d�C�[� � ��L��w�w�s�|�|��� � �9�9�Q�<�<� ! /�3�9�9�Q�<�<� ! /��1�v�#�(�C�G�,�,�,��e�� !� -� -�D�A�q��1��B� �b�&�C� ��8�D��$��A���c��M�A� �$�$�a��V�,�,�,�,�
-� �c�h� � ��q�S�� !� -� -�D�A�q��1�S�5� �A��1��A���a��d��N�A� �$�$�a��V�,�,�,�,� -�
�c�g� � ��q�S�� !� -� -�D�A�q��1�S�5� �A��1��A���a��d��N�A� �$�$�a��V�,�,�,�,� -�
�c�g� � ��c�h� � �W�W�D�,@�,@���1�g�,V�,V�W�W�W�W�)�)� �1��a��A��1��a��A� �
/�
/���1�� � �!�A�a�C�%��1�� �.�.�.�.��r c
� � t dt d| j � |dz d� � � � z � � }|dz
}|S )a�
Given a desired precision `p` in bits, estimate the degree `m`
of the quadrature required to accomplish full accuracy for
typical integrals. By default, :func:`~mpmath.quad` will perform up
to `m` iterations. The value of `m` should be a slight
overestimate, so that "slightly bad" integrals can be dealt
with automatically using a few extra iterations. On the
other hand, it should not be too big, so :func:`~mpmath.quad` can
quit within a reasonable amount of time when it is given
an "unsolvable" integral.
The default formula used by :func:`~mpmath.guess_degree` is tuned
for both :class:`TanhSinh` and :class:`GaussLegendre`.
The output is roughly as follows:
+---------+---------+
| `p` | `m` |
+=========+=========+
| 50 | 6 |
+---------+---------+
| 100 | 7 |
+---------+---------+
| 500 | 10 |
+---------+---------+
| 3000 | 12 |
+---------+---------+
This formula is based purely on a limited amount of
experimentation and will sometimes be wrong.
� r g >@r )�int�maxr �log)r
r �gs r � guess_degreezQuadratureRule.guess_degree� sC � �B
��C��4�8�<�<��T� �1�5�5�6�6�6� 7� 7�� �Q����r c �n � t |� � dk r t |d |d z
� � S |d |d cxk r |d k rn n | j j S | j � t |d |d z
� � d� � }| j � t |d |d z
� � d� � }n# t
$ r |cY S w xY w| }t
dt |dz |z d|z |� � � � }| j � d� � t |� � z S )a�
Given results from integrations `[I_1, I_2, \ldots, I_k]` done
with a quadrature of rule of degree `1, 2, \ldots, k`, estimate
the error of `I_k`.
For `k = 2`, we estimate `|I_{\infty}-I_2|` as `|I_2-I_1|`.
For `k > 2`, we extrapolate `|I_{\infty}-I_k| \approx |I_{k+1}-I_k|`
from `|I_k-I_{k-1}|` and `|I_k-I_{k-2}|` under the assumption
that each degree increment roughly doubles the accuracy of
the quadrature rule (this is true for both :class:`TanhSinh`
and :class:`GaussLegendre`). The extrapolation formula is given
by Borwein, Bailey & Girgensohn. Although not very conservative,
this method seems to be very robust in practice.
r r r$ ����������������
)
�len�absr �zerorA �
ValueError�minr@ r- r? )r
�resultsr �epsilon�D1�D2�D3�D4s r �estimate_errorz QuadratureRule.estimate_error� s4 � � �w�<�<�1� � ��w�q�z�'�!�*�,�-�-� -� ��r�{�g�b�k�8�8�8�8�W�R�[�8�8�8�8�8��x�}�$��� � �c�'�"�+�g�b�k�"9� :� :�B�?�?�B��� � �c�'�"�+�g�b�k�"9� :� :�B�?�?�B�B��� � � ��N�N�N� �����U��
��C��A��b��!�B�$��+�+�
,�
,���x�|�|�B� � �3�r�7�7�*�*s �-C �!A.C � C � C c
� �� | j }|j x}} t t |� � dz
� � D �]w}
||
||
dz } } | | k r� | | f|j |j fk r|��fd�}|j |j } } g }
|j }t d|dz � � D �]}| � | | |||� � }|rBt d|� | � � �d|� | � � �d|�d|�d� � � | � |||||
|� � }|
�
|� � |dk rn| � |
||� � }|rMt d|� |� � d |� |� � d
|� |� � � � ||k r n��||
d z
}| |z
} ��y| |k r%|r#t d |� | � � � � || fS )
a�
Main integration function. Computes the 1D integral over
the interval specified by *points*. For each subinterval,
performs quadrature of degree from 1 up to *max_degree*
until :func:`~mpmath.estimate_error` signals convergence.
:func:`~mpmath.summation` transforms each subintegration to
the standard interval and then calls :func:`~mpmath.sum_next`.
r$ c �4 �� �| � � �| � � z S r r& )r( �_fs �r �<lambda>z*QuadratureRule.summation.<locals>.<lambda>� s �� �b�b�!��f�f�r�r�!�u�u�n� r zIntegrating from z to z (degree z of �)zEstimated error:z epsilon:z result: rE z/Failed to reach full accuracy. Estimated error:) r rK r rI r/ r0 r! �print�nstr�sum_nextr1 rT )r
�f�pointsr rO �
max_degreer r �I� total_err�ir r rN �errr r �resultrW s @r � summationzQuadratureRule.summation� s% �� � �h���� ��I���F� � �A�
�&�&� � �A��!�9�f�Q�q�S�k�q�A��A�v�v�� �1�v�#�(�C�G�,�,�,���,�,�,�,����#�'�1���G��(�C� ��J�q�L�1�1�
�
�� ���q�!�V�T�7�C�C��� H��E� ���!�����c�h�h�q�k�k�k�k�6�6�6�:�:�:�G� H� H� H� � � �q�%���w��P�P�����v�&�&�&��A�:�:� �-�-�g�t�W�E�E�C� � @� � 0�#�(�(�3�-�-��c�h�h�W^�N_�N_�al�nq�nv�nv�w}�n~�n~�����g�~�~� ���
���� �A� �� �I�I� �w� � ��
^��G����R[�I\�I\�]�]�]��)�|�r c �P �� | j � �fd�|D � � � � S )aC
Evaluates the step sum `\sum w_k f(x_k)` where the *nodes* list
contains the `(w_k, x_k)` pairs.
:func:`~mpmath.summation` will supply the list *results* of
values computed by :func:`~mpmath.sum_next` at previous degrees, in
case the quadrature rule is able to reuse them.
c 3 �8 �K � | ]\ }}| �|� � fV � �d S r r& �r' r( r) r] s �r � <genexpr>z*QuadratureRule.sum_next.<locals>.<genexpr> s3 �� � � � :� :�5�A�a�a���1���Y� :� :� :� :� :� :r )r �fdot)r
r] r r r �previousr s ` r r\ zQuadratureRule.sum_next� s. �� � �x�}�}� :� :� :� :�E� :� :� :�:�:�:r N�F)
�__name__�
__module__� __qualname__�__doc__r r r r! r rC rT re r\ r& r r r r s� � � � � � �
�
� !� !� !� !� !� !�"� "� "� "� � � � �B:� :� :� :�x$� $� $�L+� +� +�:+ � + � + � + �Z ;� ;� ;� ;� ;� ;r r c �" � e Zd ZdZdd�Zdd�ZdS )�TanhSinha�
This class implements "tanh-sinh" or "doubly exponential"
quadrature. This quadrature rule is based on the Euler-Maclaurin
integral formula. By performing a change of variables involving
nested exponentials / hyperbolic functions (hence the name), the
derivatives at the endpoints vanish rapidly. Since the error term
in the Euler-Maclaurin formula depends on the derivatives at the
endpoints, a simple step sum becomes extremely accurate. In
practice, this means that doubling the number of evaluation
points roughly doubles the number of accurate digits.
Comparison to Gauss-Legendre:
* Initial computation of nodes is usually faster
* Handles endpoint singularities better
* Handles infinite integration intervals better
* Is slower for smooth integrands once nodes have been computed
The implementation of the tanh-sinh algorithm is based on the
description given in Borwein, Bailey & Girgensohn, "Experimentation
in Mathematics - Computational Paths to Discovery", A K Peters,
2003, pages 312-313. In the present implementation, a few
improvements have been made:
* A more efficient scheme is used to compute nodes (exploiting
recurrence for the exponential function)
* The nodes are computed successively instead of all at once
**References**
* [Bailey]_
* http://users.cs.dal.ca/~jborwein/tanh-sinh.pdf
Fc �� �� | j � d� � | z }|r|d |dz z }n | j j }|| j � �fd�|D � � � � z
}||z S )a
Step sum for tanh-sinh quadrature of degree `m`. We exploit the
fact that half of the abscissas at degree `m` are precisely the
abscissas from degree `m-1`. Thus reusing the result from
the previous level allows a 2x speedup.
r rE c 3 �8 �K � | ]\ }}| �|� � fV � �d S r r& rh s �r ri z$TanhSinh.sum_next.<locals>.<genexpr>4 s3 �� � � �7�7���1�A�a�a��d�d�8�7�7�7�7�7�7r )r r- rK rj ) r
r] r r r rk r �h�Ss ` r r\ zTanhSinh.sum_next' sx �� �
�H�L�L��O�O�v�g� &�� � ��� �a��c�"�A�A���
�A� �T�X�]�]�7�7�7�7��7�7�7�
7�
7�7����s�
r c
� � | j }g }d}|xj |z
c_ |� d| dz
� � }|j dz }|� d| � � } |dk r'|� |j |j dz f� � | }
n| dz }
|� | � � } || z } || z }
|� |
� � }d|z }t ddd|z z dz � � D ]�}|� | |
z
� � }d|z }||z dz }||z
dz }||z }| |
z |dz z }t |dz
� � }||k r n�|� ||f� � |� | |f� � | |z } |
|z }
|rD|dz dk r;t d |�
|� |d� � |z � � � � ��|xj |z c_ |S )
a�
The abscissas and weights for tanh-sinh quadrature of degree
`m` are given by
.. math::
x_k = \tanh(\pi/2 \sinh(t_k))
w_k = \pi/2 \cosh(t_k) / \cosh(\pi/2 \sinh(t_k))^2
where `t_k = t_0 + hk` for a step length `h \sim 2^{-m}`. The
list of nodes is actually infinite, but the weights die off so
rapidly that only a few are needed.
r r$ rH r> r r i, � zCalculating nodes:) r r �ldexp�pir1 rK �expr rJ rZ r[ rA )r
r r r r r �extra�tol�pi4�t0ru �expt0r r �udelta�urdelta�k�c�d�co�sir( r) �diffs r r zTanhSinh.calc_nodes7 s � � �h������ ���E�����i�i��D�5��8�$�$���f�Q�h�� �Y�Y�q�6�'�
"�
"�� �Q�;�;�
�L�L�#�(�C�F�1�H�-� .� .� .��A�A��1��A� ���� � �� �%�K�� �%�K����������F�(����2�a��i�<��>�*�*� Q� Q�A� ����!�� � �A��!��A��A�#�q��B��A�#�q��B��R��A��1���A��
�A��q��s�8�8�D��s�{�{��� �L�L�!�Q�� � � � �L�L�1�"�a�� !� !� !�
��K�A�
��L�A��
Q�1�s�7�c�>�>� �*�C�H�H�c�g�g�d�B�6G�6G�5G�$�5N�,O�,O�P�P�P�� ���E����� r Nrl )rm rn ro rp r\ r r& r r rr rr sM � � � � � � � �D� � � � K� K� K� K� K� Kr rr c � � e Zd ZdZdd�ZdS )�
GaussLegendrea�
This class implements Gauss-Legendre quadrature, which is
exceptionally efficient for polynomials and polynomial-like (i.e.
very smooth) integrands.
The abscissas and weights are given by roots and values of
Legendre polynomials, which are the orthogonal polynomials
on `[-1, 1]` with respect to the unit weight
(see :func:`~mpmath.legendre`).
In this implementation, we take the "degree" `m` of the quadrature
to denote a Gauss-Legendre rule of degree `3 \cdot 2^m` (following
Borwein, Bailey & Girgensohn). This way we get quadratic, rather
than linear, convergence as the degree is incremented.
Comparison to tanh-sinh quadrature:
* Is faster for smooth integrands once nodes have been computed
* Initial computation of nodes is usually slower
* Handles endpoint singularities worse
* Handles infinite integration intervals worse
Fc �� � | j }|� d| dz
� � }|j }t |dz � � |_ |dk rs|� |� d� � dz � � }|� d� � dz }| |f|j |� d� � dz f||fg} ||_ | S g } dd|dz
z z }
|
dz dz } t d| � � D �]} |� t j t j
| dz
z |
d z z � � � � }
d
\ }}t d|
dz � � D ] }||d|z dz
|
z |z |dz
|z z
|z }}}�!|
|
|z |z
z |
dz dz
z }||z }|
|z
}
t |� � |k rn�l|
}dd|
dz z
|dz z z }|r | d z d k rt d
| | fz � � | �
||f� � | �
| |f� � ��||_ | S )z�
Calculates the abscissas and weights for Gauss-Legendre
quadrature of degree of given degree (actually `3 \cdot 2^m`).
r$ � g �?� � � r g �?r# )r$ r � � zComputing nodes (%i of %i))r ry r r? �sqrtr- rK r �math�cosrz rJ rZ r1 )r
r r r r rO r r( r) r �n�upto�j�r�t1�t2�j1�t3�t4r s r r zGaussLegendre.calc_nodes� sM � �
�h�� �)�)�A��u�Q�w�'�'�� �x���t�C�x�=�=��� �Q�;�;����������A� �&�&�A�����
�
�1� �A��b��V�S�X�c�g�g�a�j�j��l� 3�Q�q�E�:�E��C�H��L���
�a�&��(�m�O���!�t�a�x����4� � � "� "�A��������!�D�&�!1�1�S�5�!9�:�:�;�;�A�
� ���B� !��1�Q�3�-�-� H� H�B�!#�R�1�R�4��6�1�*�R�-�2�a�4��)�*C�R�)G�B��B�B���"��R��[�!�Q�$�q�&�)���r�E����E���q�6�6�G�#�#��
� �A��A�a��d�F�B��E�>�"�A��
@�A��F�b�L�L��2�a��Y�>�?�?�?� �L�L�!�Q�� � � � �L�L�1�"�a�� !� !� !� !����� r Nrl )rm rn ro rp r r& r r r� r� � s2 � � � � � �� �.,� ,� ,� ,� ,� ,r r� c �6 � e Zd Zd� Zd� Zd� Zd� Zdd�Zd d�ZdS )
�QuadratureMethodsc �V � t | � � | _ t | � � | _ d S r )r� �_gauss_legendrerr �
_tanh_sinh�r �args�kwargss r r zQuadratureMethods.__init__� s# � � +�C� 0� 0���!�#� � ����r c �v � ��� �
� � � |� dd� � � t � � � t u r.� dk r� j � n+� dk r� j � n t d� z � � � � � � � � |� d� � }t
�� � }� j x}� � j dz � |� d� � p� � � � � �
� fd��D � � � � xj d z
c_ |d
k r$� �
��d � � �
|� � \ }}ns|d k r,� �
� ��
�� � fd
��d � � �
|� � \ }}nA|dk r,� �
� ��
�� � fd��d � � �
|� � \ }}nt d� � �|� _ n # |� _ w xY w|� d� � r|
|fS |
S )ai'
Computes a single, double or triple integral over a given
1D interval, 2D rectangle, or 3D cuboid. A basic example::
>>> from mpmath import *
>>> mp.dps = 15; mp.pretty = True
>>> quad(sin, [0, pi])
2.0
A basic 2D integral::
>>> f = lambda x, y: cos(x+y/2)
>>> quad(f, [-pi/2, pi/2], [0, pi])
4.0
**Interval format**
The integration range for each dimension may be specified
using a list or tuple. Arguments are interpreted as follows:
``quad(f, [x1, x2])`` -- calculates
`\int_{x_1}^{x_2} f(x) \, dx`
``quad(f, [x1, x2], [y1, y2])`` -- calculates
`\int_{x_1}^{x_2} \int_{y_1}^{y_2} f(x,y) \, dy \, dx`
``quad(f, [x1, x2], [y1, y2], [z1, z2])`` -- calculates
`\int_{x_1}^{x_2} \int_{y_1}^{y_2} \int_{z_1}^{z_2} f(x,y,z)
\, dz \, dy \, dx`
Endpoints may be finite or infinite. An interval descriptor
may also contain more than two points. In this
case, the integration is split into subintervals, between
each pair of consecutive points. This is useful for
dealing with mid-interval discontinuities, or integrating
over large intervals where the function is irregular or
oscillates.
**Options**
:func:`~mpmath.quad` recognizes the following keyword arguments:
*method*
Chooses integration algorithm (described below).
*error*
If set to true, :func:`~mpmath.quad` returns `(v, e)` where `v` is the
integral and `e` is the estimated error.
*maxdegree*
Maximum degree of the quadrature rule to try before
quitting.
*verbose*
Print details about progress.
**Algorithms**
Mpmath presently implements two integration algorithms: tanh-sinh
quadrature and Gauss-Legendre quadrature. These can be selected
using *method='tanh-sinh'* or *method='gauss-legendre'* or by
passing the classes *method=TanhSinh*, *method=GaussLegendre*.
The functions :func:`~mpmath.quadts` and :func:`~mpmath.quadgl` are also available
as shortcuts.
Both algorithms have the property that doubling the number of
evaluation points roughly doubles the accuracy, so both are ideal
for high precision quadrature (hundreds or thousands of digits).
At high precision, computing the nodes and weights for the
integration can be expensive (more expensive than computing the
function values). To make repeated integrations fast, nodes
are automatically cached.
The advantages of the tanh-sinh algorithm are that it tends to
handle endpoint singularities well, and that the nodes are cheap
to compute on the first run. For these reasons, it is used by
:func:`~mpmath.quad` as the default algorithm.
Gauss-Legendre quadrature often requires fewer function
evaluations, and is therefore often faster for repeated use, but
the algorithm does not handle endpoint singularities as well and
the nodes are more expensive to compute. Gauss-Legendre quadrature
can be a better choice if the integrand is smooth and repeated
integrations are required (e.g. for multiple integrals).
See the documentation for :class:`TanhSinh` and
:class:`GaussLegendre` for additional details.
**Examples of 1D integrals**
Intervals may be infinite or half-infinite. The following two
examples evaluate the limits of the inverse tangent function
(`\int 1/(1+x^2) = \tan^{-1} x`), and the Gaussian integral
`\int_{\infty}^{\infty} \exp(-x^2)\,dx = \sqrt{\pi}`::
>>> mp.dps = 15
>>> quad(lambda x: 2/(x**2+1), [0, inf])
3.14159265358979
>>> quad(lambda x: exp(-x**2), [-inf, inf])**2
3.14159265358979
Integrals can typically be resolved to high precision.
The following computes 50 digits of `\pi` by integrating the
area of the half-circle defined by `x^2 + y^2 \le 1`,
`-1 \le x \le 1`, `y \ge 0`::
>>> mp.dps = 50
>>> 2*quad(lambda x: sqrt(1-x**2), [-1, 1])
3.1415926535897932384626433832795028841971693993751
One can just as well compute 1000 digits (output truncated)::
>>> mp.dps = 1000
>>> 2*quad(lambda x: sqrt(1-x**2), [-1, 1]) #doctest:+ELLIPSIS
3.141592653589793238462643383279502884...216420199
Complex integrals are supported. The following computes
a residue at `z = 0` by integrating counterclockwise along the
diamond-shaped path from `1` to `+i` to `-1` to `-i` to `1`::
>>> mp.dps = 15
>>> chop(quad(lambda z: 1/z, [1,j,-1,-j,1]))
(0.0 + 6.28318530717959j)
**Examples of 2D and 3D integrals**
Here are several nice examples of analytically solvable
2D integrals (taken from MathWorld [1]) that can be evaluated
to high precision fairly rapidly by :func:`~mpmath.quad`::
>>> mp.dps = 30
>>> f = lambda x, y: (x-1)/((1-x*y)*log(x*y))
>>> quad(f, [0, 1], [0, 1])
0.577215664901532860606512090082
>>> +euler
0.577215664901532860606512090082
>>> f = lambda x, y: 1/sqrt(1+x**2+y**2)
>>> quad(f, [-1, 1], [-1, 1])
3.17343648530607134219175646705
>>> 4*log(2+sqrt(3))-2*pi/3
3.17343648530607134219175646705
>>> f = lambda x, y: 1/(1-x**2 * y**2)
>>> quad(f, [0, 1], [0, 1])
1.23370055013616982735431137498
>>> pi**2 / 8
1.23370055013616982735431137498
>>> quad(lambda x, y: 1/(1-x*y), [0, 1], [0, 1])
1.64493406684822643647241516665
>>> pi**2 / 6
1.64493406684822643647241516665
Multiple integrals may be done over infinite ranges::
>>> mp.dps = 15
>>> print(quad(lambda x,y: exp(-x-y), [0, inf], [1, inf]))
0.367879441171442
>>> print(1/e)
0.367879441171442
For nonrectangular areas, one can call :func:`~mpmath.quad` recursively.
For example, we can replicate the earlier example of calculating
`\pi` by integrating over the unit-circle, and actually use double
quadrature to actually measure the area circle::
>>> f = lambda x: quad(lambda y: 1, [-sqrt(1-x**2), sqrt(1-x**2)])
>>> quad(f, [-1, 1])
3.14159265358979
Here is a simple triple integral::
>>> mp.dps = 15
>>> f = lambda x,y,z: x*y/(1+z)
>>> quad(f, [0,1], [0,1], [1,2], method='gauss-legendre')
0.101366277027041
>>> (log(3)-log(2))/4
0.101366277027041
**Singularities**
Both tanh-sinh and Gauss-Legendre quadrature are designed to
integrate smooth (infinitely differentiable) functions. Neither
algorithm copes well with mid-interval singularities (such as
mid-interval discontinuities in `f(x)` or `f'(x)`).
The best solution is to split the integral into parts::
>>> mp.dps = 15
>>> quad(lambda x: abs(sin(x)), [0, 2*pi]) # Bad
3.99900894176779
>>> quad(lambda x: abs(sin(x)), [0, pi, 2*pi]) # Good
4.0
The tanh-sinh rule often works well for integrands having a
singularity at one or both endpoints::
>>> mp.dps = 15
>>> quad(log, [0, 1], method='tanh-sinh') # Good
-1.0
>>> quad(log, [0, 1], method='gauss-legendre') # Bad
-0.999932197413801
However, the result may still be inaccurate for some functions::
>>> quad(lambda x: 1/sqrt(x), [0, 1], method='tanh-sinh')
1.99999999946942
This problem is not due to the quadrature rule per se, but to
numerical amplification of errors in the nodes. The problem can be
circumvented by temporarily increasing the precision::
>>> mp.dps = 30
>>> a = quad(lambda x: 1/sqrt(x), [0, 1], method='tanh-sinh')
>>> mp.dps = 15
>>> +a
2.0
**Highly variable functions**
For functions that are smooth (in the sense of being infinitely
differentiable) but contain sharp mid-interval peaks or many
"bumps", :func:`~mpmath.quad` may fail to provide full accuracy. For
example, with default settings, :func:`~mpmath.quad` is able to integrate
`\sin(x)` accurately over an interval of length 100 but not over
length 1000::
>>> quad(sin, [0, 100]); 1-cos(100) # Good
0.137681127712316
0.137681127712316
>>> quad(sin, [0, 1000]); 1-cos(1000) # Bad
-37.8587612408485
0.437620923709297
One solution is to break the integration into 10 intervals of
length 100::
>>> quad(sin, linspace(0, 1000, 10)) # Good
0.437620923709297
Another is to increase the degree of the quadrature::
>>> quad(sin, [0, 1000], maxdegree=10) # Also good
0.437620923709297
Whether splitting the interval or increasing the degree is
more efficient differs from case to case. Another example is the
function `1/(1+x^2)`, which has a sharp peak centered around
`x = 0`::
>>> f = lambda x: 1/(1+x**2)
>>> quad(f, [-100, 100]) # Bad
3.64804647105268
>>> quad(f, [-100, 100], maxdegree=10) # Good
3.12159332021646
>>> quad(f, [-100, 0, 100]) # Also good
3.12159332021646
**References**
1. http://mathworld.wolfram.com/DoubleIntegral.html
�method� tanh-sinh�gauss-legendrezunknown quadrature rule: %sr r� � maxdegreec �: �� g | ]}�� |� � ��S r& )�
_as_points)r' �pr s �r r* z*QuadratureMethods.quad.<locals>.<listcomp>� s% �� �4�4�4��#�.�.��#�#�4�4�4r r r$ r r c �X �� � �� �� fd��d ���� � d S )Nc � �� ��| � � S r r& )�yr] r( s ��r rX z:QuadratureMethods.quad.<locals>.<lambda>.<locals>.<lambda>� s �� ���1�Q��� r r$ r �re �r( rO r] �mr^ r �rules `������r rX z(QuadratureMethods.quad.<locals>.<lambda>� s> ��� � ���'7�'7�'7�'7�'7� �q� �4��!�5� 5�56�8� r r� c �b �� � �� ������� fd��d ���� � d S )Nc �Z �� � �� ��� fd��d ���� � d S )Nc � �� ���| � � S r r& )�zr] r( r� s ���r rX zLQuadratureMethods.quad.<locals>.<lambda>.<locals>.<lambda>.<locals>.<lambda>� s �� �Q�Q�q��1�X�X� r r r r� )r� rO r] r� r^ r r� r( s `�������r rX z:QuadratureMethods.quad.<locals>.<lambda>.<locals>.<lambda>� sA ��� � �N�N�+=�+=�+=�+=�+=�+=� "�1�I�t�W�a� 9� 9�9:� <� r r$ r r� r� s `������r rX z(QuadratureMethods.quad.<locals>.<lambda>� se ��� � ��� (<� (<� (<� (<� (<� (<� (<� (<� (<� (<� �q� �4��!�5� 5� 67�8� r z"quadrature must have dim 1, 2 or 3�error) �get�type�strr� r� rL rI r �epsrC re r )
r r] r^ r� r �dimr �vrc rO r� r r� s
``` @@@@r �quadzQuadratureMethods.quad� s> �������� �L �z�z�(�K�0�0�� ��:�:�� � ��{�"�"��~����)�)�)��*��� �!>��!E�F�F�F��4��9�9�D��*�*�Y�'�'���&�k�k���h� ��t��'�!�)�� �J�J�{� #� #� >�t�'8�'8��'>�'>��4�4�4�4�V�4�4�4�� � �H�H��N�H�H��a�x�x� � � ��6�!�9�d�G�Q��P�P���3�3����� � � � )8� )8� )8� )8� )8� )8� )8� )8� )8� �1�I�t�W�a��:� :���3�3� ���� � � � )8� )8� )8� )8� )8� )8� )8� )8� )8�
�1�I�t�W�a�� :� :���3�3� *�*N�O�O�O��C�H�H��t�C�H�O�O�O�O� �:�:�g� � � ��2�s�7�N��r� s
� B-F � Fc �& � d|d< | j |i |��S )aQ
Performs tanh-sinh quadrature. The call
quadts(func, *points, ...)
is simply a shortcut for:
quad(func, *points, ..., method=TanhSinh)
For example, a single integral and a double integral:
quadts(lambda x: exp(cos(x)), [0, 1])
quadts(lambda x, y: exp(cos(x+y)), [0, 1], [0, 1])
See the documentation for quad for information about how points
arguments and keyword arguments are parsed.
See documentation for TanhSinh for algorithmic information about
tanh-sinh quadrature.
r� r� �r� r� s r �quadtszQuadratureMethods.quadts� s% � �* '��x���s�x��(��(�(�(r c �& � d|d< | j |i |��S )a[
Performs Gauss-Legendre quadrature. The call
quadgl(func, *points, ...)
is simply a shortcut for:
quad(func, *points, ..., method=GaussLegendre)
For example, a single integral and a double integral:
quadgl(lambda x: exp(cos(x)), [0, 1])
quadgl(lambda x, y: exp(cos(x+y)), [0, 1], [0, 1])
See the documentation for quad for information about how points
arguments and keyword arguments are parsed.
See documentation for TanhSinh for algorithmic information about
tanh-sinh quadrature.
r� r� r� r� s r �quadglzQuadratureMethods.quadgl s% � �* ,��x���s�x��(��(�(�(r Nc � � ���� � � |� � \ }}� � |� � }� � |� � }|��g� d� � dk rt d� � �|� j k rH|� j k r=� � �|dg|���� � }� � �d|g|���� � } || z S |� j k rC�r!� � �fd�| | g�fd�� � S � � �fd�| | g|�� � � S |� j k rt d
� � ��s|r
d� j z |z ��fd ��d }
� � �| �|
� � g� � } � ��fd
�} | � � | |
� j g� � z
} | S )a4
Calculates
.. math ::
I = \int_a^b f(x) dx
where at least one of `a` and `b` is infinite and where
`f(x) = g(x) \cos(\omega x + \phi)` for some slowly
decreasing function `g(x)`. With proper input, :func:`~mpmath.quadosc`
can also handle oscillatory integrals where the oscillation
rate is different from a pure sine or cosine wave.
In the standard case when `|a| < \infty, b = \infty`,
:func:`~mpmath.quadosc` works by evaluating the infinite series
.. math ::
I = \int_a^{x_1} f(x) dx +
\sum_{k=1}^{\infty} \int_{x_k}^{x_{k+1}} f(x) dx
where `x_k` are consecutive zeros (alternatively
some other periodic reference point) of `f(x)`.
Accordingly, :func:`~mpmath.quadosc` requires information about the
zeros of `f(x)`. For a periodic function, you can specify
the zeros by either providing the angular frequency `\omega`
(*omega*) or the *period* `2 \pi/\omega`. In general, you can
specify the `n`-th zero by providing the *zeros* arguments.
Below is an example of each::
>>> from mpmath import *
>>> mp.dps = 15; mp.pretty = True
>>> f = lambda x: sin(3*x)/(x**2+1)
>>> quadosc(f, [0,inf], omega=3)
0.37833007080198
>>> quadosc(f, [0,inf], period=2*pi/3)
0.37833007080198
>>> quadosc(f, [0,inf], zeros=lambda n: pi*n/3)
0.37833007080198
>>> (ei(3)*exp(-3)-exp(3)*ei(-3))/2 # Computed by Mathematica
0.37833007080198
Note that *zeros* was specified to multiply `n` by the
*half-period*, not the full period. In theory, it does not matter
whether each partial integral is done over a half period or a full
period. However, if done over half-periods, the infinite series
passed to :func:`~mpmath.nsum` becomes an *alternating series* and this
typically makes the extrapolation much more efficient.
Here is an example of an integration over the entire real line,
and a half-infinite integration starting at `-\infty`::
>>> quadosc(lambda x: cos(x)/(1+x**2), [-inf, inf], omega=1)
1.15572734979092
>>> pi/e
1.15572734979092
>>> quadosc(lambda x: cos(x)/x**2, [-inf, -1], period=2*pi)
-0.0844109505595739
>>> cos(1)+si(1)-pi/2
-0.0844109505595738
Of course, the integrand may contain a complex exponential just as
well as a real sine or cosine::
>>> quadosc(lambda x: exp(3*j*x)/(1+x**2), [-inf,inf], omega=3)
(0.156410688228254 + 0.0j)
>>> pi/e**3
0.156410688228254
>>> quadosc(lambda x: exp(3*j*x)/(2+x+x**2), [-inf,inf], omega=3)
(0.00317486988463794 - 0.0447701735209082j)
>>> 2*pi/sqrt(7)/exp(3*(j+sqrt(7))/2)
(0.00317486988463794 - 0.0447701735209082j)
**Non-periodic functions**
If `f(x) = g(x) h(x)` for some function `h(x)` that is not
strictly periodic, *omega* or *period* might not work, and it might
be necessary to use *zeros*.
A notable exception can be made for Bessel functions which, though not
periodic, are "asymptotically periodic" in a sufficiently strong sense
that the sum extrapolation will work out::
>>> quadosc(j0, [0, inf], period=2*pi)
1.0
>>> quadosc(j1, [0, inf], period=2*pi)
1.0
More properly, one should provide the exact Bessel function zeros::
>>> j0zero = lambda n: findroot(j0, pi*(n-0.25))
>>> quadosc(j0, [0, inf], zeros=j0zero)
1.0
For an example where *zeros* becomes necessary, consider the
complete Fresnel integrals
.. math ::
\int_0^{\infty} \cos x^2\,dx = \int_0^{\infty} \sin x^2\,dx
= \sqrt{\frac{\pi}{8}}.
Although the integrands do not decrease in magnitude as
`x \to \infty`, the integrals are convergent since the oscillation
rate increases (causing consecutive periods to asymptotically
cancel out). These integrals are virtually impossible to calculate
to any kind of accuracy using standard quadrature rules. However,
if one provides the correct asymptotic distribution of zeros
(`x_n \sim \sqrt{n}`), :func:`~mpmath.quadosc` works::
>>> mp.dps = 30
>>> f = lambda x: cos(x**2)
>>> quadosc(f, [0,inf], zeros=lambda n:sqrt(pi*n))
0.626657068657750125603941321203
>>> f = lambda x: sin(x**2)
>>> quadosc(f, [0,inf], zeros=lambda n:sqrt(pi*n))
0.626657068657750125603941321203
>>> sqrt(pi/8)
0.626657068657750125603941321203
(Interestingly, these integrals can still be evaluated if one
places some other constant than `\pi` in the square root sign.)
In general, if `f(x) \sim g(x) \cos(h(x))`, the zeros follow
the inverse-function distribution `h^{-1}(x)`::
>>> mp.dps = 15
>>> f = lambda x: sin(exp(x))
>>> quadosc(f, [1,inf], zeros=lambda n: log(n))
-0.25024394235267
>>> pi/2-si(e)
-0.250243942352671
**Non-alternating functions**
If the integrand oscillates around a positive value, without
alternating signs, the extrapolation might fail. A simple trick
that sometimes works is to multiply or divide the frequency by 2::
>>> f = lambda x: 1/x**2+sin(x)/x**4
>>> quadosc(f, [1,inf], omega=1) # Bad
1.28642190869861
>>> quadosc(f, [1,inf], omega=0.5) # Perfect
1.28652953559617
>>> 1+(cos(1)+ci(1)+sin(1))/6
1.28652953559617
**Fast decay**
:func:`~mpmath.quadosc` is primarily useful for slowly decaying
integrands. If the integrand decreases exponentially or faster,
:func:`~mpmath.quad` will likely handle it without trouble (and generally be
much faster than :func:`~mpmath.quadosc`)::
>>> quadosc(lambda x: cos(x)/exp(x), [0, inf], omega=1)
0.5
>>> quad(lambda x: cos(x)/exp(x), [0, inf])
0.5
Nr z0must specify exactly one of omega, period, zerosr )�omega�zeros�periodc � �� �| � � S r r& �r( r] s �r rX z+QuadratureMethods.quadosc.<locals>.<lambda>� � �� �A�A�q�b�E�E� r c � �� �| � � S r r& )r� r� s �r rX z+QuadratureMethods.quadosc.<locals>.<lambda>� s �� �e�e�Q�B�i�i� r c � �� �| � � S r r& r� s �r rX z+QuadratureMethods.quadosc.<locals>.<lambda>� r� r )r� r� z1quadosc requires an infinite integration intervalc � �� | �z dz S )Nr r& )r� r� s �r rX z+QuadratureMethods.quadosc.<locals>.<lambda>� s �� �a��h�q�j� r r$ c �^ �� �� � �| � � �| dz � � g� � S )Nr$ )r� )r� r r] r� s ���r �termz'QuadratureMethods.quadosc.<locals>.term� s0 �� ��:�:�a�%�%��(�(�E�E�!�A�#�J�J�!7�8�8� 8r )
r� r+ �countrL r/ r0 �quadoscrz r� �nsum)
r r] �intervalr� r� r� r r �s1�s2r� �sr� s
`` `` r r� zQuadratureMethods.quadosc/ s� ����� �B �~�~�h�'�'���1� �K�K��N�N�� �K�K��N�N�� �6�5� !� '� '�� -� -�� 2� 2� �B�D� D�
D� ���=�=�Q�#�'�\�\����Q��A��e�5���P�P�B����Q��A��e�5���P�P�B���7�N� ���=�=��
X��{�{�>�>�>�>�Q�B��r�7�<O�<O�<O�<O�P�P�P��{�{�>�>�>�>�Q�B��r�7�%�PV�{�W�W�W� ���<�<� � P�Q�Q� Q�� )��
(��3�6��%� ��(�(�(�(�E�
�� �J�J�q�1�e�e�A�h�h�-� (� (�� 9� 9� 9� 9� 9� 9� 9� �S�X�X�d�Q���L�
)�
)�)���r c � � g }t t |� � dz
� � D ](}|� || ||dz f� � �)| j }| j } |�
d| j z }d}
|� � � } d| d< d| d< |�| j
}| j } | xj d z
c_ |�r4|� � � \ }
} | j ||
|gfi | ��\ }}|� d� � rt d
|
|
||� � ||k s|
|k r ||z
}| |z
} n�|
dz
}
|
|k r$|� d� � rt d � � |
| j k r|| j k rd}nP|
| j k rt |dz
d |z � � }n-|| j k rt |
dz d |
z � � }n |
||
z
d z z }|� |
|f� � |� ||f� � |��4| | _ n # | | _ w xY w|� d� � r|
|
fS |
S )
a?
Computes the integral of *f* over the interval or path specified
by *interval*, using :func:`~mpmath.quad` together with adaptive
subdivision of the interval.
This function gives an accurate answer for some integrals where
:func:`~mpmath.quad` fails::
>>> from mpmath import *
>>> mp.dps = 15; mp.pretty = True
>>> quad(lambda x: abs(sin(x)), [0, 2*pi])
3.99900894176779
>>> quadsubdiv(lambda x: abs(sin(x)), [0, 2*pi])
4.0
>>> quadsubdiv(sin, [0, 1000])
0.437620923709297
>>> quadsubdiv(lambda x: 1/(1+x**2), [-100, 100])
3.12159332021646
>>> quadsubdiv(lambda x: ceil(x), [0, 100])
5050.0
>>> quadsubdiv(lambda x: sin(x+exp(x)), [0,8])
0.347400172657248
The argument *maxintervals* can be set to limit the permissible
subdivision::
>>> quadsubdiv(lambda x: sin(x**2), [0,100], maxintervals=5, error=True)
(-5.40487904307774, 5.011)
>>> quadsubdiv(lambda x: sin(x**2), [0,100], maxintervals=100, error=True)
(0.631417921866934, 1.10101120134116e-17)
Subdivision does not guarantee a correct answer since, the error
estimate on subintervals may be inaccurate::
>>> quadsubdiv(lambda x: sech(10*x-2)**2 + sech(100*x-40)**4 + sech(1000*x-600)**6, [0,1], error=True)
(0.210802735500549, 1.0001111101e-17)
>>> mp.dps = 20
>>> quadsubdiv(lambda x: sech(10*x-2)**2 + sech(100*x-40)**4 + sech(1000*x-600)**6, [0,1], error=True)
(0.21080273550054927738, 2.200000001e-24)
The second answer is correct. We can get an accurate result at lower
precision by forcing a finer initial subdivision::
>>> mp.dps = 15
>>> quadsubdiv(lambda x: sech(10*x-2)**2 + sech(100*x-40)**4 + sech(1000*x-600)**6, linspace(0,1,5))
0.210802735500549
The following integral is too oscillatory for convergence, but we can get a
reasonable estimate::
>>> v, err = fp.quadsubdiv(lambda x: fp.sin(1/x), [0,1], error=True)
>>> round(v, 6), round(err, 6)
(0.504067, 1e-06)
>>> sin(1) - ci(1)
0.504067061906928
r$ NrH r Fr Tr� r� � subintervalz2warning: number of intervals exceeded maxintervalsr )�rangerI r1 rK r �copyr� �popr� r� rZ r0 rM r@ )r r] r� r} � maxintervalsr� �queuerb �total� total_errorr� � quad_argsr r r r� rc r� s r �
quadsubdivz QuadratureMethods.quadsubdiv� sp � �t ���s�8�}�}�Q��'�'� 7� 7�A� �L�L�(�1�+�x��!��}�5� 6� 6� 6� 6�����h� � � � ���=�L����K�K�M�M� � $� �)� � !� �'�� �;��7�(�C��x�� � �H�H��M�H�H��
)� �y�y�{�{���1�!���!�a��V�9�9�y�9�9���3��:�:�i�(�(� ;��-���1�c�:�:�:���9�9�� � 4� 4��Q�J�E� �3�&�K�K��Q�J�E� � �,�,����I�1F�1F�,� � R�S�S�S��S�W�H�}�}��c�g� � � ����s�w�h� � � ��!��Q�q�S�M�M����c�g� � � ��!��Q�q�S�M�M��� ��Q��!� �O���L�L�!�Q��(�(�(��L�L�!�Q��(�(�(�+ �
)�. �C�H�H��t�C�H�O�O�O�O� �:�:�g� � � ��6�K�<�'� '��6�Ms
�EG& �& G/)NNN)NN) rm rn ro r r� r� r� r� r� r& r r r� r� � s� � � � � � �'� '� '�l� l� l�\ )� )� )�0)� )� )�0A� A� A� A�Fe� e� e� e� e� er r� �__main__) r� �
libmp.backendr �objectr rr r� r� rm �doctest�testmodr& r r �<module>r� s �� � � � � "� "� "� "� "� "�|;� |;� |;� |;� |;�V� |;� |;� |;�~~� ~� ~� ~� ~�~� ~� ~� ~�BD� D� D� D� D�N� D� D� D�LL
� L
� L
� L
� L
�� L
� L
� L
�\ �z����N�N�N��G�O������ �r