random.hpp

Go to the documentation of this file.

/*
  RANDOM.hpp  -  support for random number generation with controlled seed
 
   Copyright (C)
     2024,            Hermann Vosseler <Ichthyostega@web.de>
 
 **Lumiera** is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 Free Software Foundation; either version 2 of the License, or (at your
 option) any later version. See the file COPYING for further details.
 
*/
 
 
#ifndef LIB_RANDOM_H
#define LIB_RANDOM_H
 
 
#include "lib/integral.hpp"
#include "lib/hash-value.h"
#include "lib/nocopy.hpp"
 
#include <random>
 
 
namespace lib {
  namespace {
    inline uint constexpr
    _iBOUND()
    {
      return 1u+uint(std::numeric_limits<int>::max());
    }
  }
  
  class SeedNucleus
    {
    public:
      virtual ~SeedNucleus();     
      virtual uint64_t getSeed()  =0;
    };
  
  template<class GEN>
  class RandomSequencer
    {
      GEN generator_;
      
    public:
      RandomSequencer (SeedNucleus&);
      
      template<class G>
      RandomSequencer (RandomSequencer<G>&);
      
      // default copy operations (can copy and assign a state)
      
      
      int      i(uint bound =_iBOUND());                   
      int      i32();                                      
      uint64_t u64();                                      
      double   uni();                                      
      double   range (double start, double bound);         
      double   normal(double mean=0.0, double stdev=1.0);  
      HashVal  hash();                                     
      
      template<class DIST>
      auto distribute(DIST);
      
      void reseed (SeedNucleus&);
      
      class Seed;
    };
  
  template<class GEN>
  class RandomSequencer<GEN>::Seed
    : public SeedNucleus
    {
      RandomSequencer& srcGen_;
    public:
      Seed(RandomSequencer& parent)
        : srcGen_{parent}
        { }
      
      uint64_t
      getSeed() override
        {
          return srcGen_.u64();
        }
    };
  
  
  
  using Random = RandomSequencer<std::mt19937_64>;
  
  
  extern Random defaultGen;
  
  extern Random entropyGen;
  
  
  
  /* ===== convenience accessors ===== */
  
  inline int
  rani (uint bound  =_iBOUND())
    {
      return defaultGen.i(bound);
    }
  
  inline double
  ranRange (double start, double bound)
    {
      return defaultGen.range (start, bound);
    }
  
  inline double
  ranNormal(double mean =0.0, double stdev =1.0)
    {
      return defaultGen.normal (mean, stdev);
    }
  
  inline lib::HashVal
  ranHash()
    {
      return defaultGen.hash();
    }
  
  
  void randomiseRandomness();
  
  SeedNucleus& seedFromDefaultGen();
  
  
  
  
  /* ===== Implementation details ===== */
  
  template<class GEN>
  inline
  RandomSequencer<GEN>::RandomSequencer (SeedNucleus& nucleus)
    : generator_{nucleus.getSeed()}
    { }
  
  template<class GEN>
  template<class G>
  inline
  RandomSequencer<GEN>::RandomSequencer (RandomSequencer<G>& parent)
    : generator_{RandomSequencer<GEN>::Seed{parent}.getSeed()}
    { }
  
  
  template<class GEN>
  inline void
  RandomSequencer<GEN>::reseed (SeedNucleus& nucleus)
  {
    generator_.seed (nucleus.getSeed());
  }
  
  
  template<class GEN>
  template<class DIST>
  inline auto
  RandomSequencer<GEN>::distribute (DIST distribution)
    {
      return distribution (generator_);
    }
  
  template<class GEN>
  inline int
  RandomSequencer<GEN>::i (uint bound)
    {
      if (!bound) bound=1;
      --bound;
      uint upper{std::numeric_limits<int>::max()};
      upper = bound < upper? bound : upper;
      return distribute (std::uniform_int_distribution<int> (0, upper));
    }
  
  template<class GEN>
  inline int
  RandomSequencer<GEN>::i32()
    {
      return distribute (std::uniform_int_distribution<int> {std::numeric_limits<int>::min()
                                                            ,std::numeric_limits<int>::max()});
    }
  
  template<class GEN>
  inline uint64_t
  RandomSequencer<GEN>::u64()
    {
      return distribute (std::uniform_int_distribution<uint64_t> {std::numeric_limits<uint64_t>::min()
                                                                 ,std::numeric_limits<uint64_t>::max()});
    }
  
  template<class GEN>
  inline double
  RandomSequencer<GEN>::uni()
    {
      return range (0.0, 1.0);
    }
  
  template<class GEN>
  inline double
  RandomSequencer<GEN>::range (double start, double bound)
    {
      return distribute (std::uniform_real_distribution<double>{start,bound});
    }
  
  template<class GEN>
  inline double
  RandomSequencer<GEN>::normal (double mean, double stdev)
    {
      return distribute (std::normal_distribution<double>{mean,stdev});
    }
  
  template<class GEN>
  inline HashVal
  RandomSequencer<GEN>::hash()
    {
      return distribute (std::uniform_int_distribution<lib::HashVal>{lib::HashVal(1)});
    }
  
  
  
  template<class GEN>
  class CappedGen
    : public GEN
    {
      public:
      using GEN::GEN;
      
      GEN::result_type
      operator()()
        {
          if constexpr (GEN::max() < std::numeric_limits<typename GEN::result_type>::max())
              return GEN::operator()() % (GEN::max()+1);
          else
              return GEN::operator()();
        }
    };
  
  template<class GEN>
  auto
  buildCappedSubSequence (RandomSequencer<GEN>& src)
    {
      typename RandomSequencer<GEN>::Seed seedChain(src);
      RandomSequencer<CappedGen<GEN>> subSeq{seedChain};
      return subSeq;
    }
  
  
  
} // namespace lib
#endif /*LIB_RANDOM_H*/