Extreme Optimization > QuickStart Samples > FFT/Fourier Transforms QuickStart Sample (VB.NET)

Extreme Optimization QuickStart Samples

FFT / Fourier Transforms QuickStart Sample (Visual Basic .NET)

Illustrates how to compute the forward and inverse Fourier transform of a real or complex signal using classes in the Extreme.Mathematics.SignalProcessing namespace in Visual Basic .NET.

C# code F# code Back to QuickStart Samples

Imports Extreme.Mathematics
' We'll need real vectors...
Imports Extreme.Mathematics.LinearAlgebra
' and complex vectors...
Imports Extreme.Mathematics.LinearAlgebra.Complex
' The FFT classes reside in the Extreme.Mathematics.SignalProcessing
' namespace.
Imports Extreme.Mathematics.SignalProcessing

Namespace Extreme.Mathematics.QuickStart.VB
    ' Illustrates the use of the FftProvider and Fft classes for computing 
    ' the Fourier transform of real and complex signals.
    Module FourierTransforms

        Sub Main()
            ' This QuickStart sample shows how to compute the Fouier
            ' transform of real and complex signals.

            ' Some vectors to play with:
            Dim r1 As GeneralVector = New GeneralVector(1000)
            For i As Integer = 0 To r1.Length - 1
                r1(i) = 1.0 / (1 + i)
            Next
            Dim c1 As ComplexGeneralVector = New ComplexGeneralVector(1000)
            For i As Integer = 0 To c1.Length - 1
                c1(i) = New DoubleComplex(Math.Sin(0.03 * i), Math.Cos(0.07 * i))
            Next

            Dim r2 As GeneralVector = New GeneralVector(1.0, 2.0, 3.0, 4.0)
            Dim c2 As ComplexGeneralVector = New ComplexGeneralVector(New DoubleComplex(1, 2), _
                New DoubleComplex(3, 4), New DoubleComplex(5, 6), New DoubleComplex(7, 8))

            '
            ' One-time FFT's
            '

            ' The Vector and ComplexVector classes have static methods to compute FFT's:
            Dim c3 As ComplexConjugateSignalVector = Vector.FourierTransform(r2)
            Dim r3 As Vector = Vector.InverseFourierTransform(c3)
            Console.WriteLine("fft(r2) = {0:F3}", c3)
            Console.WriteLine("ifft(fft(r2)) = {0:F3}", r3)
            ' The ComplexConjugateSignalVector type represents a complex vector
            ' that is the Fourier transform of a real signal. 
            ' It enforces certain symmetry properties:
            Console.WriteLine("c3(i) == conj(c3(N-i)): {0} == conj({1})", c3(1), c3(3))

            '
            ' FFT Providers
            '

            ' FFT's require a fair bit of pre-computation. Using the FftProvider class,
            ' you can get an Fft object that caches these computations.

            ' Here, we create an FFT implementation for a real signal:
            Dim realFft As Fft = FftProvider.ManagedProvider.Create1DRealFft(r1.Length)
            ' For a complex to complex transform:
            Dim complexFft As Fft = FftProvider.ManagedProvider.Create1DComplexFft(c1.Length)

            ' You can set the scale factor for the forward transform.
            ' The default is 1/N.
            realFft.ForwardScaleFactor = 1.0 / Math.Sqrt(c1.Length)
            ' and the backward transform, with default 1:
            realFft.BackwardScaleFactor = realFft.ForwardScaleFactor

            ' The ForwardTransform method performs a forward transform:
            Dim c4 As ComplexVector = realFft.ForwardTransform(r1)
            Console.WriteLine("First 5 terms of fft(r1):")
            For i As Integer = 0 To 4
                Console.WriteLine("   {0}: {1}", i, c4(i))
            Next i
            c4 = complexFft.ForwardTransform(c1)
            Console.WriteLine("First 5 terms of fft(c1):")
            For i As Integer = 0 To 4
                Console.WriteLine("   {0}: {1}", i, c4(i))
            Next i
            ' ForwardTransform has many overloads for real to complex and
            ' complex to complex transforms.

            ' A one-sided transform returns only the first half of the FFT of
            ' a real signal. The rest can be deduced from the symmetry properties.
            ' Here's how to compute a one-sided FFT:
            Dim c5 As ComplexVector = New ComplexGeneralVector(r1.Length / 2 + 1)
            realFft.ForwardTransform(r1, c5, RealFftFormat.OneSided)

            ' The BackwardTransform method has a similar set of overloads:
            Dim r4 As Vector = New GeneralVector(r1.Length)
            realFft.BackwardTransform(c5, r4, RealFftFormat.OneSided)

            '
            ' 2D transforms
            '

            ' 2D transforms are handled in a completely analogous way.
			Dim m As GeneralMatrix = New GeneralMatrix(36, 56)
			For i As Integer = 0 To m.RowCount - 1
				For j As Integer = 0 To m.ColumnCount - 1
					m(i, j) = Math.Exp(-0.1 * i) * Math.Sin(0.01 * (i * i + j * j - i * j))
				Next
			Next
			Dim mFft As ComplexGeneralMatrix = New ComplexGeneralMatrix(m.RowCount, m.ColumnCount)

			Fft2D fft2 = FftProvider.Current.Create2DRealFft(m.ColumnCount, m.ColumnCount))
			fft2.ForwardTransform(m, mFft);

			Console.WriteLine("First few terms of fft(m):")
			For i As Integer = 0 To 3
				Dim comma As String = String.Empty
				For j As Integer = 0 To 3
					Console.Write(comma)
					Console.Write("{0}", mFft(i, j).ToString("F4"))
					comma = ", "
				Next
				Console.WriteLine()
						Next

			fft2.BackwardTransform(mFft, m)

			' Once again, we need to dispose the FFT implementation:
			fft2.Dispose()

            Console.Write("Press Enter key to exit...")
            Console.ReadLine()

        End Sub

    End Module

End Namespace

Copyright 2004-2007, Extreme Optimization. All rights reserved.
Extreme Optimization, Complexity made simple, M#, and M Sharp  are trademarks of ExoAnalytics Inc.
Microsoft, Visual C#, Visual Basic, Visual Studio, and Visual Studio.NET are registered trademarks of Microsoft Corporation