Added crand.h - Alternative API to crandom.h, which will be deprecated.

2 files changed, 70 insertions, 70 deletions

diff --git a/misc/benchmarks/picobench/picobench_cmap.cpp b/misc/benchmarks/picobench/picobench_cmap.cpp
index 3ffba5b9..bccbe70c 100644
--- a/misc/benchmarks/picobench/picobench_cmap.cpp
+++ b/misc/benchmarks/picobench/picobench_cmap.cpp
@@ -1,5 +1,5 @@
 #define i_static
-#include <stc/crandom.h>
+#include <stc/crand.h>
 #define i_static
 #include <stc/cstr.h>
 #include <cmath>
@@ -54,36 +54,36 @@ static void ins_and_erase_i(picobench::state& s)
 {
     MapInt map;
     map.max_load_factor((int)MaxLoadFactor100 / 100.0);
-    csrandom(seed);
+    csrand(seed);
 
     picobench::scope scope(s);
     c_forrange (s.iterations())
-        map[crandom()];
+        map[crand()];
     map.clear();
-    csrandom(seed);
+    csrand(seed);
     c_forrange (s.iterations())
-        map[crandom()];
-    csrandom(seed);
+        map[crand()];
+    csrand(seed);
     c_forrange (s.iterations())
-        map.erase(crandom());
+        map.erase(crand());
     s.set_result(map.size());
 }
 /*
 static void ins_and_erase_cmap_i(picobench::state& s)
 {
     cmap_i map = cmap_i_init();
-    csrandom(seed);
+    csrand(seed);
 
     picobench::scope scope(s);
     c_forrange (s.iterations())
-        cmap_i_insert(&map, crandom(), 0);
+        cmap_i_insert(&map, crand(), 0);
     cmap_i_clear(&map);
-    csrandom(seed);
+    csrand(seed);
     c_forrange (s.iterations())
-        cmap_i_insert(&map, crandom(), 0);
-    csrandom(seed);
+        cmap_i_insert(&map, crand(), 0);
+    csrand(seed);
     c_forrange (s.iterations())
-        cmap_i_erase(&map, crandom());
+        cmap_i_erase(&map, crand());
     s.set_result(cmap_i_size(&map));
     cmap_i_drop(&map);
 }
@@ -91,18 +91,18 @@ static void ins_and_erase_cmap_i(picobench::state& s)
 static void ins_and_erase_cmap_x(picobench::state& s)
 {
     cmap_x map = cmap_x_init();
-    csrandom(seed);
+    csrand(seed);
 
     picobench::scope scope(s);
     c_forrange (s.iterations())
-        cmap_x_insert(&map, crandom(), 0);
+        cmap_x_insert(&map, crand(), 0);
     cmap_x_clear(&map);
-    csrandom(seed);
+    csrand(seed);
     c_forrange (s.iterations())
-        cmap_x_insert(&map, crandom(), 0);
-    csrandom(seed);
+        cmap_x_insert(&map, crand(), 0);
+    csrand(seed);
     c_forrange (s.iterations())
-        cmap_x_erase(&map, crandom());
+        cmap_x_erase(&map, crand());
     s.set_result(cmap_x_size(&map));
     cmap_x_drop(&map);
 }
@@ -124,11 +124,11 @@ static void ins_and_access_i(picobench::state& s)
     size_t result = 0;
     MapInt map;
     map.max_load_factor((int)MaxLoadFactor100 / 100.0);
-    csrandom(seed);
+    csrand(seed);
 
     picobench::scope scope(s);
     c_forrange (N1)
-        result += ++map[crandom() & mask];
+        result += ++map[crand() & mask];
     s.set_result(result);
 }
 
@@ -137,11 +137,11 @@ static void ins_and_access_cmap_i(picobench::state& s)
     uint64_t mask = (1ull << s.arg()) - 1;
     size_t result = 0;
     cmap_i map = cmap_i_init();
-    csrandom(seed);
+    csrand(seed);
 
     picobench::scope scope(s);
     c_forrange (N1)
-        result += ++cmap_i_insert(&map, crandom() & mask, 0).ref->second;
+        result += ++cmap_i_insert(&map, crand() & mask, 0).ref->second;
     s.set_result(result);
     cmap_i_drop(&map);
 }
@@ -158,7 +158,7 @@ PICOBENCH_SUITE("Map3");
 
 static void randomize(char* str, size_t len) {
     for (size_t k=0; k < len; ++k) {
-        union {uint64_t i; char c[8];} r = {.i = crandom()};
+        union {uint64_t i; char c[8];} r = {.i = crand()};
         for (unsigned i=0; i<8 && k<len; ++k, ++i)
             str[k] = (r.c[i] & 63) + 48;
     }
@@ -171,7 +171,7 @@ static void ins_and_access_s(picobench::state& s)
     size_t result = 0;
     MapStr map;
     map.max_load_factor((int)MaxLoadFactor100 / 100.0);
-    csrandom(seed);
+    csrand(seed);
 
     picobench::scope scope(s);
     c_forrange (s.iterations()) {
@@ -189,7 +189,7 @@ static void ins_and_access_cmap_s(picobench::state& s)
     char* buf = cstr_data(&str);
     size_t result = 0;
     cmap_str map = cmap_str_init();
-    csrandom(seed);
+    csrand(seed);
 
     picobench::scope scope(s);
     c_forrange (s.iterations()) {
@@ -223,22 +223,22 @@ static void iterate_x(picobench::state& s)
     uint64_t K = (1ull << s.arg()) - 1;
 
     picobench::scope scope(s);
-    csrandom(seed);
+    csrand(seed);
     size_t result = 0;
 
     // measure insert then iterate whole map
     c_forrange (n, s.iterations()) {
-        map[crandom()] = n;
+        map[crand()] = n;
         if (!(n & K)) for (auto const& keyVal : map)
             result += keyVal.second;
     }
 
     // reset rng back to inital state
-    csrandom(seed);
+    csrand(seed);
 
     // measure erase then iterate whole map
     c_forrange (n, s.iterations()) {
-        map.erase(crandom());
+        map.erase(crand());
         if (!(n & K)) for (auto const& keyVal : map)
             result += keyVal.second;
     }
@@ -251,22 +251,22 @@ static void iterate_cmap_x(picobench::state& s)
     uint64_t K = (1ull << s.arg()) - 1;
 
     picobench::scope scope(s);
-    csrandom(seed);
+    csrand(seed);
     size_t result = 0;
 
     // measure insert then iterate whole map
     c_forrange (n, s.iterations()) {
-        cmap_x_insert_or_assign(&map, crandom(), n);
+        cmap_x_insert_or_assign(&map, crand(), n);
         if (!(n & K)) c_foreach (i, cmap_x, map)
             result += i.ref->second;
     }
 
     // reset rng back to inital state
-    csrandom(seed);
+    csrand(seed);
 
     // measure erase then iterate whole map
     c_forrange (n, s.iterations()) {
-        cmap_x_erase(&map, crandom());
+        cmap_x_erase(&map, crand());
         if (!(n & K)) c_foreach (i, cmap_x, map)
             result += i.ref->second;
     }
diff --git a/misc/benchmarks/picobench/picobench_csmap.cpp b/misc/benchmarks/picobench/picobench_csmap.cpp
index 5caab6cc..a6a97b14 100644
--- a/misc/benchmarks/picobench/picobench_csmap.cpp
+++ b/misc/benchmarks/picobench/picobench_csmap.cpp
@@ -1,6 +1,6 @@
 #include <iostream>
 #define i_static
-#include <stc/crandom.h>
+#include <stc/crand.h>
 #define i_static
 #include <stc/cstr.h>
 #include <cmath>
@@ -71,20 +71,20 @@ template <class MapInt>
 static void insert_i(picobench::state& s)
 {
     MapInt map;
-    csrandom(seed);
+    csrand(seed);
     picobench::scope scope(s);
     c_forrange (n, s.iterations())
-        map.emplace(crandom() & 0xfffffff, n);
+        map.emplace(crand() & 0xfffffff, n);
     s.set_result(map.size());
 }
 
 static void insert_csmap_i(picobench::state& s)
 {
     csmap_i map = csmap_i_init();
-    csrandom(seed);
+    csrand(seed);
     picobench::scope scope(s);
     c_forrange (n, s.iterations())
-        csmap_i_insert(&map, crandom() & 0xfffffff, n);
+        csmap_i_insert(&map, crand() & 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;
-    csrandom(seed);
+    csrand(seed);
 
     picobench::scope scope(s);
     c_forrange (i, s.iterations())
-        map.emplace(crandom() & mask, i);
+        map.emplace(crand() & mask, i);
     result = map.size();
 
     map.clear();
-    csrandom(seed);
+    csrand(seed);
     c_forrange (i, s.iterations())
-        map[crandom() & mask] = i;
+        map[crand() & mask] = i;
 
-    csrandom(seed);
+    csrand(seed);
     c_forrange (s.iterations())
-        map.erase(crandom() & mask);
+        map.erase(crand() & 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();
-    csrandom(seed);
+    csrand(seed);
 
     picobench::scope scope(s);
     c_forrange (i, s.iterations())
-        csmap_i_insert(&map, crandom() & mask, i);
+        csmap_i_insert(&map, crand() & mask, i);
     result = csmap_i_size(&map);
 
     csmap_i_clear(&map);
-    csrandom(seed);
+    csrand(seed);
     c_forrange (i, s.iterations())
-        csmap_i_insert_or_assign(&map, crandom() & mask, i);
+        csmap_i_insert_or_assign(&map, crand() & mask, i);
 
-    csrandom(seed);
+    csrand(seed);
     c_forrange (s.iterations())
-        csmap_i_erase(&map, crandom() & mask);
+        csmap_i_erase(&map, crand() & 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;
-    csrandom(seed);
+    csrand(seed);
 
     picobench::scope scope(s);
     c_forrange (s.iterations()) {
-        result += ++map[crandom() & mask];
-        auto it = map.find(crandom() & mask);
+        result += ++map[crand() & mask];
+        auto it = map.find(crand() & 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();
-    csrandom(seed);
+    csrand(seed);
 
     picobench::scope scope(s);
     c_forrange (s.iterations()) {
-        result += ++csmap_i_insert(&map, crandom() & mask, 0).ref->second;
-        const csmap_i_value* val = csmap_i_get(&map, crandom() & mask);
+        result += ++csmap_i_insert(&map, crand() & mask, 0).ref->second;
+        const csmap_i_value* val = csmap_i_get(&map, crand() & 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, int len) {
-    union {uint64_t i; char c[8];} r = {.i = crandom()};
+    union {uint64_t i; char c[8];} r = {.i = crand()};
     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);
-    csrandom(seed);
+    csrand(seed);
     c_forrange (s.iterations()) {
         randomize(&str[0], str.size());
         map.emplace(str, str);
     }
-    csrandom(seed);
+    csrand(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);
-    csrandom(seed);
+    csrand(seed);
     c_forrange (s.iterations()) {
         randomize(buf, s.arg());
         csmap_str_emplace(&map, buf, buf);
     }
-    csrandom(seed);
+    csrand(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);
-    csrandom(seed);
+    csrand(seed);
     size_t result = 0;
 
     // measure insert then iterate whole map
     c_forrange (n, s.iterations()) {
-        map[crandom()] = n;
+        map[crand()] = n;
         if (!(n & K)) for (auto const& keyVal : map)
             result += keyVal.second;
     }
 
     // reset rng back to inital state
-    csrandom(seed);
+    csrand(seed);
 
     // measure erase then iterate whole map
     c_forrange (n, s.iterations()) {
-        map.erase(crandom());
+        map.erase(crand());
         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);
-    csrandom(seed);
+    csrand(seed);
     size_t result = 0;
 
     // measure insert then iterate whole map
     c_forrange (n, s.iterations()) {
-        csmap_x_insert_or_assign(&map, crandom(), n);
+        csmap_x_insert_or_assign(&map, crand(), n);
         if (!(n & K)) c_foreach (i, csmap_x, map)
             result += i.ref->second;
     }
 
     // reset rng back to inital state
-    csrandom(seed);
+    csrand(seed);
 
     // measure erase then iterate whole map
     c_forrange (n, s.iterations()) {
-        csmap_x_erase(&map, crandom());
+        csmap_x_erase(&map, crand());
         if (!(n & K)) c_foreach (i, csmap_x, map)
             result += i.ref->second;
     }