Random.h

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * Written (W) 2013 Viktor Gal
 * Copyright (C) 2013 Viktor Gal
 */

#ifndef __RANDOM_H__
#define __RANDOM_H__

#include <shogun/lib/config.h>

#include <shogun/base/SGObject.h>
#include <shogun/lib/config.h>
#include <shogun/lib/Lock.h>
#include <limits>

/* opaque pointers */
struct SFMT_T;
struct DSFMT_T;

namespace shogun
{
    class CLock;
    class CRandom : public CSGObject
    {
        public:
            CRandom();

            CRandom(uint32_t seed);

            virtual ~CRandom();

            void set_seed(uint32_t seed);

            uint32_t get_seed() const;

            uint32_t random_32() const;

            uint64_t random_64() const;

            inline int32_t random_s32() const
            {
                return random_32() & ((uint32_t(-1)<<1)>>1);
            }

            inline int64_t random_s64() const
            {
                return random_64() & ((uint64_t(-1)<<1)>>1);
            }

            inline uint64_t random(uint64_t min_value, uint64_t max_value)
            {
                return min_value + random_64() % (max_value-min_value+1);
            }

            inline int64_t random(int64_t min_value, int64_t max_value)
            {
                return min_value + random_s64() % (max_value-min_value+1);
            }

            inline uint32_t random(uint32_t min_value, uint32_t max_value)
            {
                return min_value + random_32() % (max_value-min_value+1);
            }

            inline int32_t random(int32_t min_value, int32_t max_value)
            {
                return min_value + random_s32() % (max_value-min_value+1);
            }

            inline float32_t random(float32_t min_value, float32_t max_value)
            {
                return min_value + ((max_value-min_value) * random_close());
            }

            inline float64_t random(float64_t min_value, float64_t max_value)
            {
                return min_value + ((max_value-min_value) * random_close());
            }

            inline floatmax_t random(floatmax_t min_value, floatmax_t max_value)
            {
                return min_value + ((max_value-min_value) * random_close());
            }

            void fill_array(uint32_t* array, int32_t size) const;

            void fill_array(uint64_t* array, int32_t size) const;

            void fill_array_oc(float64_t* array, int32_t size) const;

            void fill_array_co(float64_t* array, int32_t size) const;

            void fill_array_oo(float64_t* array, int32_t size) const;

            void fill_array_c1o2(float64_t* array, int32_t size) const;

            float64_t random_close() const;

            float64_t random_open() const;

            float64_t random_half_open() const;

            float64_t normal_distrib(float64_t mu, float64_t sigma) const;

            float64_t std_normal_distrib() const;

            static uint32_t generate_seed();

            virtual const char* get_name() const { return "Random"; }

        private:
            void init();

             void reinit(uint32_t seed);

            float64_t sample_tail() const;

            float64_t GaussianPdfDenorm(float64_t x) const;

            float64_t GaussianPdfDenormInv(float64_t y) const;

            uint32_t m_seed;

            SFMT_T* m_sfmt_32;

            SFMT_T* m_sfmt_64;

            DSFMT_T* m_dsfmt;

            int32_t m_blockCount; //= 128;

            float64_t m_R;//= 3.442619855899;

            float64_t m_A;// = 9.91256303526217e-3;

            float64_t m_uint32ToU;// = 1.0 / (float64_t)UINT32_MAX;

            float64_t m_A_div_y0;

            float64_t* m_x;
            float64_t* m_y;

            uint32_t* m_xComp;

            CLock m_state_lock;
    };
}

#endif /* __RANDOM_H__ */