在固定网格上求解常微分方程（最好在python中）

Question

I have a differential equation of the form

dy(x)/dx = f(y,x)

that I would like to solve for y .

I have an array xs containing all of the values of x for which I need ys .

For only those values of x , I can evaluate f(y,x) for any y .

How can I solve for ys , preferably in python?

MWE

import numpy as np

# these are the only x values that are legal
xs = np.array([0.15, 0.383, 0.99, 1.0001])

# some made up function --- I don't actually have an analytic form like this
def f(y, x):
    if not np.any(np.isclose(x, xs)):
        return np.nan
    return np.sin(y + x**2) 

# now I want to know which array of ys satisfies dy(x)/dx = f(y,x)

Answer 1

Assuming you can use something simple like Forward Euler...

Numerical solutions will rely on approximate solutions at previous times. So if you want a solution at t = 1 it is likely you will need the approximate solution at t<1 .

My advice is to figure out what step size will allow you to hit the times you need, and then find the approximate solution on an interval containing those times.

import numpy as np

#from your example, smallest step size required to hit all would be 0.0001.

a = 0 #start point
b = 1.5 #possible end point
h = 0.0001
N = float(b-a)/h

y = np.zeros(n)
t = np.linspace(a,b,n)
y[0] = 0.1 #initial condition here

for i in range(1,n):
   y[i] = y[i-1] + h*f(t[i-1],y[i-1])

Alternatively, you could use an adaptive step method (which I am not prepared to explain right now) to take larger steps between the times you need.

Or, you could find an approximate solution over an interval using a coarser mesh and interpolate the solution.

Any of these should work.

Answer 2

I think you should first solve ODE on a regular grid, and then interpolate solution on your fixed grid. The approximate code for your problem

import numpy as np
from scipy.integrate import odeint
from scipy import interpolate

xs = np.array([0.15, 0.383, 0.99, 1.0001])

# dy/dx = f(x,y)
def dy_dx(y, x):
    return np.sin(y + x ** 2)

y0 = 0.0 # init condition
x = np.linspace(0, 10, 200)# here you can control an accuracy
sol = odeint(dy_dx, y0, x)
f = interpolate.interp1d(x, np.ravel(sol))
ys = f(xs)

But dy_dx(y, x) should always return something reasonable (not np.none). Here is the drawing for this case