code wiki / _hdl_build / nx_pattern_emit6.nx
nx_pattern_emit6.nx source
↩ module page · 765 lines · 52859 B
1// nx_pattern_emit6.nx -- PATTERN EMITTER: MATH_KERNEL (shape 11 -- first NEW shape past the
2// original 10/10 census; the math-engine arc's autonomy lever). The Builder authors an f64
3// TRANSCENDENTAL from a data spec: LOG_REDUCE template (exponent split at the sqrt2 boundary ->
4// s=(m-1)/(m+1) -> Horner in z=s^2 -> k*ln2 hi/lo recombine). EVERY number in the emitted module
5// comes from the spec array (oracle-generated, mpmath@60dps) -- the emitter contains STRUCTURE,
6// never constants (no-magic-numbers law). The emitted test derives KATs from the ALGORITHM'S OWN
7// INVARIANTS (ln(1)=+0 exactly since s=0; the IEEE specials table), no Claude arithmetic; the
8// semantic ULP bar is the Engineer's separate oracle-vector gate (_f64_log_gate_authored).
9// Spec layout: c[0]=ONE c[1]=SQRT2_CUT_SIG c[2]=LN2_HI c[3]=LN2_LO, coeffs hi-first c[4..4+ncoef).
10// Extends emit(231)/emit2(235)/emit3(241)/emit4(262)/emit5(GEOMETRY+PID). LAWS: flat ifs, no
11// &&/||, <=6 args per func, one transcendental per emitted file. license_tier: ORIGINAL
12import "nx_pattern_emit.nx"
13import "nx_syscalls.nx"
14
15func pe6_author_logf64(name: *u8, modfile: *u8, modpath: *u8, testpath: *u8, c: *i64, ncoef: i64) -> i64 {
16 let mf: i64 = sys_openat_wr(modpath, 0x1a4); if mf < 0 { return 0 }
17 pe_w(mf, "// AUTHORED BY THE NISHI BUILDER (pattern: MATH_KERNEL / LOG_REDUCE) -- no Claude core logic.\n" as *u8)
18 pe_w(mf, "// Natural log, binary64 bits-up. All constants from the oracle-generated spec table.\n" as *u8)
19 pe_w(mf, "import \"nx_syscalls.nx\"\nimport \"nx_tier.nx\"\nimport \"nx_f64.nx\"\nimport \"nx_f64_div.nx\"\nimport \"nx_f64_cvt.nx\"\n" as *u8)
20 pe_w(mf, "func " as *u8); pe_w(mf, name); pe_w(mf, "(x: i64) -> i64 {\n" as *u8)
21 pe_w(mf, " let cls: nx_int = nx_f64_classify(x)\n" as *u8)
22 pe_w(mf, " if cls == NX_F64_CLS_NAN { return NX_F64_NAN_RAW }\n" as *u8)
23 pe_w(mf, " if cls == NX_F64_CLS_ZERO { return 0xFFF0000000000000 }\n" as *u8)
24 pe_w(mf, " if nx_f64_sign(x) == 1 { return NX_F64_NAN_RAW }\n" as *u8)
25 pe_w(mf, " if cls == NX_F64_CLS_INF { return x }\n" as *u8)
26 pe_w(mf, " var sig: i64 = nx_f64_mant_field(x)\n" as *u8)
27 pe_w(mf, " var ef: i64 = nx_f64_exp_field(x)\n" as *u8)
28 pe_w(mf, " if ef == 0 {\n ef = 1\n while sig < NX_F64_IMPLICIT_1 { sig = sig << 1; ef = ef - 1 }\n } else {\n sig = sig | NX_F64_IMPLICIT_1\n }\n" as *u8)
29 pe_w(mf, " var k: i64 = ef - 1023\n var mexp: i64 = 1023\n" as *u8)
30 pe_w(mf, " if sig >= " as *u8); pe_wn(mf, c[1]); pe_w(mf, " { k = k + 1; mexp = 1022 }\n" as *u8)
31 pe_w(mf, " let mfv: i64 = (mexp << 52) | (sig & NX_F64_MANT_MASK)\n" as *u8)
32 // Exact-identity form: f = m-1 (Sterbenz-exact), s = f/(2+f), so 2s = f - s*f
33 // EXACTLY; ln(m) = f - s*(f - R), R = z*Q(z) with Q coeffs 2/(2i+1) from spec.
34 pe_w(mf, " let f: i64 = nx_f64_sub(mfv, " as *u8); pe_wn(mf, c[0]); pe_w(mf, ")\n" as *u8)
35 pe_w(mf, " let two: i64 = nx_f64_add(" as *u8); pe_wn(mf, c[0])
36 pe_w(mf, ", " as *u8); pe_wn(mf, c[0]); pe_w(mf, ")\n" as *u8)
37 pe_w(mf, " let s: i64 = nx_f64_div(f, nx_f64_add(two, f))\n" as *u8)
38 pe_w(mf, " let z: i64 = nx_f64_mul(s, s)\n" as *u8)
39 pe_w(mf, " var p: i64 = " as *u8); pe_wn(mf, c[4]); pe_w(mf, "\n" as *u8)
40 var i: i64 = 1
41 while i < ncoef {
42 pe_w(mf, " p = nx_f64_add(nx_f64_mul(p, z), " as *u8); pe_wn(mf, c[4 + i]); pe_w(mf, ")\n" as *u8)
43 i = i + 1
44 }
45 pe_w(mf, " let r: i64 = nx_f64_mul(z, p)\n" as *u8)
46 pe_w(mf, " let lnm: i64 = nx_f64_sub(f, nx_f64_mul(s, nx_f64_sub(f, r)))\n" as *u8)
47 pe_w(mf, " let kf: i64 = nx_i64_to_f64(k)\n" as *u8)
48 pe_w(mf, " let tlo: i64 = nx_f64_add(lnm, nx_f64_mul(kf, " as *u8); pe_wn(mf, c[3]); pe_w(mf, "))\n" as *u8)
49 pe_w(mf, " return nx_f64_add(nx_f64_mul(kf, " as *u8); pe_wn(mf, c[2]); pe_w(mf, "), tlo)\n}\n" as *u8)
50 sys_close(mf)
51
52 let tf: i64 = sys_openat_wr(testpath, 0x1a4); if tf < 0 { return 0 }
53 pe_w(tf, "// AUTHORED BY THE NISHI BUILDER (pattern: MATH_KERNEL test) -- KATs from algorithm invariants.\n" as *u8)
54 pe_w(tf, "import \"" as *u8); pe_w(tf, modfile); pe_w(tf, "\"\nimport \"nx_syscalls.nx\"\n" as *u8)
55 pe_w(tf, "func main() -> i64 {\n var bad: i64 = 0\n" as *u8)
56 pe_w(tf, " if " as *u8); pe_w(tf, name); pe_w(tf, "(" as *u8); pe_wn(tf, c[0]); pe_w(tf, ") != 0 { bad = bad + 1 }\n" as *u8)
57 pe_w(tf, " if " as *u8); pe_w(tf, name); pe_w(tf, "(0) != 0xFFF0000000000000 { bad = bad + 1 }\n" as *u8)
58 pe_w(tf, " if " as *u8); pe_w(tf, name); pe_w(tf, "(0x8000000000000000) != 0xFFF0000000000000 { bad = bad + 1 }\n" as *u8)
59 pe_w(tf, " if " as *u8); pe_w(tf, name); pe_w(tf, "(0xBFF0000000000000) != 0x7FF8000000000000 { bad = bad + 1 }\n" as *u8)
60 pe_w(tf, " if " as *u8); pe_w(tf, name); pe_w(tf, "(0x7FF0000000000000) != 0x7FF0000000000000 { bad = bad + 1 }\n" as *u8)
61 pe_w(tf, " if " as *u8); pe_w(tf, name); pe_w(tf, "(0x7FF8000000000000) != 0x7FF8000000000000 { bad = bad + 1 }\n" as *u8)
62 pe_w(tf, " let nl: *u8 = sys_mmap(4)\n nl[0] = 10\n" as *u8)
63 pe_w(tf, " if bad == 0 { sys_write(1, \"MATHKERNEL-TEST GREEN\" as *u8, 21) } else { sys_write(1, \"MATHKERNEL-TEST RED\" as *u8, 19) }\n" as *u8)
64 pe_w(tf, " sys_write(1, nl, 1)\n" as *u8)
65 pe_w(tf, " sys_exit(bad)\n return bad\n}\n" as *u8)
66 sys_close(tf)
67 return 1
68}
69
70// negative-safe literal writer for emitted code (0 - N form; unary-minus landmine)
71func pe6_wlit(fd: i64, v: i64) -> i64 {
72 if v < 0 {
73 pe_w(fd, "(0 - " as *u8)
74 pe_wn(fd, 0 - v)
75 pe_w(fd, ")" as *u8)
76 return 0
77 }
78 pe_wn(fd, v)
79 return 0
80}
81
82// ============ SINCOS (MATH_KERNEL shape, template 2) ============
83// Emits nx_f64_sin + nx_f64_cos in ONE file (they share the reduction; no div
84// in the file so the mul+div quirk cannot trigger). Signed r flows through the
85// odd sin polynomial / even cos polynomial directly -- no fold flags needed.
86// Spec layout: c[0]=2/pi c[1]=HI c[2]=MID c[3]=LO c[4]=half c[5]=one
87// c[6..15] sin coeffs hi-first, c[16..25] cos coeffs hi-first.
88func pe6_author_sincos(modfile: *u8, modpath: *u8, testpath: *u8, c: *i64) -> i64 {
89 let mf: i64 = sys_openat_wr(modpath, 0x1a4); if mf < 0 { return 0 }
90 pe_w(mf, "// AUTHORED BY THE NISHI BUILDER (pattern: MATH_KERNEL / SINCOS) -- no Claude core logic.\n" as *u8)
91 pe_w(mf, "// All constants from the SOVEREIGN bigfloat spec (nx_mathspec_sincos). v1 domain |x| < 2^20.\n" as *u8)
92 pe_w(mf, "import \"nx_syscalls.nx\"\nimport \"nx_tier.nx\"\nimport \"nx_f64.nx\"\nimport \"nx_f64_cvt.nx\"\n" as *u8)
93 // shared reduction
94 pe_w(mf, "func _sc_reduce(x: i64, kout: *i64) -> i64 {\n" as *u8)
95 pe_w(mf, " let t: i64 = nx_f64_mul(x, " as *u8); pe6_wlit(mf, c[0]); pe_w(mf, ")\n" as *u8)
96 pe_w(mf, " var tk: i64 = 0\n" as *u8)
97 pe_w(mf, " if nx_f64_sign(t) == 1 { tk = nx_f64_sub(t, " as *u8); pe6_wlit(mf, c[4])
98 pe_w(mf, ") } else { tk = nx_f64_add(t, " as *u8); pe6_wlit(mf, c[4]); pe_w(mf, ") }\n" as *u8)
99 pe_w(mf, " let k: i64 = nx_f64_to_i64(tk)\n" as *u8)
100 pe_w(mf, " let kf: i64 = nx_i64_to_f64(k)\n" as *u8)
101 pe_w(mf, " var r: i64 = nx_f64_sub(x, nx_f64_mul(kf, " as *u8); pe6_wlit(mf, c[1]); pe_w(mf, "))\n" as *u8)
102 pe_w(mf, " r = nx_f64_sub(r, nx_f64_mul(kf, " as *u8); pe6_wlit(mf, c[2]); pe_w(mf, "))\n" as *u8)
103 pe_w(mf, " r = nx_f64_sub(r, nx_f64_mul(kf, " as *u8); pe6_wlit(mf, c[3]); pe_w(mf, "))\n" as *u8)
104 pe_w(mf, " kout[0] = k\n return r\n}\n" as *u8)
105 // sin polynomial: r * P(r^2), coeffs c[6..15] hi-first
106 pe_w(mf, "func _sc_sinp(r: i64) -> i64 {\n let z: i64 = nx_f64_mul(r, r)\n" as *u8)
107 pe_w(mf, " var p: i64 = " as *u8); pe6_wlit(mf, c[6]); pe_w(mf, "\n" as *u8)
108 var i: i64 = 7
109 while i <= 15 {
110 pe_w(mf, " p = nx_f64_add(nx_f64_mul(p, z), " as *u8); pe6_wlit(mf, c[i]); pe_w(mf, ")\n" as *u8)
111 i = i + 1
112 }
113 pe_w(mf, " return nx_f64_mul(r, p)\n}\n" as *u8)
114 // cos polynomial: Q(r^2), coeffs c[16..25] hi-first
115 pe_w(mf, "func _sc_cosp(r: i64) -> i64 {\n let z: i64 = nx_f64_mul(r, r)\n" as *u8)
116 pe_w(mf, " var q: i64 = " as *u8); pe6_wlit(mf, c[16]); pe_w(mf, "\n" as *u8)
117 i = 17
118 while i <= 25 {
119 pe_w(mf, " q = nx_f64_add(nx_f64_mul(q, z), " as *u8); pe6_wlit(mf, c[i]); pe_w(mf, ")\n" as *u8)
120 i = i + 1
121 }
122 pe_w(mf, " return q\n}\n" as *u8)
123 // sin: quadrant table [sinp, cosp, -sinp, -cosp]
124 pe_w(mf, "func nx_f64_sin(x: i64) -> i64 {\n" as *u8)
125 pe_w(mf, " let ax: i64 = x & 0x7FFFFFFFFFFFFFFF\n" as *u8)
126 pe_w(mf, " let ef: i64 = (x >> 52) & 0x7FF\n" as *u8)
127 pe_w(mf, " if ef == 2047 { return 0x7FF8000000000000 }\n" as *u8)
128 pe_w(mf, " if ax == 0 { return x }\n" as *u8)
129 pe_w(mf, " if ef >= 1043 { return 0x7FF8000000000000 }\n" as *u8)
130 pe_w(mf, " let ko: *i64 = sys_mmap(16) as *i64\n" as *u8)
131 pe_w(mf, " let r: i64 = _sc_reduce(x, ko)\n" as *u8)
132 pe_w(mf, " let kk: i64 = ko[0] & 3\n" as *u8)
133 pe_w(mf, " if kk == 0 { return _sc_sinp(r) }\n" as *u8)
134 pe_w(mf, " if kk == 1 { return _sc_cosp(r) }\n" as *u8)
135 pe_w(mf, " if kk == 2 { return nx_f64_neg(_sc_sinp(r)) }\n" as *u8)
136 pe_w(mf, " return nx_f64_neg(_sc_cosp(r))\n}\n" as *u8)
137 // cos: quadrant table [cosp, -sinp, -cosp, sinp]
138 pe_w(mf, "func nx_f64_cos(x: i64) -> i64 {\n" as *u8)
139 pe_w(mf, " let ax: i64 = x & 0x7FFFFFFFFFFFFFFF\n" as *u8)
140 pe_w(mf, " let ef: i64 = (x >> 52) & 0x7FF\n" as *u8)
141 pe_w(mf, " if ef == 2047 { return 0x7FF8000000000000 }\n" as *u8)
142 pe_w(mf, " if ax == 0 { return " as *u8); pe6_wlit(mf, c[5]); pe_w(mf, " }\n" as *u8)
143 pe_w(mf, " if ef >= 1043 { return 0x7FF8000000000000 }\n" as *u8)
144 pe_w(mf, " let ko: *i64 = sys_mmap(16) as *i64\n" as *u8)
145 pe_w(mf, " let r: i64 = _sc_reduce(x, ko)\n" as *u8)
146 pe_w(mf, " let kk: i64 = ko[0] & 3\n" as *u8)
147 pe_w(mf, " if kk == 0 { return _sc_cosp(r) }\n" as *u8)
148 pe_w(mf, " if kk == 1 { return nx_f64_neg(_sc_sinp(r)) }\n" as *u8)
149 pe_w(mf, " if kk == 2 { return nx_f64_neg(_sc_cosp(r)) }\n" as *u8)
150 pe_w(mf, " return _sc_sinp(r)\n}\n" as *u8)
151 sys_close(mf)
152
153 let tf: i64 = sys_openat_wr(testpath, 0x1a4); if tf < 0 { return 0 }
154 pe_w(tf, "// AUTHORED BY THE NISHI BUILDER (pattern: MATH_KERNEL SINCOS test) -- invariant KATs.\n" as *u8)
155 pe_w(tf, "import \"" as *u8); pe_w(tf, modfile); pe_w(tf, "\"\nimport \"nx_syscalls.nx\"\n" as *u8)
156 pe_w(tf, "func main() -> i64 {\n var bad: i64 = 0\n" as *u8)
157 pe_w(tf, " if nx_f64_sin(0) != 0 { bad = bad + 1 }\n" as *u8)
158 pe_w(tf, " if nx_f64_sin(1 << 63) != (1 << 63) { bad = bad + 1 }\n" as *u8)
159 pe_w(tf, " if nx_f64_cos(0) != " as *u8); pe6_wlit(tf, c[5]); pe_w(tf, " { bad = bad + 1 }\n" as *u8)
160 pe_w(tf, " if nx_f64_cos(1 << 63) != " as *u8); pe6_wlit(tf, c[5]); pe_w(tf, " { bad = bad + 1 }\n" as *u8)
161 pe_w(tf, " if nx_f64_sin(0x7FF0000000000000) != 0x7FF8000000000000 { bad = bad + 1 }\n" as *u8)
162 pe_w(tf, " if nx_f64_cos(0x7FF8000000000000) != 0x7FF8000000000000 { bad = bad + 1 }\n" as *u8)
163 pe_w(tf, " if nx_f64_sin(0x4140000000000000) != 0x7FF8000000000000 { bad = bad + 1 }\n" as *u8)
164 pe_w(tf, " let nl: *u8 = sys_mmap(4)\n nl[0] = 10\n" as *u8)
165 pe_w(tf, " if bad == 0 { sys_write(1, \"SINCOS-TEST GREEN\" as *u8, 17) } else { sys_write(1, \"SINCOS-TEST RED\" as *u8, 15) }\n" as *u8)
166 pe_w(tf, " sys_write(1, nl, 1)\n sys_exit(bad)\n return bad\n}\n" as *u8)
167 sys_close(tf)
168 return 1
169}
170
171// ============ ATAN (MATH_KERNEL shape, template 3: accurate-table) ============
172// Anchors c_j = j/8, j = 0..20 (x < 41/16 direct; else pi/2 - atan(1/x) fold,
173// where the fold target sits 2 binades below the result -> 4x error damping).
174// t = (x - c_j)/(1 + x*c_j) keeps |t| <= 1/16: x - c_j is Sterbenz-exact and an
175// 8-coeff odd Taylor poly truncates below 2^-64 relative. Result recombines as
176// A_hi[j] + (A_lo[j] + t*P(t^2)) -- the classic accurate-table half-ulp guard.
177// Spec layout: c[0]=one c[1]=half c[2]=eight c[3]=pi2_hi c[4]=pi2_lo c[5]=cut
178// c[6..26] anchors, c[27..47] A_hi, c[48..68] A_lo, c[69..76] poly hi-first.
179func pe6_author_atan(modfile: *u8, modpath: *u8, testpath: *u8, c: *i64) -> i64 {
180 let mf: i64 = sys_openat_wr(modpath, 0x1a4); if mf < 0 { return 0 }
181 pe_w(mf, "// AUTHORED BY THE NISHI BUILDER (pattern: MATH_KERNEL / ATAN) -- no Claude core logic.\n" as *u8)
182 pe_w(mf, "// All constants from the SOVEREIGN bigfloat spec (nx_mathspec_atan). Total domain.\n" as *u8)
183 pe_w(mf, "import \"nx_syscalls.nx\"\nimport \"nx_tier.nx\"\nimport \"nx_f64.nx\"\nimport \"nx_f64_div.nx\"\nimport \"nx_f64_cvt.nx\"\n" as *u8)
184 // anchor + hi/lo tables: tb[0..20] = c_j, tb[21..41] = A_hi, tb[42..62] = A_lo
185 pe_w(mf, "func _at_tab(tb: *i64) -> i64 {\n" as *u8)
186 var i: i64 = 0
187 while i <= 20 {
188 pe_w(mf, " tb[" as *u8); pe_wn(mf, i); pe_w(mf, "] = " as *u8)
189 pe6_wlit(mf, c[6 + i]); pe_w(mf, "\n" as *u8)
190 i = i + 1
191 }
192 i = 0
193 while i <= 20 {
194 pe_w(mf, " tb[" as *u8); pe_wn(mf, 21 + i); pe_w(mf, "] = " as *u8)
195 pe6_wlit(mf, c[27 + i]); pe_w(mf, "\n" as *u8)
196 i = i + 1
197 }
198 i = 0
199 while i <= 20 {
200 pe_w(mf, " tb[" as *u8); pe_wn(mf, 42 + i); pe_w(mf, "] = " as *u8)
201 pe6_wlit(mf, c[48 + i]); pe_w(mf, "\n" as *u8)
202 i = i + 1
203 }
204 pe_w(mf, " return 63\n}\n" as *u8)
205 // odd poly: t * P(t^2), coeffs c[69..76] hi-first
206 pe_w(mf, "func _at_poly(t: i64) -> i64 {\n let z: i64 = nx_f64_mul(t, t)\n" as *u8)
207 pe_w(mf, " var p: i64 = " as *u8); pe6_wlit(mf, c[69]); pe_w(mf, "\n" as *u8)
208 i = 70
209 while i <= 76 {
210 pe_w(mf, " p = nx_f64_add(nx_f64_mul(p, z), " as *u8); pe6_wlit(mf, c[i]); pe_w(mf, ")\n" as *u8)
211 i = i + 1
212 }
213 pe_w(mf, " return nx_f64_mul(t, p)\n}\n" as *u8)
214 // core on [0, 41/16): j = nearest(8x), accurate-table recombine
215 pe_w(mf, "func _at_core(ax: i64) -> i64 {\n" as *u8)
216 pe_w(mf, " let tk: i64 = nx_f64_add(nx_f64_mul(ax, " as *u8); pe6_wlit(mf, c[2])
217 pe_w(mf, "), " as *u8); pe6_wlit(mf, c[1]); pe_w(mf, ")\n" as *u8)
218 pe_w(mf, " let j: i64 = nx_f64_to_i64(tk)\n" as *u8)
219 pe_w(mf, " let tb: *i64 = sys_mmap(8 * 63) as *i64\n" as *u8)
220 pe_w(mf, " _at_tab(tb)\n" as *u8)
221 pe_w(mf, " let cj: i64 = tb[j]\n" as *u8)
222 pe_w(mf, " let num: i64 = nx_f64_sub(ax, cj)\n" as *u8)
223 pe_w(mf, " let den: i64 = nx_f64_add(" as *u8); pe6_wlit(mf, c[0])
224 pe_w(mf, ", nx_f64_mul(ax, cj))\n" as *u8)
225 pe_w(mf, " let t: i64 = nx_f64_div(num, den)\n" as *u8)
226 pe_w(mf, " let p: i64 = _at_poly(t)\n" as *u8)
227 pe_w(mf, " return nx_f64_add(tb[21 + j], nx_f64_add(tb[42 + j], p))\n}\n" as *u8)
228 // total-domain wrapper: specials, fold seam at cut, sign by OR (atan odd)
229 pe_w(mf, "func nx_f64_atan(x: i64) -> i64 {\n" as *u8)
230 pe_w(mf, " let ax: i64 = x & 0x7FFFFFFFFFFFFFFF\n" as *u8)
231 pe_w(mf, " let ef: i64 = (x >> 52) & 0x7FF\n" as *u8)
232 pe_w(mf, " let sgn: i64 = (x >> 63) & 1\n" as *u8)
233 pe_w(mf, " if ef == 2047 {\n" as *u8)
234 pe_w(mf, " if (ax & 0x000FFFFFFFFFFFFF) != 0 { return 0x7FF8000000000000 }\n" as *u8)
235 pe_w(mf, " if sgn == 1 { return " as *u8); pe6_wlit(mf, c[3]); pe_w(mf, " | (1 << 63) }\n" as *u8)
236 pe_w(mf, " return " as *u8); pe6_wlit(mf, c[3]); pe_w(mf, "\n }\n" as *u8)
237 pe_w(mf, " var v: i64 = 0\n" as *u8)
238 pe_w(mf, " if ax < " as *u8); pe6_wlit(mf, c[5]); pe_w(mf, " {\n" as *u8)
239 pe_w(mf, " v = _at_core(ax)\n } else {\n" as *u8)
240 pe_w(mf, " let u: i64 = nx_f64_div(" as *u8); pe6_wlit(mf, c[0]); pe_w(mf, ", ax)\n" as *u8)
241 pe_w(mf, " v = _at_core(u)\n" as *u8)
242 pe_w(mf, " v = nx_f64_sub(" as *u8); pe6_wlit(mf, c[3])
243 pe_w(mf, ", nx_f64_sub(v, " as *u8); pe6_wlit(mf, c[4]); pe_w(mf, "))\n }\n" as *u8)
244 pe_w(mf, " if sgn == 1 { return v | (1 << 63) }\n return v\n}\n" as *u8)
245 sys_close(mf)
246
247 let tf: i64 = sys_openat_wr(testpath, 0x1a4); if tf < 0 { return 0 }
248 pe_w(tf, "// AUTHORED BY THE NISHI BUILDER (pattern: MATH_KERNEL ATAN test) -- invariant KATs.\n" as *u8)
249 pe_w(tf, "import \"" as *u8); pe_w(tf, modfile); pe_w(tf, "\"\nimport \"nx_syscalls.nx\"\n" as *u8)
250 pe_w(tf, "func main() -> i64 {\n var bad: i64 = 0\n" as *u8)
251 pe_w(tf, " if nx_f64_atan(0) != 0 { bad = bad + 1 }\n" as *u8)
252 pe_w(tf, " if nx_f64_atan(1 << 63) != (1 << 63) { bad = bad + 1 }\n" as *u8)
253 pe_w(tf, " if nx_f64_atan(0x7FF8000000000000) != 0x7FF8000000000000 { bad = bad + 1 }\n" as *u8)
254 pe_w(tf, " if nx_f64_atan(0x7FF0000000000000) != " as *u8); pe6_wlit(tf, c[3]); pe_w(tf, " { bad = bad + 1 }\n" as *u8)
255 pe_w(tf, " if nx_f64_atan(0xFFF0000000000000) != (" as *u8); pe6_wlit(tf, c[3]); pe_w(tf, " | (1 << 63)) { bad = bad + 1 }\n" as *u8)
256 pe_w(tf, " let pv: i64 = nx_f64_atan(0x3FF8000000000000)\n" as *u8)
257 pe_w(tf, " if nx_f64_atan(0xBFF8000000000000) != (pv | (1 << 63)) { bad = bad + 1 }\n" as *u8)
258 pe_w(tf, " let sa: i64 = nx_f64_atan(0x40047FFFFFFFFFFF)\n" as *u8)
259 pe_w(tf, " let sb: i64 = nx_f64_atan(0x4004800000000000)\n" as *u8)
260 pe_w(tf, " let sc: i64 = nx_f64_atan(0x4004800000000001)\n" as *u8)
261 pe_w(tf, " if sa > sb { bad = bad + 1 }\n" as *u8)
262 pe_w(tf, " if sb > sc { bad = bad + 1 }\n" as *u8)
263 pe_w(tf, " let nl: *u8 = sys_mmap(4)\n nl[0] = 10\n" as *u8)
264 pe_w(tf, " if bad == 0 { sys_write(1, \"ATAN-TEST GREEN\" as *u8, 15) } else { sys_write(1, \"ATAN-TEST RED\" as *u8, 13) }\n" as *u8)
265 pe_w(tf, " sys_write(1, nl, 1)\n sys_exit(bad)\n return bad\n}\n" as *u8)
266 sys_close(tf)
267 return 1
268}
269
270// ============ POW (MATH_KERNEL shape, template 4: double-double) ============
271// pow(x,y) = 2^(y*log2|x|), the dd carry chain (fdlibm e_pow shape, re-derived)
272// with EXACT-RATIONAL Taylor families in place of minimax: L_j = 3/(2j+3) for
273// the log2 atanh-correction, P_k = 2*B_2k/(2k)! (Bernoulli) for the exp form
274// e^z = 1 + z - z*t1/(t1-2), t1 = z - z^2*P(z^2). 32-bit raw masking supplies
275// the Dekker splits (no FMA). Total domain; IEEE special matrix in bit logic.
276// Spec layout: see nx_mathspec_pow.nx header (35 rows).
277func pe6_author_pow(modfile: *u8, modpath: *u8, testpath: *u8, c: *i64) -> i64 {
278 let mf: i64 = sys_openat_wr(modpath, 0x1a4); if mf < 0 { return 0 }
279 pe_w(mf, "// AUTHORED BY THE NISHI BUILDER (pattern: MATH_KERNEL / POW) -- no Claude core logic.\n" as *u8)
280 pe_w(mf, "// All constants from the SOVEREIGN bigfloat spec (nx_mathspec_pow). Total domain.\n" as *u8)
281 pe_w(mf, "// dd structure (fdlibm e_pow shape) with exact-rational Taylor families.\n" as *u8)
282 pe_w(mf, "import \"nx_syscalls.nx\"\nimport \"nx_tier.nx\"\nimport \"nx_f64.nx\"\nimport \"nx_f64_div.nx\"\nimport \"nx_f64_cvt.nx\"\n" as *u8)
283 pe_w(mf, "const PW_HMASK: i64 = 0xFFFFFFFF00000000\n" as *u8)
284 pe_w(mf, "func _pw_ycls(ay: i64) -> i64 {\n" as *u8)
285 pe_w(mf, " let e: i64 = ((ay >> 52) & 0x7FF) - 1023\n" as *u8)
286 pe_w(mf, " if e < 0 { return 0 }\n if e >= 53 { return 2 }\n" as *u8)
287 pe_w(mf, " let mant: i64 = (ay & 0x000FFFFFFFFFFFFF) | 0x0010000000000000\n" as *u8)
288 pe_w(mf, " let low: i64 = 52 - e\n" as *u8)
289 pe_w(mf, " if low > 0 {\n if (mant & ((1 << low) - 1)) != 0 { return 0 }\n }\n" as *u8)
290 pe_w(mf, " if ((mant >> low) & 1) == 1 { return 1 }\n return 2\n}\n" as *u8)
291 pe_w(mf, "func _pw_flt(a: i64, b: i64) -> i64 {\n" as *u8)
292 pe_w(mf, " var oa: i64 = a\n if oa < 0 { oa = (1 << 63) - oa }\n" as *u8)
293 pe_w(mf, " var ob: i64 = b\n if ob < 0 { ob = (1 << 63) - ob }\n" as *u8)
294 pe_w(mf, " if oa < ob { return 1 }\n return 0\n}\n" as *u8)
295 // dd log2
296 pe_w(mf, "func _pw_log2m(m_in: i64, n: i64, out: *i64) -> i64 {\n" as *u8)
297 pe_w(mf, " var m: i64 = m_in\n var nn: i64 = n\n" as *u8)
298 pe_w(mf, " var bp: i64 = " as *u8); pe6_wlit(mf, c[0]); pe_w(mf, "\n" as *u8)
299 pe_w(mf, " var dph: i64 = 0\n var dpl: i64 = 0\n" as *u8)
300 pe_w(mf, " if m < " as *u8); pe6_wlit(mf, c[3]); pe_w(mf, " {\n" as *u8)
301 pe_w(mf, " bp = " as *u8); pe6_wlit(mf, c[0]); pe_w(mf, "\n } else {\n" as *u8)
302 pe_w(mf, " if m < " as *u8); pe6_wlit(mf, c[4]); pe_w(mf, " {\n" as *u8)
303 pe_w(mf, " bp = " as *u8); pe6_wlit(mf, c[5])
304 pe_w(mf, "; dph = " as *u8); pe6_wlit(mf, c[6])
305 pe_w(mf, "; dpl = " as *u8); pe6_wlit(mf, c[7]); pe_w(mf, "\n" as *u8)
306 pe_w(mf, " } else {\n nn = nn + 1\n m = m - (1 << 52)\n }\n }\n" as *u8)
307 pe_w(mf, " let u: i64 = nx_f64_sub(m, bp)\n" as *u8)
308 pe_w(mf, " let v: i64 = nx_f64_div(" as *u8); pe6_wlit(mf, c[0]); pe_w(mf, ", nx_f64_add(m, bp))\n" as *u8)
309 pe_w(mf, " let ss: i64 = nx_f64_mul(u, v)\n" as *u8)
310 pe_w(mf, " let sh: i64 = ss & PW_HMASK\n" as *u8)
311 pe_w(mf, " let th: i64 = nx_f64_add(m, bp) & PW_HMASK\n" as *u8)
312 pe_w(mf, " let tl: i64 = nx_f64_sub(m, nx_f64_sub(th, bp))\n" as *u8)
313 pe_w(mf, " let sl: i64 = nx_f64_mul(v, nx_f64_sub(nx_f64_sub(u, nx_f64_mul(sh, th)), nx_f64_mul(sh, tl)))\n" as *u8)
314 pe_w(mf, " let s2: i64 = nx_f64_mul(ss, ss)\n" as *u8)
315 pe_w(mf, " var r: i64 = " as *u8); pe6_wlit(mf, c[14]); pe_w(mf, "\n" as *u8)
316 var i: i64 = 15
317 while i <= 23 {
318 pe_w(mf, " r = nx_f64_add(nx_f64_mul(r, s2), " as *u8); pe6_wlit(mf, c[i]); pe_w(mf, ")\n" as *u8)
319 i = i + 1
320 }
321 pe_w(mf, " r = nx_f64_mul(nx_f64_mul(s2, s2), r)\n" as *u8)
322 pe_w(mf, " r = nx_f64_add(r, nx_f64_mul(sl, nx_f64_add(sh, ss)))\n" as *u8)
323 pe_w(mf, " let s2h: i64 = nx_f64_mul(sh, sh)\n" as *u8)
324 pe_w(mf, " let th3: i64 = nx_f64_add(nx_f64_add(" as *u8); pe6_wlit(mf, c[32]); pe_w(mf, ", s2h), r) & PW_HMASK\n" as *u8)
325 pe_w(mf, " let tl3: i64 = nx_f64_sub(r, nx_f64_sub(nx_f64_sub(th3, " as *u8); pe6_wlit(mf, c[32]); pe_w(mf, "), s2h))\n" as *u8)
326 pe_w(mf, " let u2: i64 = nx_f64_mul(sh, th3)\n" as *u8)
327 pe_w(mf, " let v2: i64 = nx_f64_add(nx_f64_mul(sl, th3), nx_f64_mul(tl3, ss))\n" as *u8)
328 pe_w(mf, " let ph: i64 = nx_f64_add(u2, v2) & PW_HMASK\n" as *u8)
329 pe_w(mf, " let pl: i64 = nx_f64_sub(v2, nx_f64_sub(ph, u2))\n" as *u8)
330 pe_w(mf, " let zh: i64 = nx_f64_mul(" as *u8); pe6_wlit(mf, c[8]); pe_w(mf, ", ph)\n" as *u8)
331 pe_w(mf, " let zl: i64 = nx_f64_add(nx_f64_add(nx_f64_mul(" as *u8); pe6_wlit(mf, c[9])
332 pe_w(mf, ", ph), nx_f64_mul(pl, " as *u8); pe6_wlit(mf, c[10]); pe_w(mf, ")), dpl)\n" as *u8)
333 pe_w(mf, " let t: i64 = nx_i64_to_f64(nn)\n" as *u8)
334 pe_w(mf, " let t1: i64 = nx_f64_add(nx_f64_add(nx_f64_add(zh, zl), dph), t) & PW_HMASK\n" as *u8)
335 pe_w(mf, " let t2: i64 = nx_f64_sub(zl, nx_f64_sub(nx_f64_sub(nx_f64_sub(t1, t), dph), zh))\n" as *u8)
336 pe_w(mf, " out[0] = t1\n out[1] = t2\n return 0\n}\n" as *u8)
337 // total-domain wrapper
338 pe_w(mf, "func nx_f64_pow(x: i64, y: i64) -> i64 {\n" as *u8)
339 pe_w(mf, " let ax: i64 = x & 0x7FFFFFFFFFFFFFFF\n" as *u8)
340 pe_w(mf, " let ay: i64 = y & 0x7FFFFFFFFFFFFFFF\n" as *u8)
341 pe_w(mf, " let xs: i64 = (x >> 63) & 1\n" as *u8)
342 pe_w(mf, " let ys: i64 = (y >> 63) & 1\n" as *u8)
343 pe_w(mf, " let one_raw: i64 = " as *u8); pe6_wlit(mf, c[0]); pe_w(mf, "\n" as *u8)
344 pe_w(mf, " if ay == 0 { return one_raw }\n" as *u8)
345 pe_w(mf, " if x == one_raw { return one_raw }\n" as *u8)
346 pe_w(mf, " var isnan: i64 = 0\n" as *u8)
347 pe_w(mf, " if ax > 0x7FF0000000000000 { isnan = 1 }\n" as *u8)
348 pe_w(mf, " if ay > 0x7FF0000000000000 { isnan = 1 }\n" as *u8)
349 pe_w(mf, " if isnan == 1 { return 0x7FF8000000000000 }\n" as *u8)
350 pe_w(mf, " if ay == 0x7FF0000000000000 {\n" as *u8)
351 pe_w(mf, " if ax == one_raw { return one_raw }\n" as *u8)
352 pe_w(mf, " var big: i64 = 0\n" as *u8)
353 pe_w(mf, " if ax > one_raw { big = 1 - ys } else { big = ys }\n" as *u8)
354 pe_w(mf, " if big == 1 { return 0x7FF0000000000000 }\n return 0\n }\n" as *u8)
355 pe_w(mf, " let ycls: i64 = _pw_ycls(ay)\n" as *u8)
356 pe_w(mf, " if ax == 0x7FF0000000000000 {\n" as *u8)
357 pe_w(mf, " var rs: i64 = 0\n" as *u8)
358 pe_w(mf, " if xs == 1 { if ycls == 1 { rs = 1 } }\n" as *u8)
359 pe_w(mf, " if ys == 0 { return (rs << 63) | 0x7FF0000000000000 }\n" as *u8)
360 pe_w(mf, " return rs << 63\n }\n" as *u8)
361 pe_w(mf, " if ax == 0 {\n" as *u8)
362 pe_w(mf, " var rs0: i64 = 0\n" as *u8)
363 pe_w(mf, " if xs == 1 { if ycls == 1 { rs0 = 1 } }\n" as *u8)
364 pe_w(mf, " if ys == 0 { return rs0 << 63 }\n" as *u8)
365 pe_w(mf, " return (rs0 << 63) | 0x7FF0000000000000\n }\n" as *u8)
366 pe_w(mf, " var rsign: i64 = 0\n" as *u8)
367 pe_w(mf, " if xs == 1 {\n" as *u8)
368 pe_w(mf, " if ycls == 0 { return 0x7FF8000000000000 }\n" as *u8)
369 pe_w(mf, " if ycls == 1 { rsign = 1 }\n }\n" as *u8)
370 pe_w(mf, " if y == one_raw { return x }\n" as *u8)
371 pe_w(mf, " var sig: i64 = ax & 0x000FFFFFFFFFFFFF\n" as *u8)
372 pe_w(mf, " var ef: i64 = (ax >> 52) & 0x7FF\n" as *u8)
373 pe_w(mf, " if ef == 0 {\n ef = 1\n" as *u8)
374 pe_w(mf, " while sig < 0x0010000000000000 { sig = sig << 1; ef = ef - 1 }\n" as *u8)
375 pe_w(mf, " sig = sig & 0x000FFFFFFFFFFFFF\n }\n" as *u8)
376 pe_w(mf, " let n: i64 = ef - 1023\n" as *u8)
377 pe_w(mf, " let mraw: i64 = (1023 << 52) | sig\n" as *u8)
378 pe_w(mf, " let lo2: *i64 = sys_mmap(16) as *i64\n" as *u8)
379 pe_w(mf, " _pw_log2m(mraw, n, lo2)\n" as *u8)
380 pe_w(mf, " let t1: i64 = lo2[0]\n let t2: i64 = lo2[1]\n" as *u8)
381 pe_w(mf, " let y1: i64 = y & PW_HMASK\n" as *u8)
382 pe_w(mf, " let pl0: i64 = nx_f64_add(nx_f64_mul(nx_f64_sub(y, y1), t1), nx_f64_mul(y, t2))\n" as *u8)
383 pe_w(mf, " var ph0: i64 = nx_f64_mul(y1, t1)\n" as *u8)
384 pe_w(mf, " let z: i64 = nx_f64_add(pl0, ph0)\n" as *u8)
385 pe_w(mf, " if _pw_flt(z, " as *u8); pe6_wlit(mf, c[33]); pe_w(mf, ") == 0 { return (rsign << 63) | 0x7FF0000000000000 }\n" as *u8)
386 pe_w(mf, " if _pw_flt(z, " as *u8); pe6_wlit(mf, c[34]); pe_w(mf, " | (1 << 63)) == 1 { return rsign << 63 }\n" as *u8)
387 pe_w(mf, " var n2: i64 = 0\n" as *u8)
388 pe_w(mf, " if (z & 0x7FFFFFFFFFFFFFFF) > " as *u8); pe6_wlit(mf, c[1]); pe_w(mf, " {\n" as *u8)
389 pe_w(mf, " var zr: i64 = 0\n" as *u8)
390 pe_w(mf, " if (z >> 63) == 0 { zr = nx_f64_add(z, " as *u8); pe6_wlit(mf, c[1])
391 pe_w(mf, ") } else { zr = nx_f64_sub(z, " as *u8); pe6_wlit(mf, c[1]); pe_w(mf, ") }\n" as *u8)
392 pe_w(mf, " n2 = nx_f64_to_i64(zr)\n" as *u8)
393 pe_w(mf, " ph0 = nx_f64_sub(ph0, nx_i64_to_f64(n2))\n }\n" as *u8)
394 pe_w(mf, " let tfr: i64 = nx_f64_add(pl0, ph0) & PW_HMASK\n" as *u8)
395 pe_w(mf, " let u3: i64 = nx_f64_mul(tfr, " as *u8); pe6_wlit(mf, c[12]); pe_w(mf, ")\n" as *u8)
396 pe_w(mf, " let v3: i64 = nx_f64_add(nx_f64_mul(nx_f64_sub(pl0, nx_f64_sub(tfr, ph0)), " as *u8); pe6_wlit(mf, c[11])
397 pe_w(mf, "), nx_f64_mul(tfr, " as *u8); pe6_wlit(mf, c[13]); pe_w(mf, "))\n" as *u8)
398 pe_w(mf, " let z3: i64 = nx_f64_add(u3, v3)\n" as *u8)
399 pe_w(mf, " let w3: i64 = nx_f64_sub(v3, nx_f64_sub(z3, u3))\n" as *u8)
400 pe_w(mf, " let t3: i64 = nx_f64_mul(z3, z3)\n" as *u8)
401 pe_w(mf, " var pp: i64 = " as *u8); pe6_wlit(mf, c[24]); pe_w(mf, "\n" as *u8)
402 i = 25
403 while i <= 31 {
404 pe_w(mf, " pp = nx_f64_add(nx_f64_mul(pp, t3), " as *u8); pe6_wlit(mf, c[i]); pe_w(mf, ")\n" as *u8)
405 i = i + 1
406 }
407 pe_w(mf, " let t1p: i64 = nx_f64_sub(z3, nx_f64_mul(t3, pp))\n" as *u8)
408 pe_w(mf, " let r3: i64 = nx_f64_sub(nx_f64_div(nx_f64_mul(z3, t1p), nx_f64_sub(t1p, " as *u8); pe6_wlit(mf, c[2])
409 pe_w(mf, ")), w3)\n" as *u8)
410 pe_w(mf, " let zf: i64 = nx_f64_sub(" as *u8); pe6_wlit(mf, c[0]); pe_w(mf, ", nx_f64_sub(r3, z3))\n" as *u8)
411 pe_w(mf, " let efz: i64 = (zf >> 52) & 0x7FF\n" as *u8)
412 pe_w(mf, " let eo: i64 = efz + n2\n" as *u8)
413 pe_w(mf, " if eo >= 2047 { return (rsign << 63) | 0x7FF0000000000000 }\n" as *u8)
414 pe_w(mf, " if eo >= 1 { return (rsign << 63) | (zf + (n2 << 52)) }\n" as *u8)
415 pe_w(mf, " let m1: i64 = zf - (900 << 52)\n" as *u8)
416 pe_w(mf, " let pw2: i64 = (n2 + 1923) << 52\n" as *u8)
417 pe_w(mf, " return (rsign << 63) | nx_f64_mul(m1, pw2)\n}\n" as *u8)
418 sys_close(mf)
419
420 let tf: i64 = sys_openat_wr(testpath, 0x1a4); if tf < 0 { return 0 }
421 pe_w(tf, "// AUTHORED BY THE NISHI BUILDER (pattern: MATH_KERNEL POW test) -- invariant KATs.\n" as *u8)
422 pe_w(tf, "import \"" as *u8); pe_w(tf, modfile); pe_w(tf, "\"\nimport \"nx_syscalls.nx\"\n" as *u8)
423 pe_w(tf, "func main() -> i64 {\n var bad: i64 = 0\n" as *u8)
424 pe_w(tf, " let one: i64 = " as *u8); pe6_wlit(tf, c[0]); pe_w(tf, "\n" as *u8)
425 pe_w(tf, " if nx_f64_pow(0x7FF8000000000000, 0) != one { bad = bad + 1 }\n" as *u8)
426 pe_w(tf, " if nx_f64_pow(one, 0x7FF8000000000000) != one { bad = bad + 1 }\n" as *u8)
427 pe_w(tf, " if nx_f64_pow(0x7FF8000000000000, one) != 0x7FF8000000000000 { bad = bad + 1 }\n" as *u8)
428 pe_w(tf, " if nx_f64_pow(0, " as *u8); pe6_wlit(tf, c[32]); pe_w(tf, ") != 0 { bad = bad + 1 }\n" as *u8)
429 pe_w(tf, " if nx_f64_pow(1 << 63, " as *u8); pe6_wlit(tf, c[32]); pe_w(tf, ") != (1 << 63) { bad = bad + 1 }\n" as *u8)
430 pe_w(tf, " if nx_f64_pow(0x7FF0000000000000, " as *u8); pe6_wlit(tf, c[32]); pe_w(tf, ") != 0x7FF0000000000000 { bad = bad + 1 }\n" as *u8)
431 pe_w(tf, " if nx_f64_pow(0xFFF0000000000000, " as *u8); pe6_wlit(tf, c[32]); pe_w(tf, ") != 0xFFF0000000000000 { bad = bad + 1 }\n" as *u8)
432 pe_w(tf, " let two: i64 = " as *u8); pe6_wlit(tf, c[2]); pe_w(tf, "\n" as *u8)
433 pe_w(tf, " if nx_f64_pow(two, two) != nx_f64_pow(nx_f64_pow(two, one), two) { bad = bad + 1 }\n" as *u8)
434 pe_w(tf, " if nx_f64_pow(two, one) != two { bad = bad + 1 }\n" as *u8)
435 pe_w(tf, " if nx_f64_pow(nx_f64_pow(two, two), " as *u8); pe6_wlit(tf, c[1]); pe_w(tf, ") != two { bad = bad + 1 }\n" as *u8)
436 pe_w(tf, " let nl: *u8 = sys_mmap(4)\n nl[0] = 10\n" as *u8)
437 pe_w(tf, " if bad == 0 { sys_write(1, \"POW-TEST GREEN\" as *u8, 14) } else { sys_write(1, \"POW-TEST RED\" as *u8, 12) }\n" as *u8)
438 pe_w(tf, " sys_write(1, nl, 1)\n sys_exit(bad)\n return bad\n}\n" as *u8)
439 sys_close(tf)
440 return 1
441}
442
443// ============ TAN (MATH_KERNEL shape, template 5: accurate-table + dd) ============
444// pi/2 Cody-Waite 3-part reduce -> r dd; anchors a_j = j/8 over [0, pi/4];
445// tan(a+d) = T + t*sec2(a)/(1 - T*t) with num/den in dd (Dekker 26-bit splits,
446// 1-m1 Sterbenz-exact) and one quotient refinement; odd quadrants -1/tan via a
447// refined dd reciprocal. Small-residual poly = EXACT tangent-number Taylor.
448// Spec layout: see nx_mathspec_tan.nx header (49 rows).
449func pe6_author_tan(modfile: *u8, modpath: *u8, testpath: *u8, c: *i64) -> i64 {
450 let mf: i64 = sys_openat_wr(modpath, 0x1a4); if mf < 0 { return 0 }
451 pe_w(mf, "// AUTHORED BY THE NISHI BUILDER (pattern: MATH_KERNEL / TAN) -- no Claude core logic.\n" as *u8)
452 pe_w(mf, "// All constants from the SOVEREIGN bigfloat spec (nx_mathspec_tan). v1 domain |x| < 2^20.\n" as *u8)
453 pe_w(mf, "// Accurate-table + double-double; exact tangent-number Taylor (no minimax).\n" as *u8)
454 pe_w(mf, "import \"nx_syscalls.nx\"\nimport \"nx_tier.nx\"\nimport \"nx_f64.nx\"\nimport \"nx_f64_div.nx\"\nimport \"nx_f64_cvt.nx\"\n" as *u8)
455 pe_w(mf, "const TN_SMASK: i64 = 0xFFFFFFFFF8000000\n" as *u8)
456 pe_w(mf, "func _tn_mul2(a: i64, b: i64, out: *i64) -> i64 {\n" as *u8)
457 pe_w(mf, " let ah: i64 = a & TN_SMASK\n let al: i64 = nx_f64_sub(a, ah)\n" as *u8)
458 pe_w(mf, " let bh: i64 = b & TN_SMASK\n let bl: i64 = nx_f64_sub(b, bh)\n" as *u8)
459 pe_w(mf, " let p: i64 = nx_f64_mul(a, b)\n" as *u8)
460 pe_w(mf, " var e: i64 = nx_f64_sub(nx_f64_mul(ah, bh), p)\n" as *u8)
461 pe_w(mf, " e = nx_f64_add(e, nx_f64_mul(ah, bl))\n" as *u8)
462 pe_w(mf, " e = nx_f64_add(e, nx_f64_mul(al, bh))\n" as *u8)
463 pe_w(mf, " e = nx_f64_add(e, nx_f64_mul(al, bl))\n" as *u8)
464 pe_w(mf, " out[0] = p\n out[1] = e\n return 0\n}\n" as *u8)
465 pe_w(mf, "func _tn_2sum(a: i64, b: i64, out: *i64) -> i64 {\n" as *u8)
466 pe_w(mf, " let s: i64 = nx_f64_add(a, b)\n" as *u8)
467 pe_w(mf, " let bv: i64 = nx_f64_sub(s, a)\n" as *u8)
468 pe_w(mf, " let e: i64 = nx_f64_add(nx_f64_sub(a, nx_f64_sub(s, bv)), nx_f64_sub(b, bv))\n" as *u8)
469 pe_w(mf, " out[0] = s\n out[1] = e\n return 0\n}\n" as *u8)
470 // anchor/T/S tables: tb[j]=a_j tb[7+j]=T_hi tb[14+j]=T_lo tb[21+j]=S_hi tb[28+j]=S_lo
471 pe_w(mf, "func _tn_tab(tb: *i64) -> i64 {\n" as *u8)
472 var i: i64 = 0
473 while i <= 6 {
474 pe_w(mf, " tb[" as *u8); pe_wn(mf, i); pe_w(mf, "] = " as *u8)
475 pe6_wlit(mf, c[7 + i]); pe_w(mf, "\n" as *u8)
476 i = i + 1
477 }
478 i = 0
479 while i <= 6 {
480 pe_w(mf, " tb[" as *u8); pe_wn(mf, 7 + i); pe_w(mf, "] = " as *u8)
481 pe6_wlit(mf, c[14 + i]); pe_w(mf, "\n" as *u8)
482 i = i + 1
483 }
484 i = 0
485 while i <= 6 {
486 pe_w(mf, " tb[" as *u8); pe_wn(mf, 14 + i); pe_w(mf, "] = " as *u8)
487 pe6_wlit(mf, c[21 + i]); pe_w(mf, "\n" as *u8)
488 i = i + 1
489 }
490 i = 0
491 while i <= 6 {
492 pe_w(mf, " tb[" as *u8); pe_wn(mf, 21 + i); pe_w(mf, "] = " as *u8)
493 pe6_wlit(mf, c[28 + i]); pe_w(mf, "\n" as *u8)
494 i = i + 1
495 }
496 i = 0
497 while i <= 6 {
498 pe_w(mf, " tb[" as *u8); pe_wn(mf, 28 + i); pe_w(mf, "] = " as *u8)
499 pe6_wlit(mf, c[35 + i]); pe_w(mf, "\n" as *u8)
500 i = i + 1
501 }
502 pe_w(mf, " return 35\n}\n" as *u8)
503 // core
504 pe_w(mf, "func _tn_core(ar: i64, art: i64, out: *i64) -> i64 {\n" as *u8)
505 pe_w(mf, " let tk: i64 = nx_f64_add(nx_f64_mul(ar, " as *u8); pe6_wlit(mf, c[6])
506 pe_w(mf, "), " as *u8); pe6_wlit(mf, c[1]); pe_w(mf, ")\n" as *u8)
507 pe_w(mf, " let j: i64 = nx_f64_to_i64(tk)\n" as *u8)
508 pe_w(mf, " let tb: *i64 = sys_mmap(8 * 35) as *i64\n _tn_tab(tb)\n" as *u8)
509 pe_w(mf, " let d0: i64 = nx_f64_sub(ar, tb[j])\n" as *u8)
510 pe_w(mf, " let dd: *i64 = sys_mmap(16) as *i64\n _tn_2sum(d0, art, dd)\n" as *u8)
511 pe_w(mf, " let dh: i64 = dd[0]\n let dl: i64 = dd[1]\n" as *u8)
512 pe_w(mf, " let z: i64 = nx_f64_mul(dh, dh)\n" as *u8)
513 pe_w(mf, " var q: i64 = " as *u8); pe6_wlit(mf, c[42]); pe_w(mf, "\n" as *u8)
514 i = 43
515 while i <= 48 {
516 pe_w(mf, " q = nx_f64_add(nx_f64_mul(q, z), " as *u8); pe6_wlit(mf, c[i]); pe_w(mf, ")\n" as *u8)
517 i = i + 1
518 }
519 pe_w(mf, " let tcorr: i64 = nx_f64_add(nx_f64_mul(nx_f64_mul(dh, z), q), dl)\n" as *u8)
520 pe_w(mf, " let tv: *i64 = sys_mmap(16) as *i64\n _tn_2sum(dh, tcorr, tv)\n" as *u8)
521 pe_w(mf, " let th: i64 = tv[0]\n let tl: i64 = tv[1]\n" as *u8)
522 pe_w(mf, " if j == 0 {\n out[0] = th\n out[1] = tl\n return 0\n }\n" as *u8)
523 pe_w(mf, " let pr: *i64 = sys_mmap(16) as *i64\n" as *u8)
524 pe_w(mf, " _tn_mul2(th, tb[21 + j], pr)\n" as *u8)
525 pe_w(mf, " let n1: i64 = pr[0]\n" as *u8)
526 pe_w(mf, " let n2: i64 = nx_f64_add(pr[1], nx_f64_add(nx_f64_mul(th, tb[28 + j]), nx_f64_mul(tl, tb[21 + j])))\n" as *u8)
527 pe_w(mf, " _tn_mul2(tb[7 + j], th, pr)\n" as *u8)
528 pe_w(mf, " let m1: i64 = pr[0]\n" as *u8)
529 pe_w(mf, " let m2: i64 = nx_f64_add(pr[1], nx_f64_add(nx_f64_mul(tb[7 + j], tl), nx_f64_mul(tb[14 + j], th)))\n" as *u8)
530 pe_w(mf, " let d1: i64 = nx_f64_sub(" as *u8); pe6_wlit(mf, c[0]); pe_w(mf, ", m1)\n" as *u8)
531 pe_w(mf, " let d2f: i64 = m2 ^ (1 << 63)\n" as *u8)
532 pe_w(mf, " let q0: i64 = nx_f64_div(n1, d1)\n" as *u8)
533 pe_w(mf, " _tn_mul2(q0, d1, pr)\n" as *u8)
534 pe_w(mf, " var e: i64 = nx_f64_sub(nx_f64_sub(n1, pr[0]), pr[1])\n" as *u8)
535 pe_w(mf, " e = nx_f64_add(e, n2)\n" as *u8)
536 pe_w(mf, " e = nx_f64_sub(e, nx_f64_mul(q0, d2f))\n" as *u8)
537 pe_w(mf, " let ql: i64 = nx_f64_div(e, d1)\n" as *u8)
538 pe_w(mf, " let sv: *i64 = sys_mmap(16) as *i64\n" as *u8)
539 pe_w(mf, " _tn_2sum(tb[7 + j], q0, sv)\n" as *u8)
540 pe_w(mf, " let vt: i64 = nx_f64_add(sv[1], nx_f64_add(tb[14 + j], ql))\n" as *u8)
541 pe_w(mf, " _tn_2sum(sv[0], vt, sv)\n" as *u8)
542 pe_w(mf, " out[0] = sv[0]\n out[1] = sv[1]\n return 0\n}\n" as *u8)
543 // wrapper
544 pe_w(mf, "func nx_f64_tan(x: i64) -> i64 {\n" as *u8)
545 pe_w(mf, " let ax: i64 = x & 0x7FFFFFFFFFFFFFFF\n" as *u8)
546 pe_w(mf, " let ef: i64 = (x >> 52) & 0x7FF\n" as *u8)
547 pe_w(mf, " if ef == 2047 { return 0x7FF8000000000000 }\n" as *u8)
548 pe_w(mf, " if ax == 0 { return x }\n" as *u8)
549 pe_w(mf, " if ef >= 1043 { return 0x7FF8000000000000 }\n" as *u8)
550 pe_w(mf, " let t8: i64 = nx_f64_mul(x, " as *u8); pe6_wlit(mf, c[2]); pe_w(mf, ")\n" as *u8)
551 pe_w(mf, " var tkr: i64 = 0\n" as *u8)
552 pe_w(mf, " if ((t8 >> 63) & 1) == 1 { tkr = nx_f64_sub(t8, " as *u8); pe6_wlit(mf, c[1])
553 pe_w(mf, ") } else { tkr = nx_f64_add(t8, " as *u8); pe6_wlit(mf, c[1]); pe_w(mf, ") }\n" as *u8)
554 pe_w(mf, " let k: i64 = nx_f64_to_i64(tkr)\n" as *u8)
555 pe_w(mf, " let kf: i64 = nx_i64_to_f64(k)\n" as *u8)
556 pe_w(mf, " let r1: i64 = nx_f64_sub(x, nx_f64_mul(kf, " as *u8); pe6_wlit(mf, c[3]); pe_w(mf, "))\n" as *u8)
557 pe_w(mf, " let r2: i64 = nx_f64_sub(r1, nx_f64_mul(kf, " as *u8); pe6_wlit(mf, c[4]); pe_w(mf, "))\n" as *u8)
558 pe_w(mf, " let w: i64 = nx_f64_mul(kf, " as *u8); pe6_wlit(mf, c[5]); pe_w(mf, ")\n" as *u8)
559 pe_w(mf, " let rh: i64 = nx_f64_sub(r2, w)\n" as *u8)
560 pe_w(mf, " let rt: i64 = nx_f64_sub(nx_f64_sub(r2, rh), w)\n" as *u8)
561 pe_w(mf, " let rs: i64 = (rh >> 63) & 1\n" as *u8)
562 pe_w(mf, " let ar: i64 = rh & 0x7FFFFFFFFFFFFFFF\n" as *u8)
563 pe_w(mf, " var art: i64 = rt\n" as *u8)
564 pe_w(mf, " if rs == 1 { art = rt ^ (1 << 63) }\n" as *u8)
565 pe_w(mf, " let v: *i64 = sys_mmap(16) as *i64\n" as *u8)
566 pe_w(mf, " _tn_core(ar, art, v)\n" as *u8)
567 pe_w(mf, " if (k & 1) == 0 {\n" as *u8)
568 pe_w(mf, " let res: i64 = nx_f64_add(v[0], v[1])\n" as *u8)
569 pe_w(mf, " if rs == 1 { return res ^ (1 << 63) }\n" as *u8)
570 pe_w(mf, " return res\n }\n" as *u8)
571 pe_w(mf, " let q0: i64 = nx_f64_div(" as *u8); pe6_wlit(mf, c[0]); pe_w(mf, ", v[0])\n" as *u8)
572 pe_w(mf, " let pr: *i64 = sys_mmap(16) as *i64\n" as *u8)
573 pe_w(mf, " _tn_mul2(q0, v[0], pr)\n" as *u8)
574 pe_w(mf, " var e2: i64 = nx_f64_sub(nx_f64_sub(" as *u8); pe6_wlit(mf, c[0]); pe_w(mf, ", pr[0]), pr[1])\n" as *u8)
575 pe_w(mf, " e2 = nx_f64_sub(e2, nx_f64_mul(q0, v[1]))\n" as *u8)
576 pe_w(mf, " let mag: i64 = nx_f64_add(q0, nx_f64_mul(q0, e2))\n" as *u8)
577 pe_w(mf, " if rs == 1 { return mag }\n" as *u8)
578 pe_w(mf, " return mag ^ (1 << 63)\n}\n" as *u8)
579 sys_close(mf)
580
581 let tf: i64 = sys_openat_wr(testpath, 0x1a4); if tf < 0 { return 0 }
582 pe_w(tf, "// AUTHORED BY THE NISHI BUILDER (pattern: MATH_KERNEL TAN test) -- invariant KATs.\n" as *u8)
583 pe_w(tf, "import \"" as *u8); pe_w(tf, modfile); pe_w(tf, "\"\nimport \"nx_syscalls.nx\"\n" as *u8)
584 pe_w(tf, "func main() -> i64 {\n var bad: i64 = 0\n" as *u8)
585 pe_w(tf, " if nx_f64_tan(0) != 0 { bad = bad + 1 }\n" as *u8)
586 pe_w(tf, " if nx_f64_tan(1 << 63) != (1 << 63) { bad = bad + 1 }\n" as *u8)
587 pe_w(tf, " if nx_f64_tan(0x7FF8000000000000) != 0x7FF8000000000000 { bad = bad + 1 }\n" as *u8)
588 pe_w(tf, " if nx_f64_tan(0x7FF0000000000000) != 0x7FF8000000000000 { bad = bad + 1 }\n" as *u8)
589 pe_w(tf, " if nx_f64_tan(0x4140000000000000) != 0x7FF8000000000000 { bad = bad + 1 }\n" as *u8)
590 pe_w(tf, " let pv: i64 = nx_f64_tan(0x3FE0000000000000)\n" as *u8)
591 pe_w(tf, " if nx_f64_tan(0xBFE0000000000000) != (pv | (1 << 63)) { bad = bad + 1 }\n" as *u8)
592 pe_w(tf, " let below: i64 = nx_f64_tan(0x3FF921FB54442D18)\n" as *u8)
593 pe_w(tf, " let above: i64 = nx_f64_tan(0x3FF921FB54442D19)\n" as *u8)
594 pe_w(tf, " if ((below >> 63) & 1) != 0 { bad = bad + 1 }\n" as *u8)
595 pe_w(tf, " if ((above >> 63) & 1) != 1 { bad = bad + 1 }\n" as *u8)
596 pe_w(tf, " if ((below >> 52) & 0x7FF) < 1073 { bad = bad + 1 }\n" as *u8)
597 pe_w(tf, " let nl: *u8 = sys_mmap(4)\n nl[0] = 10\n" as *u8)
598 pe_w(tf, " if bad == 0 { sys_write(1, \"TAN-TEST GREEN\" as *u8, 14) } else { sys_write(1, \"TAN-TEST RED\" as *u8, 12) }\n" as *u8)
599 pe_w(tf, " sys_write(1, nl, 1)\n sys_exit(bad)\n return bad\n}\n" as *u8)
600 sys_close(tf)
601 return 1
602}
603
604// ============ SINH+COSH (MATH_KERNEL shape, template 6: exp-dd pair) ============
605// One file, shared exp-dd core (ln2 hi/lo reduce + Bernoulli form to dd).
606// x < 1 exact-factorial Taylor; [1,28) (E -+ 2^-2n/E)/2 with refined dd
607// reciprocal; x >= 28 e^-x is sub-ulp -> 2^(n-1)*(zh+zl) exact assembly with
608// natural overflow. Spec layout: see nx_mathspec_sinhcosh.nx header (36 rows).
609func pe6_author_sinhcosh(modfile: *u8, modpath: *u8, testpath: *u8, c: *i64) -> i64 {
610 let mf: i64 = sys_openat_wr(modpath, 0x1a4); if mf < 0 { return 0 }
611 pe_w(mf, "// AUTHORED BY THE NISHI BUILDER (pattern: MATH_KERNEL / SINHCOSH) -- no Claude core logic.\n" as *u8)
612 pe_w(mf, "// All constants from the SOVEREIGN bigfloat spec (nx_mathspec_sinhcosh). Total domain.\n" as *u8)
613 pe_w(mf, "// Shared exp-dd core; exact-factorial Taylor below 1; no minimax anywhere.\n" as *u8)
614 pe_w(mf, "import \"nx_syscalls.nx\"\nimport \"nx_tier.nx\"\nimport \"nx_f64.nx\"\nimport \"nx_f64_div.nx\"\nimport \"nx_f64_cvt.nx\"\n" as *u8)
615 pe_w(mf, "const SH_SMASK: i64 = 0xFFFFFFFFF8000000\n" as *u8)
616 pe_w(mf, "func _sh_mul2(a: i64, b: i64, out: *i64) -> i64 {\n" as *u8)
617 pe_w(mf, " let ah: i64 = a & SH_SMASK\n let al: i64 = nx_f64_sub(a, ah)\n" as *u8)
618 pe_w(mf, " let bh: i64 = b & SH_SMASK\n let bl: i64 = nx_f64_sub(b, bh)\n" as *u8)
619 pe_w(mf, " let p: i64 = nx_f64_mul(a, b)\n" as *u8)
620 pe_w(mf, " var e: i64 = nx_f64_sub(nx_f64_mul(ah, bh), p)\n" as *u8)
621 pe_w(mf, " e = nx_f64_add(e, nx_f64_mul(ah, bl))\n" as *u8)
622 pe_w(mf, " e = nx_f64_add(e, nx_f64_mul(al, bh))\n" as *u8)
623 pe_w(mf, " e = nx_f64_add(e, nx_f64_mul(al, bl))\n" as *u8)
624 pe_w(mf, " out[0] = p\n out[1] = e\n return 0\n}\n" as *u8)
625 pe_w(mf, "func _sh_2sum(a: i64, b: i64, out: *i64) -> i64 {\n" as *u8)
626 pe_w(mf, " let s: i64 = nx_f64_add(a, b)\n" as *u8)
627 pe_w(mf, " let bv: i64 = nx_f64_sub(s, a)\n" as *u8)
628 pe_w(mf, " let e: i64 = nx_f64_add(nx_f64_sub(a, nx_f64_sub(s, bv)), nx_f64_sub(b, bv))\n" as *u8)
629 pe_w(mf, " out[0] = s\n out[1] = e\n return 0\n}\n" as *u8)
630 pe_w(mf, "func _sh_scale(v: i64, m: i64) -> i64 {\n" as *u8)
631 pe_w(mf, " if (v & 0x7FFFFFFFFFFFFFFF) == 0 { return v }\n" as *u8)
632 pe_w(mf, " return v + (m << 52)\n}\n" as *u8)
633 pe_w(mf, "func _sh_expdd(ax: i64, out: *i64) -> i64 {\n" as *u8)
634 pe_w(mf, " let tk: i64 = nx_f64_add(nx_f64_mul(ax, " as *u8); pe6_wlit(mf, c[3])
635 pe_w(mf, "), " as *u8); pe6_wlit(mf, c[1]); pe_w(mf, ")\n" as *u8)
636 pe_w(mf, " let n: i64 = nx_f64_to_i64(tk)\n" as *u8)
637 pe_w(mf, " let kf: i64 = nx_i64_to_f64(n)\n" as *u8)
638 pe_w(mf, " let r1: i64 = nx_f64_sub(ax, nx_f64_mul(kf, " as *u8); pe6_wlit(mf, c[4]); pe_w(mf, "))\n" as *u8)
639 pe_w(mf, " let w: i64 = nx_f64_mul(kf, " as *u8); pe6_wlit(mf, c[5]); pe_w(mf, ")\n" as *u8)
640 pe_w(mf, " let rh: i64 = nx_f64_sub(r1, w)\n" as *u8)
641 pe_w(mf, " let rt: i64 = nx_f64_sub(nx_f64_sub(r1, rh), w)\n" as *u8)
642 pe_w(mf, " let t3: i64 = nx_f64_mul(rh, rh)\n" as *u8)
643 pe_w(mf, " var pp: i64 = " as *u8); pe6_wlit(mf, c[6]); pe_w(mf, "\n" as *u8)
644 var i: i64 = 7
645 while i <= 13 {
646 pe_w(mf, " pp = nx_f64_add(nx_f64_mul(pp, t3), " as *u8); pe6_wlit(mf, c[i]); pe_w(mf, ")\n" as *u8)
647 i = i + 1
648 }
649 pe_w(mf, " let t1p: i64 = nx_f64_sub(rh, nx_f64_mul(t3, pp))\n" as *u8)
650 pe_w(mf, " let dv: i64 = nx_f64_div(nx_f64_mul(rh, t1p), nx_f64_sub(t1p, " as *u8); pe6_wlit(mf, c[2]); pe_w(mf, "))\n" as *u8)
651 pe_w(mf, " let sv: *i64 = sys_mmap(16) as *i64\n" as *u8)
652 pe_w(mf, " _sh_2sum(" as *u8); pe6_wlit(mf, c[0]); pe_w(mf, ", rh, sv)\n" as *u8)
653 pe_w(mf, " let tail: i64 = nx_f64_sub(nx_f64_add(sv[1], rt), dv)\n" as *u8)
654 pe_w(mf, " let zz: *i64 = sys_mmap(16) as *i64\n" as *u8)
655 pe_w(mf, " _sh_2sum(sv[0], tail, zz)\n" as *u8)
656 pe_w(mf, " out[0] = zz[0]\n out[1] = zz[1]\n out[2] = n\n return 0\n}\n" as *u8)
657 // sinh
658 pe_w(mf, "func nx_f64_sinh(x: i64) -> i64 {\n" as *u8)
659 pe_w(mf, " let ax: i64 = x & 0x7FFFFFFFFFFFFFFF\n" as *u8)
660 pe_w(mf, " let ef: i64 = (x >> 52) & 0x7FF\n" as *u8)
661 pe_w(mf, " let sgn: i64 = (x >> 63) & 1\n" as *u8)
662 pe_w(mf, " if ef == 2047 {\n" as *u8)
663 pe_w(mf, " if (ax & 0x000FFFFFFFFFFFFF) != 0 { return 0x7FF8000000000000 }\n" as *u8)
664 pe_w(mf, " return x\n }\n" as *u8)
665 pe_w(mf, " if ax == 0 { return x }\n" as *u8)
666 pe_w(mf, " if ax >= " as *u8); pe6_wlit(mf, c[35]); pe_w(mf, " { return (sgn << 63) | 0x7FF0000000000000 }\n" as *u8)
667 pe_w(mf, " if ax < " as *u8); pe6_wlit(mf, c[0]); pe_w(mf, " {\n" as *u8)
668 pe_w(mf, " let z: i64 = nx_f64_mul(ax, ax)\n" as *u8)
669 pe_w(mf, " var p: i64 = " as *u8); pe6_wlit(mf, c[14]); pe_w(mf, "\n" as *u8)
670 i = 15
671 while i <= 23 {
672 pe_w(mf, " p = nx_f64_add(nx_f64_mul(p, z), " as *u8); pe6_wlit(mf, c[i]); pe_w(mf, ")\n" as *u8)
673 i = i + 1
674 }
675 pe_w(mf, " let res: i64 = nx_f64_add(ax, nx_f64_mul(nx_f64_mul(ax, z), p))\n" as *u8)
676 pe_w(mf, " return (sgn << 63) | res\n }\n" as *u8)
677 pe_w(mf, " let eo2: *i64 = sys_mmap(24) as *i64\n" as *u8)
678 pe_w(mf, " _sh_expdd(ax, eo2)\n" as *u8)
679 pe_w(mf, " let zh: i64 = eo2[0]\n let zl: i64 = eo2[1]\n let n: i64 = eo2[2]\n" as *u8)
680 pe_w(mf, " if ax >= " as *u8); pe6_wlit(mf, c[34]); pe_w(mf, " {\n" as *u8)
681 pe_w(mf, " let m: i64 = nx_f64_add(zh, zl)\n" as *u8)
682 pe_w(mf, " let eo: i64 = ((m >> 52) & 0x7FF) + n - 1\n" as *u8)
683 pe_w(mf, " if eo >= 2047 { return (sgn << 63) | 0x7FF0000000000000 }\n" as *u8)
684 pe_w(mf, " return (sgn << 63) | _sh_scale(m, n - 1)\n }\n" as *u8)
685 pe_w(mf, " let q0: i64 = nx_f64_div(" as *u8); pe6_wlit(mf, c[0]); pe_w(mf, ", zh)\n" as *u8)
686 pe_w(mf, " let pr: *i64 = sys_mmap(16) as *i64\n" as *u8)
687 pe_w(mf, " _sh_mul2(q0, zh, pr)\n" as *u8)
688 pe_w(mf, " var e2: i64 = nx_f64_sub(nx_f64_sub(" as *u8); pe6_wlit(mf, c[0]); pe_w(mf, ", pr[0]), pr[1])\n" as *u8)
689 pe_w(mf, " e2 = nx_f64_sub(e2, nx_f64_mul(q0, zl))\n" as *u8)
690 pe_w(mf, " let ql: i64 = nx_f64_mul(q0, e2)\n" as *u8)
691 pe_w(mf, " let ehv: i64 = _sh_scale(zh, n)\n" as *u8)
692 pe_w(mf, " let elv: i64 = _sh_scale(zl, n)\n" as *u8)
693 pe_w(mf, " let ihv: i64 = _sh_scale(q0, 0 - n)\n" as *u8)
694 pe_w(mf, " let ilv: i64 = _sh_scale(ql, 0 - n)\n" as *u8)
695 pe_w(mf, " let sv: *i64 = sys_mmap(16) as *i64\n" as *u8)
696 pe_w(mf, " _sh_2sum(ehv, ihv ^ (1 << 63), sv)\n" as *u8)
697 pe_w(mf, " let tail: i64 = nx_f64_sub(nx_f64_add(sv[1], elv), ilv)\n" as *u8)
698 pe_w(mf, " let res2: i64 = nx_f64_add(sv[0], tail)\n" as *u8)
699 pe_w(mf, " return (sgn << 63) | _sh_scale(res2, 0 - 1)\n}\n" as *u8)
700 // cosh
701 pe_w(mf, "func nx_f64_cosh(x: i64) -> i64 {\n" as *u8)
702 pe_w(mf, " let ax: i64 = x & 0x7FFFFFFFFFFFFFFF\n" as *u8)
703 pe_w(mf, " let ef: i64 = (x >> 52) & 0x7FF\n" as *u8)
704 pe_w(mf, " if ef == 2047 {\n" as *u8)
705 pe_w(mf, " if (ax & 0x000FFFFFFFFFFFFF) != 0 { return 0x7FF8000000000000 }\n" as *u8)
706 pe_w(mf, " return 0x7FF0000000000000\n }\n" as *u8)
707 pe_w(mf, " if ax == 0 { return " as *u8); pe6_wlit(mf, c[0]); pe_w(mf, " }\n" as *u8)
708 pe_w(mf, " if ax >= " as *u8); pe6_wlit(mf, c[35]); pe_w(mf, " { return 0x7FF0000000000000 }\n" as *u8)
709 pe_w(mf, " if ax < " as *u8); pe6_wlit(mf, c[0]); pe_w(mf, " {\n" as *u8)
710 pe_w(mf, " let z: i64 = nx_f64_mul(ax, ax)\n" as *u8)
711 pe_w(mf, " var p: i64 = " as *u8); pe6_wlit(mf, c[24]); pe_w(mf, "\n" as *u8)
712 i = 25
713 while i <= 33 {
714 pe_w(mf, " p = nx_f64_add(nx_f64_mul(p, z), " as *u8); pe6_wlit(mf, c[i]); pe_w(mf, ")\n" as *u8)
715 i = i + 1
716 }
717 pe_w(mf, " return nx_f64_add(" as *u8); pe6_wlit(mf, c[0]); pe_w(mf, ", nx_f64_mul(z, p))\n }\n" as *u8)
718 pe_w(mf, " let eo2: *i64 = sys_mmap(24) as *i64\n" as *u8)
719 pe_w(mf, " _sh_expdd(ax, eo2)\n" as *u8)
720 pe_w(mf, " let zh: i64 = eo2[0]\n let zl: i64 = eo2[1]\n let n: i64 = eo2[2]\n" as *u8)
721 pe_w(mf, " if ax >= " as *u8); pe6_wlit(mf, c[34]); pe_w(mf, " {\n" as *u8)
722 pe_w(mf, " let m: i64 = nx_f64_add(zh, zl)\n" as *u8)
723 pe_w(mf, " let eo: i64 = ((m >> 52) & 0x7FF) + n - 1\n" as *u8)
724 pe_w(mf, " if eo >= 2047 { return 0x7FF0000000000000 }\n" as *u8)
725 pe_w(mf, " return _sh_scale(m, n - 1)\n }\n" as *u8)
726 pe_w(mf, " let q0: i64 = nx_f64_div(" as *u8); pe6_wlit(mf, c[0]); pe_w(mf, ", zh)\n" as *u8)
727 pe_w(mf, " let pr: *i64 = sys_mmap(16) as *i64\n" as *u8)
728 pe_w(mf, " _sh_mul2(q0, zh, pr)\n" as *u8)
729 pe_w(mf, " var e2: i64 = nx_f64_sub(nx_f64_sub(" as *u8); pe6_wlit(mf, c[0]); pe_w(mf, ", pr[0]), pr[1])\n" as *u8)
730 pe_w(mf, " e2 = nx_f64_sub(e2, nx_f64_mul(q0, zl))\n" as *u8)
731 pe_w(mf, " let ql: i64 = nx_f64_mul(q0, e2)\n" as *u8)
732 pe_w(mf, " let ehv: i64 = _sh_scale(zh, n)\n" as *u8)
733 pe_w(mf, " let elv: i64 = _sh_scale(zl, n)\n" as *u8)
734 pe_w(mf, " let ihv: i64 = _sh_scale(q0, 0 - n)\n" as *u8)
735 pe_w(mf, " let ilv: i64 = _sh_scale(ql, 0 - n)\n" as *u8)
736 pe_w(mf, " let sv: *i64 = sys_mmap(16) as *i64\n" as *u8)
737 pe_w(mf, " _sh_2sum(ehv, ihv, sv)\n" as *u8)
738 pe_w(mf, " let tail: i64 = nx_f64_add(nx_f64_add(sv[1], elv), ilv)\n" as *u8)
739 pe_w(mf, " let res2: i64 = nx_f64_add(sv[0], tail)\n" as *u8)
740 pe_w(mf, " return _sh_scale(res2, 0 - 1)\n}\n" as *u8)
741 sys_close(mf)
742
743 let tf: i64 = sys_openat_wr(testpath, 0x1a4); if tf < 0 { return 0 }
744 pe_w(tf, "// AUTHORED BY THE NISHI BUILDER (pattern: MATH_KERNEL SINHCOSH test) -- invariant KATs.\n" as *u8)
745 pe_w(tf, "import \"" as *u8); pe_w(tf, modfile); pe_w(tf, "\"\nimport \"nx_syscalls.nx\"\n" as *u8)
746 pe_w(tf, "func main() -> i64 {\n var bad: i64 = 0\n" as *u8)
747 pe_w(tf, " if nx_f64_sinh(0) != 0 { bad = bad + 1 }\n" as *u8)
748 pe_w(tf, " if nx_f64_sinh(1 << 63) != (1 << 63) { bad = bad + 1 }\n" as *u8)
749 pe_w(tf, " if nx_f64_cosh(0) != " as *u8); pe6_wlit(tf, c[0]); pe_w(tf, " { bad = bad + 1 }\n" as *u8)
750 pe_w(tf, " if nx_f64_cosh(1 << 63) != " as *u8); pe6_wlit(tf, c[0]); pe_w(tf, " { bad = bad + 1 }\n" as *u8)
751 pe_w(tf, " if nx_f64_sinh(0x7FF8000000000000) != 0x7FF8000000000000 { bad = bad + 1 }\n" as *u8)
752 pe_w(tf, " if nx_f64_sinh(0x7FF0000000000000) != 0x7FF0000000000000 { bad = bad + 1 }\n" as *u8)
753 pe_w(tf, " if nx_f64_sinh(0xFFF0000000000000) != 0xFFF0000000000000 { bad = bad + 1 }\n" as *u8)
754 pe_w(tf, " if nx_f64_cosh(0xFFF0000000000000) != 0x7FF0000000000000 { bad = bad + 1 }\n" as *u8)
755 pe_w(tf, " if nx_f64_sinh(0x4086340000000000) != 0x7FF0000000000000 { bad = bad + 1 }\n" as *u8)
756 pe_w(tf, " if nx_f64_cosh(0x4086340000000000) != 0x7FF0000000000000 { bad = bad + 1 }\n" as *u8)
757 pe_w(tf, " let pv: i64 = nx_f64_sinh(0x4000000000000000)\n" as *u8)
758 pe_w(tf, " if nx_f64_sinh(0xC000000000000000) != (pv | (1 << 63)) { bad = bad + 1 }\n" as *u8)
759 pe_w(tf, " if nx_f64_cosh(0xC000000000000000) != nx_f64_cosh(0x4000000000000000) { bad = bad + 1 }\n" as *u8)
760 pe_w(tf, " let nl: *u8 = sys_mmap(4)\n nl[0] = 10\n" as *u8)
761 pe_w(tf, " if bad == 0 { sys_write(1, \"SINHCOSH-TEST GREEN\" as *u8, 19) } else { sys_write(1, \"SINHCOSH-TEST RED\" as *u8, 17) }\n" as *u8)
762 pe_w(tf, " sys_write(1, nl, 1)\n sys_exit(bad)\n return bad\n}\n" as *u8)
763 sys_close(tf)
764 return 1
765}