LA: fix inline doc links to now-generic types

src/Examples/LinearAlgebra/IterativeSolvers/CompositeSolverExample.cs

@@ -175,7 +175,7 @@ namespace Examples.LinearAlgebra.IterativeSolversExamples
         /// Creates a fully functional iterative solver with the default settings
         /// given by this setup.
         /// </summary>
-        /// <returns>A new <see cref="IIterativeSolver"/>.</returns>
+        /// <returns>A new <see cref="IIterativeSolver{T}"/>.</returns>
         public IIterativeSolver<double> CreateNew()
         {
             return new BiCgStab();

src/Numerics/LinearAlgebra/Complex/Solvers/Iterative/BiCgStab.cs

@@ -101,7 +101,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// Initializes a new instance of the <see cref="BiCgStab"/> class.
         /// </summary>
         /// <remarks>
-        /// When using this constructor the solver will use the <see cref="IIterator"/> with
+        /// When using this constructor the solver will use the <see cref="IIterator{T}"/> with
         /// the standard settings and a default preconditioner.
         /// </remarks>
         public BiCgStab()
@@ -117,17 +117,17 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// When using this constructor the solver will use a default preconditioner.
         /// </para>
         /// <para>
-        /// The main advantages of using a user defined <see cref="IIterator"/> are:
+        /// The main advantages of using a user defined <see cref="IIterator{T}"/> are:
         /// <list type="number">
         /// <item>It is possible to set the desired convergence limits.</item>
         /// <item>
         /// It is possible to check the reason for which the solver finished 
-        /// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
+        /// the iterative procedure by calling the <see cref="IIterator{T}.Status"/> property.
         /// </item>
         /// </list>
         /// </para>
         /// </remarks>
-        /// <param name="iterator">The <see cref="IIterator"/> that will be used to monitor the iterative process. </param>
+        /// <param name="iterator">The <see cref="IIterator{T}"/> that will be used to monitor the iterative process. </param>
         public BiCgStab(IIterator<Complex> iterator)
             : this(null, iterator)
         {
@@ -137,7 +137,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// Initializes a new instance of the <see cref="BiCgStab"/> class.
         /// </summary>
         /// <remarks>
-        /// When using this constructor the solver will use the <see cref="IIterator"/> with
+        /// When using this constructor the solver will use the <see cref="IIterator{T}"/> with
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
@@ -151,18 +151,18 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// </summary>
         /// <remarks>
         /// <para>
-        /// The main advantages of using a user defined <see cref="IIterator"/> are:
+        /// The main advantages of using a user defined <see cref="IIterator{T}"/> are:
         /// <list type="number">
         /// <item>It is possible to set the desired convergence limits.</item>
         /// <item>
         /// It is possible to check the reason for which the solver finished 
-        /// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
+        /// the iterative procedure by calling the <see cref="IIterator{T}.Status"/> property.
         /// </item>
         /// </list>
         /// </para>
         /// </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"/> that will be used to monitor the iterative process. </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)
         {
             _iterator = iterator;
@@ -179,7 +179,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         }
 
         /// <summary>
-        /// Sets the <see cref="IIterator"/> that will be used to track the iterative process.
+        /// Sets the <see cref="IIterator{T}"/> that will be used to track the iterative process.
         /// </summary>
         /// <param name="iterator">The iterator.</param>
         public void SetIterator(IIterator<Complex> iterator)

src/Numerics/LinearAlgebra/Complex/Solvers/Iterative/CompositeSolver.cs

@@ -114,7 +114,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         #region Solver information loading methods
 
         /// <summary>
-        /// Loads all the available <see cref="IIterativeSolverSetup"/> objects from the MathNet.Numerics assembly.
+        /// Loads all the available <see cref="IIterativeSolverSetup{T}"/> objects from the MathNet.Numerics assembly.
         /// </summary>
         public static void LoadSolverInformation()
         {
@@ -122,9 +122,9 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         }
 
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the MathNet.Numerics assembly.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the MathNet.Numerics assembly.
         /// </summary>
-        /// <param name="typesToExclude">The <see cref="IIterativeSolver"/> types that should not be loaded.</param>
+        /// <param name="typesToExclude">The <see cref="IIterativeSolver{T}"/> types that should not be loaded.</param>
         public static void LoadSolverInformation(Type[] typesToExclude)
         {
             LoadSolverInformationFromAssembly(Assembly.GetExecutingAssembly(), typesToExclude);
@@ -132,7 +132,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
 
 #if !PORTABLE
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the assembly specified by the file location.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the assembly specified by the file location.
         /// </summary>
         /// <param name="assemblyLocation">The fully qualified path to the assembly.</param>
         public static void LoadSolverInformationFromAssembly(string assemblyLocation)
@@ -141,10 +141,10 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         }
 
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the assembly specified by the file location.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the assembly specified by the file location.
         /// </summary>
         /// <param name="assemblyLocation">The fully qualified path to the assembly.</param>
-        /// <param name="typesToExclude">The <see cref="IIterativeSolver"/> types that should not be loaded. </param>
+        /// <param name="typesToExclude">The <see cref="IIterativeSolver{T}"/> types that should not be loaded. </param>
         public static void LoadSolverInformationFromAssembly(string assemblyLocation, params Type[] typesToExclude)
         {
             if (assemblyLocation == null)
@@ -180,7 +180,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
 #endif
 
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the assembly specified by the assembly name.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the assembly specified by the assembly name.
         /// </summary>
         /// <param name="assemblyName">The <see cref="AssemblyName"/> of the assembly that should be searched for setup objects. </param>
         public static void LoadSolverInformationFromAssembly(AssemblyName assemblyName)
@@ -189,10 +189,10 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         }
 
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the assembly specified by the assembly name.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the assembly specified by the assembly name.
         /// </summary>
         /// <param name="assemblyName">The <see cref="AssemblyName"/> of the assembly that should be searched for setup objects.</param>
-        /// <param name="typesToExclude">The <see cref="IIterativeSolver"/> types that should not be loaded.</param>
+        /// <param name="typesToExclude">The <see cref="IIterativeSolver{T}"/> types that should not be loaded.</param>
         public static void LoadSolverInformationFromAssembly(AssemblyName assemblyName, params Type[] typesToExclude)
         {
             if (assemblyName == null)
@@ -212,7 +212,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         }
 
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the assembly specified by the type.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the assembly specified by the type.
         /// </summary>
         /// <param name="typeInAssembly">The type in the assembly which should be searched for setup objects.</param>
         public static void LoadSolverInformationFromAssembly(Type typeInAssembly)
@@ -221,10 +221,10 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         }
 
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the assembly specified by the type.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the assembly specified by the type.
         /// </summary>
         /// <param name="typeInAssembly">The type in the assembly which should be searched for setup objects.</param>
-        /// <param name="typesToExclude">The <see cref="IIterativeSolver"/> types that should not be loaded.</param>
+        /// <param name="typesToExclude">The <see cref="IIterativeSolver{T}"/> types that should not be loaded.</param>
         public static void LoadSolverInformationFromAssembly(Type typeInAssembly, params Type[] typesToExclude)
         {
             if (typeInAssembly == null)
@@ -236,7 +236,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         }
 
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the specified assembly.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the specified assembly.
         /// </summary>
         /// <param name="assembly">The assembly which will be searched for setup objects.</param>
         public static void LoadSolverInformationFromAssembly(Assembly assembly)
@@ -245,10 +245,10 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         }
 
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the specified assembly.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the specified assembly.
         /// </summary>
         /// <param name="assembly">The assembly which will be searched for setup objects.</param>
-        /// <param name="typesToExclude">The <see cref="IIterativeSolver"/> types that should not be loaded.</param>
+        /// <param name="typesToExclude">The <see cref="IIterativeSolver{T}"/> types that should not be loaded.</param>
         public static void LoadSolverInformationFromAssembly(Assembly assembly, params Type[] typesToExclude)
         {
             if (assembly == null)

src/Numerics/LinearAlgebra/Complex/Solvers/Iterative/GpBiCg.cs

@@ -111,7 +111,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// Initializes a new instance of the <see cref="GpBiCg"/> class.
         /// </summary>
         /// <remarks>
-        /// When using this constructor the solver will use the <see cref="IIterator"/> with
+        /// When using this constructor the solver will use the <see cref="IIterator{T}"/> with
         /// the standard settings and a default preconditioner.
         /// </remarks>
         public GpBiCg()
@@ -127,17 +127,17 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// When using this constructor the solver will use a default preconditioner.
         /// </para>
         /// <para>
-        /// The main advantages of using a user defined <see cref="IIterator"/> are:
+        /// The main advantages of using a user defined <see cref="IIterator{T}"/> are:
         /// <list type="number">
         /// <item>It is possible to set the desired convergence limits.</item>
         /// <item>
         /// It is possible to check the reason for which the solver finished 
-        /// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
+        /// the iterative procedure by calling the <see cref="IIterator{T}.Status"/> property.
         /// </item>
         /// </list>
         /// </para>
         /// </remarks>
-        /// <param name="iterator">The <see cref="IIterator"/> that will be used to monitor the iterative process.</param>
+        /// <param name="iterator">The <see cref="IIterator{T}"/> that will be used to monitor the iterative process.</param>
         public GpBiCg(IIterator<Complex> iterator)
             : this(null, iterator)
         {
@@ -147,7 +147,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// Initializes a new instance of the <see cref="GpBiCg"/> class.
         /// </summary>
         /// <remarks>
-        /// When using this constructor the solver will use the <see cref="IIterator"/> with
+        /// When using this constructor the solver will use the <see cref="IIterator{T}"/> with
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
@@ -161,18 +161,18 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// </summary>
         /// <remarks>
         /// <para>
-        /// The main advantages of using a user defined <see cref="IIterator"/> are:
+        /// The main advantages of using a user defined <see cref="IIterator{T}"/> are:
         /// <list type="number">
         /// <item>It is possible to set the desired convergence limits.</item>
         /// <item>
         /// It is possible to check the reason for which the solver finished 
-        /// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
+        /// the iterative procedure by calling the <see cref="IIterator{T}.Status"/> property.
         /// </item>
         /// </list>
         /// </para>
         /// </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"/> that will be used to monitor the iterative process.</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)
         {
             _iterator = iterator;
@@ -227,7 +227,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         }
 
         /// <summary>
-        /// Sets the <see cref="IIterator"/> that will be used to track the iterative process.
+        /// Sets the <see cref="IIterator{T}"/> that will be used to track the iterative process.
         /// </summary>
         /// <param name="iterator">The iterator.</param>
         public void SetIterator(IIterator<Complex> iterator)

src/Numerics/LinearAlgebra/Complex/Solvers/Iterative/MlkBiCgStab.cs

@@ -114,7 +114,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// Initializes a new instance of the <see cref="MlkBiCgStab"/> class.
         /// </summary>
         /// <remarks>
-        /// When using this constructor the solver will use the <see cref="IIterator"/> with
+        /// When using this constructor the solver will use the <see cref="IIterator{T}"/> with
         /// the standard settings and a default preconditioner.
         /// </remarks>
         public MlkBiCgStab()
@@ -130,17 +130,17 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// When using this constructor the solver will use a default preconditioner.
         /// </para>
         /// <para>
-        /// The main advantages of using a user defined <see cref="IIterator"/> are:
+        /// The main advantages of using a user defined <see cref="IIterator{T}"/> are:
         /// <list type="number">
         /// <item>It is possible to set the desired convergence limits.</item>
         /// <item>
         /// It is possible to check the reason for which the solver finished 
-        /// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
+        /// the iterative procedure by calling the <see cref="IIterator{T}.Status"/> property.
         /// </item>
         /// </list>
         /// </para>
         /// </remarks>
-        /// <param name="iterator">The <see cref="IIterator"/> that will be used to monitor the iterative process.</param>
+        /// <param name="iterator">The <see cref="IIterator{T}"/> that will be used to monitor the iterative process.</param>
         public MlkBiCgStab(IIterator<Complex> iterator)
             : this(null, iterator)
         {
@@ -150,7 +150,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// Initializes a new instance of the <see cref="MlkBiCgStab"/> class.
         /// </summary>
         /// <remarks>
-        /// When using this constructor the solver will use the <see cref="IIterator"/> with
+        /// When using this constructor the solver will use the <see cref="IIterator{T}"/> with
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
@@ -164,18 +164,18 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// </summary>
         /// <remarks>
         /// <para>
-        /// The main advantages of using a user defined <see cref="IIterator"/> are:
+        /// The main advantages of using a user defined <see cref="IIterator{T}"/> are:
         /// <list type="number">
         /// <item>It is possible to set the desired convergence limits.</item>
         /// <item>
         /// It is possible to check the reason for which the solver finished 
-        /// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
+        /// the iterative procedure by calling the <see cref="IIterator{T}.Status"/> property.
         /// </item>
         /// </list>
         /// </para>
         /// </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"/> that will be used to monitor the iterative process.</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)
         {
             _iterator = iterator;
@@ -224,7 +224,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         }
 
         /// <summary>
-        /// Sets the <see cref="IIterator"/> that will be used to track the iterative process.
+        /// Sets the <see cref="IIterator{T}"/> that will be used to track the iterative process.
         /// </summary>
         /// <param name="iterator">The iterator.</param>
         public void SetIterator(IIterator<Complex> iterator)

src/Numerics/LinearAlgebra/Complex/Solvers/Iterative/TFQMR.cs

@@ -89,7 +89,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// Initializes a new instance of the <see cref="TFQMR"/> class.
         /// </summary>
         /// <remarks>
-        /// When using this constructor the solver will use the <see cref="IIterator"/> with
+        /// When using this constructor the solver will use the <see cref="IIterator{T}"/> with
         /// the standard settings and a default preconditioner.
         /// </remarks>
         public TFQMR()
@@ -105,17 +105,17 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// When using this constructor the solver will use a default preconditioner.
         /// </para>
         /// <para>
-        /// The main advantages of using a user defined <see cref="IIterator"/> are:
+        /// The main advantages of using a user defined <see cref="IIterator{T}"/> are:
         /// <list type="number">
         /// <item>It is possible to set the desired convergence limits.</item>
         /// <item>
         /// It is possible to check the reason for which the solver finished 
-        /// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
+        /// the iterative procedure by calling the <see cref="IIterator{T}.Status"/> property.
         /// </item>
         /// </list>
         /// </para>
         /// </remarks>
-        /// <param name="iterator">The <see cref="IIterator"/> that will be used to monitor the iterative process.</param>
+        /// <param name="iterator">The <see cref="IIterator{T}"/> that will be used to monitor the iterative process.</param>
         public TFQMR(IIterator<Complex> iterator)
             : this(null, iterator)
         {
@@ -125,7 +125,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// Initializes a new instance of the <see cref="TFQMR"/> class.
         /// </summary>
         /// <remarks>
-        /// When using this constructor the solver will use the <see cref="IIterator"/> with
+        /// When using this constructor the solver will use the <see cref="IIterator{T}"/> with
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
@@ -139,18 +139,18 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         /// </summary>
         /// <remarks>
         /// <para>
-        /// The main advantages of using a user defined <see cref="IIterator"/> are:
+        /// The main advantages of using a user defined <see cref="IIterator{T}"/> are:
         /// <list type="number">
         /// <item>It is possible to set the desired convergence limits.</item>
         /// <item>
         /// It is possible to check the reason for which the solver finished 
-        /// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
+        /// the iterative procedure by calling the <see cref="IIterator{T}.Status"/> property.
         /// </item>
         /// </list>
         /// </para>
         /// </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"/> that will be used to monitor the iterative process.</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)
         {
             _iterator = iterator;
@@ -167,7 +167,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Iterative
         }
 
         /// <summary>
-        /// Sets the <see cref="IIterator"/> that will be used to track the iterative process.
+        /// Sets the <see cref="IIterator{T}"/> that will be used to track the iterative process.
         /// </summary>
         /// <param name="iterator">The iterator.</param>
         public void SetIterator(IIterator<Complex> iterator)

src/Numerics/LinearAlgebra/Complex/Solvers/Iterator.cs

@@ -59,7 +59,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers
         /// <summary>
         /// Creates a default iterator with all the <see cref="IIterationStopCriterium{T}"/> objects.
         /// </summary>
-        /// <returns>A new <see cref="IIterator"/> object.</returns>
+        /// <returns>A new <see cref="IIterator{T}"/> object.</returns>
         public static IIterator<Complex> CreateDefault()
         {
             var iterator = new Iterator();
@@ -117,7 +117,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers
         }
 
         /// <summary>
-        /// Adds an <see cref="IIterationStopCriterium"/> to the internal collection of stop-criteria. Only a 
+        /// Adds an <see cref="IIterationStopCriterium{T}"/> to the internal collection of stop-criteria. Only a 
         /// single stop criterium of each type can be stored.
         /// </summary>
         /// <param name="stopCriterium">The stop criterium to add.</param>
@@ -143,7 +143,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers
         }
 
         /// <summary>
-        /// Removes the <see cref="IIterationStopCriterium"/> from the internal collection.
+        /// Removes the <see cref="IIterationStopCriterium{T}"/> from the internal collection.
         /// </summary>
         /// <param name="stopCriterium">The stop criterium that must be removed.</param>
         public void Remove(IIterationStopCriterium<Complex> stopCriterium)
@@ -163,10 +163,10 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers
         }
 
         /// <summary>
-        /// Indicates if the specific stop criterium is stored by the <see cref="IIterator"/>.
+        /// Indicates if the specific stop criterium is stored by the <see cref="IIterator{T}"/>.
         /// </summary>
         /// <param name="stopCriterium">The stop criterium.</param>
-        /// <returns><c>true</c> if the <see cref="IIterator"/> contains the stop criterium; otherwise <c>false</c>.</returns>
+        /// <returns><c>true</c> if the <see cref="IIterator{T}"/> contains the stop criterium; otherwise <c>false</c>.</returns>
         public bool Contains(IIterationStopCriterium<Complex> stopCriterium)
         {
             return stopCriterium != null && _stopCriterias.ContainsKey(stopCriterium.GetType());
@@ -293,7 +293,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers
         }
 
         /// <summary>
-        /// Resets the <see cref="IIterator"/> to the pre-calculation state.
+        /// Resets the <see cref="IIterator{T}"/> to the pre-calculation state.
         /// </summary>
         public void ResetToPrecalculationState()
         {

src/Numerics/LinearAlgebra/Complex/Solvers/Preconditioners/UnitPreconditioner.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;
@@ -41,7 +43,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.Preconditioners
 
     /// <summary>
     /// A unit preconditioner. This preconditioner does not actually do anything
-    /// it is only used when running an <see cref="IIterativeSolver"/> without
+    /// it is only used when running an <see cref="IIterativeSolver{T}"/> without
     /// a preconditioner.
     /// </summary>
     internal sealed class UnitPreconditioner : IPreConditioner

src/Numerics/LinearAlgebra/Complex/Solvers/StopCriterium/DivergenceStopCriterium.cs

@@ -213,7 +213,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium
 
         /// <summary>
         /// Determines the status of the iterative calculation based on the stop criteria stored
-        /// by the current <see cref="IIterationStopCriterium"/>. Result is set into <c>Status</c> field.
+        /// by the current <see cref="IIterationStopCriterium{T}"/>. Result is set into <c>Status</c> field.
         /// </summary>
         /// <param name="iterationNumber">The number of iterations that have passed so far.</param>
         /// <param name="solutionVector">The vector containing the current solution values.</param>
@@ -353,7 +353,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium
         }
 
         /// <summary>
-        /// Resets the <see cref="IIterationStopCriterium"/> to the pre-calculation state.
+        /// Resets the <see cref="IIterationStopCriterium{T}"/> to the pre-calculation state.
         /// </summary>
         public void ResetToPrecalculationState()
         {
@@ -364,7 +364,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium
 
         /// <summary>
         /// Gets the <see cref="StopLevel"/> which indicates what sort of stop criterium this
-        /// <see cref="IIterationStopCriterium"/> monitors.
+        /// <see cref="IIterationStopCriterium{T}"/> monitors.
         /// </summary>
         /// <value>Returns <see cref="LinearAlgebra.Solvers.StopCriterium.StopLevel.Divergence"/>.</value>
         public StopLevel StopLevel

src/Numerics/LinearAlgebra/Complex/Solvers/StopCriterium/FailureStopCriterium.cs

@@ -44,7 +44,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium
 #endif
 
     /// <summary>
-    /// Defines an <see cref="IIterationStopCriterium"/> that monitors residuals for NaN's.
+    /// Defines an <see cref="IIterationStopCriterium{T}"/> that monitors residuals for NaN's.
     /// </summary>
     public sealed class FailureStopCriterium : IIterationStopCriterium<Complex>
     {
@@ -71,7 +71,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium
 
         /// <summary>
         /// Determines the status of the iterative calculation based on the stop criteria stored
-        /// by the current <see cref="IIterationStopCriterium"/>. Result is set into <c>Status</c> field.
+        /// by the current <see cref="IIterationStopCriterium{T}"/>. Result is set into <c>Status</c> field.
         /// </summary>
         /// <param name="iterationNumber">The number of iterations that have passed so far.</param>
         /// <param name="solutionVector">The vector containing the current solution values.</param>
@@ -162,7 +162,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium
         }
 
         /// <summary>
-        /// Resets the <see cref="IIterationStopCriterium"/> to the pre-calculation state.
+        /// Resets the <see cref="IIterationStopCriterium{T}"/> to the pre-calculation state.
         /// </summary>
         public void ResetToPrecalculationState()
         {
@@ -172,7 +172,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium
 
         /// <summary>
         /// Gets the <see cref="StopLevel"/>which indicates what sort of stop criterium this
-        /// <see cref="IIterationStopCriterium"/> monitors.
+        /// <see cref="IIterationStopCriterium{T}"/> monitors.
         /// </summary>
         /// <value>Returns <see cref="CalculationFailure"/>.</value>
         public StopLevel StopLevel

src/Numerics/LinearAlgebra/Complex/Solvers/StopCriterium/ResidualStopCriterium.cs

@@ -44,7 +44,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium
 #endif
 
     /// <summary>
-    /// Defines an <see cref="IIterationStopCriterium"/> that monitors residuals as stop criterium.
+    /// Defines an <see cref="IIterationStopCriterium{T}"/> that monitors residuals as stop criterium.
     /// </summary>
     public sealed class ResidualStopCriterium : IIterationStopCriterium<Complex>
     {
@@ -218,7 +218,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium
 
         /// <summary>
         /// Determines the status of the iterative calculation based on the stop criteria stored
-        /// by the current <see cref="IIterationStopCriterium"/>. Result is set into <c>Status</c> field.
+        /// by the current <see cref="IIterationStopCriterium{T}"/>. Result is set into <c>Status</c> field.
         /// </summary>
         /// <param name="iterationNumber">The number of iterations that have passed so far.</param>
         /// <param name="solutionVector">The vector containing the current solution values.</param>
@@ -369,7 +369,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium
         }
 
         /// <summary>
-        /// Resets the <see cref="IIterationStopCriterium"/> to the pre-calculation state.
+        /// Resets the <see cref="IIterationStopCriterium{T}"/> to the pre-calculation state.
         /// </summary>
         public void ResetToPrecalculationState()
         {
@@ -380,7 +380,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex.Solvers.StopCriterium
 
         /// <summary>
         /// Gets the <see cref="StopLevel"/> which indicates what sort of stop criterium this
-        /// <see cref="IIterationStopCriterium"/> monitors.
+        /// <see cref="IIterationStopCriterium{T}"/> monitors.
         /// </summary>
         /// <value>Returns <see cref="StopLevel"/>.</value>
         public StopLevel StopLevel

src/Numerics/LinearAlgebra/Complex32/Solvers/Iterative/BiCgStab.cs

@@ -95,7 +95,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// Initializes a new instance of the <see cref="BiCgStab"/> class.
         /// </summary>
         /// <remarks>
-        /// When using this constructor the solver will use the <see cref="IIterator"/> with
+        /// When using this constructor the solver will use the <see cref="IIterator{T}"/> with
         /// the standard settings and a default preconditioner.
         /// </remarks>
         public BiCgStab()
@@ -111,17 +111,17 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// When using this constructor the solver will use a default preconditioner.
         /// </para>
         /// <para>
-        /// The main advantages of using a user defined <see cref="IIterator"/> are:
+        /// The main advantages of using a user defined <see cref="IIterator{T}"/> are:
         /// <list type="number">
         /// <item>It is possible to set the desired convergence limits.</item>
         /// <item>
         /// It is possible to check the reason for which the solver finished 
-        /// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
+        /// the iterative procedure by calling the <see cref="IIterator{T}.Status"/> property.
         /// </item>
         /// </list>
         /// </para>
         /// </remarks>
-        /// <param name="iterator">The <see cref="IIterator"/> that will be used to monitor the iterative process. </param>
+        /// <param name="iterator">The <see cref="IIterator{T}"/> that will be used to monitor the iterative process. </param>
         public BiCgStab(IIterator<Complex32> iterator)
             : this(null, iterator)
         {
@@ -131,7 +131,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// Initializes a new instance of the <see cref="BiCgStab"/> class.
         /// </summary>
         /// <remarks>
-        /// When using this constructor the solver will use the <see cref="IIterator"/> with
+        /// When using this constructor the solver will use the <see cref="IIterator{T}"/> with
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
@@ -145,18 +145,18 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// </summary>
         /// <remarks>
         /// <para>
-        /// The main advantages of using a user defined <see cref="IIterator"/> are:
+        /// The main advantages of using a user defined <see cref="IIterator{T}"/> are:
         /// <list type="number">
         /// <item>It is possible to set the desired convergence limits.</item>
         /// <item>
         /// It is possible to check the reason for which the solver finished 
-        /// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
+        /// the iterative procedure by calling the <see cref="IIterator{T}.Status"/> property.
         /// </item>
         /// </list>
         /// </para>
         /// </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"/> that will be used to monitor the iterative process. </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)
         {
             _iterator = iterator;
@@ -173,7 +173,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         }
 
         /// <summary>
-        /// Sets the <see cref="IIterator"/> that will be used to track the iterative process.
+        /// Sets the <see cref="IIterator{T}"/> that will be used to track the iterative process.
         /// </summary>
         /// <param name="iterator">The iterator.</param>
         public void SetIterator(IIterator<Complex32> iterator)

src/Numerics/LinearAlgebra/Complex32/Solvers/Iterative/CompositeSolver.cs

@@ -109,7 +109,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         #region Solver information loading methods
 
         /// <summary>
-        /// Loads all the available <see cref="IIterativeSolverSetup"/> objects from the MathNet.Numerics assembly.
+        /// Loads all the available <see cref="IIterativeSolverSetup{T}"/> objects from the MathNet.Numerics assembly.
         /// </summary>
         public static void LoadSolverInformation()
         {
@@ -117,9 +117,9 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         }
 
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the MathNet.Numerics assembly.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the MathNet.Numerics assembly.
         /// </summary>
-        /// <param name="typesToExclude">The <see cref="IIterativeSolver"/> types that should not be loaded.</param>
+        /// <param name="typesToExclude">The <see cref="IIterativeSolver{T}"/> types that should not be loaded.</param>
         public static void LoadSolverInformation(Type[] typesToExclude)
         {
             LoadSolverInformationFromAssembly(Assembly.GetExecutingAssembly(), typesToExclude);
@@ -127,7 +127,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
 
 #if !PORTABLE
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the assembly specified by the file location.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the assembly specified by the file location.
         /// </summary>
         /// <param name="assemblyLocation">The fully qualified path to the assembly.</param>
         public static void LoadSolverInformationFromAssembly(string assemblyLocation)
@@ -136,10 +136,10 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         }
 
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the assembly specified by the file location.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the assembly specified by the file location.
         /// </summary>
         /// <param name="assemblyLocation">The fully qualified path to the assembly.</param>
-        /// <param name="typesToExclude">The <see cref="IIterativeSolver"/> types that should not be loaded. </param>
+        /// <param name="typesToExclude">The <see cref="IIterativeSolver{T}"/> types that should not be loaded. </param>
         public static void LoadSolverInformationFromAssembly(string assemblyLocation, params Type[] typesToExclude)
         {
             if (assemblyLocation == null)
@@ -175,7 +175,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
 #endif
 
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the assembly specified by the assembly name.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the assembly specified by the assembly name.
         /// </summary>
         /// <param name="assemblyName">The <see cref="AssemblyName"/> of the assembly that should be searched for setup objects. </param>
         public static void LoadSolverInformationFromAssembly(AssemblyName assemblyName)
@@ -184,10 +184,10 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         }
 
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the assembly specified by the assembly name.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the assembly specified by the assembly name.
         /// </summary>
         /// <param name="assemblyName">The <see cref="AssemblyName"/> of the assembly that should be searched for setup objects.</param>
-        /// <param name="typesToExclude">The <see cref="IIterativeSolver"/> types that should not be loaded.</param>
+        /// <param name="typesToExclude">The <see cref="IIterativeSolver{T}"/> types that should not be loaded.</param>
         public static void LoadSolverInformationFromAssembly(AssemblyName assemblyName, params Type[] typesToExclude)
         {
             if (assemblyName == null)
@@ -207,7 +207,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         }
 
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the assembly specified by the type.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the assembly specified by the type.
         /// </summary>
         /// <param name="typeInAssembly">The type in the assembly which should be searched for setup objects.</param>
         public static void LoadSolverInformationFromAssembly(Type typeInAssembly)
@@ -216,10 +216,10 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         }
 
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the assembly specified by the type.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the assembly specified by the type.
         /// </summary>
         /// <param name="typeInAssembly">The type in the assembly which should be searched for setup objects.</param>
-        /// <param name="typesToExclude">The <see cref="IIterativeSolver"/> types that should not be loaded.</param>
+        /// <param name="typesToExclude">The <see cref="IIterativeSolver{T}"/> types that should not be loaded.</param>
         public static void LoadSolverInformationFromAssembly(Type typeInAssembly, params Type[] typesToExclude)
         {
             if (typeInAssembly == null)
@@ -231,7 +231,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         }
 
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the specified assembly.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the specified assembly.
         /// </summary>
         /// <param name="assembly">The assembly which will be searched for setup objects.</param>
         public static void LoadSolverInformationFromAssembly(Assembly assembly)
@@ -240,10 +240,10 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         }
 
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the specified assembly.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the specified assembly.
         /// </summary>
         /// <param name="assembly">The assembly which will be searched for setup objects.</param>
-        /// <param name="typesToExclude">The <see cref="IIterativeSolver"/> types that should not be loaded.</param>
+        /// <param name="typesToExclude">The <see cref="IIterativeSolver{T}"/> types that should not be loaded.</param>
         public static void LoadSolverInformationFromAssembly(Assembly assembly, params Type[] typesToExclude)
         {
             if (assembly == null)

src/Numerics/LinearAlgebra/Complex32/Solvers/Iterative/GpBiCg.cs

@@ -105,7 +105,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// Initializes a new instance of the <see cref="GpBiCg"/> class.
         /// </summary>
         /// <remarks>
-        /// When using this constructor the solver will use the <see cref="IIterator"/> with
+        /// When using this constructor the solver will use the <see cref="IIterator{T}"/> with
         /// the standard settings and a default preconditioner.
         /// </remarks>
         public GpBiCg()
@@ -121,17 +121,17 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// When using this constructor the solver will use a default preconditioner.
         /// </para>
         /// <para>
-        /// The main advantages of using a user defined <see cref="IIterator"/> are:
+        /// The main advantages of using a user defined <see cref="IIterator{T}"/> are:
         /// <list type="number">
         /// <item>It is possible to set the desired convergence limits.</item>
         /// <item>
         /// It is possible to check the reason for which the solver finished 
-        /// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
+        /// the iterative procedure by calling the <see cref="IIterator{T}.Status"/> property.
         /// </item>
         /// </list>
         /// </para>
         /// </remarks>
-        /// <param name="iterator">The <see cref="IIterator"/> that will be used to monitor the iterative process.</param>
+        /// <param name="iterator">The <see cref="IIterator{T}"/> that will be used to monitor the iterative process.</param>
         public GpBiCg(IIterator<Complex32> iterator)
             : this(null, iterator)
         {
@@ -141,7 +141,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// Initializes a new instance of the <see cref="GpBiCg"/> class.
         /// </summary>
         /// <remarks>
-        /// When using this constructor the solver will use the <see cref="IIterator"/> with
+        /// When using this constructor the solver will use the <see cref="IIterator{T}"/> with
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
@@ -155,18 +155,18 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// </summary>
         /// <remarks>
         /// <para>
-        /// The main advantages of using a user defined <see cref="IIterator"/> are:
+        /// The main advantages of using a user defined <see cref="IIterator{T}"/> are:
         /// <list type="number">
         /// <item>It is possible to set the desired convergence limits.</item>
         /// <item>
         /// It is possible to check the reason for which the solver finished 
-        /// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
+        /// the iterative procedure by calling the <see cref="IIterator{T}.Status"/> property.
         /// </item>
         /// </list>
         /// </para>
         /// </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"/> that will be used to monitor the iterative process.</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)
         {
             _iterator = iterator;
@@ -221,7 +221,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         }
 
         /// <summary>
-        /// Sets the <see cref="IIterator"/> that will be used to track the iterative process.
+        /// Sets the <see cref="IIterator{T}"/> that will be used to track the iterative process.
         /// </summary>
         /// <param name="iterator">The iterator.</param>
         public void SetIterator(IIterator<Complex32> iterator)

src/Numerics/LinearAlgebra/Complex32/Solvers/Iterative/MlkBiCgStab.cs

@@ -108,7 +108,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// Initializes a new instance of the <see cref="MlkBiCgStab"/> class.
         /// </summary>
         /// <remarks>
-        /// When using this constructor the solver will use the <see cref="IIterator"/> with
+        /// When using this constructor the solver will use the <see cref="IIterator{T}"/> with
         /// the standard settings and a default preconditioner.
         /// </remarks>
         public MlkBiCgStab()
@@ -124,17 +124,17 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// When using this constructor the solver will use a default preconditioner.
         /// </para>
         /// <para>
-        /// The main advantages of using a user defined <see cref="IIterator"/> are:
+        /// The main advantages of using a user defined <see cref="IIterator{T}"/> are:
         /// <list type="number">
         /// <item>It is possible to set the desired convergence limits.</item>
         /// <item>
         /// It is possible to check the reason for which the solver finished 
-        /// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
+        /// the iterative procedure by calling the <see cref="IIterator{T}.Status"/> property.
         /// </item>
         /// </list>
         /// </para>
         /// </remarks>
-        /// <param name="iterator">The <see cref="IIterator"/> that will be used to monitor the iterative process.</param>
+        /// <param name="iterator">The <see cref="IIterator{T}"/> that will be used to monitor the iterative process.</param>
         public MlkBiCgStab(IIterator<Complex32> iterator)
             : this(null, iterator)
         {
@@ -144,7 +144,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// Initializes a new instance of the <see cref="MlkBiCgStab"/> class.
         /// </summary>
         /// <remarks>
-        /// When using this constructor the solver will use the <see cref="IIterator"/> with
+        /// When using this constructor the solver will use the <see cref="IIterator{T}"/> with
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
@@ -158,18 +158,18 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// </summary>
         /// <remarks>
         /// <para>
-        /// The main advantages of using a user defined <see cref="IIterator"/> are:
+        /// The main advantages of using a user defined <see cref="IIterator{T}"/> are:
         /// <list type="number">
         /// <item>It is possible to set the desired convergence limits.</item>
         /// <item>
         /// It is possible to check the reason for which the solver finished 
-        /// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
+        /// the iterative procedure by calling the <see cref="IIterator{T}.Status"/> property.
         /// </item>
         /// </list>
         /// </para>
         /// </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"/> that will be used to monitor the iterative process.</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)
         {
             _iterator = iterator;
@@ -218,7 +218,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         }
 
         /// <summary>
-        /// Sets the <see cref="IIterator"/> that will be used to track the iterative process.
+        /// Sets the <see cref="IIterator{T}"/> that will be used to track the iterative process.
         /// </summary>
         /// <param name="iterator">The iterator.</param>
         public void SetIterator(IIterator<Complex32> iterator)

src/Numerics/LinearAlgebra/Complex32/Solvers/Iterative/TFQMR.cs

@@ -83,7 +83,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// Initializes a new instance of the <see cref="TFQMR"/> class.
         /// </summary>
         /// <remarks>
-        /// When using this constructor the solver will use the <see cref="IIterator"/> with
+        /// When using this constructor the solver will use the <see cref="IIterator{T}"/> with
         /// the standard settings and a default preconditioner.
         /// </remarks>
         public TFQMR()
@@ -99,17 +99,17 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// When using this constructor the solver will use a default preconditioner.
         /// </para>
         /// <para>
-        /// The main advantages of using a user defined <see cref="IIterator"/> are:
+        /// The main advantages of using a user defined <see cref="IIterator{T}"/> are:
         /// <list type="number">
         /// <item>It is possible to set the desired convergence limits.</item>
         /// <item>
         /// It is possible to check the reason for which the solver finished 
-        /// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
+        /// the iterative procedure by calling the <see cref="IIterator{T}.Status"/> property.
         /// </item>
         /// </list>
         /// </para>
         /// </remarks>
-        /// <param name="iterator">The <see cref="IIterator"/> that will be used to monitor the iterative process.</param>
+        /// <param name="iterator">The <see cref="IIterator{T}"/> that will be used to monitor the iterative process.</param>
         public TFQMR(IIterator<Complex32> iterator)
             : this(null, iterator)
         {
@@ -119,7 +119,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// Initializes a new instance of the <see cref="TFQMR"/> class.
         /// </summary>
         /// <remarks>
-        /// When using this constructor the solver will use the <see cref="IIterator"/> with
+        /// When using this constructor the solver will use the <see cref="IIterator{T}"/> with
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
@@ -133,18 +133,18 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         /// </summary>
         /// <remarks>
         /// <para>
-        /// The main advantages of using a user defined <see cref="IIterator"/> are:
+        /// The main advantages of using a user defined <see cref="IIterator{T}"/> are:
         /// <list type="number">
         /// <item>It is possible to set the desired convergence limits.</item>
         /// <item>
         /// It is possible to check the reason for which the solver finished 
-        /// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
+        /// the iterative procedure by calling the <see cref="IIterator{T}.Status"/> property.
         /// </item>
         /// </list>
         /// </para>
         /// </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"/> that will be used to monitor the iterative process.</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)
         {
             _iterator = iterator;
@@ -161,7 +161,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.Iterative
         }
 
         /// <summary>
-        /// Sets the <see cref="IIterator"/> that will be used to track the iterative process.
+        /// Sets the <see cref="IIterator{T}"/> that will be used to track the iterative process.
         /// </summary>
         /// <param name="iterator">The iterator.</param>
         public void SetIterator(IIterator<Complex32> iterator)

src/Numerics/LinearAlgebra/Complex32/Solvers/Iterator.cs

@@ -52,9 +52,9 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers
         private static readonly ICalculationStatus DefaultStatus = new CalculationIndetermined();
 
         /// <summary>
-        /// Creates a default iterator with all the <see cref="IIterationStopCriterium"/> objects.
+        /// Creates a default iterator with all the <see cref="IIterationStopCriterium{T}"/> objects.
         /// </summary>
-        /// <returns>A new <see cref="IIterator"/> object.</returns>
+        /// <returns>A new <see cref="IIterator{T}"/> object.</returns>
         public static IIterator<Complex32> CreateDefault()
         {
             var iterator = new Iterator();
@@ -112,7 +112,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers
         }
 
         /// <summary>
-        /// Adds an <see cref="IIterationStopCriterium"/> to the internal collection of stop-criteria. Only a 
+        /// Adds an <see cref="IIterationStopCriterium{T}"/> to the internal collection of stop-criteria. Only a 
         /// single stop criterium of each type can be stored.
         /// </summary>
         /// <param name="stopCriterium">The stop criterium to add.</param>
@@ -138,7 +138,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers
         }
 
         /// <summary>
-        /// Removes the <see cref="IIterationStopCriterium"/> from the internal collection.
+        /// Removes the <see cref="IIterationStopCriterium{T}"/> from the internal collection.
         /// </summary>
         /// <param name="stopCriterium">The stop criterium that must be removed.</param>
         public void Remove(IIterationStopCriterium<Complex32> stopCriterium)
@@ -158,10 +158,10 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers
         }
 
         /// <summary>
-        /// Indicates if the specific stop criterium is stored by the <see cref="IIterator"/>.
+        /// Indicates if the specific stop criterium is stored by the <see cref="IIterator{T}"/>.
         /// </summary>
         /// <param name="stopCriterium">The stop criterium.</param>
-        /// <returns><c>true</c> if the <see cref="IIterator"/> contains the stop criterium; otherwise <c>false</c>.</returns>
+        /// <returns><c>true</c> if the <see cref="IIterator{T}"/> contains the stop criterium; otherwise <c>false</c>.</returns>
         public bool Contains(IIterationStopCriterium<Complex32> stopCriterium)
         {
             return stopCriterium != null && _stopCriterias.ContainsKey(stopCriterium.GetType());
@@ -288,7 +288,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers
         }
 
         /// <summary>
-        /// Resets the <see cref="IIterator"/> to the pre-calculation state.
+        /// Resets the <see cref="IIterator{T}"/> to the pre-calculation state.
         /// </summary>
         public void ResetToPrecalculationState()
         {

src/Numerics/LinearAlgebra/Complex32/Solvers/Preconditioners/UnitPreconditioner.cs

@@ -28,15 +28,17 @@
 // 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 Properties;
     using Numerics;
 
     /// <summary>
     /// A unit preconditioner. This preconditioner does not actually do anything
-    /// it is only used when running an <see cref="IIterativeSolver"/> without
+    /// it is only used when running an <see cref="IIterativeSolver{T}"/> without
     /// a preconditioner.
     /// </summary>
     internal sealed class UnitPreconditioner : IPreConditioner

src/Numerics/LinearAlgebra/Complex32/Solvers/StopCriterium/DivergenceStopCriterium.cs

@@ -208,7 +208,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium
 
         /// <summary>
         /// Determines the status of the iterative calculation based on the stop criteria stored
-        /// by the current <see cref="IIterationStopCriterium"/>. Result is set into <c>Status</c> field.
+        /// by the current <see cref="IIterationStopCriterium{T}"/>. Result is set into <c>Status</c> field.
         /// </summary>
         /// <param name="iterationNumber">The number of iterations that have passed so far.</param>
         /// <param name="solutionVector">The vector containing the current solution values.</param>
@@ -348,7 +348,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium
         }
 
         /// <summary>
-        /// Resets the <see cref="IIterationStopCriterium"/> to the pre-calculation state.
+        /// Resets the <see cref="IIterationStopCriterium{T}"/> to the pre-calculation state.
         /// </summary>
         public void ResetToPrecalculationState()
         {
@@ -359,7 +359,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium
 
         /// <summary>
         /// Gets the <see cref="StopLevel"/> which indicates what sort of stop criterium this
-        /// <see cref="IIterationStopCriterium"/> monitors.
+        /// <see cref="IIterationStopCriterium{T}"/> monitors.
         /// </summary>
         /// <value>Returns <see cref="LinearAlgebra.Solvers.StopCriterium.StopLevel.Divergence"/>.</value>
         public StopLevel StopLevel

src/Numerics/LinearAlgebra/Complex32/Solvers/StopCriterium/FailureStopCriterium.cs

@@ -39,7 +39,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium
     using Numerics;
 
     /// <summary>
-    /// Defines an <see cref="IIterationStopCriterium"/> that monitors residuals for NaN's.
+    /// Defines an <see cref="IIterationStopCriterium{T}"/> that monitors residuals for NaN's.
     /// </summary>
     public sealed class FailureStopCriterium : IIterationStopCriterium<Complex32>
     {
@@ -66,7 +66,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium
 
         /// <summary>
         /// Determines the status of the iterative calculation based on the stop criteria stored
-        /// by the current <see cref="IIterationStopCriterium"/>. Result is set into <c>Status</c> field.
+        /// by the current <see cref="IIterationStopCriterium{T}"/>. Result is set into <c>Status</c> field.
         /// </summary>
         /// <param name="iterationNumber">The number of iterations that have passed so far.</param>
         /// <param name="solutionVector">The vector containing the current solution values.</param>
@@ -157,7 +157,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium
         }
 
         /// <summary>
-        /// Resets the <see cref="IIterationStopCriterium"/> to the pre-calculation state.
+        /// Resets the <see cref="IIterationStopCriterium{T}"/> to the pre-calculation state.
         /// </summary>
         public void ResetToPrecalculationState()
         {

src/Numerics/LinearAlgebra/Complex32/Solvers/StopCriterium/ResidualStopCriterium.cs

@@ -213,7 +213,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium
 
         /// <summary>
         /// Determines the status of the iterative calculation based on the stop criteria stored
-        /// by the current <see cref="IIterationStopCriterium"/>. Result is set into <c>Status</c> field.
+        /// by the current <see cref="IIterationStopCriterium{T}"/>. Result is set into <c>Status</c> field.
         /// </summary>
         /// <param name="iterationNumber">The number of iterations that have passed so far.</param>
         /// <param name="solutionVector">The vector containing the current solution values.</param>
@@ -364,7 +364,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium
         }
 
         /// <summary>
-        /// Resets the <see cref="IIterationStopCriterium"/> to the pre-calculation state.
+        /// Resets the <see cref="IIterationStopCriterium{T}"/> to the pre-calculation state.
         /// </summary>
         public void ResetToPrecalculationState()
         {
@@ -375,7 +375,7 @@ namespace MathNet.Numerics.LinearAlgebra.Complex32.Solvers.StopCriterium
 
         /// <summary>
         /// Gets the <see cref="StopLevel"/> which indicates what sort of stop criterium this
-        /// <see cref="IIterationStopCriterium"/> monitors.
+        /// <see cref="IIterationStopCriterium{T}"/> monitors.
         /// </summary>
         /// <value>Returns <see cref="StopLevel"/>.</value>
         public StopLevel StopLevel

src/Numerics/LinearAlgebra/Double/Solvers/Iterative/BiCgStab.cs

@@ -93,7 +93,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         /// Initializes a new instance of the <see cref="BiCgStab"/> class.
         /// </summary>
         /// <remarks>
-        /// When using this constructor the solver will use the <see cref="IIterator"/> with
+        /// When using this constructor the solver will use the <see cref="IIterator{T}"/> with
         /// the standard settings and a default preconditioner.
         /// </remarks>
         public BiCgStab() : this(null, null)
@@ -108,17 +108,17 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         /// When using this constructor the solver will use a default preconditioner.
         /// </para>
         /// <para>
-        /// The main advantages of using a user defined <see cref="IIterator"/> are:
+        /// The main advantages of using a user defined <see cref="IIterator{T}"/> are:
         /// <list type="number">
         /// <item>It is possible to set the desired convergence limits.</item>
         /// <item>
         /// It is possible to check the reason for which the solver finished 
-        /// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
+        /// the iterative procedure by calling the <see cref="IIterator{T}.Status"/> property.
         /// </item>
         /// </list>
         /// </para>
         /// </remarks>
-        /// <param name="iterator">The <see cref="IIterator"/> that will be used to monitor the iterative process. </param>
+        /// <param name="iterator">The <see cref="IIterator{T}"/> that will be used to monitor the iterative process. </param>
         public BiCgStab(IIterator<double> iterator)
             : this(null, iterator)
         {
@@ -128,7 +128,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         /// Initializes a new instance of the <see cref="BiCgStab"/> class.
         /// </summary>
         /// <remarks>
-        /// When using this constructor the solver will use the <see cref="IIterator"/> with
+        /// When using this constructor the solver will use the <see cref="IIterator{T}"/> with
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
@@ -141,18 +141,18 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         /// </summary>
         /// <remarks>
         /// <para>
-        /// The main advantages of using a user defined <see cref="IIterator"/> are:
+        /// The main advantages of using a user defined <see cref="IIterator{T}"/> are:
         /// <list type="number">
         /// <item>It is possible to set the desired convergence limits.</item>
         /// <item>
         /// It is possible to check the reason for which the solver finished 
-        /// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
+        /// the iterative procedure by calling the <see cref="IIterator{T}.Status"/> property.
         /// </item>
         /// </list>
         /// </para>
         /// </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"/> that will be used to monitor the iterative process. </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)
         {
             _iterator = iterator;
@@ -169,7 +169,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         }
 
         /// <summary>
-        /// Sets the <see cref="IIterator"/> that will be used to track the iterative process.
+        /// Sets the <see cref="IIterator{T}"/> that will be used to track the iterative process.
         /// </summary>
         /// <param name="iterator">The iterator.</param>
         public void SetIterator(IIterator<double> iterator)

src/Numerics/LinearAlgebra/Double/Solvers/Iterative/CompositeSolver.cs

@@ -104,7 +104,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         #region Solver information loading methods
 
         /// <summary>
-        /// Loads all the available <see cref="IIterativeSolverSetup"/> objects from the MathNet.Numerics assembly.
+        /// Loads all the available <see cref="IIterativeSolverSetup{T}"/> objects from the MathNet.Numerics assembly.
         /// </summary>
         public static void LoadSolverInformation()
         {
@@ -112,9 +112,9 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         }
 
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the MathNet.Numerics assembly.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the MathNet.Numerics assembly.
         /// </summary>
-        /// <param name="typesToExclude">The <see cref="IIterativeSolver"/> types that should not be loaded.</param>
+        /// <param name="typesToExclude">The <see cref="IIterativeSolver{T}"/> types that should not be loaded.</param>
         public static void LoadSolverInformation(Type[] typesToExclude)
         {
             LoadSolverInformationFromAssembly(Assembly.GetExecutingAssembly(), typesToExclude);
@@ -122,7 +122,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
 
 #if !PORTABLE
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the assembly specified by the file location.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the assembly specified by the file location.
         /// </summary>
         /// <param name="assemblyLocation">The fully qualified path to the assembly.</param>
         public static void LoadSolverInformationFromAssembly(string assemblyLocation)
@@ -131,10 +131,10 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         }
 
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the assembly specified by the file location.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the assembly specified by the file location.
         /// </summary>
         /// <param name="assemblyLocation">The fully qualified path to the assembly.</param>
-        /// <param name="typesToExclude">The <see cref="IIterativeSolver"/> types that should not be loaded. </param>
+        /// <param name="typesToExclude">The <see cref="IIterativeSolver{T}"/> types that should not be loaded. </param>
         public static void LoadSolverInformationFromAssembly(string assemblyLocation, params Type[] typesToExclude)
         {
             if (assemblyLocation == null)
@@ -170,7 +170,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
 #endif
 
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the assembly specified by the assembly name.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the assembly specified by the assembly name.
         /// </summary>
         /// <param name="assemblyName">The <see cref="AssemblyName"/> of the assembly that should be searched for setup objects. </param>
         public static void LoadSolverInformationFromAssembly(AssemblyName assemblyName)
@@ -179,10 +179,10 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         }
 
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the assembly specified by the assembly name.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the assembly specified by the assembly name.
         /// </summary>
         /// <param name="assemblyName">The <see cref="AssemblyName"/> of the assembly that should be searched for setup objects.</param>
-        /// <param name="typesToExclude">The <see cref="IIterativeSolver"/> types that should not be loaded.</param>
+        /// <param name="typesToExclude">The <see cref="IIterativeSolver{T}"/> types that should not be loaded.</param>
         public static void LoadSolverInformationFromAssembly(AssemblyName assemblyName, params Type[] typesToExclude)
         {
             if (assemblyName == null)
@@ -202,7 +202,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         }
 
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the assembly specified by the type.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the assembly specified by the type.
         /// </summary>
         /// <param name="typeInAssembly">The type in the assembly which should be searched for setup objects.</param>
         public static void LoadSolverInformationFromAssembly(Type typeInAssembly)
@@ -211,10 +211,10 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         }
 
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the assembly specified by the type.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the assembly specified by the type.
         /// </summary>
         /// <param name="typeInAssembly">The type in the assembly which should be searched for setup objects.</param>
-        /// <param name="typesToExclude">The <see cref="IIterativeSolver"/> types that should not be loaded.</param>
+        /// <param name="typesToExclude">The <see cref="IIterativeSolver{T}"/> types that should not be loaded.</param>
         public static void LoadSolverInformationFromAssembly(Type typeInAssembly, params Type[] typesToExclude)
         {
             if (typeInAssembly == null)
@@ -226,7 +226,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         }
 
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the specified assembly.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the specified assembly.
         /// </summary>
         /// <param name="assembly">The assembly which will be searched for setup objects.</param>
         public static void LoadSolverInformationFromAssembly(Assembly assembly)
@@ -235,10 +235,10 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         }
 
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the specified assembly.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the specified assembly.
         /// </summary>
         /// <param name="assembly">The assembly which will be searched for setup objects.</param>
-        /// <param name="typesToExclude">The <see cref="IIterativeSolver"/> types that should not be loaded.</param>
+        /// <param name="typesToExclude">The <see cref="IIterativeSolver{T}"/> types that should not be loaded.</param>
         public static void LoadSolverInformationFromAssembly(Assembly assembly, params Type[] typesToExclude)
         {
             if (assembly == null)
@@ -370,7 +370,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         }
 
         /// <summary>
-        /// Sets the <see cref="IIterator"/> that will be used to track the iterative process.
+        /// Sets the <see cref="IIterator{T}"/> that will be used to track the iterative process.
         /// </summary>
         /// <param name="iterator">The iterator.</param>
         public void SetIterator(IIterator<double> iterator)

src/Numerics/LinearAlgebra/Double/Solvers/Iterative/GpBiCg.cs

@@ -103,7 +103,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         /// Initializes a new instance of the <see cref="GpBiCg"/> class.
         /// </summary>
         /// <remarks>
-        /// When using this constructor the solver will use the <see cref="IIterator"/> with
+        /// When using this constructor the solver will use the <see cref="IIterator{T}"/> with
         /// the standard settings and a default preconditioner.
         /// </remarks>
         public GpBiCg() : this(null, null)
@@ -118,17 +118,17 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         /// When using this constructor the solver will use a default preconditioner.
         /// </para>
         /// <para>
-        /// The main advantages of using a user defined <see cref="IIterator"/> are:
+        /// The main advantages of using a user defined <see cref="IIterator{T}"/> are:
         /// <list type="number">
         /// <item>It is possible to set the desired convergence limits.</item>
         /// <item>
         /// It is possible to check the reason for which the solver finished 
-        /// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
+        /// the iterative procedure by calling the <see cref="IIterator{T}.Status"/> property.
         /// </item>
         /// </list>
         /// </para>
         /// </remarks>
-        /// <param name="iterator">The <see cref="IIterator"/> that will be used to monitor the iterative process.</param>
+        /// <param name="iterator">The <see cref="IIterator{T}"/> that will be used to monitor the iterative process.</param>
         public GpBiCg(IIterator<double> iterator)
             : this(null, iterator)
         {
@@ -138,7 +138,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         /// Initializes a new instance of the <see cref="GpBiCg"/> class.
         /// </summary>
         /// <remarks>
-        /// When using this constructor the solver will use the <see cref="IIterator"/> with
+        /// When using this constructor the solver will use the <see cref="IIterator{T}"/> with
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
@@ -151,18 +151,18 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         /// </summary>
         /// <remarks>
         /// <para>
-        /// The main advantages of using a user defined <see cref="IIterator"/> are:
+        /// The main advantages of using a user defined <see cref="IIterator{T}"/> are:
         /// <list type="number">
         /// <item>It is possible to set the desired convergence limits.</item>
         /// <item>
         /// It is possible to check the reason for which the solver finished 
-        /// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
+        /// the iterative procedure by calling the <see cref="IIterator{T}.Status"/> property.
         /// </item>
         /// </list>
         /// </para>
         /// </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"/> that will be used to monitor the iterative process.</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)
         {
             _iterator = iterator;
@@ -223,7 +223,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         }
 
         /// <summary>
-        /// Sets the <see cref="IIterator"/> that will be used to track the iterative process.
+        /// Sets the <see cref="IIterator{T}"/> that will be used to track the iterative process.
         /// </summary>
         /// <param name="iterator">The iterator.</param>
         public void SetIterator(IIterator<double> iterator)

src/Numerics/LinearAlgebra/Double/Solvers/Iterative/MlkBiCgStab.cs

@@ -106,7 +106,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         /// Initializes a new instance of the <see cref="MlkBiCgStab"/> class.
         /// </summary>
         /// <remarks>
-        /// When using this constructor the solver will use the <see cref="IIterator"/> with
+        /// When using this constructor the solver will use the <see cref="IIterator{T}"/> with
         /// the standard settings and a default preconditioner.
         /// </remarks>
         public MlkBiCgStab() : this(null, null)
@@ -121,17 +121,17 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         /// When using this constructor the solver will use a default preconditioner.
         /// </para>
         /// <para>
-        /// The main advantages of using a user defined <see cref="IIterator"/> are:
+        /// The main advantages of using a user defined <see cref="IIterator{T}"/> are:
         /// <list type="number">
         /// <item>It is possible to set the desired convergence limits.</item>
         /// <item>
         /// It is possible to check the reason for which the solver finished 
-        /// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
+        /// the iterative procedure by calling the <see cref="IIterator{T}.Status"/> property.
         /// </item>
         /// </list>
         /// </para>
         /// </remarks>
-        /// <param name="iterator">The <see cref="IIterator"/> that will be used to monitor the iterative process.</param>
+        /// <param name="iterator">The <see cref="IIterator{T}"/> that will be used to monitor the iterative process.</param>
         public MlkBiCgStab(IIterator<double> iterator)
             : this(null, iterator)
         {
@@ -141,7 +141,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         /// Initializes a new instance of the <see cref="MlkBiCgStab"/> class.
         /// </summary>
         /// <remarks>
-        /// When using this constructor the solver will use the <see cref="IIterator"/> with
+        /// When using this constructor the solver will use the <see cref="IIterator{T}"/> with
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
@@ -154,18 +154,18 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         /// </summary>
         /// <remarks>
         /// <para>
-        /// The main advantages of using a user defined <see cref="IIterator"/> are:
+        /// The main advantages of using a user defined <see cref="IIterator{T}"/> are:
         /// <list type="number">
         /// <item>It is possible to set the desired convergence limits.</item>
         /// <item>
         /// It is possible to check the reason for which the solver finished 
-        /// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
+        /// the iterative procedure by calling the <see cref="IIterator{T}.Status"/> property.
         /// </item>
         /// </list>
         /// </para>
         /// </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"/> that will be used to monitor the iterative process.</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)
         {
             _iterator = iterator;
@@ -217,7 +217,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         }
 
         /// <summary>
-        /// Sets the <see cref="IIterator"/> that will be used to track the iterative process.
+        /// Sets the <see cref="IIterator{T}"/> that will be used to track the iterative process.
         /// </summary>
         /// <param name="iterator">The iterator.</param>
         public void SetIterator(IIterator<double> iterator)

src/Numerics/LinearAlgebra/Double/Solvers/Iterative/TFQMR.cs

@@ -81,7 +81,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         /// Initializes a new instance of the <see cref="TFQMR"/> class.
         /// </summary>
         /// <remarks>
-        /// When using this constructor the solver will use the <see cref="IIterator"/> with
+        /// When using this constructor the solver will use the <see cref="IIterator{T}"/> with
         /// the standard settings and a default preconditioner.
         /// </remarks>
         public TFQMR() : this(null, null)
@@ -96,17 +96,17 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         /// When using this constructor the solver will use a default preconditioner.
         /// </para>
         /// <para>
-        /// The main advantages of using a user defined <see cref="IIterator"/> are:
+        /// The main advantages of using a user defined <see cref="IIterator{T}"/> are:
         /// <list type="number">
         /// <item>It is possible to set the desired convergence limits.</item>
         /// <item>
         /// It is possible to check the reason for which the solver finished 
-        /// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
+        /// the iterative procedure by calling the <see cref="IIterator{T}.Status"/> property.
         /// </item>
         /// </list>
         /// </para>
         /// </remarks>
-        /// <param name="iterator">The <see cref="IIterator"/> that will be used to monitor the iterative process.</param>
+        /// <param name="iterator">The <see cref="IIterator{T}"/> that will be used to monitor the iterative process.</param>
         public TFQMR(IIterator<double> iterator)
             : this(null, iterator)
         {
@@ -116,7 +116,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         /// Initializes a new instance of the <see cref="TFQMR"/> class.
         /// </summary>
         /// <remarks>
-        /// When using this constructor the solver will use the <see cref="IIterator"/> with
+        /// When using this constructor the solver will use the <see cref="IIterator{T}"/> with
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
@@ -129,18 +129,18 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         /// </summary>
         /// <remarks>
         /// <para>
-        /// The main advantages of using a user defined <see cref="IIterator"/> are:
+        /// The main advantages of using a user defined <see cref="IIterator{T}"/> are:
         /// <list type="number">
         /// <item>It is possible to set the desired convergence limits.</item>
         /// <item>
         /// It is possible to check the reason for which the solver finished 
-        /// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
+        /// the iterative procedure by calling the <see cref="IIterator{T}.Status"/> property.
         /// </item>
         /// </list>
         /// </para>
         /// </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"/> that will be used to monitor the iterative process.</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)
         {
             _iterator = iterator;
@@ -157,7 +157,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.Iterative
         }
 
         /// <summary>
-        /// Sets the <see cref="IIterator"/> that will be used to track the iterative process.
+        /// Sets the <see cref="IIterator{T}"/> that will be used to track the iterative process.
         /// </summary>
         /// <param name="iterator">The iterator.</param>
         public void SetIterator(IIterator<double> iterator)

src/Numerics/LinearAlgebra/Double/Solvers/Iterator.cs

@@ -52,7 +52,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers
         /// <summary>
         /// Creates a default iterator with all the <see cref="IIterationStopCriterium{T}"/> objects.
         /// </summary>
-        /// <returns>A new <see cref="IIterator"/> object.</returns>
+        /// <returns>A new <see cref="IIterator{T}"/> object.</returns>
         public static IIterator<double> CreateDefault()
         {
             var iterator = new Iterator();
@@ -110,7 +110,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers
         }
 
         /// <summary>
-        /// Adds an <see cref="IIterationStopCriterium"/> to the internal collection of stop-criteria. Only a 
+        /// Adds an <see cref="IIterationStopCriterium{T}"/> to the internal collection of stop-criteria. Only a 
         /// single stop criterium of each type can be stored.
         /// </summary>
         /// <param name="stopCriterium">The stop criterium to add.</param>
@@ -156,10 +156,10 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers
         }
 
         /// <summary>
-        /// Indicates if the specific stop criterium is stored by the <see cref="IIterator"/>.
+        /// Indicates if the specific stop criterium is stored by the <see cref="IIterator{T}"/>.
         /// </summary>
         /// <param name="stopCriterium">The stop criterium.</param>
-        /// <returns><c>true</c> if the <see cref="IIterator"/> contains the stop criterium; otherwise <c>false</c>.</returns>
+        /// <returns><c>true</c> if the <see cref="IIterator{T}"/> contains the stop criterium; otherwise <c>false</c>.</returns>
         public bool Contains(IIterationStopCriterium<double> stopCriterium)
         {
             return stopCriterium != null && _stopCriterias.ContainsKey(stopCriterium.GetType());
@@ -203,7 +203,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers
 
         /// <summary>
         /// Determines the status of the iterative calculation based on the stop criteria stored
-        /// by the current <see cref="IIterator"/>. Result is set into <c>Status</c> field.
+        /// by the current <see cref="IIterator{T}"/>. Result is set into <c>Status</c> field.
         /// </summary>
         /// <param name="iterationNumber">The number of iterations that have passed so far.</param>
         /// <param name="solutionVector">The vector containing the current solution values.</param>
@@ -286,7 +286,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers
         }
 
         /// <summary>
-        /// Resets the <see cref="IIterator"/> to the pre-calculation state.
+        /// Resets the <see cref="IIterator{T}"/> to the pre-calculation state.
         /// </summary>
         public void ResetToPrecalculationState()
         {

src/Numerics/LinearAlgebra/Double/Solvers/Preconditioners/UnitPreconditioner.cs

@@ -28,14 +28,15 @@
 // 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 unit preconditioner. This preconditioner does not actually do anything
-    /// it is only used when running an <see cref="IIterativeSolver"/> without
+    /// it is only used when running an <see cref="IIterativeSolver{T}"/> without
     /// a preconditioner.
     /// </summary>
     internal sealed class UnitPreconditioner : IPreConditioner

src/Numerics/LinearAlgebra/Double/Solvers/StopCriterium/DivergenceStopCriterium.cs

@@ -206,7 +206,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium
 
         /// <summary>
         /// Determines the status of the iterative calculation based on the stop criteria stored
-        /// by the current <see cref="IIterationStopCriterium"/>. Result is set into <c>Status</c> field.
+        /// by the current <see cref="IIterationStopCriterium{T}"/>. Result is set into <c>Status</c> field.
         /// </summary>
         /// <param name="iterationNumber">The number of iterations that have passed so far.</param>
         /// <param name="solutionVector">The vector containing the current solution values.</param>
@@ -346,7 +346,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium
         }
 
         /// <summary>
-        /// Resets the <see cref="IIterationStopCriterium"/> to the pre-calculation state.
+        /// Resets the <see cref="IIterationStopCriterium{T}"/> to the pre-calculation state.
         /// </summary>
         public void ResetToPrecalculationState()
         {
@@ -357,7 +357,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium
 
         /// <summary>
         /// Gets the <see cref="StopLevel"/> which indicates what sort of stop criterium this
-        /// <see cref="IIterationStopCriterium"/> monitors.
+        /// <see cref="IIterationStopCriterium{T}"/> monitors.
         /// </summary>
         /// <value>Returns <see cref="LinearAlgebra.Solvers.StopCriterium.StopLevel.Divergence"/>.</value>
         public StopLevel StopLevel

src/Numerics/LinearAlgebra/Double/Solvers/StopCriterium/FailureStopCriterium.cs

@@ -37,7 +37,7 @@ using System.Diagnostics;
 namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium
 {
     /// <summary>
-    /// Defines an <see cref="IIterationStopCriterium"/> that monitors residuals for NaN's.
+    /// Defines an <see cref="IIterationStopCriterium{T}"/> that monitors residuals for NaN's.
     /// </summary>
     public sealed class FailureStopCriterium : IIterationStopCriterium<double>
     {
@@ -64,7 +64,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium
 
         /// <summary>
         /// Determines the status of the iterative calculation based on the stop criteria stored
-        /// by the current <see cref="IIterationStopCriterium"/>. Result is set into <c>Status</c> field.
+        /// by the current <see cref="IIterationStopCriterium{T}"/>. Result is set into <c>Status</c> field.
         /// </summary>
         /// <param name="iterationNumber">The number of iterations that have passed so far.</param>
         /// <param name="solutionVector">The vector containing the current solution values.</param>
@@ -155,7 +155,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium
         }
 
         /// <summary>
-        /// Resets the <see cref="IIterationStopCriterium"/> to the pre-calculation state.
+        /// Resets the <see cref="IIterationStopCriterium{T}"/> to the pre-calculation state.
         /// </summary>
         public void ResetToPrecalculationState()
         {
@@ -165,7 +165,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium
 
         /// <summary>
         /// Gets the <see cref="StopLevel"/>which indicates what sort of stop criterium this
-        /// <see cref="IIterationStopCriterium"/> monitors.
+        /// <see cref="IIterationStopCriterium{T}"/> monitors.
         /// </summary>
         /// <value>Returns <see cref="CalculationFailure"/>.</value>
         public StopLevel StopLevel

src/Numerics/LinearAlgebra/Double/Solvers/StopCriterium/ResidualStopCriterium.cs

@@ -211,7 +211,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium
 
         /// <summary>
         /// Determines the status of the iterative calculation based on the stop criteria stored
-        /// by the current <see cref="IIterationStopCriterium"/>. Result is set into <c>Status</c> field.
+        /// by the current <see cref="IIterationStopCriterium{T}"/>. Result is set into <c>Status</c> field.
         /// </summary>
         /// <param name="iterationNumber">The number of iterations that have passed so far.</param>
         /// <param name="solutionVector">The vector containing the current solution values.</param>
@@ -362,7 +362,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium
         }
 
         /// <summary>
-        /// Resets the <see cref="IIterationStopCriterium"/> to the pre-calculation state.
+        /// Resets the <see cref="IIterationStopCriterium{T}"/> to the pre-calculation state.
         /// </summary>
         public void ResetToPrecalculationState()
         {
@@ -373,7 +373,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double.Solvers.StopCriterium
 
         /// <summary>
         /// Gets the <see cref="StopLevel"/> which indicates what sort of stop criterium this
-        /// <see cref="IIterationStopCriterium"/> monitors.
+        /// <see cref="IIterationStopCriterium{T}"/> monitors.
         /// </summary>
         /// <value>Returns <see cref="StopLevel"/>.</value>
         public StopLevel StopLevel

src/Numerics/LinearAlgebra/Single/Solvers/Iterative/BiCgStab.cs

@@ -93,7 +93,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// Initializes a new instance of the <see cref="BiCgStab"/> class.
         /// </summary>
         /// <remarks>
-        /// When using this constructor the solver will use the <see cref="IIterator"/> with
+        /// When using this constructor the solver will use the <see cref="IIterator{T}"/> with
         /// the standard settings and a default preconditioner.
         /// </remarks>
         public BiCgStab() : this(null, null)
@@ -108,17 +108,17 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// When using this constructor the solver will use a default preconditioner.
         /// </para>
         /// <para>
-        /// The main advantages of using a user defined <see cref="IIterator"/> are:
+        /// The main advantages of using a user defined <see cref="IIterator{T}"/> are:
         /// <list type="number">
         /// <item>It is possible to set the desired convergence limits.</item>
         /// <item>
         /// It is possible to check the reason for which the solver finished 
-        /// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
+        /// the iterative procedure by calling the <see cref="IIterator{T}.Status"/> property.
         /// </item>
         /// </list>
         /// </para>
         /// </remarks>
-        /// <param name="iterator">The <see cref="IIterator"/> that will be used to monitor the iterative process. </param>
+        /// <param name="iterator">The <see cref="IIterator{T}"/> that will be used to monitor the iterative process. </param>
         public BiCgStab(IIterator<float> iterator)
             : this(null, iterator)
         {
@@ -128,7 +128,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// Initializes a new instance of the <see cref="BiCgStab"/> class.
         /// </summary>
         /// <remarks>
-        /// When using this constructor the solver will use the <see cref="IIterator"/> with
+        /// When using this constructor the solver will use the <see cref="IIterator{T}"/> with
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
@@ -141,18 +141,18 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// </summary>
         /// <remarks>
         /// <para>
-        /// The main advantages of using a user defined <see cref="IIterator"/> are:
+        /// The main advantages of using a user defined <see cref="IIterator{T}"/> are:
         /// <list type="number">
         /// <item>It is possible to set the desired convergence limits.</item>
         /// <item>
         /// It is possible to check the reason for which the solver finished 
-        /// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
+        /// the iterative procedure by calling the <see cref="IIterator{T}.Status"/> property.
         /// </item>
         /// </list>
         /// </para>
         /// </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"/> that will be used to monitor the iterative process. </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)
         {
             _iterator = iterator;
@@ -169,7 +169,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         }
 
         /// <summary>
-        /// Sets the <see cref="IIterator"/> that will be used to track the iterative process.
+        /// Sets the <see cref="IIterator{T}"/> that will be used to track the iterative process.
         /// </summary>
         /// <param name="iterator">The iterator.</param>
         public void SetIterator(IIterator<float> iterator)

src/Numerics/LinearAlgebra/Single/Solvers/Iterative/CompositeSolver.cs

@@ -107,7 +107,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         #region Solver information loading methods
 
         /// <summary>
-        /// Loads all the available <see cref="IIterativeSolverSetup"/> objects from the MathNet.Numerics assembly.
+        /// Loads all the available <see cref="IIterativeSolverSetup{T}"/> objects from the MathNet.Numerics assembly.
         /// </summary>
         public static void LoadSolverInformation()
         {
@@ -115,9 +115,9 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         }
 
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the MathNet.Numerics assembly.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the MathNet.Numerics assembly.
         /// </summary>
-        /// <param name="typesToExclude">The <see cref="IIterativeSolver"/> types that should not be loaded.</param>
+        /// <param name="typesToExclude">The <see cref="IIterativeSolver{T}"/> types that should not be loaded.</param>
         public static void LoadSolverInformation(Type[] typesToExclude)
         {
             LoadSolverInformationFromAssembly(Assembly.GetExecutingAssembly(), typesToExclude);
@@ -125,7 +125,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
 
 #if !PORTABLE
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the assembly specified by the file location.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the assembly specified by the file location.
         /// </summary>
         /// <param name="assemblyLocation">The fully qualified path to the assembly.</param>
         public static void LoadSolverInformationFromAssembly(string assemblyLocation)
@@ -134,10 +134,10 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         }
 
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the assembly specified by the file location.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the assembly specified by the file location.
         /// </summary>
         /// <param name="assemblyLocation">The fully qualified path to the assembly.</param>
-        /// <param name="typesToExclude">The <see cref="IIterativeSolver"/> types that should not be loaded. </param>
+        /// <param name="typesToExclude">The <see cref="IIterativeSolver{T}"/> types that should not be loaded. </param>
         public static void LoadSolverInformationFromAssembly(string assemblyLocation, params Type[] typesToExclude)
         {
             if (assemblyLocation == null)
@@ -173,7 +173,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
 #endif
 
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the assembly specified by the assembly name.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the assembly specified by the assembly name.
         /// </summary>
         /// <param name="assemblyName">The <see cref="AssemblyName"/> of the assembly that should be searched for setup objects. </param>
         public static void LoadSolverInformationFromAssembly(AssemblyName assemblyName)
@@ -182,10 +182,10 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         }
 
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the assembly specified by the assembly name.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the assembly specified by the assembly name.
         /// </summary>
         /// <param name="assemblyName">The <see cref="AssemblyName"/> of the assembly that should be searched for setup objects.</param>
-        /// <param name="typesToExclude">The <see cref="IIterativeSolver"/> types that should not be loaded.</param>
+        /// <param name="typesToExclude">The <see cref="IIterativeSolver{T}"/> types that should not be loaded.</param>
         public static void LoadSolverInformationFromAssembly(AssemblyName assemblyName, params Type[] typesToExclude)
         {
             if (assemblyName == null)
@@ -205,7 +205,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         }
 
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the assembly specified by the type.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the assembly specified by the type.
         /// </summary>
         /// <param name="typeInAssembly">The type in the assembly which should be searched for setup objects.</param>
         public static void LoadSolverInformationFromAssembly(Type typeInAssembly)
@@ -214,10 +214,10 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         }
 
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the assembly specified by the type.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the assembly specified by the type.
         /// </summary>
         /// <param name="typeInAssembly">The type in the assembly which should be searched for setup objects.</param>
-        /// <param name="typesToExclude">The <see cref="IIterativeSolver"/> types that should not be loaded.</param>
+        /// <param name="typesToExclude">The <see cref="IIterativeSolver{T}"/> types that should not be loaded.</param>
         public static void LoadSolverInformationFromAssembly(Type typeInAssembly, params Type[] typesToExclude)
         {
             if (typeInAssembly == null)
@@ -229,7 +229,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         }
 
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the specified assembly.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the specified assembly.
         /// </summary>
         /// <param name="assembly">The assembly which will be searched for setup objects.</param>
         public static void LoadSolverInformationFromAssembly(Assembly assembly)
@@ -238,10 +238,10 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         }
 
         /// <summary>
-        /// Loads the available <see cref="IIterativeSolverSetup"/> objects from the specified assembly.
+        /// Loads the available <see cref="IIterativeSolverSetup{T}"/> objects from the specified assembly.
         /// </summary>
         /// <param name="assembly">The assembly which will be searched for setup objects.</param>
-        /// <param name="typesToExclude">The <see cref="IIterativeSolver"/> types that should not be loaded.</param>
+        /// <param name="typesToExclude">The <see cref="IIterativeSolver{T}"/> types that should not be loaded.</param>
         public static void LoadSolverInformationFromAssembly(Assembly assembly, params Type[] typesToExclude)
         {
             if (assembly == null)
@@ -373,7 +373,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         }
 
         /// <summary>
-        /// Sets the <see cref="IIterator"/> that will be used to track the iterative process.
+        /// Sets the <see cref="IIterator{T}"/> that will be used to track the iterative process.
         /// </summary>
         /// <param name="iterator">The iterator.</param>
         public void SetIterator(IIterator<float> iterator)

src/Numerics/LinearAlgebra/Single/Solvers/Iterative/GpBiCg.cs

@@ -103,7 +103,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// Initializes a new instance of the <see cref="GpBiCg"/> class.
         /// </summary>
         /// <remarks>
-        /// When using this constructor the solver will use the <see cref="IIterator"/> with
+        /// When using this constructor the solver will use the <see cref="IIterator{T}"/> with
         /// the standard settings and a default preconditioner.
         /// </remarks>
         public GpBiCg()
@@ -119,17 +119,17 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// When using this constructor the solver will use a default preconditioner.
         /// </para>
         /// <para>
-        /// The main advantages of using a user defined <see cref="IIterator"/> are:
+        /// The main advantages of using a user defined <see cref="IIterator{T}"/> are:
         /// <list type="number">
         /// <item>It is possible to set the desired convergence limits.</item>
         /// <item>
         /// It is possible to check the reason for which the solver finished 
-        /// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
+        /// the iterative procedure by calling the <see cref="IIterator{T}.Status"/> property.
         /// </item>
         /// </list>
         /// </para>
         /// </remarks>
-        /// <param name="iterator">The <see cref="IIterator"/> that will be used to monitor the iterative process.</param>
+        /// <param name="iterator">The <see cref="IIterator{T}"/> that will be used to monitor the iterative process.</param>
         public GpBiCg(IIterator<float> iterator)
             : this(null, iterator)
         {
@@ -139,7 +139,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// Initializes a new instance of the <see cref="GpBiCg"/> class.
         /// </summary>
         /// <remarks>
-        /// When using this constructor the solver will use the <see cref="IIterator"/> with
+        /// When using this constructor the solver will use the <see cref="IIterator{T}"/> with
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
@@ -153,18 +153,18 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// </summary>
         /// <remarks>
         /// <para>
-        /// The main advantages of using a user defined <see cref="IIterator"/> are:
+        /// The main advantages of using a user defined <see cref="IIterator{T}"/> are:
         /// <list type="number">
         /// <item>It is possible to set the desired convergence limits.</item>
         /// <item>
         /// It is possible to check the reason for which the solver finished 
-        /// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
+        /// the iterative procedure by calling the <see cref="IIterator{T}.Status"/> property.
         /// </item>
         /// </list>
         /// </para>
         /// </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"/> that will be used to monitor the iterative process.</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)
         {
             _iterator = iterator;
@@ -219,7 +219,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         }
 
         /// <summary>
-        /// Sets the <see cref="IIterator"/> that will be used to track the iterative process.
+        /// Sets the <see cref="IIterator{T}"/> that will be used to track the iterative process.
         /// </summary>
         /// <param name="iterator">The iterator.</param>
         public void SetIterator(IIterator<float> iterator)

src/Numerics/LinearAlgebra/Single/Solvers/Iterative/MlkBiCgStab.cs

@@ -105,7 +105,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// Initializes a new instance of the <see cref="MlkBiCgStab"/> class.
         /// </summary>
         /// <remarks>
-        /// When using this constructor the solver will use the <see cref="IIterator"/> with
+        /// When using this constructor the solver will use the <see cref="IIterator{T}"/> with
         /// the standard settings and a default preconditioner.
         /// </remarks>
         public MlkBiCgStab() : this(null, null)
@@ -120,17 +120,17 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// When using this constructor the solver will use a default preconditioner.
         /// </para>
         /// <para>
-        /// The main advantages of using a user defined <see cref="IIterator"/> are:
+        /// The main advantages of using a user defined <see cref="IIterator{T}"/> are:
         /// <list type="number">
         /// <item>It is possible to set the desired convergence limits.</item>
         /// <item>
         /// It is possible to check the reason for which the solver finished 
-        /// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
+        /// the iterative procedure by calling the <see cref="IIterator{T}.Status"/> property.
         /// </item>
         /// </list>
         /// </para>
         /// </remarks>
-        /// <param name="iterator">The <see cref="IIterator"/> that will be used to monitor the iterative process.</param>
+        /// <param name="iterator">The <see cref="IIterator{T}"/> that will be used to monitor the iterative process.</param>
         public MlkBiCgStab(IIterator<float> iterator)
             : this(null, iterator)
         {
@@ -140,7 +140,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// Initializes a new instance of the <see cref="MlkBiCgStab"/> class.
         /// </summary>
         /// <remarks>
-        /// When using this constructor the solver will use the <see cref="IIterator"/> with
+        /// When using this constructor the solver will use the <see cref="IIterator{T}"/> with
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
@@ -153,18 +153,18 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// </summary>
         /// <remarks>
         /// <para>
-        /// The main advantages of using a user defined <see cref="IIterator"/> are:
+        /// The main advantages of using a user defined <see cref="IIterator{T}"/> are:
         /// <list type="number">
         /// <item>It is possible to set the desired convergence limits.</item>
         /// <item>
         /// It is possible to check the reason for which the solver finished 
-        /// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
+        /// the iterative procedure by calling the <see cref="IIterator{T}.Status"/> property.
         /// </item>
         /// </list>
         /// </para>
         /// </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"/> that will be used to monitor the iterative process.</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)
         {
             _iterator = iterator;
@@ -216,7 +216,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         }
 
         /// <summary>
-        /// Sets the <see cref="IIterator"/> that will be used to track the iterative process.
+        /// Sets the <see cref="IIterator{T}"/> that will be used to track the iterative process.
         /// </summary>
         /// <param name="iterator">The iterator.</param>
         public void SetIterator(IIterator<float> iterator)

src/Numerics/LinearAlgebra/Single/Solvers/Iterative/TFQMR.cs

@@ -81,7 +81,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// Initializes a new instance of the <see cref="TFQMR"/> class.
         /// </summary>
         /// <remarks>
-        /// When using this constructor the solver will use the <see cref="IIterator"/> with
+        /// When using this constructor the solver will use the <see cref="IIterator{T}"/> with
         /// the standard settings and a default preconditioner.
         /// </remarks>
         public TFQMR()
@@ -97,17 +97,17 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// When using this constructor the solver will use a default preconditioner.
         /// </para>
         /// <para>
-        /// The main advantages of using a user defined <see cref="IIterator"/> are:
+        /// The main advantages of using a user defined <see cref="IIterator{T}"/> are:
         /// <list type="number">
         /// <item>It is possible to set the desired convergence limits.</item>
         /// <item>
         /// It is possible to check the reason for which the solver finished 
-        /// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
+        /// the iterative procedure by calling the <see cref="IIterator{T}.Status"/> property.
         /// </item>
         /// </list>
         /// </para>
         /// </remarks>
-        /// <param name="iterator">The <see cref="IIterator"/> that will be used to monitor the iterative process.</param>
+        /// <param name="iterator">The <see cref="IIterator{T}"/> that will be used to monitor the iterative process.</param>
         public TFQMR(IIterator<float> iterator)
             : this(null, iterator)
         {
@@ -117,7 +117,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// Initializes a new instance of the <see cref="TFQMR"/> class.
         /// </summary>
         /// <remarks>
-        /// When using this constructor the solver will use the <see cref="IIterator"/> with
+        /// When using this constructor the solver will use the <see cref="IIterator{T}"/> with
         /// the standard settings.
         /// </remarks>
         /// <param name="preconditioner">The <see cref="IPreConditioner"/> that will be used to precondition the matrix equation.</param>
@@ -131,18 +131,18 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         /// </summary>
         /// <remarks>
         /// <para>
-        /// The main advantages of using a user defined <see cref="IIterator"/> are:
+        /// The main advantages of using a user defined <see cref="IIterator{T}"/> are:
         /// <list type="number">
         /// <item>It is possible to set the desired convergence limits.</item>
         /// <item>
         /// It is possible to check the reason for which the solver finished 
-        /// the iterative procedure by calling the <see cref="IIterator.Status"/> property.
+        /// the iterative procedure by calling the <see cref="IIterator{T}.Status"/> property.
         /// </item>
         /// </list>
         /// </para>
         /// </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"/> that will be used to monitor the iterative process.</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)
         {
             _iterator = iterator;
@@ -159,7 +159,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.Iterative
         }
 
         /// <summary>
-        /// Sets the <see cref="IIterator"/> that will be used to track the iterative process.
+        /// Sets the <see cref="IIterator{T}"/> that will be used to track the iterative process.
         /// </summary>
         /// <param name="iterator">The iterator.</param>
         public void SetIterator(IIterator<float> iterator)

src/Numerics/LinearAlgebra/Single/Solvers/Iterator.cs

@@ -52,7 +52,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers
         /// <summary>
         /// Creates a default iterator with all the <see cref="IIterationStopCriterium{T}"/> objects.
         /// </summary>
-        /// <returns>A new <see cref="IIterator"/> object.</returns>
+        /// <returns>A new <see cref="IIterator{T}"/> object.</returns>
         public static IIterator<float> CreateDefault()
         {
             var iterator = new Iterator();
@@ -156,10 +156,10 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers
         }
 
         /// <summary>
-        /// Indicates if the specific stop criterium is stored by the <see cref="IIterator"/>.
+        /// Indicates if the specific stop criterium is stored by the <see cref="IIterator{T}"/>.
         /// </summary>
         /// <param name="stopCriterium">The stop criterium.</param>
-        /// <returns><c>true</c> if the <see cref="IIterator"/> contains the stop criterium; otherwise <c>false</c>.</returns>
+        /// <returns><c>true</c> if the <see cref="IIterator{T}"/> contains the stop criterium; otherwise <c>false</c>.</returns>
         public bool Contains(IIterationStopCriterium<float> stopCriterium)
         {
             return stopCriterium != null && _stopCriterias.ContainsKey(stopCriterium.GetType());
@@ -203,7 +203,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers
 
         /// <summary>
         /// Determines the status of the iterative calculation based on the stop criteria stored
-        /// by the current <see cref="IIterator"/>. Result is set into <c>Status</c> field.
+        /// by the current <see cref="IIterator{T}"/>. Result is set into <c>Status</c> field.
         /// </summary>
         /// <param name="iterationNumber">The number of iterations that have passed so far.</param>
         /// <param name="solutionVector">The vector containing the current solution values.</param>
@@ -286,7 +286,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers
         }
 
         /// <summary>
-        /// Resets the <see cref="IIterator"/> to the pre-calculation state.
+        /// Resets the <see cref="IIterator{T}"/> to the pre-calculation state.
         /// </summary>
         public void ResetToPrecalculationState()
         {

src/Numerics/LinearAlgebra/Single/Solvers/Preconditioners/UnitPreconditioner.cs

@@ -28,14 +28,15 @@
 // 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 unit preconditioner. This preconditioner does not actually do anything
-    /// it is only used when running an <see cref="IIterativeSolver"/> without
+    /// it is only used when running an <see cref="IIterativeSolver{T}"/> without
     /// a preconditioner.
     /// </summary>
     internal sealed class UnitPreconditioner : IPreConditioner

src/Numerics/LinearAlgebra/Single/Solvers/StopCriterium/DivergenceStopCriterium.cs

@@ -206,7 +206,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.StopCriterium
 
         /// <summary>
         /// Determines the status of the iterative calculation based on the stop criteria stored
-        /// by the current <see cref="IIterationStopCriterium"/>. Result is set into <c>Status</c> field.
+        /// by the current <see cref="IIterationStopCriterium{T}"/>. Result is set into <c>Status</c> field.
         /// </summary>
         /// <param name="iterationNumber">The number of iterations that have passed so far.</param>
         /// <param name="solutionVector">The vector containing the current solution values.</param>
@@ -346,7 +346,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.StopCriterium
         }
 
         /// <summary>
-        /// Resets the <see cref="IIterationStopCriterium"/> to the pre-calculation state.
+        /// Resets the <see cref="IIterationStopCriterium{T}"/> to the pre-calculation state.
         /// </summary>
         public void ResetToPrecalculationState()
         {
@@ -357,7 +357,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.StopCriterium
 
         /// <summary>
         /// Gets the <see cref="StopLevel"/> which indicates what sort of stop criterium this
-        /// <see cref="IIterationStopCriterium"/> monitors.
+        /// <see cref="IIterationStopCriterium{T}"/> monitors.
         /// </summary>
         /// <value>Returns <see cref="LinearAlgebra.Solvers.StopCriterium.StopLevel.Divergence"/>.</value>
         public StopLevel StopLevel

src/Numerics/LinearAlgebra/Single/Solvers/StopCriterium/FailureStopCriterium.cs

@@ -64,7 +64,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.StopCriterium
 
         /// <summary>
         /// Determines the status of the iterative calculation based on the stop criteria stored
-        /// by the current <see cref="IIterationStopCriterium"/>. Result is set into <c>Status</c> field.
+        /// by the current <see cref="IIterationStopCriterium{T}"/>. Result is set into <c>Status</c> field.
         /// </summary>
         /// <param name="iterationNumber">The number of iterations that have passed so far.</param>
         /// <param name="solutionVector">The vector containing the current solution values.</param>
@@ -155,7 +155,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.StopCriterium
         }
 
         /// <summary>
-        /// Resets the <see cref="IIterationStopCriterium"/> to the pre-calculation state.
+        /// Resets the <see cref="IIterationStopCriterium{T}"/> to the pre-calculation state.
         /// </summary>
         public void ResetToPrecalculationState()
         {
@@ -165,7 +165,7 @@ namespace MathNet.Numerics.LinearAlgebra.Single.Solvers.StopCriterium
 
         /// <summary>
         /// Gets the <see cref="StopLevel"/>which indicates what sort of stop criterium this
-        /// <see cref="IIterationStopCriterium"/> monitors.
+        /// <see cref="IIterationStopCriterium{T}"/> monitors.
         /// </summary>
         /// <value>Returns <see cref="CalculationFailure"/>.</value>
         public StopLevel StopLevel