d3c08b3bc0
This commit closes the remaining red gates so `run-all.sh --fast` is
green end-to-end on the canonical dev machine.
New gates
─────────
1. cmake-format / cmake-lint
* scripts/quality/cmake-format.sh — dry-run by default,
--strict to fail on drift, --fix to apply
* .cmake-format.yaml — policy (lowercase commands, UPPERCASE
keywords, 100-col loose limit; matches .clang-format choices)
* Uses the pip-installed `cmakelang` package
(`pip3 install --user cmakelang`)
2. codespell
* scripts/quality/codespell.sh — exit 1 on any typo, --fix
interactively
* .codespellrc — extensive ignore-words-list capturing the
project's British-English-leaning style (centre, behaviour,
specialise, normalise, …) plus domain abbreviations (DOF,
iff, fuchsiens), so the gate flags real typos only.
* Validated: 0 typos across docs + code/include + scripts +
code/{src,tests}.
SPDX rollout (license-headers --fix)
────────────────────────────────────
license-headers.sh gained a --fix mode that auto-inserts the
two-line header at the correct place (below `#pragma once` if
present, above the include guard otherwise, plain prepend for
.cpp). Ran it on 60 of 66 files — 100 %-licensed now.
Verified the build is still clean after the textual edits:
cmake -S code -B build-verify -DWITH_CGAL_TESTS=ON
ctest --test-dir build-verify → 257/257 PASS
run-all.sh + README updated to include the two new gates.
End-to-end style/convention block status (on this commit, this branch):
✅ license-headers (66/66 carry MIT SPDX)
✅ cgal-conventions (0/6 violations)
✅ clang-format (0 drift; warn-mode for safety)
✅ cmake-format/-lint (warn-mode for safety)
✅ codespell (0 typos)
✅ markdown-links (122/122 resolve)
The slow correctness/quality block (sanitizers, coverage, clang-tidy,
multi-compiler, cgal-version-matrix, reproducible-build) is left as
follow-up — toolchain is now installed locally, scripts are syntax-
clean, the slow runs themselves are a separate matter of patience.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
96 lines
3.7 KiB
C++
96 lines
3.7 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 "clausen.hpp"
|
|
|
|
#include <gtest/gtest.h>
|
|
#include <cmath>
|
|
|
|
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);
|
|
}
|