CaAlgoRandom.h

Go to the documentation of this file.

/* Copyright (C) 2023 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Sergei Zharko [committer] */
 
 
#ifndef CaAlgoRandom_h
#define CaAlgoRandom_h 1
 
#include <Logger.h>
 
#include <cstdint>
#include <random>
#include <type_traits>
 
namespace cbm::algo::ca
{
  class Random {
    using GeneratorType_t = std::mt19937_64;
 
   public:
    Random();
 
    Random(int seed);
 
    ~Random() = default;
 
    Random(const Random& other) = delete;
 
    Random(Random&& other) = delete;
 
    Random& operator=(const Random&) = delete;
 
    Random& operator=(Random&&) = delete;
 
    int GetSeed() const { return fSeed; }
 
    void SetSeed(int seed);
 
    template<typename T, std::enable_if_t<std::is_floating_point<T>::value, bool> = true>
    T BoundedGaus(const T& mean, const T& sigma, const T& nSigmas) const;
 
    template<typename T, std::enable_if_t<std::is_floating_point<T>::value, bool> = true>
    T Uniform(const T& mean, const T& sigma) const;
 
 
   private:
    mutable GeneratorType_t fGenerator;  
    unsigned int fSeed = 1;              
  };
 
 
  // *********************************************************
  // **     Template and inline function implementation     **
  // *********************************************************
 
  // ---------------------------------------------------------------------------------------------------------------------
  //
  template<typename T, std::enable_if_t<std::is_floating_point<T>::value, bool>>
  T Random::BoundedGaus(const T& mean, const T& sigma, const T& nSigmas) const
  {
    LOG_IF(fatal, !(nSigmas > 0 && std::isfinite(nSigmas))) << "ca::algo::Random::BoundedGaus nSigmas = " << nSigmas;
    LOG_IF(fatal, !(sigma > 0 && std::isfinite(sigma))) << "ca::algo::Random::BoundedGaus sigma = " << sigma;
 
    std::normal_distribution rndGaus{mean, sigma};
    double res = 0;
    do {
      res = rndGaus(fGenerator);
    } while (std::fabs(res - mean) > nSigmas * sigma);
    return res;
  }
 
  // ---------------------------------------------------------------------------------------------------------------------
  //
  template<typename T, std::enable_if_t<std::is_floating_point<T>::value, bool>>
  T Random::Uniform(const T& mean, const T& sigma) const
  {
    LOG_IF(fatal, !(sigma > 0 && std::isfinite(sigma)))
      << "ca::algo::Random::Uniform sigma = " << sigma << " is illegal";
    std::uniform_real_distribution rnd{-sigma * std::sqrt(3) + mean, sigma * std::sqrt(3) + mean};
    return rnd(fGenerator);
  }
 
}  // namespace cbm::algo::ca
 
#endif  // CaAlgoRandom_h