(phYSSKrSSKJrJr SSKJrJrJrJ r J r J r SSK J r SrSrSrS r"S S \5r"S S \5r"SS\5r"SS\5r"SS\5r"SS\5rg)N) OdeSolver DenseOutput)validate_max_step validate_tolselect_initial_stepnormwarn_extraneousvalidate_first_step)dop853_coefficientsg?皙? c DX8S'[[USSUSS5SS9HDun up[R"USU RU SU 5U-n U"XU--X,-5X'MF X$[R"USSRU5--n U"X-U 5nXS'X4$)aPerform a single Runge-Kutta step. This function computes a prediction of an explicit Runge-Kutta method and also estimates the error of a less accurate method. Notation for Butcher tableau is as in [1]_. Parameters ---------- fun : callable Right-hand side of the system. t : float Current time. y : ndarray, shape (n,) Current state. f : ndarray, shape (n,) Current value of the derivative, i.e., ``fun(x, y)``. h : float Step to use. A : ndarray, shape (n_stages, n_stages) Coefficients for combining previous RK stages to compute the next stage. For explicit methods the coefficients at and above the main diagonal are zeros. B : ndarray, shape (n_stages,) Coefficients for combining RK stages for computing the final prediction. C : ndarray, shape (n_stages,) Coefficients for incrementing time for consecutive RK stages. The value for the first stage is always zero. K : ndarray, shape (n_stages + 1, n) Storage array for putting RK stages here. Stages are stored in rows. The last row is a linear combination of the previous rows with coefficients Returns ------- y_new : ndarray, shape (n,) Solution at t + h computed with a higher accuracy. f_new : ndarray, shape (n,) Derivative ``fun(t + h, y_new)``. References ---------- .. [1] E. Hairer, S. P. Norsett G. Wanner, "Solving Ordinary Differential Equations I: Nonstiff Problems", Sec. II.4. rrNstart) enumeratezipnpdotT)funtyfhABCKsacdyy_newf_news J/var/www/html/venv/lib/python3.13/site-packages/scipy/integrate/_ivp/rk.pyrk_stepr(s^ aDs1QR5!AB%0: 6A VVAbqEGGQrU #a '11u9af%; BFF1Sb688Q'' 'E u E bE <c<^\rSrSr%Sr\r\R\ S'\r \R\ S'\r \R\ S'\r \R\ S'\r \R\ S'\r\\ S'\r\\ S '\r\\ S '\R$S S S S4U4SjjrSrSrSrSrSrU=r$) RungeKuttaJz,Base class for explicit Runge-Kutta methods.rrrEPordererror_estimator_ordern_stagesMbP?ư>FNc >[U 5 [T U] XX4USS9 SUl[ U5Ul[ XgUR5uUlUl URURUR5Ul U ci[URURURXEURURUR URUR5 UlO[%XU5Ul[&R("UR*S-UR4URR,S9UlSUR S-- UlSUlg)NT)support_complexrdtyper)r super__init__y_oldrmax_steprnrtolatolrrrrr directionr0h_absr remptyr1r7r error_exponent h_previous selfrt0y0t_boundr;r=r> vectorized first_step extraneous __class__s r'r9RungeKutta.__init__Us  # "z)-  / )(3 +D? 49$&&$&&)  ,$&&$&&'TVVT^^**DIItyyBDJ-ZWEDJ4==1,dff5TVV\\J D$>$>$BCr)c^[R"URUR5U-$N)rrrr-)rEr rs r'_estimate_errorRungeKutta._estimate_erroris vvacc466"Q&&r)c<[URX5U- 5$rO)r rP)rEr rscales r'_estimate_error_normRungeKutta._estimate_error_normlsD((.677r)c URnURnURnURnURnS[ R "[ R"XR[ R-5U- 5-nURU:aUnOURU:aUnO URnSnSn U(GdXv:aSUR4$XpR-n X-n URXR- -S:a URn X- n [ R "U 5n[URXURXR UR"UR$UR&5 upU[ R("[ R "U5[ R "U 55U--nUR+UR&X5nUS:aKUS:Xa[,nO#[/[,[0XR2--5nU (a [/SU5nUU-nSnO(U[5[6[0XR2--5-nSn U(dGMW UlX lW UlW UlXpl W Ulg)NrFrrT)TN)rrr;r=r>rabs nextafterr?infr@TOO_SMALL_STEPrHr(rrrrrr maximumrT MAX_FACTORminSAFETYrBmax MIN_FACTORrCr:)rErrr;r=r>min_stepr@ step_accepted step_rejectedrt_newr%r&rS error_normfactors r' _step_implRungeKutta._step_implos FF FF==yyyyr||A~~/FG!KLL :: E ZZ( "EJJE  d1111&AEE~~!56:  AFF1IE"488Q4661ff#'66466466;LE2::bffQi?$FFE224661DJA~?'F !'*8K8K*K!KMF! F^F $ Z#j4G4G&GGII $ E -H  r)cURRRUR5n[ UR UR URU5$rO)r rrr. RkDenseOutputt_oldrr:)rEQs r'_dense_output_implRungeKutta._dense_output_impls9 FFHHLL TZZQ??r)) r r>rBrr@rCr;r=rrr:)__name__ __module__ __qualname____firstlineno____doc__NotImplementedrrndarray__annotations__rrr-r.r/intr0r1rYr9rPrTrgrm__static_attributes__ __classcell__rLs@r'r+r+Js6"Arzz""Arzz""Arzz""Arzz""Arzz"E3!/3/"Hc"68ff% ('8AF@@r)r+c\rSrSrSrSrSrSr\R"/SQ5r \R"/SQ/SQ/SQ/5r \R"/S Q5r \R"/S Q5r \R"/S Q/S Q/S Q/SQ/5rSrg)RK23aExplicit Runge-Kutta method of order 3(2). This uses the Bogacki-Shampine pair of formulas [1]_. The error is controlled assuming accuracy of the second-order method, but steps are taken using the third-order accurate formula (local extrapolation is done). A cubic Hermite polynomial is used for the dense output. Can be applied in the complex domain. Parameters ---------- fun : callable Right-hand side of the system: the time derivative of the state ``y`` at time ``t``. The calling signature is ``fun(t, y)``, where ``t`` is a scalar and ``y`` is an ndarray with ``len(y) = len(y0)``. ``fun`` must return an array of the same shape as ``y``. See `vectorized` for more information. t0 : float Initial time. y0 : array_like, shape (n,) Initial state. t_bound : float Boundary time - the integration won't continue beyond it. It also determines the direction of the integration. first_step : float or None, optional Initial step size. Default is ``None`` which means that the algorithm should choose. max_step : float, optional Maximum allowed step size. Default is np.inf, i.e., the step size is not bounded and determined solely by the solver. rtol, atol : float and array_like, optional Relative and absolute tolerances. The solver keeps the local error estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a relative accuracy (number of correct digits), while `atol` controls absolute accuracy (number of correct decimal places). To achieve the desired `rtol`, set `atol` to be smaller than the smallest value that can be expected from ``rtol * abs(y)`` so that `rtol` dominates the allowable error. If `atol` is larger than ``rtol * abs(y)`` the number of correct digits is not guaranteed. Conversely, to achieve the desired `atol` set `rtol` such that ``rtol * abs(y)`` is always smaller than `atol`. If components of y have different scales, it might be beneficial to set different `atol` values for different components by passing array_like with shape (n,) for `atol`. Default values are 1e-3 for `rtol` and 1e-6 for `atol`. vectorized : bool, optional Whether `fun` may be called in a vectorized fashion. False (default) is recommended for this solver. If ``vectorized`` is False, `fun` will always be called with ``y`` of shape ``(n,)``, where ``n = len(y0)``. If ``vectorized`` is True, `fun` may be called with ``y`` of shape ``(n, k)``, where ``k`` is an integer. In this case, `fun` must behave such that ``fun(t, y)[:, i] == fun(t, y[:, i])`` (i.e. each column of the returned array is the time derivative of the state corresponding with a column of ``y``). Setting ``vectorized=True`` allows for faster finite difference approximation of the Jacobian by methods 'Radau' and 'BDF', but will result in slower execution for this solver. Attributes ---------- n : int Number of equations. status : string Current status of the solver: 'running', 'finished' or 'failed'. t_bound : float Boundary time. direction : float Integration direction: +1 or -1. t : float Current time. y : ndarray Current state. t_old : float Previous time. None if no steps were made yet. step_size : float Size of the last successful step. None if no steps were made yet. nfev : int Number evaluations of the system's right-hand side. njev : int Number of evaluations of the Jacobian. Is always 0 for this solver as it does not use the Jacobian. nlu : int Number of LU decompositions. Is always 0 for this solver. References ---------- .. [1] P. Bogacki, L.F. Shampine, "A 3(2) Pair of Runge-Kutta Formulas", Appl. Math. Lett. Vol. 2, No. 4. pp. 321-325, 1989. )r??)rrr)rrr)rrr)gqq?gUUUUUU?gqq?)grqDZ?gUUUUUUgqqg?)rgUUUUUUgrq?)rrgUUUUUU)rgUUUUUU?gqq)rrrNrorprqrrrsr/r0r1rarrayrrrr-r.rxrr)r'r|r|s[x EH A  A !A )*A $  Ar)r|c 2\rSrSrSrSrSrSr\R"/SQ5r \R"/SQ/SQ/S Q/S Q/S Q/S Q/5r \R"/S Q5r \R"/SQ5r \R"/SQ/SQ/SQ/SQ/SQ/SQ/SQ/5rSrg)RK45i%a Explicit Runge-Kutta method of order 5(4). This uses the Dormand-Prince pair of formulas [1]_. The error is controlled assuming accuracy of the fourth-order method accuracy, but steps are taken using the fifth-order accurate formula (local extrapolation is done). A quartic interpolation polynomial is used for the dense output [2]_. Can be applied in the complex domain. Parameters ---------- fun : callable Right-hand side of the system. The calling signature is ``fun(t, y)``. Here ``t`` is a scalar, and there are two options for the ndarray ``y``: It can either have shape (n,); then ``fun`` must return array_like with shape (n,). Alternatively it can have shape (n, k); then ``fun`` must return an array_like with shape (n, k), i.e., each column corresponds to a single column in ``y``. The choice between the two options is determined by `vectorized` argument (see below). t0 : float Initial time. y0 : array_like, shape (n,) Initial state. t_bound : float Boundary time - the integration won't continue beyond it. It also determines the direction of the integration. first_step : float or None, optional Initial step size. Default is ``None`` which means that the algorithm should choose. max_step : float, optional Maximum allowed step size. Default is np.inf, i.e., the step size is not bounded and determined solely by the solver. rtol, atol : float and array_like, optional Relative and absolute tolerances. The solver keeps the local error estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a relative accuracy (number of correct digits), while `atol` controls absolute accuracy (number of correct decimal places). To achieve the desired `rtol`, set `atol` to be smaller than the smallest value that can be expected from ``rtol * abs(y)`` so that `rtol` dominates the allowable error. If `atol` is larger than ``rtol * abs(y)`` the number of correct digits is not guaranteed. Conversely, to achieve the desired `atol` set `rtol` such that ``rtol * abs(y)`` is always smaller than `atol`. If components of y have different scales, it might be beneficial to set different `atol` values for different components by passing array_like with shape (n,) for `atol`. Default values are 1e-3 for `rtol` and 1e-6 for `atol`. vectorized : bool, optional Whether `fun` is implemented in a vectorized fashion. Default is False. Attributes ---------- n : int Number of equations. status : string Current status of the solver: 'running', 'finished' or 'failed'. t_bound : float Boundary time. direction : float Integration direction: +1 or -1. t : float Current time. y : ndarray Current state. t_old : float Previous time. None if no steps were made yet. step_size : float Size of the last successful step. None if no steps were made yet. nfev : int Number evaluations of the system's right-hand side. njev : int Number of evaluations of the Jacobian. Is always 0 for this solver as it does not use the Jacobian. nlu : int Number of LU decompositions. Is always 0 for this solver. References ---------- .. [1] J. R. Dormand, P. J. Prince, "A family of embedded Runge-Kutta formulae", Journal of Computational and Applied Mathematics, Vol. 6, No. 1, pp. 19-26, 1980. .. [2] L. W. Shampine, "Some Practical Runge-Kutta Formulas", Mathematics of Computation,, Vol. 46, No. 173, pp. 135-150, 1986. )rr g333333?g?gqq?r)rrrrr)r rrrr)g333333?g?rrr)gII?g gqq @rr)gq@g 1'gR<6R#@gE3ҿr)g+@g>%gr!@gE]t?g/pѿ)gUUUUUU?rgVI?gUUUUU?gϡԿg1 0 ?)g2TrgĿ UZkq?ggX ?g{tg?)rg# !gJ<@gFC)rrrr)rgF@gFj'NgDg@)rgdD gaP#$@g 2)rg `_. Nrr2r3Fc >[T U]"XX4XVUX4 0U D6 [R"[R UR 4URRS9Ul URSURS-Ul g)Nr6r) r8r9rrAr N_STAGES_EXTENDEDr<rr7 K_extendedr1r rDs r'r9DOP853.__init__sr "xt# ?3= ?(($7$I$I$(FF$,3766<<A!3$--!"34r)c[R"URUR5n[R"URUR5n[R "[R "U5S[R "U5-5n[R"U5nUS:n[R "X75XW- Xg'X#-U-$)Ng?r)rrrE5E3hypotrW ones_like)rEr rerr5err3denomcorrection_factormasks r'rPDOP853._estimate_errorsvvacc477#vvacc477#sRVVD\'9:LL.qy"$&&"4u{"Bx+++r)c[R"URUR5U- n[R"URUR5U- n[R R U5S-n[R R U5S-nUS:XaUS:XagUSU--n[R"U5U-[R"U[U5-5- $)Nrrgg{Gz?) rrrrrlinalgr rWsqrtlen) rEr rrSrr err5_norm_2 err3_norm_2rs r'rTDOP853._estimate_error_normsvvacc477#e+vvacc477#e+iinnT*A- iinnT*A- !  q 0d[00vvay;&U1C)DDDr)c URnURn[[URUR 5UR S-S9HbunupE[R"USURUSU5U-nURURXR--URU-5X'Md [R"[RUR 4URR"S9nUSnUR$UR- n XS'X(-U - US'SU -X R&U--- US'U[R"UR(U5-USS&[+URUR,URU5$)Nrrr6rrr~)rrCrrA_EXTRAC_EXTRAr1rrrrrkr:rAr INTERPOLATOR_POWERr<r7rrDDop853DenseOutputr) rEr rr!r"r#r$Ff_olddelta_ys r'rmDOP853._dense_output_implsL OO OO"3t||T\\#B)-):[TU]X5 X!- UlX@lURSS- UlX0lg)Nr)r8r9rrlshaper/r:)rErkrr:rlrLs r'r9RkDenseOutput.__init__)s6 "WWQZ!^  r)c XR- UR- nURS:Xa:[R"X R S-5n[R "U5nO:[R"X R S-S45n[R "USS9nUR[R"URU5-nURS:XaX@RSS2S4- nU$X@R- nU$)Nrr)axisr) rkrndimrtiler/cumprodrrlr:)rErxprs r' _call_implRkDenseOutput._call_impl0s ^tvv % 66Q;::>*A 1 AJJNA./A 11%A FFRVVDFFA& & 66Q; AtG$ $A OAr))rlrr/r:rorprqrrr9rrxryrzs@r'rjrj(sr)rjc.^\rSrSrU4SjrSrSrU=r$)riAcN>[TU]X5 X!- UlX@lX0lgrO)r8r9rrr:)rErkrr:rrLs r'r9Dop853DenseOutput.__init__Bs# " r)cXR- UR- nURS:Xa![R"UR 5nOPUSS2S4n[R "[U5[UR 54UR RS9n[[UR55H upEX5- nUS-S:XaX2-nMUSU- -nM" X0R - nUR$)Nrr6rr) rkrrr zeros_liker:zerosrr7rreversedrr)rErrrirs r'rDop853DenseOutput._call_implHs ^tvv % 66Q; djj)A!T' A#a&#djj/2$**:J:JKAhtvv./DA FA1uzQU  0 ZZss r))rrr:rrzs@r'rrAs r)r)numpyrbaserrcommonrrrr r r r r^r`r\r(r+r|rrrjrrr)r'rs(AA!    9xj@j@Zk:k\oI:oIdNDZNDbK2 r)