ba83974525
All checks were successful
C++ Tests / test-fast (pull_request) Successful in 1m57s
API Docs / doc-build (pull_request) Successful in 59s
Markdown link check / check (pull_request) Successful in 51s
C++ Tests / test-cgal (pull_request) Has been skipped
C++ Tests / quality-gates (pull_request) Successful in 2m19s
Add bit-for-bit (1e-12) golden-value oracle tests pinning the C++ pure-math and functional cores against the compiled upstream Java library (openjdk 17): - HyperIdealGoldenJava: Clausen/Л/ImLi2, ζ13/14/15/ζ, both tetrahedron-volume formulas (real de.varylab…Clausen / HyperIdealUtility). - EuclideanGoldenJava / SphericalGoldenJava: angle formulas + β relations + Л energy terms, plus FULL-MESH oracles driving the real EuclideanCyclicFunctional / SphericalFunctional on a shared tetrahedron — per-vertex gradient (Θ−Σα) and ΔE = E(x)−E(0) (C++ Gauss-Legendre path integral vs Java closed form). - SphericalGoldenJava.FullMeshEdgeDofGradient: edge-DOF gradient (vertex + edge components, α_opp⁺+α_opp⁻−θ_e) vs raw conformalEnergyAndGradient — locks Finding 3 at the solution level (audit items 4 & 5). - PeriodMatrix.NormalizeModulus_GoldenJava: τ-reduction fold convention vs the real DiscreteEllipticUtility.normalizeModulus (audit items 7 & 8). Subtlety documented: the spherical oracles call Java's raw conformalEnergyAndGradient, not evaluate() (which pre-runs a Brent gauge maximization that C++ factors into the Newton solver's spherical_gauge_shift). Also: - P1-2 (layout.hpp): Euclidean holonomy now uses a per-cut-edge rigid-motion fit g(z)=a·z+b, exposing residual_rotation = |arg(a)| as a diagnostic; non- regressive (flat case a=1 reduces to the old midpoint formula). - P1-3 (period_matrix.hpp): is_in_fundamental_domain fixed to the correct half-open SL(2,ℤ) domain (−½ ≤ Re < ½). Updated the now-exposed ComputePeriodMatrix_ReducedTau_InFD to assert the normalizeModulus domain (closed +½ edge) instead. Test counts (single source of truth = doc/api/tests.md): 272/272 pass, 0 skipped (26 non-CGAL + 246 CGAL). Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
138 lines
6.4 KiB
C++
138 lines
6.4 KiB
C++
// 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 <gtest/gtest.h>
|
|
#include <cmath>
|
|
#include <complex>
|
|
|
|
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<double>(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);
|
|
}
|