random.hpp

Go to the documentation of this file.

/*
 
Copyright 2025 Matthew Tolman
 
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
 
   http://www.apache.org/licenses/LICENSE-2.0
 
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
 
*/
 
#ifndef MTCORE_RANDOM_H
#define MTCORE_RANDOM_H
 
#include <cmath>
#include <limits>
 
#include "mtcore/alloc.hpp"
#include "mtcore/colls/result.hpp"
#include "mtcore/core.hpp"
#include <cstdint>


namespace mtcore {
  struct PrngState {
    u8 data[32];
  };

  using SeedError = int;

  struct PrngVTable {
    uint64_t (*nextUint)(PrngState &self);

    double (*next1_0)(PrngState &self);

    Result<void, SeedError> (*seed)(PrngState &self, uint64_t seed);

    void (*deinit)(PrngState &self);
  };

  struct Prng {
    // State
    PrngState state;
    // V-Table
    const PrngVTable *vtable;

    [[nodiscard]] bool can_get1_0() const noexcept { return vtable && vtable->next1_0 != nullptr; }

    [[nodiscard]] bool can_get_uint() const noexcept { return vtable && vtable->nextUint != nullptr; }

    [[nodiscard]] bool can_reseed() const noexcept { return vtable && vtable->seed != nullptr; }

    [[nodiscard]] double next1_0() noexcept {
      ensure(vtable, "MISSING VTABLE FOR PRNG");
      ensure(vtable->next1_0, "MISSING next1_0 IN PRNG VTABLE");
      return vtable->next1_0(state);
    }

    [[nodiscard]] u64 next_uint() noexcept {
      ensure(vtable, "MISSING VTABLE FOR PRNG");
      ensure(vtable->nextUint, "MISSING nextUint IN PRNG VTABLE");
      return vtable->nextUint(state);
    }

    [[nodiscard]] u64 in_range(const u64 min, const u64 max) noexcept {
      ensure(min < max, "INVALID RANGE PROVIDED");
      ensure(can_get_uint() || can_get1_0(), "INVALID PRNG - MUST HAVE next1_0 OR nextUint IN VTABLE");
 
      const u64 count = max - min;
 
      if (count == 1) {
        return min;
      }
 
      const auto offset = std::numeric_limits<u64>::max() % count;
      if (can_get_uint()) {
        u64 res;
        do {
          res = next_uint();
        } while (res >= (std::numeric_limits<u64>::max() - offset));
        res %= count;
        return res + min;
      }
      else {
        const long double v = next1_0();
        return static_cast<u64>(floor(v * static_cast<long double>(count))) + min;
      }
    }

    [[nodiscard]] f64 in_range_f64(const f64 min, const f64 max) noexcept {
      ensure(min < max, "INVALID RANGE PROVIDED");
      ensure(can_get_uint() || can_get1_0(), "INVALID PRNG - MUST HAVE next1_0 OR nextUint IN VTABLE");
 
      const auto count = max - min;
 
      if (count == 1) {
        return min;
      }
 
      if (can_get1_0()) {
        const double v = next1_0();
        return v * count + min;
      }
      else {
        constexpr auto m      = 10000000000;
        const auto n          = in_range(0, m);
        const long double rng = static_cast<long double>(n) / static_cast<long double>(m);
        return static_cast<f64>(rng * count) + min;
      }
    }

    [[nodiscard]] Result<void, SeedError> seed(const u64 seed) noexcept {
      ensure(vtable && vtable->seed, "INVALID VTABLE!");
      return vtable->seed(state, seed);
    }

    void deinit() noexcept {
      mtdefer { vtable = nullptr; };
      if (vtable && vtable->deinit) {
        vtable->deinit(state);
      }
    }
  };

  Prng tinymt_init(uint64_t seed) noexcept;

  Prng lcg_init(uint64_t seed) noexcept;

  enum class Mt19937_64Error { ALLOCATION_FAILED, MT19937_BAD_INIT };

  Result<Prng, Mt19937_64Error> mt19937_64(Allocator *alloc, uint64_t seed) noexcept;
 
}  // namespace mtcore
 
#endif  // MTCORE_RANDOM_H