XorshiroRandomGeneratorStatic.h

#pragma once

namespace FLImaging
{
    namespace ImageProcessing
    {
        class FL_EXPORT CXorshiroRandomGeneratorStatic : public Base::CFLBase
        {
        private:
            CXorshiroRandomGeneratorStatic();
 
        public:

            static uint32_t GenerateUniformRandomValueU32();

            static uint32_t GenerateUniformRandomValueU32(uint64_t u64Seed);

            static uint32_t GenerateUniformRandomValueU32(uint32_t arrU32State[2]);

            static uint32_t GenerateUniformRandomValueU32(uint32_t u32Min, uint32_t u32Max);

            static uint32_t GenerateUniformRandomValueU32(uint32_t u32Min, uint32_t u32Max, uint64_t u64Seed);

            static uint32_t GenerateUniformRandomValueU32(uint32_t u32Min, uint32_t u32Max, uint32_t arrU32State[2]);

            static int32_t GenerateUniformRandomValueI32(int32_t i32Min, int32_t i32Max);

            static int32_t GenerateUniformRandomValueI32(int32_t i32Min, int32_t i32Max, uint64_t u64Seed);

            static int32_t GenerateUniformRandomValueI32(int32_t i32Min, int32_t i32Max, uint32_t arrU32State[2]);

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

            static float GenerateUniformRandomValueF32(float f32Min, float f32Max, uint64_t u64Seed);

            static float GenerateUniformRandomValueF32(float f32Min, float f32Max, uint32_t arrU32State[2]);

            static float GenerateStandardNormalRandomValueF32();

            static float GenerateStandardNormalRandomValueF32(uint64_t u64Seed);

            static float GenerateStandardNormalRandomValueF32(float &f32StdNormal2nd);

            static float GenerateStandardNormalRandomValueF32(uint32_t arrU32State[2]);

            static float GenerateStandardNormalRandomValueF32(uint32_t arrU32State[2], float &f32StdNormal2nd);

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

            static float GenerateNormalRandomValueF32(float f32Mean, float f32Stdev, uint64_t u64Seed);
            
            static float GenerateNormalRandomValueF32(float f32Mean, float f32Stdev, float &f32Normal2nd);

            static float GenerateNormalRandomValueF32(float f32Mean, float f32Stdev, uint32_t arrU32State[2]);

            static float GenerateNormalRandomValueF32(float f32Mean, float f32Stdev, uint32_t arrU32State[2], float &f32Normal2nd);
            
            static uint64_t GenerateUniformRandomValueU64();

            static uint64_t GenerateUniformRandomValueU64(uint64_t u64Seed);

            static uint64_t GenerateUniformRandomValueU64(uint64_t arrU64State[2]);

            static uint64_t GenerateUniformRandomValueU64(uint64_t u64Min, uint64_t u64Max);

            static uint64_t GenerateUniformRandomValueU64(uint64_t u64Min, uint64_t u64Max, uint64_t u64Seed);

            static uint64_t GenerateUniformRandomValueU64(uint64_t u64Min, uint64_t u64Max, uint64_t arrU64State[2]);

            static int64_t GenerateUniformRandomValueI64(int64_t i64Min, int64_t i64Max);

            static int64_t GenerateUniformRandomValueI64(int64_t i64Min, int64_t i64Max, uint64_t u64Seed);

            static int64_t GenerateUniformRandomValueI64(int64_t i64Min, int64_t i64Max, uint64_t arrU64State[2]);

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

            static double GenerateUniformRandomValueF64(double f64Min, double f64Max, uint64_t u64Seed);

            static double GenerateUniformRandomValueF64(double f64Min, double f64Max, uint64_t arrU64State[2]);

            static double GenerateStandardNormalRandomValueF64();

            static double GenerateStandardNormalRandomValueF64(uint64_t u64Seed);

            static double GenerateStandardNormalRandomValueF64(double &f64StdNormal2nd);

            static double GenerateStandardNormalRandomValueF64(uint64_t arrU64State[2]);

            static double GenerateStandardNormalRandomValueF64(uint64_t arrU64State[2], double &f64StdNormal2nd);

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

            static double GenerateNormalRandomValueF64(double f64Mean, double f64Stdev, uint64_t u64Seed);

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

            static double GenerateNormalRandomValueF64(double f64Mean, double f64Stdev, uint64_t arrU64State[2]);

            static double GenerateNormalRandomValueF64(double f64Mean, double f64Stdev, uint64_t arrU64State[2], double &f64Normal2nd);

            static void Seed(uint64_t u64Seed = 0x9d84a3d390df0c46);

            static void Initialize();

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

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

            static void SetInternalState32(const uint32_t arrU32State[2]);

            static void SetInternalState64(const uint64_t arrU64State[2]);

            static void GetInternalState32(uint32_t arrU32State[2]);

            static void GetInternalState64(uint64_t arrU64State[2]);
            static void Jump32();

            static void Jump32(uint32_t arrU32State[2]);

            static void Jump64();

            static void Jump64(uint64_t arrU64State[2]);
 
 
        protected:
 
            static uint32_t m_arrU32State[2];
            static uint64_t m_arrU64State[2];
        };
    }
}