144 lines
3.8 KiB
TypeScript
144 lines
3.8 KiB
TypeScript
import type { RNG } from './RNG.js';
|
|
|
|
export class RandUtil {
|
|
constructor(protected rng: RNG) {
|
|
|
|
}
|
|
|
|
public nextFloat1(): Promise<number> {
|
|
return this.rng.nextFloat1();
|
|
}
|
|
|
|
public async nextRange(min: number, max: number): Promise<number> {
|
|
const range = max - min;
|
|
return await this.nextFloat1() * (range) + min;
|
|
}
|
|
|
|
public async nextRangeInt(min: number, max: number): Promise<number> {
|
|
const range = max - min;
|
|
return await this.rng.nextInt(range) + min;
|
|
}
|
|
|
|
public nextInt(max?: number): Promise<number> {
|
|
return this.rng.nextInt(max);
|
|
}
|
|
|
|
public async nextBit(): Promise<boolean> {
|
|
const view = new DataView(await this.rng.nextBits(1) as ArrayBufferLike);
|
|
return view.getUint8(0) != 0;
|
|
}
|
|
|
|
public async nextBool(prob = 0.5): Promise<boolean> {
|
|
if (prob >= 1) {
|
|
return true;
|
|
}
|
|
if (prob === 0.5){
|
|
return this.nextBit();
|
|
}
|
|
if (prob <= 0){
|
|
return false;
|
|
}
|
|
return await this.nextFloat1() < prob;
|
|
}
|
|
|
|
public async shuffle<T>(srcArray: T[]): Promise<T[]> {
|
|
const cnt = srcArray.length;
|
|
if(cnt === 0){
|
|
return [];
|
|
}
|
|
if (cnt > this.rng.getMaxInt()) {
|
|
throw 'Invalid random int range';
|
|
}
|
|
|
|
const result: T[] = Array.from(srcArray);
|
|
for (let srcIdx = 0; srcIdx < cnt; srcIdx += 1) {
|
|
const destIdx = await this.rng.nextInt(cnt - srcIdx - 1) + srcIdx;
|
|
if(srcIdx === destIdx){
|
|
continue;
|
|
}
|
|
[result[srcIdx], result[destIdx]] = [result[destIdx], result[srcIdx]];
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
//Object는 integer key에 예외가 있어 shuffleAssoc은 없음
|
|
|
|
public async choice<T>(items: T[] | Record<string | number, T> | Set<T>): Promise<T> {
|
|
if (items instanceof Array) {
|
|
if(items.length === 0){
|
|
throw new Error('Empty items');
|
|
}
|
|
const idx = await this.rng.nextInt(items.length - 1);
|
|
return items[idx];
|
|
}
|
|
|
|
if (items instanceof Set) {
|
|
return this.choice(Array.from(items.values()));
|
|
}
|
|
|
|
return items[await this.choice(Array.from(Object.keys(items)))];
|
|
}
|
|
|
|
public async choiceUsingWeight(items: Record<string | number, number>): Promise<string | number> {
|
|
if(Object.keys(items).length === 0){
|
|
throw new Error('Empty items');
|
|
}
|
|
let sum = 0;
|
|
for (const value of Object.values(items)) {
|
|
if (value <= 0) {
|
|
continue;
|
|
}
|
|
sum += value;
|
|
}
|
|
|
|
let rd = await this.nextFloat1() * sum;
|
|
|
|
for (const [item, value] of Object.entries(items)) {
|
|
if (value <= 0) {
|
|
if (rd <= 0) {
|
|
return item;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (rd <= value) {
|
|
return item;
|
|
}
|
|
rd -= value;
|
|
}
|
|
|
|
throw new Error('Unreacheable');
|
|
}
|
|
|
|
public async choiceUsingWeightPair<T>(items: [T, number][]): Promise<T> {
|
|
if(items.length === 0){
|
|
throw new Error('Empty items');
|
|
}
|
|
let sum = 0;
|
|
for (const [, value] of items) {
|
|
if (value <= 0) {
|
|
continue;
|
|
}
|
|
sum += value;
|
|
}
|
|
|
|
let rd = await this.nextFloat1() * sum;
|
|
|
|
for (const [item, value] of items) {
|
|
if (value <= 0) {
|
|
if (rd <= 0) {
|
|
return item;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (rd <= value) {
|
|
return item;
|
|
}
|
|
rd -= value;
|
|
}
|
|
|
|
throw new Error('Unreacheable');
|
|
}
|
|
} |