From 05ca8260912d4792f2f4f1ab9c2a5da1a8778da7 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Fri, 25 Sep 2026 23:14:10 +0200 Subject: [PATCH] tests: pin cellular's HLSL mirror against radius-2, 2^24, and tie inputs EveryMirrorFunctionMatchesCSharpMath's generic random/special-value cases never happen to hit a point where a radius-2 cell wins (about 3.5e-5 of points) or an integer point at or past 2^23, so an HLSL mutant of cellular's search radius, its lower-bound prune, or the removed F2=0 guard could change cultmath_cellular's real output and still pass this test. Adds three targeted point cases, reusing CellularAndSminGradTests' own fixtures so the mirror test does not carry a second copy of the construction: - the six points from AxisAlignedRadiusTwoOffsets/FindPointRealizingOffset, each of which realizes a different axis-aligned radius-2 offset as F1 or F2 in the independent 7x7x7 oracle; - four integer points at 2^24 (both signs), where distinct cells' jittered features can round onto the same float32 value, reaching the F2 = 0 guard; - one exact F1 = F2 tie point, the midpoint of two adjacent cells' feature points (bit-exact-equidistant from both by construction, no search needed). Verified against four HLSL mutants applied to shaders/CultMath.hlsl on scratch copies (not committed) and reverted after each check: - `dz < 2` instead of `dz <= 2`: killed by the axis-slice point at (-56.671272, -67.01973, -79.001). - `dx` starting at -1 instead of -2: killed by the axis-slice point at (62, -77.91331, -79.42451). - pruning against f1 instead of f2: killed by an axis-slice point and both of the 2^24 integer points (3 mismatches). - the F2 = 0 guard removed (`grad2 = (p - c2) / f2`, unconditional): killed by the (2^24, 2^24, 2^24) integer point (NaN vs the guarded zero). Co-Authored-By: Claude Sonnet 5 --- .../HlslSourceCompatibilityTests.cs | 35 +++++++++++++++++++ 1 file changed, 35 insertions(+) diff --git a/packages/cultmath/tests/CultMath.Tests/HlslSourceCompatibilityTests.cs b/packages/cultmath/tests/CultMath.Tests/HlslSourceCompatibilityTests.cs index fdc9b403..fb269ee2 100644 --- a/packages/cultmath/tests/CultMath.Tests/HlslSourceCompatibilityTests.cs +++ b/packages/cultmath/tests/CultMath.Tests/HlslSourceCompatibilityTests.cs @@ -64,6 +64,41 @@ public sealed class HlslSourceCompatibilityTests for (var k = 0; k < 64; k++) { var values = Enumerable.Range(0, 32).Select(_ => Next()).ToArray(); cases.Add(i => values[i]); } for (var k = 0; k < 16; k++) { var values = Enumerable.Range(0, 32).Select(_ => Next()).ToArray(); cases.Add(i => values[i & ~1]); } + // Points aimed squarely at cellular's HLSL mirror (F6/F3 Soul findings): the generic random + // and special-value cases above pass ~92 inputs through cultmath_cellular and never happen to + // hit a point where a radius-2 cell wins (about 3.5e-5 of points, Soul measured) or an + // integer point at or past 2^23, so an HLSL mutant of the search radius, the prune, or the + // removed F2=0 guard can survive this test even though it changes cellular's real output. + void AddPointCase(float3 point) + { + var values = new[] { point.x, point.y, point.z }; + cases.Add(i => i < values.Length ? values[i] : 0.0f); + } + + // The six constructed points from CellularAndSminGradTests.SearchReachesEveryAxisAlignedRadiusTwoSlice: + // each one realizes a different axis-aligned radius-2 offset as F1 or F2, which is exactly + // the case an `if (lowerBound >= f2)` prune written as `>= f1`, or a search radius narrowed on + // one axis (`dz < 2`, `dx` starting at -1), changes. + foreach (var offset in CellularAndSminGradTests.AxisAlignedRadiusTwoOffsets) + AddPointCase(CellularAndSminGradTests.FindPointRealizingOffset(offset)); + + // Integer points at 2^24, several, both signs: past |p| ~= 2^23 distinct cells' jittered + // features can round onto the same float32 value (design.md, "Precision domain"), making + // F2 = 0 reachable and exercising the grad2 = f2 > 0 ? ... : zero guard this test would + // otherwise never touch. + const float twoTo24 = 16777216.0f; + AddPointCase(new float3(twoTo24, twoTo24, twoTo24)); + AddPointCase(new float3(-twoTo24, -twoTo24, -twoTo24)); + AddPointCase(new float3(twoTo24 + 3.0f, -twoTo24 + 5.0f, twoTo24 - 7.0f)); + AddPointCase(new float3(-twoTo24 + 11.0f, twoTo24 - 13.0f, -twoTo24 + 17.0f)); + + // One exact F1 = F2 tie point: the midpoint of two adjacent cells' feature points is + // bit-exact-equidistant from both by construction (negating a vector does not change its + // length, and p - a = -(p - b) here by symmetry), without needing to search for one. + var tieMidpoint = (CellularAndSminGradTests.FeaturePoint(new float3(0.0f, 0.0f, 0.0f)) + + CellularAndSminGradTests.FeaturePoint(new float3(1.0f, 0.0f, 0.0f))) * 0.5f; + AddPointCase(tieMidpoint); + var mismatches = new List(); var compared = new HashSet(); foreach (var mirror in shaderType.GetMethods(BindingFlags.Instance | BindingFlags.NonPublic).Where(m => m.Name.StartsWith("cultmath_")))