The Generalized Singular Value Decomposition

The singular value decomposition of a matrix is represented by the by the GeneralizedSingularValueDecompositionT class. It has no constructors. Instead, it is created by calling the GetSingularValueDecomposition method on the primary matrix. This method has four overloads. The first overload takes one argument: the secondary matrix B. The second overload takes an additional Boolean value that specifies whether the contents of the matrices may be overwritten during the SVD calculation. The default is false.

var A = Matrix.Create(5, 3, new double[] {
    1,2,3,4,5,
    6,7,8,9,10,
    11,12,13,14,15
}, MatrixElementOrder.ColumnMajor);
var B = Matrix.Create(3, 3, new double[] {
    8, 3, 4,
    1, 5, 9,
    6, 7, 2
}, MatrixElementOrder.ColumnMajor);
var gsvd = A.GetSingularValueDecomposition(B);

Dim A = Matrix.Create(5, 3, New Double() {
    1, 2, 3, 4, 5,
    6, 7, 8, 9, 10,
    11, 12, 13, 14, 15
}, MatrixElementOrder.ColumnMajor)
Dim B = Matrix.Create(3, 3, New Double() {
    8, 3, 4,
    1, 5, 9,
    6, 7, 2
}, MatrixElementOrder.ColumnMajor)
Dim gsvd = A.GetSingularValueDecomposition(B)

let A = Matrix.Create(5, 3, 
          [|
            1;2;3;4;5;
            6;7;8;9;10;
            11;12;13;14;15
          |], MatrixElementOrder.ColumnMajor)
let B = Matrix.Create(3, 3,
          [|
            8; 3; 4;
            1; 5; 9;
            6; 7; 2
          |], MatrixElementOrder.ColumnMajor)
let gsvd = A.GetSingularValueDecomposition(B)

The two remaining overloads let you specify which calculations are to be performed. Because the calculation of the singular vectors U and V as well as the orthogonal factor Q is relatively expensive and not always needed, it is possible to specify that only the singular values should be computed. This is done in one of two ways. The first is by passing a value of type GeneralizedSingularValueDecompositionFactors to the method. Alternatively, you can set the RequestedFactors property to a value of the same type before the decomposition is computed. The possible values for the SingularValueDecompositionFactors enumeration are listed below:

A common option is Thin, which is often used for matrices that have more rows than columns. In this case, only a few of the left singular vectors correspond to singular values. The remaining singular vectors correspond to zero rows in the matrix of singular values, and are rarely used.

The Decompose method performs the actual decomposition. This method copies the matrix if necessary. It then calls the appropriate routine to perform the actual decomposition. This method is called by other methods as needed. You will rarely need to call it explicitly.

The GeneralizedSingularValues property returns a vector containing the generalized singular values. The PrimarySingularValues property returns a vector containing the singular values of the primary matrix. The PrimarySingularValueMatrix returns the matrix Σ₁ in the decomposition: a diagonal matrix of the same shape as A with the singular values on the diagonal.

The SecondarySingularValues property returns a vector containing the singular values of the secondary matrix. The SecondarySingularValueMatrix returns the matrix Σ₂ in the decomposition: a diagonal matrix of the same shape as B with the singular values on the diagonal.

The PrimarySingularVectors and SecondarySingularVectors return the matrices U and V, respectively. The singular vectors are stored in the columns of these matrices. When a thin SVD is requested, the meaning is slightly different. For a matrix with more rows than columns, the singular matrix contains only n columns, where n is the number of columns in the matrix. The columns of these reduced matrices are still orthogonal.

The SharedTriangularFactor and SharedOrthogonalFactor return the matrices [0 R] and Q, respectively. To get just the triangular part, R or just those columns of Q that are multiplied with non-zero columns of [0 R], use the TrimmedSharedTriangularFactor. To get the matrix X from the decomposition, use SharedFactor.

var S = gsvd.GeneralizedSingularValues;
var S1 = gsvd.PrimarySingularValues;
var S2 = gsvd.SecondarySingularValues;
var U = gsvd.PrimarySingularVectors;
var V = gsvd.SecondarySingularVectors;
var Q = gsvd.SharedOrthogonalFactor;
var R = gsvd.TrimmedSharedTriangularFactor;
var X = gsvd.SharedFactor;

Dim S = gsvd.GeneralizedSingularValues
Dim S1 = gsvd.PrimarySingularValues
Dim S2 = gsvd.SecondarySingularValues
Dim U = gsvd.PrimarySingularVectors
Dim V = gsvd.SecondarySingularVectors
Dim Q = gsvd.SharedOrthogonalFactor
Dim R = gsvd.TrimmedSharedTriangularFactor
Dim X = gsvd.SharedFactor

let S = gsvd.GeneralizedSingularValues
let S1 = gsvd.PrimarySingularValues
let S2 = gsvd.SecondarySingularValues
let U = gsvd.PrimarySingularVectors
let V = gsvd.SecondarySingularVectors
let Q = gsvd.SharedOrthogonalFactor
let R = gsvd.TrimmedSharedTriangularFactor
let X = gsvd.SharedFactor

The implementation of the singular value decomposition is based on the LAPACK routine DGGSVD3.