146 lines
4.2 KiB
C
146 lines
4.2 KiB
C
#include "quickjs.h"
|
|
#include "cell.h"
|
|
#include <stdint.h>
|
|
|
|
// Random number generation constants for MT19937-64
|
|
#define STATE_VECTOR_LENGTH 312
|
|
#define STATE_VECTOR_M 156
|
|
#define NN STATE_VECTOR_LENGTH
|
|
#define MM STATE_VECTOR_M
|
|
#define MATRIX_A 0xB5026F5AA96619E9ULL
|
|
#define UM 0xFFFFFFFF80000000ULL /* Most significant 33 bits */
|
|
#define LM 0x7FFFFFFFULL /* Least significant 31 bits */
|
|
|
|
typedef struct tagMTRand {
|
|
uint64_t mt[STATE_VECTOR_LENGTH];
|
|
int32_t index;
|
|
} MTRand;
|
|
|
|
// Random number generation functions
|
|
static void m_seedRand(MTRand* rand, uint64_t seed) {
|
|
rand->mt[0] = seed;
|
|
for(rand->index = 1; rand->index < NN; rand->index++) {
|
|
rand->mt[rand->index] = (6364136223846793005ULL * (rand->mt[rand->index-1] ^ (rand->mt[rand->index-1] >> 62)) + rand->index);
|
|
}
|
|
}
|
|
|
|
static int64_t genRandLong(MTRand* rand) {
|
|
int i;
|
|
uint64_t x;
|
|
static uint64_t mag01[2] = {0ULL, MATRIX_A};
|
|
|
|
if (rand->index >= NN) { /* generate NN words at one time */
|
|
/* if init_genrand64() has not been called, */
|
|
/* a default initial seed is used */
|
|
if (rand->index == NN+1)
|
|
m_seedRand(rand, 5489ULL);
|
|
|
|
for (i = 0; i < NN-MM; i++) {
|
|
x = (rand->mt[i] & UM) | (rand->mt[i+1] & LM);
|
|
rand->mt[i] = rand->mt[i+MM] ^ (x>>1) ^ mag01[(int)(x&1ULL)];
|
|
}
|
|
for (; i < NN-1; i++) {
|
|
x = (rand->mt[i] & UM) | (rand->mt[i+1] & LM);
|
|
rand->mt[i] = rand->mt[i+(MM-NN)] ^ (x>>1) ^ mag01[(int)(x&1ULL)];
|
|
}
|
|
x = (rand->mt[NN-1] & UM) | (rand->mt[0] & LM);
|
|
rand->mt[NN-1] = rand->mt[MM-1] ^ (x>>1) ^ mag01[(int)(x&1ULL)];
|
|
|
|
rand->index = 0;
|
|
}
|
|
|
|
x = rand->mt[rand->index++];
|
|
|
|
x ^= (x >> 29) & 0x5555555555555555ULL;
|
|
x ^= (x << 17) & 0x71D67FFFEDA60000ULL;
|
|
x ^= (x << 37) & 0xFFF7EEE000000000ULL;
|
|
x ^= (x >> 43);
|
|
|
|
return (int64_t)(x & 0x000FFFFFFFFFFFFFULL); /* return 52-bit value safe for JS */
|
|
}
|
|
|
|
static double genRand(MTRand* rand) {
|
|
/* generates a random number on [0,1)-real-interval */
|
|
return (genRandLong(rand) >> 11) * (1.0/9007199254740992.0);
|
|
}
|
|
|
|
/* JS Class Definition */
|
|
static JSClassID js_mersenne_class_id;
|
|
|
|
static void js_mersenne_finalizer(JSRuntime *rt, JSValue val) {
|
|
MTRand *mrand = JS_GetOpaque(val, js_mersenne_class_id);
|
|
js_free_rt(rt, mrand);
|
|
}
|
|
|
|
static JSClassDef js_mersenne_class = {
|
|
"Mersenne",
|
|
.finalizer = js_mersenne_finalizer,
|
|
};
|
|
|
|
static MTRand *js2mersenne(JSContext *js, JSValue v) {
|
|
return JS_GetOpaque(v, js_mersenne_class_id);
|
|
}
|
|
|
|
/* Methods */
|
|
JSC_CCALL(mersenne_get,
|
|
MTRand *mrand = js2mersenne(js, self);
|
|
if (!mrand) return JS_ThrowTypeError(js, "Invalid mersenne context");
|
|
return JS_NewFloat64(js, genRand(mrand));
|
|
)
|
|
|
|
static const JSCFunctionListEntry js_mersenne_funcs[] = {
|
|
JS_CFUNC_DEF("get", 0, js_mersenne_get),
|
|
};
|
|
|
|
/* Factory Function (constructor-style, see js_blob_constructor in qjs_blob.c) */
|
|
static JSValue js_mersenne_use_call(JSContext *js, JSValueConst new_target, int argc, JSValueConst *argv)
|
|
{
|
|
uint64_t seed;
|
|
|
|
if (argc == 0 || JS_IsNull(argv[0])) {
|
|
// Use OS random
|
|
extern int randombytes(void *buf, size_t n);
|
|
randombytes(&seed, 8);
|
|
} else {
|
|
if (JS_ToFloat64(js, (double*)&seed, argv[0])) {
|
|
// Fallback to number if bigint fails or is not provided as bigint
|
|
double d;
|
|
if (JS_ToFloat64(js, &d, argv[0])) return JS_EXCEPTION;
|
|
seed = (uint64_t)d;
|
|
}
|
|
}
|
|
|
|
MTRand *mrand = js_malloc(js, sizeof(MTRand));
|
|
if (!mrand) return JS_ThrowOutOfMemory(js);
|
|
|
|
m_seedRand(mrand, seed);
|
|
|
|
JSValue obj = JS_NewObjectClass(js, js_mersenne_class_id);
|
|
if (JS_IsException(obj)) {
|
|
js_free(js, mrand);
|
|
return obj;
|
|
}
|
|
|
|
JS_SetOpaque(obj, mrand);
|
|
|
|
// Store seed as a read-only property
|
|
JS_DefinePropertyValueStr(js, obj, "seed",
|
|
JS_NewFloat64(js, seed),
|
|
JS_PROP_ENUMERABLE | JS_PROP_CONFIGURABLE // Read-only (no WRITABLE)
|
|
);
|
|
|
|
return obj;
|
|
}
|
|
|
|
CELL_USE_INIT(
|
|
JS_NewClassID(&js_mersenne_class_id);
|
|
JS_NewClass(JS_GetRuntime(js), js_mersenne_class_id, &js_mersenne_class);
|
|
|
|
JSValue proto = JS_NewObject(js);
|
|
JS_SetPropertyFunctionList(js, proto, js_mersenne_funcs, sizeof(js_mersenne_funcs)/sizeof(JSCFunctionListEntry));
|
|
JS_SetClassProto(js, js_mersenne_class_id, proto);
|
|
|
|
// Return the factory function
|
|
return JS_NewCFunction2(js, js_mersenne_use_call, "mersenne", 1, JS_CFUNC_constructor, 0);
|
|
)
|