dlib C++ Library - rand_kernel_1.h

    // Copyright (C) 2007  Davis E. King (davisking@users.sourceforge.net)
    // License: Boost Software License   See LICENSE.txt for the full license.
    #ifndef DLIB_RAND_KERNEl_1_
    #define DLIB_RAND_KERNEl_1_

    #include <string>
    #include "../algs.h"
    #include "rand_kernel_abstract.h"
    #include "mersenne_twister.h"

    namespace dlib
    {

        class rand_kernel_1
        {

            /*!
                INITIAL VALUE
                    - seed == ""

                CONVENTION
                    - the random numbers come from the boost mersenne_twister code
                    - get_seed() == seed
            !*/

            public:

                rand_kernel_1(
                )
                {
                    // prime the generator a bit
                    for (int i = 0; i < 10000; ++i)
                        mt();
                }

                virtual ~rand_kernel_1(
                )
                {}

                void clear(
                )
                {
                    mt.seed();
                    seed.clear();

                    // prime the generator a bit
                    for (int i = 0; i < 10000; ++i)
                        mt();
                }

                const std::string& get_seed (
                )
                {
                    return seed;
                }

                void set_seed (
                    const std::string& value
                )
                {
                    seed = value;
                    uint32 s = 0;
                    for (std::string::size_type i = 0; i < seed.size(); ++i)
                    {
                        s = (s*37) + static_cast<uint32>(seed[i]);
                    }
                    mt.seed(s);
                    // prime the generator a bit
                    for (int i = 0; i < 10000; ++i)
                        mt();
                }

                unsigned char get_random_8bit_number (
                )
                {
                    return static_cast<unsigned char>(mt());
                }

                uint16 get_random_16bit_number (
                )
                {
                    return static_cast<uint16>(mt());
                }

                inline uint32 get_random_32bit_number (
                )
                {
                    return mt();
                }

                void swap (
                    rand_kernel_1& item
                )
                {
                    exchange(mt,item.mt);
                    exchange(seed, item.seed);
                }

            private:
                mt19937 mt;

                std::string seed;

                // restricted functions
                rand_kernel_1(rand_kernel_1&);        // copy constructor
                rand_kernel_1& operator=(rand_kernel_1&);    // assignment operator

        };

        inline void swap (
            rand_kernel_1& a,
            rand_kernel_1& b
        ) { a.swap(b); }

    }

    #endif // DLIB_RAND_KERNEl_1_