Variable RandomUtilsConst

Type declaration

• Seeded: typeof SeededRandom

  The SeededRandom class for creating reproducible random sequences

• random:function

  • random(): number

  • Generate a random number between 0 and 1 (exclusive)

    Returns number

    Random number in [0,1)

• number:function

  • number(lo, hi, step?, randomFn?): number

  • Generate a random number in a specified range

    Parameters

    • lo: number

      Lower bound
    • hi: number

      Upper bound
    • Optional step: number

      Optional step size
    • randomFn: (() => number) = Math.random

      Optional custom random function

      • • (): number

        • Returns number

    Returns number

    Random number in specified range

• int:function

  • int(lo, hi, step?, randomFn?): number

  • Generate a random integer in a specified range

    Parameters

    • lo: number

      Lower bound (inclusive)
    • hi: number

      Upper bound (inclusive)
    • Optional step: number

      Optional step size
    • randomFn: (() => number) = Math.random

      Optional custom random function

      • • (): number

        • Returns number

    Returns number

    Random integer in specified range

• bigint:function

  • bigint(lo, hi, step?, randomFn?): bigint

  • Generate a random BigInt in a specified range

    Parameters

    • lo: bigint

      Lower bound (inclusive)
    • hi: bigint

      Upper bound (inclusive)
    • Optional step: bigint

      Optional step size
    • randomFn: (() => number) = Math.random

      Optional custom random function

      • • (): number

        • Returns number

    Returns bigint

    Random BigInt in specified range

• bytes:function

  • bytes(n, randomFn?): Uint8Array<ArrayBufferLike>

  • Generate random bytes

    Parameters

    • n: number

      Number of bytes to generate
    • randomFn: (() => number) = Math.random

      Optional custom random function

      • • (): number

        • Returns number

    Returns Uint8Array<ArrayBufferLike>

    Uint8Array of random bytes

• fillBytes:function

  • fillBytes<T>(buffer, start?, end?, randomFn?): T

  • Fill a buffer with random bytes

    Type Parameters

    • T extends ArrayBuffer | ArrayBufferView<ArrayBufferLike>

    Parameters

    • buffer: T

      Buffer to fill (ArrayBuffer or TypedArray)
    • Optional start: number

      Start position (optional)
    • Optional end: number

      End position (optional)
    • randomFn: (() => number) = Math.random

      Optional custom random function

      • • (): number

        • Returns number

    Returns T

    The filled buffer

• boolean:function

  • boolean(probability?, randomFn?): boolean

  • Generate a random boolean value

    Parameters

    • probability: number = 0.5

      Probability of returning true (0-1, default: 0.5)
    • randomFn: (() => number) = Math.random

      Optional custom random function

      • • (): number

        • Returns number

    Returns boolean

    Random boolean

• choice:function

  • choice<T>(array, randomFn?): T

  • Choose a random element from an array

    Type Parameters

    • T

    Parameters

    • array: T[]

      Array to choose from
    • randomFn: (() => number) = Math.random

      Optional custom random function

      • • (): number

        • Returns number

    Returns T

    Random element from the array

• sample:function

  • sample<T>(array, count, randomFn?): T[]

  • Choose multiple random elements from an array without replacement

    Type Parameters

    • T

    Parameters

    • array: T[]

      Array to choose from
    • count: number

      Number of elements to choose
    • randomFn: (() => number) = Math.random

      Optional custom random function

      • • (): number

        • Returns number

    Returns T[]

    Array of randomly chosen elements

• shuffle:function

  • shuffle<T>(array, randomFn?): T[]

  • Shuffle an array using Fisher-Yates algorithm

    Type Parameters

    • T

    Parameters

    • array: T[]

      Array to shuffle
    • randomFn: (() => number) = Math.random

      Optional custom random function

      • • (): number

        • Returns number

    Returns T[]

    New shuffled array

• string:function

  • string(length, charset?, randomFn?): string

  • Generate a random string of specified length

    Parameters

    • length: number

      Length of the string to generate
    • charset: string = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"

      Character set to use (default: alphanumeric)
    • randomFn: (() => number) = Math.random

      Optional custom random function

      • • (): number

        • Returns number

    Returns string

    Random string

• uuid:function

  • uuid(randomFn?): string

  • Generate a random UUID v4

    Parameters

    • randomFn: (() => number) = Math.random

      Optional custom random function

      • • (): number

        • Returns number

    Returns string

    Random UUID string

• weightedChoice:function

  • weightedChoice<T>(items, weights, randomFn?): T

  • Generate a weighted random choice

    Type Parameters

    • T

    Parameters

    • items: T[]

      Array of items to choose from
    • weights: number[]

      Array of weights corresponding to items
    • randomFn: (() => number) = Math.random

      Optional custom random function

      • • (): number

        • Returns number

    Returns T

    Randomly chosen item based on weights

• normal:function

  • normal(mean?, stdDev?, randomFn?): number

  • Generate a random number from normal distribution (Box-Muller transform)

    Parameters

    • mean: number = 0

      Mean of the distribution (default: 0)
    • stdDev: number = 1

      Standard deviation (default: 1)
    • randomFn: (() => number) = Math.random

      Optional custom random function

      • • (): number

        • Returns number

    Returns number

    Random number from normal distribution

• exponential:function

  • exponential(rate?, randomFn?): number

  • Generate a random number from exponential distribution

    Parameters

    • rate: number = 1

      Rate parameter (lambda)
    • randomFn: (() => number) = Math.random

      Optional custom random function

      • • (): number

        • Returns number

    Returns number

    Random number from exponential distribution

• seed:function

  • seed(): Uint8Array<ArrayBufferLike>

  • Generate a random seed for seeding PRNGs

    Returns Uint8Array<ArrayBufferLike>

    32-byte Uint8Array suitable for seeding