Namespaces

Types in MathNet.Numerics.Providers.LinearAlgebra.Mkl

Type MklLinearAlgebraProvider

Namespace MathNet.Numerics.Providers.LinearAlgebra.Mkl

Parent ManagedLinearAlgebraProvider

Intel's Math Kernel Library (MKL) linear algebra provider.

Constructors

Methods

Public Constructors

MklLinearAlgebraProvider()

MklLinearAlgebraProvider(MklConsistency consistency, MklPrecision precision, MklAccuracy accuracy)

Parameters
MklConsistency consistency

Sets the desired bit consistency on repeated identical computations on varying CPU architectures, as a trade-off with performance.

MklPrecision precision

VML optimal precision and rounding.

MklAccuracy accuracy

VML accuracy mode.

MklLinearAlgebraProvider(MklConsistency consistency, MklPrecision precision, MklAccuracy accuracy)

Obsolete: Will be removed in the next major version. Use the enums in the Common namespace instead.
Parameters
MklConsistency consistency

Sets the desired bit consistency on repeated identical computations on varying CPU architectures, as a trade-off with performance.

MklPrecision precision

VML optimal precision and rounding.

MklAccuracy accuracy

VML accuracy mode.

Public Methods

void AddArrays(Complex32[] x, Complex32[] y, Complex32[] result)

Does a point wise add of two arrays z = x + y. This can be used to add vectors or matrices.
There is no equivalent BLAS routine, but many libraries provide optimized (parallel and/or vectorized) versions of this routine.
Parameters
Complex32[] x

The array x.

Complex32[] y

The array y.

Complex32[] result

The result of the addition.

void AddArrays(Single[] x, Single[] y, Single[] result)

Does a point wise add of two arrays z = x + y. This can be used to add vectors or matrices.
There is no equivalent BLAS routine, but many libraries provide optimized (parallel and/or vectorized) versions of this routine.
Parameters
Single[] x

The array x.

Single[] y

The array y.

Single[] result

The result of the addition.

void AddArrays(Complex[] x, Complex[] y, Complex[] result)

Does a point wise add of two arrays z = x + y. This can be used to add vectors or matrices.
There is no equivalent BLAS routine, but many libraries provide optimized (parallel and/or vectorized) versions of this routine.
Parameters
Complex[] x

The array x.

Complex[] y

The array y.

Complex[] result

The result of the addition.

void AddArrays(Double[] x, Double[] y, Double[] result)

Does a point wise add of two arrays z = x + y. This can be used to add vectors or matrices.
There is no equivalent BLAS routine, but many libraries provide optimized (parallel and/or vectorized) versions of this routine.
Parameters
Double[] x

The array x.

Double[] y

The array y.

Double[] result

The result of the addition.

void AddVectorToScaledVector(Double[] y, double alpha, Double[] x, Double[] result)

Adds a scaled vector to another: result = y + alpha*x.
This is similar to the AXPY BLAS routine.
Parameters
Double[] y

The vector to update.

double alpha

The value to scale x by.

Double[] x

The vector to add to y.

Double[] result

The result of the addition.

void AddVectorToScaledVector(Single[] y, float alpha, Single[] x, Single[] result)

Adds a scaled vector to another: result = y + alpha*x.
This is similar to the AXPY BLAS routine.
Parameters
Single[] y

The vector to update.

float alpha

The value to scale x by.

Single[] x

The vector to add to y.

Single[] result

The result of the addition.

void AddVectorToScaledVector(Complex[] y, Complex alpha, Complex[] x, Complex[] result)

Adds a scaled vector to another: result = y + alpha*x.
This is similar to the AXPY BLAS routine.
Parameters
Complex[] y

The vector to update.

Complex alpha

The value to scale x by.

Complex[] x

The vector to add to y.

Complex[] result

The result of the addition.

void AddVectorToScaledVector(Complex32[] y, Complex32 alpha, Complex32[] x, Complex32[] result)

Adds a scaled vector to another: result = y + alpha*x.
This is similar to the AXPY BLAS routine.
Parameters
Complex32[] y

The vector to update.

Complex32 alpha

The value to scale x by.

Complex32[] x

The vector to add to y.

Complex32[] result

The result of the addition.

void CholeskyFactor(Double[] a, int order)

Computes the Cholesky factorization of A.
This is equivalent to the POTRF LAPACK routine.
Parameters
Double[] a

On entry, a square, positive definite matrix. On exit, the matrix is overwritten with the the Cholesky factorization.

int order

The number of rows or columns in the matrix.

void CholeskyFactor(Complex[] a, int order)

Computes the Cholesky factorization of A.
This is equivalent to the POTRF LAPACK routine.
Parameters
Complex[] a

On entry, a square, positive definite matrix. On exit, the matrix is overwritten with the the Cholesky factorization.

int order

The number of rows or columns in the matrix.

void CholeskyFactor(Single[] a, int order)

Computes the Cholesky factorization of A.
This is equivalent to the POTRF LAPACK routine.
Parameters
Single[] a

On entry, a square, positive definite matrix. On exit, the matrix is overwritten with the the Cholesky factorization.

int order

The number of rows or columns in the matrix.

void CholeskyFactor(Complex32[] a, int order)

Computes the Cholesky factorization of A.
This is equivalent to the POTRF LAPACK routine.
Parameters
Complex32[] a

On entry, a square, positive definite matrix. On exit, the matrix is overwritten with the the Cholesky factorization.

int order

The number of rows or columns in the matrix.

void CholeskySolve(Complex32[] a, int orderA, Complex32[] b, int columnsB)

Solves A*X=B for X using Cholesky factorization.
This is equivalent to the POTRF add POTRS LAPACK routines.
Parameters
Complex32[] a

The square, positive definite matrix A.

int orderA

The number of rows and columns in A.

Complex32[] b

On entry the B matrix; on exit the X matrix.

int columnsB

The number of columns in the B matrix.

void CholeskySolve(Double[] a, int orderA, Double[] b, int columnsB)

Solves A*X=B for X using Cholesky factorization.
This is equivalent to the POTRF add POTRS LAPACK routines.
Parameters
Double[] a

The square, positive definite matrix A.

int orderA

The number of rows and columns in A.

Double[] b

On entry the B matrix; on exit the X matrix.

int columnsB

The number of columns in the B matrix.

void CholeskySolve(Complex[] a, int orderA, Complex[] b, int columnsB)

Solves A*X=B for X using Cholesky factorization.
This is equivalent to the POTRF add POTRS LAPACK routines.
Parameters
Complex[] a

The square, positive definite matrix A.

int orderA

The number of rows and columns in A.

Complex[] b

On entry the B matrix; on exit the X matrix.

int columnsB

The number of columns in the B matrix.

void CholeskySolve(Single[] a, int orderA, Single[] b, int columnsB)

Solves A*X=B for X using Cholesky factorization.
This is equivalent to the POTRF add POTRS LAPACK routines.
Parameters
Single[] a

The square, positive definite matrix A.

int orderA

The number of rows and columns in A.

Single[] b

On entry the B matrix; on exit the X matrix.

int columnsB

The number of columns in the B matrix.

void CholeskySolveFactored(Complex32[] a, int orderA, Complex32[] b, int columnsB)

Solves A*X=B for X using a previously factored A matrix.
This is equivalent to the POTRS LAPACK routine.
Parameters
Complex32[] a

The square, positive definite matrix A.

int orderA

The number of rows and columns in A.

Complex32[] b

On entry the B matrix; on exit the X matrix.

int columnsB

The number of columns in the B matrix.

void CholeskySolveFactored(Double[] a, int orderA, Double[] b, int columnsB)

Solves A*X=B for X using a previously factored A matrix.
This is equivalent to the POTRS LAPACK routine.
Parameters
Double[] a

The square, positive definite matrix A.

int orderA

The number of rows and columns in A.

Double[] b

On entry the B matrix; on exit the X matrix.

int columnsB

The number of columns in the B matrix.

void CholeskySolveFactored(Single[] a, int orderA, Single[] b, int columnsB)

Solves A*X=B for X using a previously factored A matrix.
This is equivalent to the POTRS LAPACK routine.
Parameters
Single[] a

The square, positive definite matrix A.

int orderA

The number of rows and columns in A.

Single[] b

On entry the B matrix; on exit the X matrix.

int columnsB

The number of columns in the B matrix.

void CholeskySolveFactored(Complex[] a, int orderA, Complex[] b, int columnsB)

Solves A*X=B for X using a previously factored A matrix.
This is equivalent to the POTRS LAPACK routine.
Parameters
Complex[] a

The square, positive definite matrix A.

int orderA

The number of rows and columns in A.

Complex[] b

On entry the B matrix; on exit the X matrix.

int columnsB

The number of columns in the B matrix.

void ConjugateArray(Double[] x, Double[] result)

Conjugates an array. Can be used to conjugate a vector and a matrix.
Parameters
Double[] x

The values to conjugate.

Double[] result

This result of the conjugation.

void ConjugateArray(Complex[] x, Complex[] result)

Conjugates an array. Can be used to conjugate a vector and a matrix.
Parameters
Complex[] x

The values to conjugate.

Complex[] result

This result of the conjugation.

void ConjugateArray(Single[] x, Single[] result)

Conjugates an array. Can be used to conjugate a vector and a matrix.
Parameters
Single[] x

The values to conjugate.

Single[] result

This result of the conjugation.

void ConjugateArray(Complex32[] x, Complex32[] result)

Conjugates an array. Can be used to conjugate a vector and a matrix.
Parameters
Complex32[] x

The values to conjugate.

Complex32[] result

This result of the conjugation.

void DisableMemoryPool()

Disable the MKL memory pool. May impact performance.

void DisablePeakMemoryStatistics()

Disable gathering of peak memory statistics of the MKL memory pool.

Complex DotProduct(Complex[] x, Complex[] y)

Computes the dot product of x and y.
This is equivalent to the DOT BLAS routine.
Parameters
Complex[] x

The vector x.

Complex[] y

The vector y.

Return
Complex

The dot product of x and y.

double DotProduct(Double[] x, Double[] y)

Computes the dot product of x and y.
This is equivalent to the DOT BLAS routine.
Parameters
Double[] x

The vector x.

Double[] y

The vector y.

Return
double

The dot product of x and y.

Complex32 DotProduct(Complex32[] x, Complex32[] y)

Computes the dot product of x and y.
This is equivalent to the DOT BLAS routine.
Parameters
Complex32[] x

The vector x.

Complex32[] y

The vector y.

Return
Complex32

The dot product of x and y.

float DotProduct(Single[] x, Single[] y)

Computes the dot product of x and y.
This is equivalent to the DOT BLAS routine.
Parameters
Single[] x

The vector x.

Single[] y

The vector y.

Return
float

The dot product of x and y.

void EigenDecomp(bool isSymmetric, int order, Single[] matrix, Single[] matrixEv, Complex[] vectorEv, Single[] matrixD)

Computes the eigenvalues and eigenvectors of a matrix.
Parameters
bool isSymmetric

Whether the matrix is symmetric or not.

int order

The order of the matrix.

Single[] matrix

The matrix to decompose. The lenth of the array must be order * order.

Single[] matrixEv

On output, the matrix contains the eigen vectors. The lenth of the array must be order * order.

Complex[] vectorEv

On output, the eigen values (λ) of matrix in ascending value. The length of the arry must order.

Single[] matrixD

On output, the block diagonal eigenvalue matrix. The lenth of the array must be order * order.

void EigenDecomp(bool isSymmetric, int order, Complex32[] matrix, Complex32[] matrixEv, Complex[] vectorEv, Complex32[] matrixD)

Computes the eigenvalues and eigenvectors of a matrix.
Parameters
bool isSymmetric

Whether the matrix is symmetric or not.

int order

The order of the matrix.

Complex32[] matrix

The matrix to decompose. The lenth of the array must be order * order.

Complex32[] matrixEv

On output, the matrix contains the eigen vectors. The lenth of the array must be order * order.

Complex[] vectorEv

On output, the eigen values (λ) of matrix in ascending value. The length of the arry must order.

Complex32[] matrixD

On output, the block diagonal eigenvalue matrix. The lenth of the array must be order * order.

void EigenDecomp(bool isSymmetric, int order, Complex[] matrix, Complex[] matrixEv, Complex[] vectorEv, Complex[] matrixD)

Computes the eigenvalues and eigenvectors of a matrix.
Parameters
bool isSymmetric

Whether the matrix is symmetric or not.

int order

The order of the matrix.

Complex[] matrix

The matrix to decompose. The lenth of the array must be order * order.

Complex[] matrixEv

On output, the matrix contains the eigen vectors. The lenth of the array must be order * order.

Complex[] vectorEv

On output, the eigen values (λ) of matrix in ascending value. The length of the arry must order.

Complex[] matrixD

On output, the block diagonal eigenvalue matrix. The lenth of the array must be order * order.

void EigenDecomp(bool isSymmetric, int order, Double[] matrix, Double[] matrixEv, Complex[] vectorEv, Double[] matrixD)

Computes the eigenvalues and eigenvectors of a matrix.
Parameters
bool isSymmetric

Whether the matrix is symmetric or not.

int order

The order of the matrix.

Double[] matrix

The matrix to decompose. The lenth of the array must be order * order.

Double[] matrixEv

On output, the matrix contains the eigen vectors. The lenth of the array must be order * order.

Complex[] vectorEv

On output, the eigen values (λ) of matrix in ascending value. The length of the arry must order.

Double[] matrixD

On output, the block diagonal eigenvalue matrix. The lenth of the array must be order * order.

void EnablePeakMemoryStatistics()

Enable gathering of peak memory statistics of the MKL memory pool.

bool Equals(object obj)

void FreeBuffers()

Frees the memory allocated to the MKL memory pool.

int GetHashCode()

Type GetType()

void InitializeVerify()

Initialize and verify that the provided is indeed available. If calling this method fails, consider to fall back to alternatives like the managed provider.

bool IsAvailable()

Try to find out whether the provider is available, at least in principle. Verification may still fail if available, but it will certainly fail if unavailable.

void LUFactor(Complex32[] data, int order, Int32[] ipiv)

Computes the LUP factorization of A. P*A = L*U.
This is equivalent to the GETRF LAPACK routine.
Parameters
Complex32[] data

An order by order matrix. The matrix is overwritten with the the LU factorization on exit. The lower triangular factor L is stored in under the diagonal of data (the diagonal is always Complex32.One for the L factor). The upper triangular factor U is stored on and above the diagonal of data.

int order

The order of the square matrix data.

Int32[] ipiv

On exit, it contains the pivot indices. The size of the array must be order.

void LUFactor(Double[] data, int order, Int32[] ipiv)

Computes the LUP factorization of A. P*A = L*U.
This is equivalent to the GETRF LAPACK routine.
Parameters
Double[] data

An order by order matrix. The matrix is overwritten with the the LU factorization on exit. The lower triangular factor L is stored in under the diagonal of data (the diagonal is always 1.0 for the L factor). The upper triangular factor U is stored on and above the diagonal of data.

int order

The order of the square matrix data.

Int32[] ipiv

On exit, it contains the pivot indices. The size of the array must be order.

void LUFactor(Complex[] data, int order, Int32[] ipiv)

Computes the LUP factorization of A. P*A = L*U.
This is equivalent to the GETRF LAPACK routine.
Parameters
Complex[] data

An order by order matrix. The matrix is overwritten with the the LU factorization on exit. The lower triangular factor L is stored in under the diagonal of data (the diagonal is always Complex.One for the L factor). The upper triangular factor U is stored on and above the diagonal of data.

int order

The order of the square matrix data.

Int32[] ipiv

On exit, it contains the pivot indices. The size of the array must be order.

void LUFactor(Single[] data, int order, Int32[] ipiv)

Computes the LUP factorization of A. P*A = L*U.
This is equivalent to the GETRF LAPACK routine.
Parameters
Single[] data

An order by order matrix. The matrix is overwritten with the the LU factorization on exit. The lower triangular factor L is stored in under the diagonal of data (the diagonal is always 1.0f for the L factor). The upper triangular factor U is stored on and above the diagonal of data.

int order

The order of the square matrix data.

Int32[] ipiv

On exit, it contains the pivot indices. The size of the array must be order.

void LUInverse(Double[] a, int order)

Computes the inverse of matrix using LU factorization.
This is equivalent to the GETRF and GETRI LAPACK routines.
Parameters
Double[] a

The N by N matrix to invert. Contains the inverse On exit.

int order

The order of the square matrix a.

void LUInverse(Complex[] a, int order)

Computes the inverse of matrix using LU factorization.
This is equivalent to the GETRF and GETRI LAPACK routines.
Parameters
Complex[] a

The N by N matrix to invert. Contains the inverse On exit.

int order

The order of the square matrix a.

void LUInverse(Single[] a, int order)

Computes the inverse of matrix using LU factorization.
This is equivalent to the GETRF and GETRI LAPACK routines.
Parameters
Single[] a

The N by N matrix to invert. Contains the inverse On exit.

int order

The order of the square matrix a.

void LUInverse(Complex32[] a, int order)

Computes the inverse of matrix using LU factorization.
This is equivalent to the GETRF and GETRI LAPACK routines.
Parameters
Complex32[] a

The N by N matrix to invert. Contains the inverse On exit.

int order

The order of the square matrix a.

void LUInverseFactored(Double[] a, int order, Int32[] ipiv)

Computes the inverse of a previously factored matrix.
This is equivalent to the GETRI LAPACK routine.
Parameters
Double[] a

The LU factored N by N matrix. Contains the inverse On exit.

int order

The order of the square matrix a.

Int32[] ipiv

The pivot indices of a.

void LUInverseFactored(Single[] a, int order, Int32[] ipiv)

Computes the inverse of a previously factored matrix.
This is equivalent to the GETRI LAPACK routine.
Parameters
Single[] a

The LU factored N by N matrix. Contains the inverse On exit.

int order

The order of the square matrix a.

Int32[] ipiv

The pivot indices of a.

void LUInverseFactored(Complex32[] a, int order, Int32[] ipiv)

Computes the inverse of a previously factored matrix.
This is equivalent to the GETRI LAPACK routine.
Parameters
Complex32[] a

The LU factored N by N matrix. Contains the inverse On exit.

int order

The order of the square matrix a.

Int32[] ipiv

The pivot indices of a.

void LUInverseFactored(Complex[] a, int order, Int32[] ipiv)

Computes the inverse of a previously factored matrix.
This is equivalent to the GETRI LAPACK routine.
Parameters
Complex[] a

The LU factored N by N matrix. Contains the inverse On exit.

int order

The order of the square matrix a.

Int32[] ipiv

The pivot indices of a.

void LUSolve(int columnsOfB, Double[] a, int order, Double[] b)

Solves A*X=B for X using LU factorization.
This is equivalent to the GETRF and GETRS LAPACK routines.
Parameters
int columnsOfB

The number of columns of B.

Double[] a

The square matrix A.

int order

The order of the square matrix a.

Double[] b

On entry the B matrix; on exit the X matrix.

void LUSolve(int columnsOfB, Complex32[] a, int order, Complex32[] b)

Solves A*X=B for X using LU factorization.
This is equivalent to the GETRF and GETRS LAPACK routines.
Parameters
int columnsOfB

The number of columns of B.

Complex32[] a

The square matrix A.

int order

The order of the square matrix a.

Complex32[] b

On entry the B matrix; on exit the X matrix.

void LUSolve(int columnsOfB, Single[] a, int order, Single[] b)

Solves A*X=B for X using LU factorization.
This is equivalent to the GETRF and GETRS LAPACK routines.
Parameters
int columnsOfB

The number of columns of B.

Single[] a

The square matrix A.

int order

The order of the square matrix a.

Single[] b

On entry the B matrix; on exit the X matrix.

void LUSolve(int columnsOfB, Complex[] a, int order, Complex[] b)

Solves A*X=B for X using LU factorization.
This is equivalent to the GETRF and GETRS LAPACK routines.
Parameters
int columnsOfB

The number of columns of B.

Complex[] a

The square matrix A.

int order

The order of the square matrix a.

Complex[] b

On entry the B matrix; on exit the X matrix.

void LUSolveFactored(int columnsOfB, Complex32[] a, int order, Int32[] ipiv, Complex32[] b)

Solves A*X=B for X using a previously factored A matrix.
This is equivalent to the GETRS LAPACK routine.
Parameters
int columnsOfB

The number of columns of B.

Complex32[] a

The factored A matrix.

int order

The order of the square matrix a.

Int32[] ipiv

The pivot indices of a.

Complex32[] b

On entry the B matrix; on exit the X matrix.

void LUSolveFactored(int columnsOfB, Double[] a, int order, Int32[] ipiv, Double[] b)

Solves A*X=B for X using a previously factored A matrix.
This is equivalent to the GETRS LAPACK routine.
Parameters
int columnsOfB

The number of columns of B.

Double[] a

The factored A matrix.

int order

The order of the square matrix a.

Int32[] ipiv

The pivot indices of a.

Double[] b

On entry the B matrix; on exit the X matrix.

void LUSolveFactored(int columnsOfB, Single[] a, int order, Int32[] ipiv, Single[] b)

Solves A*X=B for X using a previously factored A matrix.
This is equivalent to the GETRS LAPACK routine.
Parameters
int columnsOfB

The number of columns of B.

Single[] a

The factored A matrix.

int order

The order of the square matrix a.

Int32[] ipiv

The pivot indices of a.

Single[] b

On entry the B matrix; on exit the X matrix.

void LUSolveFactored(int columnsOfB, Complex[] a, int order, Int32[] ipiv, Complex[] b)

Solves A*X=B for X using a previously factored A matrix.
This is equivalent to the GETRS LAPACK routine.
Parameters
int columnsOfB

The number of columns of B.

Complex[] a

The factored A matrix.

int order

The order of the square matrix a.

Int32[] ipiv

The pivot indices of a.

Complex[] b

On entry the B matrix; on exit the X matrix.

void MatrixMultiply(Single[] x, int rowsX, int columnsX, Single[] y, int rowsY, int columnsY, Single[] result)

Multiples two matrices. result = x * y
This is a simplified version of the BLAS GEMM routine with alpha set to 1.0f and beta set to 0.0f, and x and y are not transposed.
Parameters
Single[] x

The x matrix.

int rowsX

The number of rows in the x matrix.

int columnsX

The number of columns in the x matrix.

Single[] y

The y matrix.

int rowsY

The number of rows in the y matrix.

int columnsY

The number of columns in the y matrix.

Single[] result

Where to store the result of the multiplication.

void MatrixMultiply(Complex[] x, int rowsX, int columnsX, Complex[] y, int rowsY, int columnsY, Complex[] result)

Multiples two matrices. result = x * y
This is a simplified version of the BLAS GEMM routine with alpha set to Complex.One and beta set to Complex.Zero, and x and y are not transposed.
Parameters
Complex[] x

The x matrix.

int rowsX

The number of rows in the x matrix.

int columnsX

The number of columns in the x matrix.

Complex[] y

The y matrix.

int rowsY

The number of rows in the y matrix.

int columnsY

The number of columns in the y matrix.

Complex[] result

Where to store the result of the multiplication.

void MatrixMultiply(Complex32[] x, int rowsX, int columnsX, Complex32[] y, int rowsY, int columnsY, Complex32[] result)

Multiples two matrices. result = x * y
This is a simplified version of the BLAS GEMM routine with alpha set to Complex32.One and beta set to Complex32.Zero, and x and y are not transposed.
Parameters
Complex32[] x

The x matrix.

int rowsX

The number of rows in the x matrix.

int columnsX

The number of columns in the x matrix.

Complex32[] y

The y matrix.

int rowsY

The number of rows in the y matrix.

int columnsY

The number of columns in the y matrix.

Complex32[] result

Where to store the result of the multiplication.

void MatrixMultiply(Double[] x, int rowsX, int columnsX, Double[] y, int rowsY, int columnsY, Double[] result)

Multiples two matrices. result = x * y
This is a simplified version of the BLAS GEMM routine with alpha set to 1.0 and beta set to 0.0, and x and y are not transposed.
Parameters
Double[] x

The x matrix.

int rowsX

The number of rows in the x matrix.

int columnsX

The number of columns in the x matrix.

Double[] y

The y matrix.

int rowsY

The number of rows in the y matrix.

int columnsY

The number of columns in the y matrix.

Double[] result

Where to store the result of the multiplication.

void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, float alpha, Single[] a, int rowsA, int columnsA, Single[] b, int rowsB, int columnsB, float beta, Single[] c)

Multiplies two matrices and updates another with the result. c = alpha*op(a)*op(b) + beta*c
Parameters
Transpose transposeA

How to transpose the a matrix.

Transpose transposeB

How to transpose the b matrix.

float alpha

The value to scale a matrix.

Single[] a

The a matrix.

int rowsA

The number of rows in the a matrix.

int columnsA

The number of columns in the a matrix.

Single[] b

The b matrix

int rowsB

The number of rows in the b matrix.

int columnsB

The number of columns in the b matrix.

float beta

The value to scale the c matrix.

Single[] c

The c matrix.

void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, Complex32 alpha, Complex32[] a, int rowsA, int columnsA, Complex32[] b, int rowsB, int columnsB, Complex32 beta, Complex32[] c)

Multiplies two matrices and updates another with the result. c = alpha*op(a)*op(b) + beta*c
Parameters
Transpose transposeA

How to transpose the a matrix.

Transpose transposeB

How to transpose the b matrix.

Complex32 alpha

The value to scale a matrix.

Complex32[] a

The a matrix.

int rowsA

The number of rows in the a matrix.

int columnsA

The number of columns in the a matrix.

Complex32[] b

The b matrix

int rowsB

The number of rows in the b matrix.

int columnsB

The number of columns in the b matrix.

Complex32 beta

The value to scale the c matrix.

Complex32[] c

The c matrix.

void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, Complex alpha, Complex[] a, int rowsA, int columnsA, Complex[] b, int rowsB, int columnsB, Complex beta, Complex[] c)

Multiplies two matrices and updates another with the result. c = alpha*op(a)*op(b) + beta*c
Parameters
Transpose transposeA

How to transpose the a matrix.

Transpose transposeB

How to transpose the b matrix.

Complex alpha

The value to scale a matrix.

Complex[] a

The a matrix.

int rowsA

The number of rows in the a matrix.

int columnsA

The number of columns in the a matrix.

Complex[] b

The b matrix

int rowsB

The number of rows in the b matrix.

int columnsB

The number of columns in the b matrix.

Complex beta

The value to scale the c matrix.

Complex[] c

The c matrix.

void MatrixMultiplyWithUpdate(Transpose transposeA, Transpose transposeB, double alpha, Double[] a, int rowsA, int columnsA, Double[] b, int rowsB, int columnsB, double beta, Double[] c)

Multiplies two matrices and updates another with the result. c = alpha*op(a)*op(b) + beta*c
Parameters
Transpose transposeA

How to transpose the a matrix.

Transpose transposeB

How to transpose the b matrix.

double alpha

The value to scale a matrix.

Double[] a

The a matrix.

int rowsA

The number of rows in the a matrix.

int columnsA

The number of columns in the a matrix.

Double[] b

The b matrix

int rowsB

The number of rows in the b matrix.

int columnsB

The number of columns in the b matrix.

double beta

The value to scale the c matrix.

Double[] c

The c matrix.

void MatrixMultiplyWithUpdateExperimental(Transpose transposeA, Transpose transposeB, double alpha, Double[] a, int rowsA, int columnsA, Double[] b, int rowsB, int columnsB, double beta, Double[] c)

void MatrixMultiplyWithUpdateExperimental(Transpose transposeA, Transpose transposeB, float alpha, Single[] a, int rowsA, int columnsA, Single[] b, int rowsB, int columnsB, float beta, Single[] c)

void MatrixMultiplyWithUpdateExperimental(Transpose transposeA, Transpose transposeB, Complex32 alpha, Complex32[] a, int rowsA, int columnsA, Complex32[] b, int rowsB, int columnsB, Complex32 beta, Complex32[] c)

void MatrixMultiplyWithUpdateExperimental(Transpose transposeA, Transpose transposeB, Complex alpha, Complex[] a, int rowsA, int columnsA, Complex[] b, int rowsB, int columnsB, Complex beta, Complex[] c)

double MatrixNorm(Norm norm, int rows, int columns, Single[] matrix)

Computes the requested Norm of the matrix.
Parameters
Norm norm

The type of norm to compute.

int rows

The number of rows in the matrix.

int columns

The number of columns in the matrix.

Single[] matrix

The matrix to compute the norm from.

Return
double

The requested Norm of the matrix.

double MatrixNorm(Norm norm, int rows, int columns, Complex[] matrix)

Computes the requested Norm of the matrix.
Parameters
Norm norm

The type of norm to compute.

int rows

The number of rows in the matrix.

int columns

The number of columns in the matrix.

Complex[] matrix

The matrix to compute the norm from.

Return
double

The requested Norm of the matrix.

double MatrixNorm(Norm norm, int rows, int columns, Double[] matrix)

Computes the requested Norm of the matrix.
Parameters
Norm norm

The type of norm to compute.

int rows

The number of rows in the matrix.

int columns

The number of columns in the matrix.

Double[] matrix

The matrix to compute the norm from.

Return
double

The requested Norm of the matrix.

double MatrixNorm(Norm norm, int rows, int columns, Complex32[] matrix)

Computes the requested Norm of the matrix.
Parameters
Norm norm

The type of norm to compute.

int rows

The number of rows in the matrix.

int columns

The number of columns in the matrix.

Complex32[] matrix

The matrix to compute the norm from.

Return
double

The requested Norm of the matrix.

long MemoryStatistics(Int32& allocatedBuffers)

long PeakMemoryStatistics(bool reset)

Measures peak memory usage of the MKL memory pool.
Parameters
bool reset

Whether the usage counter should be reset.

Return
long

The peak number of bytes allocated to all memory buffers.

void PointWiseDivideArrays(Complex[] x, Complex[] y, Complex[] result)

Does a point wise division of two arrays z = x / y. This can be used to divide elements of vectors or matrices.
There is no equivalent BLAS routine, but many libraries provide optimized (parallel and/or vectorized) versions of this routine.
Parameters
Complex[] x

The array x.

Complex[] y

The array y.

Complex[] result

The result of the point wise division.

void PointWiseDivideArrays(Single[] x, Single[] y, Single[] result)

Does a point wise division of two arrays z = x / y. This can be used to divide elements of vectors or matrices.
There is no equivalent BLAS routine, but many libraries provide optimized (parallel and/or vectorized) versions of this routine.
Parameters
Single[] x

The array x.

Single[] y

The array y.

Single[] result

The result of the point wise division.

void PointWiseDivideArrays(Double[] x, Double[] y, Double[] result)

Does a point wise division of two arrays z = x / y. This can be used to divide elements of vectors or matrices.
There is no equivalent BLAS routine, but many libraries provide optimized (parallel and/or vectorized) versions of this routine.
Parameters
Double[] x

The array x.

Double[] y

The array y.

Double[] result

The result of the point wise division.

void PointWiseDivideArrays(Complex32[] x, Complex32[] y, Complex32[] result)

Does a point wise division of two arrays z = x / y. This can be used to divide elements of vectors or matrices.
There is no equivalent BLAS routine, but many libraries provide optimized (parallel and/or vectorized) versions of this routine.
Parameters
Complex32[] x

The array x.

Complex32[] y

The array y.

Complex32[] result

The result of the point wise division.

void PointWiseMultiplyArrays(Single[] x, Single[] y, Single[] result)

Does a point wise multiplication of two arrays z = x * y. This can be used to multiple elements of vectors or matrices.
There is no equivalent BLAS routine, but many libraries provide optimized (parallel and/or vectorized) versions of this routine.
Parameters
Single[] x

The array x.

Single[] y

The array y.

Single[] result

The result of the point wise multiplication.

void PointWiseMultiplyArrays(Complex[] x, Complex[] y, Complex[] result)

Does a point wise multiplication of two arrays z = x * y. This can be used to multiple elements of vectors or matrices.
There is no equivalent BLAS routine, but many libraries provide optimized (parallel and/or vectorized) versions of this routine.
Parameters
Complex[] x

The array x.

Complex[] y

The array y.

Complex[] result

The result of the point wise multiplication.

void PointWiseMultiplyArrays(Complex32[] x, Complex32[] y, Complex32[] result)

Does a point wise multiplication of two arrays z = x * y. This can be used to multiple elements of vectors or matrices.
There is no equivalent BLAS routine, but many libraries provide optimized (parallel and/or vectorized) versions of this routine.
Parameters
Complex32[] x

The array x.

Complex32[] y

The array y.

Complex32[] result

The result of the point wise multiplication.

void PointWiseMultiplyArrays(Double[] x, Double[] y, Double[] result)

Does a point wise multiplication of two arrays z = x * y. This can be used to multiple elements of vectors or matrices.
There is no equivalent BLAS routine, but many libraries provide optimized (parallel and/or vectorized) versions of this routine.
Parameters
Double[] x

The array x.

Double[] y

The array y.

Double[] result

The result of the point wise multiplication.

void PointWisePowerArrays(Complex[] x, Complex[] y, Complex[] result)

Does a point wise power of two arrays z = x ^ y. This can be used to raise elements of vectors or matrices to the powers of another vector or matrix.
There is no equivalent BLAS routine, but many libraries provide optimized (parallel and/or vectorized) versions of this routine.
Parameters
Complex[] x

The array x.

Complex[] y

The array y.

Complex[] result

The result of the point wise power.

void PointWisePowerArrays(Double[] x, Double[] y, Double[] result)

Does a point wise power of two arrays z = x ^ y. This can be used to raise elements of vectors or matrices to the powers of another vector or matrix.
There is no equivalent BLAS routine, but many libraries provide optimized (parallel and/or vectorized) versions of this routine.
Parameters
Double[] x

The array x.

Double[] y

The array y.

Double[] result

The result of the point wise power.

void PointWisePowerArrays(Single[] x, Single[] y, Single[] result)

Does a point wise power of two arrays z = x ^ y. This can be used to raise elements of vectors or matrices to the powers of another vector or matrix.
There is no equivalent BLAS routine, but many libraries provide optimized (parallel and/or vectorized) versions of this routine.
Parameters
Single[] x

The array x.

Single[] y

The array y.

Single[] result

The result of the point wise power.

void PointWisePowerArrays(Complex32[] x, Complex32[] y, Complex32[] result)

Does a point wise power of two arrays z = x ^ y. This can be used to raise elements of vectors or matrices to the powers of another vector or matrix.
There is no equivalent BLAS routine, but many libraries provide optimized (parallel and/or vectorized) versions of this routine.
Parameters
Complex32[] x

The array x.

Complex32[] y

The array y.

Complex32[] result

The result of the point wise power.

void QRFactor(Single[] r, int rowsR, int columnsR, Single[] q, Single[] tau)

Computes the QR factorization of A.
This is similar to the GEQRF and ORGQR LAPACK routines.
Parameters
Single[] r

On entry, it is the M by N A matrix to factor. On exit, it is overwritten with the R matrix of the QR factorization.

int rowsR

The number of rows in the A matrix.

int columnsR

The number of columns in the A matrix.

Single[] q

On exit, A M by M matrix that holds the Q matrix of the QR factorization.

Single[] tau

A min(m,n) vector. On exit, contains additional information to be used by the QR solve routine.

void QRFactor(Double[] r, int rowsR, int columnsR, Double[] q, Double[] tau)

Computes the QR factorization of A.
This is similar to the GEQRF and ORGQR LAPACK routines.
Parameters
Double[] r

On entry, it is the M by N A matrix to factor. On exit, it is overwritten with the R matrix of the QR factorization.

int rowsR

The number of rows in the A matrix.

int columnsR

The number of columns in the A matrix.

Double[] q

On exit, A M by M matrix that holds the Q matrix of the QR factorization.

Double[] tau

A min(m,n) vector. On exit, contains additional information to be used by the QR solve routine.

void QRFactor(Complex[] r, int rowsR, int columnsR, Complex[] q, Complex[] tau)

Computes the QR factorization of A.
This is similar to the GEQRF and ORGQR LAPACK routines.
Parameters
Complex[] r

On entry, it is the M by N A matrix to factor. On exit, it is overwritten with the R matrix of the QR factorization.

int rowsR

The number of rows in the A matrix.

int columnsR

The number of columns in the A matrix.

Complex[] q

On exit, A M by M matrix that holds the Q matrix of the QR factorization.

Complex[] tau

A min(m,n) vector. On exit, contains additional information to be used by the QR solve routine.

void QRFactor(Complex32[] r, int rowsR, int columnsR, Complex32[] q, Complex32[] tau)

Computes the QR factorization of A.
This is similar to the GEQRF and ORGQR LAPACK routines.
Parameters
Complex32[] r

On entry, it is the M by N A matrix to factor. On exit, it is overwritten with the R matrix of the QR factorization.

int rowsR

The number of rows in the A matrix.

int columnsR

The number of columns in the A matrix.

Complex32[] q

On exit, A M by M matrix that holds the Q matrix of the QR factorization.

Complex32[] tau

A min(m,n) vector. On exit, contains additional information to be used by the QR solve routine.

void QRSolve(Complex[] a, int rows, int columns, Complex[] b, int columnsB, Complex[] x, QRMethod method)

Solves A*X=B for X using QR factorization of A.
Rows must be greater or equal to columns.
Parameters
Complex[] a

The A matrix.

int rows

The number of rows in the A matrix.

int columns

The number of columns in the A matrix.

Complex[] b

The B matrix.

int columnsB

The number of columns of B.

Complex[] x

On exit, the solution matrix.

QRMethod method

The type of QR factorization to perform.

void QRSolve(Double[] a, int rows, int columns, Double[] b, int columnsB, Double[] x, QRMethod method)

Solves A*X=B for X using QR factorization of A.
Rows must be greater or equal to columns.
Parameters
Double[] a

The A matrix.

int rows

The number of rows in the A matrix.

int columns

The number of columns in the A matrix.

Double[] b

The B matrix.

int columnsB

The number of columns of B.

Double[] x

On exit, the solution matrix.

QRMethod method

The type of QR factorization to perform.

void QRSolve(Single[] a, int rows, int columns, Single[] b, int columnsB, Single[] x, QRMethod method)

Solves A*X=B for X using QR factorization of A.
Rows must be greater or equal to columns.
Parameters
Single[] a

The A matrix.

int rows

The number of rows in the A matrix.

int columns

The number of columns in the A matrix.

Single[] b

The B matrix.

int columnsB

The number of columns of B.

Single[] x

On exit, the solution matrix.

QRMethod method

The type of QR factorization to perform.

void QRSolve(Complex32[] a, int rows, int columns, Complex32[] b, int columnsB, Complex32[] x, QRMethod method)

Solves A*X=B for X using QR factorization of A.
Rows must be greater or equal to columns.
Parameters
Complex32[] a

The A matrix.

int rows

The number of rows in the A matrix.

int columns

The number of columns in the A matrix.

Complex32[] b

The B matrix.

int columnsB

The number of columns of B.

Complex32[] x

On exit, the solution matrix.

QRMethod method

The type of QR factorization to perform.

void QRSolveFactored(Complex32[] q, Complex32[] r, int rowsA, int columnsA, Complex32[] tau, Complex32[] b, int columnsB, Complex32[] x, QRMethod method)

Solves A*X=B for X using a previously QR factored matrix.
Rows must be greater or equal to columns.
Parameters
Complex32[] q

The Q matrix obtained by calling QRFactor.

Complex32[] r

The R matrix obtained by calling QRFactor.

int rowsA

The number of rows in the A matrix.

int columnsA

The number of columns in the A matrix.

Complex32[] tau

Contains additional information on Q. Only used for the native solver and can be null for the managed provider.

Complex32[] b

The B matrix.

int columnsB

The number of columns of B.

Complex32[] x

On exit, the solution matrix.

QRMethod method

The type of QR factorization to perform.

void QRSolveFactored(Double[] q, Double[] r, int rowsA, int columnsA, Double[] tau, Double[] b, int columnsB, Double[] x, QRMethod method)

Solves A*X=B for X using a previously QR factored matrix.
Rows must be greater or equal to columns.
Parameters
Double[] q

The Q matrix obtained by calling QRFactor.

Double[] r

The R matrix obtained by calling QRFactor.

int rowsA

The number of rows in the A matrix.

int columnsA

The number of columns in the A matrix.

Double[] tau

Contains additional information on Q. Only used for the native solver and can be null for the managed provider.

Double[] b

The B matrix.

int columnsB

The number of columns of B.

Double[] x

On exit, the solution matrix.

QRMethod method

The type of QR factorization to perform.

void QRSolveFactored(Single[] q, Single[] r, int rowsA, int columnsA, Single[] tau, Single[] b, int columnsB, Single[] x, QRMethod method)

Solves A*X=B for X using a previously QR factored matrix.
Rows must be greater or equal to columns.
Parameters
Single[] q

The Q matrix obtained by calling QRFactor.

Single[] r

The R matrix obtained by calling QRFactor.

int rowsA

The number of rows in the A matrix.

int columnsA

The number of columns in the A matrix.

Single[] tau

Contains additional information on Q. Only used for the native solver and can be null for the managed provider.

Single[] b

The B matrix.

int columnsB

The number of columns of B.

Single[] x

On exit, the solution matrix.

QRMethod method

The type of QR factorization to perform.

void QRSolveFactored(Complex[] q, Complex[] r, int rowsA, int columnsA, Complex[] tau, Complex[] b, int columnsB, Complex[] x, QRMethod method)

Solves A*X=B for X using a previously QR factored matrix.
Rows must be greater or equal to columns.
Parameters
Complex[] q

The Q matrix obtained by calling QRFactor.

Complex[] r

The R matrix obtained by calling QRFactor.

int rowsA

The number of rows in the A matrix.

int columnsA

The number of columns in the A matrix.

Complex[] tau

Contains additional information on Q. Only used for the native solver and can be null for the managed provider.

Complex[] b

The B matrix.

int columnsB

The number of columns of B.

Complex[] x

On exit, the solution matrix.

QRMethod method

The type of QR factorization to perform.

void ScaleArray(double alpha, Double[] x, Double[] result)

Scales an array. Can be used to scale a vector and a matrix.
This is similar to the SCAL BLAS routine.
Parameters
double alpha

The scalar.

Double[] x

The values to scale.

Double[] result

This result of the scaling.

void ScaleArray(Complex alpha, Complex[] x, Complex[] result)

Scales an array. Can be used to scale a vector and a matrix.
This is similar to the SCAL BLAS routine.
Parameters
Complex alpha

The scalar.

Complex[] x

The values to scale.

Complex[] result

This result of the scaling.

void ScaleArray(Complex32 alpha, Complex32[] x, Complex32[] result)

Scales an array. Can be used to scale a vector and a matrix.
This is similar to the SCAL BLAS routine.
Parameters
Complex32 alpha

The scalar.

Complex32[] x

The values to scale.

Complex32[] result

This result of the scaling.

void ScaleArray(float alpha, Single[] x, Single[] result)

Scales an array. Can be used to scale a vector and a matrix.
This is similar to the SCAL BLAS routine.
Parameters
float alpha

The scalar.

Single[] x

The values to scale.

Single[] result

This result of the scaling.

void SingularValueDecomposition(bool computeVectors, Single[] a, int rowsA, int columnsA, Single[] s, Single[] u, Single[] vt)

Computes the singular value decomposition of A.
This is equivalent to the GESVD LAPACK routine.
Parameters
bool computeVectors

Compute the singular U and VT vectors or not.

Single[] a

On entry, the M by N matrix to decompose. On exit, A may be overwritten.

int rowsA

The number of rows in the A matrix.

int columnsA

The number of columns in the A matrix.

Single[] s

The singular values of A in ascending value.

Single[] u

If computeVectors is true , on exit U contains the left singular vectors.

Single[] vt

If computeVectors is true , on exit VT contains the transposed right singular vectors.

void SingularValueDecomposition(bool computeVectors, Double[] a, int rowsA, int columnsA, Double[] s, Double[] u, Double[] vt)

Computes the singular value decomposition of A.
This is equivalent to the GESVD LAPACK routine.
Parameters
bool computeVectors

Compute the singular U and VT vectors or not.

Double[] a

On entry, the M by N matrix to decompose. On exit, A may be overwritten.

int rowsA

The number of rows in the A matrix.

int columnsA

The number of columns in the A matrix.

Double[] s

The singular values of A in ascending value.

Double[] u

If computeVectors is true , on exit U contains the left singular vectors.

Double[] vt

If computeVectors is true , on exit VT contains the transposed right singular vectors.

void SingularValueDecomposition(bool computeVectors, Complex32[] a, int rowsA, int columnsA, Complex32[] s, Complex32[] u, Complex32[] vt)

Computes the singular value decomposition of A.
This is equivalent to the GESVD LAPACK routine.
Parameters
bool computeVectors

Compute the singular U and VT vectors or not.

Complex32[] a

On entry, the M by N matrix to decompose. On exit, A may be overwritten.

int rowsA

The number of rows in the A matrix.

int columnsA

The number of columns in the A matrix.

Complex32[] s

The singular values of A in ascending value.

Complex32[] u

If computeVectors is true , on exit U contains the left singular vectors.

Complex32[] vt

If computeVectors is true , on exit VT contains the transposed right singular vectors.

void SingularValueDecomposition(bool computeVectors, Complex[] a, int rowsA, int columnsA, Complex[] s, Complex[] u, Complex[] vt)

Computes the singular value decomposition of A.
This is equivalent to the GESVD LAPACK routine.
Parameters
bool computeVectors

Compute the singular U and VT vectors or not.

Complex[] a

On entry, the M by N matrix to decompose. On exit, A may be overwritten.

int rowsA

The number of rows in the A matrix.

int columnsA

The number of columns in the A matrix.

Complex[] s

The singular values of A in ascending value.

Complex[] u

If computeVectors is true , on exit U contains the left singular vectors.

Complex[] vt

If computeVectors is true , on exit VT contains the transposed right singular vectors.

void SubtractArrays(Complex[] x, Complex[] y, Complex[] result)

Does a point wise subtraction of two arrays z = x - y. This can be used to subtract vectors or matrices.
There is no equivalent BLAS routine, but many libraries provide optimized (parallel and/or vectorized) versions of this routine.
Parameters
Complex[] x

The array x.

Complex[] y

The array y.

Complex[] result

The result of the subtraction.

void SubtractArrays(Double[] x, Double[] y, Double[] result)

Does a point wise subtraction of two arrays z = x - y. This can be used to subtract vectors or matrices.
There is no equivalent BLAS routine, but many libraries provide optimized (parallel and/or vectorized) versions of this routine.
Parameters
Double[] x

The array x.

Double[] y

The array y.

Double[] result

The result of the subtraction.

void SubtractArrays(Complex32[] x, Complex32[] y, Complex32[] result)

Does a point wise subtraction of two arrays z = x - y. This can be used to subtract vectors or matrices.
There is no equivalent BLAS routine, but many libraries provide optimized (parallel and/or vectorized) versions of this routine.
Parameters
Complex32[] x

The array x.

Complex32[] y

The array y.

Complex32[] result

The result of the subtraction.

void SubtractArrays(Single[] x, Single[] y, Single[] result)

Does a point wise subtraction of two arrays z = x - y. This can be used to subtract vectors or matrices.
There is no equivalent BLAS routine, but many libraries provide optimized (parallel and/or vectorized) versions of this routine.
Parameters
Single[] x

The array x.

Single[] y

The array y.

Single[] result

The result of the subtraction.

void SvdSolve(Double[] a, int rowsA, int columnsA, Double[] b, int columnsB, Double[] x)

Solves A*X=B for X using the singular value decomposition of A.
Parameters
Double[] a

On entry, the M by N matrix to decompose.

int rowsA

The number of rows in the A matrix.

int columnsA

The number of columns in the A matrix.

Double[] b

The B matrix.

int columnsB

The number of columns of B.

Double[] x

On exit, the solution matrix.

void SvdSolve(Complex32[] a, int rowsA, int columnsA, Complex32[] b, int columnsB, Complex32[] x)

Solves A*X=B for X using the singular value decomposition of A.
Parameters
Complex32[] a

On entry, the M by N matrix to decompose.

int rowsA

The number of rows in the A matrix.

int columnsA

The number of columns in the A matrix.

Complex32[] b

The B matrix.

int columnsB

The number of columns of B.

Complex32[] x

On exit, the solution matrix.

void SvdSolve(Single[] a, int rowsA, int columnsA, Single[] b, int columnsB, Single[] x)

Solves A*X=B for X using the singular value decomposition of A.
Parameters
Single[] a

On entry, the M by N matrix to decompose.

int rowsA

The number of rows in the A matrix.

int columnsA

The number of columns in the A matrix.

Single[] b

The B matrix.

int columnsB

The number of columns of B.

Single[] x

On exit, the solution matrix.

void SvdSolve(Complex[] a, int rowsA, int columnsA, Complex[] b, int columnsB, Complex[] x)

Solves A*X=B for X using the singular value decomposition of A.
Parameters
Complex[] a

On entry, the M by N matrix to decompose.

int rowsA

The number of rows in the A matrix.

int columnsA

The number of columns in the A matrix.

Complex[] b

The B matrix.

int columnsB

The number of columns of B.

Complex[] x

On exit, the solution matrix.

void SvdSolveFactored(int rowsA, int columnsA, Single[] s, Single[] u, Single[] vt, Single[] b, int columnsB, Single[] x)

Solves A*X=B for X using a previously SVD decomposed matrix.
Parameters
int rowsA

The number of rows in the A matrix.

int columnsA

The number of columns in the A matrix.

Single[] s

The s values returned by SingularValueDecomposition.

Single[] u

The left singular vectors returned by SingularValueDecomposition.

Single[] vt

The right singular vectors returned by SingularValueDecomposition.

Single[] b

The B matrix.

int columnsB

The number of columns of B.

Single[] x

On exit, the solution matrix.

void SvdSolveFactored(int rowsA, int columnsA, Complex32[] s, Complex32[] u, Complex32[] vt, Complex32[] b, int columnsB, Complex32[] x)

Solves A*X=B for X using a previously SVD decomposed matrix.
Parameters
int rowsA

The number of rows in the A matrix.

int columnsA

The number of columns in the A matrix.

Complex32[] s

The s values returned by SingularValueDecomposition.

Complex32[] u

The left singular vectors returned by SingularValueDecomposition.

Complex32[] vt

The right singular vectors returned by SingularValueDecomposition.

Complex32[] b

The B matrix.

int columnsB

The number of columns of B.

Complex32[] x

On exit, the solution matrix.

void SvdSolveFactored(int rowsA, int columnsA, Complex[] s, Complex[] u, Complex[] vt, Complex[] b, int columnsB, Complex[] x)

Solves A*X=B for X using a previously SVD decomposed matrix.
Parameters
int rowsA

The number of rows in the A matrix.

int columnsA

The number of columns in the A matrix.

Complex[] s

The s values returned by SingularValueDecomposition.

Complex[] u

The left singular vectors returned by SingularValueDecomposition.

Complex[] vt

The right singular vectors returned by SingularValueDecomposition.

Complex[] b

The B matrix.

int columnsB

The number of columns of B.

Complex[] x

On exit, the solution matrix.

void SvdSolveFactored(int rowsA, int columnsA, Double[] s, Double[] u, Double[] vt, Double[] b, int columnsB, Double[] x)

Solves A*X=B for X using a previously SVD decomposed matrix.
Parameters
int rowsA

The number of rows in the A matrix.

int columnsA

The number of columns in the A matrix.

Double[] s

The s values returned by SingularValueDecomposition.

Double[] u

The left singular vectors returned by SingularValueDecomposition.

Double[] vt

The right singular vectors returned by SingularValueDecomposition.

Double[] b

The B matrix.

int columnsB

The number of columns of B.

Double[] x

On exit, the solution matrix.

void ThinQRFactor(Complex[] q, int rowsA, int columnsA, Complex[] r, Complex[] tau)

Computes the thin QR factorization of A where M > N.
This is similar to the GEQRF and ORGQR LAPACK routines.
Parameters
Complex[] q

On entry, it is the M by N A matrix to factor. On exit, it is overwritten with the Q matrix of the QR factorization.

int rowsA

The number of rows in the A matrix.

int columnsA

The number of columns in the A matrix.

Complex[] r

On exit, A N by N matrix that holds the R matrix of the QR factorization.

Complex[] tau

A min(m,n) vector. On exit, contains additional information to be used by the QR solve routine.

void ThinQRFactor(Double[] q, int rowsA, int columnsA, Double[] r, Double[] tau)

Computes the thin QR factorization of A where M > N.
This is similar to the GEQRF and ORGQR LAPACK routines.
Parameters
Double[] q

On entry, it is the M by N A matrix to factor. On exit, it is overwritten with the Q matrix of the QR factorization.

int rowsA

The number of rows in the A matrix.

int columnsA

The number of columns in the A matrix.

Double[] r

On exit, A N by N matrix that holds the R matrix of the QR factorization.

Double[] tau

A min(m,n) vector. On exit, contains additional information to be used by the QR solve routine.

void ThinQRFactor(Single[] q, int rowsA, int columnsA, Single[] r, Single[] tau)

Computes the thin QR factorization of A where M > N.
This is similar to the GEQRF and ORGQR LAPACK routines.
Parameters
Single[] q

On entry, it is the M by N A matrix to factor. On exit, it is overwritten with the Q matrix of the QR factorization.

int rowsA

The number of rows in the A matrix.

int columnsA

The number of columns in the A matrix.

Single[] r

On exit, A N by N matrix that holds the R matrix of the QR factorization.

Single[] tau

A min(m,n) vector. On exit, contains additional information to be used by the QR solve routine.

void ThinQRFactor(Complex32[] q, int rowsA, int columnsA, Complex32[] r, Complex32[] tau)

Computes the thin QR factorization of A where M > N.
This is similar to the GEQRF and ORGQR LAPACK routines.
Parameters
Complex32[] q

On entry, it is the M by N A matrix to factor. On exit, it is overwritten with the Q matrix of the QR factorization.

int rowsA

The number of rows in the A matrix.

int columnsA

The number of columns in the A matrix.

Complex32[] r

On exit, A N by N matrix that holds the R matrix of the QR factorization.

Complex32[] tau

A min(m,n) vector. On exit, contains additional information to be used by the QR solve routine.

void ThreadFreeBuffers()

Frees the memory allocated to the MKL memory pool on the current thread.

string ToString()