public void Bytes() { var rng = new StepRng(0); Random random = RandomShim.Create(rng); var buffer = new Byte[1024]; random.NextBytes(buffer); var ints = MemoryMarshal.Cast <Byte, UInt64>(buffer); for (Int32 i = 0; i < ints.Length; i++) { Assert.Equal((UInt64)i, ints[i]); } #if !NET472 random.NextBytes(buffer.AsSpan()); for (Int32 i = 0; i < ints.Length; i++) { Assert.Equal((UInt64)(i + ints.Length), ints[i]); } #endif var maxRng = new StepRng(UInt64.MaxValue) { Increment = 0 }; var maxShim = RandomNumberGeneratorShim.Create(maxRng); buffer = new Byte[1024]; maxShim.GetBytes(buffer, 200, 500); Assert.All(buffer.Take(200), b => Assert.Equal(0, b)); Assert.All(buffer.Skip(200).Take(500), b => Assert.Equal(Byte.MaxValue, b)); Assert.All(buffer.Skip(700), b => Assert.Equal(0, b)); }
public void RejectionsInt64() { const Int64 midpoint = Int64.MaxValue / 2 + Int64.MinValue / 2; const Int64 low = Int64.MinValue; const Int64 high = midpoint + 1; const UInt64 maxRand = sizeof(Int64) > 4 ? UInt64.MaxValue : UInt32.MaxValue; const UInt64 rangeSize = unchecked ((UInt64)high - (UInt64)low + 1); const UInt64 rejectCount = (maxRand - rangeSize + 1) % rangeSize; const UInt64 lastAccepted = maxRand - rejectCount; var dist = Uniform.NewInclusive(low, high); var rng = new StepRng(lastAccepted - 1); Assert.True(dist.TrySample(rng, out Int64 result)); Assert.Equal(midpoint, result); Assert.True(dist.TrySample(rng, out result)); Assert.Equal(midpoint + 1, result); Assert.False(dist.TrySample(rng, out _)); Assert.False(dist.TrySample(rng, out _)); Assert.False(dist.TrySample(rng, out _)); // Now test a blocking sample rng.State = maxRand - Math.Min(20, rejectCount) + 1; Assert.Equal(Int64.MinValue, dist.Sample(rng)); }
public void Rejections() { const Int64 midpoint = Int64.MaxValue / 2 + Int64.MinValue / 2; const Int64 lowInt = Int64.MinValue; const Int64 highInt = midpoint + 1; const UInt64 maxRand = UInt64.MaxValue; const UInt64 rangeSize = unchecked (highInt - (UInt64)lowInt + 1); const UInt64 rejectCount = (maxRand - rangeSize + 1) % rangeSize; const UInt64 lastAccepted = maxRand - rejectCount; var low = TimeSpan.FromTicks(lowInt); var high = TimeSpan.FromTicks(highInt); var dist = Uniform.NewInclusive(low, high); var rng = new StepRng(lastAccepted - 1); Assert.True(dist.TrySample(rng, out TimeSpan result)); Assert.Equal(midpoint, result.Ticks); Assert.True(dist.TrySample(rng, out result)); Assert.Equal(midpoint + 1, result.Ticks); Assert.False(dist.TrySample(rng, out _)); Assert.False(dist.TrySample(rng, out _)); Assert.False(dist.TrySample(rng, out _)); // Now test a blocking sample rng.State = maxRand - Math.Min(20, rejectCount) + 1; Assert.Equal(TimeSpan.MinValue, dist.Sample(rng)); }
public void Next() { var rng = new StepRng(0); Random random = RandomShim.Create(rng); for (Int32 i = 0; i < 100; i++) { Assert.Equal(i, random.Next()); } for (Int32 i = 0; i < 100; i++) { Assert.Equal(i, random.Next(100)); } for (Int32 i = 0; i < 100; i++) { Assert.Equal(i, random.Next(0, 100)); } for (Int32 i = 0; i < 10_000; i++) { var value = random.NextDouble(); Assert.True(0 <= value && value < 1); } }
public void DecimalRanges() { var zeroRng = new StepRng(0) { Increment = 0 }; // Generates 0.0 var openZeroRng = new SequenceRng(new UInt32[] { 1, 0, 0 }); // Generates the lowest non-zero value var openOneRng = new SequenceRng(new UInt32[] { 0x1000_0000, 0x3E25_0261, 0x204F_CE5Du << 2 }); // Generates the value just under 1.0
public Extensions() { _rng = new StepRng(0); _list = new List <Int32> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 }; }
public void UnlikelyFalse() { // This distribution normally has a probably of success of 2^64 - 1 / 2^64, // so this is very unlikely to return false. var dist = Bernoulli.FromInverse(UInt64.MaxValue); // BUt we'll force it to anyway. var rng = new StepRng(UInt64.MaxValue); Assert.False(dist.Sample(rng)); }
public void FillViaNextCleanly() { var rng = new StepRng(0); var buffer = new UInt64[8]; Filler.FillBytesViaNext(rng, MemoryMarshal.Cast <UInt64, Byte>(buffer)); for (UInt32 i = 0; i < buffer.Length; i++) { Assert.Equal(i, buffer[i]); } }
public void BadArgs() { var rng = new StepRng(0); var shim = RandomNumberGeneratorShim.Create(rng); var bytes = new Byte[32]; Assert.Throws <ArgumentNullException>(() => shim.GetBytes(null !, 0, 10)); Assert.Throws <ArgumentOutOfRangeException>(() => shim.GetBytes(bytes, -10, 10)); Assert.Throws <ArgumentOutOfRangeException>(() => shim.GetBytes(bytes, 10, -10)); Assert.Throws <ArgumentException>(() => shim.GetBytes(bytes, 32, 1)); }
public void FillViaNext4BytesLeft() { var rng = new StepRng(0); var buffer = new UInt32[17]; Filler.FillBytesViaNext(rng, MemoryMarshal.Cast <UInt32, Byte>(buffer)); for (UInt32 i = 0; i < buffer.Length / 2; i += 2) { Assert.Equal(i / 2, buffer[i]); Assert.Equal(0u, buffer[i + 1]); } Assert.Equal(8u, buffer[16]); }
public void FillViaNext2BytesLeft() { var rng = new StepRng(0); var buffer = new UInt16[33]; Filler.FillBytesViaNext(rng, MemoryMarshal.Cast <UInt16, Byte>(buffer)); for (UInt32 i = 0; i < buffer.Length / 4; i += 4) { Assert.Equal(i / 4, buffer[i]); Assert.Equal(0u, buffer[i + 1]); Assert.Equal(0u, buffer[i + 2]); Assert.Equal(0u, buffer[i + 3]); } Assert.Equal(8u, buffer[32]); }
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 UniformDists() { _rng = new StepRng(0); _uniformSByte = Uniform.New((SByte)LowerBound, (SByte)UpperBound); _uniformInt16 = Uniform.New((Int16)LowerBound, (Int16)UpperBound); _uniformInt32 = Uniform.New(LowerBound, UpperBound); _uniformInt64 = Uniform.New((Int64)LowerBound, (Int64)UpperBound); _uniformByte = Uniform.New((Byte)LowerBound, (Byte)UpperBound); _uniformUInt16 = Uniform.New((UInt16)LowerBound, (UInt16)UpperBound); _uniformUInt32 = Uniform.New((UInt32)LowerBound, (UInt32)UpperBound); _uniformUInt64 = Uniform.New((UInt64)LowerBound, (UInt64)UpperBound); _uniformSingle = Uniform.New((Single)LowerBound, (Single)UpperBound); _uniformDouble = Uniform.New((Double)LowerBound, (Double)UpperBound); _uniformTimeSpan = Uniform.New(TimeSpan.FromHours(LowerBound), TimeSpan.FromHours(UpperBound)); }
public void DoubleRanges() { var zeroRng = new StepRng(0) { Increment = 0 }; var maxRng = new StepRng(UInt64.MaxValue) { Increment = 0 }; Double low, high; var closedOpen = ClosedOpen.Double.Instance; low = closedOpen.Sample(zeroRng); high = closedOpen.Sample(maxRng); Assert.Equal(0, low); Assert.True(0 < high && high < 1); var openClosed = OpenClosed.Double.Instance; low = openClosed.Sample(zeroRng); high = openClosed.Sample(maxRng); Assert.True(0 < low && low < 1); Assert.Equal(1, high); var closed = Closed.Double.Instance; low = closed.Sample(zeroRng); high = closed.Sample(maxRng); Assert.Equal(0, low); Assert.Equal(1, high); var open = Open.Double.Instance; low = open.Sample(zeroRng); high = open.Sample(maxRng); Assert.True(0 < low && low < 1); Assert.True(0 < high && high < 1); }
public void FullRange() { var rng = new StepRng(UInt64.MaxValue - 4); var dist = Uniform.NewInclusive(TimeSpan.MinValue, TimeSpan.MaxValue); _ = dist.Sample(rng); // Sample shouldn't need to retry // Mix up Sample and TrySample for the fun of it Assert.Equal(UInt64.MaxValue - 3, rng.State); Assert.True(dist.TrySample(rng, out _)); _ = dist.Sample(rng); Assert.True(dist.TrySample(rng, out _)); Assert.Equal(UInt64.MaxValue, rng.State); // The full range is a special case, where the distribution doesn't need to add _low, // so it simply casts directly to the result. The upshot of which is that signed and // unsigned distributions will behave differently, so we have to do bitwise comparisons // instead of using type.MaxValue and type.MinValue. Assert.Equal(TimeSpan.FromTicks(-1), dist.Sample(rng)); // 0 Assert.True(dist.TrySample(rng, out TimeSpan result)); // RNG wraps around to 0 Assert.Equal(TimeSpan.Zero, result); }
public void NextUInt32ViaUInt64(UInt64 initialRngState, UInt32 expected) { var rng = new StepRng(initialRngState); Assert.Equal(expected, Filler.NextUInt32ViaUInt64(rng)); }