From 66935ae4372c9e9ff036ae6332e7fe3ea35a9dd5 Mon Sep 17 00:00:00 2001 From: timerix Date: Mon, 24 Oct 2022 04:32:06 +0600 Subject: [PATCH] no more repeating code in xoshiro/xoroshiro --- src/random/krandom.h | 84 ++++++------------- src/random/{ => splitmix64}/splitmix64.c | 7 +- src/random/splitmix64/splitmix64.h | 19 +++++ src/random/xoroshiro/32bitValue/xoroshiro64.h | 29 +++++++ .../xoroshiro/32bitValue/xoroshiro64star.c | 15 ++-- .../32bitValue/xoroshiro64starstar.c | 16 +--- .../xoroshiro/64bitValue/xoroshiro128.h | 32 +++++++ .../xoroshiro/64bitValue/xoroshiro128plus.c | 14 ++-- .../64bitValue/xoroshiro128plusplus.c | 16 +--- .../64bitValue/xoroshiro128starstar.c | 16 +--- src/random/xoroshiro/xoroshiro.h | 2 + src/random/xoshiro/32bitValue/xoshiro128.h | 33 ++++++++ .../xoshiro/32bitValue/xoshiro128plus.c | 15 ++-- .../xoshiro/32bitValue/xoshiro128plusplus.c | 17 +--- .../xoshiro/32bitValue/xoshiro128starstar.c | 17 +--- src/random/xoshiro/64bitValue/xoshiro256.h | 32 +++++++ .../xoshiro/64bitValue/xoshiro256plus.c | 14 ++-- .../xoshiro/64bitValue/xoshiro256plusplus.c | 18 +--- .../xoshiro/64bitValue/xoshiro256starstar.c | 18 +--- src/random/xoshiro/xoshiro.h | 2 + tests/test_rng_algorithms.c | 2 +- 21 files changed, 214 insertions(+), 204 deletions(-) rename src/random/{ => splitmix64}/splitmix64.c (90%) create mode 100644 src/random/splitmix64/splitmix64.h create mode 100644 src/random/xoroshiro/32bitValue/xoroshiro64.h create mode 100644 src/random/xoroshiro/64bitValue/xoroshiro128.h create mode 100644 src/random/xoroshiro/xoroshiro.h create mode 100644 src/random/xoshiro/32bitValue/xoshiro128.h create mode 100644 src/random/xoshiro/64bitValue/xoshiro256.h create mode 100644 src/random/xoshiro/xoshiro.h diff --git a/src/random/krandom.h b/src/random/krandom.h index 4815468..ce44a39 100644 --- a/src/random/krandom.h +++ b/src/random/krandom.h @@ -5,82 +5,52 @@ extern "C" { #endif #include "../base/std.h" +#include "splitmix64/splitmix64.h" +#include "xoroshiro/xoroshiro.h" +#include "xoshiro/xoshiro.h" /* You can choose any algorithm that has required functions: - some_alg64_state some_alg64_init(uint64 seed); - uint64 some_alg64_next(some_alg64_state); + some_alg32_state some_alg32_init(uint32 seed); + uint32 some_alg32_next(some_alg32_state); - #define KRAND_ALG64 some_alg64 + #define KRAND_ALG32_next some_alg32_next + #define KRAND_ALG32_init some_alg32_init #include "kerep/random/krandom.h" -The same way it works for 32-bit RNGs: - - some_alg64_state some_alg32_init(uint32 seed); - uint32 some_alg32_next(some_alg64_state); - - #define KRAND_ALG32 some_alg32 - #include "kerep/random/krandom.h" +The same way it works for 64-bit RNGs */ // default rng_next function -#ifndef KRAND_ALG32 - #define KRAND_ALG32 xoroshiro128plus +#ifndef KRAND_ALG32_next +#define KRAND_ALG32_next xoshiro128plus##_next #endif -#ifndef KRAND_ALG64 - #define KRAND_ALG64 xoshiro128plus +#ifndef KRAND_ALG32_init +#define KRAND_ALG32_init xoshiro128plus##_init +#endif +#ifndef KRAND_ALG64_next +#define KRAND_ALG64_next xoshiro256plus##_next +#endif +#ifndef KRAND_ALG64_init +#define KRAND_ALG64_init xoshiro256plus##_init #endif -typedef void* KRAND_ALG32_state; -typedef void* KRAND_ALG64_state; -#define KRAND_ALG32_next(STATE) xoshiro128plus##_next(STATE) -#define KRAND_ALG32_init(SEED) xoshiro128plus##_init(SEED) -#define KRAND_ALG32_initFromTime() xoshiro128plus##_initFromTime() -#define KRAND_ALG64_next(STATE) xoshiro256plus##_next(STATE) -#define KRAND_ALG64_init(SEED) xoshiro256plus##_init(SEED) -#define KRAND_ALG64_initFromTime() xoshiro256plus##_initFromTime() - - -#define __krand_declare_alg(ALG, VALUE_SIZE)\ - typedef void* ALG##_state;\ - ALG##_state ALG##_init(uint64 seed);\ - static inline ALG##_state ALG##_initFromTime(void) { return ALG##_init(time(NULL)); }\ - uint##VALUE_SIZE ALG##_next(ALG##_state); - -// different algorithm declarations -// for ALG32 - // xoroshiro64 -__krand_declare_alg(xoroshiro64star, 32) -__krand_declare_alg(xoroshiro64starstar, 32) - // xoshiro128 -__krand_declare_alg(xoshiro128plus, 32) -__krand_declare_alg(xoshiro128plusplus, 32) -__krand_declare_alg(xoshiro128starstar, 32) -// for ALG64 - // xoroshiro128 -__krand_declare_alg(xoroshiro128plus, 64) -__krand_declare_alg(xoroshiro128plusplus, 64) -__krand_declare_alg(xoroshiro128starstar, 64) - // xoshiro256 -__krand_declare_alg(xoshiro256plus, 64) -__krand_declare_alg(xoshiro256plusplus, 64) -__krand_declare_alg(xoshiro256starstar, 64) - // splitmix64 -__krand_declare_alg(splitmix64, 64) - +typedef void* krand_statePtr; +#define KRAND_ALG32_initFromTime xoshiro128plus##_initFromTime +#define KRAND_ALG64_initFromTime xoshiro256plus##_initFromTime #define __krand_next_definition(VALUE_SIZE) { return from+KRAND_ALG##VALUE_SIZE##_next(state)%(to-from); } // ready-to-use functions -static inline int8 krand_next8 (KRAND_ALG32_state state, int8 from, int8 to) __krand_next_definition(32) -static inline int16 krand_next16(KRAND_ALG32_state state, int16 from, int16 to) __krand_next_definition(32) -static inline int32 krand_next32(KRAND_ALG32_state state, int32 from, int32 to) __krand_next_definition(32) -static inline int64 krand_next64(KRAND_ALG64_state state, int64 from, int64 to) __krand_next_definition(64) +static inline int8 krand_next8 (krand_statePtr state, int8 from, int8 to) __krand_next_definition(32) +static inline int16 krand_next16(krand_statePtr state, int16 from, int16 to) __krand_next_definition(32) +static inline int32 krand_next32(krand_statePtr state, int32 from, int32 to) __krand_next_definition(32) +static inline int64 krand_next64(krand_statePtr state, int64 from, int64 to) __krand_next_definition(64) // divides random number by 2^64 to return a value between 0 and 1 -static inline float32 krand_nextFloat32(KRAND_ALG32_state state) {return (uint32)KRAND_ALG32_next(state)/0xffffffff; } -static inline float64 krand_nextFloat64(KRAND_ALG64_state state) {return KRAND_ALG64_next(state)/0xffffffff; } +static inline float32 krand_nextFloat32(krand_statePtr state) {return (uint32)KRAND_ALG32_next(state)/0xffffffff; } +static inline float64 krand_nextFloat64(krand_statePtr state) {return KRAND_ALG64_next(state)/0xffffffff; } ///@param chance (0-1.0) is probability of success diff --git a/src/random/splitmix64.c b/src/random/splitmix64/splitmix64.c similarity index 90% rename from src/random/splitmix64.c rename to src/random/splitmix64/splitmix64.c index cb89ed4..591167c 100644 --- a/src/random/splitmix64.c +++ b/src/random/splitmix64/splitmix64.c @@ -1,4 +1,4 @@ -#include "krandom.h" +#include "splitmix64.h" /* This is a fixed-increment version of Java 8's SplittableRandom generator @@ -12,16 +12,15 @@ generator. */ // The state can be seeded with any (upto) 64 bit integer value. -typedef uint64 _state_t; void* splitmix64_init(uint64 seed){ - _state_t* state=malloc(sizeof(_state_t)); + splitmix64_state* state=malloc(sizeof(splitmix64_state)); *state=seed; return state; } uint64 splitmix64_next(void* _state) { - _state_t* state=_state; + splitmix64_state* state=_state; // increment the state variable *state += 0x9e3779b97f4a7c15; // copy the state to a working variable diff --git a/src/random/splitmix64/splitmix64.h b/src/random/splitmix64/splitmix64.h new file mode 100644 index 0000000..ca9e77f --- /dev/null +++ b/src/random/splitmix64/splitmix64.h @@ -0,0 +1,19 @@ +#pragma once + +#if __cplusplus +extern "C" { +#endif + +#include "../../base/base.h" + +typedef uint64 splitmix64_state; +typedef void* splitmix64_statePtr; + +splitmix64_statePtr splitmix64_init(uint64 seed); +static inline splitmix64_statePtr splitmix64_initFromTime(void) { return splitmix64_init(time(NULL)); } + +uint64 splitmix64_next(splitmix64_statePtr); + +#if __cplusplus +} +#endif \ No newline at end of file diff --git a/src/random/xoroshiro/32bitValue/xoroshiro64.h b/src/random/xoroshiro/32bitValue/xoroshiro64.h new file mode 100644 index 0000000..e4295fe --- /dev/null +++ b/src/random/xoroshiro/32bitValue/xoroshiro64.h @@ -0,0 +1,29 @@ +#pragma once + +#if __cplusplus +extern "C" { +#endif + +#include "../../../base/std.h" +#include "../../splitmix64/splitmix64.h" + +typedef union { + uint64 merged; + uint32 s[2]; +} xoroshiro64_state; +typedef void* xoroshiro64_statePtr; + +xoroshiro64_statePtr xoroshiro64_init(uint64 seed); +#define xoroshiro64star_init xoroshiro64_init +#define xoroshiro64starstar_init xoroshiro64_init + +static inline xoroshiro64_statePtr xoroshiro64_initFromTime(void) { return xoroshiro64_init(time(NULL)); } +#define xoroshiro64star_initFromTime xoroshiro64_initFromTime +#define xoroshiro64starstar_initFromTime xoroshiro64_initFromTime + +uint32 xoroshiro64star_next(xoroshiro64_statePtr); +uint32 xoroshiro64starstar_next(xoroshiro64_statePtr); + +#if __cplusplus +} +#endif \ No newline at end of file diff --git a/src/random/xoroshiro/32bitValue/xoroshiro64star.c b/src/random/xoroshiro/32bitValue/xoroshiro64star.c index 89bb6cc..9b909a0 100644 --- a/src/random/xoroshiro/32bitValue/xoroshiro64star.c +++ b/src/random/xoroshiro/32bitValue/xoroshiro64star.c @@ -6,7 +6,7 @@ worldwide. This software is distributed without any warranty. See . */ -#include "../../krandom.h" +#include "xoroshiro64.h" /* This is xoroshiro64* 1.0, our best and fastest 32-bit small-state @@ -27,13 +27,8 @@ static inline uint32 rotl(const uint32 x, int k) { return (x << k) | (x >> (32 - k)); } -typedef union { - uint64 merged; - uint32 s[2]; -} _state_t; - uint32 xoroshiro64star_next(void* _state) { - _state_t* state=_state; + xoroshiro64_state* state=_state; const uint32 s0 = state->s[0]; uint32 s1 = state->s[1]; const uint32 result = s0 * 0x9E3779BB; @@ -45,9 +40,9 @@ uint32 xoroshiro64star_next(void* _state) { return result; } -void* xoroshiro64star_init(uint64 seed){ - _state_t* state=malloc(sizeof(_state_t)); - splitmix64_state splitmix=splitmix64_init(seed); +void* xoroshiro64_init(uint64 seed){ + xoroshiro64_state* state=malloc(sizeof(xoroshiro64_state)); + splitmix64_state* splitmix=splitmix64_init(seed); state->merged=splitmix64_next(splitmix); return state; } diff --git a/src/random/xoroshiro/32bitValue/xoroshiro64starstar.c b/src/random/xoroshiro/32bitValue/xoroshiro64starstar.c index 6edcd59..df4432e 100644 --- a/src/random/xoroshiro/32bitValue/xoroshiro64starstar.c +++ b/src/random/xoroshiro/32bitValue/xoroshiro64starstar.c @@ -6,7 +6,7 @@ worldwide. This software is distributed without any warranty. See . */ -#include "../../krandom.h" +#include "xoroshiro64.h" /* This is xoroshiro64** 1.0, our 32-bit all-purpose, rock-solid, small-state generator. It is extremely fast and it passes all tests we @@ -23,13 +23,8 @@ static inline uint32 rotl(const uint32 x, int k) { return (x << k) | (x >> (32 - k)); } -typedef union { - uint64 merged; - uint32 s[2]; -} _state_t; - uint32 xoroshiro64starstar_next(void* _state) { - _state_t* state=_state; + xoroshiro64_state* state=_state; const uint32 s0 = state->s[0]; uint32 s1 = state->s[1]; const uint32 result = rotl(s0 * 0x9E3779BB, 5) * 5; @@ -40,10 +35,3 @@ uint32 xoroshiro64starstar_next(void* _state) { return result; } - -void* xoroshiro64starstar_init(uint64 seed){ - _state_t* state=malloc(sizeof(_state_t)); - splitmix64_state splitmix=splitmix64_init(seed); - state->merged=splitmix64_next(splitmix); - return state; -} diff --git a/src/random/xoroshiro/64bitValue/xoroshiro128.h b/src/random/xoroshiro/64bitValue/xoroshiro128.h new file mode 100644 index 0000000..46d02e5 --- /dev/null +++ b/src/random/xoroshiro/64bitValue/xoroshiro128.h @@ -0,0 +1,32 @@ +#pragma once + +#if __cplusplus +extern "C" { +#endif + +#include "../../../base/std.h" +#include "../../splitmix64/splitmix64.h" + + +typedef union { + uint32 s[2]; +} xoroshiro128_state; +typedef void* xoroshiro128_statePtr; + +xoroshiro128_statePtr xoroshiro128_init(uint64 seed); +#define xoroshiro128plus_init xoroshiro128_init +#define xoroshiro128plusplus_init xoroshiro128_init +#define xoroshiro128starstar_init xoroshiro128_init + +static inline xoroshiro128_statePtr xoroshiro128_initFromTime(void) { return xoroshiro128_init(time(NULL)); } +#define xoroshiro128plus_initFromTime xoroshiro128_initFromTime +#define xoroshiro128plusplus_initFromTime xoroshiro128_initFromTime +#define xoroshiro128starstar_initFromTime xoroshiro128_initFromTime + +uint64 xoroshiro128plus_next(xoroshiro128_statePtr); +uint64 xoroshiro128plusplus_next(xoroshiro128_statePtr); +uint64 xoroshiro128starstar_next(xoroshiro128_statePtr); + +#if __cplusplus +} +#endif \ No newline at end of file diff --git a/src/random/xoroshiro/64bitValue/xoroshiro128plus.c b/src/random/xoroshiro/64bitValue/xoroshiro128plus.c index cf70f65..2846024 100644 --- a/src/random/xoroshiro/64bitValue/xoroshiro128plus.c +++ b/src/random/xoroshiro/64bitValue/xoroshiro128plus.c @@ -6,7 +6,7 @@ worldwide. This software is distributed without any warranty. See . */ -#include "../../krandom.h" +#include "xoroshiro128.h" /* This is xoroshiro128+ 1.0, our best and fastest small-state generator for floating-point numbers, but its state space is large enough only @@ -36,12 +36,8 @@ static inline uint64 rotl(const uint64 x, int k) { return (x << k) | (x >> (64 - k)); } -typedef union { - uint32 s[2]; -} _state_t; - uint64 xoroshiro128plus_next(void* _state){ - _state_t* state=_state; + xoroshiro128_state* state=_state; const uint64 s0 = state->s[0]; uint64 s1 = state->s[1]; const uint64 result = s0 + s1; @@ -53,9 +49,9 @@ uint64 xoroshiro128plus_next(void* _state){ return result; } -void* xoroshiro128plus_init(uint64 seed){ - _state_t* state=malloc(sizeof(_state_t)); - splitmix64_state splitmix=splitmix64_init(seed); +void* xoroshiro128_init(uint64 seed){ + xoroshiro128_state* state=malloc(sizeof(xoroshiro128_state)); + splitmix64_state* splitmix=splitmix64_init(seed); state->s[0]=splitmix64_next(splitmix); state->s[1]=splitmix64_next(splitmix); return state; diff --git a/src/random/xoroshiro/64bitValue/xoroshiro128plusplus.c b/src/random/xoroshiro/64bitValue/xoroshiro128plusplus.c index aaf384d..c01fb30 100644 --- a/src/random/xoroshiro/64bitValue/xoroshiro128plusplus.c +++ b/src/random/xoroshiro/64bitValue/xoroshiro128plusplus.c @@ -6,7 +6,7 @@ worldwide. This software is distributed without any warranty. See . */ -#include "../../krandom.h" +#include "xoroshiro128.h" /* This is xoroshiro128++ 1.0, one of our all-purpose, rock-solid, small-state generators. It is extremely (sub-ns) fast and it passes all @@ -25,12 +25,8 @@ static inline uint64 rotl(const uint64 x, int k) { return (x << k) | (x >> (64 - k)); } -typedef union { - uint32 s[2]; -} _state_t; - uint64 xoroshiro128plusplus_next(void* _state){ - _state_t* state=_state; + xoroshiro128_state* state=_state; const uint64 s0 = state->s[0]; uint64 s1 = state->s[1]; const uint64 result = rotl(s0 + s1, 17) + s0; @@ -41,11 +37,3 @@ uint64 xoroshiro128plusplus_next(void* _state){ return result; } - -void* xoroshiro128plusplus_init(uint64 seed){ - _state_t* state=malloc(sizeof(_state_t)); - splitmix64_state splitmix=splitmix64_init(seed); - state->s[0]=splitmix64_next(splitmix); - state->s[1]=splitmix64_next(splitmix); - return state; -} diff --git a/src/random/xoroshiro/64bitValue/xoroshiro128starstar.c b/src/random/xoroshiro/64bitValue/xoroshiro128starstar.c index d811ab6..3e9ac72 100644 --- a/src/random/xoroshiro/64bitValue/xoroshiro128starstar.c +++ b/src/random/xoroshiro/64bitValue/xoroshiro128starstar.c @@ -6,7 +6,7 @@ worldwide. This software is distributed without any warranty. See . */ -#include "../../krandom.h" +#include "xoroshiro128.h" /* This is xoroshiro128** 1.0, one of our all-purpose, rock-solid, small-state generators. It is extremely (sub-ns) fast and it passes all @@ -25,12 +25,8 @@ static inline uint64 rotl(const uint64 x, int k) { return (x << k) | (x >> (64 - k)); } -typedef union { - uint32 s[2]; -} _state_t; - uint64 xoroshiro128starstar_next(void* _state){ - _state_t* state=_state; + xoroshiro128_state* state=_state; const uint64 s0 = state->s[0]; uint64 s1 = state->s[1]; const uint64 result = rotl(s0 * 5, 7) * 9; @@ -41,11 +37,3 @@ uint64 xoroshiro128starstar_next(void* _state){ return result; } - -void* xoroshiro128starstar_init(uint64 seed){ - _state_t* state=malloc(sizeof(_state_t)); - splitmix64_state splitmix=splitmix64_init(seed); - state->s[0]=splitmix64_next(splitmix); - state->s[1]=splitmix64_next(splitmix); - return state; -} diff --git a/src/random/xoroshiro/xoroshiro.h b/src/random/xoroshiro/xoroshiro.h new file mode 100644 index 0000000..127c937 --- /dev/null +++ b/src/random/xoroshiro/xoroshiro.h @@ -0,0 +1,2 @@ +#include "32bitValue/xoroshiro64.h" +#include "64bitValue/xoroshiro128.h" diff --git a/src/random/xoshiro/32bitValue/xoshiro128.h b/src/random/xoshiro/32bitValue/xoshiro128.h new file mode 100644 index 0000000..ebba10f --- /dev/null +++ b/src/random/xoshiro/32bitValue/xoshiro128.h @@ -0,0 +1,33 @@ +#pragma once + +#if __cplusplus +extern "C" { +#endif + +#include "../../../base/std.h" +#include "../../splitmix64/splitmix64.h" + + +typedef union { + uint64 merged[2]; + uint32 s[4]; +} xoshiro128_state; +typedef void* xoshiro128_statePtr; + +xoshiro128_statePtr xoshiro128_init(uint64 seed); +#define xoshiro128plus_init xoshiro128_init +#define xoshiro128plusplus_init xoshiro128_init +#define xoshiro128starstar_init xoshiro128_init + +static inline xoshiro128_statePtr xoshiro128_initFromTime(void) { return xoshiro128_init(time(NULL)); } +#define xoshiro128plus_initFromTime xoshiro128_initFromTime +#define xoshiro128plusplus_initFromTime xoshiro128_initFromTime +#define xoshiro128starstar_initFromTime xoshiro128_initFromTime + +uint32 xoshiro128plus_next(xoshiro128_statePtr); +uint32 xoshiro128plusplus_next(xoshiro128_statePtr); +uint32 xoshiro128starstar_next(xoshiro128_statePtr); + +#if __cplusplus +} +#endif \ No newline at end of file diff --git a/src/random/xoshiro/32bitValue/xoshiro128plus.c b/src/random/xoshiro/32bitValue/xoshiro128plus.c index 28c90ad..540c71e 100644 --- a/src/random/xoshiro/32bitValue/xoshiro128plus.c +++ b/src/random/xoshiro/32bitValue/xoshiro128plus.c @@ -6,7 +6,7 @@ worldwide. This software is distributed without any warranty. See . */ -#include "../../krandom.h" +#include "xoshiro128.h" /* This is xoshiro128+ 1.0, our best and fastest 32-bit generator for 32-bit floating-point numbers. We suggest to use its upper bits for @@ -26,13 +26,8 @@ static inline uint32 rotl(const uint32 x, int k) { return (x << k) | (x >> (32 - k)); } -typedef union { - uint64 merged[2]; - uint32 s[4]; -} _state_t; - uint32 xoshiro128plus_next(void* _state){ - _state_t* state=_state; + xoshiro128_state* state=_state; const uint32 result = state->s[0] + state->s[3]; const uint32 t = state->s[1] << 9; @@ -49,9 +44,9 @@ uint32 xoshiro128plus_next(void* _state){ return result; } -void* xoshiro128plus_init(uint64 seed){ - _state_t* state=malloc(sizeof(_state_t)); - splitmix64_state splitmix=splitmix64_init(seed); +void* xoshiro128_init(uint64 seed){ + xoshiro128_state* state=malloc(sizeof(xoshiro128_state)); + splitmix64_state* splitmix=splitmix64_init(seed); state->merged[0]=splitmix64_next(splitmix); state->merged[1]=splitmix64_next(splitmix); return state; diff --git a/src/random/xoshiro/32bitValue/xoshiro128plusplus.c b/src/random/xoshiro/32bitValue/xoshiro128plusplus.c index 689dc06..e9be19d 100644 --- a/src/random/xoshiro/32bitValue/xoshiro128plusplus.c +++ b/src/random/xoshiro/32bitValue/xoshiro128plusplus.c @@ -6,7 +6,7 @@ worldwide. This software is distributed without any warranty. See . */ -#include "../../krandom.h" +#include "xoshiro128.h" /* This is xoshiro128++ 1.0, one of our 32-bit all-purpose, rock-solid generators. It has excellent speed, a state size (128 bits) that is @@ -23,13 +23,8 @@ static inline uint32 rotl(const uint32 x, int k) { return (x << k) | (x >> (32 - k)); } -typedef union { - uint64 merged[2]; - uint32 s[4]; -} _state_t; - uint32 xoshiro128plusplus_next(void* _state){ - _state_t* state=_state; + xoshiro128_state* state=_state; const uint32 result = rotl(state->s[0] + state->s[3], 7) + state->s[0]; const uint32 t = state->s[1] << 9; @@ -45,11 +40,3 @@ uint32 xoshiro128plusplus_next(void* _state){ return result; } - -void* xoshiro128plusplus_init(uint64 seed){ - _state_t* state=malloc(sizeof(_state_t)); - splitmix64_state splitmix=splitmix64_init(seed); - state->merged[0]=splitmix64_next(splitmix); - state->merged[1]=splitmix64_next(splitmix); - return state; -} diff --git a/src/random/xoshiro/32bitValue/xoshiro128starstar.c b/src/random/xoshiro/32bitValue/xoshiro128starstar.c index bf458fe..40a53d2 100644 --- a/src/random/xoshiro/32bitValue/xoshiro128starstar.c +++ b/src/random/xoshiro/32bitValue/xoshiro128starstar.c @@ -6,7 +6,7 @@ worldwide. This software is distributed without any warranty. See . */ -#include "../../krandom.h" +#include "xoshiro128.h" /* This is xoshiro128** 1.1, one of our 32-bit all-purpose, rock-solid generators. It has excellent speed, a state size (128 bits) that is @@ -26,13 +26,8 @@ static inline uint32 rotl(const uint32 x, int k) { return (x << k) | (x >> (32 - k)); } -typedef union { - uint64 merged[2]; - uint32 s[4]; -} _state_t; - uint32 xoshiro128starstar_next(void* _state){ - _state_t* state=_state; + xoshiro128_state* state=_state; const uint32 result = rotl(state->s[1] * 5, 7) * 9; const uint32 t = state->s[1] << 9; @@ -48,11 +43,3 @@ uint32 xoshiro128starstar_next(void* _state){ return result; } - -void* xoshiro128starstar_init(uint64 seed){ - _state_t* state=malloc(sizeof(_state_t)); - splitmix64_state splitmix=splitmix64_init(seed); - state->merged[0]=splitmix64_next(splitmix); - state->merged[1]=splitmix64_next(splitmix); - return state; -} diff --git a/src/random/xoshiro/64bitValue/xoshiro256.h b/src/random/xoshiro/64bitValue/xoshiro256.h new file mode 100644 index 0000000..0cbae44 --- /dev/null +++ b/src/random/xoshiro/64bitValue/xoshiro256.h @@ -0,0 +1,32 @@ +#pragma once + +#if __cplusplus +extern "C" { +#endif + +#include "../../../base/std.h" +#include "../../splitmix64/splitmix64.h" + + +typedef union { + uint64 s[4]; +} xoshiro256_state; +typedef void* xoshiro256_statePtr; + +xoshiro256_statePtr xoshiro256_init(uint64 seed); +#define xoshiro256plus_init xoshiro256_init +#define xoshiro256plusplus_init xoshiro256_init +#define xoshiro256starstar_init xoshiro256_init + +static inline xoshiro256_statePtr xoshiro256_initFromTime(void) { return xoshiro256_init(time(NULL)); } +#define xoshiro256plus_initFromTime xoshiro256_initFromTime +#define xoshiro256plusplus_initFromTime xoshiro256_initFromTime +#define xoshiro256starstar_initFromTime xoshiro256_initFromTime + +uint64 xoshiro256plus_next(xoshiro256_statePtr); +uint64 xoshiro256plusplus_next(xoshiro256_statePtr); +uint64 xoshiro256starstar_next(xoshiro256_statePtr); + +#if __cplusplus +} +#endif \ No newline at end of file diff --git a/src/random/xoshiro/64bitValue/xoshiro256plus.c b/src/random/xoshiro/64bitValue/xoshiro256plus.c index e6829d4..ba034be 100644 --- a/src/random/xoshiro/64bitValue/xoshiro256plus.c +++ b/src/random/xoshiro/64bitValue/xoshiro256plus.c @@ -6,7 +6,7 @@ worldwide. This software is distributed without any warranty. See . */ -#include "../../krandom.h" +#include "xoshiro256.h" /* This is xoshiro256+ 1.0, our best and fastest generator for floating-point numbers. We suggest to use its upper bits for floating-point @@ -28,12 +28,8 @@ static inline uint64 rotl(const uint64 x, int k) { return (x << k) | (x >> (64 - k)); } -typedef union { - uint64 s[4]; -} _state_t; - uint64 xoshiro256plus_next(void* _state){ - _state_t* state=_state; + xoshiro256_state* state=_state; const uint64 result = state->s[0] + state->s[3]; const uint64 t = state->s[1] << 17; @@ -50,9 +46,9 @@ uint64 xoshiro256plus_next(void* _state){ return result; } -void* xoshiro256plus_init(uint64 seed){ - _state_t* state=malloc(sizeof(_state_t)); - splitmix64_state splitmix=splitmix64_init(seed); +void* xoshiro256_init(uint64 seed){ + xoshiro256_state* state=malloc(sizeof(xoshiro256_state)); + splitmix64_state* splitmix=splitmix64_init(seed); state->s[0]=splitmix64_next(splitmix); state->s[1]=splitmix64_next(splitmix); state->s[2]=splitmix64_next(splitmix); diff --git a/src/random/xoshiro/64bitValue/xoshiro256plusplus.c b/src/random/xoshiro/64bitValue/xoshiro256plusplus.c index 042035c..77ca943 100644 --- a/src/random/xoshiro/64bitValue/xoshiro256plusplus.c +++ b/src/random/xoshiro/64bitValue/xoshiro256plusplus.c @@ -6,7 +6,7 @@ worldwide. This software is distributed without any warranty. See . */ -#include "../../krandom.h" +#include "xoshiro256.h" /* This is xoshiro256++ 1.0, one of our all-purpose, rock-solid generators. It has excellent (sub-ns) speed, a state (256 bits) that is large @@ -23,12 +23,8 @@ static inline uint64 rotl(const uint64 x, int k) { return (x << k) | (x>>(64 - k)); } -typedef union { - uint64 s[4]; -} _state_t; - uint64 xoshiro256plusplus_next(void* _state) { - _state_t* state=_state; + xoshiro256_state* state=_state; const uint64 result=rotl(state->s[0] + state->s[3], 23) + state->s[0]; const uint64 t=state->s[1] << 17; state->s[2] ^= state->s[0]; @@ -39,13 +35,3 @@ uint64 xoshiro256plusplus_next(void* _state) { state->s[3]=rotl(state->s[3], 45); return result; } - -void* xoshiro256plusplus_init(uint64 seed){ - _state_t* state=malloc(sizeof(_state_t)); - splitmix64_state splitmix=splitmix64_init(seed); - state->s[0]=splitmix64_next(splitmix); - state->s[1]=splitmix64_next(splitmix); - state->s[2]=splitmix64_next(splitmix); - state->s[3]=splitmix64_next(splitmix); - return state; -} diff --git a/src/random/xoshiro/64bitValue/xoshiro256starstar.c b/src/random/xoshiro/64bitValue/xoshiro256starstar.c index 625aedb..7829096 100644 --- a/src/random/xoshiro/64bitValue/xoshiro256starstar.c +++ b/src/random/xoshiro/64bitValue/xoshiro256starstar.c @@ -6,7 +6,7 @@ worldwide. This software is distributed without any warranty. See . */ -#include "../../krandom.h" +#include "xoshiro256.h" /* This is xoshiro256** 1.0, one of our all-purpose, rock-solid generators. It has excellent (sub-ns) speed, a state (256 bits) that is @@ -23,12 +23,8 @@ static inline uint64 rotl(const uint64 x, int k) { return (x << k) | (x >> (64 - k)); } -typedef union { - uint64 s[4]; -} _state_t; - uint64 xoshiro256starstar_next(void* _state){ - _state_t* state=_state; + xoshiro256_state* state=_state; const uint64 result = rotl(state->s[1] * 5, 7) * 9; const uint64 t = state->s[1] << 17; @@ -44,13 +40,3 @@ uint64 xoshiro256starstar_next(void* _state){ return result; } - -void* xoshiro256starstar_init(uint64 seed){ - _state_t* state=malloc(sizeof(_state_t)); - splitmix64_state splitmix=splitmix64_init(seed); - state->s[0]=splitmix64_next(splitmix); - state->s[1]=splitmix64_next(splitmix); - state->s[2]=splitmix64_next(splitmix); - state->s[3]=splitmix64_next(splitmix); - return state; -} diff --git a/src/random/xoshiro/xoshiro.h b/src/random/xoshiro/xoshiro.h new file mode 100644 index 0000000..121ed3a --- /dev/null +++ b/src/random/xoshiro/xoshiro.h @@ -0,0 +1,2 @@ +#include "32bitValue/xoshiro128.h" +#include "64bitValue/xoshiro256.h" diff --git a/tests/test_rng_algorithms.c b/tests/test_rng_algorithms.c index 250def8..eae4dfb 100644 --- a/tests/test_rng_algorithms.c +++ b/tests/test_rng_algorithms.c @@ -4,7 +4,7 @@ #define test_alg(ALG, VALUE_SIZE, EXPECTED_FROM_ZERO){\ printf("\e[94mrng algorithm: \e[96m" #ALG "\n");\ - ALG##_state s= ALG##_init(0);\ + void* s= ALG##_init(0);\ uint##VALUE_SIZE r=ALG##_next(s);\ printf("\e[97m next from zero seed:");\ if(r!=EXPECTED_FROM_ZERO){\