Y = abs(X) 返回输入 X 中每个元素的绝对值.
如果 X 是复数，则 abs(X) 返回复数的模.
X是标量 | 向量 | 矩阵 | 多维数组
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def abs_complex_modulus(input_str):
"""
计算输入表达式的绝对值或复数的模。
参数:
input_str: 输入的字符串，可以是矩阵、复数、数字或符号表达式。
返回:
如果输入是矩阵，则返回每个元素的绝对值或模；
如果输入是数字或符号表达式，则返回其绝对值或模；
如果输入无法解析，则返回错误信息。
"""
try:
# 将输入字符串解析为 SymPy 表达式
expr = sp.sympify(input_str)
error = False
result = None
# 判断是否为矩阵或多维数组
if expr.free_symbols:
# 如果是数字或符号表达式，直接计算绝对值
result = sp.Abs(expr)
elif expr.is_number:
result = np.abs(complex(expr))
else:
error = True
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于演示 abs_complex_modulus 函数的使用。
"""
# 示例 1: 输入为复数
input_str1 = "3 + 4j"
result1 = abs_complex_modulus(input_str1)
print(f"输入: {input_str1}\n结果: {result1}\n")
# 示例 3: 输入为符号表达式
input_str3 = "x**2 + y**2"
result3 = abs_complex_modulus(input_str3)
print(f"输入: {input_str3}\n结果: {result3}\n")
# 示例 4: 输入错误的情况
input_str4 = "invalid_input"
result4 = abs_complex_modulus(input_str4)
print(f"输入: {input_str4}\n结果: {result4}\n")
if __name__ == "__main__":
main()
通过将向量的元素累积到其下标定义的位置来创建数组.
A =accumarray(data, ind).
B = accumarray(ind,data) 根据ind中指定的组,通过对向量data的元素进行累加来对组数据求和.然后计算每组的总和.ind 中的值定义数据所属的组以及存储每个组总和的输出数组B的索引.
要按顺序返回组总和，请将ind指定为向量。然后，对于索引为i的组，accumarray返回其在 B(i) 中的总和.例如，如果data = [1 2 3 4], ind=[1 1 2 2]则 B = accumarray(data,ind) 返回列向量B = [0 3 7].
要以另一种形状返回组总和，请将 ind 指定为矩阵。对于 m×n 矩阵 ind，其中每一行的值表示指定的组和输出B的n维索引. 例如，如果ind包含[3 4]形式的两行,则data 中对应元素的总和存储在B 的 (3,4) 元素中.
B 中未在 ind 中显示其索引的元素默认用 0 填充.
ind — 输出索引, 向量 | 矩阵
data — 要累加的数据, 标量 | 向量
B — 输出数组, 向量 | 矩阵 | 多维数组
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import numpy as np
import ast
from itertools import product
def accumulating_array(input_str, func=None, size=None, fill_value=0, dtype=None):
"""
一个类似于 Matlab 的 `accumarray` 函数的累加函数。
参数
----------
input_str : str
输入字符串，包含输入数组和累加映射。
func : callable or None
累加函数。该函数将接收一个值列表进行累加。
如果为 None，默认使用 `numpy.sum`。
size : ndarray or None
输出数组的大小。如果为 None，则根据 `accmap` 确定大小。
fill_value : scalar
输出数组元素的默认值。
dtype : numpy 数据类型 or None
输出数组的数据类型。如果为 None，则使用输入数组的数据类型。
返回
-------
out : ndarray
累加结果。
示例
--------
见 `main` 函数中的示例代码。
"""
try:
# 解析输入字符串为 Python 对象
expr = ast.literal_eval(input_str)
a = np.array(expr[0]) # 输入数组
accmap = np.array(expr[1]) # 累加映射
# 检查参数是否合法并处理默认值
if accmap.shape[:a.ndim] != a.shape:
raise ValueError("accmap 的前几个维度必须与 a 的形状相同")
if func is None:
func = np.sum # 默认累加函数为求和
if dtype is None:
dtype = a.dtype # 默认数据类型与输入数组相同
if accmap.shape == a.shape:
accmap = np.expand_dims(accmap, -1) # 如果 accmap 是二维的，扩展为三维
# 确定输出数组的大小
adims = tuple(range(a.ndim))
if size is None:
size = 1 + np.squeeze(np.apply_over_axes(np.max, accmap, axes=adims))
size = np.atleast_1d(size)
# 创建一个存储值的 Python 列表数组
vals = np.empty(size, dtype='O')
for s in product(*[range(k) for k in size]):
vals[s] = []
for s in product(*[range(k) for k in a.shape]):
indx = tuple(accmap[s]) # 获取累加映射的索引
val = a[s] # 获取输入数组的值
vals[indx].append(val) # 将值添加到对应的列表中
# 创建输出数组
out = np.empty(size, dtype=dtype)
for s in product(*[range(k) for k in size]):
if vals[s] == []:
out[s] = fill_value # 如果列表为空，使用填充值
else:
out[s] = func(vals[s]) # 否则应用累加函数
return sp.Array(out) # 返回结果列表
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于演示 `accumulating_array` 函数的使用。
"""
# 示例 1: 对角元素求和
input_str1 = "[[[1, 2, 3], [4, -1, 6], [-1, 8, 9]], [[0, 1, 2], [2, 0, 1], [1, 2, 0]]]"
result1 = accumulating_array(input_str1)
print(f"示例 1 输入: {input_str1}\n结果: {result1}\n")
# 示例 2: 使用乘积累加
input_str2 = "[[[1, 2, 3], [4, -1, 6], [-1, 8, 9]], [[[0, 0], [0, 0], [0, 1]], [[0, 0], [0, 0], [0, 1]], [[1, 0], [1, 0], [1, 1]]]]"
result2 = accumulating_array(input_str2, func=np.prod, dtype=float)
print(f"示例 2 输入: {input_str2}\n结果: {result2}\n")
# 示例 3: 返回值的列表
input_str3 = "[[[1, 2, 3], [4, -1, 6], [-1, 8, 9]], [[[0, 0], [0, 0], [0, 1]], [[0, 0], [0, 0], [0, 1]], [[1, 0], [1, 0], [1, 1]]]]"
result3 = accumulating_array(input_str3, func=lambda x: x, dtype='O')
print(f"示例 3 输入: {input_str3}\n结果: {result3}\n")
# 示例 4: 错误输入
input_str4 = "invalid_input"
result4 = accumulating_array(input_str4)
print(f"示例 4 输入: {input_str4}\n结果: {result4}\n")
if __name__ == "__main__":
main()
通过将数组的切片累积到其下标沿指定维度定义的位置来创建数组.
A =accumdim(subs, vals, dim)
下标由索引向量subs定义.尺寸由dim指定.如果未给出，则默认为第一个非单一维度.
将subs矩阵中的行向量，按vals下标分组，每组中的向量对应列求和，得到新的一个向量.
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import ast
import numpy as np
import sympy as sp
def accumulating_dim(input_str):
"""
该函数接受一个字符串形式的输入，将其解析为一个表达式，然后根据表达式中的值和索引进行累加操作，
最后返回一个Sympy矩阵。
参数:
input_str (str): 一个字符串，表示一个包含值和索引的列表或元组。
返回:
sp.Matrix: 累加后的Sympy矩阵。
"""
try:
# 使用ast.literal_eval安全地解析输入字符串为Python表达式
expr = ast.literal_eval(input_str)
# 将表达式中的值和索引转换为NumPy数组
values = np.array(expr[0])
indices = np.array(expr[1])
# 获取结果数组的形状，行数为索引的最大值加1，列数与values的列数相同
result_shape = (indices.max() + 1, values.shape[1])
# 初始化结果数组，使用与values相同的数据类型，并填充0
result = np.zeros(result_shape, dtype=values.dtype)
# 使用np.add.at函数将values累加到result的指定位置
np.add.at(result, (indices, slice(None)), values)
# 将结果数组转换为Sympy矩阵
s_matrix = sp.Matrix(result)
return s_matrix
except Exception as e:
# 如果发生任何异常，返回错误信息
return f"错误: {e}"
def main():
"""
主函数，用于演示accumulating_dim函数的使用。
"""
# 示例输入：一个字符串，表示一个包含值和索引的列表
input_str = "([[1, 2], [3, 4], [5, 6]], [0, 1, 0])"
# 调用accumulating_dim函数
result = accumulating_dim(input_str)
# 打印结果
print("输入字符串:", input_str)
print("累加后的Sympy矩阵:")
print(result)
if __name__ == "__main__":
# 如果直接运行该脚本，则执行main函数
main()
计算x的每个元素的反余弦(以弧度为单位),返回X各元素的反余弦(cos^-1).该函数同时接受实数和复数输入.
Y=acos(X)
对于X在区间[-1, 1]内的实数值,acos(X)返回区间[0, π]内的值.
对于X在区间[-1,1]之外的实数值以及X的复数值，acos(X)返回复数值.
X是标量，向量，数组，矩阵，多维数组
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import numpy as np
import sympy as sp
def acos_inverse_cosine(input_str):
"""
计算输入表达式的反余弦值。
参数:
input_str: 输入的字符串表达式。
返回:
如果输入是矩阵，则返回矩阵中每个元素的反余弦值；
如果输入是数值或符号表达式，则返回其反余弦值；
如果输入无效，则返回错误信息。
"""
try:
expr = sp.sympify(input_str)
error = False
result = None
# 如果输入是数值或符号表达式，计算其反余弦值
if expr.is_number:
result = np.arccos(complex(expr))
elif expr.free_symbols:
result = sp.acos(expr)
else:
error = True
# 根据是否有错误返回相应的结果
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于示范 acos_inverse_cosine 函数的使用。
"""
# 示范输入为数值
input_str1 = "0.5"
result1 = acos_inverse_cosine(input_str1)
print(f"输入: {input_str1}, 结果: {result1}")
# 示范输入为符号表达式
input_str2 = "x"
result2 = acos_inverse_cosine(input_str2)
print(f"输入: {input_str2}, 结果: {result2}")
# 示范输入为无效表达式
input_str4 = "(1, 2)"
result4 = acos_inverse_cosine(input_str4)
print(f"输入: {input_str4}, 结果: {result4}")
if __name__ == "__main__":
main()
返回X的元素的反余弦(cos^-1)(以度为单位),该函数同时接受实数和复数输入.
Y=acosd(X)
对于X在区间[-1, 1]内的实数值,acos(X)返回区间[0, 180]内的值.
对于X在区间[-1,1]之外的实数值以及X的复数值,acos(X)返回复数值.
X是标量，向量，数组，矩阵.
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def acosd_inverse_cosine(input_str):
"""
计算输入表达式的反余弦值，并将结果转换为度数。
参数:
input_str: 输入的字符串表达式，可以是数字、符号或矩阵。
返回:
如果输入有效，则返回计算结果；否则返回错误信息。
"""
try:
# 将输入字符串转换为 SymPy 表达式
expr = sp.sympify(input_str)
error = False
result = None
if expr.free_symbols:
result = sp.acos(expr) * 180 / sp.pi
elif expr.is_number:
# 确保 SymPy 表达式被求值为数值
numeric_value = complex(expr)
# 使用 NumPy 计算反余弦（以弧度为单位）
rad_value = np.arccos(numeric_value)
# 将弧度转换为度
result = rad_value * 180 / np.pi
else:
error = True
# 如果发生错误，返回错误信息
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于演示 acosd_inverse_cosine 函数的使用。
"""
# 示范代码
input_examples = [
"0.5", # 数字输入
"x", # 符号输入
"acosd(0.5)", # 错误输入
"(1, 2, 3)" # 错误输入（元组）
]
for input_str in input_examples:
print(f"输入: {input_str}")
result = acosd_inverse_cosine(input_str)
print(f"结果: {result}\n")
if __name__ == "__main__":
main()
反双曲余弦
Y = acosh(X) 返回X的元素的反双曲余弦.该函数同时接受实数和复数输入.所有的角度都以弧度表示.
X是标量,向量,数组或矩阵
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def acosh_inverse_hyperbolic_cosine(input_str):
"""
计算输入表达式的反双曲余弦值（acosh），并返回结果。
参数:
input_str: 输入的字符串表达式，可以是数字、符号或矩阵。
返回:
如果输入有效，则返回计算结果；否则返回错误信息。
"""
try:
# 将输入字符串转换为 SymPy 表达式
expr = sp.sympify(input_str)
error = False
result = None
# 如果输入是元组，标记为错误
if expr.free_symbols:
result = sp.acosh(expr)
elif expr.is_number:
result = np.arccosh(complex(expr))
else:
error = True
# 如果发生错误，返回错误信息
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于演示 acosh_inverse_hyperbolic_cosine 函数的使用。
"""
# 示范代码
input_examples = [
"2+2j", # 数字输入
"x", # 符号输入
"(1, 2, 3)", # 错误输入（元组）
"1.5", # 浮点数输入
"y + 1" # 符号表达式输入
]
for input_str in input_examples:
print(f"输入: {input_str}")
result = acosh_inverse_hyperbolic_cosine(input_str)
print(f"结果: {result}\n")
if __name__ == "__main__":
main()
反余切(以弧度为单位)
Y = acot(X) 以弧度为单位返回X各元素的反余切(cot^-1).该函数同时接受实数和复数输入.
对于 X 的实数值，acot(X) 返回区间[-π/2, π/2]中的值
对于 X 的复数值，acot(X) 返回复数值
X是标量,向量,数组或矩阵
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def acot_inverse_cotangent(input_str):
"""
计算输入表达式的反余切值（acot），并返回结果。
参数:
input_str: 输入的字符串表达式，可以是数字、符号或矩阵。
返回:
如果输入有效，则返回计算结果；否则返回错误信息。
"""
try:
# 将输入字符串转换为 SymPy 表达式
expr = sp.sympify(input_str)
error = False
result = None
if expr.free_symbols:
result = sp.acot(expr)
elif expr.is_number:
#在复数域中，其结果与sympy acot(expr)得到的结果等价，
#因为它们相差 π（在复数域中）(−π/2−0.5493j)+π=π/2−0.5493j
result = np.pi/2 - np.arctan(complex(expr))
else:
error = True
# 如果发生错误，返回错误信息
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于演示 acot_inverse_cotangent 函数的使用。
"""
# 示范代码
input_examples = [
"1", # 数字输入
"x", # 符号输入
"(1, 2, 3)", # 错误输入（元组）
"0.5", # 浮点数输入
"y + 1" # 符号表达式输入
]
for input_str in input_examples:
print(f"输入: {input_str}")
result = acot_inverse_cotangent(input_str)
print(f"结果: {result}\n")
if __name__ == "__main__":
main()
反余切(以度为单位)
Y = acotd(X) 返回X的元素的反余切(cot^-1)（以度为单位）。该函数同时接受实数和复数输入.
对于 X 的实数值，acotd(X) 返回范围 [-90, 90] 中的值.
对于 X 的复数值，acotd(X) 返回复数值.
X是标量,向量,数组或矩阵
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def acot_degree_inverse_cotangent(input_str):
"""
计算输入表达式的反余切值（acot），并将结果转换为度数。
参数:
input_str: 输入的字符串表达式，可以是数字、符号或矩阵。
返回:
如果输入有效，则返回计算结果；否则返回错误信息。
"""
try:
# 将输入字符串转换为 SymPy 表达式
expr = sp.sympify(input_str)
error = False
result = None
# 如果输入是数字或包含符号，直接计算反余切值
if expr.is_number:
# 数值计算（处理实数/复数）
result = 90.0 - np.arctan(complex(expr))*180/np.pi
elif expr.free_symbols:
result = sp.deg(sp.acot(expr))
else:
error = True
# 如果发生错误，返回错误信息
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于演示 acot_degree_inverse_cotangent 函数的使用。
"""
# 示范代码
input_examples = [
"-1", # 数字输入
"x", # 符号输入
"(1, 2, 3)", # 错误输入（元组）
"0.5", # 浮点数输入
"y + 1" # 符号表达式输入
]
for input_str in input_examples:
print(f"输入: {input_str}")
result = acot_degree_inverse_cotangent(input_str)
print(f"结果: {result}\n")
if __name__ == "__main__":
main()
反双曲余切
Y = acoth(X) 返回X各元素的反双曲余切.该函数同时接受实数和复数输入.所有的角度都以弧度表示.
X是标量,向量,数组或矩阵
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def acot_hyperbolic_inverse_cotangent(input_str):
"""
计算输入表达式的反双曲余切值。
参数:
input_str: 输入的字符串表达式，可以是数字、符号、矩阵等。
返回:
如果输入有效，则返回计算结果；否则返回错误信息。
"""
try:
# 将输入字符串转换为 SymPy 表达式
expr = sp.sympify(input_str)
error = False
result = None
# 如果表达式是元组，说明输入格式错误
if expr.free_symbols:
result = sp.acoth(expr)
elif expr.is_number:
z = complex(expr)
# 检查特殊值
if abs(z) == 1:
return f"错误: 输入值{expr}无效，反双曲余切在z=1和z=-1处无定义"
result = 0.5 * np.log((z + 1) / (z - 1))
else:
error = True
# 如果出现错误，返回错误信息
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于演示 acot_hyperbolic_inverse_cotangent 函数的使用。
"""
# 示范代码
input_examples = [
"2", # 数字
"x", # 符号
"invalid_input", # 无效输入
]
for input_str in input_examples:
print(f"输入: {input_str}")
result = acot_hyperbolic_inverse_cotangent(input_str)
print(f"结果: {result}")
print("-" * 40)
if __name__ == "__main__":
main()
反余割(以弧度为单位)
Y = acsc(X) 以弧度为单位返回X各元素的 反余割(csc^-1).该函数同时接受实数和复数输入
对于 X 在区间 [-∞, -1] 和 [1, ∞]中的实数值，acsc(X)返回区间[-π/2, π/2]中的实数值
对于 X 在区间 (-1, 1) 内的实数值以及 X 的复数值，acsc(X) 返回复数值
X是标量,向量,数组或矩阵
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def acsc_inverse_cosecant(input_str):
"""
计算输入表达式的反余割值。
参数:
input_str: 输入的字符串表达式，可以是数字、符号、矩阵等。
返回:
如果输入有效，则返回计算结果；否则返回错误信息。
"""
try:
# 将输入字符串转换为 SymPy 表达式
expr = sp.sympify(input_str)
error = False
result = None
# 如果表达式是数字或包含自由符号，则直接计算反余割
if expr.is_number:
"""计算反余割函数 acsc(x)"""
z = complex(expr)
result = np.arcsin(1.0 / z)
elif expr.free_symbols:
result = sp.acsc(expr)
else:
error = True
# 如果出现错误，返回错误信息
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于演示 acsc_inverse_cosecant 函数的使用。
"""
# 示范代码
input_examples = [
"2", # 数字
"x", # 符号
"invalid_input", # 无效输入
]
for input_str in input_examples:
print(f"输入: {input_str}")
result = acsc_inverse_cosecant(input_str)
print(f"结果: {result}")
print("-" * 40)
if __name__ == "__main__":
main()
acscd 反余割(以度为单位)
Y = acscd(X) 返回 X 的元素的反余割 (cosec^-1)（以度为单位）.该函数同时接受实数和复数输入
对于 X 在区间 [-oo, -1] 和 [1,oo] 中的实数值，acscd(X) 返回范围 [-90, 90] 中的值.
对于 X 在区间 (-1, 1) 内的实数值以及 X 的复数值，acscd(X) 返回复数值.
X是标量,向量,数组或矩阵
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def acscd_inverse_cosecant(input_str):
"""
计算输入表达式的反余割值（以度为单位）。
参数:
input_str: 输入的字符串表达式，可以是数字、符号、矩阵等。
返回:
如果输入有效，则返回计算结果；否则返回错误信息。
"""
try:
# 将输入字符串转换为 SymPy 表达式
expr = sp.sympify(input_str)
error = False
result = None
if expr.free_symbols:
result = sp.deg(sp.acsc(expr))
elif expr.is_number:
z = complex(expr)
rad_result = np.arcsin(1.0 / z) # 先计算弧度
result = rad_result * 180 / np.pi # 转换为度
else:
error = True
# 如果出现错误，返回错误信息
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于演示 acscd_inverse_cosecant 函数的使用。
"""
# 示范代码
input_examples = [
"2", # 数字
"x", # 符号
"invalid_input", # 无效输入
]
for input_str in input_examples:
print(f"输入: {input_str}")
result = acscd_inverse_cosecant(input_str)
print(f"结果: {result}")
print("-" * 40)
if __name__ == "__main__":
main()
反双曲余割
Y = acsch(X) 返回X各元素的反双曲余割.该函数同时接受实数和复数输入.所有的角度都以弧度表示
X是标量,向量,数组或矩阵
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def acsch_inverse_cosecant(input_str):
"""
计算输入表达式的反双曲余割值。
参数:
input_str: 输入的字符串表达式，可以是数字、符号、矩阵等。
返回:
如果输入有效，则返回计算结果；否则返回错误信息。
"""
try:
# 将输入字符串转换为 SymPy 表达式
expr = sp.sympify(input_str)
error = False
result = None
if expr.free_symbols:
z = expr
result = sp.log(1 / z + sp.sqrt(1 / (z ** 2) + 1))
elif expr.is_number:
z = complex(expr)
if z == 0:
result = sp.nan
else:
inv_x = 1.0 / z
result = np.log(inv_x + np.sqrt(inv_x**2 + 1))
else:
error = True
# 如果出现错误，返回错误信息
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于演示 acsch_inverse_cosecant 函数的使用。
"""
# 示范代码
input_examples = [
"2", # 数字
"x", # 符号
"invalid_input", # 无效输入
]
for input_str in input_examples:
print(f"输入: {input_str}")
result = acsch_inverse_cosecant(input_str)
print(f"结果: {result}")
print("-" * 40)
if __name__ == "__main__":
main()
Airy函数,
W = airy(Z) 为Z的每个元素返回Airy函数Ai(Z).
W = airy(k,Z) 返回任何四个不同的Airy函数，具体取决于k的值，例如第二类Airy函数或Airy函数的一阶导数.
Z是向量,矩阵,多维数组
k=0,返回Ai(Z)
k=1,返回Ai(Z)的一阶导数
k=2,返回Bi(Z)
k=3,返回Bi(Z)的一阶导数
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
from scipy.special import airy
def evaluate_function_symbol(z_val, k_val):
"""
根据 k_val 的值计算 Airy 函数或其导数。
参数:
z_val: 输入的表达式，可以是数字、符号等。
k_val: 控制 Airy 函数类型的参数：
- 0: 计算 Airy Ai 函数
- 1: 计算 Airy Ai 函数的导数
- 2: 计算 Airy Bi 函数
- 3: 计算 Airy Bi 函数的导数
返回:
如果输入有效，则返回计算结果；否则返回 None。
"""
if k_val == 0:
return sp.airyai(z_val)
elif k_val == 1:
return sp.airyaiprime(z_val)
elif k_val == 2:
return sp.airybi(z_val)
elif k_val == 3:
return sp.airybiprime(z_val)
else:
return None
def evaluate_function(z_val, k_val):
"""
根据 k_val 的值计算 Airy 函数或其导数。
参数:
z_val: 输入的表达式，可以是数字、符号等。
k_val: 控制 Airy 函数类型的参数：
- 0: 计算 Airy Ai 函数
- 1: 计算 Airy Ai 函数的导数
- 2: 计算 Airy Bi 函数
- 3: 计算 Airy Bi 函数的导数
返回:
如果输入有效，则返回计算结果；否则返回 None。
"""
ai, ai_prime, bi, bi_prime = airy(complex(z_val))
if k_val == 0:
return ai
elif k_val == 1:
return ai_prime
elif k_val == 2:
return bi
elif k_val == 3:
return bi_prime
else:
return None
def airy_functions(input_str):
"""
计算输入表达式的 Airy 函数或其导数。
参数:
input_str: 输入的字符串表达式，可以是数字、符号、矩阵等。
返回:
如果输入有效，则返回计算结果；否则返回错误信息。
"""
try:
# 将输入字符串转换为 SymPy 表达式
expr = sp.sympify(input_str)
error = False
result = None
# 处理元组输入 (k, z)
if isinstance(expr, tuple) and len(expr) == 2:
k, z = expr[0], expr[1]
else:
k, z = 0, expr
# 确保k是整数类型
if not isinstance(k,(int,sp.Integer)):
return f"错误: 参数k必须为整数"
if z.free_symbols:
result = evaluate_function_symbol(z, k)
elif z.is_number:
result = evaluate_function(z, k)
else:
error = True
# 如果出现错误，返回错误信息
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于演示 airy_functions 函数的使用。
"""
# 示范代码
input_examples = [
"2+2j", # 数字
"x", # 符号
"invalid_input", # 无效输入
]
for input_str in input_examples:
print(f"输入: {input_str}")
result = airy_functions(input_str)
print(f"结果: {result}")
print("-" * 40)
if __name__ == "__main__":
main()
AiryAi函数的第k个零点
airyaiZero(k)返回第k个零点
k - 输入,整数
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
from scipy.special import ai_zeros
def airy_ai_zero(input_str):
"""
计算 Airy Ai 函数的第 n 个零点。
参数:
input_str: 输入的字符串表达式，必须是一个整数。
返回:
如果输入有效，则返回 Airy Ai 函数的第 n 个零点；否则返回错误信息。
"""
try:
# 将输入字符串转换为 SymPy 表达式
expr = sp.sympify(input_str)
error = False
result = None
# 如果输入是元组，说明输入格式错误
if isinstance(expr, tuple):
error = True
# 如果输入是整数，则计算 Airy Ai 函数的第 n 个零点
elif expr.is_integer:
# 尝试转换为整数
n_val = int(expr)
result = ai_zeros(n_val)[0][-1]
else:
error = True
# 如果出现错误，返回错误信息
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于演示 airy_ai_zero 函数的使用。
"""
# 示范代码
input_examples = [
"0", # 第 0 个零点
"1", # 第 1 个零点
"2", # 第 2 个零点
"invalid_input", # 无效输入
]
for input_str in input_examples:
print(f"输入: {input_str}")
result = airy_ai_zero(input_str)
print(f"结果: {result}")
print("-" * 40)
if __name__ == "__main__":
main()
AiryBi函数的第k个零点
airybiZero(k)返回第k个零点
k - 输入,整数
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
from scipy.special import bi_zeros
def airy_bi_zero(input_str):
"""
计算 Airy Bi 函数的第 n 个零点。
参数:
input_str: 输入的字符串表达式，必须是一个整数。
返回:
如果输入有效，则返回 Airy Bi 函数的第 n 个零点；否则返回错误信息。
"""
try:
# 对输入字符串进行预处理
# 将输入字符串转换为 SymPy 表达式
expr = sp.sympify(input_str)
error = False
result = None
# 如果输入是元组，说明输入格式错误
if isinstance(expr, tuple):
error = True
# 如果输入是整数，则计算 Airy Bi 函数的第 n 个零点
elif expr.is_integer:
# 尝试转换为整数
n_val = int(expr)
result = bi_zeros(n_val)[0][-1]
else:
error = True
# 如果出现错误，返回错误信息
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于演示 airy_bi_zero 函数的使用。
"""
# 示范代码
input_examples = [
"0", # 第 0 个零点
"1", # 第 1 个零点
"2", # 第 2 个零点
"invalid_input", # 无效输入
]
for input_str in input_examples:
print(f"输入: {input_str}")
result = airy_bi_zero(input_str)
print(f"结果: {result}")
print("-" * 40)
if __name__ == "__main__":
main()
交错数列函数
W = AlternatingSeries(a,n)把a解析成交错队列.
这个函数近似于交替序列中给定的实数.
结果以列表形式返回,每个元素都是有理数。
a是实数, n是队列长度.
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
from fractions import Fraction
def alternating_series_calculate_leibniz(input_str):
"""
计算交错数列，并将其转换为有理数形式。
参数:
input_str: 输入的字符串表达式，可以是一个数或一个元组（起始点，项数）。
返回:
如果输入有效，则返回交错数列的有理数形式列表；否则返回错误信息。
"""
try:
# 将输入字符串转换为 SymPy 表达式
expr = sp.sympify(input_str)
# 如果输入是元组，解析起始点和项数
if isinstance(expr, tuple):
starting_point = sp.N(expr[0]) # 起始点
num_terms = expr[1] # 项数
else:
starting_point = sp.N(expr) # 默认起始点
num_terms = 10 # 默认项数
# 计算莱布尼茨级数的部分和
leibniz_series = [((-1) ** i) / (2 * i + 1) for i in range(int(num_terms))]
current_sum = sum(leibniz_series)
# 调整级数以匹配起始点
leibniz_series[0] += starting_point - current_sum
# 将级数中的浮点数转换为分数形式
fraction_list = [Fraction(str(number)).limit_denominator(100) for number in leibniz_series]
# 将分数转换为 SymPy 的有理数形式
rational_list = [sp.Rational(fraction.numerator, fraction.denominator) for fraction in fraction_list]
return rational_list
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于演示 alternating_series_calculate_leibniz 函数的使用。
"""
# 示范代码
input_examples = [
"0", # 默认起始点，默认项数
"(1, 5)", # 起始点为 1，项数为 5
"invalid_input", # 无效输入
]
for input_str in input_examples:
print(f"输入: {input_str}")
result = alternating_series_calculate_leibniz(input_str)
print(f"结果: {result}")
print("-" * 40)
if __name__ == "__main__":
main()
近似最小度置换.
P = amd(A) 为稀疏矩阵 C=A+A' 返回近似最小度置换向量.
amd函数可能比symamd函数快,还可能比symamd返回更好的排序.
矩阵A必须是方阵.如果A为满矩阵，则amd(A)等效于amd(sparse(A))。
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
import scipy.sparse
import tensorflow as tf
from tensorflow.python.ops.linalg.sparse import sparse_csr_matrix_ops
def amd_approximate_minimum_degree(input_str):
"""
计算输入矩阵的近似最小度（AMD）排序。
参数:
input_str: 输入的字符串表达式，必须是一个矩阵。
返回:
如果输入有效，则返回 AMD 排序结果；否则返回错误信息。
"""
try:
# 将输入字符串转换为 SymPy 表达式
expr = sp.sympify(input_str)
# 检查输入是否为矩阵
if isinstance(expr,list):
# 将 SymPy 矩阵转换为 NumPy 数组
matrix = np.array(expr, dtype=float)
else:
return f"输入错误: {input_str}"
# 检查矩阵是否为稀疏矩阵
if scipy.sparse.issparse(matrix):
# 如果是稀疏矩阵，转换为 COO 格式
coo = matrix.tocoo()
indices = np.vstack((coo.row, coo.col)).T
values = coo.data
dense_shape = coo.shape
else:
# 如果是稠密矩阵，找到非零元素的索引和值
indices = np.argwhere(matrix != 0)
values = matrix[indices[:, 0], indices[:, 1]]
dense_shape = matrix.shape
# 从索引、值和形状创建稀疏张量
sparse_tensor = tf.sparse.SparseTensor(indices, values, dense_shape)
# 将稀疏张量转换为 CSR 稀疏矩阵
sparse_matrix = sparse_csr_matrix_ops.sparse_tensor_to_csr_sparse_matrix(
sparse_tensor.indices, sparse_tensor.values, sparse_tensor.dense_shape)
# 计算 CSR 稀疏矩阵的 AMD 排序
ordering_amd = sparse_csr_matrix_ops.sparse_matrix_ordering_amd(sparse_matrix)
# 将 AMD 排序结果转换为 NumPy 数组并返回
ordering_amd_value = ordering_amd.numpy()
return list(ordering_amd_value)
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于演示 amd_approximate_minimum_degree 函数的使用。
"""
# 示范代码
input_examples = [
"[[1, 0, 2], [0, 3, 0], [4, 0, 5]]", # 稠密矩阵
"[[0, 1, 0], [2, 0, 3], [0, 4, 0]]", # 稀疏矩阵
"invalid_input", # 无效输入
]
for input_str in input_examples:
print(f"输入: {input_str}")
result = amd_approximate_minimum_degree(input_str)
print(f"结果: {result}")
print("-" * 40)
if __name__ == "__main__":
main()
两个向量之间的角度.
X = angleBtwNDVectors(A,B)
(A,B) -- 带有两个向量的元组, 包括正交向量, 普通向量, 符号向量。
X -- 夹角的弧度
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
def angle_between_vectors(input_str):
"""
计算两个向量之间的夹角。
参数:
input_str: 输入的字符串表达式，表示两个向量，例如 "([a1, b1, c1], [a2, b2, c2])"。
返回:
如果输入有效，则返回两个向量之间的夹角（以弧度表示）；否则返回错误信息。
"""
try:
# 将输入字符串转换为 SymPy 表达式
expr = sp.sympify(input_str)
error = False
result = None
# 检查输入是否为元组且包含两个向量
if not isinstance(expr, tuple) or len(expr) != 2:
error = True
else:
# 检查第一个向量是否为列向量
if isinstance(expr[0],list):
sp_matrix = sp.Matrix(expr[0])
if sp_matrix.shape[1] == 1:
v = sp_matrix
else:
error = True
# 检查第二个向量是否为列向量
if isinstance(expr[1],list):
sp_matrix = sp.Matrix(expr[0])
if sp_matrix.shape[1] == 1:
w = sp_matrix
else:
error = True
# 如果输入无效，返回错误信息
if error:
return f"输入错误: {input_str}"
else:
# 计算两个向量之间的夹角
result = sp.acos(v.dot(w) / (v.norm() * w.norm())).evalf()
return result
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于演示 angle_between_vectors 函数的使用。
"""
# 示范代码
input_examples = [
"([1, 0, 0], [0, 1, 0])", # 两个正交向量
"([1, 2, 3], [4, 5, 6])", # 两个普通向量
"([a1, b1, c1], [a2, b2, c2])", # 符号变量
"invalid_input", # 无效输入
]
for input_str in input_examples:
print(f"输入: {input_str}")
result = angle_between_vectors(input_str)
print(f"结果: {result}")
print("-" * 40)
if __name__ == "__main__":
main()
确定是否缺失任一数组元素
如果 A 中有至少一个元素缺失，则 TF = anymissing(A) 返回逻辑值 1 (true)。如果没有元素缺失，它将返回 0 (false)
A -- 向量,矩阵
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
def any_missing(input_str):
"""
检查输入矩阵中是否包含缺失值（NaN）。
参数:
input_str: 输入的字符串表达式，可以是矩阵或其他类型。
返回:
如果输入是矩阵且包含缺失值，返回 1；
如果输入是矩阵且不包含缺失值，返回 0；
如果输入无效，返回错误信息。
"""
try:
# 将输入字符串转换为 SymPy 表达式
expr = sp.sympify(input_str)
error = False
result = None
if isinstance(expr,list):
np_arr = np.asarray(expr,dtype=complex)
if np.any(np.isnan(np_arr)): # 检查数组中是否有至少一个 NaN
result = 1
else:
result = 0
else:
error = True
# 如果出现错误，返回错误信息
if error:
return f"输入错误: {input_str}"
# 如果包含缺失值，返回 1；否则返回 0
else:
return result
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于演示 any_missing 函数的使用。
"""
# 示范代码
input_examples = [
"[[1, 2], [3, 4]]", # 不包含缺失值的矩阵
"[[1, nan], [3, 4]]", # 包含缺失值的矩阵
"([1, 2], [3, 4])", # 无效输入（元组）
"invalid_input", # 无效输入
]
for input_str in input_examples:
print(f"输入: {input_str}")
result = any_missing(input_str)
print(f"结果: {result}")
print("-" * 40)
if __name__ == "__main__":
main()
分解分式
对多项式函数执行部分分数分解.
对有理函数执行部分分式分解.
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
def is_func(expr):
"""
判断输入是否为函数或可以转换为函数的形式。
参数:
expr: 输入的表达式，可以是 SymPy 函数或其他类型。
返回:
如果输入是函数或可以转换为函数，则返回 SymPy 函数对象；否则返回 None。
"""
try:
if isinstance(expr, sp.Function):
return expr
else:
return None
except Exception as e:
print(f"{e}")
return None
def apart_expression(input_str):
"""
对输入表达式进行部分分式分解。
参数:
input_str: 输入的字符串表达式，可以是矩阵、函数或其他类型。
返回:
如果输入有效，则返回部分分式分解结果；否则返回错误信息。
"""
try:
# 将输入字符串转换为 SymPy 表达式
expr = sp.sympify(input_str)
error = False
result = None
# 如果输入是元组，说明输入格式错误
if isinstance(expr, tuple):
error = True
# 如果输入是函数，对函数进行部分分式分解
elif (f_expr := is_func(expr)) is not None:
result = sp.apart(f_expr)
# 其他情况，直接对表达式进行部分分式分解
elif expr.free_symbols:
result = sp.apart(expr)
else:
error = True
# 如果出现错误，返回错误信息
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于演示 apart_expression 函数的使用。
"""
# 示范代码
input_examples = [
"(x**2 + 3*x + 2)/(x + 1)", # 多项式分式
"sin(x)", # 函数
"invalid_input", # 无效输入
]
for input_str in input_examples:
print(f"输入: {input_str}")
result = apart_expression(input_str)
print(f"结果: {result}")
print("-" * 40)
if __name__ == "__main__":
main()
自回归条件异方差模型
是特别用来建立条件方差模型并对其进行预测的.
这些模型被运用于经济学领域，尤其是金融时间序列分析中.
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
from arch import arch_model
def archfit_regression_expression(input_str):
"""
对输入的时间序列数据进行 ARCH 模型拟合。
参数:
input_str: 输入的字符串表达式，表示时间序列数据（矩阵或列表）。
返回:
如果输入有效，则返回 ARCH 模型的拟合参数（以中文命名）；否则返回错误信息。
"""
try:
# 将输入字符串转换为 SymPy 表达式
expr = sp.sympify(input_str)
# 检查输入是否为矩阵
if isinstance(expr,list):
# 将 SymPy 矩阵转换为 NumPy 数组并展平
A = np.array(expr, dtype=float).ravel()
else:
return f"输入错误: {input_str}"
# 使用 ARCH 模型进行拟合
# 假设 p=1（ARCH(1) 模型），vol='ARCH'（ARCH 模型）
am = arch_model(A, vol='ARCH', p=1)
# 拟合模型，设置 update_freq=0 和 disp='off' 以关闭输出
res = am.fit(update_freq=0, disp='off')
# 获取拟合参数
params_dict = dict(res.params)
# 创建一个新的字典，用于存储重命名后的参数
renamed_params_dict = {}
# 遍历原始字典，将键重命名为更具描述性的中文名称
for key, value in params_dict.items():
if key == 'mu':
renamed_params_dict['均值'] = value
elif key == 'omega':
renamed_params_dict['方差偏移'] = value
elif key == 'alpha[1]':
renamed_params_dict['方差系数'] = value
else:
renamed_params_dict[key] = value
return renamed_params_dict
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于演示 archfit_regression_expression 函数的使用。
"""
# 示范代码
input_examples = [
"[[1, 2, 3, 4, 5]]", # 时间序列数据
"[[0.1, 0.2, 0.3, 0.4, 0.5]]", # 时间序列数据
"invalid_input", # 无效输入
]
for input_str in input_examples:
print(f"输入: {input_str}")
result = archfit_regression_expression(input_str)
print(f"结果: {result}")
print("-" * 40)
if __name__ == "__main__":
main()
相位角
theta = angle(z) 为复数数组z的每个元素返回区间 [-π,π] 中的相位角,theta中的角度表示为z=abs(z).*exp(i*theta)
z是标量,向量,数组或矩阵
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def angle_phase(input_str):
"""
计算复数或复数矩阵的相位角。
参数:
input_str: 输入的复数或复数矩阵的字符串表示。
返回:
如果输入是复数，返回其相位角；如果输入是复数矩阵，返回每个元素的相位角矩阵；
如果输入错误，返回错误信息。
"""
try:
# 将输入字符串转换为 SymPy 表达式
expr = sp.sympify(input_str)
error = False
result = None
# 判断输入是否为复数
if expr.is_complex:
# 如果是单个复数，计算其相位角
# 处理标量输入
z = complex(expr)
if z.real == 0 and z.imag == 0:
return 0.0 # 或np.nan，根据需求选择
return np.arctan2(z.imag, z.real)
else:
error = True
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误:{e}"
def main():
"""
主函数，用于演示 angle_phase 函数的使用。
"""
# 示范代码
# 单个复数的相位角计算
complex_number = "3+4j"
print(f"复数 {complex_number} 的相位角为: {angle_phase(complex_number)}")
# 错误输入示例
invalid_input = "1 + 2"
print(f"输入 {invalid_input} 的结果为: {angle_phase(invalid_input)}")
if __name__ == "__main__":
main()
自回归移动平均模型
Armax(data,order),其中data是输入的时间序列数据,orders是包含AR,MA和常数项阶数的向量.
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import ast
import numpy as np
import statsmodels.api as sm
def arma_regression_expression(input_str):
"""
根据输入的字符串数据拟合 ARMA 模型，并返回自回归系数、移动平均系数和常数项。
参数:
input_str: 输入的字符串，格式为 "([数据列表], (p, d, q))"，其中 p 是自回归阶数，d 是差分阶数，q 是移动平均阶数。
返回:
返回一个字符串，包含自回归系数、移动平均系数和常数项；如果出错，返回错误信息。
"""
try:
# 将输入字符串解析为 Python 对象
A = ast.literal_eval(input_str)
# 提取数据并展平为一维数组
data = np.ravel(A[0])
# 提取 ARMA 模型的阶数 (p, d, q)
order = A[1]
# 拟合 ARMA 模型
model = sm.tsa.SARIMAX(data, order=order)
result = model.fit()
# 提取并返回自回归系数、移动平均系数和常数项
return_string = (
f"自回归系数: {list(result.arparams)}, "
f"移动平均系数: {result.maparams}, "
f"常数项: {result.params[-1]}"
)
return return_string
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于演示 arma_regression_expression 函数的使用。
"""
# 示范代码
# 示例 1: 正常输入
input_str1 = "([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], (1, 0, 1))"
print(f"输入: {input_str1}")
print(f"结果: {arma_regression_expression(input_str1)}")
print()
# 示例 2: 正常输入（随机数据）
np.random.seed(0)
random_data = np.random.randn(100).tolist()
input_str2 = f"({random_data}, (2, 0, 1))"
print(f"输入: {input_str2}")
print(f"结果: {arma_regression_expression(input_str2)}")
print()
# 示例 3: 错误输入（数据格式错误）
input_str3 = "([1, 2, 3], (1, 0))" # 阶数格式错误
print(f"输入: {input_str3}")
print(f"结果: {arma_regression_expression(input_str3)}")
print()
# 示例 4: 错误输入（非数值数据）
input_str4 = "(['a', 'b', 'c'], (1, 0, 1))" # 数据格式错误
print(f"输入: {input_str4}")
print(f"结果: {arma_regression_expression(input_str4)}")
if __name__ == "__main__":
main()
反正割（以弧度为单位）
Y = asec(X) 以弧度为单位返回X各元素的反正割(sec^-1),该函数同时接受实数和复数输入
对于 X 在区间 [-∞, -1] 和 [1, ∞] 中的实数值，asec(X) 返回区间 [0, π] 中的值
对于 X 在区间 (-1, 1) 内的实数值以及 X 的复数值，asec(X) 返回复数值
X是标量,向量,数组或矩阵
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import sympy as sp
import numpy as np
def asec_inverse_sec(input_str):
"""
计算输入表达式的反正割值（arcsec）。
参数:
input_str: 输入的表达式，可以是数值、符号、矩阵或列表。
返回:
如果输入是数值或符号，返回其反正割值；
如果输入是矩阵或列表，返回每个元素的反正割值矩阵；
如果输入错误，返回错误信息。
"""
try:
# 将输入字符串转换为 SymPy 表达式
expr = sp.sympify(input_str)
error = False
result = None
# 如果输入是数值或符号表达式，计算反正割值
if expr.is_number:
z = complex(expr)
"""计算反正割函数，返回弧度值。"""
if z == 0:
result = np.inf
else:
result = np.arccos(1 / z)
elif expr.free_symbols:
result = sp.asec(expr)
else:
error = True
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于演示 asec_inverse_sec 函数的使用。
"""
# 示范代码
# 示例 1: 数值输入
input_str1 = "2"
print(f"输入: {input_str1}")
print(f"反正割值: {asec_inverse_sec(input_str1)}")
print()
# 示例 2: 符号输入
input_str2 = "x"
print(f"输入: {input_str2}")
print(f"反正割值: {asec_inverse_sec(input_str2)}")
print()
# 示例 4: 错误输入（元组）
input_str4 = "(1, 2, 3)"
print(f"输入: {input_str4}")
print(f"结果: {asec_inverse_sec(input_str4)}")
print()
# 示例 5: 错误输入（非法表达式）
input_str5 = "1 / 0"
print(f"输入: {input_str5}")
print(f"结果: {asec_inverse_sec(input_str5)}")
if __name__ == "__main__":
main()
反正割(以度为单位)
Y = asecd(X) 返回X的元素的反正割(sec^-1)（以度为单位）。该函数同时接受实数和复数输入
对于 X 在区间 [-∞, -1] 和 [1, ∞] 中的实数值，asecd(X) 返回区间 [0, 180] 中的值
对于 X 在区间 (-1, 1) 内的实数值以及 X 的复数值，asecd(X) 返回复数值.
X是标量,向量,数组或矩阵
# Copyright 2025 小塔立软件有限公司及其旗下网站:www.qikjik.com
# Licensed under the MIT License.
import numpy as np
import sympy as sp
def asecd_inverse_secant(input_str):
"""
计算输入表达式的反余割值（arcsec），并将结果转换为度数。
参数:
input_str: 输入的表达式，可以是数值、符号、矩阵或列表。
返回:
如果输入是数值或符号，返回其反余割值（以度数为单位）；
如果输入是矩阵或列表，返回每个元素的反余割值矩阵（以度数为单位）；
如果输入错误，返回错误信息。
"""
try:
# 将输入字符串转换为 SymPy 表达式
expr = sp.sympify(input_str)
error = False
result = None
# 如果输入是数值或符号表达式，计算反余割值
if expr.free_symbols:
result = sp.deg(sp.asec(expr))
elif expr.is_number:
z = complex(expr)
if z == 0:
return np.inf
else:
result = np.arccos(1 / z)*180/np.pi
else:
error = True
return result if not error else f"输入错误: {input_str}"
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于演示 asecd_inverse_secant 函数的使用。
"""
# 示范代码
# 示例 1: 数值输入
input_str1 = "1+1