ail/random.hpp

   1 #pragma once
   2
   3 #include <ail/exception.hpp>
   4 #include <ail/types.hpp>
   5
   6 #include <boost/random.hpp>
   7 #include <boost/random/uniform_real.hpp>
   8
   9 namespace ail
  10 {
  11         typedef boost::mt19937 random_algorithm_type;
  12
  13         void seed_check();
  14
  15         extern random_algorithm_type prng_algorithm;
  16         extern bool prng_has_been_seeded;
  17
  18         template <typename integer_type>
  19                 integer_type random_integer(integer_type minimum, integer_type maximum)
  20         {
  21                 seed_check();
  22
  23                 typedef boost::uniform_int<integer_type> distribution_type;
  24
  25                 distribution_type distribution(minimum, maximum);
  26                 boost::variate_generator<random_algorithm_type &, distribution_type> generator(prng_algorithm, distribution);
  27
  28                 return generator();
  29         }
  30
  31         template <class real_type>
  32                 real_type random_real(real_type minimum = 0, real_type maximum = 1)
  33         {
  34                 seed_check();
  35
  36                 typedef boost::uniform_real<real_type> distribution_type;
  37
  38                 distribution_type distribution(minimum, maximum);
  39                 boost::variate_generator<random_algorithm_type &, distribution_type> generator(prng_algorithm, distribution);
  40                 return generator();
  41         }
  42
  43         template <class element_type, std::size_t array_size>
  44                 element_type & random_pick(element_type (&array)[array_size])
  45         {
  46                 std::size_t index = random_integer<std::size_t>(0, array_size - 1);
  47                 return array[index];
  48         }
  49
  50         template <class type>
  51                 class random_scale
  52         {
  53         public:
  54                 random_scale():
  55                         total_weight(0)
  56                 {
  57                 }
  58
  59                 void add(type object, ulong weight)
  60                 {
  61                         if(weight == 0)
  62                                 throw exception("Element weight can't be zero");
  63                         elements.push_back(element(object, total_weight, total_weight + weight - 1));
  64                         total_weight += weight;
  65                 }
  66
  67                 type random()
  68                 {
  69                         return make_choice()->object;
  70                 }
  71
  72         private:
  73
  74                 struct element
  75                 {
  76                         type object;
  77
  78                         ulong minimum;
  79                         ulong maximum;
  80
  81                         element()
  82                         {
  83                         }
  84
  85                         element(type object, ulong minimum, ulong maximum):
  86                                 object(object),
  87                                 minimum(minimum),
  88                                 maximum(maximum)
  89                         {
  90                         }
  91
  92                         bool operator==(ulong input) const
  93                         {
  94                                 return input >= minimum && input <= maximum;
  95                         }
  96                 };
  97
  98                 std::vector<element> elements;
  99                 ulong total_weight;
 100
 101                 typename std::vector<element>::iterator make_choice()
 102                 {
 103                         if(total_weight == 0)
 104                                 throw exception("Random scale object doesn't contain any elements yet");
 105                         ulong choice = random_integer<ulong>(0, total_weight - 1);
 106                         typename std::vector<element>::iterator iterator = std::find(elements.begin(), elements.end(), choice);
 107                         if(iterator == elements.end())
 108                                 throw exception("Unable to match weight, code must be broken");
 109                         return iterator;
 110                 }
 111         };
 112 }