(ph]DSSKrSSKJrJr SSKJrJrJr SSK J r SSK J r SSK JrJrJrJrJrJrJrJr SSKJrJr S rS rS rS rS rSrSr"SS\5r "SS\5r!g)N) lu_factorlu_solve)issparse csc_matrixeye)splu) group_columns)validate_max_step validate_tolselect_initial_stepnormEPSnum_jacvalidate_first_stepwarn_extraneous) OdeSolver DenseOutputg? c[R"SUS-5SS2S4n[R"SUS-5n[R"US-US-45nUS- X-- U- USS2SS24'SUS'[R"USS9$)z6Compute the matrix for changing the differences array.r Nraxis)nparangezeroscumprod)orderfactorIJMs K/var/www/html/venv/lib/python3.13/site-packages/scipy/integrate/_ivp/bdf.py compute_Rr%s !UQY4(A !UQYA %!)UQY'(AQ#q(Aab!"fI AaD ::aa  c[X5n[US5nURU5n[R"URUSUS-5USUS-&g)z " Mvvbkk!n%%  ba%#+/ *rz"  D[(D  $!)!+,D9GCcI    qL TQX%6%@3%FI  3#6 a!eQ !!r&cd^\rSrSrSr\R SSSSSS4U4SjjrSrS r S r S r U=r $) BDFHa9Implicit method based on backward-differentiation formulas. This is a variable order method with the order varying automatically from 1 to 5. The general framework of the BDF algorithm is described in [1]_. This class implements a quasi-constant step size as explained in [2]_. The error estimation strategy for the constant-step BDF is derived in [3]_. An accuracy enhancement using modified formulas (NDF) [2]_ is also implemented. 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`. 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 [4]_. 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] G. D. Byrne, A. C. Hindmarsh, "A Polyalgorithm for the Numerical Solution of Ordinary Differential Equations", ACM Transactions on Mathematical Software, Vol. 1, No. 1, pp. 71-96, March 1975. .. [2] L. F. Shampine, M. W. Reichelt, "THE MATLAB ODE SUITE", SIAM J. SCI. COMPUTE., Vol. 18, No. 1, pp. 1-22, January 1997. .. [3] E. Hairer, G. Wanner, "Solving Ordinary Differential Equations I: Nonstiff Problems", Sec. III.2. .. [4] 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. gMbP?gư>NFc *>^[U 5 [TT] XX4U SS9 [U5Tl[ XgTR 5uTlTlTRTRTR5n U cU[TRTRTRXEU TRSTRTR5 TlO[XU5TlSTlSTl[%S[&-U- [)SUS-55TlSTlTR/X5uTlTl[5TR25(a3U4SjnSn[7TR S TRR8S 9nOT=RS- sl[U5$Nr )nlurAselfs r$luBDF.__init__..lusA Awr&c$URU5$)N)solver:bs r$r;BDF.__init__..solve_lusxx{"r&csc)formatdtypecB>T=RS- sl[USS9$)Nr T) overwrite_a)rPrrQs r$rTrUsA  55r&c[XSS9$)NT) overwrite_b)rrXs r$r;rZs488r&r])rgGzǿgqqgugsh|?rr)/rsuper__init__r max_stepr nrtolatolr5tr?r directionh_absr h_abs_olderror_norm_oldmaxrmin newton_tol jac_factor _validate_jacjacr"rrr]ridentityrTr;r!arrayhstackcumsumr MAX_ORDERgammaalpha error_constemptyr*r n_equal_stepsr:)rSr5t0y0t_boundrgrirjru jac_sparsity vectorized first_step extraneousrCrTr;r!kappar* __class__s` r$rf BDF.__init__s_  # "z)-  /)(3 +D? 49 HHTVVTVV $  ,TXXtvvtvv-4-1^^Q-1YY CDJ -ZWEDJ"b3hos4/EF--c@$& DFF    #DFF5 =A 6 9 DFF$&&,,7A  @AYY299Q1i!m1L-L#MNO %i4::-  4::-BIIaQ4O0OO HHi!mTVV,DFFLL Avv!4::~.! r&c^^^^TRnTRmTc@Tb*[T5(a [T5m[ T5nTU4mUU4SjnU"UT5nXV4$[ T5(aT"UT5nT=R S- sl[U5(a[UTRS9nUUU4SjnO'[R"UTRS9nUUU4SjnURTRTR4:wa2[STRTR4SURS35eXV4$[T5(a[TTRS9nO[R"TTRS9nURTRTR4:wa2[STRTR4SURS35eSnXV4$) Nc >T=RS- slTRX5n[TRXUTRTR T5unTlU$rO)njev fun_singlerfun_vectorizedrjrs)rkr?rCr"rSsparsitys r$ jac_wrapped&BDF._validate_jac..jac_wrapped sR Q OOA)%,T-@-@!-1YY-5&7"4?r&r rbcb>T=RS- sl[T"X5TRS9$Nr rb)rrr]rkr?rurSrs r$rrs%IINI%c!irxx@@r&cx>T=RS- sl[R"T"X5TRS9$r)rrasarrayr]rs r$rr s)IINI::c!irxx@@r&z `jac` is expected to have shape z, but actually has .) rkr?rrr callablerr]rrshaperh ValueError)rSrurrgroupsrr"rs``` @r$rtBDF._validate_jacs VV VV ;#H%%)(3H&x0$f- B#A>~=c]]B A IINI{{q1AAJJq1Aww466466** #CTVVTVVDTCUV667ggYa"ABB+~}}s"((3JJs"((3ww466466** #CTVVTVVDTCUV667ggYa"ABBK~r&c 4 URnURnURnS[R"[R "XR [R-5U- 5-nURU:a,Un[X RX0R- 5 SUl OHURU:a,Un[X RX@R- 5 SUl O URnURnURnURnURn URn UR n UR"n UR$n UR&SLnSnU(GdTXT:aSUR(4$XPR -nUU-nUR UUR*- -S:a;UR*n[X([R"UU- 5U- 5 SUl Sn UU- n[R"U5n[R,"USUS-SS9nXg[R"U5--n[R."USUS-R0U SUS-5X- nSnUX- nU(dU c!UR3UR4UU -- 5n [7UR8UUUUXR:UUR<5 unnnnU(dU(aOUR'UU5n Sn SnU(dMU(dSnUU-n[X(U5 SUl Sn GMSS [>-S--S [>-W-- nXg[R"W5--nXW-n[AUU- 5nUS:a5[C[DUUS US-- --5nUU-n[X(U5 SUl OSnU(dGMTU=RS- sl WUlWUl#XPlXlXlWX(S-- X(S -'UX(S-'[I[KUS-55HnUU==UUS-- ss'M URUS-:ag US:aXS- X(-n[AUW- 5n O[Rn U[L:aXS-X(S --n![AU!W- 5n"O[Rn"[RN"U WU"/5n#[RP"S S 9 U#S [RR"XS-5- -n$SSS5 [RT"W$5S- n%UU%- nXl [W[XW[RB"U$5-5nU=RU-sl[X(U5 SUl SUlg !,(df  N=f)NrrFr rTrMg?rc)TNignore)dividerd)-rkr*rgrabs nextafterrlinfrmr.rrrjrir|r{r}r"r:ruTOO_SMALL_STEPrsumr(r)rTr!rGr5r;rrr2rrp MIN_FACTORr?reversedr1rzrwerrstaterargmaxrq MAX_FACTOR)&rSrkr*rgmin_steprmrjrirr|r{r}r"r: current_jac step_acceptedhr6r7r<r9rAr8n_itery_newr>r safetyerror error_normierror_m error_m_normerror_p error_p_norm error_normsfactors delta_orders& r$ _step_implBDF._step_impl4s FF FF==r||A~~/FG!KLL :: E Q Hzz$9 :!"D  ZZ( "E Q Hzz$9 :!"D JJEyyyy   && FF WWhh$&  d1111&AEE~~!56: 266%!)#4u#<=%&" AFF1IEq%!)}15I"&&"333E&&1eai**E!UQY,?@5<OCIEL A:!a%0B.>HHeY3MM4??/,+ 65!!" 2AB"&K i6*%&"A.23q>7I9?8@AF"&&-//E&*Eeem,JA~Z#jR5195E&FFH6*%&"!% } -@ a  1QY<'!) !) % *+A aDAa!eH D,    ) 19!!),qx7G%0L66L 9 !!),q|;G%0L66Lhh j,GH [[ )!b299UAI+F&FGG*ii(1,   Z"&&/!9: f 6"* )s & V  Vc [URURURUR-UR UR SUR S-R55$rO)BdfDenseOutputt_oldrkrmrlrr*r0)rSs r$_dense_output_implBDF._dense_output_implsQdjj$&&$**t~~2M"jj$&&$**q.*A*F*F*HJ Jr&)r*r!r"r:r|rjr}ror{rmrnrursrTrgrrrrrir;rkr?) __name__ __module__ __qualname____firstlineno____doc__rrrfrtrr__static_attributes__ __classcell__rs@r$rIrIHs@{x79ff4d!d:x1fM^JJr&rIc.^\rSrSrU4SjrSrSrU=r$)ric>[TU]X5 X@lURU[R "UR5-- UlUS[R "UR5--UlXPlgrO) rerfrrkrrt_shiftdenomr*)rSrrkrrr*rs r$rfBdfDenseOutput.__init__sZ " vvBIIdjj$9 99 !bii 334 r&cURS:Xa2XR- UR- n[R"U5nO>XRSS2S4- URSS2S4- n[R"USS9n[R "UR SSRU5nURS:XaX@R S- nU$X@R SSS2S4- nU$)Nrrr )ndimrrrrr(r*r))rSrkxpr?s r$ _call_implBdfDenseOutput._call_impls 66Q;\\!TZZ/A 1 A\\!T'**djjD.AAA 11%A FF466!":<< # 66Q; NA 1d # #Ar&)r*rrr)rrrrrfrrrrs@r$rrsr&r)"numpyr scipy.linalgrr scipy.sparserrrscipy.sparse.linalgrscipy.optimize._numdiffr commonr r r rrrrrbaserrrzr2rrr%r.rGrIrr&r$rsn,22$1&&&)     !0!"H}J)}J@ [r&