F:/My Projects/LSEngine/Modules/LSMathLib/Src/Rand/LSMRand.h

#ifndef __LSM_RAND_H__
#define __LSM_RAND_H__

#include "../LSMMathLib.h"

#if defined( LSE_VISUALSTUDIO )
#pragma warning( push )

// warning C4146: unary minus operator applied to unsigned type, result still unsigned
#pragma warning( disable : 4146 )
#endif  // #if defined( LSE_VISUALSTUDIO )

namespace lsm {

        class CRand {
        public :
                // == Various constructors.
                LSE_INLINE LSE_CALLCTOR                 CRand();


                // == Types.
                enum {
                        LSM_STATE_LEN                           = 624,
                        LSM_STATE_LEN_ARRAY
                };


                // == Functions.
                LSVOID LSE_FCALL                                Seed( LSUINT32 _ui32Seed );

                LSUINT32 LSE_FCALL                              RandUInt32() const;

                LSUINT32 LSE_FCALL                              RandUInt32( LSUINT32 _ui32Max ) const;

                LSUINT64 LSE_FCALL                              RandUInt64() const;

                LSUINT64 LSE_FCALL                              RandUInt64( LSUINT64 _ui64Max ) const;

                LSREAL LSE_FCALL                                RandReal() const;

                LSREAL LSE_FCALL                                RandReal( LSREAL _fLow, LSREAL _fHigh ) const;

        protected :
                // == Types.
                enum {
                        LSM_PERIOD                                      = 397
                };


                // == Members.
                // State array.
                mutable LSUINT32                                m_ui32State[LSM_STATE_LEN_ARRAY];

                // Next value to get from the state.
                mutable LSUINT32 *                              m_pui32NextInState;

                // Values left in the state before a reload is required.
                mutable LSINT32                                 m_i32LeftInState;


                // == Functions.
                LSVOID LSE_FCALL                                Initialize( LSUINT32 _ui32Seed ) const;

                LSVOID LSE_FCALL                                Reload() const;

                static LSUINT32 LSE_FCALL               HiBit( const LSUINT32 & _ui32Val );

                static LSUINT32 LSE_FCALL               LoBit( const LSUINT32 & _ui32Val );

                static LSUINT32 LSE_FCALL               LoBits( const LSUINT32 & _ui32Val );

                static LSUINT32 LSE_FCALL               MixBits( const LSUINT32 & _ui32L, const LSUINT32 & _ui32R );

                static LSUINT32 LSE_FCALL               MersenneTwist( const LSUINT32 & _ui32F, const LSUINT32 & _ui32L, const LSUINT32 & _ui32R );
        };


        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        // DEFINITIONS
        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        // == Various constructors.
        LSE_INLINE LSE_CALLCTOR CRand::CRand() :
                m_pui32NextInState( NULL ),
                m_i32LeftInState( LSM_STATE_LEN_ARRAY ) {
                Seed( 19650218 );
        }

        // == Functions.
        LSE_INLINE LSVOID LSE_FCALL CRand::Seed( LSUINT32 _ui32Seed ) {
                Initialize( _ui32Seed );
                Reload();
        }

        LSE_INLINE LSUINT32 LSE_FCALL CRand::RandUInt32() const {
                if ( m_i32LeftInState == 0 ) { Reload(); }
                --m_i32LeftInState;

                LSUINT32 ui32Val;
                ui32Val = (*m_pui32NextInState++);
                ui32Val ^= (ui32Val >> 11);
                ui32Val ^= (ui32Val <<  7) & 0x9D2C5680UL;
                ui32Val ^= (ui32Val << 15) & 0xEFC60000UL;
                return (ui32Val ^ (ui32Val >> 18));
        }

        LSE_INLINE LSUINT32 LSE_FCALL CRand::RandUInt32( LSUINT32 _ui32Max ) const {
                return static_cast<LSUINT32>(RandUInt32() * (static_cast<LSDOUBLE>(1.0 / 4294967296.0)) * _ui32Max);
        }

        LSE_INLINE LSUINT64 LSE_FCALL CRand::RandUInt64() const {
                LSUINT64 ui64High = RandUInt32();
                return RandUInt32() | (ui64High << 32ULL);
        }

        LSE_INLINE LSUINT64 LSE_FCALL CRand::RandUInt64( LSUINT64 _ui64Max ) const {
                // If the range can be supported by RandUInt32(), revert to that.
                if ( _ui64Max <= (1ULL << 32ULL) ) { return RandUInt32( static_cast<LSUINT32>(_ui64Max) ); }
                // Otherwise the low part can be any random number and the high part is capped.
                LSUINT64 ui64High = RandUInt32( static_cast<LSUINT32>(_ui64Max >> 32ULL) );
                return RandUInt32() | (ui64High << 32ULL);
        }

        LSE_INLINE LSREAL LSE_FCALL CRand::RandReal() const {
                return static_cast<LSREAL>(RandUInt32() * (static_cast<LSDOUBLE>(1.0 / 4294967295.0)));
        }

        LSE_INLINE LSREAL LSE_FCALL CRand::RandReal( LSREAL _fLow, LSREAL _fHigh ) const {
                return _fLow + RandReal() * (_fHigh - _fLow);
        }

        LSE_INLINE LSVOID LSE_FCALL CRand::Initialize( LSUINT32 _ui32Seed ) const {
                LSUINT32 * pui32Cur = m_ui32State;
                LSUINT32 * pui32Next = m_ui32State;
                (*pui32Next++) = _ui32Seed;
                for ( LSUINT32 I = 1; I < LSM_STATE_LEN_ARRAY; ++I ) {
                        (*pui32Next++) = (1812433253 * ((*pui32Cur) ^ ((*pui32Cur) >> 30)) + I) & 0xFFFFFFFF;
                        ++pui32Cur;
                }
        }

        LSE_INLINE LSVOID LSE_FCALL CRand::Reload() const {

                LSUINT32 * pui32Cur = m_ui32State;
                for ( LSUINT32 I = LSM_STATE_LEN_ARRAY - LSM_PERIOD; I--; ++pui32Cur ) {
                        (*pui32Cur) = MersenneTwist( pui32Cur[LSM_PERIOD], pui32Cur[0], pui32Cur[1] );
                }
                for ( LSUINT32 I = LSM_PERIOD; --I; ++pui32Cur ) {
                        (*pui32Cur) = MersenneTwist( pui32Cur[LSM_PERIOD-LSM_STATE_LEN_ARRAY], pui32Cur[0], pui32Cur[1] );
                }
                (*pui32Cur) = MersenneTwist( pui32Cur[LSM_PERIOD-LSM_STATE_LEN_ARRAY], pui32Cur[0], m_ui32State[0] );

                m_i32LeftInState = LSM_STATE_LEN_ARRAY;
                m_pui32NextInState = m_ui32State;
        }


        LSE_INLINE LSUINT32 LSE_FCALL CRand::HiBit( const LSUINT32 & _ui32Val ) {
                return _ui32Val & 0x80000000;
        }

        LSE_INLINE LSUINT32 LSE_FCALL CRand::LoBit( const LSUINT32 & _ui32Val ) {
                return _ui32Val & 0x00000001;
        }

        LSE_INLINE LSUINT32 LSE_FCALL CRand::LoBits( const LSUINT32 & _ui32Val ) {
                return _ui32Val & 0x7FFFFFFF;
        }

        LSE_INLINE LSUINT32 LSE_FCALL CRand::MixBits( const LSUINT32 & _ui32L, const LSUINT32 & _ui32R ) {
                return HiBit( _ui32L ) | LoBits( _ui32R );
        }

        LSE_INLINE LSUINT32 LSE_FCALL CRand::MersenneTwist( const LSUINT32 & _ui32F, const LSUINT32 & _ui32L, const LSUINT32 & _ui32R ) {
                return _ui32F ^ (MixBits( _ui32L, _ui32R ) >> 1) ^ (-LoBit( _ui32R ) & 0x9908B0DF);
        }

}       // namespace lsm


#if defined( LSE_VISUALSTUDIO )
#pragma warning( pop )
#endif  // #if defined( LSE_VISUALSTUDIO )

#endif  // __LSM_RAND_H__