Eigen  3.4.90 (git rev a4098ac676528a83cfb73d4d26ce1b42ec05f47c)
SelfAdjointView.h
1// This file is part of Eigen, a lightweight C++ template library
2// for linear algebra.
3//
4// Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
5//
6// This Source Code Form is subject to the terms of the Mozilla
7// Public License v. 2.0. If a copy of the MPL was not distributed
8// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
9
10#ifndef EIGEN_SELFADJOINTMATRIX_H
11#define EIGEN_SELFADJOINTMATRIX_H
12
13#include "./InternalHeaderCheck.h"
14
15namespace Eigen {
16
33namespace internal {
34template<typename MatrixType, unsigned int UpLo>
35struct traits<SelfAdjointView<MatrixType, UpLo> > : traits<MatrixType>
36{
37 typedef typename ref_selector<MatrixType>::non_const_type MatrixTypeNested;
38 typedef typename remove_all<MatrixTypeNested>::type MatrixTypeNestedCleaned;
39 typedef MatrixType ExpressionType;
40 typedef typename MatrixType::PlainObject FullMatrixType;
41 enum {
42 Mode = UpLo | SelfAdjoint,
43 FlagsLvalueBit = is_lvalue<MatrixType>::value ? LvalueBit : 0,
44 Flags = MatrixTypeNestedCleaned::Flags & (HereditaryBits|FlagsLvalueBit)
45 & (~(PacketAccessBit | DirectAccessBit | LinearAccessBit)) // FIXME these flags should be preserved
46 };
47};
48}
49
50
51template<typename MatrixType_, unsigned int UpLo> class SelfAdjointView
52 : public TriangularBase<SelfAdjointView<MatrixType_, UpLo> >
53{
54 public:
55 EIGEN_STATIC_ASSERT(UpLo==Lower || UpLo==Upper,SELFADJOINTVIEW_ACCEPTS_UPPER_AND_LOWER_MODE_ONLY)
56
57 typedef MatrixType_ MatrixType;
59 typedef typename internal::traits<SelfAdjointView>::MatrixTypeNested MatrixTypeNested;
60 typedef typename internal::traits<SelfAdjointView>::MatrixTypeNestedCleaned MatrixTypeNestedCleaned;
61 typedef MatrixTypeNestedCleaned NestedExpression;
62
64 typedef typename internal::traits<SelfAdjointView>::Scalar Scalar;
65 typedef typename MatrixType::StorageIndex StorageIndex;
66 typedef typename internal::remove_all<typename MatrixType::ConjugateReturnType>::type MatrixConjugateReturnType;
68
69 enum {
70 Mode = internal::traits<SelfAdjointView>::Mode,
71 Flags = internal::traits<SelfAdjointView>::Flags,
72 TransposeMode = ((int(Mode) & int(Upper)) ? Lower : 0) | ((int(Mode) & int(Lower)) ? Upper : 0)
73 };
74 typedef typename MatrixType::PlainObject PlainObject;
75
76 EIGEN_DEVICE_FUNC
77 explicit inline SelfAdjointView(MatrixType& matrix) : m_matrix(matrix) { }
78
79 EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
80 inline Index rows() const EIGEN_NOEXCEPT { return m_matrix.rows(); }
81 EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
82 inline Index cols() const EIGEN_NOEXCEPT { return m_matrix.cols(); }
83 EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
84 inline Index outerStride() const EIGEN_NOEXCEPT { return m_matrix.outerStride(); }
85 EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR
86 inline Index innerStride() const EIGEN_NOEXCEPT { return m_matrix.innerStride(); }
87
91 EIGEN_DEVICE_FUNC
92 inline Scalar coeff(Index row, Index col) const
93 {
94 Base::check_coordinates_internal(row, col);
95 return m_matrix.coeff(row, col);
96 }
97
101 EIGEN_DEVICE_FUNC
102 inline Scalar& coeffRef(Index row, Index col)
103 {
104 EIGEN_STATIC_ASSERT_LVALUE(SelfAdjointView);
105 Base::check_coordinates_internal(row, col);
106 return m_matrix.coeffRef(row, col);
107 }
108
110 EIGEN_DEVICE_FUNC
111 const MatrixTypeNestedCleaned& _expression() const { return m_matrix; }
112
113 EIGEN_DEVICE_FUNC
114 const MatrixTypeNestedCleaned& nestedExpression() const { return m_matrix; }
115 EIGEN_DEVICE_FUNC
116 MatrixTypeNestedCleaned& nestedExpression() { return m_matrix; }
117
119 template<typename OtherDerived>
120 EIGEN_DEVICE_FUNC
121 const Product<SelfAdjointView,OtherDerived>
123 {
125 }
126
128 template<typename OtherDerived> friend
129 EIGEN_DEVICE_FUNC
132 {
134 }
135
136 friend EIGEN_DEVICE_FUNC
137 const SelfAdjointView<const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(Scalar,MatrixType,product),UpLo>
138 operator*(const Scalar& s, const SelfAdjointView& mat)
139 {
140 return (s*mat.nestedExpression()).template selfadjointView<UpLo>();
141 }
142
153 template<typename DerivedU, typename DerivedV>
154 EIGEN_DEVICE_FUNC
156
167 template<typename DerivedU>
168 EIGEN_DEVICE_FUNC
170
181 template<unsigned int TriMode>
182 EIGEN_DEVICE_FUNC
183 typename internal::conditional<(TriMode&(Upper|Lower))==(UpLo&(Upper|Lower)),
187 {
188 typename internal::conditional<(TriMode&(Upper|Lower))==(UpLo&(Upper|Lower)), MatrixType&, typename MatrixType::ConstTransposeReturnType>::type tmp1(m_matrix);
189 typename internal::conditional<(TriMode&(Upper|Lower))==(UpLo&(Upper|Lower)), MatrixType&, typename MatrixType::AdjointReturnType>::type tmp2(tmp1);
190 return typename internal::conditional<(TriMode&(Upper|Lower))==(UpLo&(Upper|Lower)),
193 }
194
197 EIGEN_DEVICE_FUNC
198 inline const ConjugateReturnType conjugate() const
199 { return ConjugateReturnType(m_matrix.conjugate()); }
200
204 template<bool Cond>
205 EIGEN_DEVICE_FUNC
206 inline typename internal::conditional<Cond,ConjugateReturnType,ConstSelfAdjointView>::type
208 {
209 typedef typename internal::conditional<Cond,ConjugateReturnType,ConstSelfAdjointView>::type ReturnType;
210 return ReturnType(m_matrix.template conjugateIf<Cond>());
211 }
212
215 EIGEN_DEVICE_FUNC
216 inline const AdjointReturnType adjoint() const
217 { return AdjointReturnType(m_matrix.adjoint()); }
218
221 template<class Dummy=int>
222 EIGEN_DEVICE_FUNC
223 inline TransposeReturnType transpose(typename internal::enable_if<Eigen::internal::is_lvalue<MatrixType>::value, Dummy*>::type = nullptr)
224 {
225 typename MatrixType::TransposeReturnType tmp(m_matrix);
226 return TransposeReturnType(tmp);
227 }
228
231 EIGEN_DEVICE_FUNC
233 {
234 return ConstTransposeReturnType(m_matrix.transpose());
235 }
236
242 EIGEN_DEVICE_FUNC
243 typename MatrixType::ConstDiagonalReturnType diagonal() const
244 {
245 return typename MatrixType::ConstDiagonalReturnType(m_matrix);
246 }
247
249
250 const LLT<PlainObject, UpLo> llt() const;
251 const LDLT<PlainObject, UpLo> ldlt() const;
252
254
259
260 EIGEN_DEVICE_FUNC
262 EIGEN_DEVICE_FUNC
263 RealScalar operatorNorm() const;
264
265 protected:
266 MatrixTypeNested m_matrix;
267};
268
269
270// template<typename OtherDerived, typename MatrixType, unsigned int UpLo>
271// internal::selfadjoint_matrix_product_returntype<OtherDerived,SelfAdjointView<MatrixType,UpLo> >
272// operator*(const MatrixBase<OtherDerived>& lhs, const SelfAdjointView<MatrixType,UpLo>& rhs)
273// {
274// return internal::matrix_selfadjoint_product_returntype<OtherDerived,SelfAdjointView<MatrixType,UpLo> >(lhs.derived(),rhs);
275// }
276
277// selfadjoint to dense matrix
278
279namespace internal {
280
281// TODO currently a selfadjoint expression has the form SelfAdjointView<.,.>
282// in the future selfadjoint-ness should be defined by the expression traits
283// such that Transpose<SelfAdjointView<.,.> > is valid. (currently TriangularBase::transpose() is overloaded to make it work)
284template<typename MatrixType, unsigned int Mode>
285struct evaluator_traits<SelfAdjointView<MatrixType,Mode> >
286{
287 typedef typename storage_kind_to_evaluator_kind<typename MatrixType::StorageKind>::Kind Kind;
288 typedef SelfAdjointShape Shape;
289};
290
291template<int UpLo, int SetOpposite, typename DstEvaluatorTypeT, typename SrcEvaluatorTypeT, typename Functor, int Version>
292class triangular_dense_assignment_kernel<UpLo,SelfAdjoint,SetOpposite,DstEvaluatorTypeT,SrcEvaluatorTypeT,Functor,Version>
293 : public generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, Version>
294{
295protected:
296 typedef generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, Version> Base;
297 typedef typename Base::DstXprType DstXprType;
298 typedef typename Base::SrcXprType SrcXprType;
299 using Base::m_dst;
300 using Base::m_src;
301 using Base::m_functor;
302public:
303
304 typedef typename Base::DstEvaluatorType DstEvaluatorType;
305 typedef typename Base::SrcEvaluatorType SrcEvaluatorType;
306 typedef typename Base::Scalar Scalar;
307 typedef typename Base::AssignmentTraits AssignmentTraits;
308
309
310 EIGEN_DEVICE_FUNC triangular_dense_assignment_kernel(DstEvaluatorType &dst, const SrcEvaluatorType &src, const Functor &func, DstXprType& dstExpr)
311 : Base(dst, src, func, dstExpr)
312 {}
313
314 EIGEN_DEVICE_FUNC void assignCoeff(Index row, Index col)
315 {
316 eigen_internal_assert(row!=col);
317 Scalar tmp = m_src.coeff(row,col);
318 m_functor.assignCoeff(m_dst.coeffRef(row,col), tmp);
319 m_functor.assignCoeff(m_dst.coeffRef(col,row), numext::conj(tmp));
320 }
321
322 EIGEN_DEVICE_FUNC void assignDiagonalCoeff(Index id)
323 {
324 Base::assignCoeff(id,id);
325 }
326
327 EIGEN_DEVICE_FUNC void assignOppositeCoeff(Index, Index)
328 { eigen_internal_assert(false && "should never be called"); }
329};
330
331} // end namespace internal
332
333/***************************************************************************
334* Implementation of MatrixBase methods
335***************************************************************************/
336
338template<typename Derived>
339template<unsigned int UpLo>
340EIGEN_DEVICE_FUNC typename MatrixBase<Derived>::template ConstSelfAdjointViewReturnType<UpLo>::Type
342{
343 return typename ConstSelfAdjointViewReturnType<UpLo>::Type(derived());
344}
345
355template<typename Derived>
356template<unsigned int UpLo>
357EIGEN_DEVICE_FUNC typename MatrixBase<Derived>::template SelfAdjointViewReturnType<UpLo>::Type
359{
360 return typename SelfAdjointViewReturnType<UpLo>::Type(derived());
361}
362
363} // end namespace Eigen
364
365#endif // EIGEN_SELFADJOINTMATRIX_H
Derived & derived()
Definition: EigenBase.h:48
Robust Cholesky decomposition of a matrix with pivoting.
Definition: LDLT.h:63
Standard Cholesky decomposition (LL^T) of a matrix and associated features.
Definition: LLT.h:70
Base class for all dense matrices, vectors, and expressions.
Definition: MatrixBase.h:52
The matrix class, also used for vectors and row-vectors.
Definition: Matrix.h:182
Expression of the product of two arbitrary matrices or vectors.
Definition: Product.h:77
Expression of a selfadjoint matrix from a triangular part of a dense matrix.
Definition: SelfAdjointView.h:53
Matrix< RealScalar, internal::traits< MatrixType >::ColsAtCompileTime, 1 > EigenvaluesReturnType
Definition: SelfAdjointView.h:258
RealScalar operatorNorm() const
Computes the L2 operator norm.
Definition: MatrixBaseEigenvalues.h:153
internal::conditional< Cond, ConjugateReturnType, ConstSelfAdjointView >::type conjugateIf() const
Definition: SelfAdjointView.h:207
TransposeReturnType transpose(typename internal::enable_if< Eigen::internal::is_lvalue< MatrixType >::value, Dummy * >::type=nullptr)
Definition: SelfAdjointView.h:223
SelfAdjointView & rankUpdate(const MatrixBase< DerivedU > &u, const MatrixBase< DerivedV > &v, const Scalar &alpha=Scalar(1))
const LLT< PlainObject, UpLo > llt() const
Definition: LLT.h:548
const AdjointReturnType adjoint() const
Definition: SelfAdjointView.h:216
const LDLT< PlainObject, UpLo > ldlt() const
Definition: LDLT.h:667
internal::conditional<(TriMode &(Upper|Lower))==(UpLo &(Upper|Lower)), TriangularView< MatrixType, TriMode >, TriangularView< typenameMatrixType::AdjointReturnType, TriMode > >::type triangularView() const
Definition: SelfAdjointView.h:186
internal::traits< SelfAdjointView >::Scalar Scalar
The type of coefficients in this matrix.
Definition: SelfAdjointView.h:64
SelfAdjointView & rankUpdate(const MatrixBase< DerivedU > &u, const Scalar &alpha=Scalar(1))
MatrixType::ConstDiagonalReturnType diagonal() const
Definition: SelfAdjointView.h:243
const ConstTransposeReturnType transpose() const
Definition: SelfAdjointView.h:232
Scalar coeff(Index row, Index col) const
Definition: SelfAdjointView.h:92
NumTraits< Scalar >::Real RealScalar
Definition: SelfAdjointView.h:256
const ConjugateReturnType conjugate() const
Definition: SelfAdjointView.h:198
Scalar & coeffRef(Index row, Index col)
Definition: SelfAdjointView.h:102
const Product< SelfAdjointView, OtherDerived > operator*(const MatrixBase< OtherDerived > &rhs) const
Definition: SelfAdjointView.h:122
EigenvaluesReturnType eigenvalues() const
Computes the eigenvalues of a matrix.
Definition: MatrixBaseEigenvalues.h:90
friend const Product< OtherDerived, SelfAdjointView > operator*(const MatrixBase< OtherDerived > &lhs, const SelfAdjointView &rhs)
Definition: SelfAdjointView.h:131
Base class for triangular part in a matrix.
Definition: TriangularMatrix.h:30
Expression of a triangular part in a matrix.
Definition: TriangularMatrix.h:191
@ SelfAdjoint
Definition: Constants.h:227
@ Lower
Definition: Constants.h:211
@ Upper
Definition: Constants.h:213
const unsigned int PacketAccessBit
Definition: Constants.h:96
const unsigned int LinearAccessBit
Definition: Constants.h:132
const unsigned int DirectAccessBit
Definition: Constants.h:157
const unsigned int LvalueBit
Definition: Constants.h:146
Namespace containing all symbols from the Eigen library.
Definition: B01_Experimental.dox:1
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:59
Eigen::Index Index
The interface type of indices.
Definition: EigenBase.h:41
Holds information about the various numeric (i.e. scalar) types allowed by Eigen.
Definition: NumTraits.h:235