XorshiroRandomGeneratorStatic.h

#pragma once

namespace FLImaging
{
    namespace ImageProcessing
    {
        class CXorshiroRandomGenerator;

        class FL_EXPORT CXorshiroRandomGeneratorStatic : public Base::CFLBase
        {
        public:

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

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

            static void GenerateUniformRandomValuesF32(Base::CFLArray<float> &flaRandom, int64_t i64Count, float f32Min = 0, float f32Max = 1);

            static void GenerateUniformRandomValuesF64(Base::CFLArray<double> &flaRandom, int64_t i64Count, double f64Min = 0, double f64Max = 1);

            static void GenerateNormalRandomValuesF32(Base::CFLArray<float> &flaRandom, int64_t i64Count, float f32Mean = 0, float f32Stdev = 1);

            static void GenerateNormalRandomValuesF64(Base::CFLArray<double> &flaRandom, int64_t i64Count, double f64Mean = 0, double f64Stdev = 1);

            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();

            static float GenerateUniformRandomValueF32(float f32Min, float f32Max);

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

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

            static float GenerateUniformRandomValueF32HalfOpen();

            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 Base::TPoint<float> GenerateUniformRandomPointInUnitDiscF32();

            static Base::TPoint<float> GenerateUniformRandomPointInDiscF32(float f32Radius);

            static Base::TPoint<float> GenerateUniformRandomPointInUnitTriangleF32();

            static Base::TPoint3<float> GenerateUniformRandomPointOnUnitSphereF32();

            static Base::TPoint3<float> GenerateUniformRandomPointInUnitBallF32();

            static Base::TPoint3<float> GenerateUniformRandomPointInUnitTetrahedronF32();

            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();

            static double GenerateUniformRandomValueF64(double f64Min, double f64Max);

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

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

            static double GenerateUniformRandomValueF64HalfOpen();

            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 Base::TPoint<double> GenerateUniformRandomPointInUnitDiscF64();

            static Base::TPoint<double> GenerateUniformRandomPointInDiscF64(double f64Radius);

            static Base::TPoint<double> GenerateUniformRandomPointInUnitTriangleF64();

            static Base::TPoint3<double> GenerateUniformRandomPointOnUnitSphereF64();

            static Base::TPoint3<double> GenerateUniformRandomPointInUnitBallF64();

            static Base::TPoint3<double> GenerateUniformRandomPointInUnitTetrahedronF64();

            static uint64_t GenerateBinomialRandomValueU64(uint64_t u64SamplingCount, double f64Probability);

            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]);
 
        private:
            CXorshiroRandomGeneratorStatic();
 
            static CXorshiroRandomGenerator& GetInternal();
        };
    }
}