FFT: wire provider to Control class

src/Numerics/Control.cs

@@ -30,6 +30,7 @@
 using MathNet.Numerics.Providers.LinearAlgebra;
 using System;
 using System.Threading.Tasks;
+using MathNet.Numerics.Providers.FourierTransform;
 
 namespace MathNet.Numerics
 {
@@ -45,6 +46,7 @@ namespace MathNet.Numerics
         static int _parallelizeOrder;
         static int _parallelizeElements;
         static ILinearAlgebraProvider _linearAlgebraProvider;
+        static IFourierTransformProvider _fourierTransformProvider;
         static readonly object _staticLock = new object();
 
         static Control()
@@ -66,11 +68,11 @@ namespace MathNet.Numerics
             TaskScheduler = TaskScheduler.Default;
         }
 
-        private static void InitializeDefaultLinearAlgebraProvider()
+        private static void InitializeDefaultProviders()
         {
             lock (_staticLock)
             {
-                if (_linearAlgebraProvider == null)
+                if (_linearAlgebraProvider == null || _fourierTransformProvider == null)
                 {
 #if NATIVE
                     try
@@ -113,6 +115,7 @@ namespace MathNet.Numerics
         public static void UseManaged()
         {
             LinearAlgebraProvider = new ManagedLinearAlgebraProvider();
+            FourierTransformProvider = new ManagedFourierTransformProvider();
         }
 
 #if NATIVE
@@ -124,6 +127,7 @@ namespace MathNet.Numerics
         public static void UseNativeMKL()
         {
             LinearAlgebraProvider = new Providers.LinearAlgebra.Mkl.MklLinearAlgebraProvider();
+            FourierTransformProvider = new Providers.FourierTransform.Mkl.MklFourierTransformProvider();
         }
 
         /// <summary>
@@ -137,6 +141,7 @@ namespace MathNet.Numerics
             Providers.LinearAlgebra.Mkl.MklAccuracy accuracy = Providers.LinearAlgebra.Mkl.MklAccuracy.High)
         {
             LinearAlgebraProvider = new Providers.LinearAlgebra.Mkl.MklLinearAlgebraProvider(consistency, precision, accuracy);
+            FourierTransformProvider = new Providers.FourierTransform.Mkl.MklFourierTransformProvider();
         }
 
         /// <summary>
@@ -158,6 +163,10 @@ namespace MathNet.Numerics
         public static void UseNativeCUDA()
         {
             LinearAlgebraProvider = new Providers.LinearAlgebra.Cuda.CudaLinearAlgebraProvider();
+            if (_fourierTransformProvider == null)
+            {
+                FourierTransformProvider = new ManagedFourierTransformProvider();
+            }
         }
 
         /// <summary>
@@ -179,6 +188,10 @@ namespace MathNet.Numerics
         public static void UseNativeOpenBLAS()
         {
             LinearAlgebraProvider = new Providers.LinearAlgebra.OpenBlas.OpenBlasLinearAlgebraProvider();
+            if (_fourierTransformProvider == null)
+            {
+                FourierTransformProvider = new ManagedFourierTransformProvider();
+            }
         }
 
         /// <summary>
@@ -226,6 +239,7 @@ namespace MathNet.Numerics
             ThreadSafeRandomNumberGenerators = false;
 
             LinearAlgebraProvider.InitializeVerify();
+            FourierTransformProvider.InitializeVerify();
         }
 
         public static void UseMultiThreading()
@@ -234,6 +248,7 @@ namespace MathNet.Numerics
             ThreadSafeRandomNumberGenerators = true;
 
             LinearAlgebraProvider.InitializeVerify();
+            FourierTransformProvider.InitializeVerify();
         }
 
         /// <summary>
@@ -266,7 +281,7 @@ namespace MathNet.Numerics
             get
             {
                 if (_linearAlgebraProvider == null)
-                    InitializeDefaultLinearAlgebraProvider();
+                    InitializeDefaultProviders();
 
                 return _linearAlgebraProvider;
             }
@@ -279,6 +294,28 @@ namespace MathNet.Numerics
             }
         }
 
+        /// <summary>
+        /// Gets or sets the fourier transform provider. Consider to use UseNativeMKL or UseManaged instead.
+        /// </summary>
+        /// <value>The linear algebra provider.</value>
+        public static IFourierTransformProvider FourierTransformProvider
+        {
+            get
+            {
+                if (_fourierTransformProvider == null)
+                    InitializeDefaultProviders();
+
+                return _fourierTransformProvider;
+            }
+            set
+            {
+                value.InitializeVerify();
+
+                // only actually set if verification did not throw
+                _fourierTransformProvider = value;
+            }
+        }
+
         /// <summary>
         /// Gets or sets a value indicating how many parallel worker threads shall be used
         /// when parallelization is applicable.
@@ -293,6 +330,7 @@ namespace MathNet.Numerics
 
                 // Reinitialize providers:
                 LinearAlgebraProvider.InitializeVerify();
+                FourierTransformProvider.InitializeVerify();
             }
         }
 

src/Numerics/Numerics.csproj

@@ -174,6 +174,7 @@
     </Compile>
     <Compile Include="Providers\FourierTransform\IFourierTransformProvider.cs" />
     <Compile Include="Providers\FourierTransform\ManagedFourierTransformProvider.cs" />
+    <Compile Include="Providers\FourierTransform\Mkl\MklFourierTransformProvider.cs" />
     <Compile Include="Providers\LinearAlgebra\Acml\AcmlLinearAlgebraProvider.Complex.cs" />
     <Compile Include="Providers\LinearAlgebra\Acml\AcmlLinearAlgebraProvider.Complex32.cs" />
     <Compile Include="Providers\LinearAlgebra\Acml\AcmlLinearAlgebraProvider.Double.cs" />

src/Numerics/Providers/FourierTransform/IFourierTransformProvider.cs

@@ -36,6 +36,11 @@ namespace MathNet.Numerics.Providers.FourierTransform
 
     public interface IFourierTransformProvider
     {
+        /// <summary>
+        /// Initialize and verify that the provided is indeed available. If not, fall back to alternatives like the managed provider
+        /// </summary>
+        void InitializeVerify();
+
         void ForwardInplace(Complex[] complex);
         void BackwardInplace(Complex[] complex);
 

src/Numerics/Providers/FourierTransform/ManagedFourierTransformProvider.cs

@@ -5,6 +5,10 @@ namespace MathNet.Numerics.Providers.FourierTransform
 {
     public class ManagedFourierTransformProvider : IFourierTransformProvider
     {
+        public virtual void InitializeVerify()
+        {
+        }
+
         public void ForwardInplace(Complex[] complex)
         {
             Fourier.BluesteinForward(complex, FourierOptions.Default);

src/Numerics/Providers/FourierTransform/Mkl/MklFourierTransformProvider.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace MathNet.Numerics.Providers.FourierTransform.Mkl
+{
+    public class MklFourierTransformProvider : ManagedFourierTransformProvider
+    {
+        public override void InitializeVerify()
+        {
+        }
+    }
+}