@mi-avalon/libs 0.0.25 → 0.0.27

package/dist/utils/calc.js

@@ -1,92 +1,366 @@
 class CMX {
+    static factorialCache = new Map();
     /**
-     ** 加
-     **/
-    add = function (arg1, arg2) {
-        let r1, r2, m, c;
-        try {
-            r1 = arg1.toString().split('.')[1].length;
-        }
-        catch (e) {
-            r1 = 0;
-        }
-        try {
-            r2 = arg2.toString().split('.')[1].length;
-        }
-        catch (e) {
-            r2 = 0;
-        }
-        c = Math.abs(r1 - r2);
-        m = Math.pow(10, Math.max(r1, r2));
-        if (c > 0) {
-            let cm = Math.pow(10, c);
-            if (r1 > r2) {
-                arg1 = Number(arg1.toString().replace('.', ''));
-                arg2 = Number(arg2.toString().replace('.', '')) * cm;
-            }
-            else {
-                arg1 = Number(arg1.toString().replace('.', '')) * cm;
-                arg2 = Number(arg2.toString().replace('.', ''));
+     * 获取数字的小数位数长度
+     * @private
+     * @param num 要检查的数字
+     * @returns 小数位数长度
+     */
+    static getDecimalLength(num) {
+        const str = num.toString();
+        const decimalIndex = str.indexOf('.');
+        return decimalIndex === -1 ? 0 : str.length - decimalIndex - 1;
+    }
+    /**
+     * 将数字转换为整数（移除小数点）
+     * @private
+     * @param num 要转换的数字
+     * @param decimalPlaces 需要补零的小数位数
+     * @returns 转换后的整数值
+     */
+    static toInteger(num, decimalPlaces) {
+        const str = num.toString().replace('.', '');
+        return Number(str) * Math.pow(10, decimalPlaces);
+    }
+    /**
+     * 精确加法运算（支持多个参数）
+     * @param args 要相加的数字序列
+     * @returns 所有数字的和
+     * @example
+     * cmx.add(0.1, 0.2) // 返回 0.3
+     * cmx.add(1, 2, 3) // 返回 6
+     */
+    add(...args) {
+        if (args.length < 2)
+            return args[0] || 0;
+        return args.reduce((acc, current) => {
+            // 获取两个数的小数位数
+            const r1 = CMX.getDecimalLength(acc);
+            const r2 = CMX.getDecimalLength(current);
+            // 计算最大小数位数和对应的10的幂
+            const maxDecimal = Math.max(r1, r2);
+            const m = Math.pow(10, maxDecimal);
+            // 将两个数调整为相同小数位数的整数
+            const adjusted1 = CMX.toInteger(acc, maxDecimal - r1);
+            const adjusted2 = CMX.toInteger(current, maxDecimal - r2);
+            // 相加后还原小数位
+            return (adjusted1 + adjusted2) / m;
+        });
+    }
+    /**
+     * 精确减法运算
+     * @param arg1 被减数
+     * @param arg2 减数
+     * @returns 两数之差
+     * @example
+     * cmx.sub(0.3, 0.1) // 返回 0.2
+     */
+    sub(arg1, arg2) {
+        const r1 = CMX.getDecimalLength(arg1);
+        const r2 = CMX.getDecimalLength(arg2);
+        const maxDecimal = Math.max(r1, r2);
+        const m = Math.pow(10, maxDecimal);
+        // 先转换为整数运算，再还原小数位
+        return Number(((arg1 * m - arg2 * m) / m).toFixed(maxDecimal));
+    }
+    /**
+     * 精确乘法运算（支持多个参数）
+     * @param args 要相乘的数字序列
+     * @returns 所有数字的乘积
+     * @example
+     * cmx.mul(0.1, 0.2) // 返回 0.02
+     * cmx.mul(2, 3, 4) // 返回 24
+     */
+    mul(...args) {
+        if (args.length < 2)
+            return args[0] || 0;
+        return args.reduce((acc, current) => {
+            // 计算总小数位数
+            const decimalPlaces = CMX.getDecimalLength(acc) + CMX.getDecimalLength(current);
+            // 移除小数点转换为整数
+            const adjusted1 = Number(acc.toString().replace('.', ''));
+            const adjusted2 = Number(current.toString().replace('.', ''));
+            // 相乘后还原总小数位
+            return (adjusted1 * adjusted2) / Math.pow(10, decimalPlaces);
+        });
+    }
+    /**
+     * 精确除法运算
+     * @param arg1 被除数
+     * @param arg2 除数
+     * @returns 两数之商
+     * @throws {Error} 除数为零时抛出错误
+     * @example
+     * cmx.div(0.3, 0.1) // 返回 3
+     */
+    div(arg1, arg2) {
+        if (arg2 === 0)
+            throw new Error('除数不能为零');
+        // 添加误差补偿
+        const compensation = 1 + Number.EPSILON;
+        const t1 = CMX.getDecimalLength(arg1);
+        const t2 = CMX.getDecimalLength(arg2);
+        const r1 = Number(arg1.toString().replace('.', '')) * compensation;
+        const r2 = Number(arg2.toString().replace('.', '')) * compensation;
+        return (r1 / r2) * Math.pow(10, t2 - t1);
+    }
+    /**
+     * 精确四舍五入
+     * @param num 要舍入的数字
+     * @param decimalPlaces 保留的小数位数（默认为0）
+     * @returns 舍入后的数字
+     * @example
+     * cmx.round(1.2345, 2) // 返回 1.23
+     */
+    round(num, decimalPlaces = 0) {
+        const m = Math.pow(10, decimalPlaces);
+        return Math.round(num * m) / m;
+    }
+    /**
+     * 计算百分比值
+     * @param value 基础值
+     * @param percent 百分比
+     * @returns 计算后的百分比值
+     * @example
+     * cmx.percent(200, 15) // 返回 30（200的15%）
+     */
+    percent(value, percent) {
+        return this.div(this.mul(value, percent), 100);
+    }
+    /**
+     * 计算平均数
+     * @param args 要计算平均数的数字序列
+     * @returns 平均数
+     * @example
+     * cmx.average(1, 2, 3) // 返回 2
+     */
+    average(...args) {
+        if (args.length === 0)
+            return 0;
+        return this.div(args.reduce((a, b) => this.add(a, b)), args.length);
+    }
+    /**
+     * 判断两个数是否近似相等（解决浮点数精度问题）
+     * @param a 第一个数
+     * @param b 第二个数
+     * @param tolerance 允许的误差范围（默认为1e-10）
+     * @returns 如果差值小于误差范围则返回true
+     * @example
+     * cmx.approxEqual(0.1 + 0.2, 0.3) // 返回 true
+     */
+    approxEqual(a, b, tolerance = 1e-10) {
+        return Math.abs(this.sub(a, b)) < tolerance;
+    }
+    /**
+     * 计算自然对数（ln(x)）
+     * @param num 要计算对数的数字
+     * @param decimalPlaces 结果保留的小数位数（默认保留10位）
+     * @returns 自然对数值
+     * @throws {Error} 当输入小于等于0时抛出错误
+     * @example
+     * cmx.ln(1)      // 返回 0
+     * cmx.ln(Math.E) // 返回 1
+     */
+    ln(num, decimalPlaces = 10) {
+        if (num <= 0)
+            throw new Error('对数函数的输入必须为正数');
+        if (num === 1)
+            return 0;
+        // 使用泰勒级数展开计算自然对数
+        let result = 0;
+        const tolerance = Math.pow(10, -decimalPlaces - 1);
+        let term = this.div(this.sub(num, 1), this.add(num, 1));
+        const termSquared = this.mul(term, term);
+        let currentTerm = term;
+        let n = 1;
+        do {
+            result = this.add(result, this.div(currentTerm, n));
+            currentTerm = this.mul(currentTerm, termSquared);
+            n += 2;
+        } while (Math.abs(currentTerm) > tolerance);
+        return this.round(this.mul(2, result), decimalPlaces);
+    }
+    /**
+     * 高精度指数函数（解决Math.exp的精度问题）
+     * @param x 指数
+     * @param decimalPlaces 精度位数（默认10位）
+     * @returns e^x 的精确值
+     * @example
+     * cmx.exp(1)  // 2.7182818285（比Math.exp(1)更可控精度）
+     * cmx.exp(-3.5)  // 0.0301973834
+     */
+    exp(x, decimalPlaces = 10) {
+        // 添加提前终止条件
+        if (x === 0)
+            return 1;
+        if (x === 1)
+            return Math.E;
+        let result = 1;
+        let term = 1;
+        const tolerance = Math.pow(10, -decimalPlaces - 1);
+        let n = 1;
+        let prevResult = 0;
+        do {
+            prevResult = result;
+            term = this.div(this.mul(term, x), n);
+            result = this.add(result, term);
+            n++;
+        } while (Math.abs(term) > tolerance &&
+            !this.approxEqual(result, prevResult, tolerance) // 新增终止条件
+        );
+        return this.round(result, decimalPlaces);
+    }
+    /**
+     * 精确计算平方根（解决Math.sqrt的精度问题）
+     * @param num 输入数字（必须 ≥0）
+     * @param decimalPlaces 结果精度（默认10位）
+     * @returns 精确的平方根值
+     * @throws {Error} 输入负数时抛出
+     * @example
+     * cmx.sqrt(2) // 1.4142135624 (Math.sqrt(2)可能产生微小误差)
+     */
+    sqrt(num, decimalPlaces = 10) {
+        if (num < 0)
+            throw new Error('负数平方根需使用复数计算');
+        if (num === 0)
+            return 0;
+        // 牛顿迭代法+自定义精度控制
+        let guess = num / 2;
+        const tolerance = Math.pow(10, -decimalPlaces - 1);
+        do {
+            guess = this.div(this.add(guess, this.div(num, guess)), 2);
+        } while (Math.abs(this.sub(this.mul(guess, guess), num)) > tolerance);
+        return this.round(guess, decimalPlaces);
+    }
+    /**
+     * 安全对数计算（解决Math.log的边界问题）
+     * @param num 输入数字（支持 ≤0 的特殊处理）
+     * @param options 配置项：
+     *   - safe: 是否返回安全值（默认true）
+     *   - replaceNeg: 负数替换值（默认NaN）
+     *   - replaceZero: 零替换值（默认-Infinity）
+     * @returns 处理后的结果
+     * @example
+     * cmx.safeLog(-1) // NaN（Math.log直接报错）
+     * cmx.safeLog(0)  // -Infinity（可配置替换值）
+     */
+    safeLog(num, options = {}) {
+        const { safe = true, replaceNeg = NaN, replaceZero = -Infinity } = options;
+        if (num > 0)
+            return Math.log(num);
+        if (!safe)
+            throw new Error('Invalid input');
+        return num === 0 ? replaceZero : replaceNeg;
+    }
+    /**
+     * 精确阶乘（解决Math无阶乘方法的问题）
+     * @param n 输入整数（0≤n≤170）
+     * @returns 精确结果（超过170返回Infinity）
+     * @example
+     * cmx.factorial(20) // 2432902008176640000（JS整数精确范围）
+     */
+    factorial(n) {
+        if (!Number.isInteger(n) || n < 0)
+            return NaN;
+        if (n < 0)
+            return NaN;
+        if (n > Number.MAX_SAFE_INTEGER) {
+            // 使用BigInt计算后转换为科学计数法
+            let result = BigInt(1);
+            for (let i = 2; i <= n; i++) {
+                result *= BigInt(i);
             }
+            return Number(result.toString());
         }
-        else {
-            arg1 = Number(arg1?.toString().replace('.', ''));
-            arg2 = Number(arg2?.toString().replace('.', ''));
-        }
-        return (arg1 + arg2) / m;
-    };
-    /**
-     ** 减
-     **/
-    sub = function (arg1, arg2) {
-        let r1, r2, m, n;
-        try {
-            r1 = arg1.toString().split('.')[1].length;
-        }
-        catch (e) {
-            r1 = 0;
-        }
-        try {
-            r2 = arg2.toString().split('.')[1].length;
-        }
-        catch (e) {
-            r2 = 0;
+        if (n > 170)
+            return Infinity;
+        if (CMX.factorialCache.has(n))
+            return CMX.factorialCache.get(n);
+        let result = 1;
+        for (let i = 2; i <= n; i++) {
+            if (CMX.factorialCache.has(i)) {
+                result = CMX.factorialCache.get(i);
+                continue;
+            }
+            result = this.mul(result, i);
+            CMX.factorialCache.set(i, result); // 缓存中间结果
         }
-        m = Math.pow(10, Math.max(r1, r2)); //last modify by deeka //动态控制精度长度
-        n = r1 >= r2 ? r1 : r2;
-        return Number(((arg1 * m - arg2 * m) / m).toFixed(n));
-    };
-    /**
-     ** 乘
-     **/
-    mul = function (arg1, arg2) {
-        let m = 0, s1 = arg1.toString(), s2 = arg2.toString();
-        try {
-            m += s1.split('.')[1].length;
+        return result;
+    }
+    /**
+     * 双曲函数精确计算（解决大数精度问题）
+     * @param x 输入值
+     * @param type 函数类型：'sinh' | 'cosh' | 'tanh'
+     * @param decimalPlaces 精度（默认10位）
+     * @returns 计算结果
+     * @example
+     * cmx.hypFunc(1, 'tanh') // 0.761594156（比Math.tanh更精确）
+     */
+    hypFunc(x, type, decimalPlaces = 10) {
+        // 使用泰勒展开式避免大数计算误差
+        const expX = this.exp(x, decimalPlaces + 2);
+        const expNegX = this.exp(-x, decimalPlaces + 2);
+        switch (type) {
+            case 'sinh':
+                return this.round(this.div(this.sub(expX, expNegX), 2), decimalPlaces);
+            case 'cosh':
+                return this.round(this.div(this.add(expX, expNegX), 2), decimalPlaces);
+            case 'tanh':
+                return this.round(this.div(this.sub(expX, expNegX), this.add(expX, expNegX)), decimalPlaces);
+            default:
+                throw new Error('不支持的函数类型');
         }
-        catch (e) { }
-        try {
-            m += s2.split('.')[1].length;
+    }
+    /**
+     * 精确排列组合（解决大数计算问题）
+     * @param n 总数
+     * @param k 选取数
+     * @param type 计算类型：'permutation' | 'combination'
+     * @returns 精确结果
+     * @example
+     * cmx.permComb(100, 5, 'combination') // 75287520
+     */
+    permComb(n, k, type) {
+        if (!Number.isInteger(n) || !Number.isInteger(k) || k > n || k < 0) {
+            return NaN;
         }
-        catch (e) { }
-        return ((Number(s1.replace('.', '')) * Number(s2.replace('.', ''))) / Math.pow(10, m));
-    };
-    /**
-     ** 除
-     **/
-    div = function (arg1, arg2) {
-        let t1 = 0, t2 = 0, r1, r2;
-        try {
-            t1 = arg1.toString().split('.')[1].length;
+        let result = 1;
+        for (let i = 0; i < k; i++) {
+            result = this.mul(result, n - i);
+            if (type === 'combination') {
+                result = this.div(result, i + 1);
+            }
         }
-        catch (e) { }
-        try {
-            t2 = arg2.toString().split('.')[1].length;
+        return result;
+    }
+    /**
+     * 计算最大公约数（GCD）
+     * @param a 第一个数字
+     * @param b 第二个数字
+     * @returns 最大公约数
+     * @example
+     * cmx.gcd(48, 18) // 返回 6
+     */
+    gcd(a, b) {
+        a = Math.abs(a);
+        b = Math.abs(b);
+        while (b !== 0) {
+            const temp = b;
+            b = a % b;
+            a = temp;
         }
-        catch (e) { }
-        r1 = Number(arg1.toString().replace('.', ''));
-        r2 = Number(arg2.toString().replace('.', ''));
-        return (r1 / r2) * Math.pow(10, t2 - t1);
-    };
+        return a;
+    }
+    /**
+     * 计算最小公倍数（LCM）
+     * @param a 第一个数字
+     * @param b 第二个数字
+     * @returns 最小公倍数
+     * @example
+     * cmx.lcm(12, 15) // 返回 60
+     */
+    lcm(a, b) {
+        return this.div(this.mul(a, b), this.gcd(a, b));
+    }
 }
 export const cmx = new CMX();

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@mi-avalon/libs",
 	"private": false,
-	"version": "0.0.25",
+	"version": "0.0.27",
 	"type": "module",
 	"main": "./dist/index.umd.js",
 	"module": "./dist/index.es.js",
@@ -16,7 +16,7 @@
 		"dev": "vite",
 		"build": "vite build && tsc",
 		"preview": "vite preview",
-		"pub": "npm run build && npm publish"
+		"pub": "pnpm build && npm run publish"
 	},
 	"devDependencies": {
 		"@types/node": "^20.0.0",
@@ -34,5 +34,8 @@
 		"antd": "^4.0.0 || ^5.0.0",
 		"react": "^16.8.0 || ^17.0.0 || ^18.0.0",
 		"react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0"
+	},
+	"dependencies": {
+		"@ant-design/icons": "^6.0.1"
 	}
 }