RandomNumberGenerator

public RandomNumberGenerator();

Creates an independent generator with its own Seed and State and automatically calls Randomize(). Zero values in reference metadata do not promise an initial zero seed. Set Seed before the first random call for repeatable output. Automatic initialization does not guarantee a unique seed for every instance.

public ulong Seed { get; set; }

Sets the sequence start and resets state. Restore Seed before State when using both.

public ulong State { get; set; }

State for resuming from a saved point. Restore a previously saved value after Seed; subsequent call order matters.

public ulong GetSeed();

Returns the seed that initialized the current stream, equivalent to reading Seed. Reading does not advance the generator. Randi and other random calls change State without turning Seed into the current state.

public ulong GetState();

Returns the current state, equivalent to reading State, without advancing the generator. The saved value resumes a sequence; the initial Seed does not replace a State snapshot.

The example stores both ulong values as decimal strings. This preserves all 64 bits when passing through formats that may convert numbers to double or a signed 64-bit type. TryRestore validates both strings before changing the generator: Seed before State. Invalid input does not reset the original state.

using System.Globalization;
using Reckfell;

public static class RandomCheckpoint
{
    public static string[] Capture(RandomNumberGenerator rng) =>
    [
        rng.Seed.ToString(CultureInfo.InvariantCulture),
        rng.State.ToString(CultureInfo.InvariantCulture)
    ];

    public static bool TryRestore(RandomNumberGenerator rng, string seedText, string stateText)
    {
        if (!ulong.TryParse(seedText, NumberStyles.None, CultureInfo.InvariantCulture, out ulong seed)
            || !ulong.TryParse(stateText, NumberStyles.None, CultureInfo.InvariantCulture, out ulong state))
            return false;
        rng.Seed = seed;
        rng.State = state;
        return true;
    }
}

After restoration, repeat the same methods with the same parameters and call order. The example was checked with a System.Text.Json string-array roundtrip; it does not guarantee network synchronization or future-version sequence identity.

public long RandWeighted(ReadOnlySpan<float> weights);

Selects an index by relative weights. Validate finite nonnegative values and a finite positive total; no-selection result −1 is not an index.

public long RandWeighted(float[] weights);

Selects an index by relative weights. Validate finite nonnegative values and a finite positive total; no-selection result −1 is not an index.

public float Randf();

Returns a pseudorandom float from 0 to 1, allowing both endpoints. Advances state; do not treat one Randf call as equivalent to one Randi for replay. Do not calculate an index as (int)(Randf() * Length): a result of 1 produces an out-of-bounds index.

public float RandfRange(float from, float to);

Computes Randf() * (to - from) + from as float. Uses ordinary float precision without a final Clamp; account for rounding error near the endpoints. Reversed bounds are not sorted: they reverse the transformation of a unit random sample.

The generator advances even when from == to, unlike RandiRange with equal bounds. Finite inputs alone do not prevent overflow: float.MaxValue - (-float.MaxValue) does not fit float, so the result can become Infinity or NaN.

public float Randfn(float mean = 0f, float deviation = 1f);

Normally distributed value around mean with the chosen deviation. Not bounded by mean ± deviation; clamping changes the distribution.

public uint Randi();

Returns a pseudorandom uint and advances this instance’s state. For an array index, use RandiRange(0, Length - 1) only when Length > 0, rather than casting the full uint to int. The order and number of random calls affect replay.

public int RandiRange(int from, int to);

Returns an integer including both bounds. For a nonempty array index use 0..Length−1, not 0..Length.

public void Randomize();

Reinitializes this instance using a value derived from time and its current state. Updates Seed and State. Do not call before every choice: it changes the stream’s start and interferes with replay. Calls do not guarantee unique seeds. Assign Seed explicitly for a repeatable run.

public void SetSeed(ulong seed);

Sets the initial value and reinitializes internal state, like assigning Seed. Setting the same seed again restarts its sequence. When restoring both seed and state, call SetSeed before SetState: reversing the order discards the saved point.

public void SetState(ulong state);

Replaces internal state, like assigning State, without changing Seed. To resume, use a previously captured GetState()/State value; arbitrary input is not checked for suitability for your replay procedure. Assigning Seed afterward reinitializes state again.