code wiki / _hdl_build / nx_seg_columnar_gate.nx
`nx_seg_columnar_gate.nx` source

1import "nx_gate_gn.nx"
2// nx_seg_columnar_gate.nx -- exceed-gate for CAP-SEG-COLUMNAR. Proves lossless compression on a column: RLE encodes
3// runs to fewer pairs and decodes back byte-exact; dictionary reduces a low-cardinality column to distinct values +
4// small ids and decodes back byte-exact. This is the analytic-scan win a row store can't give.
5// Sovereign: nx_syscalls + nx_seg_columnar. expect_exit: 0
6import "nx_syscalls.nx"
7import "nx_seg_columnar.nx"
8
9func gp(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
10func geq(a: *i64, b: *i64, n: i64) -> i64 { var i: i64=0; while i<n { if a[i]!=b[i] { return 0 } i=i+1 } return 1 }
11
12func main(argc: i64, argv: *i64) -> i64 {
13    gp("=== nx_seg_columnar_gate (columnar RLE + dictionary compression, lossless) ===\n" as *u8)
14    var pass: i64=0; var fail: i64=0
15
16    // RLE column: 8 values with runs -> 3 (count,value) runs
17    let vals: *i64=sys_mmap(8*8) as *i64
18    vals[0]=5; vals[1]=5; vals[2]=5; vals[3]=5; vals[4]=3; vals[5]=3; vals[6]=3; vals[7]=9
19    let pairs: *i64=sys_mmap(8*16) as *i64
20    let np: i64 = col_rle_encode(vals, 8, pairs)
21    if np == 3 { pass=pass+1; gp("  T1 RLE encode 8 values -> 3 runs PASS\n" as *u8) } else { fail=fail+1; gp("  T1 FAIL np=" as *u8); gn(np); gp("\n" as *u8) }
22
23    let dec: *i64=sys_mmap(8*16) as *i64
24    let dn2: i64 = col_rle_decode(pairs, np, dec)
25    if dn2 == 8 { if geq(dec, vals, 8)==1 { pass=pass+1; gp("  T2 RLE decode -> 8 values byte-exact (lossless round-trip) PASS\n" as *u8) } else { fail=fail+1; gp("  T2 FAIL bytes\n" as *u8) } } else { fail=fail+1; gp("  T2 FAIL count\n" as *u8) }
26
27    if np*2 < 8 { pass=pass+1; gp("  T3 compressed: " as *u8); gn(np*2); gp(" ints < 8 raw PASS\n" as *u8) } else { fail=fail+1; gp("  T3 FAIL no compression\n" as *u8) }
28
29    // DICTIONARY column: 5 rows, 2 distinct
30    let dv: *i64=sys_mmap(8*8) as *i64
31    dv[0]=100; dv[1]=200; dv[2]=100; dv[3]=100; dv[4]=200
32    let dict: *i64=sys_mmap(8*8) as *i64; let ids: *i64=sys_mmap(8*8) as *i64
33    let card: i64 = col_dict_encode(dv, 5, dict, ids)
34    if card == 2 { pass=pass+1; gp("  T4 dict encode: cardinality 2 < 5 rows (low-card compressed) PASS\n" as *u8) } else { fail=fail+1; gp("  T4 FAIL card=" as *u8); gn(card); gp("\n" as *u8) }
35
36    let dd: *i64=sys_mmap(8*8) as *i64
37    col_dict_decode(dict, ids, 5, dd)
38    if geq(dd, dv, 5)==1 { pass=pass+1; gp("  T5 dict decode -> byte-exact (lossless round-trip) PASS\n" as *u8) } else { fail=fail+1; gp("  T5 FAIL\n" as *u8) }
39
40    gp("RESULT pass=" as *u8); gn(pass); gp(" fail=" as *u8); gn(fail)
41    if fail == 0 { gp(" verdict=GREEN (columnar layout + lossless RLE/dict compression -- analytic-scan class)\n" as *u8); sys_exit(0); return 0 }
42    gp(" verdict=RED\n" as *u8); sys_exit(1); return 1
43}
nx_seg_columnar_gate.nx source

`nx_seg_columnar_gate.nx` source
