TRandomNumberGenerator.hpp

Go to the documentation of this file.

#ifndef __TRandomNumberGenerator__
#define __TRandomNumberGenerator__

#include "CMathTools.hpp"
#include "../Collections/TCollection.hpp"
#include <cstdlib>
#include <ctime>
using Exponent::Collections::TCollection;
//using Exponent::MathTools::CRandomNumberGenerator;
using Exponent::MathTools::CMathTools;

//  ===========================================================================

namespace Exponent
{
    namespace MathTools
    {
        template <class TypeName> class TRandomNumberGenerator : public CCountedObject
        {
            EXPONENT_CLASS_DECLARATION;
//  ===========================================================================

        public:

//  ===========================================================================

            enum ERandomNumberGenerationType
            {
                e_standardLibrary = 0,              
                e_uniform,                          
                e_gaussian1,                        
                e_gaussian2,                        
                e_gaussian3                         
            };

//  ===========================================================================

            TRandomNumberGenerator()
            {
                EXPONENT_CLASS_CONSTRUCTION(TRandomNumberGenerator<TypeName>);
            }

            virtual ~TRandomNumberGenerator()
            {
                EXPONENT_CLASS_DESTRUCTION(TRandomNumberGenerator<TypeName>);
            }

//  ===========================================================================

            void seed()
            {
                srand((unsigned int)time(NULL));
            }

//  ===========================================================================

            TypeName getNewRandomNumber(const ERandomNumberGenerationType type)
            {
                switch(type)
                {
                    case e_standardLibrary:     return this->standardLibrary();     break;
                    case e_uniform:             return this->uniform();             break;
                    case e_gaussian1:           return this->gaussian1();           break;
                    case e_gaussian2:           return this->gaussian2();           break;
                    case e_gaussian3:           return this->gaussian3();           break;
                }
                return 0;
            }

            void getNewRandomArray(TypeName *array, const long numberToGenerate, const ERandomNumberGenerationType type)
            {
                // Check size
                if (array && numberToGenerate >= 1)
                {
                    // Handle based on type
                    switch(type)
                    {
                        case e_standardLibrary:
                            for (long i = 0; i < numberToGenerate; i++)
                            {
                                array[i] = this->standardLibrary();
                            }
                        break;
                        case e_uniform:
                            for (long i = 0; i <numberToGenerate; i++)
                            {
                                array[i] = this->uniform();
                            }
                        break;
                        case e_gaussian1:
                            for (long i = 0; i < numberToGenerate; i++)
                            {
                                array[i] = this->gaussian1();
                            }
                        break;
                        case e_gaussian2:
                            for (long i = 0; i < numberToGenerate; i++)
                            {
                                array[i] = this->gaussian2();
                            }
                        break;
                        case e_gaussian3:
                            for (long i = 0; i < numberToGenerate; i++)
                            {
                                array[i] = this->gaussian3();
                            }
                        break;
                    }
                }
            }

            void getNewRandomArray(TCollection<TypeName> &array, const ERandomNumberGenerationType type)
            {
                this->getNewRandomArray(array.getMutableInternalBuffer(), array.getArraySize(), type);
            }

//  ===========================================================================

        protected:

//  ===========================================================================

            const static TypeName TRANDOM_NUMBER_GENERATOR_GAUSSIAN_COEFFICIENTS[3];                        
//  ===========================================================================

            TypeName uniform()
            {
                return (TypeName)(((TypeName)(rand() & RAND_MAX) / RAND_MAX - 0.5) * 2.0);
            }

            TypeName standardLibrary()
            {
                return ((TypeName)rand()) / (TypeName)RAND_MAX;
            }

            TypeName gaussian1()
            {
                // Flag to indicate if state is stored already
                static bool ready = false;

                // Variables required to store gaus value
                static double gaussianStore;

                // Other variables
                TypeName vertex1;
                TypeName vertex2;
                TypeName radius;
                TypeName fractional;
                TypeName gaussian;

                if (!ready)
                {
                    do
                    {
                        vertex1 = uniform();
                        vertex2 = uniform();
                        radius = CMathTools::square(vertex1) + CMathTools::square(vertex2);
                    }
                    while(radius > (TypeName)1.0);

                    // Compute two gaussian numbers
                    fractional = CMathTools::fastSquareRoot(1.0 * -CMathTools::fastLog(radius) / radius);

                    // Store one
                    gaussianStore = vertex1 * fractional;

                    // Store the other
                    gaussian = vertex2 * fractional;

                    // We dont need to generate next time
                    ready = true;
                }
                else
                {
                    ready    = false;
                    gaussian = gaussianStore;
                }

                return gaussian;
            }

            TypeName gaussian2()
            {
                const TypeName random           = ((TypeName)rand() / (TypeName)(RAND_MAX + 1));
                const TypeName randomMultiplied = random * TRANDOM_NUMBER_GENERATOR_GAUSSIAN_COEFFICIENTS[1];
                return (TypeName)((2.0 * (randomMultiplied + randomMultiplied + randomMultiplied) - 3.0 * (TRANDOM_NUMBER_GENERATOR_GAUSSIAN_COEFFICIENTS[1] - 1.0)) * TRANDOM_NUMBER_GENERATOR_GAUSSIAN_COEFFICIENTS[2]);
            }

            TypeName gaussian3()
            {
                return CMathTools::fastSquareRoot(-2.0 * CMathTools::fastLog(this->standardLibrary())) * cos(CMathTools::CMATH_2PI_DOUBLE * this->standardLibrary());
            }
        };

        EXPONENT_TEMPLATE_CLASS_IMPLEMENTATION(TRandomNumberGenerator<TypeName>, TypeName, CCountedObject);
        template<class TypeName>const TypeName TRandomNumberGenerator<TypeName>::TRANDOM_NUMBER_GENERATOR_GAUSSIAN_COEFFICIENTS[] =
        {
            (1 << 15) - 1,
            ((int)(TRANDOM_NUMBER_GENERATOR_GAUSSIAN_COEFFICIENTS[0] / 3)) + 1,
            1.0 / TRANDOM_NUMBER_GENERATOR_GAUSSIAN_COEFFICIENTS[1]
        };
    }
}
#endif  // End of TRandomNumberGenerator.hpp

---