用Python进行数学建模（二）

微分方程是描述系统的状态随时间和空间演化的数学工具。物理中许多涉及变力的运动学、动力学问题，如空气的阻力为速度函数的落体运动等问题，很多可以用微分方程求解。微分方程在化学、工程学、经济学和人口统计等领域也有广泛应用。

具体来说，微分方程是指含有未知函数及其导数的关系式。

微分方程的数学建模其实并不复杂，基本过程就是分析题目属于哪一类问题、可以选择什么微分方程模型，然后如何使用现有的微分方程模型建模。

1.微分方程的数值解法

微分方程的数值求解是先把时间和空间离散化，然后将微分化为差分，建立递推关系，然后反复进行迭代计算，得到任意时间和空间的值。

2.SciPy 求解常微分方程（组）

一阶常微分方程（组）模型

2.scipy.integrate.odeint() 函数

函数原型

参数解释
func:callable(y, t, …) or callable(t, y, …)
计算y在t点的导数。如果签名是可调用的(t, y，…)，那么参数tfirst必须设置为True。
y0:array
y的初始条件 (可以是vector).
t:array
要解出y的时间点序列。初值点应该是这个序列的第一个元素。这个序列必须是单调递增或单调递减的;允许重复值。
args:tuple, optional
向导数函数 func 传递参数。当导数函数 f ( y , t , p 1 , p 2 , . . ) f(y,t,p1,p2,…)f(y,t,p1,p2,…) 包括可变参数 p1,p2… 时，通过 args =(p1,p2,…) 可以将参数p1,p2… 传递给导数函数 func。

odeint 的主要返回值
y: array
数组，形状为 (len(t),len(y0)，给出时间序列 t 中每个时刻的 y 值。

3.Scipy 求解一阶常微分方程

scipy.integrate.odeint() 求解常微分方程初值问题的步骤

2.求微分方程的数值解

from scipy.integrate import odeint  # 导入 scipy.integrate 模块import numpy as npimport matplotlib.pyplot as pltdef dy_dt(y, t):  # 定义函数 f(y,t)    return np.sin(t**2)y0 = [1]  # y0 = 1 也可以t = np.arange(-10,10,0.01)  # (start,stop,step)y = odeint(dy_dt, y0, t)  # 求解微分方程初值问题# 绘图plt.plot(t, y)plt.title("scipy.integrate.odeint")plt.show()

4.Scipy 求解一阶常微分方程组

求洛伦兹（Lorenz）方程的数值解

2.洛伦兹（Lorenz）方程问题的编程步骤

3.代码

from scipy.integrate import odeint  # 导入 scipy.integrate 模块import numpy as npimport matplotlib.pyplot as pltfrom mpl_toolkits.mplot3d import Axes3D# 导数函数, 求 W=[x,y,z] 点的导数 dW/dtdef lorenz(W, t, p, r, b):    x, y, z = W  # W=[x,y,z]    dx_dt = p * (y - x)  # dx/dt = p*(y-x), p: sigma    dy_dt = x * (r - z) - y  # dy/dt = x*(r-z)-y, r:rho    dz_dt = x * y - b * z  # dz/dt = x*y - b*z, b;beta    return np.array([dx_dt, dy_dt, dz_dt])t = np.arange(0, 30, 0.01)  # 创建时间点 (start,stop,step)paras = (10.0, 28.0, 3.0)  # 设置 Lorenz 方程中的参数 (p,r,b)# 调用ode对lorenz进行求解, 用两个不同的初始值 W1、W2 分别求解W1 = (0.0, 1.00, 0.0)  # 定义初值为 W1track1 = odeint(lorenz, W1, t, args=(10.0, 28.0, 3.0))  # args 设置导数函数的参数W2 = (0.0, 1.01, 0.0)  # 定义初值为 W2track2 = odeint(lorenz, W2, t, args=paras)  # 通过 paras 传递导数函数的参数# 绘图fig = plt.figure()ax = Axes3D(fig, auto_add_to_figure=False)fig.add_axes(ax)ax.plot(track1[:, 0], track1[:, 1], track1[:, 2], color='magenta')  # 绘制轨迹 1ax.plot(track2[:, 0], track2[:, 1], track2[:, 2], color='deepskyblue')  # 绘制轨迹 2ax.set_title("Lorenz attractor by scipy.integrate.odeint")plt.show()

结果

5.Scipy 求解高阶常微分方程

高阶常微分方程，必须做变量替换，化为一阶微分方程组，再用 odeint 求数值解。
1.求二阶 RLC 振荡电路的数值解

2.二阶微分方程问题的编程步骤

3.代码

from scipy.integrate import odeint  # 导入 scipy.integrate 模块import numpy as npimport matplotlib.pyplot as plt# 导数函数，求 Y=[u,v] 点的导数 dY/dtdef deriv(Y, t, a, w):    u, v = Y  # Y=[u,v]    dY_dt = [v, -2 * a * v - w * w * u]    return dY_dtt = np.arange(0, 20, 0.01)  # 创建时间点 (start,stop,step)# 设置导数函数中的参数 (a, w)paras1 = (1, 0.6)  # 过阻尼：a^2 - w^2 > 0paras2 = (1, 1)  # 临界阻尼：a^2 - w^2 = 0paras3 = (0.3, 1)  # 欠阻尼：a^2 - w^2 < 0# 调用ode对进行求解, 用两个不同的初始值 W1、W2 分别求解Y0 = (1.0, 0.0)  # 定义初值为 Y0=[u0,v0]Y1 = odeint(deriv, Y0, t, args=paras1)  # args 设置导数函数的参数Y2 = odeint(deriv, Y0, t, args=paras2)  # args 设置导数函数的参数Y3 = odeint(deriv, Y0, t, args=paras3)  # args 设置导数函数的参数# 绘图plt.plot(t, Y1[:, 0], 'r-', label='u1(t)')plt.plot(t, Y2[:, 0], 'b-', label='u2(t)')plt.plot(t, Y3[:, 0], 'g-', label='u3(t)')plt.plot(t, Y1[:, 1], 'r:', label='v1(t)')plt.plot(t, Y2[:, 1], 'b:', label='v2(t)')plt.plot(t, Y3[:, 1], 'g:', label='v3(t)')plt.axis([0, 20, -0.8, 1.2])plt.legend(loc='best')plt.title("Second ODE by scipy.integrate.odeint")plt.show()

结果

微分方程是指含有未知函数及其导数的关系式。

微分方程是描述系统的状态随时间和空间演化的数学工具。

微分方程分为初值问题和边值问题。初值问题是已知微分方程的初始条件，即自变量为零时的函数值，一般可以用欧拉法、龙哥库塔法来求解。边值问题则是已知微分方程的边界条件，即自变量在边界点时的函数值。

1.常微分方程边值问题的数学模型

2.SciPy 求解常微分方程边值问题

BVP 问题的标准形式

2.scipy.integrate.solve_bvp() 函数
可以求解一阶微分方程（组）的两点边值问题（第一类边界条件）。

solve_bvp 的主要参数：
func: callable fun(x, y, …) 　　导数函数 f ( y , x ) f(y,x)f(y,x) ， y 在 x 处的导数，以函数的形式表示。可以带有参数 p。
bc: callable bc(ya, yb, …) 　　边界条件，y 在两点边界的函数，以函数的形式表示。可以带有参数 p。
x: array：　　初始网格的序列，shape (m,)。必须是单调递增的实数序列，起止于两点边界值 xa，xb。
y: array：　　网格节点处函数值的初值，shape (n,m)，第 i 列对应于 x[i]。

solve_bvp 的主要返回值：
sol: PPoly 　　通过 PPoly （如三次连续样条函数）插值求出网格节点处的 y 值。
x: array 　　数组，形状为 (m,)，最终输出的网格节点。
y: array 　　二维数组，形状为 (n,m)，输出的网格节点处的 y 值。
yp: array 　　二维数组，形状为 (n,m)，输出的网格节点处的 y’ 值。

3.一阶常微分方程边值问题

标准化

2.编程步骤

3.代码

from scipy.integrate import odeint, solve_bvpimport numpy as npimport matplotlib.pyplot as plt# 1. 求解微分方程组边值问题，DEMO# y'' + abs(y) = 0, y(0)=0.5, y(4)=-1.5# 导数函数，计算导数 dY/dxdef dydx(x, y):    dy0 = y[1]    dy1 = -abs(y[0])    return np.vstack((dy0, dy1))# 计算 边界条件def boundCond(ya, yb):    fa = 0.5  # 边界条件 y(xa=0) = 0.5    fb = -1.5  # 边界条件 y(xb=4) = -1.5    return np.array([ya[0] - fa, yb[0] - fb])xa, xb = 0, 4  # 边界点 (xa,xb)# fa, fb = 0.5, -1.5  # 边界点的 y值xini = np.linspace(xa, xb, 11)  # 确定 x 的初值yini = np.zeros((2, xini.size))  # 确定 y 的初值res = solve_bvp(dydx, boundCond, xini, yini)  # 求解 BVPxSol = np.linspace(xa, xb, 100)  # 输出的网格节点ySol = res.sol(xSol)[0]  # 网格节点处的 y 值plt.plot(xSol, ySol, label='y')plt.xlabel("x")plt.ylabel("y")plt.title("scipy.integrate.solve_bvp")plt.show()

执行结果

4.水滴横截面的形状

from scipy.integrate import odeint, solve_bvpimport numpy as npimport matplotlib.pyplot as plt# 3. 求解微分方程边值问题，水滴的横截面# 导数函数，计算 h=[h0,h1] 点的导数 dh/dxdef dhdx(x, h):    # 计算 dh0/dx, dh1/dx 的值    dh0 = h[1]  # 计算 dh0/dx    dh1 = (h[0] - 1) * (1 + h[1] * h[1]) ** 1.5  # 计算 dh1/dx    return np.vstack((dh0, dh1))# 计算 边界条件def boundCond(ha, hb):    # ha = 0  # 边界条件：h0(x=-1) = 0    # hb = 0  # 边界条件：h0(x=1) = 0    return np.array([ha[0], hb[0]])xa, xb = -1, 1  # 边界点 (xa=0, xb=1)xini = np.linspace(xa, xb, 11)  # 设置 x 的初值hini = np.zeros((2, xini.size))  # 设置 h 的初值res = solve_bvp(dhdx, boundCond, xini, hini)  # 求解 BVP# scipy.integrate.solve_bvp(fun, bc, x, y,..)#   fun(x, y, ..), 导数函数 f(y,x)，y在 x 处的导数。#   bc(ya, yb, ..), 边界条件，y 在两点边界的函数。#   x: shape (m)，初始网格的序列，起止于两点边界值 xa，xb。#   y: shape (n,m)，网格节点处函数值的初值，第 i 列对应于 x[i]。xSol = np.linspace(xa, xb, 100)  # 输出的网格节点hSol = res.sol(xSol)[0]  # 网格节点处的 h 值plt.plot(xSol, hSol, label='h(x)')plt.xlabel("x")plt.ylabel("h(x)")plt.axis([-1, 1, 0, 1])plt.title("Cross section of water drop by BVP")plt.show()

5.带有未知参数的微分方程边值问题

from scipy.integrate import odeint, solve_bvpimport numpy as npimport matplotlib.pyplot as plt# 4. 求解微分方程组边值问题，Mathieu 方程# y0' = y1, y1' = -(lam-2*q*cos(2x))y0)# y0(0)=1, y1(0)=0, y1(pi)=0# 导数函数，计算导数 dY/dxdef dydx(x, y, p):  # p 是待定参数    lam = p[0]    q = 10    dy0 = y[1]    dy1 = -(lam - 2 * q * np.cos(2 * x)) * y[0]    return np.vstack((dy0, dy1))# 计算 边界条件def boundCond(ya, yb, p):    lam = p[0]    return np.array([ya[0] - 1, ya[0], yb[0]])xa, xb = 0, np.pi  # 边界点 (xa,xb)xini = np.linspace(xa, xb, 11)  # 确定 x 的初值xSol = np.linspace(xa, xb, 100)  # 输出的网格节点for k in range(5):    A = 0.75 * k    y0ini = np.cos(8 * xini)  # 设置 y0 的初值    y1ini = -A * np.sin(8 * xini)  # 设置 y1 的初值    yini = np.vstack((y0ini, y1ini))  # 确定 y=[y0,y1] 的初值    res = solve_bvp(dydx, boundCond, xini, yini, p=[10])  # 求解 BVP    y0 = res.sol(xSol)[0]  # 网格节点处的 y 值    y1 = res.sol(xSol)[1]  # 网格节点处的 y 值    plt.plot(xSol, y0, '--')    plt.plot(xSol, y1, '-', label='A = {:.2f}'.format(A))plt.xlabel("hbu")plt.ylabel("y")plt.title("Characteristic function of Mathieu equation")plt.axis([0, np.pi, -5, 5])plt.legend(loc='best')plt.text(2, -4, "hao-hbu", color='whitesmoke')plt.show()

1.非线性规划问题的描述

2.scipy.optimize.brent() 求解单变量无约束优化问题

非线性规划最简单的形式是一维搜索，一维搜索的常用方法是函数逼近法和区间收缩法。

brent() 函数是 SciPy.optimize 模块中求解单变量无约束优化问题最小值的首选方法。这是牛顿法和二分法的混合方法，既能保证稳定性又能快速收敛。

optimize.brent() 的主要参数：
func: callable f(x,args) 　　目标函数 f ( x ) f(x)f(x)，以函数形式表示，可以通过 *args 传递参数
args: tuple　　可选项，以 f(x,*args) 的形式将可变参数 p 传递给目标函数 f ( x , p ) f(x,p)f(x,p) 。
brack: tuple　　可选项，搜索算法的开始区间（不是指 x 的上下限）

optimize.brent() 的主要返回值：
xmin: 　　返回函数达到最小值时的 x（注意是局部最优，不一定是全局最优）。
fval: 　　返回函数的最优值（默认不返回，仅当 full_output 为 1 时返回）。

optimize.brent() 的使用例程：

import numpy as npfrom scipy.optimize import brentimport matplotlib.pyplot as plt# 1. Demo1：单变量无约束优化问题(Scipy.optimize.brent)def objf(x):  # 目标函数    fx = x ** 2 - 8 * np.sin(2 * x + np.pi)    return fxxIni = -5.0xOpt = brent(objf, brack=(xIni, 2))print("xIni={:.4f}\tfxIni={:.4f}".format(xIni, objf(xIni)))print("xOpt={:.4f}\tfxOpt={:.4f}".format(xOpt, objf(xOpt)))x = np.linspace(-10, 10, 500)plt.plot(x, objf(x))plt.xlabel("x")plt.ylabel("objf(x)")plt.text(xIni, objf(xIni), "Initial")plt.text(xOpt, objf(xOpt), "Best")plt.scatter(xIni, objf(xIni))plt.scatter(xOpt, objf(xOpt))plt.show()

运行结果：

3.scipy.optimize.fmin() 求解多变量无约束优化问题

fmin() 函数是 SciPy.optimize 模块中求解多变量无约束优化问题（最小值）的首选方法，采用下山单纯性方法。下山单纯性方法又称 Nelder-Mead 法，只使用目标函数值，不需要导数或二阶导数值，是最重要的多维无约束优化问题数值方法之一。

from scipy.optimize import brent, fmin, minimizeimport numpy as np​# 2. Demo2：多变量无约束优化问题(Scipy.optimize.brent)# Rosenbrock 测试函数def objf2(x):  # Rosenbrock benchmark function    fx = sum(100.0 * (x[1:] - x[:-1] ** 2.0) ** 2.0 + (1 - x[:-1]) ** 2.0)    return fx​xIni = np.array([-2, -2])xOpt = fmin(objf2, xIni)print("xIni={:.4f},{:.4f}\tfxIni={:.4f}".format(xIni[0],xIni[1],objf2(xIni)))print("xOpt={:.4f},{:.4f}\tfxOpt={:.4f}".format(xOpt[0],xOpt[1],objf2(xOpt)))

4.scipy.optimize.minimize() 求解非线性规划问题

minimize() 函数是 SciPy.optimize 模块中求解多变量优化问题的通用方法，可以调用多种算法，支持约束优化和无约束优化。

import numpy as npfrom scipy.optimize import minimize# 定义目标函数def objf3(x):  # Rosenbrock 测试函数    fx = sum(100.0 * (x[1:] - x[:-1] ** 2.0) ** 2.0 + (1 - x[:-1]) ** 2.0)    return fx# 定义边界约束（优化变量的上下限）b0 = (0.0, None)  # 0.0 <= x[0] <= Infb1 = (0.0, 10.0)  # 0.0 <= x[1] <= 10.0b2 = (-5.0, 100.)  # -5.0 <= x[2] <= 100.0bnds = (b0, b1, b2)  # 边界约束# 优化计算xIni = np.array([1., 2., 3.])resRosen = minimize(objf3, xIni, method='SLSQP', bounds=bnds)xOpt = resRosen.xprint("xOpt = {:.4f}, {:.4f}, {:.4f}".format(xOpt[0], xOpt[1], xOpt[2]))print("min f(x) = {:.4f}".format(objf3(xOpt)))

5.约束非线性规划问题实例

import numpy as npfrom scipy.optimize import minimizedef objF4(x):  # 定义目标函数    a, b, c, d = 1, 2, 3, 8    fx = a * x[0] ** 2 + b * x[1] ** 2 + c * x[2] ** 2 + d    return fx# 定义约束条件函数def constraint1(x):  # 不等式约束 f(x)>=0    return x[0] ** 2 - x[1] + x[2] ** 2def constraint2(x):  # 不等式约束 转换为标准形式    return -(x[0] + x[1] ** 2 + x[2] ** 3 - 20)def constraint3(x):  # 等式约束    return -x[0] - x[1] ** 2 + 2def constraint4(x):  # 等式约束    return x[1] + 2 * x[2] ** 2 - 3# 定义边界约束b = (0.0, None)bnds = (b, b, b)# 定义约束条件con1 = {'type': 'ineq', 'fun': constraint1}con2 = {'type': 'ineq', 'fun': constraint2}con3 = {'type': 'eq', 'fun': constraint3}con4 = {'type': 'eq', 'fun': constraint4}cons = ([con1, con2, con3, con4])  # 3个约束条件# 求解优化问题x0 = np.array([1., 2., 3.])  # 定义搜索的初值res = minimize(objF4, x0, method='SLSQP', bounds=bnds, constraints=cons)print("Optimization problem (res):\t{}".format(res.message))  # 优化是否成功print("xOpt = {}".format(res.x))  # 自变量的优化值print("min f(x) = {:.4f}".format(res.fun))  # 目标函数的优化值

来源地址：https://blog.csdn.net/m0_46692607/article/details/126798062