/* SPDX-License-Identifier: LicenseRef-Starship-1.0 * Copyright (c) 2023-2026 Robert A. James */ /* inference.c -- the inference engine for a node's heartbeat. See v4/inference.h (#189, Phase 7). */ #include "v4/inference.h" #define WINDOW 4096u /* v3's ROLLING_WINDOW_SIZE */ #define WINDOW_MIN 256u /* v3's ADAPTIVE_MIN_WINDOW_SIZE */ #define MAX_CHUNKS (WINDOW / WINDOW_MIN) /* ---- Q48.16, as v3's (v3/include/q48_16.h, v3/src/word_source/q48_16_words.c) ---- */ static v4_q48 from_u64(uint64_t u) { return u << 16; } static uint64_t to_u64(v4_q48 q) /* v3: (int64_t)q >> 16, arithmetic */ { return (q & 0x8000000000000000ULL) ? ~((~q) >> 16) : q >> 16; } /* the high 128-bit product, >> 16: v3's __uint128_t path, written out (64 x 64 in four parts) */ v4_q48 v4_q48_mul(v4_q48 a, v4_q48 b) { uint64_t a_hi = a >> 32, a_lo = a & 0xFFFFFFFFULL, b_hi = b >> 32, b_lo = b & 0xFFFFFFFFULL; uint64_t p_ll = a_lo * b_lo, p_lh = a_lo * b_hi, p_hl = a_hi * b_lo, p_hh = a_hi * b_hi; uint64_t carry = 0, mid = p_lh + p_hl, hi, lo; if (mid < p_lh) carry++; hi = p_hh + (mid >> 32) + (carry << 32); lo = p_ll + ((mid & 0xFFFFFFFFULL) << 32); if (lo < p_ll) hi++; return (hi << 48) | (lo >> 16); } v4_q48 v4_q48_div(v4_q48 a, v4_q48 b) { if (b == 0) return 0; if (a > 0x0000FFFFFFFFFFFFULL) return 0xFFFFFFFFFFFFFFFFULL; return (a << 16) / b; } v4_q48 v4_q48_exp(v4_q48 q) { int64_t qs = (int64_t)q; int negative, n; v4_q48 x, result, term; if (q == 0) return 65536; if (qs >= 1048576) return 0xFFFFFFFFFFFFFFFFULL; if (qs <= -1048576) return 0; negative = qs < 0; x = negative ? (v4_q48)(-qs) : q; result = 65536; term = x; result += term; for (n = 2; n <= 10; n++) { term = v4_q48_mul(term, x); term = v4_q48_div(term, from_u64((uint64_t)n)); result += term; if (term < 50) break; } if (negative) result = v4_q48_div(65536, result); return result; } v4_q48 v4_q48_log(uint64_t x) { const v4_q48 ln2 = 45426; int k = 0, iter; uint64_t m = x; v4_q48 y, result; if (x == 0 || x == 65536) return 0; if (m >= 131072) { while (m >= 131072) { m >>= 1; k++; } } else if (m < 65536) { while (m < 65536) { m <<= 1; k--; } } y = m > 65536 ? m - 65536 : 0; for (iter = 0; iter < 6; iter++) { v4_q48 e = v4_q48_exp(y), corr; int64_t d; if (e == 0) break; d = (int64_t)m - (int64_t)e; if (d > 0) { corr = v4_q48_div((v4_q48)d, e); y = y + corr; } else if (d < 0) { corr = v4_q48_div((v4_q48)(-d), e); y = y > corr ? y - corr : 0; } if (d < 100 && d > -100) break; } result = y; if (k > 0) result = result + v4_q48_mul(from_u64((uint64_t)k), ln2); else if (k < 0) result = result - v4_q48_mul(from_u64((uint64_t)-k), ln2); return result; } /* ---- the engine (v3/src/inference_engine.c) ---- */ v4_q48 v4_inference_variance(const uint64_t *heat, uint64_t n) { uint64_t sum = 0, sq = 0, i; v4_q48 mean; if (n == 0) return 0; for (i = 0; i < n; i++) sum += heat[i]; mean = v4_q48_div(from_u64(sum), from_u64(n)); for (i = 0; i < n; i++) { v4_q48 h = from_u64(heat[i]), d = h > mean ? h - mean : mean - h; sq += to_u64(v4_q48_mul(d, d)); } return v4_q48_div(from_u64(sq), from_u64(n)); } static v4_q48 median(const v4_q48 *data, uint32_t n) /* v3's: a sorted copy's middle */ { v4_q48 s[MAX_CHUNKS]; uint32_t i, j; if (n == 0) return 0; if (n == 1) return data[0]; for (i = 0; i < n; i++) s[i] = data[i]; for (i = 0; i < n - 1; i++) for (j = 0; j < n - i - 1; j++) if (s[j] > s[j + 1]) { v4_q48 t = s[j]; s[j] = s[j + 1]; s[j + 1] = t; } return s[n / 2]; } static v4_q48 mean_q48(const v4_q48 *data, uint32_t n) /* v3's: of the integer parts */ { uint64_t sum = 0; uint32_t i; if (n == 0) return 0; for (i = 0; i < n; i++) sum += data[i] >> 16; return from_u64(sum / n); } static v4_q48 levene(const v4_q48 *vars, uint32_t k, uint32_t size) { v4_q48 med, z[MAX_CHUNKS], zbar, ssd = 0, num, den; uint32_t i; if (k < 2) return 0; med = median(vars, k); for (i = 0; i < k; i++) z[i] = vars[i] > med ? vars[i] - med : med - vars[i]; zbar = mean_q48(z, k); for (i = 0; i < k; i++) { v4_q48 d = z[i] > zbar ? z[i] - zbar : zbar - z[i]; ssd = ssd + v4_q48_mul(d, d); } num = v4_q48_mul(from_u64(k - 1u), v4_q48_mul(from_u64(size), ssd)); den = v4_q48_mul(from_u64(k), v4_inference_variance(z, k)); /* v3 takes the z's variance as raw values */ return den > 0 ? v4_q48_div(num, den) : 0; } uint32_t v4_inference_window_width(const uint64_t *heat, uint64_t n) { uint32_t size, max = n < WINDOW ? (uint32_t)n : WINDOW; const v4_q48 critical = 425984; /* v3's q48_from_double(6.5) */ if (n == 0) return WINDOW / 2; for (size = WINDOW_MIN; size <= max; size += 64) { uint32_t k = (uint32_t)(n / size), i; v4_q48 vars[MAX_CHUNKS]; if (k < 3) continue; if (k > MAX_CHUNKS) k = MAX_CHUNKS; /* n <= 4096, so never more */ for (i = 0; i < k; i++) vars[i] = v4_inference_variance(&heat[(uint64_t)i * size], size); if (levene(vars, k, size) <= critical) return size; } return max; } uint64_t v4_inference_decay_slope(const uint64_t *heat, uint64_t n) { uint64_t sum_t, sum_t_sq, t, num, den; v4_q48 sum_log = 0, sum_t_log = 0; int64_t a, b, ns; if (n < 2) return 0; sum_t = (n * (n - 1)) / 2; sum_t_sq = (n * (n - 1) * (2 * n - 1)) / 6; for (t = 0; t < n; t++) { v4_q48 l; if (heat[t] == 0) continue; l = v4_q48_log(heat[t]); sum_log = sum_log + l; sum_t_log = sum_t_log + v4_q48_mul(from_u64(t), l); } a = (int64_t)v4_q48_mul(from_u64(n), sum_t_log); b = (int64_t)v4_q48_mul(from_u64(sum_t), sum_log); ns = a - b; num = ns < 0 ? (uint64_t)(-ns) : (uint64_t)ns; den = n * sum_t_sq - sum_t * sum_t; if (den == 0) den = 1; return num / den; } void v4_inference_run(const uint64_t *traj, uint64_t n, int l5, int l6, v4_inference_out *out) { v4_q48 var; if (!traj || n < 2) { out->early_exited = 1; return; } var = v4_inference_variance(traj, n); if (out->window_variance_q48 != 0) { /* v3's has_variance_stabilized: within 5% */ v4_q48 last = out->window_variance_q48, d = var > last ? var - last : last - var; if (v4_q48_div(d, last) <= 3276) { out->early_exited = 1; return; } } if (l5) out->adaptive_window_width = v4_inference_window_width(traj, n); if (l6) out->adaptive_decay_slope = v4_inference_decay_slope(traj, n); out->window_variance_q48 = var; out->slope_fit_quality_q48 = 52429; /* v3's: 0.8, a placeholder it says it is */ out->early_exited = 0; }