compile_time_random_array.h

/*
  ==============================================================================
    DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 
    Copyright 2022- by sonible GmbH.
 
    This file is part of VCTR - Versatile Container Templates Reconceptualized.
 
    VCTR is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License version 3
    only, as published by the Free Software Foundation.
 
    VCTR is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License version 3 for more details.
 
    You should have received a copy of the GNU Lesser General Public License
    version 3 along with VCTR.  If not, see <https://www.gnu.org/licenses/>.
  ==============================================================================
*/
 
#pragma once
 
#include <array>
#include <cstdint>
#include <numbers>
 
#ifdef _MSC_VER
__pragma(warning(push))
__pragma(warning(disable:4244)) // conversion from 'long double' to 'T', possible loss of data
#endif
#include <gcem.hpp>
#ifdef _MSC_VER
__pragma(warning(pop))
#endif
 
namespace vctr::random::detail
{
consteval auto getTimeFromString (const char* str, int offset)
{
    return static_cast<uint32_t> (str[offset] - '0') * 10 + static_cast<uint32_t> (str[offset + 1] - '0');
}
 
consteval auto getSeedFromCurrentTime()
{
    auto t = __TIME__;
    return getTimeFromString (t, 0) * 60 * 60 + getTimeFromString (t, 3) * 60 + getTimeFromString (t, 6);
}
 
consteval uint32_t uniformDistribution (uint32_t& previous)
{
    constexpr uint32_t lce_a = 48271;
    constexpr uint32_t lce_c = 0;
    constexpr uint32_t lce_m = std::numeric_limits<int32_t>::max();
    previous = ((lce_a * previous + lce_c) % lce_m);
    return previous;
}
 
template <typename T>
consteval T uniformDistribution (T min, T max, uint32_t& seed)
{
    auto span = double (max - min);
    constexpr auto scale = double (std::numeric_limits<int32_t>::max());
    return T (double (uniformDistribution (seed)) / scale * (span)) + min;
}
 
template <size_t size, typename T>
consteval auto makeArrayWithUniformDistribution (T min, T max, uint32_t seed)
{
    std::array<T, size> dst {};
    for (auto& el : dst)
        el = uniformDistribution (min, max, seed);
 
    return dst;
}
 
template <size_t size, std::floating_point T>
consteval auto makeArrayWithNormalDistribution (T mean, T sigma, uint32_t seed)
{
    std::array<T, size> dst {};
 
    for (size_t i = 0; i < size - 1; i += 2)
    {
        auto u1 = T (0);
        auto u2 = T (0);
 
        // first two uniformly distributed values between [0.0, 1.0] are calculated
        // u1 must not be zero
        do
        {
            u1 = uniformDistribution (T (0), T (1), seed);
            u2 = uniformDistribution (T (0), T (1), seed);
        } while (u1 <= std::numeric_limits<T>::epsilon());
 
        // from these values two normally distributed values are calculated
        // these values are then transformed to a general gaussian value to achieve the desired mean and sigma
        // z1 = sqrt(-2 * ln(u1)) * cos (2 * PI * u2)
        // z1 = sigma * z1 + mean
        // z2 = sqrt(-2 * ln(u1)) * sin (2 * PI * u2)
        // z2 = sigma * z2 + mean
 
        auto mag = sigma * gcem::sqrt (T (-2) * gcem::log (u1));
        auto twoPiU2 = std::numbers::pi_v<T> * 2 * u2;
        dst[i] = mag * gcem::cos (twoPiU2) + mean;
 
        // in case of odd array sizes, the last value is simply discarded
        if (i + 1 < size)
            dst[i + 1] = mag * gcem::sin (twoPiU2) + mean;
    }
 
    return dst;
}
} // namespace vctr::random::detail
 
namespace vctr::random
{
 
template <size_t size, typename T>
consteval auto makeArrayWithUniformDistribution (T min, T max, uint32_t seedOffset = 0)
{
    return detail::makeArrayWithUniformDistribution<size, T> (min, max, detail::getSeedFromCurrentTime() + seedOffset);
}
 
template <size_t size, std::floating_point T>
consteval auto makeArrayWithNormalDistribution (T mean, T sigma)
{
    return detail::makeArrayWithNormalDistribution<size, T> (mean, sigma, detail::getSeedFromCurrentTime());
}
 
} // namespace vctr::random