source: branches/NCA/HeuristicLab.Algorithms.NCA.Tests/MatrixTest.cs @ 8464

using HeuristicLab.Common;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace HeuristicLab.Algorithms.NCA.Tests {


  /// <summary>
  ///This is a test class for MatrixTest and is intended
  ///to contain all MatrixTest Unit Tests
  ///</summary>
  [TestClass()]
  public class MatrixTest {


    private TestContext testContextInstance;

    /// <summary>
    ///Gets or sets the test context which provides
    ///information about and functionality for the current test run.
    ///</summary>
    public TestContext TestContext {
      get {
        return testContextInstance;
      }
      set {
        testContextInstance = value;
      }
    }

    #region Additional test attributes
    // 
    //You can use the following additional attributes as you write your tests:
    //
    //Use ClassInitialize to run code before running the first test in the class
    //[ClassInitialize()]
    //public static void MyClassInitialize(TestContext testContext)
    //{
    //}
    //
    //Use ClassCleanup to run code after all tests in a class have run
    //[ClassCleanup()]
    //public static void MyClassCleanup()
    //{
    //}
    //
    //Use TestInitialize to run code before running each test
    //[TestInitialize()]
    //public void MyTestInitialize()
    //{
    //}
    //
    //Use TestCleanup to run code after each test has run
    //[TestCleanup()]
    //public void MyTestCleanup()
    //{
    //}
    //
    #endregion

    private bool IsEqual(Matrix_Accessor a, Matrix_Accessor b) {
      var i1 = a.GetEnumerator();
      var i2 = b.GetEnumerator();
      bool f, g;
      do {
        f = i1.MoveNext();
        g = i2.MoveNext();
        if (!f && !g) return true;
        if (!f && g || f && !g || i1.Current != i2.Current) return false;
      } while (f && g);
      return !f && !g;
    }

    /// <summary>
    ///A test for Add
    ///</summary>
    [TestMethod()]
    [DeploymentItem("HeuristicLab.Algorithms.NCA-3.3.dll")]
    public void AddTest() {
      var mat1 = new double[,] { { -3, 2 }, { 5, 6 } };
      var mat2 = new double[,] { { 2, 1 }, { 1, 2 } };
      var result = new double[,] { { -1, 3 }, { 6, 8 } };
      Assert.IsTrue(IsEqual(new Matrix_Accessor(mat1).Add(new Matrix_Accessor(mat2)), new Matrix_Accessor(result)));
      mat1 = new double[,] { { 2, 1 }, { -4, 7 }, { 10, 20 } };
      mat2 = new double[,] { { 3, 0 }, { 2, 4 }, { 5, 8 } };
      result = new double[,] { { 5, 1 }, { -2, 11 }, { 15, 28 } };
      Assert.IsTrue(IsEqual(new Matrix_Accessor(mat1).Add(new Matrix_Accessor(mat2)), new Matrix_Accessor(result)));
    }

    /// <summary>
    ///A test for AddTo
    ///</summary>
    [TestMethod()]
    [DeploymentItem("HeuristicLab.Algorithms.NCA-3.3.dll")]
    public void AddToTest() {
      var mat1 = new double[,] { { 3, 2 }, { -5, 6 } };
      var mat2 = new double[,] { { 2, 1 }, { 1, 2 } };
      var result = new double[,] { { 5, 3 }, { -4, 8 } };
      new Matrix_Accessor(mat1).AddTo(mat2);
      Assert.IsTrue(IsEqual(new Matrix_Accessor(mat2), new Matrix_Accessor(result)));
      mat1 = new double[,] { { 2, 1 }, { 4, 7 }, { 10, -20 } };
      mat2 = new double[,] { { 3, 0 }, { 2, 4 }, { 5, 8 } };
      result = new double[,] { { 5, 1 }, { 6, 11 }, { 15, -12 } };
      new Matrix_Accessor(mat1).AddTo(mat2);
      Assert.IsTrue(IsEqual(new Matrix_Accessor(mat2), new Matrix_Accessor(result)));
    }

    /// <summary>
    ///A test for Apply
    ///</summary>
    [TestMethod()]
    [DeploymentItem("HeuristicLab.Algorithms.NCA-3.3.dll")]
    public void ApplyTest() {
      var mat = new double[,] { { 2, 1 }, { 4, 7 }, { -10, 20 } };
      Assert.IsTrue(IsEqual(new Matrix_Accessor(mat).Apply(), new Matrix_Accessor(mat)));
    }

    /// <summary>
    ///A test for Length
    ///</summary>
    [TestMethod()]
    [DeploymentItem("HeuristicLab.Algorithms.NCA-3.3.dll")]
    public void LengthTest() {
      var vector = new double[] { 5, 4, 2, 2 };
      Assert.AreEqual(new Matrix_Accessor(vector, vector.Length).VectorLength(), 7);
      vector = new double[] { 5, -4, 2, 2 };
      Assert.AreEqual(new Matrix_Accessor(vector, vector.Length).VectorLength(), 7);
      vector = new double[] { 3, 2, 1, 5 };
      Assert.IsTrue(new Matrix_Accessor(vector, vector.Length).VectorLength().IsAlmost(6.2449979983983982058468931209398));
    }

    /// <summary>
    ///A test for Multiply
    ///</summary>
    [TestMethod()]
    [DeploymentItem("HeuristicLab.Algorithms.NCA-3.3.dll")]
    public void MultiplyTest() {
      var mat1 = new double[,] { { 3, 2 }, { 5, 6 } };
      var mat2 = new double[,] { { 2, 1 }, { 1, 2 } };
      var result = new double[,] { { 8, 7 }, { 16, 17 } };
      Assert.IsTrue(IsEqual(new Matrix_Accessor(mat1).Multiply(new Matrix_Accessor(mat2)), new Matrix_Accessor(result)));
      mat1 = new double[,] { { 2, 4, 10 }, { 1, 7, 20 } };
      mat2 = new double[,] { { 3, 0 }, { 2, 4 }, { 5, 8 } };
      result = new double[,] { { 64, 96 }, { 117, 188 } };
      Assert.IsTrue(IsEqual(new Matrix_Accessor(mat1).Multiply(new Matrix_Accessor(mat2)), new Matrix_Accessor(result)));
      mat1 = new double[,] { { 2, 1 }, { 4, 7 }, { 10, 20 } };
      Assert.IsTrue(IsEqual(new Matrix_Accessor(mat1).Transpose().Multiply(new Matrix_Accessor(mat2)), new Matrix_Accessor(result)));
      mat1 = new double[,] { { -3, 2, -2 }, { 4, 0, -5 } };
      mat2 = new double[,] { { 1, -1 }, { -2, 3 }, { 2, 5 } };
      result = new double[,] { { -11, -1 }, { -6, -29 } };
      Assert.IsTrue(IsEqual(new Matrix_Accessor(mat1).Multiply(new Matrix_Accessor(mat2)), new Matrix_Accessor(result)));
      mat1 = new double[,] { { 4, 1, -2 } };
      mat2 = new double[,] { { 1, -1 }, { -3, 2 }, { 2, 4 } };
      result = new double[,] { { -3, -10 } };
      var result2 = new double[] { -3, -10 };
      Assert.IsTrue(IsEqual(new Matrix_Accessor(mat1).Multiply(new Matrix_Accessor(mat2)), new Matrix_Accessor(result)));
      Assert.IsTrue(IsEqual(new Matrix_Accessor(mat1).Multiply(new Matrix_Accessor(mat2)), new Matrix_Accessor(result2)));
    }

    /// <summary>
    ///A test for Multiply
    ///</summary>
    [TestMethod()]
    [DeploymentItem("HeuristicLab.Algorithms.NCA-3.3.dll")]
    public void MultiplyScalarTest() {
      var mat1 = new double[,] { { 3, -2 }, { 5, 6 } };
      var result = new double[,] { { 6, -4 }, { 10, 12 } };
      Assert.IsTrue(IsEqual(new Matrix_Accessor(mat1).Multiply(2.0), new Matrix_Accessor(result)));
    }

    /// <summary>
    ///A test for Negate
    ///</summary>
    [TestMethod()]
    [DeploymentItem("HeuristicLab.Algorithms.NCA-3.3.dll")]
    public void NegateTest() {
      var mat1 = new double[,] { { 3, -2 }, { -5, 6 } };
      var result = new double[,] { { -3, 2 }, { 5, -6 } };
      Assert.IsTrue(IsEqual(new Matrix_Accessor(mat1).Negate(), new Matrix_Accessor(result)));
      mat1 = new double[,] { { 3, -2 }, { -5, 6 } };
      result = new double[,] { { -3, 2 }, { 5, -6 } };
      Assert.IsTrue(IsEqual(new Matrix_Accessor(mat1).Negate().Negate(), new Matrix_Accessor(result).Negate()));
    }

    /// <summary>
    ///A test for OuterProduct
    ///</summary>
    [TestMethod()]
    [DeploymentItem("HeuristicLab.Algorithms.NCA-3.3.dll")]
    public void OuterProductTest() {
      var vec1 = new double[] { 2, 3, 5 };
      var vec2 = new double[] { -1, 4, -2 };
      var result = new double[,] { { -2, 8, -4 }, { -3, 12, -6 }, { -5, 20, -10 } };
      Assert.IsTrue(IsEqual(new Matrix_Accessor(vec1).OuterProduct(new Matrix_Accessor(vec2)), new Matrix_Accessor(result)));
    }

    /// <summary>
    ///A test for Subtract
    ///</summary>
    [TestMethod()]
    [DeploymentItem("HeuristicLab.Algorithms.NCA-3.3.dll")]
    public void SubtractTest() {
      var mat1 = new double[,] { { -3, 2 }, { 5, 6 } };
      var mat2 = new double[,] { { 2, 1 }, { 1, 2 } };
      var result = new double[,] { { -5, 1 }, { 4, 4 } };
      Assert.IsTrue(IsEqual(new Matrix_Accessor(mat1).Subtract(new Matrix_Accessor(mat2)), new Matrix_Accessor(result)));
      mat1 = new double[,] { { 2, 1 }, { -4, 7 }, { 10, 20 } };
      mat2 = new double[,] { { 3, 0 }, { 2, 4 }, { 5, 8 } };
      result = new double[,] { { -1, 1 }, { -6, 3 }, { 5, 12 } };
      Assert.IsTrue(IsEqual(new Matrix_Accessor(mat1).Subtract(new Matrix_Accessor(mat2)), new Matrix_Accessor(result)));
      Assert.IsTrue(IsEqual(new Matrix_Accessor(mat1).Subtract(new Matrix_Accessor(mat2)), new Matrix_Accessor(mat1).Add(new Matrix_Accessor(mat2).Negate())));
    }

    /// <summary>
    ///A test for Transpose
    ///</summary>
    [TestMethod()]
    [DeploymentItem("HeuristicLab.Algorithms.NCA-3.3.dll")]
    public void TransposeTest() {
      var mat1 = new double[,] { { 2, 1 }, { -4, 7 }, { 10, 20 } };
      var result = new double[,] { { 2, -4, 10 }, { 1, 7, 20 } };
      Assert.IsTrue(IsEqual(new Matrix_Accessor(mat1).Transpose(), new Matrix_Accessor(result)));
      mat1 = new double[,] { { 3, 4 }, { 5, 6 } };
      result = new double[,] { { 3, 5 }, { 4, 6 } };
      Assert.IsTrue(IsEqual(new Matrix_Accessor(mat1).Transpose(), new Matrix_Accessor(result)));
      var enumMat = new double[] { 3, 4, 5, 6 };
      Assert.IsTrue(IsEqual(new Matrix_Accessor(enumMat, 2, 2).Transpose(), new Matrix_Accessor(result)));
      mat1 = new double[,] { { 3, 4 }, { 5, 6 }, { 7, 8 }, { 9, 10 }, { 11, 12 } };
      result = new double[,] { { 3, 5, 7, 9, 11 }, { 4, 6, 8, 10, 12 } };
      Assert.IsTrue(IsEqual(new Matrix_Accessor(mat1).Transpose(), new Matrix_Accessor(result)));
    }
  }
}