FftSharp.FFT

Simple methods which act on System.Numeric.Complex data types #61

Author: swharden

src/FftSharp.Tests/FftTests.cs

@@ -0,0 +1,49 @@
+using NUnit.Framework;
+
+namespace FftSharp.Tests;
+
+internal class FftTests
+{
+    [Test]
+    public void Test_FFT_Forward()
+    {
+        double[] sample = LoadData.Double("sample.txt");
+        System.Numerics.Complex[] fft = FftSharp.FFT.Forward(sample);
+
+        Complex[] numpyFft = LoadData.Complex("fft.txt");
+        Assert.AreEqual(numpyFft.Length, fft.Length);
+
+        for (int i = 0; i < fft.Length; i++)
+        {
+            Assert.AreEqual(numpyFft[i].Real, fft[i].Real, 1e-10);
+            Assert.AreEqual(numpyFft[i].Imaginary, fft[i].Imaginary, 1e-10);
+        }
+    }
+
+    [Test]
+    public void Test_FFT_Inverse()
+    {
+        double[] sample = LoadData.Double("sample.txt");
+        System.Numerics.Complex[] fft = FftSharp.FFT.Forward(sample);
+        FftSharp.FFT.Inverse(fft);
+
+        for (int i = 0; i < fft.Length; i++)
+        {
+            Assert.AreEqual(sample[i], fft[i].Real, 1e-10);
+        }
+    }
+
+    [Test]
+    public void Test_FFT_FrequencyScale()
+    {
+        double[] numpyFftFreq = LoadData.Double("fftFreq.txt");
+        double[] fftFreq = FftSharp.FFT.FrequencyScale(length: numpyFftFreq.Length, sampleRate: 48_000);
+
+        Assert.AreEqual(numpyFftFreq.Length, fftFreq.Length);
+
+        for (int i = 0; i < fftFreq.Length; i++)
+        {
+            Assert.AreEqual(fftFreq[i], fftFreq[i], 1e-10);
+        }
+    }
+}

src/FftSharp/Extensions.cs

@@ -0,0 +1,19 @@
+namespace FftSharp;
+
+internal static class Extensions
+{
+    /// <summary>
+    /// Return a Complex array with the given values as the real component
+    /// </summary>
+    /// <param name="real"></param>
+    /// <returns></returns>
+    public static System.Numerics.Complex[] ToComplexArray(this double[] real)
+    {
+        System.Numerics.Complex[] buffer = new System.Numerics.Complex[real.Length];
+
+        for (int i = 0; i < real.Length; i++)
+            buffer[i] = new(real[i], 0);
+
+        return buffer;
+    }
+}

src/FftSharp/FFT.cs

@@ -0,0 +1,57 @@
+using System;
+
+namespace FftSharp;
+
+// TODO: support spans
+
+/// <summary>
+/// Fast Fourier Transform (FFT) operations using System.Numerics.Complex data types.
+/// </summary>
+public static class FFT
+{
+    /// <summary>
+    /// Apply the Fast Fourier Transform (FFT) to the Complex array in place.
+    /// Length of the array must be a power of 2.
+    /// </summary>
+    public static void Forward(System.Numerics.Complex[] samples)
+    {
+        if (!Transform.IsPowerOfTwo(samples.Length))
+            throw new ArgumentException($"{nameof(samples)} length must be a power of 2");
+
+        FftOperations.FFT_WithoutChecks(samples);
+    }
+
+    /// <summary>
+    /// Create a Complex array from the given data, apply the FFT, and return the result.
+    /// Length of the array must be a power of 2.
+    /// </summary>
+    public static System.Numerics.Complex[] Forward(double[] real)
+    {
+        if (!Transform.IsPowerOfTwo(real.Length))
+            throw new ArgumentException($"{nameof(real)} length must be a power of 2");
+
+        System.Numerics.Complex[] samples = real.ToComplexArray();
+        FftOperations.FFT_WithoutChecks(samples);
+        return samples;
+    }
+
+    /// <summary>
+    /// Apply the inverse Fast Fourier Transform (iFFT) to the Complex array in place.
+    /// Length of the array must be a power of 2.
+    /// </summary>
+    public static void Inverse(System.Numerics.Complex[] samples)
+    {
+        if (!Transform.IsPowerOfTwo(samples.Length))
+            throw new ArgumentException($"{nameof(samples)} length must be a power of 2");
+
+        FftOperations.IFFT_WithoutChecks(samples);
+    }
+
+    /// <summary>
+    /// Return frequencies for each index of a FFT.
+    /// </summary>
+    public static double[] FrequencyScale(int length, double sampleRate, bool positiveOnly = true)
+    {
+        return Transform.FFTfreq(sampleRate: sampleRate, pointCount: length, oneSided: positiveOnly);
+    }
+}