Skip to content

Commit

Permalink
chore: enhance with better types
Browse files Browse the repository at this point in the history
  • Loading branch information
@Shinigami92
Shinigami92 committed Jan 24, 2022
1 parent d665e64 commit 12497d5
Show file tree
Hide file tree
Showing 2 changed files with 66 additions and 46 deletions.
59 changes: 28 additions & 31 deletions src/vendor/mersenne.ts
View file
Original file line number Diff line number Diff line change
Expand Up @@ -51,48 +51,47 @@
* email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
*/

let dbg;
let dbg: number;

function MersenneTwister19937() {
function MersenneTwister19937(): void {
/* constants should be scoped inside the class */
var N, M, MATRIX_A, UPPER_MASK, LOWER_MASK;
/* Period parameters */
//c//#define N 624
//c//#define M 397
//c//#define MATRIX_A 0x9908b0dfUL /* constant vector a */
//c//#define UPPER_MASK 0x80000000UL /* most significant w-r bits */
//c//#define LOWER_MASK 0x7fffffffUL /* least significant r bits */
N = 624;
M = 397;
MATRIX_A = 0x9908b0df; /* constant vector a */
UPPER_MASK = 0x80000000; /* most significant w-r bits */
LOWER_MASK = 0x7fffffff; /* least significant r bits */
const N = 624;
const M = 397;
const MATRIX_A = 0x9908b0df; /* constant vector a */
const UPPER_MASK = 0x80000000; /* most significant w-r bits */
const LOWER_MASK = 0x7fffffff; /* least significant r bits */
//c//static unsigned long mt[N]; /* the array for the state vector */
//c//static int mti=N+1; /* mti==N+1 means mt[N] is not initialized */
var mt = new Array(N); /* the array for the state vector */
var mti = N + 1; /* mti==N+1 means mt[N] is not initialized */
const mt: number[] = new Array(N); /* the array for the state vector */
let mti = N + 1; /* mti==N+1 means mt[N] is not initialized */

function unsigned32(n1) {
function unsigned32(n1: number): number {
// returns a 32-bits unsiged integer from an operand to which applied a bit operator.
return n1 < 0 ? (n1 ^ UPPER_MASK) + UPPER_MASK : n1;
}

function subtraction32(n1, n2) {
function subtraction32(n1: number, n2: number): number {
// emulates lowerflow of a c 32-bits unsiged integer variable, instead of the operator -. these both arguments must be non-negative integers expressible using unsigned 32 bits.
return n1 < n2
? unsigned32((0x100000000 - (n2 - n1)) & 0xffffffff)
: n1 - n2;
}

function addition32(n1, n2) {
function addition32(n1: number, n2: number): number {
// emulates overflow of a c 32-bits unsiged integer variable, instead of the operator +. these both arguments must be non-negative integers expressible using unsigned 32 bits.
return unsigned32((n1 + n2) & 0xffffffff);
}

function multiplication32(n1, n2) {
function multiplication32(n1: number, n2: number): number {
// emulates overflow of a c 32-bits unsiged integer variable, instead of the operator *. these both arguments must be non-negative integers expressible using unsigned 32 bits.
var sum = 0;
for (var i = 0; i < 32; ++i) {
let sum = 0;
for (let i = 0; i < 32; ++i) {
if ((n1 >>> i) & 0x1) {
sum = addition32(sum, unsigned32(n2 << i));
}
Expand All @@ -102,7 +101,7 @@ function MersenneTwister19937() {

/* initializes mt[N] with a seed */
//c//void init_genrand(unsigned long s)
this.init_genrand = function (s) {
this.init_genrand = function (s: number) {
//c//mt[0]= s & 0xffffffff;
mt[0] = unsigned32(s & 0xffffffff);
for (mti = 1; mti < N; mti++) {
Expand Down Expand Up @@ -131,13 +130,11 @@ function MersenneTwister19937() {
/* slight change for C++, 2004/2/26 */
//c//void init_by_array(unsigned long init_key[], int key_length)
this.init_by_array = function (init_key, key_length) {
//c//int i, j, k;
var i, j, k;
//c//init_genrand(19650218);
this.init_genrand(19650218);
i = 1;
j = 0;
k = N > key_length ? N : key_length;
let i = 1;
let j = 0;
let k = N > key_length ? N : key_length;
for (; k; k--) {
//c//mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * 1664525))
//c// + init_key[j] + j; /* non linear */
Expand Down Expand Up @@ -192,20 +189,20 @@ function MersenneTwister19937() {
};

/* moved outside of genrand_int32() by jwatte 2010-11-17; generate less garbage */
var mag01 = [0x0, MATRIX_A];
const mag01 = [0x0, MATRIX_A];

/* generates a random number on [0,0xffffffff]-interval */
//c//unsigned long genrand_int32(void)
this.genrand_int32 = function () {
//c//unsigned long y;
//c//static unsigned long mag01[2]={0x0UL, MATRIX_A};
var y;
let y: number;
/* mag01[x] = x * MATRIX_A for x=0,1 */

if (mti >= N) {
/* generate N words at one time */
//c//int kk;
var kk;
let kk: number;

if (mti == N + 1) {
/* if init_genrand() has not been called, */
Expand Down Expand Up @@ -249,40 +246,40 @@ function MersenneTwister19937() {

/* generates a random number on [0,0x7fffffff]-interval */
//c//long genrand_int31(void)
this.genrand_int31 = function () {
this.genrand_int31 = function (): number {
//c//return (genrand_int32()>>1);
return this.genrand_int32() >>> 1;
};

/* generates a random number on [0,1]-real-interval */
//c//double genrand_real1(void)
this.genrand_real1 = function () {
this.genrand_real1 = function (): number {
//c//return genrand_int32()*(1.0/4294967295.0);
return this.genrand_int32() * (1.0 / 4294967295.0);
/* divided by 2^32-1 */
};

/* generates a random number on [0,1)-real-interval */
//c//double genrand_real2(void)
this.genrand_real2 = function () {
this.genrand_real2 = function (): number {
//c//return genrand_int32()*(1.0/4294967296.0);
return this.genrand_int32() * (1.0 / 4294967296.0);
/* divided by 2^32 */
};

/* generates a random number on (0,1)-real-interval */
//c//double genrand_real3(void)
this.genrand_real3 = function () {
this.genrand_real3 = function (): number {
//c//return ((genrand_int32()) + 0.5)*(1.0/4294967296.0);
return (this.genrand_int32() + 0.5) * (1.0 / 4294967296.0);
/* divided by 2^32 */
};

/* generates a random number on [0,1) with 53-bit resolution*/
//c//double genrand_res53(void)
this.genrand_res53 = function () {
this.genrand_res53 = function (): number {
//c//unsigned long a=genrand_int32()>>5, b=genrand_int32()>>6;
var a = this.genrand_int32() >>> 5,
const a = this.genrand_int32() >>> 5,
b = this.genrand_int32() >>> 6;
return (a * 67108864.0 + b) * (1.0 / 9007199254740992.0);
};
Expand Down
53 changes: 38 additions & 15 deletions src/vendor/unique.ts
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2,26 +2,30 @@
// currently uniqueness is global to entire faker instance
// this means that faker should currently *never* return duplicate values across all API methods when using `Faker.unique`
// it's possible in the future that some users may want to scope found per function call instead of faker instance
var found = {};
const found = {};

// global exclude list of results
// defaults to nothing excluded
var exclude = [];
const exclude = [];

// current iteration or retries of unique.exec ( current loop depth )
var currentIterations = 0;
let currentIterations = 0;

// uniqueness compare function
// default behavior is to check value as key against object hash
var defaultCompare = function (obj, key) {
function defaultCompare<T, Key extends keyof T>(obj: T, key: Key): 0 | -1 {
if (typeof obj[key] === 'undefined') {
return -1;
}
return 0;
};
}

// common error handler for messages
export function errorMessage(now, code, opts) {
function errorMessage(
now: number,
code: string,
opts: { startTime: number }
): never {
console.error('error', code);
console.log(
'found',
Expand All @@ -38,10 +42,19 @@ export function errorMessage(now, code, opts) {
);
}

export function exec(method, args, opts) {
//console.log(currentIterations)

var now = new Date().getTime();
export function exec<Method extends Function, Args extends any[], Result>(
method: Method,
args: Args,
opts: {
maxTime?: number;
maxRetries?: number;
exclude?: any[];
compare?: (obj: any, key: string) => 0 | -1;
currentIterations?: number;
startTime?: number;
}
): Result {
const now = new Date().getTime();

opts = opts || {};
opts.maxTime = opts.maxTime || 3;
Expand All @@ -57,7 +70,7 @@ export function exec(method, args, opts) {
opts.startTime = new Date().getTime();
}

var startTime = opts.startTime;
const startTime = opts.startTime;

// support single exclude argument as string
if (typeof opts.exclude === 'string') {
Expand All @@ -70,15 +83,25 @@ export function exec(method, args, opts) {

// console.log(now - startTime)
if (now - startTime >= opts.maxTime) {
return errorMessage(now, 'Exceeded maxTime:' + opts.maxTime, opts);
return errorMessage(
now,
'Exceeded maxTime:' + opts.maxTime,
// @ts-expect-error: we know that opts.startTime is defined
opts
);
}

if (opts.currentIterations >= opts.maxRetries) {
return errorMessage(now, 'Exceeded maxRetries:' + opts.maxRetries, opts);
return errorMessage(
now,
'Exceeded maxRetries:' + opts.maxRetries,
// @ts-expect-error: we know that opts.startTime is defined
opts
);
}

// execute the provided method to find a potential satifised value
var result = method.apply(this, args);
// execute the provided method to find a potential satisfied value
const result = method.apply(this, args);

// if the result has not been previously found, add it to the found array and return the value as it's unique
if (
Expand Down

0 comments on commit 12497d5

Please sign in to comment.