AIWROK软件数学方法集合小结 - 自动发帖软件

这段代码定义了一个名为数学的对象，该对象封装了一系列的数学函数和常量，适用于运行在Android设备上、使用Rhino 1.7.13版本的JavaScript引擎，并且遵循ES5标准。每个函数都有详细的注释说明其用途、参数和返回值。

常量定义:

__二为底的e的对数、_二的平方根、二的平方根的倒数、十的自然对数、算术常量e和圆周率这些函数都返回JavaScript内置的数学常量，如Math.LOG2E、Math.SQRT2等。

对数和指数函数:

e为底的自然对数：计算给定数字x的自然对数（底数为e），如果输入无效（非数字或小于等于0），则返回null。
e的x次幂：计算e的x次幂，如果输入x无效（非数字），则返回null。

三角函数:

x与y的弧度、余弦、正弦和正切分别用于计算两个坐标点的弧度以及单一弧度值对应的余弦、正弦和正切值。

数值处理函数:

上取整、下取整、取小数、取整分别用于对数字进行上取整、下取整、取小数部分和取整数部分。
保留小数位数用于将数字保留指定的小数位数。
取最大值和取最小值用于从一组数字中找出最大值和最小值。
四舍五入用于将数字四舍五入到最接近的整数。

字符和数字转换函数:

字符转数字将字符串转换为数字，如果字符串不能转换为数字，则返回null。
格式化长度将数字转换为字符串形式表示，无论输入的数字是否有小数部分。

高级数学函数:

双曲正切值、反余弦、反正切和反正弦分别用于计算双曲正切、反余弦、反正切和反正弦的值。

随机数生成函数:

随机小数生成指定范围内的随机小数。
随机整数生成指定范围内的随机整数。
零至一随机数生成0到1之间的随机小数。

错误处理:

每个函数都包含错误处理逻辑，确保在输入无效时返回null而不是抛出错误。

Rhino环境下的导出:

如果运行环境是Rhino，则将数学对象导出为全局对象，以便在其他脚本中使用。

测试用例:

代码末尾包含了一系列测试用例，用于验证上述函数的正确性。通过调用函数并打印结果来检查函数是否按预期工作。

注意：在代码中，反正弦函数的实现有一个小错误，应该是if (typeof x !== "number" || isNaN(x) || x < -1 || x > 1)，而不是if (typeof x === "number" || isNaN(x) || x < -1 || x > 1)。修正这个错误可以确保反正弦函数在输入无效时也能返回null。

此外，还有一些格式化输出的函数，如转小数字符和转指数计数法，用于将数字转换为特定格式的字符串。这些函数同样包含了错误处理，确保输入有效。

/**
* //适用本文档ES5系统安卓 JavaScript引擎Rhino
* 数学方法全集
* 运行环境: Android + Rhino 1.7.13 + ES5
*/

// 定义数学对象
var 数学 = {};

/**
* 二为底的e的对数
* @setting ROOT 代理激活无障碍键鼠硬件
* @returns {number} 返回二为底的e的对数
*/
数学.__二为底的e的对数 = function() {
return Math.LOG2E;
};

/**
* 二的平方根
* @setting ROOT 代理激活无障碍键鼠硬件
* @returns {number} 返回二的平方根
*/
数学._二的平方根 = function() {
return Math.SQRT2;
};

/**
* e为底的自然对数
* @setting ROOT 代理激活无障碍键鼠硬件
* @param {number} x - 要计算自然对数的数字
* @returns {number|null} 返回自然对数值或null
*/
数学.e为底的自然对数 = function(x) {
try {
if (typeof x !== "number" || isNaN(x) || x <= 0) return null;
return Math.log(x);
} catch (e) {
return null;
}
};

/**
* e的x次幂
* @setting ROOT 代理激活无障碍键鼠硬件
* @param {number} x - 指数
* @returns {number|null} 返回e的x次幂或null
*/
数学.e的x次幂 = function(x) {
try {
if (typeof x !== "number" || isNaN(x)) return null;
return Math.exp(x);
} catch (e) {
return null;
}
};

/**
* 计算x与y的弧度
* @setting ROOT 代理激活无障碍键鼠硬件
* @param {number} y - y坐标
* @param {number} x - x坐标
* @returns {number|null} 返回弧度值或null
*/
数学.x与y的弧度 = function(y, x) {
try {
if (typeof x !== "number" || typeof y !== "number" || isNaN(x) || isNaN(y)) return null;
return Math.atan2(y, x);
} catch (e) {
return null;
}
};

/**
* 上取整
* @setting ROOT 代理激活无障碍键鼠硬件
* @param {number} num - 要上取整的数字
* @returns {number|null} 返回上取整后的值或null
*/
数学.上取整 = function(num) {
try {
if (typeof num !== "number" || isNaN(num)) return null;
return Math.ceil(num);
} catch (e) {
return null;
}
};

/**
* 下取整
* @setting ROOT 代理激活无障碍键鼠硬件
* @param {number} num - 要下取整的数字
* @returns {number|null} 返回下取整后的值或null
*/
数学.下取整 = function(num) {
try {
if (typeof num !== "number" || isNaN(num)) return null;
return Math.floor(num);
} catch (e) {
return null;
}
};

/**
* 二的平方根的倒数
* @setting ROOT 代理激活无障碍键鼠硬件
* @returns {number} 返回二的平方根的倒数
*/
数学.二的平方根的倒数 = function() {
return Math.SQRT1_2;
};

/**
* 余弦
* @setting ROOT 代理激活无障碍键鼠硬件
* @param {number} x - 弧度值
* @returns {number|null} 返回余弦值或null
*/
数学.余弦 = function(x) {
try {
if (typeof x !== "number" || isNaN(x)) return null;
return Math.cos(x);
} catch (e) {
return null;
}
};

/**
* 保留小数位数
* @setting ROOT 代理激活无障碍键鼠硬件
* @param {number} num - 要处理的数字
* @param {number} digits - 保留的小数位数
* @returns {number|null} 返回处理后的数字或null
*/
数学.保留小数位数 = function(num, digits) {
try {
if (typeof num !== "number" || typeof digits !== "number" ||
isNaN(num) || isNaN(digits) || digits < 0) return null;
return Number(num.toFixed(digits));
} catch (e) {
return null;
}
};

/**
* 十的自然对数
* @setting ROOT 代理激活无障碍键鼠硬件
* @returns {number} 返回十的自然对数
*/
数学.十的自然对数 = function() {
return Math.LN10;
};

/**
* 双曲正切值
* @setting ROOT 代理激活无障碍键鼠硬件
* @param {number} x - 要计算双曲正切的数字
* @returns {number|null} 返回双曲正切值或null
*/
数学.双曲正切值 = function(x) {
try {
if (typeof x !== "number" || isNaN(x)) return null;
return Math.tanh(x);
} catch (e) {
return null;
}
};

/**
* 反余弦
* @setting ROOT 代理激活无障碍键鼠硬件
* @param {number} x - 要计算反余弦的数字
* @returns {number|null} 返回反余弦值或null
*/
数学.反余弦 = function(x) {
try {
if (typeof x !== "number" || isNaN(x) || x < -1 || x > 1) return null;
return Math.acos(x);
} catch (e) {
return null;
}
};

/**
* 反正切
* @setting ROOT 代理激活无障碍键鼠硬件
* @param {number} x - 要计算反正切的数字
* @returns {number|null} 返回反正切值或null
*/
数学.反正切 = function(x) {
try {
if (typeof x !== "number" || isNaN(x)) return null;
return Math.atan(x);
} catch (e) {
return null;
}
};

/**
* 反正弦
* @setting ROOT 代理激活无障碍键鼠硬件
* @param {number} x - 要计算反正弦的数字
* @returns {number|null} 返回反正弦值或null
*/
数学.反正弦 = function(x) {
try {
if (typeof x !== "number" || isNaN(x) || x < -1 || x > 1) return null;
return Math.asin(x);
} catch (e) {
return null;
}
};

/**
* 取小数部分
* @setting ROOT 代理激活无障碍键鼠硬件
* @param {number} num - 要取小数部分的数字
* @returns {number|null} 返回小数部分或null
*/
数学.取小数 = function(num) {
try {
if (typeof num !== "number" || isNaN(num)) return null;
return num - Math.floor(num);
} catch (e) {
return null;
}
};

/**
* 取整
* @setting ROOT 代理激活无障碍键鼠硬件
* @param {number} num - 要取整的数字
* @returns {number|null} 返回整数部分或null
*/
数学.取整 = function(num) {
try {
if (typeof num !== "number" || isNaN(num)) return null;
return Math.trunc(num);
} catch (e) {
return null;
}
};

/**
* 取最大值
* @setting ROOT 代理激活无障碍键鼠硬件
* @param {...number} nums - 要比较的数字
* @returns {number|null} 返回最大值或null
*/
数学.取最大值 = function() {
try {
if (arguments.length === 0) return null;
for (var i = 0; i < arguments.length; i++) {
if (typeof arguments !== "number" || isNaN(arguments)) return null;
}
return Math.max.apply(null, arguments);
} catch (e) {
return null;
}
};

/**
* 取最小值
* @setting ROOT 代理激活无障碍键鼠硬件
* @param {...number} nums - 要比较的数字
* @returns {number|null} 返回最小值或null
*/
数学.取最小值 = function() {
try {
if (arguments.length === 0) return null;
for (var i = 0; i < arguments.length; i++) {
if (typeof arguments !== "number" || isNaN(arguments)) return null;
}
return Math.min.apply(null, arguments);
} catch (e) {
return null;
}
};

/**
* 四舍五入
* @setting ROOT 代理激活无障碍键鼠硬件
* @param {number} num - 要四舍五入的数字
* @returns {number|null} 返回四舍五入后的值或null
*/
数学.四舍五入 = function(num) {
try {
if (typeof num !== "number" || isNaN(num)) return null;
return Math.round(num);
} catch (e) {
return null;
}
};

/**
* 圆周率
* @setting ROOT 代理激活无障碍键鼠硬件
* @returns {number} 返回圆周率
*/
数学.圆周率 = function() {
return Math.PI;
};

/**
* 字符转数字
* @setting ROOT 代理激活无障碍键鼠硬件
* @param {string} str - 要转换的字符串
* @returns {number|null} 返回转换后的数字或null
*/
数学.字符转数字 = function(str) {
try {
if (typeof str !== "string") return null;
var num = Number(str);
return isNaN(num) ? null : num;
} catch (e) {
return null;
}
};

/**
* 平方根
* @setting ROOT 代理激活无障碍键鼠硬件
* @param {number} num - 要计算平方根的数字
* @returns {number|null} 返回平方根或null
*/
数学.平方根 = function(num) {
try {
if (typeof num !== "number" || isNaN(num) || num < 0) return null;
return Math.sqrt(num);
} catch (e) {
return null;
}
};

/**
* 格式化长度
* @setting ROOT 代理激活无障碍键鼠硬件
* @param {number} num - 要格式化的数字
* @returns {string|null} 返回格式化后的字符串或null
*/
数学.格式化长度 = function(num) {
try {
if (typeof num !== "number" || isNaN(num)) return null;
return num.toString();
} catch (e) {
return null;
}
};

/**
* 正切
* @setting ROOT 代理激活无障碍键鼠硬件
* @param {number} x - 弧度值
* @returns {number|null} 返回正切值或null
*/
数学.正切 = function(x) {
try {
if (typeof x !== "number" || isNaN(x)) return null;
return Math.tan(x);
} catch (e) {
return null;
}
};

/**
* 正弦
* @setting ROOT 代理激活无障碍键鼠硬件
* @param {number} x - 弧度值
* @returns {number|null} 返回正弦值或null
*/
数学.正弦 = function(x) {
try {
if (typeof x !== "number" || isNaN(x)) return null;
return Math.sin(x);
} catch (e) {
return null;
}
};

/**
* 算术常量e
* @setting ROOT 代理激活无障碍键鼠硬件
* @returns {number} 返回算术常量e
*/
数学.算术常量e = function() {
return Math.E;
};

/**
* 绝对值
* @setting ROOT 代理激活无障碍键鼠硬件
* @param {number} num - 要计算绝对值的数字
* @returns {number|null} 返回绝对值或null
*/
数学.绝对值 = function(num) {
try {
if (typeof num !== "number" || isNaN(num)) return null;
return Math.abs(num);
} catch (e) {
return null;
}
};

/**
* 转小数字符
* @setting ROOT 代理激活无障碍键鼠硬件
* @param {number} num - 要转换的数字
* @param {number} [fractionDigits] - 小数位数
* @returns {string|null} 返回转换后的字符串或null
*/
数学.转小数字符 = function(num, fractionDigits) {
try {
if (typeof num !== "number" || isNaN(num)) return null;
return num.toFixed(fractionDigits);
} catch (e) {
return null;
}
};

/**
* 转指数计数法
* @setting ROOT 代理激活无障碍键鼠硬件
* @param {number} num - 要转换的数字
* @param {number} [fractionDigits] - 小数位数
* @returns {string|null} 返回转换后的字符串或null
*/
数学.转指数计数法 = function(num, fractionDigits) {
try {
if (typeof num !== "number" || isNaN(num)) return null;
return num.toExponential(fractionDigits);
} catch (e) {
return null;
}
};

/**
* 随机小数
* @setting ROOT 代理激活无障碍键鼠硬件
* @param {number} min - 最小值
* @param {number} max - 最大值
* @returns {number|null} 返回随机小数或null
*/
数学.随机小数 = function(min, max) {
try {
if (typeof min !== "number" || typeof max !== "number" || isNaN(min) || isNaN(max)) return null;
return Math.random() * (max - min) + min;
} catch (e) {
return null;
}
};

/**
* 随机整数
* @setting ROOT 代理激活无障碍键鼠硬件
* @param {number} min - 最小值
* @param {number} max - 最大值
* @returns {number|null} 返回随机整数或null
*/
数学.随机整数 = function(min, max) {
try {
if (typeof min !== "number" || typeof max !== "number" || isNaN(min) || isNaN(max)) return null;
min = Math.ceil(min);
max = Math.floor(max);
return Math.floor(Math.random() * (max - min + 1)) + min;
} catch (e) {
return null;
}
};

/**
* 零至一随机数
* @setting ROOT 代理激活无障碍键鼠硬件
* @returns {number} 返回0到1之间的随机数
*/
数学.零至一随机数 = function() {
return Math.random();
};

// Rhino环境下的导出
if (typeof Packages != "undefined") {
this["数学"] = 数学;
}

// ===== 测试用例 =====
printl("\n基础常量测试:");
printl("二为底的e的对数: " + 数学.__二为底的e的对数());
printl("二的平方根: " + 数学._二的平方根());
printl("二的平方根的倒数: " + 数学.二的平方根的倒数());

printl("\n对数和指数测试:");
printl("e的2次幂: " + 数学.e的x次幂(2));
printl("ln(10): " + 数学.e为底的自然对数(10));

printl("\n三角函数测试:");
printl("x与y的弧度(1,1): " + 数学.x与y的弧度(1, 1));
printl("cos(0): " + 数学.余弦(0));

printl("\n取整测试:");
printl("3.7上取整: " + 数学.上取整(3.7));
printl("3.7下取整: " + 数学.下取整(3.7));

printl("\n格式化测试:");
printl("3.14159保留2位小数: " + 数学.保留小数位数(3.14159, 2));

printl("\n高级数学函数测试:");
printl("十的自然对数: " + 数学.十的自然对数());
printl("双曲正切值(1): " + 数学.双曲正切值(1));
printl("反余弦(0.5): " + 数学.反余弦(0.5));
printl("反正切(1): " + 数学.反正切(1));
printl("反正弦(0.5): " + 数学.反正弦(0.5));

printl("\n数值处理测试:");
printl("3.14取小数: " + 数学.取小数(3.14));
printl("3.14取整: " + 数学.取整(3.14));
printl("最大值(1,2,3,4,5): " + 数学.取最大值(1,2,3,4,5));
printl("最小值(1,2,3,4,5): " + 数学.取最小值(1,2,3,4,5));
printl("3.5四舍五入: " + 数学.四舍五入(3.5));
printl("圆周率: " + 数学.圆周率());

printl("\n字符和数字转换测试:");
printl("字符转数字('123'): " + 数学.字符转数字('123'));
printl("平方根(16): " + 数学.平方根(16));
printl("格式化长度(3.14159): " + 数学.格式化长度(3.14159));

printl("\n三角函数测试:");
printl("正切(π/4): " + 数学.正切(Math.PI/4));
printl("正弦(π/2): " + 数学.正弦(Math.PI/2));

printl("\n常量和基本运算测试:");
printl("算术常量e: " + 数学.算术常量e());
printl("绝对值(-5): " + 数学.绝对值(-5));

printl("\n数字格式化测试:");
printl("转小数字符(3.14159, 2): " + 数学.转小数字符(3.14159, 2));
printl("转指数计数法(1234.5678, 2): " + 数学.转指数计数法(1234.5678, 2));

printl("\n随机数测试:");
printl("随机小数(0, 1): " + 数学.随机小数(0, 1));
printl("随机整数(1, 10): " + 数学.随机整数(1, 10));
printl("零至一随机数: " + 数学.零至一随机数());

printl("\n错误处理测试:");
printl("无效输入测试(e的x次幂): " + 数学.e的x次幂("abc"));
printl("无效输入测试(保留小数位数): " + 数学.保留小数位数(3.14, -1));
printl("无效输入测试(平方根): " + 数学.平方根(-1));
printl("无效输入测试(字符转数字): " + 数学.字符转数字("abc"));