+ LV-jY^RIt^RIHtHt^RIHtHtHtH t H t H t ^RI H t RtRt^ tRt!RR ]4t!R R ]4t!R R ]4t!RR]4t!RR]4t!RR]4tR#)N) OdeSolver DenseOutput)validate_max_step validate_tolselect_initial_stepnormwarn_extraneousvalidate_first_step)dop853_coefficientsg?皙?c W8^&\\VR,VR,4^R7FTwp wr\P!VRV PV RV 4V,p V!WV,,W,,4W&KV W$\P!VRRPV4,,p V!W,V 4pWR&W3#)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. :NNstartN) enumeratezipnpdotT)funtyfhABCKsacdyy_newf_news&&&&&&&&& h/Volumes/fast/ai/experiments/ui-tars-smoke/.venv/lib/python3.14/site-packages/scipy/integrate/_ivp/rk.pyrk_stepr's^ aDs1R5!B%0: 6A VVAbqEGGQrU #a '11u9af%; BFF1Sb688Q'' 'E u E bE <caa]tRt^JtoRt]t]t]t]t ]t ]t ]t ]t ]PRRRR3V3RlltRtRtR tR tV3R ltR tVtV;t#) RungeKuttaz,Base class for explicit Runge-Kutta methods.MbP?ư>FNc <\V 4\S V` WW4VRR7RVn\ V4Vn\ WgVP4wVnVn VPVPVP4Vn V fj\VPVPVPWEVPVPVP VPVP4 VnM\%WV4Vn\&P(!VP*^,VP3VPP,R7VnRVP ^,, VnRVnR#)T)support_complexNdtyper)r super__init__y_oldrmax_steprnrtolatolrrrrr directionerror_estimator_orderh_absr remptyn_stagesr0rerror_exponent h_previous selfrt0y0t_boundr4r6r7 vectorized first_step extraneous __class__s &&&&&&&&&&,r&r2RungeKutta.__init__Us  # "z)-  / )(3 +D? 49$&&$&&)  ,$&&$&&'TVVT^^**DIItyyBDJ-ZWEDJ4==1,dff5TVV\\J D$>$>$BCr(cf\P!VPVP4V,#N)rrrE)r@rrs&&&r&_estimate_errorRungeKutta._estimate_erroris vvacc466"Q&&r(cD\VPW4V, 4#rJ)rrL)r@rrscales&&&&r&_estimate_error_normRungeKutta._estimate_error_normlsD((.677r(c VPpVPpVPpVPpVPp^ \ P !\ P!WP\ P,4V, 4,pVPV8dTpM VPV8dTpM VPpRpRp V'EgWv8dRVP3#WpP,p W,p VPWP, ,^8d VPp W, p \ P !V 4p\VPWVPWP VP"VP$VP&4 wrV\ P(!\ P !V4\ P !V 44V,,pVP+VP&W4pV^8d\V^8Xd\,pM+\/\,\0WP2,,4pV 'd \/^V4pVV,pRpEKV\5\6\0WP2,,4,pRp EKX VnW nX VnX VnWpn X VnR#) FT)TN)rrr4r6r7rabs nextafterr8infr:TOO_SMALL_STEPrCr'rrrrrrmaximumrP MAX_FACTORminSAFETYr=max MIN_FACTORr>r3)r@rrr4r6r7min_stepr: step_accepted step_rejectedrt_newr$r%rO 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 $   r(cVPPPVP4p\ VP VP VPV4#rJ)rrrP RkDenseOutputt_oldrr3)r@Qs& r&_dense_output_implRungeKutta._dense_output_impls9 FFHHLL TZZQ??r(c<V^8dQh/S[P;R&S[P;R&S[P;R&S[P;R&S[P;R&S[;R&S[;R&S[;R&#) rrrrKrgorderr9r<)rndarrayint)format __classdict__s"r& __annotate__RungeKutta.__annotate__Js zz" zz" zz"   zz"   zz"  /"r() rr7r=rr:r>r4r6rrr3)__name__ __module__ __qualname____firstlineno____doc__NotImplementedrrrrKrgror9r<rrVr2rLrPrdrk__annotate_func____static_attributes____classdictcell__ __classcell__rGrss@@r&r*r*Jsf6"A"A"A"A"AE!/"H68ff% ('8AF@Qr(r*c]tRt^tRt^t^t^t]P!.RO4t ]P!.RO.RO.RO.4t ]P!.RO4t ]P!.R O4t ]P!.R O.R O.R O.R O.4tRtR#)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. N)r??)rrr)rrr)rrr)gqq?gUUUUUU?gqq?)grqDZ?gUUUUUUgqqg?)rgUUUUUUgrq?)rrgUUUUUU)rgUUUUUU?gqq)rrrrvrwrxryrzror9r<rarrayrrrrKrgr}rr(r&rrs[x EH A  A !A )*A $  Ar(rc 4]tRtRtRt^t^t^t]P!.RO4t ]P!.RO.RO.RO.R O.R O.R O.4t ]P!.R O4t ]P!.R O4t ]P!.RO.RO.RO.RO.RO.RO.RO.4tRtR#)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. rN)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 `_. Nr+r,Fc <\S V`!WW4WVVW3 /V B\P!\P VP 3VPPR7Vn VPRVP^,Vn R#)r/N) r1r2rr;r N_STAGES_EXTENDEDr5rr0 K_extendedr<rr?s &&&&&&&&&&,r&r2DOP853.__init__sr "xt# ?3= ?(($7$I$I$(FF$,3766<<A!3$--!"34r(c\P!VPVP4p\P!VPVP4p\P !\P !V4R\P !V4,4p\P!V4pV^8p\P !W7,4WW,, Wg&W#,V,#)g?)rrrE5E3hypotrT ones_like)r@rrerr5err3denomcorrection_factormasks&&& r&rLDOP853._estimate_errorsvvacc477#vvacc477#sRVVD\'9:LL.qy"$&&"4u{"Bx+++r(c2\P!VPVP4V, p\P!VPVP4V, p\P P V4^,p\P P V4^,pV^8Xd V^8XdR#VRV,,p\P!V4V,\P!V\V4,4, #)rngg{Gz?) rrrrrlinalgrrTsqrtlen) r@rrrOrr err5_norm_2 err3_norm_2rs &&&& r&rPDOP853._estimate_error_normsvvacc477#e+vvacc477#e+iinnT*A- iinnT*A- !  q 0d[00vvay;&U1C)DDDr(cVPpVPp\\VPVP 4VP ^,R7FrwpwrE\P!VRVPVRV4V,pVPVPWR,,VPV,4W&Kt \P!\PVP 3VPP"R7pV^,pVP$VP, p W^&W(,V , V^&^V ,W P&V,,, V^&V\P!VP(V4,VR&\+VPVP,VPV4#)rrNr/:NN)rr>rrA_EXTRAC_EXTRAr<rrrrrir3r;r INTERPOLATOR_POWERr5r0rrDDop853DenseOutputr) r@rrr r!r"r#Ff_olddelta_ys & r&rkDOP853._dense_output_implsJ OO OO"3t||T\\#B)-):*A 1 AJJNA./A 11%A FFRVVDFFA& & 66Q; G$ $A OAr()rjrror3 rvrwrxryr2rr}r~rrs@@r&rhrh(sr(rhc8aa]tRtRtoV3RltRtRtVtV;t#)riAcX<\SV`W4W!, VnW@nW0nR#rJ)r1r2rrr3)r@rirr3rrGs&&&&&r&r2Dop853DenseOutput.__init__Bs# " r(c<WP, VP, pVP^8Xd"\P!VP 4pMSVR,p\P !\V4\VP 43VP PR7p\\VP44F5wrEW5, pV^,^8Xd W2,pK%V^V, ,pK7 W0P , pVP#)rr/r) rirrr zeros_liker3zerosrr0rreversedrr)r@rrrirs&& r&rDop853DenseOutput._call_implHs ^tvv % 66Q; djj)A' A#a&#djj/2$**:J:JKAhtvv./DA FA1uzQU  0 ZZss r()rrr3rrs@@r&rrAs r(r)numpyrbaserrcommonrrrrr r r r[r]rYr'r*rrrrhrrr(r&rs(AA!    9xj@j@Zk:k\oI:oIdNDZNDbK2 r(