Tests.cs

Go to the documentation of this file.

using System;
using System.Diagnostics;
using System.Reflection;

namespace FFT.Test {
   using FFT;

   ///
   /// Test of FFT::Complex.
   ///
   public class ComplexTest : UnitTest {

      public override void Test(){
         AssertEq(new Complex(1,2).Equals(new Complex(1,2)),
                  true,
                  "Equality");

         AssertEq(new Complex(1,2.000001).Equals(new Complex(1,2)),
                  false,
                  "Inequality");

         AssertEq(new Complex(1,1),
                  new Complex(1,1),
                  "Standard constructor");

         AssertEq(Complex.FromPolar(2,Math.PI/3),
                  new Complex(2*Math.Cos(Math.PI/3),2*Math.Sin(Math.PI/3)),
                  "Polar constructor");

         AssertEq(1,
                  new Complex(1,0),
                  "Implicit cast from int");

         AssertEq(1.0,
                  new Complex(1,0),
                  "Implicit cast from double");

         AssertEq(new Complex(1,1).Re,
                  1.0,
                  "Real part");

         AssertEq(new Complex(1,1).Im,
                  1.0,
                  "Imaginary part");

         AssertEq(new Complex(3,4).Modulus,
                  5.0,
                  "Modulus");

         AssertEq(new Complex(1,1).Argument,
                  Math.PI/4.0,
                  "Argument");
         
         AssertEq(new Complex(1,1) + new Complex(2,-2),
                  new Complex(3,-1),
                  "Addition");

         AssertEq(new Complex(3,-1) - new Complex(-1,-2),
                  new Complex(4,1),
                  "Subtraction");

         AssertEq(new Complex(1,1) * new Complex(2,-1),
                  new Complex(3,1),
                  "Multiplication");

         AssertEq(new Complex(2,-2) / new Complex(1,1),
                  new Complex(0,-2),
                  "Division");

      }
   }

   ///
   /// Test of FFT::Utils.
   ///
   public class UtilsTest : UnitTest
   {
      public override void Test()
      {
         AssertEq(Utils.copy(new int[]{1,2,3}, new int[]{4,5,6,7}),
                  new int[] {1,2,3,7},
                  "(1) copy");

         AssertEq(Utils.copy(new int[]{1,2,3,4}, new int[]{4,5,6}),
                  new int[] {1,2,3},
                  "(2) copy");

         int[] dst = {1,2,3};
         AssertEq(Utils.copy(new int[] {0,0,0},dst) == dst,
                  true,
                  "(3) copy");

         AssertEq(Utils.dist(new Complex[] {1,2,3}, new Complex[] {2,1,1}),
                  Math.Sqrt(6),
                  "(1) dist");

         AssertEq(Utils.dist(new Complex[] {1,2,3}, new Complex[] {2,1}),
                  Math.Sqrt(2),
                  "(2) dist");

         AssertEq(Utils.dist(new Complex[] {1,2}, new Complex[] {2,1,1}),
                  Math.Sqrt(2),
                  "(3) dist");

         AssertEq(Utils.Log2(-1),0,"(1) Log2");
         AssertEq(Utils.Log2(0),0,"(2) Log2");
         AssertEq(Utils.Log2(1),0,"(3) Log2");
         AssertEq(Utils.Log2(2),1,"(4) Log2");
         AssertEq(Utils.Log2(3),2,"(5) Log2");
         AssertEq(Utils.Log2(4),2,"(6) Log2");
         AssertEq(Utils.Log2(5),3,"(7) Log2");

         AssertEq(Utils.IsPowerOf2(1),true,"(1) IsPowerOf");
         AssertEq(Utils.IsPowerOf2(2),true,"(2) IsPowerOf");
         AssertEq(Utils.IsPowerOf2(3),false,"(3) IsPowerOf");


         AssertEq(Utils.Exp2(0),1,"(1) Exp2");
         AssertEq(Utils.Exp2(1),2,"(2) Exp2");
         AssertEq(Utils.Exp2(2),4,"(3) Exp2");
      }
   }

   ///
   /// Test of FFT::DirectConvolution.
   ///
   public class DirectConvolutionTest : UnitTest
   {
      DirectConvolution conv;
      public DirectConvolutionTest() {
         conv = new DirectConvolution();
      }

      public override void Test()
      {
         AssertEq(conv.Convolution(new Complex[]{1,2,3}, new Complex[]{1,2}),
                  new Complex[]{1,4,7,6},
                  "Convolution");

         AssertEq(conv.ToString(),
                  "Direct",
                  "ToString");
      }
   }

   ///
   /// Test of FFT::PolynomialConvolution.
   ///
   public class PolynomialConvolutionTest : UnitTest
   {
      PolynomialConvolution conv;
      public PolynomialConvolutionTest()  {
         conv = new PolynomialConvolution();
      }

      public override void Test()
      {

         AssertEq(conv.GenerateDomain(3),
                  new Complex[3] {
                     Math.Cos(Math.PI/8),
                     Math.Cos(3*Math.PI/8),
                     Math.Cos(5*Math.PI/8)
                  },
                  "GenerateDomain");

         AssertEq(conv.Interpolate(new Complex[3]{-1,0,1}, new Complex[3]{1,3,9}),
                  new Complex[3]{3,4,2},
                  "Interpolate");

         AssertEq(conv.Evaluate(new Complex[3]{3,4,2}, new Complex[3]{-1,0,1}),
                  new Complex[3]{1,3,9},
                  "Evaluate");

         AssertEq(conv.PointwiseMultiply(new Complex[3]{1,3,2}, new Complex[3]{4,2,5}),
                  new Complex[3]{4,6,10},
                  "PointwiseMultiply");

         AssertNearEq(conv.Convolution(new Complex[]{1,2,3}, new Complex[]{1,2}),
                      new Complex[]{1,4,7,6},
                      "Convolution");

         AssertEq(conv.ToString(),
                  "Polynomial",
                  "ToString");

      }
   }

   /// 
   /// Test of FFT::DFTConvolution.
   ///
   public class DFTConvolutionTest : UnitTest
   {
      protected DFTConvolution conv = new DFTConvolution(new MockDFT());

      public override void Test()
      {
         AssertEq(conv.ToString(),
                  "DFT[Mock]",
                  "ToString");
         
         AssertNearEq(conv.Convolution(new Complex[]{1,1}, new Complex[]{1}),
                      new Complex[]{1,1},
                      "Convolution");
         
         Complex[] a = new Complex[10];
         Complex[] b = new Complex[12];
         int n = Utils.Exp2(Utils.Log2(a.Length+b.Length-1));
         conv.Normalize(ref a, ref b);
         AssertEq(a.Length,n,"Normalize (left)");
         AssertEq(b.Length,n,"Normalize (right)");

         AssertEq(conv.PointwiseMultiply(new Complex[3]{1,3,2}, new Complex[3]{4,2,5}),
                  new Complex[3]{4,6,10},
                  "PointwiseMultiply");
         
      }
   }
   
   ///
   /// A mock implementation of IDFT.
   ///
   public class MockDFT : IDFT
   {
      private PolynomialConvolution c = new PolynomialConvolution();
      public Complex[] DFT(Complex[] a, int sgn)
      {
         int n = a.Length;
         Complex[] x = new Complex[n];
         for (int i = 0; i < n; i++) {
            x[i] = Complex.FromPolar(1,sgn*2*i*Math.PI/n);
         }
         
         Complex[] y = c.Evaluate(a,x);
         
         if (sgn == -1) {
            for (int i = 0; i < n; i++) {
               y[i] /= n;
            }
         }
         
         return y;
      }
     
      public Complex[] DFT(Complex[] a)
      {
         return DFT(a,1);
      }
      
      public Complex[] InverseDFT(Complex[] y)
      {
         return DFT(y,-1);
      }
      
      public override string ToString()
      {
         return "Mock";
      }
   }

   ///
   /// Test of FFT::RecursiveFFT.
   ///
   public class RecursiveFFTTest : UnitTest
   {
      protected RecursiveFFT dft = new RecursiveFFT();
      protected MockDFT mft = new MockDFT();

      public override void Test() 
      {
         AssertNearEq(dft.DFT(new Complex[]{0,1,2,3,4,5,6,7}),
                      mft.DFT(new Complex[]{0,1,2,3,4,5,6,7}),
                      "DFT");
         AssertNearEq(dft.InverseDFT(new Complex[]{0,1,2,3,4,5,6,7}),
                      mft.InverseDFT(new Complex[]{0,1,2,3,4,5,6,7}),
                      "InverseDFT");

         AssertEq(dft.ToString(),
                  "Recursive",
                  "ToString");
      }
   }

   ///
   /// Test of FFT::IterativeFFT.
   ///
   public class IterativeFFTTest : UnitTest
   {
      protected IterativeFFT dft = new IterativeFFT();
      protected MockDFT mft = new MockDFT();

      public override void Test() 
      {
         AssertNearEq(dft.DFT(new Complex[]{0,1,2,3,4,5,6,7}),
                      mft.DFT(new Complex[]{0,1,2,3,4,5,6,7}),
                      "DFT");
         AssertNearEq(dft.InverseDFT(new Complex[]{0,1,2,3,4,5,6,7}),
                      mft.InverseDFT(new Complex[]{0,1,2,3,4,5,6,7}),
                      "InverseDFT");

         AssertEq(dft.ToString(),
                  "Iterative",
                  "ToString");

         AssertEq(dft.BitReverseCopy(new Complex[] {0,1,2,3,4,5,6,7}),
                  new Complex[] {0,4,2,6,1,5,3,7},
                  "BitReverseCopy");
      }
   }

   ///
   /// Test of FFT::ParallelFFT.
   /// 
   public class ParallelFFTTest : UnitTest
   {
      protected ParallelFFT[] dft = {
         new ParallelFFT(0),
         new ParallelFFT(1),
         new ParallelFFT(2),
         new ParallelFFT(3),
         new ParallelFFT(4) };
      protected MockDFT mft = new MockDFT();

      public override void Test() 
      {
         foreach (ParallelFFT d in dft) {
            AssertNearEq(d.DFT(new Complex[]{0,1,2,3,4,5,6,7}),
                         mft.DFT(new Complex[]{0,1,2,3,4,5,6,7}),
                         d + ": DFT");
            AssertNearEq(d.InverseDFT(new Complex[]{0,1,2,3,4,5,6,7}),
                         mft.InverseDFT(new Complex[]{0,1,2,3,4,5,6,7}),
                         d + ": InverseDFT");
            AssertEq(d.BitReverseCopy(new Complex[] {0,1,2,3,4,5,6,7}),
                      new Complex[] {0,4,2,6,1,5,3,7},
                     d + ": BitReverseCopy");
         }
      }
   }

}

---