XorshiroRandomGenerator.h

#pragma once

namespace FLImaging
{
    namespace ImageProcessing
    {
        class FL_EXPORT CXorshiroRandomGenerator : public Base::CFLBase
        {
        public:
            CXorshiroRandomGenerator(uint64_t u64Seed = 0);
 
            #if defined(_MSVC_LANG)
            #if _MSVC_LANG > 201400
            CXorshiroRandomGenerator(const CXorshiroRandomGenerator &alg) = default;
            CXorshiroRandomGenerator(CXorshiroRandomGenerator &&alg) = default;
            CXorshiroRandomGenerator &operator=(const CXorshiroRandomGenerator &alg) = default;
            CXorshiroRandomGenerator &operator=(CXorshiroRandomGenerator &&alg) = default;
            #endif 
            #endif
 
            virtual ~CXorshiroRandomGenerator();
 
        public:

            void GenerateUniformRandomValuesU32(Base::CFLArray<uint32_t> &flaRandom, int64_t i64Count, uint32_t u32Min = 0, uint32_t u32Max = UINT32_MAX);

            void GenerateUniformRandomValuesI32(Base::CFLArray<int32_t> &flaRandom, int64_t i64Count, int32_t i32Min = INT32_MIN, int32_t i32Max = INT32_MAX);

            void GenerateUniformRandomValuesF32(Base::CFLArray<float> &flaRandom, int64_t i64Count, float f32Min = 0, float f32Max = 1);
            
            void GenerateUniformRandomValuesF64(Base::CFLArray<double> &flaRandom, int64_t i64Count, double f64Min = 0, double f64Max = 1);
            
            void GenerateNormalRandomValuesF32(Base::CFLArray<float> &flaRandom, int64_t i64Count, float f32Mean = 0, float f32Stdev = 1);
            
            void GenerateNormalRandomValuesF64(Base::CFLArray<double> &flaRandom, int64_t i64Count, double f64Mean = 0, double f64Stdev = 1);

            uint32_t GenerateUniformRandomValueU32();

            uint32_t GenerateUniformRandomValueU32(uint32_t u32Min, uint32_t u32Max);

            int32_t GenerateUniformRandomValueI32(int32_t i32Min, int32_t i32Max);

            float GenerateUniformRandomValueF32(float f32Min = 0.f, float f32Max = 1.f);

            float GenerateStandardNormalRandomValueF32();

            float GenerateStandardNormalRandomValueF32(float &f32StdNormal2nd);

            float GenerateNormalRandomValueF32(float f32Mean = 0.f, float f32Stdev = 1.f);

            float GenerateNormalRandomValueF32(float f32Mean, float f32Stdev, float &f32Normal2nd);

            uint64_t GenerateUniformRandomValueU64();

            uint64_t GenerateUniformRandomValueU64(uint64_t u64Min, uint64_t u64Max);

            int64_t GenerateUniformRandomValueI64(int64_t i64Min, int64_t i64Max);

            double GenerateUniformRandomValueF64(double f64Min = 0., double f64Max = 1.);

            double GenerateStandardNormalRandomValueF64();

            double GenerateStandardNormalRandomValueF64(double &f64StdNormal2nd);

            double GenerateNormalRandomValueF64(double f64Mean = 0., double f64Stdev = 1.);

            double GenerateNormalRandomValueF64(double f64Mean, double f64Stdev, double &f64Normal2nd);

            void Seed(uint64_t u64Seed = 0x9d84a3d390df0c46);

            void Initialize();

            void InitializeExternalState32(uint32_t arrU32State[2], uint64_t u64Seed);

            void InitializeExternalState64(uint64_t arrU64State[2], uint64_t u64Seed);

            void SetInternalState32(const uint32_t arrU32State[2]);

            void SetInternalState64(const uint64_t arrU64State[2]);

            void GetInternalState32(uint32_t arrU32State[2]) const;

            void GetInternalState64(uint64_t arrU64State[2]) const;

            void Jump32();

            void Jump32(uint64_t u64Jump);

            Base::CFLArray<std::pair<uint32_t, uint32_t>> MultipleJump32(uint32_t u32Count, uint64_t u64Jump) const;

            Base::CFLArray<std::pair<uint32_t, uint32_t>> MultipleJump32(const Base::CFLArray<uint64_t> &arrU64Count) const;

            void Jump64();
            
            void Jump64(uint64_t u64JumpLow, uint64_t u64JumpHigh = 0);
            
            Base::CFLArray<std::pair<uint64_t, uint64_t>> MultipleJump64(uint32_t u32Count, uint64_t u64JumpLow, uint64_t u64JumpHigh = 0) const;

            Base::CFLArray<std::pair<uint64_t, uint64_t>> MultipleJump64(const Base::CFLArray<uint64_t> &arrU64Count) const;

            Base::CFLArray<std::pair<uint64_t, uint64_t>> MultipleJump64(const Base::CFLArray<std::pair<uint64_t, uint64_t>> &arrPrU64Count) const;
 
 
 
            DeclareGetClassType();
 
        protected:
 
            uint32_t m_arrU32State[2];
            uint64_t m_arrU64State[2];
        };
    }
}