Python实现科学计算器(二)-使用示例

[TOC]

GitHub:https://github.com/asd123pwj/Calculator
blog:https://mwhls.top/calculator

零、项目介绍

一、使用示例

1. 终端交互

1.命令行启动
>>> python main.py     # 启动
2.startup.bat启动,在Windows下使用
3.startup.sh启动,在linux下使用(未测试)

系统初始化...
输入显示精度、计算精度、最大计算循环次数   # 推荐直接回车,使用默认参数
...

选择模式:0.帮助 1.测试基本运算符示例 2.测试混合运算符示例 3.输入公式计算 4.对文件内公式计算
>>> 0            # 选择模式0:查看帮助
查看哪个模块的说明:1.系统类 2.计算器类 3.栈 4.检查类 5.数学计算类
...

选择模式:0.帮助 1.测试基本运算符示例 2.测试混合运算符示例 3.输入公式计算 4.对文件内公式计算
>>> 1            # 选择模式1:测试基本运算符示例
将给出44组约600个测试示例,包括正确示例与错误示例,
  其中,正确示例指的是理论上的正确公式,在默认参数下有十六个示例与理论值有差,有三个原因造成:
    1.计算精度不够,需要设置更高的最大计算循环次数,或降低显示精度。
    2.功能缺失,如atan,暂时只支持[-1, 1]的输入
    3.python的函数有误,如round(0.5)==0而不是1。 见https://stackoverflow.com/questions/20048986/python-3-3-2-do-i-get-the-right-understanding-of-the-function-round/20049872#20049872 
  错误示例有以下几类:
    1.缺失运算符,如"1 1",两数间没有运算符
    2.不合理的运算方式,如"1/0",除数不能为0,"(-1)!",负数无法阶乘
    3.不合理的输入,如"sinnn",不存在的运算符
...

选择模式:0.帮助 1.测试基本运算符示例 2.测试混合运算符示例 3.输入公式计算 4.对文件内公式计算
>>> 2            # 选择模式2:测试混合运算符示例       
在实现中,运算符被分成了五类:                       
  1.双目运算符:左右都需要操作数才能正常运算,如乘号            
  2.单目运算符:对右侧操作数进行运算,如三角函数                
  3.加减与正负:作为加减时,是双目运算符,作为正负时,是单目运算符     
  4.阶乘运算符:对左侧操作数进行运算,也是单目运算,因运算方式不同单独列出 
  5.括号   :用于算式可读性,与运算先后性                
在混合运算符测试中,以五类运算符为单位测试,而非以某个运算符为单位测试  
...

选择模式:0.帮助 1.测试基本运算符示例 2.测试混合运算符示例 3.输入公式计算 4.对文件内公式计算
>>> 3             # 选择模式3:输入公式进行计算
>>> 1+1           # 只输入算式
>>> 1+1, 2        # 输入算式与理论值,用逗号隔开
>>> 1+1, 1+1      # 输入算式与python表达式,用逗号隔开,其中,python表达式使用eval("1+1")计算
>>> 1   +   1, 2  # 输入算式与理论值,用逗号隔开,算式内用空格隔开提高可读性
>>> 1   +   1     # 只输入算式,算式内用空格隔开提高可读性
>>>               # 直接回车,计算前面的输入的公式
   测试开始,对5个算式进行运算
1: Done: "1+1", 运算结果 = 2.0
2: 正 确: "1+1", 运算结果 = 2.0, 理论值 = 2
3: 正 确: "1+1", 运算结果 = 2.0, 理论值 = 2
4: 正 确: "1  +  1", 运算结果 = 2.0, 理论值 = 2
5: Done: "1  +  1", 运算结果 = 2.0
   测试结束,耗时:2毫秒
...

选择模式:0.帮助 1.测试基本运算符示例 2.测试混合运算符示例 3.输入公式计算 4.对文件内公式计算
>>> 4             # 选择模式4:对外部文件内的公式进行计算 
输入文件路径
>>>               # 直接回车,默认测试当前目录下的formulas_sample.txt文件
文件内容:
1+1
1+1, 2
1 + 1, 2
1+1, 1+1
   测试开始,对4个算式进行运算
1: Done: "1+1", 运算结果 = 2.0
2: 正 确: "1+1", 运算结果 = 2.0, 理论值 = 2
3: 正 确: "1 + 1", 运算结果 = 2.0, 理论值 = 2
4: 正 确: "1+1", 运算结果 = 2.0, 理论值 = 2
   测试结束,耗时:3毫秒

2. 外部调用

from math_class import math # 引用

m = math()                  # 实例化
y = m.sin(m.pi / 2)         # 调用sin函数
print(y)                    # 0.9999999999939766
y = m.offset2decimal(y)     # 约束至计算精度
print(y)                    # 1.0

3. 文件计算

  • formulas_sample.txt内容

    1+1
    1+1, 2
    1 + 1, 2
    1+1, 1+1
  • 调用方式

    from system_class import system               # 引用
    
    sys = system()                                # 实例化
    sys.calculate_file("./formulas_sample.txt")   # 计算当前目录的txt文件

二、测试样例

1. 简单运算符测试 – 测试语句

["---------------------------    基本运算符测试    ---------------------------"],
["       注:将给出44组约600个测试示例,包括正确示例与错误示例              "],
["         其中,正确示例指的是理论上的正确公式,在默认参数下有十六个示例与理论值有差:"],
["           1.计算精度不够,需要设置更高的最大计算循环次数,或降低显示精度。     "],
["           2.功能缺失,如atan,暂时只支持[-1, 1]的输入                 "],
["           3.python的函数有误,如round(0.5)==0而不是1。                      "],
["             见:https://stackoverflow.com/questions/20048986/python-3-3-2-do-i-get-the-right-understanding-of-the-function-round/20049872#20049872 "],
["         错误示例有以下三类:                                                "],
["           1.缺失运算符,如'1 1',两数间没有运算符                            "],
["           2.不合理的运算方式,如'1/0',除数不能为0,'(-1)!',负数无法阶乘      "],
["           3.不合理的输入,如'sinnn',不存在的运算符                          "],
["----------------------------------------------------------------------------------"],
["               1.1 正确的数与括号           "],
["    注:为了可读性,算式前后 与 运算符中间 会有若干个空格填充  "],
["                       1                   ", 1],
["                      100                  ", 100],
["                     (   )                 ", 0],
["                 (( ((   )) ))             ", 0],
["                 [( [(   )] )]             ", 0],
["                     ( 1 )                 ", 1],
["                    ( 100 )                ", 100],
["               1.2 错误的数与括号            "],
["    注:为了方便核对错误位置,错误的算式会放在开头  "],
["1 1                                        "],
["(                                          "],
[")                                          "],
["(()                                        "],
["())                                        "],
["(1(1))                                     "],
["([(]))                                     "],
["----------------------------------------------------------------------------------"],
["              2.1 正确的加法与正号          "],
["            注:连续的+-被视作正负号        "],
["                    1 + 2                  ", 1+2],
["                10000 + 20000              ", 10000+20000],
["                 9999 +     1              ", 9999+1],
["                      +1                   ", 1],
["                  +   +   1                ", 1],
["                      +  001               ", 1],
["              2.2 错误的加法与正号          "],
["+                                          "],
["1+                                         "],
["+1+                                        "],
["----------------------------------------------------------------------------------"],
["              3.1 正确的减法与负号            "],
["                  1 - 2                    ", 1-2],
["                  2 - 1                    ", 2-1],
["                 -1 - 1                    ", -1-1],
["                - 1 - - 1                  ", -1--1],
["                 -1                        ", -1],
["                - 10                       ", -10],
["              3.2 错误的减法与负号          "],
["-                                          "],
["1-                                         "],
["-1-                                        "],
["----------------------------------------------------------------------------------"],
["              4.1 正确的乘法                "],
["                  1 * 2                    ", 1*2],
["                  2 * 1                    ", 2*1],
["                  0 * 10                   ", 0*10],
["              4.2 错误的乘法                "],
["*                                          "],
["1*                                         "],
["*1                                         "],
["----------------------------------------------------------------------------------"],
["              5.1 正确的除法               "],
["                  1 / 2                    ", 1/2],
["                  2 / 1                    ", 2/1],
["                  0 / 1                    ", 0/1],
["              5.2 错误的除法                "],
["/                                          "],
["1/                                         "],
["/1                                         "],
["1/0                                        "],
["----------------------------------------------------------------------------------"],
["              6.1 正确的取余                "],
["                  1 % 2                    ", 1%2],
["                  2 % 1                    ", 2%1],
["                  0 % 1                    ", 0%1],
["              6.2 错误的取余                "],
["%                                          "],
["1%                                         "],
["%1                                         "],
["1%0                                        "],
["----------------------------------------------------------------------------------"],
["              7.1 正确的取绝对值            "],
["   注:如abs等单目运算符后跟+-时,+-被认为是正负号 "],
["                 abs 1                     ", abs(1)],
["                 abs-1                     ", abs(-1)],
["                 abs+1                     ", abs(1)],
["            7.2 错误的取绝对值              "],
["abs                                        "],
["2abs                                       "],
["----------------------------------------------------------------------------------"],
["            8.1 正确的向上取整              "],
["                ceil(11.0)                 ", math_py.ceil(11.0)],
["                ceil 0.5                   ", math_py.ceil(0.5)],
["                ceil 0                     ", math_py.ceil(0)],
["                ceil -0.6                  ", math_py.ceil(-0.6)],
["                ceil-1                     ", math_py.ceil(-1)],
["            8.2 错误的向上取整              "],
["ceil                                       "],
["2ceil                                      "],
["----------------------------------------------------------------------------------"],
["           9.1 正确的向下取整               "],
["               floor(11.0)                 ", math_py.floor(11.0)],
["               floor 0.5                   ", math_py.floor(0.5)],
["               floor 0                     ", math_py.floor(0)],
["               floor -0.6                  ", math_py.floor(-0.6)],
["               floor-1                     ", math_py.floor(-1)],
["           9.2 错误的向下取整               "],
["floor                                      "],
["2floor                                     "],
["----------------------------------------------------------------------------------"],
["           10.1 正确的四舍五入              "],
["           注:在round 0.5的示例中,python的round(0.5)确实是0,不是代码打错了       "],
["                round(11.0)                ", round(11.0)],
["                round 0.5                  ", round(0.5)],
["                round 0                    ", round(0)],
["                round -0.6                 ", round(-0.6)],
["                round-1                    ", round(-1)],
["           10.2 错误的四舍五入              "],
["round                                      "],
["2round                                     "],
["----------------------------------------------------------------------------------"],
["           11.1 正确的阶乘运算              "],
["                3!                         ", math_py.factorial(3)],
["                3 !                        ", math_py.factorial(3)],
["              -(3!)                        ", -math_py.factorial(3)],
["           11.2 错误的阶乘运算              "],
["!                                          "],
["!3                                         "],
["(-3)!                                      "],
["-3 !                                       "],
["----------------------------------------------------------------------------------"],
["          12.1 正确的指数'^'运算            "],
["               2 ^ 32                      ", 2 ** 32],
["               2 ^ 16                      ", 2 ** 16],
["               2 ^ 8                       ", 2 ** 8],
["               2 ^ 4                       ", 2 ** 4],
["               2 ^ 2                       ", 2 ** 2],
["               2 ^ 1                       ", 2 ** 1],
["               2 ^ 0                       ", 2 ** 0],
["               2 ^ 0.5                     ", 2 ** 0.5],
["               2 ^ 0.1                     ", 2 ** 0.1],
["               2 ^ 0.01                    ", 2 ** 0.01],
["               2 ^ 0.001                   ", 2 ** 0.001],
["               2 ^ 0.0001                  ", 2 ** 0.0001],
["               2 ^ 0.00001                 ", 2 ** 0.00001],
["               2 ^ -1                      ", 2 ** -1],
["               2 ^ -2                      ", 2 ** -2],
["               2 ^ -4                      ", 2 ** -4],
["          12.2 错误的指数'^'运算            "],
["^                                          "],
["2^                                         "],
["^2                                         "],
["----------------------------------------------------------------------------------"],
["          13.1 正确的指数'exp'运算          "],
["               exp10                       ", math_py.exp(10)],
["               exp5                        ", math_py.exp(5)],
["               exp2                        ", math_py.exp(2)],
["               exp1                        ", math_py.exp(1)],
["               exp0.1                      ", math_py.exp(0.1)],
["               exp0.01                     ", math_py.exp(0.01)],
["               exp0.001                    ", math_py.exp(0.001)],
["               exp0.0001                   ", math_py.exp(0.0001)],
["               exp0.00001                  ", math_py.exp(0.00001)],
["               exp0                        ", math_py.exp(0)],
["               exp-1                       ", math_py.exp(-1)],
["               exp-2                       ", math_py.exp(-2)],
["               exp-5                       ", math_py.exp(-5)],
["               exp-10                      ", math_py.exp(-10)],
["          13.2 错误的指数'exp'运算          "],
["exp                                        "],
["1exp                                       "],
["----------------------------------------------------------------------------------"],
["          14.1 正确的开方运算               "],
["               sqrt10000                   ", math_py.sqrt(10000)],
["               sqrt1000                    ", math_py.sqrt(1000)],
["               sqrt100                     ", math_py.sqrt(100)],
["               sqrt10                      ", math_py.sqrt(10)],
["               sqrt5                       ", math_py.sqrt(5)],
["               sqrt2                       ", math_py.sqrt(2)],
["               sqrt1                       ", math_py.sqrt(1)],
["               sqrt0                       ", math_py.sqrt(0)],
["               sqrt0.1                     ", math_py.sqrt(0.1)],
["               sqrt0.01                    ", math_py.sqrt(0.01)],
["               sqrt0.001                   ", math_py.sqrt(0.001)],
["               sqrt0.0001                  ", math_py.sqrt(0.0001)],
["          14.2 错误的开方运算               "],
["sqrt                                       "],
["1sqrt                                      "],
["sqrt-1                                     "],
["----------------------------------------------------------------------------------"],
["          15.1 正确的自然对数运算           "],
["               ln 0.00000001               ", math_py.log(0.00000001)],
["               ln 0.0000001                ", math_py.log(0.0000001)],
["               ln 0.000001                 ", math_py.log(0.000001)],
["               ln 0.00001                  ", math_py.log(0.00001)],
["               ln 0.0001                   ", math_py.log(0.0001)],
["               ln 0.001                    ", math_py.log(0.001)],
["               ln 0.01                     ", math_py.log(0.01)],
["               ln 0.1                      ", math_py.log(0.1)],
["               ln 0.5                      ", math_py.log(0.5)],
["               ln 1                        ", math_py.log(1)],
["               ln (e/2)                    ", math_py.log(math_py.e/2)],
["               ln e                        ", math_py.log(math_py.e)],
["               ln (e^2)                    ", math_py.log(math_py.e**2)],
["               ln 2                        ", math_py.log(2)],
["               ln 5                        ", math_py.log(5)],
["               ln 10                       ", math_py.log(10)],
["               ln 100                      ", math_py.log(100)],
["               ln 1000                     ", math_py.log(1000)],
["               ln 10000                    ", math_py.log(10000)],
["               ln 100000                   ", math_py.log(100000)],
["               ln 1000000                  ", math_py.log(1000000)],
["               ln 10000000                 ", math_py.log(10000000)],
["               ln 100000000                ", math_py.log(100000000)],
["          15.2 错误的自然对数运算           "],
["ln                                         "],
["2ln                                        "],
["ln0                                        "],
["ln(-1)                                     "],
["----------------------------------------------------------------------------------"],
["          16.1 正确的常用对数运算           "],
["               lg 0.00000001               ", math_py.log10(0.00000001)],
["               lg 0.0000001                ", math_py.log10(0.0000001)],
["               lg 0.000001                 ", math_py.log10(0.000001)],
["               lg 0.00001                  ", math_py.log10(0.00001)],
["               lg 0.0001                   ", math_py.log10(0.0001)],
["               lg 0.001                    ", math_py.log10(0.001)],
["               lg 0.01                     ", math_py.log10(0.01)],
["               lg 0.1                      ", math_py.log10(0.1)],
["               lg 0.5                      ", math_py.log10(0.5)],
["               lg 1                        ", math_py.log10(1)],
["               lg (e/2)                    ", math_py.log10(math_py.e/2)],
["               lg e                        ",  math_py.log10(math_py.e)],
["               lg (e^2)                    ", math_py.log10(math_py.e**2)],
["               lg 2                        ", math_py.log10(2)],
["               lg 5                        ", math_py.log10(5)],
["               lg 10                       ", math_py.log10(10)],
["               lg 100                      ", math_py.log10(100)],
["               lg 1000                     ", math_py.log10(1000)],
["               lg 10000                    ", math_py.log10(10000)],
["               lg 100000                   ", math_py.log10(100000)],
["               lg 1000000                  ", math_py.log10(1000000)],
["               lg 10000000                 ", math_py.log10(10000000)],
["               lg 100000000                ", math_py.log10(100000000)],
["          16.2 错误的常用对数运算           "],
["lg                                         "],
["2lg                                        "],
["lg0                                        "],
["lg(-1)                                     "],
["----------------------------------------------------------------------------------"],
["          17.1 正确的sin运算                "],
["               sin 0                       ", 0],
["               sin (pi / 6)                ", math_py.sin(math_py.pi / 6)],
["               sin (pi / 4)                ", math_py.sin(math_py.pi / 4)],
["               sin (pi / 3)                ", math_py.sin(math_py.pi / 3)],
["               sin (pi / 2)                ", math_py.sin(math_py.pi / 2)],
["               sin pi                      ", math_py.sin(math_py.pi)],
["               sin (3 * pi / 4)            ", math_py.sin(3 * math_py.pi / 4)],
["               sin (3 * pi / 2)            ", math_py.sin(3 * math_py.pi / 2)],
["               sin (2 * pi)                ", math_py.sin(2 * math_py.pi)],
["               sin (-pi / 6)               ", math_py.sin(-math_py.pi / 6)],
["               sin (-pi / 4)               ", math_py.sin(-math_py.pi / 4)],
["               sin (-pi / 3)               ", math_py.sin(-math_py.pi / 3)],
["               sin (-pi / 2)               ", math_py.sin(-math_py.pi / 2)],
["          17.2 错误的sin运算                "],
["sin                                        "],
["2sin                                       "],
["----------------------------------------------------------------------------------"],
["          18.1 正确的csc运算                "],
["               csc (pi / 6)                ", sympy.csc(math_py.pi / 6)],
["               csc (pi / 4)                ", sympy.csc(math_py.pi / 4)],
["               csc (pi / 3)                ", sympy.csc(math_py.pi / 3)],
["               csc (pi / 2)                ", sympy.csc(math_py.pi / 2)],
["               csc (3 * pi / 4)            ", sympy.csc(3 * math_py.pi / 4)],
["               csc (3 * pi / 2)            ", sympy.csc(3 * math_py.pi / 2)],
["               csc (-pi / 6)               ", sympy.csc(-math_py.pi / 6)],
["               csc (-pi / 4)               ", sympy.csc(-math_py.pi / 4)],
["               csc (-pi / 3)               ", sympy.csc(-math_py.pi / 3)],
["               csc (-pi / 2)               ", sympy.csc(-math_py.pi / 2)],
["          18.2 错误的csc运算                "],
["csc                                        "],
["2csc                                       "],
["csc0                                       "],
["csc pi                                     "],
["----------------------------------------------------------------------------------"],
["          19.1 正确的cos运算                "],
["               cos 0                       ", 1],
["               cos (pi / 6)                ", math_py.cos(math_py.pi / 6)],
["               cos (pi / 4)                ", math_py.cos(math_py.pi / 4)],
["               cos (pi / 3)                ", math_py.cos(math_py.pi / 3)],
["               cos (pi / 2)                ", math_py.cos(math_py.pi / 2)],
["               cos pi                      ", math_py.cos(math_py.pi)],
["               cos (3 * pi / 4)            ", math_py.cos(3 * math_py.pi / 4)],
["               cos (3 * pi / 2)            ", math_py.cos(3 * math_py.pi / 2)],
["               cos (2 * pi)                ", math_py.cos(2 * math_py.pi)],
["               cos (-pi / 6)               ", math_py.cos(-math_py.pi / 6)],
["               cos (-pi / 4)               ", math_py.cos(-math_py.pi / 4)],
["               cos (-pi / 3)               ", math_py.cos(-math_py.pi / 3)],
["               cos (-pi / 2)               ", math_py.cos(-math_py.pi / 2)],
["          19.2 错误的cos运算                "],
["cos                                        "],
["2cos                                       "],
["----------------------------------------------------------------------------------"],
["          20.1 正确的sec运算                "],
["               sec 0                       ", 1],
["               sec (pi / 6)                ", sympy.sec(math_py.pi / 6)],
["               sec (pi / 4)                ", sympy.sec(math_py.pi / 4)],
["               sec (pi / 3)                ", sympy.sec(math_py.pi / 3)],
["               sec pi                      ", sympy.sec(math_py.pi)],
["               sec (3 * pi / 4)            ", sympy.sec(3 * math_py.pi / 4)],
["               sec (2 * pi)                ", sympy.sec(2 * math_py.pi)],
["               sec (-pi / 6)               ", sympy.sec(-math_py.pi / 6)],
["               sec (-pi / 4)               ", sympy.sec(-math_py.pi / 4)],
["               sec (-pi / 3)               ", sympy.sec(-math_py.pi / 3)],
["          20.2 错误的sec运算                "],
["sec                                        "],
["2sec                                       "],
["sec (pi / 2)                               "],
["sec (3 * pi / 2)                           "],
["----------------------------------------------------------------------------------"],
["          21.1 正确的tan运算                "],
["               tan 0                       ", math_py.tan(0)],
["               tan (pi / 6)                ", math_py.tan(math_py.pi / 6)],
["               tan (pi / 4)                ", math_py.tan(math_py.pi / 4)],
["               tan (pi / 3)                ", math_py.tan(math_py.pi / 3)],
["               tan (3 * pi / 4)            ", math_py.tan(3 * math_py.pi / 4)],
["               tan (2 * pi)                ", math_py.tan(2 * math_py.pi)],
["               tan pi                      ", math_py.tan(math_py.pi)],
["               tan (-pi / 6)               ", math_py.tan(-math_py.pi / 6)],
["               tan (-pi / 4)               ", math_py.tan(-math_py.pi / 4)],
["               tan (-pi / 3)               ", math_py.tan(-math_py.pi / 3)],
["               tan (-3 * pi / 4)           ", math_py.tan(-3 * math_py.pi / 4)],
["          21.2 错误的tan运算                "],
["tan                                        "],
["2tan                                       "],
["tan (pi / 2)                               "],
["----------------------------------------------------------------------------------"],
["          22.1 正确的cot运算                "],
["               cot (pi / 6)                ", sympy.cot(math_py.pi / 6)],
["               cot (pi / 4)                ", sympy.cot(math_py.pi / 4)],
["               cot (pi / 3)                ", sympy.cot(math_py.pi / 3)],
["               cot (pi / 2)                ", sympy.cot(math_py.pi / 2)],
["               cot (3 * pi / 4)            ", sympy.cot(3 * math_py.pi / 4)],
["               cot (3 * pi / 2)            ", sympy.cot(3 * math_py.pi / 2)],
["               cot (-pi / 6)               ", sympy.cot(-math_py.pi / 6)],
["               cot (-pi / 4)               ", sympy.cot(-math_py.pi / 4)],
["               cot (-pi / 3)               ", sympy.cot(-math_py.pi / 3)],
["               cot (-3 * pi / 4)           ", sympy.cot(-3 * math_py.pi / 4)],
["          22.2 错误的cot运算                "],
["cot                                        "],
["2cot                                       "],
["cot 0                                      "],
["----------------------------------------------------------------------------------"],
["          23.1 正确的asin运算               "],
["     注:asin需要更多的计算量才能趋近于正确的值,默认最大循环次数为100。     "],
["     注:使用self.calc.math.set_max_loop(int)提高循环次数以提高精度。   "],
["                asin 0                     ", math_py.asin(0)],
["                asin 0.5                   ", math_py.asin(0.5)],
["                asin 0.866                 ", math_py.asin(0.866)],
["                asin 1                     ", math_py.asin(1)],
["                asin -0.5                  ", math_py.asin(-0.5)],
["                asin -0.866                ", math_py.asin(-0.866)],
["                asin -1                    ", math_py.asin(-1)],
["          23.2 错误的asin运算               "],
["asin                                       "],
["2asin                                      "],
["asin2                                      "],
["asin(-2)                                   "],
["----------------------------------------------------------------------------------"],
["          24.1 正确的acsc运算               "],
["     注:acsc需要更多的计算量才能趋近于正确的值,默认最大循环次数为100        "],
["     注:使用self.calc.math.set_max_loop(int)提高循环次数以提高精度。    "],
["                acsc 1                     ", sympy.acsc(1)],
["                acsc 2                     ", sympy.acsc(2)],
["                acsc 5                     ", sympy.acsc(5)],
["                acsc -5                    ", sympy.acsc(-5)],
["                acsc -2                    ", sympy.acsc(-2)],
["                acsc -1                    ", sympy.acsc(-1)],
["          24.2 错误的acsc运算               "],
["acsc                                       "],
["2acsc                                      "],
["acsc0                                      "],
["acsc0.5                                    "],
["----------------------------------------------------------------------------------"],
["          25.1 正确的acos运算               "],
["     注:acos需要更多的计算量才能趋近于正确的值,默认最大循环次数为100        "],
["     注:使用self.calc.math.set_max_loop(int)提高循环次数以提高精度。    "],
["                acos 0                     ", math_py.acos(0)],
["                acos 0.5                   ", math_py.acos(0.5)],
["                acos 0.866                 ", math_py.acos(0.866)],
["                acos 1                     ", math_py.acos(1)],
["                acos -0.5                  ", math_py.acos(-0.5)],
["                acos -0.866                ", math_py.acos(-0.866)],
["                acos -1                    ", math_py.acos(-1)],
["         25.2 错误的acos运算                "],
["acos                                       "],
["2acos                                      "],
["acos2                                      "],
["acos(-2)                                   "],
["----------------------------------------------------------------------------------"],
["          26.1 正确的asec运算               "],
["     注:asec需要更多的计算量才能趋近于正确的值,默认最大循环次数为100         "],
["     注:使用self.calc.math.set_max_loop(int)提高循环次数以提高精度。     "],
["                asec 1                     ", sympy.asec(1)],
["                asec 2                     ", sympy.asec(2)],
["                asec 5                     ", sympy.asec(5)],
["                asec -5                    ", sympy.asec(-5)],
["                asec -2                    ", sympy.asec(-2)],
["                asec -1                    ", sympy.asec(-1)],
["          26.2 错误的asec运算               "],
["asec                                       "],
["2asec                                      "],
["asec0                                      "],
["asec0.5                                    "],
["----------------------------------------------------------------------------------"],
["          27.1 正确的atan运算               "],
["     注:atan需要更多的计算量才能趋近于正确的值,默认最大循环次数为100        "],
["     注:使用self.calc.math.set_max_loop(int)提高循环次数以提高精度。    "],
["                atan 0                      ", math_py.atan(0)],
["                atan 0.5                    ", math_py.atan(0.5)],
["                atan 0.866                  ", math_py.atan(0.866)],
["                atan 1                      ", math_py.atan(1)],
["                atan 2                      ", math_py.atan(2)],
["                atan 5                      ", math_py.atan(5)],
["                atan -0.5                   ", math_py.atan(-0.5)],
["                atan -0.866                 ", math_py.atan(-0.866)],
["                atan -1                     ", math_py.atan(-1)],
["          27.2 错误的atan运算                "],
["atan                                        "],
["2atan                                       "],
["----------------------------------------------------------------------------------"],
["           28.1 正确的acot运算               "],
["      注:acot需要更多的计算量才能趋近于正确的值,默认最大循环次数为100          "],
["      注:使用self.calc.math.set_max_loop(int)提高循环次数以提高精度。      "],
["                 acot 0                      ", sympy.acot(0)],
["                 acot 0.5                    ", sympy.acot(0.5)],
["                 acot 0.866                  ", sympy.acot(0.866)],
["                 acot 1                      ", sympy.acot(1)],
["                 acot 2                      ", sympy.acot(2)],
["                 acot 5                      ", sympy.acot(5)],
["                 acot -0.5                   ", sympy.acot(-0.5)],
["                 acot -0.866                 ", sympy.acot(-0.866)],
["                 acot -1                     ", sympy.acot(-1)],
["            28.2 错误的acot运算               "],
["acot                                         "],
["2acot                                        "],
["----------------------------------------------------------------------------------"],
["            29.1 正确的sinh运算               "],
["                  sinh 0                     ", math_py.sinh(0)],
["                  sinh 0.5                   ", math_py.sinh(0.5)],
["                  sinh 0.866                 ", math_py.sinh(0.866)],
["                  sinh 1                     ", math_py.sinh(1)],
["                  sinh 2                     ", math_py.sinh(2)],
["                  sinh 5                     ", math_py.sinh(5)],
["                  sinh -0.5                  ", math_py.sinh(-0.5)],
["                  sinh -0.866                ", math_py.sinh(-0.866)],
["                  sinh -1                    ", math_py.sinh(-1)],
["            29.2 错误的sinh运算               "],
["sinh                                         "],
["2sinh                                        "],
["----------------------------------------------------------------------------------"],
["            30.1 正确的csch运算               "],
["                  csch 0.5                   ", sympy.csch(0.5)],
["                  csch 0.866                 ", sympy.csch(0.866)],
["                  csch 1                     ", sympy.csch(1)],
["                  csch 2                     ", sympy.csch(2)],
["                  csch 5                     ", sympy.csch(5)],
["                  csch -0.5                  ", sympy.csch(-0.5)],
["                  csch -0.866                ", sympy.csch(-0.866)],
["                  csch -1                    ", sympy.csch(-1)],
["            30.2 错误的csch运算               "],
["csch                                         "],
["2csch                                        "],
["csch 0                                       "],
["----------------------------------------------------------------------------------"],
["            31.1 正确的cosh运算               "],
["                  cosh 0                     ", math_py.cosh(0)],
["                  cosh 0.5                   ", math_py.cosh(0.5)],
["                  cosh 0.866                 ", math_py.cosh(0.866)],
["                  cosh 1                     ", math_py.cosh(1)],
["                  cosh 2                     ", math_py.cosh(2)],
["                  cosh 5                     ", math_py.cosh(5)],
["                  cosh -0.5                  ", math_py.cosh(-0.5)],
["                  cosh -0.866                ", math_py.cosh(-0.866)],
["                  cosh -1                    ", math_py.cosh(-1)],
["            31.2 错误的cosh运算               "],
["cosh                                         "],
["2cosh                                        "],
["----------------------------------------------------------------------------------"],
["            32.1 正确的sech运算               "],
["                  sech 0                     ", sympy.sech(0)],
["                  sech 0.5                   ", sympy.sech(0.5)],
["                  sech 0.866                 ", sympy.sech(0.866)],
["                  sech 1                     ", sympy.sech(1)],
["                  sech 2                     ", sympy.sech(2)],
["                  sech 5                     ", sympy.sech(5)],
["                  sech -0.5                  ", sympy.sech(-0.5)],
["                  sech -0.866                ", sympy.sech(-0.866)],
["                  sech -1                    ", sympy.sech(-1)],
["            32.2 错误的sech运算               "],
["sech                                         "],
["2sech                                        "],
["----------------------------------------------------------------------------------"],
["            33.1 正确的tanh运算               "],
["                  tanh 0                     ", math_py.tanh(0)],
["                  tanh 0.5                   ", math_py.tanh(0.5)],
["                  tanh 0.866                 ", math_py.tanh(0.866)],
["                  tanh 1                     ", math_py.tanh(1)],
["                  tanh 2                     ", math_py.tanh(2)],
["                  tanh 5                     ", math_py.tanh(5)],
["                  tanh -0.5                  ", math_py.tanh(-0.5)],
["                  tanh -0.866                ", math_py.tanh(-0.866)],
["                  tanh -1                    ", math_py.tanh(-1)],
["            33.2 错误的tanh运算               "],
["tanh                                         "],
["2tanh                                        "],
["----------------------------------------------------------------------------------"],
["             34.1 正确的coth运算              "],
["                   coth 0.5                  ", sympy.coth(0.5)],
["                   coth 0.866                ", sympy.coth(0.866)],
["                   coth 1                    ", sympy.coth(1)],
["                   coth 2                    ", sympy.coth(2)],
["                   coth 5                    ", sympy.coth(5)],
["                   coth -0.5                 ", sympy.coth(-0.5)],
["                   coth -0.866               ", sympy.coth(-0.866)],
["                   coth -1                   ", sympy.coth(-1)],
["             34.2 错误的coth运算              "],
["coth                                         "],
["2coth                                        "],
["coth 0                                       "],
["----------------------------------------------------------------------------------"],
["             35.1 正确的asinh运算             "],
["                   asinh 0                   ", math_py.asinh(0)],
["                   asinh 0.5                 ", math_py.asinh(0.5)],
["                   asinh 0.866               ", math_py.asinh(0.866)],
["                   asinh 1                   ", math_py.asinh(1)],
["                   asinh 2                   ", math_py.asinh(2)],
["                   asinh 5                   ", math_py.asinh(5)],
["                   asinh -0.5                ", math_py.asinh(-0.5)],
["                   asinh -0.866              ", math_py.asinh(-0.866)],
["                   asinh -1                  ", math_py.asinh(-1)],
["             35.2 错误的asinh运算             "],
["asinh                                        "],
["2asinh                                       "],
["----------------------------------------------------------------------------------"],
["             36.1 正确的acsch运算              "],
["                   acsch 0.5                  ", sympy.acsch(0.5)],
["                   acsch 0.866                ", sympy.acsch(0.866)],
["                   acsch 1                    ", sympy.acsch(1)],
["                   acsch 2                    ", sympy.acsch(2)],
["                   acsch 5                    ", sympy.acsch(5)],
["                   acsch -0.5                 ", sympy.acsch(-0.5)],
["                   acsch -0.866               ", sympy.acsch(-0.866)],
["                   acsch -1                   ", sympy.acsch(-1)],
["             36.2 错误的acsch运算              "],
["acsch                                         "],
["2acsch                                        "],
["----------------------------------------------------------------------------------"],
["              37.1 正确的acosh运算             "],
["                    acosh 1                   ", math_py.acosh(1)],
["                    acosh 2                   ", math_py.acosh(2)],
["                    acosh 5                   ", math_py.acosh(5)],
["              37.2 错误的acosh运算             "],
["acosh                                         "],
["2acosh                                        "],
["acosh 0                                       "],
["acosh 0.5                                     "],
["acosh 0.866                                   "],
["acosh -0.5                                    "],
["acosh -0.866                                  "],
["acosh -1                                      "],
["----------------------------------------------------------------------------------"],
["             38.1 正确的asech运算              "],
["                   asech 0.5                  ", sympy.asech(0.5)],
["                   asech 0.866                ", sympy.asech(0.866)],
["                   asech 1                    ", sympy.asech(1)],
["             38.2 错误的asech运算              "],
["asech                                         "],
["2asech                                        "],
["asech 0                                       "],
["asech 2                                       "],
["asech 5                                       "],
["asech -0.5                                    "],
["asech -0.866                                  "],
["asech -1                                      "],
["----------------------------------------------------------------------------------"],
["              39.1 正确的atanh运算             "],
["                    atanh 0                   ", math_py.atanh(0)],
["                    atanh 0.5                 ", math_py.atanh(0.5)],
["                    atanh 0.866               ", math_py.atanh(0.866)],
["                    atanh -0.5                ", math_py.atanh(-0.5)],
["                    atanh -0.866              ", math_py.atanh(-0.866)],
["              39.2 错误的atanh运算             "],
["atanh                                         "],
["2atanh                                        "],
["atanh 1                                       "],
["atanh 2                                       "],
["atanh 5                                       "],
["atanh -1                                      "],
["----------------------------------------------------------------------------------"],
["              40.1 正确的acoth运算             "],
["                    acoth 2                   ", sympy.acoth(2)],
["                    acoth 5                   ", sympy.acoth(5)],
["                    acoth -2                  ", sympy.acoth(-2)],
["                    acoth -5                  ", sympy.acoth(-5)],
["              40.2 错误的acoth运算             "],
["acoth                                         "],
["2acoth                                        "],
["acoth 0                                       "],
["acoth 0.5                                     "],
["acoth 0.866                                   "],
["acoth 1                                       "],
["acoth -1                                      "],
["----------------------------------------------------------------------------------"],
["              41.1 正确的sigmoid运算           "],
["                    sigmoid 0                 ", 1 / (1 + math_py.exp(0))],
["                    sigmoid 0.5               ", 1 / (1 + math_py.exp(-0.5))],
["                    sigmoid 0.866             ", 1 / (1 + math_py.exp(-0.866))],
["                    sigmoid 1                 ", 1 / (1 + math_py.exp(-1))],
["                    sigmoid 2                 ", 1 / (1 + math_py.exp(-2))],
["                    sigmoid 5                 ", 1 / (1 + math_py.exp(-5))],
["                    sigmoid 10                ", 1 / (1 + math_py.exp(-10))],
["                    sigmoid -0.5              ", 1 / (1 + math_py.exp(0.5))],
["                    sigmoid -0.866            ", 1 / (1 + math_py.exp(0.866))],
["                    sigmoid -1                ", 1 / (1 + math_py.exp(1))],
["              41.2 错误的sigmoid运算           "],
["sigmoid                                       "],
["2sigmoid                                      "],
["----------------------------------------------------------------------------------"],
["              42.1 正确的relu运算              "],
["                    relu 0                    ", 0],
["                    relu 1                    ", 1],
["                    relu -1                   ", 0],
["              42.2 错误的relu运算              "],
["relu                                          "],
["2relu                                         "],
["----------------------------------------------------------------------------------"],
["              43.1 正确的rad运算                "],
["                    rad 0                      ", math_py.radians(0)],
["                    rad 1                      ", math_py.radians(1)],
["                    rad 10                     ", math_py.radians(10)],
["                    rad pi                     ", math_py.radians(math_py.pi)],
["                    rad (pi/2)                 ", math_py.radians(math_py.pi / 2)],
["                    rad -1                     ", math_py.radians(-1)],
["                    rad -10                    ", math_py.radians(-10)],
["                    rad -pi                    ", math_py.radians(-math_py.pi)],
["                    rad -(pi/2)                ", math_py.radians(-math_py.pi / 2)],
["              43.2 错误的rad运算                "],
["rad                                            "],
["2rad                                           "],
["----------------------------------------------------------------------------------"],
["              44.1 正确的deg运算                "],
["                    deg 0                      ", math_py.degrees(0)],
["                    deg 1                      ", math_py.degrees(1)],
["                    deg 10                     ", math_py.degrees(10)],
["                    deg pi                     ", math_py.degrees(math_py.pi)],
["                    deg (pi/2)                 ", math_py.degrees(math_py.pi / 2)],
["                    deg -1                     ", math_py.degrees(-1)],
["                    deg -10                    ", math_py.degrees(-10)],
["                    deg -pi                    ", math_py.degrees(-math_py.pi)],
["                    deg -(pi/2)                ", math_py.degrees(-math_py.pi / 2)],
["              44.2 错误的deg运算                "],
["deg                                            "],
["2deg                                           "],
["----------------------------------------------------------------------------------"]]

2. 简单运算符测试 – 计算结果

测试开始,对669个算式进行运算
1: Error: "---------------------------    基本运算符测试    ---------------------------", 位置28的' ':非法字符
2: Error: "       注:将给出44组约600个测试示例,包括正确示例与错误示例              ", 位置8的'注':非法字符
3: Error: "         其中,正确示例指的是理论上的正确公式,在默认参数下有十六个示例与理论值有差:", 位置8的' ':非法字符
4: Error: "           1.计算精度不够,需要设置更高的最大计算循环次数,或降低显示精度。     ", 位置8的' ':非法字符
5: Error: "           2.功能缺失,如atan,暂时只支持[-1, 1]的输入                 ", 位置8的' ':非法字符
6: Error: "           3.python的函数有误,如round(0.5)==0而不是1。                      ", 位置8的' ':非法字符
7: Error: "             见:https://stackoverflow.com/questions/20048986/python-3-3-2-do-i-get-the-right-understanding-of-the-function-round/20049872#20049872 ", 位置8的' ':非法字符
8: Error: "         错误示例有以下三类:                                                ", 位置8的' ':非法字符
9: Error: "           1.缺失运算符,如'1 1',两数间没有运算符                            ", 位置8的' ':非法字符
10: Error: "           2.不合理的运算方式,如'1/0',除数不能为0,'(-1)!',负数无法阶乘      ", 位置8的' ':非法字符
11: Error: "           3.不合理的输入,如'sinnn',不存在的运算符                          ", 位置8的' ':非法字符
12: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
13: Error: "               1.1 正确的数与括号           ", 位置20的'正':非法字符
14: Error: "    注:为了可读性,算式前后 与 运算符中间 会有若干个空格填充  ", 位置5的'注':非法字符
15: 正 确: "                       1                   ", 运算结果 = 1.0, 理论值 = 1
16: 正 确: "                      100                  ", 运算结果 = 100.0, 理论值 = 100
17: 正 确: "                     (   )                 ", 运算结果 = 0, 理论值 = 0
18: 正 确: "                 (( ((   )) ))             ", 运算结果 = 0, 理论值 = 0
19: 正 确: "                 [( [(   )] )]             ", 运算结果 = 0, 理论值 = 0
20: 正 确: "                     ( 1 )                 ", 运算结果 = 1.0, 理论值 = 1
21: 正 确: "                    ( 100 )                ", 运算结果 = 100.0, 理论值 = 100
22: Error: "               1.2 错误的数与括号            ", 位置20的'错':非法字符
23: Error: "    注:为了方便核对错误位置,错误的算式会放在开头  ", 位置5的'注':非法字符
24: Error: "1 1                                        ", 位置3的'1':1缺少运算符
25: Error: "(                                          ", 位置1的'(':没有匹配的')'
26: Error: ")                                          ", 位置1的')':没有匹配的'('
27: Error: "(()                                        ", 位置1的'(':没有匹配的')'
28: Error: "())                                        ", 位置3的')':没有匹配的'('
29: Error: "(1(1))                                     ", 位置3的'(':左括号出现在不合理的位置
30: Error: "([(]))                                     ", 位置4的']':没有匹配的'['
31: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
32: Error: "              2.1 正确的加法与正号          ", 位置19的'正':非法字符
33: Error: "            注:连续的+-被视作正负号        ", 位置13的'注':非法字符
34: 正 确: "                    1 + 2                  ", 运算结果 = 3.0, 理论值 = 3
35: 正 确: "                10000 + 20000              ", 运算结果 = 30000.0, 理论值 = 30000
36: 正 确: "                 9999 +     1              ", 运算结果 = 10000.0, 理论值 = 10000
37: 正 确: "                      +1                   ", 运算结果 = 1.0, 理论值 = 1
38: 正 确: "                  +   +   1                ", 运算结果 = 1.0, 理论值 = 1
39: 正 确: "                      +  001               ", 运算结果 = 1.0, 理论值 = 1
40: Error: "              2.2 错误的加法与正号          ", 位置19的'错':非法字符
41: Error: "+                                          ", 位置1的'+':出现在末尾的运算符
42: Error: "1+                                         ", 位置2的'+':出现在末尾的运算符
43: Error: "+1+                                        ", 位置3的'+':出现在末尾的运算符
44: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
45: Error: "              3.1 正确的减法与负号            ", 位置19的'正':非法字符
46: 正 确: "                  1 - 2                    ", 运算结果 = -1.0, 理论值 = -1
47: 正 确: "                  2 - 1                    ", 运算结果 = 1.0, 理论值 = 1
48: 正 确: "                 -1 - 1                    ", 运算结果 = -2.0, 理论值 = -2
49: 正 确: "                - 1 - - 1                  ", 运算结果 = 0, 理论值 = 0
50: 正 确: "                 -1                        ", 运算结果 = -1.0, 理论值 = -1
51: 正 确: "                - 10                       ", 运算结果 = -10.0, 理论值 = -10
52: Error: "              3.2 错误的减法与负号          ", 位置19的'错':非法字符
53: Error: "-                                          ", 位置1的'-':出现在末尾的运算符
54: Error: "1-                                         ", 位置2的'-':出现在末尾的运算符
55: Error: "-1-                                        ", 位置3的'-':出现在末尾的运算符
56: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
57: Error: "              4.1 正确的乘法                ", 位置19的'正':非法字符
58: 正 确: "                  1 * 2                    ", 运算结果 = 2.0, 理论值 = 2
59: 正 确: "                  2 * 1                    ", 运算结果 = 2.0, 理论值 = 2
60: 正 确: "                  0 * 10                   ", 运算结果 = 0, 理论值 = 0
61: Error: "              4.2 错误的乘法                ", 位置19的'错':非法字符
62: Error: "*                                          ", 位置1的'*':*缺少运算对象
63: Error: "1*                                         ", 位置2的'*':出现在末尾的运算符
64: Error: "*1                                         ", 位置1的'*':*缺少运算对象
65: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
66: Error: "              5.1 正确的除法               ", 位置19的'正':非法字符
67: 正 确: "                  1 / 2                    ", 运算结果 = 0.5, 理论值 = 0.5
68: 正 确: "                  2 / 1                    ", 运算结果 = 2.0, 理论值 = 2.0
69: 正 确: "                  0 / 1                    ", 运算结果 = 0, 理论值 = 0.0
70: Error: "              5.2 错误的除法                ", 位置19的'错':非法字符
71: Error: "/                                          ", 位置1的'/':/缺少运算对象
72: Error: "1/                                         ", 位置2的'/':出现在末尾的运算符
73: Error: "/1                                         ", 位置1的'/':/缺少运算对象
74: Error: "1/0                                        ", 位置2的'/':除数不能为0
75: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
76: Error: "              6.1 正确的取余                ", 位置19的'正':非法字符
77: 正 确: "                  1 % 2                    ", 运算结果 = 1.0, 理论值 = 1
78: 正 确: "                  2 % 1                    ", 运算结果 = 0, 理论值 = 0
79: 正 确: "                  0 % 1                    ", 运算结果 = 0, 理论值 = 0
80: Error: "              6.2 错误的取余                ", 位置19的'错':非法字符
81: Error: "%                                          ", 位置1的'%':%缺少运算对象
82: Error: "1%                                         ", 位置2的'%':出现在末尾的运算符
83: Error: "%1                                         ", 位置1的'%':%缺少运算对象
84: Error: "1%0                                        ", 位置2的'%':除数不能为0
85: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
86: Error: "              7.1 正确的取绝对值            ", 位置19的'正':非法字符
87: Error: "   注:如abs等单目运算符后跟+-时,+-被认为是正负号 ", 位置4的'注':非法字符
88: 正 确: "                 abs 1                     ", 运算结果 = 1.0, 理论值 = 1
89: 正 确: "                 abs-1                     ", 运算结果 = 1.0, 理论值 = 1
90: 正 确: "                 abs+1                     ", 运算结果 = 1.0, 理论值 = 1
91: Error: "            7.2 错误的取绝对值              ", 位置17的'错':非法字符
92: Error: "abs                                        ", 位置1的'abs':出现在末尾的运算符
93: Error: "2abs                                       ", 位置2的'abs':abs缺少运算对象
94: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
95: Error: "            8.1 正确的向上取整              ", 位置17的'正':非法字符
96: 正 确: "                ceil(11.0)                 ", 运算结果 = 11.0, 理论值 = 11
97: 正 确: "                ceil 0.5                   ", 运算结果 = 1.0, 理论值 = 1
98: 正 确: "                ceil 0                     ", 运算结果 = 0, 理论值 = 0
99: 正 确: "                ceil -0.6                  ", 运算结果 = 0, 理论值 = 0
100: 正 确: "                ceil-1                     ", 运算结果 = -1.0, 理论值 = -1
101: Error: "            8.2 错误的向上取整              ", 位置17的'错':非法字符
102: Error: "ceil                                       ", 位置1的'ceil':出现在末尾的运算符
103: Error: "2ceil                                      ", 位置2的'ceil':ceil缺少运算对象
104: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
105: Error: "           9.1 正确的向下取整               ", 位置16的'正':非法字符
106: 正 确: "               floor(11.0)                 ", 运算结果 = 11.0, 理论值 = 11
107: 正 确: "               floor 0.5                   ", 运算结果 = 0, 理论值 = 0
108: 正 确: "               floor 0                     ", 运算结果 = 0, 理论值 = 0
109: 正 确: "               floor -0.6                  ", 运算结果 = -1.0, 理论值 = -1
110: 正 确: "               floor-1                     ", 运算结果 = -1.0, 理论值 = -1
111: Error: "           9.2 错误的向下取整               ", 位置16的'错':非法字符
112: Error: "floor                                      ", 位置1的'floor':出现在末尾的运算符
113: Error: "2floor                                     ", 位置2的'floor':floor缺少运算对象
114: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
115: Error: "           10.1 正确的四舍五入              ", 位置17的'正':非法字符
116: Error: "           注:在round 0.5的示例中,python的round(0.5)确实是0,不是代码打错了       ", 位置12的'注':非法字符
117: 正 确: "                round(11.0)                ", 运算结果 = 11.0, 理论值 = 11
118: 与理论值不符: "                round 0.5                  ", 运算结果 = 1.0, 理论值 = 0
119: 正 确: "                round 0                    ", 运算结果 = 0, 理论值 = 0
120: 正 确: "                round -0.6                 ", 运算结果 = -1.0, 理论值 = -1
121: 正 确: "                round-1                    ", 运算结果 = -1.0, 理论值 = -1
122: Error: "           10.2 错误的四舍五入              ", 位置17的'错':非法字符
123: Error: "round                                      ", 位置1的'round':出现在末尾的运算符
124: Error: "2round                                     ", 位置2的'round':round缺少运算对象
125: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
126: Error: "           11.1 正确的阶乘运算              ", 位置17的'正':非法字符
127: 正 确: "                3!                         ", 运算结果 = 6.0, 理论值 = 6
128: 正 确: "                3 !                        ", 运算结果 = 6.0, 理论值 = 6
129: 正 确: "              -(3!)                        ", 运算结果 = -6.0, 理论值 = -6
130: Error: "           11.2 错误的阶乘运算              ", 位置17的'错':非法字符
131: Error: "!                                          ", 位置1的'!':!缺少运算对象
132: Error: "!3                                         ", 位置1的'!':!缺少运算对象
133: Error: "(-3)!                                      ", 位置5的'!':只能对正整数阶乘
134: Error: "-3 !                                       ", 位置4的'!':只能对正整数阶乘
135: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
136: Error: "          12.1 正确的指数'^'运算            ", 位置16的'正':非法字符
137: 正 确: "               2 ^ 32                      ", 运算结果 = 4294967296.0, 理论值 = 4294967296
138: 正 确: "               2 ^ 16                      ", 运算结果 = 65536.0, 理论值 = 65536
139: 正 确: "               2 ^ 8                       ", 运算结果 = 256.0, 理论值 = 256
140: 正 确: "               2 ^ 4                       ", 运算结果 = 16.0, 理论值 = 16
141: 正 确: "               2 ^ 2                       ", 运算结果 = 4.0, 理论值 = 4
142: 正 确: "               2 ^ 1                       ", 运算结果 = 2.0, 理论值 = 2
143: 正 确: "               2 ^ 0                       ", 运算结果 = 1.0, 理论值 = 1
144: 正 确: "               2 ^ 0.5                     ", 运算结果 = 1.41, 理论值 = 1.4142135623730951
145: 正 确: "               2 ^ 0.1                     ", 运算结果 = 1.07, 理论值 = 1.0717734625362931
146: 正 确: "               2 ^ 0.01                    ", 运算结果 = 1.01, 理论值 = 1.0069555500567189
147: 正 确: "               2 ^ 0.001                   ", 运算结果 = 1.0, 理论值 = 1.0006933874625807
148: 正 确: "               2 ^ 0.0001                  ", 运算结果 = 1.0, 理论值 = 1.0000693171203765
149: 正 确: "               2 ^ 0.00001                 ", 运算结果 = 1.0, 理论值 = 1.0000069314958282
150: 正 确: "               2 ^ -1                      ", 运算结果 = 0.5, 理论值 = 0.5
151: 正 确: "               2 ^ -2                      ", 运算结果 = 0.25, 理论值 = 0.25
152: 正 确: "               2 ^ -4                      ", 运算结果 = 0.06, 理论值 = 0.0625
153: Error: "          12.2 错误的指数'^'运算            ", 位置16的'错':非法字符
154: Error: "^                                          ", 位置1的'^':^缺少运算对象
155: Error: "2^                                         ", 位置2的'^':出现在末尾的运算符
156: Error: "^2                                         ", 位置1的'^':^缺少运算对象
157: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
158: Error: "          13.1 正确的指数'exp'运算          ", 位置16的'正':非法字符
159: 正 确: "               exp10                       ", 运算结果 = 22026.47, 理论值 = 22026.465794806718
160: 正 确: "               exp5                        ", 运算结果 = 148.41, 理论值 = 148.4131591025766
161: 正 确: "               exp2                        ", 运算结果 = 7.39, 理论值 = 7.38905609893065
162: 正 确: "               exp1                        ", 运算结果 = 2.72, 理论值 = 2.718281828459045
163: 正 确: "               exp0.1                      ", 运算结果 = 1.11, 理论值 = 1.1051709180756477
164: 正 确: "               exp0.01                     ", 运算结果 = 1.01, 理论值 = 1.010050167084168
165: 正 确: "               exp0.001                    ", 运算结果 = 1.0, 理论值 = 1.0010005001667084
166: 正 确: "               exp0.0001                   ", 运算结果 = 1.0, 理论值 = 1.0001000050001667
167: 正 确: "               exp0.00001                  ", 运算结果 = 1.0, 理论值 = 1.00001000005
168: 正 确: "               exp0                        ", 运算结果 = 1.0, 理论值 = 1.0
169: 正 确: "               exp-1                       ", 运算结果 = 0.37, 理论值 = 0.36787944117144233
170: 正 确: "               exp-2                       ", 运算结果 = 0.14, 理论值 = 0.1353352832366127
171: 正 确: "               exp-5                       ", 运算结果 = 0.01, 理论值 = 0.006737946999085467
172: 正 确: "               exp-10                      ", 运算结果 = 0, 理论值 = 4.5399929762484854e-05
173: Error: "          13.2 错误的指数'exp'运算          ", 位置16的'错':非法字符
174: Error: "exp                                        ", 位置1的'exp':出现在末尾的运算符
175: Error: "1exp                                       ", 位置2的'exp':exp缺少运算对象
176: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
177: Error: "          14.1 正确的开方运算               ", 位置16的'正':非法字符
178: 正 确: "               sqrt10000                   ", 运算结果 = 100.0, 理论值 = 100.0
179: 正 确: "               sqrt1000                    ", 运算结果 = 31.62, 理论值 = 31.622776601683793
180: 正 确: "               sqrt100                     ", 运算结果 = 10.0, 理论值 = 10.0
181: 正 确: "               sqrt10                      ", 运算结果 = 3.16, 理论值 = 3.1622776601683795
182: 正 确: "               sqrt5                       ", 运算结果 = 2.24, 理论值 = 2.23606797749979
183: 正 确: "               sqrt2                       ", 运算结果 = 1.41, 理论值 = 1.4142135623730951
184: 正 确: "               sqrt1                       ", 运算结果 = 1.0, 理论值 = 1.0
185: 正 确: "               sqrt0                       ", 运算结果 = 0, 理论值 = 0.0
186: 正 确: "               sqrt0.1                     ", 运算结果 = 0.32, 理论值 = 0.31622776601683794
187: 正 确: "               sqrt0.01                    ", 运算结果 = 0.1, 理论值 = 0.1
188: 正 确: "               sqrt0.001                   ", 运算结果 = 0.03, 理论值 = 0.03162277660168379
189: 正 确: "               sqrt0.0001                  ", 运算结果 = 0.01, 理论值 = 0.01
190: Error: "          14.2 错误的开方运算               ", 位置16的'错':非法字符
191: Error: "sqrt                                       ", 位置1的'sqrt':出现在末尾的运算符
192: Error: "1sqrt                                      ", 位置2的'sqrt':sqrt缺少运算对象
193: Error: "sqrt-1                                     ", 位置1的'sqrt':只能对正数开根号
194: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
195: Error: "          15.1 正确的自然对数运算           ", 位置16的'正':非法字符
196: 正 确: "               ln 0.00000001               ", 运算结果 = -18.42, 理论值 = -18.420680743952367
197: 正 确: "               ln 0.0000001                ", 运算结果 = -16.12, 理论值 = -16.11809565095832
198: 正 确: "               ln 0.000001                 ", 运算结果 = -13.82, 理论值 = -13.815510557964274
199: 正 确: "               ln 0.00001                  ", 运算结果 = -11.51, 理论值 = -11.512925464970229
200: 正 确: "               ln 0.0001                   ", 运算结果 = -9.21, 理论值 = -9.210340371976182
201: 正 确: "               ln 0.001                    ", 运算结果 = -6.91, 理论值 = -6.907755278982137
202: 正 确: "               ln 0.01                     ", 运算结果 = -4.61, 理论值 = -4.605170185988091
203: 正 确: "               ln 0.1                      ", 运算结果 = -2.3, 理论值 = -2.3025850929940455
204: 正 确: "               ln 0.5                      ", 运算结果 = -0.69, 理论值 = -0.6931471805599453
205: 正 确: "               ln 1                        ", 运算结果 = 0, 理论值 = 0.0
206: 正 确: "               ln (e/2)                    ", 运算结果 = 0.31, 理论值 = 0.30685281944005466
207: 正 确: "               ln e                        ", 运算结果 = 1.0, 理论值 = 1.0
208: 正 确: "               ln (e^2)                    ", 运算结果 = 2.0, 理论值 = 2.0
209: 正 确: "               ln 2                        ", 运算结果 = 0.69, 理论值 = 0.6931471805599453
210: 正 确: "               ln 5                        ", 运算结果 = 1.61, 理论值 = 1.6094379124341003
211: 正 确: "               ln 10                       ", 运算结果 = 2.3, 理论值 = 2.302585092994046
212: 正 确: "               ln 100                      ", 运算结果 = 4.61, 理论值 = 4.605170185988092
213: 正 确: "               ln 1000                     ", 运算结果 = 6.91, 理论值 = 6.907755278982137
214: 正 确: "               ln 10000                    ", 运算结果 = 9.21, 理论值 = 9.210340371976184
215: 正 确: "               ln 100000                   ", 运算结果 = 11.51, 理论值 = 11.512925464970229
216: 正 确: "               ln 1000000                  ", 运算结果 = 13.82, 理论值 = 13.815510557964274
217: 正 确: "               ln 10000000                 ", 运算结果 = 16.12, 理论值 = 16.11809565095832
218: 正 确: "               ln 100000000                ", 运算结果 = 18.42, 理论值 = 18.420680743952367
219: Error: "          15.2 错误的自然对数运算           ", 位置16的'错':非法字符
220: Error: "ln                                         ", 位置1的'ln':出现在末尾的运算符
221: Error: "2ln                                        ", 位置2的'ln':ln缺少运算对象
222: Error: "ln0                                        ", 位置1的'ln':只能对正数开对数
223: Error: "ln(-1)                                     ", 位置1的'ln':只能对正数开对数
224: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
225: Error: "          16.1 正确的常用对数运算           ", 位置16的'正':非法字符
226: 正 确: "               lg 0.00000001               ", 运算结果 = -8.0, 理论值 = -8.0
227: 正 确: "               lg 0.0000001                ", 运算结果 = -7.0, 理论值 = -7.0
228: 正 确: "               lg 0.000001                 ", 运算结果 = -6.0, 理论值 = -6.0
229: 正 确: "               lg 0.00001                  ", 运算结果 = -5.0, 理论值 = -5.0
230: 正 确: "               lg 0.0001                   ", 运算结果 = -4.0, 理论值 = -4.0
231: 正 确: "               lg 0.001                    ", 运算结果 = -3.0, 理论值 = -3.0
232: 正 确: "               lg 0.01                     ", 运算结果 = -2.0, 理论值 = -2.0
233: 正 确: "               lg 0.1                      ", 运算结果 = -1.0, 理论值 = -1.0
234: 正 确: "               lg 0.5                      ", 运算结果 = -0.3, 理论值 = -0.3010299956639812
235: 正 确: "               lg 1                        ", 运算结果 = 0, 理论值 = 0.0
236: 正 确: "               lg (e/2)                    ", 运算结果 = 0.13, 理论值 = 0.13326448623927062
237: 正 确: "               lg e                        ", 运算结果 = 0.43, 理论值 = 0.4342944819032518
238: 正 确: "               lg (e^2)                    ", 运算结果 = 0.87, 理论值 = 0.8685889638065036
239: 正 确: "               lg 2                        ", 运算结果 = 0.3, 理论值 = 0.3010299956639812
240: 正 确: "               lg 5                        ", 运算结果 = 0.7, 理论值 = 0.6989700043360189
241: 正 确: "               lg 10                       ", 运算结果 = 1.0, 理论值 = 1.0
242: 正 确: "               lg 100                      ", 运算结果 = 2.0, 理论值 = 2.0
243: 正 确: "               lg 1000                     ", 运算结果 = 3.0, 理论值 = 3.0
244: 正 确: "               lg 10000                    ", 运算结果 = 4.0, 理论值 = 4.0
245: 正 确: "               lg 100000                   ", 运算结果 = 5.0, 理论值 = 5.0
246: 正 确: "               lg 1000000                  ", 运算结果 = 6.0, 理论值 = 6.0
247: 正 确: "               lg 10000000                 ", 运算结果 = 7.0, 理论值 = 7.0
248: 正 确: "               lg 100000000                ", 运算结果 = 8.0, 理论值 = 8.0
249: Error: "          16.2 错误的常用对数运算           ", 位置16的'错':非法字符
250: Error: "lg                                         ", 位置1的'lg':出现在末尾的运算符
251: Error: "2lg                                        ", 位置2的'lg':lg缺少运算对象
252: Error: "lg0                                        ", 位置1的'lg':只能对正数开对数
253: Error: "lg(-1)                                     ", 位置1的'lg':只能对正数开对数
254: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
255: Error: "          17.1 正确的sin运算                ", 位置16的'正':非法字符
256: 正 确: "               sin 0                       ", 运算结果 = 0, 理论值 = 0
257: 正 确: "               sin (pi / 6)                ", 运算结果 = 0.5, 理论值 = 0.49999999999999994
258: 正 确: "               sin (pi / 4)                ", 运算结果 = 0.71, 理论值 = 0.7071067811865476
259: 正 确: "               sin (pi / 3)                ", 运算结果 = 0.87, 理论值 = 0.8660254037844386
260: 正 确: "               sin (pi / 2)                ", 运算结果 = 1.0, 理论值 = 1.0
261: 正 确: "               sin pi                      ", 运算结果 = 0, 理论值 = 1.2246467991473532e-16
262: 正 确: "               sin (3 * pi / 4)            ", 运算结果 = 0.71, 理论值 = 0.7071067811865476
263: 正 确: "               sin (3 * pi / 2)            ", 运算结果 = -1.0, 理论值 = -1.0
264: 正 确: "               sin (2 * pi)                ", 运算结果 = 0, 理论值 = -2.4492935982947064e-16
265: 正 确: "               sin (-pi / 6)               ", 运算结果 = -0.5, 理论值 = -0.49999999999999994
266: 正 确: "               sin (-pi / 4)               ", 运算结果 = -0.71, 理论值 = -0.7071067811865476
267: 正 确: "               sin (-pi / 3)               ", 运算结果 = -0.87, 理论值 = -0.8660254037844386
268: 正 确: "               sin (-pi / 2)               ", 运算结果 = -1.0, 理论值 = -1.0
269: Error: "          17.2 错误的sin运算                ", 位置16的'错':非法字符
270: Error: "sin                                        ", 位置1的'sin':出现在末尾的运算符
271: Error: "2sin                                       ", 位置2的'sin':sin缺少运算对象
272: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
273: Error: "          18.1 正确的csc运算                ", 位置16的'正':非法字符
274: 正 确: "               csc (pi / 6)                ", 运算结果 = 2.0, 理论值 = 2.00000000000000
275: 正 确: "               csc (pi / 4)                ", 运算结果 = 1.41, 理论值 = 1.41421356237310
276: 正 确: "               csc (pi / 3)                ", 运算结果 = 1.15, 理论值 = 1.15470053837925
277: 正 确: "               csc (pi / 2)                ", 运算结果 = 1.0, 理论值 = 1.00000000000000
278: 正 确: "               csc (3 * pi / 4)            ", 运算结果 = 1.41, 理论值 = 1.41421356237309
279: 正 确: "               csc (3 * pi / 2)            ", 运算结果 = -1.0, 理论值 = -1.00000000000000
280: 正 确: "               csc (-pi / 6)               ", 运算结果 = -2.0, 理论值 = -2.00000000000000
281: 正 确: "               csc (-pi / 4)               ", 运算结果 = -1.41, 理论值 = -1.41421356237310
282: 正 确: "               csc (-pi / 3)               ", 运算结果 = -1.15, 理论值 = -1.15470053837925
283: 正 确: "               csc (-pi / 2)               ", 运算结果 = -1.0, 理论值 = -1.00000000000000
284: Error: "          18.2 错误的csc运算                ", 位置16的'错':非法字符
285: Error: "csc                                        ", 位置1的'csc':出现在末尾的运算符
286: Error: "2csc                                       ", 位置2的'csc':csc缺少运算对象
287: Error: "csc0                                       ", 位置1的'csc':操作数不能等于kπ,k∈Z
288: Error: "csc pi                                     ", 位置1的'csc':操作数不能等于kπ,k∈Z
289: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
290: Error: "          19.1 正确的cos运算                ", 位置16的'正':非法字符
291: 正 确: "               cos 0                       ", 运算结果 = 1.0, 理论值 = 1
292: 正 确: "               cos (pi / 6)                ", 运算结果 = 0.87, 理论值 = 0.8660254037844387
293: 正 确: "               cos (pi / 4)                ", 运算结果 = 0.71, 理论值 = 0.7071067811865476
294: 正 确: "               cos (pi / 3)                ", 运算结果 = 0.5, 理论值 = 0.5000000000000001
295: 正 确: "               cos (pi / 2)                ", 运算结果 = 0, 理论值 = 6.123233995736766e-17
296: 正 确: "               cos pi                      ", 运算结果 = -1.0, 理论值 = -1.0
297: 正 确: "               cos (3 * pi / 4)            ", 运算结果 = -0.71, 理论值 = -0.7071067811865475
298: 正 确: "               cos (3 * pi / 2)            ", 运算结果 = 0, 理论值 = -1.8369701987210297e-16
299: 正 确: "               cos (2 * pi)                ", 运算结果 = 1.0, 理论值 = 1.0
300: 正 确: "               cos (-pi / 6)               ", 运算结果 = 0.87, 理论值 = 0.8660254037844387
301: 正 确: "               cos (-pi / 4)               ", 运算结果 = 0.71, 理论值 = 0.7071067811865476
302: 正 确: "               cos (-pi / 3)               ", 运算结果 = 0.5, 理论值 = 0.5000000000000001
303: 正 确: "               cos (-pi / 2)               ", 运算结果 = 0, 理论值 = 6.123233995736766e-17
304: Error: "          19.2 错误的cos运算                ", 位置16的'错':非法字符
305: Error: "cos                                        ", 位置1的'cos':出现在末尾的运算符
306: Error: "2cos                                       ", 位置2的'cos':cos缺少运算对象
307: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
308: Error: "          20.1 正确的sec运算                ", 位置16的'正':非法字符
309: 正 确: "               sec 0                       ", 运算结果 = 1.0, 理论值 = 1
310: 正 确: "               sec (pi / 6)                ", 运算结果 = 1.15, 理论值 = 1.15470053837925
311: 正 确: "               sec (pi / 4)                ", 运算结果 = 1.41, 理论值 = 1.41421356237309
312: 正 确: "               sec (pi / 3)                ", 运算结果 = 2.0, 理论值 = 2.00000000000000
313: 正 确: "               sec pi                      ", 运算结果 = -1.0, 理论值 = -1.00000000000000
314: 正 确: "               sec (3 * pi / 4)            ", 运算结果 = -1.41, 理论值 = -1.41421356237310
315: 正 确: "               sec (2 * pi)                ", 运算结果 = 1.0, 理论值 = 1.00000000000000
316: 正 确: "               sec (-pi / 6)               ", 运算结果 = 1.15, 理论值 = 1.15470053837925
317: 正 确: "               sec (-pi / 4)               ", 运算结果 = 1.41, 理论值 = 1.41421356237309
318: 正 确: "               sec (-pi / 3)               ", 运算结果 = 2.0, 理论值 = 2.00000000000000
319: Error: "          20.2 错误的sec运算                ", 位置16的'错':非法字符
320: Error: "sec                                        ", 位置1的'sec':出现在末尾的运算符
321: Error: "2sec                                       ", 位置2的'sec':sec缺少运算对象
322: Error: "sec (pi / 2)                               ", 位置1的'sec':操作数不能等于π/2+kπ,k∈Z
323: Error: "sec (3 * pi / 2)                           ", 位置1的'sec':操作数不能等于π/2+kπ,k∈Z
324: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
325: Error: "          21.1 正确的tan运算                ", 位置16的'正':非法字符
326: 正 确: "               tan 0                       ", 运算结果 = 0, 理论值 = 0.0
327: 正 确: "               tan (pi / 6)                ", 运算结果 = 0.58, 理论值 = 0.5773502691896257
328: 正 确: "               tan (pi / 4)                ", 运算结果 = 1.0, 理论值 = 0.9999999999999999
329: 正 确: "               tan (pi / 3)                ", 运算结果 = 1.73, 理论值 = 1.7320508075688767
330: 正 确: "               tan (3 * pi / 4)            ", 运算结果 = -1.0, 理论值 = -1.0000000000000002
331: 正 确: "               tan (2 * pi)                ", 运算结果 = 0, 理论值 = -2.4492935982947064e-16
332: 正 确: "               tan pi                      ", 运算结果 = 0, 理论值 = -1.2246467991473532e-16
333: 正 确: "               tan (-pi / 6)               ", 运算结果 = -0.58, 理论值 = -0.5773502691896257
334: 正 确: "               tan (-pi / 4)               ", 运算结果 = -1.0, 理论值 = -0.9999999999999999
335: 正 确: "               tan (-pi / 3)               ", 运算结果 = -1.73, 理论值 = -1.7320508075688767
336: 正 确: "               tan (-3 * pi / 4)           ", 运算结果 = 1.0, 理论值 = 1.0000000000000002
337: Error: "          21.2 错误的tan运算                ", 位置16的'错':非法字符
338: Error: "tan                                        ", 位置1的'tan':出现在末尾的运算符
339: Error: "2tan                                       ", 位置2的'tan':tan缺少运算对象
340: Error: "tan (pi / 2)                               ", 位置1的'tan':操作数不能等于π/2+kπ,k∈Z
341: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
342: Error: "          22.1 正确的cot运算                ", 位置16的'正':非法字符
343: 正 确: "               cot (pi / 6)                ", 运算结果 = 1.73, 理论值 = 1.73205080756888
344: 正 确: "               cot (pi / 4)                ", 运算结果 = 1.0, 理论值 = 1.00000000000000
345: 正 确: "               cot (pi / 3)                ", 运算结果 = 0.58, 理论值 = 0.577350269189626
346: 正 确: "               cot (pi / 2)                ", 运算结果 = 0, 理论值 = 6.12323399573677e-17
347: 正 确: "               cot (3 * pi / 4)            ", 运算结果 = -1.0, 理论值 = -1.00000000000000
348: 正 确: "               cot (3 * pi / 2)            ", 运算结果 = 0, 理论值 = 1.83697019872103e-16
349: 正 确: "               cot (-pi / 6)               ", 运算结果 = -1.73, 理论值 = -1.73205080756888
350: 正 确: "               cot (-pi / 4)               ", 运算结果 = -1.0, 理论值 = -1.00000000000000
351: 正 确: "               cot (-pi / 3)               ", 运算结果 = -0.58, 理论值 = -0.577350269189626
352: 正 确: "               cot (-3 * pi / 4)           ", 运算结果 = 1.0, 理论值 = 1.00000000000000
353: Error: "          22.2 错误的cot运算                ", 位置16的'错':非法字符
354: Error: "cot                                        ", 位置1的'cot':出现在末尾的运算符
355: Error: "2cot                                       ", 位置2的'cot':cot缺少运算对象
356: Error: "cot 0                                      ", 位置1的'cot':操作数不能等于kπ,k∈Z
357: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
358: Error: "          23.1 正确的asin运算               ", 位置16的'正':非法字符
359: Error: "     注:asin需要更多的计算量才能趋近于正确的值,默认最大循环次数为100。     ", 位置6的'注':非法字符
360: Error: "     注:使用self.calc.math.set_max_loop(int)提高循环次数以提高精度。   ", 位置6的'注':非法字符
361: 正 确: "                asin 0                     ", 运算结果 = 0, 理论值 = 0.0
362: 正 确: "                asin 0.5                   ", 运算结果 = 0.52, 理论值 = 0.5235987755982989
363: 正 确: "                asin 0.866                 ", 运算结果 = 1.05, 理论值 = 1.0471467458630677
364: 与理论值不符: "                asin 1                     ", 运算结果 = 1.51, 理论值 = 1.5707963267948966
365: 正 确: "                asin -0.5                  ", 运算结果 = -0.52, 理论值 = -0.5235987755982989
366: 正 确: "                asin -0.866                ", 运算结果 = -1.05, 理论值 = -1.0471467458630677
367: 与理论值不符: "                asin -1                    ", 运算结果 = -1.51, 理论值 = -1.5707963267948966
368: Error: "          23.2 错误的asin运算               ", 位置16的'错':非法字符
369: Error: "asin                                       ", 位置1的'asin':出现在末尾的运算符
370: Error: "2asin                                      ", 位置2的'asin':asin缺少运算对象
371: Error: "asin2                                      ", 位置1的'asin':只能对-1到1之间的数开反正弦
372: Error: "asin(-2)                                   ", 位置1的'asin':只能对-1到1之间的数开反正弦
373: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
374: Error: "          24.1 正确的acsc运算               ", 位置16的'正':非法字符
375: Error: "     注:acsc需要更多的计算量才能趋近于正确的值,默认最大循环次数为100        ", 位置6的'注':非法字符
376: Error: "     注:使用self.calc.math.set_max_loop(int)提高循环次数以提高精度。    ", 位置6的'注':非法字符
377: 与理论值不符: "                acsc 1                     ", 运算结果 = 1.51, 理论值 = pi/2
378: 正 确: "                acsc 2                     ", 运算结果 = 0.52, 理论值 = pi/6
379: 正 确: "                acsc 5                     ", 运算结果 = 0.2, 理论值 = acsc(5)
380: 正 确: "                acsc -5                    ", 运算结果 = -0.2, 理论值 = -acsc(5)
381: 正 确: "                acsc -2                    ", 运算结果 = -0.52, 理论值 = -pi/6
382: 与理论值不符: "                acsc -1                    ", 运算结果 = -1.51, 理论值 = -pi/2
383: Error: "          24.2 错误的acsc运算               ", 位置16的'错':非法字符
384: Error: "acsc                                       ", 位置1的'acsc':出现在末尾的运算符
385: Error: "2acsc                                      ", 位置2的'acsc':acsc缺少运算对象
386: Error: "acsc0                                      ", 位置1的'acsc':只能对绝对值大于等于一的数开反余弦
387: Error: "acsc0.5                                    ", 位置1的'acsc':只能对绝对值大于等于一的数开反余弦
388: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
389: Error: "          25.1 正确的acos运算               ", 位置16的'正':非法字符
390: Error: "     注:acos需要更多的计算量才能趋近于正确的值,默认最大循环次数为100        ", 位置6的'注':非法字符
391: Error: "     注:使用self.calc.math.set_max_loop(int)提高循环次数以提高精度。    ", 位置6的'注':非法字符
392: 正 确: "                acos 0                     ", 运算结果 = 1.57, 理论值 = 1.5707963267948966
393: 正 确: "                acos 0.5                   ", 运算结果 = 1.05, 理论值 = 1.0471975511965979
394: 正 确: "                acos 0.866                 ", 运算结果 = 0.52, 理论值 = 0.5236495809318289
395: 与理论值不符: "                acos 1                     ", 运算结果 = 0.06, 理论值 = 0.0
396: 正 确: "                acos -0.5                  ", 运算结果 = 2.09, 理论值 = 2.0943951023931957
397: 正 确: "                acos -0.866                ", 运算结果 = 2.62, 理论值 = 2.6179430726579644
398: 与理论值不符: "                acos -1                    ", 运算结果 = 3.09, 理论值 = 3.141592653589793
399: Error: "         25.2 错误的acos运算                ", 位置15的'错':非法字符
400: Error: "acos                                       ", 位置1的'acos':出现在末尾的运算符
401: Error: "2acos                                      ", 位置2的'acos':acos缺少运算对象
402: Error: "acos2                                      ", 位置1的'acos':只能对-1到1之间的数开反余弦
403: Error: "acos(-2)                                   ", 位置1的'acos':只能对-1到1之间的数开反余弦
404: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
405: Error: "          26.1 正确的asec运算               ", 位置16的'正':非法字符
406: Error: "     注:asec需要更多的计算量才能趋近于正确的值,默认最大循环次数为100         ", 位置6的'注':非法字符
407: Error: "     注:使用self.calc.math.set_max_loop(int)提高循环次数以提高精度。     ", 位置6的'注':非法字符
408: 与理论值不符: "                asec 1                     ", 运算结果 = 0.06, 理论值 = 0
409: 正 确: "                asec 2                     ", 运算结果 = 1.05, 理论值 = pi/3
410: 正 确: "                asec 5                     ", 运算结果 = 1.37, 理论值 = asec(5)
411: 正 确: "                asec -5                    ", 运算结果 = 1.77, 理论值 = asec(-5)
412: 正 确: "                asec -2                    ", 运算结果 = 2.09, 理论值 = 2*pi/3
413: 与理论值不符: "                asec -1                    ", 运算结果 = 3.09, 理论值 = pi
414: Error: "          26.2 错误的asec运算               ", 位置16的'错':非法字符
415: Error: "asec                                       ", 位置1的'asec':出现在末尾的运算符
416: Error: "2asec                                      ", 位置2的'asec':asec缺少运算对象
417: Error: "asec0                                      ", 位置1的'asec':只能对绝对值大于等于一的数开反正割
418: Error: "asec0.5                                    ", 位置1的'asec':只能对绝对值大于等于一的数开反正割
419: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
420: Error: "          27.1 正确的atan运算               ", 位置16的'正':非法字符
421: Error: "     注:atan需要更多的计算量才能趋近于正确的值,默认最大循环次数为100        ", 位置6的'注':非法字符
422: Error: "     注:使用self.calc.math.set_max_loop(int)提高循环次数以提高精度。    ", 位置6的'注':非法字符
423: 正 确: "                atan 0                      ", 运算结果 = 0, 理论值 = 0.0
424: 正 确: "                atan 0.5                    ", 运算结果 = 0.46, 理论值 = 0.4636476090008061
425: 正 确: "                atan 0.866                  ", 运算结果 = 0.71, 理论值 = 0.7137098623140186
426: 正 确: "                atan 1                      ", 运算结果 = 0.78, 理论值 = 0.7853981633974483
427: Error: "                atan 2                      ", 位置17的'atan':目前仅支持对-1到1之间的数开反正切
428: Error: "                atan 5                      ", 位置17的'atan':目前仅支持对-1到1之间的数开反正切
429: 正 确: "                atan -0.5                   ", 运算结果 = -0.46, 理论值 = -0.4636476090008061
430: 正 确: "                atan -0.866                 ", 运算结果 = -0.71, 理论值 = -0.7137098623140186
431: 正 确: "                atan -1                     ", 运算结果 = -0.78, 理论值 = -0.7853981633974483
432: Error: "          27.2 错误的atan运算                ", 位置16的'错':非法字符
433: Error: "atan                                        ", 位置1的'atan':出现在末尾的运算符
434: Error: "2atan                                       ", 位置2的'atan':atan缺少运算对象
435: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
436: Error: "           28.1 正确的acot运算               ", 位置17的'正':非法字符
437: Error: "      注:acot需要更多的计算量才能趋近于正确的值,默认最大循环次数为100          ", 位置7的'注':非法字符
438: Error: "      注:使用self.calc.math.set_max_loop(int)提高循环次数以提高精度。      ", 位置7的'注':非法字符
439: Error: "                 acot 0                      ", 位置18的'acot':目前仅支持绝对值大于等于一的数开反正切
440: Error: "                 acot 0.5                    ", 位置18的'acot':目前仅支持绝对值大于等于一的数开反正切
441: Error: "                 acot 0.866                  ", 位置18的'acot':目前仅支持绝对值大于等于一的数开反正切
442: 正 确: "                 acot 1                      ", 运算结果 = 0.78, 理论值 = pi/4
443: 正 确: "                 acot 2                      ", 运算结果 = 0.46, 理论值 = acot(2)
444: 正 确: "                 acot 5                      ", 运算结果 = 0.2, 理论值 = acot(5)
445: Error: "                 acot -0.5                   ", 位置18的'acot':目前仅支持绝对值大于等于一的数开反正切
446: Error: "                 acot -0.866                 ", 位置18的'acot':目前仅支持绝对值大于等于一的数开反正切
447: 正 确: "                 acot -1                     ", 运算结果 = -0.78, 理论值 = -pi/4
448: Error: "            28.2 错误的acot运算               ", 位置18的'错':非法字符
449: Error: "acot                                         ", 位置1的'acot':出现在末尾的运算符
450: Error: "2acot                                        ", 位置2的'acot':acot缺少运算对象
451: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
452: Error: "            29.1 正确的sinh运算               ", 位置18的'正':非法字符
453: 正 确: "                  sinh 0                     ", 运算结果 = 0, 理论值 = 0.0
454: 正 确: "                  sinh 0.5                   ", 运算结果 = 0.52, 理论值 = 0.5210953054937474
455: 正 确: "                  sinh 0.866                 ", 运算结果 = 0.98, 理论值 = 0.9783757842158765
456: 正 确: "                  sinh 1                     ", 运算结果 = 1.18, 理论值 = 1.1752011936438014
457: 正 确: "                  sinh 2                     ", 运算结果 = 3.63, 理论值 = 3.6268604078470186
458: 正 确: "                  sinh 5                     ", 运算结果 = 74.2, 理论值 = 74.20321057778875
459: 正 确: "                  sinh -0.5                  ", 运算结果 = -0.52, 理论值 = -0.5210953054937474
460: 正 确: "                  sinh -0.866                ", 运算结果 = -0.98, 理论值 = -0.9783757842158765
461: 正 确: "                  sinh -1                    ", 运算结果 = -1.18, 理论值 = -1.1752011936438014
462: Error: "            29.2 错误的sinh运算               ", 位置18的'错':非法字符
463: Error: "sinh                                         ", 位置1的'sinh':出现在末尾的运算符
464: Error: "2sinh                                        ", 位置2的'sinh':sinh缺少运算对象
465: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
466: Error: "            30.1 正确的csch运算               ", 位置18的'正':非法字符
467: 正 确: "                  csch 0.5                   ", 运算结果 = 1.92, 理论值 = 1.91903475133494
468: 正 确: "                  csch 0.866                 ", 运算结果 = 1.02, 理论值 = 1.02210215760957
469: 正 确: "                  csch 1                     ", 运算结果 = 0.85, 理论值 = csch(1)
470: 正 确: "                  csch 2                     ", 运算结果 = 0.28, 理论值 = csch(2)
471: 正 确: "                  csch 5                     ", 运算结果 = 0.01, 理论值 = csch(5)
472: 正 确: "                  csch -0.5                  ", 运算结果 = -1.92, 理论值 = -1.91903475133494
473: 正 确: "                  csch -0.866                ", 运算结果 = -1.02, 理论值 = -1.02210215760957
474: 正 确: "                  csch -1                    ", 运算结果 = -0.85, 理论值 = -csch(1)
475: Error: "            30.2 错误的csch运算               ", 位置18的'错':非法字符
476: Error: "csch                                         ", 位置1的'csch':出现在末尾的运算符
477: Error: "2csch                                        ", 位置2的'csch':csch缺少运算对象
478: Error: "csch 0                                       ", 位置1的'csch':双曲余割值不存在
479: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
480: Error: "            31.1 正确的cosh运算               ", 位置18的'正':非法字符
481: 正 确: "                  cosh 0                     ", 运算结果 = 1.0, 理论值 = 1.0
482: 正 确: "                  cosh 0.5                   ", 运算结果 = 1.13, 理论值 = 1.1276259652063807
483: 正 确: "                  cosh 0.866                 ", 运算结果 = 1.4, 理论值 = 1.399006495746189
484: 正 确: "                  cosh 1                     ", 运算结果 = 1.54, 理论值 = 1.5430806348152437
485: 正 确: "                  cosh 2                     ", 运算结果 = 3.76, 理论值 = 3.7621956910836314
486: 正 确: "                  cosh 5                     ", 运算结果 = 74.21, 理论值 = 74.20994852478785
487: 正 确: "                  cosh -0.5                  ", 运算结果 = 1.13, 理论值 = 1.1276259652063807
488: 正 确: "                  cosh -0.866                ", 运算结果 = 1.4, 理论值 = 1.399006495746189
489: 正 确: "                  cosh -1                    ", 运算结果 = 1.54, 理论值 = 1.5430806348152437
490: Error: "            31.2 错误的cosh运算               ", 位置18的'错':非法字符
491: Error: "cosh                                         ", 位置1的'cosh':出现在末尾的运算符
492: Error: "2cosh                                        ", 位置2的'cosh':cosh缺少运算对象
493: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
494: Error: "            32.1 正确的sech运算               ", 位置18的'正':非法字符
495: 正 确: "                  sech 0                     ", 运算结果 = 1.0, 理论值 = 1
496: 正 确: "                  sech 0.5                   ", 运算结果 = 0.89, 理论值 = 0.886818883970074
497: 正 确: "                  sech 0.866                 ", 运算结果 = 0.71, 理论值 = 0.714792964178933
498: 正 确: "                  sech 1                     ", 运算结果 = 0.65, 理论值 = sech(1)
499: 正 确: "                  sech 2                     ", 运算结果 = 0.27, 理论值 = sech(2)
500: 正 确: "                  sech 5                     ", 运算结果 = 0.01, 理论值 = sech(5)
501: 正 确: "                  sech -0.5                  ", 运算结果 = 0.89, 理论值 = 0.886818883970074
502: 正 确: "                  sech -0.866                ", 运算结果 = 0.71, 理论值 = 0.714792964178933
503: 正 确: "                  sech -1                    ", 运算结果 = 0.65, 理论值 = sech(1)
504: Error: "            32.2 错误的sech运算               ", 位置18的'错':非法字符
505: Error: "sech                                         ", 位置1的'sech':出现在末尾的运算符
506: Error: "2sech                                        ", 位置2的'sech':sech缺少运算对象
507: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
508: Error: "            33.1 正确的tanh运算               ", 位置18的'正':非法字符
509: 正 确: "                  tanh 0                     ", 运算结果 = 0, 理论值 = 0.0
510: 正 确: "                  tanh 0.5                   ", 运算结果 = 0.46, 理论值 = 0.46211715726000974
511: 正 确: "                  tanh 0.866                 ", 运算结果 = 0.7, 理论值 = 0.6993361268805544
512: 正 确: "                  tanh 1                     ", 运算结果 = 0.76, 理论值 = 0.7615941559557649
513: 正 确: "                  tanh 2                     ", 运算结果 = 0.96, 理论值 = 0.9640275800758169
514: 正 确: "                  tanh 5                     ", 运算结果 = 1.0, 理论值 = 0.9999092042625951
515: 正 确: "                  tanh -0.5                  ", 运算结果 = -0.46, 理论值 = -0.46211715726000974
516: 正 确: "                  tanh -0.866                ", 运算结果 = -0.7, 理论值 = -0.6993361268805544
517: 正 确: "                  tanh -1                    ", 运算结果 = -0.76, 理论值 = -0.7615941559557649
518: Error: "            33.2 错误的tanh运算               ", 位置18的'错':非法字符
519: Error: "tanh                                         ", 位置1的'tanh':出现在末尾的运算符
520: Error: "2tanh                                        ", 位置2的'tanh':tanh缺少运算对象
521: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
522: Error: "             34.1 正确的coth运算              ", 位置19的'正':非法字符
523: 正 确: "                   coth 0.5                  ", 运算结果 = 2.16, 理论值 = 2.16395341373865
524: 正 确: "                   coth 0.866                ", 运算结果 = 1.43, 理论值 = 1.42992755781198
525: 正 确: "                   coth 1                    ", 运算结果 = 1.31, 理论值 = coth(1)
526: 正 确: "                   coth 2                    ", 运算结果 = 1.04, 理论值 = coth(2)
527: 正 确: "                   coth 5                    ", 运算结果 = 1.0, 理论值 = coth(5)
528: 正 确: "                   coth -0.5                 ", 运算结果 = -2.16, 理论值 = -2.16395341373865
529: 正 确: "                   coth -0.866               ", 运算结果 = -1.43, 理论值 = -1.42992755781198
530: 正 确: "                   coth -1                   ", 运算结果 = -1.31, 理论值 = -coth(1)
531: Error: "             34.2 错误的coth运算              ", 位置19的'错':非法字符
532: Error: "coth                                         ", 位置1的'coth':出现在末尾的运算符
533: Error: "2coth                                        ", 位置2的'coth':coth缺少运算对象
534: Error: "coth 0                                       ", 位置1的'coth':双曲余切值不存在
535: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
536: Error: "             35.1 正确的asinh运算             ", 位置19的'正':非法字符
537: 正 确: "                   asinh 0                   ", 运算结果 = 0, 理论值 = 0.0
538: 正 确: "                   asinh 0.5                 ", 运算结果 = 0.48, 理论值 = 0.48121182505960347
539: 正 确: "                   asinh 0.866               ", 运算结果 = 0.78, 理论值 = 0.7833804149095004
540: 正 确: "                   asinh 1                   ", 运算结果 = 0.88, 理论值 = 0.8813735870195429
541: 正 确: "                   asinh 2                   ", 运算结果 = 1.44, 理论值 = 1.4436354751788103
542: 正 确: "                   asinh 5                   ", 运算结果 = 2.31, 理论值 = 2.3124383412727525
543: 正 确: "                   asinh -0.5                ", 运算结果 = -0.48, 理论值 = -0.48121182505960347
544: 正 确: "                   asinh -0.866              ", 运算结果 = -0.78, 理论值 = -0.7833804149095004
545: 正 确: "                   asinh -1                  ", 运算结果 = -0.88, 理论值 = -0.8813735870195429
546: Error: "             35.2 错误的asinh运算             ", 位置19的'错':非法字符
547: Error: "asinh                                        ", 位置1的'asinh':出现在末尾的运算符
548: Error: "2asinh                                       ", 位置2的'asinh':asinh缺少运算对象
549: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
550: Error: "             36.1 正确的acsch运算              ", 位置19的'正':非法字符
551: 正 确: "                   acsch 0.5                  ", 运算结果 = 1.44, 理论值 = 1.44363547517881
552: 正 确: "                   acsch 0.866                ", 运算结果 = 0.99, 理论值 = 0.986669135750430
553: 正 确: "                   acsch 1                    ", 运算结果 = 0.88, 理论值 = log(1 + sqrt(2))
554: 正 确: "                   acsch 2                    ", 运算结果 = 0.48, 理论值 = log(1/2 + sqrt(5)/2)
555: 正 确: "                   acsch 5                    ", 运算结果 = 0.2, 理论值 = acsch(5)
556: 正 确: "                   acsch -0.5                 ", 运算结果 = -1.44, 理论值 = -1.44363547517881
557: 正 确: "                   acsch -0.866               ", 运算结果 = -0.99, 理论值 = -0.986669135750430
558: 正 确: "                   acsch -1                   ", 运算结果 = -0.88, 理论值 = -log(1 + sqrt(2))
559: Error: "             36.2 错误的acsch运算              ", 位置19的'错':非法字符
560: Error: "acsch                                         ", 位置1的'acsch':出现在末尾的运算符
561: Error: "2acsch                                        ", 位置2的'acsch':acsch缺少运算对象
562: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
563: Error: "              37.1 正确的acosh运算             ", 位置20的'正':非法字符
564: 正 确: "                    acosh 1                   ", 运算结果 = 0, 理论值 = 0.0
565: 正 确: "                    acosh 2                   ", 运算结果 = 1.32, 理论值 = 1.3169578969248166
566: 正 确: "                    acosh 5                   ", 运算结果 = 2.29, 理论值 = 2.2924316695611777
567: Error: "              37.2 错误的acosh运算             ", 位置20的'错':非法字符
568: Error: "acosh                                         ", 位置1的'acosh':出现在末尾的运算符
569: Error: "2acosh                                        ", 位置2的'acosh':acosh缺少运算对象
570: Error: "acosh 0                                       ", 位置1的'acosh':反双曲余弦值不存在
571: Error: "acosh 0.5                                     ", 位置1的'acosh':反双曲余弦值不存在
572: Error: "acosh 0.866                                   ", 位置1的'acosh':反双曲余弦值不存在
573: Error: "acosh -0.5                                    ", 位置1的'acosh':反双曲余弦值不存在
574: Error: "acosh -0.866                                  ", 位置1的'acosh':反双曲余弦值不存在
575: Error: "acosh -1                                      ", 位置1的'acosh':反双曲余弦值不存在
576: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
577: Error: "             38.1 正确的asech运算              ", 位置19的'正':非法字符
578: 正 确: "                   asech 0.5                  ", 运算结果 = 1.32, 理论值 = 1.31695789692482
579: 正 确: "                   asech 0.866                ", 运算结果 = 0.55, 理论值 = 0.549364810140471
580: 正 确: "                   asech 1                    ", 运算结果 = 0, 理论值 = 0
581: Error: "             38.2 错误的asech运算              ", 位置19的'错':非法字符
582: Error: "asech                                         ", 位置1的'asech':出现在末尾的运算符
583: Error: "2asech                                        ", 位置2的'asech':asech缺少运算对象
584: Error: "asech 0                                       ", 位置1的'asech':反双曲正割值不存在
585: Error: "asech 2                                       ", 位置1的'asech':反双曲正割值不存在
586: Error: "asech 5                                       ", 位置1的'asech':反双曲正割值不存在
587: Error: "asech -0.5                                    ", 位置1的'asech':反双曲正割值不存在
588: Error: "asech -0.866                                  ", 位置1的'asech':反双曲正割值不存在
589: Error: "asech -1                                      ", 位置1的'asech':反双曲正割值不存在
590: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
591: Error: "              39.1 正确的atanh运算             ", 位置20的'正':非法字符
592: 正 确: "                    atanh 0                   ", 运算结果 = 0, 理论值 = 0.0
593: 正 确: "                    atanh 0.5                 ", 运算结果 = 0.55, 理论值 = 0.5493061443340549
594: 正 确: "                    atanh 0.866               ", 运算结果 = 1.32, 理论值 = 1.3168562907281889
595: 正 确: "                    atanh -0.5                ", 运算结果 = -0.55, 理论值 = -0.5493061443340549
596: 正 确: "                    atanh -0.866              ", 运算结果 = -1.32, 理论值 = -1.3168562907281889
597: Error: "              39.2 错误的atanh运算             ", 位置20的'错':非法字符
598: Error: "atanh                                         ", 位置1的'atanh':出现在末尾的运算符
599: Error: "2atanh                                        ", 位置2的'atanh':atanh缺少运算对象
600: Error: "atanh 1                                       ", 位置1的'atanh':反双曲正切值不存在
601: Error: "atanh 2                                       ", 位置1的'atanh':反双曲正切值不存在
602: Error: "atanh 5                                       ", 位置1的'atanh':反双曲正切值不存在
603: Error: "atanh -1                                      ", 位置1的'atanh':反双曲正切值不存在
604: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
605: Error: "              40.1 正确的acoth运算             ", 位置20的'正':非法字符
606: 正 确: "                    acoth 2                   ", 运算结果 = 0.55, 理论值 = acoth(2)
607: 正 确: "                    acoth 5                   ", 运算结果 = 0.2, 理论值 = acoth(5)
608: 正 确: "                    acoth -2                  ", 运算结果 = -0.55, 理论值 = -acoth(2)
609: 正 确: "                    acoth -5                  ", 运算结果 = -0.2, 理论值 = -acoth(5)
610: Error: "              40.2 错误的acoth运算             ", 位置20的'错':非法字符
611: Error: "acoth                                         ", 位置1的'acoth':出现在末尾的运算符
612: Error: "2acoth                                        ", 位置2的'acoth':acoth缺少运算对象
613: Error: "acoth 0                                       ", 位置1的'acoth':双曲余切值不存在
614: Error: "acoth 0.5                                     ", 位置1的'acoth':双曲余切值不存在
615: Error: "acoth 0.866                                   ", 位置1的'acoth':双曲余切值不存在
616: Error: "acoth 1                                       ", 位置1的'acoth':双曲余切值不存在
617: Error: "acoth -1                                      ", 位置1的'acoth':双曲余切值不存在
618: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
619: Error: "              41.1 正确的sigmoid运算           ", 位置20的'正':非法字符
620: 正 确: "                    sigmoid 0                 ", 运算结果 = 0.5, 理论值 = 0.5
621: 正 确: "                    sigmoid 0.5               ", 运算结果 = 0.62, 理论值 = 0.6224593312018546
622: 正 确: "                    sigmoid 0.866             ", 运算结果 = 0.7, 理论值 = 0.7039127001012062
623: 正 确: "                    sigmoid 1                 ", 运算结果 = 0.73, 理论值 = 0.7310585786300049
624: 正 确: "                    sigmoid 2                 ", 运算结果 = 0.88, 理论值 = 0.8807970779778823
625: 正 确: "                    sigmoid 5                 ", 运算结果 = 0.99, 理论值 = 0.9933071490757153
626: 正 确: "                    sigmoid 10                ", 运算结果 = 1.0, 理论值 = 0.9999546021312976
627: 正 确: "                    sigmoid -0.5              ", 运算结果 = 0.38, 理论值 = 0.3775406687981454
628: 正 确: "                    sigmoid -0.866            ", 运算结果 = 0.3, 理论值 = 0.2960872998987938
629: 正 确: "                    sigmoid -1                ", 运算结果 = 0.27, 理论值 = 0.2689414213699951
630: Error: "              41.2 错误的sigmoid运算           ", 位置20的'错':非法字符
631: Error: "sigmoid                                       ", 位置1的'sigmoid':出现在末尾的运算符
632: Error: "2sigmoid                                      ", 位置2的'sigmoid':sigmoid缺少运算对象
633: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
634: Error: "              42.1 正确的relu运算              ", 位置20的'正':非法字符
635: 正 确: "                    relu 0                    ", 运算结果 = 0, 理论值 = 0
636: 正 确: "                    relu 1                    ", 运算结果 = 1.0, 理论值 = 1
637: 正 确: "                    relu -1                   ", 运算结果 = 0, 理论值 = 0
638: Error: "              42.2 错误的relu运算              ", 位置20的'错':非法字符
639: Error: "relu                                          ", 位置1的'relu':出现在末尾的运算符
640: Error: "2relu                                         ", 位置2的'relu':relu缺少运算对象
641: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
642: Error: "              43.1 正确的rad运算                ", 位置20的'正':非法字符
643: 正 确: "                    rad 0                      ", 运算结果 = 0, 理论值 = 0.0
644: 正 确: "                    rad 1                      ", 运算结果 = 0.02, 理论值 = 0.017453292519943295
645: 正 确: "                    rad 10                     ", 运算结果 = 0.17, 理论值 = 0.17453292519943295
646: 正 确: "                    rad pi                     ", 运算结果 = 0.05, 理论值 = 0.05483113556160755
647: 正 确: "                    rad (pi/2)                 ", 运算结果 = 0.03, 理论值 = 0.027415567780803774
648: 正 确: "                    rad -1                     ", 运算结果 = -0.02, 理论值 = -0.017453292519943295
649: 正 确: "                    rad -10                    ", 运算结果 = -0.17, 理论值 = -0.17453292519943295
650: 正 确: "                    rad -pi                    ", 运算结果 = -0.05, 理论值 = -0.05483113556160755
651: 正 确: "                    rad -(pi/2)                ", 运算结果 = -0.03, 理论值 = -0.027415567780803774
652: Error: "              43.2 错误的rad运算                ", 位置20的'错':非法字符
653: Error: "rad                                            ", 位置1的'rad':出现在末尾的运算符
654: Error: "2rad                                           ", 位置2的'rad':rad缺少运算对象
655: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
656: Error: "              44.1 正确的deg运算                ", 位置20的'正':非法字符
657: 正 确: "                    deg 0                      ", 运算结果 = 0, 理论值 = 0.0
658: 正 确: "                    deg 1                      ", 运算结果 = 57.3, 理论值 = 57.29577951308232
659: 正 确: "                    deg 10                     ", 运算结果 = 572.96, 理论值 = 572.9577951308232
660: 正 确: "                    deg pi                     ", 运算结果 = 180.0, 理论值 = 180.0
661: 正 确: "                    deg (pi/2)                 ", 运算结果 = 90.0, 理论值 = 90.0
662: 正 确: "                    deg -1                     ", 运算结果 = -57.3, 理论值 = -57.29577951308232
663: 正 确: "                    deg -10                    ", 运算结果 = -572.96, 理论值 = -572.9577951308232
664: 正 确: "                    deg -pi                    ", 运算结果 = -180.0, 理论值 = -180.0
665: 正 确: "                    deg -(pi/2)                ", 运算结果 = -90.0, 理论值 = -90.0
666: Error: "              44.2 错误的deg运算                ", 位置20的'错':非法字符
667: Error: "deg                                            ", 位置1的'deg':出现在末尾的运算符
668: Error: "2deg                                           ", 位置2的'deg':deg缺少运算对象
669: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
测试结束,耗时:1136毫秒

3. 混合运算符测试 – 测试语句

["---------------------------    混合运算符测试    ---------------------------"],
["       注:这里的测试样例是测试几种运算符的混合运算                  "],
["         在实现中,运算符被分成了五类:                       "],
["           1.双目运算符:左右都需要操作数才能正常运算,如乘号            "],
["           2.单目运算符:对右侧操作数进行运算,如三角函数                "],
["           3.加减与正负:作为加减时,是双目运算符,作为正负时,是单目运算符     "],
["           4.阶乘运算符:对左侧操作数进行运算,也是单目运算,因运算方式不同单独列出 "],
["           5.括号   :用于算式可读性,与运算先后性                "],
["         在本次混合运算符测试中,以五类运算符为单位测试,而非以某个运算符为单位测试  "],
["         各个数学函数的正误测试请见基本运算符测试                  "],
["----------------------------------------------------------------------------------"],
["       1. 基本加减乘除正误示例                        "],
["                 4 * 8 / 16                          ", 4*8/16],
["4*8/16                                               ", 4*8/16],
["4*8/0                                                ", 4*8/16],
["            (2 - 4 * 8 / 16) * 2                     ", (2-4*8/16)*2],
[" (2-4*8/16)*2                                        ", (2-4*8/16)*2],
["((2-4*8/16)*2                                        ", (2-4*8/16)*2],
["       (1 + (2 - 4 * 8 / 16) * 2)                    ", 1+(2-4*8/16)*2],
["(1+(2-4*8/16)*2)                                     ", 1+(2-4*8/16)*2],
["(1 (2-4*8/16)*2)                                     ", 1+(2-4*8/16)*2],
["----------------------------------------------------------------------------------"],
["       2. 绝对值函数正误示例                          "],
["              (abs(-4) * 8) / 16                     ", abs(-4)*8/16],
["(abs (-4)*8)/16                                      ", abs(-4)*8/16],
["(absa(-4)*8)/16                                      ", abs(-4)*8/16],
["         2 * -(abs(-4) * 8) / 16                     ", 2*-abs(-4)*8/16],
["2*-(abs(-4)*8)/16                                    ", 2*-abs(-4)*8/16],
["2**(abs(-4)*8)/16                                    ", 2*-abs(-4)*8/16],
["  sqrt -(2 * -(abs(-4) * 8) / 16)                    ", math_py.sqrt(-2*-abs(-4)*8/16)],
["sqrt-(2*-(abs(-4)*8)/16)                             ", math_py.sqrt(-2*-abs(-4)*8/16)],
["sqrt (2*-(abs(-4)*8)/16)                             ", math_py.sqrt(-2*-abs(-4)*8/16)],
["----------------------------------------------------------------------------------"],
["       3. 指数函数与对数函数正误示例                   "],
["             sqrt ((2 * 1) ^ (3 - 1))                ", math_py.sqrt(2**(3-1))],
["sqrt ((2*1)^(3-1))                                   ", math_py.sqrt(2**(3-1))],
["sq rt((2*1)^(3-1))                                   ", math_py.sqrt(2**(3-1))],
["        exp( sqrt ((2 * 1) ^ (3 - 1)) )              ", math_py.exp(math_py.sqrt(2**(3-1)))],
["exp(sqrt((2*1)^(3-1)))                               ", math_py.exp(math_py.sqrt(2**(3-1)))],
["expsqrt ((2*1)^(3-1)))                               ", math_py.exp(math_py.sqrt(2**(3-1)))],
["     ln exp( sqrt ((2 * 1) ^ (3 - 1)) )              ", math_py.log(math_py.exp(math_py.sqrt(2**(3-1))))],
["ln exp(sqrt((2*1)^(3-1)))                            ", math_py.log(math_py.exp(math_py.sqrt(2**(3-1))))],
["ln(exp(sqrt((2*1)^(3-1)))                            ", math_py.log(math_py.exp(math_py.sqrt(2**(3-1))))],
["----------------------------------------------------------------------------------"],
["       4. 三角函数正误示例                            "],
["        (  sin((pi / 2)) - cos((pi / 3))  )          ", math_py.sin(math_py.pi/2)-math_py.cos(math_py.pi/3)],
["(sin((pi/2))-cos((pi/3)))                            ", math_py.sin(math_py.pi/2)-math_py.cos(math_py.pi/3)],
["[sin[[pi/2))-cos[[pi/3)))                            ", math_py.sin(math_py.pi/2)-math_py.cos(math_py.pi/3)],
["   (4 ^ (  sin((pi / 2)) - cos((pi / 3))  ))         ", 4**(math_py.sin(math_py.pi/2)-math_py.cos(math_py.pi/3))],
["(4^(sin((pi/2))-cos((pi/3))))                        ", 4**(math_py.sin(math_py.pi/2)-math_py.cos(math_py.pi/3))],
["[4^(sin((pi/2))-cos((pi/3))))                        ", 4**(math_py.sin(math_py.pi/2)-math_py.cos(math_py.pi/3))],
["  ((4 ^ (  sin((pi / 2)) - cos((pi / 3))  )) + 1)!   ", math_py.factorial((4**(math_py.sin(math_py.pi/2)-math_py.cos(math_py.pi/3)))+1)],
["((4^(sin((pi/2))-cos((pi/3))))+1)!                   ", math_py.factorial((4**(math_py.sin(math_py.pi/2)-math_py.cos(math_py.pi/3)))+1)],
["((4^(sin((pi/2))-cos((pi/3))))-9)!                   ", math_py.factorial((4**(math_py.sin(math_py.pi/2)-math_py.cos(math_py.pi/3)))+1)],
["----------------------------------------------------------------------------------"],
["       5. 取整函数正误示例                            "],
["       注:下面的三个round测试中有大小写区别,         "],
["           但会在运算时统一为小写,                    "],
["           所以在结果展示中看起来一样。                "],
["                 ln e  +  lg 10  + e                 ", math_py.log(math_py.e)+math_py.log10(10)+math_py.e],
["ln e + lg 10 + e                                     ", math_py.log(math_py.e)+math_py.log10(10)+math_py.e],
["lne  + lg 10 + e                                     ", math_py.log(math_py.e)+math_py.log10(10)+math_py.e],
["         round ( ln e  +  lg 10  + e )               ", round(math_py.log(math_py.e)+math_py.log10(10)+math_py.e)],
["         Round ( Ln e  +  lG 10  + E )               ", round(math_py.log(math_py.e)+math_py.log10(10)+math_py.e)],
["         ROUND ( ln e  +  lg 10  + e )               ", round(math_py.log(math_py.e)+math_py.log10(10)+math_py.e)],
["         ceil  ( ln e  +  lg 10  + e )               ", math_py.ceil(math_py.log(math_py.e)+math_py.log10(10)+math_py.e)],
["ceil(ln e + lg 10 + e)                               ", math_py.ceil(math_py.log(math_py.e)+math_py.log10(10)+math_py.e)],
["ceil(ln e + lg 10 + e)错                             ", math_py.ceil(math_py.log(math_py.e)+math_py.log10(10)+math_py.e)],
["         floor ( ln e  +  lg 10  + e )               ", math_py.floor(math_py.log(math_py.e)+math_py.log10(10)+math_py.e)],
["floor(ln e + lg 10 + e)                              ", math_py.floor(math_py.log(math_py.e)+math_py.log10(10)+math_py.e)],
["floor(ln e + lg 10 + e)A                             ", math_py.floor(math_py.log(math_py.e)+math_py.log10(10)+math_py.e)],
["    sqrt floor ( ln e  +  lg 10  + e )               ", math_py.sqrt(math_py.floor(math_py.log(math_py.e)+math_py.log10(10)+math_py.e))],
["sqrt(floor(ln e + lg 10 + e))                        ", math_py.sqrt(math_py.floor(math_py.log(math_py.e)+math_py.log10(10)+math_py.e))],
["sqrt(floor(ln e + lg 10 + e))?                       ", math_py.sqrt(math_py.floor(math_py.log(math_py.e)+math_py.log10(10)+math_py.e))],
[" 1+ sqrt floor ( ln e  +  lg 10  + e ) +1            ", 1+math_py.sqrt(math_py.floor(math_py.log(math_py.e)+math_py.log10(10)+math_py.e))+1],
["1+sqrt(floor(ln e + lg 10 + e))+1                    ", 1+math_py.sqrt(math_py.floor(math_py.log(math_py.e)+math_py.log10(10)+math_py.e))+1],
["1+sqrt(floor(ln e + lg 10 + e))+1$$$$$               ", 1+math_py.sqrt(math_py.floor(math_py.log(math_py.e)+math_py.log10(10)+math_py.e))+1],
["----------------------------------------------------------------------------------"],
["       6. 三角函数与弧度角度转换函数正误示例           "],
["             sin(rad(60)) - sin(pi/3)                ", math_py.sin(math_py.radians(60))-math_py.sin(math_py.pi/3)],
["sin(rad(60))-sin(pi/3)                               ", math_py.sin(math_py.radians(60))-math_py.sin(math_py.pi/3)],
["sin(rad(60))-sin(p /3)                               ", math_py.sin(math_py.radians(60))-math_py.sin(math_py.pi/3)],
["        cos( sin(rad(60)) - sin(pi/3) )              ", math_py.cos(math_py.sin(math_py.radians(60))-math_py.sin(math_py.pi/3))],
["cos(sin(rad(60))-sin(pi/3))                          ", math_py.cos(math_py.sin(math_py.radians(60))-math_py.sin(math_py.pi/3))],
["cossin((rad(60))-sin(pi/3))                          ", math_py.cos(math_py.sin(math_py.radians(60))-math_py.sin(math_py.pi/3))],
["   rad( cos( sin(rad(60)) - sin(pi/3) ) *180)        ", math_py.radians(math_py.cos(math_py.sin(math_py.radians(60))-math_py.sin(math_py.pi/3))*180)],
["rad(cos(sin(rad(60))-sin(pi/3))*180)                 ", math_py.radians(math_py.cos(math_py.sin(math_py.radians(60))-math_py.sin(math_py.pi/3))*180)],
["rad(coss(in(rad(60))-sin(pi/3))*180)                 ", math_py.radians(math_py.cos(math_py.sin(math_py.radians(60))-math_py.sin(math_py.pi/3))*180)],
["----------------------------------------------------------------------------------"],
["       7. 三角函数与角度转弧度函数正误示例             "],
["          注:部分运算需要更高的计算时间才能提高精度。  "],
["          注:使用self.calc.math.set_max_loop(int)提高循环次数以提高精度。"],
["                   sin asin 1                        ", math_py.sin(math_py.asin(1))],
["sin(asin(1))                                         ", math_py.sin(math_py.asin(1))],
["sin(asin( ))                                         ", math_py.sin(math_py.asin(1))],
["              pi * sin asin 1 + tan (pi/4)-1         ", math_py.pi*math_py.sin(math_py.asin(1))+math_py.tan(math_py.pi/4)-1],
["pi*sin(asin(1))+tan(pi/4)-1                          ", math_py.pi*math_py.sin(math_py.asin(1))+math_py.tan(math_py.pi/4)-1],
["pi*sin(asin(1))+tan(pi/0)-1                          ", math_py.pi*math_py.sin(math_py.asin(1))+math_py.tan(math_py.pi/4)-1],
["         deg( pi * sin asin 1 + tan (pi/4)-1 )       ", math_py.degrees(math_py.pi*math_py.sin(math_py.asin(1))+math_py.tan(math_py.pi/4)-1)],
["deg(pi*sin(asin(1))+tan(pi/4)-1)                     ", math_py.degrees(math_py.pi*math_py.sin(math_py.asin(1))+math_py.tan(math_py.pi/4)-1)],
["deg(pi*sin(asin(2))+tan(pi/4)-1)                     ", math_py.degrees(math_py.pi*math_py.sin(math_py.asin(1))+math_py.tan(math_py.pi/4)-1)],
["----------------------------------------------------------------------------------"],
["       8. 冗余运算符与括号正误示例                    "],
["          (([-- --(-- 1)--1]))                       ", ----(--1)--1],
["(([----(--1)--1]))                                   ", ----(--1)--1],
["(([----(--1)--1)])                                   ", ----(--1)--1],
["  abs-abs-(((-- --(-- 1)--1)))                       ", abs(abs(----(--1)--1))],
["abs-abs-(((----(--1)--1)))                           ", abs(abs(----(--1)--1))],
["abs-abs-[((----(--1)--1)))                           ", abs(abs(----(--1)--1))],
["  abs-abs-(((-- --[-- 1]--1))) +++++++abs((+++-1))   ", abs(abs(----(--1)--1))+++++++abs(+++-1)],
["abs(abs(----[--1]--1))+++++++abs(+++-1)              ", abs(abs(----(--1)--1))+++++++abs(+++-1)],
["abs(abs(----[--1)--1))+++++++abs(+++-1)              ", abs(abs(----(--1)--1))+++++++abs(+++-1)],
["----------------------------------------------------------------------------------"],

4. 混合运算符测试 – 计算结果

测试开始,对113个算式进行运算
1: Error: "---------------------------    混合运算符测试    ---------------------------", 位置28的' ':非法字符
2: Error: "       注:这里的测试样例是测试几种运算符的混合运算                  ", 位置8的'注':非法字符
3: Error: "         在实现中,运算符被分成了五类:                       ", 位置8的' ':非法字符
4: Error: "           1.双目运算符:左右都需要操作数才能正常运算,如乘号            ", 位置8的' ':非法字符
5: Error: "           2.单目运算符:对右侧操作数进行运算,如三角函数                ", 位置8的' ':非法字符
6: Error: "           3.加减与正负:作为加减时,是双目运算符,作为正负时,是单目运算符     ", 位置8的' ':非法字符
7: Error: "           4.阶乘运算符:对左侧操作数进行运算,也是单目运算,因运算方式不同单独列出 ", 位置8的' ':非法字符
8: Error: "           5.括号   :用于算式可读性,与运算先后性                ", 位置8的' ':非法字符
9: Error: "         在本次混合运算符测试中,以五类运算符为单位测试,而非以某个运算符为单位测试  ", 位置8的' ':非法字符
10: Error: "         各个数学函数的正误测试请见基本运算符测试                  ", 位置8的' ':非法字符
11: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
12: Error: "       1. 基本加减乘除正误示例                        ", 位置11的'基':非法字符
13: 正 确: "                 4 * 8 / 16                          ", 运算结果 = 2.0, 理论值 = 2.0
14: 正 确: "4*8/16                                               ", 运算结果 = 2.0, 理论值 = 2.0
15: Error: "4*8/0                                                ", 位置4的'/':除数不能为0
16: 正 确: "            (2 - 4 * 8 / 16) * 2                     ", 运算结果 = 0, 理论值 = 0.0
17: 正 确: " (2-4*8/16)*2                                        ", 运算结果 = 0, 理论值 = 0.0
18: Error: "((2-4*8/16)*2                                        ", 位置1的'(':没有匹配的')'
19: 正 确: "       (1 + (2 - 4 * 8 / 16) * 2)                    ", 运算结果 = 1.0, 理论值 = 1.0
20: 正 确: "(1+(2-4*8/16)*2)                                     ", 运算结果 = 1.0, 理论值 = 1.0
21: Error: "(1 (2-4*8/16)*2)                                     ", 位置4的'(':左括号出现在不合理的位置
22: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
23: Error: "       2. 绝对值函数正误示例                          ", 位置11的'绝':非法字符
24: 正 确: "              (abs(-4) * 8) / 16                     ", 运算结果 = 2.0, 理论值 = 2.0
25: 正 确: "(abs (-4)*8)/16                                      ", 运算结果 = 2.0, 理论值 = 2.0
26: Error: "(absa(-4)*8)/16                                      ", 位置2的'absa':非法字符
27: 正 确: "         2 * -(abs(-4) * 8) / 16                     ", 运算结果 = -4.0, 理论值 = -4.0
28: 正 确: "2*-(abs(-4)*8)/16                                    ", 运算结果 = -4.0, 理论值 = -4.0
29: Error: "2**(abs(-4)*8)/16                                    ", 位置2的'*':*缺少运算对象
30: 正 确: "  sqrt -(2 * -(abs(-4) * 8) / 16)                    ", 运算结果 = 2.0, 理论值 = 2.0
31: 正 确: "sqrt-(2*-(abs(-4)*8)/16)                             ", 运算结果 = 2.0, 理论值 = 2.0
32: Error: "sqrt (2*-(abs(-4)*8)/16)                             ", 位置1的'sqrt':只能对正数开根号
33: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
34: Error: "       3. 指数函数与对数函数正误示例                   ", 位置11的'指':非法字符
35: 正 确: "             sqrt ((2 * 1) ^ (3 - 1))                ", 运算结果 = 2.0, 理论值 = 2.0
36: 正 确: "sqrt ((2*1)^(3-1))                                   ", 运算结果 = 2.0, 理论值 = 2.0
37: Error: "sq rt((2*1)^(3-1))                                   ", 位置1的'sq':非法字符
38: 正 确: "        exp( sqrt ((2 * 1) ^ (3 - 1)) )              ", 运算结果 = 7.39, 理论值 = 7.38905609893065
39: 正 确: "exp(sqrt((2*1)^(3-1)))                               ", 运算结果 = 7.39, 理论值 = 7.38905609893065
40: Error: "expsqrt ((2*1)^(3-1)))                               ", 位置22的')':没有匹配的'('
41: 正 确: "     ln exp( sqrt ((2 * 1) ^ (3 - 1)) )              ", 运算结果 = 2.0, 理论值 = 2.0
42: 正 确: "ln exp(sqrt((2*1)^(3-1)))                            ", 运算结果 = 2.0, 理论值 = 2.0
43: Error: "ln(exp(sqrt((2*1)^(3-1)))                            ", 位置3的'(':没有匹配的')'
44: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
45: Error: "       4. 三角函数正误示例                            ", 位置11的'三':非法字符
46: 正 确: "        (  sin((pi / 2)) - cos((pi / 3))  )          ", 运算结果 = 0.5, 理论值 = 0.4999999999999999
47: 正 确: "(sin((pi/2))-cos((pi/3)))                            ", 运算结果 = 0.5, 理论值 = 0.4999999999999999
48: Error: "[sin[[pi/2))-cos[[pi/3)))                            ", 位置11的')':没有匹配的'('
49: 正 确: "   (4 ^ (  sin((pi / 2)) - cos((pi / 3))  ))         ", 运算结果 = 2.0, 理论值 = 1.9999999999999998
50: 正 确: "(4^(sin((pi/2))-cos((pi/3))))                        ", 运算结果 = 2.0, 理论值 = 1.9999999999999998
51: Error: "[4^(sin((pi/2))-cos((pi/3))))                        ", 位置29的')':没有匹配的'('
52: 正 确: "  ((4 ^ (  sin((pi / 2)) - cos((pi / 3))  )) + 1)!   ", 运算结果 = 6.0, 理论值 = 6
53: 正 确: "((4^(sin((pi/2))-cos((pi/3))))+1)!                   ", 运算结果 = 6.0, 理论值 = 6
54: Error: "((4^(sin((pi/2))-cos((pi/3))))-9)!                   ", 位置34的'!':只能对正整数阶乘
55: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
56: Error: "       5. 取整函数正误示例                            ", 位置11的'取':非法字符
57: Error: "       注:下面的三个round测试中有大小写区别,         ", 位置8的'注':非法字符
58: Error: "           但会在运算时统一为小写,                    ", 位置12的'但':非法字符
59: Error: "           所以在结果展示中看起来一样。                ", 位置12的'所':非法字符
60: 正 确: "                 ln e  +  lg 10  + e                 ", 运算结果 = 4.72, 理论值 = 4.718281828459045
61: 正 确: "ln e + lg 10 + e                                     ", 运算结果 = 4.72, 理论值 = 4.718281828459045
62: Error: "lne  + lg 10 + e                                     ", 位置1的'lne':非法字符
63: 正 确: "         round ( ln e  +  lg 10  + e )               ", 运算结果 = 5.0, 理论值 = 5
64: 正 确: "         round ( ln e  +  lg 10  + e )               ", 运算结果 = 5.0, 理论值 = 5
65: 正 确: "         round ( ln e  +  lg 10  + e )               ", 运算结果 = 5.0, 理论值 = 5
66: 正 确: "         ceil  ( ln e  +  lg 10  + e )               ", 运算结果 = 5.0, 理论值 = 5
67: 正 确: "ceil(ln e + lg 10 + e)                               ", 运算结果 = 5.0, 理论值 = 5
68: Error: "ceil(ln e + lg 10 + e)错                             ", 位置23的'错':非法字符
69: 正 确: "         floor ( ln e  +  lg 10  + e )               ", 运算结果 = 4.0, 理论值 = 4
70: 正 确: "floor(ln e + lg 10 + e)                              ", 运算结果 = 4.0, 理论值 = 4
71: Error: "floor(ln e + lg 10 + e)a                             ", 位置24的'a':非法字符
72: 正 确: "    sqrt floor ( ln e  +  lg 10  + e )               ", 运算结果 = 2.0, 理论值 = 2.0
73: 正 确: "sqrt(floor(ln e + lg 10 + e))                        ", 运算结果 = 2.0, 理论值 = 2.0
74: Error: "sqrt(floor(ln e + lg 10 + e))?                       ", 位置30的'?':非法字符
75: 正 确: " 1+ sqrt floor ( ln e  +  lg 10  + e ) +1            ", 运算结果 = 4.0, 理论值 = 4.0
76: 正 确: "1+sqrt(floor(ln e + lg 10 + e))+1                    ", 运算结果 = 4.0, 理论值 = 4.0
77: Error: "1+sqrt(floor(ln e + lg 10 + e))+1$$$$$               ", 位置34的'$':非法字符
78: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
79: Error: "       6. 三角函数与弧度角度转换函数正误示例           ", 位置11的'三':非法字符
80: 正 确: "             sin(rad(60)) - sin(pi/3)                ", 运算结果 = 0, 理论值 = 0.0
81: 正 确: "sin(rad(60))-sin(pi/3)                               ", 运算结果 = 0, 理论值 = 0.0
82: Error: "sin(rad(60))-sin(p /3)                               ", 位置18的'p':非法字符
83: 正 确: "        cos( sin(rad(60)) - sin(pi/3) )              ", 运算结果 = 1.0, 理论值 = 1.0
84: 正 确: "cos(sin(rad(60))-sin(pi/3))                          ", 运算结果 = 1.0, 理论值 = 1.0
85: Error: "cossin((rad(60))-sin(pi/3))                          ", 位置1的'cossin':非法字符
86: 正 确: "   rad( cos( sin(rad(60)) - sin(pi/3) ) *180)        ", 运算结果 = 3.14, 理论值 = 3.141592653589793
87: 正 确: "rad(cos(sin(rad(60))-sin(pi/3))*180)                 ", 运算结果 = 3.14, 理论值 = 3.141592653589793
88: Error: "rad(coss(in(rad(60))-sin(pi/3))*180)                 ", 位置5的'coss':非法字符
89: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
90: Error: "       7. 三角函数与角度转弧度函数正误示例             ", 位置11的'三':非法字符
91: Error: "          注:部分运算需要更高的计算时间才能提高精度。  ", 位置11的'注':非法字符
92: Error: "          注:使用self.calc.math.set_max_loop(int)提高循环次数以提高精度。", 位置11的'注':非法字符
93: 正 确: "                   sin asin 1                        ", 运算结果 = 1.0, 理论值 = 1.0
94: 正 确: "sin(asin(1))                                         ", 运算结果 = 1.0, 理论值 = 1.0
95: Error: "sin(asin( ))                                         ", 位置12的')':右括号出现在不合理的位置
96: 正 确: "              pi * sin asin 1 + tan (pi/4)-1         ", 运算结果 = 3.14, 理论值 = 3.141592653589793
97: 正 确: "pi*sin(asin(1))+tan(pi/4)-1                          ", 运算结果 = 3.14, 理论值 = 3.141592653589793
98: Error: "pi*sin(asin(1))+tan(pi/0)-1                          ", 位置23的'/':除数不能为0
99: 与理论值不符: "         deg( pi * sin asin 1 + tan (pi/4)-1 )       ", 运算结果 = 179.71, 理论值 = 180.0
100: 与理论值不符: "deg(pi*sin(asin(1))+tan(pi/4)-1)                     ", 运算结果 = 179.71, 理论值 = 180.0
101: Error: "deg(pi*sin(asin(2))+tan(pi/4)-1)                     ", 位置12的'asin':只能对-1到1之间的数开反正弦
102: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
103: Error: "       8. 冗余运算符与括号正误示例                    ", 位置11的'冗':非法字符
104: 正 确: "          (([-- --(-- 1)--1]))                       ", 运算结果 = 2.0, 理论值 = 2
105: 正 确: "(([----(--1)--1]))                                   ", 运算结果 = 2.0, 理论值 = 2
106: Error: "(([----(--1)--1)])                                   ", 位置16的')':没有匹配的'('
107: 正 确: "  abs-abs-(((-- --(-- 1)--1)))                       ", 运算结果 = 2.0, 理论值 = 2
108: 正 确: "abs-abs-(((----(--1)--1)))                           ", 运算结果 = 2.0, 理论值 = 2
109: Error: "abs-abs-[((----(--1)--1)))                           ", 位置26的')':没有匹配的'('
110: 正 确: "  abs-abs-(((-- --[-- 1]--1))) +++++++abs((+++-1))   ", 运算结果 = 3.0, 理论值 = 3
111: 正 确: "abs(abs(----[--1]--1))+++++++abs(+++-1)              ", 运算结果 = 3.0, 理论值 = 3
112: Error: "abs(abs(----[--1)--1))+++++++abs(+++-1)              ", 位置17的')':没有匹配的'('
113: Error: "----------------------------------------------------------------------------------", 位置82的'+':出现在末尾的运算符
测试结束,耗时:247毫秒

You may also like...

发表评论

您的电子邮箱地址不会被公开。

88 − = 79