
    5[gY                         d dl ZddlmZmZ ddlmZmZmZm	Z	m
Z
mZ ddlmZ dZdZdZd	 Z G d
 de      Z G d de      Z G d de      Z G d de      Z G d de      Z G d de      Zy)    N   )	OdeSolverDenseOutput)validate_max_stepvalidate_tolselect_initial_stepnormwarn_extraneousvalidate_first_step)dop853_coefficientsg?皙?
   c	                 T   ||d<   t        t        |dd |dd       d      D ]F  \  }	\  }
}t        j                  |d|	 j                  |
d|	       |z  } | |||z  z   ||z         ||	<   H ||t        j                  |dd j                  |      z  z   } | ||z   |      }||d<   ||fS )a8  Perform 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.
    r   r   Nstart)	enumeratezipnpdotT)funtyfhABCKsacdyy_newf_news                  R/var/www/html/bid-api/venv/lib/python3.12/site-packages/scipy/integrate/_ivp/rk.pyrk_stepr(      s    ^ AaDs1QR5!AB%0:	6AqVVAbqEGGQrU#a'1q1u9a"f%! ; BFF1Sb688Q'''EAuEAbE%<    c                   0    e Zd ZU dZeZej                  ed<   eZ	ej                  ed<   eZ
ej                  ed<   eZej                  ed<   eZej                  ed<   eZeed<   eZeed<   eZeed	<   ej"                  d
dddf fd	Zd Zd Zd Zd Z xZS )
RungeKuttaz,Base class for explicit Runge-Kutta methods.r   r   r   EPordererror_estimator_ordern_stagesMbP?ư>FNc
                    t        |
       t        | 	  |||||d       d | _        t	        |      | _        t        ||| j                        \  | _        | _	        | j                  | j                  | j                        | _        |	jt        | j                  | j                  | j                  ||| j                  | j                  | j                   | j                  | j                  
      | _        nt%        |	||      | _        t'        j(                  | j*                  dz   | j                  f| j                  j,                        | _        d| j                   dz   z  | _        d | _        y )NT)support_complexr   dtyper   )r
   super__init__y_oldr   max_stepr   nrtolatolr   r   r   r   r   	directionr/   h_absr   r   emptyr0   r6   r    error_exponent
h_previousselfr   t0y0t_boundr:   r<   r=   
vectorized
first_step
extraneous	__class__s              r'   r8   zRungeKutta.__init__U   s    	
#b"gz)- 	 	/
)(3+D$?	49$&&$&&),$&&$&&'8TVVT^^**DIItyyBDJ -ZWEDJ4==1,dff5TVV\\J D$>$>$BCr)   c                 \    t        j                  |j                  | j                        |z  S N)r   r   r   r,   )rD   r    r   s      r'   _estimate_errorzRungeKutta._estimate_errori   s     vvacc466"Q&&r)   c                 >    t        | j                  ||      |z        S rM   )r	   rN   )rD   r    r   scales       r'   _estimate_error_normzRungeKutta._estimate_error_norml   s    D((A.677r)   c                    | j                   }| j                  }| j                  }| j                  }| j                  }dt        j                  t        j                  || j                  t
        j                  z        |z
        z  }| j                  |kD  r|}n| j                  |k  r|}n| j                  }d}d}	|s||k  rd| j                  fS || j                  z  }
||
z   }| j                  || j                  z
  z  dkD  r| j                  }||z
  }
t        j                  |
      }t        | j                  ||| j                  |
| j                   | j"                  | j$                  | j&                  	      \  }}|t        j(                  t        j                  |      t        j                  |            |z  z   }| j+                  | j&                  |
|      }|dk  rF|dk(  rt,        }n$t/        t,        t0        || j2                  z  z        }|	rt/        d|      }||z  }d}n)|t5        t6        t0        || j2                  z  z        z  }d}	|s
| _        || _        | _         | _        || _
        | _        y)Nr   Fr   r   T)TN)r   r   r:   r<   r=   r   abs	nextafterr>   infr?   TOO_SMALL_STEPrG   r(   r   r   r   r   r   r    maximumrQ   
MAX_FACTORminSAFETYrA   max
MIN_FACTORrB   r9   )rD   r   r   r:   r<   r=   min_stepr?   step_acceptedstep_rejectedr   t_newr%   r&   rP   
error_normfactors                    r'   
_step_implzRungeKutta._step_implo   s/   FFFF==yyyyr||At~~/FG!KLL:: EZZ("EJJExd1111&AEE~~!56:	AFF1IE"488Q4661dff#'66466466;LE52::bffQi?$FFE224661eDJA~?'F !'*8K8K*K!KMF ! F^F $Z#jD4G4G&GGI I $E  H 

r)   c                     | j                   j                  j                  | j                        }t	        | j
                  | j                  | j                  |      S rM   )r    r   r   r-   RkDenseOutputt_oldr   r9   )rD   Qs     r'   _dense_output_implzRungeKutta._dense_output_impl   s9    FFHHLL TZZQ??r)   )__name__
__module____qualname____doc__NotImplementedr   r   ndarray__annotations__r   r   r,   r-   r.   intr/   r0   rU   r8   rN   rQ   rc   rh   __classcell__rK   s   @r'   r+   r+   J   s    6"Arzz""Arzz""Arzz""Arzz""Arzz"E3!/3/"Hc"68ff% ('8AF@r)   r+   c                      e Zd ZdZdZdZdZ ej                  g d      Z	 ej                  g dg dg dg      Z
 ej                  g d      Z ej                  g d	      Z ej                  g d
g dg dg dg      Zy)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 time derivative of the state ``y``
        at time ``t``. The calling signature is ``fun(t, y)``, where ``t`` is a
        scalar and ``y`` is an ndarray with ``len(y) = len(y0)``. ``fun`` must
        return an array of the same shape as ``y``. See `vectorized` for more
        information.
    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` may be called in a vectorized fashion. False (default)
        is recommended for this solver.

        If ``vectorized`` is False, `fun` will always be called with ``y`` of
        shape ``(n,)``, where ``n = len(y0)``.

        If ``vectorized`` is True, `fun` may be called with ``y`` of shape
        ``(n, k)``, where ``k`` is an integer. In this case, `fun` must behave
        such that ``fun(t, y)[:, i] == fun(t, y[:, i])`` (i.e. each column of
        the returned array is the time derivative of the state corresponding
        with a column of ``y``).

        Setting ``vectorized=True`` allows for faster finite difference
        approximation of the Jacobian by methods 'Radau' and 'BDF', but
        will result in slower execution for this solver.

    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         ?      ?)r   r   r   )rw   r   r   )r   rx   r   )gqq?gUUUUUU?gqq?)grqǱ?gUUUUUUgqqg      ?)r   gUUUUUUgrq?)r   r   gUUUUUU)r   gUUUUUU?gqq)r   r   r   Nri   rj   rk   rl   r.   r/   r0   r   arrayr   r   r   r,   r-    r)   r'   rt   rt      s    [x EHA 	A
 	!A)*A$  	Ar)   rt   c            
       *   e Zd ZdZdZdZdZ ej                  g d      Z	 ej                  g dg dg dg d	g d
g dg      Z
 ej                  g d      Z ej                  g d      Z ej                  g dg dg dg dg dg dg dg      Zy)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.
             )r   r   g333333?g?gqq?r   )r   r   r   r   r   )r   r   r   r   r   )g333333?g?r   r   r   )gII?ggqq@r   r   )gq@g 1'gR<6R#@gE3ҿr   )g+@g>%gr!@gE]t?g/pѿ)gUUUUUU?r   gVI?gUUUUU?gϡԿg10?)g2Tr   gĿ
UZkq?ggX
?g{tg?)r   g#
!gJ<@gFC)r   r   r   r   )r   gF@gFj'NgDg@)r   gdDgaP#$@g2)r   g<p@g@갘g,@)r   gRq#g_40g.
@gF)r   g'?g'gK@Nry   r{   r)   r'   r}   r}   %  s    Rf EH,-A#:= 	A 	BCA  	A 		#	"	"	&NFH 	IAr)   r}   c                   d    e Zd ZdZej
                  ZdZdZej                  dedef   Z	ej                  Z
ej                  de Zej                  Zej                  Zej                  Zej                  edz   d Zej                  edz   d Zej$                  ddddf fd		Zd
 Zd Zd Z xZS )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 literal 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>`_.
          Nr   r1   r2   Fc
                    t        |   |||||||||	f	i |
 t        j                  t        j
                  | j                  f| j                  j                        | _	        | j                  d | j                  dz    | _        y )Nr5   r   )r7   r8   r   r@   r   N_STAGES_EXTENDEDr;   r   r6   
K_extendedr0   r    rC   s              r'   r8   zDOP853.__init__  sz     	b"gxt#Z	?3=	?(($7$I$I$(FF$,3766<<A!3$--!"34r)   c                    t        j                  |j                  | j                        }t        j                  |j                  | j                        }t        j
                  t        j                  |      dt        j                  |      z        }t        j                  |      }|dkD  }t        j                  ||         ||   z  ||<   ||z  |z  S )Ng?r   )r   r   r   E5E3hypotrS   	ones_like)rD   r    r   err5err3denomcorrection_factormasks           r'   rN   zDOP853._estimate_error  s    vvacc477#vvacc477#sRVVD\'9:LL.qy"$&&d"4uT{"B$4x+++r)   c                    t        j                  |j                  | j                        |z  }t        j                  |j                  | j                        |z  }t         j
                  j                  |      dz  }t         j
                  j                  |      dz  }|dk(  r|dk(  ry|d|z  z   }t        j                  |      |z  t        j                  |t        |      z        z  S )Nrv   r   g        g{Gz?)
r   r   r   r   r   linalgr	   rS   sqrtlen)	rD   r    r   rP   r   r   err5_norm_2err3_norm_2r   s	            r'   rQ   zDOP853._estimate_error_norm  s    vvacc477#e+vvacc477#e+iinnT*A-iinnT*A-!q 0d[00vvay;&U1C)DDDr)   c                 .   | j                   }| j                  }t        t        | j                  | j
                        | j                  dz         D ]c  \  }\  }}t        j                  |d | j                  |d |       |z  }| j                  | j                  ||z  z   | j                  |z         ||<   e t        j                  t        j                  | j                   f| j                  j"                        }|d   }| j$                  | j                  z
  }	|	|d<   ||z  |	z
  |d<   d|	z  || j&                  |z   z  z
  |d<   |t        j                  | j(                  |      z  |dd  t+        | j                  | j,                  | j                  |      S )Nr   r   r5   r   rv   ru   )r   rB   r   r   A_EXTRAC_EXTRAr0   r   r   r   r   rf   r9   r@   r   INTERPOLATOR_POWERr;   r6   r   r   DDop853DenseOutputr   )
rD   r    r   r!   r"   r#   r$   Ff_olddelta_ys
             r'   rh   zDOP853._dense_output_impl  sX   OOOO"3t||T\\#B)-):<IAv1"12A'!+B88DJJQ.

R@AaD<
 HH)<<dffE::++- !&&4::%!5y7"!7{Q$&&5.11!BFF4661%%!" TVVTZZCCr)   )ri   rj   rk   rl   r   N_STAGESr0   r.   r/   r   r   r   r   r   r   r   r   r   rU   r8   rN   rQ   rh   rq   rr   s   @r'   r   r     s    Pb #++HEixi(23AAix(A			B			BA!##HqLM2G!##HqLM2G68ff% 5,EDr)   r   c                   $     e Zd Z fdZd Z xZS )re   c                     t         |   ||       ||z
  | _        || _        |j                  d   dz
  | _        || _        y )Nr   )r7   r8   r   rg   shaper.   r9   )rD   rf   r   r9   rg   rK   s        r'   r8   zRkDenseOutput.__init__)  s>    "UWWQZ!^

r)   c                    || j                   z
  | j                  z  }|j                  dk(  r9t        j                  || j
                  dz         }t        j                  |      }n<t        j                  || j
                  dz   df      }t        j                  |d      }| j                  t        j                  | j                  |      z  }|j                  dk(  r|| j                  d d d f   z  }|S || j                  z  }|S )Nr   r   )axisrv   )
rf   r   ndimr   tiler.   cumprodr   rg   r9   )rD   r   xpr   s        r'   
_call_implzRkDenseOutput._call_impl0  s    ^tvv%66Q;4::>*A

1ADJJNA./A

11%AFFRVVDFFA&&66Q;AtG$$A  OAr)   ri   rj   rk   r8   r   rq   rr   s   @r'   re   re   (  s    r)   re   c                   $     e Zd Z fdZd Z xZS )r   c                 V    t         |   ||       ||z
  | _        || _        || _        y rM   )r7   r8   r   r   r9   )rD   rf   r   r9   r   rK   s        r'   r8   zDop853DenseOutput.__init__B  s+    "U
r)   c                    || j                   z
  | j                  z  }|j                  dk(  r t        j                  | j
                        }nR|d d d f   }t        j                  t        |      t        | j
                        f| j
                  j                        }t        t        | j                              D ]   \  }}||z  }|dz  dk(  r||z  }|d|z
  z  }" || j
                  z  }|j                  S )Nr   r5   rv   r   )rf   r   r   r   
zeros_liker9   zerosr   r6   r   reversedr   r   )rD   r   r   r   ir   s         r'   r   zDop853DenseOutput._call_implH  s    ^tvv%66Q;djj)A!T'
A#a&#djj/2$**:J:JKAhtvv./DAqFA1uzQQU
 0 	
TZZss
r)   r   rr   s   @r'   r   r   A  s    r)   r   )numpyr   baser   r   commonr   r   r   r	   r
   r    r   rZ   r\   rX   r(   r+   rt   r}   r   re   r   r{   r)   r'   <module>r      s     (A A ! 


9xj@ j@Zk: k\oI: oIdNDZ NDbK 2 r)   