From e87a93997d632fc3d2560fe6269759b9ce6c48ae Mon Sep 17 00:00:00 2001
From: basp <akovn@yandex.ru>
Date: Fri, 12 Jul 2019 14:26:09 +0300
Subject: [PATCH] Add tests on sparse matrices

---
 test/ElasticMatrixTest.cs | 156 ++++++++++++++++++
 test/SparseMatrixTest.cs  | 335 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 491 insertions(+)
 create mode 100644 test/ElasticMatrixTest.cs
 create mode 100644 test/SparseMatrixTest.cs

diff --git a/test/ElasticMatrixTest.cs b/test/ElasticMatrixTest.cs
new file mode 100644
index 0000000..4d97eaf
--- /dev/null
+++ b/test/ElasticMatrixTest.cs
@@ -0,0 +1,156 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using sharpcode;
+
+namespace sharpcode.test
+{
+    [TestClass]
+    public class ElasticMatrixTest
+    {
+        [TestMethod]
+        public void Transpose()
+        {
+            var A = new ElasticMatrix<int>(3, 2);
+            A[0, 0] = 0; A[0, 1] = 1;
+            A[1, 0] = 2; A[1, 1] = 4;
+            A[2, 0] = 0; A[2, 1] = 3;
+
+            var At = A.Transpose();
+            var Att = At.Transpose();
+            var Attt = Att.Transpose();
+
+            Assert.IsTrue(A.Equals(Att));
+            Assert.IsTrue(At.Equals(Attt));
+            Assert.IsFalse(A.Equals(At));
+        }
+
+        [TestMethod]
+        public void Sorting()
+        {
+            var A = new ElasticMatrix<int>(3, 4);
+            A[0, 0] = 10; A[0, 1] = 11; A[0, 2] = 12; A[0, 3] = 13;
+            A[1, 3] = 23; A[1, 0] = 20; A[1, 1] = 21;
+            A[2, 3] = 33; A[2, 2] = 32; A[2, 1] = 31; A[2, 0] = 30;
+
+            var B = new ElasticMatrix<int>(A);
+
+            Assert.IsTrue(A.Equals(B));
+
+            A.Sorting();
+
+            Assert.IsFalse(A.Equals(B));
+
+            var E = new ElasticMatrix<int>(3, 4);
+            E[0, 0] = 10; E[0, 1] = 11; E[0, 2] = 12; E[0, 3] = 13;
+            E[1, 0] = 20; E[1, 1] = 21; E[1, 3] = 23;
+            E[2, 0] = 30; E[2, 1] = 31; E[2, 2] = 32; E[2, 3] = 33;
+
+            Assert.IsTrue(E.Equals(A));
+        }
+
+        [TestMethod]
+        public void GetRow()
+        {
+            var A = new ElasticMatrix<int>(3, 4);
+            A[0, 0] = 10; A[0, 1] = 11; A[0, 2] = 12; A[0, 3] = 13;
+            A[1, 3] = 23; A[1, 0] = 20; A[1, 1] = 21;
+            A[2, 3] = 33; A[2, 2] = 32; A[2, 1] = 31; A[2, 0] = 30;
+
+            var row = A.GetRow(0);
+            Assert.AreEqual(4, row.Size);
+            Assert.AreEqual(4, row.Count);
+            Assert.AreEqual(10, row[0]);
+            Assert.AreEqual(11, row[1]);
+            Assert.AreEqual(12, row[2]);
+            Assert.AreEqual(13, row[3]);
+
+            row = A.GetRow(1);
+            Assert.AreEqual(4, row.Size);
+            Assert.AreEqual(3, row.Count);
+            Assert.AreEqual(20, row[0]);
+            Assert.AreEqual(21, row[1]);
+            Assert.AreEqual(23, row[3]);
+
+            row = A.GetRow(2);
+            Assert.AreEqual(4, row.Size);
+            Assert.AreEqual(4, row.Count);
+            Assert.AreEqual(30, row[0]);
+            Assert.AreEqual(31, row[1]);
+            Assert.AreEqual(32, row[2]);
+            Assert.AreEqual(33, row[3]);
+        }
+
+        [TestMethod]
+        public void ForLine()
+        {
+            var A = new ElasticMatrix<double>(3, 4);
+            A[0, 0] = 10; A[0, 1] = 11; A[0, 2] = 12; A[0, 3] = 13;
+            A[1, 3] = 23; A[1, 0] = 20; A[1, 1] = 21;
+            A[2, 3] = 33; A[2, 2] = 32; A[2, 1] = 31; A[2, 0] = 30;
+
+            A.ForRow(0, (j, value) =>
+            {
+                switch (j)
+                {
+                    case 0:
+                        Assert.AreEqual(10, value);
+                        break;
+                    case 1:
+                        Assert.AreEqual(11, value);
+                        break;
+                    case 2:
+                        Assert.AreEqual(12, value);
+                        break;
+                    case 3:
+                        Assert.AreEqual(13, value);
+                        break;
+                    default:
+                        Assert.Fail();
+                        break;
+                }
+            });
+
+
+            A.ForRow(1, (j, value) =>
+            {
+                switch (j)
+                {
+                    case 0:
+                        Assert.AreEqual(20, value);
+                        break;
+                    case 1:
+                        Assert.AreEqual(21, value);
+                        break;
+                    case 3:
+                        Assert.AreEqual(23, value);
+                        break;
+                    default:
+                        Assert.Fail();
+                        break;
+                }
+            });
+
+            A.ForRow(2, (j, value) =>
+            {
+                switch (j)
+                {
+                    case 0:
+                        Assert.AreEqual(30, value);
+                        break;
+                    case 1:
+                        Assert.AreEqual(31, value);
+                        break;
+                    case 2:
+                        Assert.AreEqual(32, value);
+                        break;
+                    case 3:
+                        Assert.AreEqual(33, value);
+                        break;
+                    default:
+                        Assert.Fail();
+                        break;
+                }
+            });
+        }
+    }
+}
\ No newline at end of file
diff --git a/test/SparseMatrixTest.cs b/test/SparseMatrixTest.cs
new file mode 100644
index 0000000..b29e468
--- /dev/null
+++ b/test/SparseMatrixTest.cs
@@ -0,0 +1,335 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using sharpcode;
+
+namespace sharpcode.test
+{
+    [TestClass]
+    public class SparseMatrixTest
+    {
+        [TestMethod]
+        public void Constructor()
+        {
+            var P = new ElasticMatrix<double>(3, 4);
+            P[0, 0] = 10; P[0, 1] = 11; P[0, 2] = 12; P[0, 3] = 13;
+            P[1, 3] = 23; P[1, 0] = 20; P[1, 1] = 21;
+            P[2, 3] = 33; P[2, 2] = 32; P[2, 1] = 31; P[2, 0] = 30;
+
+            var A = new SparseMatrix<double>(P);
+            Assert.AreEqual(11, A.Count);
+
+            Assert.AreEqual(10, A[0, 0]);
+            Assert.AreEqual(11, A[0, 1]);
+            Assert.AreEqual(12, A[0, 2]);
+            Assert.AreEqual(13, A[0, 3]);
+
+            Assert.AreEqual(20, A[1, 0]);
+            Assert.AreEqual(21, A[1, 1]);
+            Assert.AreEqual(23, A[1, 3]);
+
+            Assert.AreEqual(30, A[2, 0]);
+            Assert.AreEqual(31, A[2, 1]);
+            Assert.AreEqual(32, A[2, 2]);
+            Assert.AreEqual(33, A[2, 3]);
+
+            for (int i = 0; i < A.Rows; i++)
+            {
+                foreach (var it in A.GetRow(i))
+                {
+                    Assert.AreEqual(A[i, it.Key], it.Value);
+                }
+            }
+
+            for (int j = 0; j < A.Columns; j++)
+            {
+                foreach (var it in A.GetColumn(j))
+                {
+                    Assert.AreEqual(A[it.Key, j], it.Value);
+                }
+            }
+        }
+
+        [TestMethod]
+        public void Constructor_2()
+        {
+            var A = new SparseMatrix<double>(
+                3, 4,
+                new int[] { 0, 4, 7, 11 },
+                new int[] { 0, 1, 2, 3, 0, 1, 3, 0, 1, 2, 3 },
+                new double[] { 10, 11, 12, 13, 20, 21, 23, 30, 31, 32, 33 });
+
+            var P = new ElasticMatrix<double>(3, 4);
+            P[0, 0] = 10; P[0, 1] = 11; P[0, 2] = 12; P[0, 3] = 13;
+            P[1, 3] = 23; P[1, 0] = 20; P[1, 1] = 21;
+            P[2, 3] = 33; P[2, 2] = 32; P[2, 1] = 31; P[2, 0] = 30;
+            var E = new SparseMatrix<double>(P);
+
+            Assert.IsTrue(A.Equals(E));
+
+            for (int i = 0; i < A.Rows; i++)
+            {
+                foreach (var it in A.GetRow(i))
+                {
+                    Assert.AreEqual(E[i, it.Key], it.Value);
+                }
+            }
+
+            for (int j = 0; j < A.Columns; j++)
+            {
+                foreach (var it in A.GetColumn(j))
+                {
+                    Assert.AreEqual(E[it.Key, j], it.Value);
+                }
+            }
+        }
+
+        [TestMethod]
+        public void GetRow()
+        {
+            var P = new ElasticMatrix<double>(3, 4);
+            P[0, 0] = 10; P[0, 1] = 11; P[0, 2] = 12; P[0, 3] = 13;
+            P[1, 3] = 23; P[1, 0] = 20; P[1, 1] = 21;
+            P[2, 3] = 33; P[2, 2] = 32; P[2, 1] = 31; P[2, 0] = 30;
+
+            var A = new SparseMatrix<double>(P);
+
+            var row = A.GetRow(0);
+            Assert.AreEqual(4, row.Size);
+            Assert.AreEqual(4, row.Count);
+            Assert.AreEqual(10, row[0]);
+            Assert.AreEqual(11, row[1]);
+            Assert.AreEqual(12, row[2]);
+            Assert.AreEqual(13, row[3]);
+
+            row = A.GetRow(1);
+            Assert.AreEqual(4, row.Size);
+            Assert.AreEqual(3, row.Count);
+            Assert.AreEqual(20, row[0]);
+            Assert.AreEqual(21, row[1]);
+            Assert.AreEqual(23, row[3]);
+
+            row = A.GetRow(2);
+            Assert.AreEqual(4, row.Size);
+            Assert.AreEqual(4, row.Count);
+            Assert.AreEqual(30, row[0]);
+            Assert.AreEqual(31, row[1]);
+            Assert.AreEqual(32, row[2]);
+            Assert.AreEqual(33, row[3]);
+        }
+
+        [TestMethod]
+        public void GetColumn()
+        {
+            var P = new ElasticMatrix<double>(3, 4);
+            P[0, 0] = 10; P[0, 1] = 11; P[0, 2] = 12; P[0, 3] = 13;
+            P[1, 3] = 23; P[1, 0] = 20; P[1, 1] = 21;
+            P[2, 3] = 33; P[2, 2] = 32; P[2, 1] = 31; P[2, 0] = 30;
+
+            var A = new SparseMatrix<double>(P);
+
+            var column = A.GetColumn(0);
+            Assert.AreEqual(3, column.Size);
+            Assert.AreEqual(3, column.Count);
+            Assert.AreEqual(10, column[0]);
+            Assert.AreEqual(20, column[1]);
+            Assert.AreEqual(30, column[2]);
+
+            column = A.GetColumn(1);
+            Assert.AreEqual(3, column.Size);
+            Assert.AreEqual(3, column.Count);
+            Assert.AreEqual(11, column[0]);
+            Assert.AreEqual(21, column[1]);
+            Assert.AreEqual(31, column[2]);
+
+            column = A.GetColumn(2);
+            Assert.AreEqual(3, column.Size);
+            Assert.AreEqual(2, column.Count);
+            Assert.AreEqual(12, column[0]);
+            Assert.AreEqual(32, column[2]);
+
+            column = A.GetColumn(3);
+            Assert.AreEqual(3, column.Size);
+            Assert.AreEqual(3, column.Count);
+            Assert.AreEqual(13, column[0]);
+            Assert.AreEqual(23, column[1]);
+            Assert.AreEqual(33, column[2]);
+        }
+
+        [TestMethod]
+        public void Transpose()
+        {
+            var P = new ElasticMatrix<double>(3, 2);
+            P[0, 0] = 0; P[0, 1] = 1;
+            P[1, 0] = 2; P[1, 1] = 4;
+            P[2, 0] = 0; P[2, 1] = 3;
+
+            var A = new SparseMatrix<double>(P);
+
+            var At = A.Transpose();
+            var Att = At.Transpose();
+            var Attt = Att.Transpose();
+
+            Assert.IsTrue(A.Equals(Att));
+            Assert.IsTrue(At.Equals(Attt));
+            Assert.IsFalse(A.Equals(At));
+        }
+
+        [TestMethod]
+        public void ForRow()
+        {
+            var P = new ElasticMatrix<double>(3, 4);
+            P[0, 0] = 10; P[0, 1] = 11; P[0, 2] = 12; P[0, 3] = 13;
+            P[1, 3] = 23; P[1, 0] = 20; P[1, 1] = 21;
+            P[2, 3] = 33; P[2, 2] = 32; P[2, 1] = 31; P[2, 0] = 30;
+            var A = new SparseMatrix<double>(P);
+
+            A.ForRow(0, (j, value) =>
+            {
+                switch (j)
+                {
+                    case 0:
+                        Assert.AreEqual(10, value);
+                        break;
+                    case 1:
+                        Assert.AreEqual(11, value);
+                        break;
+                    case 2:
+                        Assert.AreEqual(12, value);
+                        break;
+                    case 3:
+                        Assert.AreEqual(13, value);
+                        break;
+                    default:
+                        Assert.Fail();
+                        break;
+                }
+            });
+
+
+            A.ForRow(1, (j, value) =>
+            {
+                switch (j)
+                {
+                    case 0:
+                        Assert.AreEqual(20, value);
+                        break;
+                    case 1:
+                        Assert.AreEqual(21, value);
+                        break;
+                    case 3:
+                        Assert.AreEqual(23, value);
+                        break;
+                    default:
+                        Assert.Fail();
+                        break;
+                }
+            });
+
+            A.ForRow(2, (j, value) =>
+            {
+                switch (j)
+                {
+                    case 0:
+                        Assert.AreEqual(30, value);
+                        break;
+                    case 1:
+                        Assert.AreEqual(31, value);
+                        break;
+                    case 2:
+                        Assert.AreEqual(32, value);
+                        break;
+                    case 3:
+                        Assert.AreEqual(33, value);
+                        break;
+                    default:
+                        Assert.Fail();
+                        break;
+                }
+            });
+        }
+
+        [TestMethod]
+        public void ForColumn()
+        {
+            var P = new ElasticMatrix<double>(3, 4);
+            P[0, 0] = 10; P[0, 1] = 11; P[0, 2] = 12; P[0, 3] = 13;
+            P[1, 3] = 23; P[1, 0] = 20; P[1, 1] = 21;
+            P[2, 3] = 33; P[2, 2] = 32; P[2, 1] = 31; P[2, 0] = 30;
+            var A = new SparseMatrix<double>(P);
+
+            A.ForColumn(0, (i, value) =>
+            {
+                switch (i)
+                {
+                    case 0:
+                        Assert.AreEqual(10, value);
+                        break;
+                    case 1:
+                        Assert.AreEqual(20, value);
+                        break;
+                    case 2:
+                        Assert.AreEqual(30, value);
+                        break;
+                    default:
+                        Assert.Fail();
+                        break;
+                }
+            });
+
+
+            A.ForColumn(1, (i, value) =>
+            {
+                switch (i)
+                {
+                    case 0:
+                        Assert.AreEqual(11, value);
+                        break;
+                    case 1:
+                        Assert.AreEqual(21, value);
+                        break;
+                    case 2:
+                        Assert.AreEqual(31, value);
+                        break;
+                    default:
+                        Assert.Fail();
+                        break;
+                }
+            });
+
+            A.ForColumn(2, (i, value) =>
+            {
+                switch (i)
+                {
+                    case 0:
+                        Assert.AreEqual(12, value);
+                        break;
+                    case 2:
+                        Assert.AreEqual(32, value);
+                        break;
+                    default:
+                        Assert.Fail();
+                        break;
+                }
+            });
+
+            A.ForColumn(3, (i, value) =>
+            {
+                switch (i)
+                {
+                    case 0:
+                        Assert.AreEqual(13, value);
+                        break;
+                    case 1:
+                        Assert.AreEqual(23, value);
+                        break;
+                    case 2:
+                        Assert.AreEqual(33, value);
+                        break;
+                    default:
+                        Assert.Fail();
+                        break;
+                }
+            });
+        }
+    }
+}
\ No newline at end of file