m3

tests/EigenDecompositionTest.cs

@@ -0,0 +1,89 @@
+using System;
+using System.Linq;
+using System.Numerics;
+using Skeleton.Algebra.Extensions;
+using Skeleton.DataStructure.Packs.MatrixDecompositions;
+using Skeleton.Samples;
+
+namespace SkeletonTest.tests;
+
+public class EigenDecompositionTest
+{
+    private static readonly Complex I = Complex.ImaginaryOne;
+    [DatapointSource] 
+    public static readonly C22[] DataPoints = 
+        30.ScaleSamples(-1, 1).C22InvertibleSamples().ToArray();
+
+    [Theory]
+    public static void DecompositionIdentityTest(C22 data)
+    {
+        JDPair<C22> decomp = data.EigenDecomposition();
+        C22 J = decomp.J;
+        C22 D = decomp.D;
+        Assert.IsTrue((J * D * J.Inv()).IsEqualApprox(data));
+    }
+
+    [Theory]
+    public static void UnitaryDecompositionTest(C22 data)
+    {
+        U2 unitaryData = new U2(data);
+        Console.WriteLine(data.Representation);
+        Assert.IsTrue((unitaryData * unitaryData.Hermitian()).IsEqualApprox(U2.One));
+        Assert.IsTrue(unitaryData.Det().Magnitude.IsEqualApprox(1));
+        JDPair<C22> decomp = unitaryData.EigenDecomposition();
+
+        C22 J = decomp.J;
+        C22 D = decomp.D;
+        Assert.IsTrue(D.Property.IsDiagonal);
+        Assert.IsTrue((J * J.Hermitian()).IsEqualApprox(C22.One));
+        Assert.IsTrue((J * D * J.Inv()).IsEqualApprox(unitaryData));
+    }
+
+    [Test]
+    public static void DecompositionTest()
+    {
+        C22 a = new C22(I, 1, 1, I);
+        JDPair<C22> t = a.EigenDecomposition();
+        C22 J = t.J;
+        C22 D = t.D;
+        Assert.IsTrue((J * D * J.Inv()).IsEqualApprox(a));
+    }
+
+    [Test]
+    public static void UnitaryDecompositionCase0()
+    {
+        U2 m = new U2(
+            -0.08908708063747477 + 0.44543540318737385 * I, 0.3008484477213831 + 0.8385350351383227 * I,
+            -0.5345224838248488 + 0.7126966450997985 * I, 0.04608742177859454 - 0.45191277466233243 * I
+        );
+        JDPair<C22> t = m.EigenDecomposition();
+        C22 J = t.J;
+        C22 D = t.D;
+        
+        Assert.IsTrue((J * D * J.Inv()).IsEqualApprox(m));
+        Assert.IsTrue((J * J.Hermitian()).IsEqualApprox(C22.One));
+
+
+        //C22 JH = J.Hermitian();
+        D.SwapRow(1, 2);
+        J.SwapColumn(1, 2);
+        Console.WriteLine((J.Hermitian()*m*J).Representation);
+        Console.WriteLine("  --  ");
+        Console.WriteLine(D.Representation);
+        //Assert.IsTrue((JH.Hermitian() * D * JH).IsEqualApprox(m));
+        
+        
+    }
+
+    [Test]
+    public static void UnitaryDecompositionCase1()
+    {
+        U2 m = new U2(
+            0.8666666666666667 - 0.8666666666666667 * I, -0.4 + 0.46666666666666656 * I,
+            -0.8666666666666667 - 0.6 * I, 0.6666666666666667
+        );
+        Assert.IsTrue((m * m.Hermitian()).IsEqualApprox(C22.One));
+    }
+}
+
+