00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039 #include "global.hpp"
00040
00041 #include "config.hpp"
00042 #include "random.hpp"
00043 #include "util.hpp"
00044
00045 #include <cassert>
00046 #include <cstdio>
00047 #include <sstream>
00048
00049 rng::rng() : random_(NULL), random_child_(0)
00050 {}
00051
00052 int rng::get_random()
00053 {
00054 if (!random_)
00055 return rand() & 0x7FFFFFFF;
00056
00057 const config::child_list random(random_->get_children("random"));
00058 if (random_child_ >= random.size()) {
00059 random_child_ = random.size() + 1;
00060 int res = rand() & 0x7FFFFFFF;
00061 (random_->add_child("random"))["value"] = lexical_cast<std::string>(res);
00062 return res;
00063 } else {
00064 return lexical_cast_default<int>((*random[random_child_++])["value"], 0);
00065 }
00066 }
00067
00068 const config* rng::get_random_results()
00069 {
00070 assert(random_ != NULL);
00071
00072 const config::child_list random(random_->get_children("random"));
00073 if (random_child_ <= 0 ||random_child_ > random.size()) return NULL;
00074 return random[random_child_-1]->child("results");
00075 }
00076
00077 void rng::set_random_results(const config& cfg)
00078 {
00079 assert(random_ != NULL);
00080
00081 const config::child_list random(random_->get_children("random"));
00082 if (random_child_ <= 0 || random_child_ > random.size()) return;
00083 random[random_child_-1]->clear_children("results");
00084 random[random_child_-1]->add_child("results",cfg);
00085 }
00086
00087 config* rng::random()
00088 {
00089 return random_;
00090 }
00091
00092 void rng::set_random(config* random)
00093 {
00094 random_ = random;
00095 random_child_ = 0;
00096 return;
00097 }
00098
00099 namespace {
00100 rng* random_generator = NULL;
00101 }
00102
00103 set_random_generator::set_random_generator(rng* r) : old_(random_generator)
00104 {
00105 random_generator = r;
00106 }
00107
00108 set_random_generator::~set_random_generator()
00109 {
00110 random_generator = old_;
00111 }
00112
00113 int get_random()
00114 {
00115 assert(random_generator!=NULL);
00116 return random_generator->get_random();
00117 }
00118
00119 const config* get_random_results()
00120 {
00121 assert(random_generator!=NULL);
00122 return random_generator->get_random_results();
00123 }
00124
00125 void set_random_results(const config& cfg)
00126 {
00127 assert(random_generator!=NULL);
00128 random_generator->set_random_results(cfg);
00129 }
00130
00131 simple_rng::simple_rng() :
00132 random_seed_(rand()),
00133 random_pool_(random_seed_),
00134 random_calls_(0)
00135 {}
00136
00137 simple_rng::simple_rng(const config& cfg) :
00138
00139
00140 random_seed_(lexical_cast_default<int>(cfg["random_seed"], 42)),
00141 random_pool_(random_seed_),
00142 random_calls_(0)
00143 {}
00144
00145
00146 int simple_rng::get_random()
00147 {
00148 random_next();
00149 ++random_calls_;
00150
00151
00152
00153 return (static_cast<unsigned>(random_pool_ / 65536) % 32768);
00154 }
00155
00156
00157
00158
00159
00160
00161 void simple_rng::seed_random(const unsigned call_count)
00162 {
00163 seed_random(random_seed_, call_count);
00164 }
00165
00166
00167
00168
00169
00170
00171
00172 void simple_rng::seed_random(const int seed, const unsigned call_count)
00173 {
00174 random_pool_ = seed;
00175 random_seed_ = seed;
00176 for(random_calls_ = 0; random_calls_ < call_count; ++random_calls_) {
00177 random_next();
00178 }
00179
00180
00181
00182 }
00183
00184
00185 void simple_rng::random_next()
00186 {
00187
00188
00189
00190 random_pool_ = random_pool_ * 1103515245 + 12345;
00191 }
00192