Ë
    3^(h´&  ã                   ó„   — d dl m Z  ddlmZ  G d„ de«      Zd„ Zd
d„Zee_        ed	k(  rd dlZ ej                  «        yy)é    )Úbisecté   )Úxrangec                   ó   — e Zd Zy)Ú
ODEMethodsN)Ú__name__Ú
__module__Ú__qualname__© ó    úR/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/mpmath/calculus/odes.pyr   r      s   „ Ør   r   c                 óä  — | j                  d| «      x}}t        |«      }|g}	|g}
|}|}| j                  }	 |d|z   z  | _        t        |«      D ]_  } |||«      }t	        t        |«      «      D �cg c]  }||   |||   z  z   ‘Œ }}||z  }|	j                  |«       |
j                  |«       Œa t        |«      D �cg c]  }g ‘Œ }}t        |dz   «      D ]©  }dg|z  }d|dz  z  }d}t        |dz   «      D ]<  }t        |«      D ]  }||xx   ||
|   |   z  z  cc<   Œ |||z
  dz   z  | z  }|dz  }Œ> || z  | j                  |«      z  }t        |«      D ]$  }||   |z  ||<   ||   j                  ||   «       Œ& Œ« 	 || _        | j                  }|D ]3  }|d   sŒ	t        || j                  |t        |d   «      z  |«      «      }Œ5 |dz  }|||z   fS c c}w c c}w # || _        w xY w)Né   r   éÿÿÿÿr   )ÚldexpÚlenÚprecÚranger   ÚappendÚfacÚoneÚminÚnthrootÚabs)ÚctxÚderivsÚx0Úy0Útol_precÚnÚhÚtolÚdimÚxsÚysÚxÚyÚorigÚiÚfxyÚdÚserÚjÚsÚbÚkÚscaleÚradiusÚtss                            r   Ú
ode_taylorr4      sB  € Ø�i‰i˜˜H˜9Ó%Ð%€AˆÜ
ˆb‹'€CØ
ˆ€BØ
ˆ€BØ
€AØ
€AØ�8‰8€DðØ˜˜1™‘:ˆŒô �q“ò 	ˆAÙ˜˜A“,ˆCÜ(.¬s°1«v«Ö7 1��1‘�a˜˜A™‘h“Ð7ˆAÐ7Ø�‰FˆAØ�I‰I�aŒLØ�I‰I�a�Lð	ô ! ›:Ö&�aŠrÐ&ˆÐ&Ü�q˜‘s“ò 	$ˆAØ��C‘ˆAØ˜˜Q™‘ˆAØˆAÜ˜1˜Q™3“Zò �Ü˜s›ò )�AØ�a“D˜A  1¡ a¡™LÑ(”Dð)à˜!˜A™#˜a™%‘[ q bÑ)�Ø�Q‘‘ð	ð
 ˜˜‘G˜cŸg™g a›jÑ(ˆEÜ˜3“Zò $�Ø˜‘t˜e‘|��!‘Ø�A‘—‘˜a ™dÕ#ñ$ñ	$ð ˆŒð �W‰W€FØò BˆØˆb‹6Ü˜ §¡¨S´°R¸±V³©_¸aÓ!@ÓA‰FðBð ˆa�K€FØ��6‘	ˆ>Ðùò9 8ùò
 'øð ˆ�ús*   ¸:G& Á2GÂ8G& Â?	G!ÃB<G& Ç
G& Ç&	G/Nc           	      ó¦  ‡ ‡‡‡‡‡‡‡‡‡‡‡‡— |r t        ‰ j                  |d«       «      dz   Šn‰ j                  dz   Š‰xs dt        d‰ j                  z  dz  «      z   Š‰ j                  dz   Š	 t	        |«       dŠt        ‰ ‰‰|‰‰«      \  }}	‰|	gŠ|‰|	fgŠˆ fd	„Šˆˆ ˆˆˆˆˆˆˆf	d
„Šˆ ˆˆˆˆfd„}
|
S # t
        $ r ‰Šˆfd„Š|g}dŠY ŒQw xY w)aû  
    Returns a function `y(x) = [y_0(x), y_1(x), \ldots, y_n(x)]`
    that is a numerical solution of the `n+1`-dimensional first-order
    ordinary differential equation (ODE) system

    .. math ::

        y_0'(x) = F_0(x, [y_0(x), y_1(x), \ldots, y_n(x)])

        y_1'(x) = F_1(x, [y_0(x), y_1(x), \ldots, y_n(x)])

        \vdots

        y_n'(x) = F_n(x, [y_0(x), y_1(x), \ldots, y_n(x)])

    The derivatives are specified by the vector-valued function
    *F* that evaluates
    `[y_0', \ldots, y_n'] = F(x, [y_0, \ldots, y_n])`.
    The initial point `x_0` is specified by the scalar argument *x0*,
    and the initial value `y(x_0) =  [y_0(x_0), \ldots, y_n(x_0)]` is
    specified by the vector argument *y0*.

    For convenience, if the system is one-dimensional, you may optionally
    provide just a scalar value for *y0*. In this case, *F* should accept
    a scalar *y* argument and return a scalar. The solution function
    *y* will return scalar values instead of length-1 vectors.

    Evaluation of the solution function `y(x)` is permitted
    for any `x \ge x_0`.

    A high-order ODE can be solved by transforming it into first-order
    vector form. This transformation is described in standard texts
    on ODEs. Examples will also be given below.

    **Options, speed and accuracy**

    By default, :func:`~mpmath.odefun` uses a high-order Taylor series
    method. For reasonably well-behaved problems, the solution will
    be fully accurate to within the working precision. Note that
    *F* must be possible to evaluate to very high precision
    for the generation of Taylor series to work.

    To get a faster but less accurate solution, you can set a large
    value for *tol* (which defaults roughly to *eps*). If you just
    want to plot the solution or perform a basic simulation,
    *tol = 0.01* is likely sufficient.

    The *degree* argument controls the degree of the solver (with
    *method='taylor'*, this is the degree of the Taylor series
    expansion). A higher degree means that a longer step can be taken
    before a new local solution must be generated from *F*,
    meaning that fewer steps are required to get from `x_0` to a given
    `x_1`. On the other hand, a higher degree also means that each
    local solution becomes more expensive (i.e., more evaluations of
    *F* are required per step, and at higher precision).

    The optimal setting therefore involves a tradeoff. Generally,
    decreasing the *degree* for Taylor series is likely to give faster
    solution at low precision, while increasing is likely to be better
    at higher precision.

    The function
    object returned by :func:`~mpmath.odefun` caches the solutions at all step
    points and uses polynomial interpolation between step points.
    Therefore, once `y(x_1)` has been evaluated for some `x_1`,
    `y(x)` can be evaluated very quickly for any `x_0 \le x \le x_1`.
    and continuing the evaluation up to `x_2 > x_1` is also fast.

    **Examples of first-order ODEs**

    We will solve the standard test problem `y'(x) = y(x), y(0) = 1`
    which has explicit solution `y(x) = \exp(x)`::

        >>> from mpmath import *
        >>> mp.dps = 15; mp.pretty = True
        >>> f = odefun(lambda x, y: y, 0, 1)
        >>> for x in [0, 1, 2.5]:
        ...     print((f(x), exp(x)))
        ...
        (1.0, 1.0)
        (2.71828182845905, 2.71828182845905)
        (12.1824939607035, 12.1824939607035)

    The solution with high precision::

        >>> mp.dps = 50
        >>> f = odefun(lambda x, y: y, 0, 1)
        >>> f(1)
        2.7182818284590452353602874713526624977572470937
        >>> exp(1)
        2.7182818284590452353602874713526624977572470937

    Using the more general vectorized form, the test problem
    can be input as (note that *f* returns a 1-element vector)::

        >>> mp.dps = 15
        >>> f = odefun(lambda x, y: [y[0]], 0, [1])
        >>> f(1)
        [2.71828182845905]

    :func:`~mpmath.odefun` can solve nonlinear ODEs, which are generally
    impossible (and at best difficult) to solve analytically. As
    an example of a nonlinear ODE, we will solve `y'(x) = x \sin(y(x))`
    for `y(0) = \pi/2`. An exact solution happens to be known
    for this problem, and is given by
    `y(x) = 2 \tan^{-1}\left(\exp\left(x^2/2\right)\right)`::

        >>> f = odefun(lambda x, y: x*sin(y), 0, pi/2)
        >>> for x in [2, 5, 10]:
        ...     print((f(x), 2*atan(exp(mpf(x)**2/2))))
        ...
        (2.87255666284091, 2.87255666284091)
        (3.14158520028345, 3.14158520028345)
        (3.14159265358979, 3.14159265358979)

    If `F` is independent of `y`, an ODE can be solved using direct
    integration. We can therefore obtain a reference solution with
    :func:`~mpmath.quad`::

        >>> f = lambda x: (1+x**2)/(1+x**3)
        >>> g = odefun(lambda x, y: f(x), pi, 0)
        >>> g(2*pi)
        0.72128263801696
        >>> quad(f, [pi, 2*pi])
        0.72128263801696

    **Examples of second-order ODEs**

    We will solve the harmonic oscillator equation `y''(x) + y(x) = 0`.
    To do this, we introduce the helper functions `y_0 = y, y_1 = y_0'`
    whereby the original equation can be written as `y_1' + y_0' = 0`. Put
    together, we get the first-order, two-dimensional vector ODE

    .. math ::

        \begin{cases}
        y_0' = y_1 \\
        y_1' = -y_0
        \end{cases}

    To get a well-defined IVP, we need two initial values. With
    `y(0) = y_0(0) = 1` and `-y'(0) = y_1(0) = 0`, the problem will of
    course be solved by `y(x) = y_0(x) = \cos(x)` and
    `-y'(x) = y_1(x) = \sin(x)`. We check this::

        >>> f = odefun(lambda x, y: [-y[1], y[0]], 0, [1, 0])
        >>> for x in [0, 1, 2.5, 10]:
        ...     nprint(f(x), 15)
        ...     nprint([cos(x), sin(x)], 15)
        ...     print("---")
        ...
        [1.0, 0.0]
        [1.0, 0.0]
        ---
        [0.54030230586814, 0.841470984807897]
        [0.54030230586814, 0.841470984807897]
        ---
        [-0.801143615546934, 0.598472144103957]
        [-0.801143615546934, 0.598472144103957]
        ---
        [-0.839071529076452, -0.54402111088937]
        [-0.839071529076452, -0.54402111088937]
        ---

    Note that we get both the sine and the cosine solutions
    simultaneously.

    **TODO**

    * Better automatic choice of degree and step size
    * Make determination of Taylor series convergence radius
      more robust
    * Allow solution for `x < x_0`
    * Allow solution for complex `x`
    * Test for difficult (ill-conditioned) problems
    * Implement Runge-Kutta and other algorithms

    r   é
   é   g       @é(   Tc                 ó   •—  ‰| |d   «      gS ©Nr   r   )r&   r'   ÚF_s     €r   ú<lambda>zodefun.<locals>.<lambda>ñ   s   ø€ ™"˜Q  !¡›+˜€ r   Fc           	      óZ   •— | D �cg c]  }‰j                  |d d d…   |«      ‘Œ c}S c c}w )Nr   )Úpolyval)r,   Úar.   r   s      €r   Úmpolyvalzodefun.<locals>.mpolyvalø   s*   ø€ Ø14Ö5¨A�—‘˜A™d ˜d™G QÕ'Ò5Ð5ùÒ5s   †(c                 ó8  •	— | ‰k  rt         ‚t        ‰
| «      }|t        ‰
«      k  r‰|dz
     S 	 ‰d   \  }}}‰rt        d||fz  «        ‰	|||z
  «      }|}t	        ‰‰||‰‰«      \  }}‰
j                  |«       ‰j                  |||f«       | |k  r‰d   S Œl)Nr   r   z$Computing Taylor series for [%f, %f])Ú
ValueErrorr   r   Úprintr4   r   )r&   r    r,   ÚxaÚxbr'   ÚFr   Údegreer@   Úseries_boundariesÚseries_datar   Úverboser   s         €€€€€€€€€r   Ú
get_serieszodefun.<locals>.get_seriesû   sÆ   ø€ ØˆrŠ6ÜÐÜÐ$ aÓ(ˆØŒsÐ$Ó%Ò%Ø˜q ™sÑ#Ð#ØØ% b™/‰KˆC��RÙÜÐ<ÀÀB¸xÑGÔHÙ˜˜b ™eÓ$ˆAØˆBÜ   a¨¨Q°¸&ÓA‰GˆC�Ø×$Ñ$ RÔ(Ø×Ñ  R¨˜}Ô-Ø�BŠwØ" 2‘Ð&ð r   c                 óà   •— ‰j                  | «      } ‰j                  }	 ‰‰_         ‰| «      \  }}} ‰	|| |z
  «      }|‰_        ‰
r|D �cg c]  }|­‘Œ c}S |d   ­S # |‰_        w xY wc c}w r:   )Úconvertr   )r&   r(   r,   rD   rE   r'   Úykr   rK   r@   Úreturn_vectorÚworkprecs          €€€€€r   Úinterpolantzodefun.<locals>.interpolant  sy   ø€ Ø�K‰K˜‹NˆØ�x‰xˆð	ØˆCŒHÙ$ Q›-‰KˆC��RÙ˜˜a ™dÓ#ˆAàˆCŒHÙØ"#Ö$˜B�R’CÒ$Ð$à�a‘D�5ˆLøð	 ˆC�Hüâ$s    A Á
A+Á	A()ÚintÚlogr   Údpsr   Ú	TypeErrorr4   )r   rF   r   r   r"   rG   ÚmethodrJ   r,   rE   rQ   r;   rK   r@   rO   rH   rI   r   rP   s   ```  ` `   @@@@@@@@r   ÚodefunrW   3   së   ÿü€ ñf Ü˜Ÿ™  Q›Ð'Ó(¨Ñ+‰à—8‘8˜B‘;ˆØÒ.˜œC  #§'¡'¡	¨"¡Ó-Ñ-€FØ�x‰x˜"‰}€HðÜˆBŒØˆô ˜˜a  R¨°6Ó:�G€CˆØ˜R˜ÐØ˜˜R�=�/€Kô6÷'ô '÷$ð ð ÐøôW ò ØˆÛ&ˆØˆTˆØŠð	ús   Á1B8 Â8CÃCÚ__main__)NNÚtaylorF)
r   Úlibmp.backendr   Úobjectr   r4   rW   r   ÚdoctestÚtestmodr   r   r   ú<module>r^      sJ   ðÝ Ý "ô	�ô 	ò*óXgðR €
Ô àˆzÒÛØ€G‡O�OÕð r   