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);
}
