反正弦(以弧度为单位)
Y = asin(X) 以弧度为单位返回 X 各元素的 反正弦 (sin^-1)。该函数同时接受实数和复数输入
对于 X 在区间 [-1, 1] 内的实数值，asin(X) 返回区间 [-π/2, π/2] 内的值
对于 X 在区间 [-1, 1] 之外的实数值以及 X 的复数值，asin(X) 返回复数值
X是标量,向量,数组或矩阵
import sympy as sp
def is_matrix(expr):
"""
判断输入是否为矩阵或可以转换为矩阵的形式。
参数:
expr: 输入的表达式，可以是 SymPy 矩阵、列表或其他类型。
返回:
如果输入是矩阵或可以转换为矩阵，则返回 SymPy 矩阵对象；否则返回 None。
"""
try:
result = None
# 如果输入已经是 SymPy 的 MutableDenseMatrix 类型，直接返回
if isinstance(expr, sp.MutableDenseMatrix):
result = expr
# 如果输入是列表，尝试将其转换为 SymPy 矩阵
elif isinstance(expr, list):
result = sp.Matrix(expr)
else:
pass
return result
except Exception as e:
print(f"{e}")
return None
def asin_inverse_sine(input_str):
"""
计算输入表达式的反正弦值（arcsin），结果以弧度为单位。
参数:
input_str: 输入的表达式，可以是数值、符号、矩阵或列表。
返回:
如果输入是数值或符号，返回其反正弦值（以弧度为单位）；
如果输入是矩阵或列表，返回每个元素的反正弦值矩阵（以弧度为单位）；
如果输入错误，返回错误信息。
"""
try:
# 将输入字符串转换为 SymPy 表达式
expr = sp.sympify(input_str)
error = False
result = None
# 如果输入是元组，标记为错误
if isinstance(expr, tuple):
error = True
# 如果输入是矩阵，对每个元素计算反正弦值
elif (sp_matrix := is_matrix(expr)) is not None:
result = sp_matrix.applyfunc(sp.asin).evalf()
# 如果输入是数值或符号表达式，计算反正弦值
elif expr.is_number or expr.free_symbols:
result = sp.asin(expr).evalf()
else:
error = True
if error:
return f"输入错误: {input_str}"
else:
return result
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于演示 asin_inverse_sine 函数的使用。
"""
# 示范代码
# 示例 1: 数值输入
input_str1 = "0.5"
print(f"输入: {input_str1}")
print(f"反正弦值（弧度）: {asin_inverse_sine(input_str1)}")
print()
# 示例 2: 符号输入
input_str2 = "x"
print(f"输入: {input_str2}")
print(f"反正弦值（弧度）: {asin_inverse_sine(input_str2)}")
print()
# 示例 3: 矩阵输入
input_str3 = "[[0.1, 0.2], [0.3, 0.4]]"
print(f"输入: {input_str3}")
print(f"反正弦值矩阵（弧度）: {asin_inverse_sine(input_str3)}")
print()
# 示例 4: 错误输入（元组）
input_str4 = "(1, 2, 3)"
print(f"输入: {input_str4}")
print(f"结果: {asin_inverse_sine(input_str4)}")
print()
# 示例 5: 错误输入（非法表达式）
input_str5 = "1 / 0"
print(f"输入: {input_str5}")
print(f"结果: {asin_inverse_sine(input_str5)}")
if __name__ == "__main__":
main()
反正弦(以度为单位)
Y = asind(X) 以度为单位返回 X 各元素的 反正弦 (sin^-1)。该函数同时接受实数和复数输入
对于 X 在区间 [-1, 1] 内的实数值，asind(X) 返回区间 [-90, 90] 内的值
对于 X 在区间 [-1, 1] 之外的实数值以及 X 的复数值，asind(X) 返回复数值
X是标量,向量,数组或矩阵
import sympy as sp
def is_matrix(expr):
"""
判断输入是否为矩阵或可以转换为矩阵的形式。
参数:
expr: 输入的表达式，可以是 SymPy 矩阵、列表或其他类型。
返回:
如果输入是矩阵或可以转换为矩阵，则返回 SymPy 矩阵对象；否则返回 None。
"""
try:
result = None
# 如果输入已经是 SymPy 的 MutableDenseMatrix 类型，直接返回
if isinstance(expr, sp.MutableDenseMatrix):
result = expr
# 如果输入是列表，尝试将其转换为 SymPy 矩阵
elif isinstance(expr, list):
result = sp.Matrix(expr)
else:
pass
return result
except Exception as e:
print(f"{e}")
return None
def asind_inverse_sine(input_str):
"""
计算反正弦函数的值，并将结果转换为度数。
参数:
input_str: 输入的字符串，可以是数字、符号表达式、矩阵或列表。
返回:
如果输入有效，返回计算结果；否则返回错误信息。
"""
try:
expr = sp.sympify(input_str)
error = False
result = None
def evaluate_asind_function(z):
"""
计算单个值的反正弦函数，并将结果转换为度数。
参数:
z: 输入的 SymPy 表达式。
返回:
如果 z 是数字，返回计算结果的浮点值；如果 z 包含符号，返回符号表达式；否则返回 None。
"""
if z.is_number:
return sp.deg(sp.asin(z)).evalf()
elif z.free_symbols:
return sp.deg(sp.asin(z))
else:
return None
# 如果输入是元组，标记为错误
if isinstance(expr, tuple):
error = True
# 如果输入是矩阵，对矩阵中的每个元素应用 evaluate_asind_function
elif (sp_matrix := is_matrix(expr)) is not None:
result = sp_matrix.applyfunc(lambda x: evaluate_asind_function(x))
# 如果输入是数字或包含符号，直接计算
elif expr.is_number or expr.free_symbols:
result = evaluate_asind_function(expr)
else:
error = True
if error:
return f"输入错误: {input_str}"
else:
return result
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于演示 asind_inverse_sine 函数的使用。
"""
# 示范代码
input_examples = [
"0.5", # 数字输入
"sqrt(2)/2", # 符号表达式输入
"[[1/2, sqrt(3)/2], [0, 1]]", # 矩阵输入
"invalid_input" # 无效输入
]
for input_str in input_examples:
print(f"输入: {input_str}")
result = asind_inverse_sine(input_str)
print(f"结果: {result}\n")
if __name__ == "__main__":
main()
反双曲正弦
Y = asinh(X) 返回X的元素的反双曲正弦.该函数同时接受实数和复数输入.所有的角度都以弧度表示
X是标量,向量,数组或矩阵
import sympy as sp
def is_matrix(expr):
"""
判断输入是否为矩阵或可以转换为矩阵的形式。
参数:
expr: 输入的表达式，可以是 SymPy 矩阵、列表或其他类型。
返回:
如果输入是矩阵或可以转换为矩阵，则返回 SymPy 矩阵对象；否则返回 None。
"""
try:
result = None
# 如果输入已经是 SymPy 的 MutableDenseMatrix 类型，直接返回
if isinstance(expr, sp.MutableDenseMatrix):
result = expr
# 如果输入是列表，尝试将其转换为 SymPy 矩阵
elif isinstance(expr, list):
result = sp.Matrix(expr)
else:
pass
return result
except Exception as e:
print(f"{e}")
return None
def asinh_inverse_hyperbolic_sine(input_str):
"""
计算反双曲正弦函数的值。
参数:
input_str: 输入的字符串，可以是数字、符号表达式、矩阵或列表。
返回:
如果输入有效，返回计算结果；否则返回错误信息。
"""
try:
expr = sp.sympify(input_str)
error = False
result = None
# 如果输入是元组，标记为错误
if isinstance(expr, tuple):
error = True
# 如果输入是矩阵，对矩阵中的每个元素应用反双曲正弦函数
elif (sp_matrix := is_matrix(expr)) is not None:
result = sp_matrix.applyfunc(sp.asinh).evalf()
# 如果输入是数字或包含符号，直接计算反双曲正弦函数
elif expr.is_number or expr.free_symbols:
result = sp.asinh(expr).evalf()
else:
error = True
if error:
return f"输入错误: {input_str}"
else:
return result
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于演示 asinh_inverse_hyperbolic_sine 函数的使用。
"""
# 示范代码
input_examples = [
"0.5", # 数字输入
"1", # 数字输入
"[[1, 2], [3, 4]]", # 矩阵输入
"x", # 符号表达式输入
"invalid_input" # 无效输入
]
for input_str in input_examples:
print(f"输入: {input_str}")
result = asinh_inverse_hyperbolic_sine(input_str)
print(f"结果: {result}\n")
if __name__ == "__main__":
main()
反正切(以弧度为单位)
Y = atan(X) 以弧度为单位返回X各元素的反正切 (tan^-1). 该函数同时接受实数和复数输入.
对于X的实数值,atan(X)返回区间 [-π/2, π/2] 中的值.
对于X的复数值,atan(X)返回复数值.
X -- 角正切,标量,向量,数组或矩阵
import sympy as sp
def is_matrix(expr):
"""
判断输入是否为矩阵或可以转换为矩阵的形式。
参数:
expr: 输入的表达式，可以是 SymPy 矩阵、列表或其他类型。
返回:
如果输入是矩阵或可以转换为矩阵，则返回 SymPy 矩阵对象；否则返回 None。
"""
try:
result = None
# 如果输入已经是 SymPy 的 MutableDenseMatrix 类型，直接返回
if isinstance(expr, sp.MutableDenseMatrix):
result = expr
# 如果输入是列表，尝试将其转换为 SymPy 矩阵
elif isinstance(expr, list):
result = sp.Matrix(expr)
else:
pass
return result
except Exception as e:
print(f"{e}")
return None
def atan_inverse_tangent(input_str):
"""
计算反正切函数的值。
参数:
input_str: 输入的字符串，可以是数字、符号表达式、矩阵或列表。
返回:
如果输入有效，返回计算结果；否则返回错误信息。
"""
try:
expr = sp.sympify(input_str)
error = False
result = None
# 如果输入是元组，标记为错误
if isinstance(expr, tuple):
error = True
# 如果输入是矩阵，对矩阵中的每个元素应用反正切函数
elif (sp_matrix := is_matrix(expr)) is not None:
result = sp_matrix.applyfunc(sp.atan).evalf()
# 如果输入是数字或包含符号，直接计算反正切函数
elif expr.is_number or expr.free_symbols:
result = sp.atan(expr).evalf()
else:
error = True
if error:
return f"输入错误: {input_str}"
else:
return result
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于演示 atan_inverse_tangent 函数的使用。
"""
# 示范代码
input_examples = [
"1", # 数字输入
"sqrt(3)", # 符号表达式输入
"[[1, 0], [0, 1]]", # 矩阵输入
"x", # 符号变量输入
"invalid_input" # 无效输入
]
for input_str in input_examples:
print(f"输入: {input_str}")
result = atan_inverse_tangent(input_str)
print(f"结果: {result}\n")
if __name__ == "__main__":
main()
反正切(以度为单位)
Y = atand(X) 返回 X 的元素的反正切 (tan-1)（以度为单位）.该函数同时接受实数和复数输入.
对于X的实数值,atand(X)返回区间 [-90, 90] 中的值。
对于X的复数值,atand(X)返回复数值.
X -- 角正切,标量,向量,数组或矩阵
Y — 输出,以度为单位的角, 标量值,向量,矩阵
import sympy as sp
def is_matrix(expr):
"""
判断输入是否为矩阵或可以转换为矩阵的形式。
参数:
expr: 输入的表达式，可以是 SymPy 矩阵、列表或其他类型。
返回:
如果输入是矩阵或可以转换为矩阵，则返回 SymPy 矩阵对象；否则返回 None。
"""
try:
result = None
# 如果输入已经是 SymPy 的 MutableDenseMatrix 类型，直接返回
if isinstance(expr, sp.MutableDenseMatrix):
result = expr
# 如果输入是列表，尝试将其转换为 SymPy 矩阵
elif isinstance(expr, list):
result = sp.Matrix(expr)
else:
pass
return result
except Exception as e:
print(f"{e}")
return None
def atand_inverse_tangent(input_str):
"""
计算反正切函数的值，并将结果转换为度数。
参数:
input_str: 输入的字符串，可以是数字、符号表达式、矩阵或列表。
返回:
如果输入有效，返回计算结果；否则返回错误信息。
"""
try:
expr = sp.sympify(input_str)
error = False
result = None
def evaluate_atand_function(z):
"""
计算单个值的反正切函数，并将结果转换为度数。
参数:
z: 输入的 SymPy 表达式。
返回:
如果 z 是数字，返回计算结果的浮点值；如果 z 包含符号，返回符号表达式；否则返回 None。
"""
if z.is_number:
return sp.deg(sp.atan(z)).evalf()
elif z.free_symbols:
return sp.deg(sp.atan(z))
else:
return None
# 如果输入是元组，标记为错误
if isinstance(expr, tuple):
error = True
# 如果输入是矩阵，对矩阵中的每个元素应用 evaluate_atand_function
elif (sp_matrix := is_matrix(expr)) is not None:
result = sp_matrix.applyfunc(lambda x: evaluate_atand_function(x))
# 如果输入是数字或包含符号，直接计算
elif expr.is_number or expr.free_symbols:
result = evaluate_atand_function(expr)
else:
error = True
if error:
return f"输入错误: {input_str}"
else:
return result
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于演示 atand_inverse_tangent 函数的使用。
"""
# 示范代码
input_examples = [
"1", # 数字输入
"sqrt(3)", # 符号表达式输入
"[[1, 0], [0, 1]]", # 矩阵输入
"x", # 符号变量输入
"invalid_input" # 无效输入
]
for input_str in input_examples:
print(f"输入: {input_str}")
result = atand_inverse_tangent(input_str)
print(f"结果: {result}\n")
if __name__ == "__main__":
main()
反双曲正切
Y = atanh(X)返回X的元素的反双曲正切.该函数同时接受实数和复数输入.所有的角度都以弧度表示.
X -- 角的双曲正切,标量,向量,数组或矩阵
import sympy as sp
def is_matrix(expr):
"""
判断输入是否为矩阵或可以转换为矩阵的形式。
参数:
expr: 输入的表达式，可以是 SymPy 矩阵、列表或其他类型。
返回:
如果输入是矩阵或可以转换为矩阵，则返回 SymPy 矩阵对象；否则返回 None。
"""
try:
result = None
# 如果输入已经是 SymPy 的 MutableDenseMatrix 类型，直接返回
if isinstance(expr, sp.MutableDenseMatrix):
result = expr
# 如果输入是列表，尝试将其转换为 SymPy 矩阵
elif isinstance(expr, list):
result = sp.Matrix(expr)
else:
pass
return result
except Exception as e:
print(f"{e}")
return None
def atanh_inverse_hyperbolic_tangent(input_str):
"""
计算反双曲正切函数的值。
参数:
input_str: 输入的字符串，可以是数字、符号表达式、矩阵或列表。
返回:
如果输入有效，返回计算结果；否则返回错误信息。
"""
try:
expr = sp.sympify(input_str)
error = False
result = None
# 如果输入是元组，标记为错误
if isinstance(expr, tuple):
error = True
# 如果输入是矩阵，对矩阵中的每个元素应用反双曲正切函数
elif (sp_matrix := is_matrix(expr)) is not None:
result = sp_matrix.applyfunc(sp.atanh).evalf()
# 如果输入是数字或包含符号，直接计算反双曲正切函数
elif expr.is_number or expr.free_symbols:
result = sp.atanh(expr).evalf()
else:
error = True
if error:
return f"输入错误: {input_str}"
else:
return result
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于演示 atanh_inverse_hyperbolic_tangent 函数的使用。
"""
# 示范代码
input_examples = [
"0.5", # 数字输入
"0", # 数字输入
"[[0.1, 0.2], [0.3, 0.4]]", # 矩阵输入
"x", # 符号表达式输入
"invalid_input" # 无效输入
]
for input_str in input_examples:
print(f"输入: {input_str}")
result = atanh_inverse_hyperbolic_tangent(input_str)
print(f"结果: {result}\n")
if __name__ == "__main__":
main()
四象限反正切
P = atanTwo(Y,X) 返回Y和X的四象限反正切(tan^-1),该值必须为实数. atanTwo函数遵循当x在数学上为零(或者为0或-0)时atanTwo(x,x)返回0的约定.
X -- x坐标,标量,向量,矩阵
Y -- y坐标,标量,向量,矩阵
import sympy as sp
def is_matrix(expr):
"""
判断输入是否为矩阵或可以转换为矩阵的形式。
参数:
expr: 输入的表达式，可以是 SymPy 矩阵、列表或其他类型。
返回:
如果输入是矩阵或可以转换为矩阵，则返回 SymPy 矩阵对象；否则返回 None。
"""
try:
result = None
# 如果输入已经是 SymPy 的 MutableDenseMatrix 类型，直接返回
if isinstance(expr, sp.MutableDenseMatrix):
result = expr
# 如果输入是列表，尝试将其转换为 SymPy 矩阵
elif isinstance(expr, list):
result = sp.Matrix(expr)
else:
pass
return result
except Exception as e:
print(f"{e}")
return None
def atan2_inverse_tangent(input_str):
"""
计算 atan2 函数的值，用于计算两个数的四象限反正切值。
参数:
input_str: 输入的字符串，可以是元组（包含两个数字、符号表达式或矩阵）。
返回:
如果输入有效，返回计算结果；否则返回错误信息。
"""
try:
expr = sp.sympify(input_str)
error = False
result = None
# 检查输入是否为元组且长度为 2
if isinstance(expr, tuple) and len(expr) == 2:
n = expr[0] # 第一个输入
x = expr[1] # 第二个输入
# 检查是否为矩阵
N = is_matrix(n)
X = is_matrix(x)
# 获取矩阵的形状
N_shape = N.shape if N is not None else None
X_shape = X.shape if X is not None else None
# 确定返回结果的形状
result_shape = None
if N is not None:
result_shape = N_shape
elif X is not None:
result_shape = X_shape
# 检查是否有两个矩阵且形状不同
if N is not None and X is not None and N_shape != X_shape:
error = True
# 计算结果
if result_shape:
# 如果输入是矩阵，逐元素计算 atan2
result = sp.Matrix(result_shape[0], result_shape[1], lambda i, j: sp.atan2(
N[i, j] if N is not None else n,
X[i, j] if X is not None else x
).evalf())
else:
# 如果输入是数字或符号表达式，直接计算 atan2
result = sp.atan2(n, x).evalf()
else:
error = True
if error:
return f"输入错误: {input_str}"
else:
return result
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于演示 atan2_inverse_tangent 函数的使用。
"""
# 示范代码
input_examples = [
"(1, 1)", # 数字输入
"(0, 1)", # 数字输入
"([[1, 2], [3, 4]], [[1, 0], [0, 1]])", # 矩阵输入
"(x, y)", # 符号表达式输入
"invalid_input" # 无效输入
]
for input_str in input_examples:
print(f"输入: {input_str}")
result = atan2_inverse_tangent(input_str)
print(f"结果: {result}\n")
if __name__ == "__main__":
main()
四象限反正切(以度为单位)
D = atanTwoD(Y,X) 返回Y和X的四象限反正切(tan^-1),该值必须为实数.结果D用度表示.
X -- x坐标,标量,向量,矩阵
Y -- y坐标,标量,向量,矩阵
import sympy as sp
def is_matrix(expr):
"""
判断输入是否为矩阵或可以转换为矩阵的形式。
参数:
expr: 输入的表达式，可以是 SymPy 矩阵、列表或其他类型。
返回:
如果输入是矩阵或可以转换为矩阵，则返回 SymPy 矩阵对象；否则返回 None。
"""
try:
result = None
# 如果输入已经是 SymPy 的 MutableDenseMatrix 类型，直接返回
if isinstance(expr, sp.MutableDenseMatrix):
result = expr
# 如果输入是列表，尝试将其转换为 SymPy 矩阵
elif isinstance(expr, list):
result = sp.Matrix(expr)
else:
pass
return result
except Exception as e:
print(f"{e}")
return None
def atan2d_inverse_tangent(input_str):
"""
计算 atan2 函数的值，并将结果转换为度数。
参数:
input_str: 输入的字符串，可以是元组（包含两个数字、符号表达式或矩阵）。
返回:
如果输入有效，返回计算结果；否则返回错误信息。
"""
try:
expr = sp.sympify(input_str)
error = False
result = None
def evaluate_atan2d_function(x, y):
"""
计算 atan2 函数的值，并将结果转换为度数。
参数:
x: 第一个输入，可以是数字或符号表达式。
y: 第二个输入，可以是数字或符号表达式。
返回:
如果 x 和 y 是数字，返回计算结果的浮点值；如果包含符号，返回符号表达式；否则返回 None。
"""
if x.is_number and y.is_number:
return sp.deg(sp.atan2(x, y)).evalf()
elif x.free_symbols or y.free_symbols:
return sp.deg(sp.atan2(x, y))
else:
return None
# 检查输入是否为元组且长度为 2
if isinstance(expr, tuple) and len(expr) == 2:
n = expr[0] # 第一个输入
x = expr[1] # 第二个输入
# 检查是否为矩阵
N = is_matrix(n)
X = is_matrix(x)
# 获取矩阵的形状
N_shape = N.shape if N is not None else None
X_shape = X.shape if X is not None else None
# 确定返回结果的形状
result_shape = None
if N is not None:
result_shape = N_shape
elif X is not None:
result_shape = X_shape
# 检查是否有两个矩阵且形状不同
if N is not None and X is not None and N_shape != X_shape:
error = True
# 计算结果
if result_shape:
# 如果输入是矩阵，逐元素计算 atan2d
result = sp.Matrix(result_shape[0], result_shape[1], lambda i, j: evaluate_atan2d_function(
N[i, j] if N is not None else n,
X[i, j] if X is not None else x
))
else:
# 如果输入是数字或符号表达式，直接计算 atan2d
result = evaluate_atan2d_function(n, x)
else:
error = True
if error:
return f"输入错误: {input_str}"
else:
return result
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于演示 atan2d_inverse_tangent 函数的使用。
"""
# 示范代码
input_examples = [
"(1, 1)", # 数字输入
"(0, 1)", # 数字输入
"([[1, 2], [3, 4]], [[1, 0], [0, 1]])", # 矩阵输入
"(x, y)", # 符号表达式输入
"invalid_input" # 无效输入
]
for input_str in input_examples:
print(f"输入: {input_str}")
result = atan2d_inverse_tangent(input_str)
print(f"结果: {result}\n")
if __name__ == "__main__":
main()
给定时间序列（向量）y，返回一个矩阵，其中第一列为1，其他列为y的前k个滞后值
换句话说，对于t>k，[1，y（t-1），…，y（t-k）]是结果的第t行.
所得到的矩阵可以用作自回归中的回归矩阵.
import sympy as sp
import numpy as np
def is_matrix(expr):
"""
判断输入是否为矩阵或可以转换为矩阵的形式。
参数:
expr: 输入的表达式，可以是 SymPy 矩阵、列表或其他类型。
返回:
如果输入是矩阵或可以转换为矩阵，则返回 SymPy 矩阵对象；否则返回 None。
"""
try:
result = None
# 如果输入已经是 SymPy 的 MutableDenseMatrix 类型，直接返回
if isinstance(expr, sp.MutableDenseMatrix):
result = expr
# 如果输入是列表，尝试将其转换为 SymPy 矩阵
elif isinstance(expr, list):
result = sp.Matrix(expr)
else:
pass
return result
except Exception as e:
print(f"{e}")
return None
def autoreg_matrix_generation(input_str):
"""
生成自回归模型的自变量矩阵。
参数:
input_str: 输入的字符串，格式为 (矩阵, 滞后阶数 k)。
返回:
如果输入有效，返回生成的自变量矩阵（SymPy 矩阵对象）；否则返回错误信息。
"""
try:
# 将输入字符串解析为 SymPy 表达式
expr = sp.sympify(input_str)
# 检查输入是否为元组且长度为 2
if isinstance(expr, tuple) and len(expr) == 2:
# 检查第一个元素是否为矩阵
if (sp_matrix := is_matrix(expr[0])) is not None:
# 将矩阵展平为一维数组
y = np.ravel(sp_matrix)
else:
return f"输入错误: {input_str}"
# 获取滞后阶数 k
k = int(expr[1])
n = len(y)
# 检查滞后阶数 k 是否小于时间序列长度
if k >= n:
return f"滞后阶数 k 必须小于时间序列长度"
# 初始化自变量矩阵 X 和因变量向量 y_shifted
X = np.zeros((n - k, k + 1))
y_shifted = np.zeros(n - k)
# 填充自变量矩阵 X 和因变量向量 y_shifted
for i in range(k, n):
X[i - k, 0] = 1 # 常数项
for j in range(1, k + 1):
X[i - k, j] = y[i - j] # 滞后值
y_shifted[i - k] = y[i] # 因变量值
# 将自变量矩阵转换为 SymPy 矩阵
A = sp.Matrix(X)
return A
else:
return f"输入错误: {input_str}"
except Exception as e:
return f"错误: {e}"
def main():
"""
主函数，用于演示 autoreg_matrix_generation 函数的使用。
"""
# 示范代码
input_examples = [
"([[1, 2, 3, 4, 5]], 2)", # 矩阵输入，滞后阶数 2
"([[1, 2, 3]], 1)", # 矩阵输入，滞后阶数 1
"([[1, 2, 3, 4]], 4)", # 滞后阶数等于时间序列长度（错误）
"([[1, 2, 3]], 0)", # 滞后阶数为 0（错误）
"invalid_input" # 无效输入
]
for input_str in input_examples:
print(f"输入: {input_str}")
result = autoreg_matrix_generation(input_str)
print(f"结果: {result}\n")
if __name__ == "__main__":
main()