code wiki / _hdl_build / nx_deflate_enc_gate.nx
nx_deflate_enc_gate.nx source
↩ module page · 76 lines · 3435 B
1// nx_deflate_enc_gate.nx -- prove the sovereign DEFLATE compressor round-trips against our own inflater.
2// T1 compresses (output smaller than input on compressible data)
3// T2 our nx_deflate.nx INFLATE decodes it with no error
4// T3 the decoded bytes are BYTE-IDENTICAL to the original (correctness)
5// T4 a second dataset (image-like: zero runs + repeats) also round-trips + compresses
6// license_tier: ORIGINAL expect_exit: 0
7import "nx_syscalls.nx"
8import "nx_deflate_enc.nx"
9import "nx_deflate.nx"
10
11func hw(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
12func pn(v: i64) -> i64 {
13 let b: *u8 = sys_mmap(32) as *u8
14 var x: i64 = v
15 var i: i64 = 31
16 if x == 0 { b[i] = 48 as u8; i = i - 1 }
17 while x > 0 { b[i] = (48 + x % 10) as u8; x = x / 10; i = i - 1 }
18 sys_write(1, (b as i64 + i + 1) as *u8, 31 - i)
19 return 0
20}
21
22// compress src[0..slen), inflate, verify identical. returns compressed length (or -1 on mismatch/error).
23func roundtrip(src: *u8, slen: i64, label: *u8) -> i64 {
24 let out: *u8 = sys_mmap(slen * 2 + 128) as *u8
25 let clen: i64 = dfe_compress(src, slen, out)
26 hw(label); hw(": raw="); pn(slen); hw(" -> deflate="); pn(clen)
27 let res: *NxDeflateResult = nx_deflate_inflate(out, clen, slen + 16)
28 if res == (0 as *NxDeflateResult) { hw(" INFLATE-NULL\n" as *u8); return 0 - 1 }
29 if res.error_code != 0 { hw(" INFLATE-ERR="); pn(res.error_code); hw("\n" as *u8); return 0 - 1 }
30 if res.output_size != slen { hw(" SIZE-MISMATCH="); pn(res.output_size); hw("\n" as *u8); return 0 - 1 }
31 let dec: *u8 = res.output_data
32 var i: i64 = 0
33 while i < slen {
34 let a: *u8 = (dec as i64 + i) as *u8
35 let b: *u8 = (src as i64 + i) as *u8
36 if a[0] != b[0] { hw(" BYTE-DIFF@"); pn(i); hw("\n" as *u8); return 0 - 1 }
37 i = i + 1
38 }
39 let pct: i64 = clen * 100 / slen
40 hw(" OK round-trip ("); pn(pct); hw("% of raw)\n" as *u8)
41 return clen
42}
43
44func main() -> i64 {
45 var fails: i64 = 0
46 // dataset A: literals + an exact long-distance repeat + a zero run + blocky
47 let na: i64 = 4096
48 let a: *u8 = sys_mmap(na) as *u8
49 var i: i64 = 0
50 while i < na {
51 if i < 1000 { a[i] = ((i * 31 + 7) & 0xff) as u8 }
52 else { if i < 2000 { a[i] = a[i - 1000] }
53 else { if i < 3000 { a[i] = 0 as u8 }
54 else { a[i] = (((i / 8) & 1) * 200) as u8 } } }
55 i = i + 1
56 }
57 let ca: i64 = roundtrip(a, na, "T1/T3 mixed" as *u8)
58 if ca < 0 { fails = fails + 1 } else { if ca >= na { hw(" (warn: no shrink on mixed)\n" as *u8) } }
59
60 // dataset B: image-like -- long zero runs + a repeated gradient block (what PNG-filtered rows look like)
61 let nb: i64 = 8192
62 let b: *u8 = sys_mmap(nb) as *u8
63 i = 0
64 while i < nb {
65 let ph: i64 = i % 256
66 if ph < 200 { b[i] = 0 as u8 } // filtered flat area -> zeros
67 else { b[i] = ((i / 3) & 0x1f) as u8 } // small residuals
68 i = i + 1
69 }
70 let cb: i64 = roundtrip(b, nb, "T4 image-like" as *u8)
71 if cb < 0 { fails = fails + 1 } else { if cb >= nb / 2 { hw(" (warn: weak ratio on image-like)\n" as *u8) } }
72
73 if fails == 0 { hw("VERDICT GREEN: sovereign DEFLATE compressor round-trips byte-identical vs our inflater + shrinks real data\n" as *u8) }
74 else { hw("VERDICT RED fails="); pn(fails); hw("\n" as *u8) }
75 return fails
76}