cRandomFloat.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cRandomFloat_H
#define _INC_cRandomFloat_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayLibBase.h"
#include "GrayCore/include/cRandom.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cRandomFloat);
 
        class GRAYLIB_LINK cRandomFloat : public cRandomBase
        {
 
        public:
                virtual double get_RandDouble();        // 0 to < 1.0
                virtual float get_RandFloat();          // 0 to < 1.0
 
                double GetRandDX(double nScale)
                {
                        if (nScale <= 0)
                                return 0;
                        return get_RandDouble() * nScale;
                }
                float GetRandFX(float nScale)
                {
                        if (nScale <= 0)
                                return 0;
                        return get_RandFloat() * nScale;
                }
 
                float GetRandFRange(float fRangeLo, float fRangeHi);    // output random float
 
                // implement shaped random distributions.
                // int GetBellInt( int iCenter, int iVariance25 );
                // int GetParabolicInt( int iVariance25 );
                // int GetHyperbolicInt( int iVariance25 );
 
                UNITTEST_FRIEND(cRandomFloat);
        };
 
        class GRAYLIB_LINK cRandomFloatDef : public cRandomFloat
        {
 
                cRandomDef& m_def;
        public:
                cRandomFloatDef(cRandomDef& def) noexcept
                        : m_def(def)
                {
                }
 
                virtual void InitSeed(const void* pData, size_t iSize) override;        // Start a repeatable seeded series
                virtual UINT GetRandUX(UINT nScale) override; // cRandomDef::k_RAND_MAX
        };
 
        class GRAYLIB_LINK cRandomMersenne : public cRandomFloat
        {
#if 1
                // define constants for MT11213A
                static const int k_N = 351;
                static const int k_M = 175;
                static const int k_R = 19;
                static const int k_TEML = 17;
 
                static const DWORD k_RANDOM_MATRIX_A = 0xE4BD75F5;
                static const DWORD k_RANDOM_TEMB = 0x655E5280;
                static const DWORD k_RANDOM_TEMC = 0xFFD58000;
#else
                // or constants for MT19937
                static const int k_N = 624;
                static const int k_M = 397;
                static const int k_R = 31;
                static const int k_TEML = 18;
 
                static const DWORD k_RANDOM_MATRIX_A = 0x9908B0DF;
                static const DWORD k_RANDOM_TEMB = 0x9D2C5680;
                static const DWORD k_RANDOM_TEMC = 0xEFC60000;
#endif
                static const int k_TEMU = 11;
                static const int k_TEMS = 7;
                static const int k_TEMT = 15;
 
        private:
                UINT m_mt[k_N];                 
                int m_mti;                     
 
        public:
                cRandomMersenne(const void* pData, size_t iSize);
                virtual ~cRandomMersenne()
                {}
 
                virtual void InitSeed(const void* pData, size_t iSize) override;      // re-seed
                virtual UINT get_RandUns() override;             // output random bits
        };
 
        class GRAYLIB_LINK cRandomBGenerator : public cRandomFloat
        {
 
                static const int k_KK = 17;
                static const int k_JJ = 10;
                static const int k_R1 = 13;
                static const int k_R2 = 9;
 
        protected:
                int m_p1;
                int m_p2;                      
                UINT m_randbuffer[k_KK];        
 
        public:
                cRandomBGenerator(const void* pData, size_t iSize);    // constructor
                virtual ~cRandomBGenerator()
                {}
 
                virtual void InitSeed(const void* pData, size_t iSize) override;      
                virtual UINT get_RandUns() override;
        };
 
#ifdef USE_LONG_DOUBLE
        typedef long double LONG_DOUBLE;           
#else
        typedef double LONG_DOUBLE;                
#endif
 
        class GRAYLIB_LINK cRandomWGenerator : public cRandomFloat
        {
 
                static const int k_KK = 17;
                static const int k_JJ = 10;
                static const int k_R1 = 19;
                static const int k_R2 = 27;
 
        protected:
                int m_p1;
                int m_p2;                          
                union
                {                              
                        LONG_DOUBLE m_randp1;
                        UINT m_randbits[3];
                } m_u;
                UINT m_randbuffer[k_KK][2];     
 
        public:
                cRandomWGenerator(const void* pData, size_t iSize);   // constructor
                virtual ~cRandomWGenerator()
                {}
 
                virtual void InitSeed(const void* pData, size_t iSize) override;     
                virtual UINT get_RandUns() override;            
        };
 
#ifdef USE_LONG_DOUBLE
 
        class GRAYLIB_LINK cRandomMotherOfAll : public cRandomFloat
        {
        protected:
                double m_x[5];                         
        public:
                cRandomMotherOfAll(const void* pData, size_t iSize);   // constructor
                virtual ~cRandomMotherOfAll()
                {}
 
                virtual void InitSeed(const void* pData, size_t iSize) override;                        
                virtual double get_RandDouble() override;                 
                virtual UINT GetRandUX(UINT nScale) override;     
        };
 
#endif
 
        extern GRAYLIB_LINK cRandomFloatDef g_RandFloat;        
};
#endif // _INC_cRandom_H