+
YjF ^ RI HtHt ^ RIHt ! R R4 t ! R R]4 t ! R R]4 t ! R R
]4 tR t RR
lt
R t R # ) )array_namespacexp_size)cached_propertyc 8 a ] tR t^t o RtRR ltRR ltRtV tR# )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 \ h)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 &&&&&]/home/luca/screen-checking/.venv/lib/python3.14/site-packages/scipy/integrate/_rules/_base.pyestimate
Rule.estimateC s B "! c V P WW44 p^ p\ W#4 F w rxW`P WW4 ,
pK V P P WV,
4 # )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 _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____classdictcell__
__classdict__s @r r r s :x!"F1. 1.r r c D a ] tR t^t o RtR t]R 4 tRR ltRt V t
R# ) 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 R V n R # Nr r s &r __init__FixedRule.__init__ s r c \ hr, r r. s &r nodes_and_weightsFixedRule.nodes_and_weights s !!r c V P w rVV P f \ V4 V n \ WW5WdV P 4 # )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)``.
)r2 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/ propertyr2 r r% r& r' s @r r* r* s0 %N " ")I )Ir r* c T a ] tR t^t o RtR t]R 4 t]R 4 tRR lt Rt
V t R# ) NestedFixedRuleab
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 , Wn W n R V n R # r, higherlowerr )r r> r? s &&&r r/ NestedFixedRule.__init__ s
r c V V P e V P P # \ hr, )r> r2 r
r. s &r r2 !NestedFixedRule.nodes_and_weights" s" ;; ";;00 0% %r c V V P e V P P # \ hr, )r? r2 r
r. s &r lower_nodes_and_weights'NestedFixedRule.lower_nodes_and_weights) s" :: !::// /% %r c R V P w rVV P w rxV P f \ V4 V n V P P WW.^ R7 p V P P Wh) .^ R7 p
V P P \
WW9WV P 4 4 # )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)``.
axis)r2 rD r r concatr r5 ) r r r
r r r6 r7 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/ r9 r2 rD r r% r& r' s @r r; r; sB %N
& & & & -
-
r r; c J a ] tR tRt o RtR t]R 4 t]R 4 tRt V t
R# )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 t V F$ p\ V\ 4 ' d K \ R 4 h Wn RV n R# )z
"sFmUc6]** #
F Fs =D
'D & D
'D-A D
c l VP pVP W74 pVP WG4 pVP ^8X d
VR, pVP R, p\ V4 p \ V4 p
W8w g W8w d \ RV RV RV
24 hW!,
p V^, V R, , V, p VP
WR7 ^V, , p
WM, pV ! V .VO5! pVP VR.^.VP ^,
, O54 pVP VV, ^ VR7 pV# ) z@rule and function are of incompatible dimension, nodes havendim z,, while limit of integration has ndima_ndim=z , b_ndim=g ?)dtype)rH rv ):NNNNrY ) rv astypendimrm r rS r[ re sum)r r
r
orig_nodes orig_weightsr r result_dtype rule_ndima_ndimb_ndimlengthsr6 weight_scale_factorr7 f_nodesweights_reshapedr s &&&&&&& r r5 r5 s5 77L:4J99\8L ! (
$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 rZ r r5 r r r r sV : %Q. Q.hXI XIvh
i h
VW W t+2*r