public void TestMultiplyByMatrix()
{
const double angle = Math.PI / 4.0;
double cos = Math.Cos(angle / 2.0);
double sin = Math.Sin(angle / 2.0);
double a = cos * cos - sin * sin / 3.0;
double b = 2.0 * (sin * sin + sin * cos * Math.Sqrt(3.0)) / 3.0;
double c = 2.0 * (sin * sin - sin * cos * Math.Sqrt(3.0)) / 3.0;
// The matrix here is formed from the orthonormal set obtained by rotating
// the x-axis, y-axis, and z-axis through an angle of 45 degrees about
// the (1,1,1) vector.
Matrix3By3 matrix = new Matrix3By3(a, c, b,
b, a, c,
c, b, a);
Matrix3By3 transpose = matrix.Transpose();
Matrix3By3 result = matrix.Multiply(transpose);
Assert.IsTrue(result.EqualsEpsilon(Matrix3By3.Identity, Constants.Epsilon16));
result = matrix * transpose;
Assert.IsTrue(result.EqualsEpsilon(Matrix3By3.Identity, Constants.Epsilon16));
}
public void TestEquality()
{
Matrix3By3 first = new Matrix3By3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
Matrix3By3 second = new Matrix3By3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
Assert.AreEqual(first, second);
Assert.AreEqual(second, first);
Assert.IsTrue(first == second);
Assert.IsTrue(second == first);
Assert.IsFalse(first != second);
Assert.IsFalse(second != first);
Assert.IsTrue(first.Equals(second));
Assert.IsTrue(second.Equals(first));
for (int i = 0; i < 9; ++i)
{
double[] values = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 };
values[i] = 0.0;
second = new Matrix3By3(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8]);
Assert.AreNotEqual(first, second);
Assert.AreNotEqual(second, first);
Assert.IsFalse(first == second);
Assert.IsFalse(second == first);
Assert.IsTrue(first != second);
Assert.IsTrue(second != first);
Assert.IsFalse(first.Equals(second));
Assert.IsFalse(second.Equals(first));
}
}
public void TestEquality()
{
Matrix3By3 first = new Matrix3By3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
Matrix3By3 second = new Matrix3By3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
Assert.AreEqual(first, second);
Assert.AreEqual(second, first);
Assert.IsTrue(first == second);
Assert.IsTrue(second == first);
Assert.IsFalse(first != second);
Assert.IsFalse(second != first);
Assert.IsTrue(first.Equals(second));
Assert.IsTrue(second.Equals(first));
for (int i = 0; i < 9; ++i)
{
double[] values = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 };
values[i] = 0.0;
second = new Matrix3By3(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8]);
Assert.AreNotEqual(first, second);
Assert.AreNotEqual(second, first);
Assert.IsFalse(first == second);
Assert.IsFalse(second == first);
Assert.IsTrue(first != second);
Assert.IsTrue(second != first);
Assert.IsFalse(first.Equals(second));
Assert.IsFalse(second.Equals(first));
}
}
public void TestEqualityWithWrongType()
{
Matrix3By3 first = Matrix3By3.Identity;
Cartesian second = new Cartesian(1.0, 2.0, 3.0);
Assert.IsFalse(first.Equals(second));
}
public void TestEqualityWithWrongType()
{
Matrix3By3 first = Matrix3By3.Identity;
Cartesian second = new Cartesian(1.0, 2.0, 3.0);
// ReSharper disable once SuspiciousTypeConversion.Global
Assert.IsFalse(first.Equals(second));
}
public void TestMathOperatorsWithCartesian()
{
Matrix3By3 test = new Matrix3By3(1.0, 2.0, 4.0, 2.0, 3.0, 5.0, 4.0, 5.0, 6.0);
Cartesian mult = new Cartesian(1, 2, 3);
Assert.IsTrue((new Cartesian(17, 23, 32).Equals(test.Multiply(mult))));
Assert.IsTrue((new Cartesian(17, 23, 32).Equals(test * mult)));
}
public void TestGetHashCode()
{
Matrix3By3 object1 = Matrix3By3.Identity;
Matrix3By3 object2 = Matrix3By3.Identity;
Matrix3By3 object3 = new Matrix3By3();
Assert.AreEqual(object1.GetHashCode(), object2.GetHashCode());
Assert.AreNotEqual(object1.GetHashCode(), object3.GetHashCode());
}
private void OnTimeChanged(object sender, TimeChangedEventArgs e)
{
if (m_temeToFixedEvaluator == null)
{
return;
}
JulianDate date = e.Time;
Matrix3By3 temeToFixed = new Matrix3By3(m_temeToFixedEvaluator.Evaluate(date));
KinematicTransformation transformation = m_fixedToFacilityTopoEvaluator.Evaluate(date, 0);
List <int> satellitesToRemove = null;
m_satellites.ClearPositions();
for (int i = 0; i < m_satellites.Count; ++i)
{
MotionEvaluator <Cartesian> satellite = m_satellites.GetSatellite(i);
try
{
// Update position of marker representing this satellite
Cartesian position = satellite.Evaluate(date).Rotate(temeToFixed);
// Compute access from satellite to facility
if (m_showAccess)
{
Cartesian positionInTopo = transformation.Transform(position);
AzimuthElevationRange azimuthElevationRange = new AzimuthElevationRange(positionInTopo);
m_satellites.AppendPosition(position, azimuthElevationRange.Elevation > 0.0);
}
else
{
m_satellites.AppendPosition(position, false);
}
}
catch (Exception)
{
if (satellitesToRemove == null)
{
satellitesToRemove = new List <int>();
}
satellitesToRemove.Add(i);
}
}
// Remove satellites that could not be evaluated
if (satellitesToRemove != null)
{
m_satellites.RemoveUsingIndexList(satellitesToRemove);
SetText(m_satellites.Count);
}
m_satellites.SetMarkerBatches();
}
public void TestMathOperators()
{
Matrix3By3 test1 = new Matrix3By3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
Matrix3By3 test2 = new Matrix3By3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
Assert.IsTrue(Matrix3By3.Zero.Equals(test1.Subtract(test2)));
Assert.IsTrue(Matrix3By3.Zero.Equals(test1 - test2));
Assert.IsTrue((test2 * 2.0).Equals(test1.Add(test2)));
Assert.IsTrue((test2 * 2.0).Equals(test1 + test2));
Assert.IsTrue((new Matrix3By3(30, 36, 42, 66, 81, 96, 102, 126, 150).Equals(test1.Multiply(test2))));
Assert.IsTrue((new Matrix3By3(30, 36, 42, 66, 81, 96, 102, 126, 150).Equals(test1 * test2)));
}
public void IndexerThrowsWithColumnOutOfRange([Range(0, 2)] int row,
[Values(-1, 3)] int column)
{
Matrix3By3 matrix = Matrix3By3.DiagonalMatrix(-3.0, 1.0, 5.0);
var exception = Assert.Throws <ArgumentOutOfRangeException>(() =>
{
double unused = matrix[row, column];
});
Assert.AreEqual("column", exception.ParamName);
}
public void TestMathOperatorsWithCartesian()
{
Matrix3By3 matrix = new Matrix3By3(1.0, 2.0, 4.0,
2.0, 3.0, 5.0,
4.0, 5.0, 6.0);
Cartesian vector = new Cartesian(1, 2, 3);
var expected = new Cartesian(17, 23, 32);
Assert.AreEqual(expected, matrix.Multiply(vector));
Assert.AreEqual(expected, matrix * vector);
}
public void TestHoldValue()
{
Matrix3By3 test = new Matrix3By3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
Assert.AreEqual(1.0, test.M11);
Assert.AreEqual(2.0, test.M12);
Assert.AreEqual(3.0, test.M13);
Assert.AreEqual(4.0, test.M21);
Assert.AreEqual(5.0, test.M22);
Assert.AreEqual(6.0, test.M23);
Assert.AreEqual(7.0, test.M31);
Assert.AreEqual(8.0, test.M32);
Assert.AreEqual(9.0, test.M33);
}
static void Main(string[] args)
{
// 球坐标转为笛卡尔坐标
var spherical0 = new Spherical(Math.PI / 4, Math.PI / 8, 100.0);
var cartesian0 = new Cartesian(spherical0);
Console.WriteLine("球坐标：{0}；笛卡尔坐标：{1}", spherical0, cartesian0);
// 笛卡尔坐标归一化
UnitCartesian unitCartesian1 = cartesian0.Normalize();
Console.WriteLine("单位矢量笛卡尔坐标：{0}", unitCartesian1);
// 地图坐标转为笛卡尔坐标
var cartographic2 = new Cartographic(Trig.DegreesToRadians(120), Trig.DegreesToRadians(30), 100);
EarthCentralBody earth = CentralBodiesFacet.GetFromContext().Earth;
Cartesian cartesian2 = earth.Shape.CartographicToCartesian(cartographic2);
Console.WriteLine("地图坐标：{0}；笛卡尔坐标：{1}", cartographic2, cartesian2);
// 笛卡尔坐标转为地图坐标
Cartographic cartographic3 = earth.Shape.CartesianToCartographic(cartesian2);
Console.WriteLine("笛卡尔坐标：{0}；地图坐标：{1}", cartesian2, cartographic3);
// 新坐标系绕原坐标系z轴旋转90度，原向量(1,0,0)
var vector4 = new Cartesian(1, 0, 0);
var rotation4 = new ElementaryRotation(AxisIndicator.Third, Trig.DegreesToRadians(90));
Cartesian newVector4 = new Matrix3By3(rotation4).Multiply(vector4);
Console.WriteLine("旋转前：{0}；旋转后：{1}", vector4, newVector4);
// 欧拉旋转
var vector5 = new Cartesian(1, 0, 0);
double angle = Trig.DegreesToRadians(90);
var euler = new EulerSequence(angle, angle, angle, EulerSequenceIndicator.Euler321);
Cartesian newVector5 = new Matrix3By3(euler).Multiply(vector5);
Console.WriteLine("旋转前：{0}；旋转后：{1}", vector5, newVector5);
// 偏航俯仰翻滚旋转
var vector6 = new Cartesian(1, 0, 0);
double angle6 = Trig.DegreesToRadians(90);
var ypr = new YawPitchRoll(angle, angle, angle, YawPitchRollIndicator.YPR);
Cartesian newVector6 = new Matrix3By3(ypr).Multiply(vector6);
Console.WriteLine("旋转前：{0}；旋转后：{1}", vector6, newVector6);
Console.Read();
}
public void TestZeroMatrix()
{
Matrix3By3 zero = Matrix3By3.Zero;
Assert.AreEqual(0.0, zero.M11);
Assert.AreEqual(0.0, zero.M12);
Assert.AreEqual(0.0, zero.M13);
Assert.AreEqual(0.0, zero.M21);
Assert.AreEqual(0.0, zero.M22);
Assert.AreEqual(0.0, zero.M23);
Assert.AreEqual(0.0, zero.M31);
Assert.AreEqual(0.0, zero.M32);
Assert.AreEqual(0.0, zero.M33);
}
public void TestIndex()
{
Matrix3By3 original = new Matrix3By3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
Assert.AreEqual(1.0, original[0, 0]);
Assert.AreEqual(2.0, original[0, 1]);
Assert.AreEqual(3.0, original[0, 2]);
Assert.AreEqual(4.0, original[1, 0]);
Assert.AreEqual(5.0, original[1, 1]);
Assert.AreEqual(6.0, original[1, 2]);
Assert.AreEqual(7.0, original[2, 0]);
Assert.AreEqual(8.0, original[2, 1]);
Assert.AreEqual(9.0, original[2, 2]);
}
public void TestIdentity()
{
Matrix3By3 identity = Matrix3By3.Identity;
Assert.AreEqual(1.0, identity.M11);
Assert.AreEqual(0.0, identity.M12);
Assert.AreEqual(0.0, identity.M13);
Assert.AreEqual(0.0, identity.M21);
Assert.AreEqual(1.0, identity.M22);
Assert.AreEqual(0.0, identity.M23);
Assert.AreEqual(0.0, identity.M31);
Assert.AreEqual(0.0, identity.M32);
Assert.AreEqual(1.0, identity.M33);
}
public void TestHoldValue()
{
Matrix3By3 test = new Matrix3By3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
Assert.AreEqual(1.0, test.M11);
Assert.AreEqual(2.0, test.M12);
Assert.AreEqual(3.0, test.M13);
Assert.AreEqual(4.0, test.M21);
Assert.AreEqual(5.0, test.M22);
Assert.AreEqual(6.0, test.M23);
Assert.AreEqual(7.0, test.M31);
Assert.AreEqual(8.0, test.M32);
Assert.AreEqual(9.0, test.M33);
}
public void TestEqualsEpsilon()
{
Matrix3By3 first = new Matrix3By3(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
Matrix3By3 second = new Matrix3By3(1e-2, 1e-3, 1e-4, 1e-5, 1e-6, 1e-7, 1e-8, 1e-9, 1e-10);
Assert.IsTrue(second.EqualsEpsilon(first, 1e-1));
Assert.IsTrue(second.EqualsEpsilon(first, 1e-2));
Assert.IsFalse(second.EqualsEpsilon(first, 1e-3));
Assert.IsFalse(second.EqualsEpsilon(first, 1e-4));
Assert.IsFalse(second.EqualsEpsilon(first, 1e-5));
Assert.IsFalse(second.EqualsEpsilon(first, 1e-6));
Assert.IsFalse(second.EqualsEpsilon(first, 1e-7));
Assert.IsFalse(second.EqualsEpsilon(first, 1e-8));
Assert.IsFalse(second.EqualsEpsilon(first, 1e-9));
Assert.IsFalse(second.EqualsEpsilon(first, 1e-10));
}
public void TestInvert()
{
Matrix3By3 test = new Matrix3By3(1.0, 5.0, 2.0, 1.0, 1.0, 7.0, 0.0, -3.0, 4.0);
Matrix3By3 inv = test.Invert();
Assert.AreEqual(-25.0, inv.M11);
Assert.AreEqual(26.0, inv.M12);
Assert.AreEqual(-33.0, inv.M13);
Assert.AreEqual(4.0, inv.M21);
Assert.AreEqual(-4.0, inv.M22);
Assert.AreEqual(5.0, inv.M23);
Assert.AreEqual(3.0, inv.M31);
Assert.AreEqual(-3.0, inv.M32);
Assert.AreEqual(4.0, inv.M33);
}
public void TestFromQuaternion()
{
UnitQuaternion quaternion = UnitQuaternion.Identity;
Matrix3By3 matrix = new Matrix3By3(quaternion);
Assert.AreEqual(1.0, matrix.M11);
Assert.AreEqual(0.0, matrix.M12);
Assert.AreEqual(0.0, matrix.M13);
Assert.AreEqual(0.0, matrix.M21);
Assert.AreEqual(1.0, matrix.M22);
Assert.AreEqual(0.0, matrix.M23);
Assert.AreEqual(0.0, matrix.M31);
Assert.AreEqual(0.0, matrix.M32);
Assert.AreEqual(1.0, matrix.M33);
}
public void TestTranspose()
{
Matrix3By3 original = new Matrix3By3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
Matrix3By3 transposed = original.Transpose();
Assert.AreEqual(transposed.M11, original.M11);
Assert.AreEqual(transposed.M12, original.M21);
Assert.AreEqual(transposed.M13, original.M31);
Assert.AreEqual(transposed.M21, original.M12);
Assert.AreEqual(transposed.M22, original.M22);
Assert.AreEqual(transposed.M23, original.M32);
Assert.AreEqual(transposed.M31, original.M13);
Assert.AreEqual(transposed.M32, original.M23);
Assert.AreEqual(transposed.M33, original.M33);
}
public void TestEqualsEpsilon()
{
Matrix3By3 first = new Matrix3By3(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
Matrix3By3 second = new Matrix3By3(1e-2, 1e-3, 1e-4, 1e-5, 1e-6, 1e-7, 1e-8, 1e-9, 1e-10);
Assert.IsTrue(second.EqualsEpsilon(first, 1e-1));
Assert.IsFalse(second.EqualsEpsilon(first, 1e-2));
Assert.IsFalse(second.EqualsEpsilon(first, 1e-3));
Assert.IsFalse(second.EqualsEpsilon(first, 1e-4));
Assert.IsFalse(second.EqualsEpsilon(first, 1e-5));
Assert.IsFalse(second.EqualsEpsilon(first, 1e-6));
Assert.IsFalse(second.EqualsEpsilon(first, 1e-7));
Assert.IsFalse(second.EqualsEpsilon(first, 1e-8));
Assert.IsFalse(second.EqualsEpsilon(first, 1e-9));
Assert.IsFalse(second.EqualsEpsilon(first, 1e-10));
}
public void TestFromQuaternion()
{
UnitQuaternion quaternion = UnitQuaternion.Identity;
Matrix3By3 matrix = new Matrix3By3(quaternion);
Assert.AreEqual(1.0, matrix.M11);
Assert.AreEqual(0.0, matrix.M12);
Assert.AreEqual(0.0, matrix.M13);
Assert.AreEqual(0.0, matrix.M21);
Assert.AreEqual(1.0, matrix.M22);
Assert.AreEqual(0.0, matrix.M23);
Assert.AreEqual(0.0, matrix.M31);
Assert.AreEqual(0.0, matrix.M32);
Assert.AreEqual(1.0, matrix.M33);
}
public void TestMatrixReturns()
{
double x = 1;
double y = 2;
double z = 3;
Matrix3By3 mat1 = Matrix3By3.CrossProductEquivalentMatrix(new Cartesian(x, y, z));
Assert.AreEqual(0.0, mat1.M11);
Assert.AreEqual(-z, mat1.M12);
Assert.AreEqual(y, mat1.M13);
Assert.AreEqual(z, mat1.M21);
Assert.AreEqual(0, mat1.M22);
Assert.AreEqual(-x, mat1.M23);
Assert.AreEqual(-y, mat1.M31);
Assert.AreEqual(x, mat1.M32);
Assert.AreEqual(0.0, mat1.M33);
UnitCartesian u = new UnitCartesian(x, y, z);
x = u.X;
y = u.Y;
z = u.Z;
Matrix3By3 mat2 = Matrix3By3.CrossProductEquivalentMatrix(u);
Assert.AreEqual(0.0, mat2.M11);
Assert.AreEqual(-z, mat2.M12);
Assert.AreEqual(y, mat2.M13);
Assert.AreEqual(z, mat2.M21);
Assert.AreEqual(0, mat2.M22);
Assert.AreEqual(-x, mat2.M23);
Assert.AreEqual(-y, mat2.M31);
Assert.AreEqual(x, mat2.M32);
Assert.AreEqual(0.0, mat2.M33);
Matrix3By3 mat3 = Matrix3By3.DiagonalMatrix(new Cartesian(1, 2, 3));
Assert.AreEqual(mat3.M11, 1);
Assert.AreEqual(mat3.M22, 2);
Assert.AreEqual(mat3.M33, 3);
Matrix3By3 mat4 = Matrix3By3.DiagonalMatrix(new UnitCartesian(1, 0, 0));
Assert.AreEqual(mat4.M11, 1);
Assert.AreEqual(mat4.M22, 0);
Assert.AreEqual(mat4.M33, 0);
}
public void TestIsUndefined()
{
Assert.IsFalse(Matrix3By3.Identity.IsUndefined);
Assert.IsTrue(Matrix3By3.Undefined.IsUndefined);
// Check what happens if any of the elements are NaN
for (int i = 0; i < 9; i++)
{
double[] values =
{
1.0, 1.0, 1.0,
1.0, 1.0, 1.0,
1.0, 1.0, 1.0,
};
values[i] = double.NaN;
var matrix = new Matrix3By3(values[0], values[1], values[2],
values[3], values[4], values[5],
values[6], values[7], values[8]);
Assert.IsTrue(matrix.IsUndefined);
}
}
public void TestMathOperators()
{
var matrix1 = new Matrix3By3(1.0, 2.0, 3.0,
4.0, 5.0, 6.0,
7.0, 8.0, 9.0);
var matrix2 = new Matrix3By3(1.0, 2.0, 3.0,
4.0, 5.0, 6.0,
7.0, 8.0, 9.0);
Assert.AreEqual(Matrix3By3.Zero, matrix1.Subtract(matrix2));
Assert.AreEqual(Matrix3By3.Zero, matrix1 - matrix2);
Assert.AreEqual(matrix2 * 2.0, matrix1.Add(matrix2));
Assert.AreEqual(matrix2 * 2.0, matrix1 + matrix2);
var expected = new Matrix3By3(30, 36, 42,
66, 81, 96,
102, 126, 150);
Assert.AreEqual(expected, matrix1.Multiply(matrix2));
Assert.AreEqual(expected, matrix1 * matrix2);
}
public void TestMultiplyByScalar()
{
Matrix3By3 matrix = new Matrix3By3(1.0, 2.0, 3.0,
4.0, 5.0, 6.0,
7.0, 8.0, 9.0);
Matrix3By3 result = matrix.Multiply(-2.0);
Assert.AreEqual(-2.0, result.M11);
Assert.AreEqual(-4.0, result.M12);
Assert.AreEqual(-6.0, result.M13);
Assert.AreEqual(-8.0, result.M21);
Assert.AreEqual(-10.0, result.M22);
Assert.AreEqual(-12.0, result.M23);
Assert.AreEqual(-14.0, result.M31);
Assert.AreEqual(-16.0, result.M32);
Assert.AreEqual(-18.0, result.M33);
result = matrix * -2.0;
Assert.AreEqual(-2.0, result.M11);
Assert.AreEqual(-4.0, result.M12);
Assert.AreEqual(-6.0, result.M13);
Assert.AreEqual(-8.0, result.M21);
Assert.AreEqual(-10.0, result.M22);
Assert.AreEqual(-12.0, result.M23);
Assert.AreEqual(-14.0, result.M31);
Assert.AreEqual(-16.0, result.M32);
Assert.AreEqual(-18.0, result.M33);
result = -2.0 * matrix;
Assert.AreEqual(-2.0, result.M11);
Assert.AreEqual(-4.0, result.M12);
Assert.AreEqual(-6.0, result.M13);
Assert.AreEqual(-8.0, result.M21);
Assert.AreEqual(-10.0, result.M22);
Assert.AreEqual(-12.0, result.M23);
Assert.AreEqual(-14.0, result.M31);
Assert.AreEqual(-16.0, result.M32);
Assert.AreEqual(-18.0, result.M33);
}
private void _TestFromMatrix3By3(double angle, Cartesian axis)
{
Cartesian unit = axis.Normalize();
double c = Math.Cos(angle);
double s = Math.Sin(angle);
double w = c;
double x = s * unit.X;
double y = s * unit.Y;
double z = s * unit.Z;
UnitQuaternion quaternion = new UnitQuaternion(w, x, y, z);
Matrix3By3 matrix = new Matrix3By3(quaternion);
UnitQuaternion test = new UnitQuaternion(matrix);
Assert.AreEqual(w, quaternion.W, Constants.Epsilon15);
Assert.AreEqual(x, quaternion.X, Constants.Epsilon15);
Assert.AreEqual(y, quaternion.Y, Constants.Epsilon15);
Assert.AreEqual(z, quaternion.Z, Constants.Epsilon15);
}
public void TestMathOperatorsWithCartesian()
{
Matrix3By3 test = new Matrix3By3(1.0, 2.0, 4.0, 2.0, 3.0, 5.0, 4.0, 5.0, 6.0);
Cartesian mult = new Cartesian(1, 2, 3);
Assert.IsTrue((new Cartesian(17, 23, 32).Equals(test.Multiply(mult))));
Assert.IsTrue((new Cartesian(17, 23, 32).Equals(test * mult)));
}
public void TestZeroInvertException()
{
Matrix3By3 mat = Matrix3By3.Zero.Invert();
}
public void TestIndex()
{
Matrix3By3 original = new Matrix3By3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
Assert.AreEqual(1.0, original[0, 0]);
Assert.AreEqual(2.0, original[0, 1]);
Assert.AreEqual(3.0, original[0, 2]);
Assert.AreEqual(4.0, original[1, 0]);
Assert.AreEqual(5.0, original[1, 1]);
Assert.AreEqual(6.0, original[1, 2]);
Assert.AreEqual(7.0, original[2, 0]);
Assert.AreEqual(8.0, original[2, 1]);
Assert.AreEqual(9.0, original[2, 2]);
}
private void _TestFromMatrix3By3(double angle, Cartesian axis)
{
Cartesian unit = axis.Normalize();
double c = Math.Cos(angle);
double s = Math.Sin(angle);
double w = c;
double x = s * unit.X;
double y = s * unit.Y;
double z = s * unit.Z;
UnitQuaternion quaternion = new UnitQuaternion(w, x, y, z);
Matrix3By3 matrix = new Matrix3By3(quaternion);
UnitQuaternion test = new UnitQuaternion(matrix);
Assert.AreEqual(w, quaternion.W, Constants.Epsilon15);
Assert.AreEqual(x, quaternion.X, Constants.Epsilon15);
Assert.AreEqual(y, quaternion.Y, Constants.Epsilon15);
Assert.AreEqual(z, quaternion.Z, Constants.Epsilon15);
}
public void TestMultiplyByScalar()
{
Matrix3By3 test = new Matrix3By3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
Matrix3By3 result = test.Multiply(-2.0);
Assert.AreEqual(-2.0, result.M11);
Assert.AreEqual(-4.0, result.M12);
Assert.AreEqual(-6.0, result.M13);
Assert.AreEqual(-8.0, result.M21);
Assert.AreEqual(-10.0, result.M22);
Assert.AreEqual(-12.0, result.M23);
Assert.AreEqual(-14.0, result.M31);
Assert.AreEqual(-16.0, result.M32);
Assert.AreEqual(-18.0, result.M33);
result = test * -2.0;
Assert.AreEqual(-2.0, result.M11);
Assert.AreEqual(-4.0, result.M12);
Assert.AreEqual(-6.0, result.M13);
Assert.AreEqual(-8.0, result.M21);
Assert.AreEqual(-10.0, result.M22);
Assert.AreEqual(-12.0, result.M23);
Assert.AreEqual(-14.0, result.M31);
Assert.AreEqual(-16.0, result.M32);
Assert.AreEqual(-18.0, result.M33);
result = -2.0 * test;
Assert.AreEqual(-2.0, result.M11);
Assert.AreEqual(-4.0, result.M12);
Assert.AreEqual(-6.0, result.M13);
Assert.AreEqual(-8.0, result.M21);
Assert.AreEqual(-10.0, result.M22);
Assert.AreEqual(-12.0, result.M23);
Assert.AreEqual(-14.0, result.M31);
Assert.AreEqual(-16.0, result.M32);
Assert.AreEqual(-18.0, result.M33);
}
public void TestTranspose()
{
Matrix3By3 original = new Matrix3By3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
Matrix3By3 transposed = original.Transpose();
Assert.AreEqual(transposed.M11, original.M11);
Assert.AreEqual(transposed.M12, original.M21);
Assert.AreEqual(transposed.M13, original.M31);
Assert.AreEqual(transposed.M21, original.M12);
Assert.AreEqual(transposed.M22, original.M22);
Assert.AreEqual(transposed.M23, original.M32);
Assert.AreEqual(transposed.M31, original.M13);
Assert.AreEqual(transposed.M32, original.M23);
Assert.AreEqual(transposed.M33, original.M33);
}
public void TestSecondIndexTooLow2()
{
Matrix3By3 diagonal = Matrix3By3.DiagonalMatrix(-3.0, 1.0, 5.0);
double bad = diagonal[2, -1];
}
public void TestMultiplyByMatrix()
{
double angle = Math.PI / 4.0;
double cos = Math.Cos(angle / 2.0);
double sin = Math.Sin(angle / 2.0);
double a = cos * cos - sin * sin / 3.0;
double b = 2.0 * (sin * sin + sin * cos * Math.Sqrt(3.0)) / 3.0;
double c = 2.0 * (sin * sin - sin * cos * Math.Sqrt(3.0)) / 3.0;
// The matrix here is formed from the orthonormal set obtained by rotating
// the x-axis, y-axis, and z-axis through an angle of 45 degrees about
// the (1,1,1) vector.
Matrix3By3 test = new Matrix3By3(a, c, b, b, a, c, c, b, a);
Matrix3By3 transpose = test.Transpose();
Matrix3By3 result = test.Multiply(transpose);
Assert.IsTrue(result.EqualsEpsilon(Matrix3By3.Identity, 1e-16));
result = test * transpose;
Assert.IsTrue(result.EqualsEpsilon(Matrix3By3.Identity, 1e-16));
}
public void TestGetHashCode()
{
Matrix3By3 object1 = Matrix3By3.Identity;
Matrix3By3 object2 = Matrix3By3.Identity;
Matrix3By3 object3 = new Matrix3By3();
Assert.AreEqual(object1.GetHashCode(), object2.GetHashCode());
Assert.AreNotEqual(object1.GetHashCode(), object3.GetHashCode());
}
public void TestSecondIndexTooHigh0()
{
Matrix3By3 diagonal = Matrix3By3.DiagonalMatrix(-3.0, 1.0, 5.0);
double bad = diagonal[0, 3];
}
public void TestFirstIndexTooLow()
{
Matrix3By3 diagonal = Matrix3By3.DiagonalMatrix(-3.0, 1.0, 5.0);
double bad = diagonal[-1, 0];
}
public void TestMathOperators()
{
Matrix3By3 test1 = new Matrix3By3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
Matrix3By3 test2 = new Matrix3By3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
Assert.IsTrue(Matrix3By3.Zero.Equals(test1.Subtract(test2)));
Assert.IsTrue(Matrix3By3.Zero.Equals(test1 - test2));
Assert.IsTrue((test2 * 2.0).Equals(test1.Add(test2)));
Assert.IsTrue((test2 * 2.0).Equals(test1 + test2));
Assert.IsTrue((new Matrix3By3(30, 36, 42, 66, 81, 96, 102, 126, 150).Equals(test1.Multiply(test2))));
Assert.IsTrue((new Matrix3By3(30, 36, 42, 66, 81, 96, 102, 126, 150).Equals(test1 * test2)));
}
public void TestInvert()
{
Matrix3By3 test = new Matrix3By3(1.0, 5.0, 2.0, 1.0, 1.0, 7.0, 0.0, -3.0, 4.0);
Matrix3By3 inv = test.Invert();
Assert.AreEqual(-25.0, inv.M11);
Assert.AreEqual(26.0, inv.M12);
Assert.AreEqual(-33.0, inv.M13);
Assert.AreEqual(4.0, inv.M21);
Assert.AreEqual(-4.0, inv.M22);
Assert.AreEqual(5.0, inv.M23);
Assert.AreEqual(3.0, inv.M31);
Assert.AreEqual(-3.0, inv.M32);
Assert.AreEqual(4.0, inv.M33);
}
