`Javascript
choice(arr: Array): T
`

Returns a random element from arr.

If arr is empty, an exception is thrown.


`Javascript
choices(arr: Array, k: number): Array
`

Returns a k-sized array sampled with replacement from arr,
i.e. each element can be sampled more than once.

If k > 0 and arr is empty, throws an exception.

For an alternative without replacement, see sample.


`Javascript
exponential(lambda: number): number
`

Returns a random number from an exponential distribution.

Useful for modeling time between events in a Poisson process (e.g., time between arrivals, radioactive decay).

Parameters:
- lambda - The rate parameter (lambda > 0). Higher values produce smaller numbers.

Example:
`javascript
// Average 5 events per second → lambda=5
// Time until next event in seconds
const timeUntilNext = Srand.exponential(5);
`


`Javascript
gaussian(mean?: number, stddev?: number): number
`

Returns a random number from a Gaussian (normal) distribution.

Uses the Box-Muller transform to generate normally distributed values.

Parameters:
- mean - The mean (center) of the distribution (default: 0)
- stddev - The standard deviation (spread) of the distribution (default: 1)

Example:
`javascript
// IQ scores: mean=100, stddev=15
const iq = Srand.gaussian(100, 15);
`

Useful for simulations, procedural generation, and statistical modeling.


`Javascript
getState(): State
`

`Javascript
inRange(a: number, b: number): number
`

Returns a pseudo-random float number between a inclusive and b exclusive.


`Javascript
intInRange(min: number, max: number): number
`

Returns a psuedo-random integer between min and max inclusive.


`Javascript
noConflict(): Srand
`

Only available when using Srand as a plain script.

In the uncommon case the name Srand is already taken, restores its initial value and return the Srand object.

`javascript
Srand = "my value";

// .. jsrand is loaded ...

const mySrand = Srand.noConflict();
Srand; // "my value"
`

`Javascript
poisson(lambda: number): number
`

Returns a random integer from a Poisson distribution.

Useful for modeling the number of events occurring in a fixed interval (e.g., number of calls per hour, bugs per line of code).

Parameters:
- lambda - The expected number of events (lambda > 0)

Example:
`javascript
// Average 3 customers per hour
const customers = Srand.poisson(3);
`

Uses Knuth's algorithm for generating Poisson-distributed values.


`Javascript
random(): number
`

Returns a pseudo-random float number between 0 inclusive and 1 exclusive.

The algorithm used is a one-seeded version of the multiply-with-carry method by George Marsaglia.

`Javascript
randomize(): number
`

`Javascript
sample(arr: Array, k: number): Array
`

Returns a k-sized array sampled without replacement from arr.

If k > arr.length, an exception is thrown.

For an alternative with replacement, see choices.


`Javascript
seed(seed?: number): number
`

The seed can be any float or integer number.

`Javascript
setState(state: State): void
`

Resume a state previously returned by getState.


`Javascript
shuffle(arr: Array): Array
`

Shuffles arr in-place using the Fisher-Yates algorithm and returns it (arr is modified).


`Javascript
weightedChoice(arr: Array, weights: Array): T
`

Returns a random element from arr based on the provided weights.

Weights should be positive numbers and will be normalized internally, so [1, 2, 3] is equivalent to [0.166, 0.333, 0.5].

Example:
`javascript
// 90% common, 10% rare loot drops
const loot = Srand.weightedChoice(
['common', 'rare', 'legendary'],
[90, 9, 1]
);
`

If arr is empty, weights length doesn't match arr length, or all weights are zero/negative, an exception is thrown.