首页 函数目录

    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