Renamed stc64_random() => crandom(), stc64_srandom(seed) => csrandom(seed). Kept old names for backward comp.

8 files changed, 139 insertions, 139 deletions

diff --git a/benchmarks/misc/sso_bench.c b/benchmarks/misc/sso_bench.c
index 0d40a017..450884f3 100644
--- a/benchmarks/misc/sso_bench.c
+++ b/benchmarks/misc/sso_bench.c
@@ -12,10 +12,10 @@
 #include <stc/crandom.h>
 
 void rndstr(char buf[64], int max) {
-    unsigned n = stc64_random() % max;
+    unsigned n = crandom() % max;
     static char chr[64] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_";
     c_forrange (i, n)
-        buf[i] = chr[stc64_random() & 63];
+        buf[i] = chr[crandom() & 63];
     buf[n] = '\0';
 }
 
@@ -27,7 +27,7 @@ int main(void) {
     c_auto (Map, map) {
         char buf[128];
 
-        stc64_srandom(time(NULL));
+        csrandom(time(NULL));
         printf("map\n");
         clock_t t0 = clock(), t1, t2;
         c_forrange (i, int, N) {
diff --git a/benchmarks/picobench/picobench_cmap.cpp b/benchmarks/picobench/picobench_cmap.cpp
index 52d219bc..02daad51 100644
--- a/benchmarks/picobench/picobench_cmap.cpp
+++ b/benchmarks/picobench/picobench_cmap.cpp
@@ -59,18 +59,18 @@ static void ins_and_erase_i(picobench::state& s)
     size_t result = 0;

     MapInt map;

     map.max_load_factor((int)MaxLoadFactor100 / 100.0);

-    stc64_srandom(seed);

+    csrandom(seed);

 

     picobench::scope scope(s);

     c_forrange (s.iterations())

-        map[stc64_random()];

+        map[crandom()];

     map.clear();

-    stc64_srandom(seed);

+    csrandom(seed);

     c_forrange (s.iterations())

-        map[stc64_random()];

-    stc64_srandom(seed);

+        map[crandom()];

+    csrandom(seed);

     c_forrange (s.iterations())

-        map.erase(stc64_random());

+        map.erase(crandom());

     s.set_result(map.size());

 }

 

@@ -78,18 +78,18 @@ static void ins_and_erase_cmap_i(picobench::state& s)
 {

     cmap_i map = cmap_i_init();

     cmap_i_max_load_factor(&map, (int)MaxLoadFactor100 / 100.0);

-    stc64_srandom(seed);

+    csrandom(seed);

 

     picobench::scope scope(s);

     c_forrange (s.iterations())

-        cmap_i_insert(&map, stc64_random(), 0);

+        cmap_i_insert(&map, crandom(), 0);

     cmap_i_clear(&map);

-    stc64_srandom(seed);

+    csrandom(seed);

     c_forrange (s.iterations())

-        cmap_i_insert(&map, stc64_random(), 0);

-    stc64_srandom(seed);

+        cmap_i_insert(&map, crandom(), 0);

+    csrandom(seed);

     c_forrange (s.iterations())

-        cmap_i_erase(&map, stc64_random());

+        cmap_i_erase(&map, crandom());

     s.set_result(cmap_i_size(map));

     cmap_i_drop(&map);

 }

@@ -98,18 +98,18 @@ static void ins_and_erase_cmap_x(picobench::state& s)
 {

     cmap_x map = cmap_x_init();

     cmap_x_max_load_factor(&map, (int)MaxLoadFactor100 / 100.0);

-    stc64_srandom(seed);

+    csrandom(seed);

 

     picobench::scope scope(s);

     c_forrange (s.iterations())

-        cmap_x_insert(&map, stc64_random(), 0);

+        cmap_x_insert(&map, crandom(), 0);

     cmap_x_clear(&map);

-    stc64_srandom(seed);

+    csrandom(seed);

     c_forrange (s.iterations())

-        cmap_x_insert(&map, stc64_random(), 0);

-    stc64_srandom(seed);

+        cmap_x_insert(&map, crandom(), 0);

+    csrandom(seed);

     c_forrange (s.iterations())

-        cmap_x_erase(&map, stc64_random());

+        cmap_x_erase(&map, crandom());

     s.set_result(cmap_x_size(map));

     cmap_x_drop(&map);

 }

@@ -133,11 +133,11 @@ static void ins_and_access_i(picobench::state& s)
     size_t result = 0;

     MapInt map;

     map.max_load_factor((int)MaxLoadFactor100 / 100.0);

-    stc64_srandom(seed);

+    csrandom(seed);

 

     picobench::scope scope(s);

     c_forrange (N1)

-        result += ++map[stc64_random() & mask];

+        result += ++map[crandom() & mask];

     s.set_result(result);

 }

 

@@ -147,11 +147,11 @@ static void ins_and_access_cmap_i(picobench::state& s)
     size_t result = 0;

     cmap_i map = cmap_i_init();

     cmap_i_max_load_factor(&map, (int)MaxLoadFactor100 / 100.0);

-    stc64_srandom(seed);

+    csrandom(seed);

 

     picobench::scope scope(s);

     c_forrange (N1)

-        result += ++cmap_i_insert(&map, stc64_random() & mask, 0).ref->second;

+        result += ++cmap_i_insert(&map, crandom() & mask, 0).ref->second;

     s.set_result(result);

     cmap_i_drop(&map);

 }

@@ -170,7 +170,7 @@ PICOBENCH_SUITE("Map3");
 

 static void randomize(char* str, size_t len) {

     for (int k=0; k < len; ++k) {

-        union {uint64_t i; char c[8];} r = {.i = stc64_random()};

+        union {uint64_t i; char c[8];} r = {.i = crandom()};

         for (int i=0; i<8 && k<len; ++k, ++i)

             str[k] = (r.c[i] & 63) + 48;

     }

@@ -183,7 +183,7 @@ static void ins_and_access_s(picobench::state& s)
     size_t result = 0;

     MapStr map;

     map.max_load_factor((int)MaxLoadFactor100 / 100.0);

-    stc64_srandom(seed);

+    csrandom(seed);

 

     picobench::scope scope(s);

     c_forrange (s.iterations()) {

@@ -202,7 +202,7 @@ static void ins_and_access_cmap_s(picobench::state& s)
     size_t result = 0;

     cmap_str map = cmap_str_init();

     cmap_str_max_load_factor(&map, (int)MaxLoadFactor100 / 100.0);

-    stc64_srandom(seed);

+    csrandom(seed);

 

     picobench::scope scope(s);

     c_forrange (s.iterations()) {

@@ -238,22 +238,22 @@ static void iterate_x(picobench::state& s)
     uint64_t K = (1ull << s.arg()) - 1;

 

     picobench::scope scope(s);

-    stc64_srandom(seed);

+    csrandom(seed);

     size_t result = 0;

 

     // measure insert then iterate whole map

     c_forrange (n, s.iterations()) {

-        map[stc64_random()] = n;

+        map[crandom()] = n;

         if (!(n & K)) for (auto const& keyVal : map)

             result += keyVal.second;

     }

 

     // reset rng back to inital state

-    stc64_srandom(seed);

+    csrandom(seed);

 

     // measure erase then iterate whole map

     c_forrange (n, s.iterations()) {

-        map.erase(stc64_random());

+        map.erase(crandom());

         if (!(n & K)) for (auto const& keyVal : map)

             result += keyVal.second;

     }

@@ -267,22 +267,22 @@ static void iterate_cmap_x(picobench::state& s)
     uint64_t K = (1ull << s.arg()) - 1;

 

     picobench::scope scope(s);

-    stc64_srandom(seed);

+    csrandom(seed);

     size_t result = 0;

 

     // measure insert then iterate whole map

     c_forrange (n, s.iterations()) {

-        cmap_x_insert_or_assign(&map, stc64_random(), n);

+        cmap_x_insert_or_assign(&map, crandom(), n);

         if (!(n & K)) c_foreach (i, cmap_x, map)

             result += i.ref->second;

     }

 

     // reset rng back to inital state

-    stc64_srandom(seed);

+    csrandom(seed);

 

     // measure erase then iterate whole map

     c_forrange (n, s.iterations()) {

-        cmap_x_erase(&map, stc64_random());

+        cmap_x_erase(&map, crandom());

         if (!(n & K)) c_foreach (i, cmap_x, map)

             result += i.ref->second;

     }

diff --git a/benchmarks/picobench/picobench_csmap.cpp b/benchmarks/picobench/picobench_csmap.cpp
index be645932..f5235ce1 100644
--- a/benchmarks/picobench/picobench_csmap.cpp
+++ b/benchmarks/picobench/picobench_csmap.cpp
@@ -70,10 +70,10 @@ static void insert_i(picobench::state& s)
 {

     size_t result = 0;

     MapInt map;

-    stc64_srandom(seed);

+    csrandom(seed);

     picobench::scope scope(s);

     c_forrange (n, s.iterations())

-        map.emplace(stc64_random() & 0xfffffff, n);

+        map.emplace(crandom() & 0xfffffff, n);

     s.set_result(map.size());

 }

 

@@ -81,10 +81,10 @@ static void insert_csmap_i(picobench::state& s)
 {

     size_t result = 0;

     csmap_i map = csmap_i_init();

-    stc64_srandom(seed);

+    csrandom(seed);

     picobench::scope scope(s);

     c_forrange (n, s.iterations())

-        csmap_i_insert(&map, stc64_random() & 0xfffffff, n);

+        csmap_i_insert(&map, crandom() & 0xfffffff, n);

     s.set_result(csmap_i_size(map));

     csmap_i_drop(&map);

 }

@@ -103,21 +103,21 @@ static void ins_and_erase_i(picobench::state& s)
     size_t result = 0;

     uint64_t mask = (1ull << s.arg()) - 1;

     MapInt map;

-    stc64_srandom(seed);

+    csrandom(seed);

 

     picobench::scope scope(s);

     c_forrange (i, s.iterations())

-        map.emplace(stc64_random() & mask, i);

+        map.emplace(crandom() & mask, i);

     result = map.size();

 

     map.clear();

-    stc64_srandom(seed);

+    csrandom(seed);

     c_forrange (i, s.iterations())

-        map[stc64_random() & mask] = i;

+        map[crandom() & mask] = i;

 

-    stc64_srandom(seed);

+    csrandom(seed);

     c_forrange (s.iterations())

-        map.erase(stc64_random() & mask);

+        map.erase(crandom() & mask);

     s.set_result(result);

 }

 

@@ -126,21 +126,21 @@ static void ins_and_erase_csmap_i(picobench::state& s)
     size_t result = 0;

     uint64_t mask = (1ull << s.arg()) - 1;

     csmap_i map = csmap_i_init();

-    stc64_srandom(seed);

+    csrandom(seed);

 

     picobench::scope scope(s);

     c_forrange (i, s.iterations())

-        csmap_i_insert(&map, stc64_random() & mask, i);

+        csmap_i_insert(&map, crandom() & mask, i);

     result = csmap_i_size(map);

 

     csmap_i_clear(&map);

-    stc64_srandom(seed);

+    csrandom(seed);

     c_forrange (i, s.iterations())

-        csmap_i_insert_or_assign(&map, stc64_random() & mask, i);

+        csmap_i_insert_or_assign(&map, crandom() & mask, i);

 

-    stc64_srandom(seed);

+    csrandom(seed);

     c_forrange (s.iterations())

-        csmap_i_erase(&map, stc64_random() & mask);

+        csmap_i_erase(&map, crandom() & mask);

     s.set_result(result);

     csmap_i_drop(&map);

 }

@@ -158,12 +158,12 @@ static void ins_and_access_i(picobench::state& s)
     uint64_t mask = (1ull << s.arg()) - 1;

     size_t result = 0;

     MapInt map;

-    stc64_srandom(seed);

+    csrandom(seed);

 

     picobench::scope scope(s);

     c_forrange (s.iterations()) {

-        result += ++map[stc64_random() & mask];

-        auto it = map.find(stc64_random() & mask);

+        result += ++map[crandom() & mask];

+        auto it = map.find(crandom() & mask);

         if (it != map.end()) map.erase(it->first);

     }

     s.set_result(result + map.size());

@@ -174,12 +174,12 @@ static void ins_and_access_csmap_i(picobench::state& s)
     uint64_t mask = (1ull << s.arg()) - 1;

     size_t result = 0;

     csmap_i map = csmap_i_init();

-    stc64_srandom(seed);

+    csrandom(seed);

 

     picobench::scope scope(s);

     c_forrange (s.iterations()) {

-        result += ++csmap_i_insert(&map, stc64_random() & mask, 0).ref->second;

-        const csmap_i_value* val = csmap_i_get(&map, stc64_random() & mask);

+        result += ++csmap_i_insert(&map, crandom() & mask, 0).ref->second;

+        const csmap_i_value* val = csmap_i_get(&map, crandom() & mask);

         if (val) csmap_i_erase(&map, val->first);

     }

     s.set_result(result + csmap_i_size(map));

@@ -194,7 +194,7 @@ PICOBENCH(ins_and_access_csmap_i).P;
 PICOBENCH_SUITE("Map4");

 

 static void randomize(char* str, size_t len) {

-    union {uint64_t i; char c[8];} r = {.i = stc64_random()};

+    union {uint64_t i; char c[8];} r = {.i = crandom()};

     for (int i = len - 7, j = 0; i < len; ++j, ++i)

         str[i] = (r.c[j] & 63) + 48;

 }

@@ -207,12 +207,12 @@ static void ins_and_access_s(picobench::state& s)
     MapStr map;

 

     picobench::scope scope(s);

-    stc64_srandom(seed);

+    csrandom(seed);

     c_forrange (s.iterations()) {

         randomize(&str[0], str.size());

         map.emplace(str, str);

     }

-    stc64_srandom(seed);

+    csrandom(seed);

     c_forrange (s.iterations()) {

         randomize(&str[0], str.size());

         result += map.erase(str);

@@ -228,12 +228,12 @@ static void ins_and_access_csmap_s(picobench::state& s)
     csmap_str map = csmap_str_init();

 

     picobench::scope scope(s);

-    stc64_srandom(seed);

+    csrandom(seed);

     c_forrange (s.iterations()) {

         randomize(buf, s.arg());

         csmap_str_emplace(&map, buf, buf);

     }

-    stc64_srandom(seed);

+    csrandom(seed);

     c_forrange (s.iterations()) {

         randomize(buf, s.arg());

         result += csmap_str_erase(&map, buf);

@@ -262,22 +262,22 @@ static void iterate_x(picobench::state& s)
     uint64_t K = (1ull << s.arg()) - 1;

 

     picobench::scope scope(s);

-    stc64_srandom(seed);

+    csrandom(seed);

     size_t result = 0;

 

     // measure insert then iterate whole map

     c_forrange (n, s.iterations()) {

-        map[stc64_random()] = n;

+        map[crandom()] = n;

         if (!(n & K)) for (auto const& keyVal : map)

             result += keyVal.second;

     }

 

     // reset rng back to inital state

-    stc64_srandom(seed);

+    csrandom(seed);

 

     // measure erase then iterate whole map

     c_forrange (n, s.iterations()) {

-        map.erase(stc64_random());

+        map.erase(crandom());

         if (!(n & K)) for (auto const& keyVal : map)

             result += keyVal.second;

     }

@@ -290,22 +290,22 @@ static void iterate_csmap_x(picobench::state& s)
     uint64_t K = (1ull << s.arg()) - 1;

 

     picobench::scope scope(s);

-    stc64_srandom(seed);

+    csrandom(seed);

     size_t result = 0;

 

     // measure insert then iterate whole map

     c_forrange (n, s.iterations()) {

-        csmap_x_insert_or_assign(&map, stc64_random(), n);

+        csmap_x_insert_or_assign(&map, crandom(), n);

         if (!(n & K)) c_foreach (i, csmap_x, map)

             result += i.ref->second;

     }

 

     // reset rng back to inital state

-    stc64_srandom(seed);

+    csrandom(seed);

 

     // measure erase then iterate whole map

     c_forrange (n, s.iterations()) {

-        csmap_x_erase(&map, stc64_random());

+        csmap_x_erase(&map, crandom());

         if (!(n & K)) c_foreach (i, csmap_x, map)

             result += i.ref->second;

     }

diff --git a/benchmarks/plotbench/cdeq_benchmark.cpp b/benchmarks/plotbench/cdeq_benchmark.cpp
index f57da6b2..b6eebb26 100644
--- a/benchmarks/plotbench/cdeq_benchmark.cpp
+++ b/benchmarks/plotbench/cdeq_benchmark.cpp
@@ -27,10 +27,10 @@ Sample test_std_deque() {
     {

         s.test[INSERT].t1 = clock();

         container con;

-        stc64_srandom(seed);

-        c_forrange (N/3) con.push_front(stc64_random() & mask1);

-        c_forrange (N/3) {con.push_back(stc64_random() & mask1); con.pop_front();}

-        c_forrange (N/3) con.push_back(stc64_random() & mask1);

+        csrandom(seed);

+        c_forrange (N/3) con.push_front(crandom() & mask1);

+        c_forrange (N/3) {con.push_back(crandom() & mask1); con.pop_front();}

+        c_forrange (N/3) con.push_back(crandom() & mask1);

         s.test[INSERT].t2 = clock();

         s.test[INSERT].sum = con.size();

         s.test[ERASE].t1 = clock();

@@ -39,13 +39,13 @@ Sample test_std_deque() {
         s.test[ERASE].sum = con.size();

      }{

         container con;

-        stc64_srandom(seed);

-        c_forrange (N) con.push_back(stc64_random() & mask2);

+        csrandom(seed);

+        c_forrange (N) con.push_back(crandom() & mask2);

         s.test[FIND].t1 = clock();

         size_t sum = 0;

         // Iteration - not inherent find - skipping

         //container::iterator it;

-        //c_forrange (S) if ((it = std::find(con.begin(), con.end(), stc64_random() & mask2)) != con.end()) sum += *it;

+        //c_forrange (S) if ((it = std::find(con.begin(), con.end(), crandom() & mask2)) != con.end()) sum += *it;

         s.test[FIND].t2 = clock();

         s.test[FIND].sum = sum;

         s.test[ITER].t1 = clock();

@@ -71,10 +71,10 @@ Sample test_stc_deque() {
         s.test[INSERT].t1 = clock();

         container con = cdeq_x_init();

         //cdeq_x_reserve(&con, N);

-        stc64_srandom(seed);

-        c_forrange (N/3) cdeq_x_push_front(&con, stc64_random() & mask1);

-        c_forrange (N/3) {cdeq_x_push_back(&con, stc64_random() & mask1); cdeq_x_pop_front(&con);}

-        c_forrange (N/3) cdeq_x_push_back(&con, stc64_random() & mask1);

+        csrandom(seed);

+        c_forrange (N/3) cdeq_x_push_front(&con, crandom() & mask1);

+        c_forrange (N/3) {cdeq_x_push_back(&con, crandom() & mask1); cdeq_x_pop_front(&con);}

+        c_forrange (N/3) cdeq_x_push_back(&con, crandom() & mask1);

         s.test[INSERT].t2 = clock();

         s.test[INSERT].sum = cdeq_x_size(con);

         s.test[ERASE].t1 = clock();

@@ -83,13 +83,13 @@ Sample test_stc_deque() {
         s.test[ERASE].sum = cdeq_x_size(con);

         cdeq_x_drop(&con);

      }{

-        stc64_srandom(seed);

+        csrandom(seed);

         container con = cdeq_x_init();

-        c_forrange (N) cdeq_x_push_back(&con, stc64_random() & mask2);

+        c_forrange (N) cdeq_x_push_back(&con, crandom() & mask2);

         s.test[FIND].t1 = clock();

         size_t sum = 0;

         //cdeq_x_iter it, end = cdeq_x_end(&con);

-        //c_forrange (S) if ((it = cdeq_x_find(&con, stc64_random() & mask2)).ref != end.ref) sum += *it.ref;

+        //c_forrange (S) if ((it = cdeq_x_find(&con, crandom() & mask2)).ref != end.ref) sum += *it.ref;

         s.test[FIND].t2 = clock();

         s.test[FIND].sum = sum;

         s.test[ITER].t1 = clock();

diff --git a/benchmarks/plotbench/clist_benchmark.cpp b/benchmarks/plotbench/clist_benchmark.cpp
index eaa18201..c82c9506 100644
--- a/benchmarks/plotbench/clist_benchmark.cpp
+++ b/benchmarks/plotbench/clist_benchmark.cpp
@@ -27,9 +27,9 @@ Sample test_std_forward_list() {
     {

         s.test[INSERT].t1 = clock();

         container con;

-        stc64_srandom(seed);

-        c_forrange (N/2) con.push_front(stc64_random() & mask1);

-        c_forrange (N/2) con.push_front(stc64_random() & mask1);

+        csrandom(seed);

+        c_forrange (N/2) con.push_front(crandom() & mask1);

+        c_forrange (N/2) con.push_front(crandom() & mask1);

         s.test[INSERT].t2 = clock();

         s.test[INSERT].sum = 0;

         s.test[ERASE].t1 = clock();

@@ -38,13 +38,13 @@ Sample test_std_forward_list() {
         s.test[ERASE].sum = 0;

      }{

         container con;

-        stc64_srandom(seed);

-        c_forrange (N) con.push_front(stc64_random() & mask2);

+        csrandom(seed);

+        c_forrange (N) con.push_front(crandom() & mask2);

         s.test[FIND].t1 = clock();

         size_t sum = 0;

         container::iterator it;

         // Iteration - not inherent find - skipping

-        //c_forrange (S) if ((it = std::find(con.begin(), con.end(), stc64_random() & mask2)) != con.end()) sum += *it;

+        //c_forrange (S) if ((it = std::find(con.begin(), con.end(), crandom() & mask2)) != con.end()) sum += *it;

         s.test[FIND].t2 = clock();

         s.test[FIND].sum = sum;

         s.test[ITER].t1 = clock();

@@ -69,9 +69,9 @@ Sample test_stc_forward_list() {
     {

         s.test[INSERT].t1 = clock();

         container con = clist_x_init();

-        stc64_srandom(seed);

-        c_forrange (N/2) clist_x_push_front(&con, stc64_random() & mask1);

-        c_forrange (N/2) clist_x_push_back(&con, stc64_random() & mask1);

+        csrandom(seed);

+        c_forrange (N/2) clist_x_push_front(&con, crandom() & mask1);

+        c_forrange (N/2) clist_x_push_back(&con, crandom() & mask1);

         s.test[INSERT].t2 = clock();

         s.test[INSERT].sum = 0;

         s.test[ERASE].t1 = clock();

@@ -80,13 +80,13 @@ Sample test_stc_forward_list() {
         s.test[ERASE].sum = 0;

         clist_x_drop(&con);

      }{

-        stc64_srandom(seed);

+        csrandom(seed);

         container con = clist_x_init();

-        c_forrange (N) clist_x_push_front(&con, stc64_random() & mask2);

+        c_forrange (N) clist_x_push_front(&con, crandom() & mask2);

         s.test[FIND].t1 = clock();

         size_t sum = 0;

         //clist_x_iter it, end = clist_x_end(&con);

-        //c_forrange (S) if ((it = clist_x_find(&con, stc64_random() & mask2)).ref != end.ref) sum += *it.ref;

+        //c_forrange (S) if ((it = clist_x_find(&con, crandom() & mask2)).ref != end.ref) sum += *it.ref;

         s.test[FIND].t2 = clock();

         s.test[FIND].sum = sum;

         s.test[ITER].t1 = clock();

diff --git a/benchmarks/plotbench/cmap_benchmark.cpp b/benchmarks/plotbench/cmap_benchmark.cpp
index d8d1c6ab..0554ae9c 100644
--- a/benchmarks/plotbench/cmap_benchmark.cpp
+++ b/benchmarks/plotbench/cmap_benchmark.cpp
@@ -26,28 +26,28 @@ Sample test_std_unordered_map() {
     typedef std::unordered_map<uint64_t, uint64_t> container;

     Sample s = {"std,unordered_map"};

     {

-        stc64_srandom(seed);

+        csrandom(seed);

         s.test[INSERT].t1 = clock();

         container con;

-        c_forrange (i, N/2) con.emplace(stc64_random() & mask1, i);

+        c_forrange (i, N/2) con.emplace(crandom() & mask1, i);

         c_forrange (i, N/2) con.emplace(i, i);

         s.test[INSERT].t2 = clock();

         s.test[INSERT].sum = con.size();

-        stc64_srandom(seed);

+        csrandom(seed);

         s.test[ERASE].t1 = clock();

-        c_forrange (N) con.erase(stc64_random() & mask1);

+        c_forrange (N) con.erase(crandom() & mask1);

         s.test[ERASE].t2 = clock();

         s.test[ERASE].sum = con.size();

      }{

         container con;

-        stc64_srandom(seed);

-        c_forrange (i, N/2) con.emplace(stc64_random() & mask1, i);

+        csrandom(seed);

+        c_forrange (i, N/2) con.emplace(crandom() & mask1, i);

         c_forrange (i, N/2) con.emplace(i, i);

-        stc64_srandom(seed);

+        csrandom(seed);

         s.test[FIND].t1 = clock();

         size_t sum = 0;

         container::iterator it;

-        c_forrange (N) if ((it = con.find(stc64_random() & mask1)) != con.end()) sum += it->second;

+        c_forrange (N) if ((it = con.find(crandom() & mask1)) != con.end()) sum += it->second;

         s.test[FIND].t2 = clock();

         s.test[FIND].sum = sum;

         s.test[ITER].t1 = clock();

@@ -70,30 +70,30 @@ Sample test_stc_unordered_map() {
     typedef cmap_x container;

     Sample s = {"STC,unordered_map"};

     {

-        stc64_srandom(seed);

+        csrandom(seed);

         s.test[INSERT].t1 = clock();

         container con = cmap_x_init();

-        c_forrange (i, N/2) cmap_x_insert(&con, stc64_random() & mask1, i);

+        c_forrange (i, N/2) cmap_x_insert(&con, crandom() & mask1, i);

         c_forrange (i, N/2) cmap_x_insert(&con, i, i);

         s.test[INSERT].t2 = clock();

         s.test[INSERT].sum = cmap_x_size(con);

-        stc64_srandom(seed);

+        csrandom(seed);

         s.test[ERASE].t1 = clock();

-        c_forrange (N) cmap_x_erase(&con, stc64_random() & mask1);

+        c_forrange (N) cmap_x_erase(&con, crandom() & mask1);

         s.test[ERASE].t2 = clock();

         s.test[ERASE].sum = cmap_x_size(con);

         cmap_x_drop(&con);

      }{

         container con = cmap_x_init();

-        stc64_srandom(seed);

-        c_forrange (i, N/2) cmap_x_insert(&con, stc64_random() & mask1, i);

+        csrandom(seed);

+        c_forrange (i, N/2) cmap_x_insert(&con, crandom() & mask1, i);

         c_forrange (i, N/2) cmap_x_insert(&con, i, i);

-        stc64_srandom(seed);

+        csrandom(seed);

         s.test[FIND].t1 = clock();

         size_t sum = 0;

         const cmap_x_value* val;

         c_forrange (N) 

-            if ((val = cmap_x_get(&con, stc64_random() & mask1)))

+            if ((val = cmap_x_get(&con, crandom() & mask1)))

                 sum += val->second;

         s.test[FIND].t2 = clock();

         s.test[FIND].sum = sum;

diff --git a/benchmarks/plotbench/csmap_benchmark.cpp b/benchmarks/plotbench/csmap_benchmark.cpp
index e7603b58..baf4c879 100644
--- a/benchmarks/plotbench/csmap_benchmark.cpp
+++ b/benchmarks/plotbench/csmap_benchmark.cpp
@@ -25,28 +25,28 @@ Sample test_std_map() {
     typedef std::map<size_t, size_t> container;

     Sample s = {"std,map"};

     {

-        stc64_srandom(seed);

+        csrandom(seed);

         s.test[INSERT].t1 = clock();

         container con;

-        c_forrange (i, N/2) con.emplace(stc64_random() & mask1, i);

+        c_forrange (i, N/2) con.emplace(crandom() & mask1, i);

         c_forrange (i, N/2) con.emplace(i, i);

         s.test[INSERT].t2 = clock();

         s.test[INSERT].sum = con.size();

-        stc64_srandom(seed);

+        csrandom(seed);

         s.test[ERASE].t1 = clock();

-        c_forrange (N) con.erase(stc64_random() & mask1);

+        c_forrange (N) con.erase(crandom() & mask1);

         s.test[ERASE].t2 = clock();

         s.test[ERASE].sum = con.size();

      }{

         container con;

-        stc64_srandom(seed);

-        c_forrange (i, N/2) con.emplace(stc64_random() & mask1, i);

+        csrandom(seed);

+        c_forrange (i, N/2) con.emplace(crandom() & mask1, i);

         c_forrange (i, N/2) con.emplace(i, i);

-        stc64_srandom(seed);

+        csrandom(seed);

         s.test[FIND].t1 = clock();

         size_t sum = 0;

         container::iterator it;

-        c_forrange (N) if ((it = con.find(stc64_random() & mask1)) != con.end()) sum += it->second;

+        c_forrange (N) if ((it = con.find(crandom() & mask1)) != con.end()) sum += it->second;

         s.test[FIND].t2 = clock();

         s.test[FIND].sum = sum;

         s.test[ITER].t1 = clock();

@@ -70,30 +70,30 @@ Sample test_stc_map() {
     typedef csmap_x container;

     Sample s = {"STC,map"};

     {

-        stc64_srandom(seed);

+        csrandom(seed);

         s.test[INSERT].t1 = clock();

         container con = csmap_x_init();

-        c_forrange (i, N/2) csmap_x_insert(&con, stc64_random() & mask1, i);

+        c_forrange (i, N/2) csmap_x_insert(&con, crandom() & mask1, i);

         c_forrange (i, N/2) csmap_x_insert(&con, i, i);

         s.test[INSERT].t2 = clock();

         s.test[INSERT].sum = csmap_x_size(con);

-        stc64_srandom(seed);

+        csrandom(seed);

         s.test[ERASE].t1 = clock();

-        c_forrange (N) csmap_x_erase(&con, stc64_random() & mask1);

+        c_forrange (N) csmap_x_erase(&con, crandom() & mask1);

         s.test[ERASE].t2 = clock();

         s.test[ERASE].sum = csmap_x_size(con);

         csmap_x_drop(&con);

      }{

         container con = csmap_x_init();

-        stc64_srandom(seed);

-        c_forrange (i, N/2) csmap_x_insert(&con, stc64_random() & mask1, i);

+        csrandom(seed);

+        c_forrange (i, N/2) csmap_x_insert(&con, crandom() & mask1, i);

         c_forrange (i, N/2) csmap_x_insert(&con, i, i);

-        stc64_srandom(seed);

+        csrandom(seed);

         s.test[FIND].t1 = clock();

         size_t sum = 0;

         const csmap_x_value* val;

         c_forrange (N) 

-            if ((val = csmap_x_get(&con, stc64_random() & mask1)))

+            if ((val = csmap_x_get(&con, crandom() & mask1)))

                 sum += val->second;

         s.test[FIND].t2 = clock();

         s.test[FIND].sum = sum;

diff --git a/benchmarks/plotbench/cvec_benchmark.cpp b/benchmarks/plotbench/cvec_benchmark.cpp
index 21e7a229..357cfcf0 100644
--- a/benchmarks/plotbench/cvec_benchmark.cpp
+++ b/benchmarks/plotbench/cvec_benchmark.cpp
@@ -27,8 +27,8 @@ Sample test_std_vector() {
     {

         s.test[INSERT].t1 = clock();

         container con;

-        stc64_srandom(seed);

-        c_forrange (N) con.push_back(stc64_random() & mask1);

+        csrandom(seed);

+        c_forrange (N) con.push_back(crandom() & mask1);

         s.test[INSERT].t2 = clock();

         s.test[INSERT].sum = con.size();

         s.test[ERASE].t1 = clock();

@@ -37,13 +37,13 @@ Sample test_std_vector() {
         s.test[ERASE].sum = con.size();

      }{

         container con;

-        stc64_srandom(seed);

-        c_forrange (N) con.push_back(stc64_random() & mask2);

+        csrandom(seed);

+        c_forrange (N) con.push_back(crandom() & mask2);

         s.test[FIND].t1 = clock();

         size_t sum = 0;

         container::iterator it;

         // Iteration - not inherent find - skipping

-        //c_forrange (S) if ((it = std::find(con.begin(), con.end(), stc64_random() & mask2)) != con.end()) sum += *it;

+        //c_forrange (S) if ((it = std::find(con.begin(), con.end(), crandom() & mask2)) != con.end()) sum += *it;

         s.test[FIND].t2 = clock();

         s.test[FIND].sum = sum;

         s.test[ITER].t1 = clock();

@@ -69,8 +69,8 @@ Sample test_stc_vector() {
     {

         s.test[INSERT].t1 = clock();

         container con = cvec_x_init();

-        stc64_srandom(seed);

-        c_forrange (N) cvec_x_push_back(&con, stc64_random() & mask1);

+        csrandom(seed);

+        c_forrange (N) cvec_x_push_back(&con, crandom() & mask1);

         s.test[INSERT].t2 = clock();

         s.test[INSERT].sum = cvec_x_size(con);

         s.test[ERASE].t1 = clock();

@@ -79,13 +79,13 @@ Sample test_stc_vector() {
         s.test[ERASE].sum = cvec_x_size(con);

         cvec_x_drop(&con);

      }{

-        stc64_srandom(seed);

+        csrandom(seed);

         container con = cvec_x_init();

-        c_forrange (N) cvec_x_push_back(&con, stc64_random() & mask2);

+        c_forrange (N) cvec_x_push_back(&con, crandom() & mask2);

         s.test[FIND].t1 = clock();

         size_t sum = 0;

         //cvec_x_iter it, end = cvec_x_end(&con);

-        //c_forrange (S) if ((it = cvec_x_find(&con, stc64_random() & mask2)).ref != end.ref) sum += *it.ref;

+        //c_forrange (S) if ((it = cvec_x_find(&con, crandom() & mask2)).ref != end.ref) sum += *it.ref;

         s.test[FIND].t2 = clock();

         s.test[FIND].sum = sum;

         s.test[ITER].t1 = clock();