正则化不完全gamma函数
Y = gammainc(X,A) 返回在 X 和 A 的元素处计算的正则化下不完全 gamma 函数。X 和 A 必须都为实数，A 必须为非负值.
Y = gammainc(X,A,type) 返回正则化下/上不完全 gamma 函数。type 的选项是 'lower'（默认值）和 'upper'.
X是标量,向量,矩阵
A是标量,向量,矩阵. A的元素必须为非负实数.X和A必须大小相同,或者其中之一必须为标量.
type是正则化不完全gamma函数的类型,upper或lower(默认)
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import scipy.special as sc
def gamma_incomplete_function(input_str):
"""
对标 MATLAB 的 gammainc 函数，计算正则化的下/上不完全伽马函数。
参数:
input_str: 输入的数学表达式字符串，格式为元组 (x, a, 'type')，其中 type 可选 'lower' 或 'upper'。
返回:
计算结果或错误信息字符串。
示例:
>>> gamma_incomplete_function("(2, 5, lower)")
0.052653017343711
>>> gamma_incomplete_function("(Matrix([[1,2]]), Matrix([[3,4]]), upper)")
Matrix([[0.849145, 0.238536]])
>>> gamma_incomplete_function("(x, a, lower)")
lowergamma(a, x)/gamma(a)
"""
try:
expr = sp.sympify(input_str, evaluate=False)
error = False
result = None
if isinstance(expr, tuple):
# 解析参数
if len(expr) == 3:
x, a, gammainc_type = expr
gammainc_type = str(gammainc_type)
elif len(expr) == 2:
x, a = expr
gammainc_type = 'lower'
else:
error = True
return f"输入错误: 参数数量错误，期望2或3个参数，实际{len(expr)}个"
# 检查类型参数有效性
if gammainc_type not in ['lower', 'upper']:
error = True
return f"输入错误: 类型参数必须为 'lower' 或 'upper'，实际为 {gammainc_type}"
if gammainc_type == "lower":
if any(e.free_symbols for e in [x, a]):
result = sp.lowergamma(a, x) / sp.gamma(a)
elif all(e.is_number for e in [x, a]):
result = sc.gammainc(float(a), float(x))
else:
if any(e.free_symbols for e in [x, a]):
result = sp.uppergamma(a, x) / sp.gamma(a)
elif all(e.is_number for e in [x, a]):
result = sc.gammaincc(float(a), float(x))
return result
else:
return f"输入错误: 输入必须是元组"
except Exception as e:
return f"错误: {e}"
# 示例测试
if __name__ == "__main__":
# 标量测试
print(gamma_incomplete_function("2, 5, lower"))
# 0.052653017343711125
print(gamma_incomplete_function("(5, 2, upper)"))
# 0.04042768199451279
# 符号测试
print(gamma_incomplete_function("(x, a, lower)"))
# lowergamma(a, x)/gamma(a)
正则化不完全gamma函数的逆函数
X = gammaincinv(Y,A)返回在Y和A元素处计算的正则化下不完全gamma函数的逆函数,满足Y = gammainc(X,A). Y和A都必须为实数. Y的元素必须在闭区间[0,1]内,A必须为非负值.
X = gammaincinv(Y,A,type) 返回正则化下或上不完全gamma函数的逆函数.type的选项是'lower'（默认值）和'upper'.
Y是标量,向量,矩阵
A是标量,向量,矩阵. A的元素必须为非负实数.Y和A必须大小相同,或者其中之一必须为标量.
type是逆不完全gamma函数的类型,upper或lower(默认)
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import scipy.special as sc
def gamma_incomplete_inverse_function(input_str):
"""
计算逆不完全伽马函数，类似MATLAB的gammaincinv函数。
参数:
input_str: 输入的字符串表达式，格式为元组(y, a, 'lower'/'upper')或(y, a)。
返回:
标量数值、SymPy矩阵或错误信息字符串。
示例:
>>> gamma_incomplete_inverse_function("(0.5, 1)")
0.6931471806
>>> gamma_incomplete_inverse_function("([[0.5], [0.6]], [[1], [2]])")
Matrix([[1.386294361], [1.42711696]])
"""
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(float(e.evalf()) for e in expr)
result = sc.gammaincinv(*params[::-1])
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(gamma_incomplete_inverse_function("0.5, 0.6"))
# 0.31570201701610756
Y = gammaln(A)返回gamma函数的对数gammaln(A)=log(gamma(A)).
A 必须是非负数和实数. gammaln命令可避免直接使用log(gamma(A))计算时可能会出现的下溢和上溢.
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
from scipy.special import gammaln
def gamma_logarithm(input_str):
"""
计算gamma函数的自然对数，对标MATLAB的gammaln函数。
参数:
input_str (str): 输入的数学表达式字符串，支持标量、矩阵或符号表达式。
对于数值输入，必须为非负实数；符号表达式需为合法SymPy表达式。
返回:
SymPy表达式/float/np.ndarray/str:
- 符号输入返回SymPy的loggamma表达式
- 标量数值输入返回float结果
- 矩阵输入返回NumPy数组
- 错误时返回字符串描述
示例:
>>> gamma_logarithm("5") # 标量数值输入
3.1780538303479458
>>> gamma_logarithm("z") # 符号输入
loggamma(z)
>>> gamma_logarithm("[[1, 2], [3, 4]]") # 矩阵输入
array([[0. , 0.69314718],
[1.79175947, 3.17805383]])
>>> gamma_logarithm("-1") # 错误输入
'错误：输入必须为非负实数。'
"""
try:
expr = sp.sympify(input_str)
error = False
result = None
if expr.free_symbols:
result = sp.loggamma(expr)
elif expr.is_number:
# 数值型输入验证
z = float(expr)
# 使用SciPy计算数值结果
result = gammaln(z)
else:
error = True
return result if not error else f"输入错误: {input_str}"
except (sp.SympifyError, TypeError) as e:
return f"语法错误：无法解析输入 '{input_str}' -> {e}"
except ValueError as e:
return f"计算错误：{e}"
except Exception as e:
return f"未知错误：{type(e).__name__} - {str(e)}"
# 符号表达式
print(gamma_logarithm("x+y"))
# loggamma(x + y)
# 标量计算测试
print(gamma_logarithm("6"))
# 4.787491742782046
伽玛概率密度函数
p＝gampdf（x，a）返回具有a中的形状参数的标准gamma分布的概率密度函数（pdf），在x中的值处进行评估。.
y=gampdf（x，a，b）返回具有形状参数a和比例参数b的伽马分布的pdf,在x中的值处进行评估.
x是评估pdf的值,非负标量,非负标量数组
a是形状参数,正标量值,正标量值数组
b是比例参数,默认值是1,正标量值,正标量的数组.
如果输入参数x,a和b中的一个或多个是数组,则数组大小必须相同.在这种情况下,gampdf将每个标量输入扩展为与数组输入大小相同的常量数组.p中的每个元素都是由a和b中的对应元素指定的分布的cdf值, 在x中的相应元素处进行评估.
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
from sympy.stats import Geometric, density, cdf, Gamma, E, variance
from scipy.stats import gamma as scipy_gamma
def gamma_pdf(input_str):
"""
计算伽马分布概率密度函数 (对标MATLAB gampdf)
参数:
x: 输入值/矩阵
k: 形状参数/矩阵
theta: 尺度参数/矩阵 (默认1)
返回:
SymPy矩阵/数值/错误信息
示例:
>>> gamma_pdf(2, 1) # 标量计算
0.1353352832366127
>>> gamma_pdf([[1,2],[3,4]], 2, 1) # 矩阵输入
Matrix([
[0.367879441171442, 0.270670566473225],
[0.149361205103592, 0.073262555554937]])
"""
try:
expr = sp.sympify(input_str)
error = False
result = None
if isinstance(expr, tuple) and len(expr) <= 3:
if len(expr) == 2:
theta = 1
if all(e.is_number for e in expr):
params = tuple(float(e.evalf()) for e in expr)
result = scipy_gamma.pdf(*params, theta)
elif any(e.free_symbols for e in expr):
G = Gamma("gamma", expr[1], theta)
result = density(G)(expr[0])
elif len(expr) == 3:
if all(e.is_number for e in expr):
result = scipy_gamma.pdf(*expr)
elif any(e.free_symbols for e in expr):
G = Gamma("gamma", expr[1], expr[2])
result = density(G)(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(gamma_pdf("2, 1"))
# 0.36787944117144233
# 符号变量测试
print(gamma_pdf("x, 1"))
# exp(-x)
高斯窗
w = gausswin(L,std,sym=1) 返回一个长度为L个点的修正的高斯窗 默认sym=1
当sym=1, 生成一个对称窗口，用于滤波器设计.
当sym=0, 生成一个周期性窗口，用于光谱分析.
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import scipy.signal as signal
def gausswin_window(input_str):
"""
对标MATLAB的gausswin函数，生成高斯窗口。
参数：
input_str (str): 输入的参数字符串，格式应为 "M", "M, alpha" 或 "M, alpha, sym_flag"
- M: 窗口长度（正整数）
- alpha: 高斯窗的alpha参数（正数，默认2.5），对应MATLAB中的alpha，与标准差σ的关系为σ = (M-1)/(2*alpha)
- sym_flag: 可选参数，0表示非对称窗口（sym=False），其他值表示对称窗口（默认，sym=True）
返回：
list: 高斯窗口数组，或错误信息字符串。
"""
try:
expr = sp.sympify(input_str)
m = None
alpha = 2.5 # MATLAB默认alpha为2.5
sym = True # 默认对称窗口
# 解析输入参数
if isinstance(expr, (int, sp.Integer, float, sp.Float)):
# 单个参数，例如 "64"
m = int(expr)
elif isinstance(expr, tuple):
# 元组参数，例如 "64, 0.4" 或 "64, 0.4, 0"
if len(expr) >= 1:
m = int(expr[0])
if len(expr) >= 2:
alpha = float(expr[1])
if len(expr) >= 3:
# 处理第三个参数（sym_flag）
sym_flag = str(expr[2])
sym = False if sym_flag == '0' else True
if len(expr) > 3:
raise ValueError("参数过多，最多支持3个参数")
else:
return f"输入错误：无法解析的参数格式 '{input_str}'"
# 参数有效性检查
if m is None or m <= 0:
return "错误：窗口长度M必须为正整数"
if alpha <= 0:
return "错误：alpha必须为正数"
# 计算标准差σ，根据MATLAB公式 σ = (M-1)/(2*alpha)
std = (m - 1) / (2 * alpha)
# 生成高斯窗口
window = signal.windows.gaussian(m, std, sym)
return list(window)
except Exception as e:
return f"错误：{e}"
# 示例代码
if __name__ == "__main__":
# 示例1：默认参数（M=64, alpha=2.5, sym=True）
print("示例1 默认参数:", gausswin_window("64")[:5])
# [0.04393693362340742, 0.053411098929097026, 0.06452050267116646, 0.0774512497553297, 0.09238970420181072]
# 示例2：自定义alpha（M=64, alpha=0.4, sym=True）
print("示例2 自定义alpha:", gausswin_window("64,0.4")[:5])
# [0.9231163463866358, 0.9277423175922188, 0.9322411350082428, 0.936610727772961, 0.9408490778060681]
# 示例3：非对称窗口（M=64, alpha=0.4, sym=False）
print("示例3 非对称窗口:", gausswin_window("64,0.4,0")[:5])
# [0.9207563392996183, 0.9254450947656505, 0.9300077511714193, 0.9344422118574613, 0.938746432156527]
最大公约数
G = gcd(A,B,v=0) 返回 A 和 B 的元素的最大公约数. G 中的元素始终是非负值, gcd(0,0) 返回 0. 此语法支持任何数值类型的输入
[G,U,V] = gcd(A,B,v=1) 还返回 Bézout 系数 U 和 V，它们满足：A.*U + B.*V = G。Bézout 系数用于对 Diophantine 方程求解。
A,B — 输入值,标量,向量或实整数值数组
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def gcd_number(input_str):
"""
对标MATLAB的gcd函数，计算最大公约数及Bézout系数
参数：
input_str (str): 输入的参数字符串，格式应为 "a, b"（支持标量或矩阵）
返回：
tuple: (G, U, V) 包含最大公约数和Bézout系数的矩阵/标量
str: 错误信息（格式错误/非整数输入/矩阵形状不匹配等）
功能说明：
1. 支持标量计算：gcd(6,15) → (3, -2, 1)
2. 支持矩阵计算：逐元素计算gcd
3. 自动处理标量与矩阵的广播
4. 返回Bézout系数满足 a*u + b*v = gcd(a,b)
"""
try:
expr = sp.sympify(input_str)
error = False
result = None
def extended_gcd(a, b):
# 转换为 NumPy 数组并确保是整数类型
a0 = np.array(a, dtype=np.int64, ndmin=1, copy=False)
b0 = np.array(b, dtype=np.int64, ndmin=1, copy=False)
# 应用广播规则
a_broadcast, b_broadcast = np.broadcast_arrays(a0, b0)
# 初始化结果数组
shape = a_broadcast.shape
g_arr = np.zeros(shape, dtype=np.int64)
u_arr = np.zeros(shape, dtype=np.int64)
v_arr = np.zeros(shape, dtype=np.int64)
# 对每个元素单独计算扩展欧几里得算法
for idx in np.ndindex(shape):
a_val = a_broadcast[idx]
b_val = b_broadcast[idx]
sign_a = np.sign(a_val) if a_val != 0 else 1
sign_b = np.sign(b_val) if b_val != 0 else 1
a1 = np.abs(a_val)
b1 = np.abs(b_val)
u, v = 1, 0
u1, v1 = 0, 1
while b1 != 0:
q = a1 // b1
r = a1 % b1
new_u = u - q * u1
new_v = v - q * v1
a1, b1 = b1, r
u, v = u1, v1
u1, v1 = new_u, new_v
g_arr[idx] = a1
u_arr[idx] = u * sign_a
v_arr[idx] = v * sign_b
return g_arr, u_arr, v_arr
# 检查传入的 expr 是否为元组类型
if isinstance(expr, tuple):
# 如果 expr 是一个长度为 3 的元组
if len(expr) == 3:
# 从元组中提取第一个元素作为底数 n（这里注释提到 base b 可能有误，推测应该是 base n）
n = expr[0]
# 从元组中提取第二个元素
x = expr[1]
# 将元组中的第三个元素转换为整数类型
v = int(expr[2])
# 检查 v 是否既不等于 0 也不等于 1
if v != 0 and v != 1:
# 如果不满足条件，抛出 ValueError 异常，提示参数必须是 0 或 1
raise ValueError("参数必须是0或1")
# 如果 expr 是一个长度为 2 的元组
elif len(expr) == 2:
# 从元组中提取第一个元素作为底数 n
n = expr[0]
# 从元组中提取第二个元素
x = expr[1]
# 将 v 的值设为 0
v = 0
if v == 0:
result = np.gcd(n, x)
else:
result = extended_gcd(n, x)
# 如果 expr 不是元组类型
else:
# 将错误标志设为 True
error = True
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"输入错误:{input_str}"
# 示例代码 ======================================================================
if __name__ == "__main__":
# 示例1：标量计算
print("示例1：gcd(6, 15, 1)")
result = gcd_number("6, 15, 1")
print(result)
print("\n")
# (array([3]), array([-2]), array([1]))
# 示例2：
test_input = "12,15"
print("输入：", test_input)
result = gcd_number(test_input)
print(result)
print("\n")
# 3
test_input = "5, 15, 1"
print("输入：", test_input)
result = gcd_number(test_input)
print(result)
print("\n")
# (array([5]), array([1]), array([0]))
最大公约数矩阵
A = gcdmat(n) 返回 n×n 矩阵，其 A(i,j) 等于 gcd(i,j)
对于所有非负r, 矩阵 A 是对称正定矩阵, A^r 是对称半正定矩阵
n — 输入,标量
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def generate_gcd_matrix(n):
"""
生成n×n的GCD矩阵，其中元素A[i][j] = gcd(i+1, j+1)
参数:
n (int): 矩阵维度（正整数）
返回:
np.ndarray: 生成的GCD矩阵
"""
# 初始化n×n的零矩阵
A = np.zeros((n, n), dtype=int)
# 遍历每个元素计算gcd（注意i和j从0开始，对应1-based编号）
for i in range(n):
for j in range(n):
A[i][j] = sp.gcd(i + 1, j + 1)
return A
def gcdmat_matrix(input_str):
"""
根据输入字符串生成GCD矩阵
参数:
input_str (str): 输入的矩阵维度字符串表达式（需能解析为正整数）
返回:
sp.Matrix | str: 生成的Sympy矩阵对象或错误信息
"""
try:
# 将输入字符串解析为Sympy表达式
expr = sp.sympify(input_str)
# 检查是否为有效正整数
if not expr.is_integer: # 检查数学上是否为整数
return f"错误：输入必须为整数，但收到 {input_str}"
n = int(expr) # 转换为Python整数
if n <= 0:
return f"错误：维度必须为正整数，但收到 {n}"
# 生成矩阵并转换为Sympy矩阵对象
return sp.Matrix(generate_gcd_matrix(n))
except sp.SympifyError:
return f"解析错误：'{input_str}' 不是有效的数学表达式"
except Exception as e:
return f"运行时错误：{str(e)}"
if __name__ == "__main__":
# 示例测试代码
test_cases = [
"3",
# Matrix([[1, 1, 1],
# [1, 2, 1],
# [1, 1, 3]])
"4"
# Matrix([[1, 1, 1, 1],
# [1, 2, 1, 2],
# [1, 1, 3, 1],
# [1, 2, 1, 4]])
]
for case in test_cases:
print(f"输入 '{case}':")
result = gcdmat_matrix(case)
if isinstance(result, sp.Matrix):
print(f"生成的 {result.rows}x{result.cols} 矩阵:")
print(result)
else:
print(result)
print("\n" + "-" * 50 + "\n")
Gear矩阵
A = gearmat(n,i,j) 返回 n×n 矩阵, 其中下对角线和上对角线上为 1, (1,abs(i)) 位置为 sign(i), (n,n+1-abs(j)) 位置为 sign(j), 其余所有位置为 0.
参量 i 和 j 的默认值分别为 n 和 -n. 它们必须为 -n 到 n 范围内的整数
矩阵 A 是奇异矩阵，可具有双重和三重特征值，并且可以是亏损矩阵
所有特征值的形式均为 2*cos(a)，特征向量的形式为 [sin(w+a), sin(w+2a), …, sin(w+na)]
n,i,j — 输入,标量
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def generate_gear_matrix(n, i, j):
"""
生成n×n的齿轮矩阵，具有以下特征：
1. 次对角线（上下对角线）填充1
2. (1,|i|)位置填充sign(i)
3. (n, n+1-|j|)位置填充sign(j)
参数:
n (int): 矩阵维度（>=2的正整数）
i (int): 第一行特征位置（非零整数，-n <= i <=n）
j (int): 最后一行特征位置（非零整数，-n <= j <=n）
返回:
np.ndarray: 生成的齿轮矩阵
异常:
ValueError: 参数不符合要求时抛出
"""
# 参数验证
if n < 1:
raise ValueError("矩阵维度n必须是正整数")
if i == 0 or j == 0:
raise ValueError("参数i和j不能为零")
if not (-n <= i <= n) or not (-n <= j <= n):
raise ValueError(f"参数i和j必须在[-{n}, {n}]范围内")
# 创建基础矩阵
A = np.zeros((n, n), dtype=int)
# 填充次对角线（Python使用0-based索引）
# 下对角线（主对角线下方）
np.fill_diagonal(A[1:], 1)
# 上对角线（主对角线上方）
np.fill_diagonal(A[:, 1:], 1)
# 设置特征元素（转换为0-based索引）
# 第一行：位置(0, abs(i)-1)
A[0, abs(i) - 1] = np.sign(i)
# 最后一行：位置(n-1, n - abs(j) -1)
# 计算公式调整为：n - abs(j) 对应MATLAB的n+1-|j|
A[n - 1, n - abs(j)] = np.sign(j)
return A
def gearmat_matrix(input_str):
"""
解析输入字符串并生成齿轮矩阵
参数:
input_str (str): 支持两种格式：
- 单整数："n" 生成默认矩阵（i=n, j=-n）
- 元组："(n,i,j)" 或 "n,i,j" 生成自定义矩阵
返回:
sp.Matrix | str: Sympy矩阵对象或错误信息
"""
try:
expr = sp.sympify(input_str)
# 处理元组输入 (n, i, j)
if isinstance(expr, tuple):
if len(expr) != 3:
return f"需要3个参数，但收到{len(expr)}个"
# 验证所有元素为整数
if not all(e.is_integer for e in expr):
return "所有参数必须为整数"
n, i, j = map(int, expr)
matrix = generate_gear_matrix(n, i, j)
# 处理单整数输入
elif expr.is_integer:
n = int(expr)
if n < 1:
return f"维度必须≥1，但收到{n}"
matrix = generate_gear_matrix(n, i=n, j=-n) # 默认参数
else:
return "无效的输入格式"
return sp.Matrix(matrix)
except (sp.SympifyError, ValueError) as e:
return f"输入错误：{str(e)}"
except Exception as e:
return f"运行时错误：{str(e)}"
if __name__ == "__main__":
# 示例测试
test_cases = [
"3",
# Matrix([[0, 1, 1],
# [1, 0, 1],
# [-1, 1, 0]])
"(4, 2, -3)",
# Matrix([[0, 1, 0, 0],
# [1, 0, 1, 0],
# [0, 1, 0, 1],
# [0, -1, 1, 0]])
]
for case in test_cases:
print(f"输入: {case}")
result = gearmat_matrix(case)
if isinstance(result, sp.Matrix):
print(f"生成 {result.rows}x{result.cols} 齿轮矩阵:")
print(result)
else:
print(result)
print("\n" + "=" * 50 + "\n")
几何分布的累积分布函数
y=geocdf（x，p）返回几何分布的累积分布函数（cdf），使用p中的相应概率在x中的每个值处进行评估。
x -- 整数标量, 向量，矩阵，多维数组，是第一次成功之前的失败次数
p -- 标量，向量，矩阵，多维数组，是成功的概率
y -- cdf值，作为标量或[0,1]范围内的标量数组返回。在任何必要的标量展开后，y与x和p的大小相同。
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import numpy as np
import scipy.stats as st
import sympy as sp
from sympy.stats import Geometric, cdf
# 几何分布的累积分布函数
def geometric_cdf(input_str):
try:
expr = sp.sympify(input_str)
error = False
result = None
# 计算卡方分布的概率密度函数 (PDF)
# 转换为 SymPy 数组（仅在符号分支使用）
if isinstance(expr, tuple) and len(expr) == 2:
if all(e.is_number for e in expr):
k = int(expr[0]) # 实验的次数，标量或数组
p = float(expr[1]) # 成功的概率
# 计算概率值，处理k为负值的情况（设置概率为0）
result = np.where(k >= 0, st.geom.cdf(k, p), 0)
elif any(e.free_symbols for e in expr):
k, p = expr
X = Geometric('geom', p)
cdf_expr = cdf(X)(k)
result = cdf_expr.evalf()
else:
error = True
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误:{e}"
# 示例使用:
# 标量输入
print(geometric_cdf("3, 0.5"))
# 0.875
# 符号变量输入
print(geometric_cdf("x, 0.5"))
# Piecewise((1.0 - 2.0*0.5**(floor(x) + 1.0), x >= 1), (0, True))
几何分布的概率质量函数
y=geopdf（x，p）使用p中的相应概率返回x中每个值处的几何分布的概率密度函数（pdf）。x和p可以是向量、矩阵或多维数组。标量输入被扩展为与其他输入具有相同维度的常数数组。p中的参数必须位于[0,1]区间内。
x -- 整数标量, 向量，矩阵，多维数组，是第一次成功之前的失败次数
p -- 标量，向量，矩阵，多维数组，是成功的概率
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import numpy as np
import scipy.stats as st
import sympy as sp
from sympy.stats import Geometric, density
# 几何分布的概率质量函数
def geometric_pdf(input_str):
try:
expr = sp.sympify(input_str)
error = False
result = None
# 计算卡方分布的概率密度函数 (PDF)
# 转换为 SymPy 数组（仅在符号分支使用）
if isinstance(expr, tuple) and len(expr) == 2:
if all(e.is_number for e in expr):
k = int(expr[0]) # 实验的次数，标量或数组
p = float(expr[1]) # 成功的概率
# 计算概率值，处理k为负值的情况（设置概率为0）
result = np.where(k >= 0, st.geom.pmf(k, p), 0)
elif any(e.free_symbols for e in expr):
k, p = expr
X = Geometric('geom', p)
density_expr = density(X)(k)
result = density_expr.evalf()
else:
error = True
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误:{e}"
# 示例使用:
# 标量输入
print(geometric_pdf("3, 0.5"))
# 0.125
# 符号变量输入
print(geometric_pdf("x, 0.5"))
# 0.5*0.5**(x - 1.0)