gpmp::linalg::SVD Class Reference

#include <svd.hpp>

Public Member Functions
	SVD (std::vector< std::vector< double >> &matrix)
	Constructor to compute SVD for a given matrix. More...
std::vector< double >	getSingularValues () const
	Get the singular values of the matrix. More...
std::vector< std::vector< double > >	getLeftSingularVectors () const
	Get the left singular vectors of the matrix. More...
std::vector< std::vector< double > >	getRightSingularVectors () const
	Get the right singular vectors of the matrix. More...

Private Member Functions
void	computeSVD (std::vector< std::vector< double >> &matrix)
void	bidiagonalize (std::vector< std::vector< double >> &matrix, std::vector< double > &diagonal, std::vector< double > &superdiagonal)
void	computeHouseholderReflection (const std::vector< double > &x, std::vector< double > &v, double &beta)
void	applyHouseholder (std::vector< std::vector< double >> &matrix, const std::vector< double > &v, double beta, size_t fromRow, size_t fromCol)

Private Attributes
std::vector< double >	singularValues_
std::vector< std::vector< double > >	leftSingularVectors_
std::vector< std::vector< double > >	rightSingularVectors_

Detailed Description

Definition at line 44 of file svd.hpp.

Constructor & Destructor Documentation

SVD()

gpmp::linalg::SVD::SVD ( std::vector< std::vector< double >> &  matrix )

explicit

Constructor to compute SVD for a given matrix.

Parameters

matrix

The input matrix for SVD

Exceptions

std::invalid_argument

if the matrix is empty

Definition at line 38 of file svd.cpp.

                                                       {
    if (matrix.empty() || matrix[0].empty()) {
        throw std::invalid_argument("Error: Matrix for SVD is empty.");
    }
 
    computeSVD(matrix);
}

References computeSVD().

Member Function Documentation

applyHouseholder()

void gpmp::linalg::SVD::applyHouseholder ( std::vector< std::vector< double >> &  matrix, const std::vector< double > &  v, double  beta, size_t  fromRow, size_t  fromCol  )

private

Definition at line 136 of file svd.cpp.

                    {
    size_t m = matrix.size();
    size_t n = matrix[0].size();
 
    for (size_t i = fromRow; i < m; ++i) {
        double dotProduct = 0.0;
        for (size_t j = fromCol; j < n; ++j) {
            dotProduct += matrix[i][j] * v[j - fromCol];
        }
 
        dotProduct *= beta;
 
        for (size_t j = fromCol; j < n; ++j) {
            matrix[i][j] -= dotProduct * v[j - fromCol];
        }
    }
}

bidiagonalize()

void gpmp::linalg::SVD::bidiagonalize ( std::vector< std::vector< double >> &  matrix, std::vector< double > &  diagonal, std::vector< double > &  superdiagonal  )

private

Definition at line 86 of file svd.cpp.

                                                                        {
    size_t m = matrix.size();
    size_t n = matrix[0].size();
 
    diagonal.resize(std::min(m, n));
    superdiagonal.resize(std::min(m, n) - 1);
 
    for (size_t k = 0; k < std::min(m, n); ++k) {
        double alpha = 0.0;
        for (size_t i = k; i < m; ++i) {
            alpha += matrix[i][k] * matrix[i][k];
        }
        alpha = (matrix[k][k] > 0) ? -std::sqrt(alpha) : std::sqrt(alpha);
 
        double beta = alpha * (alpha - matrix[k][k]);
        diagonal[k] = -alpha;
 
        // make a copy of the current column of the matrix
        std::vector<double> columnCopy(m - k);
        for (size_t i = k; i < m; ++i) {
            columnCopy[i - k] = matrix[i][k];
        }
 
        computeHouseholderReflection(columnCopy, superdiagonal, beta);
        applyHouseholder(matrix, superdiagonal, beta, k, k + 1);
    }
}

computeHouseholderReflection()

void gpmp::linalg::SVD::computeHouseholderReflection ( const std::vector< double > &  x, std::vector< double > &  v, double &  beta  )

private

Definition at line 116 of file svd.cpp.

                  {
    size_t n = x.size();
    double sigma = 0.0;
 
    for (size_t i = 1; i < n; ++i) {
        sigma += x[i] * x[i];
    }
 
    v.resize(n);
    v[0] = 1.0;
    for (size_t i = 1; i < n; ++i) {
        v[i] = x[i] / sigma;
    }
 
    beta = 2.0 / (sigma + 1.0);
}

computeSVD()

void gpmp::linalg::SVD::computeSVD ( std::vector< std::vector< double >> &  matrix )

private

Definition at line 60 of file svd.cpp.

                                                                   {
    size_t m = matrix.size();
    size_t n = matrix[0].size();
 
    singularValues_.resize(std::min(m, n));
    leftSingularVectors_ =
        std::vector<std::vector<double>>(m, std::vector<double>(m, 0.0));
    rightSingularVectors_ =
        std::vector<std::vector<double>>(n, std::vector<double>(n, 0.0));
 
    std::vector<double> superdiagonal(n - 1, 0.0);
 
    bidiagonalize(const_cast<std::vector<std::vector<double>> &>(matrix),
                  singularValues_,
                  superdiagonal);
 
    // left/right singular vectors as identity matrices
    for (size_t i = 0; i < m; ++i) {
        leftSingularVectors_[i][i] = 1.0;
    }
 
    for (size_t i = 0; i < n; ++i) {
        rightSingularVectors_[i][i] = 1.0;
    }
}

Referenced by SVD().

getLeftSingularVectors()

std::vector< std::vector< double > > gpmp::linalg::SVD::getLeftSingularVectors

(

)

const

Get the left singular vectors of the matrix.

Returns

Matrix containing left singular vectors as columns

Definition at line 51 of file svd.cpp.

                                            {
    return leftSingularVectors_;
}

getRightSingularVectors()

std::vector< std::vector< double > > gpmp::linalg::SVD::getRightSingularVectors

(

)

const

Get the right singular vectors of the matrix.

Returns

Matrix containing right singular vectors as columns

Definition at line 56 of file svd.cpp.

                                             {
    return rightSingularVectors_;
}

getSingularValues()

std::vector< double > gpmp::linalg::SVD::getSingularValues

(

)

const

Get the singular values of the matrix.

Returns

Vector containing singular values in descending order

Definition at line 46 of file svd.cpp.

                                                         {
    return singularValues_;
}

Member Data Documentation

leftSingularVectors_

std::vector<std::vector<double> > gpmp::linalg::SVD::leftSingularVectors_

private

Definition at line 73 of file svd.hpp.

rightSingularVectors_

std::vector<std::vector<double> > gpmp::linalg::SVD::rightSingularVectors_

private

Definition at line 74 of file svd.hpp.

singularValues_

std::vector<double> gpmp::linalg::SVD::singularValues_

private

Definition at line 72 of file svd.hpp.

---

The documentation for this class was generated from the following files:

• include/openGPMP/linalg/svd.hpp
• modules/linalg/svd.cpp