diff --git a/AGENTS.md b/AGENTS.md index de09a85..c33596e 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -80,7 +80,7 @@ r8forge_synth_test examples/full_add.r8asm # all eight combinations ok r8forge verify_clb_bit_add_nc.r8asm # 4 cell 加法切片(进位进->出) r8forge verify_clb_bit_inc_nc.r8asm # 3 cell 自增切片,进位同样进->出 r8forge_derive verify_loop.r8asm -1 0=5 # 动态循环:跑 5 次,out 应该是 5 0 -r8forge_byte_op_test # 字节级库:18 个操作穷举/抽样,1.5 秒 +r8forge_byte_op_test # 字节级库:19 个操作穷举/抽样,1.5 秒 r8forge_macro_docs_test # asm/ 里每个宏的注释格式 ``` @@ -212,6 +212,7 @@ inline constexpr uint32_t kDefaultCellMask = (1u << kDefaultCellSize) - 1u; | **`clb_add_ip`(a+=b,原地,4 cell)** | `drv/add_ip_byte.r8asm` | **726 字符** | **2048 抽样全过**(O(b) 运行) | | **`clb_mul`(mc×mul → 两 cell 积,10 cell)** | `drv/mul_byte.r8asm` | **3977 字符** | **65536/65536**(O(位宽) 运行) | | **`clb_ones`(数量 → 从末位起 N 个 1,4 cell)** | `drv/ones.r8asm` | **742 字符**(带 output)/ **828**(最小驱动) | **12 个计数全对**(N=0..11) | +| **`clb_divmod`(N div D / N mod D,9 cell)** | `drv/divmod.r8asm` | **5839 字符**(最小驱动)/ 5845(带 output) | **76 组抽样全对**(O(N/D) 运行,`2047/1` 会撞步数上限) | | `asm/fibonacci.r8asm` | — | 11959 字符 | 跑出 13 项 `1 1 2 3 5 8 13 21 34 55 89 144 233` | `raw_*` 保留操作数(A、B 原样还回来),`clb_*_nc` 把 A、B 吃干净 —— 所以后者能省掉 @@ -478,6 +479,7 @@ SPEC 第 136-150 行的标准宏前缀: | `clb_not_ip` / `clb_inc_ip` / `clb_neg_ip` / `clb_dec_ip` / `clb_add_ip` | 同上再加 `_ip`(in place):结果回到原来的 cell,草稿 cell 由调用者传 | | `clb_nonzero` | 破坏性的纯计算(把 B 抄成"非零"标志),不带 `_ip` 后缀 | | `clb_ones` | 破坏性的纯计算(把"数量"展开成从末位起的一串 1,输入被吃干净);结果写在另一个 cell 里,所以也不带 `_ip` | +| `clb_divmod` | 破坏性的纯计算(除/取模,商和余数各落在自己的 cell 里);N、D 都被吃干净,所以不带 `_ip` | | `loop` / `endloop` | 结构性的**宏对**(开/收一个运行时循环),不带前缀;不开 anchor 所以能嵌套,收口后 dp 停在计数器上 | | `clb_bit_mov` | 位级搬运,并且把源吃掉 | | `bit_copy` / `copy` | 位级/字节级拷贝,缓冲由调用者传(历史命名,少了 `raw`) | diff --git a/SPEC.md b/SPEC.md index 504905d..7c5048a 100644 --- a/SPEC.md +++ b/SPEC.md @@ -394,6 +394,30 @@ A 的 12 个取值全对(`r8forge_byte_op_test` 的 `test_ones`)。 * 反过来先摆一个 `2^n` 再 `clb_dec_ip`,也得到 n 个 1(这条比上面的循环短 128 字符的 `clb_dec_ip` 反而更长,因为循环体里要一直 `set_1`,见 `asm/ones.r8asm` 的注释)。 +### 7.6 `clb_divmod`:除法与取模 + +`clb_divmod N D Q W V T Ci X BUF`:`Q = N div D`、**`N` 结束时就是余数 R**,D 被吃干净。 +9 个 cell(3 个数据 + 6 个草稿),纸带 **5839 字符**(`drv/divmod.r8asm` 是 5845), +76 组抽样全对(`r8forge_byte_op_test` 的 `test_divmod`)。 + +算法是最钝的那招: + + Q = 0 + while N >= D: N -= D ; Q += 1 + +两处踩出来的设计: + +1. **`clb_sub_nc` 会把 N 和 D 都吃掉**,而减法**不能用 `S == A` 的别名** —— 实测 + `clb_sub_nc A B A Ci`(A=15 B=10 Ci=1)直接给出 `0`。所以每轮都得 copy 出 `W = N`、 + `V = D` 再减,三个 copy 里有两个是"过路费"。 +2. **首轮要能什么都不做**:`T` 预置成 `N`、`Q` 预置成 `-1`。于是第一轮"提交 `T -> N`"是 + 空操作,`Q += 1` 正好把 −1 补回 0;探测放在循环体**末尾**,所以零轮(`N < D`)和一轮 + (`N == D`)都对,而且**探测代码只出现一次**(不这么写要多 1.3k)。 + +`O(N/D)` 的代价要记住:`2047 / 1` 会撞 500 万步上限(实测 HANG),每轮约 2.4k 步, +所以 **N/D 最多到 1500 左右**;`2047 / 2` 是 1023 轮,正常返回 `1023 1`。 +除零没有定义,调用者保证 `D >= 1`。 + --- ## 8. 原地 `_ip` 家族(结果回到原来的 cell) @@ -475,13 +499,13 @@ clb_add_ip PH Ci S F ; 把进位加进高字节(Ci 被吃) | 测试 | 覆盖 | 断言口径 | |---|---|---| -| `r8forge_byte_op_test` | 18 个测试项 = 17 个宏(`clb_neg_nc` 的 Ci=1 / Ci=0 各算一项),见 §7.1、§7.2、§7.5、§8、§9 | **按返回值**:穷举 0..255(`clb_add_ip` 2048 抽样、`clb_mul` 65536 全穷举、`clb_ones` 12 个计数全穷举),任一不符即退出码非 0 | +| `r8forge_byte_op_test` | 19 个测试项 = 18 个宏(`clb_neg_nc` 的 Ci=1 / Ci=0 各算一项),见 §7.1、§7.2、§7.5、§7.6、§8、§9 | **按返回值**:穷举 0..255(`clb_add_ip` 2048 抽样、`clb_mul` 65536 全穷举、`clb_ones` 12 个计数全穷举、`clb_divmod` 76 组抽样),任一不符即退出码非 0 | | `r8forge_synth_test examples/full_add.r8asm` | `%synth` 端到端:汇编 + 跑 8 种输入 | `all eight combinations ok` | | `r8forge verify_clb_bit_add_nc.r8asm` | 4 cell 加法切片(进位进→出) | 单点:`0+0+Ci` | | `r8forge verify_clb_bit_inc_nc.r8asm` | 3 cell 自增切片 | 单点 | | `r8forge_derive verify_loop.r8asm -1 0=N` | 动态循环:`N=0..11` 时循环体跑 `N` 次(`A = N`、`C = 0`) | 逐值 `out` | | `r8forge verify_set_0.r8asm` | `set_0` 只清 LSB | `-1 0=255 → 254`、`0=128 → 128` | -| `r8forge_macro_docs_test` | `asm/` 里 44 个宏的注释格式 | 全绿或报错行号 | +| `r8forge_macro_docs_test` | `asm/` 里 45 个宏的注释格式 | 全绿或报错行号 | | `r8forge_tape_run ` | 第二个解释器,直接跑纸带 | 与 `r8forge_derive` 对答案 | | `r8forge_derive -1/-2` | 拿汇编源码跑,打印 `out` / 非零 cell | 人工/脚本比对 | diff --git a/asm/divmod.r8asm b/asm/divmod.r8asm new file mode 100644 index 0000000..9ff37d7 --- /dev/null +++ b/asm/divmod.r8asm @@ -0,0 +1,77 @@ +%include "asm/raw_sub_nc.r8asm" +%include "asm/add_ip.r8asm" + +; 除法/取模:Q = N div D,R = N mod D。 +; +; 用它自己那句老话:**只有纸带长度是目标**。所以这里不写长除法的移位/恢复, +; 就是最钝的那招: +; +; Q = 0 +; while N >= D: N -= D ; Q += 1 +; +; 循环体在纸带里只出现一次,长度和 N、D 的大小无关;代价是运行 O(N/D) +; (N=2047、D=1 时约 2047 轮,是这台机器上最慢的宏,但还在 500 万步以内)。 +; +; 两个关键点,都是踩出来的: +; +; 1. **`clb_sub_nc` 会把 N 和 D 都吃掉**,而减法不能用 `S == A` 的别名 +; (实测 `clb_sub_nc A B A Ci` 直接给出 0)。所以每轮都要 copy 出 W = N、 +; V = D 再减 —— 三个 copy 里有两个是给它交的"过路费"。 +; +; 2. **首轮要能"什么都不做"**:把 T 预置成 N,Q 预置成 -1。于是第一轮的 +; "提交 T -> N" 是空操作,"Q += 1" 正好把 -1 补回 0;探测放在循环体末尾, +; 所以 `N < D`(零轮)和 `N == D`(一轮)都对,而且探测代码只出现一次。 +; 没有这个技巧就得在循环外面再写一遍探测,纸带多 1.3k。 +; +; 除零没有定义:调用者保证 D >= 1,这里不检查(D = 0 会一直循环)。 + +; Macro clb_divmod +; %1: Cell N +; %2: Cell D +; %3: Cell Q +; %4: Cell W +; %5: Cell V +; %6: Cell T +; %7: Cell Ci +; %8: Cell X +; %9: Cell BUF +; +; N 是被除数,结束时就是余数 R;D 是除数,会被吃干净;Q 是商(宏自己清零后累加)。 +; W、V、T、Ci、X、BUF 都是草稿 cell,进来时要求是干净的。 +; 前提 D >= 1(除零没有定义,这里不检查)。 +%macro clb_divmod 9 +.anchor before_clb_divmod + +; T = N:第一轮"提交"是空操作 +.tp %1 +copy %6 %9 + +; Q = -1:第一轮的 +1 把它补回 0 +erase %3 +clb_dec_ip %3 %8 + +; Ci = 1 只为让底下那个 biz 直接进循环体; +; 真正的判断在体尾的 clb_sub_nc 里 +.tp %7 +set_1 + +biz + ; ---- 体:提交上一轮减出来的 T,记一个商,再探一次 + .tp %6 + copy %1 %9 ; N = T + + clb_inc_ip %3 %8 ; Q += 1 + + .tp %1 + copy %4 %9 ; W = N + .tp %2 + copy %5 %9 ; V = D + .tp %7 + set_1 ; 进位入 = 1,做的是普通减法 + clb_sub_nc %4 %5 %6 %7 ; T = N - D,Ci = (N >= D) + + .tp %7 +rnz + +.tp before_clb_divmod +%endmacro diff --git a/drv/divmod.r8asm b/drv/divmod.r8asm new file mode 100644 index 0000000..14be2c6 --- /dev/null +++ b/drv/divmod.r8asm @@ -0,0 +1,22 @@ +%include "asm/divmod.r8asm" + +; clb_divmod 的驱动:0 号 cell 放 X、1 号放 D,输出商和余数。 +; +; r8forge_derive drv/divmod.r8asm -2 0=2047 1=10 # 204 7 +; r8forge_derive drv/divmod.r8asm -2 0=7 1=10 # 0 7(零轮) +; +; out 依次是商、余数。 +.var N 0 +.var D 1 +.var Q 2 +.var W 3 +.var V 4 +.var T 5 +.var Ci 6 +.var X 7 +.var BUF 8 + +clb_divmod N D Q W V T Ci X BUF + +output Q +output N diff --git a/tests/byte_op_test.cc b/tests/byte_op_test.cc index 8f96fa3..a82234b 100644 --- a/tests/byte_op_test.cc +++ b/tests/byte_op_test.cc @@ -464,6 +464,36 @@ int test_ones(const std::string &file) { return bad; } +// clb_divmod: Q = N div D, R = N mod D. Repeated subtraction, so the runtime is +// O(N/D) and the worst case (D = 1) would cross the step budget: sampled only. +int test_divmod(const std::string &file) { + const std::string tape = assemble(file); + std::cout << "clb_divmod: " << tape.size() << " characters (sampled)\n"; + const int nums[] = {0, 1, 2, 9, 10, 11, 100, 511, 1024, 2047}; + const int divs[] = {1, 2, 3, 7, 10, 100, 1000, 2047}; + int bad = 0, n = 0; + for (int a : nums) + for (int d : divs) { + if (a / d > 600) continue; // keep well inside the 5M step budget + machine m; + m.cells[0] = uint16_t(a); // N + m.cells[1] = uint16_t(d); // D + m.run(tape, 5'000'000); + n++; + const bool ok = m.finished && m.out.size() == 2 && m.out[0] == a / d && + m.out[1] == a % d; + if (!ok) { + bad++; + if (bad <= 3) + report("clb_divmod", a, d, m, + std::to_string(a / d) + " " + std::to_string(a % d)); + } + } + std::cout << " " << (bad ? "FAILED" : "all " + std::to_string(n) + " sampled pairs ok") + << (bad ? " (" + std::to_string(bad) + " wrong)" : "") << "\n"; + return bad; +} + // clb_add_ip: A = A + B in place, B is eaten. The loop runs B times, so this // one is sampled rather than exhaustive -- 256 addends x 8 accumulators. int test_add_ip(const std::string &file) { @@ -545,6 +575,7 @@ int main(int argc, char **argv) { test_dec_ip(drv + "dec_ip_byte.r8asm") + test_nonzero(drv + "nonzero_byte.r8asm") + test_ones(drv + "ones.r8asm") + + test_divmod(drv + "divmod.r8asm") + test_add_ip(drv + "add_ip_byte.r8asm") + test_mul(drv + "mul_byte.r8asm") + test_sub_nc(drv + "raw_sub_nc_byte.r8asm");