^Mh FddlmZmZddlmZGddZGddeZGddeZGd d eZd Z dd Z dZ d S))array_namespacexp_size)cached_propertyc"eZdZdZddZddZdS)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 \/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/scipy/integrate/_rules/_base.pyestimatez Rule.estimateCs B"!c|||||}d}t||D] \}}||||||z }!|j||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 rrrest refined_esta_kb_ks restimate_errorzRule.estimate_errorfsuVmmAq!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|_dSN)rr s r__init__zFixedRule.__init__s rctr%r r&s rnodes_and_weightszFixedRule.nodes_and_weightss!!rrc |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 rrrnodesweightss rrzFixedRule.estimatesCH/w 7?%e,,DG Aq%$HHHrNr)rrr r!r'propertyr)rrrrr#r#sc%%N""X")I)I)I)I)I)Irr#cLeZdZdZdZedZedZddZdS) 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]) c0||_||_d|_dSr%)higherlowerr)r r2r3s rr'zNestedFixedRule.__init__s  rc6|j |jjStr%)r2r)r r&s rr)z!NestedFixedRule.nodes_and_weights"s ; ";0 0% %rc6|j |jjStr%)r3r)r r&s rlower_nodes_and_weightsz'NestedFixedRule.lower_nodes_and_weights)s : !:/ /% %rrc >|j\}}|j\}}|jt||_|j||gd} |j|| gd} |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)``. Nraxis)r)r6rrconcatrr+) r r rrrr,r- lower_nodes lower_weights error_nodes error_weightss rrzNestedFixedRule.estimate_error0sD/w%)%A" ] 7?%e,,DGgnne[%9nBB -'@qII w{{ aA{M4 Q Q   rNr) rrr r!r'r.r)r6rrrrr0r0sx%%N &&X& &&X& - - - - - - rr0cDeZdZdZdZedZedZdS)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) ct|D]&}t|tstd'||_d|_dS)Nzz8ProductNestedFixed.nodes_and_weights..s C C C4T #A & C C Crc(g|]}|jdSrIrJs rrLz8ProductNestedFixed.nodes_and_weights..s GGGt'*GGGrr8_cartesian_productrDrrprodr r,r-s rr)z$ProductNestedFixed.nodes_and_weightss" C C4? C C C   7?%e,,DG',, GGtGGG     g~rctd|jD}|jt||_|jtd|jDd}||fS)Nc(g|]}|jdSrHr6rKcubatures rrLz>ProductNestedFixed.lower_nodes_and_weights..s Q Q QXX -a 0 Q Q Qrc(g|]}|jdSrNrWrXs rrLz>ProductNestedFixed.lower_nodes_and_weights..s UUU1!4UUUrrPr8rQrTs rr6z*ProductNestedFixed.lower_nodes_and_weightss" Q Q Q Q Q   7?%e,,DG',, UUT_UUU     g~rN)rrr r!r'rr)r6rrrr@r@`sd))V_"_rr@ct|}|j|ddi}|||ddt |f}|S)NindexingijrPr8)rmeshgridreshapestacklen)arraysr arrays_ixresults rrRrRsU & !B V3d33I ZZ44r3v;;6G H HF MrNc#Ktzdz fdtjdD}fdtjdD}t|}t|}t|jdD]}||df||dffVdS)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]) NcVg|]%}||g&Srasarray)rKirsplit_atrs rrLz$_split_subregion..s2 G G GBJJ!hqk* + + G G GrrcVg|]%}||g&Srrh)rKrjrrkrs rrLz$_split_subregion..s2 H H HRZZ!ad+ , , H H Hr.)rrangeshaperR) rrrrkleftrighta_subb_subrjs ```` rrrs A  BEQ; G G G G G GU171:5F5F G G GD H H H H H HeAGAJ6G6G H H HE t $ $E u % %E 5;q> " "++AsFmU1c6]*****++rc6|j}|||}|||}|jdkr |dddf}|jd}t |} t |} || ks|| krt d|d| d| ||z } |dz| dzz|z} || |d|zz } || z}|| g|R}||dgdg|jdz zR}|||zd | }|S) NrOrPz@rule and function are of incompatible dimension, nodes havendim z,, while limit of integration has ndima_ndim=z , b_ndim=g?)dtyperfr)r9rt) rtastypendimrnrrCrSr_sum)r rr orig_nodes orig_weightsrr result_dtype rule_ndima_ndimb_ndimlengthsr,weight_scale_factorr-f_nodesweights_reshapedrs rr+r+sz7L:|44J99\<88L!4(  $I QZZF QZZFFi611=!*==#)==4:==>> >!eG !^# . 2E''''>>IM00GaooooGzz'B+L1#9I2J+L+LMM &&!G+!<& H HC Jrr%) scipy._lib._array_apirr functoolsrrr#r0r@rRrr+rrrrs=::::::::%%%%%%Q.Q.Q.Q.Q.Q.Q.Q.hXIXIXIXIXIXIXIXIvh h h h h ih h h VWWWWWWWWt++++2*****r