pzv4f82wm
/
college_computing_final_project
1
0
Fork 1
Code Issues Pull Requests Packages Projects Releases Wiki Activity

修改代码

Browse Source
main
Mu_Xin 8 months ago
parent cfb941f95c
commit bdb591fb06
1 changed files with 145 additions and 84 deletions
Show Stats Download Patch File Download Diff File

229
multiple_integration.py
Unescape View File

@ -5,76 +5,75 @@ import sympy as sp
from convert_formula import *
import math
def rectangular_double_integration(region1, region2, function):
"""
求直角坐标系下二重积分
:param region1: y的积分区域(以元组或列表形式给出)
:param region2: x的积分区域(同region1)
:param function: 被积函数
:return: 二重积分值
"""
lower1, upper1= region1[0], region1[1]
lower2, upper2= region2[0], region2[1]
def rectangular_double_integration(region1, region2, function, integration_order=('y','x')):
var1, var2 = integration_order
lower1, upper1 = region1 # 直接使用符号表达式（可能包含外层变量）
lower2, upper2 = region2
function = sp.sympify(convert_formula(function))
x, y= sp.symbols('x y')
integration1 = sp.integrate(function, (y, lower1, upper1))
result = sp.integrate(integration1, (x,lower2,upper2))
x, y = sp.symbols('x y')
# 根据积分顺序动态选择积分变量
if var1 == 'y' and var2 == 'x':
integration1 = sp.integrate(function, (y, lower1, upper1)) # 内层积分限可包含x
result = sp.integrate(integration1, (x, lower2, upper2))
elif var1 == 'x' and var2 == 'y':
integration1 = sp.integrate(function, (x, lower1, upper1)) # 内层积分限可包含y
result = sp.integrate(integration1, (y, lower2, upper2))
else:
raise ValueError('积分顺序仅支持("y","x")或("x","y")')
return result
def polar_double_integration(function, rou, theta):
"""
求极坐标下的二重积分
:param function: 用极坐标表示的被积函数
:param rou: ρ的积分区间(以元组或列表给出)
:param theta: θ的积分区间(同ρ)
:return: 极坐标下的积分值
"""
rou1, rou2= rou[0], rou[1]
theta1, theta2= theta[0], theta[1]
rou, theta= sp.symbols('rou theta')
function= sp.sympify(convert_formula(function))
function= function* rou
integration1= sp.integrate(function, (rou, rou1, rou2))
result= sp.integrate(integration1, (theta, theta1, theta2))
def polar_double_integration(function, rou_region, theta_region, integration_order=('rou','theta')):
var1, var2 = integration_order
function = sp.sympify(convert_formula(function)) * sp.symbols('rou') # 极坐标雅可比行列式
rou, theta = sp.symbols('rou theta')
# 根据顺序动态积分
if var1 == 'rou' and var2 == 'theta':
inner = sp.integrate(function, (rou, *rou_region))
result = sp.integrate(inner, (theta, *theta_region))
elif var1 == 'theta' and var2 == 'rou':
inner = sp.integrate(function, (theta, *theta_region))
result = sp.integrate(inner, (rou, *rou_region))
else:
raise ValueError('积分顺序仅支持("rou","theta")或("theta","rou")')
return result
def rectangular_triple_integration(region1, region2, region3, function):
"""
求三重积分值
:param region1: z积分区域(以元组或列表形式给出)
:param region2: y积分区域(同上)
:param region3: x积分区域(同上)
:param function: 被积函数
:return: 三重积分值
"""
lower1, upper1= region1[0], region1[1]
lower2, upper2= region2[0], region2[1]
lower3, upper3 = region3[0], region3[1]
def rectangular_triple_integration(region1, region2, region3, function, integration_order=('z','y','x')):
var1, var2, var3 = integration_order
function = sp.sympify(convert_formula(function))
x, y, z= sp.symbols('x y z')
integration1 = sp.integrate(function, (z, lower1, upper1))
integration2 = sp.integrate(integration1, (y, lower2, upper2))
result = sp.integrate(integration2, (x, lower3, upper3))
x, y, z = sp.symbols('x y z')
# 动态构建积分变量元组
vars = {'x':x, 'y':y, 'z':z}
regions = {var1: region1, var2: region2, var3: region3}
# 按顺序嵌套积分
inner = sp.integrate(function, (vars[var1], *regions[var1]))
middle = sp.integrate(inner, (vars[var2], *regions[var2]))
result = sp.integrate(middle, (vars[var3], *regions[var3]))
return result
def cylindrical_triple_integration(rou, theta, region, function):
"""
求柱坐标下三重积分值
:param rou: ρ的积分区域(以元组或列表形式给出)
:param theta: θ的积分区间(以元组或列表形式给出)
:param region: z的积分区间(以元组或列表形式给出)
:param function: 被积函数(以柱坐标形式给出)
:return: 三重积分值
"""
rou1, rou2 = rou[0], rou[1]
theta1, theta2 = theta[0], theta[1]
z1, z2 = region[0], region[1]
function = sp.sympify(convert_formula(function))
rou, theta, z= sp.symbols('rou theta z')
function = function * rou
integration1 = sp.integrate(function, (rou, rou1, rou2))
integration2 = sp.integrate(integration1, (theta, theta1, theta2))
result = sp.integrate(integration2, (z, z1, z2))
def cylindrical_triple_integration(function, z_region, rou_region, theta_region, integration_order=('z','rou','theta')):
var1, var2, var3 = integration_order
function = sp.sympify(convert_formula(function)) * sp.symbols('rou') # 柱坐标雅可比行列式rou
z, rou, theta = sp.symbols('z rou theta')
# 动态映射积分变量与区域
vars = {'z': z, 'rou': rou, 'theta': theta}
regions = {var1: z_region, var2: rou_region, var3: theta_region}
# 按顺序嵌套积分
inner = sp.integrate(function, (vars[var1], *regions[var1]))
middle = sp.integrate(inner, (vars[var2], *regions[var2]))
result = sp.integrate(middle, (vars[var3], *regions[var3]))
return result
def spherical_triple_integration(function, r_region, phi_region, theta_region, integration_order=('r','phi','theta')):
var1, var2, var3 = integration_order
function = sp.sympify(convert_formula(function)) * (sp.symbols('r')**2) * sp.sin(sp.symbols('phi')) # 球坐标雅可比行列式r²sinφ
r, phi, theta = sp.symbols('r phi theta')
# 动态映射积分变量与区域
vars = {'r': r, 'phi': phi, 'theta': theta}
regions = {var1: r_region, var2: phi_region, var3: theta_region}
# 按顺序嵌套积分
inner = sp.integrate(function, (vars[var1], *regions[var1]))
middle = sp.integrate(inner, (vars[var2], *regions[var2]))
result = sp.integrate(middle, (vars[var3], *regions[var3]))
return result
def spherical_triple_integration(rou, theta, gamma, function):
@ -201,35 +200,97 @@ class TestIntegralFunctions(unittest.TestCase):
def UI():
while True:
command = input('请选择将要进行的操作：1.直角坐标下二重积分 2.极坐标下二重积分 3.直角坐标系下三重积分 4.柱坐标下三重积分 5.球坐标下三重积分 6.退出（所有积分区间请以元组或列表的形式给出）')
command = input('请选择将要进行的操作：1.直角坐标下二重积分 2.极坐标下二重积分 3.直角坐标系下三重积分 4.柱坐标下三重积分 5.球坐标下三重积分 6.退出\n（所有积分区间请不要使用半开半闭区间的形式给出，积分顺序由内到外输入，极坐标、柱坐标、球坐标需在原函数上乘的雅戈比行列式已经自动传入，不要重复输入）')
if command=='1':
function = input('请输入被积函数：')
region1 = input('请输入第一重积分区间：')
region2 = input('请输入第二重积分区间：')
print('直角坐标系下二重积分值：', rectangular_double_integration(region1, region2, function))
order = input('请输入积分顺序（格式："y,x"或"x,y"，默认y,x）：') or 'y,x'
var1, var2 = order.split(',') # 解析积分变量顺序
# 输入符号积分限（支持变量表达式如"x"、"2*y"）
lower1 = sp.sympify(convert_formula(input(f'请输入{var1}的下限：')))
upper1 = sp.sympify(convert_formula(input(f'请输入{var1}的上限：')))
lower2 = sp.sympify(convert_formula(input(f'请输入{var2}的下限：')))
upper2 = sp.sympify(convert_formula(input(f'请输入{var2}的上限：')))
print('直角坐标系下二重积分值：', rectangular_double_integration(
region1=(lower1, upper1),
region2=(lower2, upper2),
function=function,
integration_order=tuple(order.split(','))
))
if command=='2':
function = input('请输入用极坐标表示的被积函数：')
rou = input('请输入ρ的积分区间：')
theta = input('请输入θ的积分区间：')
print('极坐标下二重积分值：', polar_double_integration(function, rou, theta))
function = input('请输入极坐标被积函数：')
order = input('请输入积分顺序（格式："rou,theta"或"theta,rou"，默认rou,theta）：') or 'rou,theta'
var1, var2 = order.split(',')
# 符号积分限输入
lower1 = sp.sympify(convert_formula(input(f'请输入{var1}的下限：')))
upper1 = sp.sympify(convert_formula(input(f'请输入{var1}的上限：')))
lower2 = sp.sympify(convert_formula(input(f'请输入{var2}的下限：')))
upper2 = sp.sympify(convert_formula(input(f'请输入{var2}的上限：')))
print('极坐标二重积分值：', polar_double_integration(
function=function,
rou_region=(lower1, upper1) if var1=='rou' else (lower2, upper2),
theta_region=(lower2, upper2) if var1=='rou' else (lower1, upper1),
integration_order=tuple(order.split(','))
))
if command=='3':
function = input('请输入被积函数：')
region1 = input('请输入第一重积分区间：')
region2 = input('请输入第二重积分区间：')
region3 = input('请输入第三重积分区间：')
print('直角坐标系下三重积分值：', rectangular_triple_integration(region1, region2, region3, function))
order = input('请输入积分顺序（格式："z,y,x"或其他排列，默认z,y,x）：') or 'z,y,x'
vars = order.split(',')
# 输入三个符号积分限
regions = [
(sp.sympify(convert_formula(input(f'请输入{vars[0]}的下限：'))),
sp.sympify(convert_formula(input(f'请输入{vars[0]}的上限：'))),),
(sp.sympify(convert_formula(input(f'请输入{vars[1]}的下限：'))),
sp.sympify(convert_formula(input(f'请输入{vars[1]}的上限：'))),),
(sp.sympify(convert_formula(input(f'请输入{vars[2]}的下限：'))),
sp.sympify(convert_formula(input(f'请输入{vars[2]}的上限：'))),)
]
print('直角坐标三重积分值：', rectangular_triple_integration(
function=function,
region1=regions[0],
region2=regions[1],
region3=regions[2],
integration_order=tuple(vars)
))
if command=='4':
function = input('请输入用柱坐标表示的被积函数：')
rou = input('请输入ρ的积分区间：')
theta = input('请输入θ的积分区间：')
region = input('请输入z的积分区间：')
print('柱坐标系下三重积分值：',cylindrical_triple_integration(rou, theta, region, function))
function = input('请输入柱坐标被积函数：')
order = input('请输入积分顺序（格式："z,rou,theta"或其他排列，默认z,rou,theta）：') or 'z,rou,theta'
vars = order.split(',')
# 输入符号积分限（支持变量表达式）
regions = [
(sp.sympify(convert_formula(input(f'请输入{vars[0]}的下限（r/phi/theta）：'))),
sp.sympify(convert_formula(input(f'请输入{vars[0]}的上限（r/phi/theta）：')))),
(sp.sympify(convert_formula(input(f'请输入{vars[1]}的下限（r/phi/theta）：'))),
sp.sympify(convert_formula(input(f'请输入{vars[1]}的上限（r/phi/theta）：')))),
(sp.sympify(convert_formula(input(f'请输入{vars[2]}的下限（r/phi/theta）：'))),
sp.sympify(convert_formula(input(f'请输入{vars[2]}的上限（r/phi/theta）：'))))
]
print('柱坐标三重积分值：', cylindrical_triple_integration(
function=function,
z_region=regions[0] if vars[0]=='z' else next(r for r in regions if vars.index(r[0].name) == 0),
rou_region=regions[1] if vars[1]=='rou' else next(r for r in regions if vars.index(r[1].name) == 1),
theta_region=regions[2] if vars[2]=='theta' else next(r for r in regions if vars.index(r[2].name) == 2),
integration_order=tuple(vars)
))
if command=='5':
function = input('请输入用球坐标表示的被积函数：')
rou = input('请输入ρ的积分区间：')
theta = input('请输入θ的积分区间：')
gamma = input('请输入γ的积分区间：')
print('球坐标系下三重积分值：',spherical_triple_integration(rou, theta, gamma, function))
function = input('请输入球坐标被积函数（使用r,phi,theta）：')
order = input('请输入积分顺序（格式："r,phi,theta"或其他排列，默认r,phi,theta）：') or 'r,phi,theta'
vars = order.split(',')
# 输入符号积分限（支持变量表达式）
regions = [
(sp.sympify(convert_formula(input(f'请输入{vars[0]}的下限（r/phi/theta）：'))),
sp.sympify(convert_formula(input(f'请输入{vars[0]}的上限（r/phi/theta）：')))),
(sp.sympify(convert_formula(input(f'请输入{vars[1]}的下限（r/phi/theta）：'))),
sp.sympify(convert_formula(input(f'请输入{vars[1]}的上限（r/phi/theta）：')))),
(sp.sympify(convert_formula(input(f'请输入{vars[2]}的下限（r/phi/theta）：'))),
sp.sympify(convert_formula(input(f'请输入{vars[2]}的上限（r/phi/theta）：'))))
]
print('球坐标三重积分值：', spherical_triple_integration(
function=function,
r_region=regions[0] if vars[0]=='r' else next(r for r in regions if vars.index(r[0].name) == 0),
phi_region=regions[1] if vars[1]=='phi' else next(r for r in regions if vars.index(r[1].name) == 1),
theta_region=regions[2] if vars[2]=='theta' else next(r for r in regions if vars.index(r[2].name) == 2),
integration_order=tuple(vars)
))
if command=='6':
break

Write Preview
Loading…
Cancel
Save