native: a little more reorganizing and stylecop cleanup

src/Numerics/Algorithms/LinearAlgebra/ManagedLinearAlgebraProvider.Complex.cs

@@ -1,4 +1,4 @@
-// <copyright file="ManagedLinearAlgebraProvider.cs" company="Math.NET">
+// <copyright file="ManagedLinearAlgebraProvider.Complex.cs" company="Math.NET">
 // Math.NET Numerics, part of the Math.NET Project
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
@@ -33,7 +33,7 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
     /// <summary>
     /// The managed linear algebra provider.
     /// </summary>
-    public partial class ManagedLinearAlgebraProvider : ILinearAlgebraProvider
+    public partial class ManagedLinearAlgebraProvider
     {
         /// <summary>
         /// Adds a scaled vector to another: <c>y += alpha*x</c>.
@@ -1301,7 +1301,7 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
         /// <param name="rowDim">Number of rows</param>
         /// <param name="firstCol">Column start</param>
         /// <param name="colLimit">Total columns</param>
-        /// <param name="multipliers">Multipliears calculated previously</param>
+        /// <param name="multipliers">Multipliers calculated previously</param>
         /// <param name="availableCores">Number of available processors</param>
         private static void DoCholeskyStep(Complex[] data, int rowDim, int firstCol, int colLimit, Complex[] multipliers, int availableCores)
         {
@@ -1535,7 +1535,7 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
         /// Perform calculation of Q or R
         /// </summary>
         /// <param name="work">Work array</param>
-        /// <param name="workIndex">Index of colunn in work array</param>
+        /// <param name="workIndex">Index of column in work array</param>
         /// <param name="a">Q or R matrices</param>
         /// <param name="rowStart">The first row in </param>
         /// <param name="rowCount">The last row</param>
@@ -1584,7 +1584,7 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
         /// <param name="work">Work array</param>
         /// <param name="a">Initial matrix</param>
         /// <param name="rowCount">The number of rows in matrix</param>
-        /// <param name="row">The firts row</param>
+        /// <param name="row">The first row</param>
         /// <param name="column">Column index</param>
         private static void GenerateColumn(Complex[] work, Complex[] a, int rowCount, int row, int column)
         {
@@ -1871,9 +1871,9 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
         /// <param name="rowsA">The number of rows in the A matrix.</param>
         /// <param name="columnsA">The number of columns in the A matrix.</param>
         /// <param name="s">The singular values of A in ascending value.</param>
-        /// <param name="u">If <paramref name="computeVectors"/> is true, on exit U contains the left
+        /// <param name="u">If <paramref name="computeVectors"/> is <c>true</c>, on exit U contains the left
         /// singular vectors.</param>
-        /// <param name="vt">If <paramref name="computeVectors"/> is true, on exit VT contains the transposed
+        /// <param name="vt">If <paramref name="computeVectors"/> is <c>true</c>, on exit VT contains the transposed
         /// right singular vectors.</param>
         /// <remarks>This is equivalent to the GESVD LAPACK routine.</remarks>
         public virtual void SingularValueDecomposition(bool computeVectors, Complex[] a, int rowsA, int columnsA, Complex[] s, Complex[] u, Complex[] vt)
@@ -1926,9 +1926,9 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
         /// <param name="rowsA">The number of rows in the A matrix.</param>
         /// <param name="columnsA">The number of columns in the A matrix.</param>
         /// <param name="s">The singular values of A in ascending value.</param>
-        /// <param name="u">If <paramref name="computeVectors"/> is true, on exit U contains the left
+        /// <param name="u">If <paramref name="computeVectors"/> is <c>true</c>, on exit U contains the left
         /// singular vectors.</param>
-        /// <param name="vt">If <paramref name="computeVectors"/> is true, on exit VT contains the transposed
+        /// <param name="vt">If <paramref name="computeVectors"/> is <c>true</c>, on exit VT contains the transposed
         /// right singular vectors.</param>
         /// <param name="work">The work array. For real matrices, the work array should be at least
         /// Max(3*Min(M, N) + Max(M, N), 5*Min(M,N)). For complex matrices, 2*Min(M, N) + Max(M, N).

src/Numerics/Algorithms/LinearAlgebra/ManagedLinearAlgebraProvider.Complex32.cs

@@ -1,4 +1,4 @@
-// <copyright file="ManagedLinearAlgebraProvider.cs" company="Math.NET">
+// <copyright file="ManagedLinearAlgebraProvider.Complex32.cs" company="Math.NET">
 // Math.NET Numerics, part of the Math.NET Project
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
@@ -26,14 +26,13 @@
 namespace MathNet.Numerics.Algorithms.LinearAlgebra
 {
     using System;
-    using System.Numerics;
     using Properties;
     using Threading;
 
     /// <summary>
     /// The managed linear algebra provider.
     /// </summary>
-    public partial class ManagedLinearAlgebraProvider : ILinearAlgebraProvider
+    public partial class ManagedLinearAlgebraProvider
     {
         /// <summary>
         /// Adds a scaled vector to another: <c>y += alpha*x</c>.
@@ -1308,7 +1307,7 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
         /// <param name="rowDim">Number of rows</param>
         /// <param name="firstCol">Column start</param>
         /// <param name="colLimit">Total columns</param>
-        /// <param name="multipliers">Multipliears calculated previously</param>
+        /// <param name="multipliers">Multipliers calculated previously</param>
         /// <param name="availableCores">Number of available processors</param>
         private static void DoCholeskyStep(Complex32[] data, int rowDim, int firstCol, int colLimit, Complex32[] multipliers, int availableCores)
         {
@@ -1542,7 +1541,7 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
         /// Perform calculation of Q or R
         /// </summary>
         /// <param name="work">Work array</param>
-        /// <param name="workIndex">Index of colunn in work array</param>
+        /// <param name="workIndex">Index of column in work array</param>
         /// <param name="a">Q or R matrices</param>
         /// <param name="rowStart">The first row in </param>
         /// <param name="rowCount">The last row</param>
@@ -1591,7 +1590,7 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
         /// <param name="work">Work array</param>
         /// <param name="a">Initial matrix</param>
         /// <param name="rowCount">The number of rows in matrix</param>
-        /// <param name="row">The firts row</param>
+        /// <param name="row">The first row</param>
         /// <param name="column">Column index</param>
         private static void GenerateColumn(Complex32[] work, Complex32[] a, int rowCount, int row, int column)
         {
@@ -1878,9 +1877,9 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
         /// <param name="rowsA">The number of rows in the A matrix.</param>
         /// <param name="columnsA">The number of columns in the A matrix.</param>
         /// <param name="s">The singular values of A in ascending value.</param>
-        /// <param name="u">If <paramref name="computeVectors"/> is true, on exit U contains the left
+        /// <param name="u">If <paramref name="computeVectors"/> is <c>true</c>, on exit U contains the left
         /// singular vectors.</param>
-        /// <param name="vt">If <paramref name="computeVectors"/> is true, on exit VT contains the transposed
+        /// <param name="vt">If <paramref name="computeVectors"/> is <c>true</c>, on exit VT contains the transposed
         /// right singular vectors.</param>
         /// <remarks>This is equivalent to the GESVD LAPACK routine.</remarks>
         public virtual void SingularValueDecomposition(bool computeVectors, Complex32[] a, int rowsA, int columnsA, Complex32[] s, Complex32[] u, Complex32[] vt)
@@ -1933,9 +1932,9 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
         /// <param name="rowsA">The number of rows in the A matrix.</param>
         /// <param name="columnsA">The number of columns in the A matrix.</param>
         /// <param name="s">The singular values of A in ascending value.</param>
-        /// <param name="u">If <paramref name="computeVectors"/> is true, on exit U contains the left
+        /// <param name="u">If <paramref name="computeVectors"/> is <c>true</c>, on exit U contains the left
         /// singular vectors.</param>
-        /// <param name="vt">If <paramref name="computeVectors"/> is true, on exit VT contains the transposed
+        /// <param name="vt">If <paramref name="computeVectors"/> is <c>true</c>, on exit VT contains the transposed
         /// right singular vectors.</param>
         /// <param name="work">The work array. For real matrices, the work array should be at least
         /// Max(3*Min(M, N) + Max(M, N), 5*Min(M,N)). For complex matrices, 2*Min(M, N) + Max(M, N).

src/Numerics/Algorithms/LinearAlgebra/ManagedLinearAlgebraProvider.Double.cs

@@ -1,4 +1,4 @@
-// <copyright file="ManagedLinearAlgebraProvider.cs" company="Math.NET">
+// <copyright file="ManagedLinearAlgebraProvider.Double.cs" company="Math.NET">
 // Math.NET Numerics, part of the Math.NET Project
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
@@ -1286,7 +1286,7 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
         /// <param name="rowDim">Number of rows</param>
         /// <param name="firstCol">Column start</param>
         /// <param name="colLimit">Total columns</param>
-        /// <param name="multipliers">Multipliears calculated previously</param>
+        /// <param name="multipliers">Multipliers calculated previously</param>
         /// <param name="availableCores">Number of available processors</param>
         private static void DoCholeskyStep(double[] data, int rowDim, int firstCol, int colLimit, double[] multipliers, int availableCores)
         {
@@ -1520,7 +1520,7 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
         /// Perform calculation of Q or R
         /// </summary>
         /// <param name="work">Work array</param>
-        /// <param name="workIndex">Index of colunn in work array</param>
+        /// <param name="workIndex">Index of column in work array</param>
         /// <param name="a">Q or R matrices</param>
         /// <param name="rowStart">The first row in </param>
         /// <param name="rowCount">The last row</param>
@@ -1569,7 +1569,7 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
         /// <param name="work">Work array</param>
         /// <param name="a">Initial matrix</param>
         /// <param name="rowCount">The number of rows in matrix</param>
-        /// <param name="row">The firts row</param>
+        /// <param name="row">The first row</param>
         /// <param name="column">Column index</param>
         private static void GenerateColumn(double[] work, double[] a, int rowCount, int row, int column)
         {
@@ -1857,9 +1857,9 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
         /// <param name="rowsA">The number of rows in the A matrix.</param>
         /// <param name="columnsA">The number of columns in the A matrix.</param>
         /// <param name="s">The singular values of A in ascending value.</param>
-        /// <param name="u">If <paramref name="computeVectors"/> is true, on exit U contains the left
+        /// <param name="u">If <paramref name="computeVectors"/> is <c>true</c>, on exit U contains the left
         /// singular vectors.</param>
-        /// <param name="vt">If <paramref name="computeVectors"/> is true, on exit VT contains the transposed
+        /// <param name="vt">If <paramref name="computeVectors"/> is <c>true</c>, on exit VT contains the transposed
         /// right singular vectors.</param>
         /// <remarks>This is equivalent to the GESVD LAPACK routine.</remarks>
         public virtual void SingularValueDecomposition(bool computeVectors, double[] a, int rowsA, int columnsA, double[] s, double[] u, double[] vt)
@@ -1912,9 +1912,9 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
         /// <param name="rowsA">The number of rows in the A matrix.</param>
         /// <param name="columnsA">The number of columns in the A matrix.</param>
         /// <param name="s">The singular values of A in ascending value.</param>
-        /// <param name="u">If <paramref name="computeVectors"/> is true, on exit U contains the left
+        /// <param name="u">If <paramref name="computeVectors"/> is <c>true</c>, on exit U contains the left
         /// singular vectors.</param>
-        /// <param name="vt">If <paramref name="computeVectors"/> is true, on exit VT contains the transposed
+        /// <param name="vt">If <paramref name="computeVectors"/> is <c>true</c>, on exit VT contains the transposed
         /// right singular vectors.</param>
         /// <param name="work">The work array. For real matrices, the work array should be at least
         /// Max(3*Min(M, N) + Max(M, N), 5*Min(M,N)). For complex matrices, 2*Min(M, N) + Max(M, N).
@@ -2590,7 +2590,7 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
         }
 
         /// <summary>
-        /// Given the Cartesian coordinates (da, db) of a point p, these fucntion return the parameters da, db, c, and s 
+        /// Given the Cartesian coordinates (da, db) of a point p, these function return the parameters da, db, c, and s 
         /// associated with the Givens rotation that zeros the y-coordinate of the point.
         /// </summary>
         /// <param name="da">Provides the x-coordinate of the point p. On exit contains the parameter r associated with the Givens rotation</param>

src/Numerics/Algorithms/LinearAlgebra/ManagedLinearAlgebraProvider.Single.cs

@@ -1,4 +1,4 @@
-// <copyright file="ManagedLinearAlgebraProvider.cs" company="Math.NET">
+// <copyright file="ManagedLinearAlgebraProvider.Single.cs" company="Math.NET">
 // Math.NET Numerics, part of the Math.NET Project
 // http://numerics.mathdotnet.com
 // http://github.com/mathnet/mathnet-numerics
@@ -26,14 +26,13 @@
 namespace MathNet.Numerics.Algorithms.LinearAlgebra
 {
     using System;
-    using System.Numerics;
     using Properties;
     using Threading;
 
     /// <summary>
     /// The managed linear algebra provider.
     /// </summary>
-    public partial class ManagedLinearAlgebraProvider : ILinearAlgebraProvider
+    public partial class ManagedLinearAlgebraProvider
     {
         /// <summary>
         /// Adds a scaled vector to another: <c>y += alpha*x</c>.
@@ -1290,7 +1289,7 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
         /// <param name="rowDim">Number of rows</param>
         /// <param name="firstCol">Column start</param>
         /// <param name="colLimit">Total columns</param>
-        /// <param name="multipliers">Multipliears calculated previously</param>
+        /// <param name="multipliers">Multipliers calculated previously</param>
         /// <param name="availableCores">Number of available processors</param>
         private static void DoCholeskyStep(float[] data, int rowDim, int firstCol, int colLimit, float[] multipliers, int availableCores)
         {
@@ -1524,7 +1523,7 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
         /// Perform calculation of Q or R
         /// </summary>
         /// <param name="work">Work array</param>
-        /// <param name="workIndex">Index of colunn in work array</param>
+        /// <param name="workIndex">Index of column in work array</param>
         /// <param name="a">Q or R matrices</param>
         /// <param name="rowStart">The first row in </param>
         /// <param name="rowCount">The last row</param>
@@ -1573,7 +1572,7 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
         /// <param name="work">Work array</param>
         /// <param name="a">Initial matrix</param>
         /// <param name="rowCount">The number of rows in matrix</param>
-        /// <param name="row">The firts row</param>
+        /// <param name="row">The first row</param>
         /// <param name="column">Column index</param>
         private static void GenerateColumn(float[] work, float[] a, int rowCount, int row, int column)
         {
@@ -1861,9 +1860,9 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
         /// <param name="rowsA">The number of rows in the A matrix.</param>
         /// <param name="columnsA">The number of columns in the A matrix.</param>
         /// <param name="s">The singular values of A in ascending value.</param>
-        /// <param name="u">If <paramref name="computeVectors"/> is true, on exit U contains the left
+        /// <param name="u">If <paramref name="computeVectors"/> is <c>true</c>, on exit U contains the left
         /// singular vectors.</param>
-        /// <param name="vt">If <paramref name="computeVectors"/> is true, on exit VT contains the transposed
+        /// <param name="vt">If <paramref name="computeVectors"/> is <c>true</c>, on exit VT contains the transposed
         /// right singular vectors.</param>
         /// <remarks>This is equivalent to the GESVD LAPACK routine.</remarks>
         public virtual void SingularValueDecomposition(bool computeVectors, float[] a, int rowsA, int columnsA, float[] s, float[] u, float[] vt)
@@ -1916,9 +1915,9 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
         /// <param name="rowsA">The number of rows in the A matrix.</param>
         /// <param name="columnsA">The number of columns in the A matrix.</param>
         /// <param name="s">The singular values of A in ascending value.</param>
-        /// <param name="u">If <paramref name="computeVectors"/> is true, on exit U contains the left
+        /// <param name="u">If <paramref name="computeVectors"/> is <c>true</c>, on exit U contains the left
         /// singular vectors.</param>
-        /// <param name="vt">If <paramref name="computeVectors"/> is true, on exit VT contains the transposed
+        /// <param name="vt">If <paramref name="computeVectors"/> is <c>true</c>, on exit VT contains the transposed
         /// right singular vectors.</param>
         /// <param name="work">The work array. For real matrices, the work array should be at least
         /// Max(3*Min(M, N) + Max(M, N), 5*Min(M,N)). For complex matrices, 2*Min(M, N) + Max(M, N).
@@ -2594,7 +2593,7 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra
         }
 
         /// <summary>
-        /// Given the Cartesian coordinates (da, db) of a point p, these fucntion return the parameters da, db, c, and s 
+        /// Given the Cartesian coordinates (da, db) of a point p, these function return the parameters da, db, c, and s 
         /// associated with the Givens rotation that zeros the y-coordinate of the point.
         /// </summary>
         /// <param name="da">Provides the x-coordinate of the point p. On exit contains the parameter r associated with the Givens rotation</param>

src/Numerics/Algorithms/LinearAlgebra/Mkl/SafeNativeMethods.tt

@@ -3,46 +3,8 @@
 <# string namespaceSuffix = "Mkl";
    string library = "MKL"; 
 #>
-<#@ include file="..\SafeNativeMethods.include" #>
+<#@ include file="..\safe.native.common.include" #>
+<#@ include file="..\safe.native.vector.include" #>
 
-        #region Vector Functions
-        
-        [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
-        internal static extern void s_vector_add(int n, float[] x, float[] y, [In, Out] float[] result);
-
-        [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
-        internal static extern void s_vector_subtract(int n, float[] x, float[] y, [In, Out] float[] result);
-
-        [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
-        internal static extern void s_vector_multiply(int n, float[] x, float[] y, [In, Out] float[] result);
-
-        [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
-        internal static extern void d_vector_add(int n, double[] x, double[] y, [In, Out] double[] result);
-
-        [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
-        internal static extern void d_vector_subtract(int n, double[] x, double[] y, [In, Out] double[] result);
-
-        [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
-        internal static extern void d_vector_multiply(int n, double[] x, double[] y, [In, Out] double[] result);
-
-        [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
-        internal static extern void c_vector_add(int n, Complex32[] x, Complex32[] y, [In, Out] Complex32[] result);
-
-        [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
-        internal static extern void c_vector_subtract(int n, Complex32[] x, Complex32[] y, [In, Out] Complex32[] result);
-
-        [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
-        internal static extern void c_vector_multiply(int n, Complex32[] x, Complex32[] y, [In, Out] Complex32[] result);
-
-        [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
-        internal static extern void z_vector_add(int n, Complex[] x, Complex[] y, [In, Out] Complex[] result);
-
-        [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
-        internal static extern void z_vector_subtract(int n, Complex[] x, Complex[] y, [In, Out] Complex[] result);
-
-        [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
-        internal static extern void z_vector_multiply(int n, Complex[] x, Complex[] y, [In, Out] Complex[] result);
-        
-        #endregion  Vector Functions
     }
 }

src/Numerics/Algorithms/LinearAlgebra/native.common.include

@@ -82,17 +82,17 @@
         /// 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="rowsX">The number of rows in the x matrix.</param>
+        /// <param name="columnsX">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="rowsY">The number of rows in the y matrix.</param>
+        /// <param name="columnsY">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 <#=one#> and beta set to <#=zero#>, and x and y are not transposed.</remarks>
-        public override void MatrixMultiply(<#=dataType#>[] x, int xRows, int xColumns, <#=dataType#>[] y, int yRows, int yColumns, <#=dataType#>[] result)
+        public override void MatrixMultiply(<#=dataType#>[] x, int rowsX, int columnsX, <#=dataType#>[] y, int rowsY, int columnsY, <#=dataType#>[] result)
         {
-            MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.DontTranspose, <#=one#>, x, xRows, xColumns, y, yRows, yColumns, <#=zero#>, result);
+            MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.DontTranspose, <#=one#>, x, rowsX, columnsX, y, rowsY, columnsY, <#=zero#>, result);
         }
 
         /// <summary>
@@ -102,15 +102,14 @@
         /// <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="rowsA">The number of rows in the <paramref name="a"/> matrix.</param>
+        /// <param name="columnsA">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="rowsB">The number of rows in the <paramref name="b"/> matrix.</param>
+        /// <param name="columnsB">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 override void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, <#=dataType#> alpha, <#=dataType#>[] a, 
-			int aRows, int aColumns, <#=dataType#>[] b, int bRows, int bColumns, <#=dataType#> beta, <#=dataType#>[] c)
+        public override void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, <#=dataType#> alpha, <#=dataType#>[] a, int rowsA, int columnsA, <#=dataType#>[] b, int rowsB, int columnsB, <#=dataType#> beta, <#=dataType#>[] c)
         {
             if (a == null)
             {
@@ -127,16 +126,16 @@
                 throw new ArgumentNullException("c");
             }
 
-            var m = transposeA == Transpose.DontTranspose ? aRows : aColumns;
-            var n = transposeB == Transpose.DontTranspose ? bColumns : bRows;
-            var k = transposeA == Transpose.DontTranspose ? aColumns : aRows;
+            var m = transposeA == Transpose.DontTranspose ? rowsA : columnsA;
+            var n = transposeB == Transpose.DontTranspose ? columnsB : rowsB;
+            var k = transposeA == Transpose.DontTranspose ? columnsA : rowsA;
 
-            if( c.Length != aRows * bColumns)
+            if (c.Length != rowsA * columnsB)
             {
                 throw new ArgumentException(Resources.ArgumentMatrixDimensions);   
             }
 
-            if (aColumns != bRows)
+            if (columnsA != rowsB)
             {
                 throw new ArgumentException(Resources.ArgumentMatrixDimensions);
             }
@@ -144,7 +143,7 @@
             SafeNativeMethods.<#=prefix#>_matrix_multiply(transposeA, transposeB, m, n, k, <#=reff#>alpha, a, b, <#=reff#>beta, c);
         }
 
-		/// <summary>
+        /// <summary>
         /// Computes the requested <see cref="Norm"/> of the matrix.
         /// </summary>
         /// <param name="norm">The type of norm to compute.</param>
@@ -176,8 +175,6 @@
             throw new NotImplementedException();
         }
 
-
-		
         /// <summary>
         /// Computes the LUP factorization of A. P*A = L*U.
         /// </summary>
@@ -326,13 +323,13 @@
         /// Solves A*X=B for X using Cholesky factorization.
         /// </summary>
         /// <param name="a">The square, positive definite matrix A.</param>
-        /// <param name="aOrder">The number of rows and columns in A.</param>
+        /// <param name="orderA">The number of rows and columns in A.</param>
         /// <param name="b">The B matrix.</param>
-        /// <param name="bRows">The number of rows in the B matrix.</param>
-        /// <param name="bColumns">The number of columns in the B matrix.</param>
+        /// <param name="rowsB">The number of rows in the B matrix.</param>
+        /// <param name="columnsB">The number of columns in the B matrix.</param>
         /// <remarks>This is equivalent to the POTRF add POTRS LAPACK routines.
         /// </remarks>
-        public override void CholeskySolve(<#=dataType#>[] a, int aOrder, <#=dataType#>[] b, int bRows, int bColumns)
+        public override void CholeskySolve(<#=dataType#>[] a, int orderA, <#=dataType#>[] b, int rowsB, int columnsB)
         {
             throw new NotImplementedException();
         }
@@ -341,12 +338,12 @@
         /// Solves A*X=B for X using a previously factored A matrix.
         /// </summary>
         /// <param name="a">The square, positive definite matrix A.</param>
-        /// <param name="aOrder">The number of rows and columns in A.</param>
+        /// <param name="orderA">The number of rows and columns in A.</param>
         /// <param name="b">The B matrix.</param>
-        /// <param name="bRows">The number of rows in the B matrix.</param>
-        /// <param name="bColumns">The number of columns in the B matrix.</param>
+        /// <param name="rowsB">The number of rows in the B matrix.</param>
+        /// <param name="columnsB">The number of columns in the B matrix.</param>
         /// <remarks>This is equivalent to the POTRS LAPACK routine.</remarks>
-        public override void CholeskySolveFactored(<#=dataType#>[] a, int aOrder, <#=dataType#>[] b, int bRows, int bColumns)
+        public override void CholeskySolveFactored(<#=dataType#>[] a, int orderA, <#=dataType#>[] b, int rowsB, int columnsB)
         {
             throw new NotImplementedException();
         }
@@ -356,12 +353,12 @@
         /// </summary>
         /// <param name="r">On entry, it is the M by N A matrix to factor. On exit,
         /// it is overwritten with the R matrix of the QR factorization. </param>
-        /// <param name="rRows">The number of rows in the A matrix.</param>
-        /// <param name="rColumns">The number of columns in the A matrix.</param>
+        /// <param name="rowsR">The number of rows in the A matrix.</param>
+        /// <param name="columnsR">The number of columns in the A matrix.</param>
         /// <param name="q">On exit, A M by M matrix that holds the Q matrix of the
         /// QR factorization.</param>
         /// <remarks>This is similar to the GEQRF and ORGQR LAPACK routines.</remarks>
-        public override void QRFactor(<#=dataType#>[] r, int rRows, int rColumns, <#=dataType#>[] q)
+        public override void QRFactor(<#=dataType#>[] r, int rowsR, int columnsR, <#=dataType#>[] q)
         {
             throw new NotImplementedException();
         }
@@ -371,15 +368,15 @@
         /// </summary>
         /// <param name="r">On entry, it is the M by N A matrix to factor. On exit,
         /// it is overwritten with the R matrix of the QR factorization. </param>
-        /// <param name="rRows">The number of rows in the A matrix.</param>
-        /// <param name="rColumns">The number of columns in the A matrix.</param>
+        /// <param name="rowsR">The number of rows in the A matrix.</param>
+        /// <param name="columnsR">The number of columns in the A matrix.</param>
         /// <param name="q">On exit, A M by M matrix that holds the Q matrix of the 
         /// QR factorization.</param>
         /// <param name="work">The work array. The array must have a length of at least N,
         /// but should be N*blocksize. The blocksize is machine dependent. On exit, work[0] contains the optimal
         /// work size value.</param>
         /// <remarks>This is similar to the GEQRF and ORGQR LAPACK routines.</remarks>
-        public override void QRFactor(<#=dataType#>[] r, int rRows, int rColumns, <#=dataType#>[] q, <#=dataType#>[] work)
+        public override void QRFactor(<#=dataType#>[] r, int rowsR, int columnsR, <#=dataType#>[] q, <#=dataType#>[] work)
         {
             throw new NotImplementedException();
         }
@@ -389,14 +386,14 @@
         /// </summary>
         /// <param name="r">On entry, it is the M by N A matrix to factor. On exit,
         /// it is overwritten with the R matrix of the QR factorization. </param>
-        /// <param name="rRows">The number of rows in the A matrix.</param>
-        /// <param name="rColumns">The number of columns in the A matrix.</param>
+        /// <param name="rowsR">The number of rows in the A matrix.</param>
+        /// <param name="columnsR">The number of columns in the A matrix.</param>
         /// <param name="q">On exit, A M by M matrix that holds the Q matrix of the 
         /// QR factorization.</param>
         /// <param name="b">The B matrix.</param>
-        /// <param name="bColumns">The number of columns of B.</param>
+        /// <param name="columnsB">The number of columns of B.</param>
         /// <param name="x">On exit, the solution matrix.</param>
-        public override void QRSolve(<#=dataType#>[] r, int rRows, int rColumns, <#=dataType#>[] q, <#=dataType#>[] b, int bColumns, <#=dataType#>[] x)
+        public override void QRSolve(<#=dataType#>[] r, int rowsR, int columnsR, <#=dataType#>[] q, <#=dataType#>[] b, int columnsB, <#=dataType#>[] x)
         {
             throw new NotImplementedException();
         }
@@ -406,17 +403,17 @@
         /// </summary>
         /// <param name="r">On entry, it is the M by N A matrix to factor. On exit,
         /// it is overwritten with the R matrix of the QR factorization. </param>
-        /// <param name="rRows">The number of rows in the A matrix.</param>
-        /// <param name="rColumns">The number of columns in the A matrix.</param>
+        /// <param name="rowsR">The number of rows in the A matrix.</param>
+        /// <param name="columnsR">The number of columns in the A matrix.</param>
         /// <param name="q">On exit, A M by M matrix that holds the Q matrix of the 
         /// QR factorization.</param>
         /// <param name="b">The B matrix.</param>
-        /// <param name="bColumns">The number of columns of B.</param>
+        /// <param name="columnsB">The number of columns of B.</param>
         /// <param name="x">On exit, the solution matrix.</param>
         /// <param name="work">The work array. The array must have a length of at least N,
         /// but should be N*blocksize. The blocksize is machine dependent. On exit, work[0] contains the optimal
         /// work size value.</param>
-        public override void QRSolve(<#=dataType#>[] r, int rRows, int rColumns, <#=dataType#>[] q, <#=dataType#>[] b, int bColumns, <#=dataType#>[] x, <#=dataType#>[] work)
+        public override void QRSolve(<#=dataType#>[] r, int rowsR, int columnsR, <#=dataType#>[] q, <#=dataType#>[] b, int columnsB, <#=dataType#>[] x, <#=dataType#>[] work)
         {
             throw new NotImplementedException();
         }
@@ -426,12 +423,12 @@
         /// </summary>
         /// <param name="q">The Q matrix obtained by calling <see cref="QRFactor(<#=dataType#>[],int,int,<#=dataType#>[])"/>.</param>
         /// <param name="r">The R matrix obtained by calling <see cref="QRFactor(<#=dataType#>[],int,int,<#=dataType#>[])"/>. </param>
-        /// <param name="rRows">The number of rows in the A matrix.</param>
-        /// <param name="rColumns">The number of columns in the A matrix.</param>
+        /// <param name="rowsR">The number of rows in the A matrix.</param>
+        /// <param name="columnsR">The number of columns in the A matrix.</param>
         /// <param name="b">The B matrix.</param>
-        /// <param name="bColumns">The number of columns of B.</param>
+        /// <param name="columnsB">The number of columns of B.</param>
         /// <param name="x">On exit, the solution matrix.</param>
-        public override void QRSolveFactored(<#=dataType#>[] q, <#=dataType#>[] r, int rRows, int rColumns, <#=dataType#>[] b, int bColumns, <#=dataType#>[] x)
+        public override void QRSolveFactored(<#=dataType#>[] q, <#=dataType#>[] r, int rowsR, int columnsR, <#=dataType#>[] b, int columnsB, <#=dataType#>[] x)
         {
             throw new NotImplementedException();
         }
@@ -441,15 +438,15 @@
         /// </summary>
         /// <param name="computeVectors">Compute the singular U and VT vectors or not.</param>
         /// <param name="a">On entry, the M by N matrix to decompose. On exit, A may be overwritten.</param>
-        /// <param name="aRows">The number of rows in the A matrix.</param>
-        /// <param name="aColumns">The number of columns in the A matrix.</param>
+        /// <param name="rowsA">The number of rows in the A matrix.</param>
+        /// <param name="columnsA">The number of columns in the A matrix.</param>
         /// <param name="s">The singular values of A in ascending value.</param>
-        /// <param name="u">If <paramref name="computeVectors"/> is true, on exit U contains the left
+        /// <param name="u">If <paramref name="computeVectors"/> is <c>true</c>, on exit U contains the left
         /// singular vectors.</param>
-        /// <param name="vt">If <paramref name="computeVectors"/> is true, on exit VT contains the transposed
+        /// <param name="vt">If <paramref name="computeVectors"/> is <c>true</c>, on exit VT contains the transposed
         /// right singular vectors.</param>
         /// <remarks>This is equivalent to the GESVD LAPACK routine.</remarks>
-        public override void SingularValueDecomposition(bool computeVectors, <#=dataType#>[] a, int aRows, int aColumns, <#=dataType#>[] s, <#=dataType#>[] u, <#=dataType#>[] vt)
+        public override void SingularValueDecomposition(bool computeVectors, <#=dataType#>[] a, int rowsA, int columnsA, <#=dataType#>[] s, <#=dataType#>[] u, <#=dataType#>[] vt)
         {
             throw new NotImplementedException();
         }
@@ -459,18 +456,18 @@
         /// </summary>
         /// <param name="computeVectors">Compute the singular U and VT vectors or not.</param>
         /// <param name="a">On entry, the M by N matrix to decompose. On exit, A may be overwritten.</param>
-        /// <param name="aRows">The number of rows in the A matrix.</param>
-        /// <param name="aColumns">The number of columns in the A matrix.</param>
+        /// <param name="rowsA">The number of rows in the A matrix.</param>
+        /// <param name="columnsA">The number of columns in the A matrix.</param>
         /// <param name="s">The singular values of A in ascending value.</param>
-        /// <param name="u">If <paramref name="computeVectors"/> is true, on exit U contains the left
+        /// <param name="u">If <paramref name="computeVectors"/> is <c>true</c>, on exit U contains the left
         /// singular vectors.</param>
-        /// <param name="vt">If <paramref name="computeVectors"/> is true, on exit VT contains the transposed
+        /// <param name="vt">If <paramref name="computeVectors"/> is <c>true</c>, on exit VT contains the transposed
         /// right singular vectors.</param>
         /// <param name="work">The work array. For real matrices, the work array should be at least
         /// Max(3*Min(M, N) + Max(M, N), 5*Min(M,N)). For complex matrices, 2*Min(M, N) + Max(M, N).
         /// On exit, work[0] contains the optimal work size value.</param>
         /// <remarks>This is equivalent to the GESVD LAPACK routine.</remarks>
-        public override void SingularValueDecomposition(bool computeVectors, <#=dataType#>[] a, int aRows, int aColumns, <#=dataType#>[] s, <#=dataType#>[] u, <#=dataType#>[] vt, <#=dataType#>[] work)
+        public override void SingularValueDecomposition(bool computeVectors, <#=dataType#>[] a, int rowsA, int columnsA, <#=dataType#>[] s, <#=dataType#>[] u, <#=dataType#>[] vt, <#=dataType#>[] work)
         {
             throw new NotImplementedException();
         }
@@ -479,15 +476,15 @@
         /// Solves A*X=B for X using the singular value decomposition of A.
         /// </summary>
         /// <param name="a">On entry, the M by N matrix to decompose. On exit, A may be overwritten.</param>
-        /// <param name="aRows">The number of rows in the A matrix.</param>
-        /// <param name="aColumns">The number of columns in the A matrix.</param>
+        /// <param name="rowsA">The number of rows in the A matrix.</param>
+        /// <param name="columnsA">The number of columns in the A matrix.</param>
         /// <param name="s">The singular values of A in ascending value.</param>
         /// <param name="u">On exit U contains the left singular vectors.</param>
         /// <param name="vt">On exit VT contains the transposed right singular vectors.</param>
         /// <param name="b">The B matrix.</param>
-        /// <param name="bColumns">The number of columns of B.</param>
+        /// <param name="columnsB">The number of columns of B.</param>
         /// <param name="x">On exit, the solution matrix.</param>
-        public override void SvdSolve(<#=dataType#>[] a, int aRows, int aColumns, <#=dataType#>[] s, <#=dataType#>[] u, <#=dataType#>[] vt, <#=dataType#>[] b, int bColumns, <#=dataType#>[] x)
+        public override void SvdSolve(<#=dataType#>[] a, int rowsA, int columnsA, <#=dataType#>[] s, <#=dataType#>[] u, <#=dataType#>[] vt, <#=dataType#>[] b, int columnsB, <#=dataType#>[] x)
         {
             throw new NotImplementedException();
         }
@@ -496,18 +493,18 @@
         /// Solves A*X=B for X using the singular value decomposition of A.
         /// </summary>
         /// <param name="a">On entry, the M by N matrix to decompose. On exit, A may be overwritten.</param>
-        /// <param name="aRows">The number of rows in the A matrix.</param>
-        /// <param name="aColumns">The number of columns in the A matrix.</param>
+        /// <param name="rowsA">The number of rows in the A matrix.</param>
+        /// <param name="columnsA">The number of columns in the A matrix.</param>
         /// <param name="s">The singular values of A in ascending value.</param>
         /// <param name="u">On exit U contains the left singular vectors.</param>
         /// <param name="vt">On exit VT contains the transposed right singular vectors.</param>
         /// <param name="b">The B matrix.</param>
-        /// <param name="bColumns">The number of columns of B.</param>
+        /// <param name="columnsB">The number of columns of B.</param>
         /// <param name="x">On exit, the solution matrix.</param>
         /// <param name="work">The work array. For real matrices, the work array should be at least
         /// Max(3*Min(M, N) + Max(M, N), 5*Min(M,N)). For complex matrices, 2*Min(M, N) + Max(M, N).
         /// On exit, work[0] contains the optimal work size value.</param>
-        public override void SvdSolve(<#=dataType#>[] a, int aRows, int aColumns, <#=dataType#>[] s, <#=dataType#>[] u, <#=dataType#>[] vt, <#=dataType#>[] b, int bColumns, <#=dataType#>[] x, <#=dataType#>[] work)
+        public override void SvdSolve(<#=dataType#>[] a, int rowsA, int columnsA, <#=dataType#>[] s, <#=dataType#>[] u, <#=dataType#>[] vt, <#=dataType#>[] b, int columnsB, <#=dataType#>[] x, <#=dataType#>[] work)
         {
             throw new NotImplementedException();
         }
@@ -515,15 +512,15 @@
         /// <summary>
         /// Solves A*X=B for X using a previously SVD decomposed matrix.
         /// </summary>
-        /// <param name="aRows">The number of rows in the A matrix.</param>
-        /// <param name="aColumns">The number of columns in the A matrix.</param>
+        /// <param name="rowsA">The number of rows in the A matrix.</param>
+        /// <param name="columnsA">The number of columns in the A matrix.</param>
         /// <param name="s">The s values returned by <see cref="SingularValueDecomposition(bool,<#=dataType#>[],int,int,<#=dataType#>[],<#=dataType#>[],<#=dataType#>[])"/>.</param>
         /// <param name="u">The left singular vectors returned by  <see cref="SingularValueDecomposition(bool,<#=dataType#>[],int,int,<#=dataType#>[],<#=dataType#>[],<#=dataType#>[])"/>.</param>
         /// <param name="vt">The right singular  vectors returned by  <see cref="SingularValueDecomposition(bool,<#=dataType#>[],int,int,<#=dataType#>[],<#=dataType#>[],<#=dataType#>[])"/>.</param>
         /// <param name="b">The B matrix.</param>
-        /// <param name="bColumns">The number of columns of B.</param>
+        /// <param name="columnsB">The number of columns of B.</param>
         /// <param name="x">On exit, the solution matrix.</param>
-        public override void SvdSolveFactored(int aRows, int aColumns, <#=dataType#>[] s, <#=dataType#>[] u, <#=dataType#>[] vt, <#=dataType#>[] b, int bColumns, <#=dataType#>[] x)
+        public override void SvdSolveFactored(int rowsA, int columnsA, <#=dataType#>[] s, <#=dataType#>[] u, <#=dataType#>[] vt, <#=dataType#>[] b, int columnsB, <#=dataType#>[] x)
         {
             throw new NotImplementedException();
         }

src/Numerics/Algorithms/LinearAlgebra/native.header.include

@@ -35,11 +35,11 @@
 namespace MathNet.Numerics.Algorithms.LinearAlgebra.<#=library#>
 {
     using System;
-	using System.Numerics;
+    using System.Numerics;
     using Properties;
    
-	/// <summary>
+    /// <summary>
     /// <#=title#> linear algebra provider.
     /// </summary>
     public partial class <#=library#>LinearAlgebraProvider : ManagedLinearAlgebraProvider
-    {
+    {

src/Numerics/Algorithms/LinearAlgebra/native.vector.include

@@ -30,7 +30,7 @@
                 throw new ArgumentException(Resources.ArgumentArraysSameLength);
             }
 
-			SafeNativeMethods.<#=prefix#>_vector_add( x.Length, x, y, result );
+            SafeNativeMethods.<#=prefix#>_vector_add(x.Length, x, y, result);
         }
 
         /// <summary>
@@ -65,7 +65,7 @@
                 throw new ArgumentException(Resources.ArgumentArraysSameLength);
             }
             
-			SafeNativeMethods.<#=prefix#>_vector_subtract( x.Length, x, y, result );
+            SafeNativeMethods.<#=prefix#>_vector_subtract(x.Length, x, y, result);
         }
 
         /// <summary>
@@ -100,5 +100,40 @@
                 throw new ArgumentException(Resources.ArgumentArraysSameLength);
             }
             
-			SafeNativeMethods.<#=prefix#>_vector_multiply( x.Length, x, y, result );
+            SafeNativeMethods.<#=prefix#>_vector_multiply(x.Length, x, y, result);
+        }
+
+                /// <summary>
+        /// Does a point wise division of two arrays <c>z = x / y</c>. This can be used
+        /// to divide elements of vectors or matrices.
+        /// </summary>
+        /// <param name="x">The array x.</param>
+        /// <param name="y">The array y.</param>
+        /// <param name="result">The result of the point wise division.</param>
+        /// <remarks>There is no equivalent BLAS routine, but many libraries
+        /// provide optimized (parallel and/or vectorized) versions of this
+        /// routine.</remarks>
+        public override void PointWiseDivideArrays(<#=dataType#>[] x, <#=dataType#>[] y, <#=dataType#>[] result)
+        {
+            if (y == null)
+            {
+                throw new ArgumentNullException("y");
+            }
+
+            if (x == null)
+            {
+                throw new ArgumentNullException("x");
+            }
+
+            if (x.Length != y.Length)
+            {
+                throw new ArgumentException(Resources.ArgumentArraysSameLength);
+            }
+            
+            if (x.Length != result.Length)
+            {
+                throw new ArgumentException(Resources.ArgumentArraysSameLength);
+            }
+            
+            SafeNativeMethods.<#=prefix#>_vector_divide(x.Length, x, y, result);
         }

src/Numerics/Algorithms/LinearAlgebra/SafeNativeMethods.include → src/Numerics/Algorithms/LinearAlgebra/safe.native.common.include

@@ -27,7 +27,6 @@
 // </copyright>
 
 /* This file is automatically generated - do not modify it. 
-   Change SafeNativeMethods.include instead.
    Last generated on UTC <#=DateTime.UtcNow.ToString("u")#>
 */
 

src/Numerics/Algorithms/LinearAlgebra/safe.native.vector.include

@@ -0,0 +1,52 @@
+
+        #region Vector Functions
+        
+        [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void s_vector_add(int n, float[] x, float[] y, [In, Out] float[] result);
+
+        [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void s_vector_subtract(int n, float[] x, float[] y, [In, Out] float[] result);
+
+        [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void s_vector_multiply(int n, float[] x, float[] y, [In, Out] float[] result);
+
+        [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void s_vector_divide(int n, float[] x, float[] y, [In, Out] float[] result);
+
+        [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void d_vector_add(int n, double[] x, double[] y, [In, Out] double[] result);
+
+        [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void d_vector_subtract(int n, double[] x, double[] y, [In, Out] double[] result);
+
+        [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void d_vector_multiply(int n, double[] x, double[] y, [In, Out] double[] result);
+
+        [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void d_vector_divide(int n, double[] x, double[] y, [In, Out] double[] result);
+
+        [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void c_vector_add(int n, Complex32[] x, Complex32[] y, [In, Out] Complex32[] result);
+
+        [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void c_vector_subtract(int n, Complex32[] x, Complex32[] y, [In, Out] Complex32[] result);
+
+        [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void c_vector_multiply(int n, Complex32[] x, Complex32[] y, [In, Out] Complex32[] result);
+
+        [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void c_vector_divide(int n, Complex32[] x, Complex32[] y, [In, Out] Complex32[] result);
+
+        [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void z_vector_add(int n, Complex[] x, Complex[] y, [In, Out] Complex[] result);
+
+        [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void z_vector_subtract(int n, Complex[] x, Complex[] y, [In, Out] Complex[] result);
+
+        [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void z_vector_multiply(int n, Complex[] x, Complex[] y, [In, Out] Complex[] result);
+
+        [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern void z_vector_divide(int n, Complex[] x, Complex[] y, [In, Out] Complex[] result);
+        
+        #endregion  Vector Functions

src/Numerics/Numerics.csproj

@@ -70,6 +70,9 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
+    <None Include="Algorithms\LinearAlgebra\safe.native.vector.include">
+      <LastGenOutput>SafeNativeMethods.cs</LastGenOutput>
+    </None>
     <None Include="Algorithms\LinearAlgebra\native.footer.include" />
     <None Include="Algorithms\LinearAlgebra\native.common.include" />
     <None Include="Algorithms\LinearAlgebra\Mkl\MklLinearAlgebraProvider.Complex32.tt">
@@ -456,7 +459,7 @@
       <Link>MathNet.Numerics.snk</Link>
     </None>
     <None Include="Algorithms\LinearAlgebra\native.header.include" />
-    <None Include="Algorithms\LinearAlgebra\SafeNativeMethods.include">
+    <None Include="Algorithms\LinearAlgebra\safe.native.common.include">
       <LastGenOutput>SafeNativeMethods.cs</LastGenOutput>
     </None>
     <Compile Include="Distributions\Continuous\StudentT.cs" />