直方图
直方图是一种条形图, 它将数据分组为bin. 创建Histogram对象后, 可以通过更改直方图的属性值修改它的各个方面. 这对快速修改bin属性或更改显示特别有用
HistogramPlot(X) 基于X创建直方图. histogram函数使用自动分bin算法, 然后返回均匀宽度的bin, 这些bin可涵盖 X 中的元素范围并显示分布的基本形状. histogram将bin显示为矩形条, 这样每个矩形的高度就表示bin中的元素数量.
HistogramPlot(X,nbins)指定bin的数量.
HistogramPlot(X,edges) 将X划分为在向量中指定bin边界的bin.
X — 要分布到各 bin 的数据, 向量, 矩阵
nbins — bin 数量, 正整数
edges — bin 边界, 向量
电商用户消费金额分析: 分析双11期间用户的单笔订单金额分布
HistogramPlot([89,120,150,199,210,299,320,399,450,499,520,599,620,799,850,999,1200,1500],[0,200,400,600,800,1000,2000])
工厂零件尺寸质检: 检测流水线生产的螺栓直径（标准值10.0±0.2mm）
HistogramPlot([9.7,9.8,9.85,9.9,9.95,10.0,10.0,10.05,10.1,10.1,10.15,10.2,10.2,10.25,10.3,10.4],8)
APP用户活跃时长分析: 统计每日用户使用时长（分钟）
HistogramPlot([2,5,8,10,12,15,15,18,20,25,30,35,40,45,50,60,75,90,120],[0,1,5,15,30,60,180])
医院患者年龄分布: 某科室疾病患者的年龄分布
HistogramPlot([32,35,38,40,42,45,48,50,52,55,58,60,62,65,68,70,72,75,80,85],[30,40,50,60,70,90])
网络请求响应时间监控: API接口的响应时间（毫秒）
HistogramPlot([12,15,18,20,22,25,28,30,35,40,45,50,60,75,100,150,200,500],[10,20,50,100,200,1000])
二元直方图
二元直方图是一种数值数据条形图, 它将数据分组到二维bin中. 创建Histogram2Plot对象后, 可以通过更改直方图的属性值修改它的各个方面. 这对快速修改bin属性或更改显示特别有用
histogram2Plot(X,Y) 创建 X 和 Y 的二元直方图. histogram2 函数使用自动分 bin 算法, 然后返回均匀面积的 bin, 这些 bin 可涵盖 X 和 Y 中的元素范围并显示分布的基本形状. histogram2 将 bin 显示为二维矩形条形，这样每个条形的高度就表示 bin 中的元素数量.
histogram2Plot(X,Y,nbins) 指定要在每个维度中使用的 bin 数量.
X,Y — 要分布到各 bin 的数据, 向量, 矩阵
nbins — bin 数量, 正整数
身高体重关系（健康数据分析）:
深色区域显示最常见的身高体重组合（如170cm/65kg），右上角稀疏区可能是异常值
Histogram2Plot([165,170,178,162,185], # 身高(cm)
[55,68,72,60,80], # 体重(kg)
12)
广告点击分析（数字营销）:
观看时长8-15秒且点击率1-2%的区域密度最高，短时长(<5s)点击率波动大
Histogram2Plot([12,8,25,3,17], # 广告观看时长(秒)
[0.2,1.5,0.8,3.2,1.6], # 点击率(%)
10)
气象模式分析（气候科学）:
高温(>30℃)与低降雨(<2mm)强相关，25℃中温区降雨分布最广
Histogram2Plot([28,32,25,30], # 日间温度(℃)
[0,5.2,12.8,3.4], # 降雨量(mm)
15)
股票收益率分析（金融量化）:
高波动率(>0.2)时收益率分布更分散，低波动率时收益率集中在±5%
Histogram2Plot([0.15,0.22,0.08], # 波动率
[-0.03,0.12,0.05], # 日收益率
20)
城市通勤研究（交通规划）:
10km/25min区域密度最高，20km以上出现明显的交通效率下降
Histogram2Plot([8,15,5,20], # 通勤距离(km)
[30,45,20,60], # 通勤时间(分钟)
12)
霍纳法则(秦九韶算法)
把表达式转成嵌套形式，提高计算效率.
horner(p)返回多项式p的霍纳形式,
horner(p，var)使用var中的变量.
p是符号表达式,符号函数,符号表达式数组,符号函数数组.
var是变量,符号变量,符号变量数组.
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
from sympy.matrices import MatrixBase, MutableDenseMatrix
from sympy.polys.polyfuncs import horner
def horner_nested_polynomial(input_str):
"""
将输入的多项式或矩阵中的每个元素转换为霍纳嵌套形式。
参数:
input_str: 字符串，表示SymPy可解析的表达式。可以是多项式、矩阵或元组（矩阵或表达式，变量）。
返回:
SymPy表达式或矩阵，表示霍纳形式的多项式。若输入错误则返回错误信息。
示例:
>>> x, y = sp.symbols('x y')
>>> horner_nested_polynomial("x**3 + 2*x**2 + 3*x +4")
x*(x*(x + 2) + 3) + 4
>>> horner_nested_polynomial("[[x**3, x**2 + 2*x], [x+1, 5]]")
Matrix([
[ x**3, x*(x + 2)],
[ x + 1, 5]])
>>> horner_nested_polynomial("(x**2 + x*y + y**2, y)")
y*(x + y) + x**2
>>> horner_nested_polynomial("([[x**3 + y*x, x + y]], y)")
Matrix([[x*y + x**3, x + y]])
"""
try:
expr = sp.sympify(input_str)
error = False
result = None
def eval_horner(expression, wrt_var=None):
"""内部函数：应用霍纳法则到单个表达式"""
if wrt_var is not None:
poly = sp.poly(expression, wrt_var)
else:
poly = sp.poly(expression)
return horner(poly, wrt=wrt_var)
# 处理元组输入（表达式/矩阵，变量）
if isinstance(expr, tuple) and len(expr) == 2:
if all(e.free_symbols for e in expr):
result = eval_horner(*expr)
else:
error = True
elif expr.free_symbols:
# 处理普通表达式
result = eval_horner(expr)
else:
error = True
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误:{e}"
# 示例测试
if __name__ == "__main__":
print(horner_nested_polynomial("9*x**4+8*x**3+7*x**2+6*x+5"))
# x*(x*(x*(9*x + 8) + 7) + 6) + 5
希尔伯特变换
H = htrans(f) 返回符号函数 f 的希尔伯特变换. 默认情况下, 独立变量为 t, 变换变量为 x.
f — 输入, 符号表达式, 符号函数
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
import scipy.signal as signal
def hilbert_transform_func(input_str):
"""
对标MATLAB的htrans函数，计算输入表达式的数值希尔伯特变换。
参数:
input_str (str): 以't'为变量的数学表达式，例如'sin(t)'、'exp(t)*cos(t)'等。
返回:
tuple: (t_values, H_values) 包含时间序列和对应的希尔伯特变换数值结果。
或 str: 错误信息。
"""
try:
# 步骤1: 将输入字符串转换为SymPy表达式
expr = sp.sympify(input_str)
t = sp.symbols('t')
# 步骤2: 检查表达式是否含有符号't'，若无则报错
if not expr.has(t):
return f"错误: 表达式必须包含变量't'，但输入为'{expr}'"
# 步骤3: 替换所有其他符号为1（例如，处理如'a*sin(t)'中的'a'）
free_symbols = expr.free_symbols - {t}
subs_dict = {symbol: 1 for symbol in free_symbols}
expr_substituted = expr.subs(subs_dict)
# 步骤4: 将SymPy表达式转换为NumPy函数
expr_numpy = sp.lambdify(t, expr_substituted, modules='numpy')
# 步骤5: 生成时间序列（0到2π，1000个点）
t_vals = np.linspace(0, 2 * np.pi, 1000)
# 步骤6: 计算原始信号y(t)
y = expr_numpy(t_vals)
# 步骤7: 使用SciPy计算希尔伯特变换（注意：返回的是解析信号，虚部为Hilbert变换）
analytic_signal = signal.hilbert(y)
H = np.imag(analytic_signal)
return (t_vals, H)
except sp.SympifyError:
return f"错误: 无法解析输入表达式 '{input_str}'"
except Exception as e:
return f"错误: {str(e)}"
# 示例使用
if __name__ == "__main__":
# 示例1: 计算sin(t)的希尔伯特变换（理论值为-cos(t)）
input_expr = "sin(t)"
result = hilbert_transform_func(input_expr)
if isinstance(result, tuple):
import matplotlib.pyplot as plt
t_vals, H = result
plt.figure(figsize=(10, 6))
plt.plot(t_vals, H, '--', label='Computed Hilbert')
plt.xlabel('t')
plt.legend()
plt.title('Hilbert Transform Demo')
plt.show()
else:
print(result)
赫尔维茨黎曼函数
Z=Hurwitz-zeta(s,a)为数字或符号输入s和a计算Hurwitz zeta函数.只有当s不为1且a既不是0也不是负整数时,才定义Hurwitz zeta函数.
Z=hurwitzZeta(n,s,a)返回参照变量s的n阶hurwitz-zeta(s,a)的导数.
s是数字,数组,符号数,符号变量,符号函数,符号表达式,符号数组.
a是数字,数组,符号数,符号变量,符号函数,符号表达式,符号数组.
n是导数的阶数,非负整数.
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
from mpmath import zeta as mp_zeta
def hurwitz_zeta_function(input_expr):
"""
对标MATLAB的hurwitzZeta函数，计算Hurwitz zeta函数或其导数。
Hurwitz zeta函数定义: ζ(s, a) = ∑_{k=0}^∞ 1/(k + a)^s
导数定义: ζ^{(n)}(s, a) = d^n/ds^n ζ(s, a)
参数:
input_expr (str/tuple): 输入表达式，可以是以下形式：
- "(s, a)" 字符串，计算ζ(s, a)
- "(s, a, n)" 字符串，计算n阶导数ζ^{(n)}(s, a)
- 包含s和a的元组或矩阵
n (int, optional): 导数阶数，如果输入元组中已包含则优先使用元组中的n
返回:
SymPy表达式/矩阵或错误信息。
示例:
>>> hurwitz_zeta_function("(2, 0.5)")
-1.46035450880959
>>> hurwitz_zeta_function("(s, a, 1)", s=2, a=0.5)
-2.40411380631918
"""
try:
expr = sp.sympify(input_expr)
error = False
result = None
def hurwitz_zeta_sym(s_val, a_val, n_val=None):
zeta_expr = sp.zeta(s_val, a_val)
if n_val is not None and s_val.free_symbols:
vars = s_val.free_symbols
result = zeta_expr.rewrite(sp.lerchphi).diff(*vars, n_val)
else:
result = zeta_expr.rewrite(sp.lerchphi)
return result
def hurwitz_zeta_math(s_val, a_val, n_val=None):
if n_val:
n = float(n_val)
result = mp_zeta(s_val, a_val, n)
else:
result = mp_zeta(s_val, a_val)
return result
if isinstance(expr, tuple):
if len(expr) == 2:
derivative_order = None
elif len(expr) == 3 and expr[2].is_integer and expr[2] > 0:
derivative_order = expr[2]
else:
error = True
if all(e.is_number for e in expr[:2]):
params = tuple(complex(e) for e in expr[:2])
result = hurwitz_zeta_math(*params, derivative_order)
elif any(e.free_symbols for e in expr[:2]):
result = hurwitz_zeta_sym(*expr)
else:
error = True
return result if not error else f"输入错误: {input_expr}"
except Exception as e:
return f"错误:{e}"
# 示例使用
if __name__ == "__main__":
# 示例1: 标量计算
print("ζ(2, 0.5) =", hurwitz_zeta_function("(2,0.5)"))
# 4.93480220054468
# 示例2: 导数计算
s = sp.Symbol('s')
expr = hurwitz_zeta_function("s, 0.5, 1")
print("ζ'(s, 0.5) =", expr)
# Derivative(lerchphi(1, s, 0.5), s)
超几何函数的累积分布函数
hygecdf（x，M，K，N）使用相应的总体大小M,总体中具有所需特征的项目数量K和提取的样本数量N, 计算x中每个值的超几何cdf. x,M,K和N的向量或矩阵输入必须具有相同的大小. 标量输入被扩展为与其他输入具有相同维数的常数矩阵.
x -- 标量, 符号变量, 向量, 矩阵
M, K, N -- 数值标量, 向量, 矩阵.
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
from sympy.stats import Hypergeometric, cdf
from scipy.stats import hypergeom
def hypergeometric_cumulative_distribution(input_str):
try:
# 将输入的字符串转换为SymPy表达式
expr = sp.sympify(input_str)
# 初始化错误标志为False
error = False
# 初始化结果为None
result = None
# 检查表达式是否为长度为4的元组
if isinstance(expr, tuple) and len(expr) == 4:
if all(e.is_integer for e in expr):
params = tuple(int(e) for e in expr)
"""
计算超几何分布的累积分布函数值
参数:
x_val (int): 累积概率的上限值
m_val (int): 总体大小
k_val (int): 总体中成功的次数
n_val (int): 样本大小
返回:
float: 累积分布函数值，即P(X ≤ x_val)
"""
# 直接调用scipy.stats.hypergeom.cdf函数计算累积分布函数值
result = hypergeom.cdf(*params)
elif any(e.free_symbols for e in expr):
"""
计算超几何分布的累积分布函数值。
参数:
x_val: 随机变量的值
m_val: 总体中的成功元素个数
k_val: 总体的元素个数
n_val: 抽样的元素个数
返回:
超几何分布的累积分布函数值或符号表达式
"""
# 创建一个超几何分布随机变量X
X = Hypergeometric(*expr)
# 返回累积分布函数的符号表达式
result = cdf(X)
else:
error = True
else:
# 如果输入不是长度为4的元组，设置错误标志为True
error = True
# 如果没有错误，返回计算结果；否则返回错误信息
return result if not error else f"输入错误: {input_str}"
except Exception as e:
# 如果在计算过程中出现异常，返回错误信息
return f"错误: {e}"
# 标量输入示例
print(hypergeometric_cumulative_distribution("(2, 50, 10, 5)"))
# 0.9517396968037909
# 符号输入示例
print(hypergeometric_cumulative_distribution("(x, a, b, c)"))
# Lambda(_k, Sum(Piecewise((binomial(b, _ki)*binomial(a - b, -_ki + c)/binomial(a, c), (_ki >= 0) & (_ki <= c)), (0, True)), (_ki, 0, _k)))
超几何函数的逆累积分布函数
Y = hygeinv(P,M,K,N)返回最小的整数X,使得在X处计算的超几何cdf等于或超过P.您可以将P视为在N个图纸中观察到X个有缺陷的项目而不替换K有缺陷的M个项目组的概率.
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
from scipy.stats import hypergeom
# 定义计算单个元素的逆CDF函数
def compute_inv_cdf(p_val, M_val, K_val, n_val):
# 参数验证
if not (0 <= p_val <= 1):
raise ValueError(f"概率p必须在[0,1]范围内，当前为{p_val}")
# 转换为整数并验证
try:
M_int = int(M_val)
K_int = int(K_val)
n_int = int(n_val)
if M_int != M_val or K_int != K_val or n_int != n_val:
raise ValueError("参数M, K, n必须为整数")
except (TypeError, ValueError):
raise ValueError("参数M, K, n必须为整数")
if M_int <= 0 or K_int < 0 or n_int < 0:
raise ValueError("参数必须满足 M>0, K≥0, n≥0")
if K_int > M_int or n_int > M_int:
raise ValueError("K和n不能超过M")
# 处理边界情况
if p_val <= 0:
return 0
if p_val >= 1:
return min(K_int, n_int)
# 创建分布对象并查找分位数
hg = hypergeom(M_int, K_int, n_int)
max_k = min(K_int, n_int)
for k in range(0, max_k + 1):
if hg.cdf(k) >= p_val - 1e-10: # 浮点容差
return k
return max_k # 理论上不会执行到此
def hypergeometric_inverse_cumulative_distribution(input_str):
"""
计算超几何分布的逆累积分布函数（分位数值），对标Matlab的hygeinv函数。
参数:
input_str: 输入字符串，格式为四元组 (p, M, K, n)，各参数可为矩阵或标量。
返回:
数值、SymPy矩阵或错误信息字符串。
示例:
>>> hypergeometric_inverse_cumulative_distribution("(0.5, 10, 5, 3)")
1
>>> hypergeometric_inverse_cumulative_distribution("([[0.1, 0.5], [0.9, 1.0]], 10, 5, 3)")
Matrix([[1, 1], [2, 3]])
"""
try:
expr = sp.sympify(input_str)
error = False
result = None
if isinstance(expr, tuple) and len(expr) == 4:
if all(e.is_number for e in expr):
p, M, K, n = expr # 参数顺序: p, M总体大小, K成功数, n抽样数
# 标量计算
try:
p_val = float(p)
M_val = int(M)
K_val = int(K)
n_val = int(n)
result = compute_inv_cdf(p_val, M_val, K_val, n_val)
except Exception as e:
error = True
result = f"参数错误: {str(e)}"
else:
error = True
else:
error = True
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {str(e)}"
# 标量计算示例
print(hypergeometric_inverse_cumulative_distribution("0.99,1000,10,50"))
# 3
print(hypergeometric_inverse_cumulative_distribution("0.5,1000,10,50"))
# 0
超几何函数的概率密度函数
Y = hygepdf（X，M，K，N）使用相应的总体大小M, 总体中具有所需特征的项目数量K和提取的样本数量N计算X中每个值的超几何pdf. X,M,K和N可以是向量,矩阵,它们都具有相同的大小.标量输入被扩展为与其他输入具有相同维度的常数数组.
M,K和N中的参数必须都是正整数,N≤M. X中的值必须小于或等于所有参数值.
X -- 标量, 符号变量, 向量, 矩阵
M, K, N -- 数值标量, 向量, 矩阵.
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
from sympy.stats import Hypergeometric, density
from scipy.stats import hypergeom
def hypergeometric_probability_density(input_str):
"""
计算超几何分布概率密度函数，对标Matlab的hygepdf函数。
参数:
input_str: 输入字符串，格式为四元组 (x, M, K, n)，各参数可为矩阵或标量。
参数说明:
- x: 成功次数
- M: 总体大小
- K: 总体中成功数量
- n: 抽样数量
返回:
数值、SymPy矩阵或错误信息字符串。
示例:
>>> hypergeometric_probability_density("(2, 100, 20, 5)")
0.2022
>>> hypergeometric_probability_density("([0,1,2], 10, 5, 3)")
Matrix([[0.0833, 0.4167, 0.4167]])
"""
try:
expr = sp.sympify(input_str)
error = False
result = None
def eval_hypergeometric_pdf(x_val, M_val, K_val, n_val):
"""计算单个元素的概率密度"""
# 参数验证
# 符号计算直接返回表达式
X = Hypergeometric('X', M_val, K_val, n_val)
return density(X)(x_val)
if isinstance(expr, tuple) and len(expr) == 4:
if all(e.is_integer for e in expr):
params = tuple(int(e) for e in expr)
"""
计算超几何分布的概率质量函数（PMF），对标Matlab的hygepdf函数
参数:
x_val (int): 成功次数
M_val (int): 总体大小
K_val (int): 总体中成功的元素个数
n_val (int): 抽取的样本大小
返回:
float: 超几何分布在x_val处的概率密度值
"""
# 直接调用scipy.stats.hypergeom.pmf计算概率密度
result = hypergeom.pmf(*params)
elif any(e.free_symbols for e in expr):
"""计算单个元素的概率密度"""
# 参数验证
X = Hypergeometric('X', *expr[1:])
result = density(X)(expr[0])
else:
error = True
return result if not error else f"输入错误:{input_str}"
except Exception as e:
return f"系统错误: {str(e)}"
# 测试示例
if __name__ == "__main__":
# 标量测试
print(hypergeometric_probability_density("(2, 100, 20, 5)"))
# 输出: 0.20734379349990548
# 符号计算测试
print(hypergeometric_probability_density("(k, 10, 5, 3)"))
# 输出: binomial(5, k)*binomial(5, 3 - k)/120
超几何函数的随机数
R = hygernd(M,K,N)从具有相应总体大小的超几何分布中生成随机数,M,总体中具有所需特征的项目数量K, 以及提取的样本数量N. M,K和N可以是向量,矩阵,它们都具有相同的大小, 这也是R的大小.
M,K或N的标量输入被扩展为与其他输入具有相同维度的常数数组.
R=hyernd(M,K,N,M,N)生成一个M-by-N阵列. M,K,N参数可以是标量或与R大小相同的数组.
M, K, N -- 数值标量, 向量, 矩阵.
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
from scipy.stats import hypergeom
import numpy as np
def hypergeometric_random_number(input_str):
"""
生成超几何分布随机数，对标Matlab的hygernd函数。
参数格式:
(M, K, N) -> 单个随机数
(M, K, N, size) -> 指定形状的数组
(M_mat, K_mat, N_mat) -> 矩阵参数，逐元素生成随机数
参数说明:
M: 总体大小（必须为正整数）
K: 成功项数量（0 ≤ K ≤ M）
N: 抽样数量（0 ≤ N ≤ M）
size: 输出形状（整数或元组）
返回:
随机数、SymPy矩阵、numpy数组或错误信息
示例:
>>> hypergeometric_random_number("(100, 20, 5)")
3
>>> hypergeometric_random_number("(100, 20, 5, 3)")
Matrix([[2, 4, 3]])
>>> hypergeometric_random_number("([[90,100],[110,120]], 20, 5)")
Matrix([[2, 3], [1, 4]])
"""
try:
expr = sp.sympify(input_str)
error = False
result = None
def generate_rvs(M_val, K_val, N_val, size=None):
"""核心生成函数"""
# 参数验证
M = int(M_val)
K = int(K_val)
N = int(N_val)
if M <= 0 or K < 0 or N < 0:
raise ValueError("参数必须满足 M>0, K≥0, N≥0")
if K > M or N > M:
raise ValueError("K和N不能超过M")
# 生成随机数
if size:
arr = hypergeom.rvs(M, K, N, size=size)
return sp.Matrix(arr) if isinstance(arr, np.ndarray) else arr
else:
return hypergeom.rvs(M, K, N)
# 解析输入参数
if isinstance(expr, tuple):
# 处理标量参数+size参数 ------------------------------------------------
if len(expr) == 3: # 单个随机数
return generate_rvs(*expr)
elif len(expr) >= 4: # 带size参数
M, K, N = expr[:3]
size = tuple(int(x) for x in expr[3:]) if len(expr) > 4 else int(expr[3])
return generate_rvs(M, K, N, size=size)
raise ValueError("输入格式错误，应为 (M,K,N) 或 (M,K,N,size)")
except Exception as e:
return f"错误: {str(e)}"
# 测试示例
if __name__ == "__main__":
# 标量测试
print(hypergeometric_random_number("(100, 20, 5)"))
# 0
# 一维数组测试
print(hypergeometric_random_number("(100, 20, 5, 3)"))
# Matrix([[2],
# [1],
# [0]])
超几何函数的均值和方差
[MN，V] = hygestat（M, K, N）返回具有相应总体大小的超几何分布的均值和方差, M, 总体中具有所需特征的项目数量K, 以及提取的样本数量N. M,K和N的向量或矩阵输入必须具有相同的大小,这也是MN和V的大小.
M,K或N的标量输入被扩展为与其他输入具有相同维度的常数矩阵.
具有参数M,K和N的超几何分布的平均值为NK/M,方差为NK(M-K)(M-N)/[M^2(M-1)].
M, K, N -- 数值标量, 向量, 矩阵.
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
from scipy.stats import hypergeom
def hypergeometric_mean_variance(input_str):
"""
计算超几何分布的均值与方差，对标Matlab的hygestat函数。
参数格式:
(M, K, N) -> 返回标量均值与方差
(M_mat, K_mat, N_mat) -> 返回同形状的均值矩阵和方差矩阵
参数说明:
M: 总体大小（必须为正整数）
K: 成功项数量（0 ≤ K ≤ M）
N: 抽样数量（0 ≤ N ≤ M）
返回:
(均值, 方差) 元组，或错误信息字符串
示例:
>>> hypergeometric_mean_variance("(100, 20, 5)")
(4.0, 1.2626262626262625)
>>> hypergeometric_mean_variance("([100, 150], [20, 30], [5, 10])")
(Matrix([[4.0, 6.0]]), Matrix([[1.2626, 2.2222]]))
>>> hypergeometric_mean_variance("(50, 60, 30)")
'错误：K必须在0到M之间'
"""
try:
expr = sp.sympify(input_str)
mean_matrix, var_matrix = None, None
error = False
def compute_stats(M_val, K_val, N_val):
"""核心计算函数"""
# 参数验证
try:
M = int(M_val)
K = int(K_val)
N = int(N_val)
except (TypeError, ValueError):
raise ValueError("参数M、K、N必须为整数")
if M <= 0:
raise ValueError("M必须为正整数")
if not (0 <= K <= M):
raise ValueError("K必须在0到M之间")
if not (0 <= N <= M):
raise ValueError("N必须在0到M之间")
# 计算统计量
dist = hypergeom(M, K, N)
return dist.mean(), dist.var()
# 解析输入参数 -----------------------------------------------------------
if isinstance(expr, tuple) and len(expr) == 3:
M, K, N = expr # 参数顺序对应Matlab的hygestat(M, K, N)
# 标量计算模式
try:
mean, var = compute_stats(M, K, N)
return (mean, var)
except Exception as e:
return f"错误：{str(e)}"
else:
return "输入格式错误：应为三元素元组 (M, K, N)"
except Exception as e:
return f"系统错误：{str(e)}"
# 测试示例
if __name__ == "__main__":
# 标量测试
print(hypergeometric_mean_variance("(100, 20, 5)"))
# (1.0, 0.7676767676767676)
广义超几何函数
hypergeom(a,b,z) 根据输入是浮点还是符号，超几何返回浮点或符号结果。
计算这些数字的超几何函数。因为这些数字是浮点数，所以hypergeom返回浮点结果。
a —— 超几何函数的上参数,数字,向量,符号数字,符号变量,符号表达式,符号函数,符号向量
b —— 超几何函数的下参数,数字,向量,符号数字,符号变量,符号表达式,符号函数,符号向量
z —— 标量,数值,符号变量
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
def hypergeometric_function_construct(input_str):
"""
构造并简化广义超几何函数，对标MATLAB的hypergeom函数。
参数:
input_str (str): 输入字符串，格式应为'([a1, a2, ...], [b1, b2, ...], z)'，其中：
- a1, a2, ... 是上参数列表
- b1, b2, ... 是下参数列表
- z 是变量或数值
返回:
Sympy表达式: 简化后的超几何函数表达式，或错误信息。
"""
try:
# 将输入字符串解析为Sympy表达式
expr = sp.sympify(input_str)
error = False
result = None
# 检查输入是否为三元组（上参数，下参数，z）
if isinstance(expr, tuple) and len(expr) == 3:
# 处理上参数列表
a = tuple(expr[0]) if isinstance(expr[0], list) else (expr[0],)
# 处理下参数列表
b = tuple(expr[1]) if isinstance(expr[1], list) else (expr[1],)
z = expr[2]
# 构造超几何函数
hyper_func = sp.hyper(a, b, z)
# 尝试展开为更简单的表达式
result = sp.hyperexpand(hyper_func)
else:
error = True
return result if not error else f"输入格式错误: {input_str}"
except Exception as e:
return f"错误: {e}"
# 示例代码
if __name__ == "__main__":
# 示例1：符号参数，返回未简化形式
input1 = '(a,[],x)'
result1 = hypergeometric_function_construct(input1)
print(f"示例1结果: {result1}")
# (1 - x)**(-a)
# 示例2：可简化的超几何函数
input2 = '([1, 1], [2], -x)'
result2 = hypergeometric_function_construct(input2)
print(f"示例2结果: {result2}")
# log(x + 1)/x
# 示例3：数值参数，返回符号表达式（如需要数值结果可调用.evalf()）
input3 = '([1, 1], [2], -1)'
result3 = hypergeometric_function_construct(input3)
print(f"示例3符号结果: {result3}")
# log(2)
print(f"示例3数值结果: {result3.evalf()}")
# 0.693147180559945
平方和的平方根(斜边)
C = hypot(A,B)返回以下方程的计算结果(计算是为了避免下溢或上溢)： C = sqrt(abs(A)^2 + abs(B)^2)
A,B — 输入数组,标量,向量,矩阵
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def hypotenuse_calculate(input_str):
"""
对标MATLAB hypot函数计算直角三角形的斜边
参数:
input_str (str): SymPy可解析的字符串，格式为：
(n, x) 其中n和x可以是标量或矩阵
返回:
Matrix/float: 计算结果矩阵或标量
"""
try:
expr = sp.sympify(input_str)
error = False
# 检查输入是否为二元组
if not isinstance(expr, tuple) or len(expr) != 2:
return f"输入错误: 需要两个参数 {input_str}"
# 参数解析
a, b = expr[0], expr[1]
# 转换为numpy数组（支持标量和矩阵）
def to_ndarray(val):
if isinstance(val, list):
return np.array(val, dtype=float)
elif isinstance(val, sp.Number):
return float(val)
else:
return None
np_a = to_ndarray(a)
np_b = to_ndarray(b)
if np_a is None or np_b is None:
return f"参数类型错误: 需要数值或矩阵 {input_str}"
# 计算斜边（自动处理广播）
result = np.hypot(np_a, np_b)
# 转换回SymPy格式
if isinstance(result, np.ndarray):
return sp.Matrix(result.tolist())
else:
return float(result)
except Exception as e:
return f"错误: {str(e)}"
# 案例1：标量计算
print(hypotenuse_calculate("(3, 4)"))
# → 5.0
# 案例2：矩阵与标量
print(hypotenuse_calculate("([3,4], 4)"))
# Matrix([[5.00000000000000],
# [5.65685424949238]])
# 案例3：矩阵广播
print(hypotenuse_calculate("([[1,2],[3,4]], [5,6])"))
# Matrix([[5.09901951359278, 6.32455532033676],
# [5.83095189484530, 7.21110255092798]])