[Lemon-commits] [lemon_svn] deba: r2991 - in hugo/trunk: benchmark demo lemon test
Lemon SVN
svn at lemon.cs.elte.hu
Mon Nov 6 21:51:42 CET 2006
Author: deba
Date: Sat Oct 14 17:26:05 2006
New Revision: 2991
Modified:
hugo/trunk/benchmark/edge_lookup.cc
hugo/trunk/benchmark/radix_sort-bench.cc
hugo/trunk/benchmark/swap_bipartite_bench.cc
hugo/trunk/demo/descriptor_map_demo.cc
hugo/trunk/demo/simann_maxcut_demo.cc
hugo/trunk/demo/topology_demo.cc
hugo/trunk/lemon/hypercube_graph.h
hugo/trunk/lemon/random.h
hugo/trunk/lemon/simann.h
hugo/trunk/test/all_pairs_shortest_path_test.cc
hugo/trunk/test/arborescence_test.cc
hugo/trunk/test/graph_utils_test.cc
hugo/trunk/test/graph_utils_test.h
hugo/trunk/test/heap_test.h
hugo/trunk/test/matrix_maps_test.cc
hugo/trunk/test/radix_sort_test.cc
hugo/trunk/test/simann_test.cc
hugo/trunk/test/test_tools.h
Log:
New random interface
Switching to the new interface
Modified: hugo/trunk/benchmark/edge_lookup.cc
==============================================================================
--- hugo/trunk/benchmark/edge_lookup.cc (original)
+++ hugo/trunk/benchmark/edge_lookup.cc Sat Oct 14 17:26:05 2006
@@ -2,6 +2,7 @@
#include<lemon/smart_graph.h>
#include<vector>
#include<lemon/time_measure.h>
+#include<lemon/random.h>
using namespace lemon;
@@ -100,7 +101,7 @@
std::vector<Node> v;
for(int i=0;i<N;i++) v.push_back(g.addNode());
- for(int i=0;i<M;i++) g.addEdge(v[int(drand48()*N)],v[int(drand48()*N)]);
+ for(int i=0;i<M;i++) g.addEdge(v[rnd[N]],v[rnd[N]]);
// {
// Edge e;
Modified: hugo/trunk/benchmark/radix_sort-bench.cc
==============================================================================
--- hugo/trunk/benchmark/radix_sort-bench.cc (original)
+++ hugo/trunk/benchmark/radix_sort-bench.cc Sat Oct 14 17:26:05 2006
@@ -26,6 +26,8 @@
#include <lemon/radix_sort.h>
+#include <lemon/random.h>
+
#include <vector>
#include <algorithm>
#include <cmath>
@@ -37,7 +39,7 @@
int n = 10000000;
vector<int> data(n);
for (int i = 0; i < n; ++i) {
- data[i] = (int)(1000 * (rand() / (RAND_MAX + 1.0))) - 500;
+ data[i] = rnd[1000] - 500;
}
radixSort(data.begin(), data.end());
}
@@ -47,7 +49,7 @@
int n = 10000000;
vector<int> data(n);
for (int i = 0; i < n; ++i) {
- data[i] = (int)(1000 * (rand() / (RAND_MAX + 1.0))) - 500;
+ data[i] = rnd[1000] - 500;
}
counterSort(data.begin(), data.end());
}
@@ -56,7 +58,7 @@
int n = 10000000;
vector<int> data(n);
for (int i = 0; i < n; ++i) {
- data[i] = (int)(1000 * (rand() / (RAND_MAX + 1.0))) - 500;
+ data[i] = rnd[1000] - 500;
}
sort(data.begin(), data.end());
}
@@ -65,7 +67,7 @@
int n = 10000000;
vector<int> data(n);
for (int i = 0; i < n; ++i) {
- data[i] = (int)(1000 * (rand() / (RAND_MAX + 1.0))) - 500;
+ data[i] = rnd[1000] - 500;
}
stable_sort(data.begin(), data.end());
}
Modified: hugo/trunk/benchmark/swap_bipartite_bench.cc
==============================================================================
--- hugo/trunk/benchmark/swap_bipartite_bench.cc (original)
+++ hugo/trunk/benchmark/swap_bipartite_bench.cc Sat Oct 14 17:26:05 2006
@@ -12,6 +12,7 @@
#include <lemon/graph_to_eps.h>
#include <lemon/time_measure.h>
+#include <lemon/random.h>
using namespace std;
using namespace lemon;
@@ -20,17 +21,6 @@
typedef ListBpUGraph LGraph;
BPUGRAPH_TYPEDEFS(Graph);
-int _urandom_init() {
- int seed = time(0);
- srand(seed);
- return seed;
-}
-
-int urandom(int n) {
- static int seed = _urandom_init();
- ignore_unused_variable_warning(seed);
- return (int)(rand() / (1.0 + RAND_MAX) * n);
-}
int main() {
@@ -66,8 +56,8 @@
}
for (int i = 0; i < e; ++i) {
int a,b;
- Node aNode = aNodes[a=urandom(n)];
- Node bNode = bNodes[b=urandom(m)];
+ Node aNode = aNodes[a=rnd[n]];
+ Node bNode = bNodes[b=rnd[m]];
graph.addEdge(aNode, bNode);
LGraph::Node laNode = laNodes[a];
LGraph::Node lbNode = lbNodes[b];
Modified: hugo/trunk/demo/descriptor_map_demo.cc
==============================================================================
--- hugo/trunk/demo/descriptor_map_demo.cc (original)
+++ hugo/trunk/demo/descriptor_map_demo.cc Sat Oct 14 17:26:05 2006
@@ -32,11 +32,12 @@
#include <lemon/dim2.h>
#include <lemon/graph_to_eps.h>
+#include <lemon/random.h>
+
#include <iostream>
-#include <cstdlib>
#include <cmath>
-#include <ctime>
+
using namespace lemon;
@@ -75,7 +76,6 @@
};
int main() {
- std::srand(std::time(0));
typedef ListGraph Graph;
typedef Graph::Node Node;
typedef Graph::Edge Edge;
@@ -105,8 +105,8 @@
// it holds reference to it.
const int EDGE = (int)(NODE * std::log(double(NODE)));
for (int i = 0; i < EDGE; ++i) {
- int si = (int)(std::rand() / (RAND_MAX + 1.0) * NODE);
- int ti = (int)(std::rand() / (RAND_MAX + 1.0) * NODE);
+ int si = rnd[NODE];
+ int ti = rnd[NODE];
graph.addEdge(nodeInv[si], nodeInv[ti]);
}
Modified: hugo/trunk/demo/simann_maxcut_demo.cc
==============================================================================
--- hugo/trunk/demo/simann_maxcut_demo.cc (original)
+++ hugo/trunk/demo/simann_maxcut_demo.cc Sat Oct 14 17:26:05 2006
@@ -54,7 +54,7 @@
Entity(Graph& _g, Graph::EdgeMap<int>& _w) : g(_g), w(_w), a(_g) {}
double mutate() {
static const int node_num = countNodes(g);
- int i = 1 + (int) (node_num * (rand() / (RAND_MAX + 1.0)));
+ int i = 1 + rnd[node_num];
NodeIt n(g);
int j = 1;
while (j < i) {
@@ -91,7 +91,7 @@
for (NodeIt n(g); n != INVALID; ++n)
a[n] = false;
for (NodeIt n(g); n != INVALID; ++n)
- if (rand() < 0.5) a[n] = true;
+ if (rnd.boolean(0.5)) a[n] = true;
sum = 0;
for (EdgeIt e(g); e != INVALID; ++e)
if (a[g.source(e)] != a[g.target(e)])
Modified: hugo/trunk/demo/topology_demo.cc
==============================================================================
--- hugo/trunk/demo/topology_demo.cc (original)
+++ hugo/trunk/demo/topology_demo.cc Sat Oct 14 17:26:05 2006
@@ -184,8 +184,6 @@
}
int main() {
- srand(time(0));
-
drawConnectedComponents();
drawStronglyConnectedComponents();
drawNodeBiconnectedComponents();
Modified: hugo/trunk/lemon/hypercube_graph.h
==============================================================================
--- hugo/trunk/lemon/hypercube_graph.h (original)
+++ hugo/trunk/lemon/hypercube_graph.h Sat Oct 14 17:26:05 2006
@@ -260,8 +260,8 @@
/// HyperCubeGraph graph(DIM);
/// dim2::Point<double> base[DIM];
/// for (int k = 0; k < DIM; ++k) {
- /// base[k].x = random.getReal();
- /// base[k].y = random.getReal();
+ /// base[k].x = rnd();
+ /// base[k].y = rnd();
/// }
/// HyperCubeGraph::HyperMap<dim2::Point<double> >
/// pos(graph, base, base + DIM, dim2::Point<double>(0.0, 0.0));
Modified: hugo/trunk/lemon/random.h
==============================================================================
--- hugo/trunk/lemon/random.h (original)
+++ hugo/trunk/lemon/random.h Sat Oct 14 17:26:05 2006
@@ -20,6 +20,8 @@
#define LEMON_RANDOM_H
#include <algorithm>
+#include <iterator>
+#include <vector>
#include <ctime>
#include <cmath>
@@ -33,477 +35,556 @@
namespace lemon {
-#if WORD_BIT == 32
+ namespace _random_bits {
+
+ template <typename _Word, int _bits = std::numeric_limits<_Word>::digits>
+ struct RandomTraits {};
- /// \ingroup misc
- ///
- /// \brief Mersenne Twister random number generator
- ///
- /// The Mersenne Twister is a twisted generalized feedback
- /// shift-register generator of Matsumoto and Nishimura. The period of
- /// this generator is \f$ 2^{19937} - 1 \f$ and it is equi-distributed in
- /// 623 dimensions. The time performance of this generator is comparable
- /// to the commonly used generators.
- ///
- /// \author Balazs Dezso
- class Random {
+ template <typename _Word>
+ struct RandomTraits<_Word, 32> {
- static const int length = 624;
- static const int shift = 397;
+ typedef _Word Word;
+ static const int bits = 32;
- public:
+ static const int length = 624;
+ static const int shift = 397;
+
+ static const Word mul = 0x6c078965u;
+ static const Word arrayInit = 0x012BD6AAu;
+ static const Word arrayMul1 = 0x0019660Du;
+ static const Word arrayMul2 = 0x5D588B65u;
+
+ static const Word mask = 0x9908B0DFu;
+ static const Word loMask = (1u << 31) - 1;
+ static const Word hiMask = ~loMask;
+
+
+ static Word tempering(Word rnd) {
+ rnd ^= (rnd >> 11);
+ rnd ^= (rnd << 7) & 0x9D2C5680u;
+ rnd ^= (rnd << 15) & 0xEFC60000u;
+ rnd ^= (rnd >> 18);
+ return rnd;
+ }
- static const unsigned long min = 0ul;
- static const unsigned long max = ~0ul;
-
- /// \brief Constructor
- ///
- /// Constructor with time dependent seeding.
- Random() { initState(std::time(0)); }
+ };
- /// \brief Constructor
- ///
- /// Constructor
- Random(unsigned long seed) { initState(seed); }
+ template <typename _Word>
+ struct RandomTraits<_Word, 64> {
- /// \brief Copy constructor
- ///
- /// Copy constructor. The generated sequence will be identical to
- /// the other sequence.
- Random(const Random& other) {
- std::copy(other.state, other.state + length, state);
- current = state + (other.current - other.state);
- }
+ typedef _Word Word;
+ static const int bits = 64;
- /// \brief Assign operator
- ///
- /// Assign operator. The generated sequence will be identical to
- /// the other sequence.
- Random& operator=(const Random& other) {
- if (&other != this) {
- std::copy(other.state, other.state + length, state);
- current = state + (other.current - other.state);
+ static const int length = 312;
+ static const int shift = 156;
+
+ static const Word mul = (Word)0x5851F42Du << 32 | (Word)0x4C957F2Du;
+ static const Word arrayInit = (Word)0x00000000u << 32 |(Word)0x012BD6AAu;
+ static const Word arrayMul1 = (Word)0x369DEA0Fu << 32 |(Word)0x31A53F85u;
+ static const Word arrayMul2 = (Word)0x27BB2EE6u << 32 |(Word)0x87B0B0FDu;
+
+ static const Word mask = (Word)0xB5026F5Au << 32 | (Word)0xA96619E9u;
+ static const Word loMask = ((Word)1u << 31) - 1;
+ static const Word hiMask = ~loMask;
+
+ static Word tempering(Word rnd) {
+ rnd ^= (rnd >> 29) & ((Word)0x55555555u << 32 | (Word)0x55555555u);
+ rnd ^= (rnd << 17) & ((Word)0x71D67FFFu << 32 | (Word)0xEDA60000u);
+ rnd ^= (rnd << 37) & ((Word)0xFFF7EEE0u << 32 | (Word)0x00000000u);
+ rnd ^= (rnd >> 43);
+ return rnd;
}
- return *this;
- }
- /// \brief Returns an unsigned random number
- ///
- /// It returns an unsigned integer random number from the range
- /// \f$ \{0, 1, \dots, 2^{32} - 1\} \f$.
- unsigned long getUnsigned() {
- if (current == state) fillState();
- --current;
- unsigned long rnd = *current;
- rnd ^= (rnd >> 11);
- rnd ^= (rnd << 7) & 0x9D2C5680ul;
- rnd ^= (rnd << 15) & 0xEFC60000ul;
- rnd ^= (rnd >> 18);
- return rnd;
- }
-
- /// \brief Returns a random number
- ///
- /// It returns an integer random number from the range
- /// \f$ \{-2^{31}, \dots, 2^{31} - 1\} \f$.
- long getInt() {
- return (long)getUnsigned();
- }
+ };
+
+ template <typename _Word>
+ class RandomCore {
+ public:
+
+ typedef _Word Word;
+
+ private:
+
+ static const int bits = RandomTraits<Word>::bits;
+
+ static const int length = RandomTraits<Word>::length;
+ static const int shift = RandomTraits<Word>::shift;
+
+ public:
+
+ void initState() {
+ static const Word seedArray[4] = {
+ 0x12345u, 0x23456u, 0x34567u, 0x45678u
+ };
- /// \brief Returns an unsigned integer random number
- ///
- /// It returns an unsigned integer random number from the range
- /// \f$ \{0, 1, \dots, 2^{31} - 1\} \f$.
- long getNatural() {
- return (long)(getUnsigned() >> 1);
- }
+ initState(seedArray, seedArray + 4);
+ }
- /// \brief Returns a random bool
- ///
- /// It returns a random bool.
- bool getBool() {
- return (bool)(getUnsigned() & 1);
- }
-
- /// \brief Returns a real random number
- ///
- /// It returns a real random number from the range
- /// \f$ [0, 1) \f$. The double will have 32 significant bits.
- double getReal() {
- return std::ldexp((double)getUnsigned(), -32);
- }
-
- /// \brief Returns a real random number
- ///
- /// It returns a real random number from the range
- /// \f$ [0, 1) \f$. The double will have 53 significant bits,
- /// but it is slower than the \c getReal().
- double getPrecReal() {
- return std::ldexp((double)(getUnsigned() >> 5), -27) +
- std::ldexp((double)(getUnsigned() >> 6), -53);
- }
-
- /// \brief Returns an unsigned random number from a given range
- ///
- /// It returns an unsigned integer random number from the range
- /// \f$ \{0, 1, \dots, n - 1\} \f$.
- unsigned long getUnsigned(unsigned long n) {
- unsigned long mask = n - 1, rnd;
- mask |= mask >> 1;
- mask |= mask >> 2;
- mask |= mask >> 4;
- mask |= mask >> 8;
- mask |= mask >> 16;
- do rnd = getUnsigned() & mask; while (rnd >= n);
- return rnd;
- }
-
- /// \brief Returns a random number from a given range
- ///
- /// It returns an unsigned integer random number from the range
- /// \f$ \{0, 1, \dots, n - 1\} \f$.
- long getInt(long n) {
- long mask = n - 1, rnd;
- mask |= mask >> 1;
- mask |= mask >> 2;
- mask |= mask >> 4;
- mask |= mask >> 8;
- mask |= mask >> 16;
- do rnd = getUnsigned() & mask; while (rnd >= n);
- return rnd;
- }
+ void initState(Word seed) {
- private:
+ static const Word mul = RandomTraits<Word>::mul;
- void initState(unsigned long seed) {
- static const unsigned long mul = 0x6c078965ul;
+ current = state;
- current = state;
+ Word *curr = state + length - 1;
+ curr[0] = seed; --curr;
+ for (int i = 1; i < length; ++i) {
+ curr[0] = (mul * ( curr[1] ^ (curr[1] >> (bits - 2)) ) + i);
+ --curr;
+ }
+ }
- unsigned long *curr = state + length - 1;
- curr[0] = seed; --curr;
- for (int i = 1; i < length; ++i) {
- curr[0] = (mul * ( curr[1] ^ (curr[1] >> 30) ) + i);
- --curr;
+ template <typename Iterator>
+ void initState(Iterator begin, Iterator end) {
+
+ static const Word init = RandomTraits<Word>::arrayInit;
+ static const Word mul1 = RandomTraits<Word>::arrayMul1;
+ static const Word mul2 = RandomTraits<Word>::arrayMul2;
+
+
+ Word *curr = state + length - 1; --curr;
+ Iterator it = begin; int cnt = 0;
+ int num;
+
+ initState(init);
+
+ num = length > end - begin ? length : end - begin;
+ while (num--) {
+ curr[0] = (curr[0] ^ ((curr[1] ^ (curr[1] >> (bits - 2))) * mul1))
+ + *it + cnt;
+ ++it; ++cnt;
+ if (it == end) {
+ it = begin; cnt = 0;
+ }
+ if (curr == state) {
+ curr = state + length - 1; curr[0] = state[0];
+ }
+ --curr;
+ }
+
+ num = length - 1; cnt = length - (curr - state) - 1;
+ while (num--) {
+ curr[0] = (curr[0] ^ ((curr[1] ^ (curr[1] >> (bits - 2))) * mul2))
+ - cnt;
+ --curr; ++cnt;
+ if (curr == state) {
+ curr = state + length - 1; curr[0] = state[0]; --curr;
+ cnt = 1;
+ }
+ }
+
+ state[length - 1] = (Word)1 << (bits - 1);
}
- }
+
+ void copyState(const RandomCore& other) {
+ std::copy(other.state, other.state + length, state);
+ current = state + (other.current - other.state);
+ }
+
+ Word operator()() {
+ if (current == state) fillState();
+ --current;
+ Word rnd = *current;
+ return RandomTraits<Word>::tempering(rnd);
+ }
+
+ private:
+
- void fillState() {
- static const unsigned long mask[2] = { 0x0ul, 0x9908B0DFul };
- static const unsigned long loMask = (1ul << 31) - 1;
- static const unsigned long hiMask = ~loMask;
+ void fillState() {
+ static const Word mask[2] = { 0x0ul, RandomTraits<Word>::mask };
+ static const Word loMask = RandomTraits<Word>::loMask;
+ static const Word hiMask = RandomTraits<Word>::hiMask;
- current = state + length;
+ current = state + length;
- register unsigned long *curr = state + length - 1;
- register long num;
+ register Word *curr = state + length - 1;
+ register long num;
- num = length - shift;
- while (num--) {
- curr[0] = (((curr[0] & hiMask) | (curr[-1] & loMask)) >> 1) ^
- curr[- shift] ^ mask[curr[-1] & 1ul];
- --curr;
- }
- num = shift - 1;
- while (num--) {
- curr[0] = (((curr[0] & hiMask) | (curr[-1] & loMask)) >> 1) ^
- curr[length - shift] ^ mask[curr[-1] & 1ul];
- --curr;
+ num = length - shift;
+ while (num--) {
+ curr[0] = (((curr[0] & hiMask) | (curr[-1] & loMask)) >> 1) ^
+ curr[- shift] ^ mask[curr[-1] & 1ul];
+ --curr;
+ }
+ num = shift - 1;
+ while (num--) {
+ curr[0] = (((curr[0] & hiMask) | (curr[-1] & loMask)) >> 1) ^
+ curr[length - shift] ^ mask[curr[-1] & 1ul];
+ --curr;
+ }
+ curr[0] = (((curr[0] & hiMask) | (curr[length - 1] & loMask)) >> 1) ^
+ curr[length - shift] ^ mask[curr[length - 1] & 1ul];
+
}
- curr[0] = (((curr[0] & hiMask) | (curr[length - 1] & loMask)) >> 1) ^
- curr[length - shift] ^ mask[curr[length - 1] & 1ul];
- }
- unsigned long *current;
- unsigned long state[length];
+ Word *current;
+ Word state[length];
+
+ };
+
+
+ template <typename Result,
+ int shift = (std::numeric_limits<Result>::digits + 1) / 2>
+ struct Masker {
+ static Result mask(const Result& result) {
+ return Masker<Result, (shift + 1) / 2>::
+ mask((Result)(result | (result >> shift)));
+ }
+ };
- };
+ template <typename Result>
+ struct Masker<Result, 1> {
+ static Result mask(const Result& result) {
+ return (Result)(result | (result >> 1));
+ }
+ };
-#elif WORD_BIT == 64
+ template <typename Result, typename Word,
+ int rest = std::numeric_limits<Result>::digits, int shift = 0,
+ bool last = rest <= std::numeric_limits<Word>::digits>
+ struct IntConversion {
+ static const int bits = std::numeric_limits<Word>::digits;
+
+ static Result convert(RandomCore<Word>& rnd) {
+ return (Result)(rnd() >> (bits - rest)) << shift;
+ }
+
+ };
- /// \ingroup misc
- ///
- /// \brief Mersenne Twister random number generator
- ///
- /// The Mersenne Twister is a twisted generalized feedback
- /// shift-register generator of Matsumoto and Nishimura. The period of
- /// this generator is \f$ 2^{19937} - 1 \f$ and it is equi-distributed in
- /// 311 dimensions. The time performance of this generator is comparable
- /// to the commonly used generators.
- class Random {
+ template <typename Result, typename Word, int rest, int shift>
+ struct IntConversion<Result, Word, rest, shift, false> {
+ static const int bits = std::numeric_limits<Word>::digits;
+
+ static Result convert(RandomCore<Word>& rnd) {
+ return ((Result)rnd() << shift) |
+ IntConversion<Result, Word, rest - bits, shift + bits>::convert(rnd);
+ }
+ };
- static const int length = 312;
- static const int shift = 156;
- public:
+ template <typename Result, typename Word,
+ bool one_word = std::numeric_limits<Word>::digits <
+ std::numeric_limits<Result>::digits>
+ struct Mapping {
+ static Result map(RandomCore<Word>& rnd, const Result& bound) {
+ Word max = (Word)(bound - 1);
+ Result mask = Masker<Result>::mask(bound - 1);
+ Result num;
+ do {
+ num = IntConversion<Result, Word>::convert(rnd) & mask;
+ } while (num > max);
+ return num;
+ }
+ };
- static const unsigned long min = 0ul;
- static const unsigned long max = ~0ul;
-
- /// \brief Constructor
- ///
- /// Constructor with time dependent seeding.
- Random() { initState(std::time(0)); }
+ template <typename Result, typename Word>
+ struct Mapping<Result, Word, false> {
+ static Result map(RandomCore<Word>& rnd, const Result& bound) {
+ Word max = (Word)(bound - 1);
+ Word mask = Masker<Word, (std::numeric_limits<Result>::digits + 1) / 2>
+ ::mask(max);
+ Word num;
+ do {
+ num = rnd() & mask;
+ } while (num > max);
+ return num;
+ }
+ };
- /// \brief Constructor
- ///
- /// Constructor
- Random(unsigned long seed) { initState(seed); }
+ template <typename Result, int exp, bool pos = (exp >= 0)>
+ struct ShiftMultiplier {
+ static const Result multiplier() {
+ Result res = ShiftMultiplier<Result, exp / 2>::multiplier();
+ res *= res;
+ if ((exp & 1) == 1) res *= (Result)2.0;
+ return res;
+ }
+ };
- /// \brief Copy constructor
- ///
- /// Copy constructor. The generated sequence will be identical to
- /// the other sequence.
- Random(const Random& other) {
- std::copy(other.state, other.state + length, state);
- current = state + (other.current - other.state);
- }
+ template <typename Result, int exp>
+ struct ShiftMultiplier<Result, exp, false> {
+ static const Result multiplier() {
+ Result res = ShiftMultiplier<Result, exp / 2>::multiplier();
+ res *= res;
+ if ((exp & 1) == 1) res *= (Result)0.5;
+ return res;
+ }
+ };
- /// \brief Assign operator
- ///
- /// Assign operator. The generated sequence will be identical to
- /// the other sequence.
- Random& operator=(const Random& other) {
- if (&other != this) {
- std::copy(other.state, other.state + length, state);
- current = state + (other.current - other.state);
+ template <typename Result>
+ struct ShiftMultiplier<Result, 0, true> {
+ static const Result multiplier() {
+ return (Result)1.0;
}
- return *this;
- }
+ };
- /// \brief Returns an unsigned random number
- ///
- /// It returns an unsigned integer random number from the range
- /// \f$ \{0, 1, \dots, 2^{64} - 1\} \f$.
- unsigned long getUnsigned() {
- if (current == state) fillState();
- --current;
- unsigned long rnd = *current;
- rnd ^= (rnd >> 29) & 0x5555555555555555ul;
- rnd ^= (rnd << 17) & 0x71D67FFFEDA60000ul;
- rnd ^= (rnd << 37) & 0xFFF7EEE000000000ul;
- rnd ^= (rnd >> 43);
- return rnd;
- }
-
- /// \brief Returns a random number
- ///
- /// It returns an integer random number from the range
- /// \f$ \{-2^{63}, \dots, 2^{63} - 1\} \f$.
- long getInt() {
- return (long)getUnsigned();
- }
+ template <typename Result>
+ struct ShiftMultiplier<Result, -20, true> {
+ static const Result multiplier() {
+ return (Result)(1.0/1048576.0);
+ }
+ };
- /// \brief Returns an unsigned integer random number
- ///
- /// It returns an unsigned integer random number from the range
- /// \f$ \{0, 1, \dots, 2^{63} - 1\} \f$.
- long getNatural() {
- return (long)(getUnsigned() >> 1);
- }
-
- /// \brief Returns a random bool
- ///
- /// It returns a random bool.
- bool getBool() {
- return (bool)(getUnsigned() & 1);
- }
-
- /// \brief Returns a real random number
- ///
- /// It returns a real random number from the range
- /// \f$ [0, 1) \f$.
- double getReal() {
- return std::ldexp((double)(getUnsigned() >> 11), -53);
- }
-
- /// \brief Returns a real random number
- ///
- /// It returns a real random number from the range
- /// \f$ [0, 1) \f$. This function is identical to the \c getReal().
- double getPrecReal() {
- return getReal();
- }
-
- /// \brief Returns an unsigned random number from a given range
- ///
- /// It returns an unsigned integer random number from the range
- /// \f$ \{0, 1, \dots, n - 1\} \f$.
- unsigned long getUnsigned(unsigned long n) {
- unsigned long mask = n - 1, rnd;
- mask |= mask >> 1;
- mask |= mask >> 2;
- mask |= mask >> 4;
- mask |= mask >> 8;
- mask |= mask >> 16;
- mask |= mask >> 32;
- do rnd = getUnsigned() & mask; while (rnd >= n);
- return rnd;
- }
-
- /// \brief Returns a random number from a given range
- ///
- /// It returns an unsigned integer random number from the range
- /// \f$ \{0, 1, \dots, n - 1\} \f$.
- long getInt(long n) {
- long mask = n - 1, rnd;
- mask |= mask >> 1;
- mask |= mask >> 2;
- mask |= mask >> 4;
- mask |= mask >> 8;
- mask |= mask >> 16;
- mask |= mask >> 32;
- do rnd = getUnsigned() & mask; while (rnd >= n);
- return rnd;
- }
+ template <typename Result>
+ struct ShiftMultiplier<Result, -32, true> {
+ static const Result multiplier() {
+ return (Result)(1.0/424967296.0);
+ }
+ };
- private:
+ template <typename Result>
+ struct ShiftMultiplier<Result, -53, true> {
+ static const Result multiplier() {
+ return (Result)(1.0/9007199254740992.0);
+ }
+ };
- void initState(unsigned long seed) {
+ template <typename Result>
+ struct ShiftMultiplier<Result, -64, true> {
+ static const Result multiplier() {
+ return (Result)(1.0/18446744073709551616.0);
+ }
+ };
- static const unsigned long mul = 0x5851F42D4C957F2Dul;
+ template <typename Result, int exp>
+ struct Shifting {
+ static Result shift(const Result& result) {
+ return result * ShiftMultiplier<Result, exp>::multiplier();
+ }
+ };
- current = state;
+ template <typename Result, typename Word,
+ int rest = std::numeric_limits<Result>::digits, int shift = 0,
+ bool last = rest <= std::numeric_limits<Word>::digits>
+ struct RealConversion{
+ static const int bits = std::numeric_limits<Word>::digits;
+
+ static Result convert(RandomCore<Word>& rnd) {
+ return Shifting<Result, - shift - rest>::
+ shift((Result)(rnd() >> (bits - rest)));
+ }
+ };
- unsigned long *curr = state + length - 1;
- curr[0] = seed; --curr;
- for (int i = 1; i < length; ++i) {
- curr[0] = (mul * ( curr[1] ^ (curr[1] >> 62) ) + i);
- --curr;
+ template <typename Result, typename Word, int rest, int shift>
+ struct RealConversion<Result, Word, rest, shift, false> {
+ static const int bits = std::numeric_limits<Word>::digits;
+
+ static Result convert(RandomCore<Word>& rnd) {
+ return Shifting<Result, - shift - bits>::shift((Result)rnd()) +
+ RealConversion<Result, Word, rest-bits, shift + bits>::convert(rnd);
}
- }
-
- void fillState() {
- static const unsigned long mask[2] = { 0x0ul, 0xB5026F5AA96619E9ul };
- static const unsigned long loMask = (1ul << 31) - 1;
- static const unsigned long hiMask = ~loMask;
+ };
- current = state + length;
+ template <typename Result, typename Word>
+ struct Initializer {
- register unsigned long *curr = state + length - 1;
- register int num;
-
- num = length - shift;
- while (num--) {
- curr[0] = (((curr[0] & hiMask) | (curr[-1] & loMask)) >> 1) ^
- curr[- shift] ^ mask[curr[-1] & 1ul];
- --curr;
- }
- num = shift - 1;
- while (num--) {
- curr[0] = (((curr[0] & hiMask) | (curr[-1] & loMask)) >> 1) ^
- curr[length - shift] ^ mask[curr[-1] & 1ul];
- --curr;
+ template <typename Iterator>
+ static void init(RandomCore<Word>& rnd, Iterator begin, Iterator end) {
+ std::vector<Word> ws;
+ for (Iterator it = begin; it != end; ++it) {
+ ws.push_back((Word)*it);
+ }
+ rnd.initState(ws.begin(), ws.end());
}
- curr[0] = (((curr[0] & hiMask) | (curr[length - 1] & loMask)) >> 1) ^
- curr[length - shift] ^ mask[curr[length - 1] & 1ul];
- }
-
- unsigned long *current;
- unsigned long state[length];
-
- };
+ template <typename Iterator>
+ static void init(RandomCore<Word>& rnd, Result seed) {
+ rnd.initState(seed);
+ }
+ };
-#else
+ template <typename Word>
+ struct BoolConversion {
+ static bool convert(RandomCore<Word>& rnd) {
+ return (rnd() & 1) == 1;
+ }
+ };
+
+ }
/// \ingroup misc
///
/// \brief Mersenne Twister random number generator
///
/// The Mersenne Twister is a twisted generalized feedback
- /// shift-register generator of Matsumoto and Nishimura. There is
- /// two different implementation in the Lemon library, one for
- /// 32-bit processors and one for 64-bit processors. The period of
- /// the generated sequence is \f$ 2^{19937} - 1 \f$, the generated
- /// sequence of 32-bit random numbers is equi-distributed in 623
- /// dimensions. The time performance of this generator is comparable
- /// to the commonly used generators.
+ /// shift-register generator of Matsumoto and Nishimura. The period
+ /// of this generator is \f$ 2^{19937} - 1 \f$ and it is
+ /// equi-distributed in 623 dimensions for 32-bit numbers. The time
+ /// performance of this generator is comparable to the commonly used
+ /// generators.
+ ///
+ /// This implementation is specialized for both 32-bit and 64-bit
+ /// architectures. The generators differ sligthly in the
+ /// initialization and generation phase so they produce two
+ /// completly different sequences.
+ ///
+ /// The generator gives back random numbers of serveral types. To
+ /// get a random number from a range of a floating point type you
+ /// can use one form of the \c operator(). If you want to get random
+ /// number from a the {0, 1, ..., n-1} integer range use the \c
+ /// operator[]. And to get random number from the whole range of an
+ /// integer type you can use the \c integer() or \c uinteger()
+ /// functions. After all you can get random bool with equal chance
+ /// or given probability with the \c boolean() member function.
+ ///
+ ///\code
+ /// int a = rnd[100000]; // 0..99999
+ /// int b = rnd.uinteger<int>(); // 0 .. 2^31 - 1
+ /// int c = rnd.integer<int>(); // - 2^31 .. 2^31 - 1
+ /// double d = rnd(); // [0.0, 1.0)
+ /// double e = rnd(100.0); // [0.0, 100.0)
+ /// double f = rnd(1.0, 2.0); // [1.0, 2.0)
+ /// bool g = rnd.boolean(); // P(g = true) = 0.5
+ /// bool h = rnd.boolean(0.8); // P(h = true) = 0.8
+ ///\endcode
+ ///
+ /// The lemon provides a global instance of the random number generator
+ /// which name is \c rnd. Usually it is a good programming convenience
+ /// to use this global generator to get random numbers.
+ ///
+ /// \author Balazs Dezso
class Random {
+ private:
+
+#if WORD_BIT == 32
+ typedef unsigned int Word;
+#elif WORD_BIT == 64
+ typedef unsigned long Word;
+#endif
+
+ _random_bits::RandomCore<Word> core;
+
public:
- static const unsigned long min = 0ul;
- static const unsigned long max = ~0ul;
-
/// \brief Constructor
///
- /// Constructor with time dependent seeding.
- Random() {}
+ /// Constructor with constant seeding.
+ Random() { core.initState(); }
/// \brief Constructor
///
- /// Constructor
- Random(unsigned long seed) {}
+ /// Constructor with seed. The current number type will be converted
+ /// to the architecture word type.
+ template <typename Number>
+ Random(Number seed) {
+ _random_bits::Initializer<Number, Word>::init(core, seed);
+ }
+
+ /// \brief Constructor
+ ///
+ /// Constructor with array seeding. The given range should contain
+ /// any number type and the numbers will be converted to the
+ /// architecture word type.
+ template <typename Iterator>
+ Random(Iterator begin, Iterator end) {
+ typedef typename std::iterator_traits<Iterator>::value_type Number;
+ _random_bits::Initializer<Number, Word>::init(core, begin, end);
+ }
/// \brief Copy constructor
///
/// Copy constructor. The generated sequence will be identical to
/// the other sequence.
- Random(const Random& other) {}
+ Random(const Random& other) {
+ core.copyState(other.core);
+ }
/// \brief Assign operator
///
/// Assign operator. The generated sequence will be identical to
/// the other sequence.
- Random& operator=(const Random& other) { return *this; }
+ Random& operator=(const Random& other) {
+ if (&other != this) {
+ core.copyState(other.core);
+ }
+ return *this;
+ }
- /// \brief Returns an unsigned random number
+ /// \brief Returns a random real number
///
- /// It returns an unsigned integer random number from the range
- /// \f$ \{0, 1, \dots, 2^{64} - 1\} \f$ for 64-bit processors and from
- /// \f$ \{0, 1, \dots, 2^{32} - 1\} \f$ for 32-bit processors.
- unsigned long getUnsigned() { return 0ul; }
+ /// It returns a random real number from the range [0, 1). The default
+ /// result type of this function is double.
+ template <typename Number>
+ Number operator()() {
+ return _random_bits::RealConversion<Number, Word>::convert(core);
+ }
- /// \brief Returns a random number
- ///
- /// It returns an integer random number from the range
- /// \f$ \{-2^{63}, \dots, 2^{63} - 1\} \f$ for 64-bit processors and from
- /// \f$ \{-2^{31}, \dots, 2^{31} - 1\} \f$ for 32-bit processors.
- long getInt() { return 0l; }
-
- /// \brief Returns an unsigned integer random number
+ double operator()() {
+ return operator()<double>();
+ }
+
+ /// \brief Returns a random real number
///
- /// It returns an unsigned integer random number from the range
- /// \f$ \{0, 1, \dots, 2^{63} - 1\} \f$ for 64-bit processors and
- /// from \f$ \{0, 1, \dots, 2^{31} - 1\} \f$ for 32-bit processors.
- long getNatural() { return 0l; }
+ /// It returns a random real number from the range [0, b).
+ template <typename Number>
+ Number operator()(Number b) {
+ return operator()<Number>() * b;
+ }
- /// \brief Returns a random bool
+ /// \brief Returns a random real number
///
- /// It returns a random bool.
- bool getBool() { return false; }
+ /// It returns a random real number from the range [a, b).
+ template <typename Number>
+ Number operator()(Number a, Number b) {
+ return operator()<Number>() * (b - a) + a;
+ }
- /// \brief Returns a real random number
+ /// \brief Returns a random integer from a range
///
- /// It returns a real random number from the range
- /// \f$ [0, 1) \f$. For 32-bit processors the generated random
- /// number will just have 32 significant bits.
- double getReal() { return 0.0; }
+ /// It returns a random integer from the range {0, 1, ..., bound - 1}.
+ template <typename Number>
+ Number operator[](const Number& bound) {
+ return _random_bits::Mapping<Number, Word>::map(core, bound);
+ }
- /// \brief Returns a real random number
+ /// \brief Returns a random non-negative integer
///
- /// It returns a real random number from the range
- /// \f$ [0, 1) \f$. This function returns random numbers with 53
- /// significant bits for 32-bit processors. For 64-bit processors
- /// it is identical to the \c getReal().
- double getPrecReal() { return 0.0; }
+ /// It returns a random non-negative integer uniformly from the
+ /// whole range of the current \c Number type. The default result
+ /// type of this function is unsigned int.
+ template <typename Number>
+ Number uinteger() {
+ return _random_bits::IntConversion<Number, Word>::convert(core);
+ }
+
+ unsigned int uinteger() {
+ return uinteger<unsigned int>();
+ }
- /// \brief Returns an unsigned random number from a given range
+ /// \brief Returns a random integer
///
- /// It returns an unsigned integer random number from the range
- /// \f$ \{0, 1, \dots, n - 1\} \f$.
- unsigned long getUnsigned(unsigned long n) { return 0; }
+ /// It returns a random integer uniformly from the whole range of
+ /// the current \c Number type. The default result type of this
+ /// function is int.
+ template <typename Number>
+ Number integer() {
+ static const int nb = std::numeric_limits<Number>::digits +
+ (std::numeric_limits<Number>::is_signed ? 1 : 0);
+ return _random_bits::IntConversion<Number, Word, nb>::convert(core);
+ }
- /// \brief Returns a random number from a given range
+ int integer() {
+ return integer<int>();
+ }
+
+ /// \brief Returns a random bool
///
- /// It returns an unsigned integer random number from the range
- /// \f$ \{0, 1, \dots, n - 1\} \f$.
- long getInt(long n) { return 0; }
+ /// It returns a random bool
+ bool boolean() {
+ return _random_bits::BoolConversion<Word>::convert(core);
+ }
+ /// \brief Returns a random bool
+ ///
+ /// It returns a random bool with given probability of true result
+ bool boolean(double p) {
+ return operator()() < p;
+ }
+
};
-#endif
/// \brief Global random number generator instance
///
Modified: hugo/trunk/lemon/simann.h
==============================================================================
--- hugo/trunk/lemon/simann.h (original)
+++ hugo/trunk/lemon/simann.h Sat Oct 14 17:26:05 2006
@@ -257,7 +257,7 @@
/// \brief Decides whether to accept the current solution or not.
bool accept() {
double cost_diff = simann->getCurrCost() - simann->getPrevCost();
- return (rnd.getReal() <= exp(-(cost_diff / temp)));
+ return (rnd() <= exp(-(cost_diff / temp)));
}
/// \brief Destructor.
virtual ~SimpleController() {}
@@ -365,7 +365,7 @@
}
else {
double cost_diff = simann->getCurrCost() - simann->getPrevCost();
- return (rnd.getReal() <= exp(-(cost_diff / temp)));
+ return (rnd() <= exp(-(cost_diff / temp)));
}
}
/// \brief Destructor.
Modified: hugo/trunk/test/all_pairs_shortest_path_test.cc
==============================================================================
--- hugo/trunk/test/all_pairs_shortest_path_test.cc (original)
+++ hugo/trunk/test/all_pairs_shortest_path_test.cc Sat Oct 14 17:26:05 2006
@@ -36,19 +36,18 @@
using namespace std;
int main(int argc, const char *argv[]) {
- srand(time(0));
typedef SmartGraph Graph;
typedef Graph::Node Node;
typedef Graph::Edge Edge;
typedef Graph::NodeIt NodeIt;
typedef Graph::EdgeIt EdgeIt;
- typedef Graph::EdgeMap<double> LengthMap;
- typedef Graph::NodeMap<double> DistMap;
+ typedef Graph::EdgeMap<int> LengthMap;
+ typedef Graph::NodeMap<int> DistMap;
const int n = argc > 1 ? atoi(argv[1]) : 20;
const int e = argc > 2 ? atoi(argv[2]) : (int)(n * log((double)n));
- const double m = argc > 3 ? (double)atoi(argv[3]) : 100.0;
+ const int m = argc > 3 ? atoi(argv[3]) : 100;
Graph graph;
LengthMap length(graph);
@@ -58,15 +57,14 @@
for (int i = 0; i < n; ++i) {
Node node = graph.addNode();
nodes.push_back(node);
- shift[node] = m * (double)rand() / (RAND_MAX + 1.0);
+ shift[node] = rnd[m];
}
for (int i = 0; i < e; ++i) {
- int s = (int)(n * (double)rand() / (RAND_MAX + 1.0));
- int t = (int)(n * (double)rand() / (RAND_MAX + 1.0));
- double c = m * (double)rand() / (RAND_MAX + 1.0);
+ int s = rnd[n];
+ int t = rnd[n];
Edge edge = graph.addEdge(nodes[s], nodes[t]);
- length[edge] = c - shift[nodes[s]] + shift[nodes[t]];
+ length[edge] = rnd[m] - shift[nodes[s]] + shift[nodes[t]];
}
Johnson<Graph, LengthMap> johnson(graph, length);
@@ -76,8 +74,8 @@
cout << "Johnson: " << timer << endl;
}
- typedef FibHeap<Node, double, Graph::NodeMap<int> > DoubleFibHeap;
- Johnson<Graph, LengthMap>::DefStandardHeap<DoubleFibHeap>
+ typedef FibHeap<Node, int, Graph::NodeMap<int> > IntFibHeap;
+ Johnson<Graph, LengthMap>::DefStandardHeap<IntFibHeap>
::Create fibJohnson(graph, length);
{
Timer timer;
Modified: hugo/trunk/test/arborescence_test.cc
==============================================================================
--- hugo/trunk/test/arborescence_test.cc (original)
+++ hugo/trunk/test/arborescence_test.cc Sat Oct 14 17:26:05 2006
@@ -47,7 +47,6 @@
int main() {
- srand(time(0));
typedef SmartGraph Graph;
GRAPH_TYPEDEFS(Graph);
Modified: hugo/trunk/test/graph_utils_test.cc
==============================================================================
--- hugo/trunk/test/graph_utils_test.cc (original)
+++ hugo/trunk/test/graph_utils_test.cc Sat Oct 14 17:26:05 2006
@@ -116,7 +116,7 @@
std::vector<ListGraph::Edge> edges(edgeNum);
for (int i = 0; i < edgeNum; ++i) {
edges[i] =
- graph.addEdge(nodes[urandom(nodeNum)], nodes[urandom(nodeNum)]);
+ graph.addEdge(nodes[rnd[nodeNum]], nodes[rnd[nodeNum]]);
}
for (int i = 0; i < nodeNum; ++i) {
check(inDeg[nodes[i]] == countInEdges(graph, nodes[i]),
Modified: hugo/trunk/test/graph_utils_test.h
==============================================================================
--- hugo/trunk/test/graph_utils_test.h (original)
+++ hugo/trunk/test/graph_utils_test.h Sat Oct 14 17:26:05 2006
@@ -56,8 +56,8 @@
DescriptorMap<Graph, Node> nodes(graph);
typename DescriptorMap<Graph, Node>::InverseMap invNodes(nodes);
for (int i = 0; i < 100; ++i) {
- int src = rnd.getInt(invNodes.size());
- int trg = rnd.getInt(invNodes.size());
+ int src = rnd[invNodes.size()];
+ int trg = rnd[invNodes.size()];
graph.addEdge(invNodes[src], invNodes[trg]);
}
typename Graph::template EdgeMap<bool> found(graph, false);
Modified: hugo/trunk/test/heap_test.h
==============================================================================
--- hugo/trunk/test/heap_test.h (original)
+++ hugo/trunk/test/heap_test.h Sat Oct 14 17:26:05 2006
@@ -45,7 +45,7 @@
std::vector<int> v(n);
for (int i = 0; i < n; ++i) {
- v[i] = rnd.getInt(1000);
+ v[i] = rnd[1000];
heap.push(i, v[i]);
}
std::sort(v.begin(), v.end());
@@ -65,11 +65,11 @@
std::vector<int> v(n);
for (int i = 0; i < n; ++i) {
- v[i] = rnd.getInt(1000);
+ v[i] = rnd[1000];
heap.push(i, v[i]);
}
for (int i = 0; i < n; ++i) {
- v[i] += rnd.getInt(1000);
+ v[i] += rnd[1000];
heap.increase(i, v[i]);
}
std::sort(v.begin(), v.end());
Modified: hugo/trunk/test/matrix_maps_test.cc
==============================================================================
--- hugo/trunk/test/matrix_maps_test.cc (original)
+++ hugo/trunk/test/matrix_maps_test.cc Sat Oct 14 17:26:05 2006
@@ -67,7 +67,7 @@
}
for (Graph::NodeIt it(graph); it != INVALID; ++it) {
for (Graph::NodeIt jt(graph); jt != INVALID; ++jt) {
- int val = urandom(100);
+ int val = rnd[100];
matrix.set(it, jt, val);
check(matrix(it, jt) == val, "Wrong assign");
check(matrix(it, jt) == matrixRowMap(matrix, it)[jt], "Wrong rowMap");
@@ -108,7 +108,7 @@
}
for (Graph::NodeIt it(graph); it != INVALID; ++it) {
for (Graph::NodeIt jt(graph); jt != INVALID; ++jt) {
- int val = urandom(100);
+ int val = rnd[100];
matrix.set(it, jt, val);
check(matrix(it, jt) == val, "Wrong assign");
check(matrix(jt, it) == val, "Wrong assign");
@@ -154,7 +154,7 @@
}
for (Graph::NodeIt it(graph1); it != INVALID; ++it) {
for (Graph::EdgeIt jt(graph2); jt != INVALID; ++jt) {
- int val = urandom(100);
+ int val = rnd[100];
matrix.set(it, jt, val);
check(matrix(it, jt) == val, "Wrong assign");
check(matrix(it, jt) == matrixRowMap(matrix, it)[jt], "Wrong rowMap");
@@ -198,7 +198,7 @@
}
for (Graph::NodeIt it(graph); it != INVALID; ++it) {
for (Graph::NodeIt jt(graph); jt != INVALID; ++jt) {
- int val = urandom(100);
+ int val = rnd[100];
matrix.set(it, jt, val);
check(matrix(it, jt) == val, "Wrong assign");
check(matrix(it, jt) == matrixRowMap(matrix, it)[jt], "Wrong rowMap");
Modified: hugo/trunk/test/radix_sort_test.cc
==============================================================================
--- hugo/trunk/test/radix_sort_test.cc (original)
+++ hugo/trunk/test/radix_sort_test.cc Sat Oct 14 17:26:05 2006
@@ -37,7 +37,7 @@
int n = 10000;
vector<int> data1(n), data2(n);
for (int i = 0; i < n; ++i) {
- data1[i] = data2[i] = (int)(1000 * (rand() / (RAND_MAX + 1.0))) - 500;
+ data1[i] = data2[i] = rnd[1000] - 500;
}
radixSort(data1.begin(), data1.end());
sort(data2.begin(), data2.end());
@@ -48,7 +48,7 @@
int n = 10000;
vector<unsigned char> data1(n), data2(n);
for (int i = 0; i < n; ++i) {
- data1[i] = data2[i] = (int)(200 * (rand() / (RAND_MAX + 1.0)));
+ data1[i] = data2[i] = rnd[(unsigned char)200];
}
radixSort(data1.begin(), data1.end());
sort(data2.begin(), data2.end());
@@ -64,7 +64,7 @@
int n = 10000;
vector<int> data1(n), data2(n);
for (int i = 0; i < n; ++i) {
- data1[i] = data2[i] = (int)(1000 * (rand() / (RAND_MAX + 1.0))) - 500;
+ data1[i] = data2[i] = rnd[1000] - 500;
}
counterSort(data1.begin(), data1.end());
sort(data2.begin(), data2.end());
@@ -75,7 +75,7 @@
int n = 10000;
vector<unsigned char> data1(n), data2(n);
for (int i = 0; i < n; ++i) {
- data1[i] = data2[i] = (int)(200 * (rand() / (RAND_MAX + 1.0)));
+ data1[i] = data2[i] = rnd[(unsigned char)200];
}
counterSort(data1.begin(), data1.end());
sort(data2.begin(), data2.end());
@@ -106,8 +106,8 @@
}
vector<Edge> edges;
for (int i = 0; i < e; ++i) {
- int s = (int)(n * (double)rand() / (RAND_MAX + 1.0));
- int t = (int)(n * (double)rand() / (RAND_MAX + 1.0));
+ int s = rnd[n];
+ int t = rnd[n];
edges.push_back(graph.addEdge(nodes[s], nodes[t]));
}
@@ -145,8 +145,8 @@
}
vector<Edge> edges;
for (int i = 0; i < e; ++i) {
- int s = (int)(n * (double)rand() / (RAND_MAX + 1.0));
- int t = (int)(n * (double)rand() / (RAND_MAX + 1.0));
+ int s = rnd[n];
+ int t = rnd[n];
edges.push_back(graph.addEdge(nodes[s], nodes[t]));
}
Modified: hugo/trunk/test/simann_test.cc
==============================================================================
--- hugo/trunk/test/simann_test.cc (original)
+++ hugo/trunk/test/simann_test.cc Sat Oct 14 17:26:05 2006
@@ -23,10 +23,10 @@
class MyEntity : public EntityBase {
public:
double d, prev_d;
- MyEntity() : d(100000.0) { srand48(time(0)); }
+ MyEntity() : d(100000.0) {}
double mutate() {
prev_d = d;
- if (drand48() < 0.8) { d += 1.0; }
+ if (rnd.boolean(0.8)) { d += 1.0; }
else { d -= 1.0; }
return d;
}
Modified: hugo/trunk/test/test_tools.h
==============================================================================
--- hugo/trunk/test/test_tools.h (original)
+++ hugo/trunk/test/test_tools.h Sat Oct 14 17:26:05 2006
@@ -174,12 +174,8 @@
n.chords.push_back(G.addEdge(n.outer[i],n.inner[i]));
n.outcir.push_back(G.addEdge(n.outer[i],n.outer[(i+1)%5]));
n.incir.push_back(G.addEdge(n.inner[i],n.inner[(i+2)%5]));
- }
+ }
return n;
}
-int urandom(int n) {
- return rnd.getInt(n);
-}
-
#endif
More information about the Lemon-commits
mailing list