Eigen::CauchyLU< Scalar_ > Class Template Reference

#include <contrib/Eigen/src/StructuredMatrices/Cauchy.h>

Detailed Description

template<typename Scalar_>
class Eigen::CauchyLU< Scalar_ >

Partially pivoted O(n^2) LU solver for square Cauchy systems (Gohberg-Kailath-Olshevsky).

A Cauchy matrix satisfies the displacement equation \( D_x C - C D_y = \mathbf{1}\mathbf{1}^T \), and – crucially – this structure survives row permutations. The GKO algorithm exploits it to compute the row-pivoted factorization P*C = L*U in O(n^2) operations: at each step the current column of the Schur complement is generated from O(n) data, the largest entry is chosen as pivot, and the Schur complement stays Cauchy-like with updated generators. This gives Cauchy systems what the Levinson world lacks: genuine partial pivoting at fast-algorithm cost.

Usage follows the usual decomposition style, including the transposed and adjoint solves of SolverBase (from the same factorization):

CauchyLU<double> lu(C);              // or lu.compute(C);
VectorXd u = lu.solve(b);             // solve C   * u = b
VectorXd v = lu.transpose().solve(b); // solve C^T * v = b
VectorXd w = lu.adjoint().solve(b);   // solve C^H * w = b

The factors are stored densely (O(n^2) memory, like the dense LU decompositions).

References: I. Gohberg, T. Kailath, V. Olshevsky, "Fast Gaussian elimination with partial pivoting for matrices with displacement structure," Math. Comp. 64 (1995).

Template Parameters

Scalar_

the scalar type, real or complex.

See also

class Cauchy

Inheritance diagram for Eigen::CauchyLU< Scalar_ >:

Public Member Functions
	CauchyLU ()
template<int Rows_, int Cols_>
	CauchyLU (const Cauchy< Scalar, Rows_, Cols_ > &C)
template<int Rows_, int Cols_>
CauchyLU &	compute (const Cauchy< Scalar, Rows_, Cols_ > &C)
ComputationInfo	info () const
template<typename Rhs>
const Solve< CauchyLU, Rhs >	solve (const MatrixBase< Rhs > &b) const

Constructor & Destructor Documentation

CauchyLU() [1/2]

template<typename Scalar_>

Eigen::CauchyLU< Scalar_ >::CauchyLU ( )

inline

Default constructor; call compute before solve.

CauchyLU() [2/2]

template<typename Scalar_>

template<int Rows_, int Cols_>

Eigen::CauchyLU< Scalar_ >::CauchyLU ( const Cauchy< Scalar, Rows_, Cols_ > & C )

inlineexplicit

Constructs and factorizes from the square Cauchy matrix C.

Member Function Documentation

compute()

template<typename Scalar_>

template<int Rows_, int Cols_>

CauchyLU & Eigen::CauchyLU< Scalar_ >::compute ( const Cauchy< Scalar, Rows_, Cols_ > & C )

inline

Factorizes the square Cauchy matrix C as P*C = L*U by the GKO recursion with partial pivoting. The Schur complement retains the form

\[ S_{ij}=\frac{a_i b_j}{x_i-y_j}, \qquad a_i\leftarrow a_i\frac{x_i-x_k}{x_i-y_k},\quad b_j\leftarrow b_j\frac{y_j-y_k}{y_j-x_k}. \]

This follows from the rank-one displacement \(D_x C-C D_y=\mathbf{1}\mathbf{1}^T\).

See also

solve

info()

template<typename Scalar_>

ComputationInfo Eigen::CauchyLU< Scalar_ >::info ( ) const

inline

Returns

Success, or NumericalIssue when the factorization encounters a zero or non-finite entry that prevents a usable factorization.

solve()

template<typename Scalar_>

template<typename Rhs>

const Solve< CauchyLU, Rhs > Eigen::CauchyLU< Scalar_ >::solve ( const MatrixBase< Rhs > & b ) const

inline

Returns

the solution u of C*u = b, as a lazily evaluated expression. Supports multiple right-hand sides. The transposed and adjoint systems reuse the same factorization through transpose().solve(b) and adjoint().solve(b).

Precondition

compute has been called.

---

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

• /builds/libeigen/eigen/contrib/Eigen/src/StructuredMatrices/Cauchy.h