Eigne Matrix Class Library
Dependents: Eigen_test Odometry_test AttitudeEstimation_usingTicker MPU9250_Quaternion_Binary_Serial ... more
Diagonal.h
00001 // This file is part of Eigen, a lightweight C++ template library 00002 // for linear algebra. 00003 // 00004 // Copyright (C) 2007-2009 Benoit Jacob <jacob.benoit.1@gmail.com> 00005 // Copyright (C) 2009-2010 Gael Guennebaud <gael.guennebaud@inria.fr> 00006 // 00007 // This Source Code Form is subject to the terms of the Mozilla 00008 // Public License v. 2.0. If a copy of the MPL was not distributed 00009 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 00010 00011 #ifndef EIGEN_DIAGONAL_H 00012 #define EIGEN_DIAGONAL_H 00013 00014 namespace Eigen { 00015 00016 /** \class Diagonal 00017 * \ingroup Core_Module 00018 * 00019 * \brief Expression of a diagonal/subdiagonal/superdiagonal in a matrix 00020 * 00021 * \param MatrixType the type of the object in which we are taking a sub/main/super diagonal 00022 * \param DiagIndex the index of the sub/super diagonal. The default is 0 and it means the main diagonal. 00023 * A positive value means a superdiagonal, a negative value means a subdiagonal. 00024 * You can also use Dynamic so the index can be set at runtime. 00025 * 00026 * The matrix is not required to be square. 00027 * 00028 * This class represents an expression of the main diagonal, or any sub/super diagonal 00029 * of a square matrix. It is the return type of MatrixBase::diagonal() and MatrixBase::diagonal(Index) and most of the 00030 * time this is the only way it is used. 00031 * 00032 * \sa MatrixBase::diagonal(), MatrixBase::diagonal(Index) 00033 */ 00034 00035 namespace internal { 00036 template<typename MatrixType, int DiagIndex> 00037 struct traits<Diagonal<MatrixType,DiagIndex> > 00038 : traits<MatrixType> 00039 { 00040 typedef typename nested<MatrixType>::type MatrixTypeNested; 00041 typedef typename remove_reference<MatrixTypeNested>::type _MatrixTypeNested; 00042 typedef typename MatrixType::StorageKind StorageKind; 00043 enum { 00044 RowsAtCompileTime = (int(DiagIndex) == DynamicIndex || int(MatrixType::SizeAtCompileTime) == Dynamic) ? Dynamic 00045 : (EIGEN_PLAIN_ENUM_MIN(MatrixType::RowsAtCompileTime - EIGEN_PLAIN_ENUM_MAX(-DiagIndex, 0), 00046 MatrixType::ColsAtCompileTime - EIGEN_PLAIN_ENUM_MAX( DiagIndex, 0))), 00047 ColsAtCompileTime = 1, 00048 MaxRowsAtCompileTime = int(MatrixType::MaxSizeAtCompileTime) == Dynamic ? Dynamic 00049 : DiagIndex == DynamicIndex ? EIGEN_SIZE_MIN_PREFER_FIXED(MatrixType::MaxRowsAtCompileTime, 00050 MatrixType::MaxColsAtCompileTime) 00051 : (EIGEN_PLAIN_ENUM_MIN(MatrixType::MaxRowsAtCompileTime - EIGEN_PLAIN_ENUM_MAX(-DiagIndex, 0), 00052 MatrixType::MaxColsAtCompileTime - EIGEN_PLAIN_ENUM_MAX( DiagIndex, 0))), 00053 MaxColsAtCompileTime = 1, 00054 MaskLvalueBit = is_lvalue<MatrixType>::value ? LvalueBit : 0, 00055 Flags = (unsigned int)_MatrixTypeNested::Flags & (HereditaryBits | LinearAccessBit | MaskLvalueBit | DirectAccessBit) & ~RowMajorBit, 00056 CoeffReadCost = _MatrixTypeNested::CoeffReadCost, 00057 MatrixTypeOuterStride = outer_stride_at_compile_time<MatrixType>::ret, 00058 InnerStrideAtCompileTime = MatrixTypeOuterStride == Dynamic ? Dynamic : MatrixTypeOuterStride+1, 00059 OuterStrideAtCompileTime = 0 00060 }; 00061 }; 00062 } 00063 00064 template<typename MatrixType, int _DiagIndex> class Diagonal 00065 : public internal::dense_xpr_base< Diagonal<MatrixType,_DiagIndex> >::type 00066 { 00067 public: 00068 00069 enum { DiagIndex = _DiagIndex }; 00070 typedef typename internal::dense_xpr_base<Diagonal>::type Base; 00071 EIGEN_DENSE_PUBLIC_INTERFACE(Diagonal) 00072 00073 inline Diagonal(MatrixType& matrix, Index a_index = DiagIndex) : m_matrix(matrix), m_index(a_index) {} 00074 00075 EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Diagonal) 00076 00077 inline Index rows() const 00078 { return m_index.value()<0 ? (std::min<Index>)(m_matrix.cols(),m_matrix.rows()+m_index.value()) : (std::min<Index>)(m_matrix.rows(),m_matrix.cols()-m_index.value()); } 00079 00080 inline Index cols() const { return 1; } 00081 00082 inline Index innerStride() const 00083 { 00084 return m_matrix.outerStride() + 1; 00085 } 00086 00087 inline Index outerStride() const 00088 { 00089 return 0; 00090 } 00091 00092 typedef typename internal::conditional< 00093 internal::is_lvalue<MatrixType>::value, 00094 Scalar, 00095 const Scalar 00096 >::type ScalarWithConstIfNotLvalue; 00097 00098 inline ScalarWithConstIfNotLvalue* data() { return &(m_matrix.const_cast_derived().coeffRef(rowOffset(), colOffset())); } 00099 inline const Scalar* data() const { return &(m_matrix.const_cast_derived().coeffRef(rowOffset(), colOffset())); } 00100 00101 inline Scalar& coeffRef(Index row, Index) 00102 { 00103 EIGEN_STATIC_ASSERT_LVALUE(MatrixType) 00104 return m_matrix.const_cast_derived().coeffRef(row+rowOffset(), row+colOffset()); 00105 } 00106 00107 inline const Scalar& coeffRef(Index row, Index) const 00108 { 00109 return m_matrix.const_cast_derived().coeffRef(row+rowOffset(), row+colOffset()); 00110 } 00111 00112 inline CoeffReturnType coeff(Index row, Index) const 00113 { 00114 return m_matrix.coeff(row+rowOffset(), row+colOffset()); 00115 } 00116 00117 inline Scalar& coeffRef(Index idx) 00118 { 00119 EIGEN_STATIC_ASSERT_LVALUE(MatrixType) 00120 return m_matrix.const_cast_derived().coeffRef(idx+rowOffset(), idx+colOffset()); 00121 } 00122 00123 inline const Scalar& coeffRef(Index idx) const 00124 { 00125 return m_matrix.const_cast_derived().coeffRef(idx+rowOffset(), idx+colOffset()); 00126 } 00127 00128 inline CoeffReturnType coeff(Index idx) const 00129 { 00130 return m_matrix.coeff(idx+rowOffset(), idx+colOffset()); 00131 } 00132 00133 const typename internal::remove_all<typename MatrixType::Nested>::type& 00134 nestedExpression() const 00135 { 00136 return m_matrix; 00137 } 00138 00139 int index() const 00140 { 00141 return m_index.value(); 00142 } 00143 00144 protected: 00145 typename MatrixType::Nested m_matrix; 00146 const internal::variable_if_dynamicindex<Index, DiagIndex> m_index; 00147 00148 private: 00149 // some compilers may fail to optimize std::max etc in case of compile-time constants... 00150 EIGEN_STRONG_INLINE Index absDiagIndex() const { return m_index.value()>0 ? m_index.value() : -m_index.value(); } 00151 EIGEN_STRONG_INLINE Index rowOffset() const { return m_index.value()>0 ? 0 : -m_index.value(); } 00152 EIGEN_STRONG_INLINE Index colOffset() const { return m_index.value()>0 ? m_index.value() : 0; } 00153 // triger a compile time error is someone try to call packet 00154 template<int LoadMode> typename MatrixType::PacketReturnType packet(Index) const; 00155 template<int LoadMode> typename MatrixType::PacketReturnType packet(Index,Index) const; 00156 }; 00157 00158 /** \returns an expression of the main diagonal of the matrix \c *this 00159 * 00160 * \c *this is not required to be square. 00161 * 00162 * Example: \include MatrixBase_diagonal.cpp 00163 * Output: \verbinclude MatrixBase_diagonal.out 00164 * 00165 * \sa class Diagonal */ 00166 template<typename Derived> 00167 inline typename MatrixBase<Derived>::DiagonalReturnType 00168 MatrixBase<Derived>::diagonal() 00169 { 00170 return derived(); 00171 } 00172 00173 /** This is the const version of diagonal(). */ 00174 template<typename Derived> 00175 inline typename MatrixBase<Derived>::ConstDiagonalReturnType 00176 MatrixBase<Derived>::diagonal() const 00177 { 00178 return ConstDiagonalReturnType(derived()); 00179 } 00180 00181 /** \returns an expression of the \a DiagIndex-th sub or super diagonal of the matrix \c *this 00182 * 00183 * \c *this is not required to be square. 00184 * 00185 * The template parameter \a DiagIndex represent a super diagonal if \a DiagIndex > 0 00186 * and a sub diagonal otherwise. \a DiagIndex == 0 is equivalent to the main diagonal. 00187 * 00188 * Example: \include MatrixBase_diagonal_int.cpp 00189 * Output: \verbinclude MatrixBase_diagonal_int.out 00190 * 00191 * \sa MatrixBase::diagonal(), class Diagonal */ 00192 template<typename Derived> 00193 inline typename MatrixBase<Derived>::DiagonalDynamicIndexReturnType 00194 MatrixBase<Derived>::diagonal(Index index) 00195 { 00196 return DiagonalDynamicIndexReturnType(derived(), index); 00197 } 00198 00199 /** This is the const version of diagonal(Index). */ 00200 template<typename Derived> 00201 inline typename MatrixBase<Derived>::ConstDiagonalDynamicIndexReturnType 00202 MatrixBase<Derived>::diagonal(Index index) const 00203 { 00204 return ConstDiagonalDynamicIndexReturnType(derived(), index); 00205 } 00206 00207 /** \returns an expression of the \a DiagIndex-th sub or super diagonal of the matrix \c *this 00208 * 00209 * \c *this is not required to be square. 00210 * 00211 * The template parameter \a DiagIndex represent a super diagonal if \a DiagIndex > 0 00212 * and a sub diagonal otherwise. \a DiagIndex == 0 is equivalent to the main diagonal. 00213 * 00214 * Example: \include MatrixBase_diagonal_template_int.cpp 00215 * Output: \verbinclude MatrixBase_diagonal_template_int.out 00216 * 00217 * \sa MatrixBase::diagonal(), class Diagonal */ 00218 template<typename Derived> 00219 template<int Index> 00220 inline typename MatrixBase<Derived>::template DiagonalIndexReturnType<Index>::Type 00221 MatrixBase<Derived>::diagonal() 00222 { 00223 return derived(); 00224 } 00225 00226 /** This is the const version of diagonal<int>(). */ 00227 template<typename Derived> 00228 template<int Index> 00229 inline typename MatrixBase<Derived>::template ConstDiagonalIndexReturnType<Index>::Type 00230 MatrixBase<Derived>::diagonal() const 00231 { 00232 return derived(); 00233 } 00234 00235 } // end namespace Eigen 00236 00237 #endif // EIGEN_DIAGONAL_H
Generated on Tue Jul 12 2022 17:46:52 by 1.7.2