EiF S SK JrJr S SKJr " S S5 r " S S\5 r " S S\5 r " S S
\5 rS r SS
jr
S r g ) )array_namespacexp_size)cached_propertyc , \ rS rSrSrSS jrSS jrSrg)Rule a
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 [ e)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)selffabargss Y/home/mande/repo/quber/.venv/lib/python3.13/site-packages/scipy/integrate/_rules/_base.pyestimate
Rule.estimateC s B "! c U R XX45 nSn[ X#5 H u pxX`R XX5 -
nM U R R XV-
5 $ )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_ks r estimate_errorRule.estimate_errorf sV V mmA!* (.HC ==; ;K / ww{{3,--r Nr )__name__
__module__ __qualname____firstlineno____doc__r r __static_attributes__r r r r r s :x!"F1.r r c 8 \ rS rSrSrS r\S 5 rSS jrSr g) FixedRule a^
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 S U l g Nr r
s r __init__FixedRule.__init__ s r c [ er+ r r- s r nodes_and_weightsFixedRule.nodes_and_weights s !!r c U R u pVU R c [ U5 U l [ XX5XdU R 5 $ )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)``.
)r1 r r _apply_fixed_rule)r
r r r r nodesweightss r r FixedRule.estimate s< H // 77?%e,DG qHHr r, Nr )
r! r" r# r$ r% r. propertyr1 r r& r r r r( r( s' %N " ")Ir r( c H \ rS rSrSrS r\S 5 r\S 5 rS S jr Sr
g)
NestedFixedRule ab
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 * Xl X l S U l g r+ higherlowerr )r
r> r? s r r. NestedFixedRule.__init__ s
r c T U R b U R R $ [ er+ )r> r1 r r- s r r1 !NestedFixedRule.nodes_and_weights" s" ;; ";;00 0% %r c T U R b U R R $ [ er+ )r? r1 r r- s r lower_nodes_and_weights'NestedFixedRule.lower_nodes_and_weights) s" :: !::// /% %r c D U R u pVU R u pxU R c [ U5 U l U R R XW/SS9n U R R Xh* /SS9n
U R R [
XX9XU R 5 5 $ )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)``.
r axis)r1 rD r r concatr r4 ) r
r r r r r5 r6 lower_nodes
lower_weights error_nodes
error_weightss r r NestedFixedRule.estimate_error0 s D //%)%A%A" 77?%e,DGggnne%9nB '@qI
ww{{ aAM Q
r r= Nr ) r! r" r# r$ r% r. r8 r1 rD r r& r r r r: r: s: %N
& & & & -
r r: c > \ rS rSrSrS r\S 5 r\S 5 rSr g)ProductNestedFixedi` a
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 p U H# n[ U[ 5 ( a M [ S5 e Xl S U l g )Nz
"sFmUc6]** #
F Fs 0C C C . CAC c UR nUR X75 nUR XG5 nUR S:X a US S 2S 4 nUR S n[ U5 n [ U5 n
X:w d X:w a [ SU SU SU
35 eX!-
n US- U S- - U- n UR
XS9SU- - n
XM- nU " U /UQ76 nUR US/S/UR S-
- Q75 nUR UU- S US
9nU$ ) NrY rZ z@rule and function are of incompatible dimension, nodes havendim z,, while limit of integration has ndima_ndim=z , b_ndim=g ?)dtyperm r )rH rw ) rw astypendimro r rS r\ rf sum)r r r
orig_nodes orig_weightsr r result_dtype rule_ndima_ndimb_ndimlengthsr5 weight_scale_factorr6 f_nodesweights_reshapedr s r r4 r4 s9 77L:4J99\8L ! 4(
$I
QZF
QZFi 1 !!* ,##)()F8= > > eG !^#
. 2E ''''>I M0GooGzz'B+L1# 9I2J+LM
&&!G+!<&
HC Jr r+ ) scipy._lib._array_apir r functoolsr r r( r: rP r[ r r4 r r r r sV : %Q. Q.hXI XIvh
i h
VW W t+2*r