From 3a13ad858e5af8eb3c26459eddc1401648b32422 Mon Sep 17 00:00:00 2001 From: Daniel Seemaier Date: Wed, 25 Mar 2026 02:26:11 +0100 Subject: [PATCH 1/2] Expand rgg2d + rgg3d tests --- tests/geometric/rgg2d_test.cpp | 214 +++++++++++++++++++++++++++++++- tests/geometric/rgg3d_test.cpp | 218 ++++++++++++++++++++++++++++++++- tests/geometric/utils.h | 2 +- 3 files changed, 422 insertions(+), 12 deletions(-) diff --git a/tests/geometric/rgg2d_test.cpp b/tests/geometric/rgg2d_test.cpp index f8a011d3..6e3b2e4d 100644 --- a/tests/geometric/rgg2d_test.cpp +++ b/tests/geometric/rgg2d_test.cpp @@ -32,10 +32,11 @@ void validate_graph(const Graph& local_graph, const PGeneratorConfig& config) { } } -void test_configuration(const SInt n, const double radius) { +void test_configuration(const SInt n, const double radius, const int seed = 1) { PGeneratorConfig config; config.n = n; config.r = radius; + config.seed = seed; config.coordinates = true; RGG2DFactory factory; @@ -52,14 +53,217 @@ void test_configuration(const SInt n, const double radius) { } } // namespace -TEST(Geometric2DTest, generates_graph_on_np_PE_n32_r125) { - test_configuration(32, 0.125); +// All tests use: +// - n >= 8 to avoid MPI buffer aliasing in gather infrastructure +// - r <= 0.125 to stay within k <= 1/r^2 constraint for k=64 (3,5,6 PEs) + +// === Small graphs === + +TEST(RGG2DTest, n8_r0125) { + test_configuration(8, 0.125); +} + +TEST(RGG2DTest, n8_r005) { + test_configuration(8, 0.05); +} + +TEST(RGG2DTest, n8_r001) { + test_configuration(8, 0.01); } -TEST(Geometric2DTest, generates_graph_on_np_PE_n16_r10) { +// === Original tests === + +TEST(RGG2DTest, n16_r01) { test_configuration(16, 0.1); } -TEST(Geometric2DTest, generates_graph_on_np_PE_n512_r01) { +TEST(RGG2DTest, n32_r0125) { + test_configuration(32, 0.125); +} + +TEST(RGG2DTest, n512_r001) { test_configuration(512, 0.01); } + +// === Moderate graphs with varying radius === + +TEST(RGG2DTest, n16_r0125) { + test_configuration(16, 0.125); +} + +TEST(RGG2DTest, n16_r005) { + test_configuration(16, 0.05); +} + +TEST(RGG2DTest, n16_r002) { + test_configuration(16, 0.02); +} + +TEST(RGG2DTest, n32_r01) { + test_configuration(32, 0.1); +} + +TEST(RGG2DTest, n32_r005) { + test_configuration(32, 0.05); +} + +TEST(RGG2DTest, n32_r002) { + test_configuration(32, 0.02); +} + +TEST(RGG2DTest, n64_r01) { + test_configuration(64, 0.1); +} + +TEST(RGG2DTest, n64_r005) { + test_configuration(64, 0.05); +} + +TEST(RGG2DTest, n64_r002) { + test_configuration(64, 0.02); +} + +TEST(RGG2DTest, n100_r008) { + test_configuration(100, 0.08); +} + +TEST(RGG2DTest, n128_r005) { + test_configuration(128, 0.05); +} + +// === Larger graphs === + +TEST(RGG2DTest, n256_r003) { + test_configuration(256, 0.03); +} + +TEST(RGG2DTest, n256_r005) { + test_configuration(256, 0.05); +} + +// === Edge case: maximum allowed radius (r=0.125 boundary) === +// With k=64: 1/r^2 = 64, so r=0.125 is the exact boundary + +TEST(RGG2DTest, n32_r0125_boundary) { + test_configuration(32, 0.125); +} + +TEST(RGG2DTest, n64_r0125) { + test_configuration(64, 0.125); +} + +TEST(RGG2DTest, n16_r0124) { + // Just below boundary + test_configuration(16, 0.124); +} + +// === Edge case: very small radius (sparse, few/zero edges) === + +TEST(RGG2DTest, n32_r0005) { + test_configuration(32, 0.005); +} + +TEST(RGG2DTest, n64_r0005) { + test_configuration(64, 0.005); +} + +// === Different seeds for reproducibility === + +TEST(RGG2DTest, n32_r01_seed42) { + test_configuration(32, 0.1, 42); +} + +TEST(RGG2DTest, n32_r01_seed123) { + test_configuration(32, 0.1, 123); +} + +TEST(RGG2DTest, n64_r005_seed7) { + test_configuration(64, 0.05, 7); +} + +TEST(RGG2DTest, n64_r005_seed999) { + test_configuration(64, 0.05, 999); +} + +// === Non-power-of-two node counts === + +TEST(RGG2DTest, n9_r01) { + test_configuration(9, 0.1); +} + +TEST(RGG2DTest, n13_r01) { + test_configuration(13, 0.1); +} + +TEST(RGG2DTest, n50_r005) { + test_configuration(50, 0.05); +} + +TEST(RGG2DTest, n99_r003) { + test_configuration(99, 0.03); +} + +TEST(RGG2DTest, n127_r004) { + test_configuration(127, 0.04); +} + +// === Larger graphs (1000+ vertices) === + +TEST(RGG2DTest, n1000_r005) { + test_configuration(1000, 0.05); +} + +TEST(RGG2DTest, n1000_r01) { + test_configuration(1000, 0.1); +} + +TEST(RGG2DTest, n1000_r0125) { + // Max radius boundary with large n + test_configuration(1000, 0.125); +} + +TEST(RGG2DTest, n2000_r003) { + test_configuration(2000, 0.03); +} + +TEST(RGG2DTest, n2000_r008) { + test_configuration(2000, 0.08); +} + +TEST(RGG2DTest, n3000_r005) { + test_configuration(3000, 0.05); +} + +TEST(RGG2DTest, n4000_r003) { + test_configuration(4000, 0.03); +} + +TEST(RGG2DTest, n1500_r007) { + // Non-round node count + test_configuration(1500, 0.07); +} + +TEST(RGG2DTest, n2500_r004_seed42) { + test_configuration(2500, 0.04, 42); +} + +// === cells_per_dim transitions === +// With k=64 (3,5,6 PEs), chunk_size=0.125 +// cells_per_dim = floor(0.125 / r) +// r=0.125: cells_per_dim=1, r=0.063: cells_per_dim=1, r=0.062: cells_per_dim=2 +// r=0.04: cells_per_dim=3, r=0.03: cells_per_dim=4 + +TEST(RGG2DTest, n32_r0062) { + // cells_per_dim=2 boundary + test_configuration(32, 0.062); +} + +TEST(RGG2DTest, n32_r004) { + // cells_per_dim=3 + test_configuration(32, 0.04); +} + +TEST(RGG2DTest, n32_r003) { + // cells_per_dim=4 + test_configuration(32, 0.03); +} diff --git a/tests/geometric/rgg3d_test.cpp b/tests/geometric/rgg3d_test.cpp index 6e09d205..fd9a83e4 100644 --- a/tests/geometric/rgg3d_test.cpp +++ b/tests/geometric/rgg3d_test.cpp @@ -1,6 +1,6 @@ #include "kagen/context.h" #include "kagen/definitions.h" -#include "kagen/generators/geometric/geometric_2d.h" +#include "kagen/generators/geometric/geometric_3d.h" #include "kagen/generators/geometric/rgg.h" #include @@ -32,10 +32,11 @@ void validate_graph(const Graph& local_graph, const PGeneratorConfig& config) { } } -void test_configuration(const SInt n, const double radius) { +void test_configuration(const SInt n, const double radius, const int seed = 1) { PGeneratorConfig config; config.n = n; config.r = radius; + config.seed = seed; config.coordinates = true; RGG3DFactory factory; @@ -52,14 +53,219 @@ void test_configuration(const SInt n, const double radius) { } } // namespace -TEST(Geometric3DTest, generates_graph_on_np_PE_n32_r125) { - test_configuration(32, 0.125); +// All tests use: +// - n >= 8 to avoid MPI buffer aliasing in gather infrastructure +// - r <= 0.25 to stay within chunk_size/r >= 1 for k=64 (3,5,6 PEs) +// - Avoid very small r to prevent excessive cell counts + +// === Small graphs === + +TEST(RGG3DTest, n8_r025) { + test_configuration(8, 0.25); +} + +TEST(RGG3DTest, n8_r015) { + test_configuration(8, 0.15); +} + +TEST(RGG3DTest, n8_r005) { + test_configuration(8, 0.05); } -TEST(Geometric3DTest, generates_graph_on_np_PE_n16_r10) { +// === Original tests === + +TEST(RGG3DTest, n16_r01) { test_configuration(16, 0.1); } -TEST(Geometric3DTest, generates_graph_on_np_PE_n512_r01) { +TEST(RGG3DTest, n32_r0125) { + test_configuration(32, 0.125); +} + +TEST(RGG3DTest, n512_r001) { test_configuration(512, 0.01); } + +// === Moderate graphs with varying radius === + +TEST(RGG3DTest, n16_r025) { + test_configuration(16, 0.25); +} + +TEST(RGG3DTest, n16_r015) { + test_configuration(16, 0.15); +} + +TEST(RGG3DTest, n16_r005) { + test_configuration(16, 0.05); +} + +TEST(RGG3DTest, n32_r02) { + test_configuration(32, 0.2); +} + +TEST(RGG3DTest, n32_r01) { + test_configuration(32, 0.1); +} + +TEST(RGG3DTest, n32_r005) { + test_configuration(32, 0.05); +} + +TEST(RGG3DTest, n64_r015) { + test_configuration(64, 0.15); +} + +TEST(RGG3DTest, n64_r01) { + test_configuration(64, 0.1); +} + +TEST(RGG3DTest, n64_r005) { + test_configuration(64, 0.05); +} + +TEST(RGG3DTest, n100_r01) { + test_configuration(100, 0.1); +} + +TEST(RGG3DTest, n128_r008) { + test_configuration(128, 0.08); +} + +// === Larger graphs === + +TEST(RGG3DTest, n256_r005) { + test_configuration(256, 0.05); +} + +TEST(RGG3DTest, n256_r008) { + test_configuration(256, 0.08); +} + +// === Edge case: maximum allowed radius (r=0.25 boundary) === +// With k=64 for 3D: chunks_per_dim=4, chunk_size=0.25 +// cells_per_dim = floor(0.25 / r), needs to be >= 1 + +TEST(RGG3DTest, n32_r025) { + test_configuration(32, 0.25); +} + +TEST(RGG3DTest, n64_r025) { + test_configuration(64, 0.25); +} + +TEST(RGG3DTest, n16_r024) { + // Just below boundary + test_configuration(16, 0.24); +} + +// === Edge case: very small radius (sparse, few/zero edges) === + +TEST(RGG3DTest, n32_r002) { + test_configuration(32, 0.02); +} + +TEST(RGG3DTest, n64_r002) { + test_configuration(64, 0.02); +} + +// === Different seeds === + +TEST(RGG3DTest, n32_r015_seed42) { + test_configuration(32, 0.15, 42); +} + +TEST(RGG3DTest, n32_r015_seed123) { + test_configuration(32, 0.15, 123); +} + +TEST(RGG3DTest, n64_r008_seed7) { + test_configuration(64, 0.08, 7); +} + +TEST(RGG3DTest, n64_r008_seed999) { + test_configuration(64, 0.08, 999); +} + +// === Non-power-of-two node counts === + +TEST(RGG3DTest, n9_r015) { + test_configuration(9, 0.15); +} + +TEST(RGG3DTest, n13_r01) { + test_configuration(13, 0.1); +} + +TEST(RGG3DTest, n50_r008) { + test_configuration(50, 0.08); +} + +TEST(RGG3DTest, n99_r005) { + test_configuration(99, 0.05); +} + +TEST(RGG3DTest, n127_r006) { + test_configuration(127, 0.06); +} + +// === Larger graphs (1000+ vertices) === + +TEST(RGG3DTest, n1000_r008) { + test_configuration(1000, 0.08); +} + +TEST(RGG3DTest, n1000_r015) { + test_configuration(1000, 0.15); +} + +TEST(RGG3DTest, n1000_r025) { + // Max radius boundary with large n + test_configuration(1000, 0.25); +} + +TEST(RGG3DTest, n2000_r005) { + test_configuration(2000, 0.05); +} + +TEST(RGG3DTest, n2000_r01) { + test_configuration(2000, 0.1); +} + +TEST(RGG3DTest, n3000_r008) { + test_configuration(3000, 0.08); +} + +TEST(RGG3DTest, n4000_r005) { + test_configuration(4000, 0.05); +} + +TEST(RGG3DTest, n1500_r01) { + // Non-round node count + test_configuration(1500, 0.1); +} + +TEST(RGG3DTest, n2500_r006_seed42) { + test_configuration(2500, 0.06, 42); +} + +// === cells_per_dim transitions === +// With k=64 (3,5,6 PEs), chunks_per_dim=4, chunk_size=0.25 +// cells_per_dim = floor(0.25 / r) +// r=0.25: cells_per_dim=1, r=0.13: cells_per_dim=1, r=0.125: cells_per_dim=2 +// r=0.08: cells_per_dim=3, r=0.06: cells_per_dim=4 + +TEST(RGG3DTest, n32_r0125_cells2) { + // cells_per_dim=2 boundary + test_configuration(32, 0.125); +} + +TEST(RGG3DTest, n32_r008) { + // cells_per_dim=3 + test_configuration(32, 0.08); +} + +TEST(RGG3DTest, n32_r006) { + // cells_per_dim=4 + test_configuration(32, 0.06); +} diff --git a/tests/geometric/utils.h b/tests/geometric/utils.h index fb7542da..cd8f2c91 100644 --- a/tests/geometric/utils.h +++ b/tests/geometric/utils.h @@ -30,7 +30,7 @@ inline Edgelist CreateExpectedRGG3DEdges(PGeneratorConfig config, const Graph& g for (SInt j = 0; j < config.n; j++) { auto [x2, y2, z2] = graph.coordinates.second[j]; // Comparing all coordinates - if (i != j && std::hypot(x1 - x2, y1 - y2, z1 - z2) < config.r) { + if (i != j && std::hypot(x1 - x2, y1 - y2, z1 - z2) <= config.r) { edges.emplace_back(i, j); } } From 6ff184b8283c6ffeea216aa7ca72d2d4ccb34850 Mon Sep 17 00:00:00 2001 From: Daniel Seemaier Date: Wed, 25 Mar 2026 03:04:26 +0100 Subject: [PATCH 2/2] Expand rhg tests, fix edge case (possibly missing reverse edges between local chunks) --- kagen/generators/hyperbolic/hyperbolic.cpp | 14 +- kagen/generators/hyperbolic/hyperbolic.h | 2 +- tests/geometric/hyperbolic_test.cpp | 206 ++++++++++++++++++++- 3 files changed, 211 insertions(+), 11 deletions(-) diff --git a/kagen/generators/hyperbolic/hyperbolic.cpp b/kagen/generators/hyperbolic/hyperbolic.cpp index 5aaeb338..48a2e379 100644 --- a/kagen/generators/hyperbolic/hyperbolic.cpp +++ b/kagen/generators/hyperbolic/hyperbolic.cpp @@ -451,7 +451,7 @@ void Hyperbolic::Query( right_processed_cell_ = cell_id; // Iterate over cell - if (search_down /* || !IsLocalChunk(chunk_id) */) // second condition should be always true? + if (search_down || !IsLocalChunk(chunk_id)) GenerateGridEdges(annulus_id, chunk_id, cell_id, q); bool found_nonlocal_chunk = false; @@ -467,7 +467,7 @@ void Hyperbolic::Query( // std::cout << "go right " << next_chunk_id << " " << annulus_id << " " << next_cell_id << std::endl; GenerateVertices(annulus_id, next_chunk_id, next_cell_id); found_nonlocal_chunk |= QueryRightNeighbor( - annulus_id, next_chunk_id, next_cell_id, q, std::abs(min_cell_phi - 0.0) < cell_eps_); + annulus_id, next_chunk_id, next_cell_id, q, std::abs(min_cell_phi - 0.0) < cell_eps_, search_down); } // Continue left @@ -513,7 +513,7 @@ void Hyperbolic::Query( template bool Hyperbolic::QueryRightNeighbor( - const SInt annulus_id, SInt chunk_id, SInt cell_id, const Vertex& q, bool phase) { + const SInt annulus_id, SInt chunk_id, SInt cell_id, const Vertex& q, bool phase, bool search_down) { /*bool out = false; if (std::get<5>(q) == 1280) { std::cout << "\tQueryRightNeighbor(" << annulus_id << ", " << chunk_id << ", " << cell_id << ", " @@ -549,10 +549,10 @@ bool Hyperbolic::QueryRightNeighbor( << std::endl; }*/ - // if ((false && search_down && IsLocalChunk(chunk_id) && min_cell_phi > std::get<0>(q)) || - // !IsLocalChunk(chunk_id)) - if (!IsLocalChunk(chunk_id)) { - found_nonlocal_chunk = true; + if (search_down || !IsLocalChunk(chunk_id)) { + if (!IsLocalChunk(chunk_id)) { + found_nonlocal_chunk = true; + } GenerateGridEdges(annulus_id, chunk_id, cell_id, q); } diff --git a/kagen/generators/hyperbolic/hyperbolic.h b/kagen/generators/hyperbolic/hyperbolic.h index 265b0009..b0637598 100644 --- a/kagen/generators/hyperbolic/hyperbolic.h +++ b/kagen/generators/hyperbolic/hyperbolic.h @@ -99,7 +99,7 @@ class Hyperbolic : public virtual Generator, private EdgeListOnlyGenerator { void Query(SInt annulus_id, SInt chunk_id, SInt cell_id, const Vertex& q, bool search_down = true); - bool QueryRightNeighbor(SInt annulus_id, SInt chunk_id, SInt cell_id, const Vertex& q, bool phase); + bool QueryRightNeighbor(SInt annulus_id, SInt chunk_id, SInt cell_id, const Vertex& q, bool phase, bool search_down); bool QueryLeftNeighbor(SInt annulus_id, SInt chunk_id, SInt cell_id, const Vertex& q, bool phase, bool search_down); diff --git a/tests/geometric/hyperbolic_test.cpp b/tests/geometric/hyperbolic_test.cpp index 9902c3d4..2174ab83 100644 --- a/tests/geometric/hyperbolic_test.cpp +++ b/tests/geometric/hyperbolic_test.cpp @@ -31,11 +31,12 @@ void validate_graph(const Graph& local_graph, const PGeneratorConfig& config) { } } -void test_configuration(const SInt n, const double avg_degree, const double plexp) { +void test_configuration(const SInt n, const double avg_degree, const double plexp, const int seed = 1) { PGeneratorConfig config; config.n = n; config.avg_degree = avg_degree; config.plexp = plexp; + config.seed = seed; config.hp_floats = true; config.coordinates = true; @@ -53,10 +54,209 @@ void test_configuration(const SInt n, const double avg_degree, const double plex } } // namespace -TEST(Geometric2DTest, generates_graph_on_np_PE_n16_d4_g3) { +// All tests use n >= 8 to avoid MPI buffer aliasing in gather infrastructure. +// Parameters: n, avg_degree, plexp (gamma) + +// === Original tests === + +TEST(HyperbolicTest, n16_d4_g3) { test_configuration(16, 4.0, 3.0); } -TEST(Geometric2DTest, generates_graph_on_np_PE_n512_d4_g3) { +TEST(HyperbolicTest, n512_d4_g3) { test_configuration(512, 4.0, 3.0); } + +// === Known problematic case (vertex_range inconsistencies) === + +TEST(HyperbolicTest, n1024_d16_g3) { + test_configuration(1024, 16.0, 3.0); +} + +// === Small graphs === + +TEST(HyperbolicTest, n8_d2_g3) { + test_configuration(8, 2.0, 3.0); +} + +TEST(HyperbolicTest, n8_d4_g3) { + test_configuration(8, 4.0, 3.0); +} + +TEST(HyperbolicTest, n16_d2_g3) { + test_configuration(16, 2.0, 3.0); +} + +TEST(HyperbolicTest, n32_d4_g3) { + test_configuration(32, 4.0, 3.0); +} + +// === Varying avg_degree === + +TEST(HyperbolicTest, n64_d2_g3) { + // Low average degree (sparse) + test_configuration(64, 2.0, 3.0); +} + +TEST(HyperbolicTest, n64_d4_g3) { + test_configuration(64, 4.0, 3.0); +} + +TEST(HyperbolicTest, n64_d8_g3) { + // Higher average degree + test_configuration(64, 8.0, 3.0); +} + +TEST(HyperbolicTest, n128_d4_g3) { + test_configuration(128, 4.0, 3.0); +} + +TEST(HyperbolicTest, n128_d8_g3) { + test_configuration(128, 8.0, 3.0); +} + +TEST(HyperbolicTest, n128_d16_g3) { + // High average degree + test_configuration(128, 16.0, 3.0); +} + +TEST(HyperbolicTest, n256_d4_g3) { + test_configuration(256, 4.0, 3.0); +} + +TEST(HyperbolicTest, n256_d16_g3) { + test_configuration(256, 16.0, 3.0); +} + +// === Varying plexp (gamma / power law exponent) === + +TEST(HyperbolicTest, n64_d4_g22) { + // Low gamma: flatter degree distribution, more hub nodes + test_configuration(64, 4.0, 2.2); +} + +TEST(HyperbolicTest, n64_d4_g25) { + test_configuration(64, 4.0, 2.5); +} + +TEST(HyperbolicTest, n64_d4_g35) { + // Higher gamma: steeper power law, fewer hubs + test_configuration(64, 4.0, 3.5); +} + +TEST(HyperbolicTest, n64_d4_g5) { + // Very high gamma: very steep power law + test_configuration(64, 4.0, 5.0); +} + +TEST(HyperbolicTest, n128_d4_g22) { + test_configuration(128, 4.0, 2.2); +} + +TEST(HyperbolicTest, n128_d4_g25) { + test_configuration(128, 4.0, 2.5); +} + +TEST(HyperbolicTest, n256_d4_g25) { + test_configuration(256, 4.0, 2.5); +} + +TEST(HyperbolicTest, n256_d4_g5) { + test_configuration(256, 4.0, 5.0); +} + +// === Combined: varying both avg_degree and plexp === + +TEST(HyperbolicTest, n64_d2_g25) { + // Sparse + low gamma + test_configuration(64, 2.0, 2.5); +} + +TEST(HyperbolicTest, n64_d8_g25) { + // Dense + low gamma + test_configuration(64, 8.0, 2.5); +} + +TEST(HyperbolicTest, n64_d2_g5) { + // Sparse + high gamma + test_configuration(64, 2.0, 5.0); +} + +TEST(HyperbolicTest, n64_d8_g5) { + // Dense + high gamma + test_configuration(64, 8.0, 5.0); +} + +// === Larger graphs === + +TEST(HyperbolicTest, n1000_d4_g3) { + test_configuration(1000, 4.0, 3.0); +} + +TEST(HyperbolicTest, n1000_d8_g25) { + test_configuration(1000, 8.0, 2.5); +} + +TEST(HyperbolicTest, n2000_d4_g3) { + test_configuration(2000, 4.0, 3.0); +} + +TEST(HyperbolicTest, n2000_d8_g3) { + test_configuration(2000, 8.0, 3.0); +} + +TEST(HyperbolicTest, n2000_d16_g3) { + test_configuration(2000, 16.0, 3.0); +} + +TEST(HyperbolicTest, n3000_d4_g25) { + test_configuration(3000, 4.0, 2.5); +} + +// === Different seeds === + +TEST(HyperbolicTest, n64_d4_g3_seed42) { + test_configuration(64, 4.0, 3.0, 42); +} + +TEST(HyperbolicTest, n64_d4_g3_seed123) { + test_configuration(64, 4.0, 3.0, 123); +} + +TEST(HyperbolicTest, n256_d4_g3_seed7) { + test_configuration(256, 4.0, 3.0, 7); +} + +TEST(HyperbolicTest, n256_d8_g25_seed999) { + test_configuration(256, 8.0, 2.5, 999); +} + +// === Non-power-of-two node counts === + +TEST(HyperbolicTest, n9_d4_g3) { + test_configuration(9, 4.0, 3.0); +} + +TEST(HyperbolicTest, n13_d4_g3) { + test_configuration(13, 4.0, 3.0); +} + +TEST(HyperbolicTest, n50_d4_g3) { + test_configuration(50, 4.0, 3.0); +} + +TEST(HyperbolicTest, n99_d4_g3) { + test_configuration(99, 4.0, 3.0); +} + +TEST(HyperbolicTest, n127_d4_g3) { + test_configuration(127, 4.0, 3.0); +} + +TEST(HyperbolicTest, n500_d4_g3) { + test_configuration(500, 4.0, 3.0); +} + +TEST(HyperbolicTest, n1500_d8_g3) { + test_configuration(1500, 8.0, 3.0); +}