B 0dN%@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)npasarray)ty)rfunK/var/www/html/venv/lib/python3.7/site-packages/scipy/integrate/_ivp/base.py fun_wrappedsz$check_arguments..fun_wrapped) rrZ issubdtyperZcomplexfloating ValueErrorcomplexfloatZastypendim)r y0support_complexr r )rr 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||dddfS)N)_funZravel)rr)selfr r fun_single|sz&OdeSolver.__init__..fun_singlecs>t|}x.t|jD] \}}|||dd|f<qW|S)N)rZ empty_like enumerateTr)rrfiyi)rr r fun_vectorizeds z*OdeSolver.__init__..fun_vectorizedcsjd7_||S)Nr)nfevr)rr)rr r r szOdeSolver.__init__..funrrunningr)t_oldrrrrt_bound vectorizedr rrrsign directionsizenstatusrZnjevZnlu) rr t0rr!r"rrrr )rr __init__ss(    zOdeSolver.__init__cCs$|jdkrdSt|j|jSdS)N)r rabsr)rr 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. rz/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 r.r&rConstantDenseOutputr_dense_output_impl)rr r r dense_outputs  zOdeSolver.dense_outputcCstdS)N)NotImplementedError)rr r r r/szOdeSolver._step_implcCstdS)N)r6)rr r r r4szOdeSolver._dense_output_implN)F) __name__ __module__ __qualname____doc__ZTOO_SMALL_STEPr)propertyr+r2r5r/r4r 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|||_dS)N)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_impl)rrr r r __call__s  zDenseOutput.__call__cCstdS)N)r6)rrr r r r?szDenseOutput._call_implN)r7r8r9r:r)r@r?r r r r r<s r<cs(eZdZdZfddZddZZS)r3zConstant value interpolator. This class used for degenerate integration cases: equal integration limits or a system with 0 equations. cst||||_dS)N)superr)value)rr rrB) __class__r r r)szConstantDenseOutput.__init__cCsN|jdkr|jSt|jjd|jdf}|jdddf|dd<|SdS)Nr)rrBremptyshape)rrretr r r r? s  zConstantDenseOutput._call_impl)r7r8r9r:r)r? __classcell__r r )rCr r3s r3)numpyrrrr<r3r r r r s A)