uniform_random.hpp

#ifndef JMATH_UNIFORM_GENERATOR_HPP
#define JMATH_UNIFORM_GENERATOR_HPP

#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include <boost/random/uniform_real.hpp>
#include <boost/random/variate_generator.hpp>
#include <boost/numeric/ublas/vector.hpp>
#include <boost/numeric/ublas/matrix.hpp>
#include <limits>
#include <ctime>

namespace ublas = boost::numeric::ublas;

namespace jafar {
  namespace jmath {
    template <typename T> struct uniform_distribution;
    template<> struct uniform_distribution<int> {
      typedef boost::uniform_int<int> type;
    };
    template<> struct uniform_distribution<unsigned int> {
      typedef boost::uniform_int<unsigned int> type;
    };
    template<> struct uniform_distribution<float> {
      typedef boost::uniform_real<float> type;
    };
    template<> struct uniform_distribution<double> {
      typedef boost::uniform_real<double> type;
    };

    template<typename T>
    class UNIFORM_GENERATOR {
      T min;
      T max;
      uint32_t seed_value;
      typedef boost::mt19937 generator_type;
      typedef typename uniform_distribution<T>::type distribution_type;
      distribution_type distribution;
      generator_type rng;
      boost::variate_generator<generator_type&, distribution_type> generator;

    public:
      UNIFORM_GENERATOR(T _min = 0, 
                        T _max = 1, 
                        uint32_t _seed = -1) : 
        min(_min), max(_max), seed_value(_seed),
        distribution(_min, _max), generator(rng, distribution) {
        if(seed_value != -1)
          rng.seed(_seed);
      }
      inline T run() {
        return generator();
      }

      void seed(uint32_t _seed) {
        rng.seed(_seed);
      }
      inline void fill_vector(ublas::vector<T>& v) {
        for(typename ublas::vector<T>::iterator it = v.begin(); it != v.end(); it++)
          *it = run();
      }     
      inline void fill_vector(std::vector<T>& v) {
        for(typename std::vector<T>::iterator it = v.begin(); it != v.end(); it++)
          *it = run();
      }
      inline void fill_matrix(ublas::matrix<T>& m) {
        for(typename ublas::matrix<T>::iterator1 rit = m.begin1(); rit != m.end1(); rit++)
          for(typename ublas::matrix<T>::iterator2 it = rit.begin(); it != rit.end(); it++)
            *it = run();
      }
    };
    typedef UNIFORM_GENERATOR<double> uniform_generator;
  }

  namespace random {
    template<typename T>
    static void uniform_fill(T min, T max, ublas::vector<T>& v) {
      jafar::jmath::UNIFORM_GENERATOR<T> gen(min, max, static_cast<unsigned int>(std::time(0)));
      gen.fill_vector(v);
    }
    template<typename T>
    static void uniform_fill(T min, T max, std::vector<T>& v) {
      jafar::jmath::UNIFORM_GENERATOR<T> gen(min, max, static_cast<unsigned int>(std::time(0)));
      gen.fill_vector(v);
    }

    template<typename T>
    static void uniform_fill(T min, T max, ublas::matrix<T>& m) {
      jafar::jmath::UNIFORM_GENERATOR<T> gen(min, max, static_cast<unsigned int>(std::time(0)));
      gen.fill_matrix(m);
    }
  }

}

#endif