Spec-Zone.ru › Eigen3

Eigen::LLT

template<typename _MatrixType, int _UpLo>
class Eigen::LLT< _MatrixType, _UpLo >

Стандартное разложение Холецкого (LLT) матрицы и связанные с ним функции.

Параметры шаблона
_MatrixType тип матрицы, для которой вычисляется разложение Холецкого LLT
_UpLo треугольная часть, которая будет использоваться для разложения: Нижняя (по умолчанию) или Верхняя. Другая треугольная часть не будет считываться.

Этот класс выполняет разложение Холецкого LLT симметричной положительно определенной матрицы A, такой что A = LL* = U*U, где L - нижняя треугольная матрица.

Хотя разложение Холецкого особенно полезно для решения самосопряженных задач, таких как D*Dx = b, для этой цели мы рекомендуем использовать разложение Холецкого без квадратного корня, которое более устойчиво и даже быстрее. Тем не менее, это стандартное разложение Холецкого остается полезным во многих других ситуациях, например, в обобщенных задачах собственных значений с эрмитовыми матрицами.

Помните, что разложения Холецкого не являются разложениями, определяющими ранг. Это разложение LLT устойчиво только для положительно определенных матриц, для полуопределённого случая используйте LDLT вместо него. Кроме того, не используйте разложение Холецкого для определения того, имеет ли система уравнений решение.

Пример:

MatrixXd A(3,3);
A << 4,-1,2, -1,6,0, 2,0,5;
cout << "The matrix A is" << endl << A << endl;
 
LLT<MatrixXd> lltOfA(A); // compute the Cholesky decomposition of A
MatrixXd L = lltOfA.matrixL(); // retrieve factor L  in the decomposition
// The previous two lines can also be written as "L = A.llt().matrixL()"
 
cout << "The Cholesky factor L is" << endl << L << endl;
cout << "To check this, let us compute L * L.transpose()" << endl;
cout << L * L.transpose() << endl;
cout << "This should equal the matrix A" << endl;

Вывод:

The matrix A is
 4 -1  2
-1  6  0
 2  0  5
The Cholesky factor L is
    2     0     0
 -0.5   2.4     0
    1 0.209  1.99
To check this, let us compute L * L.transpose()
 4 -1  2
-1  6  0
 2  0  5
This should equal the matrix A

Производительность: для наилучшей производительности рекомендуется использовать формат хранения по столбцам с нижней треугольной частью (по умолчанию) или, эквивалентно, формат хранения по строкам с верхней треугольной частью. В противном случае вы можете получить снижение производительности на 20% для шага полного факторизации, а обновления ранга могут быть до 3 раз медленнее.

Этот класс поддерживает механизм разложения на месте.

Обратите внимание, что во время разложения учитывается только нижняя (или верхняя, как определено _UpLo) треугольная часть A. Поэтому строгая нижняя часть не должна содержать правильных значений.

См. также
MatrixBase::llt(), SelfAdjointView::llt(), класс LDLT
Inheritance graph
const LLT & adjoint () const EIGEN_NOEXCEPT
template<typename InputType >
LLT< MatrixType, _UpLo > & compute (const EigenBase< InputType > &a)
ComputationInfo info () const
Сообщает, была ли предыдущая вычисление успешной. Подробнее...
LLT ()
Конструктор по умолчанию. Подробнее...
template<typename InputType >
LLT (EigenBase< InputType > &matrix)
Конструирует факторизацию LLT из заданной матрицы. Подробнее...
LLT (Index size)
Конструктор по умолчанию с предварительной выделением памяти. Подробнее...
Traits::MatrixL matrixL () const
const MatrixType & matrixLLT () const
Traits::MatrixU matrixU () const
template<typename VectorType >
LLT< _MatrixType, _UpLo > & rankUpdate (const VectorType &v, const RealScalar &sigma)
RealScalar rcond () const
MatrixType reconstructedMatrix () const
template<typename Rhs >
const Solve< LLT, Rhs > solve (const MatrixBase< Rhs > &b) const
- Публичные методы, унаследованные от Eigen::SolverBase< LLT< _MatrixType, _UpLo > >
AdjointReturnType adjoint () const
LLT< _MatrixType, _UpLo > & derived ()
const LLT< _MatrixType, _UpLo > & derived () const
const Solve< LLT< _MatrixType, _UpLo >, Rhs > solve (const MatrixBase< Rhs > &b) const
SolverBase ()
ConstTransposeReturnType transpose () const
- Публичные методы, унаследованные от Eigen::EigenBase< Derived >
EIGEN_CONSTEXPR Index cols () const EIGEN_NOEXCEPT
Derived & derived ()
const Derived & derived () const
EIGEN_CONSTEXPR Index rows () const EIGEN_NOEXCEPT
EIGEN_CONSTEXPR Index size () const EIGEN_NOEXCEPT
- Публичные типы, унаследованные от Eigen::EigenBase< Derived >
typedef Eigen::Index Index
Интерфейсный тип индексов. Подробнее...

LLT() [1/3]

template<typename _MatrixType , int _UpLo>
Eigen::LLT< _MatrixType, _UpLo >::LLT ( )
inline

Конструктор по умолчанию.

Конструктор по умолчанию полезен в тех случаях, когда пользователь намерен выполнить разложение через LLT::compute(const MatrixType&).

LLT() [2/3]

template<typename _MatrixType , int _UpLo>
Eigen::LLT< _MatrixType, _UpLo >::LLT ( Index size )
inlineexplicit

Конструктор по умолчанию с предварительной выделением памяти.

Аналогичен конструктору по умолчанию, но с предварительным выделением внутренней памяти в соответствии с указанным размером задачи size.

См. также
LLT()

LLT() [3/3]

template<typename _MatrixType , int _UpLo>
template<typename InputType >
Eigen::LLT< _MatrixType, _UpLo >::LLT ( EigenBase< InputType > & matrix )
inlineexplicit

Создает факторизацию LLT из заданной матрицы.

Этот перегруженный конструктор предоставляется для разложения на месте, когда MatrixType является Eigen::Ref.

См. также
LLT(const EigenBase&)

adjoint()

template<typename _MatrixType , int _UpLo>
const LLT& Eigen::LLT< _MatrixType, _UpLo >::adjoint ( ) const
inline
Возвращает
сопряженное значение *this, то есть константную ссылку на само разложение, так как основная матрица является самосопряженной.

Этот метод предоставляется для совместимости с другими разложениями матриц, что позволяет использовать общий код, например:

x = decomposition.adjoint().solve(b) 

compute()

template<typename _MatrixType , int _UpLo>
template<typename InputType >
LLT<MatrixType,_UpLo>& Eigen::LLT< _MatrixType, _UpLo >::compute ( const EigenBase< InputType > & a )

Вычисляет/перевычисляет разложение Холецкого A = LL^* = U^*U для matrix

Возвращает
ссылку на *this

Пример:

#include <iostream>
#include <Eigen/Dense>
 
using namespace std;
using namespace Eigen;
 
int main()
{
   Matrix2f A, b;
   LLT<Matrix2f> llt;
   A << 2, -1, -1, 3;
   b << 1, 2, 3, 1;
   cout << "Here is the matrix A:\n" << A << endl;
   cout << "Here is the right hand side b:\n" << b << endl;
   cout << "Computing LLT decomposition..." << endl;
   llt.compute(A);
   cout << "The solution is:\n" << llt.solve(b) << endl;
   A(1,1)++;
   cout << "The matrix A is now:\n" << A << endl;
   cout << "Computing LLT decomposition..." << endl;
   llt.compute(A);
   cout << "The solution is now:\n" << llt.solve(b) << endl;
}

Вывод:

Here is the matrix A:
 2 -1
-1  3
Here is the right hand side b:
1 2
3 1
Computing LLT decomposition...
The solution is:
1.2 1.4
1.4 0.8
The matrix A is now:
 2 -1
-1  4
Computing LLT decomposition...
The solution is now:
    1  1.29
    1 0.571

info()

template<typename _MatrixType , int _UpLo>
ComputationInfo Eigen::LLT< _MatrixType, _UpLo >::info ( ) const
inline

Сообщает, было ли предыдущее вычисление успешным.

Возвращает
Success если вычисление прошло успешно, NumericalIssue если матрица, похоже, не является положительно определенной.

matrixL()

template<typename _MatrixType , int _UpLo>
Traits::MatrixL Eigen::LLT< _MatrixType, _UpLo >::matrixL ( ) const
inline
Возвращает
вид нижней треугольной матрицы L

matrixLLT()

template<typename _MatrixType , int _UpLo>
const MatrixType& Eigen::LLT< _MatrixType, _UpLo >::matrixLLT ( ) const
inline
Возвращает
матрицу разложения LLT

TODO: документировать расположение хранения

matrixU()

template<typename _MatrixType , int _UpLo>
Traits::MatrixU Eigen::LLT< _MatrixType, _UpLo >::matrixU ( ) const
inline
Возвращает
вид верхней треугольной матрицы U

rankUpdate()

template<typename _MatrixType , int _UpLo>
template<typename VectorType >
LLT<_MatrixType,_UpLo>& Eigen::LLT< _MatrixType, _UpLo >::rankUpdate ( const VectorType & v,
const RealScalar & sigma
)

Выполняет обновление (или корректировку) ранга одной матрицы. Если A = LL^* до обновления ранга одной матрицы, то после него мы имеем LL^* = A + sigma * v v^*, где v должен быть вектором той же размерности.

rcond()

template<typename _MatrixType , int _UpLo>
RealScalar Eigen::LLT< _MatrixType, _UpLo >::rcond ( ) const
inline
Возвращает
оценку обратной числовой характеристики матрицы, для которой *this является разложением Холецкого.

reconstructedMatrix()

template<typename MatrixType , int _UpLo>
MatrixType Eigen::LLT< MatrixType, _UpLo >::reconstructedMatrix
Возвращает
матрицу, представленную разложением, т.е., она возвращает произведение: L L^*. Эта функция предоставляется для отладки.

solve()

template<typename _MatrixType , int _UpLo>
template<typename Rhs >
const Solve<LLT, Rhs> Eigen::LLT< _MatrixType, _UpLo >::solve ( const MatrixBase< Rhs > & b ) const
inline
Возвращает
решение x для \( A x = b \) с использованием текущего разложения A.

Поскольку этот класс LLT предполагает, что матрица A обратима, решение теоретически существует и уникально независимо от b.

Пример:

typedef Matrix<float,Dynamic,2> DataMatrix;
// let's generate some samples on the 3D plane of equation z = 2x+3y (with some noise)
DataMatrix samples = DataMatrix::Random(12,2);
VectorXf elevations = 2*samples.col(0) + 3*samples.col(1) + VectorXf::Random(12)*0.1;
// and let's solve samples * [x y]^T = elevations in least square sense:
Matrix<float,2,1> xy
 = (samples.adjoint() * samples).llt().solve((samples.adjoint()*elevations));
cout << xy << endl;

Вывод:

2.02
2.97
См. также
solveInPlace(), MatrixBase::llt(), SelfAdjointView::llt()

Документация для этого класса была сгенерирована из следующего файла:
  • LLT.h

© Eigen.
Licensed under the MPL2 License.
https://eigen.tuxfamily.org/dox/classEigen_1_1LLT.html

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API