Eigen  3.4.90 (git rev 67eeba6e720c5745abc77ae6c92ce0a44aa7b7ae)
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 
15 namespace Eigen {
16 
33 namespace internal {
34 template<typename MatrixType, unsigned int UpLo>
35 struct traits<SelfAdjointView<MatrixType, UpLo> > : traits<MatrixType>
36 {
37  typedef typename ref_selector<MatrixType>::non_const_type MatrixTypeNested;
38  typedef remove_all_t<MatrixTypeNested> 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 
51 template<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 internal::remove_all_t<typename MatrixType::ConjugateReturnType> 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  {
124  return Product<SelfAdjointView,OtherDerived>(*this, rhs.derived());
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  std::conditional_t<(TriMode&(Upper|Lower))==(UpLo&(Upper|Lower)),
187  {
188  std::conditional_t<(TriMode&(Upper|Lower))==(UpLo&(Upper|Lower)), MatrixType&, typename MatrixType::ConstTransposeReturnType> tmp1(m_matrix);
189  std::conditional_t<(TriMode&(Upper|Lower))==(UpLo&(Upper|Lower)), MatrixType&, typename MatrixType::AdjointReturnType> tmp2(tmp1);
190  return std::conditional_t<(TriMode&(Upper|Lower))==(UpLo&(Upper|Lower)),
193  }
194 
195  typedef SelfAdjointView<const MatrixConjugateReturnType,UpLo> ConjugateReturnType;
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 std::conditional_t<Cond,ConjugateReturnType,ConstSelfAdjointView>
207  conjugateIf() const
208  {
209  typedef std::conditional_t<Cond,ConjugateReturnType,ConstSelfAdjointView> 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(std::enable_if_t<Eigen::internal::is_lvalue<MatrixType>::value, Dummy*> = nullptr)
224  {
225  typename MatrixType::TransposeReturnType tmp(m_matrix);
226  return TransposeReturnType(tmp);
227  }
228 
231  EIGEN_DEVICE_FUNC
232  inline const ConstTransposeReturnType transpose() const
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 
279 namespace 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)
284 template<typename MatrixType, unsigned int Mode>
285 struct 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 
291 template<int UpLo, int SetOpposite, typename DstEvaluatorTypeT, typename SrcEvaluatorTypeT, typename Functor, int Version>
292 class triangular_dense_assignment_kernel<UpLo,SelfAdjoint,SetOpposite,DstEvaluatorTypeT,SrcEvaluatorTypeT,Functor,Version>
293  : public generic_dense_assignment_kernel<DstEvaluatorTypeT, SrcEvaluatorTypeT, Functor, Version>
294 {
295 protected:
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;
302 public:
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 
338 template<typename Derived>
339 template<unsigned int UpLo>
340 EIGEN_DEVICE_FUNC typename MatrixBase<Derived>::template ConstSelfAdjointViewReturnType<UpLo>::Type
342 {
343  return typename ConstSelfAdjointViewReturnType<UpLo>::Type(derived());
344 }
345 
355 template<typename Derived>
356 template<unsigned int UpLo>
357 EIGEN_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
std::conditional_t< Cond, ConjugateReturnType, ConstSelfAdjointView > conjugateIf() const
Definition: SelfAdjointView.h:207
RealScalar operatorNorm() const
Computes the L2 operator norm.
Definition: MatrixBaseEigenvalues.h:153
TransposeReturnType transpose(std::enable_if_t< Eigen::internal::is_lvalue< MatrixType >::value, Dummy * >=nullptr)
Definition: SelfAdjointView.h:223
const LLT< PlainObject, UpLo > llt() const
Definition: LLT.h:548
SelfAdjointView & rankUpdate(const MatrixBase< DerivedU > &u, const MatrixBase< DerivedV > &v, const Scalar &alpha=Scalar(1))
const AdjointReturnType adjoint() const
Definition: SelfAdjointView.h:216
const LDLT< PlainObject, UpLo > ldlt() const
Definition: LDLT.h:667
const Product< SelfAdjointView, OtherDerived > operator*(const MatrixBase< OtherDerived > &rhs) const
Definition: SelfAdjointView.h:122
internal::traits< SelfAdjointView >::Scalar Scalar
The type of coefficients in this matrix.
Definition: SelfAdjointView.h:64
friend const Product< OtherDerived, SelfAdjointView > operator*(const MatrixBase< OtherDerived > &lhs, const SelfAdjointView &rhs)
Definition: SelfAdjointView.h:131
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
std::conditional_t<(TriMode &(Upper|Lower))==(UpLo &(Upper|Lower)), TriangularView< MatrixType, TriMode >, TriangularView< typename MatrixType::AdjointReturnType, TriMode > > triangularView() const
Definition: SelfAdjointView.h:186
NumTraits< Scalar >::Real RealScalar
Definition: SelfAdjointView.h:256
Scalar & coeffRef(Index row, Index col)
Definition: SelfAdjointView.h:102
const ConjugateReturnType conjugate() const
Definition: SelfAdjointView.h:198
EigenvaluesReturnType eigenvalues() const
Computes the eigenvalues of a matrix.
Definition: MatrixBaseEigenvalues.h:90
SelfAdjointView & rankUpdate(const MatrixBase< DerivedU > &u, const Scalar &alpha=Scalar(1))
Base class for triangular part in a matrix.
Definition: TriangularMatrix.h:30
Expression of a triangular part in a matrix.
Definition: TriangularMatrix.h:190
@ 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: Core:139
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:231