code wiki / _hdl_build / _f64_log_gate_authored.nx
_f64_log_gate_authored.nx source
↩ module page · 104 lines · 3232 B
1// _f64_log_gate_authored.nx -- ME1 rung 2 gate: TEAM-AUTHORED nx_f64_log (via the
2// MATH_KERNEL emitter) vs mpmath-60dps oracle. 196 vectors; pass = ULP <= 1 each.
3// log results span negative values, so ULP distance uses the monotone ordered map
4// ord(v) = v >= 0 ? v : i64min - v (exact bit-adjacency metric across the sign).
5//
6// Markers: LOGBAD ... / LOG-ULP total= exact= ulp1= worse= max= / LOG-GATE verdict=
7
8import "nx_syscalls.nx"
9import "nx_f64.nx"
10import "nx_f64_div.nx"
11import "nx_f64_sqrt.nx"
12import "nx_f64_cvt.nx"
13import "_pe_f64log.nx"
14import "_f64_log_kat_vectors.nx"
15
16func f6l_puts(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
17
18func f6l_putn(v: i64) -> i64 {
19 let bb: *u8 = sys_mmap(28)
20 var m: i64 = v
21 if m < 0 { m = 0 - m; sys_write(1, "-" as *u8, 1) }
22 let t: *u8 = sys_mmap(28)
23 var k: i64 = 0
24 if m == 0 { t[0] = 48; k = 1 }
25 while m > 0 { t[k] = 48 + (m % 10); m = m / 10; k = k + 1 }
26 var i: i64 = 0
27 while i < k { bb[i] = t[k-1-i]; i = i + 1 }
28 sys_write(1, bb, k)
29 return 0
30}
31
32func f6l_puthex(v: i64) -> i64 {
33 let bb: *u8 = sys_mmap(20)
34 var i: i64 = 0
35 while i < 16 {
36 let nib: i64 = (v >> ((15 - i) * 4)) & 15
37 if nib < 10 { bb[i] = 48 + nib } else { bb[i] = 55 + nib }
38 i = i + 1
39 }
40 sys_write(1, bb, 16)
41 return 0
42}
43
44func f6l_ord(v: i64) -> i64 {
45 if v >= 0 { return v }
46 return (1 << 63) - v
47}
48
49func main() -> i64 {
50 let av: *i64 = sys_mmap(8 * 256) as *i64
51 let ev: *i64 = sys_mmap(8 * 256) as *i64
52 let n: i64 = f64l_kat_fill_all(av, ev)
53
54 var exact: i64 = 0
55 var ulp1: i64 = 0
56 var worse: i64 = 0
57 var maxulp: i64 = 0
58 var i: i64 = 0
59 while i < n {
60 let x: i64 = av[i]
61 let want: i64 = ev[i]
62 let got: i64 = nx_f64_log(x)
63 var ulp: i64 = 0
64 if got != want {
65 var settled: i64 = 0
66 if want == 0x7FF8000000000000 {
67 if nx_f64_is_nan(got) == 1 { settled = 1 }
68 }
69 if settled == 0 {
70 ulp = f6l_ord(got) - f6l_ord(want)
71 if ulp < 0 { ulp = 0 - ulp }
72 }
73 }
74 if ulp == 0 { exact = exact + 1 }
75 if ulp == 1 { ulp1 = ulp1 + 1 }
76 if ulp > 1 {
77 worse = worse + 1
78 if worse <= 40 {
79 f6l_puts("LOGBAD i=" as *u8); f6l_putn(i)
80 f6l_puts(" x=" as *u8); f6l_puthex(x)
81 f6l_puts(" exp=" as *u8); f6l_puthex(want)
82 f6l_puts(" got=" as *u8); f6l_puthex(got)
83 f6l_puts(" ulp=" as *u8); f6l_putn(ulp)
84 f6l_puts("\n" as *u8)
85 }
86 }
87 if ulp > maxulp { maxulp = ulp }
88 i = i + 1
89 }
90
91 f6l_puts("LOG-ULP total=" as *u8); f6l_putn(n)
92 f6l_puts(" exact=" as *u8); f6l_putn(exact)
93 f6l_puts(" ulp1=" as *u8); f6l_putn(ulp1)
94 f6l_puts(" worse=" as *u8); f6l_putn(worse)
95 f6l_puts(" max=" as *u8); f6l_putn(maxulp)
96 f6l_puts("\n" as *u8)
97 if worse == 0 {
98 f6l_puts("LOG-GATE verdict=GREEN\n" as *u8)
99 return 0
100 }
101 f6l_puts("LOG-GATE verdict=RED\n" as *u8)
102 if worse > 100 { return 100 }
103 return worse
104}