protected override void OnCreate()
{
m_EndSimulationEcbSystem = World
.GetOrCreateSystem <EndSimulationEntityCommandBufferSystem>();
randomSystem = World.GetOrCreateSystem <RandomSystem>();
worldGridSystem = World.GetOrCreateSystem <WorldGridSystem>();
}
public void MedianTests(int maxCount)
{
Test.Begin("median tests");
foreach (var pm in new[] { false, true })
{
for (int count = 1; count <= maxCount; count *= 2)
{
var rnd = new RandomSystem(count);
var array = rnd.CreatePermutationArray(count);
var a = new int[count];
Test.Begin("{0}quick-median {1} items", pm ? "permutation " : "", count);
if (pm)
{
for (int i = 0; i < a.Length; i++)
{
a.SetByIndex(pi => pi);
a.PermutationQuickMedianAscending(array, i);
Test.IsTrue(array[a[i]] == i);
}
}
else
{
for (int i = 0; i < a.Length; i++)
{
array.CopyTo(a, 0);
a.QuickMedianAscending(i);
Test.IsTrue(a[i] == i);
}
}
Test.End();
}
}
Test.End();
}
public static void JulianDay()
{
var rnd = new RandomSystem(123);
TestDate(new DateTime(2019, 3, 5, 12, 0, 0, 0));
TestDate(new DateTime(2019, 3, 5, 12, 1, 0, 0));
TestDate(new DateTime(2019, 3, 5, 11, 59, 0, 0));
// https://en.wikipedia.org/wiki/Julian_day
// 00:30:00.0 UT January 1, 2013, is 2 456 293.520 833
var test2 = new DateTime(2013, 1, 1, 0, 30, 0);
TestDate(test2);
for (int i = 0; i < 10000000; i++)
{
var lg = rnd.UniformLong();
if (lg > DateTime.MaxValue.Ticks || lg < DateTime.MinValue.Ticks)
{
continue;
}
var dt = new DateTime(lg);
TestDate(dt);
}
Report.Line("Times: (NOTE benchmark meaningless, measurement of first algorithm will always have x3 time)");
Report.Line("GetDatePart: {0}ms", sw0.Elapsed.TotalMilliseconds);
Report.Line("ComputeJulianDayNREL: {0}ms", sw1.Elapsed.TotalMilliseconds);
Report.Line("ComputeJulianDayInt2: {0}ms", sw2.Elapsed.TotalMilliseconds);
Report.Line("ComputeJulianDayMeeus: {0}ms", sw3.Elapsed.TotalMilliseconds);
Report.Line("ComputeJulianDayInt: {0}ms", sw4.Elapsed.TotalMilliseconds);
Report.Line("ComputeJulianDayRaw: {0}ms", sw5.Elapsed.TotalMilliseconds);
}
public static void MatrixRepresentation()
{
var rnd = new RandomSystem(1);
for (int i = 0; i < iterations; i++)
{
var q1 = GetRandomQuat(rnd);
var q2 = GetRandomQuat(rnd);
var m1 = (M44d)q1;
var m2 = (M44d)q2;
var q1_plus_q2 = (M44d)(q1 + q2);
var m1_plus_m2 = m1 + m2;
var q1q2 = (M44d)(q1 * q2);
var m1m2 = m1 * m2;
var q2q1 = (M44d)(q2 * q1);
var m2m1 = m2 * m1;
Assert.IsTrue(Fun.ApproximateEquals(q1_plus_q2, m1_plus_m2, 0.00001));
Assert.IsTrue(Fun.ApproximateEquals(q1q2, m1m2, 0.00001));
Assert.IsTrue(Fun.ApproximateEquals(q2q1, m2m1, 0.00001));
}
}
public static void OrthoNormalOrientation()
{
// Previous implementation
Func <Trafo3d, Trafo3d> reference = trafo =>
{
var x = trafo.Forward.C0.XYZ.Normalized; // TransformDir(V3f.XAxis)
var y = trafo.Forward.C1.XYZ.Normalized; // TransformDir(V3f.YAxis)
var z = trafo.Forward.C2.XYZ.Normalized; // TransformDir(V3f.ZAxis)
y = z.Cross(x).Normalized;
z = x.Cross(y).Normalized;
return(Trafo3d.FromBasis(x, y, z, V3d.Zero));
};
var rnd = new RandomSystem(1);
TrafoTesting.GenericTest(rnd =>
{
var trafo = TrafoTesting.GetRandomTrafo(rnd);
var res = trafo.GetOrthoNormalOrientation();
var res_ref = reference(trafo);
TrafoTesting.AreEqual(res, res_ref);
});
}
protected override void OnCreate()
{
base.OnCreate();
_endSimulationEcbSystem = World.GetOrCreateSystem <EndSimulationEntityCommandBufferSystem>();
_randomSystem = World.GetOrCreateSystem <RandomSystem>();
}
public void CreateStringTable(int count, int subCount)
{
Report.BeginTimed("creating string table with {0} items", count);
m_stringTable = new string[count];
for (int i = 0; i < count; i++)
{
m_stringTable[i] = Guid.NewGuid().ToString();
}
//+ Guid.NewGuid().ToString() + Guid.NewGuid().ToString()
//+ Guid.NewGuid().ToString() + Guid.NewGuid().ToString();
Report.End();
m_symbolTable = new Symbol[count];
Report.BeginTimed("create symbols from strings");
for (int i = 0; i < count; i++)
{
m_symbolTable[i] = Symbol.Create(m_stringTable[i]);
}
Report.End();
Report.BeginTimed("create subset");
var rnd = new RandomSystem(13);
var perm = rnd.CreatePermutationArray(count);
m_stringSubsetTable = new string[subCount];
m_symbolSubsetTable = new Symbol[subCount];
for (int i = 0; i < subCount; i++)
{
m_stringSubsetTable[i] = m_stringTable[perm[i]];
m_symbolSubsetTable[i] = m_symbolTable[perm[i]];
}
Report.End();
}
public __type__()
{
var rnd = new RandomSystem(1);
indices.SetByIndex(i => rnd.UniformV2i(__n__));
vectors.SetByIndex(i => new __vtype__(rnd.CreateUniformDoubleArray(__n__)));
matrices.SetByIndex(i => new __nmtype__(rnd.CreateUniformDoubleArray(__nm__)));
}
public MatrixMinor()
{
var rnd = new RandomSystem(1);
A.SetByIndex(i => new M44d(rnd.CreateUniformDoubleArray(16)));
rows.SetByIndex(i => rnd.UniformInt(4));
columns.SetByIndex(i => rnd.UniformInt(4));
}
static void Main(string[] args)
{
// This initialization is required to be able to use DeviL for loading and saving PixImages.
Aardvark.Base.Aardvark.Init();
var rnd = new RandomSystem(1);
var series = new(string, IRandomSeries)[]
public Indexers3()
{
var rnd = new RandomSystem(1);
indices.SetByIndex(i => rnd.UniformV2i(3));
vectors.SetByIndex(i => new Vector(rnd.CreateUniformDoubleArray(3)));
matrices.SetByIndex(i => new Matrix(rnd.CreateUniformDoubleArray(9)));
}
/// <summary>
/// Runs the given test function multiple times and provides a RandomSystem.
/// </summary>
public static void GenericTest(Action <RandomSystem, int> f)
{
var rnd = new RandomSystem(1);
for (int i = 0; i < Iterations; i++)
{
f(rnd, i);
}
}
private IEnumerator TPRandomToggleObject(int repeat)
{
while (repeat >= 0)
{
GameObject selectedObject = RandomSystem.PickObjectWithProbability(probabilityElements);
selectedObject.SetActive(!selectedObject.activeSelf);
repeat--;
yield return(ExampleHelper.WaitSecond);
}
}
public void BoxTransformTest()
{
var cnt = 10000;
var rnd = new RandomSystem(1);
var trafos = new M44d[cnt].SetByIndex(i => new M44d(rnd.CreateUniformDoubleArray(16)));
//var trafos = new M44d[cnt].SetByIndex(i => M44d.FromBasis(rnd.UniformV3d(), rnd.UniformV3d(), rnd.UniformV3d(), rnd.UniformV3d()));
//var trafos = new M44d[cnt].SetByIndex(i => M44d.Translation(rnd.UniformV3d()));
//var trafos = new M44d[cnt].SetByIndex(i => M44d.Rotation(rnd.UniformV3d()) * M44d.Translation(rnd.UniformV3d()));
var boxes = new Box3d[cnt].SetByIndex(i => Box3d.FromCenterAndSize(rnd.UniformV3d(), rnd.UniformV3d()));
var refBoxes = boxes.Map((b, i) => Transform1(b, trafos[i]));
for (int j = 0; j < 10; j++)
{
Report.BeginTimed("Transform Boxes Aardvark");
for (int i = 0; i < trafos.Length; i++)
{
var test = boxes[i].Transformed(trafos[i]);
Assert.IsTrue(test.Min.ApproximateEquals(refBoxes[i].Min, 1e-7) && test.Max.ApproximateEquals(refBoxes[i].Max, 1e-7));
}
Report.End();
Report.BeginTimed("Transform Boxes1");
for (int i = 0; i < trafos.Length; i++)
{
var test = Transform1(boxes[i], trafos[i]);
Assert.IsTrue(test.Min.ApproximateEquals(refBoxes[i].Min, 1e-7) && test.Max.ApproximateEquals(refBoxes[i].Max, 1e-7));
}
Report.End();
Report.BeginTimed("Transform Boxes2");
for (int i = 0; i < trafos.Length; i++)
{
var test = Transform2(boxes[i], trafos[i]);
Assert.IsTrue(test.Min.ApproximateEquals(refBoxes[i].Min, 1e-7) && test.Max.ApproximateEquals(refBoxes[i].Max, 1e-7));
}
Report.End();
Report.BeginTimed("Transform Boxes3");
for (int i = 0; i < trafos.Length; i++)
{
var test = Transform3(boxes[i], trafos[i]);
Assert.IsTrue(test.Min.ApproximateEquals(refBoxes[i].Min, 1e-7) && test.Max.ApproximateEquals(refBoxes[i].Max, 1e-7));
}
Report.End();
Report.BeginTimed("Transform Boxes4");
for (int i = 0; i < trafos.Length; i++)
{
var test = Transform4(boxes[i], trafos[i]);
Assert.IsTrue(test.Min.ApproximateEquals(refBoxes[i].Min, 1e-7) && test.Max.ApproximateEquals(refBoxes[i].Max, 1e-7));
}
Report.End();
}
}
public void SortTests(int maxCount)
{
var sortDict = new Dict <string, Action <int[]> >
{
{ "heap", SortingExtensions.HeapSortAscending },
{ "quick", SortingExtensions.QuickSortAscending },
{ "smooth", SortingExtensions.SmoothSortAscending },
{ "tim", SortingExtensions.TimSortAscending },
};
var permSortDict = new Dict <string, Action <int[], int[]> >
{
{ "heap", SortingExtensions.PermutationHeapSortAscending },
{ "quick", SortingExtensions.PermutationQuickSortAscending },
{ "smooth", SortingExtensions.PermutationSmoothSortAscending },
{ "tim", SortingExtensions.PermutationTimSortAscending },
};
Test.Begin("sort tests");
foreach (var pm in new[] { false, true })
{
for (int count = 1; count <= maxCount; count *= 2)
{
var rnd = new RandomSystem(count);
var array = rnd.CreatePermutationArray(count);
var a = new int[count];
foreach (var sort in new[] { "heap", "quick", "smooth", "tim" })
{
Test.Begin("{0}{1}-sort {2} items", pm ? "permutation " : "", sort, count);
if (pm)
{
a.SetByIndex(pi => pi);
permSortDict[sort](a, array);
for (int i = 0; i < count; i++)
{
Test.IsTrue(array[a[i]] == i);
}
}
else
{
array.CopyTo(a, 0);
sortDict[sort](a);
for (int i = 0; i < count; i++)
{
Test.IsTrue(a[i] == i);
}
}
Test.End();
}
}
}
Test.End();
}
public void InPlaceTransposeTest()
{
var rand = new RandomSystem();
var m = new M44d(rand.CreateUniformDoubleArray(16));
var transposed = m.Transposed;
Mat.Transpose(ref m);
Assert.IsTrue(Fun.ApproximateEquals(m, transposed, 0.0001));
}
public IntegerPowerLong()
{
var rnd = new RandomSystem(1);
numbers.SetByIndex(i =>
{
var x = rnd.UniformDouble() - 0.5;
x += 0.1 * Fun.Sign(x);
return((long)(x * 10));
});
exponents.SetByIndex(i => rnd.UniformInt(32));
}
public void TrafoDecomposeTest()
{
var rnd = new RandomSystem();
for (int i = 0; i < 100000; i++)
{
var rot = rnd.UniformV3dFull() * Constant.PiTimesFour - Constant.PiTimesTwo;
var trans = rnd.UniformV3dFull() * 10 - 5;
var scale = rnd.UniformV3dFull() * 4 - 2;
TestDecompose(scale, rot, trans);
}
}
public static void IdentityTest()
{
var rnd = new RandomSystem(1);
for (int i = 0; i < iterations; i++)
{
var q = GetRandomQuat(rnd);
var id = QuaternionD.Identity;
Assert.IsTrue(Fun.ApproximateEquals(q * id, q, 0.00001));
Assert.IsTrue(Fun.ApproximateEquals(id * q, q, 0.00001));
Assert.IsTrue(Fun.ApproximateEquals(id * id, id, 0.00001));
}
}
public static void Comparison()
{
var rnd = new RandomSystem(1);
for (int i = 0; i < iterations; i++)
{
var q0 = GetRandomQuat(rnd);
var q1 = new QuaternionD((V4d)q0 + V4d.OIOI);
Assert.IsFalse(q0.Equals(q1));
Assert.IsFalse(q0 == q1);
Assert.IsTrue(q0 != q1);
}
}
public static void ToStringAndParse()
{
var rnd = new RandomSystem(1);
for (int i = 0; i < iterations; i++)
{
var q = GetRandomQuat(rnd);
var str = q.ToString();
var parsed = QuaternionD.Parse(str);
Assert.IsTrue(Fun.ApproximateEquals(parsed, q, 0.00001));
}
}
public void MatrixMultiplicationTest()
{
using (Report.JobTimed("Matrix multiplication tests"))
{
var rand = new RandomSystem();
Test.Begin("Row vector with matrix");
var m = new M44d(rand.CreateUniformDoubleArray(16));
var v = new V4d(rand.CreateUniformDoubleArray(4));
Test.IsTrue(v * m == m.Transposed * v);
Test.End();
}
}
public void ConcurrentSymbolDictTest(int rounds, int tasks)
{
int count = m_stringTable.Length;
int block = count / tasks;
var rnd = new RandomSystem();
var perm = new int[count].SetByIndex(i => i);
var map = new SymbolDict <int>().AsConcurrent();
// var map = new FastConcurrentSymbolDict<int>();
Test.Begin("parallel adding and removing tests {0}", count);
for (int r = 0; r < rounds; r++)
{
Test.Begin("round {0}", r);
Test.Begin("adding in parallel");
Parallel.For(0, tasks, t =>
{
for (int i = t * block, e = i + block; i < e; i++)
{
map[m_symbolTable[perm[i]]] = i;
}
});
Test.IsTrue(count == map.Count);
Test.End();
Test.Begin("checking");
for (int i = 0; i < count; i++)
{
Test.IsTrue(map[m_symbolTable[perm[i]]] == i);
}
Test.End();
rnd.Randomize(perm);
Test.Begin("removing in parallel");
Parallel.For(0, tasks, t =>
{
for (int i = t * block, e = i + block; i < e; i++)
{
map.Remove(m_symbolTable[perm[i]]);
}
});
Test.IsTrue(map.Count == 0);
Test.End();
Test.End();
}
Test.End();
}
public void TransformedInfinite()
{
var rnd = new RandomSystem(123);
for (int i = 0; i < 1000; i++)
{
var mat = new M44d(rnd.CreateUniformDoubleArray(16));
var test = Box3d.Infinite.Transformed(mat);
if (test.Min.AnyInfinity || test.Max.AnyInfinity)
{
Report.Line("Max -> Infinite"); // NOTE: some max values will be infinite
}
Assert.False(test.Max.AnyNaN || test.Min.AnyNaN || test.IsEmpty);
}
}
public static Trafo3d GetRandomTrafo(RandomSystem rnd, bool withPerspective)
{
var rot = rnd.UniformV3dFull() * Constant.PiTimesFour - Constant.PiTimesTwo;
var trans = rnd.UniformV3dFull() * 10 - 5;
var scale = rnd.UniformV3dFull() * 4 - 2;
var trafo = Trafo3d.FromComponents(scale, rot, trans);
if (withPerspective)
{
trafo *= Trafo3d.PerspectiveProjectionRH(-1, 1, -1, 1, rnd.UniformDouble(), rnd.UniformDouble() * 100);
}
return(trafo);
}
public void ListHeapTest(int count, bool print)
{
Test.Begin("heap size {0}", count);
var rnd = new RandomSystem(count);
Report.BeginTimed("creating array");
var array = rnd.CreatePermutationArray(count);
Report.End();
var heap = new List <int>();
Report.BeginTimed("enqueueing items");
foreach (var item in array)
{
heap.HeapAscendingEnqueue(item);
}
Report.End();
Test.Begin("dequeueing items");
var pos = 0;
if (print)
{
while (heap.Count > 0)
{
var item = heap.HeapAscendingDequeue();
Test.IsTrue(pos == item, "item[{0}] = {1}", pos, item);
++pos;
Report.Text("{0,3},", item);
if ((pos & 0xf) == 0)
{
Report.Line();
}
}
}
else
{
while (heap.Count > 0)
{
var item = heap.HeapAscendingDequeue();
Test.IsTrue(pos == item, "item[{0}] = {1}", pos, item);
++pos;
}
}
Test.End();
Test.End();
}
public void TransformedEmpty()
{
var rnd = new RandomSystem(123);
for (int i = 0; i < 1000; i++)
{
var mat = new M44d(rnd.CreateUniformDoubleArray(16));
var test = Box3d.Invalid.Transformed(mat);
Assert.True(test.IsEmpty);
Assert.False(test.Max.AnyNaN || test.Min.AnyNaN || test.IsNonEmpty);
if (test.Min.AnyInfinity || test.Max.AnyInfinity)
{
Report.Line("Max -> Infinite");
}
}
}
private IEnumerator TPObjectPoolSpawnObjects(UnityPool <GameObject> pool)
{
isRunning = true;
GameObject prevObj = pool.Get();
prevObj.transform.position = RandomSystem.InsideUnitSquare() * 5;
while (run)
{
yield return(ExampleHelper.WaitSecond);
pool.Push(prevObj);
prevObj = pool.Get();
prevObj.transform.position = RandomSystem.InsideUnitSquare() * 5;
prevObj.SetActive(true);
}
isRunning = false;
}
public static void NormalizeTest()
{
var rnd = new RandomSystem(1);
for (int i = 0; i < iterations; i++)
{
var q = GetRandomQuat(rnd);
// Normalized property
var q1 = q.Normalized;
// Normalize method
var q2 = new QuaternionD(q);
Quaternion.Normalize(ref q2);
Assert.IsTrue(Fun.ApproximateEquals(q1.Norm, 1, 0.00001));
Assert.IsTrue(Fun.ApproximateEquals(q2.Norm, 1, 0.00001));
}
}
public AngleBetweenFloat()
{
var rnd = new RandomSystem(1);
A.SetByIndex(i => rnd.UniformV3fDirection());
angles.SetByIndex(i => rnd.UniformFloat() * (float)Constant.Pi);
B.SetByIndex(i =>
{
V3f v;
do
{
v = rnd.UniformV3fDirection();
}while (v.Dot(A[i]).IsTiny());
V3f axis = v.Cross(A[i]).Normalized;
return(M44f.Rotation(axis, angles[i]).TransformDir(A[i]));
});
}
