feat(Distribution): Generic Double Distribution factory

francoisbonneau · francoisbonneau · commit 61e625cee947 · 2025-11-05T22:57:05.000+01:00
diff --git a/include/geode/stochastic/sampling/direct/double_sampler.hpp b/include/geode/stochastic/sampling/direct/double_sampler.hpp
@@ -35,6 +35,16 @@ namespace geode
 
 namespace geode
 {
+    struct opengeode_stochastic_stochastic_api DistributionDescription
+    {
+        std::string name;
+        DistributionType distribution_type;
+
+        double min_value{};
+        double max_value{};
+        std::optional< double > mean{};
+        std::optional< double > standard_deviation{};
+    };
 
     struct opengeode_stochastic_stochastic_api DoubleSampler
     {
@@ -43,6 +53,9 @@ namespace geode
             Gaussian,
             TruncatedGaussian >;
 
+        static Distribution create_distribution(
+            const DistributionDescription& desc );
+
         static double sample( RandomEngine& engine, const Distribution& dist );
     };
 
diff --git a/include/geode/stochastic/sampling/distributions.hpp b/include/geode/stochastic/sampling/distributions.hpp
@@ -27,8 +27,16 @@
 
 #include <optional>
 
+#include <geode/basic/named_type.hpp>
+
 namespace geode
 {
+    struct DistributionTag
+    {
+    };
+
+    using DistributionType = NamedType< std::string, DistributionTag >;
+
     template < typename Type >
     struct UniformClosed
     {
@@ -37,6 +45,16 @@ namespace geode
 
         Type min_value{ static_cast< Type >( 0 ) };
         Type max_value{ static_cast< Type >( 1 ) };
+
+        [[nodiscard]] static DistributionType distribution_type_static()
+        {
+            return DistributionType{ "UniformClosed" };
+        }
+
+        [[nodiscard]] DistributionType distribution_type() const
+        {
+            return distribution_type_static();
+        }
     };
 
     template < typename Type >
@@ -47,6 +65,16 @@ namespace geode
 
         Type min_value{ static_cast< Type >( 0 ) };
         Type max_value{ static_cast< Type >( 1 ) };
+
+        [[nodiscard]] static DistributionType distribution_type_static()
+        {
+            return DistributionType{ "UniformClosedOpen" };
+        }
+
+        [[nodiscard]] DistributionType distribution_type() const
+        {
+            return distribution_type_static();
+        }
     };
 
     struct opengeode_stochastic_stochastic_api Gaussian
@@ -56,6 +84,16 @@ namespace geode
 
         double mean{ 0. };
         double standard_deviation{ 1. };
+
+        [[nodiscard]] static DistributionType distribution_type_static()
+        {
+            return DistributionType{ "Gaussian" };
+        }
+
+        [[nodiscard]] DistributionType distribution_type() const
+        {
+            return distribution_type_static();
+        }
     };
 
     struct opengeode_stochastic_stochastic_api TruncatedGaussian
@@ -69,6 +107,16 @@ namespace geode
 
         std::optional< double > min_value;
         std::optional< double > max_value;
+
+        [[nodiscard]] static DistributionType distribution_type_static()
+        {
+            return DistributionType{ "TruncatedGaussian" };
+        }
+
+        [[nodiscard]] DistributionType distribution_type() const
+        {
+            return distribution_type_static();
+        }
     };
 
 } // namespace geode
diff --git a/src/geode/stochastic/sampling/direct/double_sampler.cpp b/src/geode/stochastic/sampling/direct/double_sampler.cpp
@@ -28,6 +28,69 @@
 
 namespace geode
 {
+    struct DistributionTypeHasher
+    {
+        std::size_t operator()( const DistributionType& d ) const noexcept
+        {
+            // Use the underlying string from NamedType
+            return absl::Hash< std::string >{}( d.get() );
+        }
+    };
+
+    using DistributionFactory = std::function< DoubleSampler::Distribution(
+        const DistributionDescription& ) >;
+
+    static absl::flat_hash_map< DistributionType, // key type
+        DistributionFactory, // value type
+        DistributionTypeHasher // custom hasher
+        >
+        distribution_registry = {
+            { UniformClosed< double >::distribution_type_static(),
+                []( const DistributionDescription& d ) {
+                    UniformClosed< double > dist;
+                    dist.min_value = d.min_value;
+                    dist.max_value = d.max_value;
+                    return dist;
+                } },
+            { UniformClosedOpen< double >::distribution_type_static(),
+                []( const DistributionDescription& d ) {
+                    UniformClosedOpen< double > dist;
+                    dist.min_value = d.min_value;
+                    dist.max_value = d.max_value;
+                    return dist;
+                } },
+            { Gaussian::distribution_type_static(),
+                []( const DistributionDescription& d ) {
+                    Gaussian dist;
+                    dist.mean =
+                        d.mean.value_or( ( d.max_value - d.min_value ) / 2.0 );
+                    dist.standard_deviation = d.standard_deviation.value_or(
+                        ( d.max_value - d.min_value ) / 6.0 );
+                    return dist;
+                } },
+            { TruncatedGaussian::distribution_type_static(),
+                []( const DistributionDescription& d ) {
+                    TruncatedGaussian dist;
+                    dist.mean =
+                        d.mean.value_or( ( d.max_value - d.min_value ) / 2.0 );
+                    dist.standard_deviation = d.standard_deviation.value_or(
+                        ( d.max_value - d.min_value ) / 6.0 );
+                    dist.min_value = d.min_value;
+                    dist.max_value = d.max_value;
+                    return dist;
+                } }
+        };
+
+    DoubleSampler::Distribution DoubleSampler::create_distribution(
+        const DistributionDescription& desc )
+    {
+        auto it = distribution_registry.find( desc.distribution_type );
+        if( it == distribution_registry.end() )
+            throw geode::OpenGeodeException( absl::StrCat(
+                "Unknown distribution type: ", desc.distribution_type.get() ) );
+        return it->second( desc );
+    }
+
     double DoubleSampler::sample(
         RandomEngine& engine, const Distribution& dist )
     {
diff --git a/tests/stochastic/sampling/direct/test-double-sampler.cpp b/tests/stochastic/sampling/direct/test-double-sampler.cpp
@@ -69,6 +69,43 @@ void test_double_sampler( geode::RandomEngine& engine )
         value != 1000., "[Gaussian] -  value did not changed." );
 }
 
+// Test function: create a uniform closed distribution from description
+void test_create_uniform_closed( geode::RandomEngine& engine )
+{
+    geode::DistributionDescription desc;
+    desc.name = "uniform_closed";
+    desc.distribution_type =
+        geode::UniformClosed< double >::distribution_type_static();
+    desc.min_value = 2.;
+    desc.max_value = 5.;
+
+    auto dist = geode::DoubleSampler::create_distribution( desc );
+    double value = geode::DoubleSampler::sample( engine, dist );
+    OPENGEODE_EXCEPTION(
+        value >= 2. && value <= 5., "[UniformClosed] - value out of bounds" );
+}
+
+// Test function: create a truncated Gaussian distribution from description
+void test_create_truncated_gaussian( geode::RandomEngine& engine )
+{
+    geode::DistributionDescription desc;
+    desc.name = "truncated_gaussian";
+    desc.distribution_type =
+        geode::TruncatedGaussian::distribution_type_static();
+    desc.min_value = -2.;
+    desc.max_value = 2.;
+    desc.mean = 0.0;
+    desc.standard_deviation = 1.0;
+
+    auto dist = geode::DoubleSampler::create_distribution( desc );
+    for( int i = 0; i < 100; ++i )
+    {
+        double value = geode::DoubleSampler::sample( engine, dist );
+        OPENGEODE_EXCEPTION( value >= -2. && value <= 2.,
+            "[TruncatedGaussian] - value out of bounds" );
+    }
+}
+
 int main()
 {
     try
@@ -78,6 +115,9 @@ int main()
 
         test_double_sampler( random_engine );
 
+        test_create_uniform_closed( random_engine );
+        test_create_truncated_gaussian( random_engine );
+
         geode::Logger::info( "TEST SUCCESS" );
         return 0;
     }
diff --git a/tests/stochastic/sampling/mcmc/test-mh-fractures.cpp b/tests/stochastic/sampling/mcmc/test-mh-fractures.cpp
@@ -21,6 +21,7 @@
  *
  */
 #include <geode/geometry/point.hpp>
+#include <geode/stochastic/sampling/direct/double_sampler.hpp>
 #include <geode/stochastic/sampling/direct/object_set_sampler/segment_set_sampler.hpp>
 #include <geode/stochastic/sampling/mcmc/helpers/simulation_runner.hpp>
 #include <geode/stochastic/sampling/mcmc/metropolis_hasting_sampler.hpp>
@@ -37,17 +38,8 @@ namespace
     {
         std::string name;
 
-        // length
-        std::string length_distribution_type;
-        double minimal_length;
-        double maximal_length;
-        double mean_length;
-
-        // azimuth
-        std::string azimuth_distribution_type;
-        double minimal_azimuth;
-        double maximal_azimuth;
-        double mean_azimuth;
+        geode::DistributionDescription length;
+        geode::DistributionDescription azimuth;
 
         // positionning
         double p20;
@@ -89,14 +81,12 @@ namespace
                 const auto set_id = this->object_sets_.add_set( set_desc.name );
                 name_to_uuid[set_desc.name] = set_id;
 
-                geode::UniformClosed< double > length_distribution;
-                length_distribution.min_value = set_desc.minimal_length;
-                length_distribution.max_value = set_desc.maximal_length;
-
-                geode::UniformClosed< double > azimuth_distribution;
-                azimuth_distribution.min_value = set_desc.minimal_azimuth;
-                azimuth_distribution.max_value = set_desc.maximal_azimuth;
-
+                auto length_distribution =
+                    geode::DoubleSampler::create_distribution(
+                        set_desc.length );
+                auto azimuth_distribution =
+                    geode::DoubleSampler::create_distribution(
+                        set_desc.azimuth );
                 this->set_samplers_.push_back(
                     std::make_unique< geode::UniformSegmentSetSampler >(
                         box_, length_distribution, azimuth_distribution ) );
@@ -175,12 +165,16 @@ namespace
         setA.name = "A";
 
         // length
-        setA.minimal_length = 1;
-        setA.maximal_length = 10.;
+        setA.length.distribution_type =
+            geode::UniformClosed< double >::distribution_type_static();
+        setA.length.min_value = 1;
+        setA.length.max_value = 10.;
 
         // azimuth
-        setA.minimal_azimuth = 1;
-        setA.maximal_azimuth = 10;
+        setA.azimuth.distribution_type =
+            geode::UniformClosed< double >::distribution_type_static();
+        setA.azimuth.min_value = 1;
+        setA.azimuth.max_value = 10.;
 
         // positionning
         setA.p20 = 0.1;
@@ -219,12 +213,16 @@ namespace
         setA.name = "A";
 
         // length
-        setA.minimal_length = 1;
-        setA.maximal_length = 10.;
+        setA.length.distribution_type =
+            geode::UniformClosed< double >::distribution_type_static();
+        setA.length.min_value = 1;
+        setA.length.max_value = 10.;
 
         // azimuth
-        setA.minimal_azimuth = 1;
-        setA.maximal_azimuth = 10;
+        setA.azimuth.distribution_type =
+            geode::UniformClosed< double >::distribution_type_static();
+        setA.azimuth.min_value = 1;
+        setA.azimuth.max_value = 10.;
 
         // positionning
         setA.p20 = 0.1;
@@ -235,12 +233,16 @@ namespace
         setB.name = "B";
 
         // length
-        setB.minimal_length = 1;
-        setB.maximal_length = 10.;
+        setB.length.distribution_type =
+            geode::UniformClosed< double >::distribution_type_static();
+        setB.length.min_value = 1;
+        setB.length.max_value = 10.;
 
         // azimuth
-        setB.minimal_azimuth = 90;
-        setB.maximal_azimuth = 100;
+        setB.azimuth.distribution_type =
+            geode::UniformClosed< double >::distribution_type_static();
+        setB.azimuth.min_value = 90.;
+        setB.azimuth.max_value = 100.;
 
         // positionning
         setB.p20 = 0.1;
