&]\c@`sddlmZmZmZddlZddlmZmZddl m Z m Z m Z m Z mZmZdZdZdZd Zd efd YZd efd YZdefdYZdefdYZdS(i(tdivisiontprint_functiontabsolute_importNi(t OdeSolvert DenseOutput(tvalidate_max_stept validate_toltselect_initial_steptnormtwarn_extraneoustvalidate_first_stepg?g?i c C`s|| dc K`st| tt|j|||||dtd|_t||_t |||j \|_ |_ |j |j|j|_| dkrt|j |j|j|j|j|j|j |j |_nt| |||_tj|jd|j fd|jj|_dS(Ntsupport_complexitdtype(R tsuperR"t__init__tTruetNonety_oldRtmax_stepRtntrtoltatolRRRRRt directiontorderth_absR R temptytn_stagesR$R( tselfRtt0ty0tt_boundR*R,R-t vectorizedt first_stept extraneous((s6lib/python2.7/site-packages/scipy/integrate/_ivp/rk.pyR&[s ! ! c C`sY|j}|j}|j}|j}|j}dtjtj||jtj |}|j |krr|}n!|j |kr|}n |j }|j }t } x}| s!||krt |j fS||j} || } |j| |jdkr|j} n| |} tj| }t|j|||j| |j|j|j|j|j \} } }|tjtj|tj| |}t||}|dkr|t9}t} q|dkr|tttdt|d|d9}t} q|ttt|d|d9}qW||_| |_| |_||_ | |_tdfS(Ni igii(!RRR*R,R-R tabst nextafterR.tinfR0R/tFalsetTOO_SMALL_STEPR6R!RRRRRRRtmaximumRt MAX_FACTORR'tmintmaxtSAFETYt MIN_FACTORR)R((R3RRR*R,R-tmin_stepR0R/t step_acceptedRtt_newRRR tscalet error_norm((s6lib/python2.7/site-packages/scipy/integrate/_ivp/rk.pyt _step_implmsR     -           ',     #       cC`s4|jjj|j}t|j|j|j|S(N(RRRtPt RkDenseOutputtt_oldRR)(R3tQ((s6lib/python2.7/site-packages/scipy/integrate/_ivp/rk.pyt_dense_output_implsN(t__name__t __module__t__doc__tNotImplementedRRRRRKR/R2R R<R=R(R&RJRO(((s6lib/python2.7/site-packages/scipy/integrate/_ivp/rk.pyR"Qs   ;tRK23cB`seZdZdZdZejddgZejdgejddggZejdddgZ ejddddgZ ejdddgdddgdddgdd dggZ RS(s Explicit Runge-Kutta method of order 3(2). This uses the Bogacki-Shampine pair of formulas [1]_. The error is controlled assuming accuracy of the second-order method, but steps are taken using the third-order accurate formula (local extrapolation is done). A cubic Hermite polynomial is used for the dense output. Can be applied in the complex domain. 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, k), then ``fun`` must return array_like with shape (n, k), i.e. 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. 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). But if a component of `y` is approximately below `atol`, the error only needs to fall within the same `atol` threshold, and the number of correct digits is not guaranteed. 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`. vectorized : bool, optional Whether `fun` is implemented in a vectorized fashion. 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 evaluations of the system's right-hand side. njev : int Number of evaluations of the Jacobian. Is always 0 for this solver as it does not use the Jacobian. nlu : int Number of LU decompositions. Is always 0 for this solver. References ---------- .. [1] P. Bogacki, L.F. Shampine, "A 3(2) Pair of Runge-Kutta Formulas", Appl. Math. Lett. Vol. 2, No. 4. pp. 321-325, 1989. iiiiii iiHii iiiig?g?g?g?gqq?gUUUUUU?gqq?grqDZ?gUUUUUUgqqg?gUUUUUUgrq?gUUUUUUgUUUUUU?gqq( RPRQRRR/R2R tarrayRRRRRK(((s6lib/python2.7/site-packages/scipy/integrate/_ivp/rk.pyRTsK  tRK45c B`sdeZdZdZdZejdSdTdUdVdgZejdWgejdXdYgejdZd[d\gejd]d^d_d`gejdadbdcdddeggZejdfd"dgdhdidjgZ ejdkd"dldmdndodpgZ ejddqdrdsgd"d"d"d"gd"dtdudvgd"dwdxdygd"dzd{d|gd"d}d~dgd"dddggZ RS(s Explicit Runge-Kutta method of order 5(4). This uses the Dormand-Prince pair of formulas [1]_. The error is controlled assuming accuracy of the fourth-order method accuracy, but steps are taken using the fifth-order accurate formula (local extrapolation is done). A quartic interpolation polynomial is used for the dense output [2]_. Can be applied in the complex domain. 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 the ndarray ``y``: It can either have shape (n,); then ``fun`` must return array_like with shape (n,). Alternatively it can have shape (n, k); then ``fun`` must return an array_like with shape (n, k), i.e. 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. 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). But if a component of `y` is approximately below `atol`, the error only needs to fall within the same `atol` threshold, and the number of correct digits is not guaranteed. 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`. vectorized : bool, optional Whether `fun` is implemented in a vectorized fashion. 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 evaluations of the system's right-hand side. njev : int Number of evaluations of the Jacobian. Is always 0 for this solver as it does not use the Jacobian. nlu : int Number of LU decompositions. Is always 0 for this solver. References ---------- .. [1] J. R. Dormand, P. J. Prince, "A family of embedded Runge-Kutta formulae", Journal of Computational and Applied Mathematics, Vol. 6, No. 1, pp. 19-26, 1980. .. [2] L. W. Shampine, "Some Practical Runge-Kutta Formulas", Mathematics of Computation,, Vol. 46, No. 173, pp. 135-150, 1986. iiiiii ii i(i,i-iii iKiiiii,ii9#i` ii!iii1iiiHi#iiiiYi}iiuii iTiiiGi7AiieCi-ii IdD IIhI IvIyII#I㲉I^i9kipIU`NiPTI9ǂipI 4I`6 IaTNµI˚HqI4h.i&i*B ikrZxiӀ$i_Wiī1i2kiGOiU$hiy,g?g333333?g?gqq?g?g333333?g?gII?g gqq @gq@g 1'gR<6R#@gE3ҿg+@g>%gr!@gE]t?g/pѿgUUUUUU?gVI?gUUUUU?gϡԿg1 0 ?g2TgĿ UZkq?ggX ?g{tg?g# !gJ<@gFCgF@gFj'NgDg@gdD gaP#$@g 2g s . B\Yi