Clamp probabilities passed to binomial distribution to $[0.0, 1.0]$. (#86)

* Clamp probabilities passed to binomial distribution to $[0.0, 1.0]$.

When the probability is computed based on chunk and cell sizes which
are equal, floating point inaccuracies may lead to probabilities
greater than 1.0.

* Fix compilation.

* Use spaces instead of tabs.

* Fix erroneous upper bound in one of the clamp calls.

Author: niklas-uhl

kagen/generators/geometric/geometric_2d.h

@@ -19,6 +19,7 @@
 #include "libmorton/morton2D.h"
 #include <tuple>
 #include <vector>
+#include <algorithm>
 
 namespace kagen {
 class Geometric2D : public virtual Generator, private EdgeListOnlyGenerator {
@@ -206,7 +207,8 @@ class Geometric2D : public virtual Generator, private EdgeListOnlyGenerator {
         for (SInt i = 0; i < cells_per_chunk_; ++i) {
             seed                  = config_.seed + chunk_id * cells_per_chunk_ + i + total_chunks_ * cells_per_chunk_;
             SInt    h             = sampling::Spooky::hash(seed);
-            SInt    cell_vertices = rng_.GenerateBinomial(h, n, cell_area / total_area);
+            // due to potential floating point inaccuracies clamp probability
+            SInt    cell_vertices = rng_.GenerateBinomial(h, n, std::clamp(cell_area / total_area, 0.0, 1.0));
             LPFloat cell_start_x  = std::get<1>(chunk) + (i / cells_per_dim_) * cell_size_;
             LPFloat cell_start_y  = std::get<2>(chunk) + (i % cells_per_dim_) * cell_size_;
             if (cell_vertices != 0) {

kagen/generators/geometric/geometric_3d.h

@@ -19,6 +19,7 @@
 #include "libmorton/morton3D.h"
 #include <tuple>
 #include <vector>
+#include <algorithm>
 
 namespace kagen {
 class Geometric3D : public virtual Generator, private EdgeListOnlyGenerator {
@@ -247,7 +248,7 @@ class Geometric3D : public virtual Generator, private EdgeListOnlyGenerator {
         for (SInt i = 0; i < cells_per_chunk_; ++i) {
             seed                  = config_.seed + chunk_id * cells_per_chunk_ + i + total_chunks_ * cells_per_chunk_;
             SInt    h             = sampling::Spooky::hash(seed);
-            SInt    cell_vertices = rng_.GenerateBinomial(h, n, cell_area / total_area);
+            SInt    cell_vertices = rng_.GenerateBinomial(h, n, std::clamp(cell_area / total_area, 0.0, 1.0));
             LPFloat cell_start_x  = std::get<1>(chunk) + ((i / cells_per_dim_) % cells_per_dim_) * cell_size_;
             LPFloat cell_start_y  = std::get<2>(chunk) + (i % cells_per_dim_) * cell_size_;
             LPFloat cell_start_z  = std::get<3>(chunk) + (i / (cells_per_dim_ * cells_per_dim_)) * cell_size_;

kagen/generators/geometric/rgg/rgg_2d.cpp

@@ -1,5 +1,7 @@
 #include "kagen/generators/geometric/rgg/rgg_2d.h"
 
+#include <algorithm>
+
 #include "kagen/tools/geometry.h"
 
 namespace kagen {
@@ -152,7 +154,8 @@ void RGG2D::GenerateCells(const SInt chunk_id) {
     for (SInt i = 0; i < cells_per_chunk_; ++i) {
         seed                  = config_.seed + chunk_id * cells_per_chunk_ + i + total_chunks_ * cells_per_chunk_;
         SInt    h             = sampling::Spooky::hash(seed);
-        SInt    cell_vertices = rng_.GenerateBinomial(h, n, cell_area / total_area);
+        // due to potential floating point inaccuracies clamp probability
+        SInt    cell_vertices = rng_.GenerateBinomial(h, n, std::clamp(cell_area / total_area, 0.0, 1.0));
         LPFloat cell_start_x  = std::get<1>(chunk) + (i / cells_per_dim_) * cell_size_;
         LPFloat cell_start_y  = std::get<2>(chunk) + (i % cells_per_dim_) * cell_size_;
 

kagen/generators/geometric/rgg/rgg_3d.cpp

@@ -1,5 +1,7 @@
 #include "kagen/generators/geometric/rgg/rgg_3d.h"
 
+#include <algorithm>
+
 namespace kagen {
 RGG3D::RGG3D(const PGeneratorConfig& config, const PEID rank, const PEID size) : Geometric3D(config, rank, size) {
     // Chunk variables
@@ -176,7 +178,8 @@ void RGG3D::GenerateCells(const SInt chunk_id) {
     for (SInt i = 0; i < cells_per_chunk_; ++i) {
         seed                  = config_.seed + chunk_id * cells_per_chunk_ + i + total_chunks_ * cells_per_chunk_;
         SInt    h             = sampling::Spooky::hash(seed);
-        SInt    cell_vertices = rng_.GenerateBinomial(h, n, cell_area / total_area);
+        // due to potential floating point inaccuracies clamp probability
+        SInt    cell_vertices = rng_.GenerateBinomial(h, n, std::clamp(cell_area / total_area, 0.0, 1.0));
         LPFloat cell_start_x  = std::get<1>(chunk) + ((i / cells_per_dim_) % cells_per_dim_) * cell_size_;
         LPFloat cell_start_y  = std::get<2>(chunk) + (i % cells_per_dim_) * cell_size_;
         LPFloat cell_start_z  = std::get<3>(chunk) + (i / (cells_per_dim_ * cells_per_dim_)) * cell_size_;

kagen/generators/hyperbolic/hyperbolic.cpp

@@ -7,6 +7,7 @@
 #include "kagen/tools/postprocessor.h"
 
 #include <iostream>
+#include <algorithm>
 
 namespace kagen {
 PGeneratorConfig
@@ -188,7 +189,8 @@ void Hyperbolic<Double>::ComputeAnnuli(const SInt chunk_id) {
 
         // Variate
         SInt h = sampling::Spooky::hash(config_.seed + total_annuli_ * config_.k + chunk_id * total_annuli_ + i);
-        SInt n_annulus = rng_.GenerateBinomial(h, n, ring_area / total_area);
+        // due to potential floating point inaccuracies clamp probability
+        SInt n_annulus = rng_.GenerateBinomial(h, n, std::clamp(ring_area / total_area, Double {0.0}, Double{1.0}));
 
         // Push annuli_
         annuli_[ComputeGlobalChunkId(i - 1, chunk_id)] = std::make_tuple(n_annulus, min_r, max_r, false, offset);
@@ -294,7 +296,7 @@ void Hyperbolic<Double>::GenerateCells(const SInt annulus_id, SInt chunk_id) {
         if (!clique)
             seed = config_.seed + annulus_id * config_.k + chunk_id + i + config_.n;
         SInt h      = sampling::Spooky::hash(seed);
-        SInt n_cell = rng_.GenerateBinomial(h, n, grid_phi / total_phi);
+        SInt n_cell = rng_.GenerateBinomial(h, n, std::clamp(grid_phi / total_phi, Double{0.0}, Double{1.0}));
 
         SInt global_cell_id = ComputeGlobalCellId(annulus_id, chunk_id, i);
         cells_[global_cell_id] =