将角的单位从弧度转换为度
D = rad2deg(R) 将 R 中每个元素的角单位从弧度转换为度.
R — 以弧度为单位的角,标量,向量,矩阵
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import numpy as np
import sympy as sp
def radian_to_degree(input_str):
"""
将输入字符串中的弧度值转换为角度值，支持标量和矩阵。
参数:
input_str (str): 输入的弧度表达式，可以是数字、矩阵或其他形式
返回:
sp.Matrix/float/str: 转换后的结果，若输入不合法则返回错误字符串
示例:
>>> radian_to_degree("1.0471975511965976")
60.0
>>> radian_to_degree("[[0.5235987755982988, 0.7853981633974483], [1.5707963267948966, 3.141592653589793]]")
Matrix([[30.0, 45.0], [90.0, 180.0]])
"""
try:
# 将输入字符串解析为SymPy表达式
expr = sp.sympify(input_str)
error = False
result = None
def evaluate_rad2deg_function(z):
"""内部函数：处理单个元素的转换"""
if z.is_number:
return np.rad2deg(float(z)) # 使用NumPy的rad2deg函数进行转换
else:
return None # 非数值元素返回None
# 处理元组类型（不支持）
if isinstance(expr, tuple):
error = True
# 处理标量数值
if expr.is_number:
result = evaluate_rad2deg_function(expr)
# 其他类型视为错误
else:
error = True
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {e}"
if __name__ == "__main__":
# 示例测试用例
test_cases = [
"1.0471975511965976",
# 59.99999999999999
]
for case in test_cases:
print(f"输入：'{case}'")
result = radian_to_degree(case)
print("输出：")
if isinstance(result, sp.Matrix):
# 格式化矩阵输出
print(result)
else:
print(result)
print("-" * 40)
随机均匀矩阵
X = rand(n) 返回一个由均匀分布的随机数组成的 n×n 矩阵
X = rand(m,n) 返回一个由均匀分布的随机数组成的 m×n 矩阵.
X = rand(m,n,min) 返回一个由均匀分布的随机数组成的 m×n 矩阵, 数值在min与inf之间的矩阵.
X = rand(m,n,min,max) 返回一个由均匀分布的随机数组成的 m×n 矩阵, 数值在min与max之间的矩阵.
m, n — 方阵的大小,整数值
min,max,整数值
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def matrix_rand(input_str):
"""
根据输入字符串生成均匀分布的随机矩阵，对标MATLAB的rand函数，支持扩展参数。
参数：
input_str (str): 表示矩阵维度和范围的字符串。支持以下格式：
- "n"：生成n×n的0~1随机矩阵。
- "(rows, cols)"：生成rows×cols的0~1随机矩阵。
- "(rows, cols, a)"：生成元素在[a, a+1)区间的随机矩阵。
- "(rows, cols, a, b)"：生成元素在[a, b)区间的随机矩阵。
返回：
sympy.Matrix or str: 生成的随机矩阵，若输入无效则返回错误信息。
示例：
>>> matrix_rand("3") # 3x3矩阵，元素0~1
>>> matrix_rand("(2,3)") # 2x3矩阵，元素0~1
>>> matrix_rand("(2,2,5)") # 2x2矩阵，元素5~6
>>> matrix_rand("(3,2,5,10)") # 3x2矩阵，元素5~10
"""
try:
expr = sp.sympify(input_str) # 解析输入字符串为SymPy表达式
error = False
result = None
if isinstance(expr, tuple):
# 处理元组参数
if len(expr) == 4:
# 参数格式：(rows, cols, a, b)，生成[a, b)区间的随机矩阵
rows, cols, a, b = expr
random_matrix = np.random.rand(rows, cols) * (b - a) + a
result = sp.Matrix(random_matrix)
elif len(expr) == 3:
# 参数格式：(rows, cols, a)，生成[a, a+1)区间的随机矩阵
rows, cols, a = expr
random_matrix = np.random.rand(rows, cols) + a
result = sp.Matrix(random_matrix)
elif len(expr) == 2:
# 参数格式：(rows, cols)，生成0~1的随机矩阵
rows, cols = expr
random_matrix = np.random.rand(rows, cols)
result = sp.Matrix(random_matrix)
else:
error = True # 参数长度不符合要求
elif expr.is_integer:
# 参数格式：整数n，生成n×n的0~1随机矩阵
n = int(expr)
random_matrix = np.random.rand(n, n)
result = sp.Matrix(random_matrix)
else:
error = True # 无效的输入类型
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"Error: {e}"
# 示例代码
if __name__ == "__main__":
# 示例1：3x3矩阵，元素0~1
print("示例1:", matrix_rand("3"))
# Matrix([[0.183112236962607, 0.212394217857657, 0.664021485720149],
# [0.669792434360979, 0.0240691129401981, 0.463604975941356],
# [0.288865834582140, 0.330471827282497, 0.923577809087900]])
# 示例2：2x3矩阵，元素0~1
print("示例2:", matrix_rand("(2,3)"))
# Matrix([[0.595556557127196, 0.867659443372348, 0.0504270317200585],
# [0.776355720672051, 0.656865338639271, 0.102445830808784]])
# 示例3：2x2矩阵，元素5~6
print("示例3:", matrix_rand("(2,2,5)"))
# Matrix([[5.61650241924118, 5.87854171655421],
# [5.05252724807980, 5.82949043459748]])
# 示例4：3x2矩阵，元素5~10
print("示例4:", matrix_rand("(3,2,5,10)"))
# Matrix([[9.78184517353882, 8.41039417069258],
# [7.18826504860124, 5.54331991813526],
# [5.50597244331105, 8.61157846090020]])
均匀分布的伪随机整数
X = randi(imax) 返回一个介于 1 和 imax 之间的伪随机整数标量
X = randi(imax,n) 返回 n×n 矩阵，其中包含从区间 [1,imax] 的均匀离散分布中得到的伪随机整数.
X = randi(imax,sz1,...,szN) 返回 sz1×...×szN 数组，其中 sz1,sz2指示每个维度的大小。例如，randi(10,3,4) 返回一个由介于 1 和 10 之间的伪随机整数组成的 3×4 数组.
imax — 示例区间中的最大整数,整数值
imin — 示例区间中的最小整数(默认)
n — 方阵的大小,整数值
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def random_imax_generation(input_str):
"""
根据输入字符串生成均匀分布的伪随机整数，对标MATLAB的randi函数
参数：
input_str (str): 表示生成范围和维度的字符串，支持格式：
- "max_val" : 生成单个1~max_val的整数
- "(max_val, size)" : 生成size×size的矩阵
- "(max_val, rows, cols)" : 生成rows×cols的矩阵
返回：
sympy.Matrix/int/str: 生成的整数或矩阵，错误时返回字符串
示例：
>>> random_imax_generation("5") # 生成1~5的随机整数
>>> random_imax_generation("(5, 2)") # 2×2矩阵，元素1~5
>>> random_imax_generation("(5, 2, 3)") # 2×3矩阵，元素1~5
"""
try:
expr = sp.sympify(input_str)
error = False
result = None
if isinstance(expr, tuple):
# 处理元组参数
if len(expr) == 3:
# 格式：(max_val, rows, cols)
max_val = int(expr[0])
rows = int(expr[1])
cols = int(expr[2])
result = sp.Matrix(np.random.randint(1, max_val + 1, (rows, cols)))
elif len(expr) == 2:
# 格式：(max_val, size)
max_val = int(expr[0])
size = int(expr[1])
result = sp.Matrix(np.random.randint(1, max_val + 1, (size, size)))
else:
error = True # 无效元组长度
elif expr.is_integer:
# 格式：单个整数max_val
max_val = int(expr)
result = np.random.randint(1, max_val + 1)
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:", random_imax_generation("5"))
# 1
# 示例2：生成3×3矩阵
print("\n示例2:", random_imax_generation("(5, 3)"))
# Matrix([[5, 5, 3],
# [3, 5, 1],
# [2, 2, 2]])
# 示例3：生成2×4矩阵
print("\n示例3:", random_imax_generation("(10, 2, 4)"))
# Matrix([[3, 1, 3, 6],
# [5, 10, 8, 3]])
随机正态矩阵
X = rand(n) 返回一个由正态分布的随机数组成的 1×n 矩阵
X = rand(m,n) 返回一个由正态分布的随机数组成的 m×n 矩阵.
m, n — 方阵的大小,整数值
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def matrix_randn(input_str):
"""
根据输入字符串生成正态分布的随机矩阵，对标MATLAB的randn函数，支持扩展参数。
参数：
input_str (str): 表示矩阵维度和分布参数的字符串。支持以下格式：
- "n"：生成n×n的标准正态分布矩阵（均值0，标准差1）
- "(rows, cols)"：生成rows×cols的标准正态分布矩阵
- "(rows, cols, mu)"：生成均值为mu，标准差为1的正态分布矩阵
- "(rows, cols, mu, sigma)"：生成均值为mu，标准差为sigma的正态分布矩阵
返回：
sympy.Matrix or str: 生成的随机矩阵，若输入无效则返回错误信息。
示例：
>>> matrix_randn("3") # 3x3标准正态分布矩阵
>>> matrix_randn("(2,3)") # 2x3标准正态分布矩阵
>>> matrix_randn("(2,2,5)") # 2x2矩阵，均值5，标准差1
>>> matrix_randn("(3,2,5,2)") # 3x2矩阵，均值5，标准差2
"""
try:
expr = sp.sympify(input_str) # 解析输入字符串为SymPy表达式
error = False
result = None
if isinstance(expr, tuple):
# 处理元组参数
if len(expr) == 2:
# 格式：(rows, cols)，生成标准正态分布
rows = int(expr[0])
cols = int(expr[1])
random_matrix = np.random.randn(rows, cols)
result = sp.Matrix(random_matrix)
elif len(expr) == 3:
# 格式：(rows, cols, mu)，生成N(mu,1)
rows = int(expr[0])
cols = int(expr[1])
mu = float(expr[2])
random_matrix = np.random.randn(rows, cols) + mu
result = sp.Matrix(random_matrix)
elif len(expr) == 4:
# 格式：(rows, cols, mu, sigma)，生成N(mu, sigma^2)
rows = int(expr[0])
cols = int(expr[1])
mu = float(expr[2])
sigma = float(expr[3])
random_matrix = sigma * np.random.randn(rows, cols) + mu
result = sp.Matrix(random_matrix)
else:
error = True # 不支持的参数长度
elif expr.is_integer:
# 格式：整数n，生成n×n标准正态分布矩阵
n = int(expr)
random_matrix = np.random.randn(n, n)
result = sp.Matrix(random_matrix)
else:
error = True # 无效的输入类型
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"Error: {e}"
# 示例代码
if __name__ == "__main__":
# 示例1：3x3标准正态分布矩阵
print("示例1:", matrix_randn("3"))
# Matrix([[1.39013708918388, -0.324752480460865, -0.190469074314680],
# [0.924750724511891, 1.15842217229967, -0.111156310307857],
# [-0.142219586288319, 0.955105925465763, -0.331834544891866]])
# 示例2：2x3标准正态分布矩阵
print("示例2:", matrix_randn("(2,3)"))
# Matrix([[-1.03503301334510, 0.187320578973013, 0.00353779280429042],
# [1.73695585011864, 0.966429881059110, -1.43696858006492]])
# 示例3：2x2矩阵，均值5，标准差1
print("示例3:", matrix_randn("(2,2,5)"))
# Matrix([[6.15546425528767, 6.43937825874499],
# [5.58857185229244, 6.65723732023311]])
# 示例4：3x2矩阵，均值5，标准差2
print("示例4:", matrix_randn("(3,2,5,2)"))
# Matrix([[4.48575907428833, 5.43818803588287],
# [6.50850096480664, 6.91253704333354],
# [2.45699214062053, 3.87080672903311]])
整数的随机排列
p = randperm(n) 返回行向量,其中包含从1到n没有重复元素的整数随机排列.
p = randperm(n,k) 返回行向量,其中包含在1到n之间随机选择的k个唯一整数.
n — 采样间隔中的整数数量,正整数值
k — 所选整数的数量,正整数值
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def random_permutation_generation(input_str):
"""
生成整数的随机排列，对标MATLAB的randperm函数
参数：
input_str (str): 表示排列参数的字符串，支持格式：
- "n" : 生成1~n的随机排列
- "(n, k)" : 从1~n中随机选择k个不重复整数
返回：
numpy.ndarray/sympy.Matrix: 生成的随机排列数组或矩阵
str: 输入错误时的提示信息
示例：
>>> random_permutation_generation("5") # 生成1~5的随机排列
>>> random_permutation_generation("(10,3)") # 从1~10选3个随机数
"""
try:
expr = sp.sympify(input_str)
error = False
result = None
# 处理元组参数 (n, k)
if isinstance(expr, tuple):
if len(expr) == 2:
# 验证参数是否为有效数字
if expr[0].is_integer and expr[1].is_integer:
n = int(expr[0])
k = int(expr[1])
# 参数有效性检查
if n <= 0 or k <= 0:
raise ValueError("参数必须为正整数")
if k > n:
raise ValueError("k不能大于n")
# 生成随机排列（MATLAB的randperm(n,k)行为）
result = np.random.choice(np.arange(1, n + 1), k, replace=False)
else:
error = True
else:
error = True
# 处理单个整数参数 n
elif expr.is_integer:
n = int(expr)
if n <= 0:
raise ValueError("参数必须为正整数")
# 生成完整随机排列（MATLAB的randperm(n)行为）
result = np.random.permutation(np.arange(1, n + 1))
else:
error = True
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {str(e)}"
# 示例测试
if __name__ == "__main__":
# 正常用例
print("=== 正常用例测试 ===")
print("1. 基础排列:", random_permutation_generation("5"))
# [3 5 2 4 1]
print("\n2. 子集选择:", random_permutation_generation("(10,3)"))
# [ 9 10 2]
# 边界用例
print("\n=== 边界用例测试 ===")
print("3. 最小参数:", random_permutation_generation("(1,1)"))
# [1]
print("4. 最大选择:", random_permutation_generation("(5,5)"))
# [4 5 3 1 2]
随机列表或矩阵
Random(a,b,size) -- 生成指定范围内的均匀分布随机数，支持标量/向量/矩阵/高维数组
a,b,size -- 标量
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def random_generation(input_str):
"""
生成指定范围内的均匀分布随机数，支持标量/向量/矩阵/高维数组
参数：
input_str (str): 表示范围和维度的字符串，格式为：
- "(low, high)" : 生成单个 [low, high) 之间的随机数
- "(low, high, size)" : 生成一维数组
- "(low, high, rows, cols)" : 生成二维矩阵(sympy.Matrix)
- "(low, high, d1, d2,...,dn)" : 生成n维numpy数组
返回：
[float/sp.Matrix/np.ndarray]: 生成的随机数结构
示例：
>>> random_generation("(0,1)") # 单个0~1的随机数
>>> random_generation("(2,5,3)") # 3个元素的1D数组
>>> random_generation("(0.5,1.5,2,2)") # 2x2的矩阵
>>> random_generation("(10,20,3,2,4)") # 3x2x4的3D数组
"""
try:
expr = sp.sympify(input_str)
error = False
result = None
if isinstance(expr, tuple):
# 参数必须包含至少low和high两个参数
if len(expr) >= 2:
low = float(expr[0]) # 转换为浮点数确保精度
high = float(expr[1])
# 处理不同维度情况
if len(expr) == 2:
# 格式1：生成单个随机数
result = np.random.uniform(low, high)
else:
# 转换维度参数为整数元组
shape = tuple(int(d) for d in expr[2:])
# 生成numpy数组
arr = np.random.uniform(low, high, shape)
# 二维矩阵转sympy类型以保持一致性
if len(shape) == 2:
result = sp.Matrix(arr)
else:
result = arr
else:
error = True
else:
error = True
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误:{e}"
# 示例测试
if __name__ == "__main__":
# 标量测试
print("标量测试:", random_generation("(0,1)"))
# 0.7152685221222377
# 一维数组测试
print("\n一维数组:", random_generation("(2,5,3)"))
# [2.41453067 3.70404521 4.03557003]
# 二维矩阵测试
print("\n二维矩阵:", random_generation("(0.5,1.5,2,2)"))
# Matrix([[0.986714064531144, 1.14702670344779],
# [0.860102519975358, 0.934994265190028]])
# 三维数组测试
print("\n三维数组:", random_generation("(10,20,3,2,4)"))
# [[[18.00333876 10.34994515 16.50753459 17.67988035]
# [16.09993668 18.59615135 16.9802518 19.65361739]]
#
# [[11.24132715 13.53054531 16.41626786 18.35072047]
# [19.62384891 13.28545208 18.91747723 17.68413307]]
#
# [[15.77014999 19.95114792 18.64022946 13.05333766]
# [16.3620224 10.64245557 11.13328264 17.22049697]]]
矩阵的秩
k = rank(A) 返回矩阵 A 的秩.
A — 输入矩阵,矩阵
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def rank_of_matrix(input_str):
"""
计算矩阵秩，支持符号和数值矩阵，对标MATLAB的rank函数
参数:
input_str (str): 矩阵输入，支持格式：
- "[[1,2],[3,4]]" # 数值矩阵
- "Matrix([[x,1],[2,y]])" # 符号矩阵
tol (float): 可选参数，指定秩计算的容差
返回:
int: 矩阵的秩
str: 错误信息
示例:
>>> rank_of_matrix("[[1,2],[3,4]]") # 数值矩阵
>>> rank_of_matrix("Matrix([[x,1],[2,y]]") # 符号矩阵
>>> rank_of_matrix("[[1,0.999],[2,2]]") # 接近奇异的数值矩阵
"""
try:
# 转换为SymPy矩阵
expr = sp.sympify(input_str)
mat = sp.Matrix(expr) if isinstance(expr, list) else None
if mat is None:
return "错误: 输入无法转换为矩阵"
# 数值矩阵使用SVD计算（类似MATLAB）
if mat.is_symbolic() is False:
# 转换为numpy数组
np_mat = np.array(mat.tolist(), dtype=float)
# 计算SVD
s = np.linalg.svd(np_mat, compute_uv=False)
# 自动计算容差（MATLAB默认算法）
max_singular = np.max(s) if s.size > 0 else 0
tol = max(np_mat.shape) * np.spacing(max_singular)
# 统计大于容差的奇异值数量
rank = np.sum(s > tol)
# 处理数值精度问题
if rank == 0 and not np.allclose(np_mat, 0):
return 0 if np.allclose(np_mat, 0) else 1
return int(rank)
# 符号矩阵使用SymPy默认方法
else:
return mat.rank()
except Exception as e:
return f"错误: {str(e)}"
# 示例测试
if __name__ == "__main__":
# 正常用例测试
print("=== 正常用例 ===")
print("1. 满秩矩阵:", rank_of_matrix("[[1,2],[3,4]]"))
# 2
print("2. 秩亏矩阵:", rank_of_matrix("[[1,2],[2,4]]"))
# 1
print("3. 符号矩阵:", rank_of_matrix("[[x,1],[2,y]]"))
# 2
# 数值边界测试
print("\n=== 数值边界 ===")
print("4. 零矩阵:", rank_of_matrix("[[0,0],[0,0]]"))
# 0
print("5. 接近奇异的矩阵:",
rank_of_matrix("[[1, 0.9999999999], [2, 2]]"))
# 2
有理分式近似值
R = rat(X) 返回 X 在默认容差 1e-6*norm(X(:),1) 内的有理分式近似值. 近似值是一个包含截断的连分式展开项的字符向量.
R = rat(X,tol) 在容差 tol 内求 X 的近似值
[N,D] = rat(___) 使用以上任何语法返回两个数组 N 和 D, 以使 N./D 求 X 的近似值
X — 输入数组,数值数组
tol — 容差,标量
R — 连分式,字符数组
N — 分子,数值数组
D — 分母,数值数组
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
def rational_approximation(input_str):
"""
数值有理分式近似，对标MATLAB的rat函数
参数:
input_str (str): 输入表达式，支持格式：
- "x" : 单个数值近似
- "(x, tol)" : 带容差的单个数值近似
- "[[1.25,3.14],[2.71,4.44]]" : 矩阵近似
- "(matrix, tol)" : 带容差的矩阵近似
返回:
tuple/float: 矩阵返回(N,D)元组，标量返回分数形式
str: 错误信息
示例:
>>> rational_approximation("0.333") # 返回 1/3
>>> rational_approximation("(0.333, 0.01)") # 返回 1/3
>>> rational_approximation("[[0.333,1.414],[3.141,2.718]]")
"""
try:
expr = sp.sympify(input_str)
error = False
result = None
def rat_scalar(x, tol=0.001):
"""处理标量有理近似"""
return sp.nsimplify(x, tolerance=tol, rational=True)
# 处理元组输入 (参数, 容差)
if isinstance(expr, tuple):
if len(expr) != 2:
raise ValueError("元组参数必须包含两个元素")
# 标量+容差模式
if all(e.is_number for e in expr):
params = tuple(float(e.evalf()) for e in expr)
result = rat_scalar(*params)
else:
error = True
# 处理标量输入
elif expr.is_number:
result = rat_scalar(float(expr))
else:
error = True
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {str(e)}"
# 示例测试
if __name__ == "__main__":
print("=== 标量测试 ===")
print("1. 1/3近似:", rational_approximation("0.333333"))
# 1/3
print("2. 带容差:", rational_approximation("(0.333, 0.1)"))
# 1/3
有理输出
S = rats(X) 返回一个包含 X 的元素的有理近似值的字符向量. 星号指示无法在分配的空间中输出, 但与 X 中的其他元素相比并非可忽略不计的元素.
S = rats(X,tol) 在容差 tol 内求 X 的近似值
X — 输入数组,数值数组
tol — 容差,标量
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
def rational_approximation_strlen(input_str):
try:
expr = sp.sympify(input_str)
error = False
result = None
def rat_to_str(x, tol=0.001):
"""将数值转换为分数字符串"""
rational = sp.nsimplify(x, tolerance=tol, rational=True)
return rational
# 处理元组输入（带容差）
if isinstance(expr, tuple):
if len(expr) != 2:
raise ValueError("元组参数必须为 (输入值, 容差)")
input_val, tol_val = expr[0], float(expr[1])
# 处理标量输入
if input_val.is_number:
result = rat_to_str(float(input_val), tol_val)
else:
error = True
# 处理标量输入
elif expr.is_number:
result = rat_to_str(float(expr))
else:
error = True
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误:{e}"
# 示例测试
if __name__ == "__main__":
print("=== 标量测试 ===")
print("1. 基础测试:", rational_approximation_strlen("0.333333"))
# 1/3
print("2. 整数测试:", rational_approximation_strlen("2"))
# 2
print("3. 带容差测试:", rational_approximation_strlen("(3.1415926, 0.001)"))
# 355/113
有理模型拟合
有理模型的分子和分母均为多项式,其中分母的首项系数设置为1.模型名称为ratij,其中i是分子的次数,j是分母的次数.分子和分母的次数最高都为5.
rat02: Y = (p1)/(x^2+q1*x+q2)
rat21: Y = (p1*x^2+p2*x+p3)/(x+q1)
rat55: Y = (p1*x^5+...+p6)/(x^5+...+q5)
返回有理模型拟合方程式
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
from scipy.optimize import curve_fit
def rat_fit_nonlinear(input_str):
"""
有理函数非线性拟合，支持多种分子分母阶数组合
参数:
input_str (str): 输入表达式字符串，格式为：
"(x_data, y_data, model_code)"
其中：
- x_data: 自变量数据矩阵/列表
- y_data: 因变量数据矩阵/列表
- model_code: 模型代码，支持：
2 : p1/(x² + q1x + q2)
21 : (p1x² + p2x + p3)/(x + q1)
55 : 五阶分子/分母多项式
返回:
sympy.Expr: 拟合得到的有理函数表达式
str: 错误信息
示例:
>>> rat_fit_nonlinear("([[1,2,3]], [[0.5,0.3,0.2]], 2)")
>>> rat_fit_nonlinear("([[0.1,0.5,1]], [[1.2,0.8,0.5]], 21)")
"""
try:
expr = sp.sympify(input_str)
error = False
expression = None
maxfev = 100000 # 最大函数评估次数
# 定义有理函数模型 --------------------------------------------------------
def rat_model2(x, p1, q1, q2):
"""(2阶分母模型) p1 / (x² + q1*x + q2)"""
return p1 / (x ** 2 + q1 * x + q2)
def rat_model21(x, p1, p2, p3, q1):
"""(2阶分子/1阶分母模型) (p1x² + p2x + p3)/(x + q1)"""
return (p1 * x ** 2 + p2 * x + p3) / (x + q1)
def rat_model55(x, p1, p2, p3, p4, p5, p6, q1, q2, q3, q4, q5):
"""(5阶分子/5阶分母模型) (p1x⁵+...+p6)/(x⁵+...+q5)"""
numerator = p1 * x ** 5 + p2 * x ** 4 + p3 * x ** 3 + p4 * x ** 2 + p5 * x + p6
denominator = x ** 5 + q1 * x ** 4 + q2 * x ** 3 + q3 * x ** 2 + q4 * x + q5
return numerator / denominator
# 参数解析 -------------------------------------------------------------
if isinstance(expr, tuple):
# 解析输入数据
if len(expr) >= 3:
x, y, n = expr[0], expr[1], int(expr[2])
else: # 默认使用模型2
x, y = expr[0], expr[1]
n = 2
# 转换输入矩阵为numpy数组
x_data = np.array(x).ravel() if isinstance(x, list) else None
y_data = np.array(y).ravel() if isinstance(y, list) else None
if x_data is None or y_data is None:
raise ValueError("输入数据格式错误")
# 选择拟合模型 -----------------------------------------------------
if n == 2:
# 初始参数猜测 [p1, q1, q2]
initial_guess = [1.0, 0.5, 0.5]
params, _ = curve_fit(rat_model2, x_data, y_data,
p0=initial_guess, maxfev=maxfev)
p1, q1, q2 = params
expression = f"{p1:.6f}/(x**2 + {q1:.6f}*x + {q2:.6f})"
elif n == 21:
# 初始参数猜测 [p1, p2, p3, q1]
initial_guess = [1.0, -0.5, 0.3, 0.5]
params, _ = curve_fit(rat_model21, x_data, y_data,
p0=initial_guess, maxfev=maxfev)
p1, p2, p3, q1 = params
expression = f"({p1:.6f}*x**2 + {p2:.6f}*x + {p3:.6f})/(x + {q1:.6f})"
elif n == 55:
# 初始参数猜测 [p1-6, q1-5]
initial_guess = [1.0] + [0.5] * 5 + [0.3] * 5
params, _ = curve_fit(rat_model55, x_data, y_data,
p0=initial_guess, maxfev=maxfev)
p_params = params[:6]
q_params = params[6:]
num_str = " + ".join([f"{p:.6f}*x**{5 - i}" for i, p in enumerate(p_params)])
den_str = " + ".join([f"{q:.6f}*x**{5 - i}" for i, q in enumerate(q_params)])
expression = f"({num_str})/(x**5 + {den_str})"
else:
raise ValueError(f"不支持的模型代码: {n}")
return sp.simplify(expression) if not error else f"输入错误: {input_str}"
else:
return f"输入格式错误，应为元组"
except Exception as e:
return f"拟合失败: {str(e)}"
# 示例测试 =======================================================================
if __name__ == "__main__":
# 测试用例1: 二阶分母模型
print("=== 测试1: 二阶分母模型 ===")
x_data = [[1, 2, 3, 4, 5]]
y_data = [[1 / (i ** 2 + 2 * i + 3) for i in x_data[0]]]
expr = f"({x_data}, {y_data}, 2)"
print("拟合结果:", rat_fit_nonlinear(expr))
# 1.0/(x**2 + 2.0*x + 3.0)
# 测试用例2: 二次/一次模型
print("\n=== 测试2: 二次/一次模型 ===")
x_data = [[0.5, 1.0, 1.5, 2.0]]
y_data = [[(2 * i ** 2 - 3 * i + 1) / (i + 2) for i in x_data[0]]]
expr = f"({x_data}, {y_data}, 21)"
print("拟合结果:", rat_fit_nonlinear(expr))
# (2.0*x**2 - 3.0*x + 1.0)/(x + 2.0)
条件数倒数
C = rcond(A) 返回 A 的 1-范数条件数倒数估计值. 如果A的条件设置良好, rcond(A)接近1.0. 如果A是病态的, 则rcond(A)接近 0
A — 输入矩阵, 数值方阵
C — 条件数倒数, 标量
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def reverse_condition_norm(input_str):
"""
计算矩阵条件数的倒数（对标MATLAB的rcond函数）
注意:
- 此处使用精确计算而非估计，与MATLAB的rcond实现方式不同
- MATLAB的rcond使用1-范数估计，而这里计算精确的1-范数条件数倒数
参数:
input_str: 矩阵的字符串表示（如"[[1, 0], [0, 1]]"）或Matrix对象
返回:
float: 条件数的倒数
str: 错误时返回错误信息
"""
try:
# 将输入转换为SymPy表达式
expr = sp.sympify(input_str)
error = False
result = None
# 尝试转换为矩阵
if isinstance(expr, list):
# 转换为NumPy数组进行数值计算
A = np.array(expr, dtype=float)
# 计算1-范数条件数
cond_A = np.linalg.cond(A, p=1)
# 返回条件数的倒数
result = 1 / cond_A
else:
error = True
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误:{e}"
# 示例代码
if __name__ == "__main__":
# 示例1：单位矩阵（条件数=1，倒数=1）
print("示例1:", reverse_condition_norm("[[1, 0], [0, 1]]"))
# 1.0
# 示例2：接近奇异的矩阵
ill_conditioned_matrix = "[[1, 1], [1, 1.0001]]"
print("示例2:", reverse_condition_norm(ill_conditioned_matrix))
# 2.4997500187484752e-05
# 示例3：直接使用Python列表输入
print("示例3:", reverse_condition_norm([[1, 2], [3, 4]]))
# 0.04761904761904764
# 示例4：使用SymPy矩阵语法
print("示例5:", reverse_condition_norm("[[2, 0], [0, 2]]"))
# 1.0
复数的实部
X = real(Z) 返回数组 Z 中每个元素的实部
Z - 输入数组,标量,向量,矩阵
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
def re_part_of_complex(input_str):
"""
提取复数或复数矩阵的实部（对标MATLAB的real函数）
参数:
input_str: 输入可以是以下类型：
- 复数/实数的字符串表示（如"3+4*I"）
- 矩阵的字符串表示（如"[[1, 2+I], [3, 4]]"）
- 直接传入Python列表或SymPy矩阵
返回:
sp.Expr/sp.Matrix: 实部计算结果
str: 错误时返回错误信息
注意:
- 支持符号运算，但需要明确声明复数属性（如使用Symbol('x', real=False)）
- 输入矩阵需符合SymPy矩阵语法
"""
try:
# 将输入转换为SymPy表达式
expr = sp.sympify(input_str)
error = False
result = None
def eval_re_part(x):
"""递归处理元素的实部提取"""
return sp.re(x) if x.is_complex else x
if expr.is_number or expr.is_symbol:
# 处理标量或符号
result = eval_re_part(expr)
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:", re_part_of_complex("3 + 4*I"))
# 3
# 示例2：实数标量
print("示例2:", re_part_of_complex("5"))
# 5
非负实数数组的自然对数
Y = reallog(X)返回数组X中每个元素的自然对数.数组X只能包含非负实数.Y的大小与X的大小相同.
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
def real_log_array(input_str):
"""
计算非负实数数组的自然对数（对标MATLAB的reallog函数）
参数:
input_str: 输入可以是以下类型：
- 非负实数/数值的字符串表示（如"5"）
- 矩阵的字符串表示（如"[[1, 2], [3, 4]]"）
- 直接传入Python列表或SymPy矩阵
返回:
sp.Matrix/sp.Expr: 自然对数计算结果
str: 错误时返回错误信息
注意:
- 输入必须全为非负实数，负数或复数将引发错误
- 符号变量需明确声明为非负实数（如Symbol('x', nonnegative=True)）
- 支持符号运算但需满足非负实数条件
"""
try:
expr = sp.sympify(input_str)
result = None
def check_nonnegative(e):
"""递归检查元素的非负实数属性"""
return bool(e.is_real and e.is_nonnegative) # 确保返回布尔值
if expr.is_number or expr.is_symbol:
# 检查标量是否为非负实数
if not check_nonnegative(expr):
return f"错误：输入 {expr} 包含非负实数以外的元素"
result = sp.log(expr).evalf()
else:
return f"输入类型错误: {type(expr)}"
return result
except Exception as e:
return f"错误:{e}"
# 示例代码
if __name__ == "__main__":
# 示例1：标量输入
print("示例1:", real_log_array("2.718"))
# 0.999896315728952
仅实数输出的数组幂
Z = realpow(X,Y) 将数组X的每个元素提升到数组Y中的对应元素的幂.数组X和Y的大小必须相同.realpow的范围是所有实数集合,即输出数组Z的所有元素必须为实数.
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def real_pow_array(input_str):
"""
计算实数安全的逐元素幂运算（对标MATLAB的realpow函数）
参数:
input_str: 输入可以是以下类型：
- 包含两个元素的元组（X, Y）
- 元组的字符串表示（如"([1, 2], [3, 4])"）
- 直接传入Python列表/SymPy矩阵的元组
返回:
sp.Matrix: 计算结果矩阵
str: 错误时返回错误信息
注意:
- 要求X和Y必须同维度
- X中元素为负数时，对应Y元素必须为整数
- 零的负数次幂会触发错误
- 符号变量需明确声明属性（如非负性、整数性）
"""
try:
# 将输入转换为SymPy表达式
expr = sp.sympify(input_str)
error = False
result = None
def pow_element_sym(a, b):
"""元素级安全性检查"""
# 检查零的负数次幂
if a.is_zero and b.is_negative:
return sp.nan
# 检查负数底数与非整数指数
if a.is_negative:
if not (b.is_integer or b.is_Integer):
return sp.nan
return sp.Pow(a, b)
def pow_element_num(a, b):
"""
数值标量安全性检查的幂运算
参数：
a, b: 数值标量（整数或浮点数）
返回：
float: 计算结果，若存在安全问题则返回NaN
安全性检查：
1. 零的负数次幂返回NaN
2. 负数底数与非整数指数返回NaN
3. 正确处理0^0情况（定义为1）
示例：
>>> eval_pow_element(4, 0.5) # 2.0
>>> eval_pow_element(-4, 0.5) # nan
>>> eval_pow_element(0, -1) # nan
>>> eval_pow_element(8, 1/3) # 2.0
>>> eval_pow_element(0, 0) # 1.0
"""
# 安全性检查1：零的负数次幂
if a == 0 and b < 0:
return float('nan')
# 安全性检查2：负数底数与非整数指数
if a < 0:
# 检查b是否为整数（考虑浮点精度）
if abs(b - round(b)) > 1e-10: # 容差处理浮点精度问题
return float('nan')
# 特殊处理：0^0定义为1
if a == 0 and b == 0:
return 1.0
# 安全计算幂
return a ** b
# 主处理逻辑
if isinstance(expr, tuple) and len(expr) == 2:
# 计算结果
if all(e.is_number for e in expr):
params = tuple(float(e) for e in expr)
result = pow_element_num(*params)
elif any(e.free_symbols for e in expr):
result = pow_element_sym(*expr)
else:
error = True
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误：{str(e)}"
# 示例代码
if __name__ == "__main__":
# 示例1：合法数值输入
print("示例1:")
print(real_pow_array("4,0.5"))
# 2.0
# 示例2：符号运算合法
x = sp.Symbol('x')
y = sp.Symbol('y')
print("示例2:", real_pow_array("x,y"))
# x**y
非负实数数组的平方根
Y = realsqrt(X) 返回数组X的每个元素的平方根. Y的大小与X的大小相同.
如果您希望负的复数返回复数结果而不是错误消息,请改用sqrt.
X - 输入矩阵,标量,向量,矩阵
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
def real_sqrt_array(input_str):
"""
计算非负实数数组的平方根，对标MATLAB的realsqrt函数
参数:
input_str: 输入表达式（SymPy矩阵/列表/矩阵字符串）
返回:
sp.Matrix: 数值平方根矩阵（元素为浮点数）
str: 错误信息（若输入非法或存在负数元素）
示例:
>>> real_sqrt_array("[1, 4, 9]")
Matrix([[1.0], [2.0], [3.0]])
>>> real_sqrt_array("Matrix([[0, 2], [3, 4.0]])")
Matrix([[0.0, 1.4142135623730951], [1.7320508075688772, 2.0]])
>>> real_sqrt_array("[[-1, 4], [2, 3]]")
'错误：元素 -1 是负数'
>>> real_sqrt_array("[x, 4]")
'错误：元素 x 无法转换为数值'
"""
try:
expr = sp.sympify(input_str)
sp_matrix = sp.Matrix(expr) if isinstance(expr, list) else None
# 检查输入是否为有效矩阵
if sp_matrix is None:
return f"输入错误: {input_str} 无法转换为矩阵"
# 检查所有元素是否为非负实数
for element in sp_matrix:
try:
num = element.evalf() # 尝试转换为数值
if not num.is_real: # 确保元素为实数
return f"错误：元素 {element} 不是实数"
if num < 0: # 确保元素非负
return f"错误：元素 {element} 是负数"
float(num) # 强制转换为浮点数验证数值有效性
except:
return f"错误：元素 {element} 无法转换为数值"
# 计算平方根并数值化结果
return sp_matrix.applyfunc(sp.sqrt).evalf()
except Exception as e:
return f"运行时错误: {e}"
# 合法数值输入
print(real_sqrt_array("[1, 4, 9]"))
# Matrix([[1.00000000000000],
# [2.00000000000000],
# [3.00000000000000]])
print(real_sqrt_array("[[0, 2], [3, 4.0]]"))
# Matrix([[0, 1.41421356237310],
# [1.73205080756888, 2.00000000000000]])
参数区域图
RegionPlot(expression1, expression2)通过参数方程定义了一个二维区域，并可视化该区域在笛卡尔平面中的形状。
1. 机械振动分析 - 李萨如图形区域
可视化机械系统在特定频率比下的振动轨迹包络区域
RegionPlot(2*sin(3*theta+phi),1.5*sin(2*theta),phi=[0,@pi/4],theta=[0,2@pi])
2. 电磁场分析 - 偶极子辐射场
天线辐射方向图的3D可视化
RegionPlot(1/(1-0.5*cos(phi))*sin(theta)*cos(phi),1/(1-0.5*cos(phi))*sin(theta)*sin(phi),theta=[0,@pi],phi=[0,2@pi])
3. 流体力学 - 卡门涡街区域
圆柱绕流中涡旋脱落的周期性区域
RegionPlot(2t+0.3*sin(2*@pi*0.4*t)*exp(-0.2y),y,t=[0,5],y=[-1,1])
4. 材料科学 - 晶体滑移系统
六方晶系材料在特定取向下的滑移系统激活区域
RegionPlot(r*cos(3*theta),r*sin(3*theta),r=[0.8,1.2],theta=[0,@pi/3])
5. 化学工程 - 反应器停留时间分布
连续搅拌釜反应器系统的停留时间分布区域
RegionPlot(t,(t^(n-1)*exp(-t*n))/(n-1)!,t=[0,3],n=[1,10])
复变函数的实部和虚部关系图
ReImPlot(expression)展示了一个复变函数在实轴这个“切片”上的行为，让我们能像观察一元实函数一样，直观地看到它的实部和虚部如何随实数x变化。
1. 平方根函数
标记出了函数的分支切割位置。在切割线上，函数发生了“跳跃”，实部和虚部表现出不连续的特性。
这对于物理和工程中处理多值函数（如电磁场、流体力学）至关重要，因为它指导我们如何选择正确的分支以避免得到非物理的结果。
ReImPlot(sqrt((x^2-1)*(x^2-4)),x=[-3,3])
2. 倒数函数
在 x=0 点，函数趋向于无穷，这是一个极点。图清晰地显示了极点的位置和性质。
在电磁学中，这可以表示一个点电荷的电位在电荷所在位置是奇异的。
ReImPlot(1/x,x=[-3,3])
3. 指数函数
这展示了指数函数在实轴上是纯实数的、且没有任何奇点的良好性质。
它常用于描述增长和衰减过程，如人口增长、放射性衰变、电路暂态响应等。其导数仍是自身，这一特性在求解微分方程时极为有用。
ReImPlot(exp(x),x=[-2,2])
4. 对数函数
这个图完美地展示了对数函数的分支切割。在图上，当 x 从正方向接近0时，ln(x) 趋向 -∞。当 x 穿越0到负实轴时，虚部发生了一个π的跳跃，这正体现了函数在分支切割上的不连续性。
对数函数在复分析、数论（例如素数定理）和信号处理（复倒谱分析）中应用广泛。
ReImPlot(ln(abs(x)),x=[-3,3])
5. 三角函数
这验证了复三角函数是实三角函数的自然推广，在实轴上完全退化为我们熟悉的样子。
它在描述波动现象（声波、光波、交流电）时是核心工具。
ReImPlot(sin(x),x=[-2@pi,2@pi])
叠加复变函数的实部和虚部关系图
ReImPlot(expression1, expression2)在同一个坐标系中直观地比较多个函数的性质，揭示它们之间深刻的内在联系。
直接比较不同函数的行为, 发现函数之间的恒等关系、对称性或差异, 同时观察多个函数共有的特性（如奇点、分支点）。
1. 三角恒等式
在 [-1, 1] 区间，两条实部曲线关于 π/4 对称，像镜子一样，它们的和是常数。
超出这个区间，虽然函数变得复杂，但它们的实部之和仍然保持为常数 π/2。这验证了恒等式的强大和普适性。
ReImPlot(asin(x),acos(x),x=[-4,4])
2. 指数函数与双曲函数
悬链线问题：描述悬挂在两点的绳子形状。
狭义相对论：洛伦兹变换因子 γ 和快度（rapidity）的关系就用双曲函数描述，其本质是指数函数在闵可夫斯基时空的体现。
ReImPlot(exp(x),sinh(x),cosh(x),x=[-2,2])
3. 函数与其导数
导数即斜率：sec(x)^2 的曲线完美地描绘了 tan(x) 曲线上每一点的瞬时变化率（斜率）。
奇点行为：当 x 接近 ±π/2 时，tan(x) 和 sec(x)^2 都趋向于无穷，这直观地展示了函数及其导数在奇点附近的行为。
在光学中，正切函数可以描述某些边界条件，其导数则与场的强度相关。
ReImPlot(tan(x),sec(x)^2,x=[-1.5,1.5])
4. 恒等函数与平方函数
f(z)=z 只是一个旋转和平移。
f(z)=z^2 会将角度加倍（例如，第一象限会被映射到上半平面）。
ReImPlot(x,x^2,x=[-2,2])
复变函数的实部和虚部关系三维图
ReImPlot3D(expression1) 不再将自变量限制在实轴上，而是允许其在复平面的一个区域上自由变化。它通过两个三维曲面来完整地表示一个复变函数.
ReImPlot3D 将复变函数从抽象的公式变成了可视化，理解函数奇点（极点、分支点）、全局特性（解析性、周期性）和特殊行为（如ζ函数的零点）
1. 平方根函数
实部曲面 (u(x,y))： 形状像一个拧毛巾的曲面。
虚部曲面 (v(x,y))： 形状像一个螺旋桨或双曲抛物面。
在物理学中，sqrt(z) 经常出现在涉及平方关系的领域，例如波矢 k = sqrt(ω² - ω_c²) 在波导理论中的计算，正确处理其分支至关重要。
ReImPlot3D(sqrt(x),x=[-3-3@i,3+3@i])
2. 倒数函数
实部曲面：u(x,y) = x/(x²+y²)。形状像一个无限高的漏斗或尖峰。
虚部曲面：v(x,y) = -y/(x²+y²)。
极点可视化：这个图形将极点 (Pole) 的概念展现得淋漓尽致。
电磁场应用：在电磁学中，1/z 可以表示一个二维点电荷的复电位。
ReImPlot3D(1/x,x=[-3-3@i,3+3@i])
3. 指数函数
实部曲面：u(x,y) = e^x * cos(y)。这是一个随着 x 增大幅度不断增大的周期振荡波形。
虚部曲面：v(x,y) = e^x * sin(y)。同样是一个振幅增长的周期波形，但与实部曲面存在 π/2 的相位差。
调和函数：它的实部和虚部本身都是调和函数（满足拉普拉斯方程 ∇²u=0）。
信号处理：它描述了复指数信号的实部和虚部，是傅里叶分析和信号处理的基础。
ReImPlot3D(exp(x),x=[-2-2@i,2+2@i])
4. 对数函数
实部曲面： 这个曲面是一个关于原点对称的曲面，形状像一个“漏斗”或“火山口”。
虚部曲面： 虚部曲面是复平面 (x, y)(x,y) 本身（即高度始终为0的平面）。
电磁学：在二维静电学中，\ln(|z|)ln(∣z∣) 表示一个无限长线电荷的电势（泊松方程的解）。
流体力学：描述不可压缩流体的源或汇的 velocity potential（速度势），其中流体从原点流出或流入。
ReImPlot3D(ln(abs(x)),x=[-3-2@i,3+3@i])
5. 三角函数
实部曲面： u(x, y) = sin(x)*cosh(y) 整体形状像一系列“振荡的山脊”，在 y=0y=0 附近振幅较小，远离时振幅变大。
虚部曲面： 整体形状像一种“扭曲的 saddle 形状”，在 y=0y=0 处为0，随 |y|∣y∣ 增大而振幅增大。
ReImPlot3D(sin(x),x=[-2@pi-2@pi*@i,2@pi+2@pi*@i])
多曲面复变函数的实部和虚部关系三维图
ReImPlot3D(expression1, expression2, ...)用于同时比较多个复变函数在复平面上的行为。这种可视化方法特别有助于理解函数之间的关系、对称性和变换特性。
特别适合研究函数族、变换对和特殊函数之间的关系。
1. 多值函数，通过分支切割定义其主值
实部曲面: Re(asin(z)) 曲面, Re(acos(z)) 曲面, 两个实部曲面之间的关系反映了恒等式 Re(asin(z)) + Re(acos(z)) = π/2
虚部曲面: Im(asin(z)) 曲面, Im(acos(z)) 曲面, 在分支切割线上有不连续性
三维可视化直观展示了 asin(z) + acos(z) = π/2 在复平面上的表现, 清晰地显示了分支切割的位置和性质
ReImPlot3D(asin(x),acos(x),x=[-4-4@i,4+4@i])
2. 指数函数与对数函数
实际意义：
展示指数函数和对数函数作为互逆运算的关系
揭示指数函数的周期性和对数函数的多值性之间的关系
曲面特征：
exp(z) 的实部和虚部都是周期振荡的曲面
log(z) 的实部是径向对称的曲面，虚部是幅角函数（螺旋状曲面）
ReImPlot3D(exp(z),log(z),z=[-2-2@i,2+2@i])
3. 双曲函数与三角函数
实际意义：
展示双曲函数与三角函数之间的深刻联系：sinh(iz) = i sin(z) 和 cosh(iz) = cos(z)
在物理学中，这对理解振动问题（三角函数）和悬链线问题（双曲函数）之间的关系很重要
在相对论中，双曲函数描述快度，而三角函数描述旋转，这种对应关系有重要意义
曲面特征：
三角函数的实部和虚部是周期振荡的曲面
双曲函数的实部和虚部是指数增长/衰减的曲面
可以观察到通过虚数变换 z → iz 时，双曲函数曲面如何转换为三角函数曲面
ReImPlot3D(sinh(z),cosh(z),sin(z),cos(z),z=[-2-2@i,2+2@i])
4. 特殊函数
实际意义：
Gamma 函数是阶乘在复平面上的推广，在数论、概率论和物理学中有广泛应用
同时显示 Gamma 函数及其倒数有助于理解函数的极点和零点分布
在量子场论中，Gamma 函数出现在费曼积分计算中
曲面特征：
Gamma(z) 的曲面在负整数处有极点（趋向无穷）
1/Gamma(z) 的曲面在负整数处有零点（趋向零）
可以清晰地看到函数在正实轴上的增长行为以及在其他区域的振荡行为
ReImPlot3D(gamma(z),1/gamma(z), z=[-4-4@i,4+4@i])
除后的余数
r = rem(a,b)返回a除以b后的余数,其中a是被除数,b是除数.此函数通常称为求余运算,表达式为r=a-b*fix(a/b).
rem 函数遵从rem(a,0)是NaN的约定.
a — 被除数,标量,向量,矩阵
b — 除数,标量,向量,矩阵
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def remainder_after_division(input_expr):
"""
计算除后的余数，对标MATLAB的rem函数
参数:
input_expr: 输入表达式（元组/列表/字符串），格式为(被除数, 除数)
返回:
sp.Matrix 或 sp.Expr: 计算结果（支持符号变量）
str: 错误信息
示例:
>>> remainder_after_division((5, 3))
2
>>> remainder_after_division("(Matrix([5, -5, 5]), 3)")
Matrix([[2, -2, 2]])
>>> remainder_after_division("([x, 7], 3)")
Matrix([[Mod(x, 3)], [1]])
>>> remainder_after_division("(2, 0)")
'错误：除数不能为零'
"""
try:
expr = sp.sympify(input_expr)
error = False
result = None
def remainder_dividend_sym(a, b):
quotient = sp.sign(a) * sp.floor(sp.Abs(a) / sp.Abs(b))
return a - b * quotient
def remainder_dividend_num(a, b):
quotient = np.fix(a / b)
return a - b * quotient
if isinstance(expr, tuple) and len(expr) == 2:
if all(e.is_number for e in expr):
params = tuple(float(e.evalf()) for e in expr)
result = remainder_dividend_num(*params)
elif any(e.free_symbols for e in expr):
result = remainder_dividend_sym(*expr)
else:
error = True
return result if not error else f"输入错误: {input_expr}"
except Exception as e:
return f"计算错误：{str(e)}"
# 标量与标量运算
print(remainder_after_division("-5.5, 3"))
# -2.5
# 符号与标量运算
print(remainder_after_division("x, 3"))
# x - 3*floor(Abs(x)/3)*sign(x)
重构数组
B = reshape(A,sz) 使用大小向量sz重构A以定义size(B).
A - 输入数组,向量,矩阵
sz - 输出大小, 由整数组成的行向量
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
def reshape_matrix(input_str):
"""
对标MATLAB的reshape函数，按列优先顺序重塑矩阵维度
参数:
input_str (str): 输入字符串，格式为 "([[矩阵元素], [新形状])"，例如 "([[1,2],[3,4]], [2,2])"
返回:
sp.Matrix or str: 成功返回重塑后的SymPy矩阵，失败返回错误信息字符串
示例:
>>> reshape_matrix("([[1,2],[3,4]], [4, 1])")
Matrix([
[1],
[3],
[2],
[4]])
>>> reshape_matrix("([[1,2,3],[4,5,6]], [3,2])")
Matrix([
[1, 5],
[4, 3],
[2, 6]])
"""
try:
# 解析输入字符串为SymPy表达式
expr = sp.sympify(input_str)
# 检查输入是否为 (矩阵, 新形状) 的元组
if not (isinstance(expr, tuple) and len(expr) == 2):
return "输入错误: 输入格式应为 (矩阵, 新形状)，例如 ([[1,2],[3,4]], [2,2])"
matrix_part, shape_part = expr
# 将矩阵部分转换为SymPy矩阵
sp_matrix = sp.Matrix(matrix_part) if isinstance(matrix_part, list) else None
if sp_matrix is None:
return f"输入错误: 无法解析矩阵部分 {matrix_part}"
# 解析新形状参数
if not isinstance(shape_part, (list, tuple)):
return f"输入错误: 新形状应为列表或元组，但得到 {type(shape_part).__name__}"
if len(shape_part) != 2:
return f"输入错误: 新形状需要2个维度，但得到 {len(shape_part)} 个"
try:
new_rows, new_cols = map(int, shape_part) # 确保形状为整数
except TypeError:
return "输入错误: 新形状维度必须为整数"
# 验证元素总数匹配
original_size = sp_matrix.rows * sp_matrix.cols
new_size = new_rows * new_cols
if original_size != new_size:
return f"错误: 元素总数不匹配 ({original_size} → {new_size})"
# 按列优先顺序展开元素
elements = []
for col in range(sp_matrix.cols):
for row in range(sp_matrix.rows):
elements.append(sp_matrix[row, col])
# 重塑为临时矩阵 (new_cols行, new_rows列)
temp_matrix = sp.Matrix(elements).reshape(new_cols, new_rows)
# 转置得到最终矩阵 (new_rows行, new_cols列)
result_matrix = temp_matrix.T
return result_matrix
except Exception as e:
return f"错误: {str(e)}"
# 示例测试
if __name__ == "__main__":
# 示例1: 2x2矩阵重塑为4x1
print("示例1:")
print(reshape_matrix("([[1, 2], [3, 4]], [4, 1])"))
# Matrix([[1],
# [3],
# [2],
# [4]])
# 示例2: 2x3矩阵重塑为3x2
print("\n示例2:")
print(reshape_matrix("([[1, 2, 3], [4, 5, 6]], [3, 2])"))
# Matrix([[1, 5],
# [4, 3],
# [2, 6]])
部分分式展开
[r,p,k] = residue(b,a) 计算以如下形式展开的两个多项式之比的部分分式展开式的留数,极点和直项.
b — 分子多项式的系数,数字向量
a — 分母多项式的系数,数字向量
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
def remain_partial_fraction(input_str):
"""
对标MATLAB的residue函数，执行部分分式分解，返回留数、极点和直项
参数:
input_str (str): 输入字符串，格式为 "([分子系数列表], [分母系数列表])"，例如 "([1,2], [1,4,3])"
返回:
tuple or str: 成功时返回 (留数列表, 极点列表, 直项系数列表)，失败时返回错误信息字符串
示例:
>>> remain_partial_fraction("([1, 2], [1, 4, 3])")
([1.5, -0.5], [-3.0, -1.0], [])
>>> remain_partial_fraction("([1], [1, -2, 1])")
([0.0, 1.0], [1.0, 1.0], [])
"""
try:
x = sp.symbols('x')
expr = sp.sympify(input_str)
# 验证输入格式
if not (isinstance(expr, tuple) and len(expr) == 2):
return "输入错误：输入应为包含两个系数列表的元组，例如 ([1,2], [3,4,5])"
num_coeffs, den_coeffs = expr
# 构建分子和分母多项式
numerator = sp.Poly(num_coeffs, x)
denominator = sp.Poly(den_coeffs, x)
# 分离直项和真分式部分
quotient, remainder = sp.div(numerator, denominator)
direct_terms = [float(coeff.evalf()) for coeff in quotient.all_coeffs()]
# 对真分式进行部分分式分解
f_true = remainder / denominator.as_expr()
partial = sp.apart(f_true, x, full=True)
# 初始化结果容器
residues = []
poles = []
# 处理每个分式项
for term in partial.as_ordered_terms():
term = term.simplify()
if term == 0:
continue
if term.is_polynomial():
continue # 直项已处理
# 分离分子分母并因式分解
numer, denom = term.as_numer_denom()
denom_factorized = sp.factor(denom)
# 遍历所有分母因子
for factor, power in sp.factor_list(denom_factorized)[1]:
# 处理幂次因子
if factor.is_Pow:
base, exp = factor.args
else:
base = factor
exp = 1
# 处理线性因子 (x - a)
if sp.Poly(base).is_linear:
a = sp.solve(base, x)[0]
other_denom = denom_factorized / (base ** exp)
residue_expr = numer / other_denom
# 添加极点并计算对应留数
for i in range(exp):
pole = a.evalf()
residue_val = residue_expr.subs(x, a).evalf() if i == exp - 1 else 0.0
poles.append(float(pole))
residues.append(float(residue_val))
# 处理不可约二次因子（复数根）
else:
# 提取复数根
roots = sp.roots(base, multiple=True)
for root in roots:
pole = root.evalf()
residue_val = (numer / (denom_factorized / base ** exp)).subs(x, pole).evalf()
poles.append(complex(pole))
residues.append(complex(residue_val))
# MATLAB式排序：按实部升序，虚部升序
sorted_pairs = sorted(zip(poles, residues),
key=lambda x: (x[0].real if isinstance(x[0], complex) else x[0],
x[0].imag if isinstance(x[0], complex) else 0))
if sorted_pairs:
poles, residues = zip(*sorted_pairs)
return (residues, poles, direct_terms)
except Exception as e:
return f"错误：{str(e)}"
# 示例测试
if __name__ == "__main__":
# 示例1: 单极点情况
print("示例1:")
print(remain_partial_fraction("([-4,8], [1,6,8])"))
# ((-12.0, 8.0), (-4.0, -2.0), [0.0])
# 示例2: 重复极点
print("\n示例2:")
print(remain_partial_fraction("([2,0,0,1,0], [1, 0, 1])"))
# (((2-1j), (2+1j)), (-1j, 1j), [2.0, 0.0, -2.0])
# 示例3: 复数极点
print("\n示例3:")
print(remain_partial_fraction("([1], [1, 0, 1])"))
# (((1+0j), (1+0j)), (-1j, 1j), [0.0])
旋转曲面
RevolutionPlot3D(expr1,expr2)通过将平面曲线绕固定轴旋转而生成的 3D 曲面。这种曲面在数学、工程和自然界中广泛存在，具有优美的对称性和实用性。
1. 圆环面 (Torus)
几何意义：将小圆绕大圆旋转
实际应用： 甜甜圈形状, 管道连接件, 粒子加速器的环形轨道
RevolutionPlot3D(3+cos(t),sin(t),t=[0,2@pi])
2. 球面 (Sphere)
几何意义：半圆绕直径旋转
实际应用：球形储罐, 天文馆穹顶, 轴承滚珠
RevolutionPlot3D(cos(t),sin(t),t=[0,2@pi]
3. 圆锥面 (Cone)
几何意义：直线绕 z 轴旋转
实际应用：圆锥形屋顶, 离心分离器, 交通锥标
RevolutionPlot3D(t,t=[0,5])
4. 双曲面 (Hyperboloid)
几何意义：双曲线绕轴旋转
实际应用：核电站冷却塔, 太空望远镜支撑结构, 建筑薄壳结构
RevolutionPlot3D(cosh(t),t,t=[-1,1])
5. 花瓶曲面 (Vase)
几何意义：波动曲线旋转
实际应用：陶瓷器皿设计, 建筑柱式装饰, 容器造型优化
RevolutionPlot3D(2+sin(t)+t/5,t,t=[0,4@pi])
6. 螺旋曲面 (Spiral Surface)
几何意义：螺旋线绕轴旋转
实际应用：螺旋输送机, DNA分子模型, 涡轮叶片设计
RevolutionPlot3D(t,sin(2t),t=[0,4@pi])
rewrite（expr，target）根据目标函数target重写符号表达式expr.
重写后的表达式在数学上等同于原始表达式,如果expr是一个向量或矩阵,rewrite对expr执行元素式操作.
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
def rewrite_another_expression(input_str):
"""
将输入表达式或矩阵中的元素用另一种函数重写。
参数:
input_str: 输入字符串，应为一个元组，格式为 (表达式或矩阵, 目标函数)。
例如："(sin(x), exp)" 或 "([[sin(x), cos(x)]], exp)"
返回:
重写后的表达式或矩阵，若输入错误则返回错误信息。
"""
try:
expr = sp.sympify(input_str)
error = False
result = None
# 检查输入是否为元组且包含两个元素
if isinstance(expr, tuple) and len(expr) == 2:
input_expr, target = expr[0], expr[1]
# 检查是否为矩阵
sp_matrix = sp.Matrix(input_expr) if isinstance(input_expr, list) else None
if sp_matrix is not None:
# 对矩阵每个元素应用 rewrite
result = sp_matrix.applyfunc(lambda x: x.rewrite(target))
else:
# 普通表达式应用 rewrite
result = input_expr.rewrite(target)
else:
error = True
return result if not error else f"输入格式错误: {input_str}"
except Exception as e:
return f"错误: {e}"
# 示例代码
if __name__ == "__main__":
# 示例 1: 将 sin(x) 用 exp 重写
input_str1 = "(sin(x), exp)"
print("示例1输入:", input_str1)
print("示例1输出:", rewrite_another_expression(input_str1))
# -I*(exp(I*x) - exp(-I*x))/2
# 示例 2: 将矩阵中的三角函数用 exp 重写
input_str2 = "([[sin(x), cos(x)]], exp)"
print("\n示例2输入:", input_str2)
print("示例2输出:", rewrite_another_expression(input_str2))
# Matrix([[-I*(exp(I*x) - exp(-I*x))/2, exp(I*x)/2 + exp(-I*x)/2]])
黎曼球复变函数图
RiemannSphereComplexPlot(exp)提供复变函数在整个扩展复平面（包括无穷远）上的全景视图。
在标准复平面上，函数在无穷远的行为很难可视化（通常用箭头表示趋于无穷的方向）。在球面上，这直接对应函数值在北极N附近的行为。
许多复变变换（特别是分式线性变换/Möbius 变换）在黎曼球面上有非常简洁和优美的几何解释（旋转、缩放、平移）。
函数在无穷远点的性质（极点、本性奇点、可去奇点）可以通过分析其在北极 N 附近的行为来定义和研究。
1. 分式线性变换 (Möbius 变换) 之一
清晰展示了分式线性变换在黎曼球面上的全局等距（保角）性质，以及无穷远点与有限点的互换
RiemannSphereComplexPlot(1/z, z=[-2-2@i, 2+2@i])
2. 正弦函数是整函数（全平面解析），但超越整函数，有无穷多个零点
生动展示了本性奇点在无穷远处的复杂行为，这是标准复平面绘图难以清晰表现的（通常只能看到模的爆炸增长或振荡，但无法同时体现其“填满”整个邻域的特性）。
RiemannSphereComplexPlot(sin(z), z=[-4-4@i,4+4@i])
3. 指数函数是整函数，没有零点
直观地展示了指数函数的周期性、模随实部的指数变化规律，以及本性奇点在无穷远处的行为（不同路径趋向无穷导致函数值行为迥异：趋向北极、趋向南极、或绕赤道旋转）。
RiemannSphereComplexPlot(exp(z), z=[-4-4@i,4+4@i])
4. 这是一个有理函数（亚纯函数），在 z = ±i 处有单极点
清晰地展示了一个简单亚纯函数的全局结构：两个有限极点（映射到 N），一个在无穷远的零点（映射到 S）。
这是理解更复杂有理函数零极点分布的基础。
在系统理论（如控制论、信号处理）中，这种零极点图（通常在复平面上画）对分析系统稳定性至关重要，黎曼球面提供了一种包含无穷远点的完整视角。
RiemannSphereComplexPlot(1/(z^2+1), z=[-3-3@i,3+3@i])
黎曼球面
RiemannSphereComplexPlot3D(expression) 使得复平面上的每个点都唯一对应球面上的一个点，从而允许我们可视化复函数在无穷远点的行为，并简化某些复分析问题的处理。
1. 分式函数
展示极点和零点的对称性。
RiemannSphereComplexPlot(1/z, z=[-2-2@i, 2+2@i])
2. 简单多项式
显示二次映射的特性。
RiemannSphereComplexPlot(z^5+1/10,z=[-2-2@i,2+2@i])
3. 三角函数
在黎曼球面上显示其周期性和极点分布。
RiemannSphereComplexPlot(sin(z), z=[-4-4@i,4+4@i])
删除缺失的条目
R = rmmissing(A) 从数组或表中删除缺失的条目. 如果A是向量,则rmmissing会删除包含缺失数据的所有条目. 如果A是矩阵,则rmmissing会删除包含缺失数据的所有行.
R = rmmissing(A,dim) 指定要沿其进行运算的 A 的维度. 默认情况下, rmmissing 沿其大小不为1的第一个维度进行运算
A — 输入数据,向量,矩阵
dim — 沿其运算的维度,1或2
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
from sympy.matrices import MatrixBase
import numpy as np
def remove_missing(input_str):
"""
删除矩阵或向量中的缺失值（NaN）
参数:
input_str: 输入字符串，支持以下格式：
- 单个矩阵：例如 "[[1, nan], [3, 4]]"
- 带参数的元组：例如 "([[1, nan], [3, 4]], 1)"
参数说明：1=删除包含NaN的行，2=删除包含NaN的列
返回:
处理后的矩阵（保持矩阵结构）或向量（返回列表形式）
如果输入错误，返回错误信息字符串
"""
try:
# 将字符串中的 nan 转换为 SymPy 的 nan 符号
expr = sp.sympify(input_str, locals={'nan': sp.nan})
result = None
error = False
# 处理带参数的元组输入
if isinstance(expr, tuple):
if len(expr) != 2:
error = True
else:
matrix_part, direction = expr
sp_matrix = sp.Matrix(matrix_part) if isinstance(matrix_part, list) else None
if sp_matrix is None or direction not in (1, 2):
error = True
else:
# 转换为 NumPy 数组处理
np_array = np.array(sp_matrix, dtype=float)
if direction == 1: # 删除包含NaN的行
mask = ~np.isnan(np_array).any(axis=1)
result_array = np_array[mask]
else: # 删除包含NaN的列
mask = ~np.isnan(np_array).any(axis=0)
result_array = np_array[:, mask]
# 转换回 SymPy 矩阵
result = sp.Matrix(result_array.tolist())
# 处理单个矩阵输入
else:
sp_matrix = sp.Matrix(expr) if isinstance(expr, list) else None
if sp_matrix is None:
error = True
else:
np_array = np.array(sp_matrix, dtype=float)
# 判断是否为向量（行数或列数为1）
if 1 in sp_matrix.shape:
# 展平并过滤NaN
flat_array = np_array.flatten()
filtered = flat_array[~np.isnan(flat_array)]
result = filtered.tolist() # 向量返回列表形式
else:
# 默认删除包含NaN的行
mask = ~np.isnan(np_array).any(axis=1)
result_array = np_array[mask]
result = sp.Matrix(result_array.tolist())
return result if not error else f"输入格式错误: {input_str}"
except Exception as e:
return f"处理错误: {str(e)}"
# 示例代码
if __name__ == "__main__":
# 示例1：删除包含NaN的行
print("示例1 输入:", "([1,3,nan,6,nan])")
print("示例1 输出:", remove_missing("([1,3,nan,6,nan])"))
# [1.0, 3.0, 6.0]
# 示例2：删除包含NaN的列
print("\n示例2 输入:", "([[1, nan], [3, 4]], 2)")
print("示例2 输出:", remove_missing("([[1, nan], [3, 4]], 2)"))
# Matrix([[1.00000000000000],
# [3.00000000000000]])
# 示例3：处理向量输入
print("\n示例3 输入:", "[nan, 2, 3]")
print("示例3 输出:", remove_missing("[nan, 2, 3]"))
# [2.0, 3.0]
检测并删除数据中的离群值
B = rmoutliers(A) 在 A 的数据中检测并删除离群值。如果 A 是矩阵，则 rmoutliers 会分别检测 A 的每列中的离群值，并删除整行。
B = rmoutliers(A,method) 指定检测离群值的方法。例如，rmoutliers(A,"mean") 将 A 中与均值相差超过三倍标准差的元素定义为离群值。
median(默认) — 离群值定义为与中位数相差超过三倍换算 MAD 的元素。换算 MAD 定义为 c*median(abs(A-median(A)))，其中 c=-1/(sqrt(2)*erfcinv(3/2))。
mean - 离群值定义为与均值相差超过三倍标准差的元素。此方法比 "median" 快，但没有它可靠。
quartiles - 离群值定义为比上四分位数 (75%) 大 1.5 个四分位差以上或比下四分位数 (25%) 小 1.5 个四分位差以上的元素。当 A 中的数据不是正态分布时，此方法很有用。
grubbs - 使用针对离群值的格拉布斯检验检测离群值，即基于假设检验每次迭代删除一个离群值。此方法假设 A 中的数据呈正态分布。
A — 数值向量，矩阵。
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
from scipy.special import erfcinv
def remove_outliers_data(input_str):
"""
对标 MATLAB 的 rmoutliers 函数，检测并删除数据中的离群值
参数:
input_str: 输入数据的字符串表达式，可以是矩阵、列表或元组（矩阵, 方法）
返回:
处理后的 SymPy 矩阵或错误信息字符串
支持方法:
'mean' - 三倍标准差法（默认）
'median' - 中位数绝对偏差法
'quartiles' - 四分位距法
'grubbs' - 格拉布斯检验法
"""
try:
expr = sp.sympify(input_str)
error = False
result = None
def evaluation_rmoutliers(A, method="median"):
"""
函数功能：在输入数据A中检测并删除离群值
参数说明：
A: 输入的数据，可以是一维数组或者二维矩阵形式
method: 检测离群值的方法，支持'mean'（与均值相差超过三倍标准差）、
'median'（与中位数相差超过三倍换算MAD的元素）、
'quartiles'（基于四分位数判定）、
'grubbs'（格拉布斯检验）、
'gesd'（广义极端Student化偏差检验），默认是'mean'
返回值：
删除离群值后的结果数据
"""
if method == "mean":
if A.ndim == 1:
mean_val = np.mean(A)
std_val = np.std(A)
mask = np.abs(A - mean_val) <= 3 * std_val
return A[mask]
elif A.ndim == 2:
row_num, col_num = A.shape
keep_rows = []
for col_idx in range(col_num):
col_data = A[:, col_idx]
mean_val = np.mean(col_data)
std_val = np.std(col_data)
col_mask = np.abs(col_data - mean_val) <= 3 * std_val
keep_rows.append(col_mask)
combined_mask = np.all(keep_rows, axis=0)
return A[combined_mask, :]
elif method == "median":
if A.ndim == 1:
median_val = np.median(A)
mad = np.median(np.abs(A - median_val))
c = -1 / (np.sqrt(2) * erfcinv(3 / 2))
diff = np.abs(A - median_val)
mask = diff <= 3 * c * mad
return A[mask]
elif A.ndim == 2:
row_num, col_num = A.shape
keep_rows = []
for col_idx in range(col_num):
col_data = A[:, col_idx]
median_val = np.median(col_data)
mad = np.median(np.abs(col_data - median_val))
c = -1 / (np.sqrt(2) * erfcinv(3 / 2))
diff = np.abs(col_data - median_val)
col_mask = diff <= 2 * c * mad
keep_rows.append(col_mask)
combined_mask = np.all(keep_rows, axis=0)
return A[combined_mask, :]
elif method == "quartiles":
if A.ndim == 1:
q1 = np.percentile(A, 25)
q3 = np.percentile(A, 75)
iqr = q3 - q1
lower_bound = q1 - 1.5 * iqr
upper_bound = q3 + 1.5 * iqr
mask = (A >= lower_bound) & (A <= upper_bound)
return A[mask]
elif A.ndim == 2:
row_num, col_num = A.shape
keep_rows = []
for col_idx in range(col_num):
col_data = A[:, col_idx]
q1 = np.percentile(col_data, 25)
q3 = np.percentile(col_data, 75)
iqr = q3 - q1
lower_bound = q1 - 1.5 * iqr
upper_bound = q3 + 1.5 * iqr
col_mask = (col_data >= lower_bound) & (col_data <= upper_bound)
keep_rows.append(col_mask)
combined_mask = np.all(keep_rows, axis=0)
return A[combined_mask, :]
elif method == "grubbs":
from scipy.stats import zscore
if A.ndim == 1:
while True:
z_scores = zscore(A)
max_abs_z = np.max(np.abs(z_scores))
if max_abs_z < 3: # 可根据实际调整临界值，这里暂用3作为参考
break
index_to_remove = np.argmax(np.abs(z_scores))
A = np.delete(A, index_to_remove)
return A
elif A.ndim == 2:
row_num, col_num = A.shape
keep_rows = []
for col_idx in range(col_num):
col_data = A[:, col_idx]
while True:
z_scores = zscore(col_data)
max_abs_z = np.max(np.abs(z_scores))
if max_abs_z < 3:
break
index_to_remove = np.argmax(np.abs(z_scores))
col_data = np.delete(col_data, index_to_remove)
keep_rows.append(np.isin(A[:, col_idx], col_data))
combined_mask = np.all(keep_rows, axis=0)
return A[combined_mask, :]
elif method == "gesd":
# 这里只是个简单框架示例，实际的gesd算法较复杂，可能需进一步完善和优化
if A.ndim == 1:
# 假设这里有合适的gesd实现逻辑，暂用简单逻辑替代
return A
elif A.ndim == 2:
# 同理，对于二维情况暂简单处理
return A
else:
return None
# 解析输入参数
if isinstance(expr, tuple) and len(expr) == 2:
matrix_part = sp.Matrix(expr[0]) if isinstance(expr[0], list) else None
method_part = expr[1]
if matrix_part is None or not str(method_part) in ["mean", "median", "quartiles", "grubbs"]:
error = True
else:
# 转换为 numpy 数组
if matrix_part.shape[1] == 1:
A = np.ravel(np.array(matrix_part, dtype=float))
else:
A = np.array(matrix_part, dtype=float)
result = evaluation_rmoutliers(A, method=str(method_part))
# 无方法参数的情况
elif isinstance(expr, list):
matrix_part = sp.Matrix(expr)
if matrix_part.shape[1] == 1:
A = np.ravel(np.array(matrix_part, dtype=float))
else:
A = np.array(matrix_part, dtype=float)
result = evaluation_rmoutliers(A, method="mean") # 默认使用均值法
else:
error = True
if error:
return f"输入格式错误: {input_str}"
else:
# 转换回 SymPy 矩阵并调整形状
result = sp.Matrix(result)
if result.shape[1] == 1 and A.ndim == 1:
return result.T # 一维数据返回行向量
return result
except Exception as e:
return f"处理过程中发生错误: {str(e)}"
if __name__ == "__main__":
# 示例代码
# 示例1：一维数据均值法
print("示例1 输出:", remove_outliers_data("[1, 2, 3, 100]"))
# Matrix([[1.00000000000000, 2.00000000000000, 3.00000000000000, 100.000000000000]])
# 示例2：二维数据中位数法
data = "[[1,200],[2,3],[3,4],[5,6]]"
print("示例2 输出:\n", remove_outliers_data(f"({data}, 'median')"))
# Matrix([[2.00000000000000, 3.00000000000000],
# [3.00000000000000, 4.00000000000000],
# [5.00000000000000, 6.00000000000000]])
# 示例3：四分位距法处理二维数据
data = "[[1, 2], [3, 4], [5, 6], [100, 200]]"
print("示例3 输出:\n", remove_outliers_data(f"({data}, 'quartiles')"))
# Matrix([[1.00000000000000, 2.00000000000000],
# [3.00000000000000, 4.00000000000000],
# [5.00000000000000, 6.00000000000000]])
# 示例4：格拉布斯检验法处理一维数据
print("示例4 输出:", remove_outliers_data("([10, 12, 13, 14, 100], 'grubbs')"))
# Matrix([[10.0000000000000, 12.0000000000000, 13.0000000000000, 14.0000000000000, 100.000000000000]])
多项式根
r = roots(p) 以列向量r的形式返回p中的系数表示的多项式的根.输入p是一个包含n+1多项式系数的向量,以x^n系数开头.例如：p = [3 2 -2]表示多项式3x^2+2x−2.0系数表示方程中不存在的中间幂.
p — 多项式系数,向量
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
def roots_of_poly(input_str):
"""
对标 MATLAB 的 roots 函数，计算多项式的根
参数:
input_str (str): 多项式的字符串表示，可以是：
- 系数列表（如 '[1, -3, 2]'，对应 x²-3x+2）
- 多项式表达式（如 'x**2 - 3*x + 2'）
返回:
list[complex]: 包含所有根的列表（复数形式），数值解经过四舍五入处理
str: 错误信息字符串（当输入无效时）
实现特性:
- 支持系数列表和多项式表达式两种输入形式
- 自动处理数值计算误差（四舍五入到小数点后10位）
- 返回包含复数根的完整解集
- 错误处理包含详细的异常信息
"""
try:
# 符号变量定义
x = sp.symbols('x')
# 解析输入字符串为SymPy表达式
expr = sp.sympify(input_str)
# 多项式对象生成逻辑
if isinstance(expr, list):
# 系数列表输入模式（MATLAB roots函数风格）
# 示例：输入 "[1, 2, 3]" 对应 x² + 2x + 3
poly = sp.Poly(expr, x)
else:
# 多项式表达式输入模式
# 示例：输入 "x**3 - 1" 对应 x³ - 1
poly = sp.Poly(expr, x)
# 计算数值根（包含复数根）
numerical_roots = poly.nroots()
# 处理数值精度问题
processed_roots = []
for root in numerical_roots:
# 改进后的SymPy原生处理
exact_root = sp.N(root, 10) # SymPy精度控制
r = sp.re(exact_root).evalf(10) # 精确实部
i = sp.im(exact_root).evalf(10) # 精确虚部
if i == 0:
processed_root = r # 纯实数输出
else:
processed_root = r + i * sp.I # SymPy复数
processed_roots.append(processed_root)
return processed_roots
except Exception as e:
# 错误处理（包含常见错误类型）
return f"错误: {str(e)}"
if __name__ == "__main__":
# 示例测试用例
test_cases = [
("[1, -3, 2]", "二次多项式（实数根）"),
# [1.000000000, 2.000000000]
("x**3 - 1", "三次单位根"),
# [1.000000000, -0.5 - 0.8660254038*I, -0.5 + 0.8660254038*I]
("x**2 + 4", "纯虚数根"),
# [-2.0*I, 2.0*I]
("[1, 0, 0, -1]", "四次多项式（x⁴-1）"),
# [1.000000000, -0.5 - 0.8660254038*I, -0.5 + 0.8660254038*I]
]
for input_str, description in test_cases:
print(f"测试用例: {description}")
print(f"输入: {input_str}")
result = roots_of_poly(input_str)
print("结果:", result)
print("-" * 60)
将数组旋转90度
B = rot90(A) 将数组A逆时针旋转90度, rot90在由第一个和第二个维度构成的平面中旋转.
B = rot90(A,k) 将数组A按逆时针方向旋转k*90度,其中k是一个整数.
A — 输入数组,向量,矩阵或多维数组
k是旋转常量,整数
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
def rot90_matrix(input_str):
"""
对标 MATLAB 的 rot90 函数，实现矩阵旋转功能
参数:
input_str (str): 输入字符串表达式，支持格式：
- 矩阵 (如 "[[1,2],[3,4]]")
- 元组格式 (矩阵, 旋转次数) (如 "([[1,2],[3,4]], 2)")
返回:
sp.Matrix: 旋转后的矩阵 (成功时)
str: 错误信息 (失败时)
功能特性:
- 支持逆时针旋转 (k>0)
- 支持顺时针旋转 (自动转换负数为等效正数)
- 自动处理整数溢出 (k 取模 4)
- 输入格式自动验证
"""
try:
expr = sp.sympify(input_str)
result = None
error = False
# 处理元组输入 (矩阵, 旋转次数)
if isinstance(expr, tuple) and len(expr) == 2:
matrix = sp.Matrix(expr[0]) if isinstance(expr[0], list) else None
k_expr = expr[1]
# 验证旋转次数是否为整数
if matrix is not None and k_expr.is_Integer:
k = int(k_expr) % 4 # 规范化旋转次数
result = matrix.rot90(k)
else:
error = True
# 处理单个矩阵输入 (默认旋转1次)
else:
matrix = sp.Matrix(expr) if isinstance(expr, list) else None
if matrix is not None:
result = matrix.rot90(1)
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 = [
("[[1,2],[3,4]]", "默认旋转1次 (逆时针90度)"),
# Matrix([[3, 1],
# [4, 2]])
("([[1,2],[3,4]], 2)", "旋转2次 (180度)"),
# Matrix([[4, 3],
# [2, 1]])
("([[1,2,3],[4,5,6]], -1)", "负数旋转 (顺时针90度)"),
# Matrix([[3, 6],
# [2, 5],
# [1, 4]])
("([1,2,3], 1)", "列向量旋转"),
# Matrix([[3, 2, 1]])
]
for input_str, desc in test_cases:
print(f"测试用例: {desc}")
print(f"输入: {input_str}")
result = rot90_matrix(input_str)
print("输出:" if isinstance(result, sp.Matrix) else "结果:", result)
print("=" * 60)
舍入至最近的小数或整数
Y = round(X)将X的每个元素四舍五入为最近的整数.在舍入机会均等的情况下,即有元素的十进制小数部分为0.5(在舍入误差内)时,round函数会偏离零四舍五入到最接近的具有更大幅值的整数.
Y = round(X,N) 四舍五入到N位数:
N > 0：舍入到小数点右侧的第N位数.
N = 0：四舍五入到最接近的整数.
N < 0：舍入到小数点左侧的第N位数.
X — 输入数组,标量,向量,矩阵
N — 位数,整数标量
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
def round_decimal_place(input_str):
"""
对标 MATLAB 的 round 函数，实现数值舍入功能
参数:
input_str (str): 输入字符串表达式，支持格式：
- 单个数值/表达式 (如 "3.1415" 或 "sqrt(2)")
- 矩阵 (如 "[[1.2, 3.4], [5.6, 7.8]]")
- 元组格式 (数值/矩阵, 小数位数) (如 "(3.1415, 2)")
返回:
float/sp.Matrix: 舍入后的数值或矩阵 (成功时)
str: 错误信息 (失败时)
功能特性:
- 支持矩阵元素级舍入
- 自动处理符号表达式数值化
- 支持正/负数舍入位数
- 自动验证输入格式有效性
"""
try:
expr = sp.sympify(input_str)
result = None
error = False
def evaluation_round(x, n=None):
"""核心舍入函数，处理数值和符号表达式"""
# 处理纯数值
return x.round(n) if n else x.round()
# 处理元组输入 (数值/矩阵, 小数位数)
if isinstance(expr, tuple) and len(expr) == 2:
x_part, n_part = expr
# 验证小数位数是否为整数
if not n_part.is_Integer:
error = True
else:
n = int(n_part)
# 处理矩阵输入
if isinstance(x_part, list):
matrix = sp.Matrix(x_part)
result = sp.Matrix(matrix.shape[0], matrix.shape[1],
lambda i, j: evaluation_round(matrix[i, j], n))
# 处理数值/符号输入
elif x_part.is_number or x_part.free_symbols:
result = evaluation_round(x_part, n)
else:
error = True
# 处理单个元素输入
else:
# 处理矩阵输入
if isinstance(expr, list):
matrix = sp.Matrix(expr)
result = sp.Matrix(matrix.shape[0], matrix.shape[1],
lambda i, j: evaluation_round(matrix[i, j]))
# 处理数值/符号输入
elif expr.is_number:
result = evaluation_round(expr)
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.1415926", "基本数值舍入"),
# 3
("([[1.234, 5.678], [9.012, 3.456]], 1)", "矩阵保留1位小数"),
# Matrix([[1.2, 5.7],
# [9.00000000000000, 3.5]])
("([2.345, 6.789], 2)", "列向量保留2位小数"),
# Matrix([[2.34],
# [6.79]])
("(-3.5, 0)", "负数舍入到整数"),
# -4
]
for input_str, desc in test_cases:
print(f"测试用例: {desc}")
print(f"输入: {input_str}")
result = round_decimal_place(input_str)
if isinstance(result, sp.Matrix):
print("输出矩阵:")
print(result)
else:
print("结果:", result)
print("=" * 60)
简化的行阶梯形矩阵(高斯消去法)
R = rref(A) 使用 Gauss-Jordan 消去法和部分主元消去法返回简化行阶梯形的A
A — 输入矩阵, 矩阵
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
def row_reduce_gauss(input_str):
"""
对标 MATLAB 的 rref 函数，计算简化行阶梯形矩阵
参数:
input_str (str): 输入字符串表达式，支持格式：
- 数值矩阵 (如 "[[1,2],[3,4]]")
- 符号矩阵 (如 "[[x, 1], [2, y]]")
- 增广矩阵 (如 "[[1,2,5],[3,4,6]]")
返回:
sp.Matrix: 简化行阶梯形矩阵 (成功时)
str: 错误信息 (失败时)
功能特性:
- 支持符号运算
- 自动处理分数形式
- 保留行交换信息
- 完整错误处理链
"""
try:
# 解析输入表达式
expr = sp.sympify(input_str)
# 转换为矩阵对象
matrix = sp.Matrix(expr) if isinstance(expr, list) else None
if matrix is None:
return f"输入错误: 无法转换为矩阵 - {input_str}"
# 执行高斯消去法
reduced_matrix, pivots = matrix.rref()
return reduced_matrix
except Exception as e:
return f"错误: {str(e)}"
if __name__ == "__main__":
# 示例测试用例
test_cases = [
("[[1,2],[3,4]]", "数值矩阵"),
# Matrix([[1, 0],
# [0, 1]])
("[[1,2,5],[3,4,6]]", "增广矩阵"),
# Matrix([[1, 0, -4],
# [0, 1, 9/2]])
("[[x,1],[2,y]]", "符号矩阵"),
# Matrix([[1, 0],
# [0, 1]])
("[1,2,3]", "行向量"),
# Matrix([[1],
# [0],
# [0]])
]
for input_str, desc in test_cases:
print(f"测试用例: {desc}")
print(f"输入: {input_str}")
result = row_reduce_gauss(input_str)
if isinstance(result, sp.Matrix):
print("简化行阶梯形:")
print(result)
else:
print("结果:", result)
print("=" * 60)
将实数舒尔形式转换为复数舒尔形式
[Unew,Tnew] = rsf2csf(U,T) 将实矩阵 X 的 [U,T] = schur(X) 的输出从实数舒尔形式变换为复数舒尔形式。
此操作变换 X 的特征值在 T 中的表示方式，并变换 U 以使 X = Unew*Tnew*Unew' 且 Unew'*Unew = eye(size(X))。.
U — 酉矩阵, 矩阵
T — 舒尔形式, 矩阵
Unew — 变换后的酉矩阵, 矩阵, 矩阵 Unew 满足 Unew'*Unew = eye(size(X))。
Tnew — 变换后的舒尔形式, 矩阵, Tnew 是上三角矩阵，X 的特征值在对角线上，且它满足 X = Unew*Tnew*Unew'。
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
from scipy import linalg
import numpy as np
def real_schur_complex_schur(input_str):
"""
将实数舒尔形式转换为复数舒尔形式（参数顺序调整为MATLAB风格）
参数:
U (sympy.Matrix): 正交变换矩阵
T (sympy.Matrix): 实数舒尔形式的上准三角矩阵
返回:
tuple: (U_csf, T_csf) 与MATLAB一致
异常:
ValueError: 如果输入矩阵无效
"""
try:
# 检查输入矩阵
expr = sp.sympify(input_str)
T, U = None, None
# 检查表达式是否为元组且长度为 2
if isinstance(expr, tuple) and len(expr) == 2:
# 如果是，则将元组中的元素分别赋值给 U 和 T
U, T = expr
else:
# 若不满足条件，返回输入参数错误的提示信息
return f"输入参数不对。"
# 将 sympy 矩阵 T 转换为 numpy 数组，数据类型为 float
if isinstance(T, list):
T_np = np.array(T, dtype=float)
# 将 sympy 矩阵 U 转换为 numpy 数组，数据类型为 float
if isinstance(U, list):
U_np = np.array(U, dtype=float)
# 调用 scipy.linalg 的 rsf2csf 函数，将实数舒尔形式转换为复数舒尔形式
T2, U2 = linalg.rsf2csf(T_np, U_np)
# 将转换后的 numpy 数组 T2 和 U2 转换为 sympy 矩阵并返回
return sp.Matrix(T2), sp.Matrix(U2)
except Exception as e:
raise ValueError(f"转换失败: {str(e)}")
# 修改后的示例代码
if __name__ == "__main__":
# 示例矩阵（调整参数顺序为U,T）
T_real = [
[4.8121, 1.1972, -2.2273, -1.0067],
[0, 1.9202, -3.0485, -1.8381],
[0, 0.7129, 1.9202, 0.2566],
[0, 0, 0, 1.3474]
]
U_real = [
[-0.4916, -0.49, -0.6331, -0.3428],
[-0.4980, 0.2403, -0.2325, 0.8001],
[-0.6751, 0.4288, 0.4230, -0.4260],
[-0.2337, -0.7200, 0.6052, 0.2466]
]
# 直接传入矩阵对象（不再使用字符串）
U_csf, T_csf = real_schur_complex_schur(f"{U_real},{T_real}")
print("复数舒尔形式 T_csf:")
print(T_csf)
# Matrix([[-0.491600000000000, -0.275620718655525 - 0.441127791460706*I, 0.213321990429959 + 0.56995511178321*I, -0.342800000000000],
# [-0.498000000000000, -0.101219107704011 + 0.216332669975526*I, -0.104614845510856 + 0.209310635744111*I, 0.800100000000000],
# [-0.675100000000000, 0.184153473371169 + 0.386031830568063*I, -0.186678509176258 - 0.380810317934446*I, -0.426000000000000],
# [-0.233700000000000, 0.263474425731044 - 0.648187775207568*I, 0.313452720631777 - 0.544837835493917*I, 0.246600000000000]])
print("\n酉矩阵 U_csf:")
print(U_csf)
# Matrix([[4.81210000000000, -0.969657284254384 + 1.07779222844236*I, -0.521202218250505 + 2.00515087738864*I, -1.00670000000000],
# [0, 1.9202 + 1.47420339505782*I, 2.33560000000000, 0.111711066825158 + 1.65476937445699*I],
# [0, 0, 1.9202 - 1.47420339505782*I, 0.800218674712874 + 0.231006920997586*I], [0, 0, 0, 1.34740000000000]])
黎曼和
rsums(f) 以交互方式通过 x 从 0 到 1 的中间黎曼和来近似 f(x) 的积分.
f — 被积函数,符号表达式,符号函数,符号数
a — 下限数字,符号数字.
b — 上限数字,符号数字.
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
def riemann_sums_evaluation(input_str):
try:
# 将输入字符串转换为SymPy表达式
expr = sp.sympify(input_str)
error = False
result = None
def evaluation_riemann_sum(f, a=0, b=1):
"""
计算函数f在区间[a, b]上的左端点黎曼和。
参数:
f: SymPy表达式，被积函数
a: 积分下限
b: 积分上限
返回:
黎曼和的数值结果，无法计算时返回None
"""
# 确定积分变量
method = 'midpoint'
n = 100
symbols = f.free_symbols
if len(symbols) == 0:
x = sp.Symbol('x') # 处理常数函数
elif len(symbols) == 1:
x = symbols.pop()
else:
return None
dx = (b - a) / n
riemann_sum = 0
for i in range(n):
if method == 'left':
x_i = a + i * dx
elif method == 'midpoint':
x_i = a + (i + 0.5) * dx # 中点法修正
elif method == 'right':
x_i = a + (i + 1) * dx
else:
raise ValueError("Invalid method")
riemann_sum += f.subs(x, x_i) * dx
return sp.N(riemann_sum)
# 处理输入为元组（函数, a, b）的情况
if isinstance(expr, tuple) and len(expr) == 3:
f_part, a_part, b_part = expr
# 检查函数变量数和a,b是否为数值
if (len(f_part.free_symbols) <= 1 and
a_part.is_number and
b_part.is_number):
result = evaluation_riemann_sum(f_part, a_part.evalf(), b_part.evalf())
error = result is None
else:
error = True
# 处理输入为单个表达式的情况（使用默认区间[0, 1]）
elif isinstance(expr, sp.Expr):
result = evaluation_riemann_sum(expr)
error = result is None
else:
error = True
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {e}"
# 示例用法
if __name__ == "__main__":
# 示例1：x^2在[0,1]的黎曼和
print(riemann_sums_evaluation("x**2"))
#0.333325000000000
# 示例2：sin(x)在[0, pi]的积分
print(riemann_sums_evaluation("(sin(x), 0, pi)"))
# 2.00008224907099
# 示例3：常数函数3在[0,2]的积分
print(riemann_sums_evaluation("(3, 0, 2)"))
# 5.99999999999999
# 示例4：a > b的情况
print(riemann_sums_evaluation("(x, 2, 1)"))
# -1.50000000000000