shuffleWithIndex

Shuffle a slice into a random order, using an index of a specified type to maintain distribution across targets. Asserts the index type can represent buf.len.

Indexes into the slice are generated using the specified Index type, which determines distribution properties. This allows for results to be independent of usize representation.

Prefer shuffle if this isn't important.

See intRangeLessThan, which this function uses, for commentary on the runtime of this function.

Function parameters

Parameters

r:Random
T:type
buf:[]T
Index:type

Fast unbiased random numbers.

Types

DefaultPrng: Fast unbiased random numbers.
DefaultCsprng: Cryptographically secure random numbers.
Ascon
ChaCha
Isaac64
Pcg
Xoroshiro128
Xoshiro256
Sfc64
RomuTrio
SplitMix64
ziggurat

Functions in this namespace

Functions

init
bytes: Read random bytes into the specified buffer until full.
boolean
enumValue: Returns a random value from an enum, evenly distributed.
enumValueWithIndex: Returns a random value from an enum, evenly distributed.
int: Returns a random int `i` such that `minInt(T) <= i <= maxInt(T)`.
uintLessThanBiased: Constant-time implementation off `uintLessThan`.
uintLessThan: Returns an evenly distributed random unsigned integer `0 <= i < less_than`.
uintAtMostBiased: Constant-time implementation off `uintAtMost`.
uintAtMost: Returns an evenly distributed random unsigned integer `0 <= i <= at_most`.
intRangeLessThanBiased: Constant-time implementation off `intRangeLessThan`.
intRangeLessThan: Returns an evenly distributed random integer `at_least <= i < less_than`.
intRangeAtMostBiased: Constant-time implementation off `intRangeAtMostBiased`.
intRangeAtMost: Returns an evenly distributed random integer `at_least <= i <= at_most`.
float: Return a floating point value evenly distributed in the range [0, 1).
floatNorm: Return a floating point value normally distributed with mean = 0, stddev = 1.
floatExp: Return an exponentially distributed float with a rate parameter of 1.
shuffle: Shuffle a slice into a random order.
shuffleWithIndex: Shuffle a slice into a random order, using an index of a
weightedIndex: Randomly selects an index into `proportions`, where the likelihood of each
limitRangeBiased: Convert a random integer 0 <= random_int <= maxValue(T),

Source

Implementation

pub fn shuffleWithIndex(r: Random, comptime T: type, buf: []T, comptime Index: type) void {
    const MinInt = MinArrayIndex(Index);
    if (buf.len < 2) {
        return;
    }

    // `i <= j < max <= maxInt(MinInt)`
    const max: MinInt = @intCast(buf.len);
    var i: MinInt = 0;
    while (i < max - 1) : (i += 1) {
        const j: MinInt = @intCast(r.intRangeLessThan(Index, i, max));
        mem.swap(T, &buf[i], &buf[j]);
    }
}