Please, help us to better know about our user community by answering the following short survey: https://forms.gle/wpyrxWi18ox9Z5ae9
Eigen  3.4.0
 
Loading...
Searching...
No Matches
ComplexEigenSolver.h
1// This file is part of Eigen, a lightweight C++ template library
2// for linear algebra.
3//
4// Copyright (C) 2009 Claire Maurice
5// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
6// Copyright (C) 2010,2012 Jitse Niesen <jitse@maths.leeds.ac.uk>
7//
8// This Source Code Form is subject to the terms of the Mozilla
9// Public License v. 2.0. If a copy of the MPL was not distributed
10// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
11
12#ifndef EIGEN_COMPLEX_EIGEN_SOLVER_H
13#define EIGEN_COMPLEX_EIGEN_SOLVER_H
14
15#include "./ComplexSchur.h"
16
17namespace Eigen {
18
45template<typename _MatrixType> class ComplexEigenSolver
46{
47 public:
48
50 typedef _MatrixType MatrixType;
51
52 enum {
53 RowsAtCompileTime = MatrixType::RowsAtCompileTime,
54 ColsAtCompileTime = MatrixType::ColsAtCompileTime,
55 Options = MatrixType::Options,
56 MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
57 MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
58 };
59
61 typedef typename MatrixType::Scalar Scalar;
62 typedef typename NumTraits<Scalar>::Real RealScalar;
64
71 typedef std::complex<RealScalar> ComplexScalar;
72
78 typedef Matrix<ComplexScalar, ColsAtCompileTime, 1, Options&(~RowMajor), MaxColsAtCompileTime, 1> EigenvalueType;
79
86
93 : m_eivec(),
94 m_eivalues(),
95 m_schur(),
96 m_isInitialized(false),
97 m_eigenvectorsOk(false),
98 m_matX()
99 {}
100
108 : m_eivec(size, size),
109 m_eivalues(size),
110 m_schur(size),
111 m_isInitialized(false),
112 m_eigenvectorsOk(false),
113 m_matX(size, size)
114 {}
115
125 template<typename InputType>
126 explicit ComplexEigenSolver(const EigenBase<InputType>& matrix, bool computeEigenvectors = true)
127 : m_eivec(matrix.rows(),matrix.cols()),
128 m_eivalues(matrix.cols()),
129 m_schur(matrix.rows()),
130 m_isInitialized(false),
131 m_eigenvectorsOk(false),
132 m_matX(matrix.rows(),matrix.cols())
133 {
134 compute(matrix.derived(), computeEigenvectors);
135 }
136
158 {
159 eigen_assert(m_isInitialized && "ComplexEigenSolver is not initialized.");
160 eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues.");
161 return m_eivec;
162 }
163
183 {
184 eigen_assert(m_isInitialized && "ComplexEigenSolver is not initialized.");
185 return m_eivalues;
186 }
187
212 template<typename InputType>
213 ComplexEigenSolver& compute(const EigenBase<InputType>& matrix, bool computeEigenvectors = true);
214
220 {
221 eigen_assert(m_isInitialized && "ComplexEigenSolver is not initialized.");
222 return m_schur.info();
223 }
224
227 {
228 m_schur.setMaxIterations(maxIters);
229 return *this;
230 }
231
234 {
235 return m_schur.getMaxIterations();
236 }
237
238 protected:
239
240 static void check_template_parameters()
241 {
242 EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
243 }
244
245 EigenvectorType m_eivec;
246 EigenvalueType m_eivalues;
247 ComplexSchur<MatrixType> m_schur;
248 bool m_isInitialized;
249 bool m_eigenvectorsOk;
250 EigenvectorType m_matX;
251
252 private:
253 void doComputeEigenvectors(RealScalar matrixnorm);
254 void sortEigenvalues(bool computeEigenvectors);
255};
256
257
258template<typename MatrixType>
259template<typename InputType>
260ComplexEigenSolver<MatrixType>&
261ComplexEigenSolver<MatrixType>::compute(const EigenBase<InputType>& matrix, bool computeEigenvectors)
262{
263 check_template_parameters();
264
265 // this code is inspired from Jampack
266 eigen_assert(matrix.cols() == matrix.rows());
267
268 // Do a complex Schur decomposition, A = U T U^*
269 // The eigenvalues are on the diagonal of T.
270 m_schur.compute(matrix.derived(), computeEigenvectors);
271
272 if(m_schur.info() == Success)
273 {
274 m_eivalues = m_schur.matrixT().diagonal();
275 if(computeEigenvectors)
276 doComputeEigenvectors(m_schur.matrixT().norm());
277 sortEigenvalues(computeEigenvectors);
278 }
279
280 m_isInitialized = true;
281 m_eigenvectorsOk = computeEigenvectors;
282 return *this;
283}
284
285
286template<typename MatrixType>
287void ComplexEigenSolver<MatrixType>::doComputeEigenvectors(RealScalar matrixnorm)
288{
289 const Index n = m_eivalues.size();
290
291 matrixnorm = numext::maxi(matrixnorm,(std::numeric_limits<RealScalar>::min)());
292
293 // Compute X such that T = X D X^(-1), where D is the diagonal of T.
294 // The matrix X is unit triangular.
295 m_matX = EigenvectorType::Zero(n, n);
296 for(Index k=n-1 ; k>=0 ; k--)
297 {
298 m_matX.coeffRef(k,k) = ComplexScalar(1.0,0.0);
299 // Compute X(i,k) using the (i,k) entry of the equation X T = D X
300 for(Index i=k-1 ; i>=0 ; i--)
301 {
302 m_matX.coeffRef(i,k) = -m_schur.matrixT().coeff(i,k);
303 if(k-i-1>0)
304 m_matX.coeffRef(i,k) -= (m_schur.matrixT().row(i).segment(i+1,k-i-1) * m_matX.col(k).segment(i+1,k-i-1)).value();
305 ComplexScalar z = m_schur.matrixT().coeff(i,i) - m_schur.matrixT().coeff(k,k);
306 if(z==ComplexScalar(0))
307 {
308 // If the i-th and k-th eigenvalue are equal, then z equals 0.
309 // Use a small value instead, to prevent division by zero.
310 numext::real_ref(z) = NumTraits<RealScalar>::epsilon() * matrixnorm;
311 }
312 m_matX.coeffRef(i,k) = m_matX.coeff(i,k) / z;
313 }
314 }
315
316 // Compute V as V = U X; now A = U T U^* = U X D X^(-1) U^* = V D V^(-1)
317 m_eivec.noalias() = m_schur.matrixU() * m_matX;
318 // .. and normalize the eigenvectors
319 for(Index k=0 ; k<n ; k++)
320 {
321 m_eivec.col(k).normalize();
322 }
323}
324
325
326template<typename MatrixType>
327void ComplexEigenSolver<MatrixType>::sortEigenvalues(bool computeEigenvectors)
328{
329 const Index n = m_eivalues.size();
330 for (Index i=0; i<n; i++)
331 {
332 Index k;
333 m_eivalues.cwiseAbs().tail(n-i).minCoeff(&k);
334 if (k != 0)
335 {
336 k += i;
337 std::swap(m_eivalues[k],m_eivalues[i]);
338 if(computeEigenvectors)
339 m_eivec.col(i).swap(m_eivec.col(k));
340 }
341 }
342}
343
344} // end namespace Eigen
345
346#endif // EIGEN_COMPLEX_EIGEN_SOLVER_H
Computes eigenvalues and eigenvectors of general complex matrices.
Definition: ComplexEigenSolver.h:46
const EigenvalueType & eigenvalues() const
Returns the eigenvalues of given matrix.
Definition: ComplexEigenSolver.h:182
ComplexEigenSolver & setMaxIterations(Index maxIters)
Sets the maximum number of iterations allowed.
Definition: ComplexEigenSolver.h:226
ComplexEigenSolver()
Default constructor.
Definition: ComplexEigenSolver.h:92
std::complex< RealScalar > ComplexScalar
Complex scalar type for MatrixType.
Definition: ComplexEigenSolver.h:71
const EigenvectorType & eigenvectors() const
Returns the eigenvectors of given matrix.
Definition: ComplexEigenSolver.h:157
MatrixType::Scalar Scalar
Scalar type for matrices of type MatrixType.
Definition: ComplexEigenSolver.h:61
Matrix< ComplexScalar, RowsAtCompileTime, ColsAtCompileTime, Options, MaxRowsAtCompileTime, MaxColsAtCompileTime > EigenvectorType
Type for matrix of eigenvectors as returned by eigenvectors().
Definition: ComplexEigenSolver.h:85
ComplexEigenSolver(const EigenBase< InputType > &matrix, bool computeEigenvectors=true)
Constructor; computes eigendecomposition of given matrix.
Definition: ComplexEigenSolver.h:126
ComplexEigenSolver(Index size)
Default Constructor with memory preallocation.
Definition: ComplexEigenSolver.h:107
Eigen::Index Index
Definition: ComplexEigenSolver.h:63
Matrix< ComplexScalar, ColsAtCompileTime, 1, Options &(~RowMajor), MaxColsAtCompileTime, 1 > EigenvalueType
Type for vector of eigenvalues as returned by eigenvalues().
Definition: ComplexEigenSolver.h:78
ComputationInfo info() const
Reports whether previous computation was successful.
Definition: ComplexEigenSolver.h:219
_MatrixType MatrixType
Synonym for the template parameter _MatrixType.
Definition: ComplexEigenSolver.h:50
Index getMaxIterations()
Returns the maximum number of iterations.
Definition: ComplexEigenSolver.h:233
ComplexEigenSolver & compute(const EigenBase< InputType > &matrix, bool computeEigenvectors=true)
Computes eigendecomposition of given matrix.
Index getMaxIterations()
Returns the maximum number of iterations.
Definition: ComplexSchur.h:235
ComputationInfo info() const
Reports whether previous computation was successful.
Definition: ComplexSchur.h:217
ComplexSchur & setMaxIterations(Index maxIters)
Sets the maximum number of iterations allowed.
Definition: ComplexSchur.h:228
The matrix class, also used for vectors and row-vectors.
Definition: Matrix.h:180
ComputationInfo
Definition: Constants.h:440
Namespace containing all symbols from the Eigen library.
Definition: Core:141
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:74
Definition: EigenBase.h:30
Derived & derived()
Definition: EigenBase.h:46