Renamed files cvec_pq.h --> cpqueue.h and crand.h --> crandom.h

12 files changed, 102 insertions, 102 deletions

diff --git a/README.md b/README.md
index 52ce7e99..26149a44 100644
--- a/README.md
+++ b/README.md
@@ -12,9 +12,9 @@ An elegant, fully typesafe, generic, customizable, user-friendly, consistent, an
 - **stc/cset.h** - A generic **unordered set** implemented in tandem with *unordered map*

 - **stc/cstr.h** - Compact and powerful **string** class.

 - **stc/cvec.h** - Dynamic generic **vector** class, works well as a **stack**.

-- **stc/cvec_pq.h** - Priority queue adapter for **cvec.h**, as a **heap**.

+- **stc/cpqueue.h** - Priority queue adapter for **cvec.h**, as a **heap**.

 - **stc/copt.h** - Implementation of a **getopt_long()**-like function, *copt_get()*, to parse command line arguments.

-- **stc/crand.h** - A few very efficent modern random number generators *pcg32* and my own *64-bit PRNG* inspired by *sfc64*.

+- **stc/crandom.h** - A few very efficent modern random number generators *pcg32* and my own *64-bit PRNG* inspired by *sfc64*.

 - **stc/cdefs.h** - A common include file with some general definitions.

 

 The usage of the containers is vert similar to the C++ standard containers, so it should be easy if you are familiar with them.

@@ -254,17 +254,17 @@ int main() {
 #include <stdio.h>

 #include <time.h>

 #include <stc/clist.h>

-#include <stc/crand.h>

+#include <stc/crandom.h>

 declare_clist(fx, double);

 

 int main() {

     clist_fx list = clist_init;

-    crand_eng64_t eng = crand_eng64_init(time(NULL));

-    crand_uniform_f64_t dist = crand_uniform_f64_init(100.0, 1000.0);

+    crandom_eng64_t eng = crandom_eng64_init(time(NULL));

+    crandom_uniform_f64_t dist = crandom_uniform_f64_init(100.0, 1000.0);

     int k;

     

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

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

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

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

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

 

diff --git a/examples/benchmark.c b/examples/benchmark.c
index 07219ec2..7b707260 100644
--- a/examples/benchmark.c
+++ b/examples/benchmark.c
@@ -1,4 +1,4 @@
-#include <stc/crand.h>

+#include <stc/crandom.h>

 #include <stc/cstr.h>

 #include <stc/cmap.h>

 #include "others/khash.h"

@@ -26,9 +26,9 @@ KHASH_MAP_INIT_INT64(ii, uint64_t)
 size_t seed;

 static const float max_load_factor = 0.77f;

 

-crand_eng64_t rng;

-#define SEED(s) rng = crand_eng64_init(seed)

-#define RAND(N) (crand_gen_i64(&rng) & ((1 << N) - 1))

+crandom_eng64_t rng;

+#define SEED(s) rng = crandom_eng64_init(seed)

+#define RAND(N) (crandom_gen_i64(&rng) & ((1 << N) - 1))

 

 

 #define CMAP_SETUP(tag, Key, Value) cmap_##tag map = cmap_init \

diff --git a/examples/geek7.c b/examples/geek7.c
index 58fadcae..9a60c0a9 100644
--- a/examples/geek7.c
+++ b/examples/geek7.c
@@ -24,7 +24,7 @@ After inserting all the elements excluding the ones which are to be deleted, Pop
 #include <stdio.h>

 #include <stc/clist.h>

 #include <stc/cmap.h>

-#include <stc/cvec_pq.h>

+#include <stc/cpqueue.h>

 

 declare_cmap(ii, int, int);

 declare_cvec(i, int);

diff --git a/examples/heap.c b/examples/heap.c
index 72232d58..58895115 100644
--- a/examples/heap.c
+++ b/examples/heap.c
@@ -1,7 +1,7 @@
 #include <stdio.h>

 #include <time.h>

-#include <stc/crand.h>

-#include <stc/cvec_pq.h>

+#include <stc/crandom.h>

+#include <stc/cpqueue.h>

 

 declare_cvec(f, float);

 declare_cvec_pqueue(f, >);

@@ -9,12 +9,12 @@ declare_cvec_pqueue(f, >);
 int main()

 {

     uint32_t seed = time(NULL);

-    crand_eng32_t pcg = crand_eng32_init(seed);

+    crandom_eng32_t pcg = crandom_eng32_init(seed);

     int N = 30000000, M = 100;

     cvec_f vec = cvec_init;

     clock_t start = clock();

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

-        cvec_f_push_back(&vec, crand_gen_i32(&pcg));

+        cvec_f_push_back(&vec, crandom_gen_i32(&pcg));

     cvec_f_pqueue_build(&vec);

     printf("Built priority queue: %f secs\n", (clock() - start) / (float) CLOCKS_PER_SEC);

 

@@ -25,10 +25,10 @@ int main()
         cvec_f_pqueue_pop(&vec);

     printf("\n\npopped PQ: %f secs\n", (clock() - start) / (float) CLOCKS_PER_SEC);

 

-    pcg = crand_eng32_init(seed);

+    pcg = crandom_eng32_init(seed);

     start = clock();

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

-        cvec_f_pqueue_push(&vec, crand_gen_i32(&pcg));

+        cvec_f_pqueue_push(&vec, crandom_gen_i32(&pcg));

     printf("pushed PQ: %f secs\n", (clock() - start) / (float) CLOCKS_PER_SEC);

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

         printf("%.0f ", cvec_f_pqueue_top(&vec)), cvec_f_pqueue_pop(&vec);

diff --git a/examples/inits.c b/examples/inits.c
index 91973190..6b88905f 100644
--- a/examples/inits.c
+++ b/examples/inits.c
@@ -1,7 +1,7 @@
 #include <stdio.h>

 #include <stc/cstr.h>

 #include <stc/cmap.h>

-#include <stc/cvec_pq.h>

+#include <stc/cpqueue.h>

 #include <stc/clist.h>

 

 declare_cmap(id, int, cstr_t, cstr_destroy); // Map of int -> cstr_t

diff --git a/examples/list.c b/examples/list.c
index bf777611..b981b1ec 100644
--- a/examples/list.c
+++ b/examples/list.c
@@ -1,17 +1,17 @@
 #include <stdio.h>

 #include <time.h>

 #include <stc/clist.h>

-#include <stc/crand.h>

+#include <stc/crandom.h>

 declare_clist(fx, double);

 

 int main() {

     int k, n = 100000;

     clist_fx list = clist_init;

-    crand_eng64_t eng = crand_eng64_init(time(NULL));

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

+    crandom_eng64_t eng = crandom_eng64_init(time(NULL));

+    crandom_uniform_f64_t dist = crandom_uniform_f64_init(0.0f, n);

     

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

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

+        clist_fx_push_back(&list, crandom_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 015f24fb..70d89f2a 100644
--- a/examples/priority.c
+++ b/examples/priority.c
@@ -1,21 +1,21 @@
 

 #include <stdio.h>

 #include <time.h>

-#include <stc/cvec_pq.h>

+#include <stc/cpqueue.h>

 #include <stc/cmap.h>

-#include <stc/crand.h>

+#include <stc/crandom.h>

 

 declare_cvec(i, uint32_t);

 declare_cvec_pqueue(i, >); // min-heap (increasing values)

 

 int main() {

-    crand_eng32_t pcg = crand_eng32_init(time(NULL));

-    crand_uniform_i32_t dist = crand_uniform_i32_init(0, 100000000);

+    crandom_eng32_t pcg = crandom_eng32_init(time(NULL));

+    crandom_uniform_i32_t dist = crandom_uniform_i32_init(0, 100000000);

     cvec_i heap = cvec_init;

 

     // Push ten million random numbers to priority queue

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

-        cvec_i_pqueue_push(&heap, crand_uniform_i32(&pcg, dist));

+        cvec_i_pqueue_push(&heap, crandom_uniform_i32(&pcg, dist));

 

     // Extract the hundred smallest.

     for (int i=0; i<100; ++i) {

diff --git a/examples/rngbirthday.c b/examples/rngbirthday.c
index 03c5b783..216a4cb1 100644
--- a/examples/rngbirthday.c
+++ b/examples/rngbirthday.c
@@ -2,7 +2,7 @@
 #include <stdio.h>

 #include <time.h>

 

-#include <stc/crand.h>

+#include <stc/crandom.h>

 #include <stc/cmap.h>

 #include <stc/cvec.h>

 #include <stc/cstr.h>

@@ -15,12 +15,12 @@ const static uint64_t mask = (1ull << 52) - 1;
 

 void repeats(void)

 {

-    crand_eng64_t rng = crand_eng64_init(seed);

+    crandom_eng64_t rng = crandom_eng64_init(seed);

     cmap_ic m = cmap_init;

     cmap_ic_reserve(&m, N);

     clock_t now = clock();

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

-        uint64_t k = crand_gen_i64(&rng) & mask;

+        uint64_t k = crandom_gen_i64(&rng) & mask;

         int v = ++cmap_ic_insert(&m, k, 0)->value;

         if (v > 1) printf("%zu: %llx - %d\n", i, k, v);

     }

@@ -34,13 +34,13 @@ declare_cvec(x, uint64_t);
 

 void distribution(void)

 {

-    crand_eng32_t rng = crand_eng32_init(seed); // time(NULL), time(NULL));

+    crandom_eng32_t rng = crandom_eng32_init(seed); // time(NULL), time(NULL));

     const size_t N = 1ull << 28, M = 1ull << 9; // 1ull << 10;

     cmap_x map = cmap_x_make(M);

     clock_t now = clock();

-    crand_uniform_i32_t dist = crand_uniform_i32_init(0, M);

+    crandom_uniform_i32_t dist = crandom_uniform_i32_init(0, M);

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

-        ++cmap_x_insert(&map, crand_uniform_i32(&rng, dist), 0)->value;

+        ++cmap_x_insert(&map, crandom_uniform_i32(&rng, dist), 0)->value;

     }

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

 

diff --git a/examples/rngtest.c b/examples/rngtest.c
index f8fe44cf..ac464afd 100644
--- a/examples/rngtest.c
+++ b/examples/rngtest.c
@@ -1,6 +1,6 @@
 #include <stdio.h>

 #include <time.h>

-#include <stc/crand.h>

+#include <stc/crandom.h>

 #ifdef __cplusplus

 #include <random>

 #endif

@@ -14,34 +14,34 @@ int main(void)
     uint64_t v;

     printf("start\n");

 

-    crand_eng32_t pcg = crand_eng32_init(time(NULL));

+    crandom_eng32_t pcg = crandom_eng32_init(time(NULL));

     before = clock(); \

     v = 0;

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

-        v += crand_gen_i32(&pcg);

+        v += crandom_gen_i32(&pcg);

     }

     difference = clock() - before;

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

 

-    crand_eng64_t sfc = crand_eng64_init(time(NULL));

+    crandom_eng64_t sfc = crandom_eng64_init(time(NULL));

     before = clock(); \

     v = 0;

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

-        v += crand_gen_i64(&sfc) & 0xffffffff;

+        v += crandom_gen_i64(&sfc) & 0xffffffff;

     }

     difference = clock() - before;

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

 

-    crand_uniform_i32_t i32dist = crand_uniform_i32_init(10, 20);

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

+    crandom_uniform_i32_t i32dist = crandom_uniform_i32_init(10, 20);

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

     puts("");

 

-    crand_uniform_f32_t f32dist = crand_uniform_f32_init(10, 20);

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

+    crandom_uniform_f32_t f32dist = crandom_uniform_f32_init(10, 20);

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

     puts("");

 

-    crand_uniform_f64_t fdist = crand_uniform_f64_init(10, 20);

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

-    //for (int i=0; i<8; ++i) printf("%zu ", crand_gen_i64(&sfc));

+    crandom_uniform_f64_t fdist = crandom_uniform_f64_init(10, 20);

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

+    //for (int i=0; i<8; ++i) printf("%zu ", crandom_gen_i64(&sfc));

     puts("");

 }
\ No newline at end of file
diff --git a/stc/clist.h b/stc/clist.h
index 2ba55c4f..ef2ffa85 100644
--- a/stc/clist.h
+++ b/stc/clist.h
@@ -34,15 +34,15 @@
    

     #include <stdio.h>

     #include <stc/clist.h>

-    #include <stc/crand.h>

+    #include <stc/crandom.h>

     declare_clist(ix, int64_t);

  

     int main() {

         clist_ix list = clist_init;

-        crand_eng32_t pcg = crand_eng32_init(12345);

+        crandom_eng32_t pcg = crandom_eng32_init(12345);

         int n;

         for (int i=0; i<1000000; ++i) // one million

-            clist_ix_push_back(&list, crand_gen_i32(&pcg));

+            clist_ix_push_back(&list, crandom_gen_i32(&pcg));

         n = 0; 

         c_foreach (i, clist_ix, list)

             if (++n % 10000 == 0) printf("%8d: %10zd\n", n, i.item->value);

diff --git a/stc/cvec_pq.h b/stc/cpqueue.h
index c6a896d3..771c7b87 100644
--- a/stc/cvec_pq.h
+++ b/stc/cpqueue.h
@@ -23,19 +23,19 @@
 

 /*  Priority Queue using cvec as heap.

 

-    #include <stc/crand.h>

-    #include <stc/cvec_pq.h>

+    #include <stc/crandom.h>

+    #include <stc/cpqueue.h>

     declare_cvec(f, float);

     declare_cvec_pqueue(f, >); // min-heap (increasing values)

 

     int main() {

-        crand_eng32_t gen = crand_eng32_init(1234);

-        crand_uniform_f32_t dist = crand_uniform_f32_init(10.0f, 100.0f);

+        crandom_eng32_t gen = crandom_eng32_init(1234);

+        crandom_uniform_f32_t dist = crandom_uniform_f32_init(10.0f, 100.0f);

 

         cvec_f queue = cvec_init;

         // Push ten million random numbers onto the queue.

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

-            cvec_f_pqueue_push(&queue, crand_uniform_f32(&gen, dist));

+            cvec_f_pqueue_push(&queue, crandom_uniform_f32(&gen, dist));

         // Extract the 100 smallest.

         for (int i=0; i<100; ++i) {

             printf("%f ", cvec_f_pqueue_top(&queue));

@@ -45,8 +45,8 @@
     }

 */

 

-#ifndef CVEC_PQ__H__

-#define CVEC_PQ__H__

+#ifndef CPQUEUE__H__

+#define CPQUEUE__H__

 

 #include "cvec.h"

 

diff --git a/stc/crand.h b/stc/crandom.h
index b6595bcd..e687ce76 100644
--- a/stc/crand.h
+++ b/stc/crandom.h
@@ -21,78 +21,78 @@
  * SOFTWARE.

  */

 

-#ifndef CRAND__H__

-#define CRAND__H__

+#ifndef CRANDOM__H__

+#define CRANDOM__H__

 

 #include "cdefs.h"

 #include <string.h>

 /*

-    crand_eng32_t eng = crand_eng32_init(seed);

-    crand_uniform_f32_t fdist = crand_uniform_f32_init(1.0f, 6.0f);

-    crand_uniform_i32_t idist = crand_uniform_i32_init(1, 6);

+    crandom_eng32_t eng = crandom_eng32_init(seed);

+    crandom_uniform_f32_t fdist = crandom_uniform_f32_init(1.0f, 6.0f);

+    crandom_uniform_i32_t idist = crandom_uniform_i32_init(1, 6);

     

-    uint32_t i = crand_gen_i32(&eng);

-    int j = crand_uniform_i32(&eng, idist);

-    float r = crand_uniform_f32(&eng, fdist);

+    uint32_t i = crandom_gen_i32(&eng);

+    int j = crandom_uniform_i32(&eng, idist);

+    float r = crandom_uniform_f32(&eng, fdist);

 */

 

-typedef struct {uint64_t state[2];} crand_eng32_t;

-typedef struct {int32_t min, range;} crand_uniform_i32_t;

-typedef struct {float min, range;} crand_uniform_f32_t;

+typedef struct {uint64_t state[2];} crandom_eng32_t;

+typedef struct {int32_t min, range;} crandom_uniform_i32_t;

+typedef struct {float min, range;} crandom_uniform_f32_t;

 

 /* 32 bit random number generator engine */

-STC_API crand_eng32_t crand_eng32_with_seq(uint64_t seed, uint64_t seq);

-STC_INLINE crand_eng32_t crand_eng32_init(uint64_t seed) {

-    return crand_eng32_with_seq(seed, seed);

+STC_API crandom_eng32_t crandom_eng32_with_seq(uint64_t seed, uint64_t seq);

+STC_INLINE crandom_eng32_t crandom_eng32_init(uint64_t seed) {

+    return crandom_eng32_with_seq(seed, seed);

 }

 

 /* int random number generator, range [0, 2^32) */

-STC_API uint32_t crand_gen_i32(crand_eng32_t* rng);

+STC_API uint32_t crandom_gen_i32(crandom_eng32_t* rng);

 

-STC_INLINE float crand_gen_f32(crand_eng32_t* rng) {

-    union {uint32_t i; float f;} u = {0x3F800000u | (crand_gen_i32(rng) >> 9)};

+STC_INLINE float crandom_gen_f32(crandom_eng32_t* rng) {

+    union {uint32_t i; float f;} u = {0x3F800000u | (crandom_gen_i32(rng) >> 9)};

     return u.f - 1.0f;

 }

 

 /* int random number generator in range [low, high] */

-STC_INLINE crand_uniform_i32_t crand_uniform_i32_init(int32_t low, int32_t high) {

-    crand_uniform_i32_t dist = {low, high - low + 1}; return dist;

+STC_INLINE crandom_uniform_i32_t crandom_uniform_i32_init(int32_t low, int32_t high) {

+    crandom_uniform_i32_t dist = {low, high - low + 1}; return dist;

 }

-STC_INLINE int32_t crand_uniform_i32(crand_eng32_t* rng, crand_uniform_i32_t dist) {

-    return dist.min + (int32_t) (((uint64_t) crand_gen_i32(rng) * dist.range) >> 32);

+STC_INLINE int32_t crandom_uniform_i32(crandom_eng32_t* rng, crandom_uniform_i32_t dist) {

+    return dist.min + (int32_t) (((uint64_t) crandom_gen_i32(rng) * dist.range) >> 32);

 }

 

 /* float random number in range [low, high). Note: 23 bit resolution. */

-STC_INLINE crand_uniform_f32_t crand_uniform_f32_init(float low, float high) {

-    crand_uniform_f32_t dist = {low, high - low}; return dist;

+STC_INLINE crandom_uniform_f32_t crandom_uniform_f32_init(float low, float high) {

+    crandom_uniform_f32_t dist = {low, high - low}; return dist;

 }

-STC_INLINE float crand_uniform_f32(crand_eng32_t* rng, crand_uniform_f32_t dist) {

-    return dist.min + crand_gen_f32(rng) * dist.range;

+STC_INLINE float crandom_uniform_f32(crandom_eng32_t* rng, crandom_uniform_f32_t dist) {

+    return dist.min + crandom_gen_f32(rng) * dist.range;

 }

 

 

-typedef struct {uint64_t state[4];} crand_eng64_t;

-typedef struct {double min, range;} crand_uniform_f64_t;

+typedef struct {uint64_t state[4];} crandom_eng64_t;

+typedef struct {double min, range;} crandom_uniform_f64_t;

 

 /* 64 bit random number generator engine */

-STC_API crand_eng64_t crand_eng64_with_seq(uint64_t seed, uint64_t seq);

-STC_INLINE crand_eng64_t crand_eng64_init(uint64_t seed) {

-    return crand_eng64_with_seq(seed, 1);

+STC_API crandom_eng64_t crandom_eng64_with_seq(uint64_t seed, uint64_t seq);

+STC_INLINE crandom_eng64_t crandom_eng64_init(uint64_t seed) {

+    return crandom_eng64_with_seq(seed, 1);

 }

 /* int random number generator, range [0, 2^64) */

-STC_API uint64_t crand_gen_i64(crand_eng64_t* rng);

+STC_API uint64_t crandom_gen_i64(crandom_eng64_t* rng);

 

-STC_INLINE double crand_gen_f64(crand_eng64_t* rng) {

-    union {uint64_t i; double f;} u = {0x3FF0000000000000ull | (crand_gen_i64(rng) >> 12)};

+STC_INLINE double crandom_gen_f64(crandom_eng64_t* rng) {

+    union {uint64_t i; double f;} u = {0x3FF0000000000000ull | (crandom_gen_i64(rng) >> 12)};

     return u.f - 1.0;

 }

 

 /* double random number in range [low, high). 52 bit resolution. */

-STC_INLINE crand_uniform_f64_t crand_uniform_f64_init(float low, float high) {

-    crand_uniform_f64_t dist = {low, high - low}; return dist;

+STC_INLINE crandom_uniform_f64_t crandom_uniform_f64_init(float low, float high) {

+    crandom_uniform_f64_t dist = {low, high - low}; return dist;

 }

-STC_INLINE double crand_uniform_f64(crand_eng64_t* rng, crand_uniform_f64_t dist) {

-    return dist.min + crand_gen_f64(rng) * dist.range;

+STC_INLINE double crandom_uniform_f64(crandom_eng64_t* rng, crandom_uniform_f64_t dist) {

+    return dist.min + crandom_gen_f64(rng) * dist.range;

 }

 

 

@@ -100,15 +100,15 @@ STC_INLINE double crand_uniform_f64(crand_eng64_t* rng, crand_uniform_f64_t dist
 

 /* PCG32 random number generator: https://www.pcg-random.org/download.html */

 

-STC_API crand_eng32_t crand_eng32_with_seq(uint64_t seed, uint64_t seq) {

-    crand_eng32_t rng = {0u, (seq << 1u) | 1u}; /* inc must be odd */

-    crand_gen_i32(&rng);

+STC_API crandom_eng32_t crandom_eng32_with_seq(uint64_t seed, uint64_t seq) {

+    crandom_eng32_t rng = {0u, (seq << 1u) | 1u}; /* inc must be odd */

+    crandom_gen_i32(&rng);

     rng.state[0] += seed;

-    crand_gen_i32(&rng);

+    crandom_gen_i32(&rng);

     return rng;

 }

 

-STC_API uint32_t crand_gen_i32(crand_eng32_t* rng) {

+STC_API uint32_t crandom_gen_i32(crandom_eng32_t* rng) {

     uint64_t old = rng->state[0];

     rng->state[0] = old * 6364136223846793005ull + rng->state[1];

     uint32_t xors = ((old >> 18u) ^ old) >> 27u;

@@ -119,13 +119,13 @@ STC_API uint32_t crand_gen_i32(crand_eng32_t* rng) {
 /* New 64bit PRNG losely based on SFC64: Copyright 2020, Tyge Løvset */

 /* Faster: Updates only 192bit state. Parallel: Ensures unique sequence for each seq (2^63 seqs) */

 /* Minimal period is 2^64 per seq, average ~ 2^127 per seq */

-STC_API crand_eng64_t crand_eng64_with_seq(uint64_t seed, uint64_t seq) {

-    crand_eng64_t rng = {seed, seed, seed, (seq << 1u) | 1u}; /* increment must be odd */

-    for (int i = 0; i < 12; ++i) crand_gen_i64(&rng);

+STC_API crandom_eng64_t crandom_eng64_with_seq(uint64_t seed, uint64_t seq) {

+    crandom_eng64_t rng = {seed, seed, seed, (seq << 1u) | 1u}; /* increment must be odd */

+    for (int i = 0; i < 12; ++i) crandom_gen_i64(&rng);

     return rng;

 }

 

-STC_API uint64_t crand_gen_i64(crand_eng64_t* rng) {

+STC_API uint64_t crandom_gen_i64(crandom_eng64_t* rng) {

     enum {LROT = 24, RSHIFT = 11, LSHIFT = 3};

     uint64_t *s = rng->state;

     const uint64_t b = s[1], result = s[0] ^ (s[2] += s[3]|1);

@@ -135,7 +135,7 @@ STC_API uint64_t crand_gen_i64(crand_eng64_t* rng) {
 }

 

 /* // SFC64 random number generator: http://pracrand.sourceforge.net

-STC_API uint64_t crand_gen_i64(crand_eng64_t* rng) {

+STC_API uint64_t crandom_gen_i64(crandom_eng64_t* rng) {

     enum {LROT = 24, RSHIFT = 11, LSHIFT = 3};

     uint64_t *s = rng->state;

     const uint64_t result = s[0] + s[1] + s[3]++;