public void AverageDecimals(Decimal low, Decimal high, UInt64 seed)
{
const Int32 iterations = 10_000;
const Decimal sqr3 = 1.7320508075688772935274463415m;
var populationMean = high / 2 + low / 2;
var popStdDev = 1.0m / sqr3 * (high / 2 - low / 2);
var exclusiveDist = Uniform.New(low, high);
var inclusiveDist = Uniform.NewInclusive(low, high);
var rng = Pcg32.Create(789 + seed, 11634580027462260723ul);
Decimal exclusiveMean = 0;
Decimal inclusiveMean = 0;
for (var i = 0; i < iterations; i++)
{
var exclusive = exclusiveDist.Sample(rng);
var exclusiveDelta = exclusive - exclusiveMean;
exclusiveMean += exclusiveDelta / (i + 1);
Assert.True(low <= exclusive);
Assert.True(exclusive < high);
var inclusive = inclusiveDist.Sample(rng);
var inclusiveDelta = inclusive - inclusiveMean;
inclusiveMean += inclusiveDelta / (i + 1);
Assert.True(low <= inclusive);
Assert.True(inclusive < high);
}
Assert.True(Statistics.WithinConfidence(populationMean, popStdDev, exclusiveMean, iterations));
Assert.True(Statistics.WithinConfidence(populationMean, popStdDev, inclusiveMean, iterations));
}
public void AverageDoubles(Double low, Double high, UInt64 seed)
{
const Int32 iterations = 10_000;
var populationMean = high / 2 + low / 2;
var popStdDev = 1.0 / Math.Sqrt(3) * (high / 2 - low / 2);
var exclusiveDist = Uniform.New(low, high);
var inclusiveDist = Uniform.NewInclusive(low, high);
var rng = Pcg32.Create(789 + seed, 11634580027462260723ul);
Double exclusiveMean = 0;
Double inclusiveMean = 0;
for (var i = 0; i < iterations; i++)
{
var exclusive = exclusiveDist.Sample(rng);
var exclusiveDelta = exclusive - exclusiveMean;
exclusiveMean += exclusiveDelta / (i + 1);
Assert.True(low <= exclusive);
Assert.True(exclusive < high);
var inclusive = inclusiveDist.Sample(rng);
var inclusiveDelta = inclusive - inclusiveMean;
inclusiveMean += inclusiveDelta / (i + 1);
Assert.True(low <= inclusive);
Assert.True(inclusive < high);
}
Assert.True(Statistics.WithinConfidence(populationMean, popStdDev, exclusiveMean, iterations));
Assert.True(Statistics.WithinConfidence(populationMean, popStdDev, inclusiveMean, iterations));
}
public void SingleAverage(IDistribution <Single> dist, UInt64 seed)
{
const Int32 iterations = 10_000;
var rng = Pcg32.Create(seed, 11634580027462260723ul);
Double mean = 0;
for (var i = 0; i < iterations; i++)
{
var result = dist.Sample(rng);
var delta = result - mean;
mean += delta / (i + 1);
Assert.True(0 <= result);
Assert.True(result <= 1);
}
Assert.True(Statistics.WithinConfidence(popMean: 0.5, popStdDev: 0.5, mean, iterations));
Double mean2 = 0;
for (var i = 0; i < iterations; i++)
{
Assert.True(dist.TrySample(rng, out var result));
var delta = result - mean2;
mean2 += delta / (i + 1);
Assert.True(0 <= result);
Assert.True(result <= 1);
}
Assert.True(Statistics.WithinConfidence(popMean: 0.5, popStdDev: 0.5, mean2, iterations));
}
public void TrySampleDouble()
{
var rng = Pcg32.Create(789, 11634580027462260723ul);
var dist = Uniform.New((Double)0, (Double)100);
for (Int32 i = 0; i < 10_000; i++)
{
Assert.True(dist.TrySample(rng, out _));
}
}
public void SampleExclusiveInt64(Int64 low, Int64 high)
{
var dist = Uniform.New(low, high);
var rng = Pcg32.Create(252, 11634580027462260723ul);
for (var i = 0; i < 10000; i++)
{
var result = dist.Sample(rng);
Assert.True(low <= result);
Assert.True(result < high);
}
}
public void SampleInclusiveSByte(SByte low, SByte high)
{
var dist = Uniform.NewInclusive(low, high);
var rng = Pcg32.Create(252, 11634580027462260723ul);
for (var i = 0; i < 10000; i++)
{
var result = dist.Sample(rng);
Assert.True(low <= result);
Assert.True(result <= high);
}
}
public Level Generate(SimulationParameters parameters, Int32 rngSeed)
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
IRng rng = Pcg32.Create((UInt64)rngSeed, 0);
// Generate the terrain and ensure that the starting square isn't completely blocked in
TerrainType[,] terrain = Generate(parameters, rng);
return(new Level(terrain, new ProtoLevel(parameters, this, rngSeed)));
}
/// <summary>
/// Generate the XOR key for a specific PRNG seed.
/// </summary>
/// <param name="seed">Seed</param>
/// <param name="outputLength">Output length</param>
/// <returns>XOR key</returns>
static byte[] GenerateXorKey(ulong seed, int outputLength)
{
var buffer = new byte[256];
var key = new byte[outputLength];
var component = new byte[outputLength];
// Initialize random generator
var prng = new Pcg32(seed, 0);
// Each key is generated over 16 iterations
for (int i = 0; i < 16; ++i)
{
// Generate base array
for (int j = 0; j < buffer.Length; ++j)
{
buffer[j] = (byte)j;
}
// Shuffle array
for (int j = buffer.Length - 1; j >= 1; --j)
{
var index = prng.GenerateNext((uint)j + 1);
var old = buffer[index];
buffer[index] = buffer[j];
buffer[j] = old;
}
// We only need the first N elements
Array.Copy(buffer, 0, component, 0, component.Length);
// Generate limit
var part1 = prng.GenerateNext();
var part2 = prng.GenerateNext();
ulong limit = ((ulong)part2 << 32) | part1;
// Sort
FastShittySort(component, limit);
// XOR with current candidate
for (int j = 0; j < key.Length; ++j)
{
key[j] ^= component[j];
}
// Reverse candidate
Array.Reverse(key);
}
// Return key
return(key);
}
public RngUInt32()
{
_chaCha8 = ChaCha.GetChaCha8Factory().Create(new ChaCha.Seed());
_chaCha12 = ChaCha.GetChaCha12Factory().Create(new ChaCha.Seed());
_chaCha20 = ChaCha.GetChaCha20Factory().Create(new ChaCha.Seed());
_pcg32 = Rngs.Pcg32.Create(0, 0);
_mt1993764 = Rngs.Mt1993764.Create(0);
_xorShift = Rngs.XorShift.Create(1, 1, 1, 1);
_systemCryptoRng = Rngs.SystemCryptoRng.Create();
#pragma warning disable CS0618
_cryptoServiceProvider = Rngs.CryptoServiceProvider.Create();
#pragma warning restore CS0618
_random = new Random(42);
}
public void SampleExclusive(Int64 lowInt, Int64 highInt)
{
var low = TimeSpan.FromTicks(lowInt);
var high = TimeSpan.FromTicks(highInt);
var dist = Uniform.New(low, high);
var rng = Pcg32.Create(252, 11634580027462260723ul);
for (var i = 0; i < 10000; i++)
{
var result = dist.Sample(rng);
Assert.True(low <= result);
Assert.True(result < high);
}
}
public void DoubleRange(Double low, Double high)
{
var rng = Pcg32.Create(252, 11634580027462260723ul);
var zeroRng = new StepRng(0)
{
Increment = 0
};
var maxRng = new StepRng(0xFFFF_FFFF_FFFF_FFFF)
{
Increment = 0
};
var uniform = Uniform.New(low, high);
var inclusiveUniform = Uniform.NewInclusive(low, high);
for (var i = 0; i < 100; i++)
{
var exclusive = uniform.Sample(rng);
Assert.True(low <= exclusive && exclusive < high, $"Exclusive sampling of RNG failed; low: {low}, high: {high}, actual: {exclusive}");
var inclusive = uniform.Sample(rng);
Assert.True(low <= inclusive && inclusive <= high, $"Inclusive sampling of RNG failed; low: {low}, high: {high}, actual: {inclusive}");
}
Assert.Equal(low, Uniform.NewInclusive(low, low).Sample(rng));
Assert.Equal(low, uniform.Sample(zeroRng));
Assert.Equal(low, inclusiveUniform.Sample(zeroRng));
Assert.True(uniform.Sample(maxRng) < high, $"Exclusive sampling of Max RNG failed; low: {low}, high: {high}, actual: {uniform.Sample(maxRng)}");
Assert.True(inclusiveUniform.Sample(maxRng) <= high, $"Inclusive sampling of Max RNG failed; low: {low}, high: {high}, actual: {inclusiveUniform.Sample(maxRng):G19}");
// Don't run this test for really tiny differences between high and low
// since for those rounding might result in selecting high for a very
// long time.
if (high - low <= 0.0001)
{
return;
}
var loweringMaxRng = new StepRng(0xFFFF_FFFF_FFFF_FFFF)
{
Increment = unchecked ((UInt64)(-1L << 12))
};
Assert.True(uniform.Sample(loweringMaxRng) < high);
Assert.True(uniform.Sample(loweringMaxRng) < high);
}
public void FloatTest(Decimal low, Decimal high)
{
var rng = Pcg32.Create(252, 11634580027462260723ul);
var zeroRng = new StepRng(0)
{
Increment = 0
};
var maxRng = new StepRng(0xFFFF_FFFF_FFFF_FFFF)
{
Increment = 0
};
var exclusiveUniform = Uniform.New(low, high);
var inclusiveUniform = Uniform.NewInclusive(low, high);
for (var i = 0; i < 100; i++)
{
var exclusive = exclusiveUniform.Sample(rng);
Assert.True(low <= exclusive && exclusive < high);
var inclusive = exclusiveUniform.Sample(rng);
Assert.True(low <= inclusive && inclusive <= high);
}
Assert.Equal(low, Uniform.NewInclusive(low, low).Sample(rng));
Assert.Equal(low, exclusiveUniform.Sample(zeroRng));
Assert.Equal(low, inclusiveUniform.Sample(zeroRng));
Assert.True(exclusiveUniform.Sample(maxRng) < high);
Assert.True(inclusiveUniform.Sample(maxRng) <= high);
var loweringMaxRng = new StepRng(0xFFFF_FFFF_FFFF_FFFF)
{
Increment = unchecked ((UInt64)(-1L << 12))
};
Assert.True(exclusiveUniform.Sample(loweringMaxRng) < high);
Assert.True(exclusiveUniform.Sample(loweringMaxRng) < high);
var maxDoubleInclusive = Uniform.NewInclusive(Decimal.MaxValue, Decimal.MaxValue);
Assert.Equal(Decimal.MaxValue, maxDoubleInclusive.Sample(rng));
var minDoubleInclusive = Uniform.NewInclusive(-Decimal.MaxValue, -Decimal.MaxValue);
Assert.Equal(-Decimal.MaxValue, minDoubleInclusive.Sample(rng));
}
public void MinMax()
{
var rng = Pcg32.Create(252, 11634580027462260723ul);
var maxSingleInclusive = Uniform.NewInclusive(Single.MaxValue, Single.MaxValue);
Assert.Equal(Single.MaxValue, maxSingleInclusive.Sample(rng));
var minSingleInclusive = Uniform.NewInclusive(-Single.MaxValue, -Single.MaxValue);
Assert.Equal(-Single.MaxValue, minSingleInclusive.Sample(rng));
var maxDoubleInclusive = Uniform.NewInclusive(Double.MaxValue, Double.MaxValue);
Assert.Equal(Double.MaxValue, maxDoubleInclusive.Sample(rng));
var minDoubleInclusive = Uniform.NewInclusive(-Double.MaxValue, -Double.MaxValue);
Assert.Equal(-Double.MaxValue, minDoubleInclusive.Sample(rng));
}
public void Test()
{
var rng = new Pcg32(42, 54);
foreach (var round in Pcg32Rounds)
{
foreach (var expected in round.RandomNumbers)
{
Assert.Equal(expected, rng.GenerateNext());
}
rng.Advance((ulong)-round.RandomNumbers.Length);
foreach (var expected in round.RandomNumbers)
{
Assert.Equal(expected, rng.GenerateNext());
}
foreach (var coin in round.Coins)
{
Assert.Equal(coin, (int)rng.GenerateNext(2));
}
foreach (var roll in round.Rolls)
{
Assert.Equal(roll, (int)rng.GenerateNext(6) + 1);
}
var cards = Enumerable.Range(0, 52).ToArray();
for (var i = cards.Length; i > 1; i--)
{
var chosen = rng.GenerateNext((uint)i);
var card = cards[chosen];
cards[chosen] = cards[i - 1];
cards[i - 1] = card;
}
string actual = string.Join(" ", cards.Select(x => $"{"A23456789TJQK"[x / 4]}{"hcds"[x % 4]}"));
Assert.Equal(round.Cards, actual);
}
}
private SmallRng(Pcg32 wrapped) => _wrapped = wrapped;
public IntelligentRandomAi(Int32 seed)
{
_seed = seed;
_rng = Pcg32.Create((UInt64)seed, 0);
}
private static readonly Bernoulli _wallClearChance = Bernoulli.FromRatio(1, 5); // 20% chance of clearing a wall
public Level Generate(SimulationParameters parameters, Int32 rngSeed)
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
Pcg32 rng = Pcg32.Create((UInt64)rngSeed, 0);
Int32 width = parameters.BottomRight.X + 1;
Int32 height = parameters.BottomRight.Y + 1;
TerrainType[,] terrain = new TerrainType[width, height];
Position start = parameters.InitialPosition;
Stack <CoordinatePair> stack = new Stack <CoordinatePair>();
HashSet <CoordinatePair> visited = new HashSet <CoordinatePair>();
stack.Push(start);
visited.Add(start);
terrain[start.X, start.Y] = TerrainType.Smooth;
while (stack.Count > 0)
{
var current = stack.Peek();
Int32 offset = _directionDist.Sample(rng);
Boolean anyNewNeighbors = false;
for (Int32 i = 0; i < Direction.DirectionCount; i++)
{
Direction direction = (Direction)((i + offset) % Direction.DirectionCount);
var passage = current + direction;
var neighbor = passage + direction;
var boundaryCheck = neighbor + direction;
if (!parameters.BottomRight.Contains(boundaryCheck) || visited.Contains(neighbor))
{
continue;
}
anyNewNeighbors = true;
terrain[passage.X, passage.Y] = TerrainType.Smooth;
terrain[neighbor.X, neighbor.Y] = TerrainType.Smooth;
visited.Add(neighbor);
stack.Push(neighbor);
}
if (!anyNewNeighbors)
{
if (_wallClearChance.Sample(rng))
{
Direction direction = (Direction)_directionDist.Sample(rng);
var passage = current + direction;
var boundaryCheck = passage + direction;
if (parameters.BottomRight.Contains(boundaryCheck) && terrain[passage.X, passage.Y] == TerrainType.Impassable)
{
terrain[passage.X, passage.Y] = TerrainType.Rough;
}
}
stack.Pop();
}
}
return(new Level(terrain, new ProtoLevel(parameters, this, rngSeed)));
}
