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
DiagonalMatrix.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// Copyright (C) 2007-2009 Benoit Jacob <jacob.benoit.1@gmail.com>
6//
7// This Source Code Form is subject to the terms of the Mozilla
8// Public License v. 2.0. If a copy of the MPL was not distributed
9// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
10
11#ifndef EIGEN_DIAGONALMATRIX_H
12#define EIGEN_DIAGONALMATRIX_H
13
14namespace Eigen {
15
16#ifndef EIGEN_PARSED_BY_DOXYGEN
17template<typename Derived>
18class DiagonalBase : public EigenBase<Derived>
19{
20 public:
21 typedef typename internal::traits<Derived>::DiagonalVectorType DiagonalVectorType;
22 typedef typename DiagonalVectorType::Scalar Scalar;
23 typedef typename DiagonalVectorType::RealScalar RealScalar;
24 typedef typename internal::traits<Derived>::StorageKind StorageKind;
25 typedef typename internal::traits<Derived>::StorageIndex StorageIndex;
26
27 enum {
28 RowsAtCompileTime = DiagonalVectorType::SizeAtCompileTime,
29 ColsAtCompileTime = DiagonalVectorType::SizeAtCompileTime,
30 MaxRowsAtCompileTime = DiagonalVectorType::MaxSizeAtCompileTime,
31 MaxColsAtCompileTime = DiagonalVectorType::MaxSizeAtCompileTime,
32 IsVectorAtCompileTime = 0,
34 };
35
36 typedef Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, 0, MaxRowsAtCompileTime, MaxColsAtCompileTime> DenseMatrixType;
37 typedef DenseMatrixType DenseType;
38 typedef DiagonalMatrix<Scalar,DiagonalVectorType::SizeAtCompileTime,DiagonalVectorType::MaxSizeAtCompileTime> PlainObject;
39
40 EIGEN_DEVICE_FUNC
41 inline const Derived& derived() const { return *static_cast<const Derived*>(this); }
42 EIGEN_DEVICE_FUNC
43 inline Derived& derived() { return *static_cast<Derived*>(this); }
44
45 EIGEN_DEVICE_FUNC
46 DenseMatrixType toDenseMatrix() const { return derived(); }
47
48 EIGEN_DEVICE_FUNC
49 inline const DiagonalVectorType& diagonal() const { return derived().diagonal(); }
50 EIGEN_DEVICE_FUNC
51 inline DiagonalVectorType& diagonal() { return derived().diagonal(); }
52
53 EIGEN_DEVICE_FUNC
54 inline Index rows() const { return diagonal().size(); }
55 EIGEN_DEVICE_FUNC
56 inline Index cols() const { return diagonal().size(); }
57
58 template<typename MatrixDerived>
59 EIGEN_DEVICE_FUNC
60 const Product<Derived,MatrixDerived,LazyProduct>
61 operator*(const MatrixBase<MatrixDerived> &matrix) const
62 {
63 return Product<Derived, MatrixDerived, LazyProduct>(derived(),matrix.derived());
64 }
65
66 typedef DiagonalWrapper<const CwiseUnaryOp<internal::scalar_inverse_op<Scalar>, const DiagonalVectorType> > InverseReturnType;
67 EIGEN_DEVICE_FUNC
68 inline const InverseReturnType
69 inverse() const
70 {
71 return InverseReturnType(diagonal().cwiseInverse());
72 }
73
74 EIGEN_DEVICE_FUNC
75 inline const DiagonalWrapper<const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(DiagonalVectorType,Scalar,product) >
76 operator*(const Scalar& scalar) const
77 {
78 return DiagonalWrapper<const EIGEN_EXPR_BINARYOP_SCALAR_RETURN_TYPE(DiagonalVectorType,Scalar,product) >(diagonal() * scalar);
79 }
80 EIGEN_DEVICE_FUNC
81 friend inline const DiagonalWrapper<const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(Scalar,DiagonalVectorType,product) >
82 operator*(const Scalar& scalar, const DiagonalBase& other)
83 {
84 return DiagonalWrapper<const EIGEN_SCALAR_BINARYOP_EXPR_RETURN_TYPE(Scalar,DiagonalVectorType,product) >(scalar * other.diagonal());
85 }
86
87 template<typename OtherDerived>
88 EIGEN_DEVICE_FUNC
89 #ifdef EIGEN_PARSED_BY_DOXYGEN
90 inline unspecified_expression_type
91 #else
92 inline const DiagonalWrapper<const EIGEN_CWISE_BINARY_RETURN_TYPE(DiagonalVectorType,typename OtherDerived::DiagonalVectorType,sum) >
93 #endif
94 operator+(const DiagonalBase<OtherDerived>& other) const
95 {
96 return (diagonal() + other.diagonal()).asDiagonal();
97 }
98
99 template<typename OtherDerived>
100 EIGEN_DEVICE_FUNC
101 #ifdef EIGEN_PARSED_BY_DOXYGEN
102 inline unspecified_expression_type
103 #else
104 inline const DiagonalWrapper<const EIGEN_CWISE_BINARY_RETURN_TYPE(DiagonalVectorType,typename OtherDerived::DiagonalVectorType,difference) >
105 #endif
106 operator-(const DiagonalBase<OtherDerived>& other) const
107 {
108 return (diagonal() - other.diagonal()).asDiagonal();
109 }
110};
111
112#endif
113
127namespace internal {
128template<typename _Scalar, int SizeAtCompileTime, int MaxSizeAtCompileTime>
129struct traits<DiagonalMatrix<_Scalar,SizeAtCompileTime,MaxSizeAtCompileTime> >
130 : traits<Matrix<_Scalar,SizeAtCompileTime,SizeAtCompileTime,0,MaxSizeAtCompileTime,MaxSizeAtCompileTime> >
131{
132 typedef Matrix<_Scalar,SizeAtCompileTime,1,0,MaxSizeAtCompileTime,1> DiagonalVectorType;
133 typedef DiagonalShape StorageKind;
134 enum {
136 };
137};
138}
139template<typename _Scalar, int SizeAtCompileTime, int MaxSizeAtCompileTime>
141 : public DiagonalBase<DiagonalMatrix<_Scalar,SizeAtCompileTime,MaxSizeAtCompileTime> >
142{
143 public:
144 #ifndef EIGEN_PARSED_BY_DOXYGEN
145 typedef typename internal::traits<DiagonalMatrix>::DiagonalVectorType DiagonalVectorType;
146 typedef const DiagonalMatrix& Nested;
147 typedef _Scalar Scalar;
148 typedef typename internal::traits<DiagonalMatrix>::StorageKind StorageKind;
149 typedef typename internal::traits<DiagonalMatrix>::StorageIndex StorageIndex;
150 #endif
151
152 protected:
153
154 DiagonalVectorType m_diagonal;
155
156 public:
157
159 EIGEN_DEVICE_FUNC
160 inline const DiagonalVectorType& diagonal() const { return m_diagonal; }
162 EIGEN_DEVICE_FUNC
163 inline DiagonalVectorType& diagonal() { return m_diagonal; }
164
166 EIGEN_DEVICE_FUNC
167 inline DiagonalMatrix() {}
168
170 EIGEN_DEVICE_FUNC
171 explicit inline DiagonalMatrix(Index dim) : m_diagonal(dim) {}
172
174 EIGEN_DEVICE_FUNC
175 inline DiagonalMatrix(const Scalar& x, const Scalar& y) : m_diagonal(x,y) {}
176
178 EIGEN_DEVICE_FUNC
179 inline DiagonalMatrix(const Scalar& x, const Scalar& y, const Scalar& z) : m_diagonal(x,y,z) {}
180
181 #if EIGEN_HAS_CXX11
192 template <typename... ArgTypes>
193 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
194 DiagonalMatrix(const Scalar& a0, const Scalar& a1, const Scalar& a2, const ArgTypes&... args)
195 : m_diagonal(a0, a1, a2, args...) {}
196
200 EIGEN_DEVICE_FUNC
201 explicit EIGEN_STRONG_INLINE DiagonalMatrix(const std::initializer_list<std::initializer_list<Scalar>>& list)
202 : m_diagonal(list) {}
203 #endif // EIGEN_HAS_CXX11
204
206 template<typename OtherDerived>
207 EIGEN_DEVICE_FUNC
208 inline DiagonalMatrix(const DiagonalBase<OtherDerived>& other) : m_diagonal(other.diagonal()) {}
209
210 #ifndef EIGEN_PARSED_BY_DOXYGEN
212 inline DiagonalMatrix(const DiagonalMatrix& other) : m_diagonal(other.diagonal()) {}
213 #endif
214
216 template<typename OtherDerived>
217 EIGEN_DEVICE_FUNC
218 explicit inline DiagonalMatrix(const MatrixBase<OtherDerived>& other) : m_diagonal(other)
219 {}
220
222 template<typename OtherDerived>
223 EIGEN_DEVICE_FUNC
224 DiagonalMatrix& operator=(const DiagonalBase<OtherDerived>& other)
225 {
226 m_diagonal = other.diagonal();
227 return *this;
228 }
229
230 #ifndef EIGEN_PARSED_BY_DOXYGEN
234 EIGEN_DEVICE_FUNC
236 {
237 m_diagonal = other.diagonal();
238 return *this;
239 }
240 #endif
241
243 EIGEN_DEVICE_FUNC
244 inline void resize(Index size) { m_diagonal.resize(size); }
246 EIGEN_DEVICE_FUNC
247 inline void setZero() { m_diagonal.setZero(); }
249 EIGEN_DEVICE_FUNC
250 inline void setZero(Index size) { m_diagonal.setZero(size); }
252 EIGEN_DEVICE_FUNC
253 inline void setIdentity() { m_diagonal.setOnes(); }
255 EIGEN_DEVICE_FUNC
256 inline void setIdentity(Index size) { m_diagonal.setOnes(size); }
257};
258
273namespace internal {
274template<typename _DiagonalVectorType>
275struct traits<DiagonalWrapper<_DiagonalVectorType> >
276{
277 typedef _DiagonalVectorType DiagonalVectorType;
278 typedef typename DiagonalVectorType::Scalar Scalar;
279 typedef typename DiagonalVectorType::StorageIndex StorageIndex;
280 typedef DiagonalShape StorageKind;
281 typedef typename traits<DiagonalVectorType>::XprKind XprKind;
282 enum {
283 RowsAtCompileTime = DiagonalVectorType::SizeAtCompileTime,
284 ColsAtCompileTime = DiagonalVectorType::SizeAtCompileTime,
285 MaxRowsAtCompileTime = DiagonalVectorType::MaxSizeAtCompileTime,
286 MaxColsAtCompileTime = DiagonalVectorType::MaxSizeAtCompileTime,
287 Flags = (traits<DiagonalVectorType>::Flags & LvalueBit) | NoPreferredStorageOrderBit
288 };
289};
290}
291
292template<typename _DiagonalVectorType>
294 : public DiagonalBase<DiagonalWrapper<_DiagonalVectorType> >, internal::no_assignment_operator
295{
296 public:
297 #ifndef EIGEN_PARSED_BY_DOXYGEN
298 typedef _DiagonalVectorType DiagonalVectorType;
299 typedef DiagonalWrapper Nested;
300 #endif
301
303 EIGEN_DEVICE_FUNC
304 explicit inline DiagonalWrapper(DiagonalVectorType& a_diagonal) : m_diagonal(a_diagonal) {}
305
307 EIGEN_DEVICE_FUNC
308 const DiagonalVectorType& diagonal() const { return m_diagonal; }
309
310 protected:
311 typename DiagonalVectorType::Nested m_diagonal;
312};
313
323template<typename Derived>
324EIGEN_DEVICE_FUNC inline const DiagonalWrapper<const Derived>
326{
327 return DiagonalWrapper<const Derived>(derived());
328}
329
338template<typename Derived>
339bool MatrixBase<Derived>::isDiagonal(const RealScalar& prec) const
340{
341 if(cols() != rows()) return false;
342 RealScalar maxAbsOnDiagonal = static_cast<RealScalar>(-1);
343 for(Index j = 0; j < cols(); ++j)
344 {
345 RealScalar absOnDiagonal = numext::abs(coeff(j,j));
346 if(absOnDiagonal > maxAbsOnDiagonal) maxAbsOnDiagonal = absOnDiagonal;
347 }
348 for(Index j = 0; j < cols(); ++j)
349 for(Index i = 0; i < j; ++i)
350 {
351 if(!internal::isMuchSmallerThan(coeff(i, j), maxAbsOnDiagonal, prec)) return false;
352 if(!internal::isMuchSmallerThan(coeff(j, i), maxAbsOnDiagonal, prec)) return false;
353 }
354 return true;
355}
356
357namespace internal {
358
359template<> struct storage_kind_to_shape<DiagonalShape> { typedef DiagonalShape Shape; };
360
361struct Diagonal2Dense {};
362
363template<> struct AssignmentKind<DenseShape,DiagonalShape> { typedef Diagonal2Dense Kind; };
364
365// Diagonal matrix to Dense assignment
366template< typename DstXprType, typename SrcXprType, typename Functor>
367struct Assignment<DstXprType, SrcXprType, Functor, Diagonal2Dense>
368{
369 static void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
370 {
371 Index dstRows = src.rows();
372 Index dstCols = src.cols();
373 if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
374 dst.resize(dstRows, dstCols);
375
376 dst.setZero();
377 dst.diagonal() = src.diagonal();
378 }
379
380 static void run(DstXprType &dst, const SrcXprType &src, const internal::add_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
381 { dst.diagonal() += src.diagonal(); }
382
383 static void run(DstXprType &dst, const SrcXprType &src, const internal::sub_assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar> &/*func*/)
384 { dst.diagonal() -= src.diagonal(); }
385};
386
387} // namespace internal
388
389} // end namespace Eigen
390
391#endif // EIGEN_DIAGONALMATRIX_H
internal::traits< Derived >::StorageIndex StorageIndex
The type used to store indices.
Definition: DenseBase.h:63
internal::traits< Derived >::Scalar Scalar
Definition: DenseBase.h:66
Represents a diagonal matrix with its storage.
Definition: DiagonalMatrix.h:142
DiagonalMatrix()
Definition: DiagonalMatrix.h:167
DiagonalMatrix(const MatrixBase< OtherDerived > &other)
Definition: DiagonalMatrix.h:218
DiagonalMatrix(const Scalar &x, const Scalar &y, const Scalar &z)
Definition: DiagonalMatrix.h:179
void setIdentity(Index size)
Definition: DiagonalMatrix.h:256
const DiagonalVectorType & diagonal() const
Definition: DiagonalMatrix.h:160
void setZero(Index size)
Definition: DiagonalMatrix.h:250
DiagonalMatrix(const DiagonalBase< OtherDerived > &other)
Definition: DiagonalMatrix.h:208
void setIdentity()
Definition: DiagonalMatrix.h:253
DiagonalMatrix(const Scalar &a0, const Scalar &a1, const Scalar &a2, const ArgTypes &... args)
Construct a diagonal matrix with fixed size from an arbitrary number of coefficients....
Definition: DiagonalMatrix.h:194
DiagonalMatrix(const Scalar &x, const Scalar &y)
Definition: DiagonalMatrix.h:175
DiagonalMatrix(const std::initializer_list< std::initializer_list< Scalar > > &list)
Constructs a DiagonalMatrix and initializes it by elements given by an initializer list of initialize...
Definition: DiagonalMatrix.h:201
DiagonalMatrix(Index dim)
Definition: DiagonalMatrix.h:171
DiagonalMatrix & operator=(const DiagonalBase< OtherDerived > &other)
Definition: DiagonalMatrix.h:224
void setZero()
Definition: DiagonalMatrix.h:247
DiagonalVectorType & diagonal()
Definition: DiagonalMatrix.h:163
void resize(Index size)
Definition: DiagonalMatrix.h:244
Expression of a diagonal matrix.
Definition: DiagonalMatrix.h:295
const DiagonalVectorType & diagonal() const
Definition: DiagonalMatrix.h:308
DiagonalWrapper(DiagonalVectorType &a_diagonal)
Definition: DiagonalMatrix.h:304
Base class for all dense matrices, vectors, and expressions.
Definition: MatrixBase.h:50
const unsigned int NoPreferredStorageOrderBit
Definition: Constants.h:178
const unsigned int LvalueBit
Definition: Constants.h:144
Namespace containing all symbols from the Eigen library.
Definition: Core:141
const Eigen::CwiseUnaryOp< Eigen::internal::scalar_inverse_op< typename Derived::Scalar >, const Derived > inverse(const Eigen::ArrayBase< Derived > &x)
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:74