diff --git a/src/Numerics/Algorithms/LinearAlgebra/Atlas/AtlasLinearAlgebraProvider.cs b/src/Numerics/Algorithms/LinearAlgebra/Atlas/AtlasLinearAlgebraProvider.cs
index 4b96eaad..14b44008 100644
--- a/src/Numerics/Algorithms/LinearAlgebra/Atlas/AtlasLinearAlgebraProvider.cs
+++ b/src/Numerics/Algorithms/LinearAlgebra/Atlas/AtlasLinearAlgebraProvider.cs
@@ -24,7 +24,7 @@
 
 /* This file is automatically generated - do not modify it. 
    Change NativeLinearAlgebraProvider.include instead.
-   Last generated on: 13/11/2009 08:19:56
+   Last generated on: 14/11/2009 20:09:22
 */
 namespace MathNet.Numerics.Algorithms.LinearAlgebra.Atlas
 {
@@ -116,12 +116,39 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.Atlas
             throw new NotImplementedException();
         }
 
+        /// <summary>
+        /// Multiples two matrices. <c>result = x * y</c>
+        /// </summary>
+        /// <param name="x">The x matrix.</param>
+        /// <param name="xRows">The number of rows in the x matrix.</param>
+        /// <param name="xColumns">The number of columns in the x matrix.</param>
+        /// <param name="y">The y matrix.</param>
+        /// <param name="yRows">The number of rows in the y matrix.</param>
+        /// <param name="yColumns">The number of columns in the y matrix.</param>
+        /// <param name="result">Where to store the result of the multiplication.</param>
+        /// <remarks>This is a simplified version of the BLAS GEMM routine with alpha
+        /// set to 1.0 and beta set to 0.0, and x and y are not transposed.</remarks>
         public void MatrixMultiply(double[] x, int xRows, int xColumns, double[] y, int yRows, int yColumns, double[] result)
         {
             throw new NotImplementedException();
         }
 
-        public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, double alpha, double[] a, double[] b, double beta, double[] c)
+        /// <summary>
+        /// Multiplies two matrices and updates another with the result. <c>c = alpha*op(a)*op(b) + beta*c</c>
+        /// </summary>
+        /// <param name="transposeA">How to transpose the <paramref name="a"/> matrix.</param>
+        /// <param name="transposeB">How to transpose the <paramref name="b"/> matrix.</param>
+        /// <param name="alpha">The value to scale <paramref name="a"/> matrix.</param>
+        /// <param name="a">The a matrix.</param>
+        /// <param name="aRows">The number of rows in the <paramref name="a"/> matrix.</param>
+        /// <param name="aColumns">The number of columns in the <paramref name="a"/> matrix.</param>
+        /// <param name="b">The b matrix</param>
+        /// <param name="bRows">The number of rows in the <paramref name="b"/> matrix.</param>
+        /// <param name="bColumns">The number of columns in the <paramref name="b"/> matrix.</param>
+        /// <param name="beta">The value to scale the <paramref name="c"/> matrix.</param>
+        /// <param name="c">The c matrix.</param>
+        public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, double alpha, double[] a, 
+			int aRows, int aColumns, double[] b, int bRows, int bColumns, double beta, double[] c)
         {
             throw new NotImplementedException();
         }
@@ -301,12 +328,39 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.Atlas
             throw new NotImplementedException();
         }
 
+        /// <summary>
+        /// Multiples two matrices. <c>result = x * y</c>
+        /// </summary>
+        /// <param name="x">The x matrix.</param>
+        /// <param name="xRows">The number of rows in the x matrix.</param>
+        /// <param name="xColumns">The number of columns in the x matrix.</param>
+        /// <param name="y">The y matrix.</param>
+        /// <param name="yRows">The number of rows in the y matrix.</param>
+        /// <param name="yColumns">The number of columns in the y matrix.</param>
+        /// <param name="result">Where to store the result of the multiplication.</param>
+        /// <remarks>This is a simplified version of the BLAS GEMM routine with alpha
+        /// set to 1.0 and beta set to 0.0, and x and y are not transposed.</remarks>
         public void MatrixMultiply(float[] x, int xRows, int xColumns, float[] y, int yRows, int yColumns, float[] result)
         {
             throw new NotImplementedException();
         }
 
-        public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, float alpha, float[] a, float[] b, float beta, float[] c)
+        /// <summary>
+        /// Multiplies two matrices and updates another with the result. <c>c = alpha*op(a)*op(b) + beta*c</c>
+        /// </summary>
+        /// <param name="transposeA">How to transpose the <paramref name="a"/> matrix.</param>
+        /// <param name="transposeB">How to transpose the <paramref name="b"/> matrix.</param>
+        /// <param name="alpha">The value to scale <paramref name="a"/> matrix.</param>
+        /// <param name="a">The a matrix.</param>
+        /// <param name="aRows">The number of rows in the <paramref name="a"/> matrix.</param>
+        /// <param name="aColumns">The number of columns in the <paramref name="a"/> matrix.</param>
+        /// <param name="b">The b matrix</param>
+        /// <param name="bRows">The number of rows in the <paramref name="b"/> matrix.</param>
+        /// <param name="bColumns">The number of columns in the <paramref name="b"/> matrix.</param>
+        /// <param name="beta">The value to scale the <paramref name="c"/> matrix.</param>
+        /// <param name="c">The c matrix.</param>
+        public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, float alpha, float[] a, 
+			int aRows, int aColumns, float[] b, int bRows, int bColumns, float beta, float[] c)
         {
             throw new NotImplementedException();
         }
@@ -486,12 +540,39 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.Atlas
             throw new NotImplementedException();
         }
 
+        /// <summary>
+        /// Multiples two matrices. <c>result = x * y</c>
+        /// </summary>
+        /// <param name="x">The x matrix.</param>
+        /// <param name="xRows">The number of rows in the x matrix.</param>
+        /// <param name="xColumns">The number of columns in the x matrix.</param>
+        /// <param name="y">The y matrix.</param>
+        /// <param name="yRows">The number of rows in the y matrix.</param>
+        /// <param name="yColumns">The number of columns in the y matrix.</param>
+        /// <param name="result">Where to store the result of the multiplication.</param>
+        /// <remarks>This is a simplified version of the BLAS GEMM routine with alpha
+        /// set to 1.0 and beta set to 0.0, and x and y are not transposed.</remarks>
         public void MatrixMultiply(Complex[] x, int xRows, int xColumns, Complex[] y, int yRows, int yColumns, Complex[] result)
         {
             throw new NotImplementedException();
         }
 
-        public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, Complex alpha, Complex[] a, Complex[] b, Complex beta, Complex[] c)
+        /// <summary>
+        /// Multiplies two matrices and updates another with the result. <c>c = alpha*op(a)*op(b) + beta*c</c>
+        /// </summary>
+        /// <param name="transposeA">How to transpose the <paramref name="a"/> matrix.</param>
+        /// <param name="transposeB">How to transpose the <paramref name="b"/> matrix.</param>
+        /// <param name="alpha">The value to scale <paramref name="a"/> matrix.</param>
+        /// <param name="a">The a matrix.</param>
+        /// <param name="aRows">The number of rows in the <paramref name="a"/> matrix.</param>
+        /// <param name="aColumns">The number of columns in the <paramref name="a"/> matrix.</param>
+        /// <param name="b">The b matrix</param>
+        /// <param name="bRows">The number of rows in the <paramref name="b"/> matrix.</param>
+        /// <param name="bColumns">The number of columns in the <paramref name="b"/> matrix.</param>
+        /// <param name="beta">The value to scale the <paramref name="c"/> matrix.</param>
+        /// <param name="c">The c matrix.</param>
+        public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, Complex alpha, Complex[] a, 
+			int aRows, int aColumns, Complex[] b, int bRows, int bColumns, Complex beta, Complex[] c)
         {
             throw new NotImplementedException();
         }
@@ -670,12 +751,39 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.Atlas
             throw new NotImplementedException();
         }
 
+        /// <summary>
+        /// Multiples two matrices. <c>result = x * y</c>
+        /// </summary>
+        /// <param name="x">The x matrix.</param>
+        /// <param name="xRows">The number of rows in the x matrix.</param>
+        /// <param name="xColumns">The number of columns in the x matrix.</param>
+        /// <param name="y">The y matrix.</param>
+        /// <param name="yRows">The number of rows in the y matrix.</param>
+        /// <param name="yColumns">The number of columns in the y matrix.</param>
+        /// <param name="result">Where to store the result of the multiplication.</param>
+        /// <remarks>This is a simplified version of the BLAS GEMM routine with alpha
+        /// set to 1.0 and beta set to 0.0, and x and y are not transposed.</remarks>
         public void MatrixMultiply(Complex32[] x, int xRows, int xColumns, Complex32[] y, int yRows, int yColumns, Complex32[] result)
         {
             throw new NotImplementedException();
         }
 
-        public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, Complex32 alpha, Complex32[] a, Complex32[] b, Complex32 beta, Complex32[] c)
+        /// <summary>
+        /// Multiplies two matrices and updates another with the result. <c>c = alpha*op(a)*op(b) + beta*c</c>
+        /// </summary>
+        /// <param name="transposeA">How to transpose the <paramref name="a"/> matrix.</param>
+        /// <param name="transposeB">How to transpose the <paramref name="b"/> matrix.</param>
+        /// <param name="alpha">The value to scale <paramref name="a"/> matrix.</param>
+        /// <param name="a">The a matrix.</param>
+        /// <param name="aRows">The number of rows in the <paramref name="a"/> matrix.</param>
+        /// <param name="aColumns">The number of columns in the <paramref name="a"/> matrix.</param>
+        /// <param name="b">The b matrix</param>
+        /// <param name="bRows">The number of rows in the <paramref name="b"/> matrix.</param>
+        /// <param name="bColumns">The number of columns in the <paramref name="b"/> matrix.</param>
+        /// <param name="beta">The value to scale the <paramref name="c"/> matrix.</param>
+        /// <param name="c">The c matrix.</param>
+        public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, Complex32 alpha, Complex32[] a, 
+			int aRows, int aColumns, Complex32[] b, int bRows, int bColumns, Complex32 beta, Complex32[] c)
         {
             throw new NotImplementedException();
         }
diff --git a/src/Numerics/Algorithms/LinearAlgebra/ILinearAlgebraProviderOfT.cs b/src/Numerics/Algorithms/LinearAlgebra/ILinearAlgebraProviderOfT.cs
index 4bde927a..c90e7be1 100644
--- a/src/Numerics/Algorithms/LinearAlgebra/ILinearAlgebraProviderOfT.cs
+++ b/src/Numerics/Algorithms/LinearAlgebra/ILinearAlgebraProviderOfT.cs
@@ -193,10 +193,15 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
         /// <param name="transposeB">How to transpose the <paramref name="b"/> matrix.</param>
         /// <param name="alpha">The value to scale <paramref name="a"/> matrix.</param>
         /// <param name="a">The a matrix.</param>
+        /// <param name="aRows">The number of rows in the <paramref name="a"/> matrix.</param>
+        /// <param name="aColumns">The number of columns in the <paramref name="a"/> matrix.</param>
         /// <param name="b">The b matrix</param>
+        /// <param name="bRows">The number of rows in the <paramref name="b"/> matrix.</param>
+        /// <param name="bColumns">The number of columns in the <paramref name="b"/> matrix.</param>
         /// <param name="beta">The value to scale the <paramref name="c"/> matrix.</param>
         /// <param name="c">The c matrix.</param>
-        void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, T alpha, T[] a, T[] b, T beta, T[] c);
+        void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, T alpha, T[] a, 
+            int aRows, int aColumns, T[] b, int bRows, int bColumns, T beta, T[] c);
 
         /// <summary>
         /// Computes the LU factorization of A.
diff --git a/src/Numerics/Algorithms/LinearAlgebra/ManagedLinearAlgebraProvider.cs b/src/Numerics/Algorithms/LinearAlgebra/ManagedLinearAlgebraProvider.cs
index a8eed634..81bbf501 100644
--- a/src/Numerics/Algorithms/LinearAlgebra/ManagedLinearAlgebraProvider.cs
+++ b/src/Numerics/Algorithms/LinearAlgebra/ManagedLinearAlgebraProvider.cs
@@ -340,7 +340,22 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
             });
         }
 
-        public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, double alpha, double[] a, double[] b, double beta, double[] c)
+        /// <summary>
+        /// Multiplies two matrices and updates another with the result. <c>c = alpha*op(a)*op(b) + beta*c</c>
+        /// </summary>
+        /// <param name="transposeA">How to transpose the <paramref name="a"/> matrix.</param>
+        /// <param name="transposeB">How to transpose the <paramref name="b"/> matrix.</param>
+        /// <param name="alpha">The value to scale <paramref name="a"/> matrix.</param>
+        /// <param name="a">The a matrix.</param>
+        /// <param name="aRows">The number of rows in the <paramref name="a"/> matrix.</param>
+        /// <param name="aColumns">The number of columns in the <paramref name="a"/> matrix.</param>
+        /// <param name="b">The b matrix</param>
+        /// <param name="bRows">The number of rows in the <paramref name="b"/> matrix.</param>
+        /// <param name="bColumns">The number of columns in the <paramref name="b"/> matrix.</param>
+        /// <param name="beta">The value to scale the <paramref name="c"/> matrix.</param>
+        /// <param name="c">The c matrix.</param>
+        public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, double alpha, double[] a, 
+            int aRows, int aColumns, double[] b, int bRows, int bColumns, double beta, double[] c)
         {
             throw new NotImplementedException();
         }
@@ -756,7 +771,22 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
             });
         }
 
-        public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, float alpha, float[] a, float[] b, float beta, float[] c)
+        /// <summary>
+        /// Multiplies two matrices and updates another with the result. <c>c = alpha*op(a)*op(b) + beta*c</c>
+        /// </summary>
+        /// <param name="transposeA">How to transpose the <paramref name="a"/> matrix.</param>
+        /// <param name="transposeB">How to transpose the <paramref name="b"/> matrix.</param>
+        /// <param name="alpha">The value to scale <paramref name="a"/> matrix.</param>
+        /// <param name="a">The a matrix.</param>
+        /// <param name="aRows">The number of rows in the <paramref name="a"/> matrix.</param>
+        /// <param name="aColumns">The number of columns in the <paramref name="a"/> matrix.</param>
+        /// <param name="b">The b matrix</param>
+        /// <param name="bRows">The number of rows in the <paramref name="b"/> matrix.</param>
+        /// <param name="bColumns">The number of columns in the <paramref name="b"/> matrix.</param>
+        /// <param name="beta">The value to scale the <paramref name="c"/> matrix.</param>
+        /// <param name="c">The c matrix.</param>
+        public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, float alpha, float[] a, 
+            int aRows, int aColumns, float[] b, int bRows, int bColumns, float beta, float[] c)
         {
             throw new NotImplementedException();
         }
@@ -1172,7 +1202,22 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
                 });
         }
 
-        public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, Complex alpha, Complex[] a, Complex[] b, Complex beta, Complex[] c)
+        /// <summary>
+        /// Multiplies two matrices and updates another with the result. <c>c = alpha*op(a)*op(b) + beta*c</c>
+        /// </summary>
+        /// <param name="transposeA">How to transpose the <paramref name="a"/> matrix.</param>
+        /// <param name="transposeB">How to transpose the <paramref name="b"/> matrix.</param>
+        /// <param name="alpha">The value to scale <paramref name="a"/> matrix.</param>
+        /// <param name="a">The a matrix.</param>
+        /// <param name="aRows">The number of rows in the <paramref name="a"/> matrix.</param>
+        /// <param name="aColumns">The number of columns in the <paramref name="a"/> matrix.</param>
+        /// <param name="b">The b matrix</param>
+        /// <param name="bRows">The number of rows in the <paramref name="b"/> matrix.</param>
+        /// <param name="bColumns">The number of columns in the <paramref name="b"/> matrix.</param>
+        /// <param name="beta">The value to scale the <paramref name="c"/> matrix.</param>
+        /// <param name="c">The c matrix.</param>
+        public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, Complex alpha, Complex[] a, 
+            int aRows, int aColumns, Complex[] b, int bRows, int bColumns, Complex beta, Complex[] c)
         {
             throw new NotImplementedException();
         }
@@ -1588,7 +1633,22 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
             });
         }
 
-        public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, Complex32 alpha, Complex32[] a, Complex32[] b, Complex32 beta, Complex32[] c)
+        /// <summary>
+        /// Multiplies two matrices and updates another with the result. <c>c = alpha*op(a)*op(b) + beta*c</c>
+        /// </summary>
+        /// <param name="transposeA">How to transpose the <paramref name="a"/> matrix.</param>
+        /// <param name="transposeB">How to transpose the <paramref name="b"/> matrix.</param>
+        /// <param name="alpha">The value to scale <paramref name="a"/> matrix.</param>
+        /// <param name="a">The a matrix.</param>
+        /// <param name="aRows">The number of rows in the <paramref name="a"/> matrix.</param>
+        /// <param name="aColumns">The number of columns in the <paramref name="a"/> matrix.</param>
+        /// <param name="b">The b matrix</param>
+        /// <param name="bRows">The number of rows in the <paramref name="b"/> matrix.</param>
+        /// <param name="bColumns">The number of columns in the <paramref name="b"/> matrix.</param>
+        /// <param name="beta">The value to scale the <paramref name="c"/> matrix.</param>
+        /// <param name="c">The c matrix.</param>
+        public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, Complex32 alpha, Complex32[] a, 
+            int aRows, int aColumns, Complex32[] b, int bRows, int bColumns, Complex32 beta, Complex32[] c)
         {
             throw new NotImplementedException();
         }
diff --git a/src/Numerics/Algorithms/LinearAlgebra/Mkl/MklLinearAlgebraProvider.cs b/src/Numerics/Algorithms/LinearAlgebra/Mkl/MklLinearAlgebraProvider.cs
index ac0507c9..2c49c8f6 100644
--- a/src/Numerics/Algorithms/LinearAlgebra/Mkl/MklLinearAlgebraProvider.cs
+++ b/src/Numerics/Algorithms/LinearAlgebra/Mkl/MklLinearAlgebraProvider.cs
@@ -24,7 +24,7 @@
 
 /* This file is automatically generated - do not modify it. 
    Change NativeLinearAlgebraProvider.include instead.
-   Last generated on: 13/11/2009 08:19:48
+   Last generated on: 14/11/2009 20:09:20
 */
 namespace MathNet.Numerics.Algorithms.LinearAlgebra.Mkl
 {
@@ -116,12 +116,39 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.Mkl
             throw new NotImplementedException();
         }
 
+        /// <summary>
+        /// Multiples two matrices. <c>result = x * y</c>
+        /// </summary>
+        /// <param name="x">The x matrix.</param>
+        /// <param name="xRows">The number of rows in the x matrix.</param>
+        /// <param name="xColumns">The number of columns in the x matrix.</param>
+        /// <param name="y">The y matrix.</param>
+        /// <param name="yRows">The number of rows in the y matrix.</param>
+        /// <param name="yColumns">The number of columns in the y matrix.</param>
+        /// <param name="result">Where to store the result of the multiplication.</param>
+        /// <remarks>This is a simplified version of the BLAS GEMM routine with alpha
+        /// set to 1.0 and beta set to 0.0, and x and y are not transposed.</remarks>
         public void MatrixMultiply(double[] x, int xRows, int xColumns, double[] y, int yRows, int yColumns, double[] result)
         {
             throw new NotImplementedException();
         }
 
-        public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, double alpha, double[] a, double[] b, double beta, double[] c)
+        /// <summary>
+        /// Multiplies two matrices and updates another with the result. <c>c = alpha*op(a)*op(b) + beta*c</c>
+        /// </summary>
+        /// <param name="transposeA">How to transpose the <paramref name="a"/> matrix.</param>
+        /// <param name="transposeB">How to transpose the <paramref name="b"/> matrix.</param>
+        /// <param name="alpha">The value to scale <paramref name="a"/> matrix.</param>
+        /// <param name="a">The a matrix.</param>
+        /// <param name="aRows">The number of rows in the <paramref name="a"/> matrix.</param>
+        /// <param name="aColumns">The number of columns in the <paramref name="a"/> matrix.</param>
+        /// <param name="b">The b matrix</param>
+        /// <param name="bRows">The number of rows in the <paramref name="b"/> matrix.</param>
+        /// <param name="bColumns">The number of columns in the <paramref name="b"/> matrix.</param>
+        /// <param name="beta">The value to scale the <paramref name="c"/> matrix.</param>
+        /// <param name="c">The c matrix.</param>
+        public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, double alpha, double[] a, 
+			int aRows, int aColumns, double[] b, int bRows, int bColumns, double beta, double[] c)
         {
             throw new NotImplementedException();
         }
@@ -301,12 +328,39 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.Mkl
             throw new NotImplementedException();
         }
 
+        /// <summary>
+        /// Multiples two matrices. <c>result = x * y</c>
+        /// </summary>
+        /// <param name="x">The x matrix.</param>
+        /// <param name="xRows">The number of rows in the x matrix.</param>
+        /// <param name="xColumns">The number of columns in the x matrix.</param>
+        /// <param name="y">The y matrix.</param>
+        /// <param name="yRows">The number of rows in the y matrix.</param>
+        /// <param name="yColumns">The number of columns in the y matrix.</param>
+        /// <param name="result">Where to store the result of the multiplication.</param>
+        /// <remarks>This is a simplified version of the BLAS GEMM routine with alpha
+        /// set to 1.0 and beta set to 0.0, and x and y are not transposed.</remarks>
         public void MatrixMultiply(float[] x, int xRows, int xColumns, float[] y, int yRows, int yColumns, float[] result)
         {
             throw new NotImplementedException();
         }
 
-        public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, float alpha, float[] a, float[] b, float beta, float[] c)
+        /// <summary>
+        /// Multiplies two matrices and updates another with the result. <c>c = alpha*op(a)*op(b) + beta*c</c>
+        /// </summary>
+        /// <param name="transposeA">How to transpose the <paramref name="a"/> matrix.</param>
+        /// <param name="transposeB">How to transpose the <paramref name="b"/> matrix.</param>
+        /// <param name="alpha">The value to scale <paramref name="a"/> matrix.</param>
+        /// <param name="a">The a matrix.</param>
+        /// <param name="aRows">The number of rows in the <paramref name="a"/> matrix.</param>
+        /// <param name="aColumns">The number of columns in the <paramref name="a"/> matrix.</param>
+        /// <param name="b">The b matrix</param>
+        /// <param name="bRows">The number of rows in the <paramref name="b"/> matrix.</param>
+        /// <param name="bColumns">The number of columns in the <paramref name="b"/> matrix.</param>
+        /// <param name="beta">The value to scale the <paramref name="c"/> matrix.</param>
+        /// <param name="c">The c matrix.</param>
+        public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, float alpha, float[] a, 
+			int aRows, int aColumns, float[] b, int bRows, int bColumns, float beta, float[] c)
         {
             throw new NotImplementedException();
         }
@@ -486,12 +540,39 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.Mkl
             throw new NotImplementedException();
         }
 
+        /// <summary>
+        /// Multiples two matrices. <c>result = x * y</c>
+        /// </summary>
+        /// <param name="x">The x matrix.</param>
+        /// <param name="xRows">The number of rows in the x matrix.</param>
+        /// <param name="xColumns">The number of columns in the x matrix.</param>
+        /// <param name="y">The y matrix.</param>
+        /// <param name="yRows">The number of rows in the y matrix.</param>
+        /// <param name="yColumns">The number of columns in the y matrix.</param>
+        /// <param name="result">Where to store the result of the multiplication.</param>
+        /// <remarks>This is a simplified version of the BLAS GEMM routine with alpha
+        /// set to 1.0 and beta set to 0.0, and x and y are not transposed.</remarks>
         public void MatrixMultiply(Complex[] x, int xRows, int xColumns, Complex[] y, int yRows, int yColumns, Complex[] result)
         {
             throw new NotImplementedException();
         }
 
-        public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, Complex alpha, Complex[] a, Complex[] b, Complex beta, Complex[] c)
+        /// <summary>
+        /// Multiplies two matrices and updates another with the result. <c>c = alpha*op(a)*op(b) + beta*c</c>
+        /// </summary>
+        /// <param name="transposeA">How to transpose the <paramref name="a"/> matrix.</param>
+        /// <param name="transposeB">How to transpose the <paramref name="b"/> matrix.</param>
+        /// <param name="alpha">The value to scale <paramref name="a"/> matrix.</param>
+        /// <param name="a">The a matrix.</param>
+        /// <param name="aRows">The number of rows in the <paramref name="a"/> matrix.</param>
+        /// <param name="aColumns">The number of columns in the <paramref name="a"/> matrix.</param>
+        /// <param name="b">The b matrix</param>
+        /// <param name="bRows">The number of rows in the <paramref name="b"/> matrix.</param>
+        /// <param name="bColumns">The number of columns in the <paramref name="b"/> matrix.</param>
+        /// <param name="beta">The value to scale the <paramref name="c"/> matrix.</param>
+        /// <param name="c">The c matrix.</param>
+        public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, Complex alpha, Complex[] a, 
+			int aRows, int aColumns, Complex[] b, int bRows, int bColumns, Complex beta, Complex[] c)
         {
             throw new NotImplementedException();
         }
@@ -670,12 +751,39 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.Mkl
             throw new NotImplementedException();
         }
 
+        /// <summary>
+        /// Multiples two matrices. <c>result = x * y</c>
+        /// </summary>
+        /// <param name="x">The x matrix.</param>
+        /// <param name="xRows">The number of rows in the x matrix.</param>
+        /// <param name="xColumns">The number of columns in the x matrix.</param>
+        /// <param name="y">The y matrix.</param>
+        /// <param name="yRows">The number of rows in the y matrix.</param>
+        /// <param name="yColumns">The number of columns in the y matrix.</param>
+        /// <param name="result">Where to store the result of the multiplication.</param>
+        /// <remarks>This is a simplified version of the BLAS GEMM routine with alpha
+        /// set to 1.0 and beta set to 0.0, and x and y are not transposed.</remarks>
         public void MatrixMultiply(Complex32[] x, int xRows, int xColumns, Complex32[] y, int yRows, int yColumns, Complex32[] result)
         {
             throw new NotImplementedException();
         }
 
-        public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, Complex32 alpha, Complex32[] a, Complex32[] b, Complex32 beta, Complex32[] c)
+        /// <summary>
+        /// Multiplies two matrices and updates another with the result. <c>c = alpha*op(a)*op(b) + beta*c</c>
+        /// </summary>
+        /// <param name="transposeA">How to transpose the <paramref name="a"/> matrix.</param>
+        /// <param name="transposeB">How to transpose the <paramref name="b"/> matrix.</param>
+        /// <param name="alpha">The value to scale <paramref name="a"/> matrix.</param>
+        /// <param name="a">The a matrix.</param>
+        /// <param name="aRows">The number of rows in the <paramref name="a"/> matrix.</param>
+        /// <param name="aColumns">The number of columns in the <paramref name="a"/> matrix.</param>
+        /// <param name="b">The b matrix</param>
+        /// <param name="bRows">The number of rows in the <paramref name="b"/> matrix.</param>
+        /// <param name="bColumns">The number of columns in the <paramref name="b"/> matrix.</param>
+        /// <param name="beta">The value to scale the <paramref name="c"/> matrix.</param>
+        /// <param name="c">The c matrix.</param>
+        public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, Complex32 alpha, Complex32[] a, 
+			int aRows, int aColumns, Complex32[] b, int bRows, int bColumns, Complex32 beta, Complex32[] c)
         {
             throw new NotImplementedException();
         }
diff --git a/src/Numerics/Algorithms/LinearAlgebra/NativeAlgebraProvider.include b/src/Numerics/Algorithms/LinearAlgebra/NativeAlgebraProvider.include
index e4bb7d31..ac80d7fd 100644
--- a/src/Numerics/Algorithms/LinearAlgebra/NativeAlgebraProvider.include
+++ b/src/Numerics/Algorithms/LinearAlgebra/NativeAlgebraProvider.include
@@ -116,12 +116,39 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.<#=library#>
             throw new NotImplementedException();
         }
 
+        /// <summary>
+        /// Multiples two matrices. <c>result = x * y</c>
+        /// </summary>
+        /// <param name="x">The x matrix.</param>
+        /// <param name="xRows">The number of rows in the x matrix.</param>
+        /// <param name="xColumns">The number of columns in the x matrix.</param>
+        /// <param name="y">The y matrix.</param>
+        /// <param name="yRows">The number of rows in the y matrix.</param>
+        /// <param name="yColumns">The number of columns in the y matrix.</param>
+        /// <param name="result">Where to store the result of the multiplication.</param>
+        /// <remarks>This is a simplified version of the BLAS GEMM routine with alpha
+        /// set to 1.0 and beta set to 0.0, and x and y are not transposed.</remarks>
         public void MatrixMultiply(double[] x, int xRows, int xColumns, double[] y, int yRows, int yColumns, double[] result)
         {
             throw new NotImplementedException();
         }
 
-        public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, double alpha, double[] a, double[] b, double beta, double[] c)
+        /// <summary>
+        /// Multiplies two matrices and updates another with the result. <c>c = alpha*op(a)*op(b) + beta*c</c>
+        /// </summary>
+        /// <param name="transposeA">How to transpose the <paramref name="a"/> matrix.</param>
+        /// <param name="transposeB">How to transpose the <paramref name="b"/> matrix.</param>
+        /// <param name="alpha">The value to scale <paramref name="a"/> matrix.</param>
+        /// <param name="a">The a matrix.</param>
+        /// <param name="aRows">The number of rows in the <paramref name="a"/> matrix.</param>
+        /// <param name="aColumns">The number of columns in the <paramref name="a"/> matrix.</param>
+        /// <param name="b">The b matrix</param>
+        /// <param name="bRows">The number of rows in the <paramref name="b"/> matrix.</param>
+        /// <param name="bColumns">The number of columns in the <paramref name="b"/> matrix.</param>
+        /// <param name="beta">The value to scale the <paramref name="c"/> matrix.</param>
+        /// <param name="c">The c matrix.</param>
+        public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, double alpha, double[] a, 
+			int aRows, int aColumns, double[] b, int bRows, int bColumns, double beta, double[] c)
         {
             throw new NotImplementedException();
         }
@@ -301,12 +328,39 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.<#=library#>
             throw new NotImplementedException();
         }
 
+        /// <summary>
+        /// Multiples two matrices. <c>result = x * y</c>
+        /// </summary>
+        /// <param name="x">The x matrix.</param>
+        /// <param name="xRows">The number of rows in the x matrix.</param>
+        /// <param name="xColumns">The number of columns in the x matrix.</param>
+        /// <param name="y">The y matrix.</param>
+        /// <param name="yRows">The number of rows in the y matrix.</param>
+        /// <param name="yColumns">The number of columns in the y matrix.</param>
+        /// <param name="result">Where to store the result of the multiplication.</param>
+        /// <remarks>This is a simplified version of the BLAS GEMM routine with alpha
+        /// set to 1.0 and beta set to 0.0, and x and y are not transposed.</remarks>
         public void MatrixMultiply(float[] x, int xRows, int xColumns, float[] y, int yRows, int yColumns, float[] result)
         {
             throw new NotImplementedException();
         }
 
-        public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, float alpha, float[] a, float[] b, float beta, float[] c)
+        /// <summary>
+        /// Multiplies two matrices and updates another with the result. <c>c = alpha*op(a)*op(b) + beta*c</c>
+        /// </summary>
+        /// <param name="transposeA">How to transpose the <paramref name="a"/> matrix.</param>
+        /// <param name="transposeB">How to transpose the <paramref name="b"/> matrix.</param>
+        /// <param name="alpha">The value to scale <paramref name="a"/> matrix.</param>
+        /// <param name="a">The a matrix.</param>
+        /// <param name="aRows">The number of rows in the <paramref name="a"/> matrix.</param>
+        /// <param name="aColumns">The number of columns in the <paramref name="a"/> matrix.</param>
+        /// <param name="b">The b matrix</param>
+        /// <param name="bRows">The number of rows in the <paramref name="b"/> matrix.</param>
+        /// <param name="bColumns">The number of columns in the <paramref name="b"/> matrix.</param>
+        /// <param name="beta">The value to scale the <paramref name="c"/> matrix.</param>
+        /// <param name="c">The c matrix.</param>
+        public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, float alpha, float[] a, 
+			int aRows, int aColumns, float[] b, int bRows, int bColumns, float beta, float[] c)
         {
             throw new NotImplementedException();
         }
@@ -486,12 +540,39 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.<#=library#>
             throw new NotImplementedException();
         }
 
+        /// <summary>
+        /// Multiples two matrices. <c>result = x * y</c>
+        /// </summary>
+        /// <param name="x">The x matrix.</param>
+        /// <param name="xRows">The number of rows in the x matrix.</param>
+        /// <param name="xColumns">The number of columns in the x matrix.</param>
+        /// <param name="y">The y matrix.</param>
+        /// <param name="yRows">The number of rows in the y matrix.</param>
+        /// <param name="yColumns">The number of columns in the y matrix.</param>
+        /// <param name="result">Where to store the result of the multiplication.</param>
+        /// <remarks>This is a simplified version of the BLAS GEMM routine with alpha
+        /// set to 1.0 and beta set to 0.0, and x and y are not transposed.</remarks>
         public void MatrixMultiply(Complex[] x, int xRows, int xColumns, Complex[] y, int yRows, int yColumns, Complex[] result)
         {
             throw new NotImplementedException();
         }
 
-        public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, Complex alpha, Complex[] a, Complex[] b, Complex beta, Complex[] c)
+        /// <summary>
+        /// Multiplies two matrices and updates another with the result. <c>c = alpha*op(a)*op(b) + beta*c</c>
+        /// </summary>
+        /// <param name="transposeA">How to transpose the <paramref name="a"/> matrix.</param>
+        /// <param name="transposeB">How to transpose the <paramref name="b"/> matrix.</param>
+        /// <param name="alpha">The value to scale <paramref name="a"/> matrix.</param>
+        /// <param name="a">The a matrix.</param>
+        /// <param name="aRows">The number of rows in the <paramref name="a"/> matrix.</param>
+        /// <param name="aColumns">The number of columns in the <paramref name="a"/> matrix.</param>
+        /// <param name="b">The b matrix</param>
+        /// <param name="bRows">The number of rows in the <paramref name="b"/> matrix.</param>
+        /// <param name="bColumns">The number of columns in the <paramref name="b"/> matrix.</param>
+        /// <param name="beta">The value to scale the <paramref name="c"/> matrix.</param>
+        /// <param name="c">The c matrix.</param>
+        public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, Complex alpha, Complex[] a, 
+			int aRows, int aColumns, Complex[] b, int bRows, int bColumns, Complex beta, Complex[] c)
         {
             throw new NotImplementedException();
         }
@@ -670,12 +751,39 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.<#=library#>
             throw new NotImplementedException();
         }
 
+        /// <summary>
+        /// Multiples two matrices. <c>result = x * y</c>
+        /// </summary>
+        /// <param name="x">The x matrix.</param>
+        /// <param name="xRows">The number of rows in the x matrix.</param>
+        /// <param name="xColumns">The number of columns in the x matrix.</param>
+        /// <param name="y">The y matrix.</param>
+        /// <param name="yRows">The number of rows in the y matrix.</param>
+        /// <param name="yColumns">The number of columns in the y matrix.</param>
+        /// <param name="result">Where to store the result of the multiplication.</param>
+        /// <remarks>This is a simplified version of the BLAS GEMM routine with alpha
+        /// set to 1.0 and beta set to 0.0, and x and y are not transposed.</remarks>
         public void MatrixMultiply(Complex32[] x, int xRows, int xColumns, Complex32[] y, int yRows, int yColumns, Complex32[] result)
         {
             throw new NotImplementedException();
         }
 
-        public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, Complex32 alpha, Complex32[] a, Complex32[] b, Complex32 beta, Complex32[] c)
+        /// <summary>
+        /// Multiplies two matrices and updates another with the result. <c>c = alpha*op(a)*op(b) + beta*c</c>
+        /// </summary>
+        /// <param name="transposeA">How to transpose the <paramref name="a"/> matrix.</param>
+        /// <param name="transposeB">How to transpose the <paramref name="b"/> matrix.</param>
+        /// <param name="alpha">The value to scale <paramref name="a"/> matrix.</param>
+        /// <param name="a">The a matrix.</param>
+        /// <param name="aRows">The number of rows in the <paramref name="a"/> matrix.</param>
+        /// <param name="aColumns">The number of columns in the <paramref name="a"/> matrix.</param>
+        /// <param name="b">The b matrix</param>
+        /// <param name="bRows">The number of rows in the <paramref name="b"/> matrix.</param>
+        /// <param name="bColumns">The number of columns in the <paramref name="b"/> matrix.</param>
+        /// <param name="beta">The value to scale the <paramref name="c"/> matrix.</param>
+        /// <param name="c">The c matrix.</param>
+        public void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, Complex32 alpha, Complex32[] a, 
+			int aRows, int aColumns, Complex32[] b, int bRows, int bColumns, Complex32 beta, Complex32[] c)
         {
             throw new NotImplementedException();
         }