o
h F @ sx d dl mZmZ d dlmZ G dd dZG dd deZG dd deZG d d
d
eZd d Z dddZ
dd Z d
S ) )array_namespacexp_size)cached_propertyc @ s$ e Zd ZdZdddZdddZdS ) Rulea
Base class for numerical integration algorithms (cubatures).
Finds an estimate for the integral of ``f`` over the region described by two arrays
``a`` and ``b`` via `estimate`, and find an estimate for the error of this
approximation via `estimate_error`.
If a subclass does not implement its own `estimate_error`, then it will use a
default error estimate based on the difference between the estimate over the whole
region and the sum of estimates over that region divided into ``2^ndim`` subregions.
See Also
--------
FixedRule
Examples
--------
In the following, a custom rule is created which uses 3D Genz-Malik cubature for
the estimate of the integral, and the difference between this estimate and a less
accurate estimate using 5-node Gauss-Legendre quadrature as an estimate for the
error.
>>> import numpy as np
>>> from scipy.integrate import cubature
>>> from scipy.integrate._rules import (
... Rule, ProductNestedFixed, GenzMalikCubature, GaussLegendreQuadrature
... )
>>> def f(x, r, alphas):
... # f(x) = cos(2*pi*r + alpha @ x)
... # Need to allow r and alphas to be arbitrary shape
... npoints, ndim = x.shape[0], x.shape[-1]
... alphas_reshaped = alphas[np.newaxis, :]
... x_reshaped = x.reshape(npoints, *([1]*(len(alphas.shape) - 1)), ndim)
... return np.cos(2*np.pi*r + np.sum(alphas_reshaped * x_reshaped, axis=-1))
>>> genz = GenzMalikCubature(ndim=3)
>>> gauss = GaussKronrodQuadrature(npoints=21)
>>> # Gauss-Kronrod is 1D, so we find the 3D product rule:
>>> gauss_3d = ProductNestedFixed([gauss, gauss, gauss])
>>> class CustomRule(Rule):
... def estimate(self, f, a, b, args=()):
... return genz.estimate(f, a, b, args)
... def estimate_error(self, f, a, b, args=()):
... return np.abs(
... genz.estimate(f, a, b, args)
... - gauss_3d.estimate(f, a, b, args)
... )
>>> rng = np.random.default_rng()
>>> res = cubature(
... f=f,
... a=np.array([0, 0, 0]),
... b=np.array([1, 1, 1]),
... rule=CustomRule(),
... args=(rng.random((2,)), rng.random((3, 2, 3)))
... )
>>> res.estimate
array([[-0.95179502, 0.12444608],
[-0.96247411, 0.60866385],
[-0.97360014, 0.25515587]])
c C t )a
Calculate estimate of integral of `f` in rectangular region described by
corners `a` and ``b``.
Parameters
----------
f : callable
Function to integrate. `f` must have the signature::
f(x : ndarray, \*args) -> ndarray
`f` should accept arrays ``x`` of shape::
(npoints, ndim)
and output arrays of shape::
(npoints, output_dim_1, ..., output_dim_n)
In this case, `estimate` will return arrays of shape::
(output_dim_1, ..., output_dim_n)
a, b : ndarray
Lower and upper limits of integration as rank-1 arrays specifying the left
and right endpoints of the intervals being integrated over. Infinite limits
are currently not supported.
args : tuple, optional
Additional positional args passed to ``f``, if any.
Returns
-------
est : ndarray
Result of estimation. If `f` returns arrays of shape ``(npoints,
output_dim_1, ..., output_dim_n)``, then `est` will be of shape
``(output_dim_1, ..., output_dim_n)``.
NotImplementedError)selffabargsr r P/var/www/vscode/kcb/lib/python3.10/site-packages/scipy/integrate/_rules/_base.pyestimateC s !z
Rule.estimatec C sL | ||||}d}t||D ]\}}|| ||||7 }q| j|| S )a-
Estimate the error of the approximation for the integral of `f` in rectangular
region described by corners `a` and `b`.
If a subclass does not override this method, then a default error estimator is
used. This estimates the error as ``|est - refined_est|`` where ``est`` is
``estimate(f, a, b)`` and ``refined_est`` is the sum of
``estimate(f, a_k, b_k)`` where ``a_k, b_k`` are the coordinates of each
subregion of the region described by ``a`` and ``b``. In the 1D case, this
is equivalent to comparing the integral over an entire interval ``[a, b]`` to
the sum of the integrals over the left and right subintervals, ``[a, (a+b)/2]``
and ``[(a+b)/2, b]``.
Parameters
----------
f : callable
Function to estimate error for. `f` must have the signature::
f(x : ndarray, \*args) -> ndarray
`f` should accept arrays `x` of shape::
(npoints, ndim)
and output arrays of shape::
(npoints, output_dim_1, ..., output_dim_n)
In this case, `estimate` will return arrays of shape::
(output_dim_1, ..., output_dim_n)
a, b : ndarray
Lower and upper limits of integration as rank-1 arrays specifying the left
and right endpoints of the intervals being integrated over. Infinite limits
are currently not supported.
args : tuple, optional
Additional positional args passed to `f`, if any.
Returns
-------
err_est : ndarray
Result of error estimation. If `f` returns arrays of shape
``(npoints, output_dim_1, ..., output_dim_n)``, then `est` will be
of shape ``(output_dim_1, ..., output_dim_n)``.
r )r _split_subregionxpabs) r
r r r
r est refined_esta_kb_kr r r estimate_errorf s
+zRule.estimate_errorNr )__name__
__module__ __qualname____doc__r r r r r r r s
<#r c @ s. e Zd ZdZdd Zedd Zd
ddZd S ) FixedRulea
A rule implemented as the weighted sum of function evaluations at fixed nodes.
Attributes
----------
nodes_and_weights : (ndarray, ndarray)
A tuple ``(nodes, weights)`` of nodes at which to evaluate ``f`` and the
corresponding weights. ``nodes`` should be of shape ``(num_nodes,)`` for 1D
cubature rules (quadratures) and more generally for N-D cubature rules, it
should be of shape ``(num_nodes, ndim)``. ``weights`` should be of shape
``(num_nodes,)``. The nodes and weights should be for integrals over
:math:`[-1, 1]^n`.
See Also
--------
GaussLegendreQuadrature, GaussKronrodQuadrature, GenzMalikCubature
Examples
--------
Implementing Simpson's 1/3 rule:
>>> import numpy as np
>>> from scipy.integrate._rules import FixedRule
>>> class SimpsonsQuad(FixedRule):
... @property
... def nodes_and_weights(self):
... nodes = np.array([-1, 0, 1])
... weights = np.array([1/3, 4/3, 1/3])
... return (nodes, weights)
>>> rule = SimpsonsQuad()
>>> rule.estimate(
... f=lambda x: x**2,
... a=np.array([0]),
... b=np.array([1]),
... )
[0.3333333]
c C s
d | _ d S N)r r
r r r __init__ s
zFixedRule.__init__c C r r r r r r r nodes_and_weights s zFixedRule.nodes_and_weightsr c C s4 | j \}}| jdu rt|| _t||||||| jS )aM
Calculate estimate of integral of `f` in rectangular region described by
corners `a` and `b` as ``sum(weights * f(nodes))``.
Nodes and weights will automatically be adjusted from calculating integrals over
:math:`[-1, 1]^n` to :math:`[a, b]^n`.
Parameters
----------
f : callable
Function to integrate. `f` must have the signature::
f(x : ndarray, \*args) -> ndarray
`f` should accept arrays `x` of shape::
(npoints, ndim)
and output arrays of shape::
(npoints, output_dim_1, ..., output_dim_n)
In this case, `estimate` will return arrays of shape::
(output_dim_1, ..., output_dim_n)
a, b : ndarray
Lower and upper limits of integration as rank-1 arrays specifying the left
and right endpoints of the intervals being integrated over. Infinite limits
are currently not supported.
args : tuple, optional
Additional positional args passed to `f`, if any.
Returns
-------
est : ndarray
Result of estimation. If `f` returns arrays of shape ``(npoints,
output_dim_1, ..., output_dim_n)``, then `est` will be of shape
``(output_dim_1, ..., output_dim_n)``.
N)r" r r _apply_fixed_rule)r
r r r
r nodesweightsr r r r s
$
zFixedRule.estimateNr )r r r r r! propertyr" r r r r r r s '
r c @ s: e Zd ZdZdd Zedd Zedd Zd d d
Zd S )
NestedFixedRulea
A cubature rule with error estimate given by the difference between two underlying
fixed rules.
If constructed as ``NestedFixedRule(higher, lower)``, this will use::
estimate(f, a, b) := higher.estimate(f, a, b)
estimate_error(f, a, b) := \|higher.estimate(f, a, b) - lower.estimate(f, a, b)|
(where the absolute value is taken elementwise).
Attributes
----------
higher : Rule
Higher accuracy rule.
lower : Rule
Lower accuracy rule.
See Also
--------
GaussKronrodQuadrature
Examples
--------
>>> from scipy.integrate import cubature
>>> from scipy.integrate._rules import (
... GaussLegendreQuadrature, NestedFixedRule, ProductNestedFixed
... )
>>> higher = GaussLegendreQuadrature(10)
>>> lower = GaussLegendreQuadrature(5)
>>> rule = NestedFixedRule(
... higher,
... lower
... )
>>> rule_2d = ProductNestedFixed([rule, rule])
c C s || _ || _d | _d S r )higherlowerr )r
r( r) r r r r! s
zNestedFixedRule.__init__c C | j d ur | j jS tr )r( r" r r r r r r" "
z!NestedFixedRule.nodes_and_weightsc C r* r )r) r" r r r r r lower_nodes_and_weights) r+ z'NestedFixedRule.lower_nodes_and_weightsr c
C sp | j \}}| j\}}| jdu rt|| _| jj||gdd} | jj|| gdd}
| jt|||| |
|| jS )a
Estimate the error of the approximation for the integral of `f` in rectangular
region described by corners `a` and `b`.
Parameters
----------
f : callable
Function to estimate error for. `f` must have the signature::
f(x : ndarray, \*args) -> ndarray
`f` should accept arrays `x` of shape::
(npoints, ndim)
and output arrays of shape::
(npoints, output_dim_1, ..., output_dim_n)
In this case, `estimate` will return arrays of shape::
(output_dim_1, ..., output_dim_n)
a, b : ndarray
Lower and upper limits of integration as rank-1 arrays specifying the left
and right endpoints of the intervals being integrated over. Infinite limits
are currently not supported.
args : tuple, optional
Additional positional args passed to `f`, if any.
Returns
-------
err_est : ndarray
Result of error estimation. If `f` returns arrays of shape
``(npoints, output_dim_1, ..., output_dim_n)``, then `est` will be
of shape ``(output_dim_1, ..., output_dim_n)``.
Nr axis)r" r, r r concatr r# ) r
r r r
r r$ r% lower_nodes
lower_weights error_nodes
error_weightsr r r r 0 s
"
z NestedFixedRule.estimate_errorNr ) r r r r r! r& r" r, r r r r r r' s '
r' c @ s0 e Zd ZdZdd Zedd Zedd ZdS ) ProductNestedFixeda`
Find the n-dimensional cubature rule constructed from the Cartesian product of 1-D
`NestedFixedRule` quadrature rules.
Given a list of N 1-dimensional quadrature rules which support error estimation
using NestedFixedRule, this will find the N-dimensional cubature rule obtained by
taking the Cartesian product of their nodes, and estimating the error by taking the
difference with a lower-accuracy N-dimensional cubature rule obtained using the
``.lower_nodes_and_weights`` rule in each of the base 1-dimensional rules.
Parameters
----------
base_rules : list of NestedFixedRule
List of base 1-dimensional `NestedFixedRule` quadrature rules.
Attributes
----------
base_rules : list of NestedFixedRule
List of base 1-dimensional `NestedFixedRule` qudarature rules.
Examples
--------
Evaluate a 2D integral by taking the product of two 1D rules:
>>> import numpy as np
>>> from scipy.integrate import cubature
>>> from scipy.integrate._rules import (
... ProductNestedFixed, GaussKronrodQuadrature
... )
>>> def f(x):
... # f(x) = cos(x_1) + cos(x_2)
... return np.sum(np.cos(x), axis=-1)
>>> rule = ProductNestedFixed(
... [GaussKronrodQuadrature(15), GaussKronrodQuadrature(15)]
... ) # Use 15-point Gauss-Kronrod, which implements NestedFixedRule
>>> a, b = np.array([0, 0]), np.array([1, 1])
>>> rule.estimate(f, a, b) # True value 2*sin(1), approximately 1.6829
np.float64(1.682941969615793)
>>> rule.estimate_error(f, a, b)
np.float64(2.220446049250313e-16)
c C s, |D ] }t |ts
tdq|| _d | _d S )Nz z8ProductNestedFixed.nodes_and_weights..c S r: r< r= r r r r? r@ r- _cartesian_productr7 r r prodr
r$ r% r r r r"
z$ProductNestedFixed.nodes_and_weightsc C r9 )Nc S r: r; r, r> cubaturer r r r? r@ z>ProductNestedFixed.lower_nodes_and_weights..c S r: rA rI rJ r r r r? r@ rC r- rD rG r r r r, rH z*ProductNestedFixed.lower_nodes_and_weightsN)r r r r r! r r" r, r r r r r4 ` s +
r4 c C s: t | }|j| ddi}||j|dddt| f}|S )NindexingijrC r- )r meshgridreshapestacklen)arraysr arrays_ixresultr r r rE s rE Nc # s t du r d fddt jd D }fddtjd D }t|}t|}t|jd D ]}||df ||df fV q?dS )a
Given the coordinates of a region like a=[0, 0] and b=[1, 1], yield the coordinates
of all subregions, which in this case would be::
([0, 0], [1/2, 1/2]),
([0, 1/2], [1/2, 1]),
([1/2, 0], [1, 1/2]),
([1/2, 1/2], [1, 1])
N c s" g | ]
} | | gqS r asarrayr> i)r split_atr r r r? " z$_split_subregion..r c s" g | ]
} | | gqS r rV rX )r
rZ r r r r? r[ .)r rangeshaperE ) r r
r rZ leftrighta_subb_subrY r )r r
rZ r r r s
r c C s |j }|||}|||}|jdkr |d d d f }|jd }t|} t|}
|| ks1||
kr>td| d| d|
|| } |d | d | } |j| |dd| }
||
}| | g|R }||dgdg|jd R }|j|| d |d
}|S ) NrB rC z@rule and function are of incompatible dimension, nodes havendim z,, while limit of integration has ndima_ndim=z , b_ndim=g ?)dtyperU r )r. rb ) rb astypendimr] r r6 rF rO sum)r r r
orig_nodes orig_weightsr r result_dtype rule_ndima_ndimb_ndimlengthsr$ weight_scale_factorr% f_nodesweights_reshapedr r r r r# s0
r# r ) scipy._lib._array_apir r functoolsr r r r' r4 rE r r# r r r r s [kZ