广义拉盖尔函数和拉盖尔多项式
如果n是非负整数,laguerreL(n,x)返回n次拉盖尔多项式.当n不是非负整数时.laguerreL返回拉盖尔函数.
如果n是非负整数,则laguerreL(n,a,x) 返回n次广义拉盖尔多项式.
n — 多项式的次数, 数,向量,矩阵,符号数,符号向量,符号矩阵,符号函数
x — 输入, 数,向量,矩阵,符号数,符号向量,符号矩阵,符号函数
a — 输入, 数,向量,矩阵,符号数,符号向量,符号矩阵,符号函数
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
from scipy.special import eval_genlaguerre
def laguerre_polynomial(input_str):
"""
计算广义或普通 Laguerre 多项式，对标 MATLAB 的 laguerreL 函数
参数:
input_str: 字符串形式的输入，支持以下格式：
- 两个参数: "(n, x)" 对应普通 Laguerre 多项式
- 三个参数: "(n, a, x)" 对应广义 Laguerre 多项式
参数可以是标量或矩阵
返回:
SymPy 表达式/矩阵 或 错误信息字符串
示例:
>>> laguerre_polynomial("(2, 0.5)")
0.125
>>> laguerre_polynomial("(2, 1, 0.5)")
0.375
>>> laguerre_polynomial("([[1,2], [3,4]], [[0,1], [2,3]])")
Matrix([
[1, 0.5],
[0, -0.5]])
"""
try:
expr = sp.sympify(input_str)
error = False
result = None
# 参数解析逻辑
if isinstance(expr, tuple):
# 处理广义 Laguerre 多项式 (n, a, x)
if len(expr) == 3:
if all(e.is_number for e in expr):
n = int(expr[0])
a = float(expr[1])
x = complex(expr[2])
result = eval_genlaguerre(n, a, x)
elif any(e.free_symbols for e in expr):
result = sp.assoc_laguerre(*expr).doit()
else:
error = True
elif len(expr) == 2:
if all(e.is_number for e in expr):
n = int(expr[0])
a = 0
x = complex(expr[1])
result = eval_genlaguerre(n, a, x)
elif any(e.free_symbols for e in expr):
result = sp.laguerre(*expr).doit()
else:
error = True
else:
error = True
else:
error = True
return result if not error else f"错误：输入必须是参数元组"
except Exception as e:
return f"错误：{str(e)}"
# 示例测试
if __name__ == "__main__":
# 普通 Laguerre 测试
print("普通 Laguerre 多项式测试:")
print(laguerre_polynomial("0, 5"))
# (1+0j)
print(laguerre_polynomial("1, 2"))
# (-1+0j)
print(laguerre_polynomial("x, 0.5"))
# laguerre(x, 0.5)
# 广义 Laguerre 测试
print("\n广义 Laguerre 多项式测试:")
print(laguerre_polynomial("(x, 0, 5)"))
# laguerre(x, 0.5)
print(laguerre_polynomial("(2, 1, 0.5)"))
# (1.625+0j)
朗伯W函数
lambertw(x)返回Lambert W函数的主分支.此语法等效于lambertw(0,x).
lambertw(k，x)是Lambert W函数的第k个分支.仅当k=0或k=-1时.此语法才返回实值.
x —— 输入,数字,矢量,矩阵,数组,符号数,符号变量,符号数组,符号函数,符号表达式
k —— Lambert W函数的分支,整数,整数的矢量或矩阵,符号整数,符号矢量或整数的矩阵
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
from scipy.special import lambertw
def lambert_w_value(input_str):
"""
对标 MATLAB 的 lambertw 函数，计算 Lambert W 函数的值，支持标量和矩阵输入。
参数:
input_str: 输入的字符串，可以是数值、矩阵或元组（分支参数和变量参数）。
返回:
计算结果（数值、矩阵或符号表达式），或错误信息。
示例:
>>> lambert_w_value("0.5")
0.3517337112491958
>>> lambert_w_value("(-1, 0.5)")
-1.756431208626170
>>> lambert_w_value("[[1, 2], [3, 4]]")
Matrix([
[0.567143290409784, 0.852605502013725],
[1.04990889496404, 1.20216787319705]])
"""
try:
expr = sp.sympify(input_str)
error = False
result = None
# 处理元组输入 (分支k, 变量x)
if isinstance(expr, tuple) and len(expr) == 2:
k_part = expr[0]
x_part = expr[1]
if k_part.is_integer and x_part.is_number:
k = int(k_part)
x = complex(x_part)
result = lambertw(x, k=k)
elif k_part.is_integer and x_part.free_symbols:
result = sp.LambertW(x_part, k_part)
else:
error = True
elif expr.is_number:
k = 0
x = complex(expr)
result = lambertw(x, k=k)
elif expr.free_symbols:
result = sp.LambertW(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: 计算主分支 W0(0.5)
print("示例1:", lambert_w_value("0.5"))
# (0.35173371124919584+0j)
# 示例2: 计算分支 k=-1 的 W_{-1}(0.5)
print("示例2:", lambert_w_value("(-1, 0.5)"))
# (-2.259158898533606-4.220960969266197j)
拉普拉斯变换
F = laplace(f) 返回 f 的拉普拉斯变换. 默认情况下, 独立变量为t, 变换变量为s.
F = laplace(f,transVar) 使用变换变量 transVar 而不是 s.
F = laplace(f,var,transVar) 分别使用独立变量 var 和变换变量 transVar 而不是 t 和 s.
f — 输入, 符号表达式,符号函数,符号向量,符号矩阵
var — 独立变量,t(默认),符号变量. 独立变量, 指定为符号变量. 此变量通常称为“时间变量”或“空间变量”. 如果您未指定变量, 则默认情况下, 拉普拉斯使用t. 如果f不包含t, 则拉普拉斯使用函数 symvar 来确定独立变量.
transVar — 变换变量, s（默认）| z , 符号变量 , 符号表达式 , 符号向量 , 符号矩阵 变换变量,指定为符号变量、表达式、向量或矩阵. 此变量通常称为“复频率变量”. 如果您未指定变量,则默认情况下,拉普拉斯使用s. 如果s是f的独立变量, 则拉普拉斯使用z.
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
def laplace_transform(input_str):
"""
对标 MATLAB 的 laplace 函数，计算拉普拉斯变换
参数:
input_str: 输入字符串，可以是：
1. 单个表达式 (自动检测变量)
2. 元组 (f, transVar)
3. 元组 (f, var, transVar)
4. 矩阵
返回:
拉普拉斯变换结果 (数值、矩阵或符号表达式)，或错误信息
示例:
>>> laplace_transform("exp(-t)")
1/(s + 1)
>>> laplace_transform("(exp(-t), z)")
1/(z + 1)
>>> laplace_transform("(sin(a*x), x, s)")
a/(a**2 + s**2)
>>> laplace_transform("[[t, t**2], [t**3, t**4]]")
Matrix([
[ 1/s**2, 2/s**3],
[6/s**4, 24/s**5]])
"""
try:
expr = sp.sympify(input_str)
error = False
result = None
def compute_laplace(f, var=None, trans_var=None):
"""
核心计算函数
"""
# 自动检测变量
if var is None:
# 优先尝试常用变量 t
t = sp.symbols('t')
var = t if f.has(t) else next(iter(f.free_symbols), t)
# 自动生成变换变量
if trans_var is None:
trans_var = sp.symbols('s') if var == sp.symbols('t') else sp.symbols('z')
# 执行拉普拉斯变换并忽略收敛条件
return sp.laplace_transform(f, var, trans_var, noconds=True)
# 处理元组输入 (f, var, trans_var) 或 (f, trans_var)
if isinstance(expr, tuple):
params = list(expr)
n_params = len(params)
if n_params not in (2, 3):
return f"错误：需要 2 或 3 个参数，当前收到 {n_params} 个"
# 解析参数
f_part = params[0]
var_part = params[1] if n_params == 3 else None
trans_var_part = params[-1]
# 标量计算
result = compute_laplace(
f=f_part,
var=var_part,
trans_var=trans_var_part
)
# 处理标量输入
elif expr.free_symbols:
result = compute_laplace(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:", laplace_transform("exp(-t)"))
# 1/(s + 1)
# 测试2: 指定变换变量
print("测试2:", laplace_transform("(exp(-t), z)"))
# 1/(z + 1)
# 测试3: 指定变量和变换变量
print("测试3:", laplace_transform("(sin(a*x), x, s)"))
# a/(a**2 + s**2)
拉普拉斯算子
l = laplacian(f,v) 返回符号域 f 相对于笛卡尔坐标中的向量 v 的拉普拉斯算子. 如果 f 是一个数组, 则该函数计算 f 的每个元素的拉普拉斯算子并返回与 f 大小相同的输出 l.
l = laplacian(f) 返回符号域 f 相对于由 f 中的符号变量构造的默认向量的拉普拉斯算子.
f — 符号域,符号表达式,符号函数,符号矩阵变量,符号矩阵函数
v — 用于查找拉普拉斯算子的向量,符号标量变量的向量,符号函数,符号矩阵变量,符号矩阵函数
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
def laplacian_equation(input_str):
"""
对标 MATLAB 的 laplacian 函数，计算拉普拉斯算子
参数:
input_str: 输入字符串，支持以下形式：
1. 标量表达式 (自动检测变量)
2. 元组 (表达式, 变量列表)
3. 矩阵 (逐元素计算)
返回:
拉普拉斯算子计算结果 (标量、矩阵或符号表达式)，或错误信息
示例:
>>> laplacian_equation("x**2 + y**2")
4
>>> laplacian_equation("([[x*y, x**2], [y**2, x+y]], [x, y])")
Matrix([
[0, 2],
[2, 0]])
"""
try:
expr = sp.sympify(input_str)
error_msg = None
result = None
def compute_laplacian(f, vars=None):
"""计算拉普拉斯算子的核心函数"""
# 自动检测变量（按字母顺序排序）
if vars is None:
vars = sorted(f.free_symbols, key=lambda s: s.name)
if not vars:
raise ValueError("表达式不含自由变量")
# 验证变量类型
if not all(isinstance(v, sp.Symbol) for v in vars):
raise TypeError("变量列表中包含非符号对象")
# 计算拉普拉斯算子：Σ ∂²f/∂v²
return sum(sp.diff(f, v, v) for v in vars)
# 处理元组输入 (表达式, 变量列表)
if isinstance(expr, tuple):
# 参数数量验证
if len(expr) != 2:
return f"错误：需要 2 个参数的元组 (表达式, 变量列表)，收到 {len(expr)} 个参数"
f_part, vars_part = expr[0], expr[1]
# 变量列表验证
if not isinstance(vars_part, (list, tuple)):
return "错误：第二个参数必须是变量列表"
# 转换为符号变量
try:
vars_list = [sp.sympify(v) for v in vars_part]
except Exception as e:
return f"变量列表解析错误: {str(e)}"
result = compute_laplacian(f_part, vars_list)
# 处理标量输入 (自动检测变量)
elif expr.free_symbols:
result = compute_laplacian(expr)
else:
error_msg = f"无法识别的输入类型: {type(expr)}"
return result if not error_msg else error_msg
except Exception as e:
return f"错误：{str(e)}"
# 测试用例
if __name__ == "__main__":
# 测试1: 标量函数
print("测试1:", laplacian_equation("f(x,y,z)"))
# Derivative(f(x, y, z), (x, 2)) + Derivative(f(x, y, z), (y, 2)) + Derivative(f(x, y, z), (z, 2))
print("测试2:", laplacian_equation("x**2 + y**2 + z**2"))
# 6
# 测试3: 带变量列表
print("测试3:", laplacian_equation("(sin(x)*cos(y), [x, y])"))
# -2*sin(x)*cos(y)
最小公倍数
L = lcm(A,B) 返回 A 和 B 元素的最小公倍数.
A,B — 输入值,标量,向量,实数数组或正整数值
L — 最小公倍数,实数,正整数值
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def lcm_number(input_str):
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):
params = tuple(int(e) for e in expr)
result = np.lcm(*params)
elif any(e.free_symbols for e in expr):
result = sp.lcm(*expr)
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__":
# 示例1：数值计算
print(lcm_number("(6, 8)"))
# 24
埃尔米特不定矩阵的分块LDL分解
[L,D,P] = ldl(A)将满矩阵A分解为置换的下三角矩阵L和满足A = L*D*L'的分块对角矩阵D, 以向量形式返回置换信息P.
A — 输入矩阵,实数或复数方阵
L — 下三角因子,方阵
D — 分块对角因子,方阵
P — 置换信息,矩阵,向量
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import numpy as np
import sympy as sp
from scipy.linalg import lu, ldl
def ldl_decomposition_matrix(input_str):
"""
执行 LDL 分解的主函数
参数:
input_str: 输入矩阵的字符串表达式(如 "[[1, 2], [3, 4]]")
返回:
- 符号矩阵: 返回 (L, D) 元组
- 数值矩阵: 返回 (L, D, perm) 元组
- 错误输入: 返回错误消息字符串
注意:
- 当矩阵包含符号时自动声明符号为实数类型
- 自动检查矩阵对称性（符号矩阵场景）
"""
try:
# 将输入字符串转换为 SymPy 表达式
expr = sp.sympify(input_str)
error = False
result = None
A = sp.Matrix(expr) if isinstance(expr, list) else None
if A is not None:
# 检测符号和虚数存在性
contains_symbols = A.is_symbolic()
has_imaginary = any(element.has(sp.I) for element in A)
if contains_symbols:
# 自动声明所有符号为实数
symbols = A.free_symbols
real_subs = {s: sp.Symbol(s.name, real=True) for s in symbols}
A = A.subs(real_subs)
# 显式检查矩阵对称性
if A != A.T:
return f"错误: 矩阵必须对称，当前矩阵不对称\n{A}"
# 执行 LDL 分解
try:
l, d = A.LDLdecomposition()
result = (l, d)
except ValueError as e:
return f"分解错误: {e}"
elif has_imaginary:
# 执行 LDL 分解
try:
l, d = A.LDLdecomposition()
result = (l, d)
except ValueError as e:
return f"分解错误: {e}"
else:
# 数值矩阵处理
try:
N_A = np.array(A, dtype=float)
lu_mat, d_mat, perm = ldl(N_A)
result = (
sp.Matrix(lu_mat),
sp.Matrix(d_mat),
sp.Matrix(perm)
)
except np.linalg.LinAlgError as e:
return f"数值分解错误: {e}"
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: 符号矩阵分解")
symbolic_matrix = "[[a, b], [b, c]]"
print(f"输入矩阵: {symbolic_matrix}")
L, D = ldl_decomposition_matrix(symbolic_matrix)
print("L 矩阵:")
print(L)
# Matrix([[1, 0],
# [b/a, 1]])
print("D 矩阵:")
print(D)
# Matrix([[a, 0],
# [0, c - b**2/a]])
print("\n" + "=" * 50 + "\n")
# 示例 2: 实数数值矩阵分解
print("示例 2: 数值矩阵分解")
numeric_matrix = "[[4, 12, -16], [12, 37, -43], [-16, -43, 98]]"
print(f"输入矩阵: {numeric_matrix}")
L, D, perm = ldl_decomposition_matrix(numeric_matrix)
print("L 矩阵:")
print(L)
# Matrix([[1.00000000000000, 0, 0],
# [3.00000000000000, 0.147058823529412, 1.00000000000000],
# [-4.00000000000000, 1.00000000000000, 0]])
print("D 矩阵:")
print(D)
# Matrix([[4.00000000000000, 0, 0],
# [0, 34.0000000000000, 0],
# [0, 0, 0.264705882352941]])
print("置换矩阵:")
print(perm)
# Matrix([[0],
# [2],
# [1]])
print("\n" + "=" * 50 + "\n")
勒奇超越函数
LenchPhi(z,s,a)对于某些特殊参数，LerchPhi会自动计算为精确值.
LerchPhi可以评估为任意的数值精度.
z,s,a -- 输入, 数字,符号变量,向量,矩阵
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
from mpmath import lerchphi
def lench_phi_transcendent(input_str):
"""
对标 MATLAB 的 LerchPhi 函数的实现，支持标量和矩阵输入
Lerch Phi 函数定义:
Φ(z, s, a) = ∑_{n=0}^∞ z^n / (a + n)^s
分类归属:
属于特殊函数中的超越函数（Transcendental Function），
是广义的 Zeta 函数，包含 Riemann Zeta 和 Hurwitz Zeta 函数作为特例
参数:
input_str: 输入表达式字符串，格式为元组 (n, a, x) 或单个数值，
支持矩阵输入（需确保维度一致）
返回:
计算结果（标量/矩阵）或错误信息字符串
示例:
>>> lench_phi_transcendent("(0.5, 1, 0.2)")
1.64493406684823
>>> lench_phi_transcendent("([[0.5, 1], [2, 3]], 1, 0.2)")
Matrix([
[1.64493406684823, 2.16439397443791],
[3.30685281944005, 4.17469149400356]])
"""
try:
# 解析输入为 SymPy 表达式
expr = sp.sympify(input_str, evaluate=False)
error = False
# 参数校验
if not isinstance(expr, tuple) or len(expr) != 3:
return f"输入格式错误: 需要三元组 (n, a, x)，实际输入 {input_str}"
if all(e.is_number for e in expr):
params = tuple(complex(e.evalf()) for e in expr)
result = lerchphi(*params)
elif any(e.free_symbols for e in expr):
result = sp.lerchphi(*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(lench_phi_transcendent("(0.5, 1, 0.2)"))
# (5.59472668491108 + 0.0j)
print(lench_phi_transcendent("(2, 1, 1.5)"))
# (-0.376774759859769 - 1.11072073453959j)
第一类勒让德多项式
P = legendre(n,X) 为 X 中的每个元素计算阶数为n,级数为m = 0, 1, ..., n 时的第一类勒让德多项式.
n — 勒让德函数的阶,正整数
X — 输入值,标量,向量,矩阵
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
from scipy.special import eval_legendre
def legendre_polynomial(input_str):
"""
对标 MATLAB 的 legendreP 函数，计算 Legendre 多项式
参数:
input_str: 输入字符串，可以是以下形式：
1. 元组 (n, x)：标量或矩阵参数
2. 单个数值/符号：默认视为 n=输入值，x=自动符号化
返回:
Legendre 多项式计算结果 (数值、矩阵或符号表达式)，或错误信息
示例:
>>> legendre_polynomial("(0, 0.5)")
1.00000000000000
>>> legendre_polynomial("([[1,2], [3,4]], [[0.1,0.2], [0.3,0.4]])")
Matrix([
[0.100000000000000, 0.200000000000000],
[ -0.365000000000000, -1.12000000000000]])
"""
try:
expr = sp.sympify(input_str)
error_msg = None
result = None
def legendre_p_sym(n, x):
"""核心计算函数，包含参数验证"""
# 数值型n的验证
if n.is_number:
# 检查是否为整数
if not n.is_integer:
raise ValueError("阶数n必须为整数")
# 转换为Python整数
n_int = int(n)
# 检查非负性
if n_int < 0:
raise ValueError("阶数n必须为非负整数")
# 计算Legendre多项式
return sp.legendre(n, x)
def legendre_p_sic(n, x):
"""
对标 MATLAB 的 legendreP 函数，计算Legendre多项式值（仅标量数值参数）
参数:
n (int): 多项式阶数（非负整数）
x (float): 自变量值
返回:
float: Legendre多项式在x处的值
异常:
ValueError: 如果n不是整数或为负数
"""
# 验证n是否为非负整数
if not isinstance(n, (int, np.integer)):
raise ValueError("阶数n必须是整数")
if n < 0:
raise ValueError("阶数n必须为非负整数")
# 计算Legendre多项式值
return eval_legendre(n, x)
# 处理元组输入 (n, x)
if isinstance(expr, tuple) and len(expr) == 2:
if all(e.is_number for e in expr):
n = int(expr[0])
x = float(expr[1])
result = legendre_p_sic(n, x)
elif any(e.free_symbols for e in expr):
result = legendre_p_sym(*expr)
else:
error = True
else:
# 如果输入是纯数字，视为n=输入值，x=符号x
result = legendre_p_sym(expr, sp.symbols('x'))
return result
except Exception as e:
return f"错误：{str(e)}"
# 测试用例
if __name__ == "__main__":
# 测试1: 标量计算
print("测试1:", legendre_polynomial("(0, 0.5)"))
# 1.0
print("测试2:", legendre_polynomial("(2, 0.5)"))
# -0.125
print("测试4:", legendre_polynomial("(2, x)"))
# 3*x**2/2 - 1/2
print("测试5:", legendre_polynomial("3"))
# 5*x**3/2 - 3*x/2
print("测试6:", legendre_polynomial("(2.5, 0.1)"))
# -0.485
第二类勒让德多项式
P = legendre(n,X) 为 X 中的每个元素计算阶数为n,级数为m = 0, 1, ..., n 时的第二类勒让德多项式.
n — 勒让德函数的阶,正整数
X — 输入值,标量,向量,矩阵
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import numpy as np
from scipy.special import lqmn
import sympy as sp
def legendre_polynomial_second_kind(input_str):
"""
对标 Wolfram 的 LegendreQ[n, 0, x]，计算第二类 Legendre 多项式（连带次数 m=0）
参数:
input_str: 输入字符串，解析为 (n, x) 的元组，支持标量或矩阵输入
返回:
SymPy 表达式/矩阵 或错误信息字符串
注意:
- 仅支持整数阶 n 和标量 x
- 当 n 为非整数时，符号计算可能不准确
- 矩阵输入需确保形状一致
示例:
>>> legendre_polynomial_second_kind("(2, 0.5)")
0.549306144334055
>>> legendre_polynomial_second_kind("(n, x)")
(log((x + 1)/(1 - x))*LegendreP(n, x)/2 - Sum(LegendreP(k, x)/(n - k), (k, 0, n - 1))/2)
"""
try:
expr = sp.sympify(input_str)
error = False
result = None
def legendre_q_scalar(n, x):
"""
计算第二类 Legendre 函数 Q_n(x)（m=0 的情况） - 标量输入版本
参数:
n: 阶数（非负整数）
x: 自变量（实数或复数）
返回:
Q_n(x) 的值
"""
# 确保 n 是整数
if not isinstance(n, (int, np.integer, sp.Integer)):
raise TypeError("阶数 n 必须是整数")
if n < 0:
raise ValueError("阶数 n 必须为非负整数")
# 计算 Q_n(x)
q, _ = lqmn(0, int(n), complex(x))
return q[0, -1]
# 输入必须为 (n, x) 的元组
if isinstance(expr, tuple) and len(expr) == 2:
if all(e.is_number for e in expr):
result = legendre_q_scalar(*expr)
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__":
# 1. 基本用法
print("Q0(0.5) =", legendre_polynomial_second_kind("0, 0.5"))
# 0.5493061443340549
print("Q1(1.5) =", legendre_polynomial_second_kind("1, 1.5"))
# 0.20707843432557524
print("Q2(2.5) =", legendre_polynomial_second_kind("2, 2.5"))
# 0.009884255468216039
# 2. 复数输入
print("\n复数输入:")
x_complex = 0.5 + 0.5j
print(f"Q2({x_complex}) =", legendre_polynomial_second_kind(f"2, {x_complex}"))
# (-1.3663605082270465-0.7250175708671287j)
符号函数极限
limit(f,var,a)在var接近a时返回符号表达式f的双向极限.
limit(f,a)使用symvar找到的默认变量.
limit(f)返回的极限为0.
limit(f,var,a,left)在var接近a时返回f的左侧极限.
limit(f,var,a,right)在var接近a时返回f的右侧极限.
f —— 输入,符号表达式,符号函数,符号向量,符号矩阵
var — 自变量,符号变量
a —— 极限点, 数字
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
def limit_equation(input_str):
"""
对标 MATLAB 的 limit 函数实现，支持多元极限计算
功能特性:
1. 支持标量/矩阵输入
2. 支持左右极限计算
3. 自动符号变量检测
4. 数值与符号混合计算
参数格式:
"表达式, 变量->趋近点, 方向" 或元组形式 (表达式, 变量, 趋近点, 方向)
返回:
计算结果（标量/矩阵）或错误信息字符串
示例:
>>> limit_equation("(sin(x)/x, x, 0)")
1
>>> limit_equation("([[x,y], [1/x,sin(y)/y]], y, 0)")
Matrix([
[x, 0],
[1/x, 1]])
>>> limit_equation("(1/x, x, 0, 'right')")
∞
"""
try:
# 参数解析与标准化
def parse_parameters(expr):
"""将输入统一转换为四元组 (f, var, a, dir)"""
# 默认参数设置
default_var = None
default_a = 0
default_dir = '+-'
if isinstance(expr, tuple):
params = list(expr)
# 参数数量校验
if len(params) < 2 or len(params) > 4:
raise ValueError("参数数量错误，需要2-4个参数")
# 参数类型推断
f = params[0]
var = params[1] if len(params) >= 2 else default_var
a = params[2] if len(params) >= 3 else default_a
direction = params[3] if len(params) == 4 else default_dir
return f, var, a, direction
else:
# 处理非元组输入
return expr, default_var, default_a, default_dir
# 符号化输入并解析参数
expr = sp.sympify(input_str, evaluate=False)
f_expr, var_expr, a_expr, dir_expr = parse_parameters(expr)
# 主计算逻辑
def compute_limit(f, var, a, direction):
"""核心极限计算函数"""
# 自动检测变量
if var is None:
free_symbols = f.free_symbols
if len(free_symbols) != 1:
raise ValueError("自动变量检测失败：表达式包含多个自由符号")
var = next(iter(free_symbols))
# 方向参数标准化
dir_map = {'left': '-', 'right': '+', None: None}
direction = dir_map.get(str(direction).lower(), direction)
# 执行极限计算
try:
return sp.limit(f, var, a, dir=direction)
except (NotImplementedError, ValueError) as e:
return f"计算错误: {str(e)}"
# 分支处理逻辑
result = None
# 情况2：符号表达式输入
if isinstance(f_expr, sp.Expr):
result = compute_limit(f_expr, var_expr, a_expr, dir_expr)
else:
raise TypeError("不支持的输入类型")
return result.evalf() if isinstance(result, sp.Expr) else result
except Exception as e:
return f"错误: {str(e)}"
# ----------------------
# 示例测试代码
# ----------------------
if __name__ == "__main__":
# 基础标量计算
print(limit_equation("(sin(x)/x, x, 0)"))
# 1.00000000000000
print(limit_equation("(exp(1/x), x, 0, 'right')"))
# oo
# 自动变量检测
print(limit_equation("(sin(z)/z, z, 0)"))
# 1.00000000000000
print(limit_equation("(sin(x)/x)"))
# 1.00000000000000
线性方程组求解
X = linsolve(A,B) 使用以下方法之一求解线性方程组 AX = B：
当A是方阵时,linsolve使用LU分解和部分主元消元法.
对于所有其他情况,linsolve使用QR分解和列主元消元法.
如果A为病态(对于方阵)或秩亏(对于矩形矩阵),则linsolve发出警告.
A - 系数矩阵, 符号矩阵
B - 输入数组, 向量,矩阵.
X - 输出,向量,矩阵.
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
from sympy import Matrix, linsolve, linear_eq_to_matrix, Eq, sympify
def linear_equations_solve(input_str):
"""
改进后的线性方程组求解函数，支持符号输入及方程表达式直接输入
"""
try:
# 符号化输入并标准化处理
expr = sympify(input_str)
def parse_input(expr):
"""输入解析标准化为 (A, b) 形式"""
# 增广矩阵处理
M = sp.Matrix(expr) if isinstance(expr, list) else None
if M is not None:
if M.cols < 2:
raise ValueError("增广矩阵至少需要2列")
return M[:, :-1], M[:, -1]
# 元组输入处理
if isinstance(expr, tuple):
if len(expr) != 2:
raise ValueError("输入格式应为 (方程列表, 变量列表) 或 (系数矩阵, 常数项)")
equations_part, vars_part = expr
# 先判断是否为 (方程表达式, 变量列表) 形式
if all(isinstance(v, sp.Symbol) for v in vars_part):
# 检查 equations_part 是否真的是方程表达式列表
if all(isinstance(eq, (sp.Expr, sp.Eq)) for eq in equations_part):
# 将表达式列表转换为等式列表（假设表达式右边为0）
eq_list = [Eq(eq, 0) if not isinstance(eq, sp.Eq) else eq for eq in equations_part]
A, b = linear_eq_to_matrix(eq_list, vars_part)
return A, b
# 否则按 (系数矩阵, 常数项) 处理
A = Matrix(equations_part) if isinstance(equations_part, list) else equations_part
b = Matrix(vars_part) if isinstance(vars_part, list) else vars_part
if not isinstance(A, Matrix) or not isinstance(b, Matrix):
raise TypeError("系数矩阵和常数项需要为矩阵或可转换形式")
return A, b
raise TypeError("不支持的输入格式")
A, b = parse_input(expr)
# 维度校验
if A.rows != b.rows:
raise ValueError(f"维度不匹配: A({A.shape}) vs b({b.shape})")
# 符号解计算
return linsolve((A, b))
except Exception as e:
return f"求解错误: {str(e)}"
# ----------------------
# 示例测试代码
# ----------------------
if __name__ == "__main__":
x, y, z = sp.symbols('x y z')
# 正确输入测试（方程表达式列表 + 变量列表）
test_input = (
[3 * x + 2 * y - z - 1,
2 * x - 2 * y + 4 * z + 2,
2 * x - y + 2 * z],
[x, y, z]
)
print(linear_equations_solve(str(test_input)))
# {(1, -2, -2)}
# 数值解示例（增广矩阵）
print(linear_equations_solve("[[3, 2, -1, 1], [2, -2, 4, -2], [2, -1, 2, 0]]"))
# {(1, -2, -2)}
# 符号解示例（系数矩阵 + 常数项）
print(linear_equations_solve("([[1, 1], [1, -1]], [5, 1])"))
# {(3, 2)}