(phLSSKrSSKJrJr SSKJrJrJr SSK J r SSK J r SSK JrJrJrJrJrJrJrJr SSKJrJr S r\R4"S \- S - S \-S - S/5r\R4"S S \-- S S \--S/5S- rSrSr\R4"/SQ/SQ/SQ/5r\R4"/SQ/SQ/SQ/5r \ Sr!\ SS\ S--r"\R4"SS \-S- -SS\-S- - SS\--/SS \-S- - SS\-S- -SS\-- //SQ/5r#S r$S!r%S r&S"r'S#r("S$S%\5r)"S&S'\5r*g)(N) lu_factorlu_solve) csc_matrixissparseeye)splu) group_columns)validate_max_step validate_tolselect_initial_stepnormnum_jacEPSwarn_extraneousvalidate_first_step) OdeSolver DenseOutputg.! @ igs>H @yrr@Gg)g{g]#-?g;@L¿ghm?)g }?gQ  ?gmؿ)r r r)gF@gN]?gV?)gFgN]Կg!R?)g$Z?goNg{??gUUUUUU@g竪 @)gUUUUUU?gUUUUUUrg?c URSn [U- n [U- n [R U5n Un[ R "SU 45nU[-nSn[ R"U 5nSnSn[[5GH]n[S5HnU"UUU-X.U-5UU'M [ R"[ R"U55(d GOURR [5XS-- nURR [5XSSU S---- nU "UU5nU "UU5nUUS'UR US'UR"US'[%UU- 5nUbUU- nUb!US:dU[U- -SU- - U-U:a O=U U- n [R U 5nUS:XdUbUSU- - U-U:aSn OUnGM` UWS-UU4$) aSolve the collocation system. Parameters ---------- fun : callable Right-hand side of the system. t : float Current time. y : ndarray, shape (n,) Current state. h : float Step to try. Z0 : ndarray, shape (3, n) Initial guess for the solution. It determines new values of `y` at ``t + h * C`` as ``y + Z0``, where ``C`` is the Radau method constants. scale : ndarray, shape (n) Problem tolerance scale, i.e. ``rtol * abs(y) + atol``. tol : float Tolerance to which solve the system. This value is compared with the normalized by `scale` error. LU_real, LU_complex LU decompositions of the system Jacobians. solve_lu : callable Callable which solves a linear system given a LU decomposition. The signature is ``solve_lu(LU, b)``. Returns ------- converged : bool Whether iterations converged. n_iter : int Number of completed iterations. Z : ndarray, shape (3, n) Found solution. rate : float The rate of convergence. rrNFr rrT)shapeMU_REAL MU_COMPLEXTIdotnpemptyC empty_likerangeNEWTON_MAXITERallisfiniteTTI_REAL TI_COMPLEXrealimagr)funtyhZ0scaletolLU_real LU_complexsolve_lunM_real M_complexWZFch dW_norm_olddW convergedratekif_real f_complexdW_real dW_complexdW_norms M/var/www/html/venv/lib/python3.13/site-packages/scipy/integrate/_ivp/radau.pysolve_collocation_systemrP0sN  A q[FQI r A A !QA QBK q BI D > "qAq2a5y!d(+AaDvvbkk!n%% !FqTM1CCGGJ')tb1Q4i7G*HH 7F+j)4 111rEz"  "[(D  $!)!+,D9GCcI  R EE!H qL TQX%6%@3%FI  C#F a!eQ $$cUb UbUS:XaSnO X- X2- S--n[R"SS9 [SU5US--nSSS5 U$!,(df  W$=f)aPredict by which factor to increase/decrease the step size. The algorithm is described in [1]_. Parameters ---------- h_abs, h_abs_old : float Current and previous values of the step size, `h_abs_old` can be None (see Notes). error_norm, error_norm_old : float Current and previous values of the error norm, `error_norm_old` can be None (see Notes). Returns ------- factor : float Predicted factor. Notes ----- If `h_abs_old` and `error_norm_old` are both not None then a two-step algorithm is used, otherwise a one-step algorithm is used. References ---------- .. [1] E. Hairer, S. P. Norsett G. Wanner, "Solving Ordinary Differential Equations II: Stiff and Differential-Algebraic Problems", Sec. IV.8. Nrr g?ignore)dividegп)r&errstatemin)h_abs h_abs_old error_normerror_norm_old multiplierfactors rOpredict_factorr]sm:!2jAo &.*E$)NN H %Q #jE&99 & M & % Ms A  Acj^\rSrSrSr\R SSSSSS4U4SjjrSrS r S r S r S r U=r $) RadauaImplicit Runge-Kutta method of Radau IIA family of order 5. The implementation follows [1]_. The error is controlled with a third-order accurate embedded formula. A cubic polynomial which satisfies the collocation conditions is used for the dense output. 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)``. HHere `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`. jac : {None, array_like, sparse_matrix, callable}, optional Jacobian matrix of the right-hand side of the system with respect to y, required by this method. The Jacobian matrix has shape (n, n) and its element (i, j) is equal to ``d f_i / d y_j``. There are three ways to define the Jacobian: * If array_like or sparse_matrix, the Jacobian is assumed to be constant. * If callable, the Jacobian is assumed to depend on both t and y; it will be called as ``jac(t, y)`` as necessary. For the 'Radau' and 'BDF' methods, the return value might be a sparse matrix. * If None (default), the Jacobian will be approximated by finite differences. It is generally recommended to provide the Jacobian rather than relying on a finite-difference approximation. jac_sparsity : {None, array_like, sparse matrix}, optional Defines a sparsity structure of the Jacobian matrix for a finite-difference approximation. Its shape must be (n, n). This argument is ignored if `jac` is not `None`. If the Jacobian has only few non-zero elements in *each* row, providing the sparsity structure will greatly speed up the computations [2]_. A zero entry means that a corresponding element in the Jacobian is always zero. If None (default), the Jacobian is assumed to be dense. vectorized : bool, optional Whether `fun` can be called in a vectorized fashion. Default is False. 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 this method, but may result in slower execution overall in some circumstances (e.g. small ``len(y0)``). 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 of evaluations of the right-hand side. njev : int Number of evaluations of the Jacobian. nlu : int Number of LU decompositions. References ---------- .. [1] E. Hairer, G. Wanner, "Solving Ordinary Differential Equations II: Stiff and Differential-Algebraic Problems", Sec. IV.8. .. [2] A. Curtis, M. J. D. Powell, and J. Reid, "On the estimation of sparse Jacobian matrices", Journal of the Institute of Mathematics and its Applications, 13, pp. 117-120, 1974. MbP?gư>NFc >^[U 5 [TT] XX4U 5 STl[ U5Tl[ XgTR5uTlTl TRTRTR5Tl U c_[TRTRTRXETRTRSTRTR5 TlO[#XU5TlSTlSTl[)S[*-U- [-SUS-55TlSTlSTlTR5X5uTlTl[;TR85(aU4Sjn Sn[=TRSS9nO)U4S jn S n[>R@"TR5nU Tl!UTl"UTl#S Tl$STl%STl&STl'g) NrrgQ??cD>T=RS- sl[U5$Nr )nlurAselfs rOluRadau.__init__..luAsA AwrQc$URU5$N)solveLUbs rOr< Radau.__init__..solve_luEsxx{"rQcsc)formatcB>T=RS- sl[USS9$)Nr T) overwrite_a)rfrrgs rOrjrkJsA  55rQc[XSS9$)NT) overwrite_b)rros rOr<rrNs488rQT)(rsuper__init__y_oldr max_stepr r=rtolatolr3r4r5fr directionrWrrXrZmaxrrV newton_tolsol jac_factor _validate_jacjacJrrr&identityrjr<I current_jacr:r;rA)rir3t0y0t_boundr|r}r~r jac_sparsity vectorized first_step extraneousrjr<r __class__s` rOrzRadau.__init__'s  # "z: )(3 +D? 49$&&$&&)  ,$&&$&&'TVVT^^499dii)DJ-ZWEDJ"b3hos4/EF--c@$& DFF    #DFF5)A 6 9 DFF#A   rQcz^^^TRnTRnTcJTb*[T5(a [T5m[ T5nTU4mUU4SjnU"X4TR 5nXg4$[ T5(aT"X45nSTl[U5(a[U5nS UU4SjjnO"[R"U[S9nS UU4SjjnURTRTR4:wa2[STRTR4SURS35eXg4$[T5(a [T5nO[R"T[S9nURTRTR4:wa2[STRTR4SURS35eSnXg4$) Nc >T=RS- sl[TRXUTRTRT5unTlU$re)njevrfun_vectorizedr~r)r4r5rrrisparsitys rO jac_wrapped(Radau._validate_jac..jac_wrappedgsD Q %,T-@-@!-1YY-5&7"4?rQr cV>T=RS- sl[T"X5[S9$Nr dtype)rrfloatr4r5_rris rOrrts!IINI%c!iu==rQrcl>T=RS- sl[R"T"X5[S9$r)rr&asarrayrrs rOrr{s%IINI::c!iu==rQz `jac` is expected to have shape z, but actually has .rm)r4r5rrr rcallablerr&rrr!r= ValueError)rirrrrgroupsrrs``` rOrRadau._validate_jac\s VV VV ;#H%%)(3H&x0$f-  BDFF+A@~?c]]B ADI{{qM>> JJq.>>ww466466** #CTVVTVVDTCUV667ggYa"ABB+~}}sOJJs%0ww466466** #CTVVTVVDTCUV667ggYa"ABBK~rQc  URnURnURnURnURnUR nS[ R"[ R"XR[ R-5U- 5-nURU:aUnSn Sn O;URU:aUnSn Sn O$URnURn URn URn URn UR n UR"nUR$nSnSnSnU(GdX:aSUR&4$XR-nUU-nURUUR(- -S:a UR(nUU- n[ R"U5nUR*c&[ R,"SUR.S45nO(UR+UU[0--5R2U- nU[ R"U5U--nSnU(dU bU cPUR5[6U- UR8-U - 5n UR5[:U- UR8-U - 5n [=UR>XUUUUR@XURB5 unnnnU(d U(aO!UR%XU5n SnSn Sn U(dMU(d US-nSn Sn GMUWS-nUR2RE[F5U- nURCXU-5nU[ RH"[ R"U5[ R"U55U--n[KUU- 5nSS [L-S --S [L-W-- nU(a:US :a4URCXR?XU-5U-5n[KUU- 5nUS :a*[OXUU 5n U[Q[RUU -5-nSn Sn SnOSnU(dGMUSL=(a WS :=(a WS :n![OXWU 5n [U[VWU -5n U!(d U S :aS n OSn Sn UR?WW5n"U!(a U"UUU"5n SnOUbSnURUl UUl UU -Ul X l,UUlUUlU"UlWUl-XlXlXlXlXl.UR_5UlUU4$) NrFrrTrcrg?rr rag333333?)0r4r5rr|r~r}r&abs nextafterrinfrWrXrZrr:r;rrTOO_SMALL_STEPrrzerosr!r(r.rjr"rr#rPr3rr<r%Emaximumrr+r]r MIN_FACTORrV MAX_FACTORr{rAt_old_compute_dense_output)#rir4r5rr|r~r}min_steprWrXrZrr:r;rrrejected step_acceptedmessager6t_newr7r8rFn_iterrArGy_newZEerrorrYsafetyr\ recompute_jacf_news# rO _step_implRadau._step_impls FF FF FF==yyyyr||A~~/FG!KLL :: EI!N ZZ( "EI!NJJEI!00N FF,,__ && hh d1111&AEE~~!56:  AFF1IExxXXq!''!*o.XXa!a%i(**Q.266!9t++EI?j&8"gggkDFF&:Q&>?G!%a$&&)@1)D!EJ-EHHaAr5$//.8* 61d!"q)A"&K"G!%J! i$ ! "IEaBMM'r62E2::bffQi?$FFEeem,JA.23q>7I9?8@AFJN gxxu9/E/JK!%%-0 A~'(2NDZ&99!  $ E -H4FFQJF4$; *nMZ&1#FGJ& E5%(AK _K(V^   $& --/g%%rQc[R"URR[5n[ UR URURU5$rm) r&r%rAr.PRadauDenseOutputrr4r{)riQs rOrRadau._compute_dense_outputs7 FF46688Q  DFFDJJBBrQcUR$rm)r)ris rO_dense_output_implRadau._dense_output_impl!s xxrQ)rrr;r:rAr~rrZrrWrXrrrjr|rrr}rr<r4rr5r{)__name__ __module__ __qualname____firstlineno____doc__r&rrzrrrr__static_attributes__ __classcell__rs@rOr_r_sDrf79ff4d!d3j1fL&\CrQr_c.^\rSrSrU4SjrSrSrU=r$)ri%c|>[TU]X5 X!- UlX@lURSS- UlX0lgre)ryrzr6rr!orderr{)rirr4r{rrs rOrzRadauDenseOutput.__init__&s6 "WWQZ!^  rQcXR- UR- nURS:Xa:[R"X R S-5n[R "U5nO:[R"X R S-S45n[R "USS9n[R"URU5nURS:XaX@RSS2S4- nU$X@R- nU$)Nrr )axisr) rr6ndimr&tilercumprodr%rr{)rir4xpr5s rO _call_implRadauDenseOutput._call_impl-s ^tvv % 66Q;::>*A 1 AJJNA./A 11%A FF4661  66Q; AtG$ $A OArQ)rr6rr{)rrrrrzrrrrs@rOrr%srQr)+numpyr& scipy.linalgrr scipy.sparserrrscipy.sparse.linalgrscipy.optimize._numdiffr commonr r r rrrrrbaserrS6arrayr(rr"r#r.r$r/r0rr+rrrPr]r_rrQrOrs,22$1***) HHq2vma"f]A ./HHcAFlC!b&L" -.2 *5 HHDD XXCEDFG Q% UR"Q%Z  HH AbDF]EBrE!GOTAF]3 AbDF]EBrE!GOTAF]3    X%v%PoIod {rQ