U Gv fN%@s@ddlZddZGdddZGdddZGdd d eZdS) Ncsft|}t|jtjr,|s&tdtnt|jdd}|j dkrPtdfdd}||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.cstj||dS)N)dtype)npasarraytyrfun=/tmp/pip-unpacked-wheel-96ln3f52/scipy/integrate/_ivp/base.py fun_wrappedsz$check_arguments..fun_wrapped) rrZ issubdtyperZcomplexfloating ValueErrorcomplexfloatZastypendim)r y0support_complexrr r r check_argumentss  rc@sJeZdZdZdZdddZeddZdd Zd d Z d d Z ddZ dS) 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.Fc sd_|_t|||\__|_|_|rDfdd}j}nj}fdd}fdd}|_|_|_ ||krt ||nd_ jj _d_d _d _d _dS) Ncs||dddfSN)_funZravelrselfr r fun_single|sz&OdeSolver.__init__..fun_singlecs:t|}t|jD] \}}|||dd|f<q|Sr)rZ empty_like enumerateTr)rr fiyirr r fun_vectorizeds z*OdeSolver.__init__..fun_vectorizedcsjd7_||S)Nr)nfevrrrr r r szOdeSolver.__init__..funrrunningr)t_oldrrrr t_bound vectorizedr rr!rsign directionsizenstatusr"ZnjevZnlu) rr t0rr%r&rrr!r rr __init__ss(    zOdeSolver.__init__cCs$|jdkrdSt|j|jSdSr)r$rabsrrr r r step_sizes zOdeSolver.step_sizecCs|jdkrtd|jdks(|j|jkrD|j|_|j|_d}d|_n@|j}|\}}|sbd|_n"||_|j|j|jdkrd|_|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)r+ RuntimeErrorr*rr%r$ _step_implr()rmessagersuccessr r r steps  zOdeSolver.stepcCsF|jdkrtd|jdks(|j|jkr:t|j|j|jS|SdS)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$r2r*rConstantDenseOutputr _dense_output_implrr r r dense_outputs  zOdeSolver.dense_outputcCstdSrNotImplementedErrorrr r r r3szOdeSolver._step_implcCstdSrr:rr r r r8szOdeSolver._dense_output_implN)F) __name__ __module__ __qualname____doc__ZTOO_SMALL_STEPr-propertyr/r6r9r3r8r r r r rsW % !rc@s(eZdZdZddZddZddZdS) 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. cCs(||_||_t|||_t|||_dSr)r$rminZt_minmaxZt_max)rr$rr r r r-s zDenseOutput.__init__cCs&t|}|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.)rrrr _call_implrrr r r __call__s  zDenseOutput.__call__cCstdSrr:rEr r r rDszDenseOutput._call_implN)r<r=r>r?r-rFrDr r r r rAs rAcs(eZdZdZfddZddZZS)r7zConstant value interpolator. This class used for degenerate integration cases: equal integration limits or a system with 0 equations. cst||||_dSr)superr-value)rr$rrH __class__r r r-szConstantDenseOutput.__init__cCsN|jdkr|jSt|jjd|jdf}|jdddf|dd<|SdS)Nr)rrHremptyshape)rrretr r r rD s  zConstantDenseOutput._call_impl)r<r=r>r?r-rD __classcell__r r rIr r7s r7)ZnumpyrrrrAr7r r r r s A)