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.Implementation
    • DecompositionOperations(TReal, TComplex) Class
    • IArrayFunctions(T, TShape, TArray) Interface
    • ILinearAlgebraOperations(T) Interface
    • ILinearAlgebraOperations(T, TVector, TMatrix) Interface
    • ISparseLinearAlgebraOperations(T) Interface
    • IVectorFunctions(T) Interface
    • LinearAlgebraOperations(T) Class
    • LinearAlgebraOperations(TReal, TComplex) Class
    • SparseLinearAlgebraOperations(T) Class
    • SparseLinearAlgebraOperations(TReal, TComplex) Class
  • DecompositionOperations(TReal, TComplex) Class
    • DecompositionOperations(TReal, TComplex) Constructor
    • 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
    • HermitianDecompose Method
    • HermitianEigenvalueDecompose Method
    • HermitianEstimateCondition Method
    • HermitianInvert Method
    • HermitianSolve Method
    • LUDecompose Method Overloads
    • LUEstimateCondition Method Overloads
    • LUInvert Method Overloads
    • LUSolve Method Overloads
    • QRDecompose Method Overloads
    • QROrthogonalMultiply Method
    • QRUnitaryMultiply Method
    • SingularValueDecompose Method Overloads
    • SymmetricDecompose Method
    • SymmetricEigenvalueDecompose Method
    • SymmetricEstimateCondition Method
    • SymmetricInvert Method
    • SymmetricSolve Method
    • TriangularEstimateCondition Method Overloads
    • TriangularInvert Method Overloads
    • TriangularSolve Method Overloads
  • EigenvalueDecompose Method Overloads
    • EigenvalueDecompose Method (Char, Char, Int32, Array2D(TComplex), Array1D(TComplex), Array2D(TComplex), Array2D(TComplex), Int32)
    • EigenvalueDecompose Method (Char, Char, Int32, Array2D(TReal), Array1D(TReal), Array1D(TReal), Array2D(TReal), Array2D(TReal), Int32)
  • EigenvalueDecompose Method (Char, Char, Int32, Array2D(TReal), Array1D(TReal), Array1D(TReal), Array2D(TReal), Array2D(TReal), Int32)
DecompositionOperationsTReal, TComplexEigenvalueDecompose Method (Char, Char, Int32, Array2DTReal, Array1DTReal, Array1DTReal, Array2DTReal, Array2DTReal, Int32)Extreme Optimization Numerical Libraries for .NET Professional

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

Namespace: Extreme.Mathematics.Implementation
Assembly: Extreme.Numerics.Net40 (in Extreme.Numerics.Net40.dll) Version: 6.0.16073.0 (6.0.16312.0)
Syntax

C#
VB
C++
F#
Copy
public abstract void EigenvalueDecompose(
	char jobvl,
	char jobvr,
	int n,
	Array2D<TReal> a,
	Array1D<TReal> wr,
	Array1D<TReal> wi,
	Array2D<TReal> vl,
	Array2D<TReal> vr,
	out int info
)
Public MustOverride Sub EigenvalueDecompose ( 
	jobvl As Char,
	jobvr As Char,
	n As Integer,
	a As Array2D(Of TReal),
	wr As Array1D(Of TReal),
	wi As Array1D(Of TReal),
	vl As Array2D(Of TReal),
	vr As Array2D(Of TReal),
	<OutAttribute> ByRef info As Integer
)
public:
virtual void EigenvalueDecompose(
	wchar_t jobvl, 
	wchar_t jobvr, 
	int n, 
	Array2D<TReal> a, 
	Array1D<TReal> wr, 
	Array1D<TReal> wi, 
	Array2D<TReal> vl, 
	Array2D<TReal> vr, 
	[OutAttribute] int% info
) abstract
abstract EigenvalueDecompose : 
        jobvl : char * 
        jobvr : char * 
        n : int * 
        a : Array2D<'TReal> * 
        wr : Array1D<'TReal> * 
        wi : Array1D<'TReal> * 
        vl : Array2D<'TReal> * 
        vr : Array2D<'TReal> * 
        info : int byref -> unit 

Parameters

jobvl
Type: SystemChar
            = 'N': left eigenvectors of A are not computed;
            = 'V': left eigenvectors of A are computed.
            
jobvr
Type: SystemChar
            = 'N': right eigenvectors of A are not computed;
            = 'V': right eigenvectors of A are computed.
            
n
Type: SystemInt32
            The order of the matrix A. N >= 0.
            
a
Type: Extreme.CollectionsArray2DTReal
            A is TReal array, dimension (LDA,N)
            On entry, the N-by-N matrix A.
            On exit, A has been overwritten.
            
            The leading dimension of the array A.  LDA >= max(1,N).
            
wr
Type: Extreme.CollectionsArray1DTReal
            WR is TReal array, dimension (N)
            
wi
Type: Extreme.CollectionsArray1DTReal
            WI is TReal array, dimension (N)
            WR and WI contain the real and imaginary parts,
            respectively, of the computed eigenvalues.  Complex
            conjugate pairs of eigenvalues appear consecutively
            with the eigenvalue having the positive imaginary part
            first.
            
vl
Type: Extreme.CollectionsArray2DTReal
            VL is TReal array, dimension (LDVL,N)
            If JOBVL = 'V', the left eigenvectors u(j) are stored one
            after another in the columns of VL, in the same order
            as their eigenvalues.
            If JOBVL = 'N', VL is not referenced.
            If the j-th eigenvalue is real, then u(j) = VL(:,j),
            the j-th column of VL.
            If the j-th and (j+1)-st eigenvalues form a complex
            conjugate pair, then u(j) = VL(:,j) + i*VL(:,j+1) and
            u(j+1) = VL(:,j) - i*VL(:,j+1).
            
            The leading dimension of the array VL.  LDVL >= 1; if
            JOBVL = 'V', LDVL >= N.
            
vr
Type: Extreme.CollectionsArray2DTReal
            VR is TReal array, dimension (LDVR,N)
            If JOBVR = 'V', the right eigenvectors v(j) are stored one
            after another in the columns of VR, in the same order
            as their eigenvalues.
            If JOBVR = 'N', VR is not referenced.
            If the j-th eigenvalue is real, then v(j) = VR(:,j),
            the j-th column of VR.
            If the j-th and (j+1)-st eigenvalues form a complex
            conjugate pair, then v(j) = VR(:,j) + i*VR(:,j+1) and
            v(j+1) = VR(:,j) - i*VR(:,j+1).
            
            The leading dimension of the array VR.  LDVR >= 1; if
            JOBVR = 'V', LDVR >= N.
            
info
Type: SystemInt32
            = 0:  successful exit
            < 0:  if INFO = -i, the i-th argument had an illegal value.
            > 0:  if INFO = i, the QR algorithm failed to compute all the
                  eigenvalues, and no eigenvectors have been computed;
                  elements i+1:N of WR and WI contain eigenvalues which
                  have converged.
            
Remarks

            The right eigenvector v(j) of A satisfies
                             A * v(j) = lambda(j) * v(j)
            where lambda(j) is its eigenvalue.
            The left eigenvector u(j) of A satisfies
                          u(j)**T * A = lambda(j) * u(j)**T
            where u(j)**T denotes the transpose of u(j).
            The computed eigenvectors are normalized to have Euclidean norm
            equal to 1 and largest component real.
            

This method corresponds to the LAPACK routine ?GEEV.

Version Information

Numerical Libraries

Supported in: 5.x
See Also

Reference

DecompositionOperationsTReal, TComplex Class
EigenvalueDecompose Overload
Extreme.Mathematics.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.