Q(h FddlmZmZddlmZGddZGddeZGddeZGd d eZd Z dd Z dZ y ))array_namespacexp_size)cached_propertyc eZdZdZddZddZy)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]]) ct)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 Z/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/scipy/integrate/_rules/_base.pyestimatez Rule.estimateCs B"!c|j||||}d}t||D]\}}||j||||z }|jj||z 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 rrest refined_esta_kb_ks restimate_errorzRule.estimate_errorfskVmmAq!T* (A. >> 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] cd|_yN)rr s r__init__zFixedRule.__init__s rctr%r r&s rnodes_and_weightszFixedRule.nodes_and_weightss!!rc |j\}}|jt||_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)``. )r)rr_apply_fixed_rule)r r r rrnodesweightss rrzFixedRule.estimatesDH//w 77?%e,DG Aq%$HHrNr)rrr r!r'propertyr)rrrrr#r#s'%N"")Irr#c>eZdZdZdZedZedZddZy)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.||_||_d|_yr%)higherlowerr)r r2r3s rr'zNestedFixedRule.__init__s  rcR|j|jjStr%)r2r)r r&s rr)z!NestedFixedRule.nodes_and_weights"s" ;; ";;00 0% %rcR|j|jjStr%)r3r)r r&s rlower_nodes_and_weightsz'NestedFixedRule.lower_nodes_and_weights)s" :: !::// /% %rc \|j\}}|j\}}|jt||_|jj ||gd} |jj || gd} |jj t |||| | ||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)``. raxis)r)r6rrconcatrr+) r r r rrr,r- lower_nodes lower_weights error_nodes error_weightss rrzNestedFixedRule.estimate_error0sD//w%)%A%A" ] 77?%e,DGggnne[%9nB -'@qI ww{{ aA{M4 Q  rNr) rrr r!r'r.r)r6rrrrr0r0s:%N && && - rr0c6eZdZdZdZedZedZy)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) cd|D]}t|trtd||_d|_y)Nz "+AsFmU1c6]**+ H Hs1C CC/ CACc |j}|j||}|j||}|jdk(r |dddf}|jd}t |} t |} || k7s|| k7rt d|d| d| ||z } |dz| dzz|z} |j | |d|zz } || z}|| g|}|j|dgdg|jdz z}|j||zd | }|S) NrHrIz@rule and function are of incompatible dimension, nodes havendim z,, while limit of integration has ndima_ndim=z , b_ndim=g?)dtyperZr)r9re) reastypendimr\rrCrKrSsum)r r r orig_nodes orig_weightsrr result_dtype rule_ndima_ndimb_ndimlengthsr,weight_scale_factorr-f_nodesweights_reshapedrs rr+r+sH77L:|4J99\<8L!4(   $I QZF QZFFi61!!* ,##)()F8=> >!eG !^# . 2E''''>IM00GooGzz'B+L1#9I2J+LM &&!G+!<& HC Jrr%) scipy._lib._array_apirr functoolsrrr#r0r@rJrr+rrrrusV:%Q.Q.hXIXIvh ih VWWt+2*r