cRandomCombo.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cRandomCombo_H
#define _INC_cRandomCombo_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cRandomFloat.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cRandomCombo);
 
        struct cRandomComboSource
        {
                IRandomNoise*   m_pRandom;              
                size_t          m_nSizeBlock;   
                size_t          m_nSizeCur;             
        };
 
        class GRAYLIB_LINK cRandomCombo : public IRandomNoise
        {
        public:
                typedef BYTE SOURCE_t;
                static const SOURCE_t k_nMaxSources = 8;
                SOURCE_t m_nSourceQty;
                cRandomComboSource m_source[k_nMaxSources];
#ifdef _MT
                cThreadLockMutex m_Mutex;    
#endif
        public:
                cRandomCombo() noexcept
                        : m_nSourceQty(0)
                {}
                virtual ~cRandomCombo()
                {
                }
 
                HRESULT AddRandomSource(IRandomNoise* pRandom, size_t nSizeMax);
                UNITTEST2_PREDEF(cRandomCombo);
        };
 
        template <class _TYPE1, class _TYPE2>
        class cRandomCombo2 : public cRandomFloat
        {
 
        public:
                _TYPE1 m_r1;
                _TYPE2 m_r2;
 
        public:
                cRandomCombo2(const void* pData, size_t iSize)
                        : m_r1(pData, iSize)
                        , m_r2(pData, iSize)
                {
                }
                virtual ~cRandomCombo2()
                {}
 
                virtual void InitSeed(const void* pData, size_t iSize) override
                {
                        m_r1.InitSeed(pData, iSize);
                        m_r2.InitSeed(pData, iSize);
                }
 
                virtual double get_RandDouble() override
                {
                        double r = m_r1.get_RandDouble() + m_r2.get_RandDouble();
                        if (r >= 1.0)
                                r -= 1.0;
                        return r;
                }
 
                virtual UINT GetRandUX(UINT nScale) override       // get integer random number in desired interval
                {
                        if (nScale <= 0)
                                return 0; // error
                        UINT i = (UINT)(nScale * get_RandDouble()); // truncate
                        if (i >= nScale)
                                i = nScale - 1;
                        return i;
                }
        };
}
 
#endif