sketch_comparator_test.nx source
↩ module page · 120 lines · 4403 B
1// sketch_comparator_test.nx -- sealed-verdict comparator validation.
2
3import "syscalls.nx"
4import "sketch_comparator.nx"
5import "sketch_types.nx"
6
7func main() -> i64 {
8 // ---- ACCURACY axis: clear win ----
9 // Our estimate 99 vs theirs 80, truth 100. Our error 1, their error 20.
10 // delta_ppm = (20 - 1) * 1_000_000 / 100 = 190_000. Tolerance 10_000.
11 let r1: *ComparisonResult = nx_cmp_accuracy(99, 80, 100, 10000)
12 if r1.verdict != NX_CMP_VERDICT_BEATS {
13 return __syscall(93, 10, 0, 0, 0, 0, 0)
14 }
15 if r1.delta_ppm != 190000 {
16 return __syscall(93, 11, 0, 0, 0, 0, 0)
17 }
18 if r1.axis != NX_CMP_AXIS_ACCURACY {
19 return __syscall(93, 12, 0, 0, 0, 0, 0)
20 }
21
22 // ---- ACCURACY axis: clear loss ----
23 // Our 80, theirs 99, truth 100. Their wins. delta = (1 - 20)*1e6/100 = -190_000.
24 let r2: *ComparisonResult = nx_cmp_accuracy(80, 99, 100, 10000)
25 if r2.verdict != NX_CMP_VERDICT_LOSES {
26 return __syscall(93, 20, 0, 0, 0, 0, 0)
27 }
28 if r2.delta_ppm != -190000 {
29 return __syscall(93, 21, 0, 0, 0, 0, 0)
30 }
31
32 // ---- ACCURACY axis: equivalent ----
33 // Our 99, theirs 101, truth 100. Errors 1 and 1. Delta 0.
34 let r3: *ComparisonResult = nx_cmp_accuracy(99, 101, 100, 10000)
35 if r3.verdict != NX_CMP_VERDICT_EQUIVALENT {
36 return __syscall(93, 30, 0, 0, 0, 0, 0)
37 }
38
39 // ---- ACCURACY: degenerate truth=0 -> INCONCLUSIVE ----
40 let r4: *ComparisonResult = nx_cmp_accuracy(0, 0, 0, 1000)
41 if r4.verdict != NX_CMP_VERDICT_INCONCLUSIVE {
42 return __syscall(93, 40, 0, 0, 0, 0, 0)
43 }
44 if r4.conf_ppb != 500000000 {
45 return __syscall(93, 41, 0, 0, 0, 0, 0)
46 }
47
48 // ---- MEMORY axis: ours uses less = BEATS ----
49 // Ours 1024 bytes, theirs 4096. delta = (4096-1024)*1e6/4096 = 750_000.
50 let r5: *ComparisonResult = nx_cmp_memory(1024, 4096, 10000)
51 if r5.verdict != NX_CMP_VERDICT_BEATS {
52 return __syscall(93, 50, 0, 0, 0, 0, 0)
53 }
54 if r5.delta_ppm != 750000 {
55 return __syscall(93, 51, 0, 0, 0, 0, 0)
56 }
57 // Memory loss: ours larger.
58 let r6: *ComparisonResult = nx_cmp_memory(4096, 1024, 10000)
59 if r6.verdict != NX_CMP_VERDICT_LOSES {
60 return __syscall(93, 52, 0, 0, 0, 0, 0)
61 }
62
63 // ---- TIME axis: ours faster = BEATS ----
64 // Ours 50us, theirs 200us. delta = (200-50)*1e6/200 = 750_000.
65 let r7: *ComparisonResult = nx_cmp_time(50, 200, 10000)
66 if r7.verdict != NX_CMP_VERDICT_BEATS {
67 return __syscall(93, 60, 0, 0, 0, 0, 0)
68 }
69 // Time loss.
70 let r8: *ComparisonResult = nx_cmp_time(200, 50, 10000)
71 if r8.verdict != NX_CMP_VERDICT_LOSES {
72 return __syscall(93, 61, 0, 0, 0, 0, 0)
73 }
74
75 // ---- COMPOSITE: all three BEATS -> BEATS ----
76 let comp1: i64 = nx_cmp_composite(r1, r5, r7)
77 if comp1 != NX_CMP_VERDICT_BEATS {
78 return __syscall(93, 70, 0, 0, 0, 0, 0)
79 }
80
81 // ---- COMPOSITE: 2 BEATS + 1 EQUIVALENT -> BEATS ----
82 let comp2: i64 = nx_cmp_composite(r1, r5, r3)
83 if comp2 != NX_CMP_VERDICT_BEATS {
84 return __syscall(93, 71, 0, 0, 0, 0, 0)
85 }
86
87 // ---- COMPOSITE: 2 LOSES + 1 BEATS -> LOSES (loss-averse) ----
88 let comp3: i64 = nx_cmp_composite(r2, r6, r7)
89 if comp3 != NX_CMP_VERDICT_LOSES {
90 return __syscall(93, 72, 0, 0, 0, 0, 0)
91 }
92
93 // ---- COMPOSITE: 1 BEATS + 1 LOSES + 1 EQUIVALENT -> EQUIVALENT (tied) ----
94 let comp4: i64 = nx_cmp_composite(r1, r6, r3)
95 if comp4 != NX_CMP_VERDICT_EQUIVALENT {
96 return __syscall(93, 73, 0, 0, 0, 0, 0)
97 }
98
99 // ---- COMPOSITE: 2+ INCONCLUSIVE -> INCONCLUSIVE ----
100 let r_inc: *ComparisonResult = nx_cmp_memory(100, 0, 1000)
101 let comp5: i64 = nx_cmp_composite(r4, r_inc, r3)
102 if comp5 != NX_CMP_VERDICT_INCONCLUSIVE {
103 return __syscall(93, 74, 0, 0, 0, 0, 0)
104 }
105
106 // ---- typed envelope ----
107 let q: *ApproxI64 = nx_cmp_query(r1)
108 if q.envelope_kind != NX_ENV_ABS {
109 return __syscall(93, 80, 0, 0, 0, 0, 0)
110 }
111 if q.maturity != NX_MATURITY_PRODUCTION {
112 return __syscall(93, 81, 0, 0, 0, 0, 0)
113 }
114 // BEATS verdict = 0; conf = 1e9 for non-degenerate.
115 if q.value != NX_CMP_VERDICT_BEATS {
116 return __syscall(93, 82, 0, 0, 0, 0, 0)
117 }
118
119 return 0
120}