1
$ ries 2.5063
2
 2 x = 5                               for x = T - 0.0063           {49}
3
 x^2 = 2 pi                            for x = T + 0.000328275      {55}
4
 ln(6) x = sqrt(pi)+e                  for x = T + 2.73037e-05      {93}

1
function generateConstants(settings) {
2
  const maxC = [0,7,9,11,13,15,17,19,21,23][settings.level] || 11;
3
  const maxExpr = [0,2000,5000,12000,25000,...][settings.level];
4
  const CAP = 500;
5

6
  // 种子：数字 1-9，常量 π, e, φ
7
  for (let i = 1; i <= 9; i++) add({ s: String(i), v: i, c: 1 });
8
  add({ s: 'π', v: Math.PI, c: 2 });
9
  add({ s: 'e', v: Math.E,  c: 2 });
10
  add({ s: 'φ', v: (1+Math.sqrt(5))/2, c: 2 });
11

12
  // 逐层扩展
13
  for (let c = 2; c <= maxC; c++) {
14
    const buf = [];
15
    // 一元运算：对 c-w 层的表达式施加
16
    for (const op of unOps) {
17
      const src = byC.get(c - op.w);
18
      if (!src) continue;
19
      for (const a of src) buf.push({ s: op.s(a.s), v: op.f(a.v), c });
20
    }
21
    // 二元运算：组合互补复杂度层
22
    for (const op of binOps) {
23
      for (const [ca, A] of byC) {
24
        const cb = c - ca - op.w;
25
        if (cb < 1) continue;
26
        const B = byC.get(cb);
27
        if (!B) continue;
28
        for (const a of A.slice(0, CAP))
29
          for (const b of B.slice(0, CAP))
30
            buf.push({ s: op.s(a.s, b.s), v: op.f(a.v, b.v), c });
31
      }
32
    }
33
    flushLevel(buf, c);  // 排序 + 去重 + 截断
34
  }
35
}

1
// 二元：LHS op 常量
2
for (const op of binOps) {
3
  for (const [ca, A] of byC) {
4
    const cb = c - ca - op.w;
5
    if (cb < 1) continue;
6
    const B = constants.filter(k => k.c === cb);
7
    for (const a of A) {
8
      for (const b of B.slice(0, CAP_CONST)) {
9
        add({ s: op.s(a.s, b.s), c, fn: x => op.f(a.fn(x), b.v) });
10
        if (!op.comm)
11
          add({ s: op.s(b.s, a.s), c, fn: x => op.f(b.v, a.fn(x)) });
12
      }
13
    }
14
  }
15
}

1
function equationSearch(constants, lhs, settings) {
2
  const sorted = constants.slice().sort((a, b) => a.v - b.v);
3

4
  for (const f of lhs) {
5
    const fv = f.fn(settings.target);     // LHS 在 target 处求值
6
    const pos = lowerBound(sorted, fv);   // 二分查找最近的 RHS
7

8
    // 检查 ±8 邻域
9
    for (let j = Math.max(0, pos-8); j < Math.min(sorted.length, pos+9); j++) {
10
      const rhs = sorted[j];
11
      const root = refineRoot(f.fn, rhs.v, settings.target);  // Newton 精化
12
      const err = Math.abs(root - settings.target);
13
      if (err > settings.tol) continue;
14

15
      // 过滤恒等式（如 x/x = 1）
16
      const fv2 = f.fn(settings.target + 1);
17
      if (Math.abs(fv2 - fv) < 1e-14) continue;
18

19
      // 过滤退化方程（如 exp(-x) = 0）
20
      if (Math.abs(rhs.v) < 1e-6) continue;
21

22
      rows.push({ lhs: f.s, rhs: rhs.s, root, err, exact: err < 1e-12, c: f.c + rhs.c });
23
    }
24
  }
25
  return rows.sort((a, b) => a.exact - b.exact || a.c - b.c || a.err - b.err);
26
}

1
function refineRoot(fn, rhs, target) {
2
  let x = target;
3
  for (let i = 0; i < 8; i++) {
4
    const y = fn(x) - rhs;
5
    const h = 1e-6 * Math.max(1, Math.abs(x));
6
    const dy = (fn(x + h) - fn(x - h)) / (2 * h);  // 中心差分
7
    if (Math.abs(dy) < 1e-11) break;
8
    const nx = x - y / dy;
9
    if (Math.abs(nx - x) < 1e-13 * Math.max(1, Math.abs(x))) { x = nx; break; }
10
    x = nx;
11
  }
12
  return x;
13
}

1
function fmt(e) {
2
  if (e.type === 'var') return 'x';
3
  if (e.type === 'const') return e.name;
4
  if (e.arity === 1) {
5
    // 取负：-(a+b) 需要括号，-x 不需要
6
    if (e.op === 'neg') {
7
      if (c.arity === 2 && (c.op === '+' || c.op === '-'))
8
        return '-(' + inner + ')';
9
      return '-' + inner;
10
    }
11
    // 函数：sin(x) 总是带括号
12
    return names[e.op] + '(' + inner + ')';
13
  }
14
  // 二元：根据优先级决定是否加括号
15
  // ^ 优先级 100, */  优先级 80, +- 优先级 60
16
}

1
:root {
2
  --bg: #080808;
3
  --txt: #d4cdc0;
4
  --accent: #018574;     /* 深青绿 */
5
  --green: #3fb950;      /* exact 标签 */
6
  --red: #e06c60;        /* close 标签 */
7
}