403Webshell
Server IP : 217.160.0.135  /  Your IP : 216.73.217.85
Web Server : Apache
System : Linux www 6.18.52-i1-ampere #1203 SMP Mon Sep 14 18:29:59 CEST 2026 aarch64
User : sws1074145052 ( 1074145052)
PHP Version : 8.3.32
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : OFF  |  Pkexec : OFF
Directory :  /usr/lib/python3/dist-packages/scipy/integrate/_ivp/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ Back ]     

Current File : /usr/lib/python3/dist-packages/scipy/integrate/_ivp/__pycache__/rk.cpython-311.pyc
�

d�c�V���ddlZddlmZmZddlmZmZmZm	Z	m
Z
mZddlm
Z
dZdZdZd	�ZGd
�de��ZGd�d
e��ZGd�de��ZGd�de��ZGd�de��ZGd�de��ZdS)�N�)�	OdeSolver�DenseOutput)�validate_max_step�validate_tol�select_initial_step�norm�warn_extraneous�validate_first_step)�dop853_coefficientsg�������?皙�����?�
c	��||d<tt|dd�|dd���d���D]M\}	\}
}tj|d|	�j|
d|	���|z}||||zz||z��||	<�N||tj|dd�j|��zz}
|||z|
��}||d<|
|fS)a8Perform a single Runge-Kutta step.

    This function computes a prediction of an explicit Runge-Kutta method and
    also estimates the error of a less accurate method.

    Notation for Butcher tableau is as in [1]_.

    Parameters
    ----------
    fun : callable
        Right-hand side of the system.
    t : float
        Current time.
    y : ndarray, shape (n,)
        Current state.
    f : ndarray, shape (n,)
        Current value of the derivative, i.e., ``fun(x, y)``.
    h : float
        Step to use.
    A : ndarray, shape (n_stages, n_stages)
        Coefficients for combining previous RK stages to compute the next
        stage. For explicit methods the coefficients at and above the main
        diagonal are zeros.
    B : ndarray, shape (n_stages,)
        Coefficients for combining RK stages for computing the final
        prediction.
    C : ndarray, shape (n_stages,)
        Coefficients for incrementing time for consecutive RK stages.
        The value for the first stage is always zero.
    K : ndarray, shape (n_stages + 1, n)
        Storage array for putting RK stages here. Stages are stored in rows.
        The last row is a linear combination of the previous rows with
        coefficients

    Returns
    -------
    y_new : ndarray, shape (n,)
        Solution at t + h computed with a higher accuracy.
    f_new : ndarray, shape (n,)
        Derivative ``fun(t + h, y_new)``.

    References
    ----------
    .. [1] E. Hairer, S. P. Norsett G. Wanner, "Solving Ordinary Differential
           Equations I: Nonstiff Problems", Sec. II.4.
    rrN��start���)�	enumerate�zip�np�dot�T)�fun�t�y�f�h�A�B�C�K�s�a�c�dy�y_new�f_news               �9/usr/lib/python3/dist-packages/scipy/integrate/_ivp/rk.py�rk_stepr(s���^
�A�a�D��s�1�Q�R�R�5�!�A�B�B�%�0�0��:�:�:�&�&�	��6�A�q�
�V�A�b�q�b�E�G�Q�r��r�U�
#�
#�a�
'���s�1�q�1�u�9�a�"�f�%�%��!���
��B�F�1�S�b�S�6�8�Q�'�'�'�'�E��C��A��u���E��A�b�E��%�<��c����eZdZUdZeZejed<eZ	ejed<eZ
ejed<eZejed<eZejed<eZ
eed<eZeed<eZeed	<ejd
ddd
f�fd�	Zd�Zd�Zd�Zd�Z�xZS)�
RungeKuttaz,Base class for explicit Runge-Kutta methods.rrr�E�P�order�error_estimator_order�n_stages���MbP?���ư>FNc

���t|
��t���|||||d���d|_t	|��|_t
|||j��\|_|_	|�
|j|j��|_
|	�Dt|j
|j|j|j
|j|j|j|j	��|_nt%|	||��|_t'j|jdz|jf|jj���|_d|jdzz|_d|_dS)NT)�support_complexr��dtyper)r
�super�__init__�y_oldr�max_stepr�n�rtol�atolrrrrr�	directionr/�h_absrr�emptyr0r6r �error_exponent�
h_previous��selfr�t0�y0�t_boundr:r<r=�
vectorized�
first_step�
extraneous�	__class__s           �r'r8zRungeKutta.__init__Us'���	�
�#�#�#�
������b�"�g�z�)-�	�	/�	/�	/���
�)�(�3�3��
�+�D�$���?�?���	�4�9����$�&�$�&�)�)�����,���$�&�$�&�$�&�$�.��*�D�I�t�y�B�B�D�J�J�-�Z��W�E�E�D�J���4�=�1�,�d�f�5�T�V�\�J�J�J��� �D�$>��$B�C�������r)c�F�tj|j|j��|zS�N)rrrr,)rDr rs   r'�_estimate_errorzRungeKutta._estimate_erroris���v�a�c�4�6�"�"�Q�&�&r)c�N�t|�||��|z��SrM)r	rN)rDr r�scales    r'�_estimate_error_normzRungeKutta._estimate_error_normls%���D�(�(��A�.�.��6�7�7�7r)c�@�|j}|j}|j}|j}|j}dtjtj||jt
j	z��|z
��z}|j
|kr|}n|j
|kr|}n|j
}d}d}	|�sg||kr	d|jfS||jz}
||
z}|j||jz
zdkr|j}||z
}
tj|
��}t|j|||j|
|j|j|j|j�	�	\}}
|tjtj|��tj|����|zz}|�|j|
|��}|dkrM|dkrt,}n%t/t,t0||jzz��}|	rt/d|��}||z}d}n*|t5t6t0||jzz��z}d}	|��g|
|_||_||_||_||_
|
|_dS)NrFrrT)TN)rrr:r<r=r�abs�	nextafterr>�infr?�TOO_SMALL_STEPrGr(rrrrrr �maximumrQ�
MAX_FACTOR�min�SAFETYrA�max�
MIN_FACTORrBr9)rDrrr:r<r=�min_stepr?�
step_accepted�
step_rejectedr�t_newr%r&rP�
error_norm�factors                 r'�
_step_implzRungeKutta._step_implos>���F���F���=���y���y�����r�|�A�t�~���/F�G�G�!�K�L�L�L���:�� � ��E�E�
�Z�(�
"�
"��E�E��J�E��
��
��"	%��x����d�1�1�1����&�A���E�E��~����!5�6��:�:������	�A��F�1�I�I�E�"�4�8�Q��4�6�1�d�f�#'�6�4�6�4�6�;�;�L�E�5��2�:�b�f�Q�i�i������?�?�$�F�F�E��2�2�4�6�1�e�D�D�J��A�~�~���?�?�'�F�F� ��!'�*��8K�*K�!K�M�M�F�!�,� ��F�^�^�F����� $�
�
���Z�#�j�D�4G�&G�G�I�I�I�� $�
�E �"	%�H�����
���������
�����zr)c��|jj�|j��}t	|j|j|j|��SrM)r rrr-�
RkDenseOutput�t_oldrr9)rD�Qs  r'�_dense_output_implzRungeKutta._dense_output_impl�s3���F�H�L�L��� � ���T�Z�����Q�?�?�?r))�__name__�
__module__�__qualname__�__doc__�NotImplementedrr�ndarray�__annotations__rrr,r-r.�intr/r0rUr8rNrQrcrh�
__classcell__�rKs@r'r+r+Js&��������6�6�"�A�r�z�"�"�"�"�A�r�z�"�"�"�"�A�r�z�"�"�"�"�A�r�z�"�"�"�"�A�r�z�"�"�"��E�3����!/��3�/�/�/�"�H�c�"�"�"�68�f���%� �������('�'�'�8�8�8�A�A�A�F@�@�@�@�@�@�@r)r+c���eZdZdZdZdZdZejgd���Z	ejgd�gd�gd�g��Z
ejgd���Zejgd	���Zejgd
�gd�gd�gd
�g��Z
dS)�RK23a�
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), 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`.
    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.
    ��)r��?��?)rrr)rwrr)rrxr)g�q�q�?gUUUUUU�?g�q�q�?)gr�qDZ?gUUUUUU��g�q�q��g�?)rgUUUUUU��gr�q��?)rrgUUUUUU�)rgUUUUUU�?g�q�q�)rrrN�rirjrkrlr.r/r0r�arrayrrrr,r-�r)r'rtrt�s�������N�N�^
�E����H���������A�����	�	��������	�	�A�
	������!�!�A����)�)�)�*�*�A����$�$�$��,�,� �.�.��*�*��	�	�A�A�Ar)rtc
��eZdZdZdZdZdZejgd���Z	ejgd�gd�gd�gd	�gd
�gd�g��Z
ejgd���Zejgd
���Zejgd�gd�gd�gd�gd�gd�gd�g��Z
dS)�RK45a�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), 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`.
    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.
    ���)rr
g333333�?g�������?g�q�q�?r)rrrrr)r
rrrr)g333333�?g�������?rrr)g��I��I�?g������
�g�q�q@rr)g�q��@g� ��1'�g�R<6R�#@gE3���ҿr)g���+�@g�>��%�g�r��!@g�E]t��?g/��p��ѿ)gUUUUUU�?rg�V�I��?gUUUUU��?g���ϡԿg1�0�?)g����2T�rgĿ
UZkq?g�����gX���
�?g���{�t��g�������?)rg#�
�!��g�J�<�@gF��C�)rrrr)rg��F�@gFj'N��g����Dg@)rgdD���
�ga��P#$@g2����)rg���<p@g�@갘�g�����,@)rgRq�#����g_40g.
@g���F��)rg'����?g'����g�
�K@Nryr{r)r'r}r}s?������Q�Q�d
�E����H����,�,�,�-�-�A�������������#�#�#�:�:�:�=�=�=�
�	�	�A�	���B�B�B�C�C�A�������	�	�A�	���	#�	#�	#����	"�	"�	"�	"�	"�	"�	&�	&�	&�N�N�N�F�F�F�H�	I�	I�A�A�Ar)r}c�$��eZdZdZejZdZdZej	de�de�fZ	ej
Z
ejde�ZejZej
Z
ejZej	edzd�Zejedzd�Zejddddf�fd	�	Zd
�Zd�Zd�Z�xZS)
�DOP853a#Explicit Runge-Kutta method of order 8.

    This is a Python implementation of "DOP853" algorithm originally written
    in Fortran [1]_, [2]_. Note that this is not a literate translation, but
    the algorithmic core and coefficients are the same.

    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), 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`.
    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] E. Hairer, S. P. Norsett G. Wanner, "Solving Ordinary Differential
           Equations I: Nonstiff Problems", Sec. II.
    .. [2] `Page with original Fortran code of DOP853
            <http://www.unige.ch/~hairer/software.html>`_.
    ��Nrr1r2Fc
����t��j|||||||||	f	i|
��tjtj|jf|jj���|_	|j	d|j
dz�|_dS)Nr5r)r7r8rr@r�N_STAGES_EXTENDEDr;rr6�
K_extendedr0r rCs           �r'r8zDOP853.__init__�s����	������b�"�g�x��t�#�Z�	?�	?�3=�	?�	?�	?��(�$7�$I�$(�F�$,�37�6�<�A�A�A�����!3�$�-�!�"3�!3�4����r)c��tj|j|j��}tj|j|j��}tjtj|��dtj|��z��}tj|��}|dk}tj||��||z||<||z|zS)Ng�������?r)rrr�E5�E3�hypotrS�	ones_like)rDr r�err5�err3�denom�correction_factor�masks        r'rNzDOP853._estimate_error�s����v�a�c�4�7�#�#���v�a�c�4�7�#�#���������s�R�V�D�\�\�'9�:�:���L��.�.���q�y��"$�&��d��"4�"4�u�T�{�"B��$���4�x�+�+�+r)c��tj|j|j��|z}tj|j|j��|z}tj�|��dz}tj�|��dz}|dkr|dkrdS|d|zz}tj|��|ztj|t|��z��zS)Nrvrgg{�G�z�?)
rrrr�r��linalgr	rS�sqrt�len)	rDr rrPr�r��err5_norm_2�err3_norm_2r�s	         r'rQzDOP853._estimate_error_norm�s����v�a�c�4�7�#�#�e�+���v�a�c�4�7�#�#�e�+���i�n�n�T�*�*�A�-���i�n�n�T�*�*�A�-���!����q� 0� 0��3��d�[�0�0���v�a�y�y�;�&�����U���1C�)D�)D�D�Dr)c��|j}|j}tt|j|j��|jdz���D]a\}\}}tj|d|�j	|d|���|z}|�
|j||zz|j|z��||<�btj
tj|jf|jj���}|d}|j|jz
}	|	|d<||z|	z
|d<d|	z||j|zzz
|d<|tj|j|��z|dd�<t+|j|j|j|��S)Nrrr5rrvru)r�rBrr�A_EXTRA�C_EXTRAr0rrrrrfr9r@r�INTERPOLATOR_POWERr;r6rr�D�Dop853DenseOutputr)
rDr rr!r"r#r$�F�f_old�delta_ys
          r'rhzDOP853._dense_output_implsZ���O���O��"�3�t�|�T�\�#B�#B�)-���):�<�<�<�	A�	A�I�A�v��1����"�1�"����2�A�2��'�'�!�+�B��8�8�D�J��Q��.��
�R��@�@�A�a�D�D��H�)�<�d�f�E��:�+�
-�
-�
-���!����&�4�:�%����!���5�y�7�"��!���7�{�Q�$�&�5�.�1�1��!���B�F�4�6�1�%�%�%��!�"�"�� ���T�V�T�Z��C�C�Cr))rirjrkrlr�N_STAGESr0r.r/rrrr�r�r�r�r�rrUr8rNrQrhrqrrs@r'r�r��s�������P�P�b#�+�H�
�E�����i�x�i��(��2�3�A���A���i�x�i�(�A�	�	�B�	�	�B���A�!�#�H�q�L�M�M�2�G�!�#�H�q�L�M�M�2�G�68�f���%� �5�5�5�5�5�5�,�,�,�E�E�E�D�D�D�D�D�D�Dr)r�c�$��eZdZ�fd�Zd�Z�xZS)rec���t���||��||z
|_||_|jddz
|_||_dS)Nr)r7r8rrg�shaper.r9)rDrfrr9rgrKs     �r'r8zRkDenseOutput.__init__sK���
�������"�"�"��U��������W�Q�Z�!�^��
���
�
�
r)c��||jz
|jz}|jdkr2tj||jdz��}tj|��}n5tj||jdzdf��}tj|d���}|jtj|j|��z}|jdkr||j	dd�dfz
}n
||j	z
}|S)Nrr)�axisrv)
rfr�ndimr�tiler.�cumprodrrgr9)rDr�x�prs     r'�
_call_implzRkDenseOutput._call_impl"s���
���^�t�v�%���6�Q�;�;����4�:��>�*�*�A��
�1�
�
�A�A����D�J��N�A�.�/�/�A��
�1�1�%�%�%�A��F�R�V�D�F�A�&�&�&���6�Q�;�;�
���A�A�A�t�G�$�$�A�A�
���O�A��r)�rirjrkr8r�rqrrs@r'reresG������������������r)rec�$��eZdZ�fd�Zd�Z�xZS)r�c�|��t���||��||z
|_||_||_dSrM)r7r8rr�r9)rDrfrr9r�rKs     �r'r8zDop853DenseOutput.__init__4s:���
�������"�"�"��U���������
�
�
r)c��||jz
|jz}|jdkrtj|j��}nM|dd�df}tjt|��t|j��f|jj���}tt|j����D]!\}}||z
}|dzdkr||z}�|d|z
z}�"||jz
}|jS)Nrr5rvr)
rfrr�r�
zeros_liker9�zerosr�r6r�reversedr�r)rDrr�r�irs      r'r�zDop853DenseOutput._call_impl:s���
���^�t�v�%���6�Q�;�;��
�d�j�)�)�A�A��!�!�!�T�'�
�A���#�a�&�&�#�d�j�/�/�2�$�*�:J�K�K�K�A��h�t�v�.�.�/�/�	�	�D�A�q�
��F�A��1�u��z�z��Q�����Q��U�
���	�T�Z����s�
r)r�rrs@r'r�r�3sG������������������r)r�)�numpyr�baserr�commonrrrr	r
r�rrZr\rXr(r+rtr}r�rer�r{r)r'�<module>r�s�������(�(�(�(�(�(�(�(�A�A�A�A�A�A�A�A�A�A�A�A�A�A�A�A�!�!�!�!�!�!�

��
�
�
�
�9�9�9�xj@�j@�j@�j@�j@��j@�j@�j@�Z^�^�^�^�^�:�^�^�^�BnI�nI�nI�nI�nI�:�nI�nI�nI�bND�ND�ND�ND�ND�Z�ND�ND�ND�b�����K����2����������r)

Youez - 2016 - github.com/yon3zu
LinuXploit