347 строки
12 KiB
C#
347 строки
12 KiB
C#
|
|
using System;
|
|
using System.Diagnostics;
|
|
|
|
using Foundation;
|
|
using ObjCRuntime;
|
|
|
|
using OpenTK;
|
|
|
|
using NUnit.Framework;
|
|
|
|
namespace MonoTouchFixtures.Simd {
|
|
[TestFixture]
|
|
[Preserve (AllMembers = true)]
|
|
public class NMatrix4dTest {
|
|
|
|
[Test]
|
|
public void Identity ()
|
|
{
|
|
var identity = new NMatrix4d {
|
|
M11 = 1d,
|
|
M22 = 1d,
|
|
M33 = 1d,
|
|
M44 = 1d,
|
|
};
|
|
Asserts.AreEqual (identity, NMatrix4d.Identity, "identity");
|
|
Asserts.AreEqual (Matrix4d.Identity, NMatrix4d.Identity, "opentk identity");
|
|
}
|
|
|
|
[Test]
|
|
public void RowConstructor ()
|
|
{
|
|
var expected = GetTestMatrix ();
|
|
var actual = new NMatrix4d (expected.Row0, expected.Row1, expected.Row2, expected.Row3);
|
|
Asserts.AreEqual (expected, actual, "ctor 1");
|
|
}
|
|
|
|
[Test]
|
|
public void ElementConstructor ()
|
|
{
|
|
var expected = GetTestMatrix ();
|
|
var actual = new NMatrix4d (expected.M11, expected.M12, expected.M13, expected.M14,
|
|
expected.M21, expected.M22, expected.M23, expected.M24,
|
|
expected.M31, expected.M32, expected.M33, expected.M34,
|
|
expected.M41, expected.M42, expected.M43, expected.M44);
|
|
Asserts.AreEqual (expected, actual, "ctor 1");
|
|
|
|
}
|
|
|
|
[Test]
|
|
public void Determinant ()
|
|
{
|
|
var expected = GetTestMatrix ();
|
|
var actual = (NMatrix4d) expected;
|
|
Assert.AreEqual (expected.Determinant, actual.Determinant, 0.000001d, "determinant\n" + actual);
|
|
|
|
}
|
|
|
|
[Test]
|
|
public void Elements ()
|
|
{
|
|
var expected = GetTestMatrix ();
|
|
var actual = (NMatrix4d) expected;
|
|
|
|
Assert.AreEqual (expected.M11, actual.M11, "m11 getter");
|
|
Assert.AreEqual (expected.M12, actual.M12, "m12 getter");
|
|
Assert.AreEqual (expected.M13, actual.M13, "m13 getter");
|
|
Assert.AreEqual (expected.M14, actual.M14, "m14 getter");
|
|
Assert.AreEqual (expected.M21, actual.M21, "m21 getter");
|
|
Assert.AreEqual (expected.M22, actual.M22, "m22 getter");
|
|
Assert.AreEqual (expected.M23, actual.M23, "m23 getter");
|
|
Assert.AreEqual (expected.M24, actual.M24, "m24 getter");
|
|
Assert.AreEqual (expected.M31, actual.M31, "m31 getter");
|
|
Assert.AreEqual (expected.M32, actual.M32, "m32 getter");
|
|
Assert.AreEqual (expected.M33, actual.M33, "m33 getter");
|
|
Assert.AreEqual (expected.M34, actual.M34, "m34 getter");
|
|
Assert.AreEqual (expected.M41, actual.M41, "m41 getter");
|
|
Assert.AreEqual (expected.M42, actual.M42, "m42 getter");
|
|
Assert.AreEqual (expected.M43, actual.M43, "m43 getter");
|
|
Assert.AreEqual (expected.M44, actual.M44, "m44 getter");
|
|
|
|
var newExpected = GetTestMatrix ();
|
|
actual.M11 = newExpected.M11;
|
|
actual.M12 = newExpected.M12;
|
|
actual.M13 = newExpected.M13;
|
|
actual.M14 = newExpected.M14;
|
|
actual.M21 = newExpected.M21;
|
|
actual.M22 = newExpected.M22;
|
|
actual.M23 = newExpected.M23;
|
|
actual.M24 = newExpected.M24;
|
|
actual.M31 = newExpected.M31;
|
|
actual.M32 = newExpected.M32;
|
|
actual.M33 = newExpected.M33;
|
|
actual.M34 = newExpected.M34;
|
|
actual.M41 = newExpected.M41;
|
|
actual.M42 = newExpected.M42;
|
|
actual.M43 = newExpected.M43;
|
|
actual.M44 = newExpected.M44;
|
|
Assert.AreEqual (newExpected.M11, actual.M11, "m11 setter");
|
|
Assert.AreEqual (newExpected.M12, actual.M12, "m12 setter");
|
|
Assert.AreEqual (newExpected.M13, actual.M13, "m13 setter");
|
|
Assert.AreEqual (newExpected.M14, actual.M14, "m14 setter");
|
|
Assert.AreEqual (newExpected.M21, actual.M21, "m21 setter");
|
|
Assert.AreEqual (newExpected.M22, actual.M22, "m22 setter");
|
|
Assert.AreEqual (newExpected.M23, actual.M23, "m23 setter");
|
|
Assert.AreEqual (newExpected.M24, actual.M24, "m24 setter");
|
|
Assert.AreEqual (newExpected.M31, actual.M31, "m31 setter");
|
|
Assert.AreEqual (newExpected.M32, actual.M32, "m32 setter");
|
|
Assert.AreEqual (newExpected.M33, actual.M33, "m33 setter");
|
|
Assert.AreEqual (newExpected.M34, actual.M34, "m34 setter");
|
|
Assert.AreEqual (newExpected.M41, actual.M41, "m41 setter");
|
|
Assert.AreEqual (newExpected.M42, actual.M42, "m42 setter");
|
|
Assert.AreEqual (newExpected.M43, actual.M43, "m43 setter");
|
|
Assert.AreEqual (newExpected.M44, actual.M44, "m44 setter");
|
|
}
|
|
|
|
[Test]
|
|
public void TransposeInstance ()
|
|
{
|
|
var expected = GetTestMatrix ();
|
|
var actual = (NMatrix4d) expected;
|
|
|
|
expected.Transpose ();
|
|
actual.Transpose ();
|
|
|
|
Asserts.AreEqual (expected, actual, "transpose");
|
|
}
|
|
|
|
[Test]
|
|
public void TransposeStatic ()
|
|
{
|
|
var input = GetTestMatrix ();
|
|
var inputSimd = (NMatrix4d) input;
|
|
|
|
var expected = Matrix4d.Transpose (input);
|
|
var actual = NMatrix4d.Transpose (inputSimd);
|
|
|
|
Asserts.AreEqual (expected, actual, "transpose");
|
|
|
|
input = GetTestMatrix ();
|
|
inputSimd = (NMatrix4d) input;
|
|
Matrix4d.Transpose (ref input, out expected);
|
|
NMatrix4d.Transpose (ref inputSimd, out actual);
|
|
Asserts.AreEqual (expected, actual, "transpose out/ref");
|
|
}
|
|
|
|
[Test]
|
|
public void TransposeStatic_ByRef ()
|
|
{
|
|
var input = GetTestMatrix ();
|
|
var inputSimd = (NMatrix4d) input;
|
|
|
|
Matrix4d expected;
|
|
NMatrix4d actual;
|
|
|
|
Matrix4d.Transpose (ref input, out expected);
|
|
NMatrix4d.Transpose (ref inputSimd, out actual);
|
|
Asserts.AreEqual (expected, actual, "transpose out/ref");
|
|
}
|
|
|
|
[Test]
|
|
public void Multiply ()
|
|
{
|
|
var inputL = GetTestMatrix ();
|
|
var inputR = GetTestMatrix ();
|
|
var inputSimdL = (NMatrix4d) inputL;
|
|
var inputSimdR = (NMatrix4d) inputR;
|
|
var expected = Matrix4d.Mult (inputL, inputR);
|
|
var actual = NMatrix4d.Multiply (inputSimdL, inputSimdR);
|
|
|
|
Asserts.AreEqual (expected, actual, "multiply");
|
|
}
|
|
|
|
[Test]
|
|
public void Multiply_ByRef ()
|
|
{
|
|
var inputL = GetTestMatrix ();
|
|
var inputR = GetTestMatrix ();
|
|
var inputSimdL = (NMatrix4d) inputL;
|
|
var inputSimdR = (NMatrix4d) inputR;
|
|
Matrix4d expected;
|
|
NMatrix4d actual;
|
|
|
|
Matrix4d.Mult (ref inputL, ref inputR, out expected);
|
|
NMatrix4d.Multiply (ref inputSimdL, ref inputSimdR, out actual);
|
|
|
|
Asserts.AreEqual (expected, actual, "multiply");
|
|
}
|
|
|
|
|
|
[Test]
|
|
public void Multiply_Operator ()
|
|
{
|
|
var inputL = GetTestMatrix ();
|
|
var inputR = GetTestMatrix ();
|
|
var inputSimdL = (NMatrix4d) inputL;
|
|
var inputSimdR = (NMatrix4d) inputR;
|
|
var expected = inputL * inputR;
|
|
var actual = inputSimdL * inputSimdR;
|
|
|
|
Asserts.AreEqual (expected, actual, "multiply");
|
|
}
|
|
|
|
[Test]
|
|
public void Equality_Operator ()
|
|
{
|
|
var inputL = GetTestMatrix ();
|
|
var inputR = GetTestMatrix ();
|
|
var inputSimdL = (NMatrix4d) inputL;
|
|
var inputSimdR = (NMatrix4d) inputR;
|
|
|
|
// matrices are different
|
|
Assert.AreEqual (inputL == inputR, inputSimdL == inputSimdR, "inequality");
|
|
Assert.IsFalse (inputL == inputR, "inequality 2 expected");
|
|
Assert.IsFalse (inputSimdL == inputSimdR, "inequality 2 actual");
|
|
|
|
inputL = inputR;
|
|
inputSimdL = inputSimdR;
|
|
// matrices are identical
|
|
Assert.AreEqual (inputL == inputR, inputSimdL == inputSimdR, "equality");
|
|
Assert.IsTrue (inputL == inputR, "equality 2 expected");
|
|
Assert.IsTrue (inputSimdL == inputSimdR, "equality 2 actual");
|
|
|
|
Assert.IsTrue (NMatrix4d.Identity == (NMatrix4d) Matrix4d.Identity, "identity equality");
|
|
}
|
|
|
|
[Test]
|
|
public void Inequality_Operator ()
|
|
{
|
|
var inputL = GetTestMatrix ();
|
|
var inputR = GetTestMatrix ();
|
|
var inputSimdL = (NMatrix4d) inputL;
|
|
var inputSimdR = (NMatrix4d) inputR;
|
|
|
|
// matrices are different
|
|
Assert.AreEqual (inputL != inputR, inputSimdL != inputSimdR, "inequality");
|
|
Assert.IsTrue (inputL != inputR, "inequality 2 expected");
|
|
Assert.IsTrue (inputSimdL != inputSimdR, "inequality 2 actual");
|
|
|
|
inputL = inputR;
|
|
inputSimdL = inputSimdR;
|
|
// matrices are identical
|
|
Assert.AreEqual (inputL != inputR, inputSimdL != inputSimdR, "equality");
|
|
Assert.IsFalse (inputL != inputR, "equality 2 expected");
|
|
Assert.IsFalse (inputSimdL != inputSimdR, "equality 2 actual");
|
|
|
|
Assert.IsFalse (NMatrix4d.Identity != (NMatrix4d) Matrix4d.Identity, "identity equality");
|
|
}
|
|
|
|
[Test]
|
|
public void Explicit_Operator_ToMatrix4d ()
|
|
{
|
|
var expected = (NMatrix4d) GetTestMatrix ();
|
|
var actual = (Matrix4d) expected;
|
|
|
|
Asserts.AreEqual (expected, actual, "tomatrix4");
|
|
|
|
actual = (Matrix4d) NMatrix4d.Identity;
|
|
Asserts.AreEqual (NMatrix4d.Identity, actual, "tomatrix4 identity");
|
|
Asserts.AreEqual (Matrix4d.Identity, actual, "tomatrix4 identity2");
|
|
}
|
|
|
|
[Test]
|
|
public void Explicit_Operator_FromMatrix4d ()
|
|
{
|
|
var expected = GetTestMatrix ();
|
|
var actual = (NMatrix4d) expected;
|
|
|
|
Asserts.AreEqual (expected, actual, "frommatrix4");
|
|
|
|
actual = (NMatrix4d) Matrix4d.Identity;
|
|
Asserts.AreEqual (NMatrix4d.Identity, actual, "tomatrix4 identity");
|
|
Asserts.AreEqual (Matrix4d.Identity, actual, "tomatrix4 identity2");
|
|
}
|
|
|
|
[Test]
|
|
public void ToStringTest ()
|
|
{
|
|
var expected = GetTestMatrix ();
|
|
var actual = (NMatrix4d) expected;
|
|
|
|
Assert.AreEqual (expected.ToString (), actual.ToString (), "tostring");
|
|
}
|
|
|
|
// GetHashCode doesn't have to be identical, so no need to test
|
|
|
|
[Test]
|
|
public void Equals_Object ()
|
|
{
|
|
var expectedA = GetTestMatrix ();
|
|
var expectedB = GetTestMatrix ();
|
|
var actualA = (NMatrix4d) expectedA;
|
|
var actualB = (NMatrix4d) expectedB;
|
|
|
|
Assert.IsTrue (actualA.Equals ((object) actualA), "self");
|
|
Assert.IsFalse (actualA.Equals ((object) actualB), "other");
|
|
Assert.IsFalse (actualA.Equals (null), "null");
|
|
Assert.IsFalse (actualA.Equals (expectedA), "other type");
|
|
}
|
|
|
|
[Test]
|
|
public void Equals_Matrix ()
|
|
{
|
|
var expectedA = GetTestMatrix ();
|
|
var expectedB = GetTestMatrix ();
|
|
var actualA = (NMatrix4d) expectedA;
|
|
var actualB = (NMatrix4d) expectedB;
|
|
|
|
Assert.IsTrue (actualA.Equals (actualA), "self");
|
|
Assert.IsFalse (actualA.Equals (actualB), "other");
|
|
}
|
|
|
|
// A collection of test matrices.
|
|
//
|
|
// I initially tried randomly generating test matrices, but it turns out
|
|
// there are accumulative computational differences in the different algorithms
|
|
// between Matrix4d and NMatrix4d. Since the differences are accumulative,
|
|
// I couldn't find a minimal sensible delta values when comparing
|
|
// matrices.
|
|
//
|
|
// So I just serialized a few matrices that were randomly generated, and
|
|
// these have been tested to not produce accumulative computational differences.
|
|
//
|
|
static Matrix4d [] test_matrices = new [] {
|
|
new Matrix4d (0.1532144d, 0.5451511d, 0.2004739d, 0.8351463d, 0.9884372d, 0.1313103d, 0.3327205d, 0.01164342d, 0.6563147d, 0.7923161d, 0.6764754d, 0.07481737d, 0.03239552d, 0.7156482d, 0.6136858d, 0.1864168f),
|
|
new Matrix4d (0.7717745d, 0.559364d, 0.00918373d, 0.6579159d, 0.123461d, 0.9993145d, 0.5487496d, 0.2823398d, 0.9710717d, 0.8750508d, 0.472472d, 0.2608089d, 0.5771761d, 0.5617125d, 0.176998d, 0.1271691f),
|
|
new Matrix4d (0.2023053d, 0.4701468d, 0.6618567d, 0.7685714d, 0.8561344d, 0.009231919d, 0.6150167d, 0.7542298d, 0.550727d, 0.3625788d, 0.6639862d, 0.5763468d, 0.9717328d, 0.003812184d, 0.985266d, 0.7540002f),
|
|
new Matrix4d (9.799572E+08d, 1.64794E+09d, 1.117296E+09d, 1.239858E+09d, 6.389504E+07d, 1.172175E+09d, 1.399567E+09d, 1.187143E+09d, 3.729208E+07d, 5.50313E+08d, 1.847369E+09d, 1.612405E+09d, 1.699488E+08d, 4.952176E+08d, 1.07262E+09d, 2.035059E+09f),
|
|
new Matrix4d (1.102396E+09d, 3.082477E+08d, 1.126484E+09d, 5.022931E+08d, 1.966322E+09d, 1.1814E+09d, 8.464673E+08d, 1.940651E+09d, 1.229937E+09d, 1.367379E+09d, 1.900015E+09d, 1.516109E+09d, 2.146064E+09d, 1.870971E+09d, 1.046267E+09d, 1.088363E+09f),
|
|
new Matrix4d (2.263112E+08d, 8.79644E+08d, 1.303282E+09d, 1.654159E+09d, 3.705524E+08d, 1.984941E+09d, 2.175935E+07d, 4.633518E+08d, 1.801243E+09d, 1.616996E+09d, 1.620852E+09d, 7291498d, 1.012728E+09d, 2.834145E+08d, 3.5328E+08d, 1.35012E+09f),
|
|
new Matrix4d (0.4904693d, 0.841727d, 0.2294401d, 0.5736054d, 0.5406881d, 0.2172498d, 0.1261143d, 0.6736677d, 0.4570194d, 0.9091009d, 0.7669608d, 0.8468134d, 0.01802658d, 0.3850208d, 0.3730424d, 0.2440258f),
|
|
new Matrix4d (0.1252193d, 0.08986127d, 0.3407605d, 0.9144857d, 0.340791d, 0.2192288d, 0.5144276d, 0.01813344d, 0.07687104d, 0.7971596d, 0.6393988d, 0.9002907d, 0.1011457d, 0.5047605d, 0.7202546d, 0.07729452f),
|
|
new Matrix4d (8.176959E+08d, 1.386156E+09d, 5.956444E+08d, 4.210506E+08d, 1.212676E+09d, 4.131035E+08d, 1.032453E+09d, 2.074689E+08d, 1.536594E+09d, 3.266183E+07d, 5.222072E+08d, 7.923175E+08d, 1.762531E+09d, 7.901702E+08d, 8.1975E+08d, 1.630734E+09f),
|
|
new Matrix4d (0.006755914d, 0.07464754d, 0.287938d, 0.3724834d, 0.1496783d, 0.6224982d, 0.7150125d, 0.5554719d, 0.4638171d, 0.4200902d, 0.4867154d, 0.773377d, 0.3558737d, 0.4043404d, 0.04670618d, 0.7695189d),
|
|
};
|
|
|
|
static int counter;
|
|
internal static Matrix4d GetTestMatrix ()
|
|
{
|
|
counter++;
|
|
if (counter == test_matrices.Length)
|
|
counter = 0;
|
|
return test_matrices [counter];
|
|
}
|
|
}
|
|
}
|