hN%dddlZdZGddZGddZGddeZdS) Nc,tj|}tj|jtjr|st dt nt|d}|j dkrt dfd}||fS)z=Helper function for checking arguments common to all solvers.zX`y0` is complex, but the chosen solver does not support integration in a complex domain.F)copyz`y0` must be 1-dimensional.cDtj||S)N)dtype)npasarray)tyrfuns U/var/www/html/Sam_Eipo/venv/lib/python3.11/site-packages/scipy/integrate/_ivp/base.py fun_wrappedz$check_arguments..fun_wrappeds"z##a))51111) rr issubdtypercomplexfloating ValueErrorcomplexfloatastypendim)r y0support_complexrrs` @r check_argumentsrs BB }RXr122 MLMM M 5u % %B w!||6777222222 ?rcNeZdZdZdZ d dZedZdZdZ dZ d Z d S) OdeSolveraBase class for ODE solvers. In order to implement a new solver you need to follow the guidelines: 1. A constructor must accept parameters presented in the base class (listed below) along with any other parameters specific to a solver. 2. A constructor must accept arbitrary extraneous arguments ``**extraneous``, but warn that these arguments are irrelevant using `common.warn_extraneous` function. Do not pass these arguments to the base class. 3. A solver must implement a private method `_step_impl(self)` which propagates a solver one step further. It must return tuple ``(success, message)``, where ``success`` is a boolean indicating whether a step was successful, and ``message`` is a string containing description of a failure if a step failed or None otherwise. 4. A solver must implement a private method `_dense_output_impl(self)`, which returns a `DenseOutput` object covering the last successful step. 5. A solver must have attributes listed below in Attributes section. Note that ``t_old`` and ``step_size`` are updated automatically. 6. Use `fun(self, t, y)` method for the system rhs evaluation, this way the number of function evaluations (`nfev`) will be tracked automatically. 7. For convenience, a base class provides `fun_single(self, t, y)` and `fun_vectorized(self, t, y)` for evaluating the rhs in non-vectorized and vectorized fashions respectively (regardless of how `fun` from the constructor is implemented). These calls don't increment `nfev`. 8. If a solver uses a Jacobian matrix and LU decompositions, it should track the number of Jacobian evaluations (`njev`) and the number of LU decompositions (`nlu`). 9. By convention, the function evaluations used to compute a finite difference approximation of the Jacobian should not be counted in `nfev`, thus use `fun_single(self, t, y)` or `fun_vectorized(self, t, y)` when computing a finite difference approximation of the Jacobian. 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 ndarray ``y``. It can either have shape (n,), then ``fun`` must return array_like with shape (n,). Or, alternatively, it can have shape (n, n_points), then ``fun`` must return array_like with shape (n, n_points) (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. vectorized : bool Whether `fun` is implemented in a vectorized fashion. support_complex : bool, optional Whether integration in a complex domain should be supported. Generally determined by a derived solver class capabilities. 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 of the system's rhs evaluations. njev : int Number of the Jacobian evaluations. nlu : int Number of LU decompositions. z8Required step size is less than spacing between numbers.Fcd_|_t|||\__|_|_|r fd}j}n j}fd}fd}|_|_|_ ||krtj ||z nd_ jj _d_d_d_d_dS)Nch||dddfSN)_funravelr r selfs r fun_singlez&OdeSolver.__init__..fun_single|s/yyAaaagJ//55777rctj|}t|jD]"\}}|||dd|f<#|Sr)r empty_like enumerateTr)r r fiyir"s r fun_vectorizedz*OdeSolver.__init__..fun_vectorizedsSM!$$&qs^^//EAr"ii2..AaaadGGrcPxjdz c_||S)Nr)nfevr#r!s r r zOdeSolver.__init__..funs& IINII??1a(( (rrrunningr)t_oldr rrr t_bound vectorizedr r#r+rsign directionsizenstatusr-njevnlu) r"r t0rr0r1rr#r+s ` r __init__zOdeSolver.__init__ss +C_EE 46 $   8 8 8 8 8!YNNJ       ) ) ) ) )$,29R--2...Q   rcV|jdStj|j|jz Sr)r/rabsr r"s r step_sizezOdeSolver.step_sizes( : 46$&4:-.. .rcV|jdkrtd|jdks|j|jkr"|j|_|j|_d}d|_nQ|j}|\}}|sd|_n)||_|j|j|jz zdkrd|_|S)aPerform one integration step. Returns ------- message : string or None Report from the solver. Typically a reason for a failure if `self.status` is 'failed' after the step was taken or None otherwise. r.z/Attempt to step on a failed or finished solver.rNfinishedfailed)r6 RuntimeErrorr5r r0r/ _step_implr3)r"messager successs r stepzOdeSolver.steps ;) # # )** * 6Q;;$&DL00DJ\DFG$DKKA#00 GW -&  >TVdl%:;q@@",DKrc|jtd|jdks|j|jkr t |j|j|jS|S)zCompute a local interpolant over the last successful step. Returns ------- sol : `DenseOutput` Local interpolant over the last successful step. Nz;Dense output is available after a successful step was made.r)r/rBr5r ConstantDenseOutputr _dense_output_implr=s r dense_outputzOdeSolver.dense_outputsh :  011 1 6Q;;$&DJ..&tz4646BB B**,, ,rctrNotImplementedErrorr=s r rCzOdeSolver._step_impl!!rctrrLr=s r rIzOdeSolver._dense_output_implrNrN)F) __name__ __module__ __qualname____doc__TOO_SMALL_STEPr:propertyr>rFrJrCrIrr rrsVVnPN"'####J//X/ B---$""""""""rrc$eZdZdZdZdZdZdS) DenseOutputaOBase class for local interpolant over step made by an ODE solver. It interpolates between `t_min` and `t_max` (see Attributes below). Evaluation outside this interval is not forbidden, but the accuracy is not guaranteed. Attributes ---------- t_min, t_max : float Time range of the interpolation. cv||_||_t|||_t |||_dSr)r/r mint_minmaxt_max)r"r/r s r r:zDenseOutput.__init__s2 E]] E]] rctj|}|jdkrtd||S)aeEvaluate the interpolant. Parameters ---------- t : float or array_like with shape (n_points,) Points to evaluate the solution at. Returns ------- y : ndarray, shape (n,) or (n, n_points) Computed values. Shape depends on whether `t` was a scalar or a 1-D array. rz#`t` must be a float or a 1-D array.)rr rr _call_implr"r s r __call__zDenseOutput.__call__s= JqMM 6A::BCC Cq!!!rctrrLr`s r r_zDenseOutput._call_implrNrN)rPrQrRrSr:rar_rVrr rXrXsK  ### """&"""""rrXc(eZdZdZfdZdZxZS)rHzConstant value interpolator. This class used for degenerate integration cases: equal integration limits or a system with 0 equations. cZt||||_dSr)superr:value)r"r/r rf __class__s r r:zConstantDenseOutput.__init__s( """ rc|jdkr|jStj|jjd|jdf}|jdddf|dd<|S)Nr)rrfremptyshape)r"r rets r r_zConstantDenseOutput._call_impl sZ 6Q;;: (DJ,Q/<==CZ4(CFJr)rPrQrRrSr:r_ __classcell__)rgs@r rHrHsQ rrH)numpyrrrrXrHrVrr rns*}"}"}"}"}"}"}"}"@&"&"&"&"&"&"&"&"R+r