将笛卡尔坐标转换为极坐标
[theta,rho] = cart2pol(x,y) 可将二维笛卡尔坐标数组x和y的对应元素变换为极坐标theta和rho
x, y, z — 笛卡尔坐标,标量,向量,矩阵
theta — 角坐标,数组
rho — 径向坐标,数组
示例1：机器人导航与路径规划
cart2pol(3, 4)
#Theta: 0.9272952180016122
#Rho: 5.0
意义: 将机器人当前位置的笛卡尔坐标(3,4)转换为极坐标，得到距离原点的距离和角度。
应用场景: 在自主机器人导航中，控制系统需要知道目标点相对于机器人的极坐标(距离和角度)，以便计算转向角度和行进距离。
示例2：天线方向图分析
cart2pol(x, y)
#Theta: atan2(y, x)
#Rho: (x**2 + y**2)**0.5
意义: 将天线辐射模式的笛卡尔坐标表示转换为极坐标表示，便于分析天线在不同方向上的增益特性。
应用场景: 在无线通信系统设计中，工程师使用极坐标来可视化和分析天线的辐射方向图，优化信号覆盖范围。
示例3：图像处理中的极坐标变换
cart2pol([1,2,3], [4,5,6])
#Theta: [1.32581766 1.19028995 1.10714872]
#Rho: [4.12310563 5.38516481 6.70820393]
意义: 将一组笛卡尔坐标点转换为极坐标，用于图像处理中的极坐标变换。
应用场景: 在计算机视觉中，极坐标变换可用于校正图像中的圆形失真，或将线性特征转换为更容易分析的径向特征。
示例4：物理学中的粒子轨迹分析
cart2pol(5,12,t)
#Theta: 1.17600520709514
#Rho: 13
#t
意义: 将粒子在二维平面中的位置(5,12)转换为极坐标，并保留时间参数t用于动力学分析。
应用场景: 在粒子物理学或天体力学中，分析粒子在中心力场中的运动轨迹，极坐标通常比笛卡尔坐标更简便。
示例5：雷达目标定位
cart2pol(100, 173.2)
#Theta: 1.0471848490249271
#Rho: 199.9955999515989
意义: 将雷达探测到的目标笛卡尔坐标转换为极坐标(距离和方位角)。
应用场景: 在雷达系统中，目标通常以极坐标形式表示(距离和方位角)，便于操作人员直观理解目标位置。
示例6：游戏开发中的角色移动
cart2pol(player_x, player_y)
#Theta: atan2(player_y, player_x)
#Rho: sqrt(player_x**2 + player_y**2)
意义: 将游戏角色相对于某个参考点的位置转换为极坐标，用于计算移动方向和距离。
应用场景: 在游戏开发中，极坐标常用于实现角色朝向特定目标移动的行为，或计算抛射物的飞行轨迹。
示例7：地理信息系统(GIS)
cart2pol(x, y, elevation)
#Theta: atan2(y, x)
#Rho: sqrt(x**2 + y**2)
#elevation
意义: 将地图上的点从笛卡尔坐标转换为极坐标，并保留高程信息。
应用场景: 在GIS中，极坐标可用于计算两点之间的方位角和距离，特别适用于航海和航空导航。
示例8：声音源定位
cart2pol(0.7, 0.7)
#Theta: 0.7853981633974483
#Rho: 0.9899494936611665
意义: 将声源在二维平面中的位置转换为极坐标，用于音频处理中的声场分析。
应用场景: 在音频工程和虚拟现实系统中，极坐标用于表示声源相对于听者的位置(距离和方向)，创建沉浸式音频体验。
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def cartesian_to_polar(input_str):
"""
将笛卡尔坐标转换为极坐标（支持数值、符号和矩阵输入）
参数:
input_str: 输入表达式字符串，可以是元组、矩阵或数值形式
返回:
根据输入类型返回：
- 两个数值/符号：返回(theta, rho)
- 两个矩阵：返回(theta矩阵, rho矩阵)
- 三个元素输入：返回(theta, rho, 第三参数)
- 错误时返回错误信息字符串
"""
try:
# 预处理输入字符串并转换为SymPy表达式
expr = sp.sympify(input_str)
error = False
T, R = None, None
def cartesian_polar_sym(x, y):
"""核心转换函数，使用SymPy函数支持符号计算"""
rho = sp.sqrt(x ** 2 + y ** 2).evalf()
theta = sp.atan2(y, x).evalf()
return theta, rho
# 定义函数（示例：笛卡尔转极坐标）
def cartesian_polar_sci(x, y):
rho = np.sqrt(x ** 2 + y ** 2)
theta = np.arctan2(y, x)
return theta, rho
# 处理元组输入（主要处理逻辑）
if isinstance(expr, tuple) and len(expr) in (2, 3):
if all(e.is_number for e in expr[:2]):
params = tuple(float(e.evalf()) for e in expr[:2])
T, R = cartesian_polar_sci(*params)
elif any(e.free_symbols for e in expr[:2]):
T, R = cartesian_polar_sym(*expr[:2])
else:
error = True
# 检查是否处理成功
error = error or (T is None or R is None)
else: # 非元组输入视为错误
error = True
# 处理结果返回
if error:
return f"输入错误: {input_str}"
# 处理可能存在的第三个参数
if len(expr) == 3:
third_param = expr[2]
if isinstance(third_param, list):
third_matrix = sp.Matrix(third_param)
return T, R, third_matrix
else:
return T, R, third_param
else:
return T, R
except Exception as e:
return f"错误: {str(e)}"
def main():
"""主函数，包含多个测试案例"""
# 测试案例1：数值输入
print("=== 示例1：数值输入 ===")
input_str = "(3, 4)"
theta, rho = cartesian_to_polar(input_str)
print(f"输入: {input_str}")
print(f"Theta: {theta}, Rho: {rho}\n")
# 结果: Theta: 0.9272952180016122, Rho: 5.0
# 测试案例2：符号输入
print("=== 示例2：符号输入 ===")
x, y = sp.symbols('x y')
input_str = "(x, y)"
theta, rho = cartesian_to_polar(input_str)
print(f"输入: {input_str}")
print("Theta:", theta)
print("Rho:", rho, "\n")
# 结果:
# Theta: atan2(y, x)
# Rho: (x**2 + y**2)**0.5
if __name__ == "__main__":
main()
将笛卡尔坐标转换为球面坐标
[azimuth,elevation,r] = cart2sph(x,y,z) 将笛卡尔坐标数组x,y和z的对应元素转换为球面坐标azimuth,elevation和r
x, y, z — 笛卡尔坐标,标量,向量,矩阵
azimuth — 方位角,数组
elevation — 仰角,数组
r — 半径,数组
示例1：基本数值转换
cart2sph(3, 4, 0)
#(0.9272952180016122, 0.0, 5.0)
cart2sph(1, 1, 1)
#(0.7853981633974483, 0.6154797086703873, 1.7320508075688772)
cart2sph(0, 0, 5)
#(0.0, 1.5707963267948966, 5.0)
示例2：物理学中的应用 - 电场计算
计算点电荷在空间中产生的电场方向
假设点电荷位于原点，计算点(2, 3, 4)处的电场方向
x, y, z = 2, 3, 4
az, el, r = cart2sph(x,y,z)
print(f"点({x}, {y}, {z})处的电场方向: 方位角={az:.3f} rad, 仰角={el:.3f} rad")
#点(2, 3, 4)处的电场方向: 方位角=0.983 rad, 仰角=0.837 rad
示例3：机器人学中的应用 - 机械臂末端位置
假设机械臂末端在笛卡尔坐标系中的位置
end_effector_pos = (1.5, 2.0, 0.8)
az, el, r = cart2sph(str(end_effector_pos))
print(f"机械臂末端位置: 距离={r:.3f} m, 方位角={az:.3f} rad, 仰角={el:.3f} rad")
#机械臂末端位置: 距离=2.625 m, 方位角=0.927 rad, 仰角=0.310 rad
示例4：天文学中的应用 - 天体位置
假设观测到的天体在观测者坐标系中的位置
celestial_body = (1000, 2000, 3000) # 单位: 光年
az, el, r = cart2sph(str(celestial_body))
print(f"天体位置: 距离={r:.3f} 光年, 方位角={az:.3f} rad, 仰角={el:.3f} rad")
#天体位置: 距离=3741.657 光年, 方位角=1.107 rad, 仰角=0.930 rad
示例5：符号计算应用
使用符号变量进行转换
az_sym, el_sym, r_sym = cart2sph(x,y,z)
符号表达式:
print(f"方位角: {az_sym}")
print(f"仰角: {el_sym}")
print(f"距离: {r_sym}")
#方位角: atan2(z, y)
#仰角: asin(x/sqrt(x**2 + y**2 + z**2))
#距离: (x**2 + y**2 + z**2)**0.5
可以进一步用具体数值替换符号
az_val = az_sym.subs({x: 1, y: 1, z: 1})
el_val = el_sym.subs({x: 1, y: 1, z: 1})
r_val = r_sym.subs({x: 1, y: 1, z: 1})
print(f"\n当x=1, y=1, z=1时: 方位角={az_val}, 仰角={el_val}, 距离={r_val}")
#当x=1, y=1, z=1时: 方位角=pi/4, 仰角=asin(sqrt(3)/3), 距离=1.73205080756888
示例6：数组输入处理
创建一组坐标点
coords = [(1, 0, 0), (0, 1, 0), (0, 0, 1), (1, 1, 1)]
for coord in coords:
az, el, r = cart2sph(str(coord))
print(f"{coord} -> 方位角: {az:.3f}, 仰角: {el:.3f}, 距离: {r:.3f}")
#(1, 0, 0) -> 方位角: 0.000, 仰角: 0.000, 距离: 1.000
#(0, 1, 0) -> 方位角: 1.571, 仰角: 0.000, 距离: 1.000
#(0, 0, 1) -> 方位角: 0.000, 仰角: 1.571, 距离: 1.000
#(1, 1, 1) -> 方位角: 0.785, 仰角: 0.615, 距离: 1.732
示例7：工程应用 - 天线方向图
假设测得天线在某点的场强分量
Ex, Ey, Ez = 0.5, 0.8, 1.2 # 电场分量
az, el, r = cart2sph(Ex, Ey, Ez)
print(f"电场方向: 方位角={az:.3f} rad, 仰角={el:.3f} rad, 幅度={r:.3f}")
#电场方向: 方位角=1.012 rad, 仰角=0.905 rad, 幅度=1.526
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def cartesian_to_spherical(input_str):
try:
expr = sp.sympify(input_str)
error = False
az, el, r = None, None, None
def cartesian_spherical_sci(x, y, z):
azimuth = np.arctan2(y, x) # 方位角
r = np.sqrt(x ** 2 + y ** 2 + z ** 2) # 距离
elevation = np.arcsin(z / r) # 仰角
return azimuth, elevation, r
def cartesian_spherical_sym(x, y, z):
"""
将笛卡尔坐标(x, y, z)转换为球坐标系(方位角, 仰角, 距离)
参数:
x, y, z: SymPy表达式/符号/数值
返回:
(azimuth, elevation, r) 元组，包含:
- 方位角 (azimuth): 弧度，xy平面内与x轴的夹角 [−π, π]
- 仰角 (elevation): 弧度，与xy平面的夹角 [−π/2, π/2]
- 距离 (r): 到原点的欧氏距离
"""
"""核心转换函数（全符号计算）"""
r = sp.sqrt(x ** 2 + y ** 2 + z ** 2)
azimuth = sp.atan2(y, x)
elevation = sp.asin(z / r) if r != 0 else sp.S.NaN
return azimuth.evalf(), elevation.evalf(), r.evalf()
if isinstance(expr, tuple) and len(expr) == 3:
if all(e.is_number for e in expr):
params = tuple(float(e.evalf()) for e in expr)
z, el, r = cartesian_spherical_sci(*params)
elif any(e.free_symbols for e in expr):
z, el, r = cartesian_spherical_sym(*expr)
else:
error = True
else:
error = True
if error:
return f"输入错误:{input_str}"
else:
return z, el, r
except Exception as e:
return f"错误:{e}"
def main():
"""测试案例"""
print("=== 数值测试 ===")
# 测试案例1：标量输入
print(cartesian_to_spherical("(3, 4, 0)"))
# 结果: (0.9272952180016122, 0.0, 5.0)
print("\n=== 符号测试 ===")
# 测试案例3：符号输入
s = "(x, y, z)"
az_sym, el_sym, r_sym = cartesian_to_spherical(s)
print("符号表达式:")
print(az_sym)
print(el_sym)
print(r_sym)
# 结果:
# az_sym: atan2(y, x)
# el_sym: asin(z/sqrt(x**2 + y**2 + z**2))
# r_sym: (x**2 + y**2 + z**2)**0.5
if __name__ == "__main__":
main()
卡塔兰数
z = catalan(n) 返回第n个卡塔兰数
卡塔兰数是组合数学中一种常出现于各种计数问题中的数列.
示例1：基本数值计算
for n in range(11): # 计算前11个卡塔兰数
result = catalan(n)
print(f"C({n}) = {result}")
#C(0) = 1
#C(1) = 1
#C(2) = 2
#C(3) = 5
#C(4) = 14
#C(5) = 42
#C(6) = 132
#C(7) = 429
#C(8) = 1430
#C(9) = 4862
#C(10) = 16796
示例2：括号匹配问题
括号匹配问题：n对括号有多少种正确的匹配方式
n = 4
catalan = catalan(n)
print(f"{n}对括号有 {catalan} 种正确的匹配方式")
#4对括号有 14 种正确的匹配方式
示例3：二叉树计数
n = 5 # 节点数
catalan = catalan(n)
print(f"{n}个节点可以组成 {catalan} 种不同的二叉树形态")
#5个节点可以组成 42 种不同的二叉树形态
示例4：凸多边形三角划分
n = 6 # 多边形边数
# 注意：n边形三角划分的种数是C(n-2)
catalan = catalan(n-2)
print(f"{n}边形有 {catalan} 种三角划分方式")
#6边形有 14 种三角划分方式
示例5：栈排序问题
栈排序问题：可能的出栈序列数量
n = 4 # 入栈序列长度
catalan = catalan(n)
print(f"长度为{n}的入栈序列有 {catalan} 种可能的出栈序列")
#长度为4的入栈序列有 14 种可能的出栈序列
示例6：路径计数问题
网格路径计数：从(0,0)到(n,n)不越过对角线的路径数
n = 4 # 网格大小
catalan = catalan(n)
print(f"从(0,0)到({n},{n})不越过对角线的路径有 {catalan} 条")
#从(0,0)到(4,4)不越过对角线的路径有 14 条
示例7：表达式加括号方式
# 例如：a+b+c+d 有5种加括号方式：
# ((a+b)+c)+d, (a+(b+c))+d, a+((b+c)+d), a+(b+(c+d)), (a+b)+(c+d)
n = 4 # 运算符数量
catalan = catalan(n)
print(f"包含{n}个运算符的表达式有 {catalan} 种加括号方式")
#包含4个运算符的表达式有 14 种加括号方式
这些示例展示了卡塔兰数在不同组合问题中的应用，包括括号匹配、二叉树计数、多边形划分、栈排序、路径计数等。卡塔兰数在计算机科学、组合数学和离散数学中有着广泛的应用。
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
def catalan_number_calculate(input_str):
"""
计算卡塔兰数（Catalan Number）的函数。
参数:
input_str (str): 输入的字符串，表示要计算的卡塔兰数的索引。
返回:
result (int or str): 如果输入有效，返回卡塔兰数的计算结果；如果输入无效，返回错误消息。
"""
try:
# 将输入字符串转换为符号表达式
x = sp.sympify(input_str)
# 检查输入是否为元组（即是否包含多个表达式）
if isinstance(x, tuple):
return f"错误输入: {input_str} 不是一个有效的数字或表达式。"
# 检查输入是否为非负整数
if not x.is_integer or x < 0:
return f"错误输入: {input_str} 必须是一个非负整数。"
# 计算卡塔兰数
result = sp.factorial(2 * x) / (sp.factorial(x + 1) * sp.factorial(x))
# 返回整数结果
return int(result)
except Exception as e:
# 转换失败，返回错误消息
return f"错误输入: {e}"
def main():
"""
主函数，用于演示 catalan_number_calculate 函数的使用。
"""
# 示例输入
inputs = ["0", "1", "5", "10"]
# 遍历输入并计算卡塔兰数
for input_str in inputs:
result = catalan_number_calculate(input_str)
print(f"输入: {input_str} -> 输出: {result}")
'''
输入: 0 -> 输出: 1
输入: 1 -> 输出: 1
输入: 5 -> 输出: 42
输入: 10 -> 输出: 16796
'''
# 调用主函数
if __name__ == "__main__":
main()
柯西矩阵
柯西矩阵（Cauchy Matrix）是一种特殊的矩阵，其元素形式为 C[i,j] = 1/(x_i - y_j)，在数值分析、插值理论和控制理论中有广泛应用。
A = cauchy(x,y) 返回一个 n×n 矩阵, 其中包含的项满足 A(i,j) = 1/(x(i)+y(j)). 参量 x 和 y 是长度为 n 的向量. 如果您为 x 和 y 传入标量, 它们将解释为向量 1:x 和 1:y
A = cauchy(x) 返回与上述 y = x 的情况相同的结果. 换言之，A(i,j) = 1/(x(i)+x(j))
x, y -- 输入, 向量.
示例1：基本柯西矩阵生成
两个不同的向量
x = [1, 2, 3, 4]
y = [5, 6, 7, 8]
cauchy(x,y)
#[[-0.25, -0.2, -0.166666666666667, -0.142857142857143],
[-0.333333333333333, -0.25, -0.2, -0.166666666666667],
[-0.5, -0.333333333333333, -0.25, -0.2],
[-1, -0.5, -0.333333333333333, -0.25]]
单个向量（x = y）
z = [1, 2, 3]
cauchy_matrix(z)
#[[oo, -1, -0.5],
[1, oo, -1],
[0.5, 1, oo]]
示例2：多项式插值中的应用
柯西矩阵在有理函数插值中有重要应用
假设我们有插值点
x_points = [1, 2, 3]
y_points = [4, 5, 6]
cauchy(x_points, y_points)
#[[-0.333333333333333, -0.25, -0.2],
[-0.5, -0.333333333333333, -0.25],
[-1, -0.5, -0.333333333333333]]
示例3：控制理论中的应用
在控制系统中，柯西矩阵用于模型降阶和系统辨识
假设系统极点和零点
poles = [1, 2, 3] # 极点
zeros = [4, 5, 6] # 零点
cauchy(poles, zeros)
#[[-0.333333333333333, -0.25, -0.2],
[-0.5, -0.333333333333333, -0.25],
[-1, -0.5, -0.333333333333333]]
示例4：数值分析中的应用
柯西矩阵常用于测试数值算法的稳定性
生成一个病态柯西矩阵（条件数大）
x_ill = [1, 1.0001, 1.0002]
y_ill = [2, 2.0001, 2.0002]
cauchy_ill = cauchy(x_ill, y_ill)
print(cauchy_ill)
#[[-1, -0.999900009999, -0.999800039992002],
[-1.000100010001, -1, -0.999900009999],
[-1.000200040008, -1.000100010001, -1]]
# 计算条件数（需要numpy）
try:
cond_num = np.linalg.cond(np.array(cauchy_ill).astype(float))
print(f"条件数: {cond_num}")
#条件数: 5.467544935181006e+16
except:
print("无法计算条件数")
示例5：非方阵柯西矩阵
生成3x2柯西矩阵
x_rect = [1, 2, 3]
y_rect = [4, 5]
cauchy(f"({x_rect}, {y_rect})")
#[[-0.333333333333333, -0.25],
[-0.5, -0.333333333333333],
[-1, -0.5]]
示例6：柯西矩阵的性质验证
柯西矩阵的行列式有特定公式
x_det = [1, 2]
y_det = [3, 4]
cauchy_det = cauchy(x_det, y_det)
print(cauchy_det)
#[[-0.5, -0.333333333333333],
[-1, -0.5]]
计算行列式
det_value = cauchy_det.det()
print(f"行列式: {det_value}")
#行列式: -0.0833333333333333
根据公式，行列式应为 ∏(x_i - x_j)(y_j - y_i) / ∏(x_i - y_j)
对于2x2矩阵: (x1-x2)(y2-y1)/((x1-y1)(x1-y2)(x2-y1)(x2-y2))
expected_det = ((x_det[0] - x_det[1]) * (y_det[1] - y_det[0]) /
((x_det[0] - y_det[0]) * (x_det[0] - y_det[1]) * (x_det[1] - y_det[0]) * (x_det[1] - y_det[1])))
print(f"预期行列式: {expected_det}")
#预期行列式: -0.08333333333333333
这些示例展示了柯西矩阵在不同领域的应用，包括多项式插值、控制理论、数值分析等。柯西矩阵具有良好的数学性质，如行列式有明确的表达式，且当x_i和y_j适当选择时，柯西矩阵可以是良态的（条件数小）。
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import numpy as np
import sympy as sp
def cauchy_matrix(input_str):
"""
生成柯西矩阵（Cauchy Matrix）的函数。
柯西矩阵的定义：C[i, j] = 1 / (x[i] - y[j])，其中 x 和 y 是两个向量。
参数:
input_str (str): 输入的字符串，表示两个向量 x 和 y 或单个向量（x = y）。
返回:
result (sp.Matrix or str): 如果输入有效，返回柯西矩阵；如果输入无效，返回错误消息。
"""
try:
# 将输入字符串转换为符号表达式
expr = sp.sympify(input_str)
error = False
result = None
def evaluation_cauchy_matrix(x, y):
"""
生成柯西矩阵的内部函数。
参数:
x (np.array): 向量 x
y (np.array): 向量 y
返回:
C (np.array): 柯西矩阵
"""
n = len(x)
m = len(y)
C = np.zeros((n, m), dtype=float)
for i in range(n):
for j in range(m):
C[i, j] = 1.0 / (x[i] - y[j])
return C
# 检查输入是否为元组，且元组的两个元素都是列表
if isinstance(expr, tuple) and isinstance(expr[0], list) and isinstance(expr[1], list):
x = np.array(expr[0], dtype=float)
y = np.array(expr[1], dtype=float)
result = evaluation_cauchy_matrix(x, y)
result = sp.Matrix(result)
# 检查输入是否为单个列表
elif isinstance(expr, list):
x = y = np.array(expr, dtype=float)
result = evaluation_cauchy_matrix(x, y)
result = sp.Matrix(result)
else:
error = True
# 如果输入无效，返回错误消息
if error:
return f"输入错误: {input_str}"
else:
return result
except Exception as e:
# 捕获异常并返回错误消息
return f"错误: {e}"
def main():
"""
主函数，用于演示 cauchy_matrix 函数的使用。
"""
# 示例输入
inputs = [
"([1, 2, 3], [4, 5, 6])",
# 输出: Matrix([[-0.333333333333333, -0.250000000000000, -0.200000000000000],
# [-0.500000000000000, -0.333333333333333, -0.250000000000000],
# [-1.00000000000000, -0.500000000000000, -0.333333333333333]])
"[1, 2, 3]",
# 输出: Matrix([[oo, -1.00000000000000, -0.500000000000000],
# [1.00000000000000, oo, -1.00000000000000],
# [0.500000000000000, 1.00000000000000, oo]])
"([1, 2], [3, 4, 5])", # 向量长度不匹配
# 输出: Matrix([[-0.500000000000000, -0.333333333333333, -0.250000000000000],
# [-1.00000000000000, -0.500000000000000, -0.333333333333333]])
]
# 遍历输入并生成柯西矩阵
for input_str in inputs:
result = cauchy_matrix(input_str)
print(f"输入: {input_str}")
print(f"输出: {result}")
print("-" * 40)
# 调用主函数
if __name__ == "__main__":
main()
定期存单的应计利息
AccrInt = cdai(CouponRate,Settle,Maturity,IssueDate) 计算定期存单的应计利息.
CouponRate —— 息票率, 用于确定债券应付息票的年百分比率, 小数
Settle —— 债券结算日期, 日期时间数组|字符串数组|日期字符向量
Maturity——债券到期日, 日期时间数组|字符串数组|日期字符向量
IssueDate —— 存单签发日期
Basis —— 日计数基准, 2（默认）|数值：0、1、2、3、4、6、7、8、9、10、11、12、13
示例1：基本定期存款利息计算
Settle = '2023-12-31' # 结算日（计息截止日）
IssueDate = '2023-01-01' # 起息日（存款开始日）
CouponRate = 0.03 # 年利率3%
Basis = 3 # 实际/365计息基础
计算从2023年1月1日到2023年12月31日的应计利息
ai = cdai(Settle, None, IssueDate, CouponRate, Basis)
print(f"应计利息: {ai}%")
#应计利息: 2.9918%
示例2：提前支取定期存款
Settle = '2023-06-30' # 提前支取日
IssueDate = '2023-01-01' # 存款起始日
CouponRate = 0.035 # 年利率3.5%
Basis = 2 # 实际/360计息基础
计算半年期定期存款提前支取的应计利息
ai = cdai(Settle, None, IssueDate, CouponRate, Basis)
print(f"提前支取应计利息: {ai}%")
#提前支取应计利息: 1.75%
示例3：跨年度存款利息计算
跨年度存款利息计算（考虑闰年）
Settle = '2024-03-01' # 结算日
IssueDate = '2023-03-01' # 起息日（跨年度）
CouponRate = 0.04 # 年利率4%
Basis = 0 # 实际/实际计息基础（考虑闰年）
计算跨年度存款的应计利息（包含闰年2月29日）
ai = cdai(Settle, None, IssueDate, CouponRate, Basis)
print(f"跨年度应计利息: {ai}%")
#跨年度应计利息: 4.011%
示例4：商业票据利息计算（使用30/360计息基础）
Settle = '2023-09-15' # 结算日
IssueDate = '2023-07-01' # 起息日
CouponRate = 0.025 # 年利率2.5%
Basis = 1 # 30/360计息基础（商业常用）
计算商业票据的应计利息
ai = cdai(Settle, None, IssueDate, CouponRate, Basis)
print(f"商业票据应计利息: {ai}%")
#商业票据应计利息: 0.5139%
示例5：大额存单到期利息计算
Settle = '2024-01-01' # 到期日
IssueDate = '2023-01-01' # 起息日
CouponRate = 0.045 # 年利率4.5%（大额存单通常利率较高）
Basis = 3 # 实际/365计息基础
计算一年期大额存单的到期应计利息
ai = cdai(Settle, None, IssueDate, CouponRate, Basis)
print(f"大额存单到期利息: {ai}%")
#大额存单到期利息: 4.5%
示例6：外币存款利息计算（使用实际/360计息基础，国际常见）
Settle = '2023-12-31' # 结算日
IssueDate = '2023-01-01' # 起息日
CouponRate = 0.018 # 年利率1.8%（外币存款利率）
Basis = 2 # 实际/360计息基础（国际常见）
计算外币存款的应计利息
ai = cdai(Settle, None, IssueDate, CouponRate, Basis)
print(f"外币存款应计利息: {ai}%")
#外币存款应计利息: 1.82%
示例7：部分期间利息计算（存款不足整月）
Settle = '2023-02-15' # 结算日（2月15日）
IssueDate = '2023-02-01' # 起息日（2月1日）
CouponRate = 0.03 # 年利率3%
Basis = 2 # 实际/360计息基础
计算半个月存款的应计利息
ai = cdai(Settle, None, IssueDate, CouponRate, Basis)
print(f"半月存款应计利息: {ai}%")
#半月存款应计利息: 0.1167%
这些示例展示了cdai函数在不同金融场景下的应用，包括普通定期存款、提前支取、跨年度计算、商业票据、大额存单、外币存款以及部分期间利息计算等。
每个示例都使用了不同的计息基础（Basis），展示了各种金融产品常用的计息方式。
将复数对角型转换为实数块对角型
[Vnew,Dnew] = cdf2rdf(V,D) 将实矩阵 X 的 [V,D] = eig(X) 或 [V,D] = eigs(X,___) 的输出从复数对角型转换为实数对角型。
此操作将变换 X 的特征值在 D 中的表示方式，并变换 V 以使 X*Vnew = Vnew*Dnew。
V — 右特征向量矩阵, 矩阵, 指定为 [V,D] = eig(X) 或 [V,D] = eigs(X,___) 返回的矩阵。
D — 对角特征值矩阵, 矩阵, 指定为 [V,D] = eig(X) 或 [V,D] = eigs(X,___) 返回的矩阵。沿 D 的对角线的一些特征值可能是实数，但假设复共轭特征值对的彼此相邻的。
Vnew — 变换后的右特征向量矩阵, 矩阵
Dnew — 变换后的对角特征值矩阵, 矩阵
示例1：控制系统状态空间分析
v_real, d_real = cdf2rdf([[-2+3@i, -2-3@i]], [[1, 1], [2, -1]])
print("转换后的实数特征向量矩阵:")
print(v_real)
#转换后的实数特征向量矩阵:
#[[-2, 3],
[-3, -2]]
print("转换后的块对角特征值矩阵:")
print(d_real)
#转换后的块对角特征值矩阵:
#[[0, 1],
[0, 0.5]]
示例2：结构振动分析
v_real, d_real = cdf2rdf([[-0.1+1.5@i, -0.1-1.5@i]], [[0.5, 0.5], [0.7, -0.7]])
print("模态形状矩阵:")
print(v_real)
#模态形状矩阵:
#[[-0.1, 1.5],
[-1.5, -0.1]]
print("频率和阻尼矩阵:")
print(d_real)
#频率和阻尼矩阵:
#[[0, 0.5],
[0, 0]]
示例3：3x3系统的复数对角化
v_real, d_real = cdf2rdf([[2+3@i, 2-3@i, 5]], [[1, 1, 0], [1, -1, 1], [0, 1, 1]])
print("3x3模态矩阵:")
print(v_real)
#3x3模态矩阵:
#[[2, 3, 0],
[-3, 2, 0],
[0, 0, 5]]
print("3x3特征值矩阵:")
print(d_real)
#3x3特征值矩阵:
#[[0, 1, 0],
[0, 0, 1],
[0, 0.5, 1]]
这种转换在控制系统分析、结构动力学和其他工程领域中非常有用，因为它允许在实数域中处理复数特征值和特征向量，简化了后续的计算和分析。
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
from scipy import linalg
def complex_diagonal_real_riagonal(input_str):
"""
严格实现MATLAB风格的cdf2rdf函数，必须输入V和D两个矩阵
参数:
input_str (str): 输入的矩阵字符串，格式示例：
"[[1,0],[0,1]], [[1+2j,0],[0,1-2j]]" # V, D矩阵
返回:
tuple: (V_real, D_real)
示例:
>>> V_real, D_real = cdf2rdf("[[1,0],[0,1]], [[1+2j,0],[0,1-2j]]")
"""
try:
expr = sp.sympify(input_str)
error = False
# 检查表达式是否为元组且长度为 2
if isinstance(expr, tuple) and len(expr) == 2:
if all(isinstance(e, list) for e in expr):
# 将 V 矩阵转换为 numpy 数组，数据类型为复数，并展平
V_np = np.array(expr[0], dtype=complex).ravel()
# 将 D 矩阵转换为 numpy 数组，数据类型为复数
D_np = np.array(expr[1], dtype=complex)
# 调用 scipy.linalg 的 cdf2rdf 函数将复数对角矩阵转换为实数块对角矩阵
V_real, D_real = linalg.cdf2rdf(V_np, D_np)
else:
error = True
else:
# 如果表达式不是元组或者长度不为 2，将错误标志设置为 True
error = True
# 如果没有错误发生
if not error:
# 将实数化后的 V 和 D 转换为 sympy 矩阵并返回
return sp.Matrix(V_real), sp.Matrix(D_real)
else:
# 如果有错误发生，返回包含输入内容的错误信息
return f"输入错误:{input_str}"
except Exception as e:
return f"错误: {str(e)}"
# 示例代码
if __name__ == "__main__":
# 正确输入示例
input_str = "[-0.37, 5.37],[[-0.8, -0.4], [0.5, -0.9]]"
V_real, D_real = complex_diagonal_real_riagonal(input_str)
print("转换后的实数V矩阵:")
print(V_real)
# Matrix([[-0.370000000000000, 0], [0, 5.37000000000000]])
print("\n转换后的块对角D矩阵:")
print(D_real)
# Matrix([[-0.800000000000000, -0.400000000000000], [0.500000000000000, -0.900000000000000]])
定期存单的价格
[Price,AccrInt] = cdprice(Yield,CouponRate,Settle,Maturity,IssueDate)计算定期存单的价格.
Yield —— 到期收益率
CouponRate —— 息票率, 用于确定债券应付息票的年百分比率, 小数
Settle —— 债券结算日期, 日期时间数组|字符串数组|日期字符向量
Maturity——债券到期日, 日期时间数组|字符串数组|日期字符向量
IssueDate —— 存单签发日期
Basis —— 日计数基准, 2（默认）|数值：0、1、2、3、4、6、7、8、9、10、11、12、13
示例1：基本定期存款定价
price, accr_int = cdprice(
Yield=0.03, # 市场收益率3%
Settle='2023-06-30', # 结算日（当前估值日）
Maturity='2024-01-01', # 到期日
IssueDate='2023-01-01', # 起息日
CouponRate=0.035, # 票面利率3.5%
Basis=3 # 实际/365计息基础
)
print(f"定期存单价格: {price} (每100面值)")
print(f"应计利息: {accr_int} (每100面值)")
#定期存单价格: 100.2238 (每100面值)
#应计利息: 1.726 (每100面值)
#这种计算用于确定定期存款在当前市场条件下的公允价值
示例2：大额存单二级市场交易定价
price, accr_int = cdprice(
Yield=0.042, # 当前市场收益率4.2%
Settle='2023-09-15', # 交易结算日
Maturity='2024-06-30', # 存单到期日
IssueDate='2023-03-15', # 存单发行日
CouponRate=0.04, # 票面利率4%
Basis=2 # 实际/360计息基础（常见于大额存单）
)
print(f"大额存单交易价格: {price} (每100面值)")
print(f"应计利息: {accr_int} (每100面值)")
#大额存单交易价格: 99.778 (每100面值)
#应计利息: 2.0444 (每100面值)
# 这种计算用于二级市场上大额存单的买卖定价
示例3：外币定期存款估值
price, accr_int = cdprice(
Yield=0.018, # 外币存款市场收益率1.8%
Settle='2023-08-31', # 估值日
Maturity='2024-02-28', # 到期日
IssueDate='2023-02-28', # 起息日
CouponRate=0.02, # 票面利率2%
Basis=2 # 实际/360计息基础（国际常见）
)
print(f"外币定期存款价格: {price} (每100面值)")
print(f"应计利息: {accr_int} (每100面值)")
#外币定期存款价格: 100.0905 (每100面值)
#应计利息: 1.0222 (每100面值)
# 这种计算用于评估外币定期存款的投资价值
示例4：提前支取定期存款的估值
price, accr_int = cdprice(
Yield=0.025, # 提前支取适用收益率（通常低于票面利率）
Settle='2023-07-01', # 提前支取日
Maturity='2024-01-01', # 原定到期日
IssueDate='2023-01-01', # 起息日
CouponRate=0.035, # 原票面利率3.5%
Basis=3 # 实际/365计息基础
)
print(f"提前支取价值: {price} (每100面值)")
print(f"已累计利息: {accr_int} (每100面值)")
#提前支取价值: 100.4762 (每100面值)
#已累计利息: 1.7356 (每100面值)
# 这种计算用于确定提前支取定期存款能获得的本金和利息
示例5：不同计息基础的比较
bases = [0, 1, 2, 3] # 四种不同的计息基础
basis_names = ["actual/actual", "30/360", "actual/360", "actual/365"]
for basis, name in zip(bases, basis_names):
price, accr_int = cdprice(
Yield=0.03,
Settle='2023-06-30',
Maturity='2024-01-01',
IssueDate='2023-01-01',
CouponRate=0.035,
Basis=basis
)
print(f"{name}基础 - 价格: {price}, 应计利息: {accr_int}")
#actual/actual基础 - 价格: 100.2238, 应计利息: 1.726
#30/360基础 - 价格: 100.2218, 应计利息: 1.7403
#actual/360基础 - 价格: 100.2265, 应计利息: 1.75
#actual/365基础 - 价格: 100.2238, 应计利息: 1.726
# 这种比较展示了不同计息方式对定价的影响
示例6：市场利率变化对存单价格的影响
yields = [0.02, 0.025, 0.03, 0.035, 0.04] # 不同的市场收益率
for y in yields:
price, accr_int = cdprice(
Yield=y,
Settle='2023-06-30',
Maturity='2024-01-01',
IssueDate='2023-01-01',
CouponRate=0.035,
Basis=3
)
print(f"市场收益率 {y*100}% - 价格: {price}, 应计利息: {accr_int}")
#市场收益率 2.0% - 价格: 100.7353, 应计利息: 1.726
#市场收益率 2.5% - 价格: 100.4789, 应计利息: 1.726
#市场收益率 3.0% - 价格: 100.2238, 应计利息: 1.726
#市场收益率 3.5000000000000004% - 价格: 99.9699, 应计利息: 1.726
#市场收益率 4.0% - 价格: 99.7173, 应计利息: 1.726
# 这种分析展示了利率变动如何影响定期存单的市场价格
这些示例展示了cdprice函数在不同金融场景下的应用，包括普通定期存款定价、大额存单交易、外币存款估值、提前支取计算以及不同计息基础的比较等。
关键应用场景包括：
银行定期存款产品的定价和估值
二级市场上存单交易的定价
投资组合中定期存款资产的估值
利率变动对存款价值的影响分析
不同计息方式下的价值比较
定期存单的到期收益率
Yield = cdyield(Price,CouponRate,Settle,Maturity,IssueDate)计算给定净价的定期存单的到期收益率.
Price —— 每100元面值的存款证净价，
CouponRate —— 息票率, 用于确定债券应付息票的年百分比率, 小数
Settle —— 债券结算日期, 日期时间数组|字符串数组|日期字符向量
Maturity——债券到期日, 日期时间数组|字符串数组|日期字符向量
IssueDate —— 存单签发日期
Basis —— 日计数基准, 2（默认）|数值：0、1、2、3、4、6、7、8、9、10、11、12、13
Yield —— 到期收益率
示例1：短期CD
这是一个标准的短期定期存单，使用actual/360基准
y1 = cdyield(
Price=101.125,
CouponRate=0.05,
Settle='2002-01-02',
Maturity='2002-03-31',
IssueDate='2001-10-01'
)
print(f"示例1计算结果: {y1}")
#示例1计算结果: 0.0562
示例2：极短期CD
这是一个非常短期的存单，只有2个月期限
y2 = cdyield(
Price=99.99,
CouponRate=0.06,
Settle='1997-09-15',
Maturity='1997-11-13',
IssueDate='1997-09-11',
Basis=2
)
print(f"示例2计算结果: {y2}")
#示例2计算结果: 0.0647
示例3：长期CD - 1年期
一年期定期存单，使用actual/365基准
y3 = cdyield(
Price=98.50,
CouponRate=0.035,
Settle='2023-03-15',
Maturity='2024-03-15',
IssueDate='2023-03-15',
Basis=3
)
print(f"示例3计算结果: {y3}")
#示例3计算结果: 0.0507
示例4：使用30/360基准的CD
使用30/360日计数基准的半年期存单
y4 = cdyield(
Price=99.25,
CouponRate=0.025,
Settle='2023-06-15',
Maturity='2023-12-15',
IssueDate='2023-06-15',
Basis=1
)
print(f"示例4计算结果: {y4}")
#示例4计算结果: 0.0403
示例5：折价发行的长期CD
两年期折价发行存单，使用actual/actual基准
y5 = cdyield(
Price=95.00,
CouponRate=0.04,
Settle='2023-01-15',
Maturity='2025-01-15',
IssueDate='2023-01-15',
Basis=0
)
print(f"示例5计算结果: {y5}")
#示例5计算结果: 0.0684
示例6：溢价发行的CD
溢价购买的存单，收益率应低于票面利率
y6 = cdyield(
Price=102.50,
CouponRate=0.03,
Settle='2023-07-01',
Maturity='2024-07-01',
IssueDate='2023-01-01',
Basis=2
)
print(f"示例6计算结果: {y6}")
#示例6计算结果: 0.0198
示例7：月末日期特殊情况
测试30/360基准下月末日期的处理
y7 = cdyield(
Price=99.80,
CouponRate=0.02,
Settle='2023-01-31',
Maturity='2023-07-31',
IssueDate='2023-01-31',
Basis=1
)
print(f"测试用例7计算结果: {y7}")
#示例7计算结果: 0.024
示例8：不同日期格式测试
测试函数处理不同日期格式的能力
y8 = cdyield(
Price=100.00,
CouponRate=0.04,
Settle='15-Mar-2023',
Maturity='15-Sep-2023',
IssueDate='15-Mar-2023',
Basis=2
)
print(f"示例8计算结果: {y8}")
#示例8计算结果: 0.04
实际应用场景说明
商业银行CD定价：银行可以使用此函数计算它们发行的定期存单的合理收益率，以吸引投资者。
投资决策：投资者可以比较不同CD的收益率，选择最有利可图的投资机会。
财务分析：金融分析师可以使用此函数评估CD投资组合的表现。
教育用途：金融课程可以使用此函数教授学生关于固定收益证券定价和收益率计算的概念。
财务软件集成：此函数可以集成到更大的财务软件系统中，用于自动化CD估值和投资分析。
这些示例展示了函数在不同市场条件下的适用性，包括不同的期限结构、价格水平、票面利率和日计数基准。
向正无穷舍入
Y = ceil(t) 将 t 的每个元素四舍五入到大于或等于此元素的最接近的数.
t是标量,向量,矩阵,多维数组,符号变量
示例1. 基本数值示例
test_cases = [
3.2,
-4.7,
5,
0,
-0.1,
]
for case in test_cases:
output = ceil(case)
print(f" ceil({case}) = {output}")
#ceil(3.2) = 4.0
#ceil(-4.7) = -4.0
#ceil(5) = 5.0
#ceil(0) = 0.0
#ceil(-0.1) = -0.0
示例2. 特殊数值示例
special_cases = [
oo, # 正无穷
-oo, # 负无穷
pi, # π的向上取整
E, # 自然常数e的向上取整
]
for case in special_cases:
output = ceil(case)
print(f" ceil({case}) = {output}")
#ceil(oo) = inf
#ceil(-oo) = -inf
#ceil(pi) = 4.0
#ceil(E) = 3.0
示例3. 符号表达式示例
expr_cases = [
x,
x + 0.5,
x**2 + y,
sin(x) + cos(y),
]
for case in expr_cases:
output = ceil(case)
print(f" ceil({case}) = {output}")
#ceil(x) = ceiling(x)
#ceil(x + 0.5) = ceiling(x + 0.5)
#ceil(x**2 + y) = ceiling(x**2 + y)
#ceil(sin(x) + cos(y)) = ceiling(sin(x) + cos(y))
示例4. 向量示例
vector_cases = [
[1.2, 3.7, -2.1, 4.0],
[x, x+0.3, x-0.7],
[@pi, @e, 1/2],
]
for case in vector_cases:
output = ceil(case)
print(f" ceil({case}) = {output}")
#ceil([1.2, 3.7, -2.1, 4.0]) = [2,4,-2,4]
#ceil([x, x+0.3, x-0.7]) = [ceiling(x), ceiling(x + 0.3), ceiling(x - 0.7)]
#ceil([@pi, @e, 1/2]) = [4,3,1]
示例5. 矩阵示例
matrix_cases = [
[[1.2, 3.7], [-2.1, 4.0]],
[[x, x+0.3], [x-0.7, y]],
[[@pi, @e], [1/2, -1/3]],
]
for case in matrix_cases:
output = ceil(case)
print(f" ceil({case}) = {output}")
#ceil([[1.2, 3.7], [-2.1, 4.0]]) = [[2 4], [-2 4]]
#ceil([[x, x+0.3], [x-0.7, y]]) = [[ceiling(x), ceiling(x + 0.3)], [ceiling(x - 0.7), ceiling(y)]]
#ceil([[@pi, @e], [1/2, -1/3]]) = [[4 3],[1 0]]
示例6. 三维数组示例
array_3d_cases = [
[[[1.2, 3.7], [-2.1, 4.0]], [[0.1, -0.9], [2.5, 3.3]]],
]
for case in array_3d_cases:
output = ceil(case)
print(f" ceil({case}) = {output}")
#ceil([[[1.2, 3.7], [-2.1, 4.0]], [[0.1, -0.9], [2.5, 3.3]]]) = [[[2 4],[-2 4]],[[1 0],[3 4]]]
示例7: 计算最少需要的包装箱数量
items = 47
capacity = 12
boxes_needed = ceil(items/capacity)
print(f" 包装{items}件商品，每箱装{capacity}件，需要{boxes_needed}个箱子")
#包装47件商品，每箱装12件，需要4.0个箱子
示例8: 计算最少需要的页数
words = 1250
words_per_page = 300
pages_needed = ceil(words/words_per_page)
print(f" 撰写{words}字的文章，每页{words_per_page}字，需要{pages_needed}页")
#撰写1250字的文章，每页300字，需要5.0页
示例9: 金融计算中的向上取整
investment = 10000
unit_price = 23.5
units = ceil(investment/unit_price)
print(f" 用{investment}元投资，每单位{unit_price}元，最多可购买{units}单位")
#用10000元投资，每单位23.5元，最多可购买426.0单位
示例10: 工程计算中的向上取整
length = 15.7
segment_length = 2.5
segments = ceil(length/segment_length)
print(f" 长度为{length}的物体，每段{segment_length}，需要{segments}段")
#长度为15.7的物体，每段2.5，需要7.0段
实际应用场景说明
包装和物流：计算需要多少个箱子或容器来装一定数量的物品，确保所有物品都能被容纳。
文档排版：确定需要多少页来容纳一定数量的文字或内容，考虑每页的最大容量。
金融投资：计算可以购买多少单位的资产，基于可用资金和单位价格。
工程测量：确定需要多少段材料来完成一个项目，考虑每段的固定长度。
资源分配：计算需要多少组资源来满足需求，特别是在数量未知但需要提前规划的情况下。
数学建模：在符号计算中处理向上取整操作，特别是在离散数学和组合优化问题中。
数据分析：对数据集中的数值进行向上取整处理，特别是在需要将连续值转换为离散类别时。
这些示例展示了向上取整函数在不同领域的实际应用，从简单的数值计算到复杂的符号表达式处理，以及从一维向量到多维数组的各种数据类型。
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def ceil_positive_infinity(input_str):
"""
对输入进行向上取整操作，支持数值、符号表达式和矩阵。
参数:
input_str (str): 输入的字符串，可以是数值、符号表达式或矩阵。
返回:
result (sp.Expr, sp.Matrix, or str):
- 若输入为数值或符号表达式，返回向上取整后的表达式；
- 若输入为矩阵，返回逐元素向上取整后的矩阵；
- 若输入无效，返回错误消息。
"""
try:
# 修复输入表达式（例如替换特殊符号）
# 将字符串转换为 SymPy 表达式
expr = sp.sympify(input_str)
error = False
result = None
# 检查输入
if expr.free_symbols:
# 处理含自由符号的表达式
result = sp.ceiling(expr)
elif expr.is_number:
# 处理数值
z = float(expr)
result = np.ceil(z)
else:
error = True
if error:
return f"输入错误: {input_str}"
else:
return result
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于演示 ceil_positive_infinity 函数的使用。
"""
# 示例输入
test_cases = [
"3.2", # 4.0
"-4.7", # -4.0
"x", # ceiling(x)
"x + 0.5", # ceiling(x + 0.5)
"oo", # inf
]
# 遍历测试用例并输出结果
for case in test_cases:
output = ceil_positive_infinity(case)
print(f"输入: {case}")
print(f"输出: {output}")
print("-" * 40)
if __name__ == "__main__":
main()
分解连分数
s = cFrac(n).
连分数是一种特殊的分数表示方法它可以用一系列的有理数来表示.这些有理数被称为连分数的部分,它们描述了数的分数部分.
n是浮点数
s是由有理数组成的连分数.
示例1. 基本有理数示例
basic_cases = [
3/2,
5,
2.5,
0.3333,
1/3,
22/7,
355/113,
]
for case in basic_cases:
output = cFrac(case)
print(f" cFrac({case}) = {output}")
#cFrac(3/2) = [1, 2]
#cFrac(5) = [5]
#cFrac(2.5) = [2, 2]
#cFrac(0.3333) = [0, 3, 3332, 1, 674191559, 1, 61, 7, 6]
#cFrac(1/3) = [0, 3]
#cFrac(22/7) = [3, 7]
#cFrac(355/113) = [3, 7, 16]
示例2. 黄金比例相关示例
phi_cases = [
"8/5", # 1.6，斐波那契数列比值的近似
"13/8", # 1.625，更接近黄金比例
"21/13", # 1.61538，更接近黄金比例
]
for case in phi_cases:
output = cFrac(case)
print(f" cFrac({case}) = {output}")
#cFrac(8/5) = [1, 1, 1, 2]
#cFrac(13/8) = [1, 1, 1, 1, 2]
#cFrac(21/13) = [1, 1, 1, 1, 1, 2]
示例3. 数学常数近似值示例
constant_cases = [
"3.14159265359", # π的近似值
"2.71828182846", # e的近似值
"1.41421356237", # √2的近似值
"1.73205080757", # √3的近似值
]
for case in constant_cases:
output = cFrac(case)
print(f" cFrac({case}) = {output}")
#cFrac(3.14159265359) = [3, 7, 15, 1, 292, 1, 1, 1, 2, 1, 4, 1, 1, 1, 1, 1, 4, 3, 22, 1, 1, 6, 3, 1, 7, 1, 1, 21, 11]
#cFrac(2.71828182846) = [2, 1, 2, 1, 1, 4, 1, 1, 6, 1, 1, 8, 1, 1, 10, 1, 1, 3, 1, 5, 1, 2, 2, 7, 4, 4, 4, 5, 1, 1, 1, 1, 1, 4, 5, 1, 1, 9, 2]
#cFrac(1.41421356237) = [1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 1, 4, 1, 2, 1, 24, 1, 1, 1, 13, 9, 2, 1, 5, 3, 2, 3, 1, 21]
#cFrac(1.73205080757) = [1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 14, 6, 1, 19, 1, 8, 13, 1, 1, 4, 382, 4, 2]
示例4: 齿轮比设计
gear_ratio = 1.75 # 7:4的齿轮比
gear_cf = cFrac(gear_ratio)
print(f" 齿轮比 {gear_ratio} 的连分数展开: {gear_cf}")
print(" 这表示可以使用7齿和4齿的齿轮组合实现此比例")
#齿轮比 1.75 的连分数展开: [1, 1, 3]
#这表示可以使用7齿和4齿的齿轮组合实现此比例
示例5: 音乐音程比例
perfect_fifth = 3/2 # 纯五度音程
fifth_cf = cFrac(perfect_fifth)
print(f" 纯五度音程比例 {perfect_fifth} 的连分数展开: {fifth_cf}")
#纯五度音程比例 3/2 的连分数展开: [1, 2]
major_third = 5/4 # 大三度音程
third_cf = cFrac(major_third)
print(f" 大三度音程比例 {major_third} 的连分数展开: {third_cf}")
#大三度音程比例 5/4 的连分数展开: [1, 4]
示例6: 屏幕宽高比
screen_ratio = 16/9 # 常见屏幕宽高比
screen_cf = cFrac(screen_ratio)
print(f" 屏幕宽高比 {screen_ratio} 的连分数展开: {screen_cf}")
#屏幕宽高比 16/9 的连分数展开: [1, 1, 3, 2]
示例7: 金融利率计算
interest_rate = 1.05 # 5%利率
interest_cf = cFrac(interest_rate)
print(f" 利率倍数 {interest_rate} 的连分数展开: {interest_cf}")
#利率倍数 1.05 的连分数展开: [1, 19, 1, 56294995342130, 4]
示例8: 工程比例计算
scale_factor = 1.333 # 4:3比例
scale_cf = cFrac(scale_factor)
print(f" 比例因子 {scale_factor} 的连分数展开: {scale_cf}")
#比例因子 1.333 的连分数展开: [1, 3, 332, 1, 26807140638, 8, 1, 5, 3]
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
from sympy.ntheory.continued_fraction import continued_fraction
def continue_fraction_rational(input_str):
"""
计算有理数的连分数展开式。
参数:
input_str (str): 输入的字符串，表示一个有理数（如整数、分数或有限小数）。
返回:
result (list or str):
- 若输入有效，返回连分数展开式的系数列表；
- 若输入无效，返回错误消息。
错误处理:
- 输入为非数值（如矩阵、符号表达式）时返回输入错误。
- 输入为无理数或无法转换为有理数的值时返回错误。
"""
try:
# 将输入字符串转换为 SymPy 表达式
expr = sp.sympify(input_str)
error = False
result = None
# 检查输入是否为元组（不支持元组输入）
if isinstance(expr, tuple):
error = True
# 检查输入是否为数值类型（整数、有理数、浮点数）
elif expr.is_number:
# 将输入转换为精确有理数（例如 3.2 → 16/5）
rational_num = sp.Rational(expr)
# 计算连分数展开式
result = list(continued_fraction(rational_num))
else:
error = True
if error:
return f"输入错误: {input_str}"
else:
return result
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于演示 `continue_fraction_rational` 函数的使用。
"""
# 示例输入
test_cases = [
"3/2", # [1, 2]
"5", # [5]
"2.5", # [2, 2]
"0.3333", # [0, 3, 3332, 1, 674191559, 1, 61, 7, 6]
]
# 遍历测试用例并输出结果
for case in test_cases:
output = continue_fraction_rational(case)
print(f"输入: {case}")
print(f"输出: {output}")
print("-" * 40)
if __name__ == "__main__":
main()
置换积分
G=changeIntegrationVariable(F,old,new)通过替换对F中的积分进行积分,其中old被new替换.
旧的必须依赖于F中积分的前一个积分变量,新的必须依赖新的积分变量.
在F中指定积分时,您可以通过使用int函数并将“Hold”选项设置为true来返回未求值的积分形式. 然后,您可以使用changeIntegrationVariable显示通过替换进行集成的步骤.
F —— 包含积分的表达式, 表达式向量, 表达式矩阵
old--要替换的子表达式
new--新的子表达式
示例1：三角函数替换（常用于处理含平方根的积分）
替换：x = sin(t)，用于处理含√(1-x²)的积分
x, t = symbols('x t')
expr = Integral(1/sqrt(1-x**2), (x, 0, 1/2))
G = changeIntegrationVariable(expr, x, sin(t))
print(G)
# 输出：Integral(cos(t)/sqrt(1 - sin(t)**2), (t, 0, pi/6))
示例2：指数函数替换
替换：u = e^x，用于处理含e^x的积分
x, u = symbols('x u')
expr = Integral(exp(x)/(1+exp(2*x)), (x, 0, 1))
G = changeIntegrationVariable(expr, exp(x), u)
print(G)
# 输出：Integral(1/(u**2 + 1), (u, 1, E))
# 这是一个标准的反正切积分
示例3：矩阵中的多个积分替换
矩阵中包含多个积分，统一进行变量替换
x, t = symbols('x t')
expr = [
Integral(sin(x), (x, 0, sp.pi)),
Integral(cos(x), (x, 0, sp.pi/2))
]
G = changeIntegrationVariable(expr, x, 2*t)
print(G)
# 输出：[[Integral(2*sin(2*t), (t, 0, pi/2))],
[Integral(2*cos(2*t), (t, 0, pi/4))]]
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
from sympy import Integral, solve, diff, symbols, Function
from sympy.core.basic import Basic
import sympy as sp
def change_integration_variable(F, old, new):
"""
将积分中的变量替换应用于表达式 \( F \)，用新变量替换旧变量。
返回变换后的表达式。
"""
def replace_integral(expr, old, new):
if isinstance(expr, Integral):
integrand = expr.function
limits = list(expr.limits)
substituted = False
for i in range(len(limits)):
if substituted:
break
limit = limits[i]
var = limit[0] # 积分变量（如x）
a = limit[1] if len(limit) > 1 else None # 下限
b = limit[2] if len(limit) > 2 else None # 上限
# 只处理包含旧变量的积分变量
if not old.has(var):
continue
# 提取新变量t（如t必须是新引入的符号）
t = new.free_symbols - old.free_symbols
if len(t) != 1:
raise ValueError("必须指定一个新变量")
t = t.pop()
# 步骤1：解方程 old = new 得到 var = g(t)
solutions = solve(old - new, var)
if not solutions:
raise ValueError(f"无法解方程 {old} = {new}")
# 步骤2：计算新积分限（用old的表达式在原始积分限处的值）
t_a_val = old.subs(var, a) if a is not None else None
t_b_val = old.subs(var, b) if b is not None else None
# 步骤3：验证解是否满足原始积分限
valid_solution = None
for sol in solutions:
# 检查当t等于新积分限时，解是否还原回原始积分限
valid_a = True
valid_b = True
if t_a_val is not None:
x_at_ta = sol.subs(t, t_a_val)
valid_a = x_at_ta.equals(a)
if t_b_val is not None:
x_at_tb = sol.subs(t, t_b_val)
valid_b = x_at_tb.equals(b)
if valid_a and valid_b:
valid_solution = sol
break
if not valid_solution:
raise ValueError("无法找到满足积分限的解")
# 步骤4：计算雅可比行列式并替换变量
dvar_dt = diff(valid_solution, t)
new_integrand = integrand.subs(var, valid_solution) * dvar_dt
# 构造新积分限
new_limits = [(t, t_a_val, t_b_val) if a is not None and b is not None else (t,)]
substituted = True
# 替换积分并返回
return Integral(new_integrand, *new_limits)
elif isinstance(expr, Basic):
return expr.func(*[replace_integral(arg) for arg in expr.args])
else:
return expr
return replace_integral(F, old, new)
x, a, b, c, t = symbols('x a b c t')
f = Function('f')(x + c)
F = Integral(f, (x, a, b))
G = change_integration_variable(F, x + c, t)
print(G)
# Integral(f(t), (t, a + c, b + c))
F = Integral(x ** 2, (x, 0, 1))
G = change_integration_variable(F, x ** 2, t)
print(G)
# Integral(sqrt(t)/2, (t, 0, 1))
f = Function('f')(sp.exp(sp.sqrt(sp.sin(x))))
F = Integral(f, (x, 0, 1))
G = change_integration_variable(F, sp.sqrt(sp.sin(x)), t)
print(G)
# Integral(2*t*f(exp(sqrt(t**2)))/sqrt(1 - t**4), (t, 0, sqrt(sin(1))))
字符的ASCII数字值
Y = char(Z) 如果Z是字符,转成相应的ASCII数字值. 如果Z是数字, 转成相应的字符.
Z是标量
示例1：
char(B)
#结果:66
char(hello)
#结果:104
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
def char_to_ascii(input_str):
"""
将字符转换为 ASCII 码或将 ASCII 码转换为字符。
参数:
input_str (str): 输入的字符串，可以是字符、ASCII 码或符号表达式。
返回:
res (int, str, or str):
- 若输入为字符，返回其 ASCII 码；
- 若输入为 ASCII 码，返回对应的字符；
- 若输入为符号表达式，返回其字符串形式的 ASCII 码；
- 若输入无效，返回错误消息。
"""
try:
# 将输入字符串转换为 SymPy 表达式
expr = sp.sympify(input_str)
error = False
res = None
# 检查输入是否为数值类型（ASCII 码）
if expr.is_integer:
# 将数值转换为字符
res = chr(int(expr))
# 检查输入是否为符号表达式
elif expr.free_symbols:
# 将符号表达式转换为字符串并取第一个字符的 ASCII 码
res = ord(str(expr)[0])
else:
error = True
if error:
return f"输入错误: {input_str} 必须是单个字符或 ASCII 码。"
else:
return res
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于演示 `char_to_ascii` 函数的使用。
"""
# 示例输入
test_cases = [
"A", # 65
"65", # A
"x", # 120
"Hello", # 72
]
# 遍历测试用例并输出结果
for case in test_cases:
output = char_to_ascii(case)
print(f"输入: {case}")
print(f"输出: {output}")
print("-" * 40)
if __name__ == "__main__":
main()
切比雪夫谱微分矩阵
这是一个非常有用的数值分析工具，特别是在谱方法和伪谱方法中。
A = chebspec(n,k) 返回一个大小为 n×n 的切比雪夫谱微分矩阵. 参量 k 可以取值 0（默认值）或 1，它决定输出矩阵的字符.
对于 k = 0（无边界条件）, A 是幂零矩阵, 这意味着存在满足 A^c = 0 的正整数 c, 矩阵 A 具有空向量 ones(n,1).
对于 k = 1, A 是非奇异且条件设置良好的矩阵, 其特征值具有负实部
n,k - 输入, 标量
1. 单参数输入（仅指定矩阵阶数）
chebspec(8) - 生成8阶一阶微分矩阵，用于求解一阶微分方程或计算函数导数
chebspec(16) - 生成16阶一阶微分矩阵，提供更高精度的导数近似
chebspec(32) - 生成32阶一阶微分矩阵，适用于需要极高精度的科学计算
实际意义: 生成n阶一阶Chebyshev谱微分矩阵，用于在Chebyshev节点上近似函数的一阶导数
2. 双参数输入（指定矩阵阶数和导数阶数）
chebspec(10,2) - 生成10阶二阶微分矩阵，用于求解泊松方程等二阶微分方程
chebspec(12,4) - 生成12阶四阶微分矩阵，用于求解板弯曲问题或高阶微分方程
chebspec(20,1) - 生成20阶一阶微分矩阵，用于高精度计算函数导数
chebspec(8,3) - 生成8阶三阶微分矩阵，用于特殊应用如计算高阶导数
实际意义: 生成n阶k阶导数的Chebyshev谱微分矩阵
3. 特殊参数组合的实际意义
chebspec(4,1) - 小规模测试，验证算法正确性
chebspec(64,2) - 大规模计算，用于高精度求解偏微分方程
chebspec(24,1) - 中等规模，平衡计算精度和效率
chebspec(100,1) - 超大规模，用于极端精度要求的科学研究
4. 不同阶数对比的实际意义
比较chebspec(8), chebspec(16), chebspec(32) - 研究谱方法的收敛性质
比较chebspec(8,2), chebspec(16,2), chebspec(32,2) - 分析二阶导数近似的精度随节点数增加的变化
比较chebspec(16,1), chebspec(16,2), chebspec(16,4) - 研究不同阶数导数的计算特性
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def chebspec_matrix(input_str):
"""
生成Chebyshev谱微分矩阵。输入应为字符串形式，如"3"（一阶3阶矩阵）或"(4,2)"（二阶4阶矩阵）。
参数:
input_str: 字符串形式的输入，如"3"或"(4,2)"。
返回:
SymPy矩阵对象或错误信息字符串。
"""
try:
expr = sp.sympify(input_str)
error = False
result = None
def eval_chebspec_matrix(n, k=1):
"""内部函数：计算n阶k次导数的Chebyshev微分矩阵。"""
# 生成Chebyshev节点（在区间[-1,1]上的极值点）
x = np.cos(np.pi * np.arange(n) / (n - 1))
# 初始化微分矩阵
D = np.zeros((n, n))
c = np.ones(n)
c[0], c[-1] = 2, 2 # 首尾节点缩放因子
# 填充非对角线元素
for i in range(n):
for j in range(n):
if i != j:
D[i, j] = (c[i] / c[j]) * (-1) ** (i + j) / (x[i] - x[j])
# 对角线元素为行和的相反数
D[i, i] = -np.sum(D[i, :])
# 计算k次导数矩阵（矩阵的k次幂）
return np.linalg.matrix_power(D, k) if k > 1 else D
# 解析输入参数：支持格式如 "3" 或 "(4, 2)"
if isinstance(expr, tuple) and len(expr) == 2:
if all(e.is_number for e in expr):
params = tuple(int(e.evalf()) for e in expr)
result = eval_chebspec_matrix(*params)
else:
error = True
elif expr.is_number:
result = eval_chebspec_matrix(n=int(expr))
else:
error = True
return sp.Matrix(result) if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {e}"
if __name__ == "__main__":
# 示例1：生成3阶一阶微分矩阵
print("示例1：3阶Chebyshev微分矩阵:")
print(chebspec_matrix("3"))
# Matrix([[1.50000000000000, -2.00000000000000, 0.500000000000000],
# [0.500000000000000, -1.11022302462516e-16, -0.500000000000000],
# [-0.500000000000000, 2.00000000000000, -1.50000000000000]])
# 示例2：生成4阶二阶微分矩阵
print("\n示例2：4阶二阶Chebyshev微分矩阵:")
print(chebspec_matrix("(4,2)"))
# Matrix([[5.33333333333334, -9.33333333333334, 6.66666666666667, -2.66666666666667],
# [3.33333333333333, -5.33333333333334, 2.66666666666667, -0.666666666666666],
# [-0.666666666666666, 2.66666666666667, -5.33333333333333, 3.33333333333333],
# [-2.66666666666667, 6.66666666666666, -9.33333333333333, 5.33333333333333]])
切比雪夫多项式的类范德蒙类矩阵
A = chebvand(x) 基于由点 x 组成的向量生成原始切比雪夫范德蒙矩阵, 这些点定义计算切比雪夫多项式的位置. 参量x是长度为 n 的向量,
A 的大小为 n×n. A 中的项满足 A(i,j) = Ti – 1(x(j)), 其中 Ti – 1 是 i - 1 次第一类切比雪夫多项式. 如果 x 为标量，则将使用区间 [0,1] 上的 x 个等间距点计算A
x - 输入, 向量
示例1. 标准 Chebyshev 节点
chebvand([-1, -0.5, 0, 0.5, 1])
#[[1, -1, 1, -1, 1],
[1, -0.5, -0.5, 1, -0.500000000000001],
[1, 6.12323399573677e-17, -1, -1.83697019872103e-16, 1],
[1, 0.5, -0.5, -1, -0.5],
[1, 1, 1, 1, 1]]
实际意义: 在区间[-1,1]上均匀分布的5个Chebyshev节点，用于Chebyshev多项式插值的基础
示例2. Chebyshev-Gauss 节点
chebvand([cos(@pi/8), cos(3@pi/8), cos(5@pi/8), cos(7@pi/8)])
#[[1, 0.923879532511287, 0.707106781186547, 0.382683432365090],
[1, 0.382683432365090, -0.707106781186547, -0.923879532511287],
[1, -0.382683432365090, -0.707106781186548, 0.923879532511287],
[1, -0.923879532511287, 0.707106781186547, -0.382683432365088]]
实际意义: 4个Chebyshev-Gauss节点，常用于高斯求积公式和谱方法
示例3. 高密度 Chebyshev 节点
chebvand([cos(0),cos(1@pi/20),cos(2@pi/20),cos(3@pi/30),cos(4@pi/20),cos(5@pi/20),cos(6@pi/30),
cos(7@pi/20),cos(8@pi/20),cos(9@pi/30),cos(10@pi/20),cos(11@pi/20),cos(12@pi/30),
cos(13@pi/20),cos(14@pi/20),cos(15@pi/30),cos(16@pi/20),cos(17@pi/20),cos(18@pi/30),
cos(19@pi/20),cos(@pi)])
实际意义: 21个高密度Chebyshev节点，用于高精度函数逼近和谱方法计算
示例4. 不对称区间节点
chebvand([0, 0.25, 0.5, 0.75, 1])
#[[1, 6.12323399573677e-17, -1, -1.83697019872103e-16, 1],
[1, 0.25, -0.875, -0.6875, 0.53125],
[1, 0.5, -0.5, -1, -0.5],
[1, 0.75, 0.125, -0.5625, -0.96875],
[1, 1, 1, 1, 1]]
实际意义: 在区间[0,1]上的Chebyshev节点，适用于需要在特定区间进行多项式逼近的问题
示例5. 密集端点节点
chebvand([-1, -0.9, -0.7, -0.4, 0, 0.4, 0.7, 0.9, 1])
实际意义: 在区间端点处节点更密集的分布，适用于边界层问题或边界条件重要的应用
示例6. 复数节点
chebvand([-1,-0.5+0.5@i,0.5@i,0.5+0.5@i,1])
#[[1, 1, 1, 1, 1],
[1, 0.5, -0.5, -1, -0.5],
[1, 6.12323399573677e-17, -1, -1.83697019872103e-16, 1],
[1, -0.5, -0.5, 1, -0.500000000000001],
[1, -1, 1, -1, 1]]
示例7. 高维节点子集
chebvand([0.2, 0.4, 0.6, 0.8])
#[[1, 0.2, -0.92, -0.568],
[1, 0.4, -0.68, -0.944],
[1, 0.6, -0.28, -0.936],
[1, 0.8, 0.28, -0.352]]
实际意义: 高维张量积网格的一维投影，用于高维函数逼近的降维处理
示例8. 特殊函数零点
chebvand([besseli(0,0),besseli(0,1),besseli(0,2),besseli(0,3),besseli(0,4)])
#[[1, 1, 1, 1, 1],
[1, 1.26606587775201, 2.20584561361593, 4.31942584822412, 8.73150974221725],
[1, 2.27958530233607, 9.39301830125324, 40.5447876258851, 175.457585615356],
[1, 4.88079258586502, 46.6442725324700, 450.441246513229, 4350.37632016666],
[1, 11.3019219521363, 254.466879624362, 5740.62770388428, 129505.785651519]]
实际意义: 贝塞尔函数零点作为节点，用于特殊函数逼近或物理问题求解
示例9. 实验数据点
chebvand([0.1, 0.3, 0.45, 0.6, 0.8, 0.95])
#[[1, 0.1, -0.98, -0.296, 0.9208, 0.48016],
[1, 0.3, -0.82, -0.792, 0.3448, 0.99888],
[1, 0.45, -0.595, -0.9855, -0.29195, 0.722745],
[1, 0.6, -0.28, -0.936, -0.8432, -0.0758399999999997],
[1, 0.8, 0.28, -0.352, -0.8432, -0.99712],
[1, 0.95, 0.805, 0.5795, 0.296049999999999, -0.0170050000000007]]
实际意义: 实验测量点作为节点，用于基于实验数据的函数逼近
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import numpy as np
import sympy as sp
def chebvand_matrix(input_str):
"""
生成Chebyshev-Vandermonde矩阵。
参数:
input_str: 输入的字符串，表示节点列表（例如 "[0, 1, 2]"）。
返回:
如果输入有效，返回对应的SymPy矩阵对象；否则返回错误信息。
"""
try:
# 预处理输入字符串，替换常见中文符号
input_str = input_str.strip().replace('，', ',').replace('【', '[').replace('】', ']')
expr = sp.sympify(input_str)
error = False
result = None
def evaluation_chebvand_matrix(x):
"""
根据节点x生成Chebyshev-Vandermonde矩阵。
参数:
x: 节点列表（NumPy数组）。
返回:
Chebyshev-Vandermonde矩阵（NumPy数组）。
"""
n = len(x)
V = np.zeros((n, n))
# 用Chebyshev多项式T_j(x_i)填充矩阵
for i in range(n):
for j in range(n):
V[i, j] = np.cos(j * np.arccos(x[i]))
return V
if isinstance(expr, tuple):
error = True
elif isinstance(expr, list):
x = np.array(expr, dtype=float)
result = evaluation_chebvand_matrix(x=x)
result = sp.Matrix(result)
else:
error = True
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {e}"
if __name__ == "__main__":
# 定义测试用例
test_cases = [
"[0.5, 0, -0.5]",
# Matrix([[1.00000000000000, 0.500000000000000, -0.500000000000000],
# [1.00000000000000, 6.12323399573677e-17, -1.00000000000000],
# [1.00000000000000, -0.500000000000000, -0.500000000000000]])
"[1, 0.5, 0]",
# Matrix([[1.00000000000000, 1.00000000000000, 1.00000000000000],
# [1.00000000000000, 0.500000000000000, -0.500000000000000],
# [1.00000000000000, 6.12323399573677e-17, -1.00000000000000]])
"[0, 1, 2]",
# Matrix([[1.00000000000000, 6.12323399573677e-17, -1.00000000000000],
# [1.00000000000000, 1.00000000000000, 1.00000000000000],
# [nan, nan, nan]])
]
# 遍历测试用例
for case in test_cases:
print(f"测试输入：{case}")
matrix = chebvand_matrix(case)
print("结果：")
if isinstance(matrix, sp.Matrix):
print(matrix) # 使用SymPy的漂亮打印输出矩阵
else:
print(matrix)
print("\n" + "=" * 50 + "\n")
切比雪夫窗
w = chebwin(L,at,sym=1) 返回一个长度为L个点, 衰减为at的修正的矩形窗 默认sym=1
当sym=1, 生成一个对称窗口，用于滤波器设计.
当sym=0, 生成一个周期性窗口，用于光谱分析.
示例1. 滤波器设计应用
window = chebwin(21,50,1)
print(window[:5])
#[0.04701489419331997, 0.09138453402857427, 0.166876175799463, 0.2680125205148906, 0.3913884321014329]
实际意义: 设计长度为21的切比雪夫窗，主瓣衰减50dB，对称窗函数。常用于FIR滤波器设计，提供良好的频率选择性和旁瓣抑制。
示例2. 频谱分析应用
window = chebwin(64,80)
print(window[:5])
#[0.0028493642872368784, 0.004363852553209171, 0.00754638518095506, 0.012093661448546693, 0.018339714569737226]
实际意义: 使用64点切比雪夫窗进行频谱分析，80dB的旁瓣抑制可以显著减少频谱泄漏，适用于分析含有强干扰信号的弱信号。
示例3. 非对称窗应用
window = chebwin(32,60,0)
print(window[:5])
#[0.018933474124488717, 0.03293723623873491, 0.05890066365956552, 0.0953386194339341, 0.14349253313717228]
实际意义: 生成32点非对称切比雪夫窗，60dB旁瓣抑制。非对称窗在某些信号处理算法中特别有用，如自适应滤波和实时处理系统。
示例4. 高衰减要求应用
window = chebwin(128,100)
print(window[:5])
#[0.0004232940803023183, 0.0004935392032544287, 0.0007744633593284243, 0.0011548932426022188, 0.0016579418772179316]
实际意义: 使用128点切比雪夫窗，提供100dB的极高旁瓣抑制。适用于需要极低频谱泄漏的应用，如雷达信号处理和声纳系统。
示例5. 短窗高衰减应用
window = chebwin(15,70)
print(window[:5])
#[0.013676777303698682, 0.058917064170330366, 0.1586257687949665, 0.3238796950376703, 0.5405196641940823]
实际意义: 短窗口(15点)配合高衰减(70dB)，适用于处理瞬态信号或需要快速响应的实时系统，如通信系统中的突发信号检测。
示例6. 长窗适中衰减应用
window = chebwin(256,40)
print(window[:5])
#[0.7939129737029521, 0.08737346870561453, 0.09212481430107142, 0.09700865687805764, 0.10202544589699064]
实际意义: 长窗口(256点)配合适中衰减(40dB)，提供良好的频率分辨率，适用于频谱细化分析和高精度频率测量。
示例7. 特殊对称性应用
window = chebwin(48,55,0)
print(window[:5])
#[0.03581420563137859, 0.03630505426021606, 0.05355628715441584, 0.07514676591779224, 0.10143526255872509]
window = chebwin(48,55,1)
print(window[:5])
#[0.03549951020239242, 0.036729370250494796, 0.05451746467576678, 0.0768545627012616, 0.10411763941832897]
实际意义: 比较相同参数下对称和非对称窗的性能差异，用于研究窗函数对称性对特定应用(如相位响应)的影响。
示例8. 多分辨率分析应用
window = chebwin(32, 50)
print(window[:5])
#[0.05066442575214733, 0.06606943466280632, 0.10497971848273262, 0.15478981120001772, 0.21565675218312705]
window = chebwin(64, 50)
print(window[:5])
#[0.07299872909012727, 0.04786458179557381, 0.06280951380570458, 0.08021333955840286, 0.10019160557412471]
window = chebwin(128, 50)
print(window[:5])
#[0.12444229865084148, 0.04068971072251296, 0.047184860174298626, 0.05424981446720973, 0.061902923228623556]
实际意义: 固定衰减系数(50dB)下不同窗口长度的比较，用于多分辨率分析和研究窗口长度对频谱特性的影响。
示例9. 变衰减系数应用
window = chebwin(64, 40)
print(window[:5])
#[0.2322700449967569, 0.103010165281808, 0.1247645933094223, 0.14870527120295107, 0.17481332814409475]
window = chebwin(64, 60)
print(window[:5])
#[0.023933773480517923, 0.02173705528931808, 0.031137988104337874, 0.0428020403938936, 0.05696957101074208]
window = chebwin(64, 80)
print(window[:5])
#[0.0028493642872368784, 0.004363852553209171, 0.00754638518095506, 0.012093661448546693, 0.018339714569737226]
实际意义: 固定窗口长度(64点)下不同衰减系数的比较，用于研究衰减系数对主瓣宽度和旁瓣抑制的权衡关系。
示例10. 极端参数测试
window = chebwin(3, 30)
print(window[:5])
#[0.5326554320337175, 1.0, 0.5326554320337175]
window = chebwin(1024, 120)
print(window[:5])
#[0.00019161405933818167, 3.942284700243726e-05, 4.346639981018619e-05, 4.7777706219050436e-05, 5.2369198081993305e-05]
实际意义: 测试极小窗口和极大窗口的极限情况，以及极高衰减系数的实现可行性，用于验证算法的鲁棒性和数值稳定性。
应用领域说明
数字滤波器设计：切比雪夫窗用于设计有限脉冲响应(FIR)滤波器，通过调整窗口参数可以平衡滤波器的过渡带宽和阻带衰减。
频谱分析：在傅里叶变换前应用切比雪夫窗，可以减少频谱泄漏，提高频率分辨率和动态范围。
波束成形：在阵列信号处理中，切比雪夫窗用于控制旁瓣电平，提高波束成形的性能。
音频处理：切比雪夫窗用于音频频谱分析和音频滤波器设计，特别是在需要高动态范围的场合。
雷达和声纳系统：切比雪夫窗的高旁瓣抑制特性使其特别适合用于雷达和声纳信号处理。
通信系统：在数字通信中，切比雪夫窗用于脉冲成形和信道估计，减少符号间干扰。
生物医学信号处理：在心电图(ECG)和脑电图(EEG)分析中，切比雪夫窗用于提高频谱分析的准确性。
这些参数示例展示了切比雪夫窗在不同领域的应用，窗口长度、衰减系数和对称性的选择直接影响窗函数的性能特征，如主瓣宽度、旁瓣电平和相位响应。
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
from scipy import signal
def chebyshev_window(input_str):
"""
根据输入的参数生成切比雪夫窗口系数。
参数:
input_str (str): 格式为'(m, at)'或'(m, at, sym)'的字符串，其中
- m (int): 窗口长度（必须为正整数）
- at (float): 主瓣衰减系数（单位：分贝）
- sym (int, 可选): 对称性标志（0表示非对称，1表示对称，默认为1）
返回:
list | str: 成功返回窗口系数列表，失败返回错误描述字符串
"""
try:
# 将输入字符串解析为SymPy表达式
expr = sp.sympify(input_str)
# 检查是否为元组格式输入
if not isinstance(expr, tuple):
return f"输入格式错误：需为元组格式，如'(11, 50)'"
# 参数数量检查
if len(expr) < 2:
return "参数不足：至少需要窗口长度和衰减系数两个参数"
# 解析基础参数
m = int(expr[0])
at = float(expr[1])
# 处理对称性参数（默认对称）
sym = True
if len(expr) >= 3:
if expr[2] == 0: # 第三个参数为0时设为非对称
sym = False
# 参数有效性检查
if m <= 0:
return "窗口长度必须为正整数"
if at <= 0:
return "衰减系数必须为正数"
# 生成切比雪夫窗口
window = signal.windows.chebwin(m, at, sym)
return list(window)
except Exception as e:
return f"处理过程中发生错误：{str(e)}"
if __name__ == "__main__":
# 测试用例
test_cases = [
"(7, 50)",
# 前5个系数：[0.11169109836363081, 0.419629989244334, 0.8137735925687217, 1.0, 0.8137735925687217]
"(8, 40.5, 0)",
# 前5个系数：[0.1261675884188586, 0.3449958474928207, 0.639797528234691, 0.897289854502741, 1.0]
"(9, 60, 1)",
# 前5个系数：[0.05186856359432399, 0.22712393362332237, 0.5379172015600897, 0.8604844373949189, 1.0]
"(5, 50, 3)",
# [0.20549421633071246, 0.70104634453696, 1.0, 0.70104634453696, 0.20549421633071246]
]
# 执行测试
for case in test_cases:
print(f"输入：{case}")
result = chebyshev_window(case)
if isinstance(result, list):
print(f"生成成功！窗口长度：{len(result)}")
print(f"前5个系数：{result[:5]}") if len(result) >= 5 else print(f"系数：{result}")
else:
print(f"错误信息：{result}")
第一类切比雪夫多项式
ChebyshevT（n，x）表示在点x处的第一类第n次Chebyshev多项式
n是多项式的次数, 标量,向量,数组,矩阵.
x是评估点,标量,向量,数组,矩阵
示例1. 射频滤波器设计 (通信工程)
chebyshevT(5,[0.1, 0.25, 0.5, 0.75, 0.9, 1.0, 1.1])
#[0.48016,0.953125,0.5,-0.890625,-0.63216,1,4.64816]
解释: 设计一个5阶切比雪夫I型低通滤波器。
参数 x 是一个归一化频率向量（x = f/f_cutoff）。
计算 T5(x) 的目的是为了确定滤波器在通带（x<1）和阻带（x>1）的频率响应（衰减）。
例如，在 x=0.5 时响应接近1（通带），在 x=1.1 时响应很小（阻带），从而实现滤除高频信号、保留低频信号的功能。
示例2. 结构振动模态分析 (航空航天工程)
n = 4 (单个整数，表示分析第4阶振动模态)
x = np.linspace(-1, 1, 100) (从翼根(-1)到翼尖(1)的100个归一化位置坐标)
result = chebyshevT(n,x)
print(result[:10])
#[1.0, 0.692830037884505, 0.416745443279524, 0.170211169209409, -0.0482758511561769, -0.240186704502349,
-0.406960497368715, -0.550004356149671, -0.670693427094264, -0.770370876306274]
解释: 分析飞机机翼的一维简化模型。参数 n 是一个标量，表示要分析的第4阶振动模态。
参数 x 是一个向量，表示从翼根到翼尖的100个位置点。计算 T₄(x) 可以得到机翼在第4阶模态下的振动形态，用于预测其在气流中的颤振特性。
n = [1, 2, 3, 4] (4个不同的模态阶数)
x = 0.5 (单个位置点，例如翼展中点)
result = chebyshevT(n,x)
print(result)
#[0.5, -0.5, -1.0, -0.5]
解释: 分析飞机机翼在特定位置(x=0.5，翼展中点)处的前四阶振动模态的振幅。
计算 Tₙ(0.5) 可以得到在翼展中点处，各阶模态的振动幅度，用于评估该位置对不同振动模式的敏感性。
示例3. 光学薄膜反射率计算 (光子学/材料科学)
result = chebyshevT(7,[[0.65, 0.75],[0.55, 0.85]])
print(result)
#[[0.971170850000007, 0.33984375],
[0.804573550000001, -0.73706135]]
解释: 设计一个7层的抗反射涂层，用于太阳能电池板。参数 x 是一个2x2的矩阵，代表照射在电池板不同区域上的光波波长。
通过切比雪夫多项式逼近，可以计算出该多层膜结构在不同波长下的反射率，目标是将 T7(x) 的值（与反射率相关）在目标波长范围内最小化，从而让更多光能穿透薄膜被电池吸收。
示例4. 机器人运动轨迹规划 (机械工程/ robotics)
n = 3
x = np.linspace(0, 10, 1000)（单位：秒）
result = chebyshevT(n,x)
print(result[:5])
#[0, -0.0300260180059904, -0.0600279638677388, -0.0899817654410087, -0.119863350581556]
解释: 规划一个机械臂关节在10秒内的运动角度。使用3阶切比雪夫多项式 T3(x) 来拟合一条平滑的运动轨迹曲线。
参数 x 是时间序列。选择切比雪夫多项式是因为其能提供在给定时间内极其平滑的运动（最小化加速度的突变），减少对机械部件的冲击和磨损。
示例5. 计算流体动力学 (CFD) 中的参数化研究
n = [0,1,2,3,4,5,6,7,8,9,10]
x = 0.723 （马赫数 Mach Number）
result = chebyshevT(n,x)
print(result)
#[1.0, 0.723, 0.0454579999999999, -0.657267732, -0.995867140472, -0.782756153122512, -0.135998256943152,
0.586102673582713, 0.983502722943761, 0.83604226379397, 0.225414390502288]
解释: 模拟一个特定翼型（NACA系列）在不同攻角下的升力系数。
首先，用10阶切比雪夫多项式来参数化翼型的几何形状（n 为阶数）。
然后，对于一个固定的飞行条件（例如，巡航马赫数 x=0.723），计算该多项式的值，生成一系列相关的几何外形。接下来对每个外形进行CFD模拟，以高效地研究几何变化对气动性能的影响。
示例6. 经济学指标预测 (计量经济学)
n = 4,
x = np.array([2021, 2022, 2023, 2024, 2025]) - 2023 （将时间中心化）
result = chebyshevT(n,x)
print(result)
#[97,1,1,1,97]
解释: 预测未来几年的GDP增长率。使用一个4阶切比雪夫多项式 T4(x) 来拟合历史数据并外推未来趋势。
参数 x 是经过中心化处理的时间变量（例如，以2023年为原点）。高阶多项式可以捕捉数据中复杂的非线性趋势，但同时需要防止过拟合。
示例7. 医学图像重建 (计算机断层扫描 CT)
n = 64,
x 是一个 512x512 的投影数据（正弦图 Sinogram）矩阵
result = chebyshevT(n,x)
解释: 在CT图像重建中，滤波反投影（FBP）算法需要一个特定的卷积滤波器。切比雪夫多项式可用于设计或近似这个滤波器。
参数 n=64 决定了滤波器的长度和特性（如锐利度）。算法会将这个滤波器（基于 T64 设计）应用到巨大的投影数据矩阵 x 的每一个像素行上，以消除模糊并重建出清晰的人体断层图像。
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
from scipy.special import eval_chebyt
def chebyshevt_polynomial(input_str):
"""
计算切比雪夫多项式，支持标量和矩阵输入
参数:
input_str (str): 输入表达式字符串，格式为"(n, x)"，其中
n: 多项式阶数（整数或整数矩阵）
x: 变量值或变量矩阵
返回:
sp.Expr 或 sp.Matrix 或 str: 计算结果，错误时返回错误描述字符串
功能说明:
1. 支持标量计算：如输入"(3, 0.5)"返回T3(0.5)的值
2. 支持矩阵计算：当n或x为矩阵时，进行逐元素计算
3. 输入验证：检查阶数有效性、矩阵形状匹配等
"""
try:
# 符号化输入表达式
expr = sp.sympify(input_str)
error = False
result = None
# 输入验证
if isinstance(expr, tuple) and len(expr) == 2:
"""计算单个元素的切比雪夫多项式值"""
if all(e.is_number for e in expr):
n, x = expr
n_raw = float(n)
x_raw = complex(x)
result = eval_chebyt(n_raw, x_raw)
elif any(e.free_symbols for e in expr):
result = sp.expand_func(sp.chebyshevt(*expr))
else:
error = True
else:
error = True
return result if not error else f"输入错误：{input_str}"
except Exception as e:
return f"计算错误：{str(e)}"
if __name__ == "__main__":
# 测试用例
test_cases = [
"(3, 0.5)", # (-1+0j)
"(4,x)", # 8*x**4 - 8*x**2 + 1
]
# 执行测试
for case in test_cases:
print(f"输入：{case}")
result = chebyshevt_polynomial(case)
if result:
print("计算结果：")
print(result)
else:
print(f"错误信息：{result}")
print("-" * 60)
第二类切比雪夫多项式
ChebyshevU（n，x）表示在点x处的第二类第n次Chebyshev多项式
n是多项式的次数, 标量,向量,数组,矩阵.
x是评估点,标量,向量,数组,矩阵
示例1. 结构振动分析（机械工程）
n = 4,
x = np.linspace(-1, 1, 50)
result = chebyshevU(n,x)
print(result[:10])
#[nan, 3.50298110897494, 2.2603557347426, 1.24761097564338, 0.441299708350762]
解释: 分析梁的横向振动模态。n=4表示分析第4阶振动模态，x是从-1到1的50个点，表示梁的长度方向归一化位置。U₄(x)描述了梁在第4阶模态下的振动形状。
示例2. 滤波器设计（信号处理）
n = [3, 5, 7]
x = 0.8
result = chebyshevU(n,x)
print(result)
#[0.896, -1.09824, -1.5110144]
解释: 设计不同阶数的切比雪夫II型滤波器。n=[3,5,7]表示同时计算3阶、5阶和7阶滤波器在归一化频率x=0.8处的响应，用于比较不同阶数滤波器的性能。
示例3. 量子力学中的波函数（物理学）
result = chebyshevU(6,x)
print(result)
#64x^6-80x^4+24x^2-1
解释: 在量子力学中，第二类切比雪夫多项式用于描述某些势场中的粒子波函数。n=6表示第6能级的波函数，x是位置变量（符号形式），用于解析推导波函数表达式。
示例4. 数值积分权重计算（计算数学）
n = 8
x = [-0.9, -0.5, 0, 0.5, 0.9]
result = chebyshevU(n,x)
print(result)
#[-1.82196223999017, 0, 1.00000000000067, -4.49640324973188e-15, -1.82196224]
解释: 在切比雪夫-Gauss积分中，第二类切比雪夫多项式用于计算积分权重。n=8表示使用8阶多项式，x是积分点位置，计算在这些点处的多项式值用于确定权重。
示例5. 图像处理中的边缘检测（计算机视觉）
n = 3
x = np.random.rand(256, 256)
result = chebyshevU(n,x)
print(result[:5,:5])
#[[1.58062273204369, 1.30296759225335, -0.0468027183434279, -1.05629153621642, -1.06858184641744],
[-0.392656241277002, -1.05266067488193, 1.55602936644183, -0.595583230935483, 3.82526935840964],
[-0.854589133670021, -0.32099914264642, 1.83141118803974, -1.07947658465664, -1.07262473844843],
[1.68623456598227, -1.03995199207091, 0.450653167606415, 2.84345431464493, 0.0692488453660534],
[-0.503495720418721, 0.033884779966823, -1.05120036409341, -0.549978740900149, -0.861032175412535]]
解释: 在图像处理中，切比雪夫多项式可用于构造边缘检测滤波器。n=3表示使用3阶多项式，x是一个256×256的随机图像矩阵（模拟图像数据），计算多项式值用于增强图像边缘。
示例6. 经济学中的时间序列预测（计量经济学）
n = 5,
x = np.array([2018, 2019, 2020, 2021, 2022]) - 2020
result = chebyshevU(n,x)
print(result)
#[-780.0, nan, 1.59872115546023e-14, 6.0, 780.0]
解释: 使用切比雪夫多项式拟合经济指标的时间序列数据。n=5表示使用5阶多项式，x是中心化后的时间变量（以2020年为基准），用于预测未来经济趋势。
示例7. 声学滤波器设计（音频工程）
n = [[2],[4],[6]]
x = [np.linspace(0.1, 0.9, 20)]
result = chebyshevU(n,x)
print(result[:5,:5])
#[[-0.96, -0.919224376731302, -0.864265927977839, -0.795124653739612, -0.71180055401662],
[0.881599999999998, 0.764197831508348, 0.611221522241238, 0.427347868724148, 0.21846058271499],
[-0.767936000000013, -0.547442730144711, -0.275213530383199, 0.0279819588697867, 0.337839607494345]]
解释: 设计音频均衡器的滤波器响应。n=[2,4,6]表示同时计算2阶、4阶和6阶滤波器在不同频率x上的响应，用于优化音频系统的频率特性。
示例8. 有限元分析中的形函数（结构工程）
n = 3
x = np.mgrid[-1:1:5j, -1:1:5j]
result = chebyshevU(n,x)
print(result)
#[[[nan, nan, nan, nan, nan],
[1.0, 1.0, 1.0, 1.0, 1.0],
[0, 0, 0, 0, 0],
[-1.0, -1.0, -1.0, -1.0, -1.0],
[4.0, 4.0, 4.0, 4.0, 4.0]],
[[nan, 1.0, 0, -1.0, 4.0],
[nan, 1.0, 0, -1.0, 4.0],
[nan, 1.0, 0, -1.0, 4.0],
[nan, 1.0, 0, -1.0, 4.0],
[nan, 1.0, 0, -1.0, 4.0]]]
解释: 在有限元分析中，切比雪夫多项式可用于构造高阶形函数。n=3表示使用3阶多项式，x是一个5×5的网格点坐标，计算多项式值用于描述单元内部的位移场。
示例9. 电磁场计算（电磁学）
n = 4
x = 0.75
result = chebyshevU(n,x)
print(result)
#-0.6875
解释: 在波导理论中，切比雪夫多项式用于描述电磁场的分布。n=4表示计算第4阶模式，x是归一化位置坐标，用于确定特定位置的场强。
示例10. 多项式逼近（数值分析）
n = 7
x = [[-0.8, -0.3], [0.2, 0.7]]
result = chebyshevU(n,x)
print(result)
#[[1.51101440000275, 0.678566399999454],
[-1.01980159999998, 0.111910400000004]]
解释: 使用切比雪夫多项式逼近复杂函数。n=7表示使用7阶多项式，x是一个2×2矩阵，表示不同区域内的点，计算多项式值用于函数逼近。
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
from scipy.special import eval_chebyu
def chebyshevu_polynomial(input_str):
"""
计算切比雪夫多项式，支持标量和矩阵输入
参数:
input_str (str): 输入表达式字符串，格式为"(n, x)"，其中
n: 多项式阶数（整数或整数矩阵）
x: 变量值或变量矩阵
返回:
sp.Expr 或 sp.Matrix 或 str: 计算结果，错误时返回错误描述字符串
功能说明:
1. 支持标量计算：如输入"(3, 0.5)"返回T3(0.5)的值
2. 支持矩阵计算：当n或x为矩阵时，进行逐元素计算
3. 输入验证：检查阶数有效性、矩阵形状匹配等
"""
try:
# 符号化输入表达式
expr = sp.sympify(input_str)
error = False
result = None
# 输入验证
if isinstance(expr, tuple) and len(expr) == 2:
"""计算单个元素的切比雪夫多项式值"""
if all(e.is_number for e in expr):
n, x = expr
n_raw = float(n)
x_raw = complex(x)
result = eval_chebyu(n_raw, x_raw)
elif any(e.free_symbols for e in expr):
result = sp.expand_func(sp.chebyshevu(*expr))
else:
error = True
else:
error = True
return result if not error else f"输入错误:{input_str}"
except Exception as e:
return f"计算错误：{str(e)}"
if __name__ == "__main__":
# 测试用例
test_cases = [
"(3, 0.5)", # (-1+0j)
"(4,x)", # 16*x**4 - 12*x**2 + 1
]
# 执行测试
for case in test_cases:
print(f"输入：{case}")
result = chebyshevu_polynomial(case)
if isinstance(result, (sp.Expr, sp.Matrix)):
print("计算结果：")
print(result)
else:
print(f"错误信息：{result}")
print("-" * 60)
符号表达的子表达或术语
subexpr = children(expr)返回一个无值单元格数组,其中包含符号表达式expr的子表达式.例如,求和的子表达式就是它的项.
subexr = children(A)返回一个嵌套单元格数组,其中包含符号矩阵A中每个表达式的子表达式.
expr —— 输入表达式,符号数,符号变量,符号函数,符号表达式
A —— 输入矩阵,符号矩阵
示例1. 数学表达式分析
children(x + sin(y)*z)
#结果: (x, z*sin(y))
应用: 在符号计算系统中，分析表达式的结构，提取操作数和运算符
用途: 自动微分、表达式简化、代码生成
示例2. 微分方程处理
children(diff(f(x), x) + f(x)**2)
#结果: (Derivative(f(x), x), f(x)**2)
应用: 在物理建模中，分析微分方程的结构
用途: 数值求解方法选择、方程分类、稳定性分析
示例3. 积分表达式分解
children(int(exp(-x**2), (x, -@inf, @inf)))
#结果: (exp(-x**2), (x, -oo, oo))
应用: 在概率论和统计学中，处理高斯积分
用途: 数值积分方法选择、近似计算、解析求解
示例4. 符号矩阵处理
children([[x+y, sin(x)*cos(y)],[x^3-y^3,exp(x*y^2)+3]])
#结果: [[x, y], [sin(x), cos(y)]]
应用: 在线性代数和控制系统理论中，分析符号矩阵
用途: 特征值计算、矩阵分解、系统稳定性分析
示例5. 函数矩阵分析
children([[sin(x), cos(y)], [tan(z), exp(w)]])
#结果: [[x, y], [z, w]]
应用: 在数学物理中，处理包含特殊函数的矩阵
用途: 特殊函数性质研究、数值计算方法选择
示例6. 多项式表达式
children(x**2 + 2*x*y + y**2 + sin(x+y))
#结果: (x**2, 2*x*y, y**2, sin(x + y))
应用: 在代数几何和优化理论中，分析多项式结构
用途: 多项式因式分解、最优化问题求解、几何形状描述
示例7. 级数展开
children(series(sin(x), x, 0, 5))
#结果: (x, -x**3/6, O(x**5))
应用: 在近似计算和数值方法中，分析泰勒级数
用途: 函数近似、误差分析、数值算法设计
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
def child_symbolic_expression(input_str):
"""
处理符号表达式或矩阵，返回其子表达式
参数:
input_str: 输入字符串，可以是矩阵或符号表达式
返回:
子表达式结构 或 错误信息字符串
处理逻辑:
1. 尝试将输入字符串转换为SymPy表达式
2. 如果是矩阵，递归处理每个元素
3. 如果是符号表达式，提取其子表达式
4. 数值表达式返回错误信息
"""
try:
expr = sp.sympify(input_str, evaluate=False)
error = False
result = None
# 普通符号表达式处理
if expr.free_symbols:
result = expr.args
# 数值表达式或无法处理的情况
else:
error = True
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误:{e}"
def main():
"""测试用例主函数"""
# 测试: 普通符号表达式
print("测试: 普通符号表达式")
input_str = "x + sin(y)*z"
print("输入字符串:", input_str)
print("解析结果:", child_symbolic_expression(input_str), "\n")
# 解析结果: (x, z*sin(y))
if __name__ == "__main__":
main()
卡方分布的累积分布函数
p＝ChiSquareCDF（x，k）返回具有自由度k的卡方分布的累积分布函数（cdf），以x中的值进行评估.
x是评估cdf的值, 非负标量,非负标量数组.
k是自由度,正标量值,正标量值数组.
示例1: 标量数值输入
ChiSquareCDF(2,3)
#结果: 0.42759329552912023
ChiSquareCDF(5.5,2)
#结果: 0.9360721387932924
示例2: 符号输入
ChiSquareCDF(x,3)
#结果: Piecewise((-0.797884560802865*x**0.5*exp(-x/2) + erf(sqrt(2)*sqrt(x)/2), x >= 0), (0, True))
ChiSquareCDF(2.5,k)
#结果: lowergamma(k/2, 1.25)/gamma(k/2)
ChiSquareCDF(x,k)
#结果: Piecewise((lowergamma(k/2, x/2)/gamma(k/2), x >= 0), (0, True))
示例3: 数组输入
不同分位数，相同自由度
ChiSquareCDF([1,2,3],2)
#结果: [0.39346934,0.63212056,0.77686984]
相同分位数，不同自由度
ChiSquareCDF(5, [1,2,3])
#结果: [0.97465268,0.917915,0.82820286]
分位数和自由度都是数组
ChiSquareCDF([1, 2, 3], [2, 3, 4])
#结果: [0.39346934,0.4275933,0.4421746]
示例4: 假设检验中的p值计算
假设卡方统计量为6.25，自由度为3
chi_statistic = 6.25
df = 3
p_value = 1 - ChiSquareCDF(chi_statistic,df)
print(f"卡方统计量: {chi_statistic}, 自由度: {df}")
print(f"p值: {p_value}")
#卡方统计量: 6.25, 自由度: 3
#p值: 0.10006083311939495
示例5: 置信区间计算
计算自由度为5时，95%置信水平对应的卡方临界值
需要解方程 F(x) = 0.95，这里演示如何使用符号计算
df = 5
confidence_level = 0.95
# 定义方程
x_sym = sp.symbols('x')
equation = sp.Eq(ChiSquareCDF(x,df),confidence_level)
print(f"需要解的方程: {equation}")
#需要解的方程: Eq(Piecewise((-(0.797884560802865*x**0.5 + 0.265961520267622*x**1.5)*exp(-x/2) + erf(sqrt(2)*sqrt(x)/2), x >= 0), (0, True)), 0.95)
# 注意: 实际应用中可能需要数值方法求解
示例6: 方差分析
假设有三个组，每组样本量分别为10, 12, 15
n1, n2, n3 = 10, 12, 15
k = 3 # 组数
df = k - 1 # 自由度
假设计算得到的Bartlett统计量为4.5
bartlett_stat = 4.5
p_value = 1 - ChiSquareCDF(bartlett_stat, df)
print(f"Bartlett统计量: {bartlett_stat}, 自由度: {df}")
print(f"p值: {p_value}")
#Bartlett统计量: 4.5, 自由度: 2
#p值: 0.10539922456186435
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
from sympy.stats import ChiSquared, cdf
from scipy.stats import chi2
def chi_squared_cdf(input_str):
"""
计算卡方分布的累积分布函数 (CDF)
参数:
input_str: 输入字符串，格式应为包含x值和自由度k的元组，例如 "(x, 2)" 或 "([1,2], 3)"
返回:
CDF计算结果 (数值/矩阵) 或 错误信息字符串
处理逻辑:
1. 将输入字符串转换为SymPy表达式
2. 解析出x值(标量/矩阵)和自由度k
3. 对每个x值计算Chi-Squared(k)的CDF
"""
try:
# 将输入字符串转换为SymPy表达式
expr = sp.sympify(input_str)
error = False
result = None
# 检查输入是否为元组 (x, k)
if isinstance(expr, tuple) and len(expr) == 2:
if all(e.is_number for e in expr):
# 验证k是否为正整数
if not (expr[1].is_Integer and expr[1] > 0):
return f"错误: 自由度k必须为正整数，当前k={expr[1]}"
"""用SciPy计算卡方分布在标量x处的CDF值"""
result = chi2.cdf(float(expr[0]), df=int(expr[1]))
elif any(e.free_symbols for e in expr):
"""计算单个值的卡方分布CDF"""
# 创建卡方分布对象
chi_dist = ChiSquared('Chi', expr[1])
# 计算CDF并转换为浮点数
result = cdf(chi_dist)(expr[0])
else:
error = True
else:
error = True
return result if not error else f"输入格式错误: 需要(x, k)元组，当前输入{input_str}"
except Exception as e:
return f"错误:{e}"
def main():
"""测试用例主函数"""
# 测试1: 标量数值输入
print("测试1: 标量数值输入")
print(chi_squared_cdf("(2, 3)")) # 应输出数值结果
# 0.42759329552912023
print(chi_squared_cdf("(5.5, 2)"), "\n") # 应输出数值结果
# 0.9360721387932924
# 测试2: 符号输入
print("测试3: 符号输入")
x = sp.symbols('x')
print(chi_squared_cdf(f"({x}, 3)"), "\n") # 应输出符号表达式
# Piecewise((-sqrt(2)*sqrt(x)*exp(-x/2)/sqrt(pi) + erf(sqrt(2)*sqrt(x)/2), x >= 0), (0, True))
if __name__ == "__main__":
main()
卡方分布的概率密度函数
y=ChiSquarePDF（x，k）返回具有k个自由度的卡方分布的概率密度函数（pdf）,以x中的值进行评估.
x是评估pdf的值,非负标量,非负标量数组
k是自由度,正标量值,正标量值数组
示例1: 标量数值输入
ChiSquarePDF(2, 3)
#结果: 0.2075537487102974
ChiSquarePDF(5.5, 2)
#结果: 0.031963930603353785
示例2: 符号输入
ChiSquarePDF(x,3) # 固定自由度，变量分位数
#结果: 0.398942280401433*x**0.5*exp(-x/2)
ChiSquarePDF(2.5, k) # 固定分位数，变量自由度
#结果: 0.28650479686019*2.5**(0.5*k - 1.0)/(2.0**(0.5*k)*gamma(k/2))
ChiSquarePDF(x,k) # 两个变量
#x**(0.5*k - 1.0)*exp(-x/2)/(2.0**(0.5*k)*gamma(k/2))
示例3: 数组输入
不同分位数，相同自由度
ChiSquarePDF([1, 2, 3, 4, 5], 3)
#结果: [0.24197072,0.20755375,0.15418033,0.10798193,0.07322491]
相同分位数，不同自由度
ChiSquarePDF(5, [1, 2, 3, 4, 5])
#结果: [0.01464498,0.0410425,0.07322491,0.10260625,0.12204152]
分位数和自由度都是数组
ChiSquarePDF([1, 2, 3], [2, 3, 4])
#结果: [0.30326533,0.20755375,0.16734762]
示例4: 绘制卡方分布曲线
x_values = np.linspace(0, 10, 100)
计算不同自由度下的PDF值
df_values = [1, 2, 3, 5, 7]
for df in df_values:
pdf_values = ChiSquarePDF(x_values, df)
print(f"自由度 {df}: 最大值在 x ≈ {x_values[np.argmax(pdf_values)]:.2f}")
#自由度 1: 最大值在 x ≈ 0.00
#自由度 2: 最大值在 x ≈ 0.00
#自由度 3: 最大值在 x ≈ 1.01
#自由度 5: 最大值在 x ≈ 3.03
#自由度 7: 最大值在 x ≈ 5.05
示例5: 似然函数计算
假设我们有一组来自卡方分布的数据
observed_data = [1.2, 2.5, 3.1, 0.8, 2.9]
对于不同的自由度，计算似然函数值
df_candidates = [1, 2, 3, 4, 5]
for df in df_candidates:
likelihood = np.prod(ChiSquarePDF(observed_data, df))
print(f"自由度 {df}: 似然值 = {likelihood:.6f}")
#自由度 1: 似然值 = 0.000011
#自由度 2: 似然值 = 0.000164
#自由度 3: 似然值 = 0.000246
#自由度 4: 似然值 = 0.000111
#自由度 5: 似然值 = 0.000022
示例6: 贝叶斯分析中的先验分布
在贝叶斯方差分析中，精度参数常使用卡方分布作为先验
true_variance = 4.0
df_prior = 5 # 先验自由度
scale_prior = 10 # 先验尺度参数
计算先验密度
precision_prior = df_prior * scale_prior / true_variance
prior_density = ChiSquarePDF(precision_prior, df_prior)
print(f"精度参数 {precision_prior:.2f} 的先验密度: {prior_density:.6f}")
#精度参数 12.50 的先验密度: 0.011345
示例7: 异常值检测
在卡方分布中，极低概率密度可能表示异常值
test_statistics = [0.5, 1.2, 8.9, 15.2, 3.4] # 假设的检验统计量
df = 3 # 自由度
计算每个统计量的概率密度
pdf_values = ChiSquarePDF(test_statistics, df)
threshold = 0.01 # 密度阈值
for i, (stat, density_val) in enumerate(zip(test_statistics, pdf_values)):
if density_val < threshold:
print(f"统计量 {stat:.2f} 可能是异常值 (密度: {density_val:.6f})")
else:
print(f"统计量 {stat:.2f} 看起来正常 (密度: {density_val:.6f})")
#统计量 0.50 看起来正常 (密度: 0.219696)
#统计量 1.20 看起来正常 (密度: 0.239841)
#统计量 8.90 看起来正常 (密度: 0.013899)
#统计量 15.20 可能是异常值 (密度: 0.000778)
#统计量 3.40 看起来正常 (密度: 0.134384)
示例8: 蒙特卡洛模拟
生成卡方分布随机数并比较理论PDF
np.random.seed(42)
df_sim = 4
n_samples = 1000
samples = np.random.chisquare(df_sim, n_samples)
计算样本直方图
hist, bin_edges = np.histogram(samples, bins=20, density=True)
bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2
计算理论PDF
theoretical_pdf = ChiSquarePDF(bin_centers, df_sim)
# 计算均方误差
mse = np.mean((hist - theoretical_pdf)**2)
print(f"蒙特卡洛模拟与理论PDF的均方误差: {mse:.6f}")
#蒙特卡洛模拟与理论PDF的均方误差: 0.000077
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
from sympy.stats import ChiSquared, density
from scipy.stats import chi2
def chi_squared_pdf(input_str):
"""
计算卡方分布的概率密度函数 (PDF)
参数:
input_str: 输入字符串，格式应为包含x值和自由度k的元组，例如 "(x, 2)" 或 "([1,2], 3)"
返回:
PDF计算结果 (数值/矩阵/符号表达式) 或 错误信息字符串
处理逻辑:
1. 将输入字符串转换为SymPy表达式
2. 解析出x值(标量/矩阵)和自由度k
3. 对每个x值计算Chi-Squared(k)的PDF
"""
try:
# 将输入字符串转换为SymPy表达式
expr = sp.sympify(input_str)
error = False
result = None
# 检查输入是否为元组 (x, k)
if isinstance(expr, tuple) and len(expr) == 2:
if all(e.is_number for e in expr):
# 验证k是否为正整数
if not (expr[1].is_integer and expr[1] > 0):
return f"错误: 自由度k必须为正整数，当前k={expr[1]}"
"""用SciPy计算卡方分布在标量x处的PDF值"""
result = chi2.pdf(float(expr[0]), df=int(expr[1]))
elif any(e.free_symbols for e in expr):
"""计算单个值的卡方分布PDF"""
# 创建卡方分布对象
chi_dist = ChiSquared('Chi', expr[1])
# 计算PDF并转换为浮点数或符号表达式
result = density(chi_dist)(expr[0])
else:
error = True
else:
error = True
return result if not error else f"输入格式错误: 需要(x, k)元组，当前输入{input_str}"
except Exception as e:
return f"错误:{e}"
def main():
"""测试用例主函数"""
# 测试1: 标量数值输入
print("测试1: 标量数值输入")
print(chi_squared_pdf("(2, 3)"))
# 0.2075537487102974
print(chi_squared_pdf("(5.5, 2)"), "\n") # 应输出0.026995
# 0.031963930603353785
# 测试2: 符号输入
print("测试3: 符号输入")
x = sp.symbols('x')
print(chi_squared_pdf(f"({x}, 3)"), "\n") # 应输出符号表达式
# 0.398942280401433*x**0.5*exp(-x/2)
if __name__ == "__main__":
main()
卡方分布的随机抽样
r＝ChiSquareRND（k，sz）从卡方分布生成随机数的数组，其中向量sz指定大小（r）.
k是自由度,正标量值,正标量值数组.
sz是每个维度的大小（作为行向量）,整数的行向量
示例1: 基本功能测试
ChiSquareRND(3,[2,3])
ChiSquareRND(1,[1,1])
示例2: 不同自由度的比较
for df in [1, 3, 5, 10]:
samples = ChiSquareRND(df, [1000, 1])
mean_val = np.mean(samples)
var_val = np.var(samples)
print(f"自由度 {df}: 均值={mean_val:.2f}, 方差={var_val:.2f} (理论值: 均值={df}, 方差={2 * df})")
#自由度 1: 均值=1.02, 方差=2.23 (理论值: 均值=1, 方差=2)
#自由度 3: 均值=2.90, 方差=5.60 (理论值: 均值=3, 方差=6)
#自由度 5: 均值=5.06, 方差=10.35 (理论值: 均值=5, 方差=10)
#自由度 10: 均值=9.69, 方差=18.81 (理论值: 均值=10, 方差=20)
示例3: 蒙特卡洛模拟 - 计算置信区间
模拟1000次实验，每次计算卡方统计量
n_simulations = 1000
df = 5
simulated_stats = ChiSquareRND(df, [1000, 1])
# 计算95%置信区间
lower_bound = np.percentile(simulated_stats, 2.5)
upper_bound = np.percentile(simulated_stats, 97.5)
print(f"自由度 {df} 的卡方统计量95%置信区间: [{lower_bound:.3f}, {upper_bound:.3f}]")
#自由度 5 的卡方统计量95%置信区间: [0.853, 13.179]
示例4: 假设检验的p值估计
假设我们有一个卡方统计量观察值
observed_stat = 8.5
df = 3
通过模拟估计p值
n_sim = 10000
simulated_stats = ChiSquareRND(df, [n_sim, 1])
p_value_est = np.mean(simulated_stats >= observed_stat)
print(f"观察统计量: {observed_stat}, 自由度: {df}")
print(f"模拟估计的p值: {p_value_est:.4f}")
#观察统计量: 8.5, 自由度: 3
#模拟估计的p值: 0.0371
示例5: 统计功效分析
分析不同效应大小下的统计功效
effect_sizes = [0.1, 0.3, 0.5] # 小、中、大效应
df = 4
n_sim = 5000
alpha = 0.05
for effect in effect_sizes:
# 生成非中心卡方分布（这里简化处理，使用偏移的卡方分布）
# 实际应用中可能需要更复杂的非中心卡方分布
critical_value = chi2.ppf(1 - alpha, df)
noncentral_stats = ChiSquareRND(df, [n_sim, 1]) + effect * df
power = np.mean(noncentral_stats >= critical_value)
print(f"效应大小 {effect}: 统计功效 = {power:.3f}")
#效应大小 0.1: 统计功效 = 0.066
#效应大小 0.3: 统计功效 = 0.078
#效应大小 0.5: 统计功效 = 0.110
示例6: 自助法(Bootstrap)应用
假设我们有一组数据，想估计其方差的分布
original_data = np.random.normal(0, 2, 50) # 均值为0，标准差为2的正态分布
n_bootstrap = 1000
bootstrap_variances = np.zeros(n_bootstrap)
for i in range(n_bootstrap):
# 有放回抽样
sample = np.random.choice(original_data, size=len(original_data), replace=True)
bootstrap_variances[i] = np.var(sample, ddof=1) # 无偏估计
使用卡方分布拟合方差估计的分布
df = len(original_data) - 1
生成卡方分布随机数，用于比较
chi2_samples = ChiSquareRND(df, [n_bootstrap, 1])
scaled_chi2 = chi2_samples * np.var(original_data, ddof=1) / df
比较两个分布的均值
print(f"原始数据方差: {np.var(original_data, ddof=1):.3f}")
print(f"自助法方差估计均值: {np.mean(bootstrap_variances):.3f}")
print(f"卡方分布缩放后均值: {np.mean(scaled_chi2):.3f}")
#原始数据方差: 4.337
#自助法方差估计均值: 4.247
#卡方分布缩放后均值: 4.369
示例7: 教学演示 - 中心极限定理
展示即使从偏态分布（卡方分布）抽样，样本均值也趋向正态分布
df = 3 # 较小的自由度使分布更偏态
n_samples = 1000
sample_size = 30 # 每次抽样的样本量
sample_means = np.zeros(n_samples)
for i in range(n_samples):
sample = ChiSquareRND(df, [sample_size, 1])
sample_means[i] = np.mean(sample)
# 检查样本均值是否近似正态分布
from scipy.stats import normaltest
stat, p = normaltest(sample_means)
print(f"样本均值的正态性检验: p值 = {p:.4f}")
#样本均值的正态性检验: p值 = 0.0712
if p > 0.05:
print("样本均值近似正态分布，验证了中心极限定理")
else:
print("样本均值可能不服从正态分布")
#样本均值近似正态分布，验证了中心极限定理
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
from scipy.stats import chi2
def chi_squared_rnd(input_str):
"""
生成卡方分布的随机数矩阵
参数:
input_str: 输入字符串，格式应为(k, [m,n])元组，例如 "(3, [2,3])"
返回:
sp.Matrix 或 错误信息字符串
处理逻辑:
1. 验证输入格式为(k, 矩阵尺寸)
2. 检查k为正整数
3. 生成指定尺寸的卡方分布随机数矩阵
"""
try:
expr = sp.sympify(input_str)
error = False
result = None
# 检查输入是否为(k, 尺寸)元组
if isinstance(expr, tuple) and len(expr) == 2:
k, sz = expr[0], expr[1]
# 验证k参数
if not (k.is_integer and k > 0):
return f"错误: 自由度k必须为正整数，当前k={k}"
# 验证尺寸参数
if isinstance(sz, list) and len(sz) == 2:
size = tuple(int(e.evalf()) for e in sz)
"""用SciPy生成卡方分布的随机数（标量输出）"""
result = chi2.rvs(df=int(k), size=size)
'''
此处是sympy实现
chi_squared = sp.stats.ChiSquared('ChiSquared', k_val)
iterator = sp.stats.sample_iter(chi_squared, numsamples=1)
return list(iterator)[0]
'''
else:
error = True
else:
error = True
return result if not error else f"输入格式错误: 需要(k, [m,n])元组，当前输入{input_str}"
except Exception as e:
return f"错误:{e}"
def main():
"""测试用例主函数"""
# 测试1: 有效输入
print("测试1: 2x3矩阵")
print(chi_squared_rnd("(3, [2,3])"), "\n") # 应输出2x3随机矩阵
# [[4.03513455 1.70488102 1.05668236]
# [5.22645923 3.76494573 8.59081048]]
# 测试2: 边界情况测试
print("测试2: 1x1矩阵")
print(chi_squared_rnd("(1, [1,1])"), "\n") # 应输出1x1矩阵
# [[0.03386891]]
if __name__ == "__main__":
main()
乔列斯基分解
chol(A) A是输入矩阵,可以使用满存储或稀疏存储，但必须为方阵和对称正定矩阵.
chol 假设A是对称实矩阵,或者是Hermitian对称复矩阵.chol仅使用A的上三角或下三角执行计算,具体取决于triangle的值.
将正定对称矩阵分解为一个下三角矩阵及其转置的上三角矩阵乘积.
示例1: 基本功能测试
chol([[4,12,-16],[12,37,-43],[-16,-43,98]])
#[[2, 6, -8],
[0, 1, 5],
[0, 0, 3]]
chol([[9, 3j],[-3j,5]])
#[[3, 0],
[-I, 2]]
示例2: 不同尺寸的矩阵
chol([[4,2],[2,5]])
#[[2, 1],
[0,2]]
chol([[9, 3, 3], [3, 10, 7], [3, 7, 8]])
#[[3, 1, 1],
[0, 3, 2],
[0, 0, 1.73205080756888]]
示例3: 卡尔曼滤波
在卡尔曼滤波中，Cholesky分解用于协方差矩阵的更新
状态协方差矩阵
P = [[2.5, 0.8], [0.8, 1.5]]
过程噪声协方差
Q = [[0.1, 0], [0, 0.1]]
测量矩阵
H = [[1, 0]]
测量噪声协方差
R = [[0.5]]
预测步骤: P = F P F^T + Q (这里简化)
P_pred = P + Q
计算卡尔曼增益: K = P_pred H^T (H P_pred H^T + R)^{-1}
使用Cholesky分解提高数值稳定性
S = H @ P_pred @ H.T + R
L_s = chol(S)
# 解线性方程组
K = P_pred @ H.T @ L_s.T.upper_triangular_solve(L_s.lower_triangular_solve(sp.eye(1)))
print(f"测量协方差S:\n{S}")
#[[3.1]]
print(f"Cholesky分解L_s:\n{L_s}")
#Cholesky分解L_s: [[1.76068168616590]]
print(f"卡尔曼增益K:\n{K}\n")
#卡尔曼增益K: [[0.838709677419355],
[0.258064516129032]]
示例4: 优化问题中的正定矩阵处理
在二次规划中，目标函数为 1/2 x^T Q x + c^T x
其中Q需要是正定矩阵
二次型矩阵
Q = [[6, 2], [2, 5]]
Cholesky分解
L = chol(Q)
print(f"Cholesky分解L:\n{L}")
#Cholesky分解L:
#[[2.44948974278318, 0.816496580927726],
[0, 2.08166599946613]]
验证分解正确性: L L^T 应等于 Q
Q_reconstructed = L @ L.T
print(f"重构的矩阵Q:\n{Q_reconstructed}")
#重构的矩阵Q:
#[[6.66666666666667, 1.69967317119759],
[1.69967317119759, 4.33333333333333]]
print(f"分解是否正确: {Q_reconstructed == Q}\n")
#分解是否正确: False
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
from scipy.linalg import cholesky
def cholesky_matrix(input_str):
"""
执行矩阵的Cholesky分解
参数:
input_str: 输入矩阵的字符串表示，可以是符号矩阵或数值矩阵
返回:
sp.Matrix 或 str: 成功返回下三角矩阵，失败返回错误信息
处理逻辑:
1. 将输入转换为SymPy矩阵
2. 检查矩阵是否对称正定
3. 符号矩阵使用SymPy分解
4. 数值矩阵使用NumPy分解（更高效）
"""
try:
expr = sp.sympify(input_str)
result = None
# 转换为SymPy矩阵
if isinstance(expr, list):
A = sp.Matrix(expr)
else:
return f"输入错误: 无法转换为矩阵 - {input_str}"
# 检查矩阵是否为方阵
if A.rows != A.cols:
return f"错误: 矩阵必须是方阵，当前尺寸为{A.rows}x{A.cols}"
# 检查是否包含符号变量
contains_symbols = any((element.has(sp.I) or element.free_symbols) for element in A)
if contains_symbols:
result = A.cholesky()
else:
N_A = np.array(A, dtype=float)
c = cholesky(N_A)
result = sp.Matrix(c)
return result
except Exception as e:
return f"错误: {e}"
def main():
"""测试用例主函数"""
# 测试1: 有效数值矩阵
print("测试1: 4x4数值矩阵")
print(cholesky_matrix("[[4,12,-16],[12,37,-43],[-16,-43,98]]"), "\n")
# Matrix([[2.00000000000000, 6.00000000000000, -8.00000000000000],
# [0, 1.00000000000000, 5.00000000000000],
# [0, 0, 3.00000000000000]])
# 测试2: 符号矩阵
print("测试2: 复数矩阵分解")
print(cholesky_matrix(f"[[9, 3j],[-3j,5]]"), "\n")
# Matrix([[3, 0], [-I, 2]])
if __name__ == "__main__":
main()
乔列斯基分解的秩1更新
R1 = cholupdate(R,x)（其中 R = chol(A) 是A的原始乔列斯基分解）返回 A + x*x' 的上三角乔列斯基因子,其中x是具有合适长度的一个列向量.cholupdate仅使用R的对角线和上三角.R 的下三角将被忽略.
R1 = cholupdate(R,x,'+') 与 R1 = cholupdate(R,x) 相同.
R1 = cholupdate(R,x,'-') 返回 A - x*x' 的乔列斯基因子.当R不是有效的乔列斯基因子或旧矩阵不是正定矩阵时,将会报告一条错误消息,这样将没有乔列斯基分解
cholupdate 仅适用于满矩阵.
示例1: 基本功能测试
秩-1更新
cholupdate([[4.0, 0.0], [0.0, 9.0]],[2.0, 3.0],plus)
#[[4.47213595499958, 1.34164078649987],
[0, 9.39148550549912]]
秩-1降级
cholupdate([[2.0, 0.0], [0.0, 3.0]], [1.0, 1.0], minus)
#[[1.73205080756888, 0.577350269189626],
[0, 2.94392028877595]]
示例2: 卡尔曼滤波中的应用:更新状态协方差矩阵，反映系统动态变化
在卡尔曼滤波中，当系统状态协方差矩阵需要更新时，可以使用秩-1更新
初始状态协方差矩阵的Cholesky因子
L_init = [[2.0, 0.0], [0.0, 3.0]]
# 过程噪声的影响向量
x_noise = [0.5, 0.8]
执行秩-1更新
L_updated = cholupdate(L_init,x_noise,plus)
print("更新后的Cholesky因子L:\n", L_updated)
#更新后的Cholesky因子L:
#[[2.06155281280883, 0.194028500029066],
[0, 3.09876635795222]]
验证更新后的协方差矩阵
P_updated = L_updated * L_updated.T
print("更新后的协方差矩阵P = L * L^T:\n", P_updated)
#更新后的协方差矩阵P = L * L^T:
#[[4.28764705882353, 0.601248988374002],
[0.601248988374002, 9.60235294117647]]
示例3: 最小二乘问题的在线更新:当新数据点到达时，高效更新回归模型
在线最小二乘中，当新增一个数据点时，可以使用秩-1更新
初始设计矩阵A的Cholesky因子 (A^T A = L L^T)
L_ATA = [[5.0, 0.0], [2.0, 4.0]]
新增数据点
new_data_point = [3.0, 1.0]
执行秩-1更新
L_updated_ls = cholupdate(L_ATA,new_data_point,plus)
print("更新后的Cholesky因子L:\n", L_updated_ls)
#更新后的Cholesky因子L:
#[[5.83095189484530, 2.22948160685261],
[0, 4.00367478258485]]
示例4: 投资组合优化中的协方差矩阵更新:根据新的收益率数据更新资产协方差矩阵
在投资组合优化中，当资产收益率协方差矩阵需要更新时，可以使用秩-1更新
初始协方差矩阵的Cholesky因子
L_cov = [[0.2, 0.0, 0.0],
[0.1, 0.3, 0.0],
[0.05, 0.1, 0.25]]
新的收益率观测向量
new_return = [0.05, -0.02, 0.03]
执行秩-1更新
L_updated_cov = cholupdate(L_cov, new_return, plus)
print("更新后的Cholesky因子L:\n", L_updated_cov)
#更新后的Cholesky因子L:
#[[0.206155281280883, 0.0921635375138065, 0.0557831937583566],
[0, 0.303159829715187, 0.0965128643755338], [0, 0, 0.251939481431846]]
示例5: 机器学习中的在线学习:根据新样本更新模型参数的Hessian矩阵
在线学习中，当模型参数需要根据新样本更新时，可以使用秩-1更新
初始Hessian矩阵的Cholesky因子
L_hessian = [[10.0, 0.0], [5.0, 8.0]]
新样本的梯度向量
gradient = [2.0, 1.0]
执行秩-1更新
L_updated_hessian = cholupdate(L_hessian,gradient,plus)
print("更新后的Cholesky因子L:\n", L_updated_hessian)
#更新后的Cholesky因子L:
#[[10.1980390271856, 5.09901951359279],
[0, 8.00000000000000]]
示例6: 矩阵逆的更新:使用Sherman-Morrison公式高效更新矩阵逆
使用秩-1更新来更新矩阵的逆
初始矩阵A的Cholesky因子
L_A = [[3.0, 0.0], [1.0, 2.0]]
更新向量
u = [1.0, 0.5]
v = [0.5, 1.0]
执行秩-1更新 (A + u v^T)
首先计算 w = L^{-1} u
w = L_A.lower_triangular_solve(u)
然后执行秩-1更新
L_updated_A = cholupdate(L_A,w,plus)
print("更新后的Cholesky因子L (A + u v^T = L L^T):\n", L_updated_A)
#更新后的Cholesky因子L (A + u v^T = L L^T):
#[[3.01846171271247, 1.00308636184652],
[0, 2.00019053970414]]
示例7: 异常检测和删除:从模型中移除异常数据点的影响
当检测到异常数据点时，可以使用秩-1降级从模型中移除该点的影响
初始协方差矩阵的Cholesky因子
L_normal = [[2.0, 0.0], [1.0, 1.5]]
异常数据点
outlier = [4.0, 2.0]
执行秩-1降级
L_updated_normal = cholupdate(L_normal,outlier,minus)
print("移除异常点后的Cholesky因子L:\n", L_updated_normal)
#移除异常点后的Cholesky因子L:
#[[nan, nan],
[0, nan]]
示例8: 递归最小二乘滤波:在实时系统中处理连续到达的测量数据
在递归最小二乘滤波中，每次新测量到达时都需要更新Cholesky因子
初始Cholesky因子
L_rls = [[5.0, 0.0, 0.0],
[2.0, 4.0, 0.0],
[1.0, 1.0, 3.0]]
新测量向量
new_measurement = [1.0, 2.0, 0.5]
执行秩-1更新
L_updated_rls = cholesky_update_rank(L_rls,new_measurement,plus)
print("更新后的Cholesky因子L:\n", L_updated_rls)
#更新后的Cholesky因子L:
#[[5.09901951359278, 2.35339362165821, 1.07863874326001],
[0, 4.29668924423660, 1.03836656735718], [0, 0, 3.00138856753559]]
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def cholesky_update_rank(input_str):
"""
执行 Cholesky 分解的秩-1 更新或降级。
参数:
input_str (str): 输入字符串，格式为表示元组的字符串。
示例: "([[4,0], [0,9]], [2,3], '+')" 表示:
- L: 下三角矩阵 [[4,0], [0,9]]
- x: 向量 [2,3]
- sign: '+' 表示更新
返回:
sp.Matrix 或 str: 成功返回更新后的矩阵，失败返回错误信息。
"""
try:
# 解析输入字符串为Python对象（如元组、列表）
expr = sp.sympify(input_str)
error = False
result = None
def evaluation_cholupdate(L, x, sign='+'):
"""
内部函数：执行 Cholesky 秩-1 更新/降级算法。
参数:
L (np.ndarray): 下三角矩阵
x (np.ndarray): 更新向量
sign (str): 操作符 '+' 或 '-'
返回:
np.ndarray: 更新后的下三角矩阵
"""
p = len(x)
x = x.copy() # 避免修改原向量
for k in range(p):
if sign == '+':
r = np.sqrt(L[k, k] ** 2 + x[k] ** 2)
elif sign == '-':
r = np.sqrt(L[k, k] ** 2 - x[k] ** 2)
else:
raise ValueError("Invalid sign")
c = r / L[k, k]
s = x[k] / L[k, k]
L[k, k] = r
if k + 1 < p:
L[k, k + 1:p] = (L[k, k + 1:p] + s * x[k + 1:p]) / c
x[k + 1:p] = c * x[k + 1:p] - s * L[k, k + 1:p]
return L
# 检查输入结构是否为元组
if isinstance(expr, tuple):
# 处理两种输入形式：(L, x) 或 (L, x, sign)
if len(expr) == 2:
L, x = expr[0], expr[1]
sign = '+' # 默认符号为+
elif len(expr) == 3:
L, x, sign_symbol = expr[0], expr[1], expr[2]
if str(sign_symbol) == "plus":
sign = '+' # 默认符号为+
elif str(sign_symbol) == "minus":
sign = '-' # 默认符号为+
else:
error = True
else:
error = True
# 转换为 SymPy 矩阵
L_matrix = sp.Matrix(L)
x_matrix = sp.Matrix(x)
# 检查矩阵有效性
if not error and L_matrix is not None and x_matrix is not None:
# 转换为 NumPy 数组
np_L = np.array(L_matrix.tolist(), dtype=float)
np_x = np.ravel(np.array(x_matrix.tolist(), dtype=float))
# 执行 Cholesky 更新
try:
result = evaluation_cholupdate(np_L.T, np_x, sign)
except ValueError as e:
error = True
return f"计算错误: {e}"
else:
error = True
else:
error = True
# 返回结果或错误
if not error and result is not None:
return sp.Matrix(result.tolist())
else:
return f"输入错误: {input_str}"
except (SyntaxError, ValueError, TypeError) as e:
return f"解析错误: {e}"
except Exception as e:
return f"未知错误: {e}"
def main():
# 示例1: 正确输入（秩-1更新）
input_str1 = "[[4.0, 0.0], [0.0, 9.0]],[2.0, 3.0],plus"
print("示例1 输入:", input_str1)
result1 = cholesky_update_rank(input_str1)
print("更新结果:\n", result1 if isinstance(result1, sp.Matrix) else result1)
# Matrix([[4.47213595499958, 1.34164078649987],
# [0, 9.39148550549912]])
# 示例2: 正确输入（秩-1降级）
input_str2 = "([[2.0, 0.0], [0.0, 3.0]], [1.0, 1.0], minus)"
print("\n示例2 输入:", input_str2)
result2 = cholesky_update_rank(input_str2)
print("降级结果:\n", result2 if isinstance(result2, sp.Matrix) else result2)
# Matrix([[1.73205080756888, 0.577350269189626],
# [0, 2.94392028877595]])
if __name__ == "__main__":
main()
奇异的托普利茨下黑森贝格矩阵
A = chow(n,alpha,delta) 返回一个阶数为 n 的 Chow 矩阵，它是 n×n 的下黑森贝格矩阵, alpha 和 delta 使用默认值 1 和 0.
n,alpha,delta - 输入, 标量.
示例1: 基本功能测试
chow(3)
#[[1, 1, 1],
[0, 1, 1],
[0, 0, 1]]
chow(2,5)
#[[5, 1],
[0, 5]]
chow(input3)
#[[1, 1, 1, 1],
[0.5, 1, 1, 1],
[0.5, 0.5, 1, 1],
[0.5, 0.5, 0.5, 1]]
示例2: 数值线性代数中的应用
Chow矩阵在数值线性代数中常用于测试算法
chow(5)
#[[1, 1, 1, 1, 1],
[0, 1, 1, 1, 1],
[0, 0, 1, 1, 1],
[0, 0, 0, 1, 1],
[0, 0, 0, 0, 1]]
计算行列式
C5.det()
#1
计算逆矩阵
C5.inv()
#[[1, -1, 0, 0, 0],
[0, 1, -1, 0, 0],
[0, 0, 1, -1, 0],
[0, 0, 0, 1, -1],
[0, 0, 0, 0, 1]]
示例3: 条件数分析
Chow矩阵的条件数分析
n_values = [3, 5, 7, 10]
for n in n_values:
C = chow(n)
# 转换为NumPy数组计算条件数
C_np = np.array(C.tolist(), dtype=float)
cond_num = np.linalg.cond(C_np)
print(f"{n}x{n} Chow矩阵的条件数: {cond_num:.4e}")
#3x3 Chow矩阵的条件数: 4.0489e+00
#5x5 Chow矩阵的条件数: 6.7420e+00
#7x7 Chow矩阵的条件数: 9.3577e+00
#10x10 Chow矩阵的条件数: 1.3232e+01
示例4: 特征值分析
分析Chow矩阵的特征值分布
chow(6)
#[[1, 1, 1, 1, 1, 1],
[0, 1, 1, 1, 1, 1],
[0, 0, 1, 1, 1, 1],
[0, 0, 0, 1, 1, 1],
[0, 0, 0, 0, 1, 1],
[0, 0, 0, 0, 0, 1]]
计算特征值
eigenvalues = C.eigenvals()
print(f"\n特征值:")
for val, mult in eigenvalues.items():
print(f"{val}: 重数 {mult}")
#特征值:
#1: 重数 6
示例5: 矩阵分解应用
对Chow矩阵进行各种分解
C = chow(4)
print(C)
#[[1, 1, 1, 1],
[0, 1, 1, 1],
[0, 0, 1, 1],
[0, 0, 0, 1]]
LU分解
L, U, _ = C.LUdecomposition()
print(f"L矩阵:\n{L}")
#L矩阵:[[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]]
print(f"U矩阵:\n{U}")
#U矩阵:[[1, 1, 1, 1],
[0, 1, 1, 1],
[0, 0, 1, 1],
[0, 0, 0, 1]]
print(f"验证: L*U =\n{L*U}")
#验证: L*U =
#[[1, 1, 1, 1],
[0, 1, 1, 1],
[0, 0, 1, 1],
[0, 0, 0, 1]]
示例6: 符号Chow矩阵
创建符号Chow矩阵
C_sym = chow(3,alpha,delta)
print(C_sym)
#[[alpha, 1, 1],
[delta, alpha, 1],
[delta, delta, alpha]]
计算符号行列式
det_sym = C_sym.det()
print(f"\n符号行列式: {det_sym}")
#符号行列式: alpha^3-3*alpha*delta+delta^2+delta
示例7: 数值稳定性测试
测试不同参数下Chow矩阵的数值稳定性
parameters = [
(4, 1, 0.1), # 小delta
(4, 1, 0.9), # 大delta
(4, 1e-6, 0.5), # 小alpha
(4, 1e6, 0.5), # 大alpha
]
for n, alpha, delta in parameters:
C = chow(n, alpha, delta)
C_np = np.array(C.tolist(), dtype=float)
cond_num = np.linalg.cond(C_np)
print(f"参数(n={n}, α={alpha}, δ={delta}): 条件数 = {cond_num:.4e}")
#参数(n=4, α=1, δ=0.1): 条件数 = 6.1853e+00
#参数(n=4, α=1, δ=0.9): 条件数 = 7.6181e+01
#参数(n=4, α=1e-06, δ=0.5): 条件数 = 4.0883e+00
#参数(n=4, α=1000000.0, δ=0.5): 条件数 = 1.0000e+00
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
def chow_matrix(input_str, locals_dict=None):
"""
根据输入字符串生成 Chow 矩阵。
参数:
input_str: 输入的字符串，可以是以下形式：
- 单个正整数 (如 "5")
- 元组格式，包含1-3个参数 (如 "(3, 2)", "(4, 1, 0.5)")
元组参数意义：(矩阵维度n, 对角线元素alpha=1, 下三角元素delta=0)
locals_dict: 用于符号解析的本地变量字典，默认为 None
返回:
生成的 SymPy 矩阵，若输入错误则返回错误信息字符串
"""
try:
# 解析输入字符串
expr = sp.sympify(input_str)
error = False
result = None
def generate_chow(n, alpha=1, delta=0):
"""生成 n x n 的 Chow 矩阵"""
# 输入验证
if not isinstance(n, int) or n <= 0:
raise ValueError("矩阵维度n必须是正整数")
# 使用 SymPy 创建矩阵
C = sp.Matrix.zeros(n, n)
for i in range(n):
for j in range(n):
if i == j:
C[i, j] = alpha
elif i > j:
C[i, j] = delta
else:
C[i, j] = 1
return C
# 处理不同输入类型
if isinstance(expr, tuple):
# 元组输入 (n, alpha, delta)
params = list(expr)
if len(params) < 1 or len(params) > 3:
error = True
else:
try:
n = int(params[0]) if params[0].is_integer else params[0]
alpha = params[1] if len(params) >= 2 else 1
delta = params[2] if len(params) >= 3 else 0
result = generate_chow(n, alpha, delta)
except (TypeError, ValueError):
error = True
elif expr.is_number and expr.is_integer:
# 单个整数输入
n = int(expr)
result = generate_chow(n)
else:
error = True
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {e}"
def main():
# 示例1: 3x3 默认参数矩阵
input1 = "3"
print(f"输入: {input1}\n输出:\n{chow_matrix(input1)}\n")
# Matrix([[1, 1, 1], [0, 1, 1], [0, 0, 1]])
# 示例2: 2x2 带alpha参数的矩阵
input2 = "(2, 5)"
print(f"输入: {input2}\n输出:\n{chow_matrix(input2)}\n")
# Matrix([[5, 1], [0, 5]])
# 示例3: 4x4 完整参数矩阵
input3 = "(4, 1, 0.5)"
print(f"输入: {input3}\n输出:\n{chow_matrix(input3)}\n")
#Matrix([[1, 1, 1, 1],
# [0.500000000000000, 1, 1, 1],
# [0.500000000000000, 0.500000000000000, 1, 1],
# [0.500000000000000, 0.500000000000000, 0.500000000000000, 1]])
if __name__ == "__main__":
main()
循环矩阵
A = circul(v) 返回一个n×n循环矩阵, 其第一行是长度为n的向量v. 循环矩阵是一种特殊的托普利茨矩阵,其中每行都通过周期性地将上一行中的各元向右移一位来获得.
如果v是标量,则 A = circul(1:v)。
v - 输入, 标量, 向量
示例1: 数值列表输入
circul([1, 2, 3])
#[[1, 2, 3],
[3, 1, 2],
[2, 3, 1]]
示例2: 符号输入
circul([a, b, c])
#[[a, b, c],
[c, a, b],
[b, c, a]]
示例3: 数值简写输入
circul(3)
# [[1, 2, 3],
# [3, 1, 2],
# [2, 3, 1]]
示例4: 三角函数表达式
circul([sin(x), cos(x), 2*sin(x)])
# [[sin(x), cos(x), 2*sin(x)],
# [2*sin(x), sin(x), cos(x)],
# [cos(x), 2*sin(x), sin(x)]])
示例5: 信号处理中的低通滤波器系数
这是一个简单的移动平均滤波器，循环矩阵形式可用于卷积运算
circul([0.25, 0.5, 0.25])
#[[0.25, 0.5, 0.25],
[0.25, 0.25, 0.5],
[0.5, 0.25, 0.25]]
示例6: 图像处理中的循环卷积核
circul([-1, 0, 1])
#[[-1, 0, 1],
[1, -1, 0],
[0, 1, -1]]
示例7: 数值分析中的托普利兹矩阵近似
托普利兹矩阵可以通过循环矩阵来近似
first_row = [1, 2, 3, 4]
circulant_approx = circul(first_row)
print(f"循环近似矩阵:\n{circulant_approx}\n")
#[[1, 2, 3, 4],
[4, 1, 2, 3],
[3, 4, 1, 2],
[2, 3, 4, 1]]
示例8: 编码理论中的循环码生成矩阵
在GF(2)上的循环码生成多项式系数
input9 = [1, 0, 1, 1] # 代表多项式 1 + x^2 + x^3
circul(input9)
#[[1, 0, 1, 1],
[1, 1, 0, 1],
[1, 1, 1, 0],
[0, 1, 1, 1]]
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def circul_matrix(input_str, locals_dict=None):
"""
根据输入生成循环矩阵
参数:
input_str - 输入字符串，支持以下格式：
1. 单个正整数 (如 "3" 生成向量[1,2,3]的循环矩阵)
2. 列表形式 (如 "[1, 2, 3]" 或 "Matrix([a, b, c])")
3. 符号表达式 (需通过locals_dict提供符号定义)
locals_dict - 符号解析字典，默认为None
返回:
SymPy矩阵对象 或 错误信息字符串
"""
try:
# 解析输入表达式
expr = sp.sympify(input_str)
error = False
result = None
def generate_circulant(vector):
"""生成循环矩阵的核心函数"""
n = len(vector)
# 使用SymPy矩阵代替numpy
C = sp.Matrix.zeros(n, n)
for i in range(n):
# 实现循环右移操作
for j in range(n):
C[i, j] = vector[(j - i) % n]
return C
# 处理不同输入类型
if isinstance(expr, sp.Matrix):
# 直接处理矩阵输入
if expr.rows == 1 or expr.cols == 1:
vector = list(expr)
result = generate_circulant(vector)
else:
error = True
elif isinstance(expr, list):
# 处理列表输入
# 尝试转换为数值或符号列表
vector = [sp.sympify(e) for e in expr]
result = generate_circulant(vector)
elif expr.is_integer and expr > 0:
# 生成1到n的序列
v = list(range(1, int(expr) + 1))
n_v = np.array(v, dtype=float)
result = generate_circulant(vector=n_v)
else:
error = True
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {str(e)}"
def main():
# 示例1: 数值列表输入
input1 = "[1, 2, 3]"
print(f"输入: {input1}\n输出:\n{circul_matrix(input1)}\n")
# Matrix([[1, 2, 3], [3, 1, 2], [2, 3, 1]])
# 示例2: 符号输入
a, b, c = sp.symbols('a b c')
input2 = "Matrix([a, b, c])"
print(f"输入: {input2}\n输出:\n{circul_matrix(input2, locals_dict={'a': a, 'b': b, 'c': c})}\n")
# Matrix([[a, b, c], [c, a, b], [b, c, a]])
# 示例3: 数值简写输入
input3 = "3"
print(f"输入: {input3}\n输出:\n{circul_matrix(input3)}\n")
# Matrix([[1.00000000000000, 2.00000000000000, 3.00000000000000],
# [3.00000000000000, 1.00000000000000, 2.00000000000000],
# [2.00000000000000, 3.00000000000000, 1.00000000000000]])
# 示例4: 三角函数表达式
x = sp.symbols('x')
input4 = "[sin(x), cos(x), 2*sin(x)]"
print(f"输入: {input4}\n输出:\n{circul_matrix(input4, {'x': x})}\n")
# Matrix([[sin(x), cos(x), 2*sin(x)],
# [2*sin(x), sin(x), cos(x)],
# [cos(x), 2*sin(x), sin(x)]])
if __name__ == "__main__":
main()
具有零值对角线元的Clement三对角矩阵
A = clement(n,k) 返回一个主对角线元为0的n×n三对角矩阵. 对于 k = 0(默认值),A 是非对称的.对于 k = 1，A 是对称的.
A = clement(n,k,1) 在对角线方面类似于 clement('clement',n,0)，其中存在一个具有相同大小的对角线矩阵 D 满足 B = inv(D)*A*D.
如果n是奇数, 则A是奇异矩阵.
A 的特征值是显式可知的, 其中包括正负数字 n-1、n-3、n-5、...、1 或 0.
n, k - 输入, 标量
示例1: 5阶非对称矩阵
clement(5)
#[[0, 2, 0, 0, 0],
[-2, 0, sqrt(6), 0, 0],
[0, -sqrt(6), 0, sqrt(6), 0],
[0, 0, -sqrt(6), 0, 2],
[0, 0, 0, -2, 0]]
示例2: 6阶对称矩阵
clement(6,1)
#[[0, 2.23606797749979, 0, 0, 0, 0],
[2.23606797749979, 0, 2.82842712474619, 0, 0, 0],
[0, 2.82842712474619, 0, 3.00000000000000, 0, 0],
[0, 0, 3.00000000000000, 0, 2.82842712474619, 0],
[0, 0, 0, 2.82842712474619, 0, 2.23606797749979],
[0, 0, 0, 0, 2.23606797749979, 0]]
示例3: 对称Clement矩阵的特征值
n_val = 4
C_sym = clement(n_val, 1)
eigenvalues = C_sym.eigenvals()
print(f"{n_val}阶对称Clement矩阵的特征值:\n{eigenvalues}\n")
#4阶对称Clement矩阵的特征值:
#{-3: 1, -1: 1, 3: 1, 1: 1}
示例4: 数值分析应用 - 特征值算法测试
Clement矩阵的特征值有解析解，可用于测试数值特征值算法
对称Clement矩阵的特征值为 ±√(k(n-k))，k=1,2,...,n-1
n_test = 5
C_test = clement(n_test, 1)
print(f"{n_test}阶对称Clement矩阵:\n{C_test}\n")
#5阶对称Clement矩阵:
#[[0, 2, 0, 0, 0],
[2, 0, 2.44948974278318, 0, 0],
[0, 2.44948974278318, 0, 2.44948974278318, 0],
[0, 0, 2.44948974278318, 0, 2],
[0, 0, 0, 2, 0]]
示例5: 离散正弦变换的联系
Clement矩阵与离散正弦变换(DST)矩阵有密切联系
事实上，Clement矩阵可以通过相似变换对角化
n_dst = 4
C_dst = clement_matrix(n_dst, 1)
# 尝试对角化
try:
P, D = C_dst.diagonalize()
print(f"对角化矩阵P:\n{P}\n")
#[[-0.353553390593274, -0.612372435695795, 0.353553390593274, -0.612372435695795],
[0.612372435695795, 0.353553390593274, 0.612372435695795, -0.353553390593274],
[-0.612372435695795, 0.353553390593274, 0.612372435695795, 0.353553390593274],
[0.353553390593274, -0.612372435695795, 0.353553390593274, 0.612372435695795]]
print(f"特征值矩阵D:\n{D}\n")
#[[-3, 0, 0, 0],
[0, -1, 0, 0],
[0, 0, 3, 0],
[0, 0, 0, 1]]
except:
print("对角化可能涉及复杂运算\n")
Clement矩阵的一个重要特性是它们的特征值可以通过解析方法计算，这对于测试数值算法的准确性非常有用。
对称版本的Clement矩阵是反对称矩阵的平方根，这在某些物理和数学问题中很有意义。
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def clement_matrix(input_str, locals_dict=None):
"""
生成 Clement 三对角矩阵 (对称或非对称版本)
参数:
input_str - 输入字符串，支持格式：
1. 单个正整数 n (如 "4")
2. 元组 (n, k) (如 "(4, 1)")
k=0: 非对称矩阵 (默认)
k=1: 对称矩阵
locals_dict - 符号解析字典，默认为None
返回:
SymPy矩阵对象 或 错误信息字符串
"""
try:
# 解析输入表达式
expr = sp.sympify(input_str)
error = False
result = None
def generate_clement(n, k=0):
"""生成 Clement 矩阵核心函数"""
# 输入验证
if not isinstance(n, int) or n < 2:
raise ValueError("矩阵维度n必须是≥2的整数")
if k not in (0, 1):
raise ValueError("参数k只能是0或1")
# 使用SymPy创建矩阵
A = sp.Matrix.zeros(n, n)
for i in range(n - 1):
val = sp.sqrt((n - i - 1) * (i + 1))
A[i, i + 1] = val
A[i + 1, i] = val if k == 1 else -val
return A
# 处理不同输入类型
if isinstance(expr, tuple):
# 元组输入 (n, k)
if len(expr) != 2:
error = True
else:
try:
n = int(expr[0]) if expr[0].is_integer else expr[0]
k = int(expr[1]) if expr[1].is_number else expr[1]
result = generate_clement(n, k)
except (TypeError, ValueError):
error = True
elif expr.is_integer and expr >= 2:
# 单个整数输入
n = int(expr)
result = generate_clement(n)
else:
error = True
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {str(e)}"
def main():
# 示例1: 4阶非对称矩阵 (默认k=0)
input1 = "4"
print(f"输入: {input1}\n输出:\n{clement_matrix(input1)}\n")
# Matrix([[0, sqrt(3), 0, 0],
# [-sqrt(3), 0, 2, 0],
# [0, -2, 0, sqrt(3)],
# [0, 0, -sqrt(3), 0]])
# 示例2: 3阶对称矩阵
input2 = "(3, 1)"
print(f"输入: {input2}\n输出:\n{clement_matrix(input2)}\n")
# Matrix([[0, sqrt(2), 0],
# [sqrt(2), 0, sqrt(2)],
# [0, sqrt(2), 0]])
if __name__ == "__main__":
main()
余弦积分
cosint(X)返回X的余弦积分函数
根据其参数，余弦返回浮点或精确的符号结果.
X是符号变量,符号表达式,函数,向量,矩阵,多维数组
示例1: 电磁学中的天线辐射场计算
cosint(z)
#结果: Ci(z)
示例2: 光学应用 - 菲涅尔衍射
在光学中，余弦积分出现在菲涅尔衍射公式中
计算直边衍射时需要使用Ci函数
cosint(1.5)
#结果: 0.470356317195400
示例3: 信号处理应用 - 滤波器设计
在某些特殊滤波器的频率响应计算中会出现Ci函数
创建一个频率值数组
frequencies = [0.1, 0.5, 1.0, 2.0, 5.0]
result4 = cosint(frequencies)
print(f"输入频率数组: {frequencies}")
print(f"对应的Ci值: {result4}\n")
#输入频率数组: [0.1, 0.5, 1.0, 2.0, 5.0]
#对应的Ci值: [-1.72786839,-0.17778408,0.33740392,0.42298083,-0.19002975]
示例4: 数学应用 - 特殊积分计算
计算一些特殊积分值
integrals_to_compute = [
"∫(cos(x)/x dx, x=1..2)", # 从1到2的cos(x)/x积分
"∫(cos(x)/x dx, x=0.1..1)" # 从0.1到1的cos(x)/x积分
]
for integral in integrals_to_compute:
print(integral)
# 计算具体值
val1 = cosint(2) - cosint(1)
val2 = cosint(1) - cosint(0.1)
print(f"∫(cos(x)/x dx, x=1..2) ≈ {val1}")
#∫(cos(x)/x dx, x=1..2) ≈ 0.08557690587389671
print(f"∫(cos(x)/x dx, x=0.1..1) ≈ {val2}\n")
#∫(cos(x)/x dx, x=0.1..1) ≈ 2.0652723095582646
示例5: 矩阵输入 - 多参数系统分析
创建一个参数矩阵
param_matrix = [
[0.5, 1.0, 2.0],
[3.0, 4.0, 5.0]
]
result6 = cosint(param_matrix)
print(f"输入矩阵: {param_matrix}")
#输入矩阵: [[0.5, 1.0, 2.0],
[3.0, 4.0, 5.0]]
print(f"Ci值矩阵:\n{result6}\n")
#Ci值矩阵:
#[[-0.17778408,0.33740392,0.42298083]
[ 0.11962979,-0.1409817,-0.19002975]]
示例6: 渐近行为研究
研究Ci函数在小参数和大参数时的行为
small_values = [0.001, 0.01, 0.1]
large_values = [10, 100, 1000]
print("小参数行为:")
for val in small_values:
ci_val = cosint(val)
print(f"Ci({val}) = {ci_val}")
#小参数行为:
#Ci(0.001) = -6.330539864080594
#Ci(0.01) = -4.027979520982392
#Ci(0.1) = -1.7278683866572966
print("\n大参数行为:")
for val in large_values:
ci_val = cosint(val)
print(f"Ci({val}) ≈ {ci_val}")
#大参数行为:
#Ci(10) ≈ -0.04545643300445538
#Ci(100) ≈ -0.005148825142610493
#Ci(1000) ≈ 0.0008263155110906821
示例7: 特殊值点
special_points = [
0.5, # 接近0的点
@pi/2, # π/2
@pi, # π
2*@pi # 2π
]
for point in special_points:
ci_val = cosint(point)
print(f"Ci({point}) = {ci_val}")
#Ci(0.5) = -0.17778407880661287
#Ci(pi/2) = 0.4720006514395685
#Ci(pi) = 0.0736679120464252
#Ci(2*pi) = -0.02256066174634607
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
from sympy.functions.special.error_functions import Ci
from scipy.special import sici
def ci_cosine_integral(input_str):
"""
计算输入的余弦积分Ci(x)，支持矩阵、数值和符号表达式
参数:
input_str: 输入的字符串表达式，可以是矩阵、数值或符号表达式
返回:
计算结果。如果输入为矩阵，返回对应元素的Ci积分矩阵；
如果输入为数值或符号，返回Ci积分值。
无法处理时返回错误信息字符串
"""
try:
# 表达式转换
expr = sp.sympify(input_str)
error = False
result = None
# 元组类型直接视为错误
if isinstance(expr, tuple):
error = True
# 处理标量数值和符号表达式
elif expr.is_number:
z = complex(expr)
"""计算余弦积分 Ci(x)"""
result = sici(z)[1] # 取返回值的第二个元素，即 Ci(x)
elif expr.free_symbols:
# 处理符号变量表达式
result = Ci(expr)
else:
error = True
return result if not error else f"输入错误: {input_str}"
except sp.SympifyError as e:
return f"表达式解析错误: {e}"
except Exception as e:
return f"运行时错误: {str(e)}"
def main():
"""
主函数测试用例
"""
test_cases = [
"0", # (-inf+nan*j)
"x", # Ci(x)
"3.14", # (0.07417499776126246+0j)
"cos(2)" # (-0.3424847875188666+3.141592653589793j)
]
for case in test_cases:
print(f"测试输入: {case}")
result = ci_cosine_integral(case)
print("返回结果:")
# 统一输出格式
if isinstance(result, sp.Matrix):
sp.pprint(result)
elif isinstance(result, sp.Expr):
print(sp.pretty(result))
else:
print(result)
print("-" * 50)
if __name__ == "__main__":
main()
多项式系数
C＝coeffs（p）返回多项式p关于由symvar在p中确定的所有变量的系数.
C＝coeffs（p，var）返回多项式p相对于变量var的系数.
C＝coeffs（p，vars）返回多元多项式p相对于变量vars的系数.
示例1: 简单单变量多项式
coeffs(3x^3-2x^2+5x-7)
#结果: [3, -2, 5, -7]
示例2: 物理中的运动方程(位移公式)
coeffs((1/2)*a*t^2 + v0*t + s0)
#结果: [1, 1/2, 1]
示例3: 经济学中的二次成本函数
coeffs(0.5*x^2+10x+100))
#结果:[0.5, 10, 100]
示例4: 指定变量的多项式
coeffs(x^2+ 2*y*x + y^2, x)) # 关于x的多项式
#结果: [1, 2y, Y^2]
示例5: 控制系统中的传递函数
coeffs((s^2+3s+2)/(s^3+4s^2+5s+6))
#结果: [1,3,2]
示例6: 多变量多项式分析
result = coeffs(x^3+2*y*x^2-5*z*x+y^2, [x, y, z])
print(f"关于x的系数: {result[0]}")
print(f"关于y的系数: {result[1]}")
print(f"关于z的系数: {result[2]}")
#关于x的系数: [1, 2*y, -5*z, y**2]
#关于y的系数: [1, 2*x**2, x**3 - 5*x*z]
#关于z的系数: [-5*x, x**3 + 2*x**2*y + y**2]
示例7: 热力学状态方程
coeffs(P*V - n*R*T))
#结果: [-1,1]
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
def coefficients_of_polynomial(input_str, locals_dict=None):
"""
提取多项式的系数列表
参数:
input_str - 输入字符串，支持格式：
1. 纯多项式表达式 (如 "x**2 + 2*x + 1")
2. 元组格式 (表达式, 变量) (如 "(x**2 + y, x)")
3. 元组格式 (表达式, [变量1, 变量2,...]) (如 "(x**2 + x*y, [x, y])")
locals_dict - 符号解析字典，默认为None
返回:
系数列表 (单变量) 或嵌套系数列表 (多变量)
错误时返回描述性错误信息
"""
try:
# 解析输入表达式
expr = sp.sympify(input_str)
result = []
# 处理不同输入格式
if isinstance(expr, tuple):
if len(expr) != 2:
raise ValueError("元组输入必须为 (表达式, 变量) 格式")
poly_expr, variables = expr
# 处理多变量情况
if isinstance(variables, list):
for var in variables:
if not var.free_symbols:
raise ValueError(f"无效变量: {var}")
poly = sp.poly(poly_expr, var)
result.append(poly.coeffs())
# 处理单变量情况
else:
if not variables.free_symbols:
raise ValueError(f"无效变量: {variables}")
poly = sp.poly(poly_expr, variables)
result = poly.coeffs()
# 处理单表达式情况
else:
poly = sp.poly(expr)
result = poly.coeffs()
return result
except Exception as e:
return f"错误: {str(e)}"
def main():
# 示例1: 单变量多项式
input1 = "x**3 + 2*x**2 - 5*x + 7"
print(f"输入: {input1}")
print("输出:", coefficients_of_polynomial(input1), end="\n\n")
# 输出: [1, 2, -5, 7]
# 示例2: 指定变量
x, y = sp.symbols('x y')
input2 = "(x**2 + 2*x*y + y**2, x)"
print(f"输入: {input2}")
print("输出:", coefficients_of_polynomial(input2, {'x': x, 'y': y}), end="\n\n")
# 输出: [1, 2*y, y**2]:
# 示例3: 多变量分析
input3 = "(x**3 + 2*y*x**2 - 5*z*x, [x, y, z])"
print(f"输入: {input3}")
print("输出:", coefficients_of_polynomial(input3, {'x': x, 'y': y, 'z': sp.symbols('z')}), end="\n\n")
# 输出: [[1, 2*y, -5*z], [2*x**2, x**3 - 5*x*z], [-5*x, x**3 + 2*x**2*y]]
# 示例4: 符号多项式
a, b = sp.symbols('a b')
input4 = "(a*x**2 + b*x + c, x)"
print(f"输入: {input4}")
print("输出:", coefficients_of_polynomial(input4, {'a': a, 'b': b, 'c': sp.symbols('c'), 'x': x}), end="\n\n")
# 输出: [a, b, c]
if __name__ == "__main__":
main()
收集系数
collect(P)收集P的默认变量的幂的P中的系数.默认变量由symvar找到.
collect(P,expr) 如果P是一个向量或矩阵,则collect对P进行元素运算.如果expr是一个矢量，那么collect根据expr中的所有表达式查找系数.
P是符号表达式,符号函数,符号向量,符号矩阵.
expr是收集系数的表达式,指定为符号数,符号变量,符号表达式,符号函数,符号向量,字符向量或字符矢量的单元数组.
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
def collect_power_expression(input_str, locals_dict=None):
"""
实现类似 MATLAB collect 函数的功能，收集表达式中的项。
参数:
input_str: 输入的字符串，可以是矩阵、表达式或元组（表达式和符号）。
locals_dict: 用于 sympify 的本地符号字典，默认为 None。
返回:
收集后的表达式或矩阵，错误时返回错误信息字符串。
"""
try:
# 定义 SymPy 函数和符号以用于解析字符串
expr = sp.sympify(input_str)
error = False
result = None
# 处理输入为元组的情况（表达式和符号）
if isinstance(expr, tuple):
if len(expr) != 2:
return f"输入错误: 元组长度必须为2，当前为{len(expr)}"
expr_part, sym_part = expr
if expr_part.free_symbols:
# 对普通表达式收集符号
result = sp.collect(expr_part, sym_part)
else:
error = True
elif expr.free_symbols:
# 收集普通表达式的所有符号
result = sp.collect(expr, list(expr.free_symbols))
else:
error = True
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {e}"
def main():
# 定义符号
x, y = sp.symbols('x y')
# 示例1: 收集表达式中的 cos(y) 项
input_str1 = "4*sin(x)*cos(y)^3+4*cos(x)*sin(y)*cos(y)^2+(-3*sin(x))*cos(y)-cos(x)*sin(y),sin(x)"
result1 = collect_power_expression(input_str1, {'x': x, 'y': y})
print("示例1 输入:", input_str1)
print("结果1:\n", result1)
# (4*cos(y)**3 - 3*cos(y))*sin(x) + 4*sin(y)*cos(x)*cos(y)**2 - sin(y)*cos(x)
# 示例2: 收集普通表达式的符号
input_str2 = "x**3 + x**2*y + x*y**2 + y**3"
result2 = collect_power_expression(input_str2, {'x': x, 'y': y})
print("\n示例3 输入:", input_str2)
print("结果3:", result2)
# x**3 + x**2*y + x*y**2 + y**3
if __name__ == "__main__":
main()
生成数组的所有元素组合
T＝组合（A1,…,An）生成输入阵列A1,…的所有元素组合,其中输出表T的每一行都是一个组合.这些组合与n组元素的笛卡尔乘积相同.
T中的行数是每个输入数组中元素数的乘积.行数与组合数相同.
T中变量的数量与输入数组的数量相同.
T中每个变量的数据类型与相应输入数组的数据类型相同.
A1,...An —— 输入数组（作为单独的参数）,标量,向量,矩阵
示例1: 基本组合
combinations([1,2], [3,4])
#[[1, 3],
[1, 4],
[2, 3],
[2, 4]]
示例2: 多维数组与一维数组的组合
combinations([[7,3],[2,6]],[9,1,4])
#[[7, 9],
[7, 1],
[7, 4],
[3, 9],
[3, 1],
[3, 4],
[2, 9],
[2, 1],
[2, 4],
[6, 9],
[6, 1],
[6, 4]]
示例3: 三个数组的组合
combinations([1,2], [3,4], [5,6])
#[[1, 3, 5],
[1, 3, 6],
[1, 4, 5],
[1, 4, 6],
[2, 3, 5],
[2, 3, 6],
[2, 4, 5],
[2, 4, 6]]
示例4: 包含符号的数组组合
combinations([x, y], [1, 2, z])
#[[x, 1],
[x, 2],
[x, z],
[y, 1],
[y, 2],
[y, z]]
示例5: 实际应用 - 坐标点组合
combinations([1, 2, 3], [4, 5])
#[[1, 4],
[1, 5],
[2, 4],
[2, 5],
[3, 4],
[3, 5]]
示例6: 概率计算
输入: 两个骰子的可能结果
combinations([1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6])
输出 (所有可能的骰子组合):
#[[1, 1], [1, 2], [1, 3], [1, 4], [1, 5], [1, 6], [2, 1], [2, 2], [2, 3],
[2, 4], [2, 5], [2, 6], [3, 1], [3, 2], [3, 3], [3, 4], [3, 5], [3, 6],
[4, 1], [4, 2], [4, 3], [4, 4], [4, 5], [4, 6], [5, 1], [5, 2], [5, 3],
[5, 4], [5, 5], [5, 6], [6, 1], [6, 2], [6, 3], [6, 4], [6, 5], [6, 6]]
示例7: 实际应用 - 商品组合
combinations([红, 蓝, 绿],[S, M, L])
输出 (所有可能的商品变体):
#[[红, S], [红, M], [红, L], [蓝, S],
[蓝, M], [蓝, L], [绿, S], [绿, M], [绿, L]]
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import itertools
import numpy as np
def combinations_all_element_arrays(input_str):
"""
生成输入中所有数组元素的笛卡尔积组合。
参数:
input_str: 输入的字符串表达式，应为元组形式，例如 "([1,2], [3,4])"
返回:
如果输入有效，返回包含所有组合的 SymPy 矩阵；否则返回错误信息。
"""
try:
# 将输入字符串转换为 SymPy 表达式
expr = sp.sympify(input_str)
error = False
result = None
# 仅处理元组类型的输入
if isinstance(expr, tuple):
expr_tuple = ()
for element in expr:
current_elements = []
# 处理列表类型元素
if isinstance(element, list):
# 使用 numpy 展平多维列表
current_elements = np.ravel(element).tolist()
expr_tuple += (current_elements,)
# 生成所有可能的组合
combinations = list(itertools.product(*expr_tuple))
# 转换为 SymPy 矩阵
C = np.array(combinations)
result = sp.Matrix(C)
else:
error = True
return result if not error else f"输入错误: {input_str} 应为元组形式，例如 '([1,2], [3,4])'"
except Exception as e:
return f"错误: {e}"
def main():
"""示例主函数，演示不同输入情况下的输出"""
test_cases = [
"([1,2], [3,4])",
# Matrix([[1, 3],
# [1, 4],
# [2, 3],
# [2, 4]])
"( [ [1,2], [3] ], [5,6] )",
# Matrix([[[1, 2], 5], [[1, 2], 6], [[3], 5], [[3], 6]])
]
for case in test_cases:
print(f"测试输入: {case}")
result = combinations_all_element_arrays(case)
print("输出结果:")
print(result)
print("-" * 50)
if __name__ == "__main__":
main()
简化表达式
Y＝combine（S）将表达式S中的幂的乘积重写为单个幂。.
S —— 输入表达式,符号表达式,符号向量,符号矩阵
示例1: 合并指数表达式
combine(x^y*x^z)
结果: x**(y + z)
示例2: 多项式合并同类项
combine(2*x + 3*x - x + y + 4*y)
结果: 4*x + 5*y
示例3: 三角函数简化
combine(sin(x)**2 + cos(x)**2)
结果: 1
示例4: 对数表达式合并
combine(log(a) + log(b) - log(c))
结果: log(a) + log(b) - log(c)
示例5: 有理式简化
combine((x**2 - 1)/(x + 1))
结果: x - 1
示例6: 矩阵表达式简化
combine([[x+y, 2*x], [3*y, x-y]] + [[2*x, y], [x, 3*y]])
#结果: [[x + y, 2*x],
[3*y, x - y],
[2*x, y],
[x, 3*y]]
示例7: 复杂表达式简化
combine(exp(x)*exp(y) + sin(x)**2 + cos(x)**2 - 1)
#结果: exp(x + y)
示例8: 带系数的多项式
combine(2*(x + y) + 3*(2*x - y) - 4*(x - 2*y))
#结果: 4*x + 7*y
示例9: 分数指数简化
combine(x**(1/2)*x**(1/3))
#结果: x**(5/6)
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
def combine_expression(input_str):
"""
对标MATLAB的combine函数，合并表达式中的乘积为单个幂或合并特定函数的多次调用。
参数:
input_str (str): 输入的表达式字符串。
target (sympy.Function, 可选): 目标函数，用于指定合并的规则。默认为None，自动处理。
返回:
sympy.Expr 或 sympy.Matrix 或 str: 合并后的表达式/矩阵，出错则返回错误信息字符串。
"""
try:
expr = sp.sympify(input_str)
except Exception as e:
return f"表达式转换错误: {e}"
try:
# 检查是否是矩阵
if isinstance(expr, list):
matrix = sp.Matrix(expr)
return matrix.applyfunc(sp.simplify)
else:
# 普通表达式处理
return sp.simplify(expr)
except Exception as e:
return f"合并错误: {e}"
if __name__ == "__main__":
# 示例1: 合并 atan 表达式 (需符号假设)
input_str1 = "exp(2) * exp(3)"
result1 = combine_expression(input_str1)
print("示例1 结果:")
print(result1)
# 输出 exp(5)
# 示例2: 合并 log 表达式
b = sp.symbols('b')
input_str2 = "log(a) + log(b)"
result2 = combine_expression(input_str2)
print("\n示例2 结果:")
print(result2)
# 输出 log(a) + log(b)
# 示例3: 自动合并矩阵元素
x, y = sp.symbols('x y', positive=True)
input_str3 = "[[log(x) + log(y), atan(x) + atan(1/x)], [exp(x)*exp(y), 2**3*2**4]]"
result3 = combine_expression(input_str3)
print("\n示例3 结果:")
print(result3)
# Matrix([[log(x) + log(y), atan(1/x) + atan(x)], [exp(x + y), 128]])
# 示例4: 指定目标函数合并矩阵
input_str4 = "[[atan(x)+atan(1/x), log(a)+log(b)]]"
result4 = combine_expression(input_str4)
print("\n示例4 结果:")
print(result4)
# Matrix([[atan(1/x) + atan(x), log(a) + log(b)]])
伴随矩阵
A = compan(u) 返回第一行为 -u(2:n)/u(1) 的对应伴随矩阵,其中u是多项式系数向量.
compan(u) 的特征值是多项式的根.
示例1: 二次多项式
compan(x^2+2x+3)
#[[-2, -3],
[1, 0]]
#特征多项式:
2
λ + 2⋅λ + 3
示例2: 三次多项式
compan(x^3 - 6x^2 + 11x - 6)
#[[6, -11, 6],
[1, 0, 0],
[0, 1, 0]]
#特征多项式:
3 2
λ - 6⋅λ + 11⋅λ - 6
示例3: 使用系数列表
compan([1, 0, -2]) #(对应 x^2 - 2)
#[[-1, 0, 2],
[1, 0, 0],
[0, 1, 0]]
#特征多项式:
3 2
λ + λ - 2
示例4: 使用矩阵输入
compan([1, -5, 6]) #(对应 x^2 - 5x + 6)
#[[-1, 5, -6],
[1, 0, 0],
[0, 1, 0]]
#特征值:
3 2
λ + λ - 5⋅λ + 6
示例5: 四次多项式
compan(x^4 - 10x^3 + 35x^2 - 50x + 24)
#[[10, -35, 50, -24],
[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 1, 0]]
#特征值:
4 3 2
λ - 10⋅λ + 35⋅λ - 50⋅λ + 24
示例6: 带分数系数的多项式
compan(x^2 + (3/2)x - 1/2)
#[[-3/2, 1/2],
[1, 0]]
#特征值:
2 3⋅λ 1
λ + ─── - ─
2 2
示例7: 符号系数多项式
compan(x^2 + a*x + b)
#[[-a, -b],
[1, 0]]
#特征值:
2
a⋅λ + b + λ
示例8: 线性多项式
compan(3x + 2) #(归一化为 x + 2/3)
#[[-2/3]]
#特征值:
λ + 2/3
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def companion_matrix(input_str):
"""
根据输入生成首一多项式（最高次项系数为1）的伴随矩阵
参数:
input_str: 输入可以是以下形式：
- 系数列表字符串（如 "[1, 2, 3]"）
- SymPy矩阵字符串（如 "Matrix([1, 2, 3])"）
- 多项式表达式字符串（如 "x**2 + 2*x + 3"）
返回:
成功时返回SymPy矩阵，失败时返回错误信息字符串
特点:
1. 自动处理三种输入类型：列表、矩阵、多项式表达式
2. 强制首一多项式规范，自动进行系数归一化
3. 完善的错误处理机制
"""
try:
# 符号变量用于多项式解析
x = sp.symbols('x')
# 将输入字符串转换为SymPy对象
expr = sp.sympify(input_str)
coeffs = []
# 输入类型分派处理
if isinstance(expr, list): # 处理Python列表输入
coeffs = expr.copy()
elif isinstance(expr, sp.Matrix): # 处理矩阵输入
coeffs = list(expr.flat())
elif isinstance(expr, sp.Expr): # 处理多项式表达式
expr_symbol = tuple(expr.free_symbols)[0]
poly = sp.Poly(expr, expr_symbol)
raw_coeffs = poly.all_coeffs()
# 归一化处理：使首项系数为1
if raw_coeffs[0] == 0:
return "错误：零首项的多项式无效"
leading_coeff = raw_coeffs[0]
coeffs = [c / leading_coeff for c in raw_coeffs[1:]]
else:
return f"错误：不支持的类型 {type(expr)}"
# 有效性检查
if len(coeffs) < 1:
return "错误：多项式次数必须至少为1"
if isinstance(expr, (list, sp.Matrix)) and expr[0] != 1:
return f"错误：列表/矩阵输入的首项必须为1，实际为 {expr[0]}"
# 创建伴随矩阵
n = len(coeffs)
matrix = np.zeros((n, n), dtype=object)
# 填充次对角线
for i in range(n - 1):
matrix[i + 1, i] = 1
# 填充首行负系数
matrix[0, :] = [-c for c in coeffs]
return sp.Matrix(matrix)
except Exception as e:
return f"错误：{str(e)}"
def main():
"""示例主函数，演示不同输入情况"""
test_cases = [
"[1, 2, 3]",
# Matrix([[-1, -2, -3],
# [1, 0, 0],
# [0, 1, 0]])
"Matrix([1, 5, 6])",
# Matrix([[-1, -5, -6],
# [1, 0, 0],
# [0, 1, 0]])
"4*x - x + 7",
# Matrix([[-7/3]])
]
for case in test_cases:
print(f"测试输入: {case}")
result = companion_matrix(case)
print("输出结果:")
print(result)
print("=" * 50)
if __name__ == "__main__":
main()
比较矩阵
A = compar(B,k) 返回 B 的比较矩阵.
对于 k = 0（默认值）, 如果 i == j, 则 A(i,j) = abs(B(i,j)), 否则 A(i,j) = -abs(B(i,j)).
对于 k = 1, A 将 B 的每个对角线元素替换为其绝对值, 并将每个非对角线元素替换为同一行中非对角线元素的最大绝对值的负值.
如果 B 是三角矩阵，则 A = compar(B,1) 也是三角矩阵。
B - 输入, 矩阵
k - 输入, 标量
示例1: 2×2矩阵，模式0
compar([[1, -2], [3, 4]])
#[[1, -2],
[-3, 4]]
示例2: 2×2矩阵，模式1 (对角线绝对值，非对角线行最大负绝对值)
compar([[2, -3], [5, 1]])
#[[2, -3],
[-5, 1]]
#解释: 第一行非对角线最大绝对值为3，第二行为5
示例3: 3×3矩阵，模式0
compar([[1, -2, 3], [-4, 5, -6], [7, -8, 9]])
#[[1, -2, -3],
[-4, 5, -6],
[-7, -8, 9]]
示例4: 3×3矩阵，模式1
compar([[1, -2, 3], [-4, 5, -6], [7, -8, 9]])
#[[1, -3, -3],
[-6, 5, -6],
[-8, -8, 9]]
#解释: 第一行非对角线最大绝对值为3，第二行为6，第三行为8
示例5: 列向量，模式0
compar([[1], [-2], [3]])
#[[1], [-2], [-3]]
示例6: 数值稳定性测试 (小数值)
compar([[0.001, -0.002], [0.003, -0.004]])
#[[0.001, -0.002],
[-0.003, 0.004]]
示例7: 模式1在控制系统中的应用 (系统矩阵)
compar([[-2, 1, 0], [0, -3, 2], [1, 0, -1]])
#[[2, -1, -1],
[-2, 3, -2],
[-1, -1, 1]]
#应用: 可用于分析系统的稳定性
示例8: 经济学中的投入产出矩阵
compar([[0.2, 0.3, 0.1], [0.4, 0.1, 0.2], [0.1, 0.2, 0.3]]
#[[0.2, -0.3, -0.1],
[-0.4, 0.1, -0.2],
[-0.1, -0.2, 0.3]]
#应用: 可用于分析经济系统的稳定性
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def compare_matrix(input_str):
"""
生成比较矩阵，支持两种比较模式
参数:
input_str: 输入字符串，可以是以下形式：
- 矩阵字符串（如 "Matrix([[1, -2], [3, 4]])"）
- 带参数的元组字符串（如 "(Matrix([[1,2],[3,4]]), 1)"）
返回:
成功时返回SymPy矩阵，失败时返回错误信息字符串
比较模式:
- k=0: 对角线为绝对值，非对角线为负绝对值
- k=1: 对角线为绝对值，非对角线为行最大负绝对值
"""
try:
expr = sp.sympify(input_str)
def generate_comparison_matrix(B, k=0):
"""
核心矩阵生成逻辑
参数:
B: 输入矩阵的NumPy数组形式
k: 比较模式选择（0或1）
"""
n, m = B.shape
A = np.zeros_like(B, dtype=float)
if k == 0:
# 模式0：直接绝对值处理
for i in range(n):
for j in range(m):
A[i, j] = abs(B[i, j]) if i == j else -abs(B[i, j])
elif k == 1:
# 模式1：行最大绝对值处理
for i in range(n):
row = B[i]
# 获取当前行非对角线元素的最大绝对值
off_diag = np.delete(row, i) if i < len(row) else row
max_val = np.max(np.abs(off_diag))
for j in range(m):
A[i, j] = abs(row[j]) if i == j else -max_val
else:
raise ValueError("参数k必须是0或1")
return A
# 输入类型处理
if isinstance(expr, tuple) and len(expr) == 2:
# 处理元组输入 (矩阵, k值)
mat, k = expr
sp_matrix = sp.Matrix(mat)
if sp_matrix is None or not k.is_number:
return "错误：元组输入格式应为(矩阵, 数字)"
np_matrix = np.array(sp_matrix, dtype=float)
k_value = int(k.evalf())
result = generate_comparison_matrix(np_matrix, k_value)
else:
# 处理单个矩阵输入（默认k=0）
sp_matrix = sp.Matrix(expr)
if sp_matrix is None:
return "错误：无法解析为有效矩阵"
np_matrix = np.array(sp_matrix, dtype=float)
result = generate_comparison_matrix(np_matrix)
return sp.Matrix(result)
except Exception as e:
return f"错误: {str(e)}"
def main():
"""示例主函数，演示不同输入情况"""
test_cases = [
"Matrix([[1, -2], [3, 4]])",
# Matrix([[1.00000000000000, -2.00000000000000],
# [-3.00000000000000, 4.00000000000000]])
"(Matrix([[2, -3], [5, 1]]), 0)",
# Matrix([[2.00000000000000, -3.00000000000000],
# [-5.00000000000000, 1.00000000000000]])
"(Matrix([[4, -1], [2, -5]]), 1)",
# Matrix([[4.00000000000000, -1.00000000000000],
# [-2.00000000000000, 5.00000000000000]])
"[1, 2, 3]",
# Matrix([[1.00000000000000], [-2.00000000000000],
# [-3.00000000000000]])
]
for case in test_cases:
print(f"测试输入: {case}")
result = compare_matrix(case)
print("输出结果:")
print(result)
print("=" * 50)
if __name__ == "__main__":
main()
复数列表图
ComplexListPlot(list1,list2,...)将复数绘制在复平面（也称为阿干特图或高斯平面）上。在复平面中，x轴代表实部，y轴代表虚部。
1. 信号处理 - 频域分析
实际意义：在信号处理中，复数常用于表示不同频率成分的幅度和相位。这个图可以帮助工程师可视化信号的频谱特性。
ComplexListPlot([1+2@i,-0.5+1@i,0.3-0.8@i,-1-1@i])
2. 电路分析 - 阻抗计算
实际意义：在电路分析中，阻抗是一个复数，实部代表电阻，虚部代表电抗。这个图可以显示电路在不同频率下的阻抗变化。
ComplexListPlot([50,45+15@i,30+25@i,20+30@i,10+35@i])
3. 控制系统 - 极点/零点分析
实际意义：在控制系统中，极点和零点的位置决定了系统的稳定性和响应特性。这个图可以帮助工程师分析系统性能。
ComplexListPlot([-2-2@i,-2+2@i,-1-1@i,-1+1@i],[0,1+1@i])
4. 量子力学 - 波函数可视化
实际意义：在量子力学中，波函数是复数函数，其模的平方表示概率密度。这个图可以直观显示量子态的概率分布。
ComplexListPlot([0.7,0.5+0.5@i,-0.7@i,-0.5-0.5@i,-0.7])
5. 数学变换 - 傅里叶系数
实际意义：傅里叶变换将信号从时域转换到频域，产生复数系数。这个图可以帮助分析信号的频率成分。
ComplexListPlot([3,1-2@i,-0.5+1@i,0.3+0.8@i,-0.2-0.5@i])
复变函数绘图
ComplexPlot(f(x)) 色相环复变函数图形是一种复变函数图形的呈现方式. 将色相表示函数值的辐角,明度表示函数值的绝对值来表达复变函数的定义域着色方法.
通过复变函数图，抽象的复数运算转化为直观的几何模式, 在二维平面上呈现四维信息（输入实部、输入虚部、输出实部、输出虚部）.
x -- 复数域范围
流体力学 - 理想流体绕圆柱流动:
ComplexPlot(2*(1+1/x),x=[-4-4@i,4+4@i])
调频信号分析:
ComplexPlot(exp(1@i*0.8*x^2),x=[-3-3@i,3+3@i])
量子隧穿效应:
ComplexPlot(exp(-x^2/2),x=[-4-4@i,4+4@i])
电磁场分布:
ComplexPlot(1/x+1/(x-2),x=[-3-3@i,5+3@i])
保角映射演示:
ComplexPlot(log(x),x=[0.1-3@i,+3@i]
电磁场分析（麦克斯韦方程）:
ComplexPlot(1/(x-1)+1/(x+1),x=[-3-3@i,3+3@i])
流体动力学（纳维-斯托克斯方程）
ComplexPlot(x+1/x,x=[-3-3@i,3+3@i])
信号处理（傅里叶分析）:
ComplexPlot(exp(1@i*3x)*exp((-x^2)/2),x=[-4-4@i,4+4@i])
先进可视化技术(3D混合呈现)
ComplexPlot(abs(sin(x)),x=[-3-3@i,3+3@i])
叠加复变函数图
ComplexPlot(f1(x),f2(x)) 揭示函数间的关联性、对称性及系统级特性。
量子纠缠态分析: 谐振子基态与第一激发态
ComplexPlot(exp((-x^2)/2), x*exp((-x^2)/2),x=[-4-4@i,4+4@i])
电磁波极化干涉: 正交偏振分量
ComplexPlot(sin(2x),cos(2x),x=[-3-3@i,3+3@i])
金融风险耦合模型: 市场波动率 + 黑天鹅事件概率
ComplexPlot(log(x+2), exp(-x^2),x=[-2.5-2@i,2.5+2@i])
声学驻波场合成: 基波+谐波+合成波
ComplexPlot(sin(2x), cos(3x), sin(2x)+cos(3x),x=[-@pi-@pi*@i,@pi+@pi*@i])
黎曼曲面研究: 不同分支平方根
ComplexPlot(sqrt(x),x^0.5,x=[-2-2@i,2+2@i])
非线性系统混沌预警: 迭代复杂度升级
ComplexPlot(x, 2exp(x), 2exp(exp(x)),x=[-1-1@i,1+1@i])
复变函数三维图
ComplexPlot3D(f(x)) 色相环复变函数图形是一种复变函数图形的呈现方式. 将色相表示函数值的辐角,明度表示函数值的绝对值来表达复变函数的定义域着色方法.
通过复变函数图，抽象的复数运算转化为直观的几何模式, 在二维平面上呈现四维信息（输入实部、输入虚部、输出实部、输出虚部）.
x -- 复数域范围
流体力学 - 理想流体绕圆柱流动:
ComplexPlot3D(2*(1+1/x),x=[-4-4@i,4+4@i])
调频信号分析:
ComplexPlot3D(exp(1@i*0.8*x^2),x=[-3-3@i,3+3@i])
量子隧穿效应:
ComplexPlot3D(exp(-x^2/2),x=[-4-4@i,4+4@i])
电磁场分布:
ComplexPlot3D(1/x+1/(x-2),x=[-3-3@i,5+3@i])
保角映射演示:
ComplexPlot3D(log(x),x=[0.1-3@i,+3@i]
电磁场分析（麦克斯韦方程）:
ComplexPlot3D(1/(x-1)+1/(x+1),x=[-3-3@i,3+3@i])
流体动力学（纳维-斯托克斯方程）
ComplexPlot3D(x+1/x,x=[-3-3@i,3+3@i])
信号处理（傅里叶分析）:
ComplexPlot3D(exp(1@i*3x)*exp((-x^2)/2),x=[-4-4@i,4+4@i])
先进可视化技术(3D混合呈现)
ComplexPlot3D(abs(sin(x)),x=[-3-3@i,3+3@i])
叠加复变函数三维图
ComplexPlot(f1(x),f2(x)) 揭示函数间的关联性、对称性及系统级特性。
量子纠缠态分析: 谐振子基态与第一激发态
ComplexPlot3D(exp((-x^2)/2), x*exp((-x^2)/2),x=[-4-4@i,4+4@i])
电磁波极化干涉: 正交偏振分量
ComplexPlot3D(sin(2x),cos(2x),x=[-3-3@i,3+3@i])
金融风险耦合模型: 市场波动率 + 黑天鹅事件概率
ComplexPlot3D(log(x+2), exp(-x^2),x=[-2.5-2@i,2.5+2@i])
声学驻波场合成: 基波+谐波+合成波
ComplexPlot3D(sin(2x), cos(3x), sin(2x)+cos(3x),x=[-@pi-@pi*@i,@pi+@pi*@i])
黎曼曲面研究: 不同分支平方根
ComplexPlot3D(sqrt(x),x^0.5,x=[-2-2@i,2+2@i])
非线性系统混沌预警: 迭代复杂度升级
ComplexPlot3D(x, 2exp(x), 2exp(exp(x)),x=[-1-1@i,1+1@i])
复变函数的向量密度图
ComplexVectorDensityPlot(f(z))
箭头 (Arrows)：表示函数 f(z) 本身的向量值，即物理场的向量属性（如速度、力场的方向和大小）。
颜色/色相 (Color/Hue)：表示从 f(z) 衍生出的某个标量函数 S(x, y) 的值，即物理场的标量属性（如势能、能量密度、压力等）。
1：绕圆柱流动 (升级版)
向量场图（箭头）：流体的速度场。
密度图（颜色）：用颜色表示速度的模|f'(z)|。
物理意义：这张图生动地展示了伯努利原理。
高级应用：根据伯努利方程 P + 1/2 ρ v² = constant，流速快（亮黄色）的地方压力小，流速慢（深蓝色）的地方压力大。
这张图因此也间接描绘了圆柱表面的压力分布，这对于计算物体所受的阻力（压差阻力）至关重要。
ComplexVectorDensityPlot(10*(z+4/z),z=[-5-5@i,5+5@i])
2 :电偶极子
向量场图（箭头）：电场强度 E 的方向。
密度图（颜色）：用颜色表示电场强度的模 |E| = |f'(z)|。
物理意义：直观显示电场强度的衰减和集中情况。
图中解读：
在靠近原点（两个电荷非常接近的位置）的区域，颜色非常明亮，甚至发白，表示场强极其巨大。
随着距离原点越远，颜色迅速变暗为蓝色，表示场强按距离的平方反比快速衰减。
高级应用：可以非常清晰地看到哪些区域的电场可能强到足以击穿空气（发生放电现象），或者对带电粒子产生显著作用。
ComplexVectorDensityPlot(1/z,z=[-5-5@i,5+5@i])
3 :复杂势阱/势垒
向量场图（箭头）：代表了“力”的方向，粒子会沿着这个方向被推动。
密度图（颜色）：用颜色表示势函数 φ(x, y) = Re(z^2) = x² - y² 的值。
物理意义：这可以模拟一个鞍点状的势能面。
图中解读：
沿着 y=0 (x轴) 方向，颜色梯度变化大，表示这是一个不稳定平衡点的路径：小球在原点处于平衡，但稍一扰动就会沿x轴加速滚下“势能山”。
沿着 x=0 (y轴) 方向，颜色梯度变化也大，但方向相反，这表示这是一个稳定平衡点的路径：小球偏离原点后，会受到恢复力而被拉回。
高级应用：在理论物理和化学中，这种图用于分析分子反应路径的过渡态。在机器学习中，它可以可视化损失函数的鞍点，帮助理解优化算法的困境。
ComplexVectorDensityPlot(z^2,z=[-5-5@i,5+5@i])
复变函数的向量场图
ComplexVectorPlot(expression)将抽象的复数运算转化为直观的几何图形。
1：恒等函数
向量场图特征：在整个复平面上，每个点 z 上的向量就是 z 本身。这意味着向量从原点呈放射状向外，离原点越远，向量越长。
物理意义：这可以解释为一个源（Source） 的流场。
流体力学：想象复平面是一个水池，原点处有一个水龙头在不断注水。水从原点均匀地流向四面八方。每个点的向量代表了水流的速度和方向。
静电学：原点处有一个正点电荷，向量代表正试探电荷在该点所受电场力的方向和大小。
ComplexVectorPlot(z,z=[-5-5@i,5+5@i])
2 :倒数函数
向量场图特征：
靠近原点：当 z 的模很小（接近原点）时，1/z 的模会非常大，向量又长又乱，原点是一个奇点。
远离原点：当 z 的模很大时，1/z 的模很小，向量很短，指向原点。
整体来看：场看起来像是从原点流出的流（源）和流入原点的流（汇）的结合。
物理意义：这描述了一个源汇偶极子（Source-Sink Dipole） 的流场，但更标准的解释是：
电磁学：它完美地描述了一个无限长直导线载有恒定电流时产生的磁场。导线垂直于复平面穿过原点，磁场线是围绕原点的同心圆。
向量场图显示的就是磁感应强度的方向和大小。原点（奇点）就是导线所在的位置。
ComplexVectorPlot(1/z,z=[-5-5@i,5+5@i])
3 :平方函数
向量场图特征：图像呈现出对称且复杂的模式。你会注意到在实轴和虚轴上，向量行为不同。
物理意义：它可以近似地描述一种拐角流动。
流体力学：想象流体在一个直角拐角处的流动。例如，河流冲过一个堤岸的直角拐弯，z^2 的向量场可以描述拐角附近流体的速度场。
ComplexVectorPlot(z^2,z=[-5-5@i,5+5@i])
4 :指数函数
向量场图特征：沿着垂直的线（x 为常数），所有向量的长度都相同。沿着水平的线（y 为常数），所有向量的方向都相同。图像呈现明显的周期性（沿垂直方向）。
物理意义：这可以描述一种周期性源或平面波。
波动物理：它可以表示一个沿水平方向传播的波，其振幅随 x 增大（或减小）而指数增长（或衰减）。
ComplexVectorPlot(exp(z),z=[-5-5@i,5+5@i])
5 :理想流体绕圆柱体的流动
这是流体力学中的一个经典模型，描述了风或水流绕过桥墩、圆柱形建筑等障碍物的流动情况。
这里，10 代表远处来流的速度 U₀ = 10 m/s。
4 是圆柱半径 R 的平方，即 R = 2 m。
向量场图意义：
这个向量场图表示的是流体的速度场。
在远离原点 (|z| 很大) 的区域，向量是几乎水平向右的，大小为 10，代表均匀的来流。
在圆柱表面 (|z| = 2) 附近，向量方向发生改变，与圆柱表面相切，这符合流体不能穿透固体的边界条件。
在圆柱的正上方和正下方，流速会加快；在圆柱的前后驻点，流速会降为 0。
物理应用：
用于计算桥梁墩柱、潜艇潜望镜、烟囱等结构所受的流体作用力。
ComplexVectorPlot(10*(z+4/z),z=[-5-5@i,5+5@i])
6 :电偶极子的电场
这个函数是电偶极子场的一种简化表示（更精确的表达式是 f(z) = p / z，其中 p 是偶极矩）。这里的常数 1 隐含了偶极矩的强度。
向量场图意义：
这个向量场图表示的是电场强度向量场。
向量从正电荷（可理解为位于原点左侧很近的位置）出发，指向负电荷（位于原点右侧很近的位置）。
场图呈现出典型的偶极子特征：在原点附近场强最大，随着距离增加而衰减；场线从正电荷发出，汇聚于负电荷。
物理应用：
分析分子（如水分子）的极性、无线电天线辐射、以及任何涉及分离正负电荷的系统。
ComplexVectorPlot(1/z,z=[-5-5@i,5+5@i])
7 :点涡与点汇的叠加流动 (浴缸排水)
这个例子模拟了一个更真实的场景：流体在旋转中流向一个排水口。
-2 * Ln(z)：代表一个汇（排水口），强度为 2 m³/s。负号表示流体是流入的。
-5i * Ln(z)：代表一个点涡，强度为 5 m²/s。-i 决定了旋转方向为顺时针。
向量场图意义：
这个向量场是上述两个场的线性叠加，表示流体的速度场。
向量场呈现出螺旋状的轨迹，流体一边绕原点顺时针旋转，一边流向中心被排出。
越靠近中心（排水口），流速越大，旋转的角速度也越大。
物理应用：
直观地模拟和解释浴缸或水槽排水时形成的漩涡、大气中的气旋或龙卷风（虽然是非常简化的模型）的核心流动特征。
ComplexVectorPlot((-2-5@i)*ln(z),z=[-5-5@i,5+5@i])
8 :均匀流绕过圆柱并有环量（产生升力）
它解释了飞机机翼产生升力的原理（库塔-茹科夫斯基定理）
8 * (z + 4/z)：是速度为 8 m/s 的均匀流绕过半径为 2 m (R²=4) 的圆柱。
+ (15i / (2*π)) * Ln(z)：这是在流场上叠加了一个点涡，环量强度为 15 m²/s。这个环量使得圆柱上下表面的流速不对称。
向量场图意义：
向量场图显示了叠加环量后的流体速度场。
由于环量的加入，圆柱上表面的流速显著大于下表面的流速。
根据伯努利原理，上表面压力小，下表面压力大，从而产生一个向上的净力，即升力。
物理应用：
这是空气动力学的基础。通过这个模型，可以理解为什么机翼的上表面要做成弯曲的（相当于增加了环量），从而产生使飞机上升的力。该理论直接应用于机翼和涡轮叶片的设计。
ComplexVectorPlot(8*(z+4/z)+(15@i/(2@pi))*ln(z),z=[-5-5@i,5+5@i])
合并函数
compose(f,g)返回f(g(y)),其中f=f(x)和g=g(y).这里x是由symvar定义的f的符号变量,y是由symfar定义的g的符号变量.
compose(f,g,z)返回f(g(z)),其中f=f(x),g=g(y),x和y是symvar定义的f和g的符号变量.
compose(f,g,x,z)返回f(g(z)),并使x成为f的自变量.也就是说,如果f=cos(x/t),则compose(f,g,x,z)返回cos(g(z)/t),而compose(f,g,t,z）则返回cos(x/g(z)).
compose(f,g,x,y,z)返回f(g(z)),并使x成为f的自变量,使y成为g的自变量.对于f=cos(x/t)和g=sin(y/u),compose(f,g,x,y,z)返回cos(sin(z/u)/t)而compose(f,g,x,u,z)则返回cos(sin/z)/t.
f —— 输入,符号功能,符号表达
g —— 输入,符号功能,符号表达
x,y,z —— 输入,符号变量
示例1: 简单函数组合 f(g(x))
compose((sin(x), x^2, t)
#结果: sin(t^2)
示例2: 三角函数组合
compose(cos(x), sin(y), t)
#结果: cos(sin(t))
示例3: 指数函数与多项式组合
compose(exp(x), 2*x+1, t)
#结果: exp(2*t + 1)
示例4: 多变量函数组合 h(x, g(z))
compose(x+y, y^2, y, z)
#结果: x + z^2
示例5: 复杂嵌套组合 h(p(x,z), z)
compose(x+y*z, y+z, x, y, z)
#结果: y*z + 2*z
示例6: 物理应用 - 弹簧系统
假设弹簧力 F = -k*x，位移 x = A*sin(ω*t)
compose(-k*x, A*sin(ω*t), x, t)
#结果: -A*k*sin(t*ω)
示例7: 经济学应用 - 复合增长
假设收入 R = p*q，销量 q = a - b*p
compose(p*q, a-b*p, q, p)
#结果: p*(a - p**2)
示例8: 概率应用 - 随机变量变换
假设 Y = g(X) = X²，求 E[Y] = E[g(X)]
compose(y, x^2, y, x)
#结果: x^2
示例9: 信号处理 - 系统响应
假设系统响应 y = h(x)，输入 x = f(t)
compose(h(x), f(t), x, t)
#结果: h(f(t))
示例10: 机器学习 - 神经网络激活函数
假设输出 = σ(W*x + b)，其中 σ 是激活函数
compose(1/(1+exp(-x)), W*x+b, x, x)
#结果: 1/(exp(-b - x^2) + 1)
这些示例展示了compose函数在不同领域的应用：
数学函数组合：基本的三角函数、指数函数和多项式函数的组合
多变量函数处理：处理包含多个变量的函数组合
物理应用：弹簧系统的力与位移关系
经济学应用：收入与价格的关系模型
概率应用：随机变量变换的期望计算
信号处理：系统响应与输入信号的关系
机器学习：神经网络激活函数的组合
compose函数在实际应用中的意义：
模型构建：通过组合简单函数构建复杂模型
变量替换：将一个函数的输出作为另一个函数的输入
系统分析：分析复合系统的行为特性
变换处理：实现变量之间的变换关系
链式法则基础：为微积分中的链式法则提供基础
compose函数是数学和工程中的基本操作，它允许我们通过简单函数的组合来表达复杂的关系，是函数式编程和数学建模的核心概念之一。
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
from sympy import symbols
def composition_function(input_str):
"""
函数组合工具，支持多种组合方式
参数:
input_str: 输入字符串，支持以下形式：
- 二元组: (f, g) → f∘g
- 三元组: (f, g, t) → f∘g(t)
- 四元组: (h, g, x, z) → h(x, g(z))
- 五元组: (h, p, x, y, z) → h(p(x,z), z)
返回:
成功时返回组合后的表达式，失败时返回错误信息
特点:
- 自动符号检测
- 动态参数处理
- 增强的错误处理
"""
try:
expr = sp.sympify(input_str, evaluate=False)
def validate_symbols(*symbols):
"""验证符号是否有效"""
return all(s.free_symbols for s in symbols)
def compose_basic(f, g):
"""
基本函数组合 f(g)
参数:
f: 外部函数
g: 内部函数
逻辑:
1. 获取f的第一个自由变量
2. 用g替换该变量
"""
f_vars = list(f.free_symbols)
if not f_vars:
raise ValueError("函数f没有自由变量")
return f.subs(f_vars[0], g)
def compose_with_param(f, g, t):
"""
带参数的函数组合 f(g(t))
参数:
t: 新引入的参数符号
"""
g_vars = list(g.free_symbols)
if not g_vars:
raise ValueError("函数g没有自由变量")
substituted_g = g.subs(g_vars[0], t)
return compose_basic(f, substituted_g)
def compose_multivar(h, g, x, z):
"""
多变量函数组合 h(x, g(z))
参数:
x: 保留的变量
z: 新变量
"""
g_vars = list(g.free_symbols)
if not g_vars:
raise ValueError("函数g没有自由变量")
substituted_g = g.subs(g_vars[0], z)
return h.subs(x, substituted_g)
def compose_nested(h, p, x, y, z):
"""
嵌套组合 h(p(x,z), z)
参数:
y: 需要替换的变量
"""
substituted_p = p.subs(y, z)
return h.subs(x, substituted_p)
# 输入分派逻辑
if isinstance(expr, tuple):
params = expr
if len(params) == 2:
if not validate_symbols(*params):
raise TypeError("参数必须包含符号变量")
return compose_basic(*params)
elif len(params) == 3:
if not validate_symbols(params[0], params[1]) or not params[2].is_Symbol:
raise TypeError("第三个参数必须是符号")
return compose_with_param(*params)
elif len(params) == 4:
if not all(s.is_Symbol for s in params[2:]):
raise TypeError("后两个参数必须是符号")
return compose_multivar(*params)
elif len(params) == 5:
if not all(s.is_Symbol for s in params[2:]):
raise TypeError("后三个参数必须是符号")
return compose_nested(*params)
else:
raise ValueError("不支持的参数数量，应为2-5个")
raise TypeError("输入必须是元组形式")
except Exception as e:
return f"错误: {str(e)}"
def main():
"""示例主函数"""
# 定义常用符号
x, y, z, t = symbols('x y z t')
test_cases = [
# 基础组合测试
"(1/(1+x^2),sin(y))",
# 1/(sin(y)**2 + 1)
"(x**2, cos(y), t)",
# cos(t)**2
# 多变量组合测试
"(x+y, y**2, y, z)",
# x + z**2
# 嵌套组合测试
"(x+y*z, y+z, x, y, z)",
# y*z + 2*z
]
for case in test_cases:
print(f"测试输入: {case}")
result = composition_function(case)
print("输出结果:")
print(result)
print("=" * 50)
if __name__ == "__main__":
main()
逆运算的条件数
C = cond(A) 返回 2-范数逆运算的条件数,等于A的最大奇异值与最小奇异值之比.
C = cond(A,p) 返回 p-范数条件数,其中p可以是1,2,In 或'fro'.
A是输入矩阵
p — 范数类型:2(默认),1,'fro',Inf
示例1: 单位矩阵（最佳条件数）
cond([[1, 0],[0,1]])
#结果: 1.0
#解释: 单位矩阵的条件数为1，是最佳条件数，表示矩阵是完美条件的
示例2: 希尔伯特矩阵（经典病态矩阵）
hilbert_matrix = [[1, 1/2, 1/3], [1/2, 1/3, 1/4], [1/3, 1/4, 1/5]]
cond(hilbert_matrix)
#结果: 524.0567775860644
#解释: 希尔伯特矩阵是著名的病态矩阵，条件数很大，数值计算困难
示例3: 不同范数下的条件数比较
matrix = [[1, 2], [3, 4]]
result3_1 = cond(matrix, 1)
result3_2 = cond(matrix, 2)
result3_inf = cond(matrix, oo)
print("1-范数条件数:", result3_1)
print("2-范数条件数:", result3_2)
print("无穷范数条件数:", result3_inf)
#1-范数条件数: 20.999999999999993
#2-范数条件数: 14.933034373659268
#无穷范数条件数: 20.999999999999993
#解释: 不同范数下的条件数可能不同，但都反映矩阵的病态程度
示例4: 对角矩阵的条件数
diag_matrix = [[100, 0], [0, 0.01]]
cond(diag_matrix)
#结果: 10000.0
#解释: 对角矩阵的条件数等于最大与最小对角线元素的绝对值比，这里是100/0.01=10000
示例5: 正交矩阵的条件数
旋转45度的正交矩阵
theta = @pi/4
rot_matrix = [[cos(theta), -sin(theta)], [sin(theta), cos(theta)]]
cond(rot_matrix)
#结果: 1.0000000000000002
#解释: 正交矩阵的条件数为1，是最佳条件数
示例6: 接近奇异的矩阵
near_singular = [[1, 2], [2, 4.0001]]
cond(near_singular)
#结果: 250008.00009210614
#解释: 矩阵接近奇异，条件数很大，数值计算不稳定
示例7: 向量条件数（1维矩阵）
vector = [1, 2, 3]
cond(vector)
#结果: 1.0
#解释: 向量的条件数通常为1，除非是零向量
示例8: 数值稳定性分析
对比两个相似但条件数不同的矩阵
well_conditioned = [[1, 0.5], [0.5, 1]]
ill_conditioned = [[1, 0.999], [0.999, 1]]
result8_1 = cond(well_conditioned)
result8_2 = cond(ill_conditioned)
print("输入1: 良态矩阵 [[1,0.5],[0.5,1]]")
print("条件数:", result8_1)
#输入1: 良态矩阵 [[1,0.5],[0.5,1]]
#条件数: 2.999999999999999
print("输入2: 病态矩阵 [[1,0.999],[0.999,1]]")
print("条件数:", result8_2)
#输入2: 病态矩阵 [[1,0.999],[0.999,1]]
#条件数: 1998.999999999916
#解释: 病态矩阵的条件数远大于良态矩阵，数值计算更不稳定
示例9: 不同大小的矩阵条件数
small_matrix = [[1, 2], [3, 4]]
large_matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
cond(small_matrix)
#结果: 14.933034373659268
cond(large_matrix)
#结果: 1.1439441181880765e+17
#解释: 第二个矩阵是奇异的（秩为2），条件数理论上应为无穷大
#注意: 实际计算中由于浮点精度，可能得到很大但不是无穷的值
示例10: 实际应用 - 线性方程组求解
假设我们要求解 Ax = b，其中 A 是以下矩阵
A_matrix = [[1, 1], [1, 1.0001]]
b_vector = [2, 2.0001]
cond(A_matrix)
#结果: 40002.00007491187
#解释: 条件数较大，表示方程组的解对输入数据的微小变化很敏感
#实际解应为 x = [1, 1]^T，但如果 b 有微小扰动，解可能变化很大
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def condition_number_of_matrix(input_str):
"""
计算矩阵的条件数，支持指定范数类型
参数:
input_str: 输入字符串，可以是以下形式：
- 矩阵列表：例如 '[[1, 2], [3, 4]]'
- 包含矩阵和范数的元组：例如 '([[1, 2], [3, 4]], 1)'
（支持的范数：1, 2, np.inf等，符号无穷大用'oo'表示）
返回:
计算结果字符串或错误信息
"""
try:
expr = sp.sympify(input_str)
error = False
result = None
# 处理包含矩阵和范数的元组输入（例如'([[1,2],[3,4]], 1)'）
if isinstance(expr, tuple) and len(expr) == 2:
matrix_part = expr[0]
p_part = expr[1]
# 转换矩阵部分
sym_matrix = sp.Matrix(matrix_part)
if sym_matrix is None:
return f"错误：无法解析矩阵部分 {matrix_part}"
# 转换范数参数
try:
if p_part.is_integer:
p = int(p_part)
else:
p = float(p_part.evalf())
except Exception as e:
return f"错误：无效的范数参数 {p_part} ({e})"
# 计算条件数
try:
A = np.array(sym_matrix, dtype=float)
result = np.linalg.cond(A, p=p)
except Exception as e:
return f"数值计算错误: {e}"
# 处理普通矩阵输入
elif isinstance(expr, list):
sym_matrix = sp.Matrix(expr)
if sym_matrix is not None:
try:
A = np.array(sym_matrix, dtype=float)
result = np.linalg.cond(A)
except Exception as e:
return f"数值计算错误: {e}"
else:
error = True
return result if not error else f"输入格式错误: {input_str}"
except Exception as e:
return f"总处理错误: {str(e)}"
def main():
"""主函数，提供测试案例"""
test_cases = [
"[[1, 0],[0,1]]",
# 结果: 1.0
"([[1, 2], [3, 4]], 1)",
# 结果: 20.999999999999993
"([[1, 2], [3, 4]], oo)",
# 结果: 20.999999999999993
"[[2, 0], [0, 0.5]]",
# 结果: 4.0
"[1, 2, 3]",
# 结果: 1.0
"([[1, 2]], 2)",
# 结果: 1.0
]
for case in test_cases:
print(f"测试案例: {case}")
result = condition_number_of_matrix(case)
print(f"结果: {result}\n{'-' * 40}")
if __name__ == "__main__":
main()
与特征值有关的条件数
c = condeig(A) 返回由A的特征值的条件数构成的向量. 这些条件数是左特征向量和右特征向量之间角度的余弦的倒数.
A -- 输入矩阵
示例1: 单位矩阵（最佳条件数）
condeig([[1, 0], [0, 1]])
#特征值条件数: [1,1]
#解释: 单位矩阵的特征值条件数为1，表示特征值对矩阵扰动最不敏感
示例2: 对称矩阵（良好条件数）
condeig([[2, 1], [1, 2]])
#特征值条件数: [1,1]
#解释: 对称矩阵的特征值条件数通常较小，特征值相对稳定
示例3: 一般矩阵（中等条件数）
condeig([[1, 2], [3, 4]])
#特征值条件数: [1.015,1.015]
#解释: 一般矩阵的特征值条件数适中，特征值对扰动有一定敏感性
示例4: 病态矩阵（高条件数）
condeig([[1, 1000], [0, 1]])
#特征值条件数: [nan,nan]
#解释: 病态矩阵的特征值条件数很大，特征值对扰动非常敏感
示例5: 接近缺陷矩阵（极高条件数）
condeig([[1, 1], [0, 1.0001]])
#特征值条件数: [10000.0001,10000.0001]
#解释: 接近缺陷的矩阵特征值条件数极高，特征值计算极不稳定
示例6: 3×3矩阵
condeig([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
#特征值条件数: [1.0396,1.0396,1]
#解释: 这个矩阵是奇异的（秩为2），特征值条件数应该很大
示例7: 对角矩阵
result7 = condeig([[10, 0, 0], [0, 1, 0], [0, 0, 0.1]])
#特征值条件数: [1,1,1]
#解释: 对角矩阵的特征值条件数通常较小，除非有非常接近的特征值
示例8: 正交矩阵（旋转矩阵）
theta = @pi/4 # 45度
rot_matrix = [[cos(theta), -sin(theta)], [sin(theta), cos(theta)]]
condeig(rot_matrix)
#特征值条件数: [nan,nan]
#解释: 正交矩阵的特征值条件数很小，特征值计算非常稳定
示例9: 希尔伯特矩阵（经典病态矩阵）
hilbert_matrix = [[1, 1/2, 1/3], [1/2, 1/3, 1/4], [1/3, 1/4, 1/5]]
condeig(hilbert_matrix)
#特征值条件数: [1,1,1]
#解释: 希尔伯特矩阵是著名的病态矩阵，特征值条件数很大
示例10: 随机矩阵
生成一个随机矩阵（确保可重复性）
np.random.seed(42)
random_matrix = np.random.rand(3, 3)
condeig(random_matrix)
#特征值条件数: [1.0984 7.6869 7.6054]
#解释: 随机矩阵的特征值条件数通常适中
这些示例展示了特征值条件数在不同类型矩阵中的应用和意义：
单位矩阵：特征值条件数为1，是最佳情况
对称矩阵：特征值条件数通常较小，特征值稳定
一般矩阵：特征值条件数适中，有一定敏感性
病态矩阵：特征值条件数很大，特征值对扰动非常敏感
接近缺陷矩阵：特征值条件数极高，特征值计算极不稳定
3×3矩阵：奇异矩阵的特征值条件数很大
对角矩阵：特征值条件数通常较小
正交矩阵：特征值条件数很小，计算稳定
希尔伯特矩阵：经典病态矩阵，特征值条件数很大
随机矩阵：特征值条件数通常适中
错误处理：非方阵和向量输入的错误处理
特征值条件数的实际意义：
数值稳定性指标：特征值条件数越大，特征值计算越不稳定
扰动敏感性度量：反映特征值对矩阵元素微小变化的敏感程度
算法选择依据：高条件数问题可能需要特殊算法或预处理
系统稳定性分析：在控制系统和动力系统中，特征值条件数与系统稳定性相关
物理系统建模：在物理建模中，特征值条件数反映系统对参数变化的敏感性
特征值条件数是数值线性代数中的重要概念，特别在特征值问题求解、系统稳定性分析和数值算法设计中有着广泛应用。高条件数的特征值问题通常需要更精细的数值方法或预处理技术来保证计算精度。
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
from scipy.linalg import eig
def condeig(A):
"""
计算矩阵特征值的条件数（基于左右特征向量夹角）
参数:
A: numpy数组形式的方阵
返回:
cond_numbers: 各特征值的条件数数组
算法说明:
1. 计算左右特征向量
2. 归一化特征向量
3. 计算左右特征向量夹角的余弦值
4. 条件数为余弦值的倒数
"""
# 检查是否为方阵
if A.shape[0] != A.shape[1]:
raise ValueError("输入矩阵必须是方阵")
# 计算左右特征向量
w, vl, vr = eig(A, left=True, right=True)
# 归一化处理 (按列向量归一化)
vl_norm = np.linalg.norm(vl, axis=0)
vr_norm = np.linalg.norm(vr, axis=0)
# 计算余弦值并避免除以零
with np.errstate(divide='ignore', invalid='ignore'):
cosines = np.abs(np.sum(vl * vr, axis=0) / (vl_norm * vr_norm))
cosines = np.where(cosines < 1e-12, np.nan, cosines) # 处理极小值
# 计算条件数
cond_numbers = 1.0 / cosines
return cond_numbers
def condition_number_eigenvalues(input_str):
"""
计算矩阵特征值条件数的入口函数
参数:
input_str: 字符串形式的矩阵输入，例如：
- "[[1, 2], [3, 4]]"
- "[[1, 0], [0, 1]]"
返回:
计算结果字符串或错误信息
"""
try:
expr = sp.sympify(input_str)
# 处理元组输入（本函数不支持参数）
if isinstance(expr, tuple):
return "错误：不支持带参数的输入格式"
# 转换为矩阵
sym_matrix = sp.Matrix(expr)
if sym_matrix is None:
return f"错误：无法解析矩阵 {input_str}"
# 检查矩阵维度
if sym_matrix.shape[1] == 1:
return "错误：输入是向量不是矩阵"
if not sym_matrix.is_square:
return "错误：矩阵必须是方阵"
# 转换为numpy数组
try:
A = np.array(sym_matrix, dtype=float)
except TypeError as e:
return f"类型错误：矩阵包含非数值元素 ({e})"
# 计算条件数
try:
cond_numbers = condeig(A)
return cond_numbers
except Exception as e:
return f"计算错误：{str(e)}"
except Exception as e:
return f"总处理错误：{str(e)}"
def main():
"""测试案例主函数"""
test_cases = [
"[[1, 0], [0, 1]]",
# 特征值条件数: [1. 1.]
"[[2, 1], [1, 2]]",
# 特征值条件数: [1. 1.]
"[[1, 2], [3, 4]]",
# 特征值条件数: [1.015 1.015]
]
for case in test_cases:
print(f"测试案例: {case}")
result = condition_number_eigenvalues(case)
if isinstance(result, np.ndarray):
print("特征值条件数:", np.round(result, 4))
else:
print("结果:", result)
print("-" * 60)
if __name__ == "__main__":
main()
1-范数条件数估计
c = condest(A) 计算方阵 A 的 1-范数条件数的下限 c.
A是输入矩阵
示例1: 单位矩阵（最佳条件数）
condest([[1, 0], [0, 1]])
#1-范数条件数估计: 1.0
#解释: 单位矩阵的条件数为1，是最佳情况，数值计算最稳定
示例2: 对角矩阵
condest([[2, 0], [0, 3]])
#1-范数条件数估计: 1.5
#解释: 对角矩阵的条件数等于最大与最小对角线元素的绝对值比，这里是3/2=1.5
示例3: 病态矩阵
condest([[1, 1000], [0, 1]])
#1-范数条件数估计: 1002001.0
#解释: 病态矩阵的条件数很大，数值计算不稳定
示例4: 希尔伯特矩阵（经典病态矩阵）
hilbert_matrix = [[1, 1/2, 1/3], [1/2, 1/3, 1/4], [1/3, 1/4, 1/5]]
condest(hilbert_matrix)
#1-范数条件数估计: 748.0000000000027
#解释: 希尔伯特矩阵是著名的病态矩阵，条件数很大
示例5: 正交矩阵（旋转矩阵）
theta = @pi/4 # 45度
rot_matrix = [[cos(theta), -sin(theta)], [sin(theta), cos(theta)]]
condest(rot_matrix)
#1-范数条件数估计: 2.0
#解释: 正交矩阵的条件数为1，数值计算非常稳定
示例6: 接近奇异的矩阵
near_singular = [[1, 2], [2, 4.0001]]
condest(near_singular)
#1-范数条件数估计: 360012.00010083907
#解释: 矩阵接近奇异，条件数很大，数值计算不稳定
示例7: 3×3矩阵
condest([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
#1-范数条件数估计: 6.485183463413514e+17
#解释: 这个矩阵是奇异的（秩为2），条件数理论上应为无穷大
示例8: 对称正定矩阵
spd_matrix = [[2, 1], [1, 2]]
condest(spd_matrix)
#1-范数条件数估计: 3.0
#解释: 对称正定矩阵的条件数通常较小，数值计算稳定
示例9: 随机矩阵
生成一个随机矩阵（确保可重复性）
np.random.seed(42)
random_matrix = np.random.rand(3, 3)
condest(random_matrix)
#1-范数条件数估计: 76.18479325571523
#解释: 随机矩阵的条件数通常适中
示例10: 大型对角矩阵（展示1-范数估计的优势）
创建一个10×10对角矩阵
diag_values = [10**i for i in range(10)]
diag_matrix = np.diag(diag_values)
condest(diag_matrix)
#1-范数条件数估计: 1000000000.0
#精确条件数（理论值）: 1000000000.0
#解释: 对于大型矩阵，1-范数估计比直接计算更高效
这些示例展示了1-范数条件数估计在不同类型矩阵中的应用和意义：
单位矩阵：条件数为1，是最佳情况
对角矩阵：条件数与对角线元素的比例相关
病态矩阵：条件数很大，数值计算不稳定
希尔伯特矩阵：经典病态矩阵，条件数很大
正交矩阵：条件数为1，数值计算非常稳定
接近奇异矩阵：条件数很大，数值计算困难
3×3矩阵：奇异矩阵的条件数理论上为无穷大
对称正定矩阵：条件数通常较小，数值计算稳定
随机矩阵：条件数通常适中
大型对角矩阵：展示1-范数估计对大型矩阵的高效性
1-范数条件数估计的实际意义：
数值稳定性指标：条件数越大，数值计算越不稳定
误差放大因子：条件数表示输入误差可能被放大的最大倍数
算法选择依据：高条件数问题可能需要特殊算法处理
大型矩阵处理：1-范数估计特别适用于大型稀疏矩阵
计算效率：相比精确计算，1-范数估计更高效，尤其对于大型矩阵
1-范数条件数估计是数值线性代数中的重要工具，特别适用于大型稀疏矩阵的条件数估计。它通过高效的迭代算法避免了直接计算矩阵逆的高计算成本，同时提供了可靠的数值稳定性评估。
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
from scipy.sparse.linalg import onenormest
from numpy.linalg import inv
def condition_one_normest(input_str):
"""
估算矩阵的 1-范数条件数 (κ₁(A) = ||A||₁ * ||A⁻¹||₁)
参数:
input_str: 表示矩阵的字符串，如 "[[1, 2], [3, 4]]"
返回:
数值类型的条件数估计值，或包含错误信息的字符串
"""
try:
# 将字符串转换为 SymPy 表达式
expr = sp.sympify(input_str)
error = False
result = None
# 排除元组类型输入
if isinstance(expr, tuple):
error = True
# 检查是否为有效矩阵
elif isinstance(expr, list):
# 将 SymPy 矩阵转换为 NumPy 数组
a = sp.Matrix(expr)
# 验证矩阵是否为方阵
if not a.is_square:
raise ValueError("矩阵必须是方阵")
A = np.array(expr, dtype=float)
# 计算矩阵的 1-范数
norm_A = onenormest(A)
# 计算矩阵的逆
A_inv = inv(A)
# 计算逆矩阵的 1-范数
norm_inv_A = onenormest(A_inv)
# 计算条件数
result = norm_A * norm_inv_A
else:
error = True
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {str(e)}"
def main():
"""主函数用于演示条件数计算功能"""
test_cases = [
("[[1, 2], [3, 4]]", "2x2 矩阵"),
# 结果: 20.999999999999993
("[[1, 0], [0, 1]]", "单位矩阵"),
# 结果: 1.0
]
for input_str, description in test_cases:
print(f"测试案例: {description}")
print(f"输入: {input_str}")
output = condition_one_normest(input_str)
print(f"结果: {output}\n{'-' * 40}")
if __name__ == "__main__":
main()
矩阵条件数估计量的反例
A = condex(n,k) 返回条件数估计量的反例矩阵. 它采用标量参数alpha（默认值为 100）, 并返回大小为 n×n 的矩阵.
k = 1, 4×4, LINPACK 的 RCOND 的反例
k = 2, 3×3, LINPACK 的 RCOND 的反例
k = 3, 任意, LINPACK 的 RCOND 的反例（独立于 alpha）
k = 4, n>=4, LINPACK 的 RCOND 的反例（它是作为反例的该矩阵的逆矩阵）
如果 n 不等于该矩阵的实际大小，则为该矩阵补上单位矩阵以构成 n 阶
n, k - 输入, 标量
示例1: 对称对角线主导矩阵 (k=1)
result1 = condex(4, 1)
#[[50.6714153011233, -18.6208837947260, 8.91070760828702, 88.2496063987030],
[-18.6208837947260, -22.4136956949181, 106.088642954668, -57.2922757752444],
[8.91070760828702, 106.088642954668, -45.3417692812462, -109.532379304164],
[88.2496063987030, -57.2922757752444, -109.532379304164, -55.2287529240973]]
示例2: 三对角矩阵 (k=2)
condex(5, 2)
#[[100, -1, 0, 0, 0],
[-1, 100, -1, 0, 0],
[0, -1, 100, -1, 0],
[0, 0, -1, 100, -1],
[0, 0, 0, -1, 100]]
示例3: 随机对称矩阵 (k=3)
condex(3, 3)
#[[-1.01283112033442, -0.549028184370009, -0.420247935416644],
[-0.549028184370009, 1.46564876892155, -0.825262243349996],
[-0.420247935416644, -0.825262243349996, -0.544382724525183]]
示例4: 稀疏矩阵 (k=4)
condex(6, 4)
#[[100, -0.600253850105912, 0, 0, 0, 0],
[0, 100, 0, 0, 0, 0],
[0, 0, 100, 0, 0.110922589709866, 0],
[0, 0, 0, 100, 0, 0],
[0, 0.947439821046639, 0, 0, 100, 0],
[0, 0, 0, 0, 0, 100]]
示例5: 默认情况 (只提供n)
condex(4)
#[[100, 0, 0, 0],
[0, 100, 0, 0],
[0, 0, 100, -0.0134972247379339],
[0, 0, 0, 100]]
示例6: 大型矩阵示例
对于大型矩阵，只显示部分元素
condex(8, 2)[0:4, 0:4]
#[[100, -1, 0, 0],
[-1, 100, -1, 0],
[0, -1, 100, -1],
[0, 0, -1, 100]]
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def condex_matrix(input_str):
"""
根据输入的字符串生成特定类型的矩阵，用于条件数估计示例。
参数：
input_str：输入的字符串，可以是单个整数n，或元组(n, k)，其中k指定矩阵类型。
返回：
sympy矩阵对象，或错误信息字符串。
支持的k值：
1 - 对称对角线主导矩阵
2 - 三对角矩阵
3 - 随机对称矩阵
4 - 稀疏矩阵
"""
try:
expr = sp.sympify(input_str)
error = False
result = None
def evaluation_condex_matrix(n, k, alpha=100):
"""
根据参数生成特定类型的矩阵。
参数：
n：矩阵的维度（正整数）
k：矩阵类型（1-4）
alpha：某些矩阵类型的参数，默认为100
返回：
生成的numpy数组
异常：
当n <= 0或k不在1-4时抛出ValueError
"""
# 检查参数有效性
if n <= 0:
raise ValueError("n必须是正整数")
if k not in [1, 2, 3, 4]:
raise ValueError("k必须是1, 2, 3, 或4")
# 根据k值生成不同类型的矩阵
if k == 1:
# 生成对称对角线主导矩阵
A = np.eye(n) + alpha * np.random.randn(n, n)
A = (A + A.T) / 2 # 确保对称性
elif k == 2:
# 生成三对角矩阵
A = np.zeros((n, n))
for i in range(n):
A[i, i] = alpha # 对角线元素
if i > 0:
A[i, i - 1] = -1 # 下对角线
if i < n - 1:
A[i, i + 1] = -1 # 上对角线
elif k == 3:
# 生成随机对称矩阵
A = np.random.randn(n, n)
A = (A + A.T) / 2 # 确保对称性
elif k == 4:
# 生成稀疏矩阵（对角线+随机稀疏非对角元素）
A = np.zeros((n, n))
for i in range(n):
A[i, i] = alpha # 对角线元素
# 添加随机稀疏非对角元素
num_nonzero = n // 2 # 非零元素数量
for _ in range(num_nonzero):
i, j = np.random.randint(0, n, 2)
if i != j:
A[i, j] = np.random.randn()
return A
# 解析输入并生成矩阵
if isinstance(expr, tuple) and len(expr) == 2:
# 处理元组输入 (n, k)
n_arg, k_arg = expr
if n_arg.is_integer and k_arg.is_integer:
n = int(n_arg)
k = int(k_arg)
result = evaluation_condex_matrix(n, k)
else:
error = True
elif expr.is_integer:
# 处理单个整数输入n（默认k=4）
n = int(expr)
result = evaluation_condex_matrix(n, k=4)
else:
error = True
# 返回结果或错误信息
if not error and result is not None:
return sp.Matrix(result)
else:
return f"输入错误: {input_str}。请输入有效参数，例如'(3,1)'或'4'。"
except Exception as e:
return f"错误: {str(e)}"
def main():
"""主函数，用于演示condex_matrix的使用"""
test_cases = [
"(3, 1)",
# 生成的矩阵：
# Matrix([[-34.1231710201152, -63.4008303741496, -123.327367608754],
# [-63.4008303741496, 52.2264963291183, 45.3067107040908],
# [-123.327367608754, 45.3067107040908, -191.364761590595]])
"4",
# Matrix([[100.000000000000, 0, -0.798603421207217, 0],
# [0, 100.000000000000, 0, 0],
# [0, -0.0429322800916667, 100.000000000000, 0],
# [0, 0, 0, 100.000000000000]])
"(2, 2)",
# Matrix([[100.000000000000, -1.00000000000000],
# [-1.00000000000000, 100.000000000000]])
]
for case in test_cases:
print(f"输入：{case}")
result = condex_matrix(case)
if isinstance(result, sp.Matrix):
print("生成的矩阵：")
print(result)
else:
print(f"结果：{result}")
print("-" * 40)
if __name__ == "__main__":
main()
复共轭
Zc = conj(Z) 返回 Z 中每个元素的复共轭.
Z — 输入数组, 标量, 向量
示例 1: 量子力学中的波函数共轭
量子力学中，波函数的模平方表示概率密度，常需要计算波函数的复共轭
psi = exp(k*x*@i) # 平面波波函数
conj(psi)
#exp(conjugate(j)*conjugate(k)*conjugate(x))
示例 2: 电学中的阻抗计算
交流电路中，复数阻抗的共轭用于计算功率
Z = R + X*@i # 复数阻抗，R为电阻，X为电抗
conj(Z)
#conjugate(R) - I*conjugate(X)
示例 3: 信号处理中的复数信号
在信号处理中，常需要处理复数信号的共轭
signal = A*exp(omega*t*@i + phi)
conj(signal)
#exp(-I*conjugate(omega)*conjugate(t) + conjugate(phi))*conjugate(A)
示例 4: 量子计算中的Pauli矩阵
量子计算中常用Pauli矩阵，它们的复共轭有特殊性质
sigma_y = [[0, -@i], [@i, 0]] # Pauli Y矩阵
conj(sigma_y)
#[[0, I], [conjugate(j), 0]]
示例 5: 矩阵特征值问题
在矩阵分析中，常需要计算厄米特矩阵（自共轭矩阵）
A = [[1, 2+@i], [2-@i, 3]] # 一个厄米特矩阵
conj(A)
#[[1, 2-1i]
[2+1i,3]]
示例 6: 复数数组处理
处理数值复数数组
complex_array = [1+2@i, 3-4@i, 5@i, 7]
conj(complex_array)
#[1-2i, 3+4i, -5i, 7]
这些示例展示了conj复共轭函数在不同领域的实际应用：
量子力学：波函数的复共轭用于计算概率密度和期望值
电学：复数阻抗的共轭用于计算交流电路中的功率
信号处理：复数信号的共轭用于各种信号处理算法
量子计算：Pauli矩阵的复共轭有特殊的物理意义
矩阵分析：验证矩阵的厄米特性（自共轭特性）
数值计算：处理数值复数数组
conj复共轭函数能够正确处理这些场景中的复共轭计算，无论是符号表达式还是数值计算，都提供了准确的结果。
特别是对于符号表达式，函数能够保持符号的完整性，这对于理论分析和公式推导非常有用。
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def conjugate_number(input_str):
"""
计算输入表达式的复共轭。
支持单个数值复数和非符号矩阵的复共轭计算。
参数:
input_str (str): 输入的表达式字符串
返回:
sp.Expr 或 str: 如果输入有效，返回复共轭结果；否则返回错误信息。
"""
try:
# 修正输入表达式
# 将输入字符串转换为 SymPy 表达式
expr = sp.sympify(input_str)
error = False
result = None
if expr.free_symbols:
result = sp.conjugate(expr)
# 检查输入是否为单个数值
elif expr.is_number:
# 计算单个数值的复共轭
z = complex(expr)
result = np.conj(z)
else:
# 其他情况标记为错误
error = True
# 如果没有错误，返回结果；否则返回错误信息
return result if not error else f"输入错误: {input_str}"
except Exception as e:
# 捕获异常并返回错误信息
return f"错误: {e}"
def main():
"""
入口函数，包含示范代码。
"""
# 示范 1: 单个复数的复共轭
input_str1 = "3 + 4j"
result1 = conjugate_number(input_str1)
print(f"示范 1 输入: {input_str1}")
print(f"示范 1 结果: {result1}")
# (3-4j)
# 示范 2: 非符号矩阵的复共轭
input_str2 = "x+y"
result2 = conjugate_number(input_str2)
print(f"示范 2 输入: {input_str2}")
print(f"示范 2 结果: {result2}")
# conjugate(x) + conjugate(y)
# 示范 3: 错误输入（符号矩阵）
x, y = sp.symbols('x y')
input_str3 = f"Matrix([[x + y*I, 1], [2, 3]])"
result3 = conjugate_number(input_str3)
print(f"示范 3 输入: {input_str3}")
print(f"示范 3 结果: {result3}")
# Matrix([[conjugate(x) - I*conjugate(y), 1],
# [2, 3]])
if __name__ == "__main__":
main()
等值线图
ContourPlot(expression1)把三维曲面（z = f(x, y)）投影到二维平面（x-y 平面）上的可视化方法。
通过等值线及其疏密程度来揭示函数值（高度、压力、温度、浓度、损失值等）在二维区域上的分布模式、变化趋势、极值位置和梯度信息。它是在众多领域分析空间数据的强大工具。
1. 电磁场强度（偶极子天线）
物理意义: 模拟偶极子天线的辐射场分布
等值线特征： 同心圆环（距离衰减）叠加辐射状花瓣（角度调制），零值线呈十字形。
ContourPlot(cos(theta)*sin(2@pi*r)/(r^2),theta=[0,2@pi],r=[0.1,5])
2. 飓风气压场
物理意义:
第一项：背景气压
第二项：飓风中心低压（随距离衰减）
第三项：不对称性（模拟移动方向的影响）
等值线特征： 偏心闭合圆环，低压中心附近等压线密集。
ContourPlot(1013-100/(1+(r/50)^2)+0.2*r*cos(theta-0.25*@pi),theta=[0,2@pi],r=[0,500])
3. 量子力学概率密度（2p轨道）
物理意义： 氢原子2pₓ轨道的电子概率密度
等值线特征： 双泪滴状结构，沿x轴对称，节线（零值）在y轴。
ContourPlot(r*cos(theta)*exp(-r/2),theta=[0,2@pi],r=[0,10])
4. 地震应力波干涉
物理意义：
第一项：断层方向性应力（矩形波干涉）
第二项：震源发出的球面波
等值线特征： 网格状条纹叠加同心圆环，交点处形成应力集中区。
ContourPlot(sin(2x)*cos(3y)+0.5*sin(5*sqrt(x^2+y^2)),x=[-5,5],y=[-5,5])
5. 海面温度分布（厄尔尼诺现象）
等值线特征： 带状分布（纬度效应）叠加波浪形扰动（经度效应）。
ContourPlot(25+5*cos(2@pi*lambd)-2*exp(-(phi/30)^2)+3*sin(4*phi)*cos(6*@pi*lambd),phi=[-60,60],lambd=[0,1])
6. 化学反应浓度场
物理意义：
第一项：反应物扩散（中心浓度最高）
第二项：对流扰动（沿x方向周期性输运）
等值线特征： 中心圆形等值线被正弦波状条纹扭曲，形成"靶心+波纹"图案。
ContourPlot(1/(1+x^2+y^2)+0.3*sin(3x)*exp(-y^2),x=[-4,4],y=[-4,4])
7. 引力透镜效应
物理意义：
分母：爱因斯坦环附近的光强增强
cos(4theta): 非对称透镜（如椭圆星系）造成的四重像
等值线特征：四个高亮弧区对称分布，临界半径处等值线密集。
ContourPlot((1/abs(1-(2/r)^2))*cos(4*theta),theta=[0,2@pi],r=[2.1,10])
8. 绘制拉压分界线 (σ_θθ == 0)
这条线是环向应力从拉伸（正）变为压缩（负）的边界
物理意义与解读： 这条 σ_θθ == 0 的线会出现在 θ=0° 和 180° 附近的一个特定半径上。
它清晰地告诉我们，在孔的侧方，压应力区仅限于孔边附近的一个小范围内，超出这个边界，环向应力又变回拉应力。
ContourPlot(50*((1+25/r^2)-(1+1875/r^4)*cos(2theta))==0,theta=[0,2@pi],r=[5,15])
9. 波动物理学：二维驻波模式
cos(x) + cos(y) == 1/2 的等值线：这条线标识出了在这个二维驻波场中，振幅（或能量）恰好等于特定值（1/2）的所有位置。
ContourPlot(cos(x)+cos(y)==1/2,x=[0,4@pi],y=[0,4@pi])
叠加等值线图
ContourPlot(expression1,expression2)揭示两个变量函数在同一参数空间中的关系、相互作用或权衡。
示例 1：无线通信的信号优化
场景：设计天线阵列时需同时最小化干扰能量 f(x,y)f(x,y) 和最大化信号强度 g(x,y)g(x,y)。
ContourPlot(5*(cos(x)-0.2*sin(y))^2+5*(-0.2*cos(x)+sin(y))^2,cos((x^2+y^2))*exp(-(x^2+y^2)/10),x=[0,2@pi],y=[0,2@pi])
示例 2：化学反应器的温度-压力控制
场景：优化反应条件使副产物生成（ff）最小化，同时主产物产率（gg）最大化。
ContourPlot(5.2*(cos(x)^2+sin(y)^2)-4*cos(x)*sin(y),cos((x^2+y^2))*exp(-(x^2+y^2)/10),x=[0,2@pi],y=[0,2@pi])
示例 3：地形分析与水资源规划
高程谷底（f1低值区）与集水高峰（f2高值区）在(±1.2, ±0.8)重叠 → 理想坝
ContourPlot(1000*exp(-(x^2+y^2)/5)+500*sin(2x)*cos(y),50*(1+0.7*cos(1.5x)*sin(1.2y))*sech((x^2+y^2)/4),x=[-3,3],y=[-3,3])"
示例 4：金融投资组合优化
# 组合波动率 (风险)
risk: sqrt(0.2x^2+0.5y^2-0.3x*y
# 预期收益率
return: 0.08x+0.12y-0.02x*y
risk等值线呈椭圆状，return为斜直线
切点(x≈0.4,y≈0.3)是有效前沿上的最优解
ContourPlot(sqrt(0.2x^2+0.5y^2-0.3x*y),0.08x+0.12y-0.02x*y,x=[0,1],y=[0,1])
示例 5：材料科学 - 合金性能
# 硬度函数：在(0,0)处有尖峰
600*exp(-2*(x^2+y^2))+200*abs(sin(3x)*cos(2y))
# 延展性函数：在角落处较高
25-5x^2-7y^2+3*sin(@pi*x*y)
ContourPlot(600*exp(-2*(x^2+y^2))+200*abs(sin(3x)*cos(2y)),25-5x^2-7y^2+3*sin(@pi*x*y),x=[-1.5,1.5],y=[-1.5,1.5])
示例 6：光学透镜设计
# 像差函数：离轴误差
5*(x^2+1.5*y^2)+2*x*y*cos(4*sqrt(x^2+y^2))
# 聚焦强度：中心峰值
exp(-(x^2+y^2)/2)*sinc(3x)*sinc(3y)
ContourPlot(5*(x^2+1.5*y^2)+2*x*y*cos(4*sqrt(x^2+y^2)),exp(-(x^2+y^2)/2)*sinc(3x)*sinc(3y),x=[-1,1],y=[-1,1])
示例 7：生态位竞争模型
# 物种A适应性：偏好负x区域
8-(x+1)^2-0.5*y^2
# 物种B适应性：偏好正y区域
7-0.8*x^2-(y-1)^2
ContourPlot(8-(x+1)^2-0.5*y^2,7-0.8*x^2-(y-1)^2,x=[-3,3],y=[-2,2])
示例 8：化学反应优化
# 主产物产率：振荡响应曲面
(0.7+0.3*cos(2*@pi*x))*(0.6+0.4*sin(2*@pi*y))
# 副产物生成率：高温高压促进
0.2x+0.3y+0.1x*y
ContourPlot((0.7+0.3*cos(2*@pi*x))*(0.6+0.4*sin(2*@pi*y)),0.2x+0.3y+0.1x*y,x=[0,1],y=[0,1])
示例 9：无线通信调度
# 信道干扰函数
1.5+0.5*cos(4x)+0.5*sin(4y)
# 信号质量函数
exp(-((x-1)^2+(y-1)^2)/2)+0.3*exp(-((x+1)^2+(y+1)^2)/2)
ContourPlot(1.5+0.5*cos(4x)+0.5*sin(4y),exp(-((x-1)^2+(y-1)^2)/2)+0.3*exp(-((x+1)^2+(y+1)^2)/2),x=[-2,2],y=[-2,2])
示例 10： 分析房间或音乐厅中的声学驻波模式（简正模式）
在矩形房间中，|sin(x)sin(y)| = 0.5 可能对应固定边界下的声压分布，而 |cos(x)cos(y)| = 0.5 可能对应自由边界下的分布。
这有助于优化扬声器和麦克风的放置，以避免驻波导致的音质问题或找到最佳听音位置。
ContourPlot(abs(cos(x)*cos(y))==0.5,abs(sin(x)*sin(y))==0.5,x=[-3,3],y=[-3,3])
极坐标等值线图
ContourPolarPlot(expression1)把三维曲面（z = f(x, y)）投影到二维平面（x-y 平面）上的可视化方法。
通过等值线及其疏密程度来揭示函数值（高度、压力、温度、浓度、损失值等）在二维区域上的分布模式、变化趋势、极值位置和梯度信息。它是在众多领域分析空间数据的强大工具。
1. 电磁场强度（偶极子天线）
物理意义: 模拟偶极子天线的辐射场分布
等值线特征： 同心圆环（距离衰减）叠加辐射状花瓣（角度调制），零值线呈十字形。
ContourPolarPlot(cos(theta)*sin(2@pi*r)/(r^2),theta=[0,2@pi],r=[0.1,5])
2. 飓风气压场
物理意义:
第一项：背景气压
第二项：飓风中心低压（随距离衰减）
第三项：不对称性（模拟移动方向的影响）
等值线特征： 偏心闭合圆环，低压中心附近等压线密集。
ContourPolarPlot(1013-100/(1+(r/50)^2)+0.2*r*cos(theta-0.25*@pi),theta=[0,2@pi],r=[0,500])
3. 量子力学概率密度（2p轨道）
物理意义： 氢原子2pₓ轨道的电子概率密度
等值线特征： 双泪滴状结构，沿x轴对称，节线（零值）在y轴。
ContourPolarPlot(r*cos(theta)*exp(-r/2),theta=[0,2@pi],r=[0,10])
4. 地震应力波干涉
物理意义：
第一项：断层方向性应力（矩形波干涉）
第二项：震源发出的球面波
等值线特征： 网格状条纹叠加同心圆环，交点处形成应力集中区。
ContourPolarPlot(sin(2x)*cos(3y)+0.5*sin(5*sqrt(x^2+y^2)),x=[-5,5],y=[-5,5])
5. 海面温度分布（厄尔尼诺现象）
等值线特征： 带状分布（纬度效应）叠加波浪形扰动（经度效应）。
ContourPolarPlot(25+5*cos(2@pi*lambd)-2*exp(-(phi/30)^2)+3*sin(4*phi)*cos(6*@pi*lambd),phi=[-60,60],lambd=[0,1])
6. 化学反应浓度场
物理意义：
第一项：反应物扩散（中心浓度最高）
第二项：对流扰动（沿x方向周期性输运）
等值线特征： 中心圆形等值线被正弦波状条纹扭曲，形成"靶心+波纹"图案。
ContourPolarPlot(1/(1+x^2+y^2)+0.3*sin(3x)*exp(-y^2),x=[-4,4],y=[-4,4])
7. 引力透镜效应
物理意义：
分母：爱因斯坦环附近的光强增强
cos(4theta): 非对称透镜（如椭圆星系）造成的四重像
等值线特征：四个高亮弧区对称分布，临界半径处等值线密集。
ContourPolarPlot((1/abs(1-(2/r)^2))*cos(4*theta),theta=[0,2@pi],r=[2.1,10])
极坐标叠加等值线图
ContourPolarPlot(expression1,expression2)揭示两个变量函数在同一参数空间中的关系、相互作用或权衡。
示例 1：无线通信的信号优化
场景：设计天线阵列时需同时最小化干扰能量 f(x,y)f(x,y) 和最大化信号强度 g(x,y)g(x,y)。
ContourPolarPlot(5*(cos(x)-0.2*sin(y))^2+5*(-0.2*cos(x)+sin(y))^2,cos((x^2+y^2))*exp(-(x^2+y^2)/10),x=[0,2@pi],y=[0,2@pi])
示例 2：化学反应器的温度-压力控制
场景：优化反应条件使副产物生成（ff）最小化，同时主产物产率（gg）最大化。
ContourPolarPlot(5.2*(cos(x)^2+sin(y)^2)-4*cos(x)*sin(y),cos((x^2+y^2))*exp(-(x^2+y^2)/10),x=[0,2@pi],y=[0,2@pi])
示例 3：地形分析与水资源规划
高程谷底（f1低值区）与集水高峰（f2高值区）在(±1.2, ±0.8)重叠 → 理想坝
ContourPolarPlot(1000*exp(-(x^2+y^2)/5)+500*sin(2x)*cos(y),50*(1+0.7*cos(1.5x)*sin(1.2y))*sech((x^2+y^2)/4),x=[-3,3],y=[-3,3])"
示例 4：金融投资组合优化
# 组合波动率 (风险)
risk: sqrt(0.2x^2+0.5y^2-0.3x*y
# 预期收益率
return: 0.08x+0.12y-0.02x*y
risk等值线呈椭圆状，return为斜直线
切点(x≈0.4,y≈0.3)是有效前沿上的最优解
ContourPolarPlot(sqrt(0.2x^2+0.5y^2-0.3x*y),0.08x+0.12y-0.02x*y,x=[0,1],y=[0,1])
示例 5：材料科学 - 合金性能
# 硬度函数：在(0,0)处有尖峰
600*exp(-2*(x^2+y^2))+200*abs(sin(3x)*cos(2y))
# 延展性函数：在角落处较高
25-5x^2-7y^2+3*sin(@pi*x*y)
ContourPolarPlot(600*exp(-2*(x^2+y^2))+200*abs(sin(3x)*cos(2y)),25-5x^2-7y^2+3*sin(@pi*x*y),x=[-1.5,1.5],y=[-1.5,1.5])
示例 6：光学透镜设计
# 像差函数：离轴误差
5*(x^2+1.5*y^2)+2*x*y*cos(4*sqrt(x^2+y^2))
# 聚焦强度：中心峰值
exp(-(x^2+y^2)/2)*sinc(3x)*sinc(3y)
ContourPolarPlot(5*(x^2+1.5*y^2)+2*x*y*cos(4*sqrt(x^2+y^2)),exp(-(x^2+y^2)/2)*sinc(3x)*sinc(3y),x=[-1,1],y=[-1,1])
示例 7：生态位竞争模型
# 物种A适应性：偏好负x区域
8-(x+1)^2-0.5*y^2
# 物种B适应性：偏好正y区域
7-0.8*x^2-(y-1)^2
ContourPolarPlot(8-(x+1)^2-0.5*y^2,7-0.8*x^2-(y-1)^2,x=[-3,3],y=[-2,2])
示例 8：化学反应优化
# 主产物产率：振荡响应曲面
(0.7+0.3*cos(2*@pi*x))*(0.6+0.4*sin(2*@pi*y))
# 副产物生成率：高温高压促进
0.2x+0.3y+0.1x*y
ContourPolarPlot((0.7+0.3*cos(2*@pi*x))*(0.6+0.4*sin(2*@pi*y)),0.2x+0.3y+0.1x*y,x=[0,1],y=[0,1])
示例 9：无线通信调度
# 信道干扰函数
1.5+0.5*cos(4x)+0.5*sin(4y)
# 信号质量函数
exp(-((x-1)^2+(y-1)^2)/2)+0.3*exp(-((x+1)^2+(y+1)^2)/2)
ContourPolarPlot(1.5+0.5*cos(4x)+0.5*sin(4y),exp(-((x-1)^2+(y-1)^2)/2)+0.3*exp(-((x+1)^2+(y+1)^2)/2),x=[-2,2],y=[-2,2])
卷积和多项式乘法
c = conv(a,b) 返回输入向量a和b的乘积.
c = conv(a,b,shape) 返回卷积的分段，由 shape 指定
a,b — 输入向量.
shape — 卷积的分段.默认full|same|valid
两个向量a和b的卷积，表示b滑过a时依据这些点确定的重叠部分的面积。从代数方法上讲，卷积就是与将其系数为a和b元素的多项式相乘的运算
该实现完整覆盖了多项式系数乘法的各种使用场景，同时提供了清晰的错误提示，适合需要多项式运算的数学计算和教学场景。
示例 1: 信号处理 - 有限脉冲响应(FIR)滤波器设计
在信号处理中，卷积用于实现滤波器
input_signal = [1, 0, 0, 0, 0, 0] # 单位脉冲信号
filter_coeff = [0.25, 0.5, 0.25] # 平滑滤波器系数
result = conv(input_signal, filter_coeff)
print("FIR滤波器输出:", result)
#FIR滤波器输出: [0.25,0.5,0.25,0,0,0,0,0]
示例 2: 概率论 - 独立随机变量和的分布
两个独立离散随机变量之和的概率分布是它们各自分布的卷积
假设X和Y是两个骰子的点数分布
X_dist = [0, 1/6, 1/6, 1/6, 1/6, 1/6, 1/6] # 骰子X的概率分布(0-6)
Y_dist = [0, 1/6, 1/6, 1/6, 1/6, 1/6, 1/6] # 骰子Y的概率分布(0-6)
sum_dist = conv(X_dist, Y_dist)
print("两个骰子点数和的概率分布:", sum_dist)
#两个骰子点数和的概率分布: [0,0,0.02777778,0.05555556,0.08333333,0.11111111,
0.13888889,0.16666667,0.13888889,0.11111111,0.08333333,
0.05555556,0.02777778]
示例 3: 控制系统 - 系统响应计算
在控制系统中，系统输出是输入信号与系统脉冲响应的卷积
input_signal = [1, 2, 1, 0, 0] # 输入信号
system_response = [0.5, 0.3, 0.2] # 系统脉冲响应
output = conv(input_signal, system_response)
print("系统输出响应:", output)
#系统输出响应: [0.5,1.3,1.3,0.7,0.2,0,0]
示例 4: 图像处理 - 模糊效果
在图像处理中，卷积用于实现各种效果，如模糊
假设我们有一行像素值
pixels = [10, 20, 30, 40, 50, 60, 70, 80]
blur_kernel = [0.2, 0.6, 0.2] # 模糊核
blurred = conv(pixels, blur_kernel, same)
print("模糊后的像素值:", blurred)
#模糊后的像素值: [10,20,30,40,50,60,70,62]
示例 5: 多项式乘法
最基本的应用：多项式乘法
(2x^2 + 3x + 1) * (x + 4) = 2x^3 + 11x^2 + 13x + 4
poly1 = [2, 3, 1] # 2x^2 + 3x + 1
poly2 = [1, 4] # x + 4
product = conv(poly1, poly2)
print("多项式乘积系数:", product)
#多项式乘积系数: [2, 11, 13, 4]
示例 6: 通信系统 - 码片序列扩展
在CDMA通信中，数据比特通过与码片序列的卷积进行扩展
data_bits = [1, -1, 1] # 数据比特(使用BPSK调制: 1和-1)
spreading_code = [1, 1, -1, -1] # 扩频码
spread_signal = conv(data_bits, spreading_code)
print("扩频后的信号:", spread_signal)
#扩频后的信号: [1,0,-1,1,0,-1]
示例 7: 经济学 - 移动平均计算
在时间序列分析中，卷积用于计算移动平均
sales_data = [100, 110, 105, 120, 115, 125, 130] # 每周销售额
ma_window = [1/3, 1/3, 1/3] # 3周简单移动平均
moving_avg = conv(sales_data, ma_window, valid)
print("3周移动平均:", moving_avg)
#3周移动平均: [105,111.66666667,113.33333333,120,123.33333333]
这些示例展示了conv卷积和多项式乘法函数在不同领域的实际应用：
信号处理：实现FIR滤波器，对信号进行平滑处理
概率论：计算独立随机变量之和的概率分布
控制系统：计算系统对输入信号的响应
图像处理：实现模糊效果等图像处理操作
多项式运算：计算多项式乘积的系数
通信系统：实现CDMA系统中的扩频操作
经济学：计算时间序列的移动平均值
con卷积和多项式乘法函数能够正确处理这些场景中的卷积计算，无论是数值计算还是符号处理，都提供了准确的结果。
特别是支持三种不同的卷积模式（'full'、'same'、'valid'），这使得它在各种应用场景中都非常灵活和实用。
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def coefficients_polynomial_multiply(input_str):
"""
计算两个多项式系数数组的卷积(多项式乘法)
参数：
input_str - 输入字符串，格式为：
"(系数数组1, 系数数组2 [, 模式])"
模式可选：'full'(默认), 'valid', 'same'
返回：
Sympy矩阵对象 或 错误信息字符串
示例：
"( [1,2], [3,4] )" -> 一维卷积(full模式)
"( [1,2], [3,4], 'same' )" -> 一维卷积(same模式)
"""
try:
expr = sp.sympify(input_str)
# 参数有效性检查
if not isinstance(expr, tuple):
return f"输入格式错误: 需要元组格式，例如'( [1,2], [3,4] )'"
if len(expr) not in (2, 3):
return f"参数个数错误: 需要2或3个参数，当前收到{len(expr)}个"
# 转换系数数组到numpy数组
def parse_coefficients(coeff):
"""将sympy表达式转换为数值数组"""
return np.array([float(x) for x in coeff], dtype=np.float64)
u = parse_coefficients(expr[0])
v = parse_coefficients(expr[1])
# 解析卷积模式
mode = 'full' # 默认模式
if len(expr) == 3:
# 处理可能的符号/字符串格式
mode_str = str(expr[2]).lower().strip("'\"") # 去除可能存在的引号
if mode_str not in ['valid', 'full', 'same']:
return f"错误: 不支持的卷积模式 '{mode_str}'"
mode = mode_str
result = np.convolve(u, v, mode=mode)
return sp.Matrix(result)
except Exception as e:
return f"错误: {str(e)}"
def main():
"""主函数用于演示功能"""
test_cases = [
"([1,2],[3,4])",
# Matrix([[3.00000000000000],
# [10.0000000000000],
# [8.00000000000000]])
"( [1, 2], [3, 4], 'same' )",
# Matrix([[3.00000000000000],
# [10.0000000000000]])
"( [2, 1, 3], [4, 5], 'valid' )",
# Matrix([[14.0000000000000],
# [17.0000000000000]])
"( [1.5, 2.5], [3], 'full' )",
# Matrix([[4.50000000000000],
# [7.50000000000000]])
"( (1,2), [3,4] )",
# Matrix([[3.00000000000000],
# [10.0000000000000],
# [8.00000000000000]])
]
for case in test_cases:
print(f"输入：{case}")
result = coefficients_polynomial_multiply(case)
if isinstance(result, sp.Matrix):
print("计算结果：")
print(result)
else:
print(result)
print("-" * 40)
if __name__ == "__main__":
main()
二维卷积
C = conv2(A,B) 返回矩阵 A 和 B 的二维卷积。
如果 A 是矩阵，而 B 是行向量（或者 A 是行向量，而 B 是矩阵），则 C 是矩阵的每行与该向量的卷积。
如果 A 是矩阵，而 B 是列向量（或者 A 是列向量，而 B 是矩阵），则 C 是矩阵的每列与该向量的卷积。
C = conv2(u,v,A) 首先求 A 的各列与向量 u 的卷积，然后求每行结果与向量 v 的卷积。无论 u 或 v 是行向量还是列向量，此行为都适用。
C = conv2(___,shape) 根据 shape 返回卷积的子区。例如，C = conv2(A,B,"same") 返回卷积中大小与 A 相同的中心部分。
A — 输入数组, 向量 | 矩阵
B — 第二个输入数组, 向量 | 矩阵
u — 输入向量, 行或列向量
v — 第二个输入向量, 行或列向量
shape — 卷积的分段, "full" (默认) | "same" | "valid"
C — 二维卷积, 向量 | 矩阵
示例 1: 图像处理 - Sobel边缘检测
Sobel算子用于检测图像中的边缘
image = [[10,10,10,0,0,0], [10,10,10,0,0,0], [10,10,10,0,0,0], [10,10,10,0,0,0], [10,10,10,0,0,0], [10,10,10,0,0,0]] # 简单图像，左侧亮，右侧暗
sobel_x = [[-1,0,1], [-2,0,2], [-1,0,1]] # 水平Sobel算子
edges_x = conv2(image, sobel_x, same)
print("水平边缘检测结果:\n", edges_x)
#水平边缘检测结果:
#[[-30, 0, 30, 30, 0, 0],
[-40, 0, 40, 40, 0, 0],
[-40, 0, 40, 40, 0, 0],
[-40, 0, 40, 40, 0, 0],
[-40, 0, 40, 40, 0, 0],
[-30, 0, 30, 30, 0, 0]]
示例 2: 图像模糊 - 高斯模糊
使用高斯核进行图像模糊
small_image = [[1,2,3,4], [5,6,7,8], [9,10,11,12], [13,14,15,16]]
gaussian_kernel = [[1,2,1], [2,4,2], [1,2,1]] # 近似高斯核
blurred = conv2(small_image, gaussian_kernel, same)
print("高斯模糊结果:\n", blurred)
#高斯模糊结果:
#[[24, 40, 52, 45],
[64, 96, 112, 92],
[112, 160, 176, 140],
[108, 152, 164, 129]]
示例 3: 可分离卷积 - 先水平后垂直的边缘检测
可分离卷积可以提高计算效率
image = [[1,1,1,0,0], [1,1,1,0,0], [1,1,1,0,0], [1,1,1,0,0], [1,1,1,0,0]]
horizontal_edge = [1, 0, -1] # 水平边缘检测
vertical_edge = [1, 2, 1] # 垂直平滑
edge_detection = conv2(horizontal_edge, vertical_edge, image)
print("可分离卷积边缘检测:\n", edge_detection)
#可分离卷积边缘检测:
#[[1, 3, 4, 3, 1, 0, 0],
[1, 3, 4, 3, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[-1, -3, -4, -3, -1, 0, 0],
[-1, -3, -4, -3, -1, 0, 0]]
示例 4: 数值模拟 - 热传导方程
卷积可以用于模拟热传导等物理过程
initial_temp = [[0,0,0,0,0], [0,0,0,0,0], [0,0,100,0,0], [0,0,0,0,0], [0,0,0,0,0]] # 中心点热源
diffusion_kernel = [[0,0.2,0], [0.2,0.2,0.2], [0,0.2,0]] # 扩散核
heat_spread = conv2(initial_temp, diffusion_kernel, same)
print("热扩散模拟:\n", heat_spread)
#热扩散模拟:
#[[0, 0, 0, 0, 0],
[0, 0, 20, 0, 0],
[0, 20, 20, 20, 0],
[0, 0, 20, 0, 0],
[0, 0, 0, 0, 0]]
示例 5: 计算机视觉 - 特征提取
使用Gabor滤波器提取纹理特征
texture = [[1,2,1,2,1], [2,1,2,1,2], [1,2,1,2,1], [2,1,2,1,2], [1,2,1,2,1]] # 棋盘纹理
gabor_filter = [[0.5,0.7,0.5], [0.7,-1,0.7], [0.5,0.7,0.5]] # 简化的Gabor滤波器
features = conv2(texture, gabor_filter, same)
print("纹理特征提取:\n", features)
#纹理特征提取:
#[[2.3, 2.1, 4.2, 2.1, 2.3],
[2.1, 6.6, 4.8, 6.6, 2.1],
[4.2, 4.8, 6.6, 4.8, 4.2],
[2.1, 6.6, 4.8, 6.6, 2.1],
[2.3, 2.1, 4.2, 2.1, 2.3]]
示例 6: 地震数据处理 - 波场传播
卷积可用于模拟地震波在地层中的传播
source_wavelet = [[0,0,0,0,0], [0,0,0,0,0], [0,0,1,0,0], [0,0,0,0,0], [0,0,0,0,0]] # 震源
earth_model = [[0.8,0.1,0], [0.1,0.8,0.1], [0,0.1,0.8]] # 简化地层模型
wave_propagation = conv2(source_wavelet, earth_model, full)
print("地震波传播模拟:\n", wave_propagation)
#地震波传播模拟:
#[[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0.8, 0.1, 0, 0, 0],
[0, 0, 0.1, 0.8, 0.1, 0, 0],
[0, 0, 0, 0.1, 0.8, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0]]
示例 7: 神经网络 - 卷积层操作
展示CNN中卷积层的基本操作
input_feature = [[1,0,1,0,1], [0,1,0,1,0], [1,0,1,0,1], [0,1,0,1,0], [1,0,1,0,1]] # 输入特征图
conv_kernel = [[1,-1], [-1,1]] # 卷积核
conv_output = conv2(input_feature, conv_kernel, valid)
print("CNN卷积层输出:\n", conv_output)
#CNN卷积层输出:
#[[2, -2, 2, -2],
[-2, 2, -2, 2],
[2, -2, 2, -2],
[-2, 2, -2, 2]]
这些示例展示了conv2二维卷积函数在不同领域的实际应用：
图像处理：边缘检测、图像模糊等基本操作
计算机视觉：特征提取、纹理分析
物理模拟：热传导、波传播等物理过程模拟
数值分析：偏微分方程的数值解法
地震数据处理：波场传播模拟
神经网络：卷积神经网络中的卷积操作
conv2二维卷积函数能够正确处理这些场景中的二维卷积计算，支持常规卷积和可分离卷积，以及三种不同的卷积模式（'full'、'same'、'valid'）。
这使得它在各种科学计算和工程应用中都非常有用。特别是可分离卷积的支持，可以显著提高计算效率，因为二维卷积可以分解为两个一维卷积的序列。
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import numpy as np
import sympy as sp
from scipy.signal import convolve2d
def coefficients_polynomial_multiply_2d(input_str):
"""
实现类似MATLAB conv2的二维卷积操作
参数格式：
- 常规卷积: ( [[a11,a12,...], ... ], [[b11,b12,...], ... ] )
- 可分离卷积: ( [u1,u2,...], [v1,v2,...], [[a11,a12,...], ... ] )
- 指定模式: ( [[a...]], [[b...]], "mode" ) ，mode可以是'full'(默认)/'same'/'valid'
"""
try:
# 将输入字符串转换为 SymPy 表达式
expr = sp.sympify(input_str)
# 检查输入是否为元组，如果不是则返回错误信息
if not isinstance(expr, tuple):
return "输入格式错误: 需要元组格式，例如'( [[1,2],[3,4]], [[5,6],[7,8]] )'"
# 获取输入元组的参数数量
param_count = len(expr)
# 检查参数数量是否为 2 或 3，如果不是则返回错误信息
if param_count not in (2, 3):
return f"错误: 需要2或3个参数，当前收到{param_count}个"
def parse_matrix(matrix_expr):
"""将SymPy表达式转换为标准二维numpy数组"""
try:
# 尝试将输入转换为 SymPy 矩阵
matrix = sp.Matrix(matrix_expr)
if matrix is not None:
# 如果矩阵是列向量，将其平铺为一维列表
if matrix.shape[1] == 1:
py_list = list(matrix.flat())
else:
# 否则将矩阵转换为嵌套列表
py_list = matrix.tolist()
# 如果输入是一个数字，将其转换为 1x1 的二维数组
elif matrix_expr.is_number:
return np.array([[float(matrix_expr)]]) # 标量处理
# 如果转换后的列表是嵌套列表，说明是二维数组，将其转换为 numpy 数组
if isinstance(py_list[0], list):
return np.array(py_list, dtype=float) # 二维数组
# 否则是一维列表，将其转换为二维行向量的 numpy 数组
return np.array([py_list], dtype=float) # 一维转二维行向量
except Exception as e:
# 若解析过程中出现异常，抛出 ValueError 异常
raise ValueError(f"矩阵解析错误: {e}")
if param_count == 2:
# 当参数数量为 2 时，进行常规的二维卷积，模式为 'full'
A = parse_matrix(expr[0])
B = parse_matrix(expr[1])
result = convolve2d(A, B, mode='full')
else:
# 当参数数量为 3 时，进一步判断是否为可分离卷积
A_part = parse_matrix(expr[0])
B_part = parse_matrix(expr[1])
# 定义一个匿名函数，用于判断数组是否为向量（行向量或列向量）
is_vector = lambda arr: arr.shape[0] == 1 or arr.shape[1] == 1
if is_vector(A_part) and is_vector(B_part):
# 如果 A_part 和 B_part 都是向量，则进行可分离卷积
u = A_part.flatten()
v = B_part.flatten()
A = parse_matrix(expr[2])
# 先对 A 的每一列与 u 进行一维卷积
col_conv = np.apply_along_axis(lambda c: np.convolve(c, u, 'full'), 0, A)
# 再对卷积结果的每一行与 v 进行一维卷积
result = np.apply_along_axis(lambda r: np.convolve(r, v, 'full'), 1, col_conv)
else:
# 否则进行指定模式的二维卷积
A = A_part
B = B_part
mode = str(expr[2]).lower()
# 检查模式是否为支持的模式，如果不是则返回错误信息
if mode not in ['full', 'same', 'valid']:
return f"错误: 不支持的卷积模式 '{mode}'"
result = convolve2d(A, B, mode=mode)
# 将卷积结果转换为 SymPy 矩阵并返回
return sp.Matrix(result)
except Exception as e:
return f"错误: {str(e)}"
# 示范代码
if __name__ == "__main__":
# 测试用例
test_cases = [
# 基本二维卷积
('[[1,2],[3,4]], [[5,6],[7,8]]'),
# Matrix([[5.00000000000000, 16.0000000000000, 12.0000000000000],
# [22.0000000000000, 60.0000000000000, 40.0000000000000],
# [21.0000000000000, 52.0000000000000, 32.0000000000000]])
# 可分离卷积
('[1,2], [3,4], [[5,6],[7,8]]'),
# Matrix([[15.0000000000000, 38.0000000000000, 24.0000000000000],
# [51.0000000000000, 128.000000000000, 80.0000000000000],
# [42.0000000000000, 104.000000000000, 64.0000000000000]])
# same模式
('[[1,2],[3,4]], [[5,6],[7,8]], same'),
# Matrix([[5.00000000000000, 16.0000000000000], [22.0000000000000, 60.0000000000000]])
# valid模式
('[[1,2,3],[4,5,6],[7,8,9]], [[1,0],[0,1]], valid')
# Matrix([[6.00000000000000, 8.00000000000000], [12.0000000000000, 14.0000000000000]])
]
for input_str in test_cases:
print(f"测试输入: {input_str}")
result = coefficients_polynomial_multiply_2d(input_str)
print("实际输出:\n", result)
N维卷积
C = convn(A,B) 返回数组 A 和 B 的 N 维卷积。
C = convn(A,B,shape) 根据 shape 返回卷积的子区。例如，C = convn(A,B,'same') 返回卷积中大小与 A 相同的中心部分。
A — 输入数组, 向量 | 矩阵 | 多维数组
B — 第二个输入数组,向量 | 矩阵 | 多维数组
shape — 卷积的分段, 'full' (默认) | 'same' | 'valid'
C — N 维卷积, 向量 | 矩阵 | 多维数组
示例1：图像边缘检测（Sobel算子）
模拟一个小图像区域
image = [[10, 10, 10, 0, 0, 0],
[10, 10, 10, 0, 0, 0],
[10, 10, 10, 0, 0, 0],
[10, 10, 10, 0, 0, 0],
[10, 10, 10, 0, 0, 0]]
Sobel水平边缘检测核
sobel_x = [[-1, 0, 1],
[-2, 0, 2],
[-1, 0, 1]]
result_sobel = convn(image, sobel_x, same)
print("水平边缘检测结果:\n", result_sobel)
# [[-30.0, 0.0, 30.0, 30.0, 0.0, 0.0],
[-40.0, 0.0, 40.0, 40.0, 0.0, 0.0],
[-40.0, 0.0, 40.0, 40.0, 0.0, 0.0],
[-40.0, 0.0, 40.0, 40.0, 0.0, 0.0],
[-30.0, 0.0, 30.0, 30.0, 0.0, 0.0]]
# 结果中的高绝对值表示边缘位置
示例2：高斯模糊（图像平滑）
5×5高斯核（近似值）
gaussian_kernel = [[1, 4, 6, 4, 1],
[4, 16, 24, 16, 4],
[6, 24, 36, 24, 6],
[4, 16, 24, 16, 4],
[1, 4, 6, 4, 1]]
简单图像（一个小方块）
small_image = [[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 255, 255, 255, 0, 0],
[0, 0, 255, 255, 255, 0, 0],
[0, 0, 255, 255, 255, 0, 0],
[0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0]]
result_blur = convn(small_image, gaussian_kernel, same)
print("高斯模糊结果（中心区域）:\n", result_blur[2:5, 2:5]) # 显示中心区域
# [[30855.0, 39270.0, 30855.0],
[39270.0, 49980.0, 39270.0],
[30855.0, 39270.0, 30855.0]]
# 可以看到原始尖锐边缘变得平滑
示例3：一维信号处理（噪声抑制）
模拟含噪声的信号
noisy_signal = [2, 5, 7, 3, 8, 12, 4, 6, 9, 5, 3, 7, 10, 6, 4]
移动平均滤波器（平滑窗口）
moving_avg = [0.2, 0.2, 0.2, 0.2, 0.2] # 5点移动平均
result_smooth = convn(noisy_signal, moving_avg, same)
print("信号平滑结果:\n", result_smooth)
# [2.8, 3.4, 5.0, 7.0, 6.8, 6.6, 7.8, 7.2, 5.4, 6.0, 6.8, 6.2, 6.0, 5.4, 4.0]
# 可以看到信号变得平滑，噪声被抑制
示例4：二维卷积用于特征提取
模拟一个小网格（可能代表图像或传感器数据）
grid = [[0, 0, 0, 0, 0, 0],
[0, 1, 1, 1, 0, 0],
[0, 1, 2, 1, 0, 0],
[0, 1, 1, 1, 0, 0],
[0, 0, 0, 0, 0, 0]]
用于检测圆形特征的核
circle_kernel = [[-1, -1, -1],
[-1, 8, -1],
[-1, -1, -1]]
result_feature = convn(grid, circle_kernel, same)
print("特征提取结果:\n", result_feature)
#[[-1.0, -2.0, -3.0, -2.0, -1.0, 0.0],
[-2.0, 4.0, 2.0, 4.0, -2.0, 0.0],
[-3.0, 2.0, 8.0, 2.0, -3.0, 0.0],
[-2.0, 4.0, 2.0, 4.0, -2.0, 0.0],
[-1.0, -2.0, -3.0, -2.0, -1.0, 0.0]]
这些示例展示了卷积操作的实际应用：
图像边缘检测：Sobel算子通过卷积突出图像中的边缘信息
高斯模糊：使用高斯核对图像进行平滑处理，减少噪声和细节
信号平滑：移动平均滤波器可以抑制信号中的高频噪声
特征提取：特定设计的卷积核可以检测图像中的特定模式或特征
实际应用中，卷积在以下领域有广泛应用：
图像处理（模糊、锐化、边缘检测）
计算机视觉（特征提取）
信号处理（滤波、降噪）
神经网络（卷积神经网络CNN）
物理学（模拟物理系统）
工程学（系统响应计算）
convnn函数提供了一个灵活的N维卷积工具，可以处理从简单一维信号到复杂多维数据结构的各种卷积操作。
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
from scipy.signal import convolve
def coefficients_polynomial_multiply_ndim(input_str):
try:
"""
对标MATLAB的convn函数，执行N维卷积操作
参数:
A_str (str): 字符串形式表示的输入数组A（如"[1,2,3]"或"[[1,2],[3,4]]"）
B_str (str): 字符串形式表示的输入数组B
shape (str): 卷积模式，可选'full'(默认), 'same', 'valid'
返回:
numpy.ndarray: 卷积结果数组，出错时返回None
"""
# 解析输入字符串为SymPy表达式
expr = sp.sympify(input_str)
# 初始化错误标志为False
error = False
# 检查解析后的表达式是否为元组
if isinstance(expr, tuple):
# 若元组长度为3，分别提取两个数组和卷积模式
if len(expr) == 3:
A_str, B_str, shape = expr[0], expr[1], str(expr[2])
# 若元组长度为2，提取两个数组，默认卷积模式为'full'
elif len(expr) == 2:
A_str, B_str = expr
shape = "full"
# 将提取的数组字符串转换为SymPy数组
A_array = sp.Array(A_str)
B_array = sp.Array(B_str)
# 检查数组转换结果是否为None，或者卷积模式是否合法
if A_array is None or B_array is None or shape not in ["full", "valid", "same"]:
# 若不满足条件，设置错误标志为True
error = True
else:
try:
# 将SymPy数组转换为numpy数组
A_np = np.array(A_array.tolist(), dtype=float)
B_np = np.array(B_array.tolist(), dtype=float)
except Exception as e:
# 若转换过程中出现异常，打印错误信息并返回None
print(f"转换为numpy数组时出错: {e}")
return None
# 执行卷积并处理可能的错误
try:
# 调用scipy的convolve函数进行卷积操作
result = convolve(A_np, B_np, mode=shape)
except ValueError as e:
# 若卷积计算出现异常，打印错误信息并返回None
print(f"卷积计算错误: {e}")
return None
else:
# 若解析后的表达式不是元组，设置错误标志为True
error = True
# 若没有错误，将卷积结果转换为SymPy数组返回；否则返回错误信息字符串
return sp.Array(result) if not error else f"输入错误: {input_str}"
except Exception as e:
print(f"转换错误: {e}")
return None
if __name__ == "__main__":
# 示例1：一维卷积（full模式）
print("示例1：一维卷积".center(50, '-'))
A = "[1, 2, 3]"
B = "[4, 5]"
result = coefficients_polynomial_multiply_ndim(f"{A}, {B}")
print("卷积结果(full):\n", result)
# [4.0, 13.0, 22.0, 15.0]
# 示例2：二维卷积（same模式）
print("\n" + "示例2：二维卷积".center(50, '-'))
A_2d = "[[1, 2], [3, 4]]"
B_2d = "[[5, 6], [7, 8]]"
result_same = coefficients_polynomial_multiply_ndim(f"{A_2d}, {B_2d}, same")
print("卷积结果(same):\n", result_same)
# [[5.0, 16.0], [22.0, 60.0]]
# 示例3：三维卷积（valid模式）
print("\n" + "示例3：三维卷积".center(50, '-'))
A_3d = "[[[1,0],[2,3]], [[4,5],[6,7]]]"
B_3d = "[[[0,1],[1,0]]]"
result_valid = coefficients_polynomial_multiply_ndim(f"{A_3d}, {B_3d}, valid")
print("卷积结果(valid):", result_valid)
# [[[2.0]], [[11.0]]]
连分数的收敛项
连分数的收敛性是指连分数在无限项时是否收敛到一个确定的值.
s = Convergents(vars)
vars是向量,表示连分数. 每个元素由有理数或者浮点数表示.连分数的收敛性由收敛项组成,这些收敛项是连分数展开过程中的中间结果.
s是向量,每个元素是有理数.
示例1：黄金比例（φ）的近似
黄金比例的连分数展开为 [1; 1, 1, 1, 1, ...]
golden_ratio_cf = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] # 取前10项
convergents = Convergents(golden_ratio_cf)
print("黄金比例连分数收敛项:")
for i, conv in enumerate(convergents):
print(f"第{i+1}项收敛: {conv} ≈ {float(conv):.8f}")
#黄金比例连分数收敛项:
#第1项收敛: 1 ≈ 1.00000000
#第2项收敛: 2 ≈ 2.00000000
#第3项收敛: 3/2 ≈ 1.50000000
#第4项收敛: 5/3 ≈ 1.66666667
#第5项收敛: 8/5 ≈ 1.60000000
#第6项收敛: 13/8 ≈ 1.62500000
#第7项收敛: 21/13 ≈ 1.61538462
#第8项收敛: 34/21 ≈ 1.61904762
#第9项收敛: 55/34 ≈ 1.61764706
#第10项收敛: 89/55 ≈ 1.61818182
# 可以看到收敛项逐渐接近黄金比例 (1+√5)/2 ≈ 1.61803399
示例2：圆周率π的近似
π的连分数展开为 [3; 7, 15, 1, 292, 1, 1, 1, 2, 1, ...]
pi_cf = [3, 7, 15, 1, 292, 1, 1, 1, 2, 1]
pi_convergents = Convergents(pi_cf)
print("圆周率连分数收敛项:")
for i, conv in enumerate(pi_convergents):
print(f"第{i+1}项收敛: {conv} ≈ {float(conv):.10f} (误差: {abs(float(conv)-3.1415926535):.2e})")
#圆周率连分数收敛项:
#第1项收敛: 3 ≈ 3.0000000000 (误差: 1.42e-01)
#第2项收敛: 22/7 ≈ 3.1428571429 (误差: 1.26e-03)
#第3项收敛: 333/106 ≈ 3.1415094340 (误差: 8.32e-05)
#第4项收敛: 355/113 ≈ 3.1415929204 (误差: 2.67e-07)
#第5项收敛: 103993/33102 ≈ 3.1415926530 (误差: 4.88e-10)
#第6项收敛: 104348/33215 ≈ 3.1415926539 (误差: 4.21e-10)
#第7项收敛: 208341/66317 ≈ 3.1415926535 (误差: 3.26e-11)
#第8项收敛: 312689/99532 ≈ 3.1415926536 (误差: 1.19e-10)
#第9项收敛: 833719/265381 ≈ 3.1415926536 (误差: 8.11e-11)
#第10项收敛: 1146408/364913 ≈ 3.1415926536 (误差: 9.14e-11)
# 可以看到收敛项逐渐接近π ≈ 3.1415926535
示例3：无理数√2的近似
√2的连分数展开为 [1; 2, 2, 2, 2, ...] (周期为2)
sqrt2_cf = [1, 2, 2, 2, 2, 2, 2, 2, 2, 2]
sqrt2_convergents = Convergents(sqrt2_cf)
print("√2连分数收敛项:")
for i, conv in enumerate(sqrt2_convergents):
print(f"第{i+1}项收敛: {conv} ≈ {float(conv):.10f} (误差: {abs(float(conv)-1.41421356237):.2e})")
#√2连分数收敛项:
#第1项收敛: 1 ≈ 1.0000000000 (误差: 4.14e-01)
#第2项收敛: 3/2 ≈ 1.5000000000 (误差: 8.58e-02)
#第3项收敛: 7/5 ≈ 1.4000000000 (误差: 1.42e-02)
#第4项收敛: 17/12 ≈ 1.4166666667 (误差: 2.45e-03)
#第5项收敛: 41/29 ≈ 1.4137931034 (误差: 4.20e-04)
#第6项收敛: 99/70 ≈ 1.4142857143 (误差: 7.22e-05)
#第7项收敛: 239/169 ≈ 1.4142011834 (误差: 1.24e-05)
#第8项收敛: 577/408 ≈ 1.4142156863 (误差: 2.12e-06)
#第9项收敛: 1393/985 ≈ 1.4142131980 (误差: 3.64e-07)
#第10项收敛: 3363/2378 ≈ 1.4142136249 (误差: 6.25e-08)
# 可以看到收敛项逐渐接近√2 ≈ 1.41421356237
示例4：有理数的最佳近似
连分数收敛项提供了有理数的最佳近似
例如，我们想找到接近0.618（黄金比例的倒数）的有理数
target = 0.6180339887
cf_approx = [0, 1, 1, 1, 1, 1, 1, 1, 1, 1] # 黄金比例倒数的连分数展开
approx_convergents = Convergents(cf_approx)
print("黄金比例倒数(≈0.618)的连分数近似:")
for i, conv in enumerate(approx_convergents):
print(f"第{i+1}项收敛: {conv} ≈ {float(conv):.10f} (误差: {abs(float(conv)-target):.2e})")
#黄金比例倒数(≈0.618)的连分数近似:
#第1项收敛: 0 ≈ 0.0000000000 (误差: 6.18e-01)
#第2项收敛: 1 ≈ 1.0000000000 (误差: 3.82e-01)
#第3项收敛: 1/2 ≈ 0.5000000000 (误差: 1.18e-01)
#第4项收敛: 2/3 ≈ 0.6666666667 (误差: 4.86e-02)
#第5项收敛: 3/5 ≈ 0.6000000000 (误差: 1.80e-02)
#第6项收敛: 5/8 ≈ 0.6250000000 (误差: 6.97e-03)
#第7项收敛: 8/13 ≈ 0.6153846154 (误差: 2.65e-03)
#第8项收敛: 13/21 ≈ 0.6190476190 (误差: 1.01e-03)
#第9项收敛: 21/34 ≈ 0.6176470588 (误差: 3.87e-04)
#第10项收敛: 34/55 ≈ 0.6181818182 (误差: 1.48e-04)
# 可以看到收敛项提供了越来越好的有理数近似
示例5：音乐理论中的应用（使用精确的有理数表示）
在音乐理论中，纯五度的频率比是3:2，这是一个精确的有理数
perfect_fifth_cf = [1, 1, 2] # 3/2 = 1 + 1/(1 + 1/2)
fifth_convergents = Convergents(perfect_fifth_cf)
print("纯五度音程(3/2)的连分数表示:")
for i, conv in enumerate(fifth_convergents):
print(f"第{i + 1}项收敛: {conv}")
#纯五度音程(3/2)的连分数表示:
#第1项收敛: 1
#第2项收敛: 2
#第3项收敛: 5/3
# 结果是 [1, 3/2]，说明3/2本身就是一个收敛项
示例6：日历系统中的应用（使用精确的有理数表示）
"十九年七闰"规则对应的比例是7/19
lunar_ratio_cf = [0, 2, 1, 2] # 7/19 = 0 + 1/(2 + 1/(1 + 1/2))
lunar_convergents = Convergents(lunar_ratio_cf)
print("农历年与太阳年比例(7/19)的连分数表示:")
for i, conv in enumerate(lunar_convergents):
print(f"第{i + 1}项收敛: {conv}")
#农历年与太阳年比例(7/19)的连分数表示:
#第1项收敛: 0
#第2项收敛: 1/2
#第3项收敛: 1/3
#第4项收敛: 3/8
# 结果是 [0, 1/2, 1/3, 7/19]，说明7/19是一个收敛项
示例7：工程应用 - 齿轮比设计
假设我们需要设计一个齿轮系统，实现1:2.718的传动比（接近自然常数e）
使用连分数找到最佳有理数近似
e_approx_cf = [2, 1, 2, 1, 1, 4, 1, 1, 6, 1] # e的连分数近似
e_convergents = Convergents(e_approx_cf)
print("自然常数e(≈2.718)的连分数近似:")
for i, conv in enumerate(e_convergents):
print(f"第{i + 1}项收敛: {conv} ≈ {float(conv):.6f}")
#自然常数e(≈2.718)的连分数近似:
#第1项收敛: 2 ≈ 2.000000
#第2项收敛: 3 ≈ 3.000000
#第3项收敛: 8/3 ≈ 2.666667
#第4项收敛: 11/4 ≈ 2.750000
#第5项收敛: 19/7 ≈ 2.714286
#第6项收敛: 87/32 ≈ 2.718750
#第7项收敛: 106/39 ≈ 2.717949
#第8项收敛: 193/71 ≈ 2.718310
#第9项收敛: 1264/465 ≈ 2.718280
#第10项收敛: 1457/536 ≈ 2.718284
# 可以看到19/7≈2.714是一个不错的近似，适合设计7齿和19齿的齿轮
示例8：金融计算 - 利率转换
假设年利率为12%，转换为月利率的最佳有理数近似
monthly_rate_cf = [0, 8, 3, 3] # 1/12 = 0 + 1/(8 + 1/(3 + 1/3))
monthly_convergents = Convergents(monthly_rate_cf)
print("月利率(1/12)的连分数表示:")
for i, conv in enumerate(monthly_convergents):
print(f"第{i + 1}项收敛: {conv}")
#月利率(1/12)的连分数表示:
#第1项收敛: 0
#第2项收敛: 1/8
#第3项收敛: 3/25
#第4项收敛: 10/83
# 结果是 [0, 1/8, 3/25, 10/83]，这些都可以作为月利率的近似
连分数收敛项的实际意义：
提供实数的最佳有理数近似
在工程设计中帮助选择最合适的比例（如齿轮比）
在金融计算中提供精确的利率转换
在音乐理论中找到和谐的音程比例
在日历系统中确定闰月周期
这些示例展示了连分数收敛项不仅仅是数学概念，而是在多个领域都有实际应用的强大工具。
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
from sympy.ntheory.continued_fraction import continued_fraction, continued_fraction_convergents
import sympy as sp
def continued_fraction_from_a(input_str):
"""
处理输入的连分数系数，生成其收敛项列表。
参数：
input_str (str): 表示连分数系数列表的字符串，例如 "[1, 2, 3]" 或 "(1, 2, 3)"。
返回：
list or str: 收敛项列表（每个元素为 sympy.Rational 类型），或错误信息字符串。
"""
try:
# 将输入字符串转换为 SymPy 表达式
expr = sp.sympify(input_str)
result = None
error = False
# 根据输入类型处理连分数系数
if isinstance(expr, (tuple, list)):
# 转换元组或列表为系数列表
coeffs = list(expr)
# 生成收敛项的迭代器
convergents = continued_fraction_convergents(coeffs)
# 将迭代器转换为列表并直接存储 Rational 对象
result = list(convergents)
else:
error = True
if error:
return f"输入错误: 输入必须是列表或元组形式的系数，但得到 {input_str}"
else:
return result
except Exception as e:
return f"错误: {e}"
def main():
"""主函数，示例用法"""
# 示例1：列表形式的连分数系数
input_str1 = "[1, 2, 3]"
print(f"输入: {input_str1}")
print("收敛项:", continued_fraction_from_a(input_str1))
# 收敛项: [1, 3/2, 10/7]
# 示例2：元组形式的连分数系数
input_str2 = "(1, 2, 3)"
print(f"\n输入: {input_str2}")
print("收敛项:", continued_fraction_from_a(input_str2))
# 收敛项: [1, 3/2, 10/7]
# 示例3：无效输入（非整数系数）
input_str3 = "[1, 2.5, 3]"
print(f"\n输入: {input_str3}")
print("结果:", continued_fraction_from_a(input_str3))
# 结果: [1, 1.40000000000000, 1.35294117647059]
if __name__ == "__main__":
main()
以弧度为单位的参量的余弦.
Y = cos(X)返回X的每个元素的余弦.cos函数按元素处理数组.该函数同时接受实数和复数输入.
对于X的实数值,cos(X)返回区间[-1, 1]内的实数值.
对于X的复数值,cos(X)返回复数值.
X是标量，向量，数组，矩阵，多维数组
示例1：基本数值计算
inputs = [0, @pi/3, @pi/2, @pi, 2@pi]
for inp in inputs:
result = cos(inp)
print(f"cos({inp}) = {result}")
#cos(0) = 1.0
#cos(sp.pi/3) = 0.5
#cos(sp.pi/2) = 6.12323399573677e-17
#cos(sp.pi) = -1.0
#cos(2*sp.pi) = 1.0
示例2：复数计算
complex_inputs = [1+2@i, 3-4@i, -2+1@i]
for inp in complex_inputs:
result = cos(inp)
print(f"cos({inp}) = {result}")
#cos(1+2@i) = 2.0327230070196656-3.0518977991518i
#cos(3-4@i) = -27.034945603074224+3.851153334811777i
#cos(-2+1@i) = -0.64214812471552+1.0686074213827783i
示例3：矩阵计算（信号处理应用）
模拟一个信号采样序列（时间点）
time_points = [0, @pi/4, @pi/2, 3@pi/4, @pi]
result = cos(time_points)
print(f"余弦值: {result}")
#余弦值: [1.0,0.707106781186548,6.12323399573677e-17,-0.707106781186547,-1.0]
# 这在信号处理和傅里叶分析中很常见
示例4：符号计算（物理学中的简谐运动）
简谐运动方程: x(t) = A*cos(ωt + φ) # 其中A是振幅，ω是角频率，φ是初相位
harmonic_motion = A*cos(ω*t + φ)
计算特定时间的位移
specific_time = harmonic_motion.replace('t', '0')
result = cos(specific_time)
print(f"t=0时的位移: {result}")
#t=0时的位移: cos(A*cos(φ))
示例5：矩阵计算（图像处理中的余弦变换）
模拟一个小图像块的像素强度（离散余弦变换的基础）
image_block = [[100, 150, 100, 150],
[150, 200, 150, 200],
[100, 150, 100, 150],
[150, 200, 150, 200]]
result = cos(image_block)
print(f"余弦变换后的值:\n{result}")
#余弦变换后的值:
#[[0.862318872287684, 0.699250806478375, 0.862318872287684, 0.699250806478375],
[0.699250806478375, 0.487187675007006, 0.699250806478375, 0.487187675007006],
[0.862318872287684, 0.699250806478375, 0.862318872287684, 0.699250806478375],
[0.699250806478375, 0.487187675007006, 0.699250806478375, 0.487187675007006]]
# 离散余弦变换是JPEG图像压缩的基础
示例6：工程应用（机械振动分析）
在机械工程中，余弦函数用于描述振动系统的响应
例如，弹簧-质量系统的位移响应
displacement = 0.1*cos(10*t) # 振幅0.1m，角频率10rad/s
print(f"振动位移: x(t) = {displacement}")
#振动位移: x(t) = 0.1*cos(10*t)
计算特定时间的位移
for time in [0, 0.1, 0.2, 0.3]:
specific_displacement = displacement.replace('t', str(time))
result = cos(specific_displacement)
print(f"t={time}s时的位移: {result} m")
#t=0s时的位移: 0.9950041652780258 m
#t=0.1s时的位移: 0.9985407221448545 m
#t=0.2s时的位移: 0.9991342340061347 m
#t=0.3s时的位移: 0.995103575338085 m
示例7：计算机图形学中的旋转
在2D旋转中，点的坐标变换使用余弦和正弦函数
旋转矩阵: [[cosθ, -sinθ], [sinθ, cosθ]]
rotation_matrix = [[cos(θ), -sin(θ)], [sin(θ), cos(θ)]]
计算特定角度的旋转矩阵
for angle in [0, sp.pi/4, sp.pi/2]:
specific_matrix = rotation_matrix.replace('θ', str(angle))
result = cos(specific_matrix)
print(f"θ={angle}时的旋转矩阵:\n{result}")
#θ=0时的旋转矩阵: [[0.54030230586814, 1.0],
[1.0, 0.54030230586814]]
#θ=pi/4时的旋转矩阵: [[0.76024459707563, 0.76024459707563],
[0.76024459707563, 0.76024459707563]]
#θ=pi/2时的旋转矩阵: [[1.0, 0.54030230586814],
[0.54030230586814, 1.0]]
示例8：电气工程应用（交流电路分析）
交流电压可以表示为余弦函数: V(t) = V_m*cos(ωt + φ)
V_m, ω, φ = 120, 2*sp.pi*60, 0 # 120V, 60Hz
ac_voltage = V_m*cos(ω*t + φ)
print(f"交流电压: V(t) = {ac_voltage}")
#交流电压: V(t) = 120*cos(120*pi*t + 0)
计算特定时间的电压
for time in [0, 1/240, 1/120]: # 0s, 1/240s, 1/120s
specific_voltage = ac_voltage.replace('t', str(time))
result = cos(specific_voltage)
print(f"t={time}s时的电压: {result} V")
#t=0s时的电压: 0.8141809705265618 V
#t=0.004166666666666667s时的电压: 1 V
#t=0.008333333333333333s时的电压: 0.8141809705265618 V
示例9：统计学应用（余弦相似度）
余弦相似度用于衡量两个向量的方向相似性
公式: cosθ = (A·B) / (||A|| * ||B||)
vector_A = [1, 2, 3]
vector_B = [4, 5, 6]
#虽然这不是直接计算余弦，但展示了余弦在相似度计算中的应用
这些示例展示了余弦函数在不同领域的实际应用：
信号处理：分析和处理周期性信号
物理学：描述简谐运动和其他周期性现象
图像处理：离散余弦变换用于图像压缩
机械工程：分析振动系统的响应
计算机图形学：实现2D和3D旋转
电气工程：分析交流电路
统计学：计算向量间的余弦相似度
余弦函数的实际意义：
描述周期性现象和波动
在傅里叶分析中作为基函数
用于坐标变换和旋转操作
在信号处理和图像压缩中起核心作用
描述交流电的电压和电流变化
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def cosine_trig_function(input_str):
"""
计算输入表达式或矩阵的余弦值。
参数:
input_str: 输入的字符串，可以是数值、符号表达式或矩阵。
返回:
计算结果（数值、符号表达式或矩阵），若输入不合法则返回错误信息。
"""
try:
# 将输入字符串转换为 SymPy 表达式
expr = sp.sympify(input_str)
error = False
result = None
# 处理数值或符号表达式
if expr.free_symbols:
# 计算余弦并数值化（若为符号表达式则保留符号形式）
result = sp.cos(expr)
elif expr.is_number:
z = complex(expr)
result = np.cos(z)
# 其他未知类型标记为错误
else:
error = True
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {e}"
if __name__ == "__main__":
# 示例1：数值输入（π）
input1 = "2"
print(f"输入：{input1}")
print("输出：", cosine_trig_function(input1)) # 应输出 -1.0
# 输出： (-0.4161468365471424-0j)
# 示例2：符号输入（x）
input2 = "x"
print(f"\n输入：{input2}")
print("输出：", cosine_trig_function(input2)) # 应输出 cos(x)
# 输出： cos(x)
以度为单位的参量的余弦.
Y = cosd(X)返回X的每个元素的余弦.cosd该函数同时接受实数和复数输入.
X是标量，向量，数组，矩阵, 多维数组
示例1：基本角度计算
common_angles = [0, 30, 45, 60, 90, 180, 270, 360]
for angle in common_angles:
result = cosd(angle)
print(f"cos({angle}°) = {result}")
#cos(0°) = 1
#cos(30°) = 0.8660254037844387
#cos(45°) = 0.7071067811865476
#cos(60°) = 0.5000000000000001
#cos(90°) = 6.123233995736766e-17
#cos(180°) = -1
#cos(270°) = -1.8369701987210297e-16
#cos(360°) = 1
示例2：矩阵计算 - 批量角度处理
在工程计算中，经常需要批量处理多个角度
angle_matrix = [[0, 30, 45], [60, 90, 120], [135, 150, 180]]
result = cosd(angle_matrix)
print(f"余弦值矩阵:\n{result}")
#余弦值矩阵: [[1.0, 0.866025403784439, 0.707106781186548],
[0.5, 6.12323399573677e-17, -0.5],
[-0.707106781186547, -0.866025403784439, -1.0]]
# 这在结构分析、信号处理等领域很常见
示例3：符号计算 - 通用公式
在物理学和工程学中，经常需要推导通用公式
general_formula = cosd(θ)
print(f"通用公式: {general_formula} = {result}")
#通用公式: cosd(θ) = cos(pi*cosd(θ)/180)
# 结果为cos(π*θ/180)，保留了符号形式
示例4：计算机图形学 - 3D旋转
在3D图形学中，旋转通常使用欧拉角表示
绕X轴旋转的矩阵包含cos(θ)项
rotation_x_matrix = [[1, 0, 0],
[0, cosd(θ), -sind(θ)],
[0, sind(θ), cosd(θ)]]
print(f"绕X轴旋转矩阵:\n{rotation_x_matrix}")
#绕X轴旋转矩阵:[[1, 0, 0],
[0, cosd(θ), -sind(θ)],
[0, sind(θ), cosd(θ)]]
# 虽然这里不能直接计算符号矩阵，但展示了cosd在3D旋转中的应用
示例5：地理学应用 - 地球纬度效应
在地球科学中，余弦函数用于计算纬度对日照的影响
日照强度 ∝ cos(纬度)
latitudes = [0, 30, 45, 60, 90] # 不同纬度
print("不同纬度的相对日照强度:")
for lat in latitudes:
intensity = cosd(str(lat))
print(f"纬度{lat}°: cos({lat}°) = {intensity}")
#不同纬度的相对日照强度:
#纬度0°: cos(0°) = 1
#纬度30°: cos(30°) = 0.8660254037844387
#纬度45°: cos(45°) = 0.7071067811865476
#纬度60°: cos(60°) = 0.5000000000000001
#纬度90°: cos(90°) = 6.123233995736766e-17
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def cosd_cosine_degree(input_str):
"""
计算角度（度数）的余弦值，支持矩阵和符号计算
参数:
input_str: 输入字符串，可以是：
- 数值（如 "30"）
- 符号表达式（如 "x"）
- 矩阵（如 "[[30, 60], [0, 90]]"）
返回:
计算结果（数值/符号/矩阵）或错误信息
"""
try:
expr = sp.sympify(input_str)
error = False
result = None
# 数值/符号处理分支
if expr.free_symbols:
result = sp.cos(expr * sp.pi / 180)
elif expr.is_number:
z = complex(expr)
result = np.cos(z * np.pi / 180)
# 未知类型标记为错误
else:
error = True
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {e}"
if __name__ == "__main__":
# 示例1：基本数值计算
print("示例1:", cosd_cosine_degree("30"))
# (0.8660254037844387-0j)
# 示例2：符号运算
print("\n示例3:", cosd_cosine_degree("x"))
# cos(pi*x/180)
双曲余弦函数.
Y = cosh(X)返回X的每个元素的双曲余弦.cosh该函数同时接受实数和复数输入,所有的角度都以弧度表示.
X是标量，向量，数组，矩阵，多维数组
示例1：基本数值计算
test_values = [0, 1, 2, 3]
for val in test_values:
result = cosh(val)
print(f"cosh({val}) = {result}")
#cosh(0) = 1.00000000000000
#cosh(1) = 1.54308063481524
#cosh(2) = 3.76219569108363
#cosh(3) = 10.0676619957778
示例2：复数计算
complex_values = [1+2@i, 3-4@i, -2+1@i]
for val in complex_values:
result = cosh(val)
print(f"cosh({val}) = {result}")
#cosh(1+2j) = -0.64214812471552 + 1.06860742138278*I
#cosh(3-4j) = -6.58066304055116 + 7.58155274274654*I
#cosh(-2+1j) = 2.03272300701967 - 3.0518977991518*I
示例3：悬链线问题（物理学应用）
悬链线方程: y = a * cosh(x/a)
其中a是参数，与链的密度和张力有关
a = 10 # 参数a
x_values = [-5, -2.5, 0, 2.5, 5] # x坐标
print(f"悬链线参数a = {a}, x坐标: {x_values}")
#悬链线参数a = 10, x坐标: [-5, -2.5, 0, 2.5, 5]
catenary_y = a * cosh(x/a)
计算特定x值的y坐标
for x_val in [-5, -2.5, 0, 2.5, 5]:
specific_y = catenary_y.replace('x', str(x_val))
result = cosh(specific_y)
print(f"x={x_val}: y = {a} * cosh({x_val}/{a}) = {result}")
#x=-5: y = 10 * cosh(-5/10) = 39462.7501456147
#x=-2.5: y = 10 * cosh(-2.5/10) = 15077.8765503424
#x=0: y = 10 * cosh(0/10) = 11013.2329201033
#x=2.5: y = 10 * cosh(2.5/10) = 15077.8765503424
#x=5: y = 10 * cosh(5/10) = 39462.7501456147
示例4：特殊相对论（物理学应用）
在特殊相对论中，双曲函数用于描述洛伦兹变换
速度v与光速c的比值β = v/c
双曲余弦cosh(θ) = 1/√(1-β²) = γ (洛伦兹因子)
β = 0.8 # v = 0.8c
θ = sp.acosh(1/sp.sqrt(1-β**2)) # 快度
print(f"相对速度β = v/c = {β}")
print(f"快度θ = acosh(1/√(1-β²)) = {θ.evalf()}")
#相对速度β = v/c = 0.8
#快度θ = acosh(1/√(1-β²)) = 1.09861228866811
result = cosh(str(θ))
print(f"洛伦兹因子γ = cosh(θ) = {result}")
#洛伦兹因子γ = cosh(θ) = 1.66666666666667
# 验证: γ应该等于1/√(1-β²) ≈ 1.6667
示例5：热传导方程（工程应用）
在某些边界条件下，热传导方程的解包含双曲余弦函数
例如，一维稳态热传导: T(x) = T₀ + (T₁ - T₀) * cosh(αx)/cosh(αL)
T0, T1 = 20, 100 # 边界温度(°C)
α, L = 0.5, 10 # 参数和长度
x = 5 # 位置
temp_profile = T0 + (T1-T0) * cosh(α*x) / cosh(α*L)"
result = cosh(temp_profile)
print(f"边界温度: T(0)={T0}°C, T(L)={T1}°C")
print(f"参数α={α}, 长度L={L}, 位置x={x}")
print(f"温度分布: T(x) = {temp_profile} = {result}°C")
#边界温度: T(0)=20°C, T(L)=100°C
#参数α=0.5, 长度L=10, 位置x=5
#温度分布: T(x) = 20 + (100-20) * cosh(0.5*5) / cosh(0.5*10) = 180247966507.575°C
示例6：矩阵计算（数值分析应用）
在数值分析中，经常需要计算矩阵的双曲函数
matrix_input = [[1, 2], [3, 4]]
result = cosh(matrix_input)
print(f"矩阵双曲余弦:\n{result}")
#矩阵双曲余弦: [[1.54308063481524, 3.76219569108363],
[10.0676619957778, 27.3082328360165]]
# 矩阵双曲余弦在线性系统和微分方程中有应用
示例7：符号计算与恒等式验证（数学推导）
验证双曲余弦的基本恒等式: cosh²(x) - sinh²(x) = 1
identity = cosh(x)**2 - sinh(x)**2
print(f"验证恒等式: {identity} = 1")
#验证恒等式: cosh(x)**2 - sinh(x)**2 = 1
更合适的方式是使用符号计算
cosh_x = sp.cosh(x)
sinh_x = sp.sinh(x)
identity_result = sp.simplify(cosh_x**2 - sinh_x**2)
print(f"符号计算验证: cosh²(x) - sinh²(x) = {identity_result}")
#符号计算验证: cosh²(x) - sinh²(x) = 1
示例8：电缆工程应用(电缆下垂计算)
电缆下垂公式: s = a * cosh(x/a) - a # 其中s是下垂量，a是参数，x是水平距离
a = 50 # 参数
x_values = [0, 10, 20, 30, 40, 50] # 水平距离
print(f"电缆参数a = {a}")
print("不同水平距离x的下垂量s:")
for x in x_values:
sag = f"{a} * cosh({x}/{a}) - {a}"
result = cosh(sag)
print(f"x={x}: s = {a} * cosh({x}/{a}) - {a} = {result}")
#电缆参数a = 50
#不同水平距离x的下垂量s:
#x=0: s = 50 * cosh(0/50) - 50 = 1.00000000000000
#x=10: s = 50 * cosh(10/50) - 50 = 1.54701180182990
#x=20: s = 50 * cosh(20/50) - 50 = 28.8114453523954
#x=30: s = 50 * cosh(30/50) - 50 = 5324.71112548548
#x=40: s = 50 * cosh(40/50) - 50 = 10623723.6094406
#x=50: s = 50 * cosh(50/50) - 50 = 310324561776.046
示例9：金融数学应用
在某些金融模型中，双曲函数用于描述效用函数或价格动态
例如，双曲绝对风险厌恶(HARA)效用函数
wealth = 100 # 财富值
α, γ = 2, 0.5 # 参数
简化的HARA效用函数形式
hara_utility = α * cosh(γ * wealth)
print(f"财富值: {wealth}")
print(f"HARA效用函数参数: α={α}, γ={γ}")
#财富值: 100
#HARA效用函数参数: α=2, γ=0.5
result = cosh(hara_utility)
print(f"近似效用值: U ≈ {result}")
#近似效用值: U ≈ oo
示例10：信号处理应用
在某些信号处理应用中，双曲函数用于设计滤波器
例如，双曲余弦滤波器的频率响应
frequencies = [0.1, 0.5, 1.0, 2.0, 5.0] # 归一化频率
简化的双曲余弦滤波器响应
filter_response = cosh(1/f) # f是频率
计算不同频率的响应
for f in [0.1, 0.5, 1.0, 2.0, 5.0]:
response = filter_response.replace('f', str(f))
result = cosh(response)
print(f"频率f={f}: 响应 = cosh(1/{f}) = {result}")
#频率f=0.1: 响应 = cosh(1/0.1) = oo
#频率f=0.5: 响应 = cosh(1/0.5) = 21.5330318657841
#频率f=1.0: 响应 = cosh(1/1.0) = 2.44635200744916
#频率f=2.0: 响应 = cosh(1/2.0) = 1.70605854012824
#频率f=5.0: 响应 = cosh(1/5.0) = 1.56697538285744
这些示例展示了双曲余弦函数在不同领域的实际应用：
物理学：
悬链线问题：描述悬挂链或电缆的形状
特殊相对论：洛伦兹变换和快度概念
工程学：
热传导方程：描述温度分布
电缆工程：计算电缆下垂量
数学：
恒等式验证：双曲函数的基本关系
矩阵函数：数值分析和线性系统
金融数学：
效用函数：描述风险偏好
信号处理：
滤波器设计：频率响应特性
双曲余弦函数的实际意义：
描述悬链线等自然现象的形状
在相对论中描述时空变换
解决某些类型的微分方程
在工程中建模物理系统
在金融中描述风险偏好和效用
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def cosh_hyperbolic_cosine(input_str):
"""
计算输入表达式的双曲余弦值，支持矩阵、数值和符号表达式。
参数:
input_str: 输入的字符串表达式，可以是矩阵、数值或符号表达式。
返回:
计算结果。如果输入为矩阵，返回对应元素的cosh矩阵；如果输入为数值或符号，返回cosh值。
如果输入无法解析或处理，返回错误信息字符串。
"""
try:
# 将输入字符串转换为SymPy表达式
expr = sp.sympify(input_str)
error = False
result = None
# 处理数值或符号表达式
if expr.free_symbols:
result = sp.cosh(expr)
elif expr.is_number:
z = complex(expr)
result = np.cosh(z)
# 其他情况视为错误
else:
error = True
# 根据错误标志返回结果或错误信息
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于测试cosh_hyperbolic_cosine函数的各种用例。
"""
test_cases = [
"3",
# (10.067661995777765+0j)
"3+2j",
# (-4.189625690968807+9.109227893755337j)
"x",
# cosh(x)
"cosh(0)",
# (1.5430806348152437+0j)
]
for case in test_cases:
print(f"测试输入: {case}")
result = cosh_hyperbolic_cosine(case)
print("返回结果:")
# 统一处理结果的打印格式
if isinstance(result, sp.Matrix):
sp.pprint(result)
else:
print(f"{result}\n")
print("-" * 50)
if __name__ == "__main__":
main()
双曲余弦积分
如果x是浮点数，则Chi(x)返回浮点结果.
Y = Chi(x)返回算术表达式
x是标量,符号变量,表达式,向量,矩阵,多维数组
示例1：基本数值计算
test_values = [0.1, 1, 2, 5, 10]
for val in test_values:
result = coshint(val)
print(f"Chi({val}) = {result}")
#Chi(0.1) = -1.72286838619433
#Chi(1) = 0.837866940980208
#Chi(2) = 2.45266692264692
#Chi(5) = 20.0920635301059
#Chi(10) = 1246.11448604245
示例2：复数计算
complex_values = [1+1@i, 2-3@i, -1+2@i]
for val in complex_values:
result = coshint(val)
print(f"Chi({val}) = {result}")
#Chi(1+1j) = 0.882172180555936 + 1.28354719327494i
#Chi(2-3j) = -0.168362868327721 - 2.62511588045132i
#Chi(-1+2j) = 0.584475996878248 + 1.27330114915676i
示例3：电磁学应用 - 天线理论
在电磁学中，双曲余弦积分用于计算某些天线的辐射模式
例如，直线天线的辐射场计算
k = 2@pi # 波数
L = 0.5 # 天线长度（波长的一半）
θ = 45 # 观察角度（度）
简化的辐射场表达式（实际公式更复杂）
radiation_field = Chi(k*L*cos(θ*pi/180))
print(f"波数k = {k}, 天线长度L = {L}λ, 观察角度θ = {θ}°")
#波数k = 6.283185307179586, 天线长度L = 0.5λ, 观察角度θ = 45°
result = coshint(radiation_field)
print(f"辐射场表达式: {radiation_field} = {result}")
#辐射场表达式: Chi(6.283185307179586*0.5*cos(45*pi/180)) = 4.61202800482474
示例4：热传导问题
在某些热传导问题中，双曲余弦积分出现在解的表达式中
例如，半无限大物体表面受热问题
α = 1e-5 # 热扩散系数 (m²/s)
t = 3600 # 时间 (s)
x = 0.1 # 深度 (m)
温度分布的简化表达式
temp_profile = Chi(x/sqrt(4*α*t))
print(f"热扩散系数α = {α} m²/s, 时间t = {t} s, 深度x = {x} m")
#热扩散系数α = 1e-05 m²/s, 时间t = 3600 s, 深度x = 0.1 m
result = coshint(temp_profile)
print(f"温度分布表达式: {temp_profile} = {result}")
#温度分布表达式: Chi(0.1/sqrt(4*1e-05*3600)) = 0.414410697614983 + 3.14159265358979i
示例5：量子力学中的势垒穿透
在量子力学中，双曲余弦积分出现在某些势垒穿透问题的解中
例如，一维势垒的透射系数计算
V = 10 # 势垒高度 (eV)
E = 5 # 粒子能量 (eV)
a = 0.1 # 势垒宽度 (nm)
简化的透射系数表达式
transmission = Chi(sqrt(2*m*(V-E))*a/ħ)
print(f"势垒高度V = {V} eV, 粒子能量E = {E} eV, 势垒宽度a = {a} nm")
print(f"透射系数表达式: {transmission}")
#势垒高度V = 10 eV, 粒子能量E = 5 eV, 势垒宽度a = 0.1 nm
#透射系数表达式: Chi(sqrt(2*m*(10-5))*0.1/ħ)
# 注意：这里使用了符号表达式，实际计算需要代入具体数值
示例6：矩阵计算（批量计算双曲余弦积分）
在科学计算中，经常需要批量计算多个点的双曲余弦积分值
x_values = [[0.1, 0.5, 1.0], [2.0, 5.0, 10.0]]
result = coshint(x_values)
print(f"双曲余弦积分矩阵:\n{result}")
#双曲余弦积分矩阵:
#[[-1.72286838619433, -0.0527768449564936, 0.837866940980208],
[2.45266692264692, 20.0920635301059, 1246.11448604245]]
示例7：符号计算与渐近行为
研究双曲余弦积分在 x→∞ 时的渐近行为
asymptotic_form = coshint(x)
print(f"双曲余弦积分的符号表达式: {asymptotic_form}")
#双曲余弦积分的符号表达式: Chi(x)
# 对于大x，Chi(x) ~ (e^x)/(2x) * (1 + 1/x + 2/x² + ...)
示例8：声学中的指向性函数
在声学中，某些换能器的指向性函数包含双曲余弦积分
k = 2 * @pi # 波数
a = 0.2 # 换能器半径 (m)
θ = 30 # 观察角度 (度)
简化的指向性函数表达式
directivity = Chi(k*a*sin(θ*pi/180))
print(f"波数k = {k}, 换能器半径a = {a} m, 观察角度θ = {θ}°")
#波数k = 6.283185307179586, 换能器半径a = 0.2 m, 观察角度θ = 30°
result = coshint(directivity)
print(f"指向性函数表达式: {directivity} = {result}")
#指向性函数表达式: Chi(6.283185307179586*0.2*sin(30*pi/180)) = -0.958645151334000
示例9：与其他特殊函数的关系
双曲余弦积分与指数积分Ei(x)的关系: Chi(x) = (Ei(x) + Ei(-x))/2
x_val = 2.5
验证这个关系
Chi_val = coshint(x_val)
Ei_val = expi(x_val) # 指数积分Ei(x)
Ei_neg_val = expi(-x_val) # Ei(-x)
relation_val = (Ei_val + Ei_neg_val) / 2
print(f"验证关系: Chi({x_val}) = (Ei({x_val}) + Ei(-{x_val}))/2")
print(f"Chi({x_val}) = {Chi_val}")
print(f"(Ei({x_val}) + Ei(-{x_val}))/2 = {relation_val}")
print(f"关系验证: {abs(Chi_val - relation_val) < 1e-10}")
#验证关系: Chi(2.5) = (Ei(2.5) + Ei(-2.5))/2
#Chi(2.5) = 3.52442548835417
#(Ei(2.5) + Ei(-2.5))/2 = 3.524425488354167
#关系验证: True
示例10：工程数学应用(积分方程求解)
在某些积分方程中，双曲余弦积分作为核函数出现
例如，形式为 ∫[0,∞] cosh(xt) f(t) dt = g(x) 的积分方程解可能包含双曲余弦积分。
双曲余弦积分在实际应用中的重要性：
提供了一种处理包含双曲余弦函数的积分的方法
在物理问题的解析解中经常出现
有助于理解和建模各种波动现象
在工程计算中提供精确的数值结果
这些示例展示了双曲余弦积分不仅仅是抽象的数学概念，而是在多个科学和工程领域都有实际应用的强大工具。
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
from sympy.functions.special.error_functions import Chi
from scipy.special import shichi
def chi_hyper_cosine_integral(input_str):
"""
计算输入的双曲余弦积分Chi(x)，支持矩阵、数值和符号表达式
参数:
input_str: 输入的字符串表达式，可以是矩阵、数值或符号表达式
返回:
计算结果。如果输入为矩阵，返回对应元素的Chi积分矩阵；
如果输入为数值或符号，返回Chi积分值。
无法处理时返回错误信息字符串
"""
try:
# 表达式转换
expr = sp.sympify(input_str)
error = False
result = None
# 处理标量数值和符号表达式
if expr.free_symbols:
result = Chi(expr)
elif expr.is_number:
z = complex(expr)
Shi_, Chi_ = shichi(z) # 解包返回值
result = Chi_
else:
error = True
return result if not error else f"输入错误: {input_str}"
except sp.SympifyError as e:
return f"表达式解析错误: {e}"
except Exception as e:
return f"运行时错误: {str(e)}"
def main():
"""
主函数测试用例
"""
test_cases = [
"0",
# (-inf+nan*j)
"2+2j",
# (0.9629226258960547+2.6677809260012038j)
"x",
# Chi(x)
"Chi(0)",
# (nan+nan*j)
"3.14"
# (5.452860589178992+0j)
]
for case in test_cases:
print(f"测试输入: {case}")
result = chi_hyper_cosine_integral(case)
print("返回结果:")
# 统一输出格式
if isinstance(result, sp.Matrix):
sp.pprint(result)
elif isinstance(result, sp.Expr):
print(sp.pretty(result))
else:
print(result)
print("-" * 50)
if __name__ == "__main__":
main()
准确计算cos(x*pi).
Y = cospi(X).该函数同时接受实数和复数输入.
X是标量，向量，数组，矩阵，多维数组
对于奇数,cospi(n/2) 正好为零.
对于整数,cospi(n) 为+1或-1
示例1：基本数值计算
test_values = [0, 0.25, 0.5, 0.75, 1, 1.5, 2]
for val in test_values:
result = cospi(val)
print(f"cos(π * {val}) = {result}")
#cos(π * 0) = 1.00000000000000
#cos(π * 0.25) = 0.707106781186548
#cos(π * 0.5) = 6.12323399573677E-17
#cos(π * 0.75) = -0.707106781186547
#cos(π * 1) = -1.00000000000000
#cos(π * 1.5) = -1.83697019872103E-16
#cos(π * 2) = 1.00000000000000
示例2：复数计算
complex_values = [1+1@i, 2-3@i, -1+2@i]
for val in complex_values:
result = cospi(val)
print(f"cos(π * {val}) = {result}")
#cos(π * 1+1j) = -11.5919532755215 - 1.41431266880528e-15i
#cos(π * 2-3j) = 6195.82394430811 - 1.51753917252981e-12i
#cos(π * -1+2j) = -267.746761483748 + 3.27892927475378e-14i
示例3：信号处理应用 - 数字滤波器设计
在数字信号处理中，cos(π * x) 常用于设计滤波器
例如，低通滤波器的频率响应可能包含 cos(π * f/fs) 项
f = 1000 # 频率 (Hz)
fs = 8000 # 采样率 (Hz)
frequency_response = cos(pi * f/fs)
print(f"频率f = {f} Hz, 采样率fs = {fs} Hz")
#频率f = 1000 Hz, 采样率fs = 8000 Hz
result = cospi(f/fs)
print(f"滤波器响应: {frequency_response} = {result}")
#滤波器响应: cos(pi * 1000/8000) = 0.923879532511287
示例4：物理学应用 - 量子力学波函数
在量子力学中，无限深势阱中的粒子波函数包含 cos(π * n * x/L) 项
n = 1 # 量子数
x = 0.5 # 位置 (归一化坐标)
L = 1 # 势阱长度
wave_function = cos(pi * n * x/L)
print(f"量子数n = {n}, 位置x = {x}, 势阱长度L = {L}")
#量子数n = 1, 位置x = 0.5, 势阱长度L = 1
result = cospi(n * x/L)
print(f"波函数: {wave_function} = {result}")
#波函数: cos(pi * 1 * 0.5/1) = 6.12323399573677E-17
示例5：图像处理应用 - 离散余弦变换
在图像处理中，离散余弦变换(DCT)的基础函数包含 cos(π * (2x+1) * u/(2N)) 项
x = 0 # 像素位置
u = 1 # 频率索引
N = 8 # 块大小
dct_basis = cos(pi * (2*x+1) * u/(2*N))
print(f"像素位置x = {x}, 频率索引u = {u}, 块大小N = {N}")
#像素位置x = 0, 频率索引u = 1, 块大小N = 8
result = cospi((2*x+1) * u/(2*N))
print(f"DCT基础函数: {dct_basis} = {result}")
#DCT基础函数: cos(pi * (2*0+1) * 1/(2*8)) = 0.980785280403230
示例6：矩阵计算（批量处理）
在科学计算中，经常需要批量计算多个点的 cos(π * x) 值
x_values = [[0, 0.25, 0.5], [0.75, 1, 1.25]]
result = cospi(x_values)
print(f"cos(π * x) 矩阵:\n{result}")
#cos(π * x) 矩阵:
#[[1.0, 0.707106781186548, 6.12323399573677e-17],
[-0.707106781186547, -1.0, -0.707106781186548]]
示例7：工程应用 - 机械振动分析
在机械工程中，cos(π * x) 用于描述某些振动系统的响应
t = 0.1 # 时间 (s)
f = 5 # 频率 (Hz)
vibration = cos(pi * 2 * f * t)
print(f"时间t = {t} s, 频率f = {f} Hz")
#时间t = 0.1 s, 频率f = 5 Hz
result = cospi(2 * f * t)
print(f"振动响应: {vibration} = {result}")
#振动响应: cos(pi * 2 * 5 * 0.1) = -1
示例8：通信系统应用 - 调制信号生成
在通信系统中，cos(π * x) 用于生成调制信号
例如，二进制相移键控(BPSK)使用 cos(π * (t/T + 1/2)) 形式的波形
t_val = 0.5 # 时间
T = 1 # 符号周期
bpsk_waveform = cos(pi * (t_val/T + 1/2))
print(f"时间t = {t_val}, 符号周期T = {T}")
#时间t = 0.5, 符号周期T = 1
result = cospi(t_val/T + 1/2)
print(f"BPSK波形: {bpsk_waveform} = {result}")
#BPSK波形: cos(pi * (0.5/1 + 1/2)) = -1
示例9：数值分析应用 - 数值积分权重
在某些数值积分方法中，cos(π * x) 用作权重函数
例如，Chebyshev-Gauss积分公式使用 cos(π * k/N) 作为节点
k = 2 # 节点索引
N = 8 # 总节点数
chebyshev_node = cos(pi * k/N)
print(f"节点索引k = {k}, 总节点数N = {N}")
#节点索引k = 2, 总节点数N = 8
result = cospi(k/N)
print(f"Chebyshev节点: {chebyshev_node} = {result}")
#Chebyshev节点: cos(pi * 2/8) = 0.707106781186548
这些示例展示了 cos(π * x) 函数在不同领域的实际应用：
信号处理：
数字滤波器设计：计算频率响应
调制信号生成：生成通信系统中的波形
物理学：
量子力学：描述无限深势阱中的波函数
振动分析：计算机械系统的振动响应
图像处理：
离散余弦变换：JPEG压缩算法的基础
图像变换：各种图像处理算法的基础函数
数值分析：
数值积分：Chebyshev积分公式中的节点计算
插值方法：某些插值方案的基础函数
工程应用：
通信系统：调制和解调信号
控制系统：系统响应分析
cos(π * x) 函数的特殊性质：
周期性：cos(π * (x + 2)) = cos(π * x)
对称性：cos(π * (-x)) = cos(π * x)
零点：在 x = 1/2 + k（k为整数）处为零
极值点：在 x = k（k为整数）处取得极值 ±1
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def cos_pi_cosine(input_str):
"""
计算表达式或矩阵中每个元素的cos(pi * x)
参数:
input_str: 输入的字符串，可以是数值、符号表达式、列表或矩阵
返回:
计算结果，如果输入无效则返回错误信息字符串
"""
try:
# 将输入字符串转换为SymPy表达式
expr = sp.sympify(input_str)
error = False
result = None
# 检查输入是否为元组（不支持的类型）
if isinstance(expr, tuple):
error = True
# 处理数值或符号表达式
elif expr.is_number:
z = complex(expr)
result = np.cos(z * np.pi)
elif expr.free_symbols:
result = sp.cos(expr * sp.pi)
else:
# 其他无效类型
error = True
# 根据错误标志返回结果或错误信息
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {e}"
def main():
# 示例测试
test_cases = [
"2", # (1+0j)
"x", # cos(pi*x)
]
for case in test_cases:
print(f"输入: {case}")
result = cos_pi_cosine(case)
print("结果:")
if isinstance(result, sp.Matrix):
sp.pprint(result)
else:
print(result)
print("\n" + "-" * 50 + "\n")
if __name__ == "__main__":
main()
角的余切(以弧度为单位)
Y = cot(X) 返回 X 的各元素的余切。cot 函数按元素处理数组。该函数同时接受实数和复数输入。
对于 X 的实数值，cot(X) 返回区间 [-∞, ∞] 内的实数值。
对于 X 的复数值，cot(X) 返回复数值。
X — 输入角（以弧度为单位）标量 | 向量 | 矩阵
Y — 输入角的余切. 标量,向量,矩阵,多维数组
示例1：基本数值计算
test_values = [0, @pi/6, @pi/4, @pi/3, @pi/2, @pi/4, @pi]
print(cot(test_values))
#[nan, 1.73205080756888, 1.0, 0.577350269189626, 6.12323399573677e-17, 1.0, -8.16561967659769e+15]
示例2：复数计算
complex_values = [1+2@i, 3-4@i, -2+1@i]
for val in complex_values:
result = cot(val)
print(f"cot({val}) = {result}")
#cot(1+2j) = 0.0327977555337526 - 0.984329226458191i
#cot(3-4j) = -0.000187587737983659 + 1.00064439247156i
#cot(-2+1j) = 0.171383612909185 - 0.821329797493852i
示例3：三角形问题（几何学应用）
在直角三角形中，cot(θ) = 邻边 / 对边
opposite = 3 # 对边长度
adjacent = 4 # 邻边长度
angle_rad = sp.atan(opposite/adjacent) # 角度（弧度）
print(f"直角三角形: 对边 = {opposite}, 邻边 = {adjacent}")
print(f"角度θ = arctan({opposite}/{adjacent}) = {angle_rad.evalf()} 弧度")
#直角三角形: 对边 = 3, 邻边 = 4
#角度θ = arctan(3/4) = 0.643501108793284 弧度
result = cot(angle_rad)
print(f"cot(θ) = 邻边/对边 = {adjacent}/{opposite} = {adjacent/opposite}")
print(f"通过函数计算: cot(angle_rad) = {result}")
#cot(θ) = 邻边/对边 = 4/3 = 1.3333333333333333
#通过函数计算: cot(0.643501108793284) = 1.33333333333333
示例4：物理学应用 - 力的分解
在斜面上，重力的分力与斜面垂直，cot(θ)可以用于计算力之间的关系
theta = 30 # 斜面角度（度）
theta_rad = theta * pi / 180 # 转换为弧度
重力分解：垂直斜面的分力 = mg * cos(θ)，平行斜面的分力 = mg * sin(θ)
因此，垂直分力与平行分力的比值 = cos(θ)/sin(θ) = cot(θ)
mg = 100 # 重力（N）
parallel_force = mg * sin(theta_rad)
normal_force = mg * cos(theta_rad)
print(f"斜面角度: {theta}° = {theta_rad.evalf()} 弧度")
print(f"重力: {mg} N")
print(f"平行分力: {parallel_force.evalf()} N")
print(f"垂直分力: {normal_force.evalf()} N")
#斜面角度: 30° = 0.523598775598299 弧度
#重力: 100 N
#平行分力: 50.0000000000000 N
#垂直分力: 86.6025403784439 N
result = cot(theta_rad)
print(f"cot({theta_rad.evalf()}) = {result}")
print(f"垂直分力/平行分力 = {normal_force/parallel_force} = {result}")
#cot(0.523598775598299) = 1.73205080756888
#垂直分力/平行分力 = sqrt(3) = 1.73205080756888
示例5：电气工程应用 - 交流电路中的阻抗
在交流电路中，电容和电感的阻抗为虚数，余切函数出现在相位计算中
例如，RC电路的相位差 φ = arctan(1/(ωRC))，cot(φ) = ωRC
R = 1000 # 电阻（Ω）
C = 1e-6 # 电容（F）
omega = 1000 # 角频率（rad/s）
phase_angle = atan(1/(omega*R*C))
print(f"电阻R = {R} Ω, 电容C = {C} F, 角频率ω = {omega} rad/s")
print(f"相位差φ = arctan(1/(ωRC)) = {phase_angle.evalf()} 弧度")
#电阻R = 1000 Ω, 电容C = 1e-06 F, 角频率ω = 1000 rad/s
#相位差φ = arctan(1/(ωRC)) = 0.785398163397448 弧度
result = cot(phase_angle)
print(f"cot(φ) = ωRC = {omega*R*C}")
print(f"通过函数计算: cot({phase_angle.evalf()}) = {result}")
#cot(φ) = ωRC = 1.0
#通过函数计算: cot(0.785398163397448) = 1
示例6：矩阵计算（结构分析中的刚度矩阵）
在结构分析中，有时需要计算角度的余切值来构造变换矩阵
angles = [@pi/6, @pi/4], [@pi/3, @pi/2]
angle_matrix = [[0.5236, 0.7854], [1.0472, 1.5708]] # 对应30°, 45°, 60°, 90°
result = cot(angle_matrix)
print(f"余切值矩阵:\n{result}")
#余切值矩阵: [[1.73204590997246, 0.999996326801643],
[0.577347004123039, -3.67320510337135e-6]]
示例7：符号计算与恒等式验证
验证恒等式: cot(x) = cos(x)/sin(x)
cot_x = cot(x)
cos_x = cos(x)
sin_x = sin(x)
identity = cos_x / sin_x
print(f"cot(x) = {cot_x}")
print(f"cos(x)/sin(x) = {identity}")
print(f"恒等式验证: {sp.simplify(cot_x - identity) == 0}")
#cot(x) = cot(x)
#cos(x)/sin(x) = cos(x)/sin(x)
#恒等式验证: True
示例8：天文学应用 - 天体测量中的角度计算
在天文学中，cot函数用于计算天体的视差和角直径
例如，视差角p与距离d的关系：cot(p) = d / (地球轨道半径)
p_arcsec = 1 # 视差角1角秒
p_rad = p_arcsec * pi / (180 * 3600) # 转换为弧度
earth_orbit_radius = 1.496e11 # 地球轨道半径（米）
distance = earth_orbit_radius / sp.tan(p_rad) # 距离d
print(f"视差角: {p_arcsec} 角秒 = {p_rad.evalf()} 弧度")
print(f"地球轨道半径: {earth_orbit_radius} 米")
print(f"计算距离: d = {earth_orbit_radius} / tan({p_rad.evalf()}) ≈ {distance.evalf()} 米")
#视差角: 1 角秒 = 0.00000484813681109536 弧度
#地球轨道半径: 149600000000.0 米
#计算距离: d = 149600000000.0 / tan(0.00000484813681109536) ≈ 3.08572150143239E+16 米
result = cot(p_rad)
print(f"cot({p_rad.evalf()}) = {result}")
print(f"通过cot计算: d = {earth_orbit_radius} * cot({p_rad.evalf()}) = {earth_orbit_radius * result}")
#cot(0.00000484813681109536) = 206264.806245480
#通过cot计算: d = 149600000000.0 * cot(0.00000484813681109536) = 3.08572150143239E+16
示例9：信号处理中的滤波器设计
在某些滤波器设计中，余切函数用于计算滤波器的参数
例如，全通滤波器的相位响应可能包含cot函数
f = 1000 # 频率（Hz）
f0 = 2000 # 截止频率（Hz）
简化的相位响应公式: φ = -2 * arctan(f/f0) -> cot(φ/2) = f0/f
phase_shift = -2 * atan(f/f0)
print(f"频率f = {f} Hz, 截止频率f0 = {f0} Hz")
print(f"相位响应φ = -2 * arctan(f/f0) = {phase_shift.evalf()} 弧度")
#频率f = 1000 Hz, 截止频率f0 = 2000 Hz
#相位响应φ = -2 * arctan(f/f0) = -0.927295218001612 弧度
result = cot(phase_shift/2)
print(f"cot(φ/2) = f0/f = {f0/f}")
print(f"通过函数计算: cot({(phase_shift/2).evalf()}) = {result}")
#cot(φ/2) = f0/f = 2.0
#通过函数计算: cot(-0.463647609000806) = -2
示例10：数学教育应用(三角恒等式的教学)
在教学过程中，经常需要计算特殊角的余切值来验证恒等式
angles_deg = [0, 30, 45, 60, 90] # 角度（度）
print("特殊角的余切值:")
for deg in angles_deg:
rad = deg * sp.pi / 180
result = cot(rad)
print(f"cot({deg}°) = cot({rad.evalf()}) = {result}")
#cot(0°) = cot(0) = nan
#cot(30°) = cot(0.523598775598299) = 1.73205080756888
#cot(45°) = cot(0.785398163397448) = 1.00000000000000
#cot(60°) = cot(1.04719755119660) = 0.577350269189626
#cot(90°) = cot(1.57079632679490) = 6.12323399573677E-17
这些示例展示了余切函数在不同领域的实际应用：
几何学：三角形计算和角度关系
物理学：力的分解、斜面问题
电气工程：交流电路中的阻抗和相位计算
结构分析：刚度矩阵和变换矩阵
天文学：天体测量和距离计算
信号处理：滤波器设计和相位响应
数学教育：特殊角的计算和恒等式验证
余切函数的实际意义：
描述直角三角形中邻边与对边的比值
在物理学中表示各种比例关系
在工程学中用于计算相位和阻抗
在天文学中用于距离测量
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
from sympy import sympify
import numpy as np
def cotangent_of_radians(input_str):
"""
计算输入表达式（数值或矩阵）的余切值（以弧度为单位）
参数:
input_str: 输入的字符串，可以是数值、矩阵的字符串表示或符号表达式
返回:
计算结果，若输入有效则返回SymPy表达式或矩阵；否则返回错误信息字符串
"""
try:
expr = sympify(input_str)
error = False
result = None
# 元组类型直接判定为无效输入
if isinstance(expr, tuple):
error = True
elif expr.is_number:
z = complex(expr)
result = 1 / np.tan(z)
elif expr.free_symbols:
# 处理数值或符号表达式
result = sp.cot(expr)
else:
error = True
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {e}"
if __name__ == "__main__":
# 示例测试
print("===== 测试1：数值计算 =====")
test_cases = [
("pi/4", "1.0 (cot(pi/4))"),
# 结果: (1.0000000000000002+0j)
("0", "无穷大 (cot(0))"),
# 结果: (inf+nan*j)
("pi/2", "0 (cot(pi/2))")
# 结果: (6.123233995736766e-17+0j)
]
for inp, desc in test_cases:
print(f"\n输入: {inp} ({desc})")
result = cotangent_of_radians(inp)
print("结果:", result)
print("\n===== 测试3：符号表达式 =====")
sym_input = "x"
print(f"\n输入符号: {sym_input}")
print("结果:", cotangent_of_radians(sym_input))
以度为单位的参量的余切
Y = cotd(X) 返回 X 的元素的余切（以度为单位）
X — 以度为单位的角, 标量值 | 向量 | 矩阵
Y — 角余切, 标量,向量,矩阵,多维数组，符号变量
示例1. 机械工程 - 斜面力学分析
斜面角度为30度时，计算所需的推力与重力的比值
angle = 30 # 斜面角度
cot_theta = cotd(angle)
print(f"斜面角度: {angle}°")
print(f"推力/重力比值 (cotθ): {cot_theta}")
#斜面角度: 30°
#推力/重力比值 (cotθ): 1.73205080756888
#说明: 在无摩擦情况下，余切函数用于计算在斜面上推动物体所需的力与重力的比值， 这对于设计斜坡、传送带和倾斜工作台至关重要。
示例2. 土木工程 - 斜坡稳定性分析
计算斜坡角度为45度时的稳定性系数
slope_angle = 45
stability_factor = cotd(slope_angle)
print(f"斜坡角度: {slope_angle}°")
print(f"稳定性系数 (cotθ): {stability_factor}")
#斜坡角度: 45°
#稳定性系数 (cotθ): 1.0
#说明: 斜坡稳定性分析中，余切函数用于计算斜坡的稳定系数，稳定性系数是斜坡设计和灾害预防的关键参数。
示例3. 电子工程 - 相位差计算
计算两个交流信号相位差为60度时的相互关系
phase_difference = 60
phase_relation = cotd(phase_difference)
print(f"相位差: {phase_difference}°")
print(f"相位关系参数: {phase_relation}")
#相位差: 60°
#相位关系参数: 0.577350269189626
#说明: 在交流电路分析中，余切函数用于描述相位差对功率因数的影响，这对于电力系统设计和效率优化非常重要。
示例4. 机器人学 - 关节角度计算
计算机器人臂关节角度为22.5度时的运动学参数
joint_angle = 22.5
kinematic_param = cotd(joint_angle)
print(f"关节角度: {joint_angle}°")
print(f"运动学参数: {kinematic_param}")
#关节角度: 22.5°
#运动学参数: 2.41421356237309
#说明: 在机器人逆运动学中，余切函数用于计算关节角度与末端执行器位置的关系。
示例5. 光学 - 布儒斯特角计算
计算折射率为1.5的介质的布儒斯特角
n = 1.5 # 折射率
brewster_angle_rad = np.arctan(n)
brewster_angle_deg = np.degrees(brewster_angle_rad)
cot_brewster = cotd(brewster_angle_deg)
print(f"折射率: {n}")
print(f"布儒斯特角: {brewster_angle_deg:.2f}°")
print(f"布儒斯特角的余切值: {cot_brewster}")
#折射率: 1.5
#布儒斯特角: 56.31°
#布儒斯特角的余切值: 0.666666666666667
#说明: 布儒斯特角的正切值等于折射率，其余切值用于计算偏振光的相关参数，这在光学器件设计和激光技术中有重要应用。
示例6. 航空航天 - 飞行路径角计算
计算飞行器爬升角度为15度时的航迹参数
climb_angle = 15
flight_param = cotd(climb_angle)
print(f"爬升角度: {climb_angle}°")
print(f"航迹参数: {flight_param}")
#爬升角度: 15°
#航迹参数: 3.73205080756888
#说明: 在飞行力学中，余切函数用于计算爬升率与空速的关系，这对于飞行性能分析和航线规划至关重要。
示例7. 建筑学 - 屋顶坡度计算
计算屋顶坡度为26.57度时的坡度比
roof_slope = 26.57
slope_ratio = cotd(roof_slope)
print(f"屋顶坡度: {roof_slope}°")
print(f"坡度比 (水平/垂直): {slope_ratio}")
#屋顶坡度: 26.57°
#坡度比 (水平/垂直): 1.99956820831900
#说明: 建筑行业中常用余切函数将角度坡度转换为比例表示（如4:12坡度），这使得坡度描述更加直观和标准化。
示例8. 地理信息系统 - 地形坡度分析
计算一组地形坡度角度[5, 10, 15, 20, 25]的坡度参数
terrain_slopes = [5, 10, 15, 20, 25]
slope_params = cotd(terrain_slopes)
print(f"地形坡度角度: {terrain_slopes}°")
print(f"坡度参数: {slope_params}")
#地形坡度角度: [5, 10, 15, 20, 25]°
#坡度参数: [11.4300523027613, 5.67128181961771, 3.73205080756888, 2.74747741945462, 2.14450692050956]
#说明: 在GIS中，余切函数用于将角度坡度转换为更适合分析的参数，这对于地形分析、洪水预测和土地利用规划非常重要。
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
from sympy import sympify
import numpy as np
def cotangent_degree_radians(input_str):
"""
计算输入的角度（度数）的余切值，支持矩阵、数值和符号表达式
参数:
input_str: 输入字符串，可以是数值、符号或矩阵表达式
返回:
计算结果（数值、矩阵或符号表达式）或错误信息字符串
"""
try:
expr = sympify(input_str) # 将输入字符串转换为SymPy表达式
error = False
result = None
# 检查输入类型
if expr.is_number:
z = complex(expr)
complex_angle = z * np.pi / 180
result = 1 / np.tan(complex_angle)
elif expr.free_symbols: # 数值或符号处理
rad_z = sp.rad(expr) # 更清晰的写法
result = sp.cot(rad_z)
else:
error = True
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {e}"
def main():
"""主函数：演示cotangent_degree_radians的使用"""
examples = [
"30",
# (1.7320508075688776+0j)
"45",
# (1.0000000000000002+0j)
"x",
# cot(pi*invalid/180)
]
for example in examples:
print(f"输入: {example}")
result = cotangent_degree_radians(example)
print("结果:")
print(result) # 使用SymPy的美化打印
print("\n" + "=" * 50 + "\n")
if __name__ == "__main__":
main()
双曲余切
Y=coth（X）返回X元素的双曲正切。coth函数对数组进行元素操作。该函数接受真实和复杂的输入。所有角度均以弧度为单位。
X —— 以弧度为单位的输入角度，标量，向量，矩阵，多维数组，符号变量。
示例1. 传输线理论 - 特性阻抗计算
计算传输线长度与波长比值为0.2时的阻抗变换因子
length_ratio = 0.2 # 传输线长度/波长
impedance_factor = coth(length_ratio)
print(f"长度/波长比值: {length_ratio}")
print(f"阻抗变换因子 (coth): {impedance_factor}")
#长度/波长比值: 0.2
#阻抗变换因子 (coth): 5.06648956343947
#说明: 在微波工程中，双曲余切函数用于计算传输线的阻抗变换，这对于高频电路设计和天线匹配至关重要。
示例2. 热传导 - 散热片效率计算
计算散热片参数m*L=1.5时的效率因子
ml_value = 1.5 # m*L参数，其中m=√(hP/kA)
efficiency_factor = coth(ml_value)
print(f"m*L参数: {ml_value}")
print(f"效率因子 (coth): {efficiency_factor}")
#m*L参数: 1.5
#效率因子 (coth): 1.10479139298251
#说明: 在热工程中，双曲余切函数用于计算散热片的效率，效率η = tanh(mL)/(mL) ≈ coth(mL)/(mL) 对于某些近似。
示例3. 相对论 - 速度合成公式
计算相对论速度合成中的双曲函数参数
rapidity = 0.5 # 快度参数
coth_rapidity = coth(rapidity)
print(f"快度参数: {rapidity}")
print(f"双曲余切值: {coth_rapidity}")
#快度参数: 0.5
#双曲余切值: 2.16395341373865
#说明: 在相对论中，速度合成公式涉及双曲函数，其中coth函数用于计算相对速度，coth(θ)表示相对论速度的某种度量。
示例4. 电气工程 - 电缆参数计算
计算电缆传播常数γ=0.1+0.2j时的参数
gamma = 0.1+0.2@i # 传播常数
cable_param = coth(gamma)
print(f"传播常数γ: {gamma}")
print(f"电缆参数: {cable_param}")
#传播常数γ: 0.1+0.2i
#电缆参数: 2.03357864486312 - 3.93328969902058i
#说明: 在电力传输中，双曲余切函数用于计算长距离电缆的参数，双曲余切函数用于计算线路的传播特性。
示例5. 量子力学 - 谐振子能级计算
计算谐振子参数βħω=1时的热力学平均值")
beta_hbar_omega = 1 # βħω参数
thermal_avg = coth(beta_hbar_omega)
print(f"βħω参数: {beta_hbar_omega}")
print(f"热力学平均值: {thermal_avg}")
# #βħω参数: 1
#热力学平均值: 1.31303528549933
#说明: 在量子统计力学中，双曲余切函数出现在谐振子的热力学平均值计算中，这对于理解量子系统的热力学行为非常重要。
示例6. 流体力学 - 边界层计算
计算边界层参数η=2时的速度分布因子
eta = 2 # 边界层相似变量
velocity_factor = coth(eta)
print(f"相似变量η: {eta}")
print(f"速度分布因子: {velocity_factor}")
#相似变量η: 2
#速度分布因子: 1.03731472072755
#说明: 在某些边界层流动问题中，双曲函数用于描述速度分布，这在航空航天和汽车工程中有应用。
示例7. 矩阵计算 - 多变量系统分析
计算系统参数矩阵[[0.5, 1.0], [1.5, 2.0]]的双曲余切
param_matrix = [[0.5, 1.0], [1.5, 2.0]]
matrix_coth = coth(param_matrix)
print(f"参数矩阵: {param_matrix}")
print(f"矩阵双曲余切: {matrix_coth}")
#参数矩阵: [[0.5, 1.0],
[1.5, 2.0]]
#矩阵双曲余切: [[2.16395341373865, 1.31303528549933],
[1.10479139298251, 1.03731472072755]]
#说明: 在多变量系统分析和控制理论中中，矩阵双曲函数用于描述系统的耦合特性。
示例8. 符号计算 - 理论物理推导
使用符号变量x进行双曲余切计算
symbolic_var = x
symbolic_coth = coth(symbolic_var)
print(f"符号变量: {symbolic_var}")
print(f"符号结果: {symbolic_coth}")
#符号变量: x
#符号结果: coth(x)
#说明: 在理论物理和数学推导中，符号双曲函数用于一般公式的推导，这使得工程师和科学家能够推导出通用公式，而不是局限于特定数值。
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
from sympy import sympify
import numpy as np
def cotangent_hyperbolic_radians(input_str):
"""
计算输入的双曲余切值（coth），支持数值、符号和矩阵输入
参数:
input_str: 输入字符串，可以是数值、符号或矩阵表达式
返回:
计算结果（数值、矩阵或符号表达式）或错误信息
"""
try:
expr = sympify(input_str) # 将输入字符串转换为SymPy表达式
error = False
result = None
# 检查输入类型
if expr.is_number:
z = complex(expr)
result = 1 / np.tanh(z)
elif expr.free_symbols: # 数值或符号处理
result = sp.coth(expr)
else:
error = True # 未知类型标记为错误
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {str(e)}" # 返回异常信息
def main():
"""主函数：演示双曲余切函数功能"""
test_cases = [
"1", # (1.3130352854993315+0j)
"0", # (inf+nan*j)
"x", # coth(x)
]
for case in test_cases:
print(f"输入: {case}")
result = cotangent_hyperbolic_radians(case)
print("结果:")
print(result) # 使用SymPy的美化打印
print("\n" + "=" * 50 + "\n")
if __name__ == "__main__":
main()
协方差
C = cov(A) 返回协方差.
协方差是统计学中衡量两个变量总体误差的度量，它表示两个变量之间的线性相关程度。
如果 A 是由观测值组成的向量，则 C 为标量值方差.
如果 A 是其列表示随机变量或行表示观测值的矩阵，则 C 为对应的列方差沿着对角线排列的协方差矩阵.
C = cov(A,B) 返回两个随机变量 A 和 B 之间的协方差
如果A和B是长度相同的观测值向量,则cov(A,B)为2×2协方差矩阵
C = cov(___,w) 为之前的任何语法指定归一化权重.如果 w = 0（默认值）,则 C 按观测值数量-1实现归一化. w=1时,按观测值数量对它实现归一化.
A —— 输入数组 向量|矩阵
B —— 附加输入数组向量|矩阵
w —— 归一化权重0（默认值）|1
示例1. 金融分析 - 股票收益率相关性
计算三只股票(AAPL, MSFT, GOOG)的日收益率协方差矩阵
stock_returns = [
[0.02, 0.015, 0.018], # 第1天: AAPL, MSFT, GOOG
[-0.01, 0.005, -0.002], # 第2天
[0.03, 0.02, 0.025], # 第3天
[0.005, 0.01, 0.008], # 第4天
[-0.015, -0.01, -0.012] # 第5天
]
cov_matrix = cov(stock_returns)
print("股票收益率数据:")
for i, day in enumerate(stock_returns):
print(f"第{i + 1}天: {day}")
print("协方差矩阵:")
print(np.round(cov_matrix, 6))
#股票收益率数据:
#第1天: [0.02, 0.015, 0.018]
#第2天: [-0.01, 0.005, -0.002]
#第3天: [0.03, 0.02, 0.025]
#第4天: [0.005, 0.01, 0.008]
#第5天: [-0.015, -0.01, -0.012]
#协方差矩阵:
#[[0.000368 0.000203 0.000282]
[0.000203 0.000133 0.000166]
[0.000282 0.000166 0.000222]]
#说明: 对角线元素是各股票收益率的方差，非对角线元素表示股票间的协方差。
#协方差矩阵帮助投资者理解不同股票收益率之间的关系， 正协方差表示股票倾向于同向移动，负协方差表示反向移动，这对于投资组合优化和风险管理至关重要。
示例2. 气象学 - 气象变量相关性
计算温度、湿度和气压的协方差矩阵
weather_data = [
[25, 60, 1013], # 温度(°C), 湿度(%), 气压(hPa)
[28, 55, 1010],
[22, 70, 1015],
[20, 75, 1018],
[26, 58, 1011]
]
weather_cov = cov(weather_data)
print("气象数据:")
for i, obs in enumerate(weather_data):
print(f"观测{i + 1}: {obs}")
print("协方差矩阵:")
print(np.round(weather_cov, 3))
#气象数据:
#观测1: [25, 60, 1013]
#观测2: [28, 55, 1010]
#观测3: [22, 70, 1015]
#观测4: [20, 75, 1018]
#观测5: [26, 58, 1011]
#协方差矩阵:
#[[ 10.2 -26.9 -10.1]
[-26.9 72.3 26.7]
[-10.1 26.7 10.3]]
#说明: 负协方差表示变量间存在负相关关系（如温度升高时气压可能下降）
#分析温度、湿度和气压等气象变量之间的相互关系，帮助气象学家理解天气系统的相互作用，负协方差可能表明变量间存在补偿关系。
示例3. 教育研究 - 考试成绩相关性
计算数学、物理和化学成绩的协方差矩阵
exam_scores = [
[85, 82, 78], # 学生1: 数学, 物理, 化学
[92, 88, 90], # 学生2
[78, 75, 80], # 学生3
[88, 85, 87], # 学生4
[95, 92, 94] # 学生5
]
score_cov = cov(exam_scores)
print("考试成绩:")
for i, student in enumerate(exam_scores):
print(f"学生{i + 1}: {student}")
print("协方差矩阵:")
print(np.round(score_cov, 2))
#考试成绩:
#学生1: [85, 82, 78]
#学生2: [92, 88, 90]
#学生3: [78, 75, 80]
#学生4: [88, 85, 87]
#学生5: [95, 92, 94]
#协方差矩阵:
#[[43.3 42.2 38.9 ]
[42.2 41.3 37.85]
[38.9 37.85 45.2 ]]
#说明: 正协方差表明科目成绩之间存在正相关关系（数学好的学生物理通常也好）
#评估不同学科成绩之间的关联程度，高正协方差表明学生在这些学科上表现一致，这对于课程设计和教学评估有重要意义。
示例4. 工程测量 - 传感器数据相关性
计算三个传感器测量值的协方差矩阵（使用有偏估计ddof=0）
sensor_data = [
[10.2, 20.5, 30.1], # 时间点1: 传感器1, 2, 3
[10.5, 20.3, 30.4], # 时间点2
[10.1, 20.6, 30.0], # 时间点3
[10.3, 20.4, 30.2] # 时间点4
]
sensor_cov = cov(sensor_data, 1) # ddof=0
print("传感器数据:")
for i, reading in enumerate(sensor_data):
print(f"时间点{i + 1}: {reading}")
print("协方差矩阵 (有偏估计):")
print(np.round(sensor_cov, 4))
#传感器数据:
#时间点1: [10.2, 20.5, 30.1]
#时间点2: [10.5, 20.3, 30.4]
#时间点3: [10.1, 20.6, 30.0]
#时间点4: [10.3, 20.4, 30.2]
#协方差矩阵 (有偏估计):
#[[ 0.0219 -0.0163 0.0219]
[-0.0163 0.0125 -0.0162]
[ 0.0219 -0.0162 0.0219]]
#说明: 小样本情况下使用有偏估计(ddof=0)可以提供更稳定的协方差估计
#分析多个传感器测量值之间的相关性，高协方差可能表明传感器测量相同或相关的物理量，有偏估计(ddof=0)在小样本情况下提供更稳定的估计。
示例5. 经济学 - 宏观经济指标相关性
计算GDP增长率、通货膨胀率和失业率的协方差矩阵
economic_data = [
[3.2, 2.1, 5.8], # 年份1: GDP增长(%), 通胀(%), 失业率(%)
[2.8, 2.5, 6.2], # 年份2
[3.5, 1.8, 5.5], # 年份3
[2.5, 2.8, 6.5], # 年份4
[3.8, 1.5, 5.2] # 年份5
]
economic_cov = cov(economic_data)
print("经济指标数据:")
for i, year in enumerate(economic_data):
print(f"年份{i + 1}: {year}")
print("协方差矩阵:")
print(np.round(economic_cov, 4))
#经济指标数据:
#年份1: [3.2, 2.1, 5.8]
#年份2: [2.8, 2.5, 6.2]
#年份3: [3.5, 1.8, 5.5]
#年份4: [2.5, 2.8, 6.5]
#年份5: [3.8, 1.5, 5.2]
#协方差矩阵:
#[[ 0.273 -0.273 -0.273]
[-0.273 0.273 0.273]
[-0.273 0.273 0.273]]
#说明: 协方差分析帮助经济学家理解不同宏观经济指标之间的关系
#研究GDP增长、通货膨胀和失业率等经济指标之间的关系，帮助政策制定者理解经济系统的内在联系，负协方差可能表明指标间存在权衡关系。
示例6. 生物统计学 - 生物特征相关性
计算身高、体重和血压的协方差矩阵
biometric_data = [
[175, 68, 120], # 个体1: 身高(cm), 体重(kg), 收缩压(mmHg)
[182, 75, 125], # 个体2
[168, 62, 118], # 个体3
[190, 85, 135], # 个体4
[172, 70, 122] # 个体5
]
biometric_cov = cov(biometric_data)
print("生物特征数据:")
for i, individual in enumerate(biometric_data):
print(f"个体{i + 1}: {individual}")
print("协方差矩阵:")
print(np.round(biometric_cov, 2))
#生物特征数据:
#个体1: [175, 68, 120]
#个体2: [182, 75, 125]
#个体3: [168, 62, 118]
#个体4: [190, 85, 135]
#个体5: [172, 70, 122]
#协方差矩阵:
#[[75.8 73. 55. ]
[73. 74.5 56.5]
[55. 56.5 44.5]]
#说明: 正协方差表明生物特征之间存在正相关关系（如身高和体重通常正相关）
#分析身高、体重和血压等生物特征之间的关联，正协方差表明这些特征倾向于同时增加或减少，这对于医学研究和健康评估有重要意义。
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
from sympy import sympify
def covariance_array(input_str):
"""
计算输入数据集的协方差矩阵（仅支持数值矩阵）
参数格式支持：
- 单个矩阵：计算该矩阵的协方差（默认归一化方式，ddof=1）
- 元组格式：
(A, B, flag): 两个矩阵A和B的协方差，flag为0或1指定归一化方式
(A, B): 两个矩阵的协方差（默认ddof=1）
(A, flag): 单个矩阵A的协方差，flag指定归一化方式
参数说明:
flag=0: 使用N-1归一化（无偏估计，ddof=1）
flag=1: 使用N归一化（有偏估计，ddof=0）
返回:
NumPy协方差矩阵 或 错误信息字符串
"""
try:
expr = sympify(input_str)
error = False
result = None
def validate_and_convert(matrix):
"""验证矩阵是否为纯数值并转换为NumPy数组"""
if matrix.is_symbolic():
raise ValueError("矩阵包含符号，无法转换为数值数组")
else:
return np.array(matrix, dtype=float)
# 处理元组输入
if isinstance(expr, tuple):
if len(expr) > 2:
if int(expr[2]) not in [0, 1]:
error = True
if isinstance(expr[0], list) and isinstance(expr[1], list):
A = sp.Matrix(expr[0])
B = sp.Matrix(expr[1])
if A.shape == B.shape:
data_a = validate_and_convert(A)
data_b = validate_and_convert(B)
result = np.cov(data_a, data_b, rowvar=False, ddof=1 - int(expr[2]))
else:
error = True
elif isinstance(expr[0], list) and isinstance(expr[1], list):
A = sp.Matrix(expr[0])
B = sp.Matrix(expr[1])
if A.shape == B.shape:
data_a = validate_and_convert(A)
data_b = validate_and_convert(B)
result = np.cov(data_a, data_b, rowvar=False)
elif isinstance(expr[0], list) and int(expr[1]) in [0, 1]:
A = sp.Matrix(expr[0])
data_a = validate_and_convert(A)
result = np.cov(data_a, rowvar=False, ddof=1 - int(expr[1]))
elif isinstance(expr, list):
A = sp.Matrix(expr)
data_a = validate_and_convert(A)
result = np.cov(data_a, rowvar=False)
else:
error = True
if error:
return f"输入错误: {input_str}"
return result
except Exception as e:
return f"错误: {str(e)}"
def main():
"""主函数：演示协方差计算功能"""
test_cases = [
# 有效输入测试
"[[1,2], [3,4], [5,6]]",
# 结果:
#[[4. 4.]
# [4. 4.]]
"[[1,2], [3,4]],[[5,6], [7,8]]",
# 结果:
# [[2. 2. 2. 2.]
# [2. 2. 2. 2.]
# [2. 2. 2. 2.]
# [2. 2. 2. 2.]]
"[[1,2], [3,4]],[[5,6], [7,8]], 0",
# 结果:
# [[2. 2. 2. 2.]
# [2. 2. 2. 2.]
# [2. 2. 2. 2.]
# [2. 2. 2. 2.]]
"[[1,2],[3,4]], 0",
# 结果:
# [[2. 2.]
# [2. 2.]]
]
for case in test_cases:
print(f"输入: {case}")
result = covariance_array(case)
print("结果:")
if isinstance(result, str):
print(result)
else:
print(np.round(result, 4)) # 保留4位小数便于观察
print("\n" + "=" * 50 + "\n")
if __name__ == "__main__":
main()
将复数排序为复共轭对组
B = cplxpair(A) 对沿复数数组不同维度的元素排序，并将复共轭对组组合在一起。
共轭对组按递增实部排序。在对组中，带有负虚部的元素排在前面。在所有复数对组后返回纯实数值。复共轭对组会强制成为精确复共轭。相对于 100*eps 的默认容差 abs(A(i)) 确定哪些数字是实数，哪些元素是成对复共轭。
如果 A 为向量，cplxpair(A) 返回复共轭对组组合在一起的 A。
如果 A 是矩阵，则 cplxpair(A) 返回其列已排序且复共轭已配对的 A。
B = cplxpair(A,tol) 覆盖默认容差。
示例1. 信号处理 - 滤波器极点分析
计算Butterworth滤波器的极点并排序为共轭对
4阶Butterworth滤波器的极点
butterworth_poles = [
-0.3827 + 0.9239@i, -0.3827 - 0.9239@i,
-0.9239 + 0.3827@i, -0.9239 - 0.3827@i
]
sorted_poles = cplxpair(butterworth_poles)
print("原始极点:", butterworth_poles)
print("排序后极点:", sorted_poles)
#原始极点: [(-0.3827+0.9239i), (-0.3827-0.9239i), (-0.9239+0.3827i), (-0.9239-0.3827i)]
#排序后极点: [-0.9239+0.3827i,-0.9239-0.3827i -0.3827+0.9239i,-0.3827-0.9239i]
#说明: 在滤波器设计中，极点总是以共轭对形式出现，排序有助于分析滤波器特性。
#极点总是以共轭对形式出现，排序有助于分析滤波器的稳定性和频率特性，这对于设计满足特定要求的滤波器至关重要。
示例2. 控制系统 - 系统极点分析
计算控制系统的极点并排序为共轭对
一个控制系统的极点
system_poles = [
-2 + 3@i, -2 - 3@i, # 振荡模式
-5, # 衰减模式
-1 + 1@i, -1 - 1@i # 另一个振荡模式
]
sorted_system_poles = cplxpair(system_poles)
print("原始系统极点:", system_poles)
print("排序后系统极点:", sorted_system_poles)
#原始系统极点: [(-2+3i), (-2-3i), -5, (-1+1i), (-1-1i)]
#排序后系统极点: [-5, -2+3i,-2-3i,-1+1i,-1-1i]
#说明: 在控制系统分析中，共轭极点对对应系统的振荡模式，实数极点对应衰减模式
#控制系统的极点决定了系统的稳定性和动态响应，排序极点有助于分析系统的稳定性和设计控制器。
示例3. 量子力学 - 能级计算
计算量子系统的能量本征值并排序
一个量子系统的能量本征值（可能有复数解）
energy_levels = [
2.5 + 0.3@i, 2.5 - 0.3@i, # 准束缚态
1.8, # 束缚态
3.2 + 0.5@i, 3.2 - 0.5@i # 另一个准束缚态
]
sorted_energy_levels = cplxpair(energy_levels)
print("原始能级:", energy_levels)
print("排序后能级:", sorted_energy_levels)
#原始能级: [(2.5+0.3i), (2.5-0.3i), 1.8, (3.2+0.5i), (3.2-0.5i)]
#排序后能级: [1.8,2.5+0.3i,2.5-0.3i,3.2+0.5i,3.2-0.5i]
#说明: 在量子力学中，复数能量本征值总是以共轭对形式出现，表示准束缚态
#这些能量本征值总是以共轭对形式出现，排序能级有助于分析量子系统的特性和能级结构。
示例4. 电路分析 - 网络参数
计算电路的散射参数(S参数)并排序
一个二端口网络的S参数（复数）
s_params = [
0.1 + 0.2@i, 0.1 - 0.2@i, # S11
0.3 + 0.4@i, 0.3 - 0.4@i, # S12/S21
0.5 + 0.6@i, 0.5 - 0.6@i # S22
]
sorted_s_params = cplxpair(s_params)
print("原始S参数:", s_params)
print("排序后S参数:", sorted_s_params)
#原始S参数: [(0.1+0.2i), (0.1-0.2i), (0.3+0.4i), (0.3-0.4i), (0.5+0.6i), (0.5-0.6i)]
#排序后S参数: [0.1+0.2i,0.1-0.2i,0.3+0.4i,0.3-0.4i,0.5+0.6i,0.5-0.6i]
#说明: 在微波工程中，S参数是复数，S参数描述了网络的传输特性，排序有助于分析网络的对称性和互易性
#这对于设计匹配网络和优化电路性能非常重要。
示例5. 数值分析 - 特征值计算
计算矩阵的特征值并排序为共轭对
一个实矩阵的特征值（总是以共轭对形式出现）
eigenvalues = [
3 + 4@i, 3 - 4@i, # 一对共轭特征值
2, # 实特征值
1 + 2@i, 1 - 2@i # 另一对共轭特征值
]
sorted_eigenvalues = cplxpair(eigenvalues)
print("原始特征值:", eigenvalues)
print("排序后特征值:", sorted_eigenvalues)
#原始特征值: [(3+4i), (3-4i), 2, (1+2i), (1-2i)]
#排序后特征值: [1+2i,1-2i,2,3+4i,3-4i]
#说明: 实矩阵的特征值总是以共轭对形式出现，排序有助于分析矩阵的性质，，如正定性、稳定性等。
#这对于解决线性代数问题和优化问题至关重要。
示例6. 通信系统 - 调制符号
计算QPSK调制符号并排序
QPSK调制符号（复数）
qpsk_symbols = [
0.707 + 0.707@i, 0.707 - 0.707@i, # 45°和315°
-0.707 + 0.707@i, -0.707 - 0.707@i # 135°和225°
]
sorted_qpsk_symbols = cplxpair(qpsk_symbols)
print("原始QPSK符号:", qpsk_symbols)
print("排序后QPSK符号:", sorted_qpsk_symbols)
#原始QPSK符号: [(0.707+0.707i), (0.707-0.707i), (-0.707+0.707i), (-0.707-0.707i)]
#排序后QPSK符号: [-0.707+0.707i,-0.707-0.707i,0.707+0.707i,0.707-0.707i]
#说明: 在数字通信中，调制符号是复数，，表示不同的比特组合。
#排序符号有助于分析星座图的对称性和检测算法，这对于设计高效的调制方案和接收机算法非常重要。
示例7. 多维数组处理 - 多通道信号
处理多通道信号的复数表示并排序
一个3通道信号的复数表示
multi_channel_signal = [
[[1+2@i, 3+4@i], [5+6@i, 7+8@i]], # 通道1
[[1-2@i, 3-4@i], [5-6@i, 7-8@i]], # 通道2
[[9, 10], [11, 12]] # 通道3（实数）
]
sorted_multi_channel = cplxpair(multi_channel_signal)
print("原始多通道信号:", multi_channel_signal)
print("排序后多通道信号:", sorted_multi_channel)
#原始多通道信号: [[[(1+2i), (3+4i)], [(5+6i), (7+8i)]], [[(1-2i), (3-4i)], [(5-6i), (7-8i)]], [[9, 10], [11, 12]]]
#排序后多通道信号: [[[ 1+2i , 3+4i]
[ 5+6i , 7+8i]]
[[ 1-2i , 3-4i]
[ 5-6i , 7-8i]]
[[ 9 , 10]
[11 , 12]]]
#说明: 在多通道信号处理中，复数信号通常以共轭对形式出现。
#排序有助于分析通道间的关系和提取有用信息，这对于音频处理、图像处理和生物信号处理等领域有应用。
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import numpy as np
import sympy as sp
def complex_conjugate_pairs(input_str):
"""
实现MATLAB cplxpair函数，将复数数组排序并配对共轭复数
参数:
input_str (str): 输入表达式，如 "A, tol"
返回:
sp.Matrix: 排序后的矩阵，共轭对相邻
异常:
ValueError: 输入不合法或无法配对
"""
try:
# 解析输入参数
expr = sp.sympify(input_str)
error = False
result = None
tol = 1e-6 # 默认容差
def cplxpair(A, tol=1e-10):
"""
MATLAB cplxpair函数的NumPy实现
参数:
A: 输入数组（向量、矩阵或多维数组）
tol: 容差，用于判断两个复数是否共轭
返回:
按共轭对排序的数组
"""
A = np.asarray(A)
# 处理空数组
if A.size == 0:
return A
# 确定第一个非单一维度
dim = next((i for i, s in enumerate(A.shape) if s > 1), 0)
# 对于向量输入，直接处理
if A.ndim == 1:
return _sort_complex_vector(A, tol)
# 对于多维数组，沿第一个非单一维度处理
else:
# 转置数组，使目标维度成为第一个维度
transpose_axes = list(range(A.ndim))
transpose_axes.insert(0, dim)
transpose_axes.pop(dim + 1)
A_transposed = A.transpose(transpose_axes)
# 重塑为二维数组（第一个维度为向量，其余维度合并）
original_shape = A_transposed.shape
A_2d = A_transposed.reshape(original_shape[0], -1)
# 对每一列应用排序
sorted_2d = np.apply_along_axis(lambda x: _sort_complex_vector(x, tol), 0, A_2d)
# 重塑回原始形状（转置后）
sorted_transposed = sorted_2d.reshape(original_shape)
# 转回原始维度顺序
inverse_transpose = [transpose_axes.index(i) for i in range(len(transpose_axes))]
sorted_A = sorted_transposed.transpose(inverse_transpose)
return sorted_A
def _sort_complex_vector(c, tol):
"""辅助函数：对复数向量进行共轭对排序"""
# 分离实部和虚部
real_part = np.real(c)
imag_part = np.imag(c)
# 创建排序索引：先按实部升序，再按虚部绝对值升序
idx = np.lexsort((np.abs(imag_part), real_part))
sorted_c = c[idx].copy() # 复制以避免修改原数组
# 处理共轭对，确保虚部非负的元素在前
n = len(sorted_c)
result = np.zeros(n, dtype=complex)
i = 0
j = 0
while i < n:
# 如果是实数值，直接添加
if np.abs(sorted_c[i].imag) < tol:
result[j] = sorted_c[i]
i += 1
j += 1
else:
# 找到共轭对
found = False
for k in range(i + 1, n):
if (np.abs(np.real(sorted_c[k]) - np.real(sorted_c[i])) < tol and
np.abs(np.imag(sorted_c[k]) + np.imag(sorted_c[i])) < tol):
# 确保虚部非负的元素在前
if sorted_c[i].imag >= 0:
result[j] = sorted_c[i]
result[j + 1] = sorted_c[k]
else:
result[j] = sorted_c[k]
result[j + 1] = sorted_c[i]
i = k + 1
j += 2
found = True
break
if not found:
# 没有找到共轭对，单独添加
result[j] = sorted_c[i]
i += 1
j += 1
return result[:j] # 裁剪到实际填充的部分
if isinstance(expr, tuple):
error = True
elif isinstance(expr, list):
A = np.asarray(expr, dtype=complex)
result = cplxpair(A, tol)
else:
error = True
return result if not error else f"输入错误:{input_str}"
except Exception as e:
raise ValueError(f"cplxpair错误: {str(e)}")
# 示范代码
if __name__ == "__main__":
# 矩阵示例
print("\n=== 矩阵示例 ===")
sorted_matrix = complex_conjugate_pairs("[[3 + 4j, 1 - 2j, 5],[1 + 2j, 3 - 4j, 6j],[7, 8 + 1j, 8 - 1j]]")
print("排序后矩阵:\n", sorted_matrix)
# [[1.+2.j 1.-2.j 0.+6.j]
# [3.+4.j 3.-4.j 5.+0.j]
# [7.+0.j 8.+1.j 8.-1.j]]
# 三维数组示例
print("\n=== 三维数组示例 (2x3x3) ===")
sorted_3d = complex_conjugate_pairs(
"[[[3 + 4j, 1 - 2j, 5],[1 + 2j, 3 - 4j, 6j],[7, 8 + 1j, 8 - 1j]],[[4 + 2j, 9, 2 - 3j],[4 - 2j, 10, 2 + 3j],[11, 12 + 5j, 12 - 5j]]]")
print("排序后三维数组:\n", sorted_3d)
# [[[ 3.+4.j 1.-2.j 2.-3.j]
# [ 1.+2.j 3.-4.j 0.+6.j]
# [ 7.+0.j 8.+1.j 8.-1.j]]
#
# [[ 4.+2.j 9.+0.j 5.+0.j]
# [ 4.-2.j 10.+0.j 2.+3.j]
# [11.+0.j 12.+5.j 12.-5.j]]]
叉积
叉积（向量积）在物理学、工程学和计算机图形学等领域有广泛的应用。
C = cross(A,B) 返回A和B的叉积.
如果A和B为向量，则它们的长度必须为3.
如果A和B为矩阵,则它们必须具有相同大小.在这种情况下，cross函数将A和B视为三元素向量集合.该函数计算对应向量沿大小等于3的第一个数组维度的叉积.
示例1. 物理学 - 力矩计算
计算力F = [10, 0, 0]N作用在位置r = [0, 2, 0]m处的力矩
r = [0, 2, 0] # 位置向量 (m)
F = [10, 0, 0] # 力向量 (N)
torque = cross(r, F)
print(f"位置向量 r: {r}")
print(f"力向量 F: {F}")
print(f"力矩 τ = r × F: {torque}")
#位置向量 r: [0, 2, 0]
#力向量 F: [10, 0, 0]
#力矩 τ = r × F:
#[[0],
[0],
[-20]]
#说明: 力矩是位置向量和力向量的叉积，表示力的旋转效应
#这对于分析刚体旋转和平衡条件至关重要, 示例中计算了力作用在杠杆上产生的力矩。
示例2. 电磁学 - 洛伦兹力计算
计算电荷q=1C以速度v=[0, 0, 5]m/s在磁场B=[0, 0.1, 0]T中受到的洛伦兹力
v = [0, 0, 5] # 速度向量 (m/s)
B = [0, 0.1, 0] # 磁场向量 (T)
F_lorentz = cross(fv,B)
print(f"速度向量 v: {v}")
print(f"磁场向量 B: {B}")
print(f"洛伦兹力 F = q(v × B): {F_lorentz} (方向)")
#速度向量 v: [0, 0, 5]
#磁场向量 B: [0, 0.1, 0]
#洛伦兹力 F = q(v × B):
#[[-0.5],
[0],
[0]] (方向)
#说明: 洛伦兹力是电荷在磁场中运动时受到的力，等于电荷量乘以速度向量和磁场向量的叉积。
#这对于理解带电粒子在磁场中的运动轨迹非常重要，示例中计算了电荷在磁场中运动时受到的力方向。
示例3. 计算机图形学 - 表面法线计算
计算由向量u=[2, 0, 0]和v=[0, 3, 0]定义的平面的法线向量
u = [2, 0, 0] # 平面上的向量
v = [0, 3, 0] # 平面上的另一个向量
normal = cross(u,v)
print(f"向量 u: {u}")
print(f"向量 v: {v}")
print(f"法线向量 n = u × v: {normal}")
#向量 u: [2, 0, 0]
#向量 v: [0, 3, 0]
#法线向量 n = u × v:
#[[0],
[0],
[6]]
#说明: 两个向量的叉积得到垂直于这两个向量的法线向量
#这对于计算光照、阴影和表面朝向至关重要，示例中计算了由两个向量定义的平面的法线。
示例4. 机械工程 - 角动量计算
计算质量m=2kg的粒子在位置r=[3, 4, 0]m以速度v=[0, 0, 5]m/s运动时的角动量
r = [3, 4, 0] # 位置向量 (m)
v = [0, 0, 5] # 速度向量 (m/s)
L = cross(r,v)
L_scaled = L * 2 # m=2kg
print(f"位置向量 r: {r}")
print(f"速度向量 v: {v}")
print(f"角动量 L = m(r × v): {L_scaled}")
#位置向量 r: [3, 4, 0]
#速度向量 v: [0, 0, 5]
#角动量 L = m(r × v):
#[[40],
[-30],
[0]]
#说明: 角动量是位置向量和动量向量(mv)的叉积。
#这对于分析旋转系统的动力学行为非常重要，示例中计算了粒子运动的角动量。
示例5. 航空航天 - 飞行器姿态控制
计算飞行器在角速度ω=[0.1, 0.2, 0.3]rad/s时的陀螺效应力矩
假设飞行器有对角惯性矩阵，主惯性矩Ix=10, Iy=20, Iz=30 kg·m²
I = [[10, 0, 0], [0, 20, 0], [0, 0, 30]] # 惯性张量
ω = [0.1, 0.2, 0.3] # 角速度向量 (rad/s)
H = I * sp.Matrix(ω) # 角动量
陀螺力矩 τ = ω × H
τ = cross(ω, H)
print(f"角速度向量 ω: {ω}")
print(f"角动量向量 H: {H}")
print(f"陀螺力矩 τ = ω × H: {τ}")
#角速度向量 ω: [0.1, 0.2, 0.3]
#角动量向量 H: [[1], [4], [9]]
#陀螺力矩 τ = ω × H:
#[[0.6],
[-0.6],
[0.2]]
#说明: 陀螺效应产生的力矩是角速度向量和角动量向量的叉积
#这对于理解和控制飞行器的姿态动力学至关重要，示例中计算了飞行器的陀螺力矩。
示例6. 机器人学 - 雅可比矩阵计算
计算机器人末端执行器的线速度和角速度关系
假设有两个关节速度向量
ω1 = [0, 0, 1] # 第一个关节的角速度
ω2 = [0, 1, 0] # 第二个关节的角速度
r1 = [1, 0, 0] # 第一个关节到末端的位置向量
r2 = [0, 1, 0] # 第二个关节到末端的位置向量
计算每个关节对末端线速度的贡献: v = ω × r
v1 = cross(ω1, r1)
v2 = cross(ω2, r2)
print(f"关节1角速度 ω1: {ω1}")
print(f"关节1到末端向量 r1: {r1}")
print(f"关节1贡献的线速度 v1 = ω1 × r1: {v1}")
print(f"关节2角速度 ω2: {ω2}")
print(f"关节2到末端向量 r2: {r2}")
print(f"关节2贡献的线速度 v2 = ω2 × r2: {v2}")
print("总末端线速度 v = v1 + v2:", v1 + v2)
#关节1角速度 ω1: [0, 0, 1]
#关节1到末端向量 r1: [1, 0, 0]
#关节1贡献的线速度 v1 = ω1 × r1:
#[[0],
[1],
[0]]
#关节2角速度 ω2: [0, 1, 0]
#关节2到末端向量 r2: [0, 1, 0]
#关节2贡献的线速度 v2 = ω2 × r2:
#[[0],
[0],
[0]]
#总末端线速度 v = v1 + v2:
#[[0],
[1],
[0]]
#说明: 在机器人运动学中，关节角速度通过叉积关系转换为末端执行器的线速度。
#这对于机器人运动规划和控制至关重要，示例中计算了机器人末端执行器的速度贡献。
示例7. 多向量计算 - 矩阵列向量的叉积
同时计算多对向量的叉积
定义两个3x3矩阵，每列代表一个向量
A = [[1, 2, 3],
[0, 1, 0],
[0, 0, 1]] # 三个向量: [1,0,0], [2,1,0], [3,0,1]
B = [[0, 1, 0],
[1, 0, 1],
[0, 0, 1]] # 三个向量: [0,1,0], [1,0,0], [0,1,1]
cross_results = cross(A, B)
print("矩阵A (每列是一个向量):")
for i in range(3):
print(f" 列{i+1}: {[A[j][i] for j in range(3)]}")
print("矩阵B (每列是一个向量):")
for i in range(3):
print(f" 列{i+1}: {[B[j][i] for j in range(3)]}")
print("叉积结果矩阵 (每列是对应向量的叉积):")
print(cross_results)
#矩阵A (每列是一个向量):
列1: [1, 0, 0]
列2: [2, 1, 0]
列3: [3, 0, 1]
#矩阵B (每列是一个向量):
列1: [0, 1, 0]
列2: [1, 0, 0]
列3: [0, 1, 1]
#叉积结果矩阵 (每列是对应向量的叉积):
#[[0, 0, -1],
[0, 0, -3],
[1, -1, 3]]
#说明: 可以同时计算多对向量的叉积，提高计算效率。
#这对于批量处理向量数据和并行计算非常重要，示例中展示了如何同时计算多对向量的叉积。
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
def cross_vector(input_str):
"""
计算两个三维向量或矩阵列向量的叉积。
参数:
input_str: 字符串形式的输入，应为包含两个矩阵或向量的元组，例如 "([1,2,3], [4,5,6])"
返回:
如果输入合法，返回叉积结果矩阵；否则返回错误信息字符串。
"""
try:
# 将输入字符串转换为SymPy表达式
expr = sp.sympify(input_str)
result = None
error = False
# 检查是否为包含两个元素的元组
if isinstance(expr, tuple) and len(expr) == 2:
# 转换两个元素为矩阵
A = sp.Matrix(expr[0]) if isinstance(expr[0], list) else None
B = sp.Matrix(expr[1]) if isinstance(expr[1], list) else None
if A is not None and B is not None:
# 处理两个3x1列向量的情况
if A.shape == (3, 1) and B.shape == (3, 1):
result = A.cross(B)
# 处理两个3xn矩阵的情况（按列计算叉积）
elif A.shape == B.shape and A.shape[0] == 3 and A.shape[1] >= 1:
vectors = []
for i in range(A.shape[1]):
a_col = A.col(i)
b_col = B.col(i)
vectors.append(a_col.cross(b_col))
# 水平拼接所有结果列向量
result = sp.Matrix.hstack(*vectors)
else:
error = True
else:
error = True
else:
error = True
if error:
return f"输入格式错误: {input_str}"
else:
return result
except Exception as e:
return f"计算过程中发生错误: {str(e)}"
def main():
"""主函数，展示cross_vector函数的使用示例"""
# 示例1：两个3D向量的叉积
input1 = "([1, 2, 3], [4, 5, 6])"
print(f"输入：{input1}")
print("输出：", cross_vector(input1), "\n")
# 输出： Matrix([[-3],
# [6],
# [-3]])
# 示例2：两个3x2矩阵的列向量叉积
input2 = "([[1, 2], [3, 4], [5, 6]], [[6, 5], [4, 3], [2, 1]])"
print(f"输入：{input2}")
print("输出：\n", cross_vector(input2), "\n")
# Matrix([[-14, -14],
# [28, 28],
# [-14, -14]])
if __name__ == "__main__":
main()
复共轭转置
B = A' 计算A的复共轭转置.
B = ctranspose(A) 是执行A'的替代方法,但很少使用.
A — 输入数组,向量,矩阵.
示例1. 量子力学 - 波函数与算符
计算量子态向量的共轭转置（bra向量）
一个量子态向量（ket向量）
psi = [[1 + 2@i], [3 - 4@i], [5 + 6@i]]
psi_dagger = ctranspose(str(psi.tolist()))
print("量子态向量 |ψ⟩ (ket):")
print(psi)
print("共轭转置 ⟨ψ| (bra):")
print(psi_dagger)
#量子态向量 |ψ⟩ (ket):
#[[1.0 + 2.0i],
[3.0 - 4.0i],
[5.0 + 6.0i]]
#共轭转置 ⟨ψ| (bra):
#[[1.0 - 2.0i, 3.0 + 4.0i, 5.0 - 6.0i]]
#说明: 在量子力学中，ket向量的共轭转置得到bra向量。
#这是计算内积 ⟨ψ|φ⟩ 和期望值 ⟨ψ|A|ψ⟩ 的基础，示例中展示了如何从量子态向量计算其共轭转置。
示例2. 信号处理 - 复数信号矩阵
计算复数信号矩阵的共轭转置
一个复数信号矩阵（例如，来自多个传感器的信号）
signal_matrix = [
[1 + 0.5@i, 2 - 0.3@i, 3 + 0.8@i],
[0.5 + 1@i, 1.2 - 0.7@i, 2.5 + 0.2@i],
[0.8 + 0.2@i, 1.5 - 0.4@i, 2.8 + 0.6@i]
]
signal_dagger = ctranspose(signal_matrix)
print("原始信号矩阵:")
print(sp.Matrix(signal_matrix))
print("共轭转置矩阵:")
print(signal_dagger)
#原始信号矩阵:
#[[1.0 + 0.5i, 2.0 - 0.3i, 3.0 + 0.8i],
[0.5 + 1.0i, 1.2 - 0.7i, 2.5 + 0.2i],
[0.8 + 0.2i, 1.5 - 0.4i, 2.8 + 0.6i]]
#共轭转置矩阵:
#[[1 - 0.5i, 0.5 - i, 0.8 - 0.2i],
[2 + 0.3i, 1.2 + 0.7i, 1.5 + 0.4i],
[3 - 0.8i, 2.5 - 0.2i, 2.8 - 0.6i]]
#说明: 在信号处理中，共轭转置用于计算相关矩阵和协方差矩阵。
#这对于波束成形、频谱估计和信号检测至关重要，示例中展示了复数信号矩阵的共轭转置计算。
示例3. 线性代数 - 厄米特矩阵验证
验证一个矩阵是否为厄米特矩阵（等于其共轭转置）
一个厄米特矩阵（Hermitian matrix）
hermitian_matrix = [
[2, 3 + 4@i, 5 - 6@i],
[3 - 4@i, 1, 7 + 2@i],
[5 + 6@i, 7 - 2@i, 4]
]
hermitian_dagger = ctranspose(hermitian_matrix)
is_hermitian = hermitian_matrix == hermitian_dagger
print("原始矩阵:")
print(sp.Matrix(hermitian_matrix))
print("共轭转置矩阵:")
print(hermitian_dagger)
print("矩阵是否等于其共轭转置（是否为厄米特矩阵）:", is_hermitian)
#原始矩阵:
#[[2, 3.0 + 4.0i, 5.0 - 6.0i],
[3.0 - 4.0i, 1, 7.0 + 2.0i],
[5.0 + 6.0i, 7.0 - 2.0i, 4]]
#共轭转置矩阵:
#[[2, 3 + 4i, 5 - 6i],
[3 - 4i, 1, 7 + 2i],
[5 + 6i, 7 - 2i, 4]]
#矩阵是否等于其共轭转置（是否为厄米特矩阵）: False
#说明: 厄米特矩阵在量子力学和信号处理中非常重要，其特征值为实数。
#厄米特矩阵（Hermitian matrix）等于其共轭转置，这类矩阵的特征值都是实数，在量子力学中表示可观测物理量。
示例4. 通信系统 - MIMO信道矩阵
计算MIMO信道矩阵的共轭转置
一个MIMO信道矩阵（复数）
mimo_channel = [
[0.8 + 0.2@i, 0.5 - 0.3@i, 0.3 + 0.4@i],
[0.4 + 0.1@i, 0.7 - 0.2@i, 0.2 + 0.3@i],
[0.6 + 0.3@i, 0.3 - 0.1@i, 0.9 + 0.2@i]
]
mimo_dagger = ctranspose(mimo_channel)
print("MIMO信道矩阵 H:")
print(sp.Matrix(mimo_channel))
print("共轭转置 Hᴴ:")
print(mimo_dagger)
#MIMO信道矩阵 H:
#[[0.8 + 0.2i, 0.5 - 0.3i, 0.3 + 0.4i],
[0.4 + 0.1i, 0.7 - 0.2i, 0.2 + 0.3i],
[0.6 + 0.3i, 0.3 - 0.1i, 0.9 + 0.2i]]
#共轭转置 H:
#[[0.8 - 0.2i, 0.4 - 0.1i, 0.6 - 0.3i],
[0.5 + 0.3i, 0.7 + 0.2i, 0.3 + 0.1i],
[0.3 - 0.4i, 0.2 - 0.3i, 0.9 - 0.2i]]
#说明: 在MIMO系统中，信道矩阵的共轭转置用于计算预编码和接收滤波器。
#这对于提高通信系统的容量和可靠性至关重要，示例中计算了MIMO信道矩阵的共轭转置。
示例5. 量子计算 - 量子门操作
验证量子门是否为酉矩阵（其共轭转置等于其逆）
一个量子门矩阵（例如，Hadamard门）
hadamard_gate = [
[1 / sp.sqrt(2), 1 / sp.sqrt(2)],
[1 / sp.sqrt(2), -1 / sp.sqrt(2)]
]
hadamard_dagger = ctranspose(hadamard_gate)
计算逆矩阵
hadamard_inv = sp.Matrix(hadamard_gate).inv()
is_unitary = sp.simplify(hadamard_dagger - hadamard_inv).is_zero_matrix
print("Hadamard门矩阵:")
print(sp.Matrix(hadamard_gate))
print("共轭转置:")
print(hadamard_dagger)
print("逆矩阵:")
print(hadamard_inv)
print("是否为酉矩阵（Uᴴ = U⁻¹）:", is_unitary)
#Hadamard门矩阵:
#[[sqrt(2)/2, sqrt(2)/2],
[sqrt(2)/2, -sqrt(2)/2]]
#共轭转置:
#[[sqrt(2)/2, sqrt(2)/2],
[sqrt(2)/2, -sqrt(2)/2]]
#逆矩阵:
#[[sqrt(2)/2, sqrt(2)/2],
[sqrt(2)/2, -sqrt(2)/2]]
#是否为酉矩阵（Uᴴ = U⁻¹）: True
#说明: 量子计算中的门操作必须是酉矩阵，，即其共轭转置等于其逆矩阵。
#这保证了量子计算的概率守恒和可逆性，示例中验证了Hadamard门是否为酉矩阵。
示例6. 图像处理 - 复数变换域
计算复数变换矩阵的共轭转置
一个复数变换矩阵（例如，傅里叶变换矩阵的一部分）
transform_matrix = [
[1, 1, 1],
[1, sp.exp(-2@i * sp.pi / 3), sp.exp(-4@i * sp.pi / 3)],
[1, sp.exp(-4@i * sp.pi / 3), sp.exp(-8@i * sp.pi / 3)]
]
transform_dagger = ctranspose(transform_matrix)
print("变换矩阵 F:")
print(sp.Matrix(transform_matrix))
print("共轭转置 Fᴴ:")
print(transform_dagger)
#变换矩阵 F:
#[[1, 1, 1],
[1, exp(-0.666666666666667*I*pi), exp(-1.33333333333333*I*pi)],
[1, exp(-1.33333333333333*I*pi), exp(-2.66666666666667*I*pi)]]
#共轭转置 F:
#[[1, 1, 1],
[1, exp(0.666666666666667*I*pi), exp(1.33333333333333*I*pi)],
[1, exp(1.33333333333333*I*pi), exp(2.66666666666667*I*pi)]]
#说明: 在图像处理中，复数变换（如傅里叶变换）的共轭转置用于实现逆变换。
#这对于图像压缩、滤波和重建至关重要，示例中计算了复数变换矩阵的共轭转置。
示例7. 控制系统 - 复数状态空间
计算复数状态空间矩阵的共轭转置
一个复数状态空间矩阵
state_matrix = [
[-1 + 2@i, 3 - 1@i],
[0.5 + 0.5@i, -2 - 3@i]
]
state_dagger = ctranspose(state_matrix)
print("状态矩阵 A:")
print(sp.Matrix(state_matrix))
print("共轭转置 Aᴴ:")
print(state_dagger)
#状态矩阵 A:
#[[-1.0 + 2.0i, 3.0 - 1.0i],
[0.5 + 0.5i, -2.0 - 3.0i]]
#共轭转置 A:
#[[-1 - 2i, 0.5 - 0.5i],
[3 + i, -2 + 3i]])
#说明: 在控制系统中，复数状态空间矩阵的共轭转置用于分析系统稳定性。
#特别是对于具有复数极点的系统，共轭转置提供了重要的分析工具，示例中计算了复数状态空间矩阵的共轭转置。
示例8. 实数矩阵的特殊情况
计算实数矩阵的共轭转置（等同于普通转置）
一个实数矩阵
real_matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
real_dagger = ctranspose(real_matrix)
real_transpose = sp.Matrix(real_matrix).T
print("实数矩阵:")
print(sp.Matrix(real_matrix))
print("共轭转置（等同于转置）:")
print(real_dagger)
print("普通转置:")
print(real_transpose)
print("两者是否相等:", real_dagger == real_transpose)
#实数矩阵:
#[[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]
#共轭转置（等同于转置）:
#[[1, 4, 7],
[2, 5, 8],
[3, 6, 9]]
#普通转置:
#[[1, 4, 7],
[2, 5, 8],
[3, 6, 9]]
#两者是否相等: True
#说明: 对于实数矩阵，共轭转置等同于普通转置。
#这是因为实数的共轭等于其自身，示例中展示了实数矩阵的共轭转置计算。
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
def conjugation_transpose_matrix(input_str):
"""
计算输入字符串所表示的矩阵的共轭转置。
参数:
input_str: 输入的字符串，可能表示一个矩阵。
返回:
如果输入是有效的矩阵，则返回其共轭转置矩阵；否则返回错误信息。
"""
try:
# 使用 sympy 的 sympify 函数将输入字符串转换为 SymPy 表达式
expr = sp.sympify(input_str)
# 初始化错误标志和结果变量
error = False
result = None
# 检查转换后的表达式是否为元组
# 如果是元组，说明输入不是有效的矩阵形式，将错误标志设为 True
if isinstance(expr, tuple):
error = True
# 如果是矩阵，则计算其共轭转置
elif isinstance(expr, list):
A = sp.Matrix(expr)
result = A.H
# 若表达式既不是矩阵也不是可转换为矩阵的形式，将错误标志设为 True
else:
error = True
# 如果没有错误，返回计算结果；否则返回错误信息
return result if not error else f"输入错误: {input_str}"
except Exception as e:
# 若在转换或计算过程中出现异常，返回错误信息
return f"错误:{e}"
def main():
"""
主程序，用于测试 conjugation_transpose_matrix 函数。
"""
# 定义测试用的输入字符串
test_inputs = [
"[[1, 2], [3, 4]]",
# Matrix([[1, 3],
# [2, 4]])
]
# 遍历测试输入，调用 conjugation_transpose_matrix 函数并打印结果
for input_str in test_inputs:
result = conjugation_transpose_matrix(input_str)
print(f"输入: {input_str}")
print(f"结果: {result}")
print()
if __name__ == "__main__":
# 调用主程序
main()
M = cummax(A) 返回 A 的累积最大元素。
如果 A 是向量，则 M 是具有相同大小和类型的向量，并且包含 A 的累积最大值。
如果 A 是矩阵，则 M 是具有相同大小和类型的矩阵，并且包含 A 的每列中的累积最大值。
M = cummax(A,dim) 返回沿维度 dim 的累积最大值。例如，如果 A 是矩阵，则 cummin(A,2) 沿 A 的各行返回累积最大值。
M = cummax(___,direction) 可在上述任一语法的基础上指定计算方向。例如，cummin(A,2,"reverse") 通过从尾到头计算 A 的第二个维度返回 A 的累积最大值。
M = cummax(___,nanflag) 指定忽略还是包括 A 中的 NaN 值。例如，cummin(A,"includenan") 在计算每个最大值时包含 NaN 值。默认情况下，cummin 忽略 NaN 值。
A — 输入数组, 向量 | 矩阵
dim — 沿其运算的维度, 正整数标量
direction — 累积方向, "forward" (默认) | "reverse"
nanflag — 缺失值条件, "omitmissing" (默认) | "omitnan" | "includemissing" | "includenan"
示例1. 金融分析 - 股票价格历史高点
计算股票价格的累积最大值（历史最高点）
stock_prices = [100, 105, 98, 110, 107, 115, 112, 120]
cummax_prices = cummax(stock_prices)
print("每日股价:", stock_prices)
print("历史最高点:", cummax_prices)
#每日股价: [100, 105, 98, 110, 107, 115, 112, 120]
#历史最高点: [100.0, 105.0, 105.0, 110.0, 110.0, 115.0, 115.0, 120.0]
#说明: 累积最大值表示到每个时间点的历史最高价格，用于分析股票表现。
#这对于分析股票表现、识别支撑位和阻力位非常重要，示例中计算了股票价格的历史高点。
示例2. 气象学 - 温度记录
计算一年中每日最高温度的累积最大值
daily_temps = [15, 18, 22, 20, 25, 23, 28, 26, 30, 27, 25, 22]
cummax_temps = cummax(daily_temps)
print("每日最高温度:", daily_temps)
print("年度温度记录:", cummax_temps)
#每日最高温度: [15, 18, 22, 20, 25, 23, 28, 26, 30, 27, 25, 22]
#年度温度记录: [15.0, 18.0, 22.0, 22.0, 25.0, 25.0, 28.0, 28.0, 30.0, 30.0, 30.0, 30.0]
#说明: 累积最大值显示了一年中的温度记录。
#这对于分析气候变化趋势和极端天气事件非常重要，示例中计算了年度最高温度记录。
示例3. 工程测量 - 传感器峰值检测
计算传感器读数的累积最大值，检测峰值
sensor_data = [2.5, 3.1, 2.8, 3.5, 3.2, 4.0, 3.7, 3.9, 3.6]
cummax_sensor = cummax(sensor_data)
print("传感器读数:", sensor_data)
print("峰值检测:", cummax_sensor)
#传感器读数: [2.5, 3.1, 2.8, 3.5, 3.2, 4.0, 3.7, 3.9, 3.6]
#峰值检测: [2.5, 3.1, 3.1, 3.5, 3.5, 4.0, 4.0, 4.0, 4.0]
#说明: 累积最大值帮助识别传感器读数中的峰值，这对于故障检测、性能监控和预警系统非常重要。
#示例中展示了如何使用累积最大值检测传感器峰值。
示例4. 运动科学 - 运动员表现追踪
计算运动员成绩的累积最大值，追踪个人最佳表现
athlete_scores = [8.5, 8.7, 8.6, 9.0, 8.8, 9.2, 9.1, 9.5, 9.3]
cummax_scores = cummax(athlete_scores)
print("每次比赛成绩:", athlete_scores)
print("个人最佳成绩:", cummax_scores)
#每次比赛成绩: [8.5, 8.7, 8.6, 9.0, 8.8, 9.2, 9.1, 9.5, 9.3]
#个人最佳成绩: [8.5, 8.7, 8.7, 9.0, 9.0, 9.2, 9.2, 9.5, 9.5]
#说明: 累积最大值显示运动员的个人最佳表现，这对于评估进步、设定目标和优化训练计划非常重要。
#示例中计算了运动员成绩的个人最佳记录。
示例5. 经济学 - GDP增长分析
计算年度GDP的累积最大值，分析经济增长
gdp_data = [100, 105, 103, 110, 108, 115, 112, 120, 118, 125]
cummax_gdp = cummax(gdp_data)
print("年度GDP:", gdp_data)
print("历史最高GDP:", cummax_gdp)
#年度GDP: [100, 105, 103, 110, 108, 115, 112, 120, 118, 125]
#历史最高GDP: [100.0, 105.0, 105.0, 110.0, 110.0, 115.0, 115.0, 120.0, 120.0, 125.0]
#说明: 累积最大值显示经济的历史最高水平，这对于分析经济增长和衰退周期、制定经济政策非常重要。
#示例中计算了年度GDP的历史最高值。
示例6. 二维数据 - 多指标分析
计算多个指标的累积最大值（按列计算）
multi_metrics = [
[80, 70, 90], # 时间点1: 指标A, B, C
[85, 75, 85], # 时间点2
[82, 80, 95], # 时间点3
[90, 78, 92] # 时间点4
]
cummax_2d = cummax(multi_metrics)
print("各指标累积最大值:")
print(cummax_2d)
#各指标累积最大值:
#[[80.0, 70.0, 90.0],
[85.0, 75.0, 90.0],
[85.0, 80.0, 95.0],
[90.0, 80.0, 95.0]]
#说明: 对于多指标数据，累积最大值可以按列计算，显示每个指标的历史最高值
#示例中展示了如何计算多个指标的累积最大值。
示例7. 反向累积最大值 - 未来展望分析
计算反向累积最大值，分析从未来回看的最高值
future_data = [10, 15, 12, 18, 16, 20, 17, 22]
reverse_cummax = cummax(future_data, reverse)
print("数据序列:", future_data)
print("反向累积最大值:", reverse_cummax)
#数据序列: [10, 15, 12, 18, 16, 20, 17, 22]
#反向累积最大值: [10, 15, 15, 18, 18, 20, 20, 22]
#说明: 反向累积最大值表示从未来回看的最高值，这对于分析数据的未来潜力和制定长期策略非常重要。
#示例中计算了数据的反向累积最大值。
示例8. 三维数据 - 多变量时间序列
计算三维数据的累积最大值（按不同维度）
创建一个2x3x4的三维数组（2个变量，3个时间点，4个测量值）
three_d_data = [
[[5, 3, 7, 2], [2, 6, 1, 4], [4, 2, 3, 5]],
[[8, 1, 5, 3], [9, 4, 6, 2], [3, 7, 2, 6]]
]
cummax_3d_dim2 = cummax(three_d_data, 2) # 沿第二个维度
cummax_3d_dim3 = cummax(three_d_data, 3) # 沿第三个维度
print("沿第二个维度的累积最大值:")
print(cummax_3d_dim2)
print("沿第三个维度的累积最大值:")
print(cummax_3d_dim3)
#沿第二个维度的累积最大值:
#[[[5.0, 3.0, 7.0, 2.0],
[5.0, 6.0, 7.0, 4.0],
[5.0, 6.0, 7.0, 5.0]],
[[8.0, 1.0, 5.0, 3.0],
[9.0, 4.0, 6.0, 3.0],
[9.0, 7.0, 6.0, 6.0]]]
#沿第三个维度的累积最大值:
#[[[5.0, 5.0, 7.0, 7.0],
[2.0, 6.0, 6.0, 6.0],
[4.0, 4.0, 4.0, 5.0]],
[[8.0, 8.0, 8.0, 8.0],
[9.0, 9.0, 9.0, 9.0],
[3.0, 7.0, 7.0, 7.0]]]
#说明: 对于三维数据，可以沿不同维度计算累积最大值，这对于分析多变量时间序列和复杂系统非常重要。
#示例中展示了如何沿不同维度计算三维数据的累积最大值
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import numpy as np
import sympy as sp
def cumulative_max_symbolic(input_str):
"""
处理符号累积和的入口函数，解析输入参数并调用核心计算函数。
参数:
input_expr: 输入的表达式，可以是矩阵、列表或包含矩阵及参数的元组
返回:
累积和的结果或错误信息
"""
try:
input_expr = sp.sympify(input_str)
result = None
def cummax(A, dim=None, direction='forward', nanflag='propagate'):
"""
MATLAB cummax函数的NumPy实现
参数:
A: 输入数组
dim: 计算累积最大值的维度，默认为第一个非单一维度
direction: 累积方向，'forward'（默认）或'backward'
nanflag: NaN处理方式，'propagate'（默认）或'omitnan'
返回:
与A形状相同的数组，包含累积最大值
"""
A = np.asarray(A)
# 处理dim参数（默认行为：选择第一个非单一维度）
if dim is None:
if A.size == 0:
dim = 0
else:
dim = next((i for i, s in enumerate(A.shape) if s > 1), 0)
# 处理direction参数
if direction == 'backward':
# 对于后向累积，先反转数组，计算前向累积，再反转回来
slices = [slice(None)] * A.ndim
slices[dim] = slice(None, None, -1)
A_reversed = A[tuple(slices)]
if nanflag == 'omitnan':
# 对每个切片单独处理NaN
result = np.apply_along_axis(_cummax_omitnan, dim, A_reversed)
else:
result = np.maximum.accumulate(A_reversed, axis=dim)
# 反转结果恢复原始顺序
result = result[tuple(slices)]
return result
else: # forward
if nanflag == 'omitnan':
# 对每个切片单独处理NaN
return np.apply_along_axis(_cummax_omitnan, dim, A)
else:
return np.maximum.accumulate(A, axis=dim)
def _cummax_omitnan(arr):
"""辅助函数：处理包含NaN的数组，忽略NaN计算累积最大值"""
mask = np.isnan(arr)
if np.all(mask):
return np.full_like(arr, np.nan)
# 找到第一个非NaN值
first_valid = next((i for i, x in enumerate(arr) if not np.isnan(x)), 0)
result = np.full_like(arr, np.nan)
result[first_valid] = arr[first_valid]
# 计算剩余位置的累积最大值
for i in range(first_valid + 1, len(arr)):
if not np.isnan(arr[i]):
result[i] = max(result[i - 1], arr[i])
else:
result[i] = result[i - 1]
return result
# 解析输入表达式
if isinstance(input_expr, tuple):
if not isinstance(input_expr[0], list):
raise ValueError(f"输入错误:{input_str}")
else:
A = sp.Array(input_expr[0])
params = input_expr[1:]
dim = None # 默认让函数内部处理
direction = 'forward'
nanflag = 'includenan'
# 解析参数
for param in params:
if isinstance(param, (int, sp.Integer)):
dim = int(param) - 1
elif str(param).lower() in ['forward', 'reverse']:
direction = str(param).lower()
elif str(param).lower() in ['includenan', 'omitnan']:
nanflag = str(param).lower()
# 参数校验
if dim is not None and dim not in [1, 2]:
return f"错误: 维度参数 dim 必须为 1 或 2，当前为 {dim}"
if direction not in ['forward', 'reverse']:
return f"错误: 方向参数 direction 必须为 'forward' 或 'reverse'，当前为 {direction}"
if nanflag not in ['includenan', 'omitnan']:
return f"错误: nanflag 参数无效，当前为 {nanflag}"
# 调用核心计算函数
np_a = np.asarray(A.tolist(), dtype=float)
result = cummax(np_a, dim=dim, direction=direction, nanflag=nanflag)
else:
# 输入为单一矩阵
if not isinstance(input_expr, list):
raise ValueError(f"输入错误:{input_str}")
else:
A = sp.Array(input_expr)
np_a = np.asarray(A.tolist(), dtype=float)
result = cummax(np_a)
return result
except Exception as e:
return f"错误: {e}"
# 三维数组示范代码
if __name__ == "__main__":
# 创建三维示例数组 (2x3x3)
A_3d = "[[[5, 3, 7],[2, 6, 1],[4, 2, 3]],[[8, 1, 5],[9, 4, 6],[3, nan,2]]]"
print("\n=== 三维数组示例 (2x3x3) ===")
print("原始数组:\n", A_3d)
# 默认参数（处理第一个非单一维度，这里是dim=0）
print("\n默认参数 (dim=0):\n", cumulative_max_symbolic(f"{A_3d}"))
# [[[ 5. 3. 7.]
# [ 2. 6. 1.]
# [ 4. 2. 3.]]
#
# [[ 8. 3. 7.]
# [ 9. 6. 6.]
# [ 4. nan 3.]]]
# 后向累积 (direction='backward')
print("\n后向累积 (dim=2, direction='backward'):\n",
cumulative_max_symbolic(f"{A_3d},2,backward"))
# [[[ 5. 3. 7.]
# [ 5. 6. 7.]
# [ 5. 6. 7.]]
#
# [[ 8. 1. 5.]
# [ 9. 4. 6.]
# [ 9. nan 6.]]]
M = cummin(A) 返回 A 的累积最小元素。
如果 A 是向量，则 M 是具有相同大小和类型的向量，并且包含 A 的累积最小值。
如果 A 是矩阵，则 M 是具有相同大小和类型的矩阵，并且包含 A 的每列中的累积最小值。
M = cummin(A,dim) 返回沿维度 dim 的累积最小值。例如，如果 A 是矩阵，则 cummin(A,2) 沿 A 的各行返回累积最小值。
M = cummin(___,direction) 可在上述任一语法的基础上指定计算方向。例如，cummin(A,2,"reverse") 通过从尾到头计算 A 的第二个维度返回 A 的累积最小值。
M = cummin(___,nanflag) 指定忽略还是包括 A 中的 NaN 值。例如，cummin(A,"includenan") 在计算每个最小值时包含 NaN 值。默认情况下，cummin 忽略 NaN 值。
A — 输入数组, 向量 | 矩阵
dim — 沿其运算的维度, 正整数标量
direction — 累积方向, "forward" (默认) | "reverse"
nanflag — 缺失值条件, "omitmissing" (默认) | "omitnan" | "includemissing" | "includenan"
示例1. 金融分析 - 股票价格历史低点
计算股票价格的累积最小值（历史最低点）")
stock_prices = [100, 95, 105, 90, 110, 85, 115, 80]
cummin_prices = cummin(stock_prices)
print("每日股价:", stock_prices)
print("历史最低点:", cummin_prices)
#每日股价: [100, 95, 105, 90, 110, 85, 115, 80]
#历史最低点: [100.0, 95.0, 95.0, 90.0, 90.0, 85.0, 85.0, 80.0]
#说明: 累积最小值表示到每个时间点的历史最低价格，这对于分析股票支撑位、识别买入机会非常重要。
#示例中计算了股票价格的历史低点
示例2. 气象学 - 温度记录低点
计算一年中每日最低温度的累积最小值
daily_temps = [15, 12, 10, 8, 7, 9, 6, 5, 8, 10, 12, 14]
cummin_temps = cummin(daily_temps)
print("每日最低温度:", daily_temps)
print("年度温度最低记录:", cummin_temps)
#每日最低温度: [15, 12, 10, 8, 7, 9, 6, 5, 8, 10, 12, 14]
#年度温度最低记录: [15.0, 12.0, 10.0, 8.0, 7.0, 7.0, 6.0, 5.0, 5.0, 5.0, 5.0, 5.0]
#说明: 累积最小值显示了一年中的温度最低记录，帮助分析寒冷期和霜冻风险。
#示例中计算了年度最低温度记录。
示例3. 工程测量 - 传感器最低值检测
计算传感器读数的累积最小值，检测异常低值
sensor_data = [5.2, 4.8, 5.5, 4.2, 5.8, 3.9, 6.1, 3.5, 6.5]
cummin_sensor = cummin(sensor_data)
print("传感器读数:", sensor_data)
print("最低值检测:", cummin_sensor)
#传感器读数: [5.2, 4.8, 5.5, 4.2, 5.8, 3.9, 6.1, 3.5, 6.5]
#最低值检测: [5.2, 4.8, 4.8, 4.2, 4.2, 3.9, 3.9, 3.5, 3.5]
#说明: 累积最小值帮助识别传感器读数中的异常低值，用于故障检测和系统监控。
#示例中展示了如何使用累积最小值检测传感器异常低值。
示例4. 水资源管理 - 河流水位监测
计算河流水位的累积最小值，监测干旱情况
water_levels = [3.5, 3.2, 3.8, 2.9, 4.1, 2.5, 4.5, 2.2, 5.0]
cummin_water = cummin(water_levels)
print("河流水位:", water_levels)
print("历史最低水位:", cummin_water)
#河流水位: [3.5, 3.2, 3.8, 2.9, 4.1, 2.5, 4.5, 2.2, 5.0]
#历史最低水位: [3.5, 3.2, 3.2, 2.9, 2.9, 2.5, 2.5, 2.2, 2.2]
#说明: 累积最小值显示河流的历史最低水位，用于干旱预警和水资源管理。
#示例中计算了河流水位的历史最低点
示例5. 经济学 - 通货膨胀率分析
计算月度通货膨胀率的累积最小值，分析通缩风险
inflation_rates = [2.5, 2.3, 2.1, 1.8, 1.5, 1.2, 0.9, 0.7, 0.5, 0.8, 1.0, 1.3]
cummin_inflation = cummin(sinflation_rates)
print("月度通胀率:", inflation_rates)
print("历史最低通胀率:", cummin_inflation)
#月度通胀率: [2.5, 2.3, 2.1, 1.8, 1.5, 1.2, 0.9, 0.7, 0.5, 0.8, 1.0, 1.3]
#历史最低通胀率: [2.5, 2.3, 2.1, 1.8, 1.5, 1.2, 0.9, 0.7, 0.5, 0.5, 0.5, 0.5]
#说明: 累积最小值显示经济的历史最低通胀率，帮助分析通缩风险和货币政策，经济预测非常重要。
#示例中计算了月度通胀率的历史最低值。
示例6. 二维数据 - 多指标最低值分析
计算多个指标的累积最小值（按列计算）
multi_metrics = [
[80, 70, 90], # 时间点1: 指标A, B, C
[75, 65, 85], # 时间点2
[82, 60, 95], # 时间点3
[70, 55, 92] # 时间点4
]
cummin_2d = cummin(multi_metrics)
print("各指标累积最小值:")
print(cummin_2d)
#各指标累积最小值:
#[[80.0, 70.0, 90.0],
[75.0, 65.0, 85.0],
[75.0, 60.0, 85.0],
[70.0, 55.0, 85.0]]
#说明: 对于多指标数据，累积最小值可以按列计算，显示每个指标的历史最低值。
#这对于同时追踪多个指标的历史最低值非常重要。
示例7. 反向累积最小值 - 未来展望分析
计算反向累积最小值，分析从未来回看的最低值
future_data = [20, 18, 22, 16, 24, 14, 26, 12]
reverse_cummin = cummin(future_data, reverse)
print("数据序列:", future_data)
print("反向累积最小值:", reverse_cummin)
#数据序列: [20, 18, 22, 16, 24, 14, 26, 12]
#反向累积最小值: [20, 18, 18, 16, 16, 14, 14, 12]
#说明: 反向累积最小值表示从未来回看的最低值，用于分析数据的潜在风险和制定应对策略非常重要。
#示例中计算了数据的反向累积最小值。
示例8. 三维数据 - 多变量时间序列最低值
计算三维数据的累积最小值（按不同维度）
创建一个2x3x4的三维数组（2个变量，3个时间点，4个测量值）
three_d_data = [
[[5, 3, 7, 2], [2, 6, 1, 4], [4, 2, 3, 5]],
[[8, 1, 5, 3], [9, 4, 6, 2], [3, 7, 2, 6]]
]
cummin_3d_dim2 = cummin(three_d_data, 2) # 沿第二个维度
cummin_3d_dim3 = cummin(three_d_data, 3) # 沿第三个维度
print("沿第二个维度的累积最小值:")
print(cummin_3d_dim2)
print("沿第三个维度的累积最小值:")
print(cummin_3d_dim3)
#沿第二个维度的累积最小值:
#[[[5.0, 3.0, 7.0, 2.0],
[2.0, 3.0, 1.0, 2.0],
[2.0, 2.0, 1.0, 2.0]],
[[8.0, 1.0, 5.0, 3.0],
[8.0, 1.0, 5.0, 2.0],
[3.0, 1.0, 2.0, 2.0]]]
#沿第三个维度的累积最小值:
#[[[5.0, 3.0, 3.0, 2.0],
[2.0, 2.0, 1.0, 1.0],
[4.0, 2.0, 2.0, 2.0]],
[[8.0, 1.0, 1.0, 1.0],
[9.0, 4.0, 4.0, 2.0],
[3.0, 3.0, 2.0, 2.0]]]
#说明: 对于三维数据，可以沿不同维度计算累积最小值，用于多变量时间序列分析和复杂系统。
#示例中展示了如何沿不同维度计算三维数据的累积最小值。
示例9. 能源管理 - 电力需求最低点
计算电力需求的累积最小值，识别用电低谷期
power_demand = [500, 480, 520, 450, 550, 420, 600, 400, 650]
cummin_power = cummin(power_demand)
print("电力需求:", power_demand)
print("历史最低需求:", cummin_power)
#电力需求: [500, 480, 520, 450, 550, 420, 600, 400, 650]
#历史最低需求: [500.0, 480.0, 480.0, 450.0, 450.0, 420.0, 420.0, 400.0, 400.0]
#说明: 累积最小值显示电力需求的历史最低点，用于能源规划和需求侧管理和电价制定。
#示例中计算了电力需求的历史最低点。
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import numpy as np
import sympy as sp
def cumulative_min_symbolic(input_str):
"""
处理符号累积和的入口函数，解析输入参数并调用核心计算函数。
参数:
input_expr: 输入的表达式，可以是矩阵、列表或包含矩阵及参数的元组
返回:
累积和的结果或错误信息
"""
try:
input_expr = sp.sympify(input_str)
result = None
def cummin(A, dim=None, direction='forward', nanflag='propagate'):
"""
MATLAB cummin函数的NumPy实现
参数:
A: 输入数组
dim: 计算累积最小值的维度，默认为第一个非单一维度
direction: 累积方向，'forward'（默认）或'backward'
nanflag: NaN处理方式，'propagate'（默认）或'omitnan'
返回:
与A形状相同的数组，包含累积最小值
"""
A = np.asarray(A)
# 处理dim参数（默认行为：选择第一个非单一维度）
if dim is None:
if A.size == 0:
dim = 0
else:
dim = next((i for i, s in enumerate(A.shape) if s > 1), 0)
# 处理direction参数
if direction == 'backward':
# 对于后向累积，先反转数组，计算前向累积，再反转回来
slices = [slice(None)] * A.ndim
slices[dim] = slice(None, None, -1)
A_reversed = A[tuple(slices)]
if nanflag == 'omitnan':
# 对每个切片单独处理NaN
result = np.apply_along_axis(_cummin_omitnan, dim, A_reversed)
else:
result = np.minimum.accumulate(A_reversed, axis=dim)
# 反转结果恢复原始顺序
result = result[tuple(slices)]
return result
else: # forward
if nanflag == 'omitnan':
# 对每个切片单独处理NaN
return np.apply_along_axis(_cummin_omitnan, dim, A)
else:
return np.minimum.accumulate(A, axis=dim)
def _cummin_omitnan(arr):
"""辅助函数：处理包含NaN的数组，忽略NaN计算累积最小值"""
mask = np.isnan(arr)
if np.all(mask):
return np.full_like(arr, np.nan)
# 找到第一个非NaN值
first_valid = next((i for i, x in enumerate(arr) if not np.isnan(x)), 0)
result = np.full_like(arr, np.nan)
result[first_valid] = arr[first_valid]
# 计算剩余位置的累积最小值
for i in range(first_valid + 1, len(arr)):
if not np.isnan(arr[i]):
result[i] = min(result[i - 1], arr[i])
else:
result[i] = result[i - 1]
return result
# 解析输入表达式
if isinstance(input_expr, tuple):
if not isinstance(input_expr[0], list):
raise ValueError(f"输入错误:{input_str}")
else:
A = sp.Array(input_expr[0])
params = input_expr[1:]
dim = None # 默认让函数内部处理
direction = 'forward'
nanflag = 'includenan'
# 解析参数
for param in params:
if isinstance(param, (int, sp.Integer)):
dim = int(param) - 1
elif str(param).lower() in ['forward', 'reverse']:
direction = str(param).lower()
elif str(param).lower() in ['includenan', 'omitnan']:
nanflag = str(param).lower()
# 参数校验
if dim is not None and dim not in [1, 2]:
return f"错误: 维度参数 dim 必须为 1 或 2，当前为 {dim}"
if direction not in ['forward', 'reverse']:
return f"错误: 方向参数 direction 必须为 'forward' 或 'reverse'，当前为 {direction}"
if nanflag not in ['includenan', 'omitnan']:
return f"错误: nanflag 参数无效，当前为 {nanflag}"
# 调用核心计算函数
np_a = np.asarray(A.tolist(), dtype=float)
result = cummin(np_a, dim=dim, direction=direction, nanflag=nanflag)
else:
# 输入为单一矩阵
if not isinstance(input_expr, list):
raise ValueError(f"输入错误:{input_str}")
else:
A = sp.Array(input_expr)
np_a = np.asarray(A.tolist(), dtype=float)
result = cummin(np_a)
return result
except Exception as e:
return f"错误: {e}"
# 示例用法
if __name__ == "__main__":
# 创建示例数组
# 测试不同参数组合
# 默认参数
print(cumulative_min_symbolic("[[3,5,2],[1,6,3],[7,8,1]]"))
# [[3. 5. 2.]
# [1. 5. 2.]
# [1. 5. 1.]]
# 指定维度
print(cumulative_min_symbolic("[[3,5,2],[1,6,3],[7,8,1]],2"))
# [[3. 3. 2.]
# [1. 1. 1.]
# [7. 7. 1.]]
# 后向累积
print(cumulative_min_symbolic("[[3,5,nan,4],[2,6,2,9],[1,3,0,nan]],backward"))
# [[ 3. 5. nan 4.]
# [ 2. 5. nan 4.]
# [ 1. 3. nan nan]]
# 忽略NaN
print(cumulative_min_symbolic("[[3,5,nan,4],[2,6,2,9],[1,3,0,nan]],includenan"))
# [[ 3. 5. nan 4.]
# [ 2. 5. nan 4.]
# [ 1. 3. nan nan]]
# 指定维度
print(cumulative_min_symbolic("[[[5, 3, 7],[2, 6, 1],[4, 2, 3]],[[8, 1, 5],[9, 4, 6],[3, nan, 2]]],2"))
# [[[ 5. 3. 7.]
# [ 2. 3. 1.]
# [ 2. 2. 1.]]
#
# [[ 8. 1. 5.]
# [ 8. 1. 5.]
# [ 3. nan 2.]]]
累积乘积
B = cumprod(A) 返回从 A 中大小不等于 1 的第一个数组维度的开头开始的 A 的累积乘积. 输出 B 的大小与 A 相同.
如果 A 是向量，则 cumprod(A) 返回一个包含 A 元素累积乘积的向量.
如果 A 是矩阵，则 cumprod(A) 返回一个包含 A 每一列累积乘积的矩阵.
B = cumprod(A,dim) 返回沿维度 dim 的累积乘积. 例如如果 A 是矩阵, 则 cumprod(A,2) 返回每行的累积乘积.
B = cumprod(___,direction) 使用任何先前的语法指定方向. 例如，cumprod(A,2,'reverse') 通过从第二维度的末尾到开头来返回 A 行内的累积乘积.
B = cumprod(___,nanflag) 指定是否在计算中包含或省略 NaN 值, 适用于任何先前的语法. cumprod(A,'includenan') 在计算中包含所有 NaN 值, 而 cumprod(A,'omitnan') 则忽略它们.
A — 输入数组,向量,矩阵.
dim — 沿正整数标量进行运算的维度, 只支持1(默认)或2.
direction — 累积方向, 'forward'（默认）| 'reverse'
nanflag — NaN 条件,'includenan'（默认）| 'omitnan'
示例1：金融投资中的复利计算
计算不同投资产品的累计收益率
investment_returns = [1.05, 1.03, 1.07, 0.98, 1.02] # 每年的收益率乘数
print(f"输入: {investment_returns}")
print(f"累计收益率: {cumprod(investment_returns)}")
#输入: [1.05, 1.03, 1.07, 0.98, 1.02]
#累计收益率: [1.05, 1.0815, 1.157205, 1.1340609, 1.156742118]
# 表示第1年增长5%，第2年累计增长8.15%，第3年累计增长15.72%...
示例2：制造业中的良品率累积计算
计算多工序生产线的累计良品率
process_yields = [0.95, 0.92, 0.97, 0.99] # 各工序的良品率
print(f"输入: {process_yields}")
print(f"累计良品率: {cumprod(process_yields)}")
#输入: [0.95, 0.92, 0.97, 0.99]
#累计良品率: [0.95, 0.874, 0.84778, 0.8393022]
# 表示经过第1道工序后良品率为95%，经过2道工序后为87.4%...
示例3：化学工程中的反应转化率
计算多级反应器的累计转化率
conversion_rates = [0.3, 0.4, 0.25, 0.35] # 各级反应器的转化率
print(f"输入: {conversion_rates}")
print(f"累计转化率: {cumprod(conversion_rates)}")
#输入: [0.3, 0.4, 0.25, 0.35]
#累计转化率: [0.3, 0.12, 0.03, 0.0105]
# 表示经过第1级反应器后剩余30%未反应，经过2级后剩余12%...
示例4：信号处理中的滤波器级联增益
计算多级滤波器的累计增益
filter_gains = ([[0.8, 0.9], [0.7, 0.85]], 2) # 二维滤波器增益矩阵
print(f"输入: {filter_gains}")
print(f"累计增益: {cumprod(filter_gains)}")
#输入: ([[0.8, 0.9], [0.7, 0.85]], 2)
#累计增益: [[0.8, 0.72], [0.7, 0.595]]
# 表示信号通过各级滤波器后的累计增益
示例5：供应链中的库存周转率
计算多环节供应链的库存周转累积效应
turnover_rates = [1.2, 0.9, 1.1, 1.05] # 各环节的库存周转率乘数
print(f"输入: {turnover_rates}")
print(f"累计效应: {cumprod(turnover_rates)}")
#输入: [1.2, 0.9, 1.1, 1.05]
#累计效应: [1.2, 1.08, 1.188, 1.2474]
# 表示经过各环节后库存周转的累积效应
示例6：能源系统中的效率损失累积
计算多级能源转换系统的效率累积
efficiency_factors = [0.95, 0.88, 0.92, 0.97] # 各级系统的效率
print(f"输入: {efficiency_factors}")
print(f"系统总效率: {cumprod(efficiency_factors)}")
#输入: [0.95, 0.88, 0.92, 0.97]
#系统总效率: [0.95, 0.836, 0.76912, 0.7460464]
# 表示能源经过各级转换后的总效率
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def cumulative_product_symbolic(input_str):
"""
对标MATLAB的cumprod函数，计算多维数组的累积乘积
参数:
input_str: 输入的字符串，表示数组或包含参数的元组
返回:
累积乘积结果或错误信息
"""
try:
expr = sp.sympify(input_str)
error = False
result = None
# 处理输入元组
if isinstance(expr, tuple):
elements = list(expr)
sp_array = sp.Array(elements[0]) if isinstance(elements[0], list) else None
if sp_array is None:
return f"输入错误: 无法解析数组 {elements[0]}"
params = elements[1:]
dim = None
direction = 'forward'
nanflag = 'includenan'
# 解析参数
for param in params:
if isinstance(param, (int, sp.Integer)):
dim = int(param)
elif str(param).lower() in ['forward', 'reverse']:
direction = str(param).lower()
elif str(param).lower() in ['includenan', 'omitnan']:
nanflag = str(param).lower()
# 将SymPy数组转换为NumPy数组
np_arr = np.asarray(sp_array, dtype=float)
# 处理NaN
if nanflag == 'omitnan':
# 对于多维数组，不能直接删除NaN，转为1
np_arr = np.nan_to_num(np_arr, nan=1.0)
# 处理方向参数
if direction == 'reverse':
# 反转数组
if dim is not None:
# 沿指定维度反转
np_arr = np.flip(np_arr, axis=dim - 1)
else:
# 默认沿第一个非单例维度
dim = next((i + 1 for i, s in enumerate(np_arr.shape) if s > 1), 1)
np_arr = np.flip(np_arr, axis=dim - 1)
# 处理维度参数 (MATLAB风格转为Python风格)
axis = dim - 1 if dim is not None else None
# 计算累积乘积
result = np.cumprod(np_arr, axis=axis)
# 如果是反向累积，需要再反转回来
if direction == 'reverse':
if dim is not None:
result = np.flip(result, axis=dim - 1)
else:
result = np.flip(result, axis=axis)
else:
# 处理简单数组输入
sp_array = sp.Array(expr) if isinstance(expr, list) else None
if sp_array is None:
return f"输入错误: {input_str}"
np_arr = np.asarray(sp_array, dtype=float)
result = np.cumprod(np_arr)
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {str(e)}"
# 测试用例
if __name__ == "__main__":
# 测试用例1: 一维数组，默认参数
print("测试1: 一维数组，默认参数")
input1 = '[1, 2, 3, 4]'
print(f"输入: {input1}")
print(f"输出: {cumulative_product_symbolic(input1)}")
print()
# 输出: [ 1. 2. 6. 24.]
# 测试用例2: 二维数组，指定维度2
print("测试2: 二维数组，指定维度2")
input2 = '([[1, 2, 3], [4, 5, 6]], 2)'
print(f"输入: {input2}")
print(f"输出: {cumulative_product_symbolic(input2)}")
print()
# 输出: [[ 1. 2. 6.]
# [ 4. 20. 120.]]
# 测试用例3: 二维数组，反向累积
print("测试3: 二维数组，反向累积")
input3 = '([[1, 2, 3], [4, 5, 6]], "reverse")'
print(f"输入: {input3}")
print(f"输出: {cumulative_product_symbolic(input3)}")
print()
# 输出: [[ 4. 10. 18.]
# [ 4. 5. 6.]]
# 测试用例4: 二维数组，忽略NaN
print("测试4: 二维数组，忽略NaN")
input4 = '([[1, nan, 3], [4, 5, nan]], "omitnan")'
print(f"输入: {input4}")
print(f"输出: {cumulative_product_symbolic(input4)}")
print()
# 输出: [ 1. 1. 3. 12. 60. 60.]
# 测试用例5: 三维数组，指定维度3
print("测试5: 三维数组，指定维度3")
input5 = '([[[1, 2], [3, 4]], [[5, 6], [7, 8]]], 3)'
print(f"输入: {input5}")
print(f"输出: {cumulative_product_symbolic(input5)}")
print()
# [[[ 1. 2.]
# [ 3. 12.]]
#
# [[ 5. 30.]
# [ 7. 56.]]]
# 测试用例6: 三维数组，反向累积
print("测试6: 三维数组，反向累积")
input6 = '([[[1, 2], [3, 4]], [[5, 6], [7, 8]]], 2, "reverse")'
print(f"输入: {input6}")
print(f"输出: {cumulative_product_symbolic(input6)}")
print()
# [[[ 3. 8.]
# [ 3. 4.]]
#
# [[35. 48.]
# [ 7. 8.]]]
累积和
B = cumsum(A) 返回从 A 中大小不等于 1 的第一个数组维度的开头开始的 A 的累积和.
如果 A 是向量, 则 B 是包含 A 累积和的相同大小的向量.
如果 A 是矩阵, 则 B 是包含 A 每一列累积和的相同大小的矩阵.
B = cumsum(A,dim) 返回维度 dim 上元素的累积和. 例如如果 A 是矩阵, 则 cumsum(A,2) 返回沿 A 行计算的累积和.
B = cumsum(___,direction) 指定任何先前语法的方向. 例如, cumsum(A,2,"reverse") 通过从第二维的末尾到开头计算，返回 A 行内的累积和.
B = cumsum(___,nanflag) 指定是否在 A 中包含或忽略 NaN 值. 例如, cumsum(A,"omitnan") 在计算每个和时忽略 NaN 值. 默认情况下, cumsum 包含 NaN 值.
A — 输入数组,向量,矩阵.
dim — 沿正整数标量进行运算的维度, 只支持1(默认)或2.
direction — 累积方向, 'forward'（默认）| 'reverse'
nanflag — NaN 条件,"includemissing" (默认) | "includenan" | "omitmissing" | "omitnan"
“includemissing” 或 “includenan” — 计算累积和时包含 A 中的 NaN 值. 一旦遇到 A 中的第一个 NaN 值, B 中的元素即为 NaN. “includemissing” 和 “includenan” 具有相同的行为.
“omitmissing” 或 “omitnan” — 计算累积和时忽略 A 中的 NaN 值. 如果 A 具有连续的前导 NaN 值, 则 B 中的相应元素为 0. “omitmissing” 和 “omitnan” 具有相同的行为.
示例1：制造业生产进度跟踪
计算生产线上每日产量累计
daily_production = [120, 135, 110, 145, 130] # 每日产量
print(f"输入: {daily_production}")
print(f"累计产量: {cumsum(daily_production)}")
#输入: [120, 135, 110, 145, 130]
#累计产量: [120.0, 255.0, 365.0, 510.0, 640.0]
# 表示第1天生产120件，第2天累计255件，第3天累计365件...
示例2：财务现金流分析
计算企业月度现金流累计
monthly_cashflow = [[-50000, 30000, 40000], [25000, 35000, 45000]] # 两个季度的月度现金流
print(f"输入: {monthly_cashflow}")
print(f"累计现金流: {cumsum(monthly_cashflow,2)}")
#输入: [[-50000, 30000, 40000], [25000, 35000, 45000]]
#累计现金流: [[-50000.0, -20000.0, 20000.0], [25000.0, 60000.0, 105000.0]]
# 表示第1季度现金流累计从-5万到+2万，第2季度从2.5万到10.5万
示例3：能源消耗监测
计算工厂各区域能耗累计
energy_consumption = [[120, 85, 110], [95, 130, 105], [115, 90, 125]] # 三个区域的小时能耗
print(f"输入: {energy_consumption}")
print(f"反向累计能耗: {cumsum(energy_consumption,1,reverse)}")
#输入: [[120, 85, 110], [95, 130, 105], [115, 90, 125]]
#反向累计能耗: [[330.0, 305.0, 340.0],
[210.0, 220.0, 230.0],
[115.0, 90.0, 125.0]]
# 表示从结束时间向前累计的能耗，用于分析峰值负载
示例4：供应链库存管理
计算多仓库库存变化累计
inventory_changes = [[50, -30, 20], [-10, 40, -15], [25, -20, 35]] # 三个仓库的每日库存变化
print(f"输入: {inventory_changes}")
print(f"库存累计变化: {cumsum(inventory_changes,omitnan)}")
#输入: [[50, -30, 20], [-10, 40, -15], [25, -20, 35]]
#库存累计变化: [[50.0, -30.0, 20.0],
[40.0, 10.0, 5.0],
[65.0, -10.0, 40.0]]
# 表示各仓库库存的累计变化，帮助预测库存需求
示例5：质量控制中的缺陷累计
计算生产批次缺陷累计
defect_counts = [3, 5, 2, 7, 4, 6] # 各批次产品的缺陷数量
print(f"输入: {defect_counts}")
print(f"累计缺陷: {cumsum(defect_counts)}")
#输入: [3, 5, 2, 7, 4, 6]
#累计缺陷: [3.0, 8.0, 10.0, 17.0, 21.0, 27.0]
# 表示生产过程中缺陷的累计数量，用于识别质量趋势
示例6：项目进度管理
计算项目各阶段任务完成累计
tasks_completed = [[8, 12, 10], [15, 9, 11], [7, 14, 13]] # 三周各阶段完成的任务数
print(f"输入: {tasks_completed}")
print(f"累计完成任务: {cumsum(tasks_completed,2)}")
#输入: [[8, 12, 10], [15, 9, 11], [7, 14, 13]]
#累计完成任务: [[8.0, 20.0, 30.0], [15.0, 24.0, 35.0], [7.0, 21.0, 34.0]]
# 表示各阶段累计完成的任务数量，用于评估项目进度
示例7：环境监测数据累计
计算污染物浓度累计
pollution_levels = [[0.5, 0.8, 1.2], [0.7, 0.9, 1.5]] # 两个监测点的污染物浓度
print(f"输入: {pollution_levels}")
print(f"累计浓度: {cumsum(pollution_levels,omitnan)}")
#输入: [[0.5, 0.8, 1.2], [0.7, 0.9, 1.5]]
#累计浓度: [[0.5, 0.8, 1.2], [1.2, 1.7, 2.7]]
# 表示污染物浓度的累计值，用于评估环境暴露风险
示例8：销售业绩累计分析
计算销售团队季度业绩累计
quarterly_sales = [[15000, 18000, 21000], [22000, 19000, 25000]], " # 两个团队的季度销售额
print(f"输入: {quarterly_sales}")
print(f"反向累计销售额: {cumsum(quarterly_sales,1,reverse)})
#输入: [[15000, 18000, 21000], [22000, 19000, 25000]]
#反向累计销售额: [[37000.0, 37000.0, 46000.0], [22000.0, 19000.0, 25000.0]]
# 表示从季度末向前累计的销售额，用于分析销售趋势
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def cumulative_sum_symbolic(input_str):
try:
input_expr = sp.sympify(input_str)
result = None
def cumsum_matlike(a, dim=None, direction='forward', nanflag='includenan'):
arr = np.asarray(a, dtype=float)
# 处理NaN值
if nanflag == 'omitnan':
arr = np.where(np.isnan(arr), 0, arr)
# 确定累积维度 (MATLAB默认按列累积，即dim=1)
if dim is None:
# 默认按列累积 (MATLAB行为)
axis = 0 if arr.ndim > 1 else 0
else:
# 将MATLAB维度转换为NumPy维度
axis = dim - 1
# 根据方向进行累积求和
if direction == 'reverse':
# 反转数组，进行正向累积，然后反转回原顺序
reversed_arr = np.flip(arr, axis=axis)
cum_result = np.cumsum(reversed_arr, axis=axis)
result = np.flip(cum_result, axis=axis)
else: # 'forward'
result = np.cumsum(arr, axis=axis)
return result
# 解析输入表达式
if isinstance(input_expr, tuple):
A = sp.Array(input_expr[0])
params = input_expr[1:]
dim = None # 默认让函数内部处理
direction = 'forward'
nanflag = 'includenan'
# 解析参数
for param in params:
if isinstance(param, (int, sp.Integer)):
dim = int(param)
elif str(param).lower() in ['forward', 'reverse']:
direction = str(param).lower()
elif str(param).lower() in ['includenan', 'omitnan']:
nanflag = str(param).lower()
# 参数校验
if dim is not None and dim not in [1, 2]:
return f"错误: 维度参数 dim 必须为 1 或 2，当前为 {dim}"
if direction not in ['forward', 'reverse']:
return f"错误: 方向参数 direction 必须为 'forward' 或 'reverse'，当前为 {direction}"
if nanflag not in ['includenan', 'omitnan']:
return f"错误: nanflag 参数无效，当前为 {nanflag}"
# 调用核心计算函数
np_a = np.asarray(A.tolist(), dtype=float)
result = cumsum_matlike(np_a, dim=dim, direction=direction, nanflag=nanflag)
else:
# 输入为单一矩阵
A = sp.Array(input_expr)
np_a = np.asarray(A.tolist(), dtype=float)
result = cumsum_matlike(np_a)
return result # 转换为列表格式输出
except Exception as e:
return f"错误: {e}"
# 测试修正后的代码
print(cumulative_sum_symbolic("[[3,5,nan,4],[2,6,nan,9],[1,3,5,nan]],omitnan"))
# 输出:
# [[ 3. 5. 0. 4.]
# [ 5. 11. 0. 13.]
# [ 6. 14. 5. 13.]]
符号向量场的旋度
c = curl(V) 返回向量场 V 相对于由 V 中的符号变量构造的默认向量的旋度.
通常情况下，向量场的旋度是对给定的函数关于变量 x,y 和 z 的偏导数而得到的，而不是针对特定的数值进行计算的.
V — 三维符号向量场, 符号标量变量的向量
示例1：电磁场分析（麦克斯韦方程）
在电磁学中，旋度操作符用于描述电场和磁场之间的关系（法拉第电磁感应定律和安培环路定律）。
计算磁场的旋度（安培环路定律）
result = curl(0, 0, B0*sin(omega*t - k*x))# 沿z方向的时变磁场
print(f"\n磁场旋度（安培环路定律）:")
print(f"x分量: {result[0]}")
print(f"y分量: {result[1]}")
print(f"z分量: {result[2]}")
#磁场旋度（安培环路定律）:
#x分量: 0
#y分量: B0*k*cos(k*x - omega*t)
#z分量: 0
示例2：流体力学中的涡量计算
在流体力学中，速度场的旋度表示流体的涡量，这是分析湍流和旋转流动的重要参数。
计算速度场的旋度（涡量）
result = curl(y, -x, 0)# 简单的旋转流场
print(f"\n速度场旋度（涡量）:")
print(f"x分量: {result[0]}")
print(f"y分量: {result[1]}")
print(f"z分量: {result[2]}")
#速度场旋度（涡量）:
#x分量: 0
#y分量: 0
#z分量: -2
示例3：结构力学中的应力分析
在弹性力学中，旋度可用于分析应力场和位移场的关系。
计算应力场的旋度
result = curl(x**2, y**2, z**2) # 假设的应力分布
print(f"\n应力场旋度:")
print(f"x分量: {result[0]}")
print(f"y分量: {result[1]}")
print(f"z分量: {result[2]}")
#应力场旋度:
#x分量: 0
#y分量: 0
#z分量: 0
示例4：热传导分析
在热力学中，温度梯度场的旋度可以揭示热流的不均匀性和可能的对流现象。
计算温度梯度场的旋度
result = curl(T0*exp(-alpha*x), 0, 0) # 沿x方向的指数衰减温度梯度
print(f"\n温度梯度场旋度:")
print(f"x分量: {result[0]}")
print(f"y分量: {result[1]}")
print(f"z分量: {result[2]}")
#温度梯度场旋度:
#x分量: 0
#y分量: 0
#z分量: 0
示例5：空气动力学中的环量计算
在空气动力学中，速度场的旋度积分可以给出翼型周围的环量，这是计算升力的关键参数。
计算复杂三维流场的旋度
result = curl(y*z, z*x, x*y) # 三维流场
print(f"\n三维流场旋度:")
print(f"x分量: {result[0]}")
print(f"y分量: {result[1]}")
print(f"z分量: {result[2]}")
#三维流场旋度:
#x分量: 0
#y分量: 0
#z分量: 0
示例6：电磁兼容性分析
在电磁兼容性(EMC)研究中，计算电场或磁场的旋度可以帮助识别潜在的电磁干扰源。
计算电场旋度（法拉第电磁感应定律）
result = curl(E0*cos(omega*t - k*z), 0, 0) # 沿x方向的平面波电场
print(f"\n电场旋度（法拉第定律）:")
print(f"x分量: {result[0]}")
print(f"y分量: {result[1]}")
print(f"z分量: {result[2]}")
#电场旋度（法拉第定律）:
#x分量: 0
#y分量: -E0*k*sin(k*z - omega*t)
#z分量: 0
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import sympy.physics.vector as svt
def curl_vector_field(input_str):
"""
计算矢量场的旋度，对标MATLAB的curl函数。
参数:
input_str (str): 矢量场的三个分量的字符串表达式，例如 "[x*y, y*z, z*x]"
返回:
tuple: 旋度的三个分量的SymPy表达式，或错误信息字符串。
"""
try:
F_expr = sp.sympify(input_str)
# 检查输入是否为三个分量的列表
if not isinstance(F_expr, tuple) or len(F_expr) != 3:
return "错误: 输入必须是包含三个分量的列表，例如 '[x*y, y*z, z*x]'"
# 创建一个参考坐标系
N = svt.ReferenceFrame('N')
# 将表达式中的符号变量替换为 N[0]、N[1] 和 N[2]
F_expr_substituted = [expr.subs({'x': N[0], 'y': N[1], 'z': N[2]}) for expr in F_expr]
# 将表达式转换为矢量场
F = F_expr_substituted[0] * N.x + F_expr_substituted[1] * N.y + F_expr_substituted[2] * N.z
# 计算矢量场的旋度
result = svt.curl(F, N)
# 计算每个分量的值
# 将 result_x 中的 N.x 替换为 x，N.y 替换为 y，N.z 替换为 z
result = result.subs({N[0]: sp.symbols('x'), N[1]: sp.symbols('y'), N[2]: sp.symbols('z')})
result_x = result.dot(N.x)
result_y = result.dot(N.y)
result_z = result.dot(N.z)
# 使用 f-string 组成结果字符串并返回
return result_x, result_y, result_z
except Exception as e:
return f"错误: {e}"
if __name__ == "__main__":
# 示例输入
input_str = "(x*y, y*z, z*x)"
print(f"输入矢量场: {input_str}")
# 计算旋度
result = curl_vector_field(input_str)
# 输出结果
if isinstance(result, tuple):
print("\n旋度计算结果:")
print(f"x分量: {result[0]}")
print(f"y分量: {result[1]}")
print(f"z分量: {result[2]}")
# x分量: -y
# y分量: -z
# z分量: -x
else:
print(result)
# 另一个示例：无旋场
input_str2 = "(y, x, 0)"
print(f"\n输入矢量场: {input_str2}")
result2 = curl_vector_field(input_str2)
if isinstance(result2, tuple):
print("\n旋度计算结果:")
print(f"x分量: {result2[0]}")
print(f"y分量: {result2[1]}")
print(f"z分量: {result2[2]}")
# x分量: 0
# y分量: 0
# z分量: 0
else:
print(result2)
输入角的余割(以弧度为单位)
余割函数在工业应用中确实有许多实际用途，特别是在波动、振动和信号处理等领域。
Y = csc(X) 返回X的元素的余割.csc函数按元素处理数组.该函数同时接受实数和复数输入.
对于X的实数值,csc(X)返回区间[-∞, - 1] 和 [1, ∞]内的实数值.
对于X的复数值,csc(X)返回复数值.
X — 输入角(以弧度为单位), 标量,向量,矩阵,多维数组,符号变量
示例1: 振动分析与共振频率计算
在某些振动系统中，余割函数出现在频率响应表达式中
t # 时间
ω # 角频率
ω_n = 50 # 自然频率 (rad/s)
ζ = 0.1 # 阻尼比
frequency_response = 1/sin(ω*t) * (1/sqrt((1-(ω/ω_n)**2)**2 + (2*ζ*ω/ω_n)**2)) #振动系统的频率响应函数
result1 = csc(frequency_response)
print(f"计算结果: {result1}")
#计算结果: csc(1/(sqrt(1.6e-5*ω**2 + (1 - ω**2/2500)**2)*sin(t*ω)))
示例2: 交流电路分析
在交流电路中，某些元件的阻抗计算涉及余割函数
f # 频率
C = 1e-6 # 电容 (F)
L = 0.1 # 电感 (H)
impedance = 1/(2*pi*f*C*sin(pi*f*sqrt(L*C))) # 特定电路配置下的阻抗表达式
result2 = csc(impedance)
print(f"计算结果: {result2}")
print(f"在f=60Hz处的值: {result2.subs(f, 60).evalf()}")
#计算结果: csc(500000.0/(pi*f*sin(0.000316227766016838*pi*f)))
#在f=60Hz处的值: -1.02168735776124
示例3: 光学系统设计
在某些光学系统中，余割函数用于描述光线路径
θ # 入射角
n1 = 1.0 # 第一种介质的折射率
n2 = 1.5 # 第二种介质的折射率
optical_path = 1/sin(θ) * sqrt(n2**2 - n1**2*sin(θ)**2) #特定光学配置中的光路函数
result3 = csc(optical_path)
print(f"计算结果: {result3}")
print(f"在θ=30°处的值: {result3.subs(θ, sp.rad(30)).evalf()}")
#计算结果: csc(1.5*sqrt(1 - 0.444444444444444*sin(θ)**2)/sin(θ))
#在θ=30°处的值: 3.24599715744638
示例4: 声学工程
在声学中，余割函数出现在某些声波传播模型中
x # 距离
k # 波数
a = 0.5 # 参数
sound_propagation = 1/sin(k*x) * exp(-a*x) #声波传播模型
result4 = csc(sound_propagation)
print(f"计算结果: {result4}")
#计算结果: csc(exp(-0.5*x)/sin(k*x))
示例5: 结构动力学
在结构动力学中，余割函数用于某些振动模式的描述
t # 时间
ω = 10 # 角频率 (rad/s)
φ # 相位角
structural_response = 1/sin(ω*t + φ) * (1 - cos(ω*t)) # 结构振动响应
result5 = csc(structural_response)
print(f"计算结果: {result5}")
print(f"在t=1s, φ=0处的值: {result5.subs({t: 1, φ: 0}).evalf()}")
#计算结果: csc((1 - cos(10*t))/sin(10*t + φ))
#在t=1s, φ=0处的值: 4.22554740170070
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def cosine_theta_value(input_str):
"""
计算输入表达式或矩阵的余割值 (csc)
参数:
input_str: 输入的字符串表达式，可以是矩阵、数值或符号表达式
返回:
计算结果 (浮点数或矩阵)，如果输入无效则返回错误信息字符串
"""
try:
# 将输入字符串解析为 SymPy 表达式
expr = sp.sympify(input_str)
error = False
result = None
# 处理元组类型输入 (不支持)
if isinstance(expr, tuple):
error = True
# 处理矩阵类型输入
# 处理数值或符号表达式
elif expr.is_number:
z = complex(expr)
result = 1 / np.sin(z)
elif expr.free_symbols:
result = sp.csc(expr).evalf() # 计算余割并转为浮点数
else:
error = True
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {e}" # 返回异常信息
def main():
"""示例入口程序，演示不同输入情况下的行为"""
test_inputs = [
"pi/2", # (1+0j)
"2", # (1.0997501702946164+0j)
"x", # csc(x)
]
for inp in test_inputs:
print(f"输入: {inp}")
result = cosine_theta_value(inp)
print(f"结果: {result}\n{'-' * 30}")
if __name__ == "__main__":
main()
输入角的余割(以度为单位)
余割(cscd)函数这在工程应用中非常有用，因为许多工业标准和技术规范都使用度数而非弧度。
Y = cscd(X) 返回X元素的余割,以度为单位表示.
X — 角度(度),标量值,向量,矩阵,多维数组,符号变量
示例1：结构工程中的桁架分析
在结构工程中，余割函数用于计算桁架系统中杆件的内力。
计算桁架杆件内力
theta = 45 # 杆件与水平面的夹角（度）
F = 1000 # 施加的力（N）
# 杆件内力计算：F_csc = F / sin(theta)
input_str = str(theta)
csc_theta = cscd(input_str)
member_force = F * csc_theta
print(f"杆件角度: {theta}°")
print(f"余割值: {csc_theta}")
print(f"杆件内力: {member_force} N")
#杆件角度: 45°
#余割值: 1.41421356237310
#杆件内力: 1414.21356237310 N
示例2：机械工程中的斜面力学
在机械设计中，余割函数用于计算斜面上的力和效率。
计算斜面上的机械效率
alpha = 30 # 斜面角度（度）
mu = 0.2 # 摩擦系数
机械效率公式：η = 1 / (1 + μ * csc(alpha))
input_str = str(alpha)
csc_alpha = cscd(input_str)
efficiency = 1 / (1 + mu * csc_alpha)
print(f"斜面角度: {alpha}°")
print(f"余割值: {csc_alpha}")
print(f"机械效率: {efficiency:.3f}")
#斜面角度: 30°
#余割值: 2.00000000000000
#机械效率: 0.714
示例3：电力工程中的功率因数校正
在电力系统中，余割函数用于计算功率因数校正所需的电容值。
计算功率因数校正
phi = 60 # 当前功率因数角（度）
P = 1000 # 有功功率（W）
V = 220 # 电压（V）
f = 50 # 频率（Hz）
所需电容计算：C = P * (csc(phi_final) - csc(phi_initial)) / (2πfV²)
input_str = str(phi)
csc_phi = cscd(input_str)
假设目标功率因数角为30度
target_phi = 30
csc_target_phi = cscd(target_phi)
C = P * (csc_target_phi - csc_phi) / (2 * pi * f * V ** 2)
print(f"当前功率因数角: {phi}°")
print(f"目标功率因数角: {target_phi}°")
print(f"所需电容值: {C * 1e6:.2f} μF")
#当前功率因数角: 60°
#目标功率因数角: 30°
#所需电容值: 55.59 μF
示例4：摄影测量中的图像校正
在摄影测量和遥感中，余割函数用于计算图像畸变校正参数。
计算图像畸变校正因子
focal_length = 50 # 焦距（mm）
pixel_size = 0.005 # 像素尺寸（mm）
theta = 60 # 视场角（度）
畸变校正因子：correction_factor = csc(theta/2)
half_theta = theta / 2
input_str = str(half_theta)
csc_half_theta = cscd(input_str)
distortion_factor = csc_half_theta
print(f"半视场角: {half_theta}°")
print(f"余割值: {csc_half_theta}")
print(f"畸变校正因子: {distortion_factor:.3f}")
#半视场角: 30.0°
#余割值: 2.0
#畸变校正因子: 2.000
示例5：符号计算应用
这在理论分析和公式推导中非常有用。
# 符号计算示例
alpha # 角度符号变量
csc_alpha = cscd(alpha)
print(f"符号角度: {alpha}°")
print(f"符号余割表达式: {csc_alpha}")
#符号角度: alpha°
#符号余割表达式: csc(pi*alpha/180)
可以进一步进行符号运算
derivative = diff(csc_alpha, alpha)
print(f"余割对角度的导数: {derivative}")
#余割对角度的导数: -pi*cot(pi*alpha/180)*csc(pi*alpha/180)/180
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def cosine_theta_degree(input_str):
"""
计算输入表达式（矩阵、数值或符号）的余割(csc)值，角度以度数表示。
参数:
input_str: 输入的字符串，可以是矩阵、数值或符号表达式。
返回:
计算结果（矩阵、数值或符号表达式）或错误信息字符串。
"""
try:
# 将输入字符串转换为SymPy表达式
expr = sp.sympify(input_str)
error = False
result = None
# 处理元组输入（视为无效）
if isinstance(expr, tuple):
error = True
# 处理矩阵输入
# 处理数值或符号表达式
elif expr.is_number:
# 数值处理：将输入转换为NumPy数组（支持标量和向量）
z = complex(expr)
# 将角度转换为弧度
x_rad = z * np.pi / 180
# 计算正弦值
sin_values = np.sin(x_rad)
# 计算余割值（1/sin(x)）
result = 1 / sin_values
elif expr.free_symbols:
result = sp.csc(expr * sp.pi / 180)
# 其他类型视为错误
else:
error = True
# 根据错误标志返回结果或错误信息
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {e}"
if __name__ == '__main__':
# 示例1：计算30度的余割（应返回2.0）
input1 = '30'
result1 = cosine_theta_degree(input1)
print(f"输入: {input1}\n结果: {result1}\n")
# 结果: (2.0000000000000004+0j)
# 示例2：符号计算（返回符号表达式）
input2 = 'x'
result2 = cosine_theta_degree(input2)
print(f"输入: {input2}\n结果: {result2}\n")
# 结果: csc(pi*x/180)
双曲余割
双曲余割函数在工业应用中虽然不如三角函数常见，但在某些特定领域仍然具有重要价值，特别是在涉及指数衰减、波动方程和特殊函数的问题中。
Y = csch(X) 返回X的元素的双曲余割.csch函数按元素处理数组.该函数同时接受实数和复数输入.所有的角度都以弧度表示.
X — 角度(度),标量值,向量,矩阵,多维数组,符号变量
示例1: 电力传输线设计
高压输电线的悬链线方程中会用到双曲余割函数
x # 距离支撑点的水平距离
H = 5000 # 水平张力 (N)
w = 15 # 电线单位重量 (N/m)
sag_expression = H/w * (1/sinh(w*x/H)) #计算电线垂度相关函数
result1 = csch(sag_expression)
print(f"计算结果: {result1}")
print(f"在x=100m处的值: {result1.subs(x, 100).evalf()}")
#计算结果: csch(1000/(3*sinh(3*x/1000)))
#在x=100m处的值: 8.21410292795256E-476
示例2: 热传导问题
某些边界条件下的热传导方程解包含双曲余割函数
t # 时间
L = 0.5 # 材料厚度 (m)
alpha = 1.4e-5 # 热扩散系数 (m²/s)
heat_expression = 1/sinh(@pi**2 * alpha * t / L^2) #电线垂度相关函数表达式
result2 = csch(heat_expression)
print(f"计算结果: {result2}")
print(f"在t=3600s(1小时)处的值: {result2.subs(t, 3600).evalf()}")
#计算结果: csch(1/sinh(5.6e-5*pi**2*t))
#在t=3600s(1小时)处的值: 3.54231789371358
示例3: 电磁场分析
某些电磁场配置的势函数包含双曲余割项
z # 沿传输线方向的坐标
k # 波数
field_expression = 1/sinh(k*z) #电磁场分布函数表达式
result3 = csch(field_expression)
print(f"计算结果: {result3}")
#计算结果: csch(1/sinh(k*z))
示例4: 结构工程中的索结构分析
悬索桥主缆受力分析
s # 沿索长的弧坐标
T0 = 10000 # 索的水平拉力 (N)
q = 200 # 索的单位长度重量 (N/m)
cable_expression = T0 * (1/sinh(q*s/T0)) #索张力分布函数表达式
result4 = csch(cable_expression)
print(f"计算结果: {result4}")
print(f"在s=50m处的值: {result4.subs(s, 50).evalf()}")
#计算结果: csch(10000/sinh(s/50))
#在s=50m处的值: 6.46477683925057E-3696
示例5: 流体力学中的边界层问题
某些边界层流动问题的解
y # 距壁面的垂直距离
delta = 0.01 # 边界层厚度 (m)
boundary_expression = 1/sinh(y/delta) #边界层相关函数表达式
result5 = csch(boundary_expression)
print(f"计算结果: {result5}")
print(f"在y=0.005m处的值: {result5.subs(y, 0.005).evalf()}")
#计算结果: csch(1/sinh(100.0*y))
#在y=0.005m处的值: 0.299956693055871
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
def cosine_theta_hyperbolic(input_str):
"""
对输入的字符串表达式进行处理，计算双曲余割值。
参数:
input_str: 输入的字符串表达式。
返回:
如果输入有效，返回计算结果；否则返回错误信息。
"""
try:
# 将输入的字符串转换为 SymPy 表达式
expr = sp.sympify(input_str)
# 初始化错误标志和结果变量
error = False
result = None
# 检查表达式是否为元组，如果是则标记为错误
if isinstance(expr, tuple):
error = True
# 检查表达式是否为数字或包含自由符号
elif expr.is_number or expr.free_symbols:
# 若为数字或包含自由符号，对表达式应用双曲余割函数并求值
result = sp.csch(expr).evalf()
else:
# 其他情况标记为错误
error = True
# 如果没有错误，返回计算结果；否则返回错误信息
return result if not error else f"输入错误: {input_str}"
except Exception as e:
# 若处理过程中出现异常，返回错误信息
return f"错误:{e}"
def main():
"""
主程序，用于测试 cosine_theta_hyperbolic 函数。
"""
# 测试输入：单个数字
input1 = "2"
result1 = cosine_theta_hyperbolic(input1)
print(f"输入: {input1}, 结果: {result1}")
# 结果: 0.275720564771783
# 测试输入：包含符号的表达式
x = sp.Symbol('x')
input3 = str(x)
result3 = cosine_theta_hyperbolic(input3)
print(f"输入: {input3}, 结果: {result3}")
# 结果: csch(x)
if __name__ == "__main__":
main()
累积梯形数值积分
Q = cumtrapz(Y) 通过梯形法按单位间距计算 Y 的近似累积积分. Y 的大小确定求积分所沿用的维度.
如果 Y 是向量, 则 cumtrapz(Y) 是 Y 的累积积分.
如果 Y 是矩阵, 则 cumtrapz(Y) 是每一列的累积积分.
Q = cumtrapz(X,Y) 根据 X 指定的坐标或标量间距对 Y 进行积分.
如果 X 是坐标向量, 则 length(X) 必须等于 Y 的大小不等于 1 的第一个维度的大小.
如果 X 是标量间距, 则 cumtrapz(X,Y) 等于 X*cumtrapz(Y).
Q = cumtrapz(___,dim) 使用上述任意语法沿维度dim求积分. 必须指定Y,也可以指定X. 如果指定X,则它可以是长度等于 size(Y,dim) 的标量或向量. 例如, 如果Y是矩阵, 则 cumtrapz(X,Y,2) 对 Y 的每一行进行累积积分.
Y — 数值数据, 向量, 矩阵, 符号表达式
X — 点间距, 1 (默认),均匀的标量间距,坐标向量
dim — 沿其运算的维度, 正整数标量 (二维矩阵只有列或行,dim值为1或2)
示例1: 电力系统能量消耗计算
计算一段时间内的总能耗，给定功率随时间变化的数据
time_points = [0, 1, 2, 3, 4, 5] # 时间 (小时)
power_data = [10, 15, 12, 18, 14, 20] # 功率 (千瓦)
energy_consumption = cumtrapz(time_points, power_data)
print(f"累积能耗 (千瓦时): {energy_consumption}")
print(f"总能耗: {energy_consumption[-1]:.2f} 千瓦时")
#累积能耗 (千瓦时): [0, 12.5, 26, 41, 57, 74]
#总能耗: 74.00 千瓦时
示例2: 结构工程中的位移计算
通过加速度数据计算速度和位移
time_points = [0, 0.1, 0.2, 0.3, 0.4, 0.5] # 时间 (秒)
acceleration = [0, 2, 4, 3, 1, 0] # 加速度 (m/s²)
先计算速度 (加速度的积分)
velocity = cumtrapz(time_points, acceleration)
再计算位移 (速度的积分)
displacement = cumtrapz(time_points, velocity)
print(f"速度: {velocity}")
print(f"位移: {displacement}")
print(f"最终位移: {displacement[-1]:.4f} 米")
#速度: [0, 0.1, 0.4, 0.75, 0.95, 1]
#位移: [0, 0.005, 0.03, 0.0875, 0.1725, 0.27]
#最终位移: 0.2700 米
示例3: 流体力学中的流量计算
通过流速剖面计算管道中的总流量
radius_points = [0, 0.2, 0.4, 0.6, 0.8, 1.0] # 管道半径位置 (米)
velocity_profile = [2.0, 1.8, 1.5, 1.0, 0.5, 0.0] # 流速 (m/s)
预先计算被积函数的值：2πr * v
integrand_values = [2 * pi * r * v for r, v in zip(radius_points, velocity_profile)]
流量是流速乘以环形面积元素的积分
flow_rate = cumtrapz(radius_points, integrand_values)
print(f"被积函数值: {[round(val, 4) for val in integrand_values]}")
print(f"累积流量: {flow_rate}")
print(f"总流量: {flow_rate[-1]:.4f} m³/s")
#被积函数值: [0.0, 2.2619, 3.7699, 3.7699, 2.5133, 0.0]
#累积流量: [0, 0.226194671058465, 0.829380460547705, 1.58336269740926, 2.21168122812721, 2.46300864041440]
#总流量: 2.4630 m³/s
示例4: 热传导分析
计算通过材料的热流量
position_points = [0, 0.1, 0.2, 0.3, 0.4, 0.5] # 位置 (米)
temperature_gradient = [50, 45, 40, 35, 30, 25] # 温度梯度 (K/m)
thermal_conductivity = 0.8 # 热导率 (W/m·K)
热流量 = 热导率 × 温度梯度
heat_flux = [thermal_conductivity * grad for grad in temperature_gradient]
total_heat_flow = cumtrapz(position_points, heat_flux)
print(f"热流量: {heat_flux}")
print(f"累积热流量: {total_heat_flow}")
print(f"总热流量: {total_heat_flow[-1]:.2f} W")
#热流量: [40.0, 36.0, 32.0, 28.0, 24.0, 20.0]
#累积热流量: [0, 3.8, 7.2, 10.2, 12.8, 15]
#总热流量: 15.00 W
示例5: 经济学中的累积收益计算
计算一段时间内的累积收益
time_periods = [0, 1, 2, 3, 4, 5] # 时间 (年)
revenue_rate = [10, 15, 20, 18, 22, 25] # 收益速率 (千元/年)
cumulative_revenue = cumtrapz(time_periods, revenue_rate)
print(f"累积收益: {cumulative_revenue}")
print(f"总收益: {cumulative_revenue[-1]:.2f} 千元")
#累积收益: [0, 12.5, 30, 49, 69, 92.5]
#总收益: 92.50 千元
示例6: 符号表达式积分 - 计算复杂函数的累积积分
计算复杂函数的累积积分
x_points = [0, 0.5, 1.0, 1.5, 2.0]
function_expression = x^2 + sin(x)
cumulative_integral = cumtrapz(x_points, function_expression)
print(f"累积积分结果: {cumulative_integral}")
print(f"最终积分值: {cumulative_integral[-1]:.4f}")
#累积积分结果: [0, 0.182356384651051, 0.825080515504076, 2.09732200835706, 4.13652011171450]
#最终积分值: 4.1365
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
from scipy import integrate
def cumulative_integrate_trapezoid(input_str):
"""
对标MATLAB的cumtrapz函数，实现累积梯形积分
支持以下输入格式:
1. 单个数组: cumulative_integrate_trapezoid('[1,2,3]')
2. 元组(x,y): cumulative_integrate_trapezoid('([1,2,3], [4,5,6])')
3. 元组(x,y,axis): cumulative_integrate_trapezoid('([1,2,3], [[4,5,6],[7,8,9]], 2)')
4. 符号表达式: cumulative_integrate_trapezoid('([1,2,3], x**2)')
参数:
input_str: 表示输入的字符串
返回:
积分结果数组或错误信息
"""
try:
expr = sp.sympify(input_str)
error = False
result = None
def symbolic_cumtrapz(y_expr, x, x_vals):
cumulative_integral = [0.0] # 初始为0
for i in range(1, len(x_vals)):
x0 = x_vals[i - 1]
x1 = x_vals[i]
y0 = y_expr.subs(x, x0)
y1 = y_expr.subs(x, x1)
integral_segment = (y0 + y1) * (x1 - x0) / 2
current = cumulative_integral[-1] + integral_segment
cumulative_integral.append(current)
return cumulative_integral
if isinstance(expr, tuple) and len(expr) > 2:
x = sp.Matrix(expr[0]) if isinstance(expr[0], list) else None
y = sp.Matrix(expr[1]) if isinstance(expr[1], list) else None
if x is not None and y is not None and expr[2] in [1, 2]:
axis = expr[2] - 1
n_x = np.ravel(np.array(x, dtype=float))
n_y = np.array(y, dtype=float)
result = integrate.cumtrapz(n_y, n_x, axis=axis, initial=0)
else:
error = True
elif isinstance(expr, tuple) and len(expr) == 2:
x = sp.Matrix(expr[0]) if isinstance(expr[0], list) else None
y = sp.Matrix(expr[1]) if isinstance(expr[1], list) else None
if x is not None and y is not None:
n_x = np.ravel(np.array(x, dtype=float))
n_y = np.array(y, dtype=float)
result = integrate.cumtrapz(n_y, n_x, initial=0)
elif x is not None and expr[1].free_symbols:
y_expr = expr[1]
y_symbol = list(y_expr.free_symbols)[0]
x_vals = np.ravel(np.array(x, dtype=float))
result = symbolic_cumtrapz(y_expr, y_symbol, x_vals)
else:
error = True
elif isinstance(expr, list):
x = sp.Matrix(expr)
n_x = np.ravel(np.array(x, dtype=float))
result = integrate.cumtrapz(n_x, initial=0)
else:
error = True
if error:
return f"输入错误: {input_str}"
else:
# 转换为SymPy矩阵
if isinstance(result, np.ndarray):
result = result.tolist()
res_matrix = sp.Matrix(result)
if res_matrix.shape[1] == 1:
return res_matrix.T.tolist()[0] # 返回向量列表
else:
return res_matrix
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于演示 cumulative_integrate_trapezoid 函数的使用。
"""
# 示例 1: 输入为数据点间距为 1 的向量的累积积分
input_str1 = "[1,4,9,16,25]"
result1 = cumulative_integrate_trapezoid(input_str1)
print(f"输入: {input_str1}\n结果: {result1}\n")
# 结果: [0, 2.50000000000000, 9.00000000000000, 21.5000000000000, 42.0000000000000]
# 示例 2: 输入为计算数据点间距均匀但不等于 1 的向量的累积积分
input_str2 = "[0,pi/5,2*pi/5,3*pi/5,4*pi/5,pi],sin(x)"
result2 = cumulative_integrate_trapezoid(input_str2)
print(f"输入: {input_str2}\n结果: {result2}\n")
# 结果: [0, 0.184658183049046, 0.668099582572247, 1.26566601552056, 1.74910741504376, 1.93376559809281]
# 示例 3: 输入为对具有非均匀数据间距的矩阵的行进行累积积分
input_str3 = "[1,2.5,7,10],[[5.2,7.7,9.6,13.2],[4.8,7,10.5,14.5],[4.9,6.5,10.2,13.8]],2"
result3 = cumulative_integrate_trapezoid(input_str3)
print(f"输入: {input_str3}\n结果: {result3}\n")
# 结果: Matrix([[0, 9.67500000000000, 48.6000000000000, 82.8000000000000],
# [0, 8.85000000000000, 48.2250000000000, 85.7250000000000],
# [0, 8.55000000000000, 46.1250000000000, 82.1250000000000]])
if __name__ == "__main__":
main()
其列周期性重复的矩阵
A = cycol(n,k)返回具有周期性重复列的 n×n 矩阵,其中一个周期由 randn(n,k) 定义的列构成.因此,矩阵 A 的秩不能超过k, k必须是标量. 参量k是标量, 默认值为 round(n/4),它不需要整除 n.
n,k - 输入, 标量
示例1: 通信系统中的循环前缀
在OFDM系统中，循环前缀用于对抗多径效应
创建一个表示循环前缀的循环矩阵
prefix_matrix = cycol(4, 8)
print("循环前缀矩阵 (4×8):")
print(prefix_matrix)
#循环前缀矩阵 (4×8):
#[[1, 4, 3, 2, 1, 4, 3, 2],
[2, 1, 4, 3, 2, 1, 4, 3],
[3, 2, 1, 4, 3, 2, 1, 4],
[4, 3, 2, 1, 4, 3, 2, 1]]
#在OFDM(正交频分复用)系统中，循环前缀用于对抗多径效应引起的符号间干扰。
示例2: 图像处理中的循环卷积
循环矩阵用于实现循环卷积，常用于图像滤波
filter_matrix = cycol(3, 5)
print("循环卷积核矩阵 (3×5):")
print(filter_matrix)
#循环卷积核矩阵 (3×5):
#[[1, 3, 2, 1, 3],
[2, 1, 3, 2, 1],
[3, 2, 1, 3, 2]]
#循环矩阵可用于实现高效的循环卷积操作，应用于图像滤波、模糊和锐化等处理。
示例3: 密码学中的循环移位加密
循环矩阵可用于简单的移位密码
encryption_matrix = cycol(5, 5)
print("循环移位加密矩阵 (5×5):")
print(encryption_matrix)
#循环移位加密矩阵 (5×5):
#[[1, 5, 4, 3, 2],
[2, 1, 5, 4, 3],
[3, 2, 1, 5, 4],
[4, 3, 2, 1, 5],
[5, 4, 3, 2, 1]]
#循环矩阵可用于实现简单的移位密码，通过循环移位操作对数据进行加密。
示例4: 控制系统中的循环调度
在工业控制系统中，循环矩阵可用于表示循环调度策略
schedule_matrix = cycol(6, 4)
print("循环调度矩阵 (6×4):")
print(schedule_matrix)
#循环调度矩阵 (6×4):
#[[1, 6, 5, 4],
[2, 1, 6, 5],
[3, 2, 1, 6],
[4, 3, 2, 1],
[5, 4, 3, 2],
[6, 5, 4, 3]]
#在工业控制系统中，循环矩阵可以表示设备的循环调度策略，确保资源在不同任务间公平分配。
示例5: 信号处理中的循环相关
循环矩阵用于计算信号的循环相关
correlation_matrix = cycol(4, 7)
print("循环相关矩阵 (4×7):")
print(correlation_matrix)
#循环相关矩阵 (4×7):
#[[1, 4, 3, 2, 1, 4, 3],
[2, 1, 4, 3, 2, 1, 4],
[3, 2, 1, 4, 3, 2, 1],
[4, 3, 2, 1, 4, 3, 2]]
#循环矩阵可用于计算信号的循环相关，用于周期性信号检测和模式识别。
示例6: 数值分析中的循环预处理
循环矩阵可作为预处理矩阵用于数值计算
preconditioner_matrix = cycol(5, 5)
print("循环预处理矩阵 (5×5):")
print(preconditioner_matrix)
#循环预处理矩阵 (5×5):
#[[1, 5, 4, 3, 2],
[2, 1, 5, 4, 3],
[3, 2, 1, 5, 4],
[4, 3, 2, 1, 5],
[5, 4, 3, 2, 1]]
#循环矩阵可作为预处理矩阵，改善迭代法在数值计算中的收敛性能。
示例7: 数据压缩中的循环变换
循环矩阵可用于数据压缩变换
transform_matrix = cycol(8, 8)
print("循环变换矩阵 (8×8):")
print(transform_matrix)
#循环变换矩阵 (8×8):
#[[1, 8, 7, 6, 5, 4, 3, 2],
[2, 1, 8, 7, 6, 5, 4, 3],
[3, 2, 1, 8, 7, 6, 5, 4],
[4, 3, 2, 1, 8, 7, 6, 5],
[5, 4, 3, 2, 1, 8, 7, 6],
[6, 5, 4, 3, 2, 1, 8, 7],
[7, 6, 5, 4, 3, 2, 1, 8],
[8, 7, 6, 5, 4, 3, 2, 1]]
#循环矩阵可用于实现变换编码，将数据转换到更适合压缩的表示形式。
示例8: 量子计算中的循环门操作
循环矩阵可用于表示量子计算中的循环门操作
quantum_gate_matrix = cycol(4, 4)
print("量子循环门矩阵 (4×4):")
print(quantum_gate_matrix)
#量子循环门矩阵 (4×4):
#[[1, 4, 3, 2],
[2, 1, 4, 3],
[3, 2, 1, 4],
[4, 3, 2, 1]]
#循环矩阵可以表示量子位的循环移位操作，用于实现特定的量子算法。
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def cycol_matrix(input_str):
"""
根据输入的字符串生成循环矩阵。输入应为形如 "(n, k)" 的字符串，
其中 n 和 k 是正整数，分别表示矩阵的行数和列数。
参数:
input_str (str): 格式为 "(n, k)" 的字符串
返回:
sp.Matrix: 生成的循环矩阵，或错误信息字符串
"""
try:
# 将输入字符串转换为SymPy表达式
expr = sp.sympify(input_str)
error = False
result = None
# 检查输入是否为包含两个正整数的元组
if (isinstance(expr, tuple) and # SymPy元组类型检查
len(expr) == 2 and # 必须包含两个元素
all(arg.is_integer for arg in expr) and # 两个元素都必须是整数
int(expr[0]) > 0 and # n必须为正整数
int(expr[1]) > 0): # k必须为正整数
n = int(expr[0])
k = int(expr[1])
def generate_cycol_matrix(n, k):
"""
生成n行k列的循环矩阵，每列是前一列的循环下移
参数:
n (int): 行数
k (int): 列数
返回:
np.ndarray: 生成的循环矩阵
"""
base_col = np.arange(1, n + 1) # 生成基础列 [1, 2, ..., n]
# 生成k个循环移位列，i列是基础列下移i次
columns = [np.roll(base_col, shift=i) for i in range(k)]
return np.column_stack(columns) # 将列合并为矩阵
result = generate_cycol_matrix(n, k)
else:
error = True
if error:
return f"输入错误: 需要两个正整数的元组，例如'(3,4)'。收到：{input_str}"
else:
return sp.Matrix(result) # 转换为SymPy矩阵返回
except Exception as e:
return f"错误: {str(e)}"
if __name__ == "__main__":
# 示例用法
print("正确输入示例:")
test_cases = [
"(3, 4)",
# Matrix([[1, 3, 2, 1],
# [2, 1, 3, 2],
# [3, 2, 1, 3]])
"(6, 3)",
# Matrix([[1, 6, 5],
# [2, 1, 6],
# [3, 2, 1],
# [4, 3, 2],
# [5, 4, 3],
# [6, 5, 4]])
"(4, 6)",
# Matrix([[1, 4, 3, 2, 1, 4],
# [2, 1, 4, 3, 2, 1],
# [3, 2, 1, 4, 3, 2],
# [4, 3, 2, 1, 4, 3]])
]
for case in test_cases:
print(f"\n输入: {case}")
print("输出矩阵:")
print(cycol_matrix(case))
圆柱坐标是一种在三维空间中描述点位置的方法,它使用径向距离 rr，极角 θθ，和垂直于极坐标平面的高度 zz.
这种坐标系统通常用于描述具有柱状对称性的物体,例如圆柱体或柱形物体.
CylindricalPlot3D(L,r1,r2,options)
L是具有两个变量的过程或表达式，或三个此类过程或表达式的列表
r1,r2是表达式变量的范围.
柱坐标3D图
1. 基础形状变体:
角向调制曲面: 锥面叠加3个角向波瓣，形成三叶旋转对称
CylindricalPlot3D((1+0.5sin(3phi))r,r=[0,1],phi=[0,2@pi])
径向振荡: 径向5个完整振荡周期，振幅受角向轻微调制
CylindricalPlot3D(sin(5@pi*r)*(1+0.2*cos(phi)),r=[0,1],phi=[0,2@pi])
2. 复杂曲面:
螺旋抛物面: 抛物面基础上叠加螺旋状扭曲，扭曲度随半径增加
CylindricalPlot3D((2+sin(phi+3r))*(r^2),r=[0,1],phi=[0,2@pi])
分瓣结构: 四瓣花形结构，瓣叶根部（r=0）高度为0
CylindricalPlot3D((0.5+0.5*abs(sin(2phi)))*sqrt(r),r=[0,1],phi=[0,2@pi])
双曲马鞍面: 四个交替起伏的鞍形区域（双曲抛物面）
CylindricalPlot3D(r*cos(2phi),r=[0,1],phi=[0,2@pi])
极坐标高斯峰: 中心尖锐峰值，角向形成4个对称波瓣
CylindricalPlot3D(exp(-10r^2)*cos(4phi),r=[0,1],phi=[0,2@pi])
3. 动态调制曲面:
频率耦合波纹: 抛物面叠加径向10波+角向5波的干涉图案
CylindricalPlot3D((1+0.3*sin(10r)*cos(5phi))*r^2,r=[0,1],phi=[0,2@pi])
衰减驻波: 角向8个强波瓣，振幅随半径指数衰减
CylindricalPlot3D(sin(8phi)*exp(-3r),r=[0,1],phi=[0,2@pi])
相位偏移结构: 径向振荡与角向绝对值函数的耦合
CylindricalPlot3D(r*abs(cos(phi))*sin(5@pi*r),r=[0,1],phi=[0,2@pi])
4. 特殊效果:
分形轮廓: 自相似纹理，同时具有径向和角向高频振荡
CylindricalPlot3D(r^(0.7)*(1+0.2*sin(16phi)*sin(8@pi*r)),r=[0,1],phi=[0,2@pi])
多曲面柱坐标3D图
将多个柱坐标曲面组合在一张图中, 直接观察多个相关曲面的空间关系, 揭示物理场之间的相互作用, 快速评估不同参数配置下的整体效果, 捕获系统在特定时刻的多层状态.
1. 旋转机械设计（涡轮叶片）
同时可视化叶片几何形状、表面压力分布和温度场，优化气动冷却设计
CylindricalPlot3D(r^2*(1+0.2*sin(5phi)), // 压力分布曲面
0.8(1+0.1*cos(3phi))r, // 叶片几何表面
exp(-2r)*(1+0.3sin(phi)), // 温度场分布
r=[0,1],phi=[0,2@pi])
2. 化学工程（催化反应器）
同步展示反应物扩散、催化剂表面活性和热分布，优化反应器设计
CylindricalPlot3D(1-exp(-3r)*(1+0.2*sin(2phi)), // 反应物浓度
r^0.5*(0.5+0.1*cos(4phi)), // 催化剂活性
0.3*(1-r)*(1+0.3*sin(3phi)), // 温度梯度
r=[0,1],phi=[0,2@pi])
3. 地质勘探（油气储层）
三维集成显示储层物性参数，指导钻井轨迹设计和采收率优化
CylindricalPlot3D(r*(0.8+0.2*sin(3phi)), // 岩层孔隙度
0.6*exp(-r)*(1+0.4*cos(2phi)), // 渗透率分布
0.3*(1-r^2)*(1+0.3*sin(phi)), // 含油饱和度
r=[0,1],phi=[0,2@pi])
4. 生物医学（血管支架）
同时显示支架几何、血流动力学特征和药物释放分布
CylindricalPlot3D((1+0.1*cos(6phi))*(1-(r-0.7)^2), // 支架几何
0.2*r*(1+0.3*sin(2phi)), // 血流速度
exp(-5(r-0.5)^2)*(0.4+0.1*sin(phi)), // 药物浓度
r=[0.4,1],phi=[0,2@pi])