random.h

/*    This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
 *    See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
 *    Author(s):       Vincent Rouvreau
 *
 *    Copyright (C) 2026 Inria
 *
 *    Modification(s):
 *      - YYYY/MM Author: Description of the modification
 */
 
#ifndef GUDHI_RANDOM_H_
#define GUDHI_RANDOM_H_
 
#include <random>  // for std::random_device, std::mt19937_64, std::uniform_real_distribution
#include <vector>
#include <algorithm>  // for std::generate
#include <cstddef>  // for std::size_t
#ifdef DEBUG_TRACES
#include <iostream>
#endif  // DEBUG_TRACES
 
namespace Gudhi {
 
namespace random {
  

  using Random_generator = std::mt19937_64;
 
#if defined( GUDHI_DEFAULT_RANDOM_DLL_EXPORT ) && defined( GUDHI_DEFAULT_RANDOM_DLL_IMPORT )
#error "GUDHI_DEFAULT_RANDOM_DLL_EXPORT and GUDHI_DEFAULT_RANDOM_DLL_IMPORT cannot be enabled at the same time"
#endif // GUDHI_DEFAULT_RANDOM_DLL_EXPORT && GUDHI_DEFAULT_RANDOM_DLL_IMPORT
 
// Defined but empty by default
#define GUDHI_RANDOM_DLL_API
 
#if defined(_WIN32)
  #if defined GUDHI_DEFAULT_RANDOM_DLL_EXPORT
    #define GUDHI_RANDOM_DLL_API __declspec(dllexport)
  #endif
  #if defined GUDHI_DEFAULT_RANDOM_DLL_IMPORT
    #define GUDHI_RANDOM_DLL_API __declspec(dllimport)
  #endif
#else
  #if defined GUDHI_DEFAULT_RANDOM_DLL_EXPORT
    // In case we start using '-fvisibility=hidden'
    #define GUDHI_RANDOM_DLL_API __attribute__((visibility("default")))
  #endif
#endif
 
  GUDHI_RANDOM_DLL_API Random_generator& get_default_random();
 
#if defined GUDHI_DEFAULT_RANDOM_DLL_IMPORT
  // No declaration, only definition
#else
  #if !defined GUDHI_DEFAULT_RANDOM_DLL_EXPORT
  inline
  #endif
  Random_generator& get_default_random() {
    thread_local Random_generator default_random{std::random_device{}()};
#ifdef DEBUG_TRACES
    std::clog << "get_default_random() " << &default_random << "\n";
#endif  // DEBUG_TRACES
    return default_random;
  }
#endif  // GUDHI_DEFAULT_RANDOM_DLL_IMPORT

  void set_seed(Random_generator::result_type seed) {
    get_default_random().seed(seed);
  }

   template <typename Type, typename CustomRandomGenerator = Random_generator&>
   Type get_uniform(const Type& min, const Type& max, CustomRandomGenerator&& rng = get_default_random()) {
       if constexpr (std::is_floating_point_v<Type>) {
           std::uniform_real_distribution<Type> dis(min, max);
           return dis(rng);
       } else if constexpr (std::is_integral_v<Type>) {
           std::uniform_int_distribution<Type> dis(min, max);
           return dis(rng);
       }
   }

  template <typename Type, typename CustomRandomGenerator = Random_generator&>
  std::vector<Type> get_uniform_range(std::size_t nbr, const Type& min, const Type& max,
                              CustomRandomGenerator&& rng = get_default_random()) {
    // With C++26, this should be replaced with std::ranges::generate_random
    std::vector<Type> result(nbr);
    if constexpr (std::is_floating_point_v<Type>) {
      std::uniform_real_distribution<Type> dis(min, max);
      std::generate(result.begin(), result.end(), [&]() { return dis(rng); });
    } else if constexpr (std::is_integral_v<Type>) {
      std::uniform_int_distribution<Type> dis(min, max);
      std::generate(result.begin(), result.end(), [&]() { return dis(rng); });
    }
    return result;
  }
  
    // end defgroup random
 
}  // namespace random
 
}  // namespace Gudhi
 
#endif  // GUDHI_RANDOM_H_