randomness.h

//  Copyright 2020-2021 Herald Project Contributors
//  SPDX-License-Identifier: Apache-2.0
//
 
#ifndef HERALD_RANDOMNESS_H
#define HERALD_RANDOMNESS_H
 
#include "data.h"
 
#include <string>
#include <random>
#include <climits>
 
namespace herald {
namespace datatype {
 
// class RandomnessSource {
// public:
//   RandomnessSource() = default;
//   virtual ~RandomnessSource() = default;
 
//   virtual std::string methodName() const = 0;
 
//   virtual void nextBytes(std::size_t count, Data& into) = 0;
//   virtual int nextInt() = 0;
//   virtual double nextDouble() = 0;
 
// };
 
class AllZerosNotRandom {
public:
  AllZerosNotRandom() = default;
  AllZerosNotRandom(AllZerosNotRandom&& other) noexcept = default;
  ~AllZerosNotRandom() = default;
 
  std::string methodName() const {
    return "allzeros";
  }
 
  void nextBytes(std::size_t count, Data& into) {
    for (std::size_t i = 0;i < count;i++) {
      into.append(std::byte(0));
    }
  }
 
  int nextInt() {
    return 0;
  }
 
  double nextDouble() {
    return 0.0;
  }
};
 
class IntegerDistributedRandomSource {
public:
  IntegerDistributedRandomSource() 
    : rd(), gen(rd()), distrib(LONG_MIN,LONG_MAX)
  {
    ;
  }
 
  IntegerDistributedRandomSource(IntegerDistributedRandomSource&& other) noexcept
    : rd(), // Doesn't have a move or copy constructor
      gen(rd()),
      distrib(other.distrib)
  {
    ;
  } 
 
  ~IntegerDistributedRandomSource() = default;
 
  std::string methodName() const {
    return "integerdistributed";
  }
 
  void nextBytes(std::size_t count, Data& into) {
    for (std::size_t i = 0;i < count;i++) {
      into.append(std::byte(distrib(gen)));
    }
  }
 
  int nextInt() {
    return (int)distrib(gen);
  }
 
  double nextDouble() {
    return (double)distrib(gen);
  }
 
private:
  std::random_device rd;  // Will be used to obtain a seed for the random number engine
  std::mt19937 gen; // Standard mersenne_twister_engine seeded with rd()
  std::uniform_int_distribution<int64_t> distrib;
};
 
template <typename RandomnessSourceT>
class RandomnessGenerator {
public:
  RandomnessGenerator(RandomnessSourceT&& toOwn)
    : m_source(std::move(toOwn)),
      m_entropy(0)
  {
    ;
  }
 
  ~RandomnessGenerator() = default;
 
  template <typename T>
  void addEntropy(T entropy) {
    // Get size of amount of entropy we have
    constexpr std::size_t size = sizeof(T);
    // TODO consider whether there's benefit to detecting most significant set bits.
    //      This may provide a benefit if the method of combination isn't XOR.
    
    // See if we are at multiples of std::size_t
    constexpr std::size_t multiple = sizeof(std::size_t) / size; // integer division, rounds down
    // Note the above cannot ever be 0 because std::size_t is always the largest size on a given architecture
 
    std::size_t toXor = 0;
    for (std::size_t i = 0;i < multiple;i++) {
      if (0 != i) {
        toXor << size;
      }
      toXor += entropy;
    }
 
    // XOR will ensure the same distribution of 0 and 1 over multiple applications
    m_entropy = m_entropy ^ toXor;
  }
 
  
  std::string methodName() const {
    return m_source.methodName();
  }
 
  void nextBytes(std::size_t count, Data& into) {
    constexpr std::size_t byteSize = sizeof(std::byte);
    constexpr std::size_t sizeTSize = sizeof(std::size_t);
    constexpr std::size_t shifts = sizeTSize / byteSize;
    Data sourcedInto;
    m_source.nextBytes(count,sourcedInto);
 
    // now add in entropy
    for (std::size_t byteIndex = 0;byteIndex < count;byteIndex++) {
      into.append((std::byte)(
        std::size_t(sourcedInto.at(byteIndex))
        ^ 
        (m_entropy >> 8 * (byteIndex % shifts))
      ));
    }
  }
 
  int nextInt() {
    return (int)(m_source.nextInt() ^ m_entropy);
  }
 
  double nextDouble() {
    return (double)(((std::size_t)m_source.nextDouble()) ^ m_entropy);
  }
 
private:
  RandomnessSourceT m_source;
  std::size_t m_entropy;
};
 
} // end namespace
} // end namespace
 
#endif