Hermitian Matrices

A HermitianMatrix<T> represents a complex matrix that is equal to its complex conjugate transpose.

How Hermitian matrices are stored

Hermitian matrices are stored in the upper or lower triangular part of a rectangular array. The MatrixTriangle property indicates how elements are stored. It is of type MatrixTriangle and can have values Upper and Lower. The element order is always column major order. Row major storage in the upper triangle is exactly equivalent to column major storage in the lower triangle.

Constructing Hermitian matrices

Constructing Hermitian matrices is analogous to triangular matrices, by calling the Matrix.CreateHermitian method. The fact that Hermitian matrices are always square means only one dimension needs to be passed to the method. The method has several overloads.

The simplest overload has just one argument. It constructs a Hermitian matrix with the specified number of rows and columns. All elements are initially set to zero. The element type must be specified as a generic type argument. For example, for a 5x5 Hermitian matrix, we have:

C# 
var h1 = Matrix.CreateHermitian<Complex<double>>(5);

The two remaining overloads allow you to initialize the elements of the matrix. The first argument once again specifies the number of rows and columns. The second argument is an array containing the elements of the new matrix. The third argument is of type MatrixTriangle, and indicates whether the elements are taken from the upper or lower triangular part of the element array. The fourth argument is of type MatrixElementOrder, and indicates whether the elements in the array are stored in column-major or row-major order.

C# 
Complex<double>[] elements = {
    new Complex<double>(1), Complex<double>.Zero, Complex<double>.Zero,
    new Complex<double>(2, 2), new Complex<double>(3), Complex<double>.Zero,
    new Complex<double>(4, 3), new Complex<double>(5, 4), new Complex<double>(6) };
var h2 = Matrix.CreateHermitian(3, elements,
    MatrixTriangle.Upper, MatrixElementOrder.ColumnMajor);
var h3 = Matrix.CreateHermitian(3, elements,
    MatrixTriangle.Lower, MatrixElementOrder.RowMajor);

The last overload adds one Boolean argument that lets you specify whether the element array should be reused or copied. If the element array is reused, any changes to its elements will result in changes to the corresponding elements of the matrix.

C# 
var h4 = Matrix.CreateHermitian(3, elements,
    MatrixTriangle.Upper, MatrixElementOrder.ColumnMajor, true);

Methods specific to Hermitian matrices

The static FromOuterProduct methods return a Hermitian matrix that is the product of a matrix with its transpose. An optional second argument of type MatrixOperationSide specifies which of the two operands should be transposed. The default is MatrixOperationSide.Left The following example creates a 2x2 Hermitian matrix that is the product of a 2x3 matrix with its transpose.

C# 
var a = Matrix.Create(3, 2, new[] {
    new Complex<double>(1, 6), new Complex<double>(2, 5), new Complex<double>(3, 4),
    new Complex<double>(4, 3), new Complex<double>(5, 2), new Complex<double>(6, 1) },
    MatrixElementOrder.ColumnMajor);
var h5 = Extreme.Mathematics.LinearAlgebra.HermitianMatrix<Complex<double>>.FromOuterProduct(a);

The HermitianMatrix<T> class has two specific instance methods. The AddOuterProduct method adds the outer product of a vector or a matrix with its transpose to a HermitianMatrix<T>. You may supply a scale factor for the outer product, as in the following example:

C# 
var A = Matrix.CreateHermitian<Complex<double>>(3);
var v = Vector.Create(new Complex<double>(1, 2), 
    new Complex<double>(3, 4), new Complex<double>(5, 6));
var w = Vector.Create(new Complex<double>(6, 5),
    new Complex<double>(4, 3), new Complex<double>(2, 1));

A.AddOuterProduct(2, v);
A.AddHermitianOuterProduct(1.0, v, w);

Complementary to this method is the SubtractOuterProduct method, which subtracts an outer product.

The GetEigenvalues method returns a DenseVector<T> that contains the eigenvalues of the matrix. If you also need the eigenvectors, it is more efficient to create a EigenvalueDecomposition<T> object from the matrix and use its Eigenvalues and Eigenvectors properties.

The ApplyMatrixFunction calculates a matrix function. Its only argument is a Func<T, TResult> delegate that specifies the function to calculate. The matrix function is computed by computing the eigenvalue decomposition and applying the function to each of the eigenvalues, and finally computing the matrix with the same eigenvectors but the transformed eigenvalues. The example below calculates the exponential of a 2x2 Hermitian matrix:

C# 
var H = Matrix.CreateHermitian(2, new[] {
    new Complex<double>(1, 2), Complex<double>.Zero,
    new Complex<double>(3, 4), new Complex<double>(5, 6) },
    MatrixTriangle.Lower, MatrixElementOrder.RowMajor);
var expS = H.ApplyMatrixFunction(Complex<double>.Exp);