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