code wiki / _hdl_build / _f64_erf_full_gate.nx
_f64_erf_full_gate.nx source
↩ module page · 70 lines · 3608 B
1// _f64_erf_full_gate.nx -- ULP gate for FULL-DOMAIN erf over the PREVIOUSLY-NAN gap
2// (1.75..6) vs the composed sovereign oracle 1 - bf_erfc(x) (the erfc CF, erf+erfc=1
3// proven to 2^-95). Grid x = k/16, k=29..95 (1.81..5.94). Also checks saturation
4// (x>=6 -> 1.0) and antisymmetry (erf(-x) = -erf(x), bit-exact by construction).
5// RUNG bar: max ULP <= 4. Durable: ERFFULL-GATE -> knowledge/status/math_engine.log.
6// license_tier: ORIGINAL
7import "nx_syscalls.nx"
8import "nx_bigfloat120.nx"
9import "nx_bigfloat120_div.nx"
10import "nx_bigfloat120_trig.nx"
11import "nx_bigfloat120_erfc.nx"
12import "_pe_f64erf_full.nx"
13
14func ef_p(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
15func ef_f(fd: i64, s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(fd,s,n); return 0 }
16func ef_n(fd: i64, v: i64) -> i64 { let bb: *u8=sys_mmap(28); var m: i64=v; if m<0{m=0-m; sys_write(fd,"-" as *u8,1)}; let t: *u8=sys_mmap(28); var k: i64=0; if m==0{t[0]=48 as u8;k=1}; while m>0{t[k]=(48+(m%10)) as u8;m=m/10;k=k+1}; var i: i64=0; while i<k{bb[i]=t[k-1-i];i=i+1}; sys_write(fd,bb,k); return 0 }
17func ef_ulp(a: i64, b: i64) -> i64 { if a >= b { return a - b } return b - a }
18
19func main() -> i64 {
20 ef_p("=== F64-ERF-FULL GATE: full-domain erf over the 1.75..6 gap vs 1-bf_erfc oracle ===\n" as *u8)
21 let one: *i64 = bf_new()
22 bf_set_int(one, 1)
23 let kb: *i64 = bf_new()
24 let xb: *i64 = bf_new()
25 let oc: *i64 = bf_new()
26 let d: *i64 = bf_new()
27 var maxulp: i64 = 0
28 var worst: i64 = 0
29 var npts: i64 = 0
30 var k: i64 = 29
31 while k <= 95 {
32 bf_set_int(kb, k)
33 bf_div_small(xb, kb, 16)
34 let xbits: i64 = bf_to_f64(xb, 0, 0)
35 bf_erfc(oc, xb)
36 bf_sub(d, one, oc) // 1 - erfc(x) = erf(x)
37 let want: i64 = bf_to_f64(d, 0, 0)
38 let got: i64 = nx_f64_erf_full(xbits)
39 let u: i64 = ef_ulp(got, want)
40 if u > maxulp { maxulp = u; worst = xbits }
41 npts = npts + 1
42 k = k + 1
43 }
44 // structural: saturation x=6.5 -> 1.0 ; antisymmetry on a gap point (x=3.0)
45 var struct_bad: i64 = 0
46 if nx_f64_erf_full(0x401A000000000000) != 0x3FF0000000000000 { struct_bad = 1 } // erf(6.5)=1.0
47 let p3: i64 = nx_f64_erf_full(0x4008000000000000) // erf(3.0)
48 if nx_f64_erf_full(0xC008000000000000) != (p3 | 0x8000000000000000) { struct_bad = 1 } // erf(-3)=-erf(3)
49
50 var ok: i64 = 0
51 if maxulp <= 4 { if struct_bad == 0 { ok = 1 } }
52 let lfd: i64 = sys_openat_append("knowledge/status/math_engine.log" as *u8, 0x1a4)
53 if lfd >= 0 {
54 ef_f(lfd, "ERFFULL-GATE epoch=" as *u8); ef_n(lfd, sys_now_realtime_sec())
55 ef_f(lfd, " gap_points=" as *u8); ef_n(lfd, npts)
56 ef_f(lfd, " max_ulp=" as *u8); ef_n(lfd, maxulp)
57 ef_f(lfd, " worst_x_bits=" as *u8); ef_n(lfd, worst)
58 ef_f(lfd, " struct_bad=" as *u8); ef_n(lfd, struct_bad)
59 ef_f(lfd, " domain=ALL-REALS method=erf-series|sign*(1-erfc)|sat oracle=1-bf_erfc(SOVEREIGN)" as *u8)
60 if ok == 1 { ef_f(lfd, " verdict=GREEN\n" as *u8) } else { ef_f(lfd, " verdict=RED\n" as *u8) }
61 sys_close(lfd)
62 }
63 ef_p(" gap_points=" as *u8); ef_n(1, npts)
64 ef_p(" max_ulp=" as *u8); ef_n(1, maxulp)
65 ef_p(" struct_bad=" as *u8); ef_n(1, struct_bad)
66 if ok == 1 { ef_p(" ERFFULL-GATE: GREEN (erf now full-domain; gap closed <=4 ulp + saturation + antisymmetry)\n" as *u8); sys_exit(0); return 0 }
67 ef_p(" ERFFULL-GATE: RED (measured gap named)\n" as *u8)
68 sys_exit(1)
69 return 1
70}