nx_cloud_volume_gate.nx source
↩ module page · 116 lines · 7089 B
1// nx_cloud_volume_gate.nx -- PG22: DOES THE CLOUD VOLUME FOLLOW THE WEATHER FIELD, AND DOES THE SHEET STILL STAND?
2//
3// SUBJECT: nx_worldgen.wg_cloud_volume (in-process) driven by nx_weather_pattern's own params (in-process). The rung's
4// done-rule in its own words: a gate proves the volume samples the weather field and the CPU tier keeps a sheet
5// fallback. Every value is emitted with gv_kv so a second method can recompute it from the declared inputs.
6// Fixtures are arithmetic (a sample grid over the deck), so the gate has no filesystem state to leak.
7import "nx_syscalls.nx"
8import "nx_gate_verdict.nx"
9import "nx_worldgen.nx"
10import "nx_weather_pattern.nx"
11const CG_SEED: i64 = 20260906
12const CG_GRID: i64 = 8 // samples per axis over the deck (8^3 per mean)
13const CG_SPAN: i64 = 12800 // world units sampled per horizontal axis
14const CG_T0: i64 = 0
15const CG_T1: i64 = 500
16const CG_WIND_Q10: i64 = 512 // half the field's unit wind
17const CG_COLS: i64 = 64
18const CG_SHEET_CLOUD: i64 = 110 // the incumbent OVERCAST cloud param (wg_weather mode 2, W[13])
19const CG_SHEET_RANGE: i64 = 3000
20const CG_SHEET_HALF: i64 = 1500
21const CG_PRIME_A: i64 = 97
22const CG_PRIME_B: i64 = 53
23
24func cg_mean_density(cover: i64, wdx: i64, wdz: i64, t: i64, seed: i64, cnt: *i64) -> i64 {
25 var sum: i64 = 0; var n: i64 = 0; var nz: i64 = 0
26 var i: i64 = 0
27 while i < CG_GRID {
28 var j: i64 = 0
29 while j < CG_GRID {
30 var k: i64 = 0
31 while k < CG_GRID {
32 let wx: i64 = i*CG_SPAN/CG_GRID
33 let wy: i64 = WG_CLOUD_BASE + (WG_CLOUD_TOP - WG_CLOUD_BASE)*(2*k+1)/(2*CG_GRID)
34 let wz: i64 = j*CG_SPAN/CG_GRID
35 let d: i64 = wg_cloud_volume(wx, wy, wz, t, cover, wdx, wdz, seed)
36 if d > 0 { nz = nz + 1 }
37 sum = sum + d; n = n + 1
38 k = k + 1
39 }
40 j = j + 1
41 }
42 i = i + 1
43 }
44 cnt[0] = n; cnt[1] = nz
45 return sum/n
46}
47// the field's own params for a kind, through the field's own organ, folded to cover by the volume's own law
48func cg_cover_for(kind: i64) -> i64 {
49 let p: *i64 = sys_mmap(64) as *i64
50 nx_weather_params(kind, p)
51 return wg_cover_from_weather(p[NX_WP_PARAM_PRECIP], p[NX_WP_PARAM_VISIBILITY], p[NX_WP_PARAM_FOG_DENSITY], NX_WP_Q)
52}
53
54func main() -> i64 {
55 let ctr: *i64 = gv_ctr()
56 gv_head("=== NX-CLOUD-VOLUME gate (PG22): the 3D cloud density follows the weather field, the CPU sheet stands ===" as *u8)
57 let cnt: *i64 = sys_mmap(32) as *i64
58 let cov_clear: i64 = cg_cover_for(NX_WEATHER_CLEAR)
59 let cov_over: i64 = cg_cover_for(NX_WEATHER_OVERCAST)
60 let cov_rain: i64 = cg_cover_for(NX_WEATHER_RAIN)
61 gv_check("field-CLEAR-covers-nothing (cover_q10 == 0)" as *u8, (cov_clear == 0) as i64, ctr)
62 gv_check("field-orders-cover CLEAR < OVERCAST < RAIN" as *u8, ((cov_clear < cov_over) as i64) * ((cov_over < cov_rain) as i64), ctr)
63 let m_clear: i64 = cg_mean_density(cov_clear, 0, 0, CG_T0, CG_SEED, cnt)
64 let m_over: i64 = cg_mean_density(cov_over, 0, 0, CG_T0, CG_SEED, cnt)
65 let n_over_nz: i64 = cnt[1]
66 let n_samples: i64 = cnt[0]
67 let m_rain: i64 = cg_mean_density(cov_rain, 0, 0, CG_T0, CG_SEED, cnt)
68 gv_check("volume-samples-the-field: mean density CLEAR < OVERCAST < RAIN over the deck" as *u8, ((m_clear < m_over) as i64) * ((m_over < m_rain) as i64), ctr)
69 gv_check("volume-CLEAR-is-empty (mean 0): an absent cloud is a valid answer" as *u8, (m_clear == 0) as i64, ctr)
70 gv_check("volume-OVERCAST-has-cloud somewhere (nonzero samples > 0)" as *u8, (n_over_nz > 0) as i64, ctr)
71 gv_check("samples-per-mean is the declared grid cubed (denominator bound)" as *u8, (n_samples == CG_GRID*CG_GRID*CG_GRID) as i64, ctr)
72 let m_over2: i64 = cg_mean_density(cov_over, 0, 0, CG_T0, CG_SEED, cnt)
73 gv_check_eq("determinism: the same inputs twice give the same mean" as *u8, m_over2, m_over, ctr)
74 var below_ok: i64 = 1; var above_ok: i64 = 1; var bounded: i64 = 1
75 var i: i64 = 0
76 while i < CG_COLS {
77 let wx: i64 = i*CG_SPAN/CG_COLS
78 if wg_cloud_volume(wx, WG_CLOUD_BASE - 1, wx, CG_T0, cov_over, 0, 0, CG_SEED) != 0 { below_ok = 0 }
79 if wg_cloud_volume(wx, WG_CLOUD_TOP + 1, wx, CG_T0, cov_over, 0, 0, CG_SEED) != 0 { above_ok = 0 }
80 let d: i64 = wg_cloud_volume(wx, (WG_CLOUD_BASE + WG_CLOUD_TOP)/2, wx*3, CG_T0, cov_rain, 0, 0, CG_SEED)
81 if d < 0 { bounded = 0 }
82 if d > WG_MAGIC_1024 { bounded = 0 }
83 i = i + 1
84 }
85 gv_check("envelope: zero below WG_CLOUD_BASE over 64 columns" as *u8, below_ok, ctr)
86 gv_check("envelope: zero above WG_CLOUD_TOP over 64 columns" as *u8, above_ok, ctr)
87 gv_check("density bounded 0..1024 over 64 mid-deck samples at RAIN cover" as *u8, bounded, ctr)
88 let m_seed2: i64 = cg_mean_density(cov_over, 0, 0, CG_T0, CG_SEED + 1, cnt)
89 gv_check("two seeds give two skies (mean differs)" as *u8, (m_seed2 != m_over) as i64, ctr)
90 let m_wind_t1: i64 = cg_mean_density(cov_over, CG_WIND_Q10, 0, CG_T1, CG_SEED, cnt)
91 let m_still_t1: i64 = cg_mean_density(cov_over, 0, 0, CG_T1, CG_SEED, cnt)
92 gv_check("wind advects the field: mean at t1 under wind differs from t0" as *u8, (m_wind_t1 != m_over) as i64, ctr)
93 gv_check_eq("neg-control-no-wind-no-motion: mean at t1 with zero wind equals t0" as *u8, m_still_t1, m_over, ctr)
94 var sheet_ok: i64 = 1; var sheet_nz: i64 = 0
95 i = 0
96 while i < CG_COLS {
97 let px: i64 = (i*CG_PRIME_A) % CG_SHEET_RANGE - CG_SHEET_HALF
98 let pz: i64 = (i*CG_PRIME_B) % CG_SHEET_RANGE - CG_SHEET_HALF
99 let inc: i64 = wg_fbm(px+WG_MAGIC_40000, pz+WG_MAGIC_40000, 7) - (WG_MAGIC_1024 - CG_SHEET_CLOUD*5)
100 let sh: i64 = wg_cloud_sheet(px, pz, CG_SHEET_CLOUD)
101 if sh != inc { sheet_ok = 0 }
102 if sh > 0 { sheet_nz = sheet_nz + 1 }
103 i = i + 1
104 }
105 gv_check("sheet-fallback-is-the-incumbent: wg_cloud_sheet equals the inline sky expression on 64 rays" as *u8, sheet_ok, ctr)
106 gv_check("sheet-fallback-covers-something at the OVERCAST cloud param" as *u8, (sheet_nz > 0) as i64, ctr)
107 let m_zero: i64 = cg_mean_density(0, CG_WIND_Q10, CG_WIND_Q10, CG_T1, CG_SEED, cnt)
108 gv_check("neg-control-zero-cover-is-empty: mean density 0 at cover 0 under wind" as *u8, (m_zero == 0) as i64, ctr)
109 gv_values_head()
110 gv_kv("cover_clear_q10" as *u8, cov_clear); gv_kv("cover_overcast_q10" as *u8, cov_over); gv_kv("cover_rain_q10" as *u8, cov_rain)
111 gv_kv("mean_density_clear_q10" as *u8, m_clear); gv_kv("mean_density_overcast_q10" as *u8, m_over); gv_kv("mean_density_rain_q10" as *u8, m_rain)
112 gv_kv("overcast_nonzero_samples" as *u8, n_over_nz); gv_kv("samples_per_mean" as *u8, n_samples)
113 gv_kv("mean_density_overcast_seed2_q10" as *u8, m_seed2); gv_kv("mean_density_overcast_wind_t1_q10" as *u8, m_wind_t1)
114 gv_kv("sheet_nonzero_rays_of_64" as *u8, sheet_nz)
115 return gv_verdict("NX-CLOUD-VOLUME" as *u8, ctr, "the volume is the weather field made 3D; the sheet is the same law flattened" as *u8)
116}