random.h

Go to the documentation of this file.

#pragma once
 
#include "fl/stdint.h"
#include "fl/int.h"
#include "lib8tion/random8.h"
 
namespace fl {

class fl_random {
private:
    u16 seed_;

    u16 next_random16() {
        seed_ = APPLY_FASTLED_RAND16_2053(seed_) + FASTLED_RAND16_13849;
        return seed_;
    }

    u32 next_random32() {
        u32 high = next_random16();
        u32 low = next_random16();
        return (high << 16) | low;
    }
 
public:
    typedef u32 result_type;

    fl_random() : seed_(random16_get_seed()) {}

    explicit fl_random(u16 seed) : seed_(seed) {}

    result_type operator()() {
        return next_random32();
    }

    result_type operator()(result_type n) {
        if (n == 0) return 0;
        u32 r = next_random32();
        fl::u64 p = (fl::u64)n * (fl::u64)r;
        return (u32)(p >> 32);
    }

    result_type operator()(result_type min, result_type max) {
        result_type delta = max - min;
        result_type r = (*this)(delta) + min;
        return r;
    }

    void set_seed(u16 seed) {
        seed_ = seed;
    }

    u16 get_seed() const {
        return seed_;
    }

    void add_entropy(u16 entropy) {
        seed_ += entropy;
    }

    static constexpr result_type minimum() {
        return 0;
    }

    static constexpr result_type maximum() {
        return 4294967295U;
    }

    u8 random8() {
        u16 r = next_random16();
        // return the sum of the high and low bytes, for better mixing
        return (u8)(((u8)(r & 0xFF)) + ((u8)(r >> 8)));
    }

    u8 random8(u8 n) {
        u8 r = random8();
        r = (r * n) >> 8;
        return r;
    }

    u8 random8(u8 min, u8 max) {
        u8 delta = max - min;
        u8 r = random8(delta) + min;
        return r;
    }

    u16 random16() {
        return next_random16();
    }

    u16 random16(u16 n) {
        return static_cast<u16>((*this)(n));
    }

    u16 random16(u16 min, u16 max) {
        return static_cast<u16>((*this)(min, max));
    }
};

fl_random& default_random();
 
} // namespace fl