reverted back to separate random engine and distribution parameters.

7 files changed, 31 insertions, 30 deletions

diff --git a/examples/birthday.c b/examples/birthday.c
index bf807e67..8b6abd77 100644
--- a/examples/birthday.c
+++ b/examples/birthday.c
@@ -38,9 +38,9 @@ void distribution(void)
     const size_t N = 1ull << 28, M = 1ull << 9; // 1ull << 10;

     cmap_x map = cmap_x_with_capacity(M);

     clock_t now = clock();

-    crand_uniform_i32_t dist = crand_uniform_i32_init(rng, 0, M);

+    crand_uniform_i32_t dist = crand_uniform_i32_init(0, M);

     for (size_t i = 0; i < N; ++i) {

-        ++cmap_x_emplace(&map, crand_uniform_i32(&dist), 0).item->value;

+        ++cmap_x_emplace(&map, crand_uniform_i32(&rng, &dist), 0).item->value;

     }

     float diff = (float) (clock() - now) / CLOCKS_PER_SEC;

 

diff --git a/examples/ex_gaussian.c b/examples/ex_gaussian.c
index d2da77d9..cd44e78a 100644
--- a/examples/ex_gaussian.c
+++ b/examples/ex_gaussian.c
@@ -26,12 +26,12 @@ int main()
     // Setup random engine with normal distribution.

     uint64_t seed = time(NULL);    

     crand_rng64_t rng = crand_rng64_init(seed);

-    crand_normal_f64_t dist = crand_normal_f64_init(rng, Mean, StdDev);

+    crand_normal_f64_t dist = crand_normal_f64_init(Mean, StdDev);

     

     // Create histogram map

     cmap_i mhist = cmap_ini;

     for (size_t i = 0; i < N; ++i) {

-        int index = round( crand_normal_f64(&dist) );

+        int index = round( crand_normal_f64(&rng, &dist) );

         cmap_i_emplace(&mhist, index, 0).item->value += 1;

     }

 

diff --git a/examples/list.c b/examples/list.c
index 24dfc82f..dd8bba2f 100644
--- a/examples/list.c
+++ b/examples/list.c
@@ -8,10 +8,10 @@ int main() {
     int k, n = 100000;

     clist_fx list = clist_ini;

     crand_rng64_t eng = crand_rng64_init(time(NULL));

-    crand_uniform_f64_t dist = crand_uniform_f64_init(eng, 0.0f, n);

+    crand_uniform_f64_t dist = crand_uniform_f64_init(0.0f, n);

     

     for (int i = 0; i < 100000; ++i)

-        clist_fx_push_back(&list, crand_uniform_f64(&dist));

+        clist_fx_push_back(&list, crand_uniform_f64(&eng, &dist));

     k = 0; c_foreach (i, clist_fx, list)

         if (++k <= 10) printf("%8d: %10f\n", k, i.item->value); else break;

 

diff --git a/examples/priority.c b/examples/priority.c
index 82e78621..e857761c 100644
--- a/examples/priority.c
+++ b/examples/priority.c
@@ -12,18 +12,18 @@ declare_cpqueue(i, cvec_i, >); // min-heap (increasing values)
 int main() {

     size_t N = 10000000;

     crand_rng64_t pcg = crand_rng64_init(time(NULL));

-    crand_uniform_i64_t dist = crand_uniform_i64_init(pcg, 0, N * 10);

+    crand_uniform_i64_t dist = crand_uniform_i64_init(0, N * 10);

     cpqueue_i heap = cpqueue_i_init();

 

     // Push ten million random numbers to priority queue

     for (int i=0; i<N; ++i)

-        cpqueue_i_push(&heap, crand_uniform_i64(&dist));

+        cpqueue_i_push(&heap, crand_uniform_i64(&pcg, &dist));

 

     // push some negative numbers too.

     c_push(&heap, cpqueue_i, c_items(-231, -32, -873, -4, -343));

 

     for (int i=0; i<N; ++i)

-        cpqueue_i_push(&heap, crand_uniform_i64(&dist));

+        cpqueue_i_push(&heap, crand_uniform_i64(&pcg, &dist));

 

 

     // Extract the hundred smallest.

diff --git a/examples/queue.c b/examples/queue.c
index 15897f38..25aefd09 100644
--- a/examples/queue.c
+++ b/examples/queue.c
@@ -8,18 +8,19 @@ declare_cqueue(i, clist_i); // min-heap (increasing values)
 int main() {

     int n = 10000000;

     crand_uniform_i32_t dist;

-    dist = crand_uniform_i32_init(crand_rng32_init(1234), 0, n);

+    crand_rng32_t rng = crand_rng32_init(1234);

+    dist = crand_uniform_i32_init(0, n);

 

     cqueue_i queue = cqueue_i_init();

 

     // Push ten million random numbers onto the queue.

     for (int i=0; i<n; ++i)

-        cqueue_i_push(&queue, crand_uniform_i32(&dist));

+        cqueue_i_push(&queue, crand_uniform_i32(&rng, &dist));

     

     // Push or pop on the queue ten million times

     printf("%d\n", n);

     for (int i=n; i>0; --i) {

-        int r = crand_uniform_i32(&dist);

+        int r = crand_uniform_i32(&rng, &dist);

         if (r & 1)

             ++n, cqueue_i_push(&queue, r);

         else

diff --git a/examples/random.c b/examples/random.c
index 16632373..b81f1826 100644
--- a/examples/random.c
+++ b/examples/random.c
@@ -13,47 +13,47 @@ int main()
     uint64_t seed = time(NULL);

     crand_rng32_t pcg = crand_rng32_init(seed);

     uint32_t range = crand_i32(&pcg) & ((1u << 28) - 1);

-    crand_uniform_i32_t dist0 = crand_uniform_i32_init(pcg, 0, range);

+    crand_uniform_i32_t dist0 = crand_uniform_i32_init(0, range);

 

     printf("32 uniform: %u\n", dist0.range);

     double fsum = 0;

     before = clock();

     for (size_t i = 0; i < N; ++i) {

-        fsum += (double) crand_uniform_i32(&dist0) / dist0.range;

+        fsum += (double) crand_uniform_i32(&pcg, &dist0) / dist0.range;

     }

     difference = clock() - before;

     printf("%zu %f: %f secs\n", N, fsum / N, (float) difference / CLOCKS_PER_SEC);

 

     pcg = crand_rng32_init(seed);

-    dist0 = crand_uniform_i32_init(pcg, 0, range);

+    dist0 = crand_uniform_i32_init(0, range);

     puts("32 unbiased");

     fsum = 0;

     before = clock();

     for (size_t i = 0; i < N; ++i) {

-        fsum += (double) crand_unbiased_i32(&dist0) / dist0.range;

+        fsum += (double) crand_unbiased_i32(&pcg, &dist0) / dist0.range;

     }

     difference = clock() - before;

     printf("%zu %f: %f secs\n", N, fsum / N, (float) difference / CLOCKS_PER_SEC);

 

     puts("64 uniform");

     crand_rng64_t stc = crand_rng64_init(seed);

-    crand_uniform_i64_t dist1 = crand_uniform_i64_init(stc, 0, N);

+    crand_uniform_i64_t dist1 = crand_uniform_i64_init(0, N);

     sum = 0;

     before = clock();    

     for (size_t i = 0; i < N; ++i) {

-        sum += crand_uniform_i64(&dist1);

+        sum += crand_uniform_i64(&stc, &dist1);

     }

     difference = clock() - before;

     printf("%zu %f: %f secs\n", N, (double) sum / N, (float) difference / CLOCKS_PER_SEC);

 

 

     puts("normal distribution");

-    crand_normal_f64_t dist2 = crand_normal_f64_init(stc, R / 2.0, R / 6.0);

+    crand_normal_f64_t dist2 = crand_normal_f64_init(R / 2.0, R / 6.0);

     size_t N2 = 10000000;

     int hist[R] = {0};

     sum = 0;

     for (size_t i = 0; i < N2; ++i) {

-        int n = (int) (crand_normal_f64(&dist2) + 0.5);

+        int n = (int) (crand_normal_f64(&stc, &dist2) + 0.5);

         sum += n;

         if (n >= 0 && n < R) ++hist[n];

     }

diff --git a/examples/rngtest.c b/examples/rngtest.c
index 6aa783e2..dbe272c0 100644
--- a/examples/rngtest.c
+++ b/examples/rngtest.c
@@ -14,21 +14,21 @@ int main(void)
     uint64_t v;

     

     crand_rng64_t stc = crand_rng64_init(time(NULL));

-    crand_uniform_i64_t idist = crand_uniform_i64_init(stc, 10, 20);

-    crand_uniform_f64_t fdist = crand_uniform_f64_init(stc, 10, 20);

+    crand_uniform_i64_t idist = crand_uniform_i64_init(10, 20);

+    crand_uniform_f64_t fdist = crand_uniform_f64_init(10, 20);

 

-    for (int i=0; i<30; ++i) printf("%02zd ", crand_uniform_i64(&idist)); 

+    for (int i=0; i<30; ++i) printf("%02zd ", crand_uniform_i64(&stc, &idist)); 

     puts("");

 

     crand_rng32_t pcg = crand_rng32_init(time(NULL));

-    crand_uniform_i32_t i32dist = crand_uniform_i32_init(pcg, 10, 20);

-    crand_uniform_f32_t f32dist = crand_uniform_f32_init(pcg, 10, 20);

+    crand_uniform_i32_t i32dist = crand_uniform_i32_init(10, 20);

+    crand_uniform_f32_t f32dist = crand_uniform_f32_init(10, 20);

 

     before = clock(); \

     v = 0;

     for (size_t i=0; i<NN; i++) {

         //v += crand_i32(&pcg);

-        v += crand_uniform_i32(&i32dist);

+        v += crand_uniform_i32(&pcg, &i32dist);

     }

     difference = clock() - before;

     printf("pcg32: %.02f, %zu\n", (float) difference / CLOCKS_PER_SEC, v);

@@ -37,19 +37,19 @@ int main(void)
     v = 0;

     for (size_t i=0; i<NN; i++) {

         //v += crand_i64(&stc) & 0xffffffff;

-        v += crand_uniform_i64(&idist);

+        v += crand_uniform_i64(&stc, &idist);

     }

     difference = clock() - before;

     printf("stc64: %.02f, %zu\n", (float) difference / CLOCKS_PER_SEC, v);

 

     

-    for (int i=0; i<8; ++i) printf("%d ", crand_uniform_i32(&i32dist));

+    for (int i=0; i<8; ++i) printf("%d ", crand_uniform_i32(&pcg, &i32dist));

     puts("");

 

     

-    for (int i=0; i<8; ++i) printf("%f ", crand_uniform_f32(&f32dist));

+    for (int i=0; i<8; ++i) printf("%f ", crand_uniform_f32(&pcg, &f32dist));

     puts("");

     

-    for (int i=0; i<8; ++i) printf("%f ", crand_uniform_f64(&fdist));

+    for (int i=0; i<8; ++i) printf("%f ", crand_uniform_f64(&stc, &fdist));

     puts("");

 }
\ No newline at end of file