- MathNet.Numerics
- MathNet.Numerics.Differentiation
- MathNet.Numerics.Distributions
- MathNet.Numerics.Financial
- MathNet.Numerics.IntegralTransforms
- MathNet.Numerics.Integration
- MathNet.Numerics.Interpolation
- MathNet.Numerics.LinearAlgebra
- MathNet.Numerics.LinearAlgebra.Complex
- MathNet.Numerics.LinearAlgebra.Complex.Solvers
- MathNet.Numerics.LinearAlgebra.Complex32
- MathNet.Numerics.LinearAlgebra.Complex32.Solvers
- MathNet.Numerics.LinearAlgebra.Double
- MathNet.Numerics.LinearAlgebra.Double.Solvers
- MathNet.Numerics.LinearAlgebra.Factorization
- MathNet.Numerics.LinearAlgebra.Single
- MathNet.Numerics.LinearAlgebra.Single.Solvers
- MathNet.Numerics.LinearAlgebra.Solvers
- MathNet.Numerics.LinearAlgebra.Storage
- MathNet.Numerics.LinearRegression
- MathNet.Numerics.OdeSolvers
- MathNet.Numerics.Optimization
- MathNet.Numerics.Optimization.LineSearch
- MathNet.Numerics.Optimization.ObjectiveFunctions
- MathNet.Numerics.Optimization.TrustRegion
- MathNet.Numerics.Providers
- MathNet.Numerics.Providers.FourierTransform
- MathNet.Numerics.Providers.LinearAlgebra
- MathNet.Numerics.Providers.SparseSolver
- MathNet.Numerics.Random
- MathNet.Numerics.RootFinding
- MathNet.Numerics.Statistics
- MathNet.Numerics.Statistics.Mcmc

**Type** ManagedLinearAlgebraProvider

**Namespace** MathNet.Numerics.Providers.LinearAlgebra

**Interfaces** ILinearAlgebraProvider

The managed linear algebra provider.

- AddArrays
- AddArrays
- AddArrays
- AddArrays
- AddVectorToScaledVector
- AddVectorToScaledVector
- AddVectorToScaledVector
- AddVectorToScaledVector
- CholeskyFactor
- CholeskyFactor
- CholeskyFactor
- CholeskyFactor
- CholeskySolve
- CholeskySolve
- CholeskySolve
- CholeskySolve
- CholeskySolveFactored
- CholeskySolveFactored
- CholeskySolveFactored
- CholeskySolveFactored
- ConjugateArray
- ConjugateArray
- ConjugateArray
- ConjugateArray
- DotProduct
- DotProduct
- DotProduct
- DotProduct
- EigenDecomp
- EigenDecomp
- EigenDecomp
- EigenDecomp
- Equals
- FreeResources
- GetHashCode
- GetType
- InitializeVerify
- IsAvailable
- LUFactor
- LUFactor
- LUFactor
- LUFactor
- LUInverse
- LUInverse
- LUInverse
- LUInverse
- LUInverseFactored
- LUInverseFactored
- LUInverseFactored
- LUInverseFactored
- LUSolve
- LUSolve
- LUSolve
- LUSolve
- LUSolveFactored
- LUSolveFactored
- LUSolveFactored
- LUSolveFactored
- MatrixMultiply
- MatrixMultiply
- MatrixMultiply
- MatrixMultiply
- MatrixMultiplyWithUpdate
- MatrixMultiplyWithUpdate
- MatrixMultiplyWithUpdate
- MatrixMultiplyWithUpdate
- MatrixNorm
- MatrixNorm
- MatrixNorm
- MatrixNorm
- PointWiseDivideArrays
- PointWiseDivideArrays
- PointWiseDivideArrays
- PointWiseDivideArrays
- PointWiseMultiplyArrays
- PointWiseMultiplyArrays
- PointWiseMultiplyArrays
- PointWiseMultiplyArrays
- PointWisePowerArrays
- PointWisePowerArrays
- PointWisePowerArrays
- PointWisePowerArrays
- QRFactor
- QRFactor
- QRFactor
- QRFactor
- QRSolve
- QRSolve
- QRSolve
- QRSolve
- QRSolveFactored
- QRSolveFactored
- QRSolveFactored
- QRSolveFactored
- ScaleArray
- ScaleArray
- ScaleArray
- ScaleArray
- SingularValueDecomposition
- SingularValueDecomposition
- SingularValueDecomposition
- SingularValueDecomposition
- SubtractArrays
- SubtractArrays
- SubtractArrays
- SubtractArrays
- SvdSolve
- SvdSolve
- SvdSolve
- SvdSolve
- SvdSolveFactored
- SvdSolveFactored
- SvdSolveFactored
- SvdSolveFactored
- ThinQRFactor
- ThinQRFactor
- ThinQRFactor
- ThinQRFactor
- ToString

Does a point wise add of two arrays
##### Parameters

`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.

`Single[]`

xThe array x.

`Single[]`

yThe array y.

`Single[]`

resultThe result of the addition.

Does a point wise add of two arrays
##### Parameters

`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.

`Double[]`

xThe array x.

`Double[]`

yThe array y.

`Double[]`

resultThe result of the addition.

Does a point wise add of two arrays
##### Parameters

`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.

`Complex[]`

xThe array x.

`Complex[]`

yThe array y.

`Complex[]`

resultThe result of the addition.

Does a point wise add of two arrays
##### Parameters

`z = x + y`

. This can be used
to add vectors or matrices. `Complex32[]`

xThe array x.

`Complex32[]`

yThe array y.

`Complex32[]`

resultThe result of the addition.

Adds a scaled vector to another:
##### Parameters

`result = y + alpha*x`

. This is similar to the AXPY BLAS routine.

`Single[]`

yThe vector to update.

`float`

alphaThe value to scale `x` by.

`Single[]`

xThe vector to add to `y`.

`Single[]`

resultThe result of the addition.

Adds a scaled vector to another:
##### Parameters

`result = y + alpha*x`

. This is similar to the AXPY BLAS routine.

`Double[]`

yThe vector to update.

`double`

alphaThe value to scale `x` by.

`Double[]`

xThe vector to add to `y`.

`Double[]`

resultThe result of the addition.

Adds a scaled vector to another:
##### Parameters

`result = y + alpha*x`

. This is similar to the AXPY BLAS routine.

`Complex32[]`

yThe vector to update.

`Complex32`

alphaThe value to scale `x` by.

`Complex32[]`

xThe vector to add to `y`.

`Complex32[]`

resultThe result of the addition.

Adds a scaled vector to another:
##### Parameters

`result = y + alpha*x`

. This is similar to the AXPY BLAS routine.

`Complex[]`

yThe vector to update.

`Complex`

alphaThe value to scale `x` by.

`Complex[]`

xThe vector to add to `y`.

`Complex[]`

resultThe result of the addition.

Computes the Cholesky factorization of A.
##### Parameters

This is equivalent to the POTRF LAPACK routine.

`Complex32[]`

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

`int`

orderThe number of rows or columns in the matrix.

Computes the Cholesky factorization of A.
##### Parameters

This is equivalent to the POTRF LAPACK routine.

`Single[]`

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

`int`

orderThe number of rows or columns in the matrix.

Computes the Cholesky factorization of A.
##### Parameters

This is equivalent to the POTRF LAPACK routine.

`Double[]`

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

`int`

orderThe number of rows or columns in the matrix.

Computes the Cholesky factorization of A.
##### Parameters

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

This is equivalent to the POTRF LAPACK routine.

`Complex[]`

a`int`

orderThe number of rows or columns in the matrix.

Solves A*X=B for X using Cholesky factorization.
##### Parameters

This is equivalent to the POTRF add POTRS LAPACK routines.

`Single[]`

aThe square, positive definite matrix A.

`int`

orderAThe number of rows and columns in A.

`Single[]`

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

`int`

columnsBThe number of columns in the B matrix.

Solves A*X=B for X using Cholesky factorization.
##### Parameters

This is equivalent to the POTRF add POTRS LAPACK routines.

`Complex32[]`

aThe square, positive definite matrix A.

`int`

orderAThe number of rows and columns in A.

`Complex32[]`

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

`int`

columnsBThe number of columns in the B matrix.

Solves A*X=B for X using Cholesky factorization.
##### Parameters

This is equivalent to the POTRF add POTRS LAPACK routines.

`Complex[]`

aThe square, positive definite matrix A.

`int`

orderAThe number of rows and columns in A.

`Complex[]`

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

`int`

columnsBThe number of columns in the B matrix.

Solves A*X=B for X using Cholesky factorization.
##### Parameters

This is equivalent to the POTRF add POTRS LAPACK routines.

`Double[]`

aThe square, positive definite matrix A.

`int`

orderAThe number of rows and columns in A.

`Double[]`

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

`int`

columnsBThe number of columns in the B matrix.

Solves A*X=B for X using a previously factored A matrix.
##### Parameters

This is equivalent to the POTRS LAPACK routine.

`Double[]`

aThe square, positive definite matrix A. Has to be different than `b`.

`int`

orderAThe number of rows and columns in A.

`Double[]`

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

`int`

columnsBThe number of columns in the B matrix.

Solves A*X=B for X using a previously factored A matrix.
##### Parameters

This is equivalent to the POTRS LAPACK routine.

`Complex[]`

aThe square, positive definite matrix A.

`int`

orderAThe number of rows and columns in A.

`Complex[]`

bThe B matrix.

`int`

columnsBThe number of columns in the B matrix.

Solves A*X=B for X using a previously factored A matrix.
##### Parameters

This is equivalent to the POTRS LAPACK routine.

`Complex32[]`

aThe square, positive definite matrix A.

`int`

orderAThe number of rows and columns in A.

`Complex32[]`

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

`int`

columnsBThe number of columns in the B matrix.

Solves A*X=B for X using a previously factored A matrix.
##### Parameters

This is equivalent to the POTRS LAPACK routine.

`Single[]`

aThe square, positive definite matrix A.

`int`

orderAThe number of rows and columns in A.

`Single[]`

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

`int`

columnsBThe number of columns in the B matrix.

Conjugates an array. Can be used to conjugate a vector and a matrix.
##### Parameters

`Single[]`

xThe values to conjugate.

`Single[]`

resultThis result of the conjugation.

Conjugates an array. Can be used to conjugate a vector and a matrix.
##### Parameters

`Complex32[]`

xThe values to conjugate.

`Complex32[]`

resultThis result of the conjugation.

Conjugates an array. Can be used to conjugate a vector and a matrix.
##### Parameters

`Double[]`

xThe values to conjugate.

`Double[]`

resultThis result of the conjugation.

Conjugates an array. Can be used to conjugate a vector and a matrix.
##### Parameters

`Complex[]`

xThe values to conjugate.

`Complex[]`

resultThis result of the conjugation.

Computes the dot product of x and y.
##### Parameters

##### Return

This is equivalent to the DOT BLAS routine.

`Single[]`

xThe vector x.

`Single[]`

yThe vector y.

`float`

The dot product of x and y.

Computes the dot product of x and y.
##### Parameters

This is equivalent to the DOT BLAS routine.

`Complex32[]`

xThe vector x.

`Complex32[]`

yThe vector y.

Computes the dot product of x and y.
##### Parameters

##### Return

This is equivalent to the DOT BLAS routine.

`Complex[]`

xThe vector x.

`Complex[]`

yThe vector y.

`Complex`

The dot product of x and y.

Computes the dot product of x and y.
##### Parameters

##### Return

This is equivalent to the DOT BLAS routine.

`Double[]`

xThe vector x.

`Double[]`

yThe vector y.

`double`

The dot product of x and y.

Computes the eigenvalues and eigenvectors of a matrix.
##### Parameters

`bool`

isSymmetricWhether the matrix is symmetric or not.

`int`

orderThe order of the matrix.

`Single[]`

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

`Single[]`

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

`Complex[]`

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

`Single[]`

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

Computes the eigenvalues and eigenvectors of a matrix.
##### Parameters

`bool`

isSymmetricWhether the matrix is symmetric or not.

`int`

orderThe order of the matrix.

`Double[]`

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

`Double[]`

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

`Complex[]`

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

`Double[]`

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

Computes the eigenvalues and eigenvectors of a matrix.
##### Parameters

`bool`

isSymmetricWhether the matrix is symmetric or not.

`int`

orderThe order of the matrix.

`Complex32[]`

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

`Complex32[]`

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

`Complex[]`

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

`Complex32[]`

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

Computes the eigenvalues and eigenvectors of a matrix.
##### Parameters

`bool`

isSymmetricWhether the matrix is symmetric or not.

`int`

orderThe order of the matrix.

`Complex[]`

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

`Complex[]`

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

`Complex[]`

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

`Complex[]`

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

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

Initialize and verify that the provided is indeed available. If not, fall back to alternatives like the managed provider

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.

Computes the LUP factorization of A. P*A = L*U.
##### Parameters

This is equivalent to the GETRF LAPACK routine.

`Single[]`

dataAn `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`

orderThe order of the square matrix `data`.

`Int32[]`

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

Computes the LUP factorization of A. P*A = L*U.
##### Parameters

This is equivalent to the GETRF LAPACK routine.

`Double[]`

dataAn `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`

orderThe order of the square matrix `data`.

`Int32[]`

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

Computes the LUP factorization of A. P*A = L*U.
##### Parameters

This is equivalent to the GETRF LAPACK routine.

`Complex32[]`

dataAn `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`

orderThe order of the square matrix `data`.

`Int32[]`

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

Computes the LUP factorization of A. P*A = L*U.
##### Parameters

This is equivalent to the GETRF LAPACK routine.

`Complex[]`

data`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`

orderThe order of the square matrix `data`.

`Int32[]`

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

Computes the inverse of matrix using LU factorization.
##### Parameters

This is equivalent to the GETRF and GETRI LAPACK routines.

`Double[]`

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

`int`

orderThe order of the square matrix `a`.

Computes the inverse of matrix using LU factorization.
##### Parameters

This is equivalent to the GETRF and GETRI LAPACK routines.

`Complex[]`

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

`int`

orderThe order of the square matrix `a`.

Computes the inverse of matrix using LU factorization.
##### Parameters

This is equivalent to the GETRF and GETRI LAPACK routines.

`Single[]`

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

`int`

orderThe order of the square matrix `a`.

Computes the inverse of matrix using LU factorization.
##### Parameters

This is equivalent to the GETRF and GETRI LAPACK routines.

`Complex32[]`

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

`int`

orderThe order of the square matrix `a`.

Computes the inverse of a previously factored matrix.
##### Parameters

This is equivalent to the GETRI LAPACK routine.

`Complex[]`

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

`int`

orderThe order of the square matrix `a`.

`Int32[]`

ipivThe pivot indices of `a`.

Computes the inverse of a previously factored matrix.
##### Parameters

This is equivalent to the GETRI LAPACK routine.

`Complex32[]`

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

`int`

orderThe order of the square matrix `a`.

`Int32[]`

ipivThe pivot indices of `a`.

Computes the inverse of a previously factored matrix.
##### Parameters

This is equivalent to the GETRI LAPACK routine.

`Single[]`

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

`int`

orderThe order of the square matrix `a`.

`Int32[]`

ipivThe pivot indices of `a`.

Computes the inverse of a previously factored matrix.
##### Parameters

This is equivalent to the GETRI LAPACK routine.

`Double[]`

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

`int`

orderThe order of the square matrix `a`.

`Int32[]`

ipivThe pivot indices of `a`.

Solves A*X=B for X using LU factorization.
##### Parameters

This is equivalent to the GETRF and GETRS LAPACK routines.

`int`

columnsOfBThe number of columns of B.

`Complex32[]`

aThe square matrix A.

`int`

orderThe order of the square matrix `a`.

`Complex32[]`

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

Solves A*X=B for X using LU factorization.
##### Parameters

This is equivalent to the GETRF and GETRS LAPACK routines.

`int`

columnsOfBThe number of columns of B.

`Complex[]`

aThe square matrix A.

`int`

orderThe order of the square matrix `a`.

`Complex[]`

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

Solves A*X=B for X using LU factorization.
##### Parameters

This is equivalent to the GETRF and GETRS LAPACK routines.

`int`

columnsOfBThe number of columns of B.

`Double[]`

aThe square matrix A.

`int`

orderThe order of the square matrix `a`.

`Double[]`

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

Solves A*X=B for X using LU factorization.
##### Parameters

This is equivalent to the GETRF and GETRS LAPACK routines.

`int`

columnsOfBThe number of columns of B.

`Single[]`

aThe square matrix A.

`int`

orderThe order of the square matrix `a`.

`Single[]`

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

Solves A*X=B for X using a previously factored A matrix.
##### Parameters

This is equivalent to the GETRS LAPACK routine.

`int`

columnsOfBThe number of columns of B.

`Complex32[]`

aThe factored A matrix.

`int`

orderThe order of the square matrix `a`.

`Int32[]`

ipivThe pivot indices of `a`.

`Complex32[]`

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

Solves A*X=B for X using a previously factored A matrix.
##### Parameters

This is equivalent to the GETRS LAPACK routine.

`int`

columnsOfBThe number of columns of B.

`Complex[]`

aThe factored A matrix.

`int`

orderThe order of the square matrix `a`.

`Int32[]`

ipivThe pivot indices of `a`.

`Complex[]`

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

Solves A*X=B for X using a previously factored A matrix.
##### Parameters

This is equivalent to the GETRS LAPACK routine.

`int`

columnsOfBThe number of columns of B.

`Double[]`

aThe factored A matrix.

`int`

orderThe order of the square matrix `a`.

`Int32[]`

ipivThe pivot indices of `a`.

`Double[]`

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

Solves A*X=B for X using a previously factored A matrix.
##### Parameters

This is equivalent to the GETRS LAPACK routine.

`int`

columnsOfBThe number of columns of B.

`Single[]`

aThe factored A matrix.

`int`

orderThe order of the square matrix `a`.

`Int32[]`

ipivThe pivot indices of `a`.

`Single[]`

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

Multiples two matrices.
##### Parameters

`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.

`Complex32[]`

xThe x matrix.

`int`

rowsXThe number of rows in the x matrix.

`int`

columnsXThe number of columns in the x matrix.

`Complex32[]`

yThe y matrix.

`int`

rowsYThe number of rows in the y matrix.

`int`

columnsYThe number of columns in the y matrix.

`Complex32[]`

resultWhere to store the result of the multiplication.

Multiples two matrices.
##### Parameters

`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.

`Double[]`

xThe x matrix.

`int`

rowsXThe number of rows in the x matrix.

`int`

columnsXThe number of columns in the x matrix.

`Double[]`

yThe y matrix.

`int`

rowsYThe number of rows in the y matrix.

`int`

columnsYThe number of columns in the y matrix.

`Double[]`

resultWhere to store the result of the multiplication.

Multiples two matrices.
##### Parameters

`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.

`Single[]`

xThe x matrix.

`int`

rowsXThe number of rows in the x matrix.

`int`

columnsXThe number of columns in the x matrix.

`Single[]`

yThe y matrix.

`int`

rowsYThe number of rows in the y matrix.

`int`

columnsYThe number of columns in the y matrix.

`Single[]`

resultWhere to store the result of the multiplication.

Multiples two matrices.
##### Parameters

`result = x * y`

`Complex[]`

xThe x matrix.

`int`

rowsXThe number of rows in the x matrix.

`int`

columnsXThe number of columns in the x matrix.

`Complex[]`

yThe y matrix.

`int`

rowsYThe number of rows in the y matrix.

`int`

columnsYThe number of columns in the y matrix.

`Complex[]`

resultWhere to store the result of the multiplication.

Multiplies two matrices and updates another with the result.
##### Parameters

`c = alpha*op(a)*op(b) + beta*c`

`Transpose`

transposeAHow to transpose the `a` matrix.

`Transpose`

transposeBHow to transpose the `b` matrix.

`float`

alphaThe value to scale `a` matrix.

`Single[]`

aThe a matrix.

`int`

rowsAThe number of rows in the `a` matrix.

`int`

columnsAThe number of columns in the `a` matrix.

`Single[]`

bThe b matrix

`int`

rowsBThe number of rows in the `b` matrix.

`int`

columnsBThe number of columns in the `b` matrix.

`float`

betaThe value to scale the `c` matrix.

`Single[]`

cThe c matrix.

Multiplies two matrices and updates another with the result.
##### Parameters

`c = alpha*op(a)*op(b) + beta*c`

`Transpose`

transposeAHow to transpose the `a` matrix.

`Transpose`

transposeBHow to transpose the `b` matrix.

`Complex`

alphaThe value to scale `a` matrix.

`Complex[]`

aThe a matrix.

`int`

rowsAThe number of rows in the `a` matrix.

`int`

columnsAThe number of columns in the `a` matrix.

`Complex[]`

bThe b matrix

`int`

rowsBThe number of rows in the `b` matrix.

`int`

columnsBThe number of columns in the `b` matrix.

`Complex`

betaThe value to scale the `c` matrix.

`Complex[]`

cThe c matrix.

Multiplies two matrices and updates another with the result.
##### Parameters

`c = alpha*op(a)*op(b) + beta*c`

`Transpose`

transposeAHow to transpose the `a` matrix.

`Transpose`

transposeBHow to transpose the `b` matrix.

`double`

alphaThe value to scale `a` matrix.

`Double[]`

aThe a matrix.

`int`

rowsAThe number of rows in the `a` matrix.

`int`

columnsAThe number of columns in the `a` matrix.

`Double[]`

bThe b matrix

`int`

rowsBThe number of rows in the `b` matrix.

`int`

columnsBThe number of columns in the `b` matrix.

`double`

betaThe value to scale the `c` matrix.

`Double[]`

cThe c matrix.

Multiplies two matrices and updates another with the result.
##### Parameters

`c = alpha*op(a)*op(b) + beta*c`

`Transpose`

transposeAHow to transpose the `a` matrix.

`Transpose`

transposeBHow to transpose the `b` matrix.

`Complex32`

alphaThe value to scale `a` matrix.

`Complex32[]`

aThe a matrix.

`int`

rowsAThe number of rows in the `a` matrix.

`int`

columnsAThe number of columns in the `a` matrix.

`Complex32[]`

bThe b matrix

`int`

rowsBThe number of rows in the `b` matrix.

`int`

columnsBThe number of columns in the `b` matrix.

`Complex32`

betaThe value to scale the `c` matrix.

`Complex32[]`

cThe c matrix.

Does a point wise division of two arrays
##### Parameters

`z = x / y`

. This can be used
to divide elements of vectors or matrices. `Double[]`

xThe array x.

`Double[]`

yThe array y.

`Double[]`

resultThe result of the point wise division.

Does a point wise division of two arrays
##### Parameters

`z = x / y`

. This can be used
to divide elements of vectors or matrices. `Complex[]`

xThe array x.

`Complex[]`

yThe array y.

`Complex[]`

resultThe result of the point wise division.

Does a point wise division of two arrays
##### Parameters

`z = x / y`

. This can be used
to divide elements of vectors or matrices. `Complex32[]`

xThe array x.

`Complex32[]`

yThe array y.

`Complex32[]`

resultThe result of the point wise division.

Does a point wise division of two arrays
##### Parameters

`z = x / y`

. This can be used
to divide elements of vectors or matrices. `Single[]`

xThe array x.

`Single[]`

yThe array y.

`Single[]`

resultThe result of the point wise division.

Does a point wise multiplication of two arrays
##### Parameters

`z = x * y`

. This can be used
to multiple elements of vectors or matrices. `Complex[]`

xThe array x.

`Complex[]`

yThe array y.

`Complex[]`

resultThe result of the point wise multiplication.

Does a point wise multiplication of two arrays
##### Parameters

`z = x * y`

. This can be used
to multiple elements of vectors or matrices. `Complex32[]`

xThe array x.

`Complex32[]`

yThe array y.

`Complex32[]`

resultThe result of the point wise multiplication.

Does a point wise multiplication of two arrays
##### Parameters

`z = x * y`

. This can be used
to multiple elements of vectors or matrices. `Single[]`

xThe array x.

`Single[]`

yThe array y.

`Single[]`

resultThe result of the point wise multiplication.

Does a point wise multiplication of two arrays
##### Parameters

`z = x * y`

. This can be used
to multiple elements of vectors or matrices. `Double[]`

xThe array x.

`Double[]`

yThe array y.

`Double[]`

resultThe result of the point wise multiplication.

Does a point wise power of two arrays
##### Parameters

`z = x ^ y`

. This can be used
to raise elements of vectors or matrices to the powers of another vector or matrix. `Single[]`

xThe array x.

`Single[]`

yThe array y.

`Single[]`

resultThe result of the point wise power.

Does a point wise power of two arrays
##### Parameters

`z = x ^ y`

. This can be used
to raise elements of vectors or matrices to the powers of another vector or matrix. `Complex32[]`

xThe array x.

`Complex32[]`

yThe array y.

`Complex32[]`

resultThe result of the point wise power.

Does a point wise power of two arrays
##### Parameters

`z = x ^ y`

. This can be used
to raise elements of vectors or matrices to the powers of another vector or matrix. `Double[]`

xThe array x.

`Double[]`

yThe array y.

`Double[]`

resultThe result of the point wise power.

Does a point wise power of two arrays
##### Parameters

`z = x ^ y`

. This can be used
to raise elements of vectors or matrices to the powers of another vector or matrix. `Complex[]`

xThe array x.

`Complex[]`

yThe array y.

`Complex[]`

resultThe result of the point wise power.

Computes the QR factorization of A.
##### Parameters

This is similar to the GEQRF and ORGQR LAPACK routines.

`Double[]`

rOn 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`

rowsRThe number of rows in the A matrix.

`int`

columnsRThe number of columns in the A matrix.

`Double[]`

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

`Double[]`

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

Computes the QR factorization of A.
##### Parameters

This is similar to the GEQRF and ORGQR LAPACK routines.

`Complex[]`

rOn 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`

rowsRThe number of rows in the A matrix.

`int`

columnsRThe number of columns in the A matrix.

`Complex[]`

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

`Complex[]`

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

Computes the QR factorization of A.
##### Parameters

This is similar to the GEQRF and ORGQR LAPACK routines.

`Complex32[]`

rOn 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`

rowsRThe number of rows in the A matrix.

`int`

columnsRThe number of columns in the A matrix.

`Complex32[]`

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

`Complex32[]`

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

Computes the QR factorization of A.
##### Parameters

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.

This is similar to the GEQRF and ORGQR LAPACK routines.

`Single[]`

r`int`

rowsRThe number of rows in the A matrix.

`int`

columnsRThe number of columns in the A matrix.

`Single[]`

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

`Single[]`

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

Solves A*X=B for X using QR factorization of A.
##### Parameters

Rows must be greater or equal to columns.

`Double[]`

aThe A matrix.

`int`

rowsThe number of rows in the A matrix.

`int`

columnsThe number of columns in the A matrix.

`Double[]`

bThe B matrix.

`int`

columnsBThe number of columns of B.

`Double[]`

xOn exit, the solution matrix.

`QRMethod`

methodThe type of QR factorization to perform.

Solves A*X=B for X using QR factorization of A.
##### Parameters

Rows must be greater or equal to columns.

`Complex[]`

aThe A matrix.

`int`

rowsThe number of rows in the A matrix.

`int`

columnsThe number of columns in the A matrix.

`Complex[]`

bThe B matrix.

`int`

columnsBThe number of columns of B.

`Complex[]`

xOn exit, the solution matrix.

`QRMethod`

methodThe type of QR factorization to perform.

Solves A*X=B for X using QR factorization of A.
##### Parameters

Rows must be greater or equal to columns.

`Complex32[]`

aThe A matrix.

`int`

rowsThe number of rows in the A matrix.

`int`

columnsThe number of columns in the A matrix.

`Complex32[]`

bThe B matrix.

`int`

columnsBThe number of columns of B.

`Complex32[]`

xOn exit, the solution matrix.

`QRMethod`

methodThe type of QR factorization to perform.

Solves A*X=B for X using QR factorization of A.
##### Parameters

Rows must be greater or equal to columns.

`Single[]`

aThe A matrix.

`int`

rowsThe number of rows in the A matrix.

`int`

columnsThe number of columns in the A matrix.

`Single[]`

bThe B matrix.

`int`

columnsBThe number of columns of B.

`Single[]`

xOn exit, the solution matrix.

`QRMethod`

methodThe type of QR factorization to perform.

Solves A*X=B for X using a previously QR factored matrix.
##### Parameters

Rows must be greater or equal to columns.

`Complex[]`

qThe Q matrix obtained by calling QRFactor.

`Complex[]`

rThe R matrix obtained by calling QRFactor.

`int`

rowsAThe number of rows in the A matrix.

`int`

columnsAThe number of columns in the A matrix.

`Complex[]`

tauContains additional information on Q. Only used for the native solver
and can be `null`

for the managed provider.

`Complex[]`

bThe B matrix.

`int`

columnsBThe number of columns of B.

`Complex[]`

xOn exit, the solution matrix.

`QRMethod`

methodThe type of QR factorization to perform.

Solves A*X=B for X using a previously QR factored matrix.
##### Parameters

Rows must be greater or equal to columns.

`Single[]`

qThe Q matrix obtained by calling QRFactor.

`Single[]`

rThe R matrix obtained by calling QRFactor.

`int`

rowsAThe number of rows in the A matrix.

`int`

columnsAThe number of columns in the A matrix.

`Single[]`

tauContains additional information on Q. Only used for the native solver
and can be `null`

for the managed provider.

`Single[]`

bThe B matrix.

`int`

columnsBThe number of columns of B.

`Single[]`

xOn exit, the solution matrix.

`QRMethod`

methodThe type of QR factorization to perform.

Solves A*X=B for X using a previously QR factored matrix.
##### Parameters

Rows must be greater or equal to columns.

`Complex32[]`

qThe Q matrix obtained by calling QRFactor.

`Complex32[]`

rThe R matrix obtained by calling QRFactor.

`int`

rowsAThe number of rows in the A matrix.

`int`

columnsAThe number of columns in the A matrix.

`Complex32[]`

tauContains additional information on Q. Only used for the native solver
and can be `null`

for the managed provider.

`Complex32[]`

bThe B matrix.

`int`

columnsBThe number of columns of B.

`Complex32[]`

xOn exit, the solution matrix.

`QRMethod`

methodThe type of QR factorization to perform.

Solves A*X=B for X using a previously QR factored matrix.
##### Parameters

Rows must be greater or equal to columns.

`Double[]`

qThe Q matrix obtained by calling QRFactor.

`Double[]`

rThe R matrix obtained by calling QRFactor.

`int`

rowsAThe number of rows in the A matrix.

`int`

columnsAThe number of columns in the A matrix.

`Double[]`

tau`null`

for the managed provider.

`Double[]`

bThe B matrix.

`int`

columnsBThe number of columns of B.

`Double[]`

xOn exit, the solution matrix.

`QRMethod`

methodThe type of QR factorization to perform.

Scales an array. Can be used to scale a vector and a matrix.
##### Parameters

This is similar to the SCAL BLAS routine.

`double`

alphaThe scalar.

`Double[]`

xThe values to scale.

`Double[]`

resultThis result of the scaling.

Scales an array. Can be used to scale a vector and a matrix.
##### Parameters

This is similar to the SCAL BLAS routine.

`float`

alphaThe scalar.

`Single[]`

xThe values to scale.

`Single[]`

resultThis result of the scaling.

Scales an array. Can be used to scale a vector and a matrix.
##### Parameters

This is similar to the SCAL BLAS routine.

`Complex`

alphaThe scalar.

`Complex[]`

xThe values to scale.

`Complex[]`

resultThis result of the scaling.

Scales an array. Can be used to scale a vector and a matrix.
##### Parameters

This is similar to the SCAL BLAS routine.

`Complex32`

alphaThe scalar.

`Complex32[]`

xThe values to scale.

`Complex32[]`

resultThis result of the scaling.

Computes the singular value decomposition of A.
##### Parameters

This is equivalent to the GESVD LAPACK routine.

`bool`

computeVectorsCompute the singular U and VT vectors or not.

`Single[]`

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

`int`

rowsAThe number of rows in the A matrix.

`int`

columnsAThe number of columns in the A matrix.

`Single[]`

sThe singular values of A in ascending value.

`Single[]`

uIf `computeVectors` is `true`

, on exit U contains the left
singular vectors.

`Single[]`

vtIf `computeVectors` is `true`

, on exit VT contains the transposed
right singular vectors.

Computes the singular value decomposition of A.
##### Parameters

This is equivalent to the GESVD LAPACK routine.

`bool`

computeVectorsCompute the singular U and VT vectors or not.

`Complex[]`

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

`int`

rowsAThe number of rows in the A matrix.

`int`

columnsAThe number of columns in the A matrix.

`Complex[]`

sThe singular values of A in ascending value.

`Complex[]`

uIf `computeVectors` is `true`

, on exit U contains the left
singular vectors.

`Complex[]`

vtIf `computeVectors` is `true`

, on exit VT contains the transposed
right singular vectors.

Computes the singular value decomposition of A.
##### Parameters

This is equivalent to the GESVD LAPACK routine.

`bool`

computeVectorsCompute the singular U and VT vectors or not.

`Complex32[]`

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

`int`

rowsAThe number of rows in the A matrix.

`int`

columnsAThe number of columns in the A matrix.

`Complex32[]`

sThe singular values of A in ascending value.

`Complex32[]`

uIf `computeVectors` is `true`

, on exit U contains the left
singular vectors.

`Complex32[]`

vtIf `computeVectors` is `true`

, on exit VT contains the transposed
right singular vectors.

Computes the singular value decomposition of A.
##### Parameters

This is equivalent to the GESVD LAPACK routine.

`bool`

computeVectorsCompute the singular U and VT vectors or not.

`Double[]`

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

`int`

rowsAThe number of rows in the A matrix.

`int`

columnsAThe number of columns in the A matrix.

`Double[]`

sThe singular values of A in ascending value.

`Double[]`

uIf `computeVectors` is `true`

, on exit U contains the left
singular vectors.

`Double[]`

vtIf `computeVectors` is `true`

, on exit VT contains the transposed
right singular vectors.

Does a point wise subtraction of two arrays
##### Parameters

`z = x - y`

. This can be used
to subtract vectors or matrices. `Complex32[]`

xThe array x.

`Complex32[]`

yThe array y.

`Complex32[]`

resultThe result of the subtraction.

Does a point wise subtraction of two arrays
##### Parameters

`z = x - y`

. This can be used
to subtract vectors or matrices. `Complex[]`

xThe array x.

`Complex[]`

yThe array y.

`Complex[]`

resultThe result of the subtraction.

Does a point wise subtraction of two arrays
##### Parameters

`z = x - y`

. This can be used
to subtract vectors or matrices. `Single[]`

xThe array x.

`Single[]`

yThe array y.

`Single[]`

resultThe result of the subtraction.

Does a point wise subtraction of two arrays
##### Parameters

`z = x - y`

. This can be used
to subtract vectors or matrices. `Double[]`

xThe array x.

`Double[]`

yThe array y.

`Double[]`

resultThe result of the subtraction.

Solves A*X=B for X using the singular value decomposition of A.
##### Parameters

`Complex32[]`

aOn entry, the M by N matrix to decompose.

`int`

rowsAThe number of rows in the A matrix.

`int`

columnsAThe number of columns in the A matrix.

`Complex32[]`

bThe B matrix.

`int`

columnsBThe number of columns of B.

`Complex32[]`

xOn exit, the solution matrix.

Solves A*X=B for X using the singular value decomposition of A.
##### Parameters

`Complex[]`

aOn entry, the M by N matrix to decompose.

`int`

rowsAThe number of rows in the A matrix.

`int`

columnsAThe number of columns in the A matrix.

`Complex[]`

bThe B matrix.

`int`

columnsBThe number of columns of B.

`Complex[]`

xOn exit, the solution matrix.

Solves A*X=B for X using the singular value decomposition of A.
##### Parameters

`Double[]`

aOn entry, the M by N matrix to decompose.

`int`

rowsAThe number of rows in the A matrix.

`int`

columnsAThe number of columns in the A matrix.

`Double[]`

bThe B matrix.

`int`

columnsBThe number of columns of B.

`Double[]`

xOn exit, the solution matrix.

Solves A*X=B for X using the singular value decomposition of A.
##### Parameters

`Single[]`

aOn entry, the M by N matrix to decompose.

`int`

rowsAThe number of rows in the A matrix.

`int`

columnsAThe number of columns in the A matrix.

`Single[]`

bThe B matrix.

`int`

columnsBThe number of columns of B.

`Single[]`

xOn exit, the solution matrix.

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

`int`

rowsAThe number of rows in the A matrix.

`int`

columnsAThe number of columns in the A matrix.

`Complex[]`

sThe s values returned by SingularValueDecomposition.

`Complex[]`

uThe left singular vectors returned by SingularValueDecomposition.

`Complex[]`

vtThe right singular vectors returned by SingularValueDecomposition.

`Complex[]`

bThe B matrix.

`int`

columnsBThe number of columns of B.

`Complex[]`

xOn exit, the solution matrix.

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

`int`

rowsAThe number of rows in the A matrix.

`int`

columnsAThe number of columns in the A matrix.

`Complex32[]`

sThe s values returned by SingularValueDecomposition.

`Complex32[]`

uThe left singular vectors returned by SingularValueDecomposition.

`Complex32[]`

vtThe right singular vectors returned by SingularValueDecomposition.

`Complex32[]`

bThe B matrix.

`int`

columnsBThe number of columns of B.

`Complex32[]`

xOn exit, the solution matrix.

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

`int`

rowsAThe number of rows in the A matrix.

`int`

columnsAThe number of columns in the A matrix.

`Double[]`

sThe s values returned by SingularValueDecomposition.

`Double[]`

uThe left singular vectors returned by SingularValueDecomposition.

`Double[]`

vtThe right singular vectors returned by SingularValueDecomposition.

`Double[]`

bThe B matrix.

`int`

columnsBThe number of columns of B.

`Double[]`

xOn exit, the solution matrix.

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

`int`

rowsAThe number of rows in the A matrix.

`int`

columnsAThe number of columns in the A matrix.

`Single[]`

sThe s values returned by SingularValueDecomposition.

`Single[]`

uThe left singular vectors returned by SingularValueDecomposition.

`Single[]`

vtThe right singular vectors returned by SingularValueDecomposition.

`Single[]`

bThe B matrix.

`int`

columnsBThe number of columns of B.

`Single[]`

xOn exit, the solution matrix.

Computes the QR factorization of A.
##### Parameters

This is similar to the GEQRF and ORGQR LAPACK routines.

`Double[]`

aOn 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`

rowsAThe number of rows in the A matrix.

`int`

columnsAThe number of columns in the A matrix.

`Double[]`

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

`Double[]`

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

Computes the QR factorization of A.
##### Parameters

This is similar to the GEQRF and ORGQR LAPACK routines.

`Complex32[]`

aOn 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`

rowsAThe number of rows in the A matrix.

`int`

columnsAThe number of columns in the A matrix.

`Complex32[]`

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

`Complex32[]`

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

Computes the QR factorization of A.
##### Parameters

This is similar to the GEQRF and ORGQR LAPACK routines.

`Single[]`

aOn 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`

rowsAThe number of rows in the A matrix.

`int`

columnsAThe number of columns in the A matrix.

`Single[]`

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

`Single[]`

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

Computes the QR factorization of A.
##### Parameters

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.

This is similar to the GEQRF and ORGQR LAPACK routines.

`Complex[]`

a`int`

rowsAThe number of rows in the A matrix.

`int`

columnsAThe number of columns in the A matrix.

`Complex[]`

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

`Complex[]`

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