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.03. 文件计算
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毫秒
共有 0 条评论