diff --git a/src/Numerics/LinearAlgebra/Complex/Solvers/Iterative/BiCgStab.cs b/src/Numerics/LinearAlgebra/Complex/Solvers/Iterative/BiCgStab.cs
index 794aed7c..b06dcfb7 100644
--- a/src/Numerics/LinearAlgebra/Complex/Solvers/Iterative/BiCgStab.cs
+++ b/src/Numerics/LinearAlgebra/Complex/Solvers/Iterative/BiCgStab.cs
@@ -85,7 +85,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// The preconditioner that will be used. Can be set to <see langword="null" />, in which case the default
         /// pre-conditioner will be used.
         /// </summary>
-        IPreConditioner _preconditioner;
+        IPreConditioner<Complex> _preconditioner;
 
         /// <summary>
         /// The iterative process controller.
@@ -141,7 +141,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
-        public BiCgStab(IPreConditioner preconditioner)
+        public BiCgStab(IPreConditioner<Complex> preconditioner)
             : this(preconditioner, null)
         {
         }
@@ -163,7 +163,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation. </param>
         /// <param name="iterator">The <see cref="IIterator{T}"/> that will be used to monitor the iterative process. </param>
-        public BiCgStab(IPreConditioner preconditioner, IIterator<Complex> iterator)
+        public BiCgStab(IPreConditioner<Complex> preconditioner, IIterator<Complex> iterator)
         {
             _iterator = iterator;
             _preconditioner = preconditioner;
@@ -173,7 +173,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// Sets the <see cref="IPreConditioner"/> that will be used to precondition the iterative process.
         /// </summary>
         /// <param name="preconditioner">The preconditioner.</param>
-        public void SetPreconditioner(IPreConditioner preconditioner)
+        public void SetPreconditioner(IPreConditioner<Complex> preconditioner)
         {
             _preconditioner = preconditioner;
         }
diff --git a/src/Numerics/LinearAlgebra/Complex/Solvers/Iterative/GpBiCg.cs b/src/Numerics/LinearAlgebra/Complex/Solvers/Iterative/GpBiCg.cs
index 85c3d140..af7575ec 100644
--- a/src/Numerics/LinearAlgebra/Complex/Solvers/Iterative/GpBiCg.cs
+++ b/src/Numerics/LinearAlgebra/Complex/Solvers/Iterative/GpBiCg.cs
@@ -83,7 +83,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// The preconditioner that will be used. Can be set to <c>null</c>, in which case the default
         /// pre-conditioner will be used.
         /// </summary>
-        IPreConditioner _preconditioner;
+        IPreConditioner<Complex> _preconditioner;
 
         /// <summary>
         /// The iterative process controller.
@@ -151,7 +151,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
-        public GpBiCg(IPreConditioner preconditioner)
+        public GpBiCg(IPreConditioner<Complex> preconditioner)
             : this(preconditioner, null)
         {
         }
@@ -173,7 +173,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
         /// <param name="iterator">The <see cref="IIterator{T}"/> that will be used to monitor the iterative process.</param>
-        public GpBiCg(IPreConditioner preconditioner, IIterator<Complex> iterator)
+        public GpBiCg(IPreConditioner<Complex> preconditioner, IIterator<Complex> iterator)
         {
             _iterator = iterator;
             _preconditioner = preconditioner;
@@ -221,7 +221,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// Sets the <see cref="IPreConditioner"/> that will be used to precondition the iterative process.
         /// </summary>
         /// <param name="preconditioner">The preconditioner.</param>
-        public void SetPreconditioner(IPreConditioner preconditioner)
+        public void SetPreconditioner(IPreConditioner<Complex> preconditioner)
         {
             _preconditioner = preconditioner;
         }
diff --git a/src/Numerics/LinearAlgebra/Complex/Solvers/Iterative/MlkBiCgStab.cs b/src/Numerics/LinearAlgebra/Complex/Solvers/Iterative/MlkBiCgStab.cs
index 1e45b998..46407fc2 100644
--- a/src/Numerics/LinearAlgebra/Complex/Solvers/Iterative/MlkBiCgStab.cs
+++ b/src/Numerics/LinearAlgebra/Complex/Solvers/Iterative/MlkBiCgStab.cs
@@ -88,7 +88,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// The preconditioner that will be used. Can be set to <see langword="null" />, in which case the default
         /// pre-conditioner will be used.
         /// </summary>
-        IPreConditioner _preconditioner;
+        IPreConditioner<Complex> _preconditioner;
 
         /// <summary>
         /// The iterative process controller.
@@ -154,7 +154,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
-        public MlkBiCgStab(IPreConditioner preconditioner)
+        public MlkBiCgStab(IPreConditioner<Complex> preconditioner)
             : this(preconditioner, null)
         {
         }
@@ -176,7 +176,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
         /// <param name="iterator">The <see cref="IIterator{T}"/> that will be used to monitor the iterative process.</param>
-        public MlkBiCgStab(IPreConditioner preconditioner, IIterator<Complex> iterator)
+        public MlkBiCgStab(IPreConditioner<Complex> preconditioner, IIterator<Complex> iterator)
         {
             _iterator = iterator;
             _preconditioner = preconditioner;
@@ -218,7 +218,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// Sets the <see cref="IPreConditioner"/> that will be used to precondition the iterative process.
         /// </summary>
         /// <param name="preconditioner">The preconditioner.</param>
-        public void SetPreconditioner(IPreConditioner preconditioner)
+        public void SetPreconditioner(IPreConditioner<Complex> preconditioner)
         {
             _preconditioner = preconditioner;
         }
diff --git a/src/Numerics/LinearAlgebra/Complex/Solvers/Iterative/TFQMR.cs b/src/Numerics/LinearAlgebra/Complex/Solvers/Iterative/TFQMR.cs
index 5fdf24c3..db65ec7e 100644
--- a/src/Numerics/LinearAlgebra/Complex/Solvers/Iterative/TFQMR.cs
+++ b/src/Numerics/LinearAlgebra/Complex/Solvers/Iterative/TFQMR.cs
@@ -73,7 +73,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// The preconditioner that will be used. Can be set to <see langword="null" />, in which case the default
         /// pre-conditioner will be used.
         /// </summary>
-        IPreConditioner _preconditioner;
+        IPreConditioner<Complex> _preconditioner;
 
         /// <summary>
         /// The iterative process controller.
@@ -129,7 +129,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
-        public TFQMR(IPreConditioner preconditioner)
+        public TFQMR(IPreConditioner<Complex> preconditioner)
             : this(preconditioner, null)
         {
         }
@@ -151,7 +151,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
         /// <param name="iterator">The <see cref="IIterator{T}"/> that will be used to monitor the iterative process.</param>
-        public TFQMR(IPreConditioner preconditioner, IIterator<Complex> iterator)
+        public TFQMR(IPreConditioner<Complex> preconditioner, IIterator<Complex> iterator)
         {
             _iterator = iterator;
             _preconditioner = preconditioner;
@@ -161,7 +161,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// Sets the <see cref="IPreConditioner"/> that will be used to precondition the iterative process.
         /// </summary>
         /// <param name="preconditioner">The preconditioner.</param>
-        public void SetPreconditioner(IPreConditioner preconditioner)
+        public void SetPreconditioner(IPreConditioner<Complex> preconditioner)
         {
             _preconditioner = preconditioner;
         }
diff --git a/src/Numerics/LinearAlgebra/Complex/Solvers/Preconditioners/Diagonal.cs b/src/Numerics/LinearAlgebra/Complex/Solvers/Preconditioners/Diagonal.cs
index 4ecad2c5..7dd47ce2 100644
--- a/src/Numerics/LinearAlgebra/Complex/Solvers/Preconditioners/Diagonal.cs
+++ b/src/Numerics/LinearAlgebra/Complex/Solvers/Preconditioners/Diagonal.cs
@@ -28,10 +28,12 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using System;
+using MathNet.Numerics.LinearAlgebra.Solvers;
+using MathNet.Numerics.Properties;
+
 namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Preconditioners
 {
-    using System;
-    using Properties;
 
 #if NOSYSNUMERICS
     using Complex = Numerics.Complex;
@@ -43,7 +45,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Preconditioners
     /// A diagonal preconditioner. The preconditioner uses the inverse
     /// of the matrix diagonal as preconditioning values.
     /// </summary>
-    public sealed class Diagonal : IPreConditioner
+    public sealed class Diagonal : IPreConditioner<Complex>
     {
         /// <summary>
         /// The inverse of the matrix diagonal.
diff --git a/src/Numerics/LinearAlgebra/Complex/Solvers/Preconditioners/IPreConditioner.cs b/src/Numerics/LinearAlgebra/Complex/Solvers/Preconditioners/IPreConditioner.cs
deleted file mode 100644
index 6c514f69..00000000
--- a/src/Numerics/LinearAlgebra/Complex/Solvers/Preconditioners/IPreConditioner.cs
+++ /dev/null
@@ -1,80 +0,0 @@
-// <copyright file="IPreConditioner.cs" company="Math.NET">
-// Math.NET Numerics, part of the Math.NET Project
-// http://numerics.mathdotnet.com
-// http://github.com/mathnet/mathnet-numerics
-// http://mathnetnumerics.codeplex.com
-//
-// Copyright (c) 2009-2010 Math.NET
-//
-// Permission is hereby granted, free of charge, to any person
-// obtaining a copy of this software and associated documentation
-// files (the "Software"), to deal in the Software without
-// restriction, including without limitation the rights to use,
-// copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the
-// Software is furnished to do so, subject to the following
-// conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-// OTHER DEALINGS IN THE SOFTWARE.
-// </copyright>
-
-namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Preconditioners
-{
-
-#if NOSYSNUMERICS
-    using Complex = Numerics.Complex;
-#else
-    using Complex = System.Numerics.Complex;
-#endif
-
-    /// <summary>
-    /// The base interface for preconditioner classes.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// Preconditioners are used by iterative solvers to improve the convergence
-    /// speed of the solving process. Increase in convergence speed
-    /// is related to the number of iterations necessary to get a converged solution.
-    /// So while in general the use of a preconditioner means that the iterative 
-    /// solver will perform fewer iterations it does not guarantee that the actual
-    /// solution time decreases given that some preconditioners can be expensive to 
-    /// setup and run.
-    /// </para>
-    /// <para>
-    /// Note that in general changes to the matrix will invalidate the preconditioner
-    /// if the changes occur after creating the preconditioner.
-    /// </para>
-    /// </remarks>
-    public interface IPreConditioner
-    {
-        /// <summary>
-        /// Initializes the preconditioner and loads the internal data structures.
-        /// </summary>
-        /// <param name="matrix">The matrix on which the preconditioner is based.</param>
-        void Initialize(Matrix<Complex> matrix);
-
-        /// <summary>
-        /// Approximates the solution to the matrix equation <b>Mx = b</b>.
-        /// </summary>
-        /// <param name="rhs">The right hand side vector.</param>
-        /// <returns>The left hand side vector.</returns>
-        Vector<Complex> Approximate(Vector<Complex> rhs);
-
-        /// <summary>
-        /// Approximates the solution to the matrix equation <b>Mx = b</b>.
-        /// </summary>
-        /// <param name="rhs">The right hand side vector.</param>
-        /// <param name="lhs">The left hand side vector. Also known as the result vector.</param>
-        void Approximate(Vector<Complex> rhs, Vector<Complex> lhs);
-    }
-}
diff --git a/src/Numerics/LinearAlgebra/Complex/Solvers/Preconditioners/Ilutp.cs b/src/Numerics/LinearAlgebra/Complex/Solvers/Preconditioners/Ilutp.cs
index 7a6c6f61..e9c9194a 100644
--- a/src/Numerics/LinearAlgebra/Complex/Solvers/Preconditioners/Ilutp.cs
+++ b/src/Numerics/LinearAlgebra/Complex/Solvers/Preconditioners/Ilutp.cs
@@ -28,11 +28,13 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using System;
+using System.Collections.Generic;
+using MathNet.Numerics.LinearAlgebra.Solvers;
+using MathNet.Numerics.Properties;
+
 namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Preconditioners
 {
-    using System;
-    using System.Collections.Generic;
-    using Properties;
 
 #if NOSYSNUMERICS
     using Complex = Numerics.Complex;
@@ -57,7 +59,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Preconditioners
     /// pp. 20 - 28 <br/>
     /// Algorithm is described in Section 2, page 22
     /// </remarks>
-    public sealed class Ilutp : IPreConditioner
+    public sealed class Ilutp : IPreConditioner<Complex>
     {
         /// <summary>
         /// The default fill level.
diff --git a/src/Numerics/LinearAlgebra/Complex/Solvers/Preconditioners/IncompleteLU.cs b/src/Numerics/LinearAlgebra/Complex/Solvers/Preconditioners/IncompleteLU.cs
index 50b4233f..c6c166a4 100644
--- a/src/Numerics/LinearAlgebra/Complex/Solvers/Preconditioners/IncompleteLU.cs
+++ b/src/Numerics/LinearAlgebra/Complex/Solvers/Preconditioners/IncompleteLU.cs
@@ -28,10 +28,12 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using System;
+using MathNet.Numerics.LinearAlgebra.Solvers;
+using MathNet.Numerics.Properties;
+
 namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Preconditioners
 {
-    using System;
-    using Properties;
 
 #if NOSYSNUMERICS
     using Complex = Numerics.Complex;
@@ -48,7 +50,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Preconditioners
     /// Yousef Saad <br/>
     /// Algorithm is described in Chapter 10, section 10.3.2, page 275 <br/>
     /// </remarks>
-    public sealed class IncompleteLU : IPreConditioner
+    public sealed class IncompleteLU : IPreConditioner<Complex>
     {
         /// <summary>
         /// The matrix holding the lower (L) and upper (U) matrices. The
diff --git a/src/Numerics/LinearAlgebra/Complex/Solvers/Preconditioners/UnitPreconditioner.cs b/src/Numerics/LinearAlgebra/Complex/Solvers/Preconditioners/UnitPreconditioner.cs
index a10ec796..06d301cc 100644
--- a/src/Numerics/LinearAlgebra/Complex/Solvers/Preconditioners/UnitPreconditioner.cs
+++ b/src/Numerics/LinearAlgebra/Complex/Solvers/Preconditioners/UnitPreconditioner.cs
@@ -46,7 +46,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Preconditioners
     /// it is only used when running an <see cref="IIterativeSolver{T}"/> without
     /// a preconditioner.
     /// </summary>
-    internal sealed class UnitPreconditioner : IPreConditioner
+    internal sealed class UnitPreconditioner : IPreConditioner<Complex>
     {
         /// <summary>
         /// The coefficient matrix on which this preconditioner operates.
diff --git a/src/Numerics/LinearAlgebra/Complex32/Solvers/Iterative/BiCgStab.cs b/src/Numerics/LinearAlgebra/Complex32/Solvers/Iterative/BiCgStab.cs
index c3d8e565..a878e1bc 100644
--- a/src/Numerics/LinearAlgebra/Complex32/Solvers/Iterative/BiCgStab.cs
+++ b/src/Numerics/LinearAlgebra/Complex32/Solvers/Iterative/BiCgStab.cs
@@ -79,7 +79,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// The preconditioner that will be used. Can be set to <see langword="null" />, in which case the default
         /// pre-conditioner will be used.
         /// </summary>
-        IPreConditioner _preconditioner;
+        IPreConditioner<Complex32> _preconditioner;
 
         /// <summary>
         /// The iterative process controller.
@@ -135,7 +135,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
-        public BiCgStab(IPreConditioner preconditioner)
+        public BiCgStab(IPreConditioner<Complex32> preconditioner)
             : this(preconditioner, null)
         {
         }
@@ -157,7 +157,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation. </param>
         /// <param name="iterator">The <see cref="IIterator{T}"/> that will be used to monitor the iterative process. </param>
-        public BiCgStab(IPreConditioner preconditioner, IIterator<Complex32> iterator)
+        public BiCgStab(IPreConditioner<Complex32> preconditioner, IIterator<Complex32> iterator)
         {
             _iterator = iterator;
             _preconditioner = preconditioner;
@@ -167,7 +167,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// Sets the <see cref="IPreConditioner"/> that will be used to precondition the iterative process.
         /// </summary>
         /// <param name="preconditioner">The preconditioner.</param>
-        public void SetPreconditioner(IPreConditioner preconditioner)
+        public void SetPreconditioner(IPreConditioner<Complex32> preconditioner)
         {
             _preconditioner = preconditioner;
         }
diff --git a/src/Numerics/LinearAlgebra/Complex32/Solvers/Iterative/GpBiCg.cs b/src/Numerics/LinearAlgebra/Complex32/Solvers/Iterative/GpBiCg.cs
index 314aacfd..ef30bfa7 100644
--- a/src/Numerics/LinearAlgebra/Complex32/Solvers/Iterative/GpBiCg.cs
+++ b/src/Numerics/LinearAlgebra/Complex32/Solvers/Iterative/GpBiCg.cs
@@ -77,7 +77,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// The preconditioner that will be used. Can be set to <c>null</c>, in which case the default
         /// pre-conditioner will be used.
         /// </summary>
-        IPreConditioner _preconditioner;
+        IPreConditioner<Complex32> _preconditioner;
 
         /// <summary>
         /// The iterative process controller.
@@ -145,7 +145,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
-        public GpBiCg(IPreConditioner preconditioner)
+        public GpBiCg(IPreConditioner<Complex32> preconditioner)
             : this(preconditioner, null)
         {
         }
@@ -167,7 +167,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
         /// <param name="iterator">The <see cref="IIterator{T}"/> that will be used to monitor the iterative process.</param>
-        public GpBiCg(IPreConditioner preconditioner, IIterator<Complex32> iterator)
+        public GpBiCg(IPreConditioner<Complex32> preconditioner, IIterator<Complex32> iterator)
         {
             _iterator = iterator;
             _preconditioner = preconditioner;
@@ -215,7 +215,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// Sets the <see cref="IPreConditioner"/> that will be used to precondition the iterative process.
         /// </summary>
         /// <param name="preconditioner">The preconditioner.</param>
-        public void SetPreconditioner(IPreConditioner preconditioner)
+        public void SetPreconditioner(IPreConditioner<Complex32> preconditioner)
         {
             _preconditioner = preconditioner;
         }
diff --git a/src/Numerics/LinearAlgebra/Complex32/Solvers/Iterative/MlkBiCgStab.cs b/src/Numerics/LinearAlgebra/Complex32/Solvers/Iterative/MlkBiCgStab.cs
index 8370c091..16e2f4a9 100644
--- a/src/Numerics/LinearAlgebra/Complex32/Solvers/Iterative/MlkBiCgStab.cs
+++ b/src/Numerics/LinearAlgebra/Complex32/Solvers/Iterative/MlkBiCgStab.cs
@@ -82,7 +82,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// The preconditioner that will be used. Can be set to <see langword="null" />, in which case the default
         /// pre-conditioner will be used.
         /// </summary>
-        IPreConditioner _preconditioner;
+        IPreConditioner<Complex32> _preconditioner;
 
         /// <summary>
         /// The iterative process controller.
@@ -148,7 +148,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
-        public MlkBiCgStab(IPreConditioner preconditioner)
+        public MlkBiCgStab(IPreConditioner<Complex32> preconditioner)
             : this(preconditioner, null)
         {
         }
@@ -170,7 +170,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
         /// <param name="iterator">The <see cref="IIterator{T}"/> that will be used to monitor the iterative process.</param>
-        public MlkBiCgStab(IPreConditioner preconditioner, IIterator<Complex32> iterator)
+        public MlkBiCgStab(IPreConditioner<Complex32> preconditioner, IIterator<Complex32> iterator)
         {
             _iterator = iterator;
             _preconditioner = preconditioner;
@@ -212,7 +212,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// Sets the <see cref="IPreConditioner"/> that will be used to precondition the iterative process.
         /// </summary>
         /// <param name="preconditioner">The preconditioner.</param>
-        public void SetPreconditioner(IPreConditioner preconditioner)
+        public void SetPreconditioner(IPreConditioner<Complex32> preconditioner)
         {
             _preconditioner = preconditioner;
         }
diff --git a/src/Numerics/LinearAlgebra/Complex32/Solvers/Iterative/TFQMR.cs b/src/Numerics/LinearAlgebra/Complex32/Solvers/Iterative/TFQMR.cs
index dd4ec90a..ecf0e258 100644
--- a/src/Numerics/LinearAlgebra/Complex32/Solvers/Iterative/TFQMR.cs
+++ b/src/Numerics/LinearAlgebra/Complex32/Solvers/Iterative/TFQMR.cs
@@ -67,7 +67,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// The preconditioner that will be used. Can be set to <see langword="null" />, in which case the default
         /// pre-conditioner will be used.
         /// </summary>
-        IPreConditioner _preconditioner;
+        IPreConditioner<Complex32> _preconditioner;
 
         /// <summary>
         /// The iterative process controller.
@@ -123,7 +123,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
-        public TFQMR(IPreConditioner preconditioner)
+        public TFQMR(IPreConditioner<Complex32> preconditioner)
             : this(preconditioner, null)
         {
         }
@@ -145,7 +145,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
         /// <param name="iterator">The <see cref="IIterator{T}"/> that will be used to monitor the iterative process.</param>
-        public TFQMR(IPreConditioner preconditioner, IIterator<Complex32> iterator)
+        public TFQMR(IPreConditioner<Complex32> preconditioner, IIterator<Complex32> iterator)
         {
             _iterator = iterator;
             _preconditioner = preconditioner;
@@ -155,7 +155,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// Sets the <see cref="IPreConditioner"/> that will be used to precondition the iterative process.
         /// </summary>
         /// <param name="preconditioner">The preconditioner.</param>
-        public void SetPreconditioner(IPreConditioner preconditioner)
+        public void SetPreconditioner(IPreConditioner<Complex32> preconditioner)
         {
             _preconditioner = preconditioner;
         }
diff --git a/src/Numerics/LinearAlgebra/Complex32/Solvers/Preconditioners/Diagonal.cs b/src/Numerics/LinearAlgebra/Complex32/Solvers/Preconditioners/Diagonal.cs
index 4a56535a..1e9c0b5a 100644
--- a/src/Numerics/LinearAlgebra/Complex32/Solvers/Preconditioners/Diagonal.cs
+++ b/src/Numerics/LinearAlgebra/Complex32/Solvers/Preconditioners/Diagonal.cs
@@ -28,17 +28,19 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using System;
+using MathNet.Numerics.LinearAlgebra.Solvers;
+using MathNet.Numerics.Properties;
+
 namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Preconditioners
 {
-    using System;
     using Numerics;
-    using Properties;
 
     /// <summary>
     /// A diagonal preconditioner. The preconditioner uses the inverse
     /// of the matrix diagonal as preconditioning values.
     /// </summary>
-    public sealed class Diagonal : IPreConditioner
+    public sealed class Diagonal : IPreConditioner<Complex32>
     {
         /// <summary>
         /// The inverse of the matrix diagonal.
diff --git a/src/Numerics/LinearAlgebra/Complex32/Solvers/Preconditioners/IPreConditioner.cs b/src/Numerics/LinearAlgebra/Complex32/Solvers/Preconditioners/IPreConditioner.cs
deleted file mode 100644
index f1e80c06..00000000
--- a/src/Numerics/LinearAlgebra/Complex32/Solvers/Preconditioners/IPreConditioner.cs
+++ /dev/null
@@ -1,75 +0,0 @@
-// <copyright file="IPreConditioner.cs" company="Math.NET">
-// Math.NET Numerics, part of the Math.NET Project
-// http://numerics.mathdotnet.com
-// http://github.com/mathnet/mathnet-numerics
-// http://mathnetnumerics.codeplex.com
-//
-// Copyright (c) 2009-2010 Math.NET
-//
-// Permission is hereby granted, free of charge, to any person
-// obtaining a copy of this software and associated documentation
-// files (the "Software"), to deal in the Software without
-// restriction, including without limitation the rights to use,
-// copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the
-// Software is furnished to do so, subject to the following
-// conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-// OTHER DEALINGS IN THE SOFTWARE.
-// </copyright>
-
-namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Preconditioners
-{
-    using Numerics;
-
-    /// <summary>
-    /// The base interface for preconditioner classes.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// Preconditioners are used by iterative solvers to improve the convergence
-    /// speed of the solving process. Increase in convergence speed
-    /// is related to the number of iterations necessary to get a converged solution.
-    /// So while in general the use of a preconditioner means that the iterative 
-    /// solver will perform fewer iterations it does not guarantee that the actual
-    /// solution time decreases given that some preconditioners can be expensive to 
-    /// setup and run.
-    /// </para>
-    /// <para>
-    /// Note that in general changes to the matrix will invalidate the preconditioner
-    /// if the changes occur after creating the preconditioner.
-    /// </para>
-    /// </remarks>
-    public interface IPreConditioner
-    {
-        /// <summary>
-        /// Initializes the preconditioner and loads the internal data structures.
-        /// </summary>
-        /// <param name="matrix">The matrix on which the preconditioner is based.</param>
-        void Initialize(Matrix<Complex32> matrix);
-
-        /// <summary>
-        /// Approximates the solution to the matrix equation <b>Mx = b</b>.
-        /// </summary>
-        /// <param name="rhs">The right hand side vector.</param>
-        /// <returns>The left hand side vector.</returns>
-        Vector<Complex32> Approximate(Vector<Complex32> rhs);
-
-        /// <summary>
-        /// Approximates the solution to the matrix equation <b>Mx = b</b>.
-        /// </summary>
-        /// <param name="rhs">The right hand side vector.</param>
-        /// <param name="lhs">The left hand side vector. Also known as the result vector.</param>
-        void Approximate(Vector<Complex32> rhs, Vector<Complex32> lhs);
-    }
-}
diff --git a/src/Numerics/LinearAlgebra/Complex32/Solvers/Preconditioners/Ilutp.cs b/src/Numerics/LinearAlgebra/Complex32/Solvers/Preconditioners/Ilutp.cs
index 52ab9c81..1a0d8272 100644
--- a/src/Numerics/LinearAlgebra/Complex32/Solvers/Preconditioners/Ilutp.cs
+++ b/src/Numerics/LinearAlgebra/Complex32/Solvers/Preconditioners/Ilutp.cs
@@ -28,12 +28,14 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using System;
+using System.Collections.Generic;
+using MathNet.Numerics.LinearAlgebra.Solvers;
+using MathNet.Numerics.Properties;
+
 namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Preconditioners
 {
-    using System;
-    using System.Collections.Generic;
     using Numerics;
-    using Properties;
 
     /// <summary>
     /// This class performs an Incomplete LU factorization with drop tolerance
@@ -52,7 +54,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Preconditioners
     /// pp. 20 - 28 <br/>
     /// Algorithm is described in Section 2, page 22
     /// </remarks>
-    public sealed class Ilutp : IPreConditioner
+    public sealed class Ilutp : IPreConditioner<Complex32>
     {
         /// <summary>
         /// The default fill level.
diff --git a/src/Numerics/LinearAlgebra/Complex32/Solvers/Preconditioners/IncompleteLU.cs b/src/Numerics/LinearAlgebra/Complex32/Solvers/Preconditioners/IncompleteLU.cs
index 3a25e7b2..32a5b618 100644
--- a/src/Numerics/LinearAlgebra/Complex32/Solvers/Preconditioners/IncompleteLU.cs
+++ b/src/Numerics/LinearAlgebra/Complex32/Solvers/Preconditioners/IncompleteLU.cs
@@ -28,11 +28,13 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using System;
+using MathNet.Numerics.LinearAlgebra.Solvers;
+using MathNet.Numerics.Properties;
+
 namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Preconditioners
 {
-    using System;
     using Numerics;
-    using Properties;
 
     /// <summary>
     /// An incomplete, level 0, LU factorization preconditioner.
@@ -43,7 +45,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Preconditioners
     /// Yousef Saad <br/>
     /// Algorithm is described in Chapter 10, section 10.3.2, page 275 <br/>
     /// </remarks>
-    public sealed class IncompleteLU : IPreConditioner
+    public sealed class IncompleteLU : IPreConditioner<Complex32>
     {
         /// <summary>
         /// The matrix holding the lower (L) and upper (U) matrices. The
diff --git a/src/Numerics/LinearAlgebra/Complex32/Solvers/Preconditioners/UnitPreconditioner.cs b/src/Numerics/LinearAlgebra/Complex32/Solvers/Preconditioners/UnitPreconditioner.cs
index 102bf37b..805b3953 100644
--- a/src/Numerics/LinearAlgebra/Complex32/Solvers/Preconditioners/UnitPreconditioner.cs
+++ b/src/Numerics/LinearAlgebra/Complex32/Solvers/Preconditioners/UnitPreconditioner.cs
@@ -41,7 +41,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Preconditioners
     /// it is only used when running an <see cref="IIterativeSolver{T}"/> without
     /// a preconditioner.
     /// </summary>
-    internal sealed class UnitPreconditioner : IPreConditioner
+    internal sealed class UnitPreconditioner : IPreConditioner<Complex32>
     {
         /// <summary>
         /// The coefficient matrix on which this preconditioner operates.
diff --git a/src/Numerics/LinearAlgebra/Double/Solvers/Iterative/BiCgStab.cs b/src/Numerics/LinearAlgebra/Double/Solvers/Iterative/BiCgStab.cs
index 3850b52a..61089ca2 100644
--- a/src/Numerics/LinearAlgebra/Double/Solvers/Iterative/BiCgStab.cs
+++ b/src/Numerics/LinearAlgebra/Double/Solvers/Iterative/BiCgStab.cs
@@ -77,7 +77,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         /// The preconditioner that will be used. Can be set to <see langword="null" />, in which case the default
         /// pre-conditioner will be used.
         /// </summary>
-        private IPreConditioner _preconditioner;
+        private IPreConditioner<double> _preconditioner;
 
         /// <summary>
         /// The iterative process controller.
@@ -132,7 +132,8 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
-        public BiCgStab(IPreConditioner preconditioner) : this(preconditioner, null)
+        public BiCgStab(IPreConditioner<double> preconditioner)
+            : this(preconditioner, null)
         {
         }
 
@@ -153,7 +154,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation. </param>
         /// <param name="iterator">The <see cref="IIterator{T}"/> that will be used to monitor the iterative process. </param>
-        public BiCgStab(IPreConditioner preconditioner, IIterator<double> iterator)
+        public BiCgStab(IPreConditioner<double> preconditioner, IIterator<double> iterator)
         {
             _iterator = iterator;
             _preconditioner = preconditioner;
@@ -163,7 +164,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         /// Sets the <see cref="IPreConditioner"/> that will be used to precondition the iterative process.
         /// </summary>
         /// <param name="preconditioner">The preconditioner.</param>
-        public void SetPreconditioner(IPreConditioner preconditioner)
+        public void SetPreconditioner(IPreConditioner<double> preconditioner)
         {
             _preconditioner = preconditioner;
         }
diff --git a/src/Numerics/LinearAlgebra/Double/Solvers/Iterative/GpBiCg.cs b/src/Numerics/LinearAlgebra/Double/Solvers/Iterative/GpBiCg.cs
index 9d14520b..a4074ae0 100644
--- a/src/Numerics/LinearAlgebra/Double/Solvers/Iterative/GpBiCg.cs
+++ b/src/Numerics/LinearAlgebra/Double/Solvers/Iterative/GpBiCg.cs
@@ -75,7 +75,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         /// The preconditioner that will be used. Can be set to <c>null</c>, in which case the default
         /// pre-conditioner will be used.
         /// </summary>
-        private IPreConditioner _preconditioner;
+        private IPreConditioner<double> _preconditioner;
 
         /// <summary>
         /// The iterative process controller.
@@ -142,7 +142,8 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
-        public GpBiCg(IPreConditioner preconditioner) : this(preconditioner, null)
+        public GpBiCg(IPreConditioner<double> preconditioner)
+            : this(preconditioner, null)
         {
         }
 
@@ -163,7 +164,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
         /// <param name="iterator">The <see cref="IIterator{T}"/> that will be used to monitor the iterative process.</param>
-        public GpBiCg(IPreConditioner preconditioner, IIterator<double> iterator)
+        public GpBiCg(IPreConditioner<double> preconditioner, IIterator<double> iterator)
         {
             _iterator = iterator;
             _preconditioner = preconditioner;
@@ -217,7 +218,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         /// Sets the <see cref="IPreConditioner"/> that will be used to precondition the iterative process.
         /// </summary>
         /// <param name="preconditioner">The preconditioner.</param>
-        public void SetPreconditioner(IPreConditioner preconditioner)
+        public void SetPreconditioner(IPreConditioner<double> preconditioner)
         {
             _preconditioner = preconditioner;
         }
diff --git a/src/Numerics/LinearAlgebra/Double/Solvers/Iterative/MlkBiCgStab.cs b/src/Numerics/LinearAlgebra/Double/Solvers/Iterative/MlkBiCgStab.cs
index 4b0856ce..78b00041 100644
--- a/src/Numerics/LinearAlgebra/Double/Solvers/Iterative/MlkBiCgStab.cs
+++ b/src/Numerics/LinearAlgebra/Double/Solvers/Iterative/MlkBiCgStab.cs
@@ -80,7 +80,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         /// The preconditioner that will be used. Can be set to <see langword="null" />, in which case the default
         /// pre-conditioner will be used.
         /// </summary>
-        private IPreConditioner _preconditioner;
+        private IPreConditioner<double> _preconditioner;
 
         /// <summary>
         /// The iterative process controller.
@@ -145,7 +145,8 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
-        public MlkBiCgStab(IPreConditioner preconditioner) : this(preconditioner, null)
+        public MlkBiCgStab(IPreConditioner<double> preconditioner)
+            : this(preconditioner, null)
         {
         }
 
@@ -166,7 +167,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
         /// <param name="iterator">The <see cref="IIterator{T}"/> that will be used to monitor the iterative process.</param>
-        public MlkBiCgStab(IPreConditioner preconditioner, IIterator<double> iterator)
+        public MlkBiCgStab(IPreConditioner<double> preconditioner, IIterator<double> iterator)
         {
             _iterator = iterator;
             _preconditioner = preconditioner;
@@ -211,7 +212,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         /// Sets the <see cref="IPreConditioner"/> that will be used to precondition the iterative process.
         /// </summary>
         /// <param name="preconditioner">The preconditioner.</param>
-        public void SetPreconditioner(IPreConditioner preconditioner)
+        public void SetPreconditioner(IPreConditioner<double> preconditioner)
         {
             _preconditioner = preconditioner;
         }
diff --git a/src/Numerics/LinearAlgebra/Double/Solvers/Iterative/TFQMR.cs b/src/Numerics/LinearAlgebra/Double/Solvers/Iterative/TFQMR.cs
index 2ce4b35b..5e76cad2 100644
--- a/src/Numerics/LinearAlgebra/Double/Solvers/Iterative/TFQMR.cs
+++ b/src/Numerics/LinearAlgebra/Double/Solvers/Iterative/TFQMR.cs
@@ -65,7 +65,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         /// The preconditioner that will be used. Can be set to <see langword="null" />, in which case the default
         /// pre-conditioner will be used.
         /// </summary>
-        private IPreConditioner _preconditioner;
+        private IPreConditioner<double> _preconditioner;
 
         /// <summary>
         /// The iterative process controller.
@@ -120,7 +120,8 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
-        public TFQMR(IPreConditioner preconditioner) : this(preconditioner, null)
+        public TFQMR(IPreConditioner<double> preconditioner)
+            : this(preconditioner, null)
         {
         }
 
@@ -141,7 +142,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
         /// <param name="iterator">The <see cref="IIterator{T}"/> that will be used to monitor the iterative process.</param>
-        public TFQMR(IPreConditioner preconditioner, IIterator<double> iterator)
+        public TFQMR(IPreConditioner<double> preconditioner, IIterator<double> iterator)
         {
             _iterator = iterator;
             _preconditioner = preconditioner;
@@ -151,7 +152,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         /// Sets the <see cref="IPreConditioner"/> that will be used to precondition the iterative process.
         /// </summary>
         /// <param name="preconditioner">The preconditioner.</param>
-        public void SetPreconditioner(IPreConditioner preconditioner)
+        public void SetPreconditioner(IPreConditioner<double> preconditioner)
         {
             _preconditioner = preconditioner;
         }
diff --git a/src/Numerics/LinearAlgebra/Double/Solvers/Preconditioners/Diagonal.cs b/src/Numerics/LinearAlgebra/Double/Solvers/Preconditioners/Diagonal.cs
index e0b84658..72c56ed7 100644
--- a/src/Numerics/LinearAlgebra/Double/Solvers/Preconditioners/Diagonal.cs
+++ b/src/Numerics/LinearAlgebra/Double/Solvers/Preconditioners/Diagonal.cs
@@ -4,7 +4,7 @@
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
 //
-// Copyright (c) 2009-2010 Math.NET
+// Copyright (c) 2009-2013 Math.NET
 //
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
@@ -28,16 +28,17 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using System;
+using MathNet.Numerics.LinearAlgebra.Solvers;
+using MathNet.Numerics.Properties;
+
 namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Preconditioners
 {
-    using System;
-    using Properties;
-
     /// <summary>
     /// A diagonal preconditioner. The preconditioner uses the inverse
     /// of the matrix diagonal as preconditioning values.
     /// </summary>
-    public sealed class Diagonal : IPreConditioner
+    public sealed class Diagonal : IPreConditioner<double>
     {
         /// <summary>
         /// The inverse of the matrix diagonal.
diff --git a/src/Numerics/LinearAlgebra/Double/Solvers/Preconditioners/Ilutp.cs b/src/Numerics/LinearAlgebra/Double/Solvers/Preconditioners/Ilutp.cs
index 16c8336c..b69a706f 100644
--- a/src/Numerics/LinearAlgebra/Double/Solvers/Preconditioners/Ilutp.cs
+++ b/src/Numerics/LinearAlgebra/Double/Solvers/Preconditioners/Ilutp.cs
@@ -4,7 +4,7 @@
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
 //
-// Copyright (c) 2009-2010 Math.NET
+// Copyright (c) 2009-2013 Math.NET
 //
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
@@ -28,12 +28,13 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using System;
+using System.Collections.Generic;
+using MathNet.Numerics.LinearAlgebra.Solvers;
+using MathNet.Numerics.Properties;
+
 namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Preconditioners
 {
-    using System;
-    using System.Collections.Generic;
-    using Properties;
-
     /// <summary>
     /// This class performs an Incomplete LU factorization with drop tolerance
     /// and partial pivoting. The drop tolerance indicates which additional entries
@@ -51,7 +52,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Preconditioners
     /// pp. 20 - 28 <br/>
     /// Algorithm is described in Section 2, page 22
     /// </remarks>
-    public sealed class Ilutp : IPreConditioner
+    public sealed class Ilutp : IPreConditioner<double>
     {
         /// <summary>
         /// The default fill level.
diff --git a/src/Numerics/LinearAlgebra/Double/Solvers/Preconditioners/IncompleteLU.cs b/src/Numerics/LinearAlgebra/Double/Solvers/Preconditioners/IncompleteLU.cs
index 8767f10f..be663f34 100644
--- a/src/Numerics/LinearAlgebra/Double/Solvers/Preconditioners/IncompleteLU.cs
+++ b/src/Numerics/LinearAlgebra/Double/Solvers/Preconditioners/IncompleteLU.cs
@@ -4,7 +4,7 @@
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
 //
-// Copyright (c) 2009-2010 Math.NET
+// Copyright (c) 2009-2013 Math.NET
 //
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
@@ -28,11 +28,12 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using System;
+using MathNet.Numerics.LinearAlgebra.Solvers;
+using MathNet.Numerics.Properties;
+
 namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Preconditioners
 {
-    using System;
-    using Properties;
-
     /// <summary>
     /// An incomplete, level 0, LU factorization preconditioner.
     /// </summary>
@@ -42,7 +43,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Preconditioners
     /// Yousef Saad <br/>
     /// Algorithm is described in Chapter 10, section 10.3.2, page 275 <br/>
     /// </remarks>
-    public sealed class IncompleteLU : IPreConditioner
+    public sealed class IncompleteLU : IPreConditioner<double>
     {
         /// <summary>
         /// The matrix holding the lower (L) and upper (U) matrices. The
diff --git a/src/Numerics/LinearAlgebra/Double/Solvers/Preconditioners/UnitPreconditioner.cs b/src/Numerics/LinearAlgebra/Double/Solvers/Preconditioners/UnitPreconditioner.cs
index 9834d3fe..ff5576da 100644
--- a/src/Numerics/LinearAlgebra/Double/Solvers/Preconditioners/UnitPreconditioner.cs
+++ b/src/Numerics/LinearAlgebra/Double/Solvers/Preconditioners/UnitPreconditioner.cs
@@ -4,7 +4,7 @@
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
 //
-// Copyright (c) 2009-2010 Math.NET
+// Copyright (c) 2009-2013 Math.NET
 //
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
@@ -39,7 +39,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Preconditioners
     /// it is only used when running an <see cref="IIterativeSolver{T}"/> without
     /// a preconditioner.
     /// </summary>
-    internal sealed class UnitPreconditioner : IPreConditioner
+    internal sealed class UnitPreconditioner : IPreConditioner<double>
     {
         /// <summary>
         /// The coefficient matrix on which this preconditioner operates.
diff --git a/src/Numerics/LinearAlgebra/Single/Solvers/Iterative/BiCgStab.cs b/src/Numerics/LinearAlgebra/Single/Solvers/Iterative/BiCgStab.cs
index 2bb1bf38..90b8a8af 100644
--- a/src/Numerics/LinearAlgebra/Single/Solvers/Iterative/BiCgStab.cs
+++ b/src/Numerics/LinearAlgebra/Single/Solvers/Iterative/BiCgStab.cs
@@ -77,7 +77,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// The preconditioner that will be used. Can be set to <see langword="null" />, in which case the default
         /// pre-conditioner will be used.
         /// </summary>
-        private IPreConditioner _preconditioner;
+        private IPreConditioner<float> _preconditioner;
 
         /// <summary>
         /// The iterative process controller.
@@ -132,7 +132,8 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
-        public BiCgStab(IPreConditioner preconditioner) : this(preconditioner, null)
+        public BiCgStab(IPreConditioner<float> preconditioner)
+            : this(preconditioner, null)
         {
         }
 
@@ -153,7 +154,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation. </param>
         /// <param name="iterator">The <see cref="IIterator{T}"/> that will be used to monitor the iterative process. </param>
-        public BiCgStab(IPreConditioner preconditioner, IIterator<float> iterator)
+        public BiCgStab(IPreConditioner<float> preconditioner, IIterator<float> iterator)
         {
             _iterator = iterator;
             _preconditioner = preconditioner;
@@ -163,7 +164,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// Sets the <see cref="IPreConditioner"/> that will be used to precondition the iterative process.
         /// </summary>
         /// <param name="preconditioner">The preconditioner.</param>
-        public void SetPreconditioner(IPreConditioner preconditioner)
+        public void SetPreconditioner(IPreConditioner<float> preconditioner)
         {
             _preconditioner = preconditioner;
         }
diff --git a/src/Numerics/LinearAlgebra/Single/Solvers/Iterative/GpBiCg.cs b/src/Numerics/LinearAlgebra/Single/Solvers/Iterative/GpBiCg.cs
index 8aa750fb..52d7ad46 100644
--- a/src/Numerics/LinearAlgebra/Single/Solvers/Iterative/GpBiCg.cs
+++ b/src/Numerics/LinearAlgebra/Single/Solvers/Iterative/GpBiCg.cs
@@ -75,7 +75,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// The preconditioner that will be used. Can be set to <c>null</c>, in which case the default
         /// pre-conditioner will be used.
         /// </summary>
-        IPreConditioner _preconditioner;
+        IPreConditioner<float> _preconditioner;
 
         /// <summary>
         /// The iterative process controller.
@@ -143,7 +143,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
-        public GpBiCg(IPreConditioner preconditioner)
+        public GpBiCg(IPreConditioner<float> preconditioner)
             : this(preconditioner, null)
         {
         }
@@ -165,7 +165,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
         /// <param name="iterator">The <see cref="IIterator{T}"/> that will be used to monitor the iterative process.</param>
-        public GpBiCg(IPreConditioner preconditioner, IIterator<float> iterator)
+        public GpBiCg(IPreConditioner<float> preconditioner, IIterator<float> iterator)
         {
             _iterator = iterator;
             _preconditioner = preconditioner;
@@ -213,7 +213,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// Sets the <see cref="IPreConditioner"/> that will be used to precondition the iterative process.
         /// </summary>
         /// <param name="preconditioner">The preconditioner.</param>
-        public void SetPreconditioner(IPreConditioner preconditioner)
+        public void SetPreconditioner(IPreConditioner<float> preconditioner)
         {
             _preconditioner = preconditioner;
         }
diff --git a/src/Numerics/LinearAlgebra/Single/Solvers/Iterative/MlkBiCgStab.cs b/src/Numerics/LinearAlgebra/Single/Solvers/Iterative/MlkBiCgStab.cs
index 5f73e017..77ea9aa0 100644
--- a/src/Numerics/LinearAlgebra/Single/Solvers/Iterative/MlkBiCgStab.cs
+++ b/src/Numerics/LinearAlgebra/Single/Solvers/Iterative/MlkBiCgStab.cs
@@ -79,7 +79,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// The preconditioner that will be used. Can be set to <see langword="null" />, in which case the default
         /// pre-conditioner will be used.
         /// </summary>
-        private IPreConditioner _preconditioner;
+        private IPreConditioner<float> _preconditioner;
 
         /// <summary>
         /// The iterative process controller.
@@ -144,7 +144,8 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
-        public MlkBiCgStab(IPreConditioner preconditioner) : this(preconditioner, null)
+        public MlkBiCgStab(IPreConditioner<float> preconditioner)
+            : this(preconditioner, null)
         {
         }
 
@@ -165,7 +166,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
         /// <param name="iterator">The <see cref="IIterator{T}"/> that will be used to monitor the iterative process.</param>
-        public MlkBiCgStab(IPreConditioner preconditioner, IIterator<float> iterator)
+        public MlkBiCgStab(IPreConditioner<float> preconditioner, IIterator<float> iterator)
         {
             _iterator = iterator;
             _preconditioner = preconditioner;
@@ -210,7 +211,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// Sets the <see cref="IPreConditioner"/> that will be used to precondition the iterative process.
         /// </summary>
         /// <param name="preconditioner">The preconditioner.</param>
-        public void SetPreconditioner(IPreConditioner preconditioner)
+        public void SetPreconditioner(IPreConditioner<float> preconditioner)
         {
             _preconditioner = preconditioner;
         }
diff --git a/src/Numerics/LinearAlgebra/Single/Solvers/Iterative/TFQMR.cs b/src/Numerics/LinearAlgebra/Single/Solvers/Iterative/TFQMR.cs
index ec83f2be..f27f5054 100644
--- a/src/Numerics/LinearAlgebra/Single/Solvers/Iterative/TFQMR.cs
+++ b/src/Numerics/LinearAlgebra/Single/Solvers/Iterative/TFQMR.cs
@@ -65,7 +65,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// The preconditioner that will be used. Can be set to <see langword="null" />, in which case the default
         /// pre-conditioner will be used.
         /// </summary>
-        IPreConditioner _preconditioner;
+        IPreConditioner<float> _preconditioner;
 
         /// <summary>
         /// The iterative process controller.
@@ -121,7 +121,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
-        public TFQMR(IPreConditioner preconditioner)
+        public TFQMR(IPreConditioner<float> preconditioner)
             : this(preconditioner, null)
         {
         }
@@ -143,7 +143,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
         /// <param name="iterator">The <see cref="IIterator{T}"/> that will be used to monitor the iterative process.</param>
-        public TFQMR(IPreConditioner preconditioner, IIterator<float> iterator)
+        public TFQMR(IPreConditioner<float> preconditioner, IIterator<float> iterator)
         {
             _iterator = iterator;
             _preconditioner = preconditioner;
@@ -153,7 +153,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// Sets the <see cref="IPreConditioner"/> that will be used to precondition the iterative process.
         /// </summary>
         /// <param name="preconditioner">The preconditioner.</param>
-        public void SetPreconditioner(IPreConditioner preconditioner)
+        public void SetPreconditioner(IPreConditioner<float> preconditioner)
         {
             _preconditioner = preconditioner;
         }
diff --git a/src/Numerics/LinearAlgebra/Single/Solvers/Preconditioners/Diagonal.cs b/src/Numerics/LinearAlgebra/Single/Solvers/Preconditioners/Diagonal.cs
index 1c6441c8..aa79081f 100644
--- a/src/Numerics/LinearAlgebra/Single/Solvers/Preconditioners/Diagonal.cs
+++ b/src/Numerics/LinearAlgebra/Single/Solvers/Preconditioners/Diagonal.cs
@@ -4,7 +4,7 @@
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
 //
-// Copyright (c) 2009-2010 Math.NET
+// Copyright (c) 2009-2013 Math.NET
 //
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
@@ -28,16 +28,17 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using System;
+using MathNet.Numerics.LinearAlgebra.Solvers;
+using MathNet.Numerics.Properties;
+
 namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Preconditioners
 {
-    using System;
-    using Properties;
-
     /// <summary>
     /// A diagonal preconditioner. The preconditioner uses the inverse
     /// of the matrix diagonal as preconditioning values.
     /// </summary>
-    public sealed class Diagonal : IPreConditioner
+    public sealed class Diagonal : IPreConditioner<float>
     {
         /// <summary>
         /// The inverse of the matrix diagonal.
diff --git a/src/Numerics/LinearAlgebra/Single/Solvers/Preconditioners/IPreConditioner.cs b/src/Numerics/LinearAlgebra/Single/Solvers/Preconditioners/IPreConditioner.cs
deleted file mode 100644
index 090316ad..00000000
--- a/src/Numerics/LinearAlgebra/Single/Solvers/Preconditioners/IPreConditioner.cs
+++ /dev/null
@@ -1,73 +0,0 @@
-// <copyright file="IPreConditioner.cs" company="Math.NET">
-// Math.NET Numerics, part of the Math.NET Project
-// http://numerics.mathdotnet.com
-// http://github.com/mathnet/mathnet-numerics
-// http://mathnetnumerics.codeplex.com
-//
-// Copyright (c) 2009-2010 Math.NET
-//
-// Permission is hereby granted, free of charge, to any person
-// obtaining a copy of this software and associated documentation
-// files (the "Software"), to deal in the Software without
-// restriction, including without limitation the rights to use,
-// copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the
-// Software is furnished to do so, subject to the following
-// conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-// OTHER DEALINGS IN THE SOFTWARE.
-// </copyright>
-
-namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Preconditioners
-{
-    /// <summary>
-    /// The base interface for preconditioner classes.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// Preconditioners are used by iterative solvers to improve the convergence
-    /// speed of the solving process. Increase in convergence speed
-    /// is related to the number of iterations necessary to get a converged solution.
-    /// So while in general the use of a preconditioner means that the iterative 
-    /// solver will perform fewer iterations it does not guarantee that the actual
-    /// solution time decreases given that some preconditioners can be expensive to 
-    /// setup and run.
-    /// </para>
-    /// <para>
-    /// Note that in general changes to the matrix will invalidate the preconditioner
-    /// if the changes occur after creating the preconditioner.
-    /// </para>
-    /// </remarks>
-    public interface IPreConditioner
-    {
-        /// <summary>
-        /// Initializes the preconditioner and loads the internal data structures.
-        /// </summary>
-        /// <param name="matrix">The matrix on which the preconditioner is based.</param>
-        void Initialize(Matrix<float> matrix);
-
-        /// <summary>
-        /// Approximates the solution to the matrix equation <b>Mx = b</b>.
-        /// </summary>
-        /// <param name="rhs">The right hand side vector.</param>
-        /// <returns>The left hand side vector.</returns>
-        Vector<float> Approximate(Vector<float> rhs);
-
-        /// <summary>
-        /// Approximates the solution to the matrix equation <b>Mx = b</b>.
-        /// </summary>
-        /// <param name="rhs">The right hand side vector.</param>
-        /// <param name="lhs">The left hand side vector. Also known as the result vector.</param>
-        void Approximate(Vector<float> rhs, Vector<float> lhs);
-    }
-}
diff --git a/src/Numerics/LinearAlgebra/Single/Solvers/Preconditioners/Ilutp.cs b/src/Numerics/LinearAlgebra/Single/Solvers/Preconditioners/Ilutp.cs
index 42551083..b6ed9c56 100644
--- a/src/Numerics/LinearAlgebra/Single/Solvers/Preconditioners/Ilutp.cs
+++ b/src/Numerics/LinearAlgebra/Single/Solvers/Preconditioners/Ilutp.cs
@@ -28,12 +28,13 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using System;
+using System.Collections.Generic;
+using MathNet.Numerics.LinearAlgebra.Solvers;
+using MathNet.Numerics.Properties;
+
 namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Preconditioners
 {
-    using System;
-    using System.Collections.Generic;
-    using Properties;
-
     /// <summary>
     /// This class performs an Incomplete LU factorization with drop tolerance
     /// and partial pivoting. The drop tolerance indicates which additional entries
@@ -51,7 +52,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Preconditioners
     /// pp. 20 - 28 <br/>
     /// Algorithm is described in Section 2, page 22
     /// </remarks>
-    public sealed class Ilutp : IPreConditioner
+    public sealed class Ilutp : IPreConditioner<float>
     {
         /// <summary>
         /// The default fill level.
diff --git a/src/Numerics/LinearAlgebra/Single/Solvers/Preconditioners/IncompleteLU.cs b/src/Numerics/LinearAlgebra/Single/Solvers/Preconditioners/IncompleteLU.cs
index 2d806b38..6cf40b6b 100644
--- a/src/Numerics/LinearAlgebra/Single/Solvers/Preconditioners/IncompleteLU.cs
+++ b/src/Numerics/LinearAlgebra/Single/Solvers/Preconditioners/IncompleteLU.cs
@@ -4,7 +4,7 @@
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
 //
-// Copyright (c) 2009-2010 Math.NET
+// Copyright (c) 2009-2013 Math.NET
 //
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
@@ -28,11 +28,12 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
+using System;
+using MathNet.Numerics.LinearAlgebra.Solvers;
+using MathNet.Numerics.Properties;
+
 namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Preconditioners
 {
-    using System;
-    using Properties;
-
     /// <summary>
     /// An incomplete, level 0, LU factorization preconditioner.
     /// </summary>
@@ -42,7 +43,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Preconditioners
     /// Yousef Saad <br/>
     /// Algorithm is described in Chapter 10, section 10.3.2, page 275 <br/>
     /// </remarks>
-    public sealed class IncompleteLU : IPreConditioner
+    public sealed class IncompleteLU : IPreConditioner<float>
     {
         /// <summary>
         /// The matrix holding the lower (L) and upper (U) matrices. The
diff --git a/src/Numerics/LinearAlgebra/Single/Solvers/Preconditioners/UnitPreconditioner.cs b/src/Numerics/LinearAlgebra/Single/Solvers/Preconditioners/UnitPreconditioner.cs
index e1af68f0..ead99b7e 100644
--- a/src/Numerics/LinearAlgebra/Single/Solvers/Preconditioners/UnitPreconditioner.cs
+++ b/src/Numerics/LinearAlgebra/Single/Solvers/Preconditioners/UnitPreconditioner.cs
@@ -4,7 +4,7 @@
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
 //
-// Copyright (c) 2009-2010 Math.NET
+// Copyright (c) 2009-2013 Math.NET
 //
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
@@ -39,7 +39,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Preconditioners
     /// it is only used when running an <see cref="IIterativeSolver{T}"/> without
     /// a preconditioner.
     /// </summary>
-    internal sealed class UnitPreconditioner : IPreConditioner
+    internal sealed class UnitPreconditioner : IPreConditioner<float>
     {
         /// <summary>
         /// The coefficient matrix on which this preconditioner operates.
diff --git a/src/Numerics/LinearAlgebra/Double/Solvers/Preconditioners/IPreConditioner.cs b/src/Numerics/LinearAlgebra/Solvers/IPreConditioner.cs
similarity index 89%
rename from src/Numerics/LinearAlgebra/Double/Solvers/Preconditioners/IPreConditioner.cs
rename to src/Numerics/LinearAlgebra/Solvers/IPreConditioner.cs
index 993e16ea..db4c183f 100644
--- a/src/Numerics/LinearAlgebra/Double/Solvers/Preconditioners/IPreConditioner.cs
+++ b/src/Numerics/LinearAlgebra/Solvers/IPreConditioner.cs
@@ -4,7 +4,7 @@
 // http://github.com/mathnet/mathnet-numerics
 // http://mathnetnumerics.codeplex.com
 //
-// Copyright (c) 2009-2010 Math.NET
+// Copyright (c) 2009-2013 Math.NET
 //
 // Permission is hereby granted, free of charge, to any person
 // obtaining a copy of this software and associated documentation
@@ -28,7 +28,9 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 // </copyright>
 
-namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Preconditioners
+using System;
+
+namespace MathNet.Numerics.LinearAlgebra.Solvers
 {
     /// <summary>
     /// The base interface for preconditioner classes.
@@ -48,26 +50,26 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Preconditioners
     /// if the changes occur after creating the preconditioner.
     /// </para>
     /// </remarks>
-    public interface IPreConditioner
+    public interface IPreConditioner<T> where T : struct, IEquatable<T>, IFormattable
     {
         /// <summary>
         /// Initializes the preconditioner and loads the internal data structures.
         /// </summary>
         /// <param name="matrix">The matrix on which the preconditioner is based.</param>
-        void Initialize(Matrix<double> matrix);
+        void Initialize(Matrix<T> matrix);
 
         /// <summary>
         /// Approximates the solution to the matrix equation <b>Mx = b</b>.
         /// </summary>
         /// <param name="rhs">The right hand side vector.</param>
         /// <returns>The left hand side vector.</returns>
-        Vector<double> Approximate(Vector<double> rhs);
+        Vector<T> Approximate(Vector<T> rhs);
 
         /// <summary>
         /// Approximates the solution to the matrix equation <b>Mx = b</b>.
         /// </summary>
         /// <param name="rhs">The right hand side vector.</param>
         /// <param name="lhs">The left hand side vector. Also known as the result vector.</param>
-        void Approximate(Vector<double> rhs, Vector<double> lhs);
+        void Approximate(Vector<T> rhs, Vector<T> lhs);
     }
 }
diff --git a/src/Numerics/Numerics.csproj b/src/Numerics/Numerics.csproj
index 209fd8c6..9aadcede 100644
--- a/src/Numerics/Numerics.csproj
+++ b/src/Numerics/Numerics.csproj
@@ -191,7 +191,6 @@
     <Compile Include="LinearAlgebra\Complex32\Factorization\QR.cs" />
     <Compile Include="LinearAlgebra\Complex32\Factorization\Svd.cs" />
     <Compile Include="LinearAlgebra\Complex32\Matrix.cs" />
-    <Compile Include="LinearAlgebra\Complex32\Solvers\Preconditioners\IPreConditioner.cs" />
     <Compile Include="LinearAlgebra\Complex32\SparseMatrix.cs" />
     <Compile Include="LinearAlgebra\Complex32\Vector.cs" />
     <Compile Include="LinearAlgebra\Complex\DenseMatrix.cs" />
@@ -206,7 +205,6 @@
     <Compile Include="LinearAlgebra\Complex\Factorization\QR.cs" />
     <Compile Include="LinearAlgebra\Complex\Factorization\Svd.cs" />
     <Compile Include="LinearAlgebra\Complex\Matrix.cs" />
-    <Compile Include="LinearAlgebra\Complex\Solvers\Preconditioners\IPreConditioner.cs" />
     <Compile Include="LinearAlgebra\Complex\SparseMatrix.cs" />
     <Compile Include="LinearAlgebra\Complex\Vector.cs" />
     <Compile Include="LinearAlgebra\Double\Factorization\Cholesky.cs" />
@@ -221,7 +219,7 @@
     <Compile Include="LinearAlgebra\Solvers\IIterativeSolver.cs" />
     <Compile Include="LinearAlgebra\Solvers\IIterativeSolverSetup.cs" />
     <Compile Include="LinearAlgebra\Solvers\IIterator.cs" />
-    <Compile Include="LinearAlgebra\Double\Solvers\Preconditioners\IPreConditioner.cs" />
+    <Compile Include="LinearAlgebra\Solvers\IPreConditioner.cs" />
     <Compile Include="LinearAlgebra\Solvers\StopCriterium\IIterationStopCriterium.cs" />
     <Compile Include="LinearAlgebra\Double\SparseMatrix.cs" />
     <Compile Include="LinearAlgebra\Double\Vector.cs" />
@@ -318,7 +316,6 @@
     <Compile Include="LinearAlgebra\Single\Solvers\Preconditioners\Ilutp.cs" />
     <Compile Include="LinearAlgebra\Single\Solvers\Preconditioners\IlutpElementSorter.cs" />
     <Compile Include="LinearAlgebra\Single\Solvers\Preconditioners\IncompleteLU.cs" />
-    <Compile Include="LinearAlgebra\Single\Solvers\Preconditioners\IPreConditioner.cs" />
     <Compile Include="LinearAlgebra\Single\Solvers\Preconditioners\UnitPreconditioner.cs" />
     <Compile Include="LinearAlgebra\Single\Solvers\StopCriterium\DivergenceStopCriterium.cs" />
     <Compile Include="LinearAlgebra\Single\Solvers\StopCriterium\FailureStopCriterium.cs" />
diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/DiagonalTest.cs b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/DiagonalTest.cs
index 49d10aa8..56deb155 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/DiagonalTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/DiagonalTest.cs
@@ -27,6 +27,7 @@
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex;
 using MathNet.Numerics.LinearAlgebra.Complex.Solvers.Preconditioners;
+using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Preconditioners
@@ -48,7 +49,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
         /// Create preconditioner.
         /// </summary>
         /// <returns>New preconditioner instance.</returns>
-        internal override IPreConditioner CreatePreconditioner()
+        internal override IPreConditioner<Complex> CreatePreconditioner()
         {
             return new Diagonal();
         }
@@ -60,7 +61,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
         /// <param name="matrix">Source matrix.</param>
         /// <param name="vector">Initial vector.</param>
         /// <param name="result">Result vector.</param>
-        protected override void CheckResult(IPreConditioner preconditioner, SparseMatrix matrix, Vector<Complex> vector, Vector<Complex> result)
+        protected override void CheckResult(IPreConditioner<Complex> preconditioner, SparseMatrix matrix, Vector<Complex> vector, Vector<Complex> result)
         {
             Assert.AreEqual(typeof(Diagonal), preconditioner.GetType(), "#01");
 
diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/IlutpTest.cs b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/IlutpTest.cs
index dbe38c39..c242b192 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/IlutpTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/IlutpTest.cs
@@ -29,6 +29,7 @@ using System.Reflection;
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex;
 using MathNet.Numerics.LinearAlgebra.Complex.Solvers.Preconditioners;
+using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Preconditioners
@@ -158,7 +159,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
         /// Create preconditioner.
         /// </summary>
         /// <returns>New preconditioner instance.</returns>
-        internal override IPreConditioner CreatePreconditioner()
+        internal override IPreConditioner<Complex> CreatePreconditioner()
         {
             _pivotTolerance = 0;
             _dropTolerance = 0.0;
@@ -173,7 +174,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
         /// <param name="matrix">Source matrix.</param>
         /// <param name="vector">Initial vector.</param>
         /// <param name="result">Result vector.</param>
-        protected override void CheckResult(IPreConditioner preconditioner, SparseMatrix matrix, Vector<Complex> vector, Vector<Complex> result)
+        protected override void CheckResult(IPreConditioner<Complex> preconditioner, SparseMatrix matrix, Vector<Complex> vector, Vector<Complex> result)
         {
             Assert.AreEqual(typeof(Ilutp), preconditioner.GetType(), "#01");
 
diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/IncompleteLUTest.cs b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/IncompleteLUTest.cs
index 78ed4627..6208baa9 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/IncompleteLUTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/IncompleteLUTest.cs
@@ -29,6 +29,7 @@ using System.Reflection;
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex;
 using MathNet.Numerics.LinearAlgebra.Complex.Solvers.Preconditioners;
+using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Preconditioners
@@ -91,7 +92,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
         /// Create preconditioner.
         /// </summary>
         /// <returns>New preconditioner instance.</returns>
-        internal override IPreConditioner CreatePreconditioner()
+        internal override IPreConditioner<Complex> CreatePreconditioner()
         {
             return new IncompleteLU();
         }
@@ -103,7 +104,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
         /// <param name="matrix">Source matrix.</param>
         /// <param name="vector">Initial vector.</param>
         /// <param name="result">Result vector.</param>
-        protected override void CheckResult(IPreConditioner preconditioner, SparseMatrix matrix, Vector<Complex> vector, Vector<Complex> result)
+        protected override void CheckResult(IPreConditioner<Complex> preconditioner, SparseMatrix matrix, Vector<Complex> vector, Vector<Complex> result)
         {
             Assert.AreEqual(typeof(IncompleteLU), preconditioner.GetType(), "#01");
 
diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/PreConditionerTest.cs b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/PreConditionerTest.cs
index 5a6c43ca..de9b5ef0 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/PreConditionerTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/PreConditionerTest.cs
@@ -27,7 +27,7 @@
 using System;
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex;
-using MathNet.Numerics.LinearAlgebra.Complex.Solvers.Preconditioners;
+using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Preconditioners
@@ -85,7 +85,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
         /// Create preconditioner.
         /// </summary>
         /// <returns>New preconditioner instance.</returns>
-        internal abstract IPreConditioner CreatePreconditioner();
+        internal abstract IPreConditioner<Complex> CreatePreconditioner();
 
         /// <summary>
         /// Check the result.
@@ -94,7 +94,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
         /// <param name="matrix">Source matrix.</param>
         /// <param name="vector">Initial vector.</param>
         /// <param name="result">Result vector.</param>
-        protected abstract void CheckResult(IPreConditioner preconditioner, SparseMatrix matrix, Vector<Complex> vector, Vector<Complex> result);
+        protected abstract void CheckResult(IPreConditioner<Complex> preconditioner, SparseMatrix matrix, Vector<Complex> vector, Vector<Complex> result);
 
         /// <summary>
         /// Approximate with a unit matrix returning new vector.
diff --git a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/UnitPreconditionerTest.cs b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/UnitPreconditionerTest.cs
index 01d9c8cb..403c71b5 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/UnitPreconditionerTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex/Solvers/Preconditioners/UnitPreconditionerTest.cs
@@ -27,6 +27,7 @@
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex;
 using MathNet.Numerics.LinearAlgebra.Complex.Solvers.Preconditioners;
+using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Preconditioners
@@ -48,7 +49,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
         /// Create preconditioner.
         /// </summary>
         /// <returns>New preconditioner instance.</returns>
-        internal override IPreConditioner CreatePreconditioner()
+        internal override IPreConditioner<Complex> CreatePreconditioner()
         {
             return new UnitPreconditioner();
         }
@@ -60,7 +61,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex.Solvers.Precondi
         /// <param name="matrix">Source matrix.</param>
         /// <param name="vector">Initial vector.</param>
         /// <param name="result">Result vector.</param>
-        protected override void CheckResult(IPreConditioner preconditioner, SparseMatrix matrix, Vector<Complex> vector, Vector<Complex> result)
+        protected override void CheckResult(IPreConditioner<Complex> preconditioner, SparseMatrix matrix, Vector<Complex> vector, Vector<Complex> result)
         {
             Assert.AreEqual(typeof(UnitPreconditioner), preconditioner.GetType(), "#01");
 
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/DiagonalTest.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/DiagonalTest.cs
index 3ce34de1..bcf063a3 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/DiagonalTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/DiagonalTest.cs
@@ -27,6 +27,7 @@
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex32;
 using MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Preconditioners;
+using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Preconditioners
@@ -43,7 +44,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
         /// Create preconditioner.
         /// </summary>
         /// <returns>New preconditioner instance.</returns>
-        internal override IPreConditioner CreatePreconditioner()
+        internal override IPreConditioner<Complex32> CreatePreconditioner()
         {
             return new Diagonal();
         }
@@ -55,7 +56,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
         /// <param name="matrix">Source matrix.</param>
         /// <param name="vector">Initial vector.</param>
         /// <param name="result">Result vector.</param>
-        protected override void CheckResult(IPreConditioner preconditioner, SparseMatrix matrix, Vector<Complex32> vector, Vector<Complex32> result)
+        protected override void CheckResult(IPreConditioner<Complex32> preconditioner, SparseMatrix matrix, Vector<Complex32> vector, Vector<Complex32> result)
         {
             Assert.AreEqual(typeof(Diagonal), preconditioner.GetType(), "#01");
 
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/IlutpTest.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/IlutpTest.cs
index 519e9483..9d259fb1 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/IlutpTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/IlutpTest.cs
@@ -29,6 +29,7 @@ using System.Reflection;
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex32;
 using MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Preconditioners;
+using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Preconditioners
@@ -153,7 +154,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
         /// Create preconditioner.
         /// </summary>
         /// <returns>New preconditioner instance.</returns>
-        internal override IPreConditioner CreatePreconditioner()
+        internal override IPreConditioner<Complex32> CreatePreconditioner()
         {
             _pivotTolerance = 0;
             _dropTolerance = 0.0;
@@ -168,7 +169,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
         /// <param name="matrix">Source matrix.</param>
         /// <param name="vector">Initial vector.</param>
         /// <param name="result">Result vector.</param>
-        protected override void CheckResult(IPreConditioner preconditioner, SparseMatrix matrix, Vector<Complex32> vector, Vector<Complex32> result)
+        protected override void CheckResult(IPreConditioner<Complex32> preconditioner, SparseMatrix matrix, Vector<Complex32> vector, Vector<Complex32> result)
         {
             Assert.AreEqual(typeof(Ilutp), preconditioner.GetType(), "#01");
 
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/IncompleteLUTest.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/IncompleteLUTest.cs
index f5237774..7e55a6d6 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/IncompleteLUTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/IncompleteLUTest.cs
@@ -29,6 +29,7 @@ using System.Reflection;
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex32;
 using MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Preconditioners;
+using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Preconditioners
@@ -86,7 +87,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
         /// Create preconditioner.
         /// </summary>
         /// <returns>New preconditioner instance.</returns>
-        internal override IPreConditioner CreatePreconditioner()
+        internal override IPreConditioner<Complex32> CreatePreconditioner()
         {
             return new IncompleteLU();
         }
@@ -98,7 +99,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
         /// <param name="matrix">Source matrix.</param>
         /// <param name="vector">Initial vector.</param>
         /// <param name="result">Result vector.</param>
-        protected override void CheckResult(IPreConditioner preconditioner, SparseMatrix matrix, Vector<Complex32> vector, Vector<Complex32> result)
+        protected override void CheckResult(IPreConditioner<Complex32> preconditioner, SparseMatrix matrix, Vector<Complex32> vector, Vector<Complex32> result)
         {
             Assert.AreEqual(typeof(IncompleteLU), preconditioner.GetType(), "#01");
 
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/PreConditionerTest.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/PreConditionerTest.cs
index cc67be88..bb784fe4 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/PreConditionerTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/PreConditionerTest.cs
@@ -27,7 +27,7 @@
 using System;
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex32;
-using MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Preconditioners;
+using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Preconditioners
@@ -78,7 +78,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
         /// Create preconditioner.
         /// </summary>
         /// <returns>New preconditioner instance.</returns>
-        internal abstract IPreConditioner CreatePreconditioner();
+        internal abstract IPreConditioner<Complex32> CreatePreconditioner();
 
         /// <summary>
         /// Check the result.
@@ -87,7 +87,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
         /// <param name="matrix">Source matrix.</param>
         /// <param name="vector">Initial vector.</param>
         /// <param name="result">Result vector.</param>
-        protected abstract void CheckResult(IPreConditioner preconditioner, SparseMatrix matrix, Vector<Complex32> vector, Vector<Complex32> result);
+        protected abstract void CheckResult(IPreConditioner<Complex32> preconditioner, SparseMatrix matrix, Vector<Complex32> vector, Vector<Complex32> result);
 
         /// <summary>
         /// Approximate with a unit matrix returning new vector.
diff --git a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/UnitPreconditionerTest.cs b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/UnitPreconditionerTest.cs
index d9faf512..078a76d6 100644
--- a/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/UnitPreconditionerTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Complex32/Solvers/Preconditioners/UnitPreconditionerTest.cs
@@ -27,6 +27,7 @@
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Complex32;
 using MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Preconditioners;
+using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Preconditioners
@@ -43,7 +44,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
         /// Create preconditioner.
         /// </summary>
         /// <returns>New preconditioner instance.</returns>
-        internal override IPreConditioner CreatePreconditioner()
+        internal override IPreConditioner<Complex32> CreatePreconditioner()
         {
             return new UnitPreconditioner();
         }
@@ -55,7 +56,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Complex32.Solvers.Precon
         /// <param name="matrix">Source matrix.</param>
         /// <param name="vector">Initial vector.</param>
         /// <param name="result">Result vector.</param>
-        protected override void CheckResult(IPreConditioner preconditioner, SparseMatrix matrix, Vector<Complex32> vector, Vector<Complex32> result)
+        protected override void CheckResult(IPreConditioner<Complex32> preconditioner, SparseMatrix matrix, Vector<Complex32> vector, Vector<Complex32> result)
         {
             Assert.AreEqual(typeof(UnitPreconditioner), preconditioner.GetType(), "#01");
 
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/DiagonalTest.cs b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/DiagonalTest.cs
index 8c602716..50afc22f 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/DiagonalTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/DiagonalTest.cs
@@ -27,6 +27,7 @@
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Double;
 using MathNet.Numerics.LinearAlgebra.Double.Solvers.Preconditioners;
+using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Preconditioners
@@ -41,7 +42,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
         /// Create preconditioner.
         /// </summary>
         /// <returns>New preconditioner instance.</returns>
-        internal override IPreConditioner CreatePreconditioner()
+        internal override IPreConditioner<double> CreatePreconditioner()
         {
             return new Diagonal();
         }
@@ -53,7 +54,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
         /// <param name="matrix">Source matrix.</param>
         /// <param name="vector">Initial vector.</param>
         /// <param name="result">Result vector.</param>
-        protected override void CheckResult(IPreConditioner preconditioner, SparseMatrix matrix, Vector<double> vector, Vector<double> result)
+        protected override void CheckResult(IPreConditioner<double> preconditioner, SparseMatrix matrix, Vector<double> vector, Vector<double> result)
         {
             Assert.AreEqual(typeof(Diagonal), preconditioner.GetType(), "#01");
 
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/IlutpTest.cs b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/IlutpTest.cs
index 6cd1ac81..a639c92c 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/IlutpTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/IlutpTest.cs
@@ -29,6 +29,7 @@ using System.Reflection;
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Double;
 using MathNet.Numerics.LinearAlgebra.Double.Solvers.Preconditioners;
+using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Preconditioners
@@ -151,7 +152,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
         /// Create preconditioner.
         /// </summary>
         /// <returns>New preconditioner instance.</returns>
-        internal override IPreConditioner CreatePreconditioner()
+        internal override IPreConditioner<double> CreatePreconditioner()
         {
             _pivotTolerance = 0;
             _dropTolerance = 0.0;
@@ -166,7 +167,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
         /// <param name="matrix">Source matrix.</param>
         /// <param name="vector">Initial vector.</param>
         /// <param name="result">Result vector.</param>
-        protected override void CheckResult(IPreConditioner preconditioner, SparseMatrix matrix, Vector<double> vector, Vector<double> result)
+        protected override void CheckResult(IPreConditioner<double> preconditioner, SparseMatrix matrix, Vector<double> vector, Vector<double> result)
         {
             Assert.AreEqual(typeof(Ilutp), preconditioner.GetType(), "#01");
 
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/IncompleteLUTest.cs b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/IncompleteLUTest.cs
index 95eb4cd8..3bc0a58a 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/IncompleteLUTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/IncompleteLUTest.cs
@@ -29,6 +29,7 @@ using System.Reflection;
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Double;
 using MathNet.Numerics.LinearAlgebra.Double.Solvers.Preconditioners;
+using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Preconditioners
@@ -84,7 +85,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
         /// Create preconditioner.
         /// </summary>
         /// <returns>New preconditioner instance.</returns>
-        internal override IPreConditioner CreatePreconditioner()
+        internal override IPreConditioner<double> CreatePreconditioner()
         {
             return new IncompleteLU();
         }
@@ -96,7 +97,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
         /// <param name="matrix">Source matrix.</param>
         /// <param name="vector">Initial vector.</param>
         /// <param name="result">Result vector.</param>
-        protected override void CheckResult(IPreConditioner preconditioner, SparseMatrix matrix, Vector<double> vector, Vector<double> result)
+        protected override void CheckResult(IPreConditioner<double> preconditioner, SparseMatrix matrix, Vector<double> vector, Vector<double> result)
         {
             Assert.AreEqual(typeof(IncompleteLU), preconditioner.GetType(), "#01");
 
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/PreConditionerTest.cs b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/PreConditionerTest.cs
index 972cb34d..d139a4f6 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/PreConditionerTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/PreConditionerTest.cs
@@ -27,7 +27,7 @@
 using System;
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Double;
-using MathNet.Numerics.LinearAlgebra.Double.Solvers.Preconditioners;
+using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Preconditioners
@@ -76,7 +76,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
         /// Create preconditioner.
         /// </summary>
         /// <returns>New preconditioner instance.</returns>
-        internal abstract IPreConditioner CreatePreconditioner();
+        internal abstract IPreConditioner<double> CreatePreconditioner();
 
         /// <summary>
         /// Check the result.
@@ -85,7 +85,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
         /// <param name="matrix">Source matrix.</param>
         /// <param name="vector">Initial vector.</param>
         /// <param name="result">Result vector.</param>
-        protected abstract void CheckResult(IPreConditioner preconditioner, SparseMatrix matrix, Vector<double> vector, Vector<double> result);
+        protected abstract void CheckResult(IPreConditioner<double> preconditioner, SparseMatrix matrix, Vector<double> vector, Vector<double> result);
 
         /// <summary>
         /// Approximate with a unit matrix returning new vector.
diff --git a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/UnitPreconditionerTest.cs b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/UnitPreconditionerTest.cs
index f757dd59..88963b1f 100644
--- a/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/UnitPreconditionerTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Double/Solvers/Preconditioners/UnitPreconditionerTest.cs
@@ -27,6 +27,7 @@
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Double;
 using MathNet.Numerics.LinearAlgebra.Double.Solvers.Preconditioners;
+using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Preconditioners
@@ -41,7 +42,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
         /// Create preconditioner.
         /// </summary>
         /// <returns>New preconditioner instance.</returns>
-        internal override IPreConditioner CreatePreconditioner()
+        internal override IPreConditioner<double> CreatePreconditioner()
         {
             return new UnitPreconditioner();
         }
@@ -53,7 +54,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Double.Solvers.Precondit
         /// <param name="matrix">Source matrix.</param>
         /// <param name="vector">Initial vector.</param>
         /// <param name="result">Result vector.</param>
-        protected override void CheckResult(IPreConditioner preconditioner, SparseMatrix matrix, Vector<double> vector, Vector<double> result)
+        protected override void CheckResult(IPreConditioner<double> preconditioner, SparseMatrix matrix, Vector<double> vector, Vector<double> result)
         {
             Assert.AreEqual(typeof(UnitPreconditioner), preconditioner.GetType(), "#01");
 
diff --git a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/DiagonalTest.cs b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/DiagonalTest.cs
index 6781f04e..e56bf72e 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/DiagonalTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/DiagonalTest.cs
@@ -27,6 +27,7 @@
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Single;
 using MathNet.Numerics.LinearAlgebra.Single.Solvers.Preconditioners;
+using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Preconditioners
@@ -41,7 +42,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
         /// Create preconditioner.
         /// </summary>
         /// <returns>New preconditioner instance.</returns>
-        internal override IPreConditioner CreatePreconditioner()
+        internal override IPreConditioner<float> CreatePreconditioner()
         {
             return new Diagonal();
         }
@@ -53,7 +54,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
         /// <param name="matrix">Source matrix.</param>
         /// <param name="vector">Initial vector.</param>
         /// <param name="result">Result vector.</param>
-        protected override void CheckResult(IPreConditioner preconditioner, SparseMatrix matrix, Vector<float> vector, Vector<float> result)
+        protected override void CheckResult(IPreConditioner<float> preconditioner, SparseMatrix matrix, Vector<float> vector, Vector<float> result)
         {
             Assert.AreEqual(typeof(Diagonal), preconditioner.GetType(), "#01");
 
diff --git a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/IlutpTest.cs b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/IlutpTest.cs
index 4c7b0ed3..6d33e93d 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/IlutpTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/IlutpTest.cs
@@ -29,6 +29,7 @@ using System.Reflection;
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Single;
 using MathNet.Numerics.LinearAlgebra.Single.Solvers.Preconditioners;
+using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Preconditioners
@@ -151,7 +152,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
         /// Create preconditioner.
         /// </summary>
         /// <returns>New preconditioner instance.</returns>
-        internal override IPreConditioner CreatePreconditioner()
+        internal override IPreConditioner<float> CreatePreconditioner()
         {
             _pivotTolerance = 0;
             _dropTolerance = 0.0;
@@ -166,7 +167,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
         /// <param name="matrix">Source matrix.</param>
         /// <param name="vector">Initial vector.</param>
         /// <param name="result">Result vector.</param>
-        protected override void CheckResult(IPreConditioner preconditioner, SparseMatrix matrix, Vector<float> vector, Vector<float> result)
+        protected override void CheckResult(IPreConditioner<float> preconditioner, SparseMatrix matrix, Vector<float> vector, Vector<float> result)
         {
             Assert.AreEqual(typeof(Ilutp), preconditioner.GetType(), "#01");
 
diff --git a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/IncompleteLUTest.cs b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/IncompleteLUTest.cs
index 5bc2bab3..4edc72bc 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/IncompleteLUTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/IncompleteLUTest.cs
@@ -29,6 +29,7 @@ using System.Reflection;
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Single;
 using MathNet.Numerics.LinearAlgebra.Single.Solvers.Preconditioners;
+using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Preconditioners
@@ -84,7 +85,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
         /// Create preconditioner.
         /// </summary>
         /// <returns>New preconditioner instance.</returns>
-        internal override IPreConditioner CreatePreconditioner()
+        internal override IPreConditioner<float> CreatePreconditioner()
         {
             return new IncompleteLU();
         }
@@ -96,7 +97,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
         /// <param name="matrix">Source matrix.</param>
         /// <param name="vector">Initial vector.</param>
         /// <param name="result">Result vector.</param>
-        protected override void CheckResult(IPreConditioner preconditioner, SparseMatrix matrix, Vector<float> vector, Vector<float> result)
+        protected override void CheckResult(IPreConditioner<float> preconditioner, SparseMatrix matrix, Vector<float> vector, Vector<float> result)
         {
             Assert.AreEqual(typeof(IncompleteLU), preconditioner.GetType(), "#01");
 
diff --git a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/PreConditionerTest.cs b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/PreConditionerTest.cs
index 4a2d89c0..a19019f9 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/PreConditionerTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/PreConditionerTest.cs
@@ -27,7 +27,7 @@
 using System;
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Single;
-using MathNet.Numerics.LinearAlgebra.Single.Solvers.Preconditioners;
+using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Preconditioners
@@ -78,7 +78,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
         /// Create preconditioner.
         /// </summary>
         /// <returns>New preconditioner instance.</returns>
-        internal abstract IPreConditioner CreatePreconditioner();
+        internal abstract IPreConditioner<float> CreatePreconditioner();
 
         /// <summary>
         /// Check the result.
@@ -87,7 +87,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
         /// <param name="matrix">Source matrix.</param>
         /// <param name="vector">Initial vector.</param>
         /// <param name="result">Result vector.</param>
-        protected abstract void CheckResult(IPreConditioner preconditioner, SparseMatrix matrix, Vector<float> vector, Vector<float> result);
+        protected abstract void CheckResult(IPreConditioner<float> preconditioner, SparseMatrix matrix, Vector<float> vector, Vector<float> result);
 
         /// <summary>
         /// Approximate with a unit matrix returning new vector.
diff --git a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/UnitPreconditionerTest.cs b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/UnitPreconditionerTest.cs
index d401f0fc..d84793c4 100644
--- a/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/UnitPreconditionerTest.cs
+++ b/src/UnitTests/LinearAlgebraTests/Single/Solvers/Preconditioners/UnitPreconditionerTest.cs
@@ -27,6 +27,7 @@
 using MathNet.Numerics.LinearAlgebra;
 using MathNet.Numerics.LinearAlgebra.Single;
 using MathNet.Numerics.LinearAlgebra.Single.Solvers.Preconditioners;
+using MathNet.Numerics.LinearAlgebra.Solvers;
 using NUnit.Framework;
 
 namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Preconditioners
@@ -41,7 +42,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
         /// Create preconditioner.
         /// </summary>
         /// <returns>New preconditioner instance.</returns>
-        internal override IPreConditioner CreatePreconditioner()
+        internal override IPreConditioner<float> CreatePreconditioner()
         {
             return new UnitPreconditioner();
         }
@@ -53,7 +54,7 @@ namespace MathNet.Numerics.UnitTests.LinearAlgebraTests.Single.Solvers.Precondit
         /// <param name="matrix">Source matrix.</param>
         /// <param name="vector">Initial vector.</param>
         /// <param name="result">Result vector.</param>
-        protected override void CheckResult(IPreConditioner preconditioner, SparseMatrix matrix, Vector<float> vector, Vector<float> result)
+        protected override void CheckResult(IPreConditioner<float> preconditioner, SparseMatrix matrix, Vector<float> vector, Vector<float> result)
         {
             Assert.AreEqual(typeof(UnitPreconditioner), preconditioner.GetType(), "#01");