public void ShuffleListInPlaceLosesDupesNoElements() { List <int> list = CreateLinearList(100); list.Shuffle(XorShift128Plus.Create(seed)); ValidateItemExistenceAndUniqueness(list); }
public void ShuffleArrayInPlaceEmptyCollection() { int[] array = CreateLinearArray(0); array.Shuffle(XorShift128Plus.Create(seed)); Assert.IsNotNull(array); Assert.AreEqual(0, array.Length); }
public void ShuffleMoveAllListInPlaceMaintainsCycle() { List <int> list = CreateLinearList(100); list.Shuffle(XorShift128Plus.Create(seed), true); ValidateIsCycle(list); }
public void ShuffleMoveAllLinkedListCopyMaintainsCycle() { LinkedList <int> list = CreateLinearLinkedList(100); int[] shuffledArray = (int[])list.ShuffleInto(new int[100], XorShift128Plus.Create(seed), true); ValidateIsCycle(shuffledArray); }
public void ShuffleMoveAllListInPlaceMovesAll() { List <int> list = CreateLinearList(100); list.Shuffle(XorShift128Plus.Create(seed), true); ValidateAllAreMoved(list); }
public void ShuffleArrayCopyEmptyCollection() { int[] array = CreateLinearArray(0); int[] shuffledArray = (int[])array.ShuffleInto(new int[0], XorShift128Plus.Create(seed)); Assert.IsNotNull(shuffledArray); Assert.AreEqual(0, shuffledArray.Length); }
public void ShuffleLinkedListCopyLosesDupesNoElements() { LinkedList <int> list = CreateLinearLinkedList(100); int[] shuffledArray = (int[])list.ShuffleInto(new int[100], XorShift128Plus.Create(seed)); ValidateItemExistenceAndUniqueness(shuffledArray); }
public void ClosedDoubleUnitRange(int sampleSizePercentage) { ValidateClosedDoubleUnitRange(10000, SystemRandom.Create(seed), sampleSizePercentage); ValidateClosedDoubleUnitRange(10000, SplitMix64.Create(seed), sampleSizePercentage); ValidateClosedDoubleUnitRange(10000, XorShift128Plus.Create(seed), sampleSizePercentage); ValidateClosedDoubleUnitRange(10000, XoroShiro128Plus.Create(seed), sampleSizePercentage); ValidateClosedDoubleUnitRange(10000, XorShift1024Star.Create(seed), sampleSizePercentage); }
public void ClosedDoubleUnitThousandBucketDistribution(int sampleSizePercentage) { ValidateClosedDoubleUnitBucketDistribution(SystemRandom.Create(seed), 1000, 100, 0.15f, sampleSizePercentage); ValidateClosedDoubleUnitBucketDistribution(SplitMix64.Create(seed), 1000, 100, 0.15f, sampleSizePercentage); ValidateClosedDoubleUnitBucketDistribution(XorShift128Plus.Create(seed), 1000, 100, 0.15f, sampleSizePercentage); ValidateClosedDoubleUnitBucketDistribution(XoroShiro128Plus.Create(seed), 1000, 100, 0.15f, sampleSizePercentage); ValidateClosedDoubleUnitBucketDistribution(XorShift1024Star.Create(seed), 1000, 100, 0.15f, sampleSizePercentage); }
public void HalfClosedFloatUnitTenBucketDistribution(int sampleSizePercentage) { ValidateHalfClosedFloatUnitBucketDistribution(SystemRandom.Create(seed), 10, 10000, 0.015f, sampleSizePercentage); ValidateHalfClosedFloatUnitBucketDistribution(SplitMix64.Create(seed), 10, 10000, 0.015f, sampleSizePercentage); ValidateHalfClosedFloatUnitBucketDistribution(XorShift128Plus.Create(seed), 10, 10000, 0.015f, sampleSizePercentage); ValidateHalfClosedFloatUnitBucketDistribution(XoroShiro128Plus.Create(seed), 10, 10000, 0.015f, sampleSizePercentage); ValidateHalfClosedFloatUnitBucketDistribution(XorShift1024Star.Create(seed), 10, 10000, 0.015f, sampleSizePercentage); }
public void ShuffleLinkedListCopyEmptyCollection() { LinkedList <int> list = CreateLinearLinkedList(0); int[] shuffledArray = (int[])list.ShuffleInto(new int[0], XorShift128Plus.Create(seed)); Assert.IsNotNull(shuffledArray); Assert.AreEqual(0, shuffledArray.Length); }
public void ShuffleListInPlaceEmptyCollection() { List <int> list = CreateLinearList(0); list.Shuffle(XorShift128Plus.Create(seed)); Assert.IsNotNull(list); Assert.AreEqual(0, list.Count); }
private static void ValidateByNameEnumDistributesWithCorrectWeights <TEnum>(int itemsPerBucket, float tolerance, int sampleSizePercentage) where TEnum : struct { itemsPerBucket = (itemsPerBucket * sampleSizePercentage) / 100; tolerance = (tolerance * 100) / sampleSizePercentage; var random = XorShift128Plus.Create(seed); var weights = new Dictionary <string, int>(); int weightSum = 0; var buckets = new Dictionary <TEnum, int>(); var enumNames = System.Enum.GetNames(typeof(TEnum)); foreach (var name in enumNames) { int weight = random.RangeCC(3, 10); weights.Add(name, weight); weightSum += weight; } foreach (var name in enumNames) { TEnum enumValue = (TEnum)System.Enum.Parse(typeof(TEnum), name); int currentTarget; if (buckets.TryGetValue(enumValue, out currentTarget)) { buckets[enumValue] = currentTarget + itemsPerBucket * enumNames.Length * weights[name] / weightSum; } else { buckets.Add(enumValue, itemsPerBucket * enumNames.Length * weights[name] / weightSum); } } int iterations = 0; foreach (var target in buckets.Values) { iterations += target; } var generator = random.MakeWeightedEnumGenerator <TEnum>((System.Func <string, int>)((string name) => weights[name])); for (int i = 0; i < iterations; ++i) { int currentTarget; TEnum enumValue = generator.Next(); if (buckets.TryGetValue(enumValue, out currentTarget)) { buckets[enumValue] = currentTarget - 1; } else { Assert.Fail("An invalid enum value was generated."); } } int[] bucketsArray = new int[buckets.Count]; buckets.Values.CopyTo(bucketsArray, 0); Assert.LessOrEqual(RandomeEngineTests.CalculateStandardDeviation(bucketsArray, 0), tolerance * itemsPerBucket); }
public void ProbabilityNumeratorUInt32(int sampleSizePercentage) { var random = XorShift128Plus.Create(seed); ValidateDistribution(10000, () => random.Probability(1638286494U), 0.381443298887f, 0.02f, sampleSizePercentage); var generator = XorShift128Plus.Create(seed).MakeProbabilityGenerator(1638286494U); ValidateDistribution(10000, () => generator.Next(), 0.381443298887f, 0.02f, sampleSizePercentage); }
public void ProbabilityNumeratorFloat(int sampleSizePercentage) { var random = XorShift128Plus.Create(seed); ValidateDistribution(10000, () => random.Probability(0.381443298969f), 0.381443298969f, 0.02f, sampleSizePercentage); var generator = XorShift128Plus.Create(seed).MakeProbabilityGenerator(0.381443298969f); ValidateDistribution(10000, () => generator.Next(), 0.381443298969f, 0.02f, sampleSizePercentage); }
public void WeightedProbabilityDenominatorDouble(int sampleSizePercentage) { var random = XorShift128Plus.Create(seed); ValidateDistribution(10000, () => random.Probability(37d, 97d), 0.381443298969f, 0.02f, sampleSizePercentage); var generator = XorShift128Plus.Create(seed).MakeProbabilityGenerator(37d, 97d); ValidateDistribution(10000, () => generator.Next(), 0.381443298969f, 0.02f, sampleSizePercentage); }
public void UniformBit(int sampleSizePercentage) { var random = XorShift128Plus.Create(seed); ValidateBitDistribution32(10000, () => random.Bit(), 1, 0.1f, sampleSizePercentage); var generator = XorShift128Plus.Create(seed).MakeBitGenerator(); ValidateBitDistribution32(10000, () => generator.Next(), 1, 0.1f, sampleSizePercentage); }
public void WeightedChanceUInt64(int sampleSizePercentage) { var random = XorShift128Plus.Create(seed); ValidateDistribution(10000, () => random.Chance(37UL, 60UL), 0.381443298969f, 0.02f, sampleSizePercentage); var generator = XorShift128Plus.Create(seed).MakeChanceGenerator(37UL, 60UL); ValidateDistribution(10000, () => generator.Next(), 0.381443298969f, 0.02f, sampleSizePercentage); }
public void UniformChance(int sampleSizePercentage) { var random = XorShift128Plus.Create(seed); ValidateDistribution(10000, () => random.Chance(), 0.5f, 0.02f, sampleSizePercentage); var generator = XorShift128Plus.Create(seed).MakeChanceGenerator(); ValidateDistribution(10000, () => generator.Next(), 0.5f, 0.02f, sampleSizePercentage); }
public void UniformBits64(int sampleSizePercentage) { for (int i = 1; i <= 64; ++i) { var random = XorShift128Plus.Create(seed); ValidateBitDistribution64(10000, () => random.Bits64(i), i, 0.1f, sampleSizePercentage); var generator = XorShift128Plus.Create(seed).MakeBits64Generator(i); ValidateBitDistribution64(10000, () => generator.Next(), i, 0.1f, sampleSizePercentage); } }
public void UnitVector4sAreLength1(int sampleSizePercentage) { int count = (10000 * sampleSizePercentage) / 100; var random = XorShift128Plus.Create(seed); for (int i = 0; i < count; ++i) { var v = random.UnitVector4(); Assert.AreEqual(1.0, v.sqrMagnitude, 0.0001); } }
public void ScaledVector2sAreLengthR(int sampleSizePercentage) { int count = (10000 * sampleSizePercentage) / 100; var random = XorShift128Plus.Create(seed); for (int i = 0; i < count; ++i) { var l = random.RangeCC(2f, 8f); var l2 = l * l; var v = random.ScaledVector2(l); Assert.AreEqual(l2, v.sqrMagnitude, l2 * 0.0001); } }
protected void OnEnable() { if (_random == null) { _random = XorShift128Plus.Create(randomSeedText); } if (_normalFaceTriangulation == null) { _normalFaceTriangulation = new SeparatedFacesUmbrellaTriangulation( (Topology.FaceEdge edge, DynamicMesh.IIndexedVertexAttributes vertexAttributes) => { vertexAttributes.normal = (_facePositions[edge.nearFace] + _surface.normal * 5f - vertexAttributes.position).normalized; vertexAttributes.uv = new Vector2(0.25f, 0f); vertexAttributes.Advance(); vertexAttributes.normal = (_facePositions[edge.nearFace] + _surface.normal * 5f - vertexAttributes.position).normalized; vertexAttributes.uv = new Vector2(0.25f, 0.5f); vertexAttributes.Advance(); }, (Topology.Face face, DynamicMesh.IIndexedVertexAttributes vertexAttributes) => { vertexAttributes.uv = new Vector2(0.25f, 1f); vertexAttributes.Advance(); }); } if (_selectedFaceTriangulation == null) { _selectedFaceTriangulation = new SeparatedFacesUmbrellaTriangulation( (Topology.FaceEdge edge, DynamicMesh.IIndexedVertexAttributes vertexAttributes) => { vertexAttributes.normal = (_facePositions[edge.nearFace] + _surface.normal * 1f - vertexAttributes.position).normalized; vertexAttributes.uv = new Vector2(0.75f, 0f); vertexAttributes.Advance(); vertexAttributes.normal = (_facePositions[edge.nearFace] + _surface.normal * 1f - vertexAttributes.position).normalized; vertexAttributes.uv = new Vector2(0.75f, 0.5f); vertexAttributes.Advance(); }, (Topology.Face face, DynamicMesh.IIndexedVertexAttributes vertexAttributes) => { vertexAttributes.uv = new Vector2(0.75f, 1f); vertexAttributes.Advance(); }); } }
protected void OnEnable() { if (!_initialized) { _random = XorShift128Plus.Create(948675); _faceTriangulation = new SeparatedFacesUmbrellaTriangulation( (Topology.FaceEdge edge, DynamicMesh.IIndexedVertexAttributes vertexAttributes) => { var face = edge.nearFace; var gridOverlayU = GetGridOverlayU(false, _faceSeenStates[face], _faceSightCounts[face]); vertexAttributes.uv2 = new Vector2(gridOverlayU, 0f); vertexAttributes.Advance(); vertexAttributes.uv2 = new Vector2(gridOverlayU, 0.5f); vertexAttributes.Advance(); }, (Topology.Face face, DynamicMesh.IIndexedVertexAttributes vertexAttributes) => { vertexAttributes.uv2 = new Vector2(GetGridOverlayU(false, _faceSeenStates[face], _faceSightCounts[face]), 1f); vertexAttributes.Advance(); }); _selectedFaceTriangulation = new SeparatedFacesUmbrellaTriangulation( (Topology.FaceEdge edge, DynamicMesh.IIndexedVertexAttributes vertexAttributes) => { var face = edge.nearFace; var gridOverlayU = GetGridOverlayU(true, _faceSeenStates[face], _faceSightCounts[face]); vertexAttributes.uv2 = new Vector2(gridOverlayU, 0f); vertexAttributes.Advance(); vertexAttributes.uv2 = new Vector2(gridOverlayU, 0.5f); vertexAttributes.Advance(); }, (Topology.Face face, DynamicMesh.IIndexedVertexAttributes vertexAttributes) => { vertexAttributes.uv2 = new Vector2(GetGridOverlayU(true, _faceSeenStates[face], _faceSightCounts[face]), 1f); vertexAttributes.Advance(); }); _pathFinder = new PathFinder(); _initialized = true; } }
private static void ValidateByNameEnumDistributesUniformly <TEnum>(int itemsPerBucket, float tolerance, int sampleSizePercentage) where TEnum : struct { itemsPerBucket = (itemsPerBucket * sampleSizePercentage) / 100; tolerance = (tolerance * 100) / sampleSizePercentage; var buckets = new Dictionary <TEnum, int>(); var enumValues = System.Enum.GetValues(typeof(TEnum)); foreach (var value in enumValues) { TEnum enumValue = (TEnum)value; int currentTarget; if (buckets.TryGetValue(enumValue, out currentTarget)) { buckets[enumValue] = currentTarget + itemsPerBucket; } else { buckets.Add(enumValue, itemsPerBucket); } } int iterations = itemsPerBucket * enumValues.Length; var random = XorShift128Plus.Create(seed); var generator = random.MakeEnumGenerator <TEnum>(true); for (int i = 0; i < iterations; ++i) { int currentTarget; TEnum enumValue = generator.Next(); if (buckets.TryGetValue(enumValue, out currentTarget)) { buckets[enumValue] = currentTarget - 1; } else { Assert.Fail("An invalid enum value was generated."); } } int[] bucketsArray = new int[buckets.Count]; buckets.Values.CopyTo(bucketsArray, 0); Assert.LessOrEqual(RandomeEngineTests.CalculateStandardDeviation(bucketsArray, 0), tolerance * itemsPerBucket); }
public void CreateDistortedHexGrid(int width, int height, int seed) { var hexGrid = RectangularHexGrid.Create(HexGridDescriptor.standardCornerUp, Vector3.zero, Quaternion.identity, false, false, new IntVector2(width, height)); surface = hexGrid; Vector3[] vertexPositionsArray; topology = hexGrid.CreateManifold(out vertexPositionsArray); vertexPositions = vertexPositionsArray.AsVertexAttribute(); var random = XorShift128Plus.Create(seed); var maxOffsetRadius = Mathf.Sqrt(3f) / 8f; foreach (var vertex in topology.vertices) { if (!vertex.hasExternalFaceNeighbor) { vertexPositions[vertex] += (Vector3)random.PointWithinCircle(maxOffsetRadius); } } facePositions = FaceAttributeUtility.CalculateFaceCentroidsFromVertexPositions(topology.internalFaces, vertexPositions); partitioning = UniversalFaceSpatialPartitioning.Create(surface, topology, vertexPositions); }
public void CreateDistortedQuadGrid(int width, int height, int seed) { var quadGrid = RectangularQuadGrid.Create(Vector2.right, Vector2.up, Vector3.zero, Quaternion.identity, false, false, new IntVector2(width, height)); surface = quadGrid; Vector3[] vertexPositionsArray; topology = quadGrid.CreateManifold(out vertexPositionsArray); vertexPositions = vertexPositionsArray.AsVertexAttribute(); var random = XorShift128Plus.Create(seed); var maxOffsetRadius = Mathf.Sqrt(2f) / 5f; for (int y = 1; y < height; ++y) { for (int x = 1; x < width; ++x) { vertexPositions[quadGrid.GetVertexIndex(x, y)] += (Vector3)random.PointWithinCircle(maxOffsetRadius); } } facePositions = FaceAttributeUtility.CalculateFaceCentroidsFromVertexPositions(topology.internalFaces, vertexPositions); partitioning = UniversalFaceSpatialPartitioning.Create(surface, topology, vertexPositions); }
public void UnitVector2sUniformlyDistributed(int sampleSizePercentage) { var bucketCount = 72; var hitsPerBucket = 144; var tolerance = 0.1f; hitsPerBucket = (hitsPerBucket * sampleSizePercentage) / 100; tolerance = (tolerance * 100) / sampleSizePercentage; var random = XorShift128Plus.Create(seed); var buckets = new int[bucketCount]; var twoPi = Mathf.PI * 2f; for (int i = 0; i < bucketCount * hitsPerBucket; ++i) { var v = random.UnitVector2(); var a = Mathf.Atan2(v.y, v.x); buckets[Mathf.FloorToInt((a + Mathf.PI) * bucketCount / twoPi)] += 1; } Assert.LessOrEqual(RandomeEngineTests.CalculateStandardDeviation(buckets, hitsPerBucket), tolerance * hitsPerBucket); }
private static void ValidateShuffleDistributesUniformly(int bucketCount, int iterations, float tolerance, System.Func <IRandom, IList <int> > shuffle, int sampleSizePercentage) { iterations = (iterations * sampleSizePercentage) / 100; tolerance = (tolerance * 100) / sampleSizePercentage; var hitsPerBucket = (bucketCount / 2) * iterations; int[] sumArray = new int[bucketCount]; var random = XorShift128Plus.Create(seed); for (int i = 0; i < iterations; ++i) { IList <int> list = shuffle(random); for (int j = 0; j < list.Count; ++j) { sumArray[j] += list[j]; } } Assert.LessOrEqual(RandomeEngineTests.CalculateStandardDeviation(sumArray, hitsPerBucket), tolerance * hitsPerBucket); }
//[UnityEditor.MenuItem("Assets/MakeIt.Random/Calculate Arch Identity Test Values")] public static void CalculateAllTestValues() { string dataFilePath = Path.GetFullPath("Packages/com.andygainey.makeit.random/Tests/Editor/Random/Data~/"); Directory.CreateDirectory(dataFilePath); CalculateTestValues(XorShift128Plus.Create(seed), "Next32", (IRandom random, BinaryWriter writer) => { writer.Write(random.Next32()); }, next32Count); CalculateTestValues(XorShift1024Star.Create(seed), "Next32", (IRandom random, BinaryWriter writer) => { writer.Write(random.Next32()); }, next32Count); CalculateTestValues(XoroShiro128Plus.Create(seed), "Next32", (IRandom random, BinaryWriter writer) => { writer.Write(random.Next32()); }, next32Count); CalculateTestValues(XorShiftAdd.Create(seed), "Next32", (IRandom random, BinaryWriter writer) => { writer.Write(random.Next32()); }, next32Count); CalculateTestValues(SplitMix64.Create(seed), "Next32", (IRandom random, BinaryWriter writer) => { writer.Write(random.Next32()); }, next32Count); CalculateTestValues(XorShift128Plus.Create(seed), "Next64", (IRandom random, BinaryWriter writer) => { writer.Write(random.Next64()); }, next64Count); CalculateTestValues(XorShift1024Star.Create(seed), "Next64", (IRandom random, BinaryWriter writer) => { writer.Write(random.Next64()); }, next64Count); CalculateTestValues(XoroShiro128Plus.Create(seed), "Next64", (IRandom random, BinaryWriter writer) => { writer.Write(random.Next64()); }, next64Count); CalculateTestValues(XorShiftAdd.Create(seed), "Next64", (IRandom random, BinaryWriter writer) => { writer.Write(random.Next64()); }, next64Count); CalculateTestValues(SplitMix64.Create(seed), "Next64", (IRandom random, BinaryWriter writer) => { writer.Write(random.Next64()); }, next64Count); CalculateTestValues(XorShift128Plus.Create(seed), "IntRange", (IRandom random, BinaryWriter writer) => { writer.Write(random.RangeCO(71, 1500)); }, intRangeCount); CalculateTestValues(XorShift128Plus.Create(seed), "IntRange_Pow2", (IRandom random, BinaryWriter writer) => { writer.Write(random.RangeCO(71, 1095)); }, intRangeCount); CalculateTestValues(XorShift128Plus.Create(seed), "FloatOO", (IRandom random, BinaryWriter writer) => { writer.Write(random.FloatOO()); }, floatRangeCount); CalculateTestValues(XorShift128Plus.Create(seed), "FloatCO", (IRandom random, BinaryWriter writer) => { writer.Write(random.FloatCO()); }, floatRangeCount); CalculateTestValues(XorShift128Plus.Create(seed), "FloatOC", (IRandom random, BinaryWriter writer) => { writer.Write(random.FloatOC()); }, floatRangeCount); CalculateTestValues(XorShift128Plus.Create(seed), "FloatCC", (IRandom random, BinaryWriter writer) => { writer.Write(random.FloatCC()); }, floatRangeCount); CalculateTestValues(XorShift128Plus.Create(seed), "DoubleOO", (IRandom random, BinaryWriter writer) => { writer.Write(random.DoubleOO()); }, floatRangeCount); CalculateTestValues(XorShift128Plus.Create(seed), "DoubleCO", (IRandom random, BinaryWriter writer) => { writer.Write(random.DoubleCO()); }, floatRangeCount); CalculateTestValues(XorShift128Plus.Create(seed), "DoubleOC", (IRandom random, BinaryWriter writer) => { writer.Write(random.DoubleOC()); }, floatRangeCount); CalculateTestValues(XorShift128Plus.Create(seed), "DoubleCC", (IRandom random, BinaryWriter writer) => { writer.Write(random.DoubleCC()); }, floatRangeCount); CalculateTestValues(XorShift128Plus.Create(seed), "UnitVector2", (IRandom random, BinaryWriter writer) => { writer.Write(random.UnitVector2()); }, geometryRangeCount); CalculateTestValues(XorShift128Plus.Create(seed), "UnitVector3", (IRandom random, BinaryWriter writer) => { writer.Write(random.UnitVector3()); }, geometryRangeCount); CalculateTestValues(XorShift128Plus.Create(seed), "UnitVector4", (IRandom random, BinaryWriter writer) => { writer.Write(random.UnitVector4()); }, geometryRangeCount); CalculateTestValues(XorShift128Plus.Create(seed), "Rotation", (IRandom random, BinaryWriter writer) => { writer.Write(random.Rotation()); }, geometryRangeCount); CalculateTestValues(XorShift128Plus.Create(seed), "PointWithinCircle", (IRandom random, BinaryWriter writer) => { writer.Write(random.PointWithinCircle()); }, geometryRangeCount); CalculateTestValues(XorShift128Plus.Create(seed), "PointWithinSphere", (IRandom random, BinaryWriter writer) => { writer.Write(random.PointWithinSphere()); }, geometryRangeCount); }