
     hj                      v    d dl Zd dlmZ ddlmZmZmZ ddlm	Z	m
Z
  G d de	          Z G d d	e
          ZdS )
    N)ode   )validate_tolvalidate_first_stepwarn_extraneous)	OdeSolverDenseOutputc            	       L     e Zd ZdZddej        ddddddf	 fd	Zd Zd	 Z xZ	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        gMbP?gư>Fc           
      T   t          |           t                                          |||||           |d}nt          |||          }|| j        z  }|t
          j        k    rd}n|dk    rt          d          |dk     rt          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                   V/var/www/html/Sam_Eipo/venv/lib/python3.11/site-packages/scipy/integrate/_ivp/lsoda.pyr   zLSODA.__init__m   sH    	
###b"gz:::JJ,ZWEEJdn$
rvHH]];<<<a<<>???!$df55
dTXs##gDth'/J$) 	 	8 	8 	8 	  R((( '+l #*0*<*B$Q'#    c           	         | j         }|j        }|j        d         }d|j        d<   |                    |j        |j        pd |j        |j        | j        |j	        |j
                  \  |_        |_        ||j        d<   |                                r>|j        | _        |j        | _        |j        d         | _        |j        d         | _        dS dS )N      c                      d S )N r3   r.   r-   <lambda>z"LSODA._step_impl.<locals>.<lambda>   s    T r.      )TN)FzUnexpected 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_implzLSODA._step_impl   s    #'
 $Q'"#
Q(nnHfj2\\FIvxL&/6+<> >	68 #(
Q 	8XDFYDF"(,DI!'+DH:77r.   c                 2   | j         j        j        }| j         j        j        }|d         }|d         }t	          j        |dd|dz   | j        z  z            | j        |dz   fd                                          }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_implzLSODA._dense_output_impl   s    ".4".4b	"IZbuqyDF&:!::;+38 8 88< 	  
DFAub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!$ !$ !$ !$ !$ !$F8 8 8.	B 	B 	B 	B 	B 	B 	Br.   r   c                   $     e Zd Z fdZd Z xZS )rL   c                     t                                          ||           || _        || _        t	          j        |dz             | _        d S )Nr   )r   r   rN   rO   r   arangep)r%   rM   r9   rN   rI   rO   r,   s         r-   r   zLsodaDenseOutput.__init__   sD    """519%%r.   c                     |j         dk    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_implzLsodaDenseOutput._call_impl   sa    6Q;;df*&461AAdf*&46!!!T'?:Avdgq!!!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 ( ( ( ( ( ( ( (iB iB iB iB iBI iB iB iBX" " " " "{ " " " " "r.   