| 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 : |
�
d�cj � �v � d dl Zd dlmZ ddlmZmZmZ ddlm Z m
Z
G d� de � � Z G d� d e
� � Z dS )
� N)�ode� )� validate_tol�validate_first_step�warn_extraneous)� OdeSolver� DenseOutputc �L � � e Zd ZdZddej ddddddf � fd� Zd� Zd � Z� xZ S )
�LSODAa� Adams/BDF method with automatic stiffness detection and switching.
This is a wrapper to the Fortran solver from ODEPACK [1]_. It switches
automatically between the nonstiff Adams method and the stiff BDF method.
The method was originally detailed in [2]_.
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). The
vectorized implementation allows a faster approximation of the Jacobian
by finite differences (required for this solver).
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.
min_step : float, optional
Minimum allowed step size. Default is 0.0, i.e., the step size is not
bounded and determined solely by the solver.
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`.
jac : None or callable, optional
Jacobian matrix of the right-hand side of the system with respect to
``y``. The Jacobian matrix has shape (n, n) and its element (i, j) is
equal to ``d f_i / d y_j``. The function will be called as
``jac(t, y)``. If None (default), the Jacobian will be
approximated by finite differences. It is generally recommended to
provide the Jacobian rather than relying on a finite-difference
approximation.
lband, uband : int or None
Parameters defining the bandwidth of the Jacobian,
i.e., ``jac[i, j] != 0 only for i - lband <= j <= i + uband``. Setting
these requires your jac routine to return the Jacobian in the packed format:
the returned array must have ``n`` columns and ``uband + lband + 1``
rows in which Jacobian diagonals are written. Specifically
``jac_packed[uband + i - j , j] = jac[i, j]``. The same format is used
in `scipy.linalg.solve_banded` (check for an illustration).
These parameters can be also used with ``jac=None`` to reduce the
number of Jacobian elements estimated by finite differences.
vectorized : bool, optional
Whether `fun` is implemented in a vectorized fashion. A vectorized
implementation offers no advantages for this solver. 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.
nfev : int
Number of evaluations of the right-hand side.
njev : int
Number of evaluations of the Jacobian.
References
----------
.. [1] A. C. Hindmarsh, "ODEPACK, A Systematized Collection of ODE
Solvers," IMACS Transactions on Scientific Computation, Vol 1.,
pp. 55-64, 1983.
.. [2] L. Petzold, "Automatic selection of methods for solving stiff and
nonstiff systems of ordinary differential equations", SIAM Journal
on Scientific and Statistical Computing, Vol. 4, No. 1, pp. 136-148,
1983.
Ng g����MbP?g���ư>Fc
�T �� t |� � t � � � |||||
� � |�d}nt |||� � }|| j z }|t
j k rd}n|dk rt d� � �|dk rt d� � �t || | j � � \ }} t | j |
� � }|� d|| |||| | �� � |�
||� � | j |j j d< |j j |j j d< || _ d S )Nr z `max_step` must be positive.z `min_step` must be nonnegative.�lsoda)�rtol�atol�max_step�min_step�
first_step�lband�uband� )r �super�__init__r � direction�np�inf�
ValueErrorr �nr �fun�set_integrator�set_initial_value�t_bound� _integrator�rwork� call_args�
_lsoda_solver)�selfr �t0�y0r r r r r r �jacr r �
vectorized�
extraneous�solver� __class__s ��</usr/lib/python3/dist-packages/scipy/integrate/_ivp/lsoda.pyr zLSODA.__init__m sH �� � �
�#�#�#�
������b�"�g�z�:�:�:� � ��J�J�,�Z��W�E�E�J��d�n�$�
� �r�v� � ��H�H�
��]�]� � ;�<�<� <� �a�<�<� � >�?�?� ?�!�$��d�f�5�5�
��d��T�X�s�#�#��� � �g�D�t�h�'/�J�$)�� � 8� 8� 8� � � ��R�(�(�(� '+�l��� ��#�*0�*<�*B���$�Q�'� #����� c � � | j }|j }|j d }d|j d< |� |j |j pd� |j |j | j |j |j
� � \ |_ |_ ||j d< |� � � r>|j | _ |j | _ |j
d | _ |j
d | _ dS dS )N� � c � � d S )N� r3 r. r- �<lambda>z"LSODA._step_impl.<locals>.<lambda>� s � �T� r. � )TN)FzUnexpected istate in LSODA.)r$ r! r# �run�fr( �_y�tr �f_params�
jac_params�
successful�y�iwork�njev�nlu)r% r+ �
integrator�itasks r- �
_step_implzLSODA._step_impl� s� � ��#���'�
� �$�Q�'��"#�
� �Q� � (�n�n� �H�f�j�2�\�\�F�I�v�x� �L�&�/�6�+<� >� >��� �6�8� #(�
� �Q� � � � � � � 8��X�D�F��Y�D�F�"�(��,�D�I�!�'��+�D�H� �:�7�7r. c �2 � | j j j }| j j j }|d }|d }t j |dd|dz | j z z � | j |dz fd�� � � � � }t | j | j
|||� � S )N� � � r �F)�order) r$ r! r> r" r �reshaper �copy�LsodaDenseOutput�t_oldr9 )r% r> r" rI �h�yhs r- �_dense_output_implzLSODA._dense_output_impl� s� � ��"�.�4���"�.�4���b� �� �"�I��
�Z��b��u�q�y�D�F�&:�!:� :�;� �����+�3�8� 8� 8�8<���� � ��
�D�F�A�u�b�A�A�Ar. )
�__name__�
__module__� __qualname__�__doc__r r r rC rP �
__classcell__�r, s @r- r r s� �� � � � � �d� d�J 9=�s� �&�t�$�D����!$� !$� !$� !$� !$� !$�F8� 8� 8�. B� B� B� B� B� B� Br. r c �$ � � e Zd Z� fd�Zd� Z� xZS )rL c � �� t � � � ||� � || _ || _ t j |dz � � | _ d S )Nr )r r rN rO r �arange�p)r% rM r9 rN rI rO r, s �r- r zLsodaDenseOutput.__init__� sD �� �
�������"�"�"���������5�1�9�%�%����r. c �� � |j dk r|| j z
| j z | j z }n$|| j z
| j z | j d d �d f z }t j | j |� � S )Nr )�ndimr9 rN rZ r �dotrO )r% r9 �xs r- �
_call_implzLsodaDenseOutput._call_impl� sa � � �6�Q�;�;��d�f�*���&�4�6�1�A�A��d�f�*���&�4�6�!�!�!�T�'�?�:�A��v�d�g�q�!�!�!r. )rQ rR rS r r_ rU rV s @r- rL rL � sG �� � � � � �&� &� &� &� &� "� "� "� "� "� "� "r. rL )
�numpyr �scipy.integrater �commonr r r �baser r r rL r3 r. r- �<module>rd s� �� � � � � � � � � � � F� F� F� F� F� F� F� F� F� F� (� (� (� (� (� (� (� (�iB� iB� iB� iB� iB�I� iB� iB� iB�X
"�
"�
"�
"�
"�{�
"�
"�
"�
"�
"r.