diff --git a/src/NativeWrappers/ATLASWrapperTests/ATLASWrapperTests.csproj b/src/NativeWrappers/ATLASWrapperTests/ATLASWrapperTests.csproj index 8dbb4531..bedb0085 100644 --- a/src/NativeWrappers/ATLASWrapperTests/ATLASWrapperTests.csproj +++ b/src/NativeWrappers/ATLASWrapperTests/ATLASWrapperTests.csproj @@ -73,7 +73,7 @@ - + MathNET.Numerics.ATLAS.dll PreserveNewest diff --git a/src/NativeWrappers/Common/blas.c b/src/NativeWrappers/Common/blas.c index 8b0c2668..a37144e1 100644 --- a/src/NativeWrappers/Common/blas.c +++ b/src/NativeWrappers/Common/blas.c @@ -21,3 +21,20 @@ DLLEXPORT void c_axpy( const int n, const Complex8 alpha, const Complex8 x[], Co DLLEXPORT void z_axpy( const int n, const Complex16 alpha, const Complex16 x[], Complex16 y[]){ cblas_zaxpy(n, &alpha, x, 1, y, 1); } + +DLLEXPORT void s_scale(const int n, const float alpha, float x[]){ + cblas_sscal(n, alpha, x, 1); +} + +DLLEXPORT void d_scale(const int n, const double alpha, double x[]){ + cblas_dscal(n, alpha, x, 1); +} + +DLLEXPORT void c_scale(const int n, const Complex8 alpha, Complex8 x[]){ + cblas_cscal(n, &alpha, x, 1); +} + +DLLEXPORT void z_scale(const int n, const Complex16 alpha, Complex16 x[]){ + cblas_zscal(n, &alpha, x, 1); +} + diff --git a/src/NativeWrappers/MKLWrapper32Tests/MKLWrapper32Tests.csproj b/src/NativeWrappers/MKLWrapper32Tests/MKLWrapper32Tests.csproj index 068af8c5..20bf3485 100644 --- a/src/NativeWrappers/MKLWrapper32Tests/MKLWrapper32Tests.csproj +++ b/src/NativeWrappers/MKLWrapper32Tests/MKLWrapper32Tests.csproj @@ -73,11 +73,11 @@ - + libiomp5md.dll PreserveNewest - + MathNET.Numerics.MKL.dll PreserveNewest diff --git a/src/NativeWrappers/MKLWrapper64Tests/MKLWrapper64Tests.csproj b/src/NativeWrappers/MKLWrapper64Tests/MKLWrapper64Tests.csproj index d82d11f5..e149d2ab 100644 --- a/src/NativeWrappers/MKLWrapper64Tests/MKLWrapper64Tests.csproj +++ b/src/NativeWrappers/MKLWrapper64Tests/MKLWrapper64Tests.csproj @@ -79,11 +79,11 @@ - + libiomp5md.dll PreserveNewest - + MathNET.Numerics.MKL.dll PreserveNewest diff --git a/src/Numerics/Algorithms/LinearAlgebra/Atlas/AtlasLinearAlgebraProvider.cs b/src/Numerics/Algorithms/LinearAlgebra/Atlas/AtlasLinearAlgebraProvider.cs index 14b44008..ccb25f89 100644 --- a/src/Numerics/Algorithms/LinearAlgebra/Atlas/AtlasLinearAlgebraProvider.cs +++ b/src/Numerics/Algorithms/LinearAlgebra/Atlas/AtlasLinearAlgebraProvider.cs @@ -1,4 +1,4 @@ -// +// // Math.NET Numerics, part of the Math.NET Project // http://mathnet.opensourcedotnet.info // Copyright (c) 2009 Math.NET @@ -78,39 +78,108 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.Atlas /// This is equivalent to the SCAL BLAS routine. public void ScaleArray(double alpha, double[] x) { - throw new NotImplementedException(); + if (alpha == 1.0) + { + return; + } + + SafeNativeMethods.d_scale(x.Length, alpha, x); } + /// + /// Queries the provider for the optimal, workspace block size + /// for the given routine. + /// + /// Name of the method to query. + /// + /// -1 if the provider cannot compute the workspace size; otherwise + /// the suggested block size. + /// public int QueryWorkspaceBlockSize(string methodName) { throw new NotImplementedException(); } + /// + /// Computes the dot product of x and y. + /// + /// The vector x. + /// The vector y. + /// The dot product of x and y. + /// This is equivalent to the DOT BLAS routine. public double DotProduct(double[] x, double[] y) { throw new NotImplementedException(); } + /// + /// Does a point wise add of two arrays z = x + y. This can be used + /// to add vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the addition. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void AddArrays(double[] x, double[] y, double[] result) { throw new NotImplementedException(); } + /// + /// Does a point wise subtraction of two arrays z = x - y. This can be used + /// to subtract vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the subtraction. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void SubtractArrays(double[] x, double[] y, double[] result) { throw new NotImplementedException(); } + /// + /// Does a point wise multiplication of two arrays z = x * y. This can be used + /// to multiple elements of vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the point wise multiplication. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void PointWiseMultiplyArrays(double[] x, double[] y, double[] result) { throw new NotImplementedException(); } + /// + /// Computes the requested of the matrix. + /// + /// The type of norm to compute. + /// The matrix to compute the norm from. + /// + /// The requested of the matrix. + /// public double MatrixNorm(Norm norm, double[] matrix) { throw new NotImplementedException(); } + /// + /// Computes the requested of the matrix. + /// + /// The type of norm to compute. + /// The matrix to compute the norm from. + /// The work array. Only used when + /// and needs to be have a length of at least M (number of rows of . + /// + /// The requested of the matrix. + /// public double MatrixNorm(Norm norm, double[] matrix, double[] work) { throw new NotImplementedException(); @@ -153,111 +222,307 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.Atlas throw new NotImplementedException(); } + /// + /// Computes the LU factorization of A. + /// + /// An m by n matrix. The matrix is overwritten with the + /// the LU factorization On exit. + /// On exit, it contains the pivot indices. The size + /// of the array must be min(m,n). + /// This is equivalent to the GETRF LAPACK routine. public void LUFactor(double[] a, int[] ipiv) { throw new NotImplementedException(); } + /// + /// Computes the inverse of matrix using LU factorization. + /// + /// The N by N matrix to invert. Contains the inverse On exit. + /// This is equivalent to the GETRF and GETRI LAPACK routines. public void LUInverse(double[] a) { throw new NotImplementedException(); } + /// + /// Computes the inverse of a previously factored matrix. + /// + /// The LU factored N by N matrix. Contains the inverse On exit. + /// The pivot indices of . + /// This is equivalent to the GETRI LAPACK routine. public void LUInverseFactored(double[] a, int[] ipiv) { throw new NotImplementedException(); } + /// + /// Computes the inverse of matrix using LU factorization. + /// + /// The N by N matrix to invert. Contains the inverse On exit. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. + /// This is equivalent to the GETRF and GETRI LAPACK routines. public void LUInverse(double[] a, double[] work) { throw new NotImplementedException(); } + /// + /// Computes the inverse of a previously factored matrix. + /// + /// The LU factored N by N matrix. Contains the inverse On exit. + /// The pivot indices of . + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. + /// This is equivalent to the GETRI LAPACK routine. public void LUInverseFactored(double[] a, int[] ipiv, double[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using LU factorization. + /// + /// The number of columns of B. + /// The square matrix A. + /// The B matrix. + /// This is equivalent to the GETRF and GETRS LAPACK routines. public void LUSolve(int columnsOfB, double[] a, double[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// The number of columns of B. + /// The factored A matrix. + /// The pivot indices of . + /// The B matrix. + /// This is equivalent to the GETRS LAPACK routine. public void LUSolveFactored(int columnsOfB, double[] a, int ipiv, double[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using LU factorization. + /// + /// How to transpose the matrix. + /// The number of columns of B. + /// The square matrix A. + /// The B matrix. + /// This is equivalent to the GETRF and GETRS LAPACK routines. public void LUSolve(Transpose transposeA, int columnsOfB, double[] a, double[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// How to transpose the matrix. + /// The number of columns of B. + /// The factored A matrix. + /// The pivot indices of . + /// The B matrix. + /// This is equivalent to the GETRS LAPACK routine. public void LUSolveFactored(Transpose transposeA, int columnsOfB, double[] a, int ipiv, double[] b) { throw new NotImplementedException(); } + /// + /// Computes the Cholesky factorization of A. + /// + /// On entry, a square, positive definite matrix. On exit, the matrix is overwritten with the + /// the Cholesky factorization. + /// This is equivalent to the POTRF LAPACK routine. public void CholeskyFactor(double[] a) { throw new NotImplementedException(); } - + + /// + /// Solves A*X=B for X using Cholesky factorization. + /// + /// The number of columns of B. + /// The square, positive definite matrix A. + /// The B matrix. + /// This is equivalent to the POTRF add POTRS LAPACK routines. public void CholeskySolve(int columnsOfB, double[] a, double[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// The number of columns of B. + /// The factored A matrix. + /// The B matrix. + /// This is equivalent to the POTRS LAPACK routine. public void CholeskySolveFactored(int columnsOfB, double[] a, double[] b) { throw new NotImplementedException(); } + /// + /// Computes the QR factorization of A. + /// + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// This is similar to the GEQRF and ORGQR LAPACK routines. public void QRFactor(double[] r, double[] q) { throw new NotImplementedException(); } + /// + /// Computes the QR factorization of A. + /// + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. public void QRFactor(double[] r, double[] q, double[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using QR factorization of A. + /// + /// The number of columns of B. + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The B matrix. + /// On exit, the solution matrix. public void QRSolve(int columnsOfB, double[] r, double[] q, double[] b, double[] x) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using QR factorization of A. + /// + /// The number of columns of B. + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The B matrix. + /// On exit, the solution matrix. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. public void QRSolve(int columnsOfB, double[] r, double[] q, double[] b, double[] x, double[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously QR factored matrix. + /// + /// The number of columns of B. + /// The Q matrix obtained by calling . + /// The R matrix obtained by calling . + /// The B matrix. + /// On exit, the solution matrix. public void QRSolveFactored(int columnsOfB, double[] q, double[] r, double[] b, double[] x) { throw new NotImplementedException(); } + /// + /// Computes the singular value decomposition of A. + /// + /// Compute the singular U and VT vectors or not. + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// If is true, on exit U contains the left + /// singular vectors. + /// If is true, on exit VT contains the transposed + /// right singular vectors. + /// This is equivalent to the GESVD LAPACK routine. public void SinguarValueDecomposition(bool computeVectors, double[] a, double[] s, double[] u, double[] vt) { throw new NotImplementedException(); } + /// + /// Computes the singular value decomposition of A. + /// + /// Compute the singular U and VT vectors or not. + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// If is true, on exit U contains the left + /// singular vectors. + /// If is true, on exit VT contains the transposed + /// right singular vectors. + /// 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. + /// This is equivalent to the GESVD LAPACK routine. public void SingularValueDecomposition(bool computeVectors, double[] a, double[] s, double[] u, double[] vt, double[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using the singular value decomposition of A. + /// + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// On exit U contains the left singular vectors. + /// On exit VT contains the transposed right singular vectors. + /// The B matrix. + /// On exit, the solution matrix. public void SvdSolve(double[] a, double[] s, double[] u, double[] vt, double[] b, double[] x) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using the singular value decomposition of A. + /// + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// On exit U contains the left singular vectors. + /// On exit VT contains the transposed right singular vectors. + /// The B matrix. + /// On exit, the solution matrix. + /// 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. public void SvdSolve(double[] a, double[] s, double[] u, double[] vt, double[] b, double[] x, double[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously SVD decomposed matrix. + /// + /// The number of columns of B. + /// The s values returned by . + /// The left singular vectors returned by . + /// The right singular vectors returned by . + /// The B matrix. + /// On exit, the solution matrix. public void SvdSolveFactored(int columnsOfB, double[] s, double[] u, double[] vt, double[] b, double[] x) { throw new NotImplementedException(); @@ -267,7 +532,13 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.Atlas #region ILinearAlgebraProvider Members - + /// + /// Adds a scaled vector to another: y += alpha*x. + /// + /// The vector to update. + /// The value to scale by. + /// The vector to add to . + /// This equivalent to the AXPY BLAS routine. public void AddVectorToScaledVector(float[] y, float alpha, float[] x) { if (y == null) @@ -293,36 +564,102 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.Atlas SafeNativeMethods.s_axpy(y.Length, alpha, x, y); } + /// + /// Scales an array. Can be used to scale a vector and a matrix. + /// + /// The scalar. + /// The values to scale. + /// This is equivalent to the SCAL BLAS routine. public void ScaleArray(float alpha, float[] x) { - throw new NotImplementedException(); + if (alpha == 1.0) + { + return; + } + + SafeNativeMethods.s_scale(x.Length, alpha, x); } + /// + /// Computes the dot product of x and y. + /// + /// The vector x. + /// The vector y. + /// The dot product of x and y. + /// This is equivalent to the DOT BLAS routine. public float DotProduct(float[] x, float[] y) { throw new NotImplementedException(); } + /// + /// Does a point wise add of two arrays z = x + y. This can be used + /// to add vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the addition. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void AddArrays(float[] x, float[] y, float[] result) { throw new NotImplementedException(); } + /// + /// Does a point wise subtraction of two arrays z = x - y. This can be used + /// to subtract vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the subtraction. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void SubtractArrays(float[] x, float[] y, float[] result) { throw new NotImplementedException(); } + /// + /// Does a point wise multiplication of two arrays z = x * y. This can be used + /// to multiple elements of vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the point wise multiplication. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void PointWiseMultiplyArrays(float[] x, float[] y, float[] result) { throw new NotImplementedException(); } + /// + /// Computes the requested of the matrix. + /// + /// The type of norm to compute. + /// The matrix to compute the norm from. + /// + /// The requested of the matrix. + /// public float MatrixNorm(Norm norm, float[] matrix) { throw new NotImplementedException(); } + /// + /// Computes the requested of the matrix. + /// + /// The type of norm to compute. + /// The matrix to compute the norm from. + /// The work array. Only used when + /// and needs to be have a length of at least M (number of rows of . + /// + /// The requested of the matrix. + /// public float MatrixNorm(Norm norm, float[] matrix, float[] work) { throw new NotImplementedException(); @@ -365,111 +702,307 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.Atlas throw new NotImplementedException(); } + /// + /// Computes the LU factorization of A. + /// + /// An m by n matrix. The matrix is overwritten with the + /// the LU factorization On exit. + /// On exit, it contains the pivot indices. The size + /// of the array must be min(m,n). + /// This is equivalent to the GETRF LAPACK routine. public void LUFactor(float[] a, int[] ipiv) { throw new NotImplementedException(); } + /// + /// Computes the inverse of matrix using LU factorization. + /// + /// The N by N matrix to invert. Contains the inverse On exit. + /// This is equivalent to the GETRF and GETRI LAPACK routines. public void LUInverse(float[] a) { throw new NotImplementedException(); } + /// + /// Computes the inverse of a previously factored matrix. + /// + /// The LU factored N by N matrix. Contains the inverse On exit. + /// The pivot indices of . + /// This is equivalent to the GETRI LAPACK routine. public void LUInverseFactored(float[] a, int[] ipiv) { throw new NotImplementedException(); } + /// + /// Computes the inverse of matrix using LU factorization. + /// + /// The N by N matrix to invert. Contains the inverse On exit. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. + /// This is equivalent to the GETRF and GETRI LAPACK routines. public void LUInverse(float[] a, float[] work) { throw new NotImplementedException(); } + /// + /// Computes the inverse of a previously factored matrix. + /// + /// The LU factored N by N matrix. Contains the inverse On exit. + /// The pivot indices of . + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. + /// This is equivalent to the GETRI LAPACK routine. public void LUInverseFactored(float[] a, int[] ipiv, float[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using LU factorization. + /// + /// The number of columns of B. + /// The square matrix A. + /// The B matrix. + /// This is equivalent to the GETRF and GETRS LAPACK routines. public void LUSolve(int columnsOfB, float[] a, float[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// The number of columns of B. + /// The factored A matrix. + /// The pivot indices of . + /// The B matrix. + /// This is equivalent to the GETRS LAPACK routine. public void LUSolveFactored(int columnsOfB, float[] a, int ipiv, float[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using LU factorization. + /// + /// How to transpose the matrix. + /// The number of columns of B. + /// The square matrix A. + /// The B matrix. + /// This is equivalent to the GETRF and GETRS LAPACK routines. public void LUSolve(Transpose transposeA, int columnsOfB, float[] a, float[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// How to transpose the matrix. + /// The number of columns of B. + /// The factored A matrix. + /// The pivot indices of . + /// The B matrix. + /// This is equivalent to the GETRS LAPACK routine. public void LUSolveFactored(Transpose transposeA, int columnsOfB, float[] a, int ipiv, float[] b) { throw new NotImplementedException(); } + /// + /// Computes the Cholesky factorization of A. + /// + /// On entry, a square, positive definite matrix. On exit, the matrix is overwritten with the + /// the Cholesky factorization. + /// This is equivalent to the POTRF LAPACK routine. public void CholeskyFactor(float[] a) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using Cholesky factorization. + /// + /// The number of columns of B. + /// The square, positive definite matrix A. + /// The B matrix. + /// This is equivalent to the POTRF add POTRS LAPACK routines. public void CholeskySolve(int columnsOfB, float[] a, float[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// The number of columns of B. + /// The factored A matrix. + /// The B matrix. + /// This is equivalent to the POTRS LAPACK routine. public void CholeskySolveFactored(int columnsOfB, float[] a, float[] b) { throw new NotImplementedException(); } + /// + /// Computes the QR factorization of A. + /// + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// This is similar to the GEQRF and ORGQR LAPACK routines. public void QRFactor(float[] r, float[] q) { throw new NotImplementedException(); } + /// + /// Computes the QR factorization of A. + /// + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. public void QRFactor(float[] r, float[] q, float[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using QR factorization of A. + /// + /// The number of columns of B. + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The B matrix. + /// On exit, the solution matrix. public void QRSolve(int columnsOfB, float[] r, float[] q, float[] b, float[] x) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using QR factorization of A. + /// + /// The number of columns of B. + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The B matrix. + /// On exit, the solution matrix. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. public void QRSolve(int columnsOfB, float[] r, float[] q, float[] b, float[] x, float[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously QR factored matrix. + /// + /// The number of columns of B. + /// The Q matrix obtained by calling . + /// The R matrix obtained by calling . + /// The B matrix. + /// On exit, the solution matrix. public void QRSolveFactored(int columnsOfB, float[] q, float[] r, float[] b, float[] x) { throw new NotImplementedException(); } + /// + /// Computes the singular value decomposition of A. + /// + /// Compute the singular U and VT vectors or not. + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// If is true, on exit U contains the left + /// singular vectors. + /// If is true, on exit VT contains the transposed + /// right singular vectors. + /// This is equivalent to the GESVD LAPACK routine. public void SinguarValueDecomposition(bool computeVectors, float[] a, float[] s, float[] u, float[] vt) { throw new NotImplementedException(); } + /// + /// Computes the singular value decomposition of A. + /// + /// Compute the singular U and VT vectors or not. + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// If is true, on exit U contains the left + /// singular vectors. + /// If is true, on exit VT contains the transposed + /// right singular vectors. + /// 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. + /// This is equivalent to the GESVD LAPACK routine. public void SingularValueDecomposition(bool computeVectors, float[] a, float[] s, float[] u, float[] vt, float[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using the singular value decomposition of A. + /// + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// On exit U contains the left singular vectors. + /// On exit VT contains the transposed right singular vectors. + /// The B matrix. + /// On exit, the solution matrix. public void SvdSolve(float[] a, float[] s, float[] u, float[] vt, float[] b, float[] x) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using the singular value decomposition of A. + /// + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// On exit U contains the left singular vectors. + /// On exit VT contains the transposed right singular vectors. + /// The B matrix. + /// On exit, the solution matrix. + /// 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. public void SvdSolve(float[] a, float[] s, float[] u, float[] vt, float[] b, float[] x, float[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously SVD decomposed matrix. + /// + /// The number of columns of B. + /// The s values returned by . + /// The left singular vectors returned by . + /// The right singular vectors returned by . + /// The B matrix. + /// On exit, the solution matrix. public void SvdSolveFactored(int columnsOfB, float[] s, float[] u, float[] vt, float[] b, float[] x) { throw new NotImplementedException(); @@ -479,7 +1012,13 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.Atlas #region ILinearAlgebraProvider Members - + /// + /// Adds a scaled vector to another: y += alpha*x. + /// + /// The vector to update. + /// The value to scale by. + /// The vector to add to . + /// This equivalent to the AXPY BLAS routine. public void AddVectorToScaledVector(Complex[] y, Complex alpha, Complex[] x) { if (y == null) @@ -505,36 +1044,102 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.Atlas SafeNativeMethods.z_axpy(y.Length, ref alpha, x, y); } + /// + /// Scales an array. Can be used to scale a vector and a matrix. + /// + /// The scalar. + /// The values to scale. + /// This is equivalent to the SCAL BLAS routine. public void ScaleArray(Complex alpha, Complex[] x) { - throw new NotImplementedException(); + if (alpha.IsOne) + { + return; + } + + SafeNativeMethods.z_scale(x.Length, ref alpha, x); } + /// + /// Computes the dot product of x and y. + /// + /// The vector x. + /// The vector y. + /// The dot product of x and y. + /// This is equivalent to the DOT BLAS routine. public Complex DotProduct(Complex[] x, Complex[] y) { throw new NotImplementedException(); } + /// + /// Does a point wise add of two arrays z = x + y. This can be used + /// to add vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the addition. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void AddArrays(Complex[] x, Complex[] y, Complex[] result) { throw new NotImplementedException(); } + /// + /// Does a point wise subtraction of two arrays z = x - y. This can be used + /// to subtract vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the subtraction. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void SubtractArrays(Complex[] x, Complex[] y, Complex[] result) { throw new NotImplementedException(); } + /// + /// Does a point wise multiplication of two arrays z = x * y. This can be used + /// to multiple elements of vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the point wise multiplication. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void PointWiseMultiplyArrays(Complex[] x, Complex[] y, Complex[] result) { throw new NotImplementedException(); } + /// + /// Computes the requested of the matrix. + /// + /// The type of norm to compute. + /// The matrix to compute the norm from. + /// + /// The requested of the matrix. + /// public Complex MatrixNorm(Norm norm, Complex[] matrix) { throw new NotImplementedException(); } + /// + /// Computes the requested of the matrix. + /// + /// The type of norm to compute. + /// The matrix to compute the norm from. + /// The work array. Only used when + /// and needs to be have a length of at least M (number of rows of . + /// + /// The requested of the matrix. + /// public Complex MatrixNorm(Norm norm, Complex[] matrix, Complex[] work) { throw new NotImplementedException(); @@ -577,111 +1182,307 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.Atlas throw new NotImplementedException(); } + /// + /// Computes the LU factorization of A. + /// + /// An m by n matrix. The matrix is overwritten with the + /// the LU factorization On exit. + /// On exit, it contains the pivot indices. The size + /// of the array must be min(m,n). + /// This is equivalent to the GETRF LAPACK routine. public void LUFactor(Complex[] a, int[] ipiv) { throw new NotImplementedException(); } + /// + /// Computes the inverse of matrix using LU factorization. + /// + /// The N by N matrix to invert. Contains the inverse On exit. + /// This is equivalent to the GETRF and GETRI LAPACK routines. public void LUInverse(Complex[] a) { throw new NotImplementedException(); } + /// + /// Computes the inverse of a previously factored matrix. + /// + /// The LU factored N by N matrix. Contains the inverse On exit. + /// The pivot indices of . + /// This is equivalent to the GETRI LAPACK routine. public void LUInverseFactored(Complex[] a, int[] ipiv) { throw new NotImplementedException(); } + /// + /// Computes the inverse of matrix using LU factorization. + /// + /// The N by N matrix to invert. Contains the inverse On exit. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. + /// This is equivalent to the GETRF and GETRI LAPACK routines. public void LUInverse(Complex[] a, Complex[] work) { throw new NotImplementedException(); } + /// + /// Computes the inverse of a previously factored matrix. + /// + /// The LU factored N by N matrix. Contains the inverse On exit. + /// The pivot indices of . + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. + /// This is equivalent to the GETRI LAPACK routine. public void LUInverseFactored(Complex[] a, int[] ipiv, Complex[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using LU factorization. + /// + /// The number of columns of B. + /// The square matrix A. + /// The B matrix. + /// This is equivalent to the GETRF and GETRS LAPACK routines. public void LUSolve(int columnsOfB, Complex[] a, Complex[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// The number of columns of B. + /// The factored A matrix. + /// The pivot indices of . + /// The B matrix. + /// This is equivalent to the GETRS LAPACK routine. public void LUSolveFactored(int columnsOfB, Complex[] a, int ipiv, Complex[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using LU factorization. + /// + /// How to transpose the matrix. + /// The number of columns of B. + /// The square matrix A. + /// The B matrix. + /// This is equivalent to the GETRF and GETRS LAPACK routines. public void LUSolve(Transpose transposeA, int columnsOfB, Complex[] a, Complex[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// How to transpose the matrix. + /// The number of columns of B. + /// The factored A matrix. + /// The pivot indices of . + /// The B matrix. + /// This is equivalent to the GETRS LAPACK routine. public void LUSolveFactored(Transpose transposeA, int columnsOfB, Complex[] a, int ipiv, Complex[] b) { throw new NotImplementedException(); } + /// + /// Computes the Cholesky factorization of A. + /// + /// On entry, a square, positive definite matrix. On exit, the matrix is overwritten with the + /// the Cholesky factorization. + /// This is equivalent to the POTRF LAPACK routine. public void CholeskyFactor(Complex[] a) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using Cholesky factorization. + /// + /// The number of columns of B. + /// The square, positive definite matrix A. + /// The B matrix. + /// This is equivalent to the POTRF add POTRS LAPACK routines. public void CholeskySolve(int columnsOfB, Complex[] a, Complex[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// The number of columns of B. + /// The factored A matrix. + /// The B matrix. + /// This is equivalent to the POTRS LAPACK routine. public void CholeskySolveFactored(int columnsOfB, Complex[] a, Complex[] b) { throw new NotImplementedException(); } + /// + /// Computes the QR factorization of A. + /// + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// This is similar to the GEQRF and ORGQR LAPACK routines. public void QRFactor(Complex[] r, Complex[] q) { throw new NotImplementedException(); } + /// + /// Computes the QR factorization of A. + /// + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. public void QRFactor(Complex[] r, Complex[] q, Complex[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using QR factorization of A. + /// + /// The number of columns of B. + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The B matrix. + /// On exit, the solution matrix. public void QRSolve(int columnsOfB, Complex[] r, Complex[] q, Complex[] b, Complex[] x) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using QR factorization of A. + /// + /// The number of columns of B. + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The B matrix. + /// On exit, the solution matrix. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. public void QRSolve(int columnsOfB, Complex[] r, Complex[] q, Complex[] b, Complex[] x, Complex[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously QR factored matrix. + /// + /// The number of columns of B. + /// The Q matrix obtained by calling . + /// The R matrix obtained by calling . + /// The B matrix. + /// On exit, the solution matrix. public void QRSolveFactored(int columnsOfB, Complex[] q, Complex[] r, Complex[] b, Complex[] x) { throw new NotImplementedException(); } + /// + /// Computes the singular value decomposition of A. + /// + /// Compute the singular U and VT vectors or not. + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// If is true, on exit U contains the left + /// singular vectors. + /// If is true, on exit VT contains the transposed + /// right singular vectors. + /// This is equivalent to the GESVD LAPACK routine. public void SinguarValueDecomposition(bool computeVectors, Complex[] a, Complex[] s, Complex[] u, Complex[] vt) { throw new NotImplementedException(); } + /// + /// Computes the singular value decomposition of A. + /// + /// Compute the singular U and VT vectors or not. + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// If is true, on exit U contains the left + /// singular vectors. + /// If is true, on exit VT contains the transposed + /// right singular vectors. + /// 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. + /// This is equivalent to the GESVD LAPACK routine. public void SingularValueDecomposition(bool computeVectors, Complex[] a, Complex[] s, Complex[] u, Complex[] vt, Complex[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using the singular value decomposition of A. + /// + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// On exit U contains the left singular vectors. + /// On exit VT contains the transposed right singular vectors. + /// The B matrix. + /// On exit, the solution matrix. public void SvdSolve(Complex[] a, Complex[] s, Complex[] u, Complex[] vt, Complex[] b, Complex[] x) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using the singular value decomposition of A. + /// + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// On exit U contains the left singular vectors. + /// On exit VT contains the transposed right singular vectors. + /// The B matrix. + /// On exit, the solution matrix. + /// 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. public void SvdSolve(Complex[] a, Complex[] s, Complex[] u, Complex[] vt, Complex[] b, Complex[] x, Complex[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously SVD decomposed matrix. + /// + /// The number of columns of B. + /// The s values returned by . + /// The left singular vectors returned by . + /// The right singular vectors returned by . + /// The B matrix. + /// On exit, the solution matrix. public void SvdSolveFactored(int columnsOfB, Complex[] s, Complex[] u, Complex[] vt, Complex[] b, Complex[] x) { throw new NotImplementedException(); @@ -691,6 +1492,13 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.Atlas #region ILinearAlgebraProvider Members + /// + /// Adds a scaled vector to another: y += alpha*x. + /// + /// The vector to update. + /// The value to scale by. + /// The vector to add to . + /// This equivalent to the AXPY BLAS routine. public void AddVectorToScaledVector(Complex32[] y, Complex32 alpha, Complex32[] x) { if (y == null) @@ -716,36 +1524,102 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.Atlas SafeNativeMethods.c_axpy(y.Length, ref alpha, x, y); } + /// + /// Scales an array. Can be used to scale a vector and a matrix. + /// + /// The scalar. + /// The values to scale. + /// This is equivalent to the SCAL BLAS routine. public void ScaleArray(Complex32 alpha, Complex32[] x) { - throw new NotImplementedException(); + if (alpha.IsOne) + { + return; + } + + SafeNativeMethods.c_scale(x.Length, ref alpha, x); } + /// + /// Computes the dot product of x and y. + /// + /// The vector x. + /// The vector y. + /// The dot product of x and y. + /// This is equivalent to the DOT BLAS routine. public Complex32 DotProduct(Complex32[] x, Complex32[] y) { throw new NotImplementedException(); } + /// + /// Does a point wise add of two arrays z = x + y. This can be used + /// to add vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the addition. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void AddArrays(Complex32[] x, Complex32[] y, Complex32[] result) { throw new NotImplementedException(); } + /// + /// Does a point wise subtraction of two arrays z = x - y. This can be used + /// to subtract vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the subtraction. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void SubtractArrays(Complex32[] x, Complex32[] y, Complex32[] result) { throw new NotImplementedException(); } + /// + /// Does a point wise multiplication of two arrays z = x * y. This can be used + /// to multiple elements of vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the point wise multiplication. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void PointWiseMultiplyArrays(Complex32[] x, Complex32[] y, Complex32[] result) { throw new NotImplementedException(); } + /// + /// Computes the requested of the matrix. + /// + /// The type of norm to compute. + /// The matrix to compute the norm from. + /// + /// The requested of the matrix. + /// public Complex32 MatrixNorm(Norm norm, Complex32[] matrix) { throw new NotImplementedException(); } + /// + /// Computes the requested of the matrix. + /// + /// The type of norm to compute. + /// The matrix to compute the norm from. + /// The work array. Only used when + /// and needs to be have a length of at least M (number of rows of . + /// + /// The requested of the matrix. + /// public Complex32 MatrixNorm(Norm norm, Complex32[] matrix, Complex32[] work) { throw new NotImplementedException(); @@ -788,111 +1662,307 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.Atlas throw new NotImplementedException(); } + /// + /// Computes the LU factorization of A. + /// + /// An m by n matrix. The matrix is overwritten with the + /// the LU factorization On exit. + /// On exit, it contains the pivot indices. The size + /// of the array must be min(m,n). + /// This is equivalent to the GETRF LAPACK routine. public void LUFactor(Complex32[] a, int[] ipiv) { throw new NotImplementedException(); } + /// + /// Computes the inverse of matrix using LU factorization. + /// + /// The N by N matrix to invert. Contains the inverse On exit. + /// This is equivalent to the GETRF and GETRI LAPACK routines. public void LUInverse(Complex32[] a) { throw new NotImplementedException(); } + /// + /// Computes the inverse of a previously factored matrix. + /// + /// The LU factored N by N matrix. Contains the inverse On exit. + /// The pivot indices of . + /// This is equivalent to the GETRI LAPACK routine. public void LUInverseFactored(Complex32[] a, int[] ipiv) { throw new NotImplementedException(); } + /// + /// Computes the inverse of matrix using LU factorization. + /// + /// The N by N matrix to invert. Contains the inverse On exit. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. + /// This is equivalent to the GETRF and GETRI LAPACK routines. public void LUInverse(Complex32[] a, Complex32[] work) { throw new NotImplementedException(); } + /// + /// Computes the inverse of a previously factored matrix. + /// + /// The LU factored N by N matrix. Contains the inverse On exit. + /// The pivot indices of . + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. + /// This is equivalent to the GETRI LAPACK routine. public void LUInverseFactored(Complex32[] a, int[] ipiv, Complex32[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using LU factorization. + /// + /// The number of columns of B. + /// The square matrix A. + /// The B matrix. + /// This is equivalent to the GETRF and GETRS LAPACK routines. public void LUSolve(int columnsOfB, Complex32[] a, Complex32[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// The number of columns of B. + /// The factored A matrix. + /// The pivot indices of . + /// The B matrix. + /// This is equivalent to the GETRS LAPACK routine. public void LUSolveFactored(int columnsOfB, Complex32[] a, int ipiv, Complex32[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using LU factorization. + /// + /// How to transpose the matrix. + /// The number of columns of B. + /// The square matrix A. + /// The B matrix. + /// This is equivalent to the GETRF and GETRS LAPACK routines. public void LUSolve(Transpose transposeA, int columnsOfB, Complex32[] a, Complex32[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// How to transpose the matrix. + /// The number of columns of B. + /// The factored A matrix. + /// The pivot indices of . + /// The B matrix. + /// This is equivalent to the GETRS LAPACK routine. public void LUSolveFactored(Transpose transposeA, int columnsOfB, Complex32[] a, int ipiv, Complex32[] b) { throw new NotImplementedException(); } + /// + /// Computes the Cholesky factorization of A. + /// + /// On entry, a square, positive definite matrix. On exit, the matrix is overwritten with the + /// the Cholesky factorization. + /// This is equivalent to the POTRF LAPACK routine. public void CholeskyFactor(Complex32[] a) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using Cholesky factorization. + /// + /// The number of columns of B. + /// The square, positive definite matrix A. + /// The B matrix. + /// This is equivalent to the POTRF add POTRS LAPACK routines. public void CholeskySolve(int columnsOfB, Complex32[] a, Complex32[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// The number of columns of B. + /// The factored A matrix. + /// The B matrix. + /// This is equivalent to the POTRS LAPACK routine. public void CholeskySolveFactored(int columnsOfB, Complex32[] a, Complex32[] b) { throw new NotImplementedException(); } + /// + /// Computes the QR factorization of A. + /// + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// This is similar to the GEQRF and ORGQR LAPACK routines. public void QRFactor(Complex32[] r, Complex32[] q) { throw new NotImplementedException(); } + /// + /// Computes the QR factorization of A. + /// + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. public void QRFactor(Complex32[] r, Complex32[] q, Complex32[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using QR factorization of A. + /// + /// The number of columns of B. + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The B matrix. + /// On exit, the solution matrix. public void QRSolve(int columnsOfB, Complex32[] r, Complex32[] q, Complex32[] b, Complex32[] x) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using QR factorization of A. + /// + /// The number of columns of B. + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The B matrix. + /// On exit, the solution matrix. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. public void QRSolve(int columnsOfB, Complex32[] r, Complex32[] q, Complex32[] b, Complex32[] x, Complex32[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously QR factored matrix. + /// + /// The number of columns of B. + /// The Q matrix obtained by calling . + /// The R matrix obtained by calling . + /// The B matrix. + /// On exit, the solution matrix. public void QRSolveFactored(int columnsOfB, Complex32[] q, Complex32[] r, Complex32[] b, Complex32[] x) { throw new NotImplementedException(); } + /// + /// Computes the singular value decomposition of A. + /// + /// Compute the singular U and VT vectors or not. + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// If is true, on exit U contains the left + /// singular vectors. + /// If is true, on exit VT contains the transposed + /// right singular vectors. + /// This is equivalent to the GESVD LAPACK routine. public void SinguarValueDecomposition(bool computeVectors, Complex32[] a, Complex32[] s, Complex32[] u, Complex32[] vt) { throw new NotImplementedException(); } + /// + /// Computes the singular value decomposition of A. + /// + /// Compute the singular U and VT vectors or not. + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// If is true, on exit U contains the left + /// singular vectors. + /// If is true, on exit VT contains the transposed + /// right singular vectors. + /// 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. + /// This is equivalent to the GESVD LAPACK routine. public void SingularValueDecomposition(bool computeVectors, Complex32[] a, Complex32[] s, Complex32[] u, Complex32[] vt, Complex32[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using the singular value decomposition of A. + /// + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// On exit U contains the left singular vectors. + /// On exit VT contains the transposed right singular vectors. + /// The B matrix. + /// On exit, the solution matrix. public void SvdSolve(Complex32[] a, Complex32[] s, Complex32[] u, Complex32[] vt, Complex32[] b, Complex32[] x) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using the singular value decomposition of A. + /// + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// On exit U contains the left singular vectors. + /// On exit VT contains the transposed right singular vectors. + /// The B matrix. + /// On exit, the solution matrix. + /// 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. public void SvdSolve(Complex32[] a, Complex32[] s, Complex32[] u, Complex32[] vt, Complex32[] b, Complex32[] x, Complex32[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously SVD decomposed matrix. + /// + /// The number of columns of B. + /// The s values returned by . + /// The left singular vectors returned by . + /// The right singular vectors returned by . + /// The B matrix. + /// On exit, the solution matrix. public void SvdSolveFactored(int columnsOfB, Complex32[] s, Complex32[] u, Complex32[] vt, Complex32[] b, Complex32[] x) { throw new NotImplementedException(); diff --git a/src/Numerics/Algorithms/LinearAlgebra/Atlas/SafeNativeMethods.cs b/src/Numerics/Algorithms/LinearAlgebra/Atlas/SafeNativeMethods.cs index 03b74b7e..3f71ad2c 100644 --- a/src/Numerics/Algorithms/LinearAlgebra/Atlas/SafeNativeMethods.cs +++ b/src/Numerics/Algorithms/LinearAlgebra/Atlas/SafeNativeMethods.cs @@ -1,4 +1,4 @@ -// +// // Math.NET Numerics, part of the Math.NET Project // http://mathnet.opensourcedotnet.info // @@ -28,7 +28,7 @@ /* This file is automatically generated - do not modify it. Change SafeNativeMethods.include instead. - Last generated on: 11/4/2009 2:23:36 PM + Last generated on: 11/6/2009 2:44:00 PM */ using System.Runtime.InteropServices; @@ -36,9 +36,15 @@ using System.Security; namespace MathNet.Numerics.Algorithms.LinearAlgebra.Atlas { + /// + /// P/Invoke methods to the native math libraries. + /// [SuppressUnmanagedCodeSecurity] internal static class SafeNativeMethods { + /// + /// Name of the native DLL. + /// private const string DllName = "MathNET.Numerics.ATLAS.dll"; #region BLAS @@ -55,6 +61,18 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.Atlas [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] internal static extern void z_axpy(int n, ref Complex alpha, Complex[] x, [In, Out] Complex[] y); + [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] + internal static extern void s_scale(int n, float alpha, [Out] float[] x); + + [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] + internal static extern void d_scale(int n, double alpha, [Out] double[] x); + + [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] + internal static extern void c_scale(int n, ref Complex32 alpha, [In, Out] Complex32[] x); + + [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] + internal static extern void z_scale(int n, ref Complex alpha, [In, Out] Complex[] x); + #endregion BLAS - } + } } diff --git a/src/Numerics/Algorithms/LinearAlgebra/Mkl/MklLinearAlgebraProvider.cs b/src/Numerics/Algorithms/LinearAlgebra/Mkl/MklLinearAlgebraProvider.cs index 2c49c8f6..1deb0d4d 100644 --- a/src/Numerics/Algorithms/LinearAlgebra/Mkl/MklLinearAlgebraProvider.cs +++ b/src/Numerics/Algorithms/LinearAlgebra/Mkl/MklLinearAlgebraProvider.cs @@ -1,4 +1,4 @@ -// +// // Math.NET Numerics, part of the Math.NET Project // http://mathnet.opensourcedotnet.info // Copyright (c) 2009 Math.NET @@ -78,39 +78,108 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.Mkl /// This is equivalent to the SCAL BLAS routine. public void ScaleArray(double alpha, double[] x) { - throw new NotImplementedException(); + if (alpha == 1.0) + { + return; + } + + SafeNativeMethods.d_scale(x.Length, alpha, x); } + /// + /// Queries the provider for the optimal, workspace block size + /// for the given routine. + /// + /// Name of the method to query. + /// + /// -1 if the provider cannot compute the workspace size; otherwise + /// the suggested block size. + /// public int QueryWorkspaceBlockSize(string methodName) { throw new NotImplementedException(); } + /// + /// Computes the dot product of x and y. + /// + /// The vector x. + /// The vector y. + /// The dot product of x and y. + /// This is equivalent to the DOT BLAS routine. public double DotProduct(double[] x, double[] y) { throw new NotImplementedException(); } + /// + /// Does a point wise add of two arrays z = x + y. This can be used + /// to add vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the addition. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void AddArrays(double[] x, double[] y, double[] result) { throw new NotImplementedException(); } + /// + /// Does a point wise subtraction of two arrays z = x - y. This can be used + /// to subtract vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the subtraction. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void SubtractArrays(double[] x, double[] y, double[] result) { throw new NotImplementedException(); } + /// + /// Does a point wise multiplication of two arrays z = x * y. This can be used + /// to multiple elements of vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the point wise multiplication. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void PointWiseMultiplyArrays(double[] x, double[] y, double[] result) { throw new NotImplementedException(); } + /// + /// Computes the requested of the matrix. + /// + /// The type of norm to compute. + /// The matrix to compute the norm from. + /// + /// The requested of the matrix. + /// public double MatrixNorm(Norm norm, double[] matrix) { throw new NotImplementedException(); } + /// + /// Computes the requested of the matrix. + /// + /// The type of norm to compute. + /// The matrix to compute the norm from. + /// The work array. Only used when + /// and needs to be have a length of at least M (number of rows of . + /// + /// The requested of the matrix. + /// public double MatrixNorm(Norm norm, double[] matrix, double[] work) { throw new NotImplementedException(); @@ -153,111 +222,307 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.Mkl throw new NotImplementedException(); } + /// + /// Computes the LU factorization of A. + /// + /// An m by n matrix. The matrix is overwritten with the + /// the LU factorization On exit. + /// On exit, it contains the pivot indices. The size + /// of the array must be min(m,n). + /// This is equivalent to the GETRF LAPACK routine. public void LUFactor(double[] a, int[] ipiv) { throw new NotImplementedException(); } + /// + /// Computes the inverse of matrix using LU factorization. + /// + /// The N by N matrix to invert. Contains the inverse On exit. + /// This is equivalent to the GETRF and GETRI LAPACK routines. public void LUInverse(double[] a) { throw new NotImplementedException(); } + /// + /// Computes the inverse of a previously factored matrix. + /// + /// The LU factored N by N matrix. Contains the inverse On exit. + /// The pivot indices of . + /// This is equivalent to the GETRI LAPACK routine. public void LUInverseFactored(double[] a, int[] ipiv) { throw new NotImplementedException(); } + /// + /// Computes the inverse of matrix using LU factorization. + /// + /// The N by N matrix to invert. Contains the inverse On exit. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. + /// This is equivalent to the GETRF and GETRI LAPACK routines. public void LUInverse(double[] a, double[] work) { throw new NotImplementedException(); } + /// + /// Computes the inverse of a previously factored matrix. + /// + /// The LU factored N by N matrix. Contains the inverse On exit. + /// The pivot indices of . + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. + /// This is equivalent to the GETRI LAPACK routine. public void LUInverseFactored(double[] a, int[] ipiv, double[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using LU factorization. + /// + /// The number of columns of B. + /// The square matrix A. + /// The B matrix. + /// This is equivalent to the GETRF and GETRS LAPACK routines. public void LUSolve(int columnsOfB, double[] a, double[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// The number of columns of B. + /// The factored A matrix. + /// The pivot indices of . + /// The B matrix. + /// This is equivalent to the GETRS LAPACK routine. public void LUSolveFactored(int columnsOfB, double[] a, int ipiv, double[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using LU factorization. + /// + /// How to transpose the matrix. + /// The number of columns of B. + /// The square matrix A. + /// The B matrix. + /// This is equivalent to the GETRF and GETRS LAPACK routines. public void LUSolve(Transpose transposeA, int columnsOfB, double[] a, double[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// How to transpose the matrix. + /// The number of columns of B. + /// The factored A matrix. + /// The pivot indices of . + /// The B matrix. + /// This is equivalent to the GETRS LAPACK routine. public void LUSolveFactored(Transpose transposeA, int columnsOfB, double[] a, int ipiv, double[] b) { throw new NotImplementedException(); } + /// + /// Computes the Cholesky factorization of A. + /// + /// On entry, a square, positive definite matrix. On exit, the matrix is overwritten with the + /// the Cholesky factorization. + /// This is equivalent to the POTRF LAPACK routine. public void CholeskyFactor(double[] a) { throw new NotImplementedException(); } - + + /// + /// Solves A*X=B for X using Cholesky factorization. + /// + /// The number of columns of B. + /// The square, positive definite matrix A. + /// The B matrix. + /// This is equivalent to the POTRF add POTRS LAPACK routines. public void CholeskySolve(int columnsOfB, double[] a, double[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// The number of columns of B. + /// The factored A matrix. + /// The B matrix. + /// This is equivalent to the POTRS LAPACK routine. public void CholeskySolveFactored(int columnsOfB, double[] a, double[] b) { throw new NotImplementedException(); } + /// + /// Computes the QR factorization of A. + /// + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// This is similar to the GEQRF and ORGQR LAPACK routines. public void QRFactor(double[] r, double[] q) { throw new NotImplementedException(); } + /// + /// Computes the QR factorization of A. + /// + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. public void QRFactor(double[] r, double[] q, double[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using QR factorization of A. + /// + /// The number of columns of B. + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The B matrix. + /// On exit, the solution matrix. public void QRSolve(int columnsOfB, double[] r, double[] q, double[] b, double[] x) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using QR factorization of A. + /// + /// The number of columns of B. + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The B matrix. + /// On exit, the solution matrix. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. public void QRSolve(int columnsOfB, double[] r, double[] q, double[] b, double[] x, double[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously QR factored matrix. + /// + /// The number of columns of B. + /// The Q matrix obtained by calling . + /// The R matrix obtained by calling . + /// The B matrix. + /// On exit, the solution matrix. public void QRSolveFactored(int columnsOfB, double[] q, double[] r, double[] b, double[] x) { throw new NotImplementedException(); } + /// + /// Computes the singular value decomposition of A. + /// + /// Compute the singular U and VT vectors or not. + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// If is true, on exit U contains the left + /// singular vectors. + /// If is true, on exit VT contains the transposed + /// right singular vectors. + /// This is equivalent to the GESVD LAPACK routine. public void SinguarValueDecomposition(bool computeVectors, double[] a, double[] s, double[] u, double[] vt) { throw new NotImplementedException(); } + /// + /// Computes the singular value decomposition of A. + /// + /// Compute the singular U and VT vectors or not. + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// If is true, on exit U contains the left + /// singular vectors. + /// If is true, on exit VT contains the transposed + /// right singular vectors. + /// 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. + /// This is equivalent to the GESVD LAPACK routine. public void SingularValueDecomposition(bool computeVectors, double[] a, double[] s, double[] u, double[] vt, double[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using the singular value decomposition of A. + /// + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// On exit U contains the left singular vectors. + /// On exit VT contains the transposed right singular vectors. + /// The B matrix. + /// On exit, the solution matrix. public void SvdSolve(double[] a, double[] s, double[] u, double[] vt, double[] b, double[] x) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using the singular value decomposition of A. + /// + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// On exit U contains the left singular vectors. + /// On exit VT contains the transposed right singular vectors. + /// The B matrix. + /// On exit, the solution matrix. + /// 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. public void SvdSolve(double[] a, double[] s, double[] u, double[] vt, double[] b, double[] x, double[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously SVD decomposed matrix. + /// + /// The number of columns of B. + /// The s values returned by . + /// The left singular vectors returned by . + /// The right singular vectors returned by . + /// The B matrix. + /// On exit, the solution matrix. public void SvdSolveFactored(int columnsOfB, double[] s, double[] u, double[] vt, double[] b, double[] x) { throw new NotImplementedException(); @@ -267,7 +532,13 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.Mkl #region ILinearAlgebraProvider Members - + /// + /// Adds a scaled vector to another: y += alpha*x. + /// + /// The vector to update. + /// The value to scale by. + /// The vector to add to . + /// This equivalent to the AXPY BLAS routine. public void AddVectorToScaledVector(float[] y, float alpha, float[] x) { if (y == null) @@ -293,36 +564,102 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.Mkl SafeNativeMethods.s_axpy(y.Length, alpha, x, y); } + /// + /// Scales an array. Can be used to scale a vector and a matrix. + /// + /// The scalar. + /// The values to scale. + /// This is equivalent to the SCAL BLAS routine. public void ScaleArray(float alpha, float[] x) { - throw new NotImplementedException(); + if (alpha == 1.0) + { + return; + } + + SafeNativeMethods.s_scale(x.Length, alpha, x); } + /// + /// Computes the dot product of x and y. + /// + /// The vector x. + /// The vector y. + /// The dot product of x and y. + /// This is equivalent to the DOT BLAS routine. public float DotProduct(float[] x, float[] y) { throw new NotImplementedException(); } + /// + /// Does a point wise add of two arrays z = x + y. This can be used + /// to add vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the addition. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void AddArrays(float[] x, float[] y, float[] result) { throw new NotImplementedException(); } + /// + /// Does a point wise subtraction of two arrays z = x - y. This can be used + /// to subtract vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the subtraction. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void SubtractArrays(float[] x, float[] y, float[] result) { throw new NotImplementedException(); } + /// + /// Does a point wise multiplication of two arrays z = x * y. This can be used + /// to multiple elements of vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the point wise multiplication. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void PointWiseMultiplyArrays(float[] x, float[] y, float[] result) { throw new NotImplementedException(); } + /// + /// Computes the requested of the matrix. + /// + /// The type of norm to compute. + /// The matrix to compute the norm from. + /// + /// The requested of the matrix. + /// public float MatrixNorm(Norm norm, float[] matrix) { throw new NotImplementedException(); } + /// + /// Computes the requested of the matrix. + /// + /// The type of norm to compute. + /// The matrix to compute the norm from. + /// The work array. Only used when + /// and needs to be have a length of at least M (number of rows of . + /// + /// The requested of the matrix. + /// public float MatrixNorm(Norm norm, float[] matrix, float[] work) { throw new NotImplementedException(); @@ -365,111 +702,307 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.Mkl throw new NotImplementedException(); } + /// + /// Computes the LU factorization of A. + /// + /// An m by n matrix. The matrix is overwritten with the + /// the LU factorization On exit. + /// On exit, it contains the pivot indices. The size + /// of the array must be min(m,n). + /// This is equivalent to the GETRF LAPACK routine. public void LUFactor(float[] a, int[] ipiv) { throw new NotImplementedException(); } + /// + /// Computes the inverse of matrix using LU factorization. + /// + /// The N by N matrix to invert. Contains the inverse On exit. + /// This is equivalent to the GETRF and GETRI LAPACK routines. public void LUInverse(float[] a) { throw new NotImplementedException(); } + /// + /// Computes the inverse of a previously factored matrix. + /// + /// The LU factored N by N matrix. Contains the inverse On exit. + /// The pivot indices of . + /// This is equivalent to the GETRI LAPACK routine. public void LUInverseFactored(float[] a, int[] ipiv) { throw new NotImplementedException(); } + /// + /// Computes the inverse of matrix using LU factorization. + /// + /// The N by N matrix to invert. Contains the inverse On exit. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. + /// This is equivalent to the GETRF and GETRI LAPACK routines. public void LUInverse(float[] a, float[] work) { throw new NotImplementedException(); } + /// + /// Computes the inverse of a previously factored matrix. + /// + /// The LU factored N by N matrix. Contains the inverse On exit. + /// The pivot indices of . + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. + /// This is equivalent to the GETRI LAPACK routine. public void LUInverseFactored(float[] a, int[] ipiv, float[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using LU factorization. + /// + /// The number of columns of B. + /// The square matrix A. + /// The B matrix. + /// This is equivalent to the GETRF and GETRS LAPACK routines. public void LUSolve(int columnsOfB, float[] a, float[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// The number of columns of B. + /// The factored A matrix. + /// The pivot indices of . + /// The B matrix. + /// This is equivalent to the GETRS LAPACK routine. public void LUSolveFactored(int columnsOfB, float[] a, int ipiv, float[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using LU factorization. + /// + /// How to transpose the matrix. + /// The number of columns of B. + /// The square matrix A. + /// The B matrix. + /// This is equivalent to the GETRF and GETRS LAPACK routines. public void LUSolve(Transpose transposeA, int columnsOfB, float[] a, float[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// How to transpose the matrix. + /// The number of columns of B. + /// The factored A matrix. + /// The pivot indices of . + /// The B matrix. + /// This is equivalent to the GETRS LAPACK routine. public void LUSolveFactored(Transpose transposeA, int columnsOfB, float[] a, int ipiv, float[] b) { throw new NotImplementedException(); } + /// + /// Computes the Cholesky factorization of A. + /// + /// On entry, a square, positive definite matrix. On exit, the matrix is overwritten with the + /// the Cholesky factorization. + /// This is equivalent to the POTRF LAPACK routine. public void CholeskyFactor(float[] a) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using Cholesky factorization. + /// + /// The number of columns of B. + /// The square, positive definite matrix A. + /// The B matrix. + /// This is equivalent to the POTRF add POTRS LAPACK routines. public void CholeskySolve(int columnsOfB, float[] a, float[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// The number of columns of B. + /// The factored A matrix. + /// The B matrix. + /// This is equivalent to the POTRS LAPACK routine. public void CholeskySolveFactored(int columnsOfB, float[] a, float[] b) { throw new NotImplementedException(); } + /// + /// Computes the QR factorization of A. + /// + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// This is similar to the GEQRF and ORGQR LAPACK routines. public void QRFactor(float[] r, float[] q) { throw new NotImplementedException(); } + /// + /// Computes the QR factorization of A. + /// + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. public void QRFactor(float[] r, float[] q, float[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using QR factorization of A. + /// + /// The number of columns of B. + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The B matrix. + /// On exit, the solution matrix. public void QRSolve(int columnsOfB, float[] r, float[] q, float[] b, float[] x) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using QR factorization of A. + /// + /// The number of columns of B. + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The B matrix. + /// On exit, the solution matrix. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. public void QRSolve(int columnsOfB, float[] r, float[] q, float[] b, float[] x, float[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously QR factored matrix. + /// + /// The number of columns of B. + /// The Q matrix obtained by calling . + /// The R matrix obtained by calling . + /// The B matrix. + /// On exit, the solution matrix. public void QRSolveFactored(int columnsOfB, float[] q, float[] r, float[] b, float[] x) { throw new NotImplementedException(); } + /// + /// Computes the singular value decomposition of A. + /// + /// Compute the singular U and VT vectors or not. + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// If is true, on exit U contains the left + /// singular vectors. + /// If is true, on exit VT contains the transposed + /// right singular vectors. + /// This is equivalent to the GESVD LAPACK routine. public void SinguarValueDecomposition(bool computeVectors, float[] a, float[] s, float[] u, float[] vt) { throw new NotImplementedException(); } + /// + /// Computes the singular value decomposition of A. + /// + /// Compute the singular U and VT vectors or not. + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// If is true, on exit U contains the left + /// singular vectors. + /// If is true, on exit VT contains the transposed + /// right singular vectors. + /// 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. + /// This is equivalent to the GESVD LAPACK routine. public void SingularValueDecomposition(bool computeVectors, float[] a, float[] s, float[] u, float[] vt, float[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using the singular value decomposition of A. + /// + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// On exit U contains the left singular vectors. + /// On exit VT contains the transposed right singular vectors. + /// The B matrix. + /// On exit, the solution matrix. public void SvdSolve(float[] a, float[] s, float[] u, float[] vt, float[] b, float[] x) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using the singular value decomposition of A. + /// + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// On exit U contains the left singular vectors. + /// On exit VT contains the transposed right singular vectors. + /// The B matrix. + /// On exit, the solution matrix. + /// 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. public void SvdSolve(float[] a, float[] s, float[] u, float[] vt, float[] b, float[] x, float[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously SVD decomposed matrix. + /// + /// The number of columns of B. + /// The s values returned by . + /// The left singular vectors returned by . + /// The right singular vectors returned by . + /// The B matrix. + /// On exit, the solution matrix. public void SvdSolveFactored(int columnsOfB, float[] s, float[] u, float[] vt, float[] b, float[] x) { throw new NotImplementedException(); @@ -479,7 +1012,13 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.Mkl #region ILinearAlgebraProvider Members - + /// + /// Adds a scaled vector to another: y += alpha*x. + /// + /// The vector to update. + /// The value to scale by. + /// The vector to add to . + /// This equivalent to the AXPY BLAS routine. public void AddVectorToScaledVector(Complex[] y, Complex alpha, Complex[] x) { if (y == null) @@ -505,36 +1044,102 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.Mkl SafeNativeMethods.z_axpy(y.Length, ref alpha, x, y); } + /// + /// Scales an array. Can be used to scale a vector and a matrix. + /// + /// The scalar. + /// The values to scale. + /// This is equivalent to the SCAL BLAS routine. public void ScaleArray(Complex alpha, Complex[] x) { - throw new NotImplementedException(); + if (alpha.IsOne) + { + return; + } + + SafeNativeMethods.z_scale(x.Length, ref alpha, x); } + /// + /// Computes the dot product of x and y. + /// + /// The vector x. + /// The vector y. + /// The dot product of x and y. + /// This is equivalent to the DOT BLAS routine. public Complex DotProduct(Complex[] x, Complex[] y) { throw new NotImplementedException(); } + /// + /// Does a point wise add of two arrays z = x + y. This can be used + /// to add vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the addition. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void AddArrays(Complex[] x, Complex[] y, Complex[] result) { throw new NotImplementedException(); } + /// + /// Does a point wise subtraction of two arrays z = x - y. This can be used + /// to subtract vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the subtraction. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void SubtractArrays(Complex[] x, Complex[] y, Complex[] result) { throw new NotImplementedException(); } + /// + /// Does a point wise multiplication of two arrays z = x * y. This can be used + /// to multiple elements of vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the point wise multiplication. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void PointWiseMultiplyArrays(Complex[] x, Complex[] y, Complex[] result) { throw new NotImplementedException(); } + /// + /// Computes the requested of the matrix. + /// + /// The type of norm to compute. + /// The matrix to compute the norm from. + /// + /// The requested of the matrix. + /// public Complex MatrixNorm(Norm norm, Complex[] matrix) { throw new NotImplementedException(); } + /// + /// Computes the requested of the matrix. + /// + /// The type of norm to compute. + /// The matrix to compute the norm from. + /// The work array. Only used when + /// and needs to be have a length of at least M (number of rows of . + /// + /// The requested of the matrix. + /// public Complex MatrixNorm(Norm norm, Complex[] matrix, Complex[] work) { throw new NotImplementedException(); @@ -577,111 +1182,307 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.Mkl throw new NotImplementedException(); } + /// + /// Computes the LU factorization of A. + /// + /// An m by n matrix. The matrix is overwritten with the + /// the LU factorization On exit. + /// On exit, it contains the pivot indices. The size + /// of the array must be min(m,n). + /// This is equivalent to the GETRF LAPACK routine. public void LUFactor(Complex[] a, int[] ipiv) { throw new NotImplementedException(); } + /// + /// Computes the inverse of matrix using LU factorization. + /// + /// The N by N matrix to invert. Contains the inverse On exit. + /// This is equivalent to the GETRF and GETRI LAPACK routines. public void LUInverse(Complex[] a) { throw new NotImplementedException(); } + /// + /// Computes the inverse of a previously factored matrix. + /// + /// The LU factored N by N matrix. Contains the inverse On exit. + /// The pivot indices of . + /// This is equivalent to the GETRI LAPACK routine. public void LUInverseFactored(Complex[] a, int[] ipiv) { throw new NotImplementedException(); } + /// + /// Computes the inverse of matrix using LU factorization. + /// + /// The N by N matrix to invert. Contains the inverse On exit. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. + /// This is equivalent to the GETRF and GETRI LAPACK routines. public void LUInverse(Complex[] a, Complex[] work) { throw new NotImplementedException(); } + /// + /// Computes the inverse of a previously factored matrix. + /// + /// The LU factored N by N matrix. Contains the inverse On exit. + /// The pivot indices of . + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. + /// This is equivalent to the GETRI LAPACK routine. public void LUInverseFactored(Complex[] a, int[] ipiv, Complex[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using LU factorization. + /// + /// The number of columns of B. + /// The square matrix A. + /// The B matrix. + /// This is equivalent to the GETRF and GETRS LAPACK routines. public void LUSolve(int columnsOfB, Complex[] a, Complex[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// The number of columns of B. + /// The factored A matrix. + /// The pivot indices of . + /// The B matrix. + /// This is equivalent to the GETRS LAPACK routine. public void LUSolveFactored(int columnsOfB, Complex[] a, int ipiv, Complex[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using LU factorization. + /// + /// How to transpose the matrix. + /// The number of columns of B. + /// The square matrix A. + /// The B matrix. + /// This is equivalent to the GETRF and GETRS LAPACK routines. public void LUSolve(Transpose transposeA, int columnsOfB, Complex[] a, Complex[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// How to transpose the matrix. + /// The number of columns of B. + /// The factored A matrix. + /// The pivot indices of . + /// The B matrix. + /// This is equivalent to the GETRS LAPACK routine. public void LUSolveFactored(Transpose transposeA, int columnsOfB, Complex[] a, int ipiv, Complex[] b) { throw new NotImplementedException(); } + /// + /// Computes the Cholesky factorization of A. + /// + /// On entry, a square, positive definite matrix. On exit, the matrix is overwritten with the + /// the Cholesky factorization. + /// This is equivalent to the POTRF LAPACK routine. public void CholeskyFactor(Complex[] a) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using Cholesky factorization. + /// + /// The number of columns of B. + /// The square, positive definite matrix A. + /// The B matrix. + /// This is equivalent to the POTRF add POTRS LAPACK routines. public void CholeskySolve(int columnsOfB, Complex[] a, Complex[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// The number of columns of B. + /// The factored A matrix. + /// The B matrix. + /// This is equivalent to the POTRS LAPACK routine. public void CholeskySolveFactored(int columnsOfB, Complex[] a, Complex[] b) { throw new NotImplementedException(); } + /// + /// Computes the QR factorization of A. + /// + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// This is similar to the GEQRF and ORGQR LAPACK routines. public void QRFactor(Complex[] r, Complex[] q) { throw new NotImplementedException(); } + /// + /// Computes the QR factorization of A. + /// + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. public void QRFactor(Complex[] r, Complex[] q, Complex[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using QR factorization of A. + /// + /// The number of columns of B. + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The B matrix. + /// On exit, the solution matrix. public void QRSolve(int columnsOfB, Complex[] r, Complex[] q, Complex[] b, Complex[] x) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using QR factorization of A. + /// + /// The number of columns of B. + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The B matrix. + /// On exit, the solution matrix. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. public void QRSolve(int columnsOfB, Complex[] r, Complex[] q, Complex[] b, Complex[] x, Complex[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously QR factored matrix. + /// + /// The number of columns of B. + /// The Q matrix obtained by calling . + /// The R matrix obtained by calling . + /// The B matrix. + /// On exit, the solution matrix. public void QRSolveFactored(int columnsOfB, Complex[] q, Complex[] r, Complex[] b, Complex[] x) { throw new NotImplementedException(); } + /// + /// Computes the singular value decomposition of A. + /// + /// Compute the singular U and VT vectors or not. + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// If is true, on exit U contains the left + /// singular vectors. + /// If is true, on exit VT contains the transposed + /// right singular vectors. + /// This is equivalent to the GESVD LAPACK routine. public void SinguarValueDecomposition(bool computeVectors, Complex[] a, Complex[] s, Complex[] u, Complex[] vt) { throw new NotImplementedException(); } + /// + /// Computes the singular value decomposition of A. + /// + /// Compute the singular U and VT vectors or not. + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// If is true, on exit U contains the left + /// singular vectors. + /// If is true, on exit VT contains the transposed + /// right singular vectors. + /// 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. + /// This is equivalent to the GESVD LAPACK routine. public void SingularValueDecomposition(bool computeVectors, Complex[] a, Complex[] s, Complex[] u, Complex[] vt, Complex[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using the singular value decomposition of A. + /// + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// On exit U contains the left singular vectors. + /// On exit VT contains the transposed right singular vectors. + /// The B matrix. + /// On exit, the solution matrix. public void SvdSolve(Complex[] a, Complex[] s, Complex[] u, Complex[] vt, Complex[] b, Complex[] x) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using the singular value decomposition of A. + /// + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// On exit U contains the left singular vectors. + /// On exit VT contains the transposed right singular vectors. + /// The B matrix. + /// On exit, the solution matrix. + /// 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. public void SvdSolve(Complex[] a, Complex[] s, Complex[] u, Complex[] vt, Complex[] b, Complex[] x, Complex[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously SVD decomposed matrix. + /// + /// The number of columns of B. + /// The s values returned by . + /// The left singular vectors returned by . + /// The right singular vectors returned by . + /// The B matrix. + /// On exit, the solution matrix. public void SvdSolveFactored(int columnsOfB, Complex[] s, Complex[] u, Complex[] vt, Complex[] b, Complex[] x) { throw new NotImplementedException(); @@ -691,6 +1492,13 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.Mkl #region ILinearAlgebraProvider Members + /// + /// Adds a scaled vector to another: y += alpha*x. + /// + /// The vector to update. + /// The value to scale by. + /// The vector to add to . + /// This equivalent to the AXPY BLAS routine. public void AddVectorToScaledVector(Complex32[] y, Complex32 alpha, Complex32[] x) { if (y == null) @@ -716,36 +1524,102 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.Mkl SafeNativeMethods.c_axpy(y.Length, ref alpha, x, y); } + /// + /// Scales an array. Can be used to scale a vector and a matrix. + /// + /// The scalar. + /// The values to scale. + /// This is equivalent to the SCAL BLAS routine. public void ScaleArray(Complex32 alpha, Complex32[] x) { - throw new NotImplementedException(); + if (alpha.IsOne) + { + return; + } + + SafeNativeMethods.c_scale(x.Length, ref alpha, x); } + /// + /// Computes the dot product of x and y. + /// + /// The vector x. + /// The vector y. + /// The dot product of x and y. + /// This is equivalent to the DOT BLAS routine. public Complex32 DotProduct(Complex32[] x, Complex32[] y) { throw new NotImplementedException(); } + /// + /// Does a point wise add of two arrays z = x + y. This can be used + /// to add vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the addition. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void AddArrays(Complex32[] x, Complex32[] y, Complex32[] result) { throw new NotImplementedException(); } + /// + /// Does a point wise subtraction of two arrays z = x - y. This can be used + /// to subtract vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the subtraction. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void SubtractArrays(Complex32[] x, Complex32[] y, Complex32[] result) { throw new NotImplementedException(); } + /// + /// Does a point wise multiplication of two arrays z = x * y. This can be used + /// to multiple elements of vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the point wise multiplication. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void PointWiseMultiplyArrays(Complex32[] x, Complex32[] y, Complex32[] result) { throw new NotImplementedException(); } + /// + /// Computes the requested of the matrix. + /// + /// The type of norm to compute. + /// The matrix to compute the norm from. + /// + /// The requested of the matrix. + /// public Complex32 MatrixNorm(Norm norm, Complex32[] matrix) { throw new NotImplementedException(); } + /// + /// Computes the requested of the matrix. + /// + /// The type of norm to compute. + /// The matrix to compute the norm from. + /// The work array. Only used when + /// and needs to be have a length of at least M (number of rows of . + /// + /// The requested of the matrix. + /// public Complex32 MatrixNorm(Norm norm, Complex32[] matrix, Complex32[] work) { throw new NotImplementedException(); @@ -788,111 +1662,307 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.Mkl throw new NotImplementedException(); } + /// + /// Computes the LU factorization of A. + /// + /// An m by n matrix. The matrix is overwritten with the + /// the LU factorization On exit. + /// On exit, it contains the pivot indices. The size + /// of the array must be min(m,n). + /// This is equivalent to the GETRF LAPACK routine. public void LUFactor(Complex32[] a, int[] ipiv) { throw new NotImplementedException(); } + /// + /// Computes the inverse of matrix using LU factorization. + /// + /// The N by N matrix to invert. Contains the inverse On exit. + /// This is equivalent to the GETRF and GETRI LAPACK routines. public void LUInverse(Complex32[] a) { throw new NotImplementedException(); } + /// + /// Computes the inverse of a previously factored matrix. + /// + /// The LU factored N by N matrix. Contains the inverse On exit. + /// The pivot indices of . + /// This is equivalent to the GETRI LAPACK routine. public void LUInverseFactored(Complex32[] a, int[] ipiv) { throw new NotImplementedException(); } + /// + /// Computes the inverse of matrix using LU factorization. + /// + /// The N by N matrix to invert. Contains the inverse On exit. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. + /// This is equivalent to the GETRF and GETRI LAPACK routines. public void LUInverse(Complex32[] a, Complex32[] work) { throw new NotImplementedException(); } + /// + /// Computes the inverse of a previously factored matrix. + /// + /// The LU factored N by N matrix. Contains the inverse On exit. + /// The pivot indices of . + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. + /// This is equivalent to the GETRI LAPACK routine. public void LUInverseFactored(Complex32[] a, int[] ipiv, Complex32[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using LU factorization. + /// + /// The number of columns of B. + /// The square matrix A. + /// The B matrix. + /// This is equivalent to the GETRF and GETRS LAPACK routines. public void LUSolve(int columnsOfB, Complex32[] a, Complex32[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// The number of columns of B. + /// The factored A matrix. + /// The pivot indices of . + /// The B matrix. + /// This is equivalent to the GETRS LAPACK routine. public void LUSolveFactored(int columnsOfB, Complex32[] a, int ipiv, Complex32[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using LU factorization. + /// + /// How to transpose the matrix. + /// The number of columns of B. + /// The square matrix A. + /// The B matrix. + /// This is equivalent to the GETRF and GETRS LAPACK routines. public void LUSolve(Transpose transposeA, int columnsOfB, Complex32[] a, Complex32[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// How to transpose the matrix. + /// The number of columns of B. + /// The factored A matrix. + /// The pivot indices of . + /// The B matrix. + /// This is equivalent to the GETRS LAPACK routine. public void LUSolveFactored(Transpose transposeA, int columnsOfB, Complex32[] a, int ipiv, Complex32[] b) { throw new NotImplementedException(); } + /// + /// Computes the Cholesky factorization of A. + /// + /// On entry, a square, positive definite matrix. On exit, the matrix is overwritten with the + /// the Cholesky factorization. + /// This is equivalent to the POTRF LAPACK routine. public void CholeskyFactor(Complex32[] a) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using Cholesky factorization. + /// + /// The number of columns of B. + /// The square, positive definite matrix A. + /// The B matrix. + /// This is equivalent to the POTRF add POTRS LAPACK routines. public void CholeskySolve(int columnsOfB, Complex32[] a, Complex32[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// The number of columns of B. + /// The factored A matrix. + /// The B matrix. + /// This is equivalent to the POTRS LAPACK routine. public void CholeskySolveFactored(int columnsOfB, Complex32[] a, Complex32[] b) { throw new NotImplementedException(); } + /// + /// Computes the QR factorization of A. + /// + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// This is similar to the GEQRF and ORGQR LAPACK routines. public void QRFactor(Complex32[] r, Complex32[] q) { throw new NotImplementedException(); } + /// + /// Computes the QR factorization of A. + /// + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. public void QRFactor(Complex32[] r, Complex32[] q, Complex32[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using QR factorization of A. + /// + /// The number of columns of B. + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The B matrix. + /// On exit, the solution matrix. public void QRSolve(int columnsOfB, Complex32[] r, Complex32[] q, Complex32[] b, Complex32[] x) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using QR factorization of A. + /// + /// The number of columns of B. + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The B matrix. + /// On exit, the solution matrix. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. public void QRSolve(int columnsOfB, Complex32[] r, Complex32[] q, Complex32[] b, Complex32[] x, Complex32[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously QR factored matrix. + /// + /// The number of columns of B. + /// The Q matrix obtained by calling . + /// The R matrix obtained by calling . + /// The B matrix. + /// On exit, the solution matrix. public void QRSolveFactored(int columnsOfB, Complex32[] q, Complex32[] r, Complex32[] b, Complex32[] x) { throw new NotImplementedException(); } + /// + /// Computes the singular value decomposition of A. + /// + /// Compute the singular U and VT vectors or not. + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// If is true, on exit U contains the left + /// singular vectors. + /// If is true, on exit VT contains the transposed + /// right singular vectors. + /// This is equivalent to the GESVD LAPACK routine. public void SinguarValueDecomposition(bool computeVectors, Complex32[] a, Complex32[] s, Complex32[] u, Complex32[] vt) { throw new NotImplementedException(); } + /// + /// Computes the singular value decomposition of A. + /// + /// Compute the singular U and VT vectors or not. + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// If is true, on exit U contains the left + /// singular vectors. + /// If is true, on exit VT contains the transposed + /// right singular vectors. + /// 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. + /// This is equivalent to the GESVD LAPACK routine. public void SingularValueDecomposition(bool computeVectors, Complex32[] a, Complex32[] s, Complex32[] u, Complex32[] vt, Complex32[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using the singular value decomposition of A. + /// + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// On exit U contains the left singular vectors. + /// On exit VT contains the transposed right singular vectors. + /// The B matrix. + /// On exit, the solution matrix. public void SvdSolve(Complex32[] a, Complex32[] s, Complex32[] u, Complex32[] vt, Complex32[] b, Complex32[] x) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using the singular value decomposition of A. + /// + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// On exit U contains the left singular vectors. + /// On exit VT contains the transposed right singular vectors. + /// The B matrix. + /// On exit, the solution matrix. + /// 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. public void SvdSolve(Complex32[] a, Complex32[] s, Complex32[] u, Complex32[] vt, Complex32[] b, Complex32[] x, Complex32[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously SVD decomposed matrix. + /// + /// The number of columns of B. + /// The s values returned by . + /// The left singular vectors returned by . + /// The right singular vectors returned by . + /// The B matrix. + /// On exit, the solution matrix. public void SvdSolveFactored(int columnsOfB, Complex32[] s, Complex32[] u, Complex32[] vt, Complex32[] b, Complex32[] x) { throw new NotImplementedException(); diff --git a/src/Numerics/Algorithms/LinearAlgebra/Mkl/SafeNativeMethods.cs b/src/Numerics/Algorithms/LinearAlgebra/Mkl/SafeNativeMethods.cs index e85222b5..c44ca405 100644 --- a/src/Numerics/Algorithms/LinearAlgebra/Mkl/SafeNativeMethods.cs +++ b/src/Numerics/Algorithms/LinearAlgebra/Mkl/SafeNativeMethods.cs @@ -1,4 +1,4 @@ -// +// // Math.NET Numerics, part of the Math.NET Project // http://mathnet.opensourcedotnet.info // @@ -28,7 +28,7 @@ /* This file is automatically generated - do not modify it. Change SafeNativeMethods.include instead. - Last generated on: 11/4/2009 2:23:40 PM + Last generated on: 11/6/2009 2:44:03 PM */ using System.Runtime.InteropServices; @@ -36,9 +36,15 @@ using System.Security; namespace MathNet.Numerics.Algorithms.LinearAlgebra.Mkl { + /// + /// P/Invoke methods to the native math libraries. + /// [SuppressUnmanagedCodeSecurity] internal static class SafeNativeMethods { + /// + /// Name of the native DLL. + /// private const string DllName = "MathNET.Numerics.MKL.dll"; #region BLAS @@ -55,6 +61,18 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.Mkl [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] internal static extern void z_axpy(int n, ref Complex alpha, Complex[] x, [In, Out] Complex[] y); + [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] + internal static extern void s_scale(int n, float alpha, [Out] float[] x); + + [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] + internal static extern void d_scale(int n, double alpha, [Out] double[] x); + + [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] + internal static extern void c_scale(int n, ref Complex32 alpha, [In, Out] Complex32[] x); + + [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] + internal static extern void z_scale(int n, ref Complex alpha, [In, Out] Complex[] x); + #endregion BLAS - } + } } diff --git a/src/Numerics/Algorithms/LinearAlgebra/NativeAlgebraProvider.include b/src/Numerics/Algorithms/LinearAlgebra/NativeAlgebraProvider.include index ac80d7fd..addb970c 100644 --- a/src/Numerics/Algorithms/LinearAlgebra/NativeAlgebraProvider.include +++ b/src/Numerics/Algorithms/LinearAlgebra/NativeAlgebraProvider.include @@ -1,4 +1,4 @@ -// +// // Math.NET Numerics, part of the Math.NET Project // http://mathnet.opensourcedotnet.info // Copyright (c) 2009 Math.NET @@ -78,39 +78,108 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.<#=library#> /// This is equivalent to the SCAL BLAS routine. public void ScaleArray(double alpha, double[] x) { - throw new NotImplementedException(); + if (alpha == 1.0) + { + return; + } + + SafeNativeMethods.d_scale(x.Length, alpha, x); } + /// + /// Queries the provider for the optimal, workspace block size + /// for the given routine. + /// + /// Name of the method to query. + /// + /// -1 if the provider cannot compute the workspace size; otherwise + /// the suggested block size. + /// public int QueryWorkspaceBlockSize(string methodName) { throw new NotImplementedException(); } + /// + /// Computes the dot product of x and y. + /// + /// The vector x. + /// The vector y. + /// The dot product of x and y. + /// This is equivalent to the DOT BLAS routine. public double DotProduct(double[] x, double[] y) { throw new NotImplementedException(); } + /// + /// Does a point wise add of two arrays z = x + y. This can be used + /// to add vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the addition. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void AddArrays(double[] x, double[] y, double[] result) { throw new NotImplementedException(); } + /// + /// Does a point wise subtraction of two arrays z = x - y. This can be used + /// to subtract vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the subtraction. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void SubtractArrays(double[] x, double[] y, double[] result) { throw new NotImplementedException(); } + /// + /// Does a point wise multiplication of two arrays z = x * y. This can be used + /// to multiple elements of vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the point wise multiplication. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void PointWiseMultiplyArrays(double[] x, double[] y, double[] result) { throw new NotImplementedException(); } + /// + /// Computes the requested of the matrix. + /// + /// The type of norm to compute. + /// The matrix to compute the norm from. + /// + /// The requested of the matrix. + /// public double MatrixNorm(Norm norm, double[] matrix) { throw new NotImplementedException(); } + /// + /// Computes the requested of the matrix. + /// + /// The type of norm to compute. + /// The matrix to compute the norm from. + /// The work array. Only used when + /// and needs to be have a length of at least M (number of rows of . + /// + /// The requested of the matrix. + /// public double MatrixNorm(Norm norm, double[] matrix, double[] work) { throw new NotImplementedException(); @@ -153,111 +222,307 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.<#=library#> throw new NotImplementedException(); } + /// + /// Computes the LU factorization of A. + /// + /// An m by n matrix. The matrix is overwritten with the + /// the LU factorization On exit. + /// On exit, it contains the pivot indices. The size + /// of the array must be min(m,n). + /// This is equivalent to the GETRF LAPACK routine. public void LUFactor(double[] a, int[] ipiv) { throw new NotImplementedException(); } + /// + /// Computes the inverse of matrix using LU factorization. + /// + /// The N by N matrix to invert. Contains the inverse On exit. + /// This is equivalent to the GETRF and GETRI LAPACK routines. public void LUInverse(double[] a) { throw new NotImplementedException(); } + /// + /// Computes the inverse of a previously factored matrix. + /// + /// The LU factored N by N matrix. Contains the inverse On exit. + /// The pivot indices of . + /// This is equivalent to the GETRI LAPACK routine. public void LUInverseFactored(double[] a, int[] ipiv) { throw new NotImplementedException(); } + /// + /// Computes the inverse of matrix using LU factorization. + /// + /// The N by N matrix to invert. Contains the inverse On exit. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. + /// This is equivalent to the GETRF and GETRI LAPACK routines. public void LUInverse(double[] a, double[] work) { throw new NotImplementedException(); } + /// + /// Computes the inverse of a previously factored matrix. + /// + /// The LU factored N by N matrix. Contains the inverse On exit. + /// The pivot indices of . + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. + /// This is equivalent to the GETRI LAPACK routine. public void LUInverseFactored(double[] a, int[] ipiv, double[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using LU factorization. + /// + /// The number of columns of B. + /// The square matrix A. + /// The B matrix. + /// This is equivalent to the GETRF and GETRS LAPACK routines. public void LUSolve(int columnsOfB, double[] a, double[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// The number of columns of B. + /// The factored A matrix. + /// The pivot indices of . + /// The B matrix. + /// This is equivalent to the GETRS LAPACK routine. public void LUSolveFactored(int columnsOfB, double[] a, int ipiv, double[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using LU factorization. + /// + /// How to transpose the matrix. + /// The number of columns of B. + /// The square matrix A. + /// The B matrix. + /// This is equivalent to the GETRF and GETRS LAPACK routines. public void LUSolve(Transpose transposeA, int columnsOfB, double[] a, double[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// How to transpose the matrix. + /// The number of columns of B. + /// The factored A matrix. + /// The pivot indices of . + /// The B matrix. + /// This is equivalent to the GETRS LAPACK routine. public void LUSolveFactored(Transpose transposeA, int columnsOfB, double[] a, int ipiv, double[] b) { throw new NotImplementedException(); } + /// + /// Computes the Cholesky factorization of A. + /// + /// On entry, a square, positive definite matrix. On exit, the matrix is overwritten with the + /// the Cholesky factorization. + /// This is equivalent to the POTRF LAPACK routine. public void CholeskyFactor(double[] a) { throw new NotImplementedException(); } - + + /// + /// Solves A*X=B for X using Cholesky factorization. + /// + /// The number of columns of B. + /// The square, positive definite matrix A. + /// The B matrix. + /// This is equivalent to the POTRF add POTRS LAPACK routines. public void CholeskySolve(int columnsOfB, double[] a, double[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// The number of columns of B. + /// The factored A matrix. + /// The B matrix. + /// This is equivalent to the POTRS LAPACK routine. public void CholeskySolveFactored(int columnsOfB, double[] a, double[] b) { throw new NotImplementedException(); } + /// + /// Computes the QR factorization of A. + /// + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// This is similar to the GEQRF and ORGQR LAPACK routines. public void QRFactor(double[] r, double[] q) { throw new NotImplementedException(); } + /// + /// Computes the QR factorization of A. + /// + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. public void QRFactor(double[] r, double[] q, double[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using QR factorization of A. + /// + /// The number of columns of B. + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The B matrix. + /// On exit, the solution matrix. public void QRSolve(int columnsOfB, double[] r, double[] q, double[] b, double[] x) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using QR factorization of A. + /// + /// The number of columns of B. + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The B matrix. + /// On exit, the solution matrix. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. public void QRSolve(int columnsOfB, double[] r, double[] q, double[] b, double[] x, double[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously QR factored matrix. + /// + /// The number of columns of B. + /// The Q matrix obtained by calling . + /// The R matrix obtained by calling . + /// The B matrix. + /// On exit, the solution matrix. public void QRSolveFactored(int columnsOfB, double[] q, double[] r, double[] b, double[] x) { throw new NotImplementedException(); } + /// + /// Computes the singular value decomposition of A. + /// + /// Compute the singular U and VT vectors or not. + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// If is true, on exit U contains the left + /// singular vectors. + /// If is true, on exit VT contains the transposed + /// right singular vectors. + /// This is equivalent to the GESVD LAPACK routine. public void SinguarValueDecomposition(bool computeVectors, double[] a, double[] s, double[] u, double[] vt) { throw new NotImplementedException(); } + /// + /// Computes the singular value decomposition of A. + /// + /// Compute the singular U and VT vectors or not. + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// If is true, on exit U contains the left + /// singular vectors. + /// If is true, on exit VT contains the transposed + /// right singular vectors. + /// 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. + /// This is equivalent to the GESVD LAPACK routine. public void SingularValueDecomposition(bool computeVectors, double[] a, double[] s, double[] u, double[] vt, double[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using the singular value decomposition of A. + /// + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// On exit U contains the left singular vectors. + /// On exit VT contains the transposed right singular vectors. + /// The B matrix. + /// On exit, the solution matrix. public void SvdSolve(double[] a, double[] s, double[] u, double[] vt, double[] b, double[] x) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using the singular value decomposition of A. + /// + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// On exit U contains the left singular vectors. + /// On exit VT contains the transposed right singular vectors. + /// The B matrix. + /// On exit, the solution matrix. + /// 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. public void SvdSolve(double[] a, double[] s, double[] u, double[] vt, double[] b, double[] x, double[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously SVD decomposed matrix. + /// + /// The number of columns of B. + /// The s values returned by . + /// The left singular vectors returned by . + /// The right singular vectors returned by . + /// The B matrix. + /// On exit, the solution matrix. public void SvdSolveFactored(int columnsOfB, double[] s, double[] u, double[] vt, double[] b, double[] x) { throw new NotImplementedException(); @@ -267,7 +532,13 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.<#=library#> #region ILinearAlgebraProvider Members - + /// + /// Adds a scaled vector to another: y += alpha*x. + /// + /// The vector to update. + /// The value to scale by. + /// The vector to add to . + /// This equivalent to the AXPY BLAS routine. public void AddVectorToScaledVector(float[] y, float alpha, float[] x) { if (y == null) @@ -293,36 +564,102 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.<#=library#> SafeNativeMethods.s_axpy(y.Length, alpha, x, y); } + /// + /// Scales an array. Can be used to scale a vector and a matrix. + /// + /// The scalar. + /// The values to scale. + /// This is equivalent to the SCAL BLAS routine. public void ScaleArray(float alpha, float[] x) { - throw new NotImplementedException(); + if (alpha == 1.0) + { + return; + } + + SafeNativeMethods.s_scale(x.Length, alpha, x); } + /// + /// Computes the dot product of x and y. + /// + /// The vector x. + /// The vector y. + /// The dot product of x and y. + /// This is equivalent to the DOT BLAS routine. public float DotProduct(float[] x, float[] y) { throw new NotImplementedException(); } + /// + /// Does a point wise add of two arrays z = x + y. This can be used + /// to add vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the addition. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void AddArrays(float[] x, float[] y, float[] result) { throw new NotImplementedException(); } + /// + /// Does a point wise subtraction of two arrays z = x - y. This can be used + /// to subtract vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the subtraction. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void SubtractArrays(float[] x, float[] y, float[] result) { throw new NotImplementedException(); } + /// + /// Does a point wise multiplication of two arrays z = x * y. This can be used + /// to multiple elements of vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the point wise multiplication. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void PointWiseMultiplyArrays(float[] x, float[] y, float[] result) { throw new NotImplementedException(); } + /// + /// Computes the requested of the matrix. + /// + /// The type of norm to compute. + /// The matrix to compute the norm from. + /// + /// The requested of the matrix. + /// public float MatrixNorm(Norm norm, float[] matrix) { throw new NotImplementedException(); } + /// + /// Computes the requested of the matrix. + /// + /// The type of norm to compute. + /// The matrix to compute the norm from. + /// The work array. Only used when + /// and needs to be have a length of at least M (number of rows of . + /// + /// The requested of the matrix. + /// public float MatrixNorm(Norm norm, float[] matrix, float[] work) { throw new NotImplementedException(); @@ -365,111 +702,307 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.<#=library#> throw new NotImplementedException(); } + /// + /// Computes the LU factorization of A. + /// + /// An m by n matrix. The matrix is overwritten with the + /// the LU factorization On exit. + /// On exit, it contains the pivot indices. The size + /// of the array must be min(m,n). + /// This is equivalent to the GETRF LAPACK routine. public void LUFactor(float[] a, int[] ipiv) { throw new NotImplementedException(); } + /// + /// Computes the inverse of matrix using LU factorization. + /// + /// The N by N matrix to invert. Contains the inverse On exit. + /// This is equivalent to the GETRF and GETRI LAPACK routines. public void LUInverse(float[] a) { throw new NotImplementedException(); } + /// + /// Computes the inverse of a previously factored matrix. + /// + /// The LU factored N by N matrix. Contains the inverse On exit. + /// The pivot indices of . + /// This is equivalent to the GETRI LAPACK routine. public void LUInverseFactored(float[] a, int[] ipiv) { throw new NotImplementedException(); } + /// + /// Computes the inverse of matrix using LU factorization. + /// + /// The N by N matrix to invert. Contains the inverse On exit. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. + /// This is equivalent to the GETRF and GETRI LAPACK routines. public void LUInverse(float[] a, float[] work) { throw new NotImplementedException(); } + /// + /// Computes the inverse of a previously factored matrix. + /// + /// The LU factored N by N matrix. Contains the inverse On exit. + /// The pivot indices of . + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. + /// This is equivalent to the GETRI LAPACK routine. public void LUInverseFactored(float[] a, int[] ipiv, float[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using LU factorization. + /// + /// The number of columns of B. + /// The square matrix A. + /// The B matrix. + /// This is equivalent to the GETRF and GETRS LAPACK routines. public void LUSolve(int columnsOfB, float[] a, float[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// The number of columns of B. + /// The factored A matrix. + /// The pivot indices of . + /// The B matrix. + /// This is equivalent to the GETRS LAPACK routine. public void LUSolveFactored(int columnsOfB, float[] a, int ipiv, float[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using LU factorization. + /// + /// How to transpose the matrix. + /// The number of columns of B. + /// The square matrix A. + /// The B matrix. + /// This is equivalent to the GETRF and GETRS LAPACK routines. public void LUSolve(Transpose transposeA, int columnsOfB, float[] a, float[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// How to transpose the matrix. + /// The number of columns of B. + /// The factored A matrix. + /// The pivot indices of . + /// The B matrix. + /// This is equivalent to the GETRS LAPACK routine. public void LUSolveFactored(Transpose transposeA, int columnsOfB, float[] a, int ipiv, float[] b) { throw new NotImplementedException(); } + /// + /// Computes the Cholesky factorization of A. + /// + /// On entry, a square, positive definite matrix. On exit, the matrix is overwritten with the + /// the Cholesky factorization. + /// This is equivalent to the POTRF LAPACK routine. public void CholeskyFactor(float[] a) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using Cholesky factorization. + /// + /// The number of columns of B. + /// The square, positive definite matrix A. + /// The B matrix. + /// This is equivalent to the POTRF add POTRS LAPACK routines. public void CholeskySolve(int columnsOfB, float[] a, float[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// The number of columns of B. + /// The factored A matrix. + /// The B matrix. + /// This is equivalent to the POTRS LAPACK routine. public void CholeskySolveFactored(int columnsOfB, float[] a, float[] b) { throw new NotImplementedException(); } + /// + /// Computes the QR factorization of A. + /// + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// This is similar to the GEQRF and ORGQR LAPACK routines. public void QRFactor(float[] r, float[] q) { throw new NotImplementedException(); } + /// + /// Computes the QR factorization of A. + /// + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. public void QRFactor(float[] r, float[] q, float[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using QR factorization of A. + /// + /// The number of columns of B. + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The B matrix. + /// On exit, the solution matrix. public void QRSolve(int columnsOfB, float[] r, float[] q, float[] b, float[] x) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using QR factorization of A. + /// + /// The number of columns of B. + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The B matrix. + /// On exit, the solution matrix. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. public void QRSolve(int columnsOfB, float[] r, float[] q, float[] b, float[] x, float[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously QR factored matrix. + /// + /// The number of columns of B. + /// The Q matrix obtained by calling . + /// The R matrix obtained by calling . + /// The B matrix. + /// On exit, the solution matrix. public void QRSolveFactored(int columnsOfB, float[] q, float[] r, float[] b, float[] x) { throw new NotImplementedException(); } + /// + /// Computes the singular value decomposition of A. + /// + /// Compute the singular U and VT vectors or not. + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// If is true, on exit U contains the left + /// singular vectors. + /// If is true, on exit VT contains the transposed + /// right singular vectors. + /// This is equivalent to the GESVD LAPACK routine. public void SinguarValueDecomposition(bool computeVectors, float[] a, float[] s, float[] u, float[] vt) { throw new NotImplementedException(); } + /// + /// Computes the singular value decomposition of A. + /// + /// Compute the singular U and VT vectors or not. + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// If is true, on exit U contains the left + /// singular vectors. + /// If is true, on exit VT contains the transposed + /// right singular vectors. + /// 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. + /// This is equivalent to the GESVD LAPACK routine. public void SingularValueDecomposition(bool computeVectors, float[] a, float[] s, float[] u, float[] vt, float[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using the singular value decomposition of A. + /// + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// On exit U contains the left singular vectors. + /// On exit VT contains the transposed right singular vectors. + /// The B matrix. + /// On exit, the solution matrix. public void SvdSolve(float[] a, float[] s, float[] u, float[] vt, float[] b, float[] x) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using the singular value decomposition of A. + /// + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// On exit U contains the left singular vectors. + /// On exit VT contains the transposed right singular vectors. + /// The B matrix. + /// On exit, the solution matrix. + /// 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. public void SvdSolve(float[] a, float[] s, float[] u, float[] vt, float[] b, float[] x, float[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously SVD decomposed matrix. + /// + /// The number of columns of B. + /// The s values returned by . + /// The left singular vectors returned by . + /// The right singular vectors returned by . + /// The B matrix. + /// On exit, the solution matrix. public void SvdSolveFactored(int columnsOfB, float[] s, float[] u, float[] vt, float[] b, float[] x) { throw new NotImplementedException(); @@ -479,7 +1012,13 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.<#=library#> #region ILinearAlgebraProvider Members - + /// + /// Adds a scaled vector to another: y += alpha*x. + /// + /// The vector to update. + /// The value to scale by. + /// The vector to add to . + /// This equivalent to the AXPY BLAS routine. public void AddVectorToScaledVector(Complex[] y, Complex alpha, Complex[] x) { if (y == null) @@ -505,36 +1044,102 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.<#=library#> SafeNativeMethods.z_axpy(y.Length, ref alpha, x, y); } + /// + /// Scales an array. Can be used to scale a vector and a matrix. + /// + /// The scalar. + /// The values to scale. + /// This is equivalent to the SCAL BLAS routine. public void ScaleArray(Complex alpha, Complex[] x) { - throw new NotImplementedException(); + if (alpha.IsOne) + { + return; + } + + SafeNativeMethods.z_scale(x.Length, ref alpha, x); } + /// + /// Computes the dot product of x and y. + /// + /// The vector x. + /// The vector y. + /// The dot product of x and y. + /// This is equivalent to the DOT BLAS routine. public Complex DotProduct(Complex[] x, Complex[] y) { throw new NotImplementedException(); } + /// + /// Does a point wise add of two arrays z = x + y. This can be used + /// to add vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the addition. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void AddArrays(Complex[] x, Complex[] y, Complex[] result) { throw new NotImplementedException(); } + /// + /// Does a point wise subtraction of two arrays z = x - y. This can be used + /// to subtract vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the subtraction. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void SubtractArrays(Complex[] x, Complex[] y, Complex[] result) { throw new NotImplementedException(); } + /// + /// Does a point wise multiplication of two arrays z = x * y. This can be used + /// to multiple elements of vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the point wise multiplication. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void PointWiseMultiplyArrays(Complex[] x, Complex[] y, Complex[] result) { throw new NotImplementedException(); } + /// + /// Computes the requested of the matrix. + /// + /// The type of norm to compute. + /// The matrix to compute the norm from. + /// + /// The requested of the matrix. + /// public Complex MatrixNorm(Norm norm, Complex[] matrix) { throw new NotImplementedException(); } + /// + /// Computes the requested of the matrix. + /// + /// The type of norm to compute. + /// The matrix to compute the norm from. + /// The work array. Only used when + /// and needs to be have a length of at least M (number of rows of . + /// + /// The requested of the matrix. + /// public Complex MatrixNorm(Norm norm, Complex[] matrix, Complex[] work) { throw new NotImplementedException(); @@ -577,111 +1182,307 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.<#=library#> throw new NotImplementedException(); } + /// + /// Computes the LU factorization of A. + /// + /// An m by n matrix. The matrix is overwritten with the + /// the LU factorization On exit. + /// On exit, it contains the pivot indices. The size + /// of the array must be min(m,n). + /// This is equivalent to the GETRF LAPACK routine. public void LUFactor(Complex[] a, int[] ipiv) { throw new NotImplementedException(); } + /// + /// Computes the inverse of matrix using LU factorization. + /// + /// The N by N matrix to invert. Contains the inverse On exit. + /// This is equivalent to the GETRF and GETRI LAPACK routines. public void LUInverse(Complex[] a) { throw new NotImplementedException(); } + /// + /// Computes the inverse of a previously factored matrix. + /// + /// The LU factored N by N matrix. Contains the inverse On exit. + /// The pivot indices of . + /// This is equivalent to the GETRI LAPACK routine. public void LUInverseFactored(Complex[] a, int[] ipiv) { throw new NotImplementedException(); } + /// + /// Computes the inverse of matrix using LU factorization. + /// + /// The N by N matrix to invert. Contains the inverse On exit. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. + /// This is equivalent to the GETRF and GETRI LAPACK routines. public void LUInverse(Complex[] a, Complex[] work) { throw new NotImplementedException(); } + /// + /// Computes the inverse of a previously factored matrix. + /// + /// The LU factored N by N matrix. Contains the inverse On exit. + /// The pivot indices of . + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. + /// This is equivalent to the GETRI LAPACK routine. public void LUInverseFactored(Complex[] a, int[] ipiv, Complex[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using LU factorization. + /// + /// The number of columns of B. + /// The square matrix A. + /// The B matrix. + /// This is equivalent to the GETRF and GETRS LAPACK routines. public void LUSolve(int columnsOfB, Complex[] a, Complex[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// The number of columns of B. + /// The factored A matrix. + /// The pivot indices of . + /// The B matrix. + /// This is equivalent to the GETRS LAPACK routine. public void LUSolveFactored(int columnsOfB, Complex[] a, int ipiv, Complex[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using LU factorization. + /// + /// How to transpose the matrix. + /// The number of columns of B. + /// The square matrix A. + /// The B matrix. + /// This is equivalent to the GETRF and GETRS LAPACK routines. public void LUSolve(Transpose transposeA, int columnsOfB, Complex[] a, Complex[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// How to transpose the matrix. + /// The number of columns of B. + /// The factored A matrix. + /// The pivot indices of . + /// The B matrix. + /// This is equivalent to the GETRS LAPACK routine. public void LUSolveFactored(Transpose transposeA, int columnsOfB, Complex[] a, int ipiv, Complex[] b) { throw new NotImplementedException(); } + /// + /// Computes the Cholesky factorization of A. + /// + /// On entry, a square, positive definite matrix. On exit, the matrix is overwritten with the + /// the Cholesky factorization. + /// This is equivalent to the POTRF LAPACK routine. public void CholeskyFactor(Complex[] a) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using Cholesky factorization. + /// + /// The number of columns of B. + /// The square, positive definite matrix A. + /// The B matrix. + /// This is equivalent to the POTRF add POTRS LAPACK routines. public void CholeskySolve(int columnsOfB, Complex[] a, Complex[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// The number of columns of B. + /// The factored A matrix. + /// The B matrix. + /// This is equivalent to the POTRS LAPACK routine. public void CholeskySolveFactored(int columnsOfB, Complex[] a, Complex[] b) { throw new NotImplementedException(); } + /// + /// Computes the QR factorization of A. + /// + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// This is similar to the GEQRF and ORGQR LAPACK routines. public void QRFactor(Complex[] r, Complex[] q) { throw new NotImplementedException(); } + /// + /// Computes the QR factorization of A. + /// + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. public void QRFactor(Complex[] r, Complex[] q, Complex[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using QR factorization of A. + /// + /// The number of columns of B. + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The B matrix. + /// On exit, the solution matrix. public void QRSolve(int columnsOfB, Complex[] r, Complex[] q, Complex[] b, Complex[] x) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using QR factorization of A. + /// + /// The number of columns of B. + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The B matrix. + /// On exit, the solution matrix. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. public void QRSolve(int columnsOfB, Complex[] r, Complex[] q, Complex[] b, Complex[] x, Complex[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously QR factored matrix. + /// + /// The number of columns of B. + /// The Q matrix obtained by calling . + /// The R matrix obtained by calling . + /// The B matrix. + /// On exit, the solution matrix. public void QRSolveFactored(int columnsOfB, Complex[] q, Complex[] r, Complex[] b, Complex[] x) { throw new NotImplementedException(); } + /// + /// Computes the singular value decomposition of A. + /// + /// Compute the singular U and VT vectors or not. + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// If is true, on exit U contains the left + /// singular vectors. + /// If is true, on exit VT contains the transposed + /// right singular vectors. + /// This is equivalent to the GESVD LAPACK routine. public void SinguarValueDecomposition(bool computeVectors, Complex[] a, Complex[] s, Complex[] u, Complex[] vt) { throw new NotImplementedException(); } + /// + /// Computes the singular value decomposition of A. + /// + /// Compute the singular U and VT vectors or not. + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// If is true, on exit U contains the left + /// singular vectors. + /// If is true, on exit VT contains the transposed + /// right singular vectors. + /// 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. + /// This is equivalent to the GESVD LAPACK routine. public void SingularValueDecomposition(bool computeVectors, Complex[] a, Complex[] s, Complex[] u, Complex[] vt, Complex[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using the singular value decomposition of A. + /// + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// On exit U contains the left singular vectors. + /// On exit VT contains the transposed right singular vectors. + /// The B matrix. + /// On exit, the solution matrix. public void SvdSolve(Complex[] a, Complex[] s, Complex[] u, Complex[] vt, Complex[] b, Complex[] x) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using the singular value decomposition of A. + /// + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// On exit U contains the left singular vectors. + /// On exit VT contains the transposed right singular vectors. + /// The B matrix. + /// On exit, the solution matrix. + /// 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. public void SvdSolve(Complex[] a, Complex[] s, Complex[] u, Complex[] vt, Complex[] b, Complex[] x, Complex[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously SVD decomposed matrix. + /// + /// The number of columns of B. + /// The s values returned by . + /// The left singular vectors returned by . + /// The right singular vectors returned by . + /// The B matrix. + /// On exit, the solution matrix. public void SvdSolveFactored(int columnsOfB, Complex[] s, Complex[] u, Complex[] vt, Complex[] b, Complex[] x) { throw new NotImplementedException(); @@ -691,6 +1492,13 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.<#=library#> #region ILinearAlgebraProvider Members + /// + /// Adds a scaled vector to another: y += alpha*x. + /// + /// The vector to update. + /// The value to scale by. + /// The vector to add to . + /// This equivalent to the AXPY BLAS routine. public void AddVectorToScaledVector(Complex32[] y, Complex32 alpha, Complex32[] x) { if (y == null) @@ -716,36 +1524,102 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.<#=library#> SafeNativeMethods.c_axpy(y.Length, ref alpha, x, y); } + /// + /// Scales an array. Can be used to scale a vector and a matrix. + /// + /// The scalar. + /// The values to scale. + /// This is equivalent to the SCAL BLAS routine. public void ScaleArray(Complex32 alpha, Complex32[] x) { - throw new NotImplementedException(); + if (alpha.IsOne) + { + return; + } + + SafeNativeMethods.c_scale(x.Length, ref alpha, x); } + /// + /// Computes the dot product of x and y. + /// + /// The vector x. + /// The vector y. + /// The dot product of x and y. + /// This is equivalent to the DOT BLAS routine. public Complex32 DotProduct(Complex32[] x, Complex32[] y) { throw new NotImplementedException(); } + /// + /// Does a point wise add of two arrays z = x + y. This can be used + /// to add vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the addition. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void AddArrays(Complex32[] x, Complex32[] y, Complex32[] result) { throw new NotImplementedException(); } + /// + /// Does a point wise subtraction of two arrays z = x - y. This can be used + /// to subtract vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the subtraction. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void SubtractArrays(Complex32[] x, Complex32[] y, Complex32[] result) { throw new NotImplementedException(); } + /// + /// Does a point wise multiplication of two arrays z = x * y. This can be used + /// to multiple elements of vectors or matrices. + /// + /// The array x. + /// The array y. + /// The result of the point wise multiplication. + /// There is no equivalent BLAS routine, but many libraries + /// provide optimized (parallel and/or vectorized) versions of this + /// routine. public void PointWiseMultiplyArrays(Complex32[] x, Complex32[] y, Complex32[] result) { throw new NotImplementedException(); } + /// + /// Computes the requested of the matrix. + /// + /// The type of norm to compute. + /// The matrix to compute the norm from. + /// + /// The requested of the matrix. + /// public Complex32 MatrixNorm(Norm norm, Complex32[] matrix) { throw new NotImplementedException(); } + /// + /// Computes the requested of the matrix. + /// + /// The type of norm to compute. + /// The matrix to compute the norm from. + /// The work array. Only used when + /// and needs to be have a length of at least M (number of rows of . + /// + /// The requested of the matrix. + /// public Complex32 MatrixNorm(Norm norm, Complex32[] matrix, Complex32[] work) { throw new NotImplementedException(); @@ -788,111 +1662,307 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.<#=library#> throw new NotImplementedException(); } + /// + /// Computes the LU factorization of A. + /// + /// An m by n matrix. The matrix is overwritten with the + /// the LU factorization On exit. + /// On exit, it contains the pivot indices. The size + /// of the array must be min(m,n). + /// This is equivalent to the GETRF LAPACK routine. public void LUFactor(Complex32[] a, int[] ipiv) { throw new NotImplementedException(); } + /// + /// Computes the inverse of matrix using LU factorization. + /// + /// The N by N matrix to invert. Contains the inverse On exit. + /// This is equivalent to the GETRF and GETRI LAPACK routines. public void LUInverse(Complex32[] a) { throw new NotImplementedException(); } + /// + /// Computes the inverse of a previously factored matrix. + /// + /// The LU factored N by N matrix. Contains the inverse On exit. + /// The pivot indices of . + /// This is equivalent to the GETRI LAPACK routine. public void LUInverseFactored(Complex32[] a, int[] ipiv) { throw new NotImplementedException(); } + /// + /// Computes the inverse of matrix using LU factorization. + /// + /// The N by N matrix to invert. Contains the inverse On exit. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. + /// This is equivalent to the GETRF and GETRI LAPACK routines. public void LUInverse(Complex32[] a, Complex32[] work) { throw new NotImplementedException(); } + /// + /// Computes the inverse of a previously factored matrix. + /// + /// The LU factored N by N matrix. Contains the inverse On exit. + /// The pivot indices of . + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. + /// This is equivalent to the GETRI LAPACK routine. public void LUInverseFactored(Complex32[] a, int[] ipiv, Complex32[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using LU factorization. + /// + /// The number of columns of B. + /// The square matrix A. + /// The B matrix. + /// This is equivalent to the GETRF and GETRS LAPACK routines. public void LUSolve(int columnsOfB, Complex32[] a, Complex32[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// The number of columns of B. + /// The factored A matrix. + /// The pivot indices of . + /// The B matrix. + /// This is equivalent to the GETRS LAPACK routine. public void LUSolveFactored(int columnsOfB, Complex32[] a, int ipiv, Complex32[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using LU factorization. + /// + /// How to transpose the matrix. + /// The number of columns of B. + /// The square matrix A. + /// The B matrix. + /// This is equivalent to the GETRF and GETRS LAPACK routines. public void LUSolve(Transpose transposeA, int columnsOfB, Complex32[] a, Complex32[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// How to transpose the matrix. + /// The number of columns of B. + /// The factored A matrix. + /// The pivot indices of . + /// The B matrix. + /// This is equivalent to the GETRS LAPACK routine. public void LUSolveFactored(Transpose transposeA, int columnsOfB, Complex32[] a, int ipiv, Complex32[] b) { throw new NotImplementedException(); } + /// + /// Computes the Cholesky factorization of A. + /// + /// On entry, a square, positive definite matrix. On exit, the matrix is overwritten with the + /// the Cholesky factorization. + /// This is equivalent to the POTRF LAPACK routine. public void CholeskyFactor(Complex32[] a) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using Cholesky factorization. + /// + /// The number of columns of B. + /// The square, positive definite matrix A. + /// The B matrix. + /// This is equivalent to the POTRF add POTRS LAPACK routines. public void CholeskySolve(int columnsOfB, Complex32[] a, Complex32[] b) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously factored A matrix. + /// + /// The number of columns of B. + /// The factored A matrix. + /// The B matrix. + /// This is equivalent to the POTRS LAPACK routine. public void CholeskySolveFactored(int columnsOfB, Complex32[] a, Complex32[] b) { throw new NotImplementedException(); } + /// + /// Computes the QR factorization of A. + /// + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// This is similar to the GEQRF and ORGQR LAPACK routines. public void QRFactor(Complex32[] r, Complex32[] q) { throw new NotImplementedException(); } + /// + /// Computes the QR factorization of A. + /// + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. public void QRFactor(Complex32[] r, Complex32[] q, Complex32[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using QR factorization of A. + /// + /// The number of columns of B. + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The B matrix. + /// On exit, the solution matrix. public void QRSolve(int columnsOfB, Complex32[] r, Complex32[] q, Complex32[] b, Complex32[] x) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using QR factorization of A. + /// + /// The number of columns of B. + /// 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. + /// On exit, A M by M matrix that holds the Q matrix of the + /// QR factorization. + /// The B matrix. + /// On exit, the solution matrix. + /// The work array. The array must have a length of at least N, + /// but should be N*blocksize. The blocksize is machine dependent. Use + /// to determine the optimal size of the work array. On exit, work[0] contains the optimal + /// work size value. public void QRSolve(int columnsOfB, Complex32[] r, Complex32[] q, Complex32[] b, Complex32[] x, Complex32[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously QR factored matrix. + /// + /// The number of columns of B. + /// The Q matrix obtained by calling . + /// The R matrix obtained by calling . + /// The B matrix. + /// On exit, the solution matrix. public void QRSolveFactored(int columnsOfB, Complex32[] q, Complex32[] r, Complex32[] b, Complex32[] x) { throw new NotImplementedException(); } + /// + /// Computes the singular value decomposition of A. + /// + /// Compute the singular U and VT vectors or not. + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// If is true, on exit U contains the left + /// singular vectors. + /// If is true, on exit VT contains the transposed + /// right singular vectors. + /// This is equivalent to the GESVD LAPACK routine. public void SinguarValueDecomposition(bool computeVectors, Complex32[] a, Complex32[] s, Complex32[] u, Complex32[] vt) { throw new NotImplementedException(); } + /// + /// Computes the singular value decomposition of A. + /// + /// Compute the singular U and VT vectors or not. + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// If is true, on exit U contains the left + /// singular vectors. + /// If is true, on exit VT contains the transposed + /// right singular vectors. + /// 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. + /// This is equivalent to the GESVD LAPACK routine. public void SingularValueDecomposition(bool computeVectors, Complex32[] a, Complex32[] s, Complex32[] u, Complex32[] vt, Complex32[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using the singular value decomposition of A. + /// + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// On exit U contains the left singular vectors. + /// On exit VT contains the transposed right singular vectors. + /// The B matrix. + /// On exit, the solution matrix. public void SvdSolve(Complex32[] a, Complex32[] s, Complex32[] u, Complex32[] vt, Complex32[] b, Complex32[] x) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using the singular value decomposition of A. + /// + /// On entry, the M by N matrix to decompose. On exit, A may be overwritten. + /// The singular values of A in ascending value. + /// On exit U contains the left singular vectors. + /// On exit VT contains the transposed right singular vectors. + /// The B matrix. + /// On exit, the solution matrix. + /// 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. public void SvdSolve(Complex32[] a, Complex32[] s, Complex32[] u, Complex32[] vt, Complex32[] b, Complex32[] x, Complex32[] work) { throw new NotImplementedException(); } + /// + /// Solves A*X=B for X using a previously SVD decomposed matrix. + /// + /// The number of columns of B. + /// The s values returned by . + /// The left singular vectors returned by . + /// The right singular vectors returned by . + /// The B matrix. + /// On exit, the solution matrix. public void SvdSolveFactored(int columnsOfB, Complex32[] s, Complex32[] u, Complex32[] vt, Complex32[] b, Complex32[] x) { throw new NotImplementedException(); diff --git a/src/Numerics/Algorithms/LinearAlgebra/SafeNativeMethods.include b/src/Numerics/Algorithms/LinearAlgebra/SafeNativeMethods.include index a0db37df..61dfc9d5 100644 --- a/src/Numerics/Algorithms/LinearAlgebra/SafeNativeMethods.include +++ b/src/Numerics/Algorithms/LinearAlgebra/SafeNativeMethods.include @@ -1,4 +1,4 @@ -// +// // Math.NET Numerics, part of the Math.NET Project // http://mathnet.opensourcedotnet.info // @@ -36,9 +36,15 @@ using System.Security; namespace MathNet.Numerics.Algorithms.LinearAlgebra.<#= namespaceSuffix #> { + /// + /// P/Invoke methods to the native math libraries. + /// [SuppressUnmanagedCodeSecurity] internal static class SafeNativeMethods { + /// + /// Name of the native DLL. + /// private const string DllName = "MathNET.Numerics.<#=library#>.dll"; #region BLAS @@ -55,6 +61,18 @@ namespace MathNet.Numerics.Algorithms.LinearAlgebra.<#= namespaceSuffix #> [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] internal static extern void z_axpy(int n, ref Complex alpha, Complex[] x, [In, Out] Complex[] y); + [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] + internal static extern void s_scale(int n, float alpha, [Out] float[] x); + + [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] + internal static extern void d_scale(int n, double alpha, [Out] double[] x); + + [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] + internal static extern void c_scale(int n, ref Complex32 alpha, [In, Out] Complex32[] x); + + [DllImport(DllName, ExactSpelling = true, SetLastError = false, CallingConvention = CallingConvention.Cdecl)] + internal static extern void z_scale(int n, ref Complex alpha, [In, Out] Complex[] x); + #endregion BLAS - } + } }