
    wg&                         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__     Y/home/mcse/projects/flask/flask-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   iiH9%%A
b'C
B
B
A
A88D1: q 	AA,C(.s1v711aAh7A7FAIIaLIIaL	 !:&ar&&qs 	$ACAQAA1Q3Z s )AaDA1aL(D)!A#a%[qb)Q	
 Gcggaj(E3Z $te|!Aad#$	$  WWF Bb6SRV_a!@AFB aKF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5AAddGQ'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    r6$a(s$%%qs##%b/KCR<BxGHbe$AB aQ&AGC$$R(R}-Bw"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    KKNxx	CH$Q-KCRad#ACH"#$BRC$$aD5L	 CH$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'(+88B;.C#''	"--Fxx"}HB aR6:GC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GOO r   