Add SolverHelper unit tests.

Author: wo80

CSparse.Tests/Complex/Helper.cs

@@ -1,6 +1,7 @@
 namespace CSparse.Tests.Complex
 {
     using CSparse.Storage;
+    using NUnit.Framework;
     using System.Numerics;
 
     static class Helper
@@ -25,5 +26,34 @@ public static Complex[] Multiply(Matrix<Complex> A, Complex[] x)
 
             return b;
         }
+
+        public static Complex[] TransposeMultiply(Matrix<Complex> A, Complex[] x, bool conjugate = true)
+        {
+            if (conjugate)
+            {
+                var conjA = ((CompressedColumnStorage<Complex>)A).Clone();
+                var values = conjA.Values;
+                for (int i = 0; i < values.Length; i++)
+                {
+                    values[i] = Complex.Conjugate(values[i]);
+                }
+                A = conjA;
+            }
+
+            var b = new Complex[A.RowCount];
+
+            A.TransposeMultiply(1.0, x, 0.0, b);
+
+            return b;
+        }
+
+        public static void AssertEqual(int length, Complex[] x, Complex[] y)
+        {
+            for (int i = 0; i < length; i++)
+            {
+                Assert.AreEqual(x[i].Real, y[i].Real);
+                Assert.AreEqual(x[i].Imaginary, y[i].Imaginary);
+            }
+        }
     }
 }

CSparse.Tests/Complex/SolverHelperTest.cs

@@ -0,0 +1,72 @@
+
+namespace CSparse.Tests.Complex
+{
+    using CSparse.Complex;
+    using CSparse.Storage;
+    using NUnit.Framework;
+    using NUnit.Framework.Internal;
+
+    using Complex = System.Numerics.Complex;
+
+    [DefaultFloatingPointTolerance(1e-12)]
+    public class SolverHelperTest
+    {
+        private readonly CompressedColumnStorage<Complex> L;
+        private readonly CompressedColumnStorage<Complex> U;
+
+        public SolverHelperTest()
+        {
+            var A = ResourceLoader.Get<Complex>("hermitian-40-spd.mat");
+
+            L = A.Clone();
+            L.Keep((i, j, a) => i >= j);
+
+            U = A.Clone();
+            U.Keep((i, j, a) => i <= j);
+        }
+
+        [Test]
+        public void TestSolveLower()
+        {
+            var x = Vector.Create(L.ColumnCount, 1.0);
+            var b = Helper.Multiply(L, x);
+
+            SolverHelper.SolveLower(L, b);
+
+            Helper.AssertEqual(L.ColumnCount, x, b);
+        }
+
+        [Test]
+        public void TestSolveLowerTranspose()
+        {
+            var x = Vector.Create(L.ColumnCount, 1.0);
+            var b = Helper.TransposeMultiply(L, x);
+
+            SolverHelper.SolveLowerTranspose(L, b);
+
+            Helper.AssertEqual(L.ColumnCount, x, b);
+        }
+
+        [Test]
+        public void TestSolveUpper()
+        {
+            var x = Vector.Create(U.ColumnCount, 1.0);
+            var b = Helper.Multiply(U, x);
+
+            SolverHelper.SolveUpper(U, b);
+
+            Helper.AssertEqual(L.ColumnCount, x, b);
+        }
+
+        [Test]
+        public void TestSolveUpperTranspose()
+        {
+            var x = Vector.Create(U.ColumnCount, 1.0);
+            var b = Helper.TransposeMultiply(U, x);
+
+            SolverHelper.SolveUpperTranspose(U, b);
+
+            Helper.AssertEqual(L.ColumnCount, x, b);
+        }
+    }
+}

CSparse.Tests/Double/Helper.cs

@@ -22,5 +22,14 @@ public static double[] Multiply(ILinearOperator<double> A, double[] x)
 
             return b;
         }
+
+        public static double[] TransposeMultiply(ILinearOperator<double> A, double[] x)
+        {
+            var b = new double[A.RowCount];
+
+            A.TransposeMultiply(1.0, x, 0.0, b);
+
+            return b;
+        }
     }
 }

CSparse.Tests/Double/SolverHelperTest.cs

@@ -0,0 +1,70 @@
+
+namespace CSparse.Tests.Double
+{
+    using CSparse.Double;
+    using CSparse.Storage;
+    using NUnit.Framework;
+    using NUnit.Framework.Internal;
+
+    [DefaultFloatingPointTolerance(1e-12)]
+    public class SolverHelperTest
+    {
+        private readonly CompressedColumnStorage<double> L;
+        private readonly CompressedColumnStorage<double> U;
+
+        public SolverHelperTest()
+        {
+            var A = ResourceLoader.Get<double>("symmetric-40-spd.mat");
+
+            L = A.Clone();
+            L.Keep((i, j, a) => i >= j);
+
+            U = A.Clone();
+            U.Keep((i, j, a) => i <= j);
+        }
+
+        [Test]
+        public void TestSolveLower()
+        {
+            var x = Vector.Create(L.ColumnCount, 1.0);
+            var b = Helper.Multiply(L, x);
+
+            SolverHelper.SolveLower(L, b);
+
+            CollectionAssert.AreEqual(x, b);
+        }
+
+        [Test]
+        public void TestSolveLowerTranspose()
+        {
+            var x = Vector.Create(L.ColumnCount, 1.0);
+            var b = Helper.TransposeMultiply(L, x);
+
+            SolverHelper.SolveLowerTranspose(L, b);
+
+            CollectionAssert.AreEqual(x, b);
+        }
+
+        [Test]
+        public void TestSolveUpper()
+        {
+            var x = Vector.Create(U.ColumnCount, 1.0);
+            var b = Helper.Multiply(U, x);
+
+            SolverHelper.SolveUpper(U, b);
+
+            CollectionAssert.AreEqual(x, b);
+        }
+
+        [Test]
+        public void TestSolveUpperTranspose()
+        {
+            var x = Vector.Create(U.ColumnCount, 1.0);
+            var b = Helper.TransposeMultiply(U, x);
+
+            SolverHelper.SolveUpperTranspose(U, b);
+
+            CollectionAssert.AreEqual(x, b);
+        }
+    }
+}