nx_caplab_quality_test.nx source
↩ module page · 108 lines · 4262 B
1// nx_caplab_quality_test.nx -- gate for Capitalism Lab R4 (quality + brand demand).
2//
3// Proves the demand model that defines Capitalism Lab: (1) the appeal formula,
4// (2) at equal price, higher QUALITY wins more share, (3) higher BRAND wins
5// more share, (4) PREMIUM positioning -- a pricier product with better
6// quality+brand beats a cheap commodity (the core insight), (5) identical
7// offerings split evenly, (6) share is CONSERVED, (7) quality keeps appeal even
8// at the choke price.
9
10import "nx_syscalls.nx"
11import "nx_runtime.nx"
12import "nx_tier.nx"
13import "nx_caplab_quality.nx"
14
15func nx_assert_eq(label: *u8, got: nx_int, want: nx_int, pass_n: *nx_int, fail_n: *nx_int) {
16 print(label); print(": got=" as *u8); print_i64(got); print(" want=" as *u8); print_i64(want)
17 if got == want {
18 println(" PASS" as *u8)
19 pass_n[0] = pass_n[0] + 1
20 return
21 }
22 println(" FAIL" as *u8)
23 fail_n[0] = fail_n[0] + 1
24}
25
26func nx_assert_gt(label: *u8, got: nx_int, floor: nx_int, pass_n: *nx_int, fail_n: *nx_int) {
27 print(label); print(": got=" as *u8); print_i64(got); print(" > " as *u8); print_i64(floor)
28 if got > floor {
29 println(" PASS" as *u8)
30 pass_n[0] = pass_n[0] + 1
31 return
32 }
33 println(" FAIL" as *u8)
34 fail_n[0] = fail_n[0] + 1
35}
36
37func mk2(a: nx_int, b: nx_int) -> *i64 {
38 let p: *i64 = (sys_mmap(16)) as *i64
39 p[0] = a
40 p[1] = b
41 return p
42}
43
44func main() -> nx_exit {
45 let pass_n: *nx_int = (sys_mmap(8)) as *nx_int
46 let fail_n: *nx_int = (sys_mmap(8)) as *nx_int
47 pass_n[0] = 0
48 fail_n[0] = 0
49
50 let choke: nx_int = 100
51 let M: nx_int = 120
52 // weights: price counts 1x, quality 2x, brand 1x
53 let wp: nx_int = 1
54 let wq: nx_int = 2
55 let wb: nx_int = 1
56
57 println("=== CAPLAB R4: quality + brand demand ===" as *u8)
58
59 // --- T1: appeal formula. (100-60) + 2*30 + 1*20 = 40+60+20 = 120 ---
60 nx_assert_eq("appeal_qb formula " as *u8, nx_clab_appeal_qb(choke, 60, 30, 20, wp, wq, wb), 120, pass_n, fail_n)
61
62 // --- T2: equal price, higher QUALITY wins more share ---
63 let pr: *i64 = mk2(50, 50)
64 let qHi: *i64 = mk2(0, 20)
65 let bz: *i64 = mk2(0, 0)
66 let q1: *i64 = mk2(0, 0)
67 nx_clab_split_qb(2, pr, qHi, bz, choke, wp, wq, wb, M, q1)
68 nx_assert_eq("quality: q0 " as *u8, q1[0], 43, pass_n, fail_n)
69 nx_assert_eq("quality: q1 " as *u8, q1[1], 77, pass_n, fail_n)
70 nx_assert_gt("quality wins share " as *u8, q1[1], q1[0], pass_n, fail_n)
71 nx_assert_eq("quality: conserved " as *u8, q1[0] + q1[1], 120, pass_n, fail_n)
72
73 // --- T3: equal price/quality, higher BRAND wins more share ---
74 let qz: *i64 = mk2(0, 0)
75 let bHi: *i64 = mk2(0, 40)
76 let q2: *i64 = mk2(0, 0)
77 nx_clab_split_qb(2, pr, qz, bHi, choke, wp, wq, wb, M, q2)
78 nx_assert_gt("brand wins share " as *u8, q2[1], q2[0], pass_n, fail_n)
79
80 // --- T4: PREMIUM positioning -- pricier but better quality+brand wins ---
81 // firm0: cheap commodity price40,q0,b0 -> appeal 60.
82 // firm1: premium price60,q30,b20 -> appeal 40+60+20=120. -> 40 vs 80.
83 let prP: *i64 = mk2(40, 60)
84 let qP: *i64 = mk2(0, 30)
85 let bP: *i64 = mk2(0, 20)
86 let q3: *i64 = mk2(0, 0)
87 nx_clab_split_qb(2, prP, qP, bP, choke, wp, wq, wb, M, q3)
88 nx_assert_eq("premium: cheap q0 " as *u8, q3[0], 40, pass_n, fail_n)
89 nx_assert_eq("premium: premium q1 " as *u8, q3[1], 80, pass_n, fail_n)
90 nx_assert_gt("premium beats cheap " as *u8, q3[1], q3[0], pass_n, fail_n)
91
92 // --- T5: identical offerings split evenly ---
93 let prE: *i64 = mk2(50, 50)
94 let qE: *i64 = mk2(10, 10)
95 let bE: *i64 = mk2(5, 5)
96 let q4: *i64 = mk2(0, 0)
97 nx_clab_split_qb(2, prE, qE, bE, choke, wp, wq, wb, M, q4)
98 nx_assert_eq("identical: even split " as *u8, q4[0], 60, pass_n, fail_n)
99
100 // --- T6: quality keeps appeal even at the choke price (brand loyalty) ---
101 nx_assert_eq("quality holds at choke " as *u8, nx_clab_appeal_qb(choke, 100, 50, 0, wp, wq, wb), 100, pass_n, fail_n)
102
103 println("" as *u8)
104 print("PASS=" as *u8); print_i64(pass_n[0])
105 print(" FAIL=" as *u8); print_i64(fail_n[0]); println("" as *u8)
106 if fail_n[0] > 0 { return 1 }
107 return 0
108}