Namespaces

Types in MathNet.Numerics.Providers.LinearAlgebra

Type ManagedLinearAlgebraProvider

Namespace MathNet.Numerics.Providers.LinearAlgebra

Interfaces ILinearAlgebraProvider

The managed linear algebra provider.

Constructors

Methods

Properties

Public Constructors

ManagedLinearAlgebraProvider()

Public Methods

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(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 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(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 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(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(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 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 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 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(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 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 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(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(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 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. Has to be different than b.

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(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

The B 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(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 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 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.

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.

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.

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.

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 length of the array must be order * order.

Single[] matrixEv

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

Complex[] vectorEv

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

Single[] matrixD

On output, the block diagonal eigenvalue matrix. The length 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 length of the array must be order * order.

Double[] matrixEv

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

Complex[] vectorEv

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

Double[] matrixD

On output, the block diagonal eigenvalue matrix. The length 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 length of the array must be order * order.

Complex32[] matrixEv

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

Complex[] vectorEv

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

Complex32[] matrixD

On output, the block diagonal eigenvalue matrix. The length 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 length of the array must be order * order.

Complex[] matrixEv

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

Complex[] vectorEv

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

Complex[] matrixD

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

bool Equals(object obj)

void FreeResources()

Frees memory buffers, caches and handles allocated in or to the provider. Does not unload the provider itself, it is still usable afterwards.

int GetHashCode()

Type GetType()

void InitializeVerify()

Initialize and verify that the provided is indeed available. If not, 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(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.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(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(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 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 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 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(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 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(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(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 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, 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 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, 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 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, 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 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 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 1.0 and beta set to 0.0, 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 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.0 and beta set to 0.0, 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 1.0 and beta set to 0.0, 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 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, 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 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.

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.

int columns

The number of columns.

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, Double[] matrix)

Computes the requested Norm of the matrix.
Parameters
Norm norm

The type of norm to compute.

int rows

The number of rows.

int columns

The number of columns.

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, Complex[] matrix)

Computes the requested Norm of the matrix.
Parameters
Norm norm

The type of norm to compute.

int rows

The number of rows.

int columns

The number of columns.

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, Complex32[] matrix)

Computes the requested Norm of the matrix.
Parameters
Norm norm

The type of norm to compute.

int rows

The number of rows.

int columns

The number of columns.

Complex32[] matrix

The matrix to compute the norm from.

Return
double

The requested Norm of the matrix.

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(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(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 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 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(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(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(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 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(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 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 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 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(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(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 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 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 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(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 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(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 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 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, 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 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, 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 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(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(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 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 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(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 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(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 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, 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, 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 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 ThinQRFactor(Double[] a, int rowsA, int columnsA, Double[] r, Double[] tau)

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

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(Complex32[] a, int rowsA, int columnsA, Complex32[] r, Complex32[] tau)

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

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 ThinQRFactor(Single[] a, int rowsA, int columnsA, Single[] r, Single[] tau)

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

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(Complex[] a, int rowsA, int columnsA, Complex[] r, Complex[] tau)

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

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.

string ToString()

Public Properties

ManagedLinearAlgebraProvider Instance get;