Extreme Optimization™: Complexity made simple.

Math and Statistics
Libraries for .NET

  • Home
  • Features
    • Math Library
    • Vector and Matrix Library
    • Statistics Library
    • Performance
    • Usability
  • Documentation
    • Introduction
    • Math Library User's Guide
    • Vector and Matrix Library User's Guide
    • Data Analysis Library User's Guide
    • Statistics Library User's Guide
    • Reference
  • Resources
    • Downloads
    • QuickStart Samples
    • Sample Applications
    • Frequently Asked Questions
    • Technical Support
  • Blog
  • Order
  • Company
    • About us
    • Testimonials
    • Customers
    • Press Releases
    • Careers
    • Partners
    • Contact us
Introduction
Deployment Guide
Configuration
Using Parallelism
Expand Mathematics Library User's GuideMathematics Library User's Guide
Expand Vector and Matrix Library User's GuideVector and Matrix Library User's Guide
Expand Data Analysis Library User's GuideData Analysis Library User's Guide
Expand Statistics Library User's GuideStatistics Library User's Guide
Expand Data Access Library User's GuideData Access Library User's Guide
Expand ReferenceReference
  • Extreme Optimization
    • Features
    • Solutions
    • Documentation
    • QuickStart Samples
    • Sample Applications
    • Downloads
    • Technical Support
    • Download trial
    • How to buy
    • Blog
    • Company
    • Resources
  • Documentation
    • Introduction
    • Deployment Guide
    • Configuration
    • Using Parallelism
    • Mathematics Library User's Guide
    • Vector and Matrix Library User's Guide
    • Data Analysis Library User's Guide
    • Statistics Library User's Guide
    • Data Access Library User's Guide
    • Reference
  • Reference
    • Extreme
    • Extreme.Collections
    • Extreme.Data
    • Extreme.Data.Json
    • Extreme.Data.Matlab
    • Extreme.Data.R
    • Extreme.Data.Stata
    • Extreme.Data.Text
    • Extreme.DataAnalysis
    • Extreme.DataAnalysis.Linq
    • Extreme.Mathematics
    • Extreme.Mathematics.Algorithms
    • Extreme.Mathematics.Calculus
    • Extreme.Mathematics.Calculus.OrdinaryDifferentialEquations
    • Extreme.Mathematics.Curves
    • Extreme.Mathematics.Curves.Nonlinear
    • Extreme.Mathematics.Distributed
    • Extreme.Mathematics.Distributed.Cuda
    • Extreme.Mathematics.EquationSolvers
    • Extreme.Mathematics.FSharp
    • Extreme.Mathematics.Generic
    • Extreme.Mathematics.Generic.LinearAlgebra
    • Extreme.Mathematics.Generic.LinearAlgebra.Implementation
    • Extreme.Mathematics.Generic.LinearAlgebra.Providers
    • Extreme.Mathematics.Generic.SignalProcessing
    • Extreme.Mathematics.Implementation
    • Extreme.Mathematics.LinearAlgebra
    • Extreme.Mathematics.LinearAlgebra.Complex
    • Extreme.Mathematics.LinearAlgebra.Complex.Decompositions
    • Extreme.Mathematics.LinearAlgebra.Implementation
    • Extreme.Mathematics.LinearAlgebra.IO
    • Extreme.Mathematics.LinearAlgebra.IterativeSolvers
    • Extreme.Mathematics.LinearAlgebra.IterativeSolvers.Preconditioners
    • Extreme.Mathematics.LinearAlgebra.Providers
    • Extreme.Mathematics.LinearAlgebra.Sparse
    • Extreme.Mathematics.Optimization
    • Extreme.Mathematics.Optimization.Genetic
    • Extreme.Mathematics.Optimization.LineSearches
    • Extreme.Mathematics.Random
    • Extreme.Mathematics.SignalProcessing
    • Extreme.Numerics.FSharp
    • Extreme.Statistics
    • Extreme.Statistics.Distributions
    • Extreme.Statistics.IO
    • Extreme.Statistics.Linq
    • Extreme.Statistics.Multivariate
    • Extreme.Statistics.Random
    • Extreme.Statistics.Tests
    • Extreme.Statistics.TimeSeriesAnalysis
  • Extreme.Mathematics.LinearAlgebra.Implementation
    • DecompositionOperations(T) Class
    • DecompositionOperations(TReal, TComplex) Class
    • GenericDecompositionOperations(T) Class
    • GenericLinearAlgebraOperations(T) Class
    • GenericSparseLinearAlgebraOperations(T) Class
    • IArrayFunctions(T, TShape, TArray) Interface
    • ILinearAlgebraOperations(T) Interface
    • ILinearAlgebraOperations(T, TVector, TMatrix) Interface
    • ISparseLinearAlgebraOperations(T) Interface
    • IVectorFunctions(T) Interface
    • LinearAlgebraOperations(T) Class
    • ManagedArrayFunctions Class
    • ManagedArrayFunctions(T) Class
    • ManagedArrayFunctionsOfSingle Class
    • ManagedLapack Class
    • ManagedLapackOfSingle Class
    • ManagedLinearAlgebraOperations Class
    • ManagedLinearAlgebraOperationsOfSingle Class
    • ManagedSparseLinearAlgebraOperations Class
    • ManagedSparseLinearAlgebraOperationsOfSingle Class
    • SparseLinearAlgebraOperations Class
    • SparseLinearAlgebraOperations(T) Class
    • SparseLinearAlgebraOperationsOfSingle Class
  • ManagedLapack Class
    • Properties
    • Methods
  • Methods
    • BandCholeskyDecompose Method Overloads
    • BandCholeskyEstimateCondition Method Overloads
    • BandCholeskySolve Method Overloads
    • BandLUDecompose Method Overloads
    • BandLUEstimateCondition Method Overloads
    • BandLUSolve Method Overloads
    • BandTriangularSolve Method
    • CholeskyDecompose Method Overloads
    • CholeskyEstimateCondition Method Overloads
    • CholeskyInvert Method Overloads
    • CholeskySolve Method Overloads
    • EigenvalueDecompose Method Overloads
    • GeneralizedEigenvalueDecompose Method Overloads
    • GeneralizedSingularValueDecompose Method Overloads
    • HermitianDecompose Method Overloads
    • HermitianEigenvalueDecompose Method Overloads
    • HermitianEstimateCondition Method Overloads
    • HermitianGeneralizedEigenvalueDecompose Method
    • HermitianInvert Method Overloads
    • HermitianSolve Method Overloads
    • LQDecompose Method Overloads
    • LQOrthogonalMultiply Method
    • LQUnitaryMultiply Method
    • LUDecompose Method Overloads
    • LUEstimateCondition Method Overloads
    • LUInvert Method Overloads
    • LUSolve Method Overloads
    • QLDecompose Method Overloads
    • QLOrthogonalMultiply Method
    • QLUnitaryMultiply Method
    • QRDecompose Method Overloads
    • QROrthogonalMultiply Method
    • QRUnitaryMultiply Method Overloads
    • RQDecompose Method Overloads
    • RQOrthogonalMultiply Method
    • RQUnitaryMultiply Method
    • SingularValueDecompose Method Overloads
    • SymmetricDecompose Method
    • SymmetricEigenvalueDecompose Method
    • SymmetricEstimateCondition Method
    • SymmetricGeneralizedEigenvalueDecompose Method
    • SymmetricInvert Method
    • SymmetricSolve Method
    • TriangularEstimateCondition Method Overloads
    • TriangularInvert Method Overloads
    • TriangularSolve Method Overloads
ManagedLapack MethodsExtreme Optimization Numerical Libraries for .NET Professional

The ManagedLapack type exposes the following members.

Methods

  NameDescription
Public methodBandCholeskyDecompose(MatrixTriangle, Int32, Int32, Array2DComplexDouble, Int32)

Computes the Cholesky factorization of a complex Hermitian positive definite band matrix A.

(Overrides DecompositionOperationsTReal, TComplexBandCholeskyDecompose(MatrixTriangle, Int32, Int32, Array2DTComplex, Int32).)
Public methodBandCholeskyDecompose(MatrixTriangle, Int32, Int32, Array2DDouble, Int32)

Computes the Cholesky factorization of a real symmetric positive definite band matrix A.

(Overrides DecompositionOperationsTReal, TComplexBandCholeskyDecompose(MatrixTriangle, Int32, Int32, Array2DTComplex, Int32).)
Public methodBandCholeskyDecompose(MatrixTriangle, Int32, Int32, Array2DDoubleComplex, Int32)

Computes the Cholesky factorization of a complex Hermitian positive definite band matrix A.

(Overrides DecompositionOperationsTReal, TComplexBandCholeskyDecompose(MatrixTriangle, Int32, Int32, Array2DTComplex, Int32).)
Public methodBandCholeskyEstimateCondition(MatrixTriangle, Int32, Int32, Array2DComplexDouble, Double, Double, Int32)

Estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite band matrix using the Cholesky factorization A = UH*U or A = L*LH computed by ZPBTRF.

(Overrides DecompositionOperationsTReal, TComplexBandCholeskyEstimateCondition(MatrixTriangle, Int32, Int32, Array2DTComplex, TReal, TReal, Int32).)
Public methodBandCholeskyEstimateCondition(MatrixTriangle, Int32, Int32, Array2DDouble, Double, Double, Int32)

Estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite band matrix using the Cholesky factorization A = UT*U or A = L*LT computed by DPBTRF.

(Overrides DecompositionOperationsTReal, TComplexBandCholeskyEstimateCondition(MatrixTriangle, Int32, Int32, Array2DTComplex, TReal, TReal, Int32).)
Public methodBandCholeskyEstimateCondition(MatrixTriangle, Int32, Int32, Array2DDoubleComplex, Double, Double, Int32)

Estimates the reciprocal of the condition number (in the 1-norm) of a complex Hermitian positive definite band matrix using the Cholesky factorization A = UH*U or A = L*LH computed by ZPBTRF.

(Overrides DecompositionOperationsTReal, TComplexBandCholeskyEstimateCondition(MatrixTriangle, Int32, Int32, Array2DTComplex, TReal, TReal, Int32).)
Public methodBandCholeskySolve(MatrixTriangle, Int32, Int32, Int32, Array2DComplexDouble, Array2DComplexDouble, Int32)

Solves a system of linear equations A*X = B with a Hermitian positive definite band matrix A using the Cholesky factorization A = UH *U or A = L*LH computed by ZPBTRF.

(Overrides DecompositionOperationsTReal, TComplexBandCholeskySolve(MatrixTriangle, Int32, Int32, Int32, Array2DTComplex, Array2DTComplex, Int32).)
Public methodBandCholeskySolve(MatrixTriangle, Int32, Int32, Int32, Array2DDouble, Array2DDouble, Int32)

Solves a system of linear equations A*X = B with a symmetric positive definite band matrix A using the Cholesky factorization A = UT*U or A = L*LT computed by DPBTRF.

(Overrides DecompositionOperationsTReal, TComplexBandCholeskySolve(MatrixTriangle, Int32, Int32, Int32, Array2DTComplex, Array2DTComplex, Int32).)
Public methodBandCholeskySolve(MatrixTriangle, Int32, Int32, Int32, Array2DDoubleComplex, Array2DDoubleComplex, Int32)

Solves a system of linear equations A*X = B with a Hermitian positive definite band matrix A using the Cholesky factorization A = UH *U or A = L*LH computed by ZPBTRF.

(Overrides DecompositionOperationsTReal, TComplexBandCholeskySolve(MatrixTriangle, Int32, Int32, Int32, Array2DTComplex, Array2DTComplex, Int32).)
Public methodBandLUDecompose(Int32, Int32, Int32, Int32, Array2DComplexDouble, Array1DInt32, Int32)

Computes an LU factorization of a complex m-by-n band matrix A using partial pivoting with row interchanges.

(Overrides DecompositionOperationsTReal, TComplexBandLUDecompose(Int32, Int32, Int32, Int32, Array2DTComplex, Array1DInt32, Int32).)
Public methodBandLUDecompose(Int32, Int32, Int32, Int32, Array2DDouble, Array1DInt32, Int32)

Computes an LU factorization of a real m-by-n band matrix A using partial pivoting with row interchanges.

(Overrides DecompositionOperationsTReal, TComplexBandLUDecompose(Int32, Int32, Int32, Int32, Array2DTComplex, Array1DInt32, Int32).)
Public methodBandLUDecompose(Int32, Int32, Int32, Int32, Array2DDoubleComplex, Array1DInt32, Int32)

Computes an LU factorization of a complex m-by-n band matrix A using partial pivoting with row interchanges.

(Overrides DecompositionOperationsTReal, TComplexBandLUDecompose(Int32, Int32, Int32, Int32, Array2DTComplex, Array1DInt32, Int32).)
Public methodBandLUEstimateCondition(MatrixNorm, Int32, Int32, Int32, Array2DComplexDouble, Array1DInt32, Double, Double, Int32)

Estimates the reciprocal of the condition number of a complex general band matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by ZGBTRF.

(Overrides DecompositionOperationsTReal, TComplexBandLUEstimateCondition(MatrixNorm, Int32, Int32, Int32, Array2DTComplex, Array1DInt32, TReal, TReal, Int32).)
Public methodBandLUEstimateCondition(MatrixNorm, Int32, Int32, Int32, Array2DDouble, Array1DInt32, Double, Double, Int32)

Estimates the reciprocal of the condition number of a real general band matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by DGBTRF.

(Overrides DecompositionOperationsTReal, TComplexBandLUEstimateCondition(MatrixNorm, Int32, Int32, Int32, Array2DTComplex, Array1DInt32, TReal, TReal, Int32).)
Public methodBandLUEstimateCondition(MatrixNorm, Int32, Int32, Int32, Array2DDoubleComplex, Array1DInt32, Double, Double, Int32)

Estimates the reciprocal of the condition number of a complex general band matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by ZGBTRF.

(Overrides DecompositionOperationsTReal, TComplexBandLUEstimateCondition(MatrixNorm, Int32, Int32, Int32, Array2DTComplex, Array1DInt32, TReal, TReal, Int32).)
Public methodBandLUSolve(TransposeOperation, Int32, Int32, Int32, Int32, Array2DComplexDouble, Array1DInt32, Array2DComplexDouble, Int32)

Solves a system of linear equations A * X = B, AT * X = B, or AH * X = B with a general band matrix A using the LU factorization computed by ZGBTRF.

(Overrides DecompositionOperationsTReal, TComplexBandLUSolve(TransposeOperation, Int32, Int32, Int32, Int32, Array2DTComplex, Array1DInt32, Array2DTComplex, Int32).)
Public methodBandLUSolve(TransposeOperation, Int32, Int32, Int32, Int32, Array2DDouble, Array1DInt32, Array2DDouble, Int32)

Solves a system of linear equations A * X = B or AT * X = B with a general band matrix A using the LU factorization computed by DGBTRF.

(Overrides DecompositionOperationsTReal, TComplexBandLUSolve(TransposeOperation, Int32, Int32, Int32, Int32, Array2DTComplex, Array1DInt32, Array2DTComplex, Int32).)
Public methodBandLUSolve(TransposeOperation, Int32, Int32, Int32, Int32, Array2DDoubleComplex, Array1DInt32, Array2DDoubleComplex, Int32)

Solves a system of linear equations A * X = B, AT * X = B, or AH * X = B with a general band matrix A using the LU factorization computed by ZGBTRF.

(Overrides DecompositionOperationsTReal, TComplexBandLUSolve(TransposeOperation, Int32, Int32, Int32, Int32, Array2DTComplex, Array1DInt32, Array2DTComplex, Int32).)
Public methodBandTriangularSolve

Solves a triangular system of the form A * X = B or AT * X = B, where A is a triangular band matrix of order N, and B is an N-by NRHS matrix.

(Overrides DecompositionOperationsTReal, TComplexBandTriangularSolve(MatrixTriangle, TransposeOperation, MatrixDiagonal, Int32, Int32, Int32, Array2DTReal, Array2DTReal, Int32).)
Public methodCholeskyDecompose(MatrixTriangle, Int32, Array2DComplexDouble, Int32)
Factors a symmetric positive definite matrix.
(Overrides DecompositionOperationsTReal, TComplexCholeskyDecompose(MatrixTriangle, Int32, Array2DTComplex, Int32).)
Public methodCholeskyDecompose(MatrixTriangle, Int32, Array2DDouble, Int32)

Computes the Cholesky factorization of a real symmetric positive definite matrix A.

(Overrides DecompositionOperationsTReal, TComplexCholeskyDecompose(MatrixTriangle, Int32, Array2DTComplex, Int32).)
Public methodCholeskyDecompose(MatrixTriangle, Int32, Array2DDoubleComplex, Int32)
Factors a symmetric positive definite matrix.
(Overrides DecompositionOperationsTReal, TComplexCholeskyDecompose(MatrixTriangle, Int32, Array2DTComplex, Int32).)
Public methodCholeskyEstimateCondition(MatrixTriangle, Int32, Array2DComplexDouble, Double, Double, Int32)
Estimates the reciprocal of the condition number of a factored hermitian matrix.
(Overrides DecompositionOperationsTReal, TComplexCholeskyEstimateCondition(MatrixTriangle, Int32, Array2DTComplex, TReal, TReal, Int32).)
Public methodCholeskyEstimateCondition(MatrixTriangle, Int32, Array2DDouble, Double, Double, Int32)

Estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric positive definite matrix using the Cholesky factorization A = UT*U or A = L*LT computed by DPOTRF.

(Overrides DecompositionOperationsTReal, TComplexCholeskyEstimateCondition(MatrixTriangle, Int32, Array2DTComplex, TReal, TReal, Int32).)
Public methodCholeskyEstimateCondition(MatrixTriangle, Int32, Array2DDoubleComplex, Double, Double, Int32)
Estimates the reciprocal of the condition number of a factored hermitian matrix.
(Overrides DecompositionOperationsTReal, TComplexCholeskyEstimateCondition(MatrixTriangle, Int32, Array2DTComplex, TReal, TReal, Int32).)
Public methodCholeskyInvert(MatrixTriangle, Int32, Array2DComplexDouble, Int32)
Computes the inverse of a factored hermitian matrix.
(Overrides DecompositionOperationsTReal, TComplexCholeskyInvert(MatrixTriangle, Int32, Array2DTComplex, Int32).)
Public methodCholeskyInvert(MatrixTriangle, Int32, Array2DDouble, Int32)

Computes the inverse of a real symmetric positive definite matrix A using the Cholesky factorization A = UT*U or A = L*LT computed by DPOTRF.

(Overrides DecompositionOperationsTReal, TComplexCholeskyInvert(MatrixTriangle, Int32, Array2DTComplex, Int32).)
Public methodCholeskyInvert(MatrixTriangle, Int32, Array2DDoubleComplex, Int32)
Computes the inverse of a factored hermitian matrix.
(Overrides DecompositionOperationsTReal, TComplexCholeskyInvert(MatrixTriangle, Int32, Array2DTComplex, Int32).)
Public methodCholeskySolve(MatrixTriangle, Int32, Int32, Array2DComplexDouble, Array2DComplexDouble, Int32)
Solves a hermitian system of equations.
(Overrides DecompositionOperationsTReal, TComplexCholeskySolve(MatrixTriangle, Int32, Int32, Array2DTComplex, Array2DTComplex, Int32).)
Public methodCholeskySolve(MatrixTriangle, Int32, Int32, Array2DDouble, Array2DDouble, Int32)

Solves a system of linear equations A*X = B with a symmetric positive definite matrix A using the Cholesky factorization A = UT*U or A = L*LT computed by DPOTRF.

(Overrides DecompositionOperationsTReal, TComplexCholeskySolve(MatrixTriangle, Int32, Int32, Array2DTComplex, Array2DTComplex, Int32).)
Public methodCholeskySolve(MatrixTriangle, Int32, Int32, Array2DDoubleComplex, Array2DDoubleComplex, Int32)
Solves a hermitian system of equations.
(Overrides DecompositionOperationsTReal, TComplexCholeskySolve(MatrixTriangle, Int32, Int32, Array2DTComplex, Array2DTComplex, Int32).)
Public methodEigenvalueDecompose(Char, Char, Int32, Array2DComplexDouble, Array1DComplexDouble, Array2DComplexDouble, Array2DComplexDouble, Int32)

Computes for an N-by-N complex non-symmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors.

(Overrides DecompositionOperationsTReal, TComplexEigenvalueDecompose(Char, Char, Int32, Array2DTComplex, Array1DTComplex, Array2DTComplex, Array2DTComplex, Int32).)
Public methodEigenvalueDecompose(Char, Char, Int32, Array2DDoubleComplex, Array1DDoubleComplex, Array2DDoubleComplex, Array2DDoubleComplex, Int32)

Computes for an N-by-N complex nonsymmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors.

(Overrides DecompositionOperationsTReal, TComplexEigenvalueDecompose(Char, Char, Int32, Array2DTComplex, Array1DTComplex, Array2DTComplex, Array2DTComplex, Int32).)
Public methodEigenvalueDecompose(Char, Char, Int32, Array2DDouble, Array1DDouble, Array1DDouble, Array2DDouble, Array2DDouble, Int32)

Computes for an N-by-N real non-symmetric matrix A, the eigenvalues and, optionally, the left and/or right eigenvectors.

(Overrides DecompositionOperationsTReal, TComplexEigenvalueDecompose(Char, Char, Int32, Array2DTReal, Array1DTReal, Array1DTReal, Array2DTReal, Array2DTReal, Int32).)
Public methodEquals
Determines whether the specified Object is equal to the current Object.
(Inherited from Object.)
Public methodGeneralizedEigenvalueDecompose(Char, Char, Int32, Array2DComplexDouble, Array2DComplexDouble, Array1DComplexDouble, Array1DComplexDouble, Array2DComplexDouble, Array2DComplexDouble, Int32)

Computes for a pair of N-by-N complex nonsymmetric matrices (A,B), the generalized eigenvalues, and optionally, the left and/or right generalized eigenvectors.

(Overrides DecompositionOperationsTReal, TComplexGeneralizedEigenvalueDecompose(Char, Char, Int32, Array2DTComplex, Array2DTComplex, Array1DTComplex, Array1DTComplex, Array2DTComplex, Array2DTComplex, Int32).)
Public methodGeneralizedEigenvalueDecompose(Char, Char, Int32, Array2DDouble, Array2DDouble, Array1DDouble, Array1DDouble, Array1DDouble, Array2DDouble, Array2DDouble, Int32)

Computes for a pair of N-by-N real nonsymmetric matrices (A,B) the generalized eigenvalues, and optionally, the left and/or right generalized eigenvectors.

(Overrides DecompositionOperationsTReal, TComplexGeneralizedEigenvalueDecompose(Char, Char, Int32, Array2DTReal, Array2DTReal, Array1DTReal, Array1DTReal, Array1DTReal, Array2DTReal, Array2DTReal, Int32).)
Public methodGeneralizedSingularValueDecompose(Char, Char, Char, Int32, Int32, Int32, Int32, Int32, Array2DComplexDouble, Array2DComplexDouble, Array1DDouble, Array1DDouble, Array2DComplexDouble, Array2DComplexDouble, Array2DComplexDouble, Array1DInt32, Int32) (Overrides DecompositionOperationsTReal, TComplexGeneralizedSingularValueDecompose(Char, Char, Char, Int32, Int32, Int32, Int32, Int32, Array2DTComplex, Array2DTComplex, Array1DTReal, Array1DTReal, Array2DTComplex, Array2DTComplex, Array2DTComplex, Array1DInt32, Int32).)
Public methodGeneralizedSingularValueDecompose(Char, Char, Char, Int32, Int32, Int32, Int32, Int32, Array2DDouble, Array2DDouble, Array1DDouble, Array1DDouble, Array2DDouble, Array2DDouble, Array2DDouble, Array1DInt32, Int32) (Overrides DecompositionOperationsTReal, TComplexGeneralizedSingularValueDecompose(Char, Char, Char, Int32, Int32, Int32, Int32, Int32, Array2DTComplex, Array2DTComplex, Array1DTReal, Array1DTReal, Array2DTComplex, Array2DTComplex, Array2DTComplex, Array1DInt32, Int32).)
Public methodGetHashCode
Serves as a hash function for a particular type.
(Inherited from Object.)
Public methodGetType
Gets the Type of the current instance.
(Inherited from Object.)
Public methodHermitianDecompose(MatrixTriangle, Int32, Array2DComplexDouble, Array1DInt32, Int32)

Computes the factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method.

(Overrides DecompositionOperationsTReal, TComplexHermitianDecompose(MatrixTriangle, Int32, Array2DTComplex, Array1DInt32, Int32).)
Public methodHermitianDecompose(MatrixTriangle, Int32, Array2DDoubleComplex, Array1DInt32, Int32)

Computes the factorization of a complex Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method.

(Overrides DecompositionOperationsTReal, TComplexHermitianDecompose(MatrixTriangle, Int32, Array2DTComplex, Array1DInt32, Int32).)
Public methodHermitianEigenvalueDecompose(Char, MatrixTriangle, Int32, Array2DComplexDouble, Array1DDouble, Int32)

Computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A.

(Overrides DecompositionOperationsTReal, TComplexHermitianEigenvalueDecompose(Char, MatrixTriangle, Int32, Array2DTComplex, Array1DTReal, Int32).)
Public methodHermitianEigenvalueDecompose(Char, MatrixTriangle, Int32, Array2DDoubleComplex, Array1DDouble, Int32)

Computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A.

(Overrides DecompositionOperationsTReal, TComplexHermitianEigenvalueDecompose(Char, MatrixTriangle, Int32, Array2DTComplex, Array1DTReal, Int32).)
Public methodHermitianEstimateCondition(MatrixTriangle, Int32, Array2DComplexDouble, Array1DInt32, Double, Double, Int32)

Estimates the reciprocal of the condition number of a complex Hermitian matrix A using the factorization A = U*D*UH or A = L*D*LH computed by ZHETRF.

(Overrides DecompositionOperationsTReal, TComplexHermitianEstimateCondition(MatrixTriangle, Int32, Array2DTComplex, Array1DInt32, TReal, TReal, Int32).)
Public methodHermitianEstimateCondition(MatrixTriangle, Int32, Array2DDoubleComplex, Array1DInt32, Double, Double, Int32)

Estimates the reciprocal of the condition number of a complex Hermitian matrix A using the factorization A = U*D*UH or A = L*D*LH computed by ZHETRF.

(Overrides DecompositionOperationsTReal, TComplexHermitianEstimateCondition(MatrixTriangle, Int32, Array2DTComplex, Array1DInt32, TReal, TReal, Int32).)
Public methodHermitianGeneralizedEigenvalueDecompose

Computes selected eigenvalues, and optionally, eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x.

(Overrides DecompositionOperationsTReal, TComplexHermitianGeneralizedEigenvalueDecompose(Int32, Char, MatrixTriangle, Int32, Array2DTComplex, Array2DTComplex, Array1DTReal, Int32).)
Public methodHermitianInvert(MatrixTriangle, Int32, Array2DComplexDouble, Array1DInt32, Int32)

Computes the inverse of a complex Hermitian indefinite matrix A using the factorization A = U*D*UH or A = L*D*LH computed by ZHETRF.

(Overrides DecompositionOperationsTReal, TComplexHermitianInvert(MatrixTriangle, Int32, Array2DTComplex, Array1DInt32, Int32).)
Public methodHermitianInvert(MatrixTriangle, Int32, Array2DDoubleComplex, Array1DInt32, Int32)

Computes the inverse of a complex Hermitian indefinite matrix A using the factorization A = U*D*UH or A = L*D*LH computed by ZHETRF.

(Overrides DecompositionOperationsTReal, TComplexHermitianInvert(MatrixTriangle, Int32, Array2DTComplex, Array1DInt32, Int32).)
Public methodHermitianSolve(MatrixTriangle, Int32, Int32, Array2DComplexDouble, Array1DInt32, Array2DComplexDouble, Int32)

Solves a system of linear equations A*X = B with a complex Hermitian matrix A using the factorization A = U*D*UH or A = L*D*LH computed by ZHETRF.

(Overrides DecompositionOperationsTReal, TComplexHermitianSolve(MatrixTriangle, Int32, Int32, Array2DTComplex, Array1DInt32, Array2DTComplex, Int32).)
Public methodHermitianSolve(MatrixTriangle, Int32, Int32, Array2DDoubleComplex, Array1DInt32, Array2DDoubleComplex, Int32)

Solves a system of linear equations A*X = B with a complex Hermitian matrix A using the factorization A = U*D*UH or A = L*D*LH computed by ZHETRF.

(Overrides DecompositionOperationsTReal, TComplexHermitianSolve(MatrixTriangle, Int32, Int32, Array2DTComplex, Array1DInt32, Array2DTComplex, Int32).)
Public methodLQDecompose(Int32, Int32, Array2DComplexDouble, Array1DComplexDouble, Int32)

Computes an LQ factorization of a complex M-by-N matrix A: A = L * Q.

(Overrides DecompositionOperationsTReal, TComplexLQDecompose(Int32, Int32, Array2DTComplex, Array1DTComplex, Int32).)
Public methodLQDecompose(Int32, Int32, Array2DDouble, Array1DDouble, Int32)

Computes an LQ factorization of a complex M-by-N matrix A: A = L * Q.

(Overrides DecompositionOperationsTReal, TComplexLQDecompose(Int32, Int32, Array2DTComplex, Array1DTComplex, Int32).)
Public methodLQOrthogonalMultiply

Overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q**T * C C * Q**T where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(k) .

(Overrides DecompositionOperationsTReal, TComplexLQOrthogonalMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Array2DTReal, Array1DTReal, Array2DTReal, Int32).)
Public methodLQUnitaryMultiply

Overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q**H * C C * Q**H where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(k)**H .

(Overrides DecompositionOperationsTReal, TComplexLQUnitaryMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Array2DTComplex, Array1DTComplex, Array2DTComplex, Int32).)
Public methodLUDecompose(Int32, Int32, Array2DComplexDouble, Array1DInt32, Int32)
ZGETRF computes an LU decomposition of a general M-by-N matrix A using partial pivoting with row interchanges.

The decomposition has the form

A = P * L * U

where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n).

This is the right-looking Level 3 BLAS version of the algorithm.

(Overrides DecompositionOperationsTReal, TComplexLUDecompose(Int32, Int32, Array2DTComplex, Array1DInt32, Int32).)
Public methodLUDecompose(Int32, Int32, Array2DDouble, Array1DInt32, Int32)

Computes an LU factorization of a general M-by-N matrix A using partial pivoting with row interchanges.

(Overrides DecompositionOperationsTReal, TComplexLUDecompose(Int32, Int32, Array2DTComplex, Array1DInt32, Int32).)
Public methodLUDecompose(Int32, Int32, Array2DDoubleComplex, Array1DInt32, Int32)
ZGETRF computes an LU decomposition of a general M-by-N matrix A using partial pivoting with row interchanges.

The decomposition has the form

A = P * L * U

where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n).

This is the right-looking Level 3 BLAS version of the algorithm.

(Overrides DecompositionOperationsTReal, TComplexLUDecompose(Int32, Int32, Array2DTComplex, Array1DInt32, Int32).)
Public methodLUEstimateCondition(MatrixNorm, Int32, Array2DComplexDouble, Double, Double, Int32)
ZGECON estimates the reciprocal of the condition number of a general real matrix A, inthis. either the 1-norm or the infinity-norm, using the LU decomposition computed by ZGETRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ). Arguments ========= NORM (input) CHARACTER*1 Specifies whether the 1-norm condition number or the infinity-norm condition number is required: = '1' or 'O': 1-norm; = 'I': Infinity-norm. N (input) INTEGER The elementOrder of the matrix A. N >= 0. A (input) ZOUBLE PRECISION array, dimension (LDA,N) The factors L and U from the decomposition A = P*L*U as computed by ZGETRF. LDA (input) INTEGER The leading dimension of the array A. LDA >= Max(1,N). ANORM (input) ZOUBLE PRECISION If NORM = '1' or 'O', the 1-norm of the original matrix A. If NORM = 'I', the infinity-norm of the original matrix A. RCOND (output) ZOUBLE PRECISION The reciprocal of the condition number of the matrix A, computed as RCOND = 1/(norm(A) * norm(inv(A))). WORK (workspace) ZOUBLE PRECISION array, dimension (4*N) IWORK (workspace) INTEGER array, dimension (N) INFO (output) INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
(Overrides DecompositionOperationsTReal, TComplexLUEstimateCondition(MatrixNorm, Int32, Array2DTComplex, TReal, TReal, Int32).)
Public methodLUEstimateCondition(MatrixNorm, Int32, Array2DDouble, Double, Double, Int32)

Estimates the reciprocal of the condition number of a general real matrix A, in either the 1-norm or the infinity-norm, using the LU factorization computed by DGETRF.

(Overrides DecompositionOperationsTReal, TComplexLUEstimateCondition(MatrixNorm, Int32, Array2DTComplex, TReal, TReal, Int32).)
Public methodLUEstimateCondition(MatrixNorm, Int32, Array2DDoubleComplex, Double, Double, Int32)
ZGECON estimates the reciprocal of the condition number of a general real matrix A, inthis. either the 1-norm or the infinity-norm, using the LU decomposition computed by ZGETRF. An estimate is obtained for norm(inv(A)), and the reciprocal of the condition number is computed as RCOND = 1 / ( norm(A) * norm(inv(A)) ). Arguments ========= NORM (input) CHARACTER*1 Specifies whether the 1-norm condition number or the infinity-norm condition number is required: = '1' or 'O': 1-norm; = 'I': Infinity-norm. N (input) INTEGER The elementOrder of the matrix A. N >= 0. A (input) ZOUBLE PRECISION array, dimension (LDA,N) The factors L and U from the decomposition A = P*L*U as computed by ZGETRF. LDA (input) INTEGER The leading dimension of the array A. LDA >= Max(1,N). ANORM (input) ZOUBLE PRECISION If NORM = '1' or 'O', the 1-norm of the original matrix A. If NORM = 'I', the infinity-norm of the original matrix A. RCOND (output) ZOUBLE PRECISION The reciprocal of the condition number of the matrix A, computed as RCOND = 1/(norm(A) * norm(inv(A))). WORK (workspace) ZOUBLE PRECISION array, dimension (4*N) IWORK (workspace) INTEGER array, dimension (N) INFO (output) INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value
(Overrides DecompositionOperationsTReal, TComplexLUEstimateCondition(MatrixNorm, Int32, Array2DTComplex, TReal, TReal, Int32).)
Public methodLUInvert(Int32, Array2DComplexDouble, Array1DInt32, Int32)
ZGETRI computes the inverse of a matrix using the LU decomposition computed by ZGETRF. This method inverts U and then computes inv(A) by solving the system inv(A)*L = inv(U) for inv(A). Arguments ========= N (input) INTEGER The elementOrder of the matrix A. N >= 0. A (input/output) ZOUBLE PRECISION array, dimension (LDA,N) On entry, the factors L and U from the decomposition A = P*L*U as computed by ZGETRF. On exit, if INFO = 0, the inverse of the original matrix A. LDA (input) INTEGER The leading dimension of the array A. LDA >= Max(1,N). IPIV (input) INTEGER array, dimension (N) The pivot indexes from ZGETRF; for 1< =i< =N, row i of the matrix was interchanged with row IPIVi. WORK (workspace/output) ZOUBLE PRECISION array, dimension (LWORK) On exit, if INFO =0, then WORK(1) returns the optimal LWORK. LWORK (input) INTEGER The dimension of the array WORK. LWORK >= Max(1,N). For optimal performance LWORK >= N*NB, where NB is the optimal blocksize returned by ILAENV. If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA. INFO (output) INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, U(i,i) is exactly zero; the matrix is singular and its inverse could not be computed.
(Overrides DecompositionOperationsTReal, TComplexLUInvert(Int32, Array2DTComplex, Array1DInt32, Int32).)
Public methodLUInvert(Int32, Array2DDouble, Array1DInt32, Int32)

Computes the inverse of a matrix using the LU factorization computed by DGETRF.

(Overrides DecompositionOperationsTReal, TComplexLUInvert(Int32, Array2DTComplex, Array1DInt32, Int32).)
Public methodLUInvert(Int32, Array2DDoubleComplex, Array1DInt32, Int32)
ZGETRI computes the inverse of a matrix using the LU decomposition computed by ZGETRF. This method inverts U and then computes inv(A) by solving the system inv(A)*L = inv(U) for inv(A). Arguments ========= N (input) INTEGER The elementOrder of the matrix A. N >= 0. A (input/output) ZOUBLE PRECISION array, dimension (LDA,N) On entry, the factors L and U from the decomposition A = P*L*U as computed by ZGETRF. On exit, if INFO = 0, the inverse of the original matrix A. LDA (input) INTEGER The leading dimension of the array A. LDA >= Max(1,N). IPIV (input) INTEGER array, dimension (N) The pivot indexes from ZGETRF; for 1< =i< =N, row i of the matrix was interchanged with row IPIVi. WORK (workspace/output) ZOUBLE PRECISION array, dimension (LWORK) On exit, if INFO =0, then WORK(1) returns the optimal LWORK. LWORK (input) INTEGER The dimension of the array WORK. LWORK >= Max(1,N). For optimal performance LWORK >= N*NB, where NB is the optimal blocksize returned by ILAENV. If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA. INFO (output) INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = i, U(i,i) is exactly zero; the matrix is singular and its inverse could not be computed.
(Overrides DecompositionOperationsTReal, TComplexLUInvert(Int32, Array2DTComplex, Array1DInt32, Int32).)
Public methodLUSolve(TransposeOperation, Int32, Int32, Array2DComplexDouble, Array1DInt32, Array2DComplexDouble, Int32)
ZGETRS solves a system of linear equations A * X = B or A' * X = B with a general N-by-N matrix A using the LU decomposition computed by ZGETRF. Arguments ========= TRANS (input) CHARACTER*1 Specifies the form of the system of equations: = 'N': A * X = B (No transpose) = TransposeOperation.Transpose: A'* X = B (Transpose) = 'C': A'* X = B (Conjugate transpose = Transpose) N (input) INTEGER The elementOrder of the matrix A. N >= 0. NRHS (input) INTEGER The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0. A (input) ZOUBLE PRECISION array, dimension (LDA,N) The factors L and U from the decomposition A = P*L*U as computed by ZGETRF. LDA (input) INTEGER The leading dimension of the array A. LDA >= Max(1,N). IPIV (input) INTEGER array, dimension (N) The pivot indexes from ZGETRF; for 1< =i< =N, row i of the matrix was interchanged with row IPIVi. B (input/output) ZOUBLE PRECISION array, dimension (LDB,NRHS) On entry, the right hand side matrix B. On exit, the solution matrix X. LDB (input) INTEGER The leading dimension of the array B. LDB >= Max(1,N). INFO (output) INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value =====================================================================
(Overrides DecompositionOperationsTReal, TComplexLUSolve(TransposeOperation, Int32, Int32, Array2DTComplex, Array1DInt32, Array2DTComplex, Int32).)
Public methodLUSolve(TransposeOperation, Int32, Int32, Array2DDouble, Array1DInt32, Array2DDouble, Int32)

Solves a system of linear equations A * X = B or AT * X = B with a general N-by-N matrix A using the LU factorization computed by DGETRF.

(Overrides DecompositionOperationsTReal, TComplexLUSolve(TransposeOperation, Int32, Int32, Array2DTComplex, Array1DInt32, Array2DTComplex, Int32).)
Public methodLUSolve(TransposeOperation, Int32, Int32, Array2DDoubleComplex, Array1DInt32, Array2DDoubleComplex, Int32)
ZGETRS solves a system of linear equations A * X = B or A' * X = B with a general N-by-N matrix A using the LU decomposition computed by ZGETRF. Arguments ========= TRANS (input) CHARACTER*1 Specifies the form of the system of equations: = 'N': A * X = B (No transpose) = TransposeOperation.Transpose: A'* X = B (Transpose) = 'C': A'* X = B (Conjugate transpose = Transpose) N (input) INTEGER The elementOrder of the matrix A. N >= 0. NRHS (input) INTEGER The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0. A (input) ZOUBLE PRECISION array, dimension (LDA,N) The factors L and U from the decomposition A = P*L*U as computed by ZGETRF. LDA (input) INTEGER The leading dimension of the array A. LDA >= Max(1,N). IPIV (input) INTEGER array, dimension (N) The pivot indexes from ZGETRF; for 1< =i< =N, row i of the matrix was interchanged with row IPIVi. B (input/output) ZOUBLE PRECISION array, dimension (LDB,NRHS) On entry, the right hand side matrix B. On exit, the solution matrix X. LDB (input) INTEGER The leading dimension of the array B. LDB >= Max(1,N). INFO (output) INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value =====================================================================
(Overrides DecompositionOperationsTReal, TComplexLUSolve(TransposeOperation, Int32, Int32, Array2DTComplex, Array1DInt32, Array2DTComplex, Int32).)
Public methodQLDecompose(Int32, Int32, Array2DComplexDouble, Array1DComplexDouble, Int32)

Computes a QL factorization of a complex M-by-N matrix A: A = Q * L.

(Overrides DecompositionOperationsTReal, TComplexQLDecompose(Int32, Int32, Array2DTComplex, Array1DTComplex, Int32).)
Public methodQLDecompose(Int32, Int32, Array2DDouble, Array1DDouble, Int32)

Computes a QL factorization of a complex M-by-N matrix A: A = Q * L.

(Overrides DecompositionOperationsTReal, TComplexQLDecompose(Int32, Int32, Array2DTComplex, Array1DTComplex, Int32).)
Public methodQLOrthogonalMultiply

Overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q**T * C C * Q**T where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(k) .

(Overrides DecompositionOperationsTReal, TComplexQLOrthogonalMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Array2DTReal, Array1DTReal, Array2DTReal, Int32).)
Public methodQLUnitaryMultiply

Overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q**H * C C * Q**H where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(k) .

(Overrides DecompositionOperationsTReal, TComplexQLUnitaryMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Array2DTComplex, Array1DTComplex, Array2DTComplex, Int32).)
Public methodQRDecompose(Int32, Int32, Array2DComplexDouble, Array1DComplexDouble, Int32)
ZGEQRF computes a QR decomposition of a real M-by-N matrix A: A = Q * R. Arguments ========= M (input) INTEGER The number of rows of the matrix A. M >= 0. N (input) INTEGER The number of columns of the matrix A. N >= 0. A (input/output) ZOUBLE PRECISION array, dimension (LDA,N) On entry, the M-by-N matrix A. On exit, the elements on and above the diagonal of the array contain the min(M,N)-by-N upper trapezoidal matrix R (R is upper triangular if m >= n); the elements below the diagonal, with the array TAU, represent the orthogonal matrix Q as a product of min(m,n) elementary reflectors (see Further Zetails). LDA (input) INTEGER The leading dimension of the array A. LDA >= max(1,M). TAU (output) ZOUBLE PRECISION array, dimension (min(M,N)) The scalar factors of the elementary reflectors (see Further Zetails). WORK (workspace/output) ZOUBLE PRECISION array, dimension (LWORK) On exit, if INFO = 0, WORK(1) returns the optimal LWORK. LWORK (input) INTEGER The dimension of the array WORK. LWORK >= max(1,N). For optimum performance LWORK >= N*NB, where NB is the optimal blocksize. If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA. INFO (output) INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value Further Zetails =============== The matrix Q is represented as a product of elementary reflectors Q = H(1) H(2) . . . H(k), where k = min(m,n). Each H(i) has the form H(i) = I - tau * v * v' where tau is a real scalar, and v is a real vector with v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit inthis. A(i+1:m,i), and tau inthis. TAU(i).
(Overrides DecompositionOperationsTReal, TComplexQRDecompose(Int32, Int32, Array2DTComplex, Array1DTComplex, Int32).)
Public methodQRDecompose(Int32, Int32, Array2DDouble, Array1DDouble, Int32)

Computes a QR factorization of a real M-by-N matrix A: A = Q * R.

(Overrides DecompositionOperationsTReal, TComplexQRDecompose(Int32, Int32, Array2DTComplex, Array1DTComplex, Int32).)
Public methodQRDecompose(Int32, Int32, Array2DDoubleComplex, Array1DDoubleComplex, Int32)
ZGEQRF computes a QR decomposition of a real M-by-N matrix A: A = Q * R. Arguments ========= M (input) INTEGER The number of rows of the matrix A. M >= 0. N (input) INTEGER The number of columns of the matrix A. N >= 0. A (input/output) ZOUBLE PRECISION array, dimension (LDA,N) On entry, the M-by-N matrix A. On exit, the elements on and above the diagonal of the array contain the min(M,N)-by-N upper trapezoidal matrix R (R is upper triangular if m >= n); the elements below the diagonal, with the array TAU, represent the orthogonal matrix Q as a product of min(m,n) elementary reflectors (see Further Zetails). LDA (input) INTEGER The leading dimension of the array A. LDA >= max(1,M). TAU (output) ZOUBLE PRECISION array, dimension (min(M,N)) The scalar factors of the elementary reflectors (see Further Zetails). WORK (workspace/output) ZOUBLE PRECISION array, dimension (LWORK) On exit, if INFO = 0, WORK(1) returns the optimal LWORK. LWORK (input) INTEGER The dimension of the array WORK. LWORK >= max(1,N). For optimum performance LWORK >= N*NB, where NB is the optimal blocksize. If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA. INFO (output) INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value Further Zetails =============== The matrix Q is represented as a product of elementary reflectors Q = H(1) H(2) . . . H(k), where k = min(m,n). Each H(i) has the form H(i) = I - tau * v * v' where tau is a real scalar, and v is a real vector with v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit inthis. A(i+1:m,i), and tau inthis. TAU(i).
(Overrides DecompositionOperationsTReal, TComplexQRDecompose(Int32, Int32, Array2DTComplex, Array1DTComplex, Int32).)
Public methodQRDecompose(Int32, Int32, Array2DDouble, Array1DInt32, Array1DDouble, Int32)

Computes a QR factorization with column pivoting of a matrix A: A*P = Q*R using Level 3 BLAS.

(Overrides DecompositionOperationsTReal, TComplexQRDecompose(Int32, Int32, Array2DTReal, Array1DInt32, Array1DTReal, Int32).)
Public methodQROrthogonalMultiply

Overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': QT * C C * QT where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) .

(Overrides DecompositionOperationsTReal, TComplexQROrthogonalMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Array2DTReal, Array1DTReal, Array2DTReal, Int32).)
Public methodQRUnitaryMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Array2DComplexDouble, Array1DComplexDouble, Array2DComplexDouble, Int32)

Overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) .

(Overrides DecompositionOperationsTReal, TComplexQRUnitaryMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Array2DTComplex, Array1DTComplex, Array2DTComplex, Int32).)
Public methodQRUnitaryMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Array2DDoubleComplex, Array1DDoubleComplex, Array2DDoubleComplex, Int32)

Overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': QH * C C * QH where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1) H(2) .

(Overrides DecompositionOperationsTReal, TComplexQRUnitaryMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Array2DTComplex, Array1DTComplex, Array2DTComplex, Int32).)
Public methodRQDecompose(Int32, Int32, Array2DComplexDouble, Array1DComplexDouble, Int32)

Computes an RQ factorization of a complex M-by-N matrix A: A = R * Q.

(Overrides DecompositionOperationsTReal, TComplexRQDecompose(Int32, Int32, Array2DTComplex, Array1DTComplex, Int32).)
Public methodRQDecompose(Int32, Int32, Array2DDouble, Array1DDouble, Int32)

Computes an RQ factorization of a complex M-by-N matrix A: A = R * Q.

(Overrides DecompositionOperationsTReal, TComplexRQDecompose(Int32, Int32, Array2DTComplex, Array1DTComplex, Int32).)
Public methodRQOrthogonalMultiply

Overwrites the general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'T': Q**T * C C * Q**T where Q is a real orthogonal matrix defined as the product of k elementary reflectors Q = H(1) H(2) .

(Overrides DecompositionOperationsTReal, TComplexRQOrthogonalMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Array2DTReal, Array1DTReal, Array2DTReal, Int32).)
Public methodRQUnitaryMultiply

Overwrites the general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N': Q * C C * Q TRANS = 'C': Q**H * C C * Q**H where Q is a complex unitary matrix defined as the product of k elementary reflectors Q = H(1)**H H(2)**H .

(Overrides DecompositionOperationsTReal, TComplexRQUnitaryMultiply(MatrixOperationSide, TransposeOperation, Int32, Int32, Int32, Array2DTComplex, Array1DTComplex, Array2DTComplex, Int32).)
Public methodSingularValueDecompose(Char, Int32, Int32, Array2DComplexDouble, Array1DDouble, Array2DComplexDouble, Array2DComplexDouble, Int32)

Computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors, by using divide-and-conquer method.

(Overrides DecompositionOperationsTReal, TComplexSingularValueDecompose(Char, Int32, Int32, Array2DTComplex, Array1DTReal, Array2DTComplex, Array2DTComplex, Int32).)
Public methodSingularValueDecompose(Char, Int32, Int32, Array2DDouble, Array1DDouble, Array2DDouble, Array2DDouble, Int32)

Computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and right singular vectors.

(Overrides DecompositionOperationsTReal, TComplexSingularValueDecompose(Char, Int32, Int32, Array2DTComplex, Array1DTReal, Array2DTComplex, Array2DTComplex, Int32).)
Public methodSingularValueDecompose(Char, Int32, Int32, Array2DDoubleComplex, Array1DDouble, Array2DDoubleComplex, Array2DDoubleComplex, Int32)

Computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors, by using divide-and-conquer method.

(Overrides DecompositionOperationsTReal, TComplexSingularValueDecompose(Char, Int32, Int32, Array2DTComplex, Array1DTReal, Array2DTComplex, Array2DTComplex, Int32).)
Public methodSymmetricDecompose

Computes the factorization of a real symmetric matrix A using the Bunch-Kaufman diagonal pivoting method.

(Overrides DecompositionOperationsTReal, TComplexSymmetricDecompose(MatrixTriangle, Int32, Array2DTReal, Array1DInt32, Int32).)
Public methodSymmetricEigenvalueDecompose

Computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A.

(Overrides DecompositionOperationsTReal, TComplexSymmetricEigenvalueDecompose(Char, MatrixTriangle, Int32, Array2DTReal, Array1DTReal, Int32).)
Public methodSymmetricEstimateCondition

Estimates the reciprocal of the condition number (in the 1-norm) of a real symmetric matrix A using the factorization A = U*D*UT or A = L*D*LT computed by DSYTRF.

(Overrides DecompositionOperationsTReal, TComplexSymmetricEstimateCondition(MatrixTriangle, Int32, Array2DTReal, Array1DInt32, TReal, TReal, Int32).)
Public methodSymmetricGeneralizedEigenvalueDecompose

Computes selected eigenvalues, and optionally, eigenvectors of a real generalized symmetric-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x.

(Overrides DecompositionOperationsTReal, TComplexSymmetricGeneralizedEigenvalueDecompose(Int32, Char, MatrixTriangle, Int32, Array2DTReal, Array2DTReal, Array1DTReal, Int32).)
Public methodSymmetricInvert

Computes the inverse of a real symmetric indefinite matrix A using the factorization A = U*D*UT or A = L*D*LT computed by DSYTRF.

(Overrides DecompositionOperationsTReal, TComplexSymmetricInvert(MatrixTriangle, Int32, Array2DTReal, Array1DInt32, Int32).)
Public methodSymmetricSolve

Solves a system of linear equations A*X = B with a real symmetric matrix A using the factorization A = U*D*UT or A = L*D*LT computed by DSYTRF.

(Overrides DecompositionOperationsTReal, TComplexSymmetricSolve(MatrixTriangle, Int32, Int32, Array2DTReal, Array1DInt32, Array2DTReal, Int32).)
Public methodToString
Returns a string that represents the current object.
(Inherited from Object.)
Public methodTriangularEstimateCondition(MatrixNorm, MatrixTriangle, MatrixDiagonal, Int32, Array2DComplexDouble, Double, Int32)
Approximates the reciprocal of the condition number of a complex triangular matrix.
(Overrides DecompositionOperationsTReal, TComplexTriangularEstimateCondition(MatrixNorm, MatrixTriangle, MatrixDiagonal, Int32, Array2DTComplex, TReal, Int32).)
Public methodTriangularEstimateCondition(MatrixNorm, MatrixTriangle, MatrixDiagonal, Int32, Array2DDouble, Double, Int32)

Estimates the reciprocal of the condition number of a triangular matrix A, in either the 1-norm or the infinity-norm.

(Overrides DecompositionOperationsTReal, TComplexTriangularEstimateCondition(MatrixNorm, MatrixTriangle, MatrixDiagonal, Int32, Array2DTComplex, TReal, Int32).)
Public methodTriangularEstimateCondition(MatrixNorm, MatrixTriangle, MatrixDiagonal, Int32, Array2DDoubleComplex, Double, Int32)
Approximates the reciprocal of the condition number of a complex triangular matrix.
(Overrides DecompositionOperationsTReal, TComplexTriangularEstimateCondition(MatrixNorm, MatrixTriangle, MatrixDiagonal, Int32, Array2DTComplex, TReal, Int32).)
Public methodTriangularInvert(MatrixTriangle, MatrixDiagonal, Int32, Array2DComplexDouble, Int32)
Computes the inverse of a complex triangular matrix.
(Overrides DecompositionOperationsTReal, TComplexTriangularInvert(MatrixTriangle, MatrixDiagonal, Int32, Array2DTComplex, Int32).)
Public methodTriangularInvert(MatrixTriangle, MatrixDiagonal, Int32, Array2DDouble, Int32)

Computes the inverse of a real upper or lower triangular matrix A.

(Overrides DecompositionOperationsTReal, TComplexTriangularInvert(MatrixTriangle, MatrixDiagonal, Int32, Array2DTComplex, Int32).)
Public methodTriangularInvert(MatrixTriangle, MatrixDiagonal, Int32, Array2DDoubleComplex, Int32)
Computes the inverse of a complex triangular matrix.
(Overrides DecompositionOperationsTReal, TComplexTriangularInvert(MatrixTriangle, MatrixDiagonal, Int32, Array2DTComplex, Int32).)
Public methodTriangularSolve(MatrixTriangle, TransposeOperation, MatrixDiagonal, Int32, Int32, Array2DComplexDouble, Array2DComplexDouble, Int32)
Solves a complex triangular system of equations.
(Overrides DecompositionOperationsTReal, TComplexTriangularSolve(MatrixTriangle, TransposeOperation, MatrixDiagonal, Int32, Int32, Array2DTComplex, Array2DTComplex, Int32).)
Public methodTriangularSolve(MatrixTriangle, TransposeOperation, MatrixDiagonal, Int32, Int32, Array2DDouble, Array2DDouble, Int32)

Solves a triangular system of the form A * X = B or AT * X = B, where A is a triangular matrix of order N, and B is an N-by-NRHS matrix.

(Overrides DecompositionOperationsTReal, TComplexTriangularSolve(MatrixTriangle, TransposeOperation, MatrixDiagonal, Int32, Int32, Array2DTComplex, Array2DTComplex, Int32).)
Public methodTriangularSolve(MatrixTriangle, TransposeOperation, MatrixDiagonal, Int32, Int32, Array2DDoubleComplex, Array2DDoubleComplex, Int32)
Solves a complex triangular system of equations.
(Overrides DecompositionOperationsTReal, TComplexTriangularSolve(MatrixTriangle, TransposeOperation, MatrixDiagonal, Int32, Int32, Array2DTComplex, Array2DTComplex, Int32).)
Top
See Also

Reference

ManagedLapack Class
Extreme.Mathematics.LinearAlgebra.Implementation Namespace

Copyright (c) 2004-2016 ExoAnalytics Inc.

Send comments on this topic to support@extremeoptimization.com

Copyright © 2004-2018, Extreme Optimization. All rights reserved.
Extreme Optimization, Complexity made simple, M#, and M Sharp are trademarks of ExoAnalytics Inc.
Microsoft, Visual C#, Visual Basic, Visual Studio, Visual Studio.NET, and the Optimized for Visual Studio logo
are registered trademarks of Microsoft Corporation.