GitHub-Proxy/eigen
1
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2025-08-12 11:49:02 +08:00
Code Issues Packages Projects Releases Wiki Activity

clean old stuff used to support precompilation inside a binary lib

Browse Source
This commit is contained in:
Gael Guennebaud 2010-06-07 14:47:20 +02:00
parent bfeba41174
commit 7726cc8a29
11 changed files with 76 additions and 206 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
Eigen/Cholesky
View File

@ -5,15 +5,6 @@
#include "src/Core/util/DisableMSVCWarnings.h" #include "src/Core/util/DisableMSVCWarnings.h"
// Note that EIGEN_HIDE_HEAVY_CODE has to be defined per module
#if (defined EIGEN_EXTERN_INSTANTIATIONS) && (EIGEN_EXTERN_INSTANTIATIONS>=2)
#ifndef EIGEN_HIDE_HEAVY_CODE
#define EIGEN_HIDE_HEAVY_CODE
#endif
#elif defined EIGEN_HIDE_HEAVY_CODE
#undef EIGEN_HIDE_HEAVY_CODE
#endif
namespace Eigen { namespace Eigen {
/** \defgroup Cholesky_Module Cholesky module /** \defgroup Cholesky_Module Cholesky module
@ -37,29 +28,6 @@ namespace Eigen {
} // namespace Eigen } // namespace Eigen
#define EIGEN_CHOLESKY_MODULE_INSTANTIATE_TYPE(MATRIXTYPE,PREFIX) \
PREFIX template class LLT<MATRIXTYPE>; \
PREFIX template class LDLT<MATRIXTYPE>
#define EIGEN_CHOLESKY_MODULE_INSTANTIATE(PREFIX) \
EIGEN_CHOLESKY_MODULE_INSTANTIATE_TYPE(Matrix2f,PREFIX); \
EIGEN_CHOLESKY_MODULE_INSTANTIATE_TYPE(Matrix2d,PREFIX); \
EIGEN_CHOLESKY_MODULE_INSTANTIATE_TYPE(Matrix3f,PREFIX); \
EIGEN_CHOLESKY_MODULE_INSTANTIATE_TYPE(Matrix3d,PREFIX); \
EIGEN_CHOLESKY_MODULE_INSTANTIATE_TYPE(Matrix4f,PREFIX); \
EIGEN_CHOLESKY_MODULE_INSTANTIATE_TYPE(Matrix4d,PREFIX); \
EIGEN_CHOLESKY_MODULE_INSTANTIATE_TYPE(MatrixXf,PREFIX); \
EIGEN_CHOLESKY_MODULE_INSTANTIATE_TYPE(MatrixXd,PREFIX); \
EIGEN_CHOLESKY_MODULE_INSTANTIATE_TYPE(MatrixXcf,PREFIX); \
EIGEN_CHOLESKY_MODULE_INSTANTIATE_TYPE(MatrixXcd,PREFIX)
#ifdef EIGEN_EXTERN_INSTANTIATIONS
namespace Eigen {
EIGEN_CHOLESKY_MODULE_INSTANTIATE(extern);
} // namespace Eigen
#endif
#include "src/Core/util/EnableMSVCWarnings.h" #include "src/Core/util/EnableMSVCWarnings.h"
#endif // EIGEN_CHOLESKY_MODULE_H #endif // EIGEN_CHOLESKY_MODULE_H

35
Eigen/Eigenvalues
View File

@ -10,15 +10,6 @@
#include "Householder" #include "Householder"
#include "LU" #include "LU"
// Note that EIGEN_HIDE_HEAVY_CODE has to be defined per module
#if (defined EIGEN_EXTERN_INSTANTIATIONS) && (EIGEN_EXTERN_INSTANTIATIONS>=2)
#ifndef EIGEN_HIDE_HEAVY_CODE
#define EIGEN_HIDE_HEAVY_CODE
#endif
#elif defined EIGEN_HIDE_HEAVY_CODE
#undef EIGEN_HIDE_HEAVY_CODE
#endif
namespace Eigen { namespace Eigen {
/** \defgroup Eigenvalues_Module Eigenvalues module /** \defgroup Eigenvalues_Module Eigenvalues module
@ -44,32 +35,6 @@ namespace Eigen {
#include "src/Eigenvalues/ComplexEigenSolver.h" #include "src/Eigenvalues/ComplexEigenSolver.h"
#include "src/Eigenvalues/MatrixBaseEigenvalues.h" #include "src/Eigenvalues/MatrixBaseEigenvalues.h"
// declare all classes for a given matrix type
#define EIGEN_EIGENVALUES_MODULE_INSTANTIATE_TYPE(MATRIXTYPE,PREFIX) \
PREFIX template class Tridiagonalization<MATRIXTYPE>; \
PREFIX template class HessenbergDecomposition<MATRIXTYPE>; \
PREFIX template class SelfAdjointEigenSolver<MATRIXTYPE>
// removed because it does not support complex yet
// PREFIX template class EigenSolver<MATRIXTYPE>
// declare all class for all types
#define EIGEN_EIGENVALUES_MODULE_INSTANTIATE(PREFIX) \
EIGEN_EIGENVALUES_MODULE_INSTANTIATE_TYPE(Matrix2f,PREFIX); \
EIGEN_EIGENVALUES_MODULE_INSTANTIATE_TYPE(Matrix2d,PREFIX); \
EIGEN_EIGENVALUES_MODULE_INSTANTIATE_TYPE(Matrix3f,PREFIX); \
EIGEN_EIGENVALUES_MODULE_INSTANTIATE_TYPE(Matrix3d,PREFIX); \
EIGEN_EIGENVALUES_MODULE_INSTANTIATE_TYPE(Matrix4f,PREFIX); \
EIGEN_EIGENVALUES_MODULE_INSTANTIATE_TYPE(Matrix4d,PREFIX); \
EIGEN_EIGENVALUES_MODULE_INSTANTIATE_TYPE(MatrixXf,PREFIX); \
EIGEN_EIGENVALUES_MODULE_INSTANTIATE_TYPE(MatrixXd,PREFIX); \
EIGEN_EIGENVALUES_MODULE_INSTANTIATE_TYPE(MatrixXcf,PREFIX); \
EIGEN_EIGENVALUES_MODULE_INSTANTIATE_TYPE(MatrixXcd,PREFIX)
#ifdef EIGEN_EXTERN_INSTANTIATIONS
EIGEN_EIGENVALUES_MODULE_INSTANTIATE(extern);
#endif // EIGEN_EXTERN_INSTANTIATIONS
} // namespace Eigen } // namespace Eigen
#include "src/Core/util/EnableMSVCWarnings.h" #include "src/Core/util/EnableMSVCWarnings.h"

29
Eigen/QR
View File

@ -9,15 +9,6 @@
#include "Jacobi" #include "Jacobi"
#include "Householder" #include "Householder"
// Note that EIGEN_HIDE_HEAVY_CODE has to be defined per module
#if (defined EIGEN_EXTERN_INSTANTIATIONS) && (EIGEN_EXTERN_INSTANTIATIONS>=2)
#ifndef EIGEN_HIDE_HEAVY_CODE
#define EIGEN_HIDE_HEAVY_CODE
#endif
#elif defined EIGEN_HIDE_HEAVY_CODE
#undef EIGEN_HIDE_HEAVY_CODE
#endif
namespace Eigen { namespace Eigen {
/** \defgroup QR_Module QR module /** \defgroup QR_Module QR module
@ -38,26 +29,6 @@ namespace Eigen {
#include "src/QR/FullPivHouseholderQR.h" #include "src/QR/FullPivHouseholderQR.h"
#include "src/QR/ColPivHouseholderQR.h" #include "src/QR/ColPivHouseholderQR.h"
// declare all classes for a given matrix type
#define EIGEN_QR_MODULE_INSTANTIATE_TYPE(MATRIXTYPE,PREFIX) \
PREFIX template class HouseholderQR<MATRIXTYPE>; \
// declare all class for all types
#define EIGEN_QR_MODULE_INSTANTIATE(PREFIX) \
EIGEN_QR_MODULE_INSTANTIATE_TYPE(Matrix2f,PREFIX); \
EIGEN_QR_MODULE_INSTANTIATE_TYPE(Matrix2d,PREFIX); \
EIGEN_QR_MODULE_INSTANTIATE_TYPE(Matrix3f,PREFIX); \
EIGEN_QR_MODULE_INSTANTIATE_TYPE(Matrix3d,PREFIX); \
EIGEN_QR_MODULE_INSTANTIATE_TYPE(Matrix4f,PREFIX); \
EIGEN_QR_MODULE_INSTANTIATE_TYPE(Matrix4d,PREFIX); \
EIGEN_QR_MODULE_INSTANTIATE_TYPE(MatrixXf,PREFIX); \
EIGEN_QR_MODULE_INSTANTIATE_TYPE(MatrixXd,PREFIX); \
EIGEN_QR_MODULE_INSTANTIATE_TYPE(MatrixXcf,PREFIX); \
EIGEN_QR_MODULE_INSTANTIATE_TYPE(MatrixXcd,PREFIX)
#ifdef EIGEN_EXTERN_INSTANTIATIONS
EIGEN_QR_MODULE_INSTANTIATE(extern);
#endif // EIGEN_EXTERN_INSTANTIATIONS
} // namespace Eigen } // namespace Eigen

4
Eigen/src/Core/products/GeneralBlockPanelKernel.h
View File

@ -25,8 +25,6 @@
#ifndef EIGEN_GENERAL_BLOCK_PANEL_H #ifndef EIGEN_GENERAL_BLOCK_PANEL_H
#define EIGEN_GENERAL_BLOCK_PANEL_H #define EIGEN_GENERAL_BLOCK_PANEL_H
#ifndef EIGEN_EXTERN_INSTANTIATIONS
#ifdef EIGEN_HAS_FUSE_CJMADD #ifdef EIGEN_HAS_FUSE_CJMADD
#define CJMADD(A,B,C,T) C = cj.pmadd(A,B,C); #define CJMADD(A,B,C,T) C = cj.pmadd(A,B,C);
#else #else
@ -762,6 +760,4 @@ struct ei_gemm_pack_rhs<Scalar, Index, nr, RowMajor, PanelMode>
} }
}; };
#endif // EIGEN_EXTERN_INSTANTIATIONS
#endif // EIGEN_GENERAL_BLOCK_PANEL_H #endif // EIGEN_GENERAL_BLOCK_PANEL_H

4
Eigen/src/Core/products/GeneralMatrixMatrix.h
View File

@ -25,8 +25,6 @@
#ifndef EIGEN_GENERAL_MATRIX_MATRIX_H #ifndef EIGEN_GENERAL_MATRIX_MATRIX_H
#define EIGEN_GENERAL_MATRIX_MATRIX_H #define EIGEN_GENERAL_MATRIX_MATRIX_H
#ifndef EIGEN_EXTERN_INSTANTIATIONS
/* Specialization for a row-major destination matrix => simple transposition of the product */ /* Specialization for a row-major destination matrix => simple transposition of the product */
template< template<
typename Scalar, typename Index, typename Scalar, typename Index,
@ -203,8 +201,6 @@ static void run(Index rows, Index cols, Index depth,
}; };
#endif // EIGEN_EXTERN_INSTANTIATIONS
/********************************************************************************* /*********************************************************************************
* Specialization of GeneralProduct<> for "large" GEMM, i.e., * Specialization of GeneralProduct<> for "large" GEMM, i.e.,
* implementation of the high level wrapper to ei_general_matrix_matrix_product * implementation of the high level wrapper to ei_general_matrix_matrix_product

42
Eigen/src/Eigenvalues/HessenbergDecomposition.h
View File

@ -53,11 +53,11 @@ struct ei_traits<HessenbergDecompositionMatrixHReturnType<MatrixType> >
* \f$ Q^{-1} = Q^* \f$). * \f$ Q^{-1} = Q^* \f$).
* *
* Call the function compute() to compute the Hessenberg decomposition of a * Call the function compute() to compute the Hessenberg decomposition of a
* given matrix. Alternatively, you can use the * given matrix. Alternatively, you can use the
* HessenbergDecomposition(const MatrixType&) constructor which computes the * HessenbergDecomposition(const MatrixType&) constructor which computes the
* Hessenberg decomposition at construction time. Once the decomposition is * Hessenberg decomposition at construction time. Once the decomposition is
* computed, you can use the matrixH() and matrixQ() functions to construct * computed, you can use the matrixH() and matrixQ() functions to construct
* the matrices H and Q in the decomposition. * the matrices H and Q in the decomposition.
* *
* The documentation for matrixH() contains an example of the typical use of * The documentation for matrixH() contains an example of the typical use of
* this class. * this class.
@ -114,8 +114,8 @@ template<typename _MatrixType> class HessenbergDecomposition
m_hCoeffs.resize(size-1); m_hCoeffs.resize(size-1);
} }
/** \brief Constructor; computes Hessenberg decomposition of given matrix. /** \brief Constructor; computes Hessenberg decomposition of given matrix.
* *
* \param[in] matrix Square matrix whose Hessenberg decomposition is to be computed. * \param[in] matrix Square matrix whose Hessenberg decomposition is to be computed.
* *
* This constructor calls compute() to compute the Hessenberg * This constructor calls compute() to compute the Hessenberg
@ -138,8 +138,8 @@ template<typename _MatrixType> class HessenbergDecomposition
m_isInitialized = true; m_isInitialized = true;
} }
/** \brief Computes Hessenberg decomposition of given matrix. /** \brief Computes Hessenberg decomposition of given matrix.
* *
* \param[in] matrix Square matrix whose Hessenberg decomposition is to be computed. * \param[in] matrix Square matrix whose Hessenberg decomposition is to be computed.
* \returns Reference to \c *this * \returns Reference to \c *this
* *
@ -177,18 +177,18 @@ template<typename _MatrixType> class HessenbergDecomposition
* or the member function compute(const MatrixType&) has been called * or the member function compute(const MatrixType&) has been called
* before to compute the Hessenberg decomposition of a matrix. * before to compute the Hessenberg decomposition of a matrix.
* *
* The Householder coefficients allow the reconstruction of the matrix * The Householder coefficients allow the reconstruction of the matrix
* \f$ Q \f$ in the Hessenberg decomposition from the packed data. * \f$ Q \f$ in the Hessenberg decomposition from the packed data.
* *
* \sa packedMatrix(), \ref Householder_Module "Householder module" * \sa packedMatrix(), \ref Householder_Module "Householder module"
*/ */
const CoeffVectorType& householderCoefficients() const const CoeffVectorType& householderCoefficients() const
{ {
ei_assert(m_isInitialized && "HessenbergDecomposition is not initialized."); ei_assert(m_isInitialized && "HessenbergDecomposition is not initialized.");
return m_hCoeffs; return m_hCoeffs;
} }
/** \brief Returns the internal representation of the decomposition /** \brief Returns the internal representation of the decomposition
* *
* \returns a const reference to a matrix with the internal representation * \returns a const reference to a matrix with the internal representation
* of the decomposition. * of the decomposition.
@ -201,11 +201,11 @@ template<typename _MatrixType> class HessenbergDecomposition
* - the upper part and lower sub-diagonal represent the Hessenberg matrix H * - the upper part and lower sub-diagonal represent the Hessenberg matrix H
* - the rest of the lower part contains the Householder vectors that, combined with * - the rest of the lower part contains the Householder vectors that, combined with
* Householder coefficients returned by householderCoefficients(), * Householder coefficients returned by householderCoefficients(),
* allows to reconstruct the matrix Q as * allows to reconstruct the matrix Q as
* \f$ Q = H_{N-1} \ldots H_1 H_0 \f$. * \f$ Q = H_{N-1} \ldots H_1 H_0 \f$.
* Here, the matrices \f$ H_i \f$ are the Householder transformations * Here, the matrices \f$ H_i \f$ are the Householder transformations
* \f$ H_i = (I - h_i v_i v_i^T) \f$ * \f$ H_i = (I - h_i v_i v_i^T) \f$
* where \f$ h_i \f$ is the \f$ i \f$th Householder coefficient and * where \f$ h_i \f$ is the \f$ i \f$th Householder coefficient and
* \f$ v_i \f$ is the Householder vector defined by * \f$ v_i \f$ is the Householder vector defined by
* \f$ v_i = [ 0, \ldots, 0, 1, M(i+2,i), \ldots, M(N-1,i) ]^T \f$ * \f$ v_i = [ 0, \ldots, 0, 1, M(i+2,i), \ldots, M(N-1,i) ]^T \f$
* with M the matrix returned by this function. * with M the matrix returned by this function.
@ -217,13 +217,13 @@ template<typename _MatrixType> class HessenbergDecomposition
* *
* \sa householderCoefficients() * \sa householderCoefficients()
*/ */
const MatrixType& packedMatrix() const const MatrixType& packedMatrix() const
{ {
ei_assert(m_isInitialized && "HessenbergDecomposition is not initialized."); ei_assert(m_isInitialized && "HessenbergDecomposition is not initialized.");
return m_matrix; return m_matrix;
} }
/** \brief Reconstructs the orthogonal matrix Q in the decomposition /** \brief Reconstructs the orthogonal matrix Q in the decomposition
* *
* \returns object representing the matrix Q * \returns object representing the matrix Q
* *
@ -274,7 +274,7 @@ template<typename _MatrixType> class HessenbergDecomposition
typedef Matrix<Scalar, 1, Size, Options | RowMajor, 1, MaxSize> VectorType; typedef Matrix<Scalar, 1, Size, Options | RowMajor, 1, MaxSize> VectorType;
typedef typename NumTraits<Scalar>::Real RealScalar; typedef typename NumTraits<Scalar>::Real RealScalar;
static void _compute(MatrixType& matA, CoeffVectorType& hCoeffs, VectorType& temp); static void _compute(MatrixType& matA, CoeffVectorType& hCoeffs, VectorType& temp);
protected: protected:
MatrixType m_matrix; MatrixType m_matrix;
CoeffVectorType m_hCoeffs; CoeffVectorType m_hCoeffs;
@ -282,8 +282,6 @@ template<typename _MatrixType> class HessenbergDecomposition
bool m_isInitialized; bool m_isInitialized;
}; };
#ifndef EIGEN_HIDE_HEAVY_CODE
/** \internal /** \internal
* Performs a tridiagonal decomposition of \a matA in place. * Performs a tridiagonal decomposition of \a matA in place.
* *
@ -325,8 +323,6 @@ void HessenbergDecomposition<MatrixType>::_compute(MatrixType& matA, CoeffVector
} }
} }
#endif // EIGEN_HIDE_HEAVY_CODE
/** \eigenvalues_module \ingroup Eigenvalues_Module /** \eigenvalues_module \ingroup Eigenvalues_Module
* \nonstableyet * \nonstableyet
* *

74
Eigen/src/Eigenvalues/SelfAdjointEigenSolver.h
View File

@ -43,7 +43,7 @@
* A matrix \f$ A \f$ is selfadjoint if it equals its adjoint. For real * A matrix \f$ A \f$ is selfadjoint if it equals its adjoint. For real
* matrices, this means that the matrix is symmetric: it equals its * matrices, this means that the matrix is symmetric: it equals its
* transpose. This class computes the eigenvalues and eigenvectors of a * transpose. This class computes the eigenvalues and eigenvectors of a
* selfadjoint matrix. These are the scalars \f$ \lambda \f$ and vectors * selfadjoint matrix. These are the scalars \f$ \lambda \f$ and vectors
* \f$ v \f$ such that \f$ Av = \lambda v \f$. The eigenvalues of a * \f$ v \f$ such that \f$ Av = \lambda v \f$. The eigenvalues of a
* selfadjoint matrix are always real. If \f$ D \f$ is a diagonal matrix with * selfadjoint matrix are always real. If \f$ D \f$ is a diagonal matrix with
* the eigenvalues on the diagonal, and \f$ V \f$ is a matrix with the * the eigenvalues on the diagonal, and \f$ V \f$ is a matrix with the
@ -68,7 +68,7 @@
* *
* The documentation for SelfAdjointEigenSolver(const MatrixType&, bool) * The documentation for SelfAdjointEigenSolver(const MatrixType&, bool)
* contains an example of the typical use of this class. * contains an example of the typical use of this class.
* *
* \sa MatrixBase::eigenvalues(), class EigenSolver, class ComplexEigenSolver * \sa MatrixBase::eigenvalues(), class EigenSolver, class ComplexEigenSolver
*/ */
template<typename _MatrixType> class SelfAdjointEigenSolver template<typename _MatrixType> class SelfAdjointEigenSolver
@ -87,15 +87,15 @@ template<typename _MatrixType> class SelfAdjointEigenSolver
typedef typename MatrixType::Scalar Scalar; typedef typename MatrixType::Scalar Scalar;
typedef typename MatrixType::Index Index; typedef typename MatrixType::Index Index;
/** \brief Real scalar type for \p _MatrixType. /** \brief Real scalar type for \p _MatrixType.
* *
* This is just \c Scalar if #Scalar is real (e.g., \c float or * This is just \c Scalar if #Scalar is real (e.g., \c float or
* \c double), and the type of the real part of \c Scalar if #Scalar is * \c double), and the type of the real part of \c Scalar if #Scalar is
* complex. * complex.
*/ */
typedef typename NumTraits<Scalar>::Real RealScalar; typedef typename NumTraits<Scalar>::Real RealScalar;
/** \brief Type for vector of eigenvalues as returned by eigenvalues(). /** \brief Type for vector of eigenvalues as returned by eigenvalues().
* *
* This is a column vector with entries of type #RealScalar. * This is a column vector with entries of type #RealScalar.
* The length of the vector is the size of \p _MatrixType. * The length of the vector is the size of \p _MatrixType.
@ -130,7 +130,7 @@ template<typename _MatrixType> class SelfAdjointEigenSolver
* This constructor is useful for dynamic-size matrices, when the user * This constructor is useful for dynamic-size matrices, when the user
* intends to perform decompositions via compute(const MatrixType&, bool) * intends to perform decompositions via compute(const MatrixType&, bool)
* or compute(const MatrixType&, const MatrixType&, bool). The \p size * or compute(const MatrixType&, const MatrixType&, bool). The \p size
* parameter is only used as a hint. It is not an error to give a wrong * parameter is only used as a hint. It is not an error to give a wrong
* \p size, but it may impair performance. * \p size, but it may impair performance.
* *
* \sa compute(const MatrixType&, bool) for an example * \sa compute(const MatrixType&, bool) for an example
@ -143,13 +143,13 @@ template<typename _MatrixType> class SelfAdjointEigenSolver
m_isInitialized(false) m_isInitialized(false)
{} {}
/** \brief Constructor; computes eigendecomposition of given matrix. /** \brief Constructor; computes eigendecomposition of given matrix.
* *
* \param[in] matrix Selfadjoint matrix whose eigendecomposition is to * \param[in] matrix Selfadjoint matrix whose eigendecomposition is to
* be computed. * be computed.
* \param[in] computeEigenvectors If true, both the eigenvectors and the * \param[in] computeEigenvectors If true, both the eigenvectors and the
* eigenvalues are computed; if false, only the eigenvalues are * eigenvalues are computed; if false, only the eigenvalues are
* computed. * computed.
* *
* This constructor calls compute(const MatrixType&, bool) to compute the * This constructor calls compute(const MatrixType&, bool) to compute the
* eigenvalues of the matrix \p matrix. The eigenvectors are computed if * eigenvalues of the matrix \p matrix. The eigenvectors are computed if
@ -158,7 +158,7 @@ template<typename _MatrixType> class SelfAdjointEigenSolver
* Example: \include SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType.cpp * Example: \include SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType.cpp
* Output: \verbinclude SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType.out * Output: \verbinclude SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType.out
* *
* \sa compute(const MatrixType&, bool), * \sa compute(const MatrixType&, bool),
* SelfAdjointEigenSolver(const MatrixType&, const MatrixType&, bool) * SelfAdjointEigenSolver(const MatrixType&, const MatrixType&, bool)
*/ */
SelfAdjointEigenSolver(const MatrixType& matrix, bool computeEigenvectors = true) SelfAdjointEigenSolver(const MatrixType& matrix, bool computeEigenvectors = true)
@ -172,14 +172,14 @@ template<typename _MatrixType> class SelfAdjointEigenSolver
} }
/** \brief Constructor; computes eigendecomposition of given matrix pencil. /** \brief Constructor; computes eigendecomposition of given matrix pencil.
* *
* \param[in] matA Selfadjoint matrix in matrix pencil. * \param[in] matA Selfadjoint matrix in matrix pencil.
* \param[in] matB Positive-definite matrix in matrix pencil. * \param[in] matB Positive-definite matrix in matrix pencil.
* \param[in] computeEigenvectors If true, both the eigenvectors and the * \param[in] computeEigenvectors If true, both the eigenvectors and the
* eigenvalues are computed; if false, only the eigenvalues are * eigenvalues are computed; if false, only the eigenvalues are
* computed. * computed.
* *
* This constructor calls compute(const MatrixType&, const MatrixType&, bool) * This constructor calls compute(const MatrixType&, const MatrixType&, bool)
* to compute the eigenvalues and (if requested) the eigenvectors of the * to compute the eigenvalues and (if requested) the eigenvectors of the
* generalized eigenproblem \f$ Ax = \lambda B x \f$ with \a matA the * generalized eigenproblem \f$ Ax = \lambda B x \f$ with \a matA the
* selfadjoint matrix \f$ A \f$ and \a matB the positive definite matrix * selfadjoint matrix \f$ A \f$ and \a matB the positive definite matrix
@ -189,7 +189,7 @@ template<typename _MatrixType> class SelfAdjointEigenSolver
* Example: \include SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType2.cpp * Example: \include SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType2.cpp
* Output: \verbinclude SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType2.out * Output: \verbinclude SelfAdjointEigenSolver_SelfAdjointEigenSolver_MatrixType2.out
* *
* \sa compute(const MatrixType&, const MatrixType&, bool), * \sa compute(const MatrixType&, const MatrixType&, bool),
* SelfAdjointEigenSolver(const MatrixType&, bool) * SelfAdjointEigenSolver(const MatrixType&, bool)
*/ */
SelfAdjointEigenSolver(const MatrixType& matA, const MatrixType& matB, bool computeEigenvectors = true) SelfAdjointEigenSolver(const MatrixType& matA, const MatrixType& matB, bool computeEigenvectors = true)
@ -202,13 +202,13 @@ template<typename _MatrixType> class SelfAdjointEigenSolver
compute(matA, matB, computeEigenvectors); compute(matA, matB, computeEigenvectors);
} }
/** \brief Computes eigendecomposition of given matrix. /** \brief Computes eigendecomposition of given matrix.
* *
* \param[in] matrix Selfadjoint matrix whose eigendecomposition is to * \param[in] matrix Selfadjoint matrix whose eigendecomposition is to
* be computed. * be computed.
* \param[in] computeEigenvectors If true, both the eigenvectors and the * \param[in] computeEigenvectors If true, both the eigenvectors and the
* eigenvalues are computed; if false, only the eigenvalues are * eigenvalues are computed; if false, only the eigenvalues are
* computed. * computed.
* \returns Reference to \c *this * \returns Reference to \c *this
* *
* This function computes the eigenvalues of \p matrix. The eigenvalues() * This function computes the eigenvalues of \p matrix. The eigenvalues()
@ -236,13 +236,13 @@ template<typename _MatrixType> class SelfAdjointEigenSolver
*/ */
SelfAdjointEigenSolver& compute(const MatrixType& matrix, bool computeEigenvectors = true); SelfAdjointEigenSolver& compute(const MatrixType& matrix, bool computeEigenvectors = true);
/** \brief Computes eigendecomposition of given matrix pencil. /** \brief Computes eigendecomposition of given matrix pencil.
* *
* \param[in] matA Selfadjoint matrix in matrix pencil. * \param[in] matA Selfadjoint matrix in matrix pencil.
* \param[in] matB Positive-definite matrix in matrix pencil. * \param[in] matB Positive-definite matrix in matrix pencil.
* \param[in] computeEigenvectors If true, both the eigenvectors and the * \param[in] computeEigenvectors If true, both the eigenvectors and the
* eigenvalues are computed; if false, only the eigenvalues are * eigenvalues are computed; if false, only the eigenvalues are
* computed. * computed.
* \returns Reference to \c *this * \returns Reference to \c *this
* *
* This function computes eigenvalues and (if requested) the eigenvectors * This function computes eigenvalues and (if requested) the eigenvectors
@ -253,11 +253,11 @@ template<typename _MatrixType> class SelfAdjointEigenSolver
* eigenvectors are also computed and can be retrieved by calling * eigenvectors are also computed and can be retrieved by calling
* eigenvectors(). * eigenvectors().
* *
* The implementation uses LLT to compute the Cholesky decomposition * The implementation uses LLT to compute the Cholesky decomposition
* \f$ B = LL^* \f$ and calls compute(const MatrixType&, bool) to compute * \f$ B = LL^* \f$ and calls compute(const MatrixType&, bool) to compute
* the eigendecomposition \f$ L^{-1} A (L^*)^{-1} \f$. This solves the * the eigendecomposition \f$ L^{-1} A (L^*)^{-1} \f$. This solves the
* generalized eigenproblem, because any solution of the generalized * generalized eigenproblem, because any solution of the generalized
* eigenproblem \f$ Ax = \lambda B x \f$ corresponds to a solution * eigenproblem \f$ Ax = \lambda B x \f$ corresponds to a solution
* \f$ L^{-1} A (L^*)^{-1} (L^* x) = \lambda (L^* x) \f$ of the * \f$ L^{-1} A (L^*)^{-1} (L^* x) = \lambda (L^* x) \f$ of the
* eigenproblem for \f$ L^{-1} A (L^*)^{-1} \f$. * eigenproblem for \f$ L^{-1} A (L^*)^{-1} \f$.
* *
@ -268,7 +268,7 @@ template<typename _MatrixType> class SelfAdjointEigenSolver
*/ */
SelfAdjointEigenSolver& compute(const MatrixType& matA, const MatrixType& matB, bool computeEigenvectors = true); SelfAdjointEigenSolver& compute(const MatrixType& matA, const MatrixType& matB, bool computeEigenvectors = true);
/** \brief Returns the eigenvectors of given matrix (pencil). /** \brief Returns the eigenvectors of given matrix (pencil).
* *
* \returns A const reference to the matrix whose columns are the eigenvectors. * \returns A const reference to the matrix whose columns are the eigenvectors.
* *
@ -293,7 +293,7 @@ template<typename _MatrixType> class SelfAdjointEigenSolver
return m_eivec; return m_eivec;
} }
/** \brief Returns the eigenvalues of given matrix (pencil). /** \brief Returns the eigenvalues of given matrix (pencil).
* *
* \returns A const reference to the column vector containing the eigenvalues. * \returns A const reference to the column vector containing the eigenvalues.
* *
@ -307,13 +307,13 @@ template<typename _MatrixType> class SelfAdjointEigenSolver
* *
* \sa eigenvectors(), MatrixBase::eigenvalues() * \sa eigenvectors(), MatrixBase::eigenvalues()
*/ */
const RealVectorType& eigenvalues() const const RealVectorType& eigenvalues() const
{ {
ei_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized."); ei_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized.");
return m_eivalues; return m_eivalues;
} }
/** \brief Computes the positive-definite square root of the matrix. /** \brief Computes the positive-definite square root of the matrix.
* *
* \returns the positive-definite square root of the matrix * \returns the positive-definite square root of the matrix
* *
@ -328,7 +328,7 @@ template<typename _MatrixType> class SelfAdjointEigenSolver
* Example: \include SelfAdjointEigenSolver_operatorSqrt.cpp * Example: \include SelfAdjointEigenSolver_operatorSqrt.cpp
* Output: \verbinclude SelfAdjointEigenSolver_operatorSqrt.out * Output: \verbinclude SelfAdjointEigenSolver_operatorSqrt.out
* *
* \sa operatorInverseSqrt(), * \sa operatorInverseSqrt(),
* \ref MatrixFunctions_Module "MatrixFunctions Module" * \ref MatrixFunctions_Module "MatrixFunctions Module"
*/ */
MatrixType operatorSqrt() const MatrixType operatorSqrt() const
@ -338,7 +338,7 @@ template<typename _MatrixType> class SelfAdjointEigenSolver
return m_eivec * m_eivalues.cwiseSqrt().asDiagonal() * m_eivec.adjoint(); return m_eivec * m_eivalues.cwiseSqrt().asDiagonal() * m_eivec.adjoint();
} }
/** \brief Computes the inverse square root of the matrix. /** \brief Computes the inverse square root of the matrix.
* *
* \returns the inverse positive-definite square root of the matrix * \returns the inverse positive-definite square root of the matrix
* *
@ -375,7 +375,7 @@ template<typename _MatrixType> class SelfAdjointEigenSolver
/** \brief Maximum number of iterations. /** \brief Maximum number of iterations.
* *
* Maximum number of iterations allowed for an eigenvalue to converge. * Maximum number of iterations allowed for an eigenvalue to converge.
*/ */
static const int m_maxIterations = 30; static const int m_maxIterations = 30;
@ -389,8 +389,6 @@ template<typename _MatrixType> class SelfAdjointEigenSolver
bool m_eigenvectorsOk; bool m_eigenvectorsOk;
}; };
#ifndef EIGEN_HIDE_HEAVY_CODE
/** \internal /** \internal
* *
* \eigenvalues_module \ingroup Eigenvalues_Module * \eigenvalues_module \ingroup Eigenvalues_Module
@ -467,7 +465,7 @@ SelfAdjointEigenSolver<MatrixType>& SelfAdjointEigenSolver<MatrixType>::compute(
ei_tridiagonal_qr_step(diag.data(), m_subdiag.data(), start, end, computeEigenvectors ? m_eivec.data() : (Scalar*)0, n); ei_tridiagonal_qr_step(diag.data(), m_subdiag.data(), start, end, computeEigenvectors ? m_eivec.data() : (Scalar*)0, n);
} }
if (iter <= m_maxIterations) if (iter <= m_maxIterations)
m_info = Success; m_info = Success;
else else
m_info = NoConvergence; m_info = NoConvergence;
@ -531,9 +529,6 @@ compute(const MatrixType& matA, const MatrixType& matB, bool computeEigenvectors
return *this; return *this;
} }
#endif // EIGEN_HIDE_HEAVY_CODE
#ifndef EIGEN_EXTERN_INSTANTIATIONS
template<typename RealScalar, typename Scalar, typename Index> template<typename RealScalar, typename Scalar, typename Index>
static void ei_tridiagonal_qr_step(RealScalar* diag, RealScalar* subdiag, Index start, Index end, Scalar* matrixQ, Index n) static void ei_tridiagonal_qr_step(RealScalar* diag, RealScalar* subdiag, Index start, Index end, Scalar* matrixQ, Index n)
{ {
@ -575,6 +570,5 @@ static void ei_tridiagonal_qr_step(RealScalar* diag, RealScalar* subdiag, Index
} }
} }
} }
#endif
#endif // EIGEN_SELFADJOINTEIGENSOLVER_H #endif // EIGEN_SELFADJOINTEIGENSOLVER_H

50
Eigen/src/Eigenvalues/Tridiagonalization.h
View File

@ -80,7 +80,7 @@ template<typename _MatrixType> class Tridiagonalization
typedef Matrix<Scalar, SizeMinusOne, 1, Options & ~RowMajor, MaxSizeMinusOne, 1> CoeffVectorType; typedef Matrix<Scalar, SizeMinusOne, 1, Options & ~RowMajor, MaxSizeMinusOne, 1> CoeffVectorType;
typedef typename ei_plain_col_type<MatrixType, RealScalar>::type DiagonalType; typedef typename ei_plain_col_type<MatrixType, RealScalar>::type DiagonalType;
typedef Matrix<RealScalar, SizeMinusOne, 1, Options & ~RowMajor, MaxSizeMinusOne, 1> SubDiagonalType; typedef Matrix<RealScalar, SizeMinusOne, 1, Options & ~RowMajor, MaxSizeMinusOne, 1> SubDiagonalType;
typedef typename ei_meta_if<NumTraits<Scalar>::IsComplex, typedef typename ei_meta_if<NumTraits<Scalar>::IsComplex,
typename Diagonal<MatrixType,0>::RealReturnType, typename Diagonal<MatrixType,0>::RealReturnType,
Diagonal<MatrixType,0> Diagonal<MatrixType,0>
@ -109,13 +109,13 @@ template<typename _MatrixType> class Tridiagonalization
* \sa compute() for an example. * \sa compute() for an example.
*/ */
Tridiagonalization(Index size = Size==Dynamic ? 2 : Size) Tridiagonalization(Index size = Size==Dynamic ? 2 : Size)
: m_matrix(size,size), : m_matrix(size,size),
m_hCoeffs(size > 1 ? size-1 : 1), m_hCoeffs(size > 1 ? size-1 : 1),
m_isInitialized(false) m_isInitialized(false)
{} {}
/** \brief Constructor; computes tridiagonal decomposition of given matrix. /** \brief Constructor; computes tridiagonal decomposition of given matrix.
* *
* \param[in] matrix Selfadjoint matrix whose tridiagonal decomposition * \param[in] matrix Selfadjoint matrix whose tridiagonal decomposition
* is to be computed. * is to be computed.
* *
@ -125,7 +125,7 @@ template<typename _MatrixType> class Tridiagonalization
* Output: \verbinclude Tridiagonalization_Tridiagonalization_MatrixType.out * Output: \verbinclude Tridiagonalization_Tridiagonalization_MatrixType.out
*/ */
Tridiagonalization(const MatrixType& matrix) Tridiagonalization(const MatrixType& matrix)
: m_matrix(matrix), : m_matrix(matrix),
m_hCoeffs(matrix.cols() > 1 ? matrix.cols()-1 : 1), m_hCoeffs(matrix.cols() > 1 ? matrix.cols()-1 : 1),
m_isInitialized(false) m_isInitialized(false)
{ {
@ -133,8 +133,8 @@ template<typename _MatrixType> class Tridiagonalization
m_isInitialized = true; m_isInitialized = true;
} }
/** \brief Computes tridiagonal decomposition of given matrix. /** \brief Computes tridiagonal decomposition of given matrix.
* *
* \param[in] matrix Selfadjoint matrix whose tridiagonal decomposition * \param[in] matrix Selfadjoint matrix whose tridiagonal decomposition
* is to be computed. * is to be computed.
* \returns Reference to \c *this * \returns Reference to \c *this
@ -167,7 +167,7 @@ template<typename _MatrixType> class Tridiagonalization
* the member function compute(const MatrixType&) has been called before * the member function compute(const MatrixType&) has been called before
* to compute the tridiagonal decomposition of a matrix. * to compute the tridiagonal decomposition of a matrix.
* *
* The Householder coefficients allow the reconstruction of the matrix * The Householder coefficients allow the reconstruction of the matrix
* \f$ Q \f$ in the tridiagonal decomposition from the packed data. * \f$ Q \f$ in the tridiagonal decomposition from the packed data.
* *
* Example: \include Tridiagonalization_householderCoefficients.cpp * Example: \include Tridiagonalization_householderCoefficients.cpp
@ -175,13 +175,13 @@ template<typename _MatrixType> class Tridiagonalization
* *
* \sa packedMatrix(), \ref Householder_Module "Householder module" * \sa packedMatrix(), \ref Householder_Module "Householder module"
*/ */
inline CoeffVectorType householderCoefficients() const inline CoeffVectorType householderCoefficients() const
{ {
ei_assert(m_isInitialized && "Tridiagonalization is not initialized."); ei_assert(m_isInitialized && "Tridiagonalization is not initialized.");
return m_hCoeffs; return m_hCoeffs;
} }
/** \brief Returns the internal representation of the decomposition /** \brief Returns the internal representation of the decomposition
* *
* \returns a const reference to a matrix with the internal representation * \returns a const reference to a matrix with the internal representation
* of the decomposition. * of the decomposition.
@ -193,14 +193,14 @@ template<typename _MatrixType> class Tridiagonalization
* The returned matrix contains the following information: * The returned matrix contains the following information:
* - the strict upper triangular part is equal to the input matrix A. * - the strict upper triangular part is equal to the input matrix A.
* - the diagonal and lower sub-diagonal represent the real tridiagonal * - the diagonal and lower sub-diagonal represent the real tridiagonal
* symmetric matrix T. * symmetric matrix T.
* - the rest of the lower part contains the Householder vectors that, * - the rest of the lower part contains the Householder vectors that,
* combined with Householder coefficients returned by * combined with Householder coefficients returned by
* householderCoefficients(), allows to reconstruct the matrix Q as * householderCoefficients(), allows to reconstruct the matrix Q as
* \f$ Q = H_{N-1} \ldots H_1 H_0 \f$. * \f$ Q = H_{N-1} \ldots H_1 H_0 \f$.
* Here, the matrices \f$ H_i \f$ are the Householder transformations * Here, the matrices \f$ H_i \f$ are the Householder transformations
* \f$ H_i = (I - h_i v_i v_i^T) \f$ * \f$ H_i = (I - h_i v_i v_i^T) \f$
* where \f$ h_i \f$ is the \f$ i \f$th Householder coefficient and * where \f$ h_i \f$ is the \f$ i \f$th Householder coefficient and
* \f$ v_i \f$ is the Householder vector defined by * \f$ v_i \f$ is the Householder vector defined by
* \f$ v_i = [ 0, \ldots, 0, 1, M(i+2,i), \ldots, M(N-1,i) ]^T \f$ * \f$ v_i = [ 0, \ldots, 0, 1, M(i+2,i), \ldots, M(N-1,i) ]^T \f$
* with M the matrix returned by this function. * with M the matrix returned by this function.
@ -212,13 +212,13 @@ template<typename _MatrixType> class Tridiagonalization
* *
* \sa householderCoefficients() * \sa householderCoefficients()
*/ */
inline const MatrixType& packedMatrix() const inline const MatrixType& packedMatrix() const
{ {
ei_assert(m_isInitialized && "Tridiagonalization is not initialized."); ei_assert(m_isInitialized && "Tridiagonalization is not initialized.");
return m_matrix; return m_matrix;
} }
/** \brief Returns the unitary matrix Q in the decomposition /** \brief Returns the unitary matrix Q in the decomposition
* *
* \returns object representing the matrix Q * \returns object representing the matrix Q
* *
@ -285,7 +285,7 @@ template<typename _MatrixType> class Tridiagonalization
*/ */
const SubDiagonalReturnType subDiagonal() const; const SubDiagonalReturnType subDiagonal() const;
/** \brief Performs a full decomposition in place /** \brief Performs a full decomposition in place
* *
* \param[in,out] mat On input, the selfadjoint matrix whose tridiagonal * \param[in,out] mat On input, the selfadjoint matrix whose tridiagonal
* decomposition is to be computed. On output, the orthogonal matrix Q * decomposition is to be computed. On output, the orthogonal matrix Q
@ -293,7 +293,7 @@ template<typename _MatrixType> class Tridiagonalization
* \param[out] diag The diagonal of the tridiagonal matrix T in the * \param[out] diag The diagonal of the tridiagonal matrix T in the
* decomposition. * decomposition.
* \param[out] subdiag The subdiagonal of the tridiagonal matrix T in * \param[out] subdiag The subdiagonal of the tridiagonal matrix T in
* the decomposition. * the decomposition.
* \param[in] extractQ If true, the orthogonal matrix Q in the * \param[in] extractQ If true, the orthogonal matrix Q in the
* decomposition is computed and stored in \p mat. * decomposition is computed and stored in \p mat.
* *
@ -311,10 +311,10 @@ template<typename _MatrixType> class Tridiagonalization
* *
* \note Notwithstanding the name, the current implementation copies * \note Notwithstanding the name, the current implementation copies
* \p mat to a temporary matrix and uses that matrix to compute the * \p mat to a temporary matrix and uses that matrix to compute the
* decomposition. * decomposition.
* *
* Example (this uses the same matrix as the example in * Example (this uses the same matrix as the example in
* Tridiagonalization(const MatrixType&)): * Tridiagonalization(const MatrixType&)):
* \include Tridiagonalization_decomposeInPlace.cpp * \include Tridiagonalization_decomposeInPlace.cpp
* Output: \verbinclude Tridiagonalization_decomposeInPlace.out * Output: \verbinclude Tridiagonalization_decomposeInPlace.out
* *
@ -367,8 +367,6 @@ Tridiagonalization<MatrixType>::matrixT() const
return matT; return matT;
} }
#ifndef EIGEN_HIDE_HEAVY_CODE
/** \internal /** \internal
* Performs a tridiagonal decomposition of \a matA in place. * Performs a tridiagonal decomposition of \a matA in place.
* *
@ -473,6 +471,4 @@ void Tridiagonalization<MatrixType>::_decomposeInPlace3x3(MatrixType& mat, Diago
} }
} }
#endif // EIGEN_HIDE_HEAVY_CODE
#endif // EIGEN_TRIDIAGONALIZATION_H #endif // EIGEN_TRIDIAGONALIZATION_H

4
Eigen/src/QR/ColPivHouseholderQR.h
View File

@ -347,8 +347,6 @@ template<typename _MatrixType> class ColPivHouseholderQR
Index m_det_pq; Index m_det_pq;
}; };
#ifndef EIGEN_HIDE_HEAVY_CODE
template<typename MatrixType> template<typename MatrixType>
typename MatrixType::RealScalar ColPivHouseholderQR<MatrixType>::absDeterminant() const typename MatrixType::RealScalar ColPivHouseholderQR<MatrixType>::absDeterminant() const
{ {
@ -513,8 +511,6 @@ typename ColPivHouseholderQR<MatrixType>::HouseholderSequenceType ColPivHousehol
return HouseholderSequenceType(m_qr, m_hCoeffs.conjugate(), false, m_nonzero_pivots, 0); return HouseholderSequenceType(m_qr, m_hCoeffs.conjugate(), false, m_nonzero_pivots, 0);
} }
#endif // EIGEN_HIDE_HEAVY_CODE
/** \return the column-pivoting Householder QR decomposition of \c *this. /** \return the column-pivoting Householder QR decomposition of \c *this.
* *
* \sa class ColPivHouseholderQR * \sa class ColPivHouseholderQR

4
Eigen/src/QR/FullPivHouseholderQR.h
View File

@ -271,8 +271,6 @@ template<typename _MatrixType> class FullPivHouseholderQR
Index m_det_pq; Index m_det_pq;
}; };
#ifndef EIGEN_HIDE_HEAVY_CODE
template<typename MatrixType> template<typename MatrixType>
typename MatrixType::RealScalar FullPivHouseholderQR<MatrixType>::absDeterminant() const typename MatrixType::RealScalar FullPivHouseholderQR<MatrixType>::absDeterminant() const
{ {
@ -437,8 +435,6 @@ typename FullPivHouseholderQR<MatrixType>::MatrixQType FullPivHouseholderQR<Matr
return res; return res;
} }
#endif // EIGEN_HIDE_HEAVY_CODE
/** \return the full-pivoting Householder QR decomposition of \c *this. /** \return the full-pivoting Householder QR decomposition of \c *this.
* *
* \sa class FullPivHouseholderQR * \sa class FullPivHouseholderQR

4
Eigen/src/QR/HouseholderQR.h
View File

@ -177,8 +177,6 @@ template<typename _MatrixType> class HouseholderQR
bool m_isInitialized; bool m_isInitialized;
}; };
#ifndef EIGEN_HIDE_HEAVY_CODE
template<typename MatrixType> template<typename MatrixType>
typename MatrixType::RealScalar HouseholderQR<MatrixType>::absDeterminant() const typename MatrixType::RealScalar HouseholderQR<MatrixType>::absDeterminant() const
{ {
@ -254,8 +252,6 @@ struct ei_solve_retval<HouseholderQR<_MatrixType>, Rhs>
} }
}; };
#endif // EIGEN_HIDE_HEAVY_CODE
/** \return the Householder QR decomposition of \c *this. /** \return the Householder QR decomposition of \c *this.
* *
* \sa class HouseholderQR * \sa class HouseholderQR