public void CreateRotation2()
{
double angle = (double)MathHelper.ToRadians(30);
Matrix22D m = Matrix22D.CreateRotation(angle);
Assert.IsTrue(Vector2D.AreNumericallyEqual(new Vector2D((double)Math.Cos(angle), (double)Math.Sin(angle)), m * Vector2D.UnitX));
}
public void SerializationBinary()
{
Matrix22D m1 = new Matrix22D(12, 23,
45, 56.3);
Matrix22D m2;
string fileName = "SerializationMatrix22D.bin";
if (File.Exists(fileName))
{
File.Delete(fileName);
}
FileStream fs = new FileStream(fileName, FileMode.Create);
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(fs, m1);
fs.Close();
fs = new FileStream(fileName, FileMode.Open);
formatter = new BinaryFormatter();
m2 = (Matrix22D)formatter.Deserialize(fs);
fs.Close();
Assert.AreEqual(m1, m2);
}
public void GetRow()
{
Matrix22D m = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
Assert.AreEqual(new Vector2D(1.0, 2.0), m.GetRow(0));
Assert.AreEqual(new Vector2D(3.0, 4.0), m.GetRow(1));
}
public void Trace()
{
Matrix22D m = new Matrix22D(new double[2, 2] {
{ 1, 2 }, { 2, 4 }
});
Assert.AreEqual(5, m.Trace);
}
public void Transposed()
{
Matrix22D m = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
Matrix22D mt = new Matrix22D(rowMajor, MatrixOrder.ColumnMajor);
Assert.AreEqual(mt, m.Transposed);
Assert.AreEqual(Matrix22D.Identity, Matrix22D.Identity.Transposed);
}
public void Addition()
{
Matrix22D m1 = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
Matrix22D m2 = Matrix22D.One;
Matrix22D result = Matrix22D.Add(m1, m2);
for (int i = 0; i < 4; i++)
Assert.AreEqual(rowMajor[i] + 1.0, result[i]);
}
public void AdditionOperator()
{
Matrix22D m1 = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
Matrix22D m2 = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor) * 3;
Matrix22D result = m1 + m2;
for (int i = 0; i < 4; i++)
Assert.AreEqual(rowMajor[i] * 4, result[i]);
}
public void Determinant()
{
Matrix22D m = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
Assert.AreEqual(-2.0, m.Determinant);
Assert.AreEqual(0.0, Matrix22D.Zero.Determinant);
Assert.AreEqual(0.0, Matrix22D.One.Determinant);
Assert.AreEqual(1.0, Matrix22D.Identity.Determinant);
}
public void CreateRotation()
{
Matrix22D m = Matrix22D.CreateRotation(0.0);
Assert.AreEqual(Matrix22D.Identity, m);
m = Matrix22D.CreateRotation((double)Math.PI / 2);
Assert.IsTrue(Vector2D.AreNumericallyEqual(Vector2D.UnitY, m * Vector2D.UnitX));
}
public void Negation()
{
Matrix22D m = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
for (int i = 0; i < 4; i++)
{
Assert.AreEqual(-rowMajor[i], Matrix22D.Negate(m)[i]);
}
}
public void InverseWithNearSingularMatrix()
{
Matrix22D m = new Matrix22D(0.0001, 0,
0, 0.0001);
Vector2D v = Vector2D.One;
Vector2D w = m * v;
Assert.IsTrue(Vector2D.AreNumericallyEqual(v, m.Inverse * w));
Assert.IsTrue(Matrix22D.AreNumericallyEqual(Matrix22D.Identity, m * m.Inverse));
}
public void Inverse()
{
Assert.AreEqual(Matrix22D.Identity, Matrix22D.Identity.Inverse);
Matrix22D m = new Matrix22D(1, 2, 3, 4);
Vector2D v = Vector2D.One;
Vector2D w = m * v;
Assert.IsTrue(Vector2D.AreNumericallyEqual(v, m.Inverse * w));
Assert.IsTrue(Matrix22D.AreNumericallyEqual(Matrix22D.Identity, m * m.Inverse));
}
public void SubtractionOperator()
{
Matrix22D m1 = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
Matrix22D m2 = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor) * 3;
Matrix22D result = m1 - m2;
for (int i = 0; i < 4; i++)
{
Assert.AreEqual(-rowMajor[i] * 2, result[i]);
}
}
public void Subtraction()
{
Matrix22D m1 = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
Matrix22D m2 = Matrix22D.One;
Matrix22D result = Matrix22D.Subtract(m1, m2);
for (int i = 0; i < 4; i++)
{
Assert.AreEqual(rowMajor[i] - 1.0, result[i]);
}
}
public void Multiplication()
{
double s = 0.1234;
Matrix22D m = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
m = Matrix22D.Multiply(s, m);
for (int i = 0; i < 4; i++)
{
Assert.AreEqual(rowMajor[i] * s, m[i]);
}
}
public void Division()
{
double s = 0.1234;
Matrix22D m = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
m = Matrix22D.Divide(m, s);
for (int i = 0; i < 4; i++)
{
Assert.IsTrue(Numeric.AreEqual(rowMajor[i] / s, m[i]));
}
}
public void ToMatrix22F()
{
double m00 = 23.5; double m01 = 0.0;
double m10 = 33.5; double m11 = 1.1;
Matrix22F matrix22F = new Matrix22D(m00, m01, m10, m11).ToMatrix22F();
Assert.IsTrue(Numeric.AreEqual((float)m00, matrix22F[0, 0]));
Assert.IsTrue(Numeric.AreEqual((float)m01, matrix22F[0, 1]));
Assert.IsTrue(Numeric.AreEqual((float)m10, matrix22F[1, 0]));
Assert.IsTrue(Numeric.AreEqual((float)m11, matrix22F[1, 1]));
}
public void RandomMatrix22D()
{
Matrix22D matrix = RandomHelper.Random.NextMatrix22D(10.0, 100.0);
for (int i = 0; i < 4; i++)
{
Assert.IsTrue(10.0 <= matrix[i] && matrix[i] <= 100.0);
}
// Must not throw exception.
RandomHelper.NextMatrix22D(null, 1, 3);
}
public void SetRow()
{
Matrix22D m = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
m.SetRow(0, new Vector2D(0.1, 0.2));
Assert.AreEqual(new Vector2D(0.1, 0.2), m.GetRow(0));
Assert.AreEqual(new Vector2D(3.0, 4.0), m.GetRow(1));
m.SetRow(1, new Vector2D(0.4, 0.5));
Assert.AreEqual(new Vector2D(0.1, 0.2), m.GetRow(0));
Assert.AreEqual(new Vector2D(0.4, 0.5), m.GetRow(1));
}
public void Transpose()
{
Matrix22D m = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
m.Transpose();
Matrix22D mt = new Matrix22D(rowMajor, MatrixOrder.ColumnMajor);
Assert.AreEqual(mt, m);
Matrix22D i = Matrix22D.Identity;
i.Transpose();
Assert.AreEqual(Matrix22D.Identity, i);
}
public void IsSymmetric()
{
Matrix22D m = new Matrix22D(new double[2, 2] {
{ 1, 2 }, { 2, 4 }
});
Assert.AreEqual(true, m.IsSymmetric);
m = new Matrix22D(new double[2, 2] {
{ 2, 1 }, { 4, 2 }
});
Assert.AreEqual(false, m.IsSymmetric);
}
public void ToList()
{
Matrix22D m = new Matrix22D(1, 2, 3, 4);
IList <double> list = m.ToList(MatrixOrder.RowMajor);
for (int i = 0; i < 4; i++)
{
Assert.AreEqual(rowMajor[i], list[i]);
}
list = m.ToList(MatrixOrder.ColumnMajor);
for (int i = 0; i < 4; i++)
{
Assert.AreEqual(columnMajor[i], list[i]);
}
}
public void AreEqualWithEpsilon()
{
double epsilon = 0.001;
Matrix22D m0 = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
Matrix22D m1 = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
m1 += new Matrix22D(0.002);
Matrix22D m2 = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
m2 += new Matrix22D(0.0001);
Assert.IsTrue(Matrix22D.AreNumericallyEqual(m0, m0, epsilon));
Assert.IsFalse(Matrix22D.AreNumericallyEqual(m0, m1, epsilon));
Assert.IsTrue(Matrix22D.AreNumericallyEqual(m0, m2, epsilon));
}
public void EqualityOperators()
{
Matrix22D m1 = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
Matrix22D m2 = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
Assert.IsTrue(m1 == m2);
Assert.IsFalse(m1 != m2);
for (int i = 0; i < 4; i++)
{
m2 = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
m2[i] += 0.1;
Assert.IsFalse(m1 == m2);
Assert.IsTrue(m1 != m2);
}
}
public void ToArray1D()
{
Matrix22D m = new Matrix22D(1, 2, 3, 4);
double[] array = m.ToArray1D(MatrixOrder.RowMajor);
for (int i = 0; i < 4; i++)
{
Assert.AreEqual(rowMajor[i], array[i]);
}
array = m.ToArray1D(MatrixOrder.ColumnMajor);
for (int i = 0; i < 4; i++)
{
Assert.AreEqual(columnMajor[i], array[i]);
}
}
public void MultiplyVector()
{
Vector2D v = new Vector2D(2.34, 3.45);
Assert.AreEqual(v, Matrix22D.Multiply(Matrix22D.Identity, v));
Assert.AreEqual(Vector2D.Zero, Matrix22D.Multiply(Matrix22D.Zero, v));
Matrix22D m = new Matrix22D(12, 23, 45, 67);
Assert.IsTrue(Vector2D.AreNumericallyEqual(v, Matrix22D.Multiply(m * m.Inverse, v)));
for (int i = 0; i < 2; i++)
{
Assert.AreEqual(Vector2D.Dot(m.GetRow(i), v), Matrix22D.Multiply(m, v)[i]);
}
}
public void Indexer1d()
{
Matrix22D m = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
for (int i = 0; i < 4; i++)
{
Assert.AreEqual(rowMajor[i], m[i]);
}
m = Matrix22D.Zero;
for (int i = 0; i < 4; i++)
{
m[i] = rowMajor[i];
}
Assert.AreEqual(new Matrix22D(columnMajor, MatrixOrder.ColumnMajor), m);
}
public void TestEquals()
{
Matrix22D m1 = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
Matrix22D m2 = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
Assert.IsTrue(m1.Equals(m1));
Assert.IsTrue(m1.Equals(m2));
for (int i = 0; i < 4; i++)
{
m2 = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
m2[i] += 0.1;
Assert.IsFalse(m1.Equals(m2));
}
Assert.IsFalse(m1.Equals(m1.ToString()));
}
public void Properties()
{
Matrix22D m = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
Assert.AreEqual(1.0, m.M00);
Assert.AreEqual(2.0, m.M01);
Assert.AreEqual(3.0, m.M10);
Assert.AreEqual(4.0, m.M11);
m = Matrix22D.Zero;
m.M00 = 1.0;
m.M01 = 2.0;
m.M10 = 3.0;
m.M11 = 4.0;
Assert.AreEqual(new Matrix22D(columnMajor, MatrixOrder.ColumnMajor), m);
}
public void Constants()
{
Matrix22D zero = Matrix22D.Zero;
for (int i = 0; i < 4; i++)
{
Assert.AreEqual(0.0, zero[i]);
}
Matrix22D one = Matrix22D.One;
for (int i = 0; i < 4; i++)
{
Assert.AreEqual(1.0, one[i]);
}
}
public void AbsoluteStatic()
{
Matrix22D m = new Matrix22D(-1, -2, -3, -4);
Matrix22D absoluteM = Matrix22D.Absolute(m);
Assert.AreEqual(1, absoluteM.M00);
Assert.AreEqual(2, absoluteM.M01);
Assert.AreEqual(3, absoluteM.M10);
Assert.AreEqual(4, absoluteM.M11);
m = new Matrix22D(1, 2, 3, 4);
absoluteM = Matrix22D.Absolute(m);
Assert.AreEqual(1, absoluteM.M00);
Assert.AreEqual(2, absoluteM.M01);
Assert.AreEqual(3, absoluteM.M10);
Assert.AreEqual(4, absoluteM.M11);
}
public void AbsoluteStatic()
{
Matrix22D m = new Matrix22D(-1, -2, -3, -4);
Matrix22D absoluteM = Matrix22D.Absolute(m);
Assert.AreEqual(1, absoluteM.M00);
Assert.AreEqual(2, absoluteM.M01);
Assert.AreEqual(3, absoluteM.M10);
Assert.AreEqual(4, absoluteM.M11);
m = new Matrix22D(1, 2, 3, 4);
absoluteM = Matrix22D.Absolute(m);
Assert.AreEqual(1, absoluteM.M00);
Assert.AreEqual(2, absoluteM.M01);
Assert.AreEqual(3, absoluteM.M10);
Assert.AreEqual(4, absoluteM.M11);
}
public void IsNaN()
{
const int numberOfRows = 2;
const int numberOfColumns = 2;
Assert.IsFalse(new Matrix22D().IsNaN);
for (int r = 0; r < numberOfRows; r++)
{
for (int c = 0; c < numberOfColumns; c++)
{
Matrix22D m = new Matrix22D();
m[r, c] = double.NaN;
Assert.IsTrue(m.IsNaN);
}
}
}
public void MultiplyVectorOperator()
{
Vector2D v = new Vector2D(2.34, 3.45);
Assert.AreEqual(v, Matrix22D.Identity * v);
Assert.AreEqual(Vector2D.Zero, Matrix22D.Zero * v);
Matrix22D m = new Matrix22D(12, 23, 45, 67);
Assert.IsTrue(Vector2D.AreNumericallyEqual(v, m * m.Inverse * v));
for (int i = 0; i < 2; i++)
Assert.AreEqual(Vector2D.Dot(m.GetRow(i), v), (m * v)[i]);
}
public void MultiplyMatrixOperator()
{
Matrix22D m = new Matrix22D(12, 23, 45, 67);
Assert.AreEqual(Matrix22D.Zero, m * Matrix22D.Zero);
Assert.AreEqual(Matrix22D.Zero, Matrix22D.Zero * m);
Assert.AreEqual(m, m * Matrix22D.Identity);
Assert.AreEqual(m, Matrix22D.Identity * m);
Assert.IsTrue(Matrix22D.AreNumericallyEqual(Matrix22D.Identity, m * m.Inverse));
Assert.IsTrue(Matrix22D.AreNumericallyEqual(Matrix22D.Identity, m.Inverse * m));
Matrix22D m1 = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
Matrix22D m2 = new Matrix22D(12, 23, 45, 67);
Matrix22D result = m1 * m2;
for (int column = 0; column < 2; column++)
for (int row = 0; row < 2; row++)
Assert.AreEqual(Vector2D.Dot(m1.GetRow(row), m2.GetColumn(column)), result[row, column]);
}
public void ToArrayJagged()
{
Matrix22D m = new Matrix22D(1, 2, 3, 4);
double[][] array = m.ToArrayJagged();
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
Assert.AreEqual(i * 2 + j + 1, array[i][j]);
array = (double[][])m;
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
Assert.AreEqual(i * 2 + j + 1, array[i][j]);
}
public void NegationOperator()
{
Matrix22D m = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
for (int i = 0; i < 4; i++)
Assert.AreEqual(-rowMajor[i], (-m)[i]);
}
public void InvertException()
{
Matrix22D m = new Matrix22D(1, 2, 4, 8);
m.Invert();
}
public void InverseWithNearSingularMatrix()
{
Matrix22D m = new Matrix22D(0.0001, 0,
0, 0.0001);
Vector2D v = Vector2D.One;
Vector2D w = m * v;
Assert.IsTrue(Vector2D.AreNumericallyEqual(v, m.Inverse * w));
Assert.IsTrue(Matrix22D.AreNumericallyEqual(Matrix22D.Identity, m * m.Inverse));
}
public void ToList()
{
Matrix22D m = new Matrix22D(1, 2, 3, 4);
IList<double> list = m.ToList(MatrixOrder.RowMajor);
for (int i = 0; i < 4; i++)
Assert.AreEqual(rowMajor[i], list[i]);
list = m.ToList(MatrixOrder.ColumnMajor);
for (int i = 0; i < 4; i++)
Assert.AreEqual(columnMajor[i], list[i]);
}
public void IsSymmetric()
{
Matrix22D m = new Matrix22D(new double[2, 2] { { 1, 2 }, { 2, 4 } });
Assert.AreEqual(true, m.IsSymmetric);
m = new Matrix22D(new double[2, 2] { { 2, 1 }, { 4, 2 } });
Assert.AreEqual(false, m.IsSymmetric);
}
public void MultiplicationOperator()
{
double s = 0.1234;
Matrix22D m = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
m = s * m;
for (int i = 0; i < 4; i++)
Assert.AreEqual(rowMajor[i] * s, m[i]);
m = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
m = m * s;
for (int i = 0; i < 4; i++)
Assert.AreEqual(rowMajor[i] * s, m[i]);
}
public void SetRowException2()
{
Matrix22D m = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
m.SetRow(2, Vector2D.One);
}
public void ToMatrix22F()
{
double m00 = 23.5; double m01 = 0.0;
double m10 = 33.5; double m11 = 1.1;
Matrix22F matrix22F = new Matrix22D(m00, m01, m10, m11).ToMatrix22F();
Assert.IsTrue(Numeric.AreEqual((float)m00, matrix22F[0, 0]));
Assert.IsTrue(Numeric.AreEqual((float)m01, matrix22F[0, 1]));
Assert.IsTrue(Numeric.AreEqual((float)m10, matrix22F[1, 0]));
Assert.IsTrue(Numeric.AreEqual((float)m11, matrix22F[1, 1]));
}
public void AreEqual()
{
double originalEpsilon = Numeric.EpsilonD;
Numeric.EpsilonD = 1e-8;
Matrix22D m0 = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
Matrix22D m1 = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
m1 += new Matrix22D(0.000001);
Matrix22D m2 = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
m2 += new Matrix22D(0.00000001);
Assert.IsTrue(Matrix22D.AreNumericallyEqual(m0, m0));
Assert.IsFalse(Matrix22D.AreNumericallyEqual(m0, m1));
Assert.IsTrue(Matrix22D.AreNumericallyEqual(m0, m2));
Numeric.EpsilonD = originalEpsilon;
}
public void TestToString()
{
Matrix22D m = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
Assert.IsFalse(String.IsNullOrEmpty(m.ToString()));
}
public void SetRow()
{
Matrix22D m = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
m.SetRow(0, new Vector2D(0.1, 0.2));
Assert.AreEqual(new Vector2D(0.1, 0.2), m.GetRow(0));
Assert.AreEqual(new Vector2D(3.0, 4.0), m.GetRow(1));
m.SetRow(1, new Vector2D(0.4, 0.5));
Assert.AreEqual(new Vector2D(0.1, 0.2), m.GetRow(0));
Assert.AreEqual(new Vector2D(0.4, 0.5), m.GetRow(1));
}
public void SerializationJson()
{
Matrix22D m1 = new Matrix22D(12, 23, 45, 67);
Matrix22D m2;
string fileName = "SerializationMatrix22D.json";
if (File.Exists(fileName))
File.Delete(fileName);
var serializer = new DataContractJsonSerializer(typeof(Matrix22D));
using (var stream = new FileStream(fileName, FileMode.CreateNew, FileAccess.Write))
serializer.WriteObject(stream, m1);
using (var stream = new FileStream(fileName, FileMode.Open, FileAccess.Read))
m2 = (Matrix22D)serializer.ReadObject(stream);
Assert.AreEqual(m1, m2);
}
public void Multiplication()
{
double s = 0.1234;
Matrix22D m = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
m = Matrix22D.Multiply(s, m);
for (int i = 0; i < 4; i++)
Assert.AreEqual(rowMajor[i] * s, m[i]);
}
public void InverseException()
{
Matrix22D m = new Matrix22D(1, 2, 4, 8);
m = m.Inverse;
}
public void SetColumnException1()
{
Matrix22D m = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
m.SetColumn(-1, Vector2D.One);
}
public void SerializationXml()
{
Matrix22D m1 = new Matrix22D(12, 23, 45, 67);
Matrix22D m2;
string fileName = "SerializationMatrix22D.xml";
if (File.Exists(fileName))
File.Delete(fileName);
XmlSerializer serializer = new XmlSerializer(typeof(Matrix22D));
StreamWriter writer = new StreamWriter(fileName);
serializer.Serialize(writer, m1);
writer.Close();
serializer = new XmlSerializer(typeof(Matrix22D));
FileStream fileStream = new FileStream(fileName, FileMode.Open);
m2 = (Matrix22D)serializer.Deserialize(fileStream);
Assert.AreEqual(m1, m2);
}
public void IsNaN()
{
const int numberOfRows = 2;
const int numberOfColumns = 2;
Assert.IsFalse(new Matrix22D().IsNaN);
for (int r = 0; r < numberOfRows; r++)
{
for (int c = 0; c < numberOfColumns; c++)
{
Matrix22D m = new Matrix22D();
m[r, c] = double.NaN;
Assert.IsTrue(m.IsNaN);
}
}
}
public void SerializationBinary()
{
Matrix22D m1 = new Matrix22D(12, 23,
45, 56.3);
Matrix22D m2;
string fileName = "SerializationMatrix22D.bin";
if (File.Exists(fileName))
File.Delete(fileName);
FileStream fs = new FileStream(fileName, FileMode.Create);
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(fs, m1);
fs.Close();
fs = new FileStream(fileName, FileMode.Open);
formatter = new BinaryFormatter();
m2 = (Matrix22D)formatter.Deserialize(fs);
fs.Close();
Assert.AreEqual(m1, m2);
}
public void Invert()
{
Assert.AreEqual(Matrix22D.Identity, Matrix22D.Identity.Inverse);
Matrix22D m = new Matrix22D(1, 2, 3, 4);
Vector2D v = Vector2D.One;
Vector2D w = m * v;
Matrix22D im = m;
im.Invert();
Assert.IsTrue(Vector2D.AreNumericallyEqual(v, im * w));
Assert.IsTrue(Matrix22D.AreNumericallyEqual(Matrix22D.Identity, m * im));
}
public void Properties()
{
Matrix22D m = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
Assert.AreEqual(1.0, m.M00);
Assert.AreEqual(2.0, m.M01);
Assert.AreEqual(3.0, m.M10);
Assert.AreEqual(4.0, m.M11);
m = Matrix22D.Zero;
m.M00 = 1.0;
m.M01 = 2.0;
m.M10 = 3.0;
m.M11 = 4.0;
Assert.AreEqual(new Matrix22D(columnMajor, MatrixOrder.ColumnMajor), m);
}
public void TestEquals()
{
Matrix22D m1 = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
Matrix22D m2 = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
Assert.IsTrue(m1.Equals(m1));
Assert.IsTrue(m1.Equals(m2));
for (int i = 0; i < 4; i++)
{
m2 = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
m2[i] += 0.1;
Assert.IsFalse(m1.Equals(m2));
}
Assert.IsFalse(m1.Equals(m1.ToString()));
}
public void ToArray1D()
{
Matrix22D m = new Matrix22D(1, 2, 3, 4);
double[] array = m.ToArray1D(MatrixOrder.RowMajor);
for (int i = 0; i < 4; i++)
Assert.AreEqual(rowMajor[i], array[i]);
array = m.ToArray1D(MatrixOrder.ColumnMajor);
for (int i = 0; i < 4; i++)
Assert.AreEqual(columnMajor[i], array[i]);
}
public void Indexer2d()
{
Matrix22D m = new Matrix22D(columnMajor, MatrixOrder.ColumnMajor);
for (int column = 0; column < 2; column++)
for (int row = 0; row < 2; row++)
Assert.AreEqual(columnMajor[column * 2 + row], m[row, column]);
m = Matrix22D.Zero;
for (int column = 0; column < 2; column++)
for (int row = 0; row < 2; row++)
m[row, column] = (row * 2 + column + 1);
Assert.AreEqual(new Matrix22D(columnMajor, MatrixOrder.ColumnMajor), m);
}
public void SerializationXml2()
{
Matrix22D m1 = new Matrix22D(12, 23, 45, 67);
Matrix22D m2;
string fileName = "SerializationMatrix22D_DataContractSerializer.xml";
if (File.Exists(fileName))
File.Delete(fileName);
var serializer = new DataContractSerializer(typeof(Matrix22D));
using (var stream = new FileStream(fileName, FileMode.CreateNew, FileAccess.Write))
using (var writer = XmlDictionaryWriter.CreateTextWriter(stream, Encoding.UTF8))
serializer.WriteObject(writer, m1);
using (var stream = new FileStream(fileName, FileMode.Open, FileAccess.Read))
using (var reader = XmlDictionaryReader.CreateTextReader(stream, new XmlDictionaryReaderQuotas()))
m2 = (Matrix22D)serializer.ReadObject(reader);
Assert.AreEqual(m1, m2);
}
