// Copyright (c) 2024-2026 Tarik Moussa. // SPDX-License-Identifier: MIT // Port of de.varylab.discreteconformal.functional.HyperIdealUtilityTest (Java/JUnit). #include "hyper_ideal_utility.hpp" #include "hyper_ideal_geometry.hpp" #include "clausen.hpp" #include #include #include using conformallab::calculateTetrahedronVolume; using conformallab::calculateTetrahedronVolumeWithIdealVertexAtGamma; using conformallab::Lobachevsky; constexpr double PI = 3.14159265358979323846264338328; // Regular tetrahedron at the Euclidean boundary (beta = arccos(1/3) for each // vertex angle) has volume 0 — it degenerates to a flat configuration. TEST(HyperIdealUtilityTest, VolumeEuclidean) { double b = std::acos(1.0 / 3.0); double V = calculateTetrahedronVolume(b, b, b, b, b, b); EXPECT_NEAR(0.0, V, 1e-7); } // Regular ideal tetrahedron with all angles pi/3. // Formula: sum of Lobachevsky values at each angle. TEST(HyperIdealUtilityTest, VolumeRegularIdeal1) { double b = PI / 3.0; double Ve = Lobachevsky(b) + Lobachevsky(b) + Lobachevsky(b); double V = calculateTetrahedronVolume(b, b, b, b, b, b); EXPECT_NEAR(Ve, V, 1e-12); } // Right-angled ideal tetrahedron (pi/2, pi/4, pi/4). TEST(HyperIdealUtilityTest, VolumeRegularIdeal2) { double bi = PI / 2.0, bj = PI / 4.0, bk = PI / 4.0; double Ve = Lobachevsky(bi) + Lobachevsky(bj) + Lobachevsky(bk); double V = calculateTetrahedronVolume(bi, bj, bk, bi, bj, bk); EXPECT_NEAR(Ve, V, 1e-12); } // Hyperideal octahedron: all angles 0, volume = 8*Л(pi/4). TEST(HyperIdealUtilityTest, VolumeOctahedron) { double Ve = 8.0 * Lobachevsky(PI / 4.0); double V = calculateTetrahedronVolume(0, 0, 0, 0, 0, 0); EXPECT_NEAR(Ve, V, 1e-12); } // Hyperideal tetrahedron with one hyperideal vertex. // Manual formula from the paper vs. general formula. TEST(HyperIdealUtilityTest, VolumeSingleHyperidealVertex) { double bi = PI / 5.0, bj = PI / 4.0, bk = PI / 4.0; double ai = (PI + bi - bj - bk) / 2.0; double aj = (PI + bj - bi - bk) / 2.0; double ak = (PI + bk - bi - bj) / 2.0; double aijk= (PI - bk - bi - bj) / 2.0; double Ve = 0.5 * (Lobachevsky(bi) + Lobachevsky(bj) + Lobachevsky(bk) + Lobachevsky(ai) + Lobachevsky(aj) + Lobachevsky(ak) + Lobachevsky(aijk)); double V = calculateTetrahedronVolume(bi, bj, bk, ai, aj, ak); EXPECT_NEAR(Ve, V, 1e-12); } // A degenerate triangle (angle = pi) must give volume 0 without NaN. TEST(HyperIdealUtilityTest, VolumeWithDegenerateTriangle) { double V = calculateTetrahedronVolume(0.0, PI, 0.0, 0.0, 0.0, PI); EXPECT_NEAR(0.0, V, 1e-12); EXPECT_FALSE(std::isnan(V)); } // The two volume formulas (general and ideal-vertex specialization) must agree // on the same input — numerical consistency check. TEST(HyperIdealUtilityTest, CompareGeneralAndIdealFormulaCase1) { constexpr double EPS = 0.1; double bi = PI / 3.0, bj = PI / 3.0, bk = PI / 3.0; double ai = PI / 3.0 - EPS, aj = PI / 3.0 - EPS, ak = PI / 3.0 - EPS; double Ve = calculateTetrahedronVolumeWithIdealVertexAtGamma(bi, bj, bk, ai, aj, ak); double V = calculateTetrahedronVolume(bi, bj, bk, ai, aj, ak); EXPECT_NEAR(Ve, V, 1e-12); } // Second consistency check with non-symmetric angles that sum to pi. TEST(HyperIdealUtilityTest, CompareGeneralAndIdealFormulaCase2) { double bi = 0.6623267054958116; double bj = 1.437248992086214; double bk = 1.0420169560077686; double ai = 0.6896178197389236; double aj = 0.5195634857410114; double ak = 0.6304500578493993; EXPECT_NEAR(PI, bi + bj + bk, 1e-12); double Ve = calculateTetrahedronVolumeWithIdealVertexAtGamma(bi, bj, bk, ai, aj, ak); double V = calculateTetrahedronVolume(bi, bj, bk, ai, aj, ak); EXPECT_NEAR(Ve, V, 1e-12); } // ───────────────────────────────────────────────────────────────────────────── // Golden-value oracle tests — pin the C++ pure-math core bit-for-bit against the // upstream Java reference (de.varylab.discreteconformal.functional.{Clausen, // HyperIdealUtility}), captured by running the compiled Java library (openjdk 17) // on these exact inputs. Unlike the FD gradient checks (which only verify // curl-freeness, since the C++ energy is the path-integral of its own gradient), // these lock the absolute values of the math-critical helpers against an // independent implementation, catching any silent convention/formula drift. // // To regenerate: see doc/reviewer/java-port-audit.md (oracle harness recipe). // Values are Java's Double.toString output (shortest round-trip). Tolerance is // 1e-12 (well above the ~1e-15 inter-platform libm divergence for these ranges). // ───────────────────────────────────────────────────────────────────────────── TEST(HyperIdealGoldenJava, ClausenLobachevskyImLi2) { EXPECT_NEAR(conformallab::clausen2(0.7), 0.954448086482735, 1e-12); EXPECT_NEAR(conformallab::clausen2(2.5), 0.4335982032355327, 1e-12); EXPECT_NEAR(conformallab::clausen2(-1.3), -0.9897032532295984, 1e-12); EXPECT_NEAR(Lobachevsky(0.9), 0.4121734067662043, 1e-12); EXPECT_NEAR(conformallab::ImLi2(std::complex(0.3, 0.4)), 0.46136289181910894, 1e-12); } TEST(HyperIdealGoldenJava, ZetaFamily) { EXPECT_NEAR(conformallab::zeta13(0.5, 0.7, 0.9), 2.663195966482385, 1e-12); EXPECT_NEAR(conformallab::zeta14(0.4, 0.8), 1.8262295633065202, 1e-12); EXPECT_NEAR(conformallab::zeta15(0.6), 2.216976794676588, 1e-12); EXPECT_NEAR(conformallab::zeta(0.5, 0.7, 0.9), 1.6156519307269948, 1e-12); } TEST(HyperIdealGoldenJava, TetrahedronVolumes) { // Generic non-degenerate generalized hyperbolic tetrahedron. EXPECT_NEAR(calculateTetrahedronVolume(0.6, 0.7, 0.8, 0.5, 0.9, 0.4), 2.9074633382516435, 1e-12); // One ideal vertex at gamma, non-symmetric angles (Java test2 inputs). EXPECT_NEAR(calculateTetrahedronVolumeWithIdealVertexAtGamma( 0.6623267054958116, 1.437248992086214, 1.0420169560077686, 0.6896178197389236, 0.5195634857410114, 0.6304500578493993), 2.0459750326926214, 1e-12); }