dsh-math-calculator 2.1.1 → 2.2.0

package/lib/ops/shared.js

@@ -12,7 +12,16 @@
  * @module dsh-math-calculator/ops/shared
 */
 import { create, all } from 'mathjs';
-import { reportPrecisionLoss } from '../precision-report.js';
+/**
+ * 单位数据表：中文单位归一化要用它派生出展开表。
+ *
+ * `units-data.ts` 是**纯数据模块**（不 import 任何本项目模块），
+ * 所以这里引用它不会造成循环依赖 —— 这一点很关键，
+ * 因为 `units.ts` 的逻辑层会 import 本模块。
+ */
+import { ALL_UNITS } from '../units-data.js';
+import { BASE_UNIT } from '../units.js';
+import { PRECISION_LOSS_THRESHOLD, isDisplayPrecisionExplicit, reportPrecisionLoss, } from '../precision-report.js';
 // ────────────────────────────────────────────────────────────────────────────
 // 错误
 // ────────────────────────────────────────────────────────────────────────────
@@ -47,6 +56,141 @@ export class CalcError extends Error {
  * **不能**删 `typed` / `parse` / `evaluate` —— derivative、simplify 依赖它们。
  */
 import { factorizeInt, makeNsolve, nullspaceOf, rankOf, singularValuesOf } from '../numeric.js';
+// ────────────────────────────────────────────────────────────────────────────
+// 把 units 的单位表注入 evaluate 引擎
+// ────────────────────────────────────────────────────────────────────────────
+/**
+ * 两套单位表长期没打通：`operation:"units"` 认 462 条，`evaluate` 只认 mathjs 自带的那批。
+ *
+ * ## 实测的落差（1107 报告问题 7）
+ *
+ *```
+ *   1 mph to m/s        units=OK   evaluate=Undefined symbol mph
+ *   1 kn  to m/s        units=OK   evaluate=Undefined symbol kn
+ *   1 rpm to Hz         units=OK   evaluate=Undefined symbol rpm
+ *   1 inHg to Pa        units=OK   evaluate=Undefined symbol inHg
+ *   1 cal to J          units=OK   evaluate=Undefined symbol cal
+ *```
+ *
+ * 报告作者为此手填系数（`10*745.7` 而不是 `10 hp`），而**手填系数正是他那
+ * 四起千倍级事故的共同源头**。换句话说：这张表不通，就是在逼人回到出错的老路。
+ *
+ * ## 为什么现在是安全的
+ *
+ * 早先刻意保留了 `createUnit` 的缺口，理由是「表达式求值不许往引擎注入定义」。
+ * 那个顾虑仍然成立，做法是**在构建期注入、注入完再删掉方法**：
+ *
+ *   · 注入发生在 `buildMath` 里，由我们的代码调用，不经过用户表达式
+ *   · 注入完成后照旧 `delete instance.createUnit`，用户表达式里仍然拿不到它
+ *
+ * 所以安全边界**一点没动**，只是把「我们自己能定义单位」这件事用上了。
+ *
+ * ## 三条必须遵守的取舍
+ *
+ * 1. **不覆盖既有单位**。已认识的（`m`/`kg`/`hp`/`psi`…）一律跳过 ——
+ *    mathjs 自己的定义比我们的 `factor` 更精确，改它只会制造回归。
+ * 2. **不收单字母单位**。`c`（光速）与 `G`（万有引力常数）在 units-data 里是常数，
+ *    进了单位表就会把变量 `c`/`G` 吃掉 —— 正是 `guardBareUnitSymbols` 一直防的事。
+ * 3. **不覆盖函数名**。`min`/`max`/`sum` 这类若被注册成单位，
+ *    `1 s to min` 会从「可诊断的报错」变成「静默取错单位」。
+ *
+ * 成本实测：构建一次 40ms（另有 plain 引擎 1ms）。引擎按精度缓存，
+ * 单次调用只付一次，换来 174 个单位可直接写进表达式。
+ *
+ * @param instance - 刚创建好、尚未删除 createUnit 的 mathjs 实例
+ * @returns 实际注入的单位名数量（供测试断言用）
+ */
+function injectUnitTable(instance) {
+    if (!instance || typeof instance.createUnit !== 'function')
+        return 0;
+    /**
+     * units-data 的基准单位写法与 mathjs 略有出入：`m²`/`m³` 上标、`Ω` 希腊字母。
+     * 直接拿去做 definition 会被解析器拒（`Unexpected "²"`），所以映射一次。
+     */
+    const baseOf = (base) => {
+        if (base === 'm²')
+            return 'm^2';
+        if (base === 'm³')
+            return 'm^3';
+        if (base === 'Ω')
+            return 'ohm';
+        return base;
+    };
+    /** mathjs 是否已经认识这个名字（单位、常量或函数都算）。 */
+    const known = (name) => {
+        try {
+            const value = instance.evaluate(name);
+            return Boolean(value && (value.isUnit || typeof value === 'function' || value === true));
+        }
+        catch {
+            return false;
+        }
+    };
+    let added = 0;
+    for (const unit of ALL_UNITS) {
+        const base = baseOf(BASE_UNIT[unit.dimension] ?? '');
+        if (base === '')
+            continue;
+        for (const rawName of [unit.name, ...(unit.aliases ?? [])]) {
+            const name = String(rawName ?? '');
+            /** 只收纯字母：上标、希腊字母、中文都进不了 mathjs 的单位命名空间。 */
+            if (name === '' || /[^A-Za-z]/.test(name))
+                continue;
+            /** 取舍 2：单字母一律不收（会在变量名域里引起冲突）。 */
+            if (name.length === 1)
+                continue;
+            /** 取舍 1：已认识的一律不动。 */
+            if (known(name))
+                continue;
+            /** 别把基准单位名定义成它自己。 */
+            if (name === base)
+                continue;
+            /** 取舍 3：函数名不能被单位覆盖。 */
+            try {
+                const asFunction = instance.evaluate(name + '(1)');
+                if (typeof asFunction !== 'undefined')
+                    continue;
+            }
+            catch {
+                /* 不是函数才往下走 */
+            }
+            /**
+             * ## 注入会顺带改写 mathjs 的「显示基准」，这里必须重置回来
+             *
+             * 这条是踩出来的，代价很具体：注入 `katha`（定义 `66.89 m^2`）之后，
+             *
+             * ```
+             *   1 m^2  →  0.0149499177754522 katha    ← 面积被改写成了卡塔
+             *   1 m^3  →  1086.95 gantang            ← 体积被改写成了甘唐
+             * ```
+             *
+             * 根因在 mathjs 的显示层：`Unit.toString()` 会调 `simplify()`，
+             * 而 `simplify()` 从 `currentUnitSystem` 里挑**第一个**同维度的单位。
+             * `createUnit` 会把新单位登记进 `currentUnitSystem`，于是刚注册的
+             * 冷门单位（卡塔、甘唐）就顶掉了 `m^2`／`m^3`。
+             *
+             * 这个坑最阴的地方：注入的用例全绿（`1 katha to m^2` 算得对），
+             * 坏的是**别的**老用例（`5 亩 + 100 m²`、`1 m^2`）。单测新增断言看不见，
+             * 只有跑全量回归才会暴露。
+             *
+             * ## 为什么重置成 `si` 而不是 `auto`
+             *
+             * 实测两者的输出**原本完全一致**（`1 m^2` 都是 `1 m^2`），
+             * 而 `si` 是只读的固定表，注入改不动它；`auto` 是可写的那个。
+             * 重置成 `si` 之后，注入的单位照样能用（`1 mph to m/s` 仍是 0.44704），
+             * 只是显示基准不再被它们干扰。
+             */
+            try {
+                instance.createUnit(name, { definition: String(unit.factor) + ' ' + base });
+                added += 1;
+            }
+            catch {
+                /* 个别名字 mathjs 拒收（如已有同义前缀），跳过即可 */
+            }
+        }
+    }
+    return added;
+}
 /**
  * 创建一个 mathjs 实例。
  *
@@ -58,6 +202,9 @@ import { factorizeInt, makeNsolve, nullspaceOf, rankOf, singularValuesOf } from
  * 安全：删除 import / createUnit，防止表达式注入任意 JS 或改写单位表。
  * **不能**删 typed/parse/evaluate —— derivative/simplify 依赖它们。
  * 自定义函数（rank/nsolve…）在删除 import **之前**注册，顺序不能反。
+ *
+ * 单位注入（`injectUnitTable`）同理：也在删除 createUnit **之前**做，
+ * 注入完方法即被删除，所以表达式求值仍然拿不到它。
  */
 export function buildMath(numberMode, precision) {
     const instance = create(all, {
@@ -84,6 +231,43 @@ export function buildMath(numberMode, precision) {
     catch {
         /* 注册失败不影响核心运算 */
     }
+    /**
+     * 把 units 的单位表注入进来 —— **必须在删除 createUnit 之前**。
+     *
+     * 注入完照旧删掉方法，所以表达式求值仍然无法注入定义。
+     * 三条取舍（不覆盖既有、不收单字母、不覆盖函数名）见 `injectUnitTable`。
+     */
+    try {
+        injectUnitTable(instance);
+    }
+    catch {
+        /* 注入失败退化为 mathjs 自带单位，不影响核心运算 */
+    }
+    /**
+     * ## 重置显示基准（必须紧跟在注入之后）
+     *
+     * `createUnit` 会把新单位登记进全局的 `currentUnitSystem`，而
+     * `Unit.toString()` 的 `simplify()` 从那里挑**第一个**同维度单位 ——
+     * 于是刚注册的冷门单位（卡塔 66.89 m²、甘唐）顶掉了 `m^2`／`m^3`：
+     *
+     * ```
+     *   1 m^2  →  0.0149499177754522 katha
+     *   1 m^3  →  1086.95 gantang
+     * ```
+     *
+     * 重置成 `si` 而不是 `auto`：两者输出**原本完全一致**，
+     * 而 `si` 是只读固定表、注入改不动它。注入的单位照样能用。
+     *
+     * 注意 `currentUnitSystem` 在 mathjs 里是**模块级全局**，
+     * 所以每个实例都必须重置一次；否则先构建的实例会污染后构建的。
+     */
+    try {
+        if (typeof instance.Unit?.setUnitSystem === 'function')
+            instance.Unit.setUnitSystem('si');
+    }
+    catch {
+        /* 重置失败就退回 auto —— 显示可能被新单位干扰，但计算不受影响 */
+    }
     for (const key of ['import', 'createUnit']) {
         try {
             delete instance[key];
@@ -121,6 +305,32 @@ export function fast() {
         fastCache = buildMath('number', 15);
     return fastCache;
 }
+/** 有理数引擎缓存。 */
+let rationalCache;
+/**
+ * 取**有理数**引擎（Fraction 模式）。
+ *
+ * ## 为什么需要它
+ *
+ * 定积分要按 Newton-Leibniz 代入上下限。用 BigNumber 引擎会出这种事：
+ *
+ *     原函数 1/3·x³，在 x=3 处
+ *     BigNumber → 8.99999999999999999999999999999999999999…
+ *     Fraction  → 9
+ *
+ * 因为 BigNumber 的 `1/3` 是**截断的小数**，乘 27 后回不到整数。
+ * 而 Fraction 保留精确分数，代入后能约分成整数 —— 结果 9 就是 9。
+ *
+ * 三角函数等无理性结果 Fraction 会退化成浮点，这是可接受的：
+ * 那些结果本来就不是有理数。
+ *
+ * @returns mathjs 实例（Fraction 模式）
+ */
+export function rational() {
+    if (!rationalCache)
+        rationalCache = buildMath('Fraction', 64);
+    return rationalCache;
+}
 // ────────────────────────────────────────────────────────────────────────────
 // 输入处理 / 数字格式化
 // ────────────────────────────────────────────────────────────────────────────
@@ -150,9 +360,329 @@ export function normalizeSource(input) {
             output += ';';
             continue;
         }
+        /**
+         * 数学记号归一化（**只在引号外做**）。
+         *
+         * 实测反馈：理工科用户的直觉写法直接报错，且报错类型还不一致：
+         *   `2 × 3`  → unknown symbol ×
+         *   `6 ÷ 2`  → unknown symbol ÷
+         *   `π`      → unknown symbol π
+         *   `ln(10)` → **internal**（Undefined function ln）
+         *
+         * 这些替换没有语义风险（× ÷ 在数学里就是乘除，π 就是圆周率），
+         * 但必须跳过引号内 —— `5 cm to "inch"` 的单位名不能被改。
+         */
+        if (char === '×' || char === '·') {
+            output += '*';
+            continue;
+        }
+        if (char === '÷') {
+            output += '/';
+            continue;
+        }
+        // U+2212 减号，字形与 ASCII '-' 不同，肉眼难辨
+        if (char === '\u2212') {
+            output += '-';
+            continue;
+        }
+        if (char === 'π') {
+            output += 'pi';
+            continue;
+        }
         output += char;
     }
-    return output.replace(/;{2,}/g, ';').replace(/^;+|;+$/g, '').trim();
+    return output
+        .replace(/;{2,}/g, ';')
+        .replace(/^;+|;+$/g, '')
+        .trim()
+        // 幂运算：Python / JS 用户习惯写 `**`；mathjs 只认 `^`，而两者都是右结合，无歧义
+        .replace(/\*\*/g, '^')
+        // 自然对数别名：mathjs 的 `log` 本就是自然对数，但用户直觉会写 `ln`
+        .replace(/\bln\s*\(/g, 'log(')
+        .replace(/\bLN\s*\(/g, 'log(')
+        // 面积别名：`km^2` / `km2` 在表达式里统一成 mathjs 认得的 `km^2`
+        // （mathjs 的单位系统能解析 `km^2`，但不能解析裸的 `km2`）
+        .replace(/(\d)\s*(m|cm|mm|km|dm|um)2(?![0-9a-zA-Z])/g, '$1 $2^2')
+        .replace(/(\d)\s*(m|cm|mm|km|dm|um)\^2(?![0-9a-zA-Z])/g, '$1 $2^2')
+        /**
+         * 上标字符 → 幂运算。
+         *
+         * mathjs 的解析器**不认上标**：`5 m²` 报 `Syntax error in part "²"`。
+         * 而 `m²` 恰恰是面积单位最自然的写法（`units` 模式里也用它当主名）。
+         * 所以表达式里出现 ²/³ 时统一换成 `^2`/`^3`。
+         */
+        .replace(/²/g, '^2')
+        .replace(/³/g, '^3');
+}
+/**
+ * 正则元字符转义。
+ *
+ * @param text - 待转义的字符串
+ * @returns 可安全嵌入正则的字符串
+ */
+function escapeRegExp(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * 中文单位展开表（由 units 数据表派生，避免两处维护）。
+ *
+ * ## 为什么必须定义在 `normalizeChineseUnits` 之前
+ *
+ * 踩过：第一版把它写在文件末尾，而函数在文件中间。
+ * `const` 有暂时性死区（TDZ）—— 函数**首次被调用时**常量还没初始化，
+ * 抛 ReferenceError，被外层的 try/catch 吞掉，表现为「函数静默返回原文」。
+ * 这个 bug 的隐蔽处在于：函数看着完全正确，测试却全不生效。
+ */
+const CHINESE_UNIT_EXPANSIONS = 
+/**
+ * ## 逐个别名判断，不按整个单位过滤
+ *
+ * 踩过两次，都是同一种错：
+ *
+ *   ① 按 `unit.name` 是否含中文来过滤 → `m` 的单位被整个排除，
+ *      于是「米」「克」这些**中文别名**也用不上了（`2 斤 + 300 克` 报错）。
+ *   ② 反过来收全部单位 → `m²` 被收进来，展开时把表达式里的 `m²`
+ *      也替换掉，变成 `... * 1 * 1 m²` 这种嵌套垃圾，把式子弄坏。
+ *
+ * 正确做法：**只挑出名字本身是纯中文的那些**，逐个判断，与单位主名无关。
+ *
+ * ```
+ *   m  → aliases 里的「米」      ✓ 收（纯中文）
+ *   m² → name `m²` 含 m         ✗ 不收（英文/符号 mathjs 自己认得）
+ *   里 → name「里」             ✓ 收
+ * ```
+ */
+ALL_UNITS.flatMap(function (unit) {
+    const names = [unit.name, ...(unit.aliases ?? [])];
+    return names
+        .filter(function (n) {
+        /**
+         * ⚠️ 方括号不能省：`/\u4e00-\u9fff/`（无方括号）匹配的是
+         * **字面字符串「一-鿿」**，不是字符范围 —— 它对任何单个汉字都返回 false。
+         *
+         * 这个坑很隐蔽：正则语法合法、编译通过、运行不报错，只是永远匹配不到，
+         * 表现为「派生表为空、函数静默不生效」。排查时我一度怀疑循环依赖或 TDZ，
+         * 实际只是一对缺失的方括号。
+         */
+        if (!/[\u4e00-\u9fff]/.test(n))
+            return false;
+        /** 纯中文：不能含 ASCII 字母数字（否则是 `m²` 这类符号名）。 */
+        return !/[A-Za-z0-9]/.test(n);
+    })
+        .map(function (n) {
+        /**
+         * 基准单位要转成 mathjs 认得的写法。
+         *
+         * `BASE_UNIT` 用人类可读的 `m²` / `m³`，但 mathjs 解析器**不认上标字符**
+         * （它会报 `Syntax error in part "²"`）。所以改成 `m^2` / `m^3`。
+         */
+        const base = BASE_UNIT[unit.dimension].replace(/²/g, '^2').replace(/³/g, '^3');
+        return { name: n, dimension: unit.dimension, factor: unit.factor, base };
+    });
+});
+/**
+ * 中文单位 → mathjs 单位表达式的归一化。
+ *
+ * ## 为什么要这一步
+ *
+ * 实测反馈（2026-11-06）：
+ *
+ * ```
+ *   3 km + 500 m   → 3.5 km       ✓
+ *   1 里 + 3 米    → Syntax error ✗
+ *   5 亩 + 100 m²  → Syntax error ✗
+ * ```
+ *
+ * **英文/符号单位可在表达式内混算，中文单位不行** —— 而 `units` 模式里
+ * 「里」「亩」都是支持的。两条路径的单位表没打通。
+ *
+ * ## 为什么不用 mathjs 的 createUnit 注册中文单位
+ *
+ * 因为 `buildMath` 里**刻意删掉了 createUnit**：那是安全边界的一部分
+ * （表达式求值时不允许往引擎里注入任意定义）。为了中文单位把这个边界放开，
+ * 代价远大于收益。
+ *
+ * ## 所以走文本替换：把「数值 + 中文单位」换成「数值 * 系数 基准单位」
+ *
+ * 这是纯文本变换，不碰引擎能力边界。规则：
+ *   · 只替换 `数字 + 可选空格 + 中文单位` 这种**明确带数值**的形态
+ *   · 替换后乘上该单位的 factor（数值直接内联，避免再算一次）
+ *   · 单位后必须不是中文/字母（否则是更长词的一部分，如「公里」不是「里」）
+ *
+ * ```
+ *   1 里 + 3 米  →  1 * 500 m + 3 * 1 m   →  mathjs 得 503 m
+ *   5 亩 + 100 m² →  5 * 666.6666666666666 m^2 + 100 m^2  →  3433.33 m²
+ * ```
+ *
+ * 例外：温度单位是**仿射**的（不能乘），所以不在此处替换 ——
+ * 带温度的表达式请走 `operation:"units"`。
+ *
+ * @param source - 已做过基础归一化的表达式
+ * @returns 中文单位已展开的表达式
+ */
+/**
+ * 中文量级词 → 10 的幂（纯乘数展开）。
+ *
+ * ## 为什么量级词不能当「单位」注册
+ *
+ * 单位表的机制是「factor × 基准单位」，要有量纲。而「万」「亿」是**无量纲乘数** ——
+ * `2.66亿` 就是 `2.66 × 10⁸`，它本身不是一个可换算的量。
+ * 硬塞进单位表会把「亿米」和「亿吨」搞成同一种东西，那比不支持更糟。
+ *
+ * 所以在这里做**文本乘数展开**：把 `2.66亿` 改写成 `(2.66 * 1e8)`。
+ *
+ * ## 长词优先 + 边界检查
+ *
+ *   · `万亿`（10¹²）必须排在 `万`（10⁴）与 `亿`（10⁸）之前，否则 `3万亿` 会被拆成 `3万`+`亿`
+ *   · 量级词后面不能紧跟中文（`亿人` 里「人」是数量名词，可以；但 `亿万` 不行）——
+ *     用「后面是中文时继续吃进数量名词」的方式放宽，见实现
+ *   · 前面必须有数字（`亿` 单独出现不展开，那是语法错，交给引擎报）
+ *
+ * @param source - 表达式原文
+ * @returns 量级词已展开的表达式
+ */
+function normalizeMagnitudeWords(source) {
+    if (typeof source !== 'string' || source === '')
+        return source;
+    let output = source;
+    /**
+     * 长词在前：`万亿` > `亿` > `万`。
+     * 每条是 [词, 10 的幂]。
+     */
+    const words = [
+        ['万亿', 12],
+        ['亿', 8],
+        ['万', 4],
+    ];
+    for (const [word, power] of words) {
+        /**
+         * 匹配「数字 + 空格? + 量级词」。
+         *
+         * 后面允许：空格、运算符、括号、结尾，或**一个数量名词**（人/吨/米/件…）。
+         * 数量名词的处理方式：把它留在原处 —— 展开只针对数字，
+         * `2.66亿人` 会变成 `(2.66 * 1e8)人`，再由单位展开或引擎处理「人」。
+         *
+         * 用负向断言保证「万亿」不会被「万」抢先拆：由于长词先处理，
+         * 处理完 `万亿` 之后 `万` 就找不到它了。
+         */
+        const pattern = new RegExp('([0-9][0-9,.]*(?:e[+-]?[0-9]+)?)\\s*' + escapeRegExp(word) + '(?![万千百十])', 'g');
+        output = output.replace(pattern, function (_match, numeric) {
+            return '(' + numeric.replace(/,/g, '') + ' * 1e' + power + ')';
+        });
+    }
+    return output;
+}
+/**
+ * 把中文单位与中文量级词展开成 mathjs 能解析的形态。
+ *
+ * ## 两次展开，顺序有讲究
+ *
+ * 1. **量级词**（万/亿/万亿）→ 纯乘数括号，如 `(2.66 * 1e8)`
+ * 2. **中文单位**（里/丈/亩/斤/吨）→ `(450 * 1e8) * 1000 kg`
+ *
+ * 顺序反了会漏：`450 亿吨` 先走单位展开时，「亿吨」不在单位表里，
+ * 原样留下；先展开量级词得到 `(450 * 1e8)吨`，再让单位展开处理「吨」才对。
+ *
+ * ## 为什么走文本变换而不是注册进 mathjs
+ *
+ * `buildMath` 里刻意删掉了 `createUnit`（表达式求值不允许往引擎注入任意定义）。
+ * 放开这个边界来支持中文单位，代价远大于收益。
+ *
+ * @param source - 已做过基础归一化的表达式
+ * @returns 中文单位与量级词已展开的表达式
+ */
+export function normalizeChineseUnits(source) {
+    if (typeof source !== 'string' || source === '')
+        return source;
+    /**
+     * ## 先展开中文量级词，再展开中文单位
+     *
+     * 顺序不能反。`450 亿吨` 若先走单位展开，会因为「亿吨」不在单位表里而原样留下；
+     * 而先展开量级词得到 `450 * 1e8 吨`，再由单位展开处理「吨」→ 才对。
+     *
+     * 这也是实测反馈（2026-11-06 第二份）里 P0 那条：
+     * 「`万/亿/万亿` 是这类语料的默认数量级词，几乎每个数都带，
+     *   而工具内置 462 条单位里一个中文量级词都没有。」
+     *
+     * 后果不只是不方便 —— 它让使用者必须手写 `/1e8` 这类除法，
+     * 而「两步除法」正是报告里两次把「吨」当成「亿吨」的直接成因。
+     */
+    let output = normalizeMagnitudeWords(source);
+    /**
+     * 长单位名优先：否则「公里」会先匹配成「里」，
+     * 把 `3 公里` 换成 `3 * 500 m`（错了 2 倍）。
+     */
+    const ordered = CHINESE_UNIT_EXPANSIONS.slice().sort(function (a, b) {
+        return b.name.length - a.name.length;
+    });
+    for (const entry of ordered) {
+        if (entry.dimension === 'temperature')
+            continue;
+        /**
+         * ## 「人」「畜」在量级词后面是**计数**，不是功率
+         *
+         * 单位表里 `人` 是「一个成年人持续体力输出 75 W」（power 量纲），
+         * `畜` 是「一头役畜 500 W」。那是为了算「这活需要几个劳力」。
+         *
+         * 但语料里 `2.66亿人` 指的是**人口数** —— 把它展开成功率会得到 `19.95 GW`，
+         * 数字看着完全正常，语义却全错。这类静默错误正是本项目最要防的。
+         *
+         * 判据：**紧跟量级词**（`亿人`/`万人`/`亿畜`）时按计数处理，不展开。
+         * 单独用（`3 人` 表示 3 个劳力）仍按功率单位展开 —— 那是有意义的换算。
+         */
+        if (entry.name === '人' || entry.name === '畜') {
+            /**
+             * 计数用法下**把量级词后面的「人/畜」直接去掉** —— 它是量纲说明词，
+             * 不是一个要参与运算的量。`(2.66 * 1e8)人` → `(2.66 * 1e8)`。
+             *
+             * 为什么不是「保留但改成无量纲」：保留会变成裸标识符（语法错），
+             * 而乘 1 又会让输出带上多余的量纲。去掉最干净 ——
+             * `2.66亿人` 在算式里本来就只是一个数。
+             */
+            const stripPattern = new RegExp('(\\([0-9.\\s*+\\-e]*\\))\\s*' + escapeRegExp(entry.name) + '(?![0-9A-Za-z\\u4e00-\\u9fff])', 'g');
+            const stripped = output.replace(stripPattern, '$1');
+            if (stripped !== output) {
+                output = stripped;
+                continue;
+            }
+        }
+        /**
+         * 匹配「数字 + 空格? + 单位」，且单位后面不能紧跟中文或字母数字，
+         * 避免命中更长词的一部分。
+         */
+        /**
+         * 数值载体有两种：
+         *   · 直接的数字（`3 米`）
+         *   · **已展开的量级词括号**（`(450 * 1e8)吨`）
+         *
+         * 第二种是量级词展开的产物 —— 若只认数字，`亿吨` 展开成 `(450 * 1e8)吨`
+         * 之后就没人处理「吨」了，表达式接着报错。这个 bug 很隐蔽：
+         * 单看量级词那条是对的，单看单位那条也是对的，两者串起来才漏。
+         */
+        const pattern = new RegExp('([0-9][0-9,.]*(?:e[+-]?[0-9]+)?|\\([0-9.\\s*+\\-e]*\\))\\s*' +
+            escapeRegExp(entry.name) + '(?![0-9A-Za-z\u4e00-\u9fff])(?![\u4e00-\u9fff])', 'gi');
+        output = output.replace(pattern, function (_match, numeric) {
+            /**
+             * ## 整个替换必须包成括号
+             *
+             * 踩过（2026-11-06）：`450 亿吨 / 31.39 亿吨` 展开成
+             *
+             * ```
+             *   (450 * 1e8) * 1000 kg / (31.39 * 1e8) * 1000 kg
+             * ```
+             *
+             * 乘除同级左结合，等于先除再乘 —— 结果带上 `Mg^2` 量纲，
+             * **而数值部分恰好是对的（14.33）**。这种「数字对、量纲错」最难发现：
+             * 单看数字会以为没问题，而量纲只在结果后缀里露出。
+             *
+             * 加外层括号后变成 `((450*1e8) * 1000 kg) / ((31.39*1e8) * 1000 kg)`，
+             * 比值无量纲、数值 14.34 —— 正确。
+             */
+            const value = numeric.startsWith('(') ? numeric + ' * ' + entry.factor : numeric.replace(/,/g, '') + ' * ' + entry.factor;
+            return '(' + value + ' ' + entry.base + ')';
+        });
+    }
+    return output;
 }
 /**
  * 当前显示精度（模块级，每次工具调用开头设置一次）。
@@ -209,16 +739,27 @@ export function trimNumber(value, precision, displayPrecision) {
     const abs = Math.abs(value);
     // 极小值：会被四舍五入成 0 时必须用科学计数法（否则非零值显示成 0，是数据丢失）
     if (abs !== 0 && abs < Math.pow(10, -decimals)) {
-        return value.toExponential(Math.max(decimals, 3));
+        reportPrecisionLoss(1);
+        return value.toExponential(Math.min(Math.max(decimals, 6), 12));
     }
     const fixed = value.toFixed(decimals);
     // 用文本去掉尾随 0（不要 `Number()` 再 `String()`，否则 0.00000081 会变 "8.1e-7"）
     const trimmed = fixed.includes('.') ? fixed.replace(/0+$/, '').replace(/\.$/, '') : fixed;
     const text = trimmed === '-0' ? '0' : trimmed;
     const shown = Number(text);
-    // 顺手记录相对误差，供「精度不够就提醒」使用
-    if (abs > 0 && Number.isFinite(shown)) {
-        reportPrecisionLoss(Math.abs(shown - value) / abs);
+    const rel = abs > 0 && Number.isFinite(shown) ? Math.abs(shown - value) / abs : 0;
+    /**
+     * 与 `formatValue` 同一条判据：定点截断丢精度超过阈值就改用科学计数法。
+     *
+     * 两处必须一致 —— 否则 `evaluate` 与 `stats`/`solve` 会给同一个小数值
+     * 不同的显示形式，那比一个地方错更让人困惑。
+     */
+    if (rel > PRECISION_LOSS_THRESHOLD) {
+        reportPrecisionLoss(rel);
+        // 与 formatValue 一致：显式指定时尊重调用方的位数选择，不擅自改格式
+        if (!isDisplayPrecisionExplicit()) {
+            return value.toExponential(Math.min(Math.max(decimals, 6), 12));
+        }
     }
     return text;
 }