lu: added missing methods

src/Numerics/Algorithms/LinearAlgebra/Atlas/AtlasLinearAlgebraProvider.cs

@@ -2438,5 +2438,61 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.Atlas
         }
 
         #endregion
+
+        /// <summary>
+        /// Computes the LU factorization of A.
+        /// </summary>
+        /// <param name="a">An m by n matrix. The matrix is overwritten with the
+        /// the LU factorization On exit.</param>
+        /// <param name="order">The order of <paramref name="a"/></param>
+        /// <param name="ipiv">On exit, it contains the pivot indices. The size
+        /// of the array must be min(m,n).</param>
+        /// <remarks>This is equivalent to the GETRF LAPACK routine.</remarks>
+        public void LUFactor(double[] a, int order, int[] ipiv)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Computes the LU factorization of A.
+        /// </summary>
+        /// <param name="a">An m by n matrix. The matrix is overwritten with the
+        /// the LU factorization On exit.</param>
+        /// <param name="order">The order of <paramref name="a"/></param>
+        /// <param name="ipiv">On exit, it contains the pivot indices. The size
+        /// of the array must be min(m,n).</param>
+        /// <remarks>This is equivalent to the GETRF LAPACK routine.</remarks>
+        public void LUFactor(float[] a, int order, int[] ipiv)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Computes the LU factorization of A.
+        /// </summary>
+        /// <param name="a">An m by n matrix. The matrix is overwritten with the
+        /// the LU factorization On exit.</param>
+        /// <param name="order">The order of <paramref name="a"/></param>
+        /// <param name="ipiv">On exit, it contains the pivot indices. The size
+        /// of the array must be min(m,n).</param>
+        /// <remarks>This is equivalent to the GETRF LAPACK routine.</remarks>
+        public void LUFactor(Complex[] a, int order, int[] ipiv)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Computes the LU factorization of A.
+        /// </summary>
+        /// <param name="a">An m by n matrix. The matrix is overwritten with the
+        /// the LU factorization On exit.</param>
+        /// <param name="order">The order of <paramref name="a"/></param>
+        /// <param name="ipiv">On exit, it contains the pivot indices. The size
+        /// of the array must be min(m,n).</param>
+        /// <remarks>This is equivalent to the GETRF LAPACK routine.</remarks>
+        public void LUFactor(Complex32[] a, int order, int[] ipiv)
+        {
+            throw new NotImplementedException();
+        }
     }
 }

src/Numerics/Algorithms/LinearAlgebra/ManagedLinearAlgebraProvider.cs

@@ -3297,5 +3297,47 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
         }
 
         #endregion
+
+        /// <summary>
+        /// Computes the LU factorization of A.
+        /// </summary>
+        /// <param name="a">An m by n matrix. The matrix is overwritten with the
+        /// the LU factorization On exit.</param>
+        /// <param name="order">The order of <paramref name="a"/></param>
+        /// <param name="ipiv">On exit, it contains the pivot indices. The size
+        /// of the array must be min(m,n).</param>
+        /// <remarks>This is equivalent to the GETRF LAPACK routine.</remarks>
+        public void LUFactor(float[] a, int order, int[] ipiv)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Computes the LU factorization of A.
+        /// </summary>
+        /// <param name="a">An m by n matrix. The matrix is overwritten with the
+        /// the LU factorization On exit.</param>
+        /// <param name="order">The order of <paramref name="a"/></param>
+        /// <param name="ipiv">On exit, it contains the pivot indices. The size
+        /// of the array must be min(m,n).</param>
+        /// <remarks>This is equivalent to the GETRF LAPACK routine.</remarks>
+        public void LUFactor(Complex[] a, int order, int[] ipiv)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Computes the LU factorization of A.
+        /// </summary>
+        /// <param name="a">An m by n matrix. The matrix is overwritten with the
+        /// the LU factorization On exit.</param>
+        /// <param name="order">The order of <paramref name="a"/></param>
+        /// <param name="ipiv">On exit, it contains the pivot indices. The size
+        /// of the array must be min(m,n).</param>
+        /// <remarks>This is equivalent to the GETRF LAPACK routine.</remarks>
+        public void LUFactor(Complex32[] a, int order, int[] ipiv)
+        {
+            throw new NotImplementedException();
+        }
     }
 }

src/Numerics/Algorithms/LinearAlgebra/Mkl/MklLinearAlgebraProvider.cs

@@ -2437,5 +2437,61 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.Mkl
         }
 
         #endregion
+
+        /// <summary>
+        /// Computes the LU factorization of A.
+        /// </summary>
+        /// <param name="a">An m by n matrix. The matrix is overwritten with the
+        /// the LU factorization On exit.</param>
+        /// <param name="order">The order of <paramref name="a"/></param>
+        /// <param name="ipiv">On exit, it contains the pivot indices. The size
+        /// of the array must be min(m,n).</param>
+        /// <remarks>This is equivalent to the GETRF LAPACK routine.</remarks>
+        public void LUFactor(double[] a, int order, int[] ipiv)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Computes the LU factorization of A.
+        /// </summary>
+        /// <param name="a">An m by n matrix. The matrix is overwritten with the
+        /// the LU factorization On exit.</param>
+        /// <param name="order">The order of <paramref name="a"/></param>
+        /// <param name="ipiv">On exit, it contains the pivot indices. The size
+        /// of the array must be min(m,n).</param>
+        /// <remarks>This is equivalent to the GETRF LAPACK routine.</remarks>
+        public void LUFactor(float[] a, int order, int[] ipiv)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Computes the LU factorization of A.
+        /// </summary>
+        /// <param name="a">An m by n matrix. The matrix is overwritten with the
+        /// the LU factorization On exit.</param>
+        /// <param name="order">The order of <paramref name="a"/></param>
+        /// <param name="ipiv">On exit, it contains the pivot indices. The size
+        /// of the array must be min(m,n).</param>
+        /// <remarks>This is equivalent to the GETRF LAPACK routine.</remarks>
+        public void LUFactor(Complex[] a, int order, int[] ipiv)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Computes the LU factorization of A.
+        /// </summary>
+        /// <param name="a">An m by n matrix. The matrix is overwritten with the
+        /// the LU factorization On exit.</param>
+        /// <param name="order">The order of <paramref name="a"/></param>
+        /// <param name="ipiv">On exit, it contains the pivot indices. The size
+        /// of the array must be min(m,n).</param>
+        /// <remarks>This is equivalent to the GETRF LAPACK routine.</remarks>
+        public void LUFactor(Complex32[] a, int order, int[] ipiv)
+        {
+            throw new NotImplementedException();
+        }
     }
 }

src/Numerics/LinearAlgebra/Double/DenseVector.cs

@@ -749,15 +749,6 @@ namespace MathNet.Numerics.LinearAlgebra.Double
             return ret;
         }
 
-        /// <summary>
-        /// Returns the value of the absolute minimum element.
-        /// </summary>
-        /// <returns>The value of the absolute minimum element.</returns>
-        public override double AbsoluteMinimum()
-        {
-            return Math.Abs(this.Data[this.AbsoluteMinimumIndex()]);
-        }
-
         /// <summary>
         /// Returns the index of the absolute minimum element.
         /// </summary>
@@ -840,15 +831,6 @@ namespace MathNet.Numerics.LinearAlgebra.Double
                 i => this.Data[i] = values[i]);
         }
 
-        /// <summary>
-        /// Returns the value of maximum element.
-        /// </summary>
-        /// <returns>The value of maximum element.</returns>        
-        public override double Maximum()
-        {
-            return this.Data[this.MaximumIndex()];
-        }
-
         /// <summary>
         /// Returns the index of the absolute maximum element.
         /// </summary>
@@ -869,15 +851,6 @@ namespace MathNet.Numerics.LinearAlgebra.Double
             return index;
         }
 
-        /// <summary>
-        /// Returns the value of the minimum element.
-        /// </summary>
-        /// <returns>The value of the minimum element.</returns>
-        public override double Minimum()
-        {
-            return this.Data[this.MinimumIndex()];
-        }
-
         /// <summary>
         /// Returns the index of the minimum element.
         /// </summary>