| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| #ifndef EIGEN_PERMUTATIONMATRIX_H |
| #define EIGEN_PERMUTATIONMATRIX_H |
|
|
| namespace Eigen { |
|
|
| namespace internal { |
|
|
| enum PermPermProduct_t {PermPermProduct}; |
|
|
| } |
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| template<typename Derived> |
| class PermutationBase : public EigenBase<Derived> |
| { |
| typedef internal::traits<Derived> Traits; |
| typedef EigenBase<Derived> Base; |
| public: |
|
|
| #ifndef EIGEN_PARSED_BY_DOXYGEN |
| typedef typename Traits::IndicesType IndicesType; |
| enum { |
| Flags = Traits::Flags, |
| RowsAtCompileTime = Traits::RowsAtCompileTime, |
| ColsAtCompileTime = Traits::ColsAtCompileTime, |
| MaxRowsAtCompileTime = Traits::MaxRowsAtCompileTime, |
| MaxColsAtCompileTime = Traits::MaxColsAtCompileTime |
| }; |
| typedef typename Traits::StorageIndex StorageIndex; |
| typedef Matrix<StorageIndex,RowsAtCompileTime,ColsAtCompileTime,0,MaxRowsAtCompileTime,MaxColsAtCompileTime> |
| DenseMatrixType; |
| typedef PermutationMatrix<IndicesType::SizeAtCompileTime,IndicesType::MaxSizeAtCompileTime,StorageIndex> |
| PlainPermutationType; |
| typedef PlainPermutationType PlainObject; |
| using Base::derived; |
| typedef Inverse<Derived> InverseReturnType; |
| typedef void Scalar; |
| #endif |
|
|
| |
| template<typename OtherDerived> |
| Derived& operator=(const PermutationBase<OtherDerived>& other) |
| { |
| indices() = other.indices(); |
| return derived(); |
| } |
|
|
| |
| template<typename OtherDerived> |
| Derived& operator=(const TranspositionsBase<OtherDerived>& tr) |
| { |
| setIdentity(tr.size()); |
| for(Index k=size()-1; k>=0; --k) |
| applyTranspositionOnTheRight(k,tr.coeff(k)); |
| return derived(); |
| } |
|
|
| |
| inline EIGEN_DEVICE_FUNC Index rows() const { return Index(indices().size()); } |
|
|
| |
| inline EIGEN_DEVICE_FUNC Index cols() const { return Index(indices().size()); } |
|
|
| |
| inline EIGEN_DEVICE_FUNC Index size() const { return Index(indices().size()); } |
|
|
| #ifndef EIGEN_PARSED_BY_DOXYGEN |
| template<typename DenseDerived> |
| void evalTo(MatrixBase<DenseDerived>& other) const |
| { |
| other.setZero(); |
| for (Index i=0; i<rows(); ++i) |
| other.coeffRef(indices().coeff(i),i) = typename DenseDerived::Scalar(1); |
| } |
| #endif |
|
|
| |
| |
| |
| |
| DenseMatrixType toDenseMatrix() const |
| { |
| return derived(); |
| } |
|
|
| |
| const IndicesType& indices() const { return derived().indices(); } |
| |
| IndicesType& indices() { return derived().indices(); } |
|
|
| |
| |
| inline void resize(Index newSize) |
| { |
| indices().resize(newSize); |
| } |
|
|
| |
| void setIdentity() |
| { |
| StorageIndex n = StorageIndex(size()); |
| for(StorageIndex i = 0; i < n; ++i) |
| indices().coeffRef(i) = i; |
| } |
|
|
| |
| |
| void setIdentity(Index newSize) |
| { |
| resize(newSize); |
| setIdentity(); |
| } |
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| Derived& applyTranspositionOnTheLeft(Index i, Index j) |
| { |
| eigen_assert(i>=0 && j>=0 && i<size() && j<size()); |
| for(Index k = 0; k < size(); ++k) |
| { |
| if(indices().coeff(k) == i) indices().coeffRef(k) = StorageIndex(j); |
| else if(indices().coeff(k) == j) indices().coeffRef(k) = StorageIndex(i); |
| } |
| return derived(); |
| } |
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| Derived& applyTranspositionOnTheRight(Index i, Index j) |
| { |
| eigen_assert(i>=0 && j>=0 && i<size() && j<size()); |
| std::swap(indices().coeffRef(i), indices().coeffRef(j)); |
| return derived(); |
| } |
|
|
| |
| |
| |
| |
| inline InverseReturnType inverse() const |
| { return InverseReturnType(derived()); } |
| |
| |
| |
| |
| inline InverseReturnType transpose() const |
| { return InverseReturnType(derived()); } |
|
|
| |
|
|
| |
| #ifndef EIGEN_PARSED_BY_DOXYGEN |
| protected: |
| template<typename OtherDerived> |
| void assignTranspose(const PermutationBase<OtherDerived>& other) |
| { |
| for (Index i=0; i<rows();++i) indices().coeffRef(other.indices().coeff(i)) = i; |
| } |
| template<typename Lhs,typename Rhs> |
| void assignProduct(const Lhs& lhs, const Rhs& rhs) |
| { |
| eigen_assert(lhs.cols() == rhs.rows()); |
| for (Index i=0; i<rows();++i) indices().coeffRef(i) = lhs.indices().coeff(rhs.indices().coeff(i)); |
| } |
| #endif |
|
|
| public: |
|
|
| |
| |
| |
| |
| template<typename Other> |
| inline PlainPermutationType operator*(const PermutationBase<Other>& other) const |
| { return PlainPermutationType(internal::PermPermProduct, derived(), other.derived()); } |
|
|
| |
| |
| |
| |
| template<typename Other> |
| inline PlainPermutationType operator*(const InverseImpl<Other,PermutationStorage>& other) const |
| { return PlainPermutationType(internal::PermPermProduct, *this, other.eval()); } |
|
|
| |
| |
| |
| |
| template<typename Other> friend |
| inline PlainPermutationType operator*(const InverseImpl<Other, PermutationStorage>& other, const PermutationBase& perm) |
| { return PlainPermutationType(internal::PermPermProduct, other.eval(), perm); } |
| |
| |
| |
| |
| |
| Index determinant() const |
| { |
| Index res = 1; |
| Index n = size(); |
| Matrix<bool,RowsAtCompileTime,1,0,MaxRowsAtCompileTime> mask(n); |
| mask.fill(false); |
| Index r = 0; |
| while(r < n) |
| { |
| |
| while(r<n && mask[r]) r++; |
| if(r>=n) |
| break; |
| |
| Index k0 = r++; |
| mask.coeffRef(k0) = true; |
| for(Index k=indices().coeff(k0); k!=k0; k=indices().coeff(k)) |
| { |
| mask.coeffRef(k) = true; |
| res = -res; |
| } |
| } |
| return res; |
| } |
|
|
| protected: |
|
|
| }; |
|
|
| namespace internal { |
| template<int SizeAtCompileTime, int MaxSizeAtCompileTime, typename _StorageIndex> |
| struct traits<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime, _StorageIndex> > |
| : traits<Matrix<_StorageIndex,SizeAtCompileTime,SizeAtCompileTime,0,MaxSizeAtCompileTime,MaxSizeAtCompileTime> > |
| { |
| typedef PermutationStorage StorageKind; |
| typedef Matrix<_StorageIndex, SizeAtCompileTime, 1, 0, MaxSizeAtCompileTime, 1> IndicesType; |
| typedef _StorageIndex StorageIndex; |
| typedef void Scalar; |
| }; |
| } |
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| template<int SizeAtCompileTime, int MaxSizeAtCompileTime, typename _StorageIndex> |
| class PermutationMatrix : public PermutationBase<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime, _StorageIndex> > |
| { |
| typedef PermutationBase<PermutationMatrix> Base; |
| typedef internal::traits<PermutationMatrix> Traits; |
| public: |
|
|
| typedef const PermutationMatrix& Nested; |
|
|
| #ifndef EIGEN_PARSED_BY_DOXYGEN |
| typedef typename Traits::IndicesType IndicesType; |
| typedef typename Traits::StorageIndex StorageIndex; |
| #endif |
|
|
| inline PermutationMatrix() |
| {} |
|
|
| |
| |
| explicit inline PermutationMatrix(Index size) : m_indices(size) |
| { |
| eigen_internal_assert(size <= NumTraits<StorageIndex>::highest()); |
| } |
|
|
| |
| template<typename OtherDerived> |
| inline PermutationMatrix(const PermutationBase<OtherDerived>& other) |
| : m_indices(other.indices()) {} |
|
|
| |
| |
| |
| |
| |
| |
| |
| template<typename Other> |
| explicit inline PermutationMatrix(const MatrixBase<Other>& indices) : m_indices(indices) |
| {} |
|
|
| |
| template<typename Other> |
| explicit PermutationMatrix(const TranspositionsBase<Other>& tr) |
| : m_indices(tr.size()) |
| { |
| *this = tr; |
| } |
|
|
| |
| template<typename Other> |
| PermutationMatrix& operator=(const PermutationBase<Other>& other) |
| { |
| m_indices = other.indices(); |
| return *this; |
| } |
|
|
| |
| template<typename Other> |
| PermutationMatrix& operator=(const TranspositionsBase<Other>& tr) |
| { |
| return Base::operator=(tr.derived()); |
| } |
|
|
| |
| const IndicesType& indices() const { return m_indices; } |
| |
| IndicesType& indices() { return m_indices; } |
|
|
|
|
| |
|
|
| #ifndef EIGEN_PARSED_BY_DOXYGEN |
| template<typename Other> |
| PermutationMatrix(const InverseImpl<Other,PermutationStorage>& other) |
| : m_indices(other.derived().nestedExpression().size()) |
| { |
| eigen_internal_assert(m_indices.size() <= NumTraits<StorageIndex>::highest()); |
| StorageIndex end = StorageIndex(m_indices.size()); |
| for (StorageIndex i=0; i<end;++i) |
| m_indices.coeffRef(other.derived().nestedExpression().indices().coeff(i)) = i; |
| } |
| template<typename Lhs,typename Rhs> |
| PermutationMatrix(internal::PermPermProduct_t, const Lhs& lhs, const Rhs& rhs) |
| : m_indices(lhs.indices().size()) |
| { |
| Base::assignProduct(lhs,rhs); |
| } |
| #endif |
|
|
| protected: |
|
|
| IndicesType m_indices; |
| }; |
|
|
|
|
| namespace internal { |
| template<int SizeAtCompileTime, int MaxSizeAtCompileTime, typename _StorageIndex, int _PacketAccess> |
| struct traits<Map<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime, _StorageIndex>,_PacketAccess> > |
| : traits<Matrix<_StorageIndex,SizeAtCompileTime,SizeAtCompileTime,0,MaxSizeAtCompileTime,MaxSizeAtCompileTime> > |
| { |
| typedef PermutationStorage StorageKind; |
| typedef Map<const Matrix<_StorageIndex, SizeAtCompileTime, 1, 0, MaxSizeAtCompileTime, 1>, _PacketAccess> IndicesType; |
| typedef _StorageIndex StorageIndex; |
| typedef void Scalar; |
| }; |
| } |
|
|
| template<int SizeAtCompileTime, int MaxSizeAtCompileTime, typename _StorageIndex, int _PacketAccess> |
| class Map<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime, _StorageIndex>,_PacketAccess> |
| : public PermutationBase<Map<PermutationMatrix<SizeAtCompileTime, MaxSizeAtCompileTime, _StorageIndex>,_PacketAccess> > |
| { |
| typedef PermutationBase<Map> Base; |
| typedef internal::traits<Map> Traits; |
| public: |
|
|
| #ifndef EIGEN_PARSED_BY_DOXYGEN |
| typedef typename Traits::IndicesType IndicesType; |
| typedef typename IndicesType::Scalar StorageIndex; |
| #endif |
|
|
| inline Map(const StorageIndex* indicesPtr) |
| : m_indices(indicesPtr) |
| {} |
|
|
| inline Map(const StorageIndex* indicesPtr, Index size) |
| : m_indices(indicesPtr,size) |
| {} |
|
|
| |
| template<typename Other> |
| Map& operator=(const PermutationBase<Other>& other) |
| { return Base::operator=(other.derived()); } |
|
|
| |
| template<typename Other> |
| Map& operator=(const TranspositionsBase<Other>& tr) |
| { return Base::operator=(tr.derived()); } |
|
|
| #ifndef EIGEN_PARSED_BY_DOXYGEN |
| |
| |
| |
| Map& operator=(const Map& other) |
| { |
| m_indices = other.m_indices; |
| return *this; |
| } |
| #endif |
|
|
| |
| const IndicesType& indices() const { return m_indices; } |
| |
| IndicesType& indices() { return m_indices; } |
|
|
| protected: |
|
|
| IndicesType m_indices; |
| }; |
|
|
| template<typename _IndicesType> class TranspositionsWrapper; |
| namespace internal { |
| template<typename _IndicesType> |
| struct traits<PermutationWrapper<_IndicesType> > |
| { |
| typedef PermutationStorage StorageKind; |
| typedef void Scalar; |
| typedef typename _IndicesType::Scalar StorageIndex; |
| typedef _IndicesType IndicesType; |
| enum { |
| RowsAtCompileTime = _IndicesType::SizeAtCompileTime, |
| ColsAtCompileTime = _IndicesType::SizeAtCompileTime, |
| MaxRowsAtCompileTime = IndicesType::MaxSizeAtCompileTime, |
| MaxColsAtCompileTime = IndicesType::MaxSizeAtCompileTime, |
| Flags = 0 |
| }; |
| }; |
| } |
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| template<typename _IndicesType> |
| class PermutationWrapper : public PermutationBase<PermutationWrapper<_IndicesType> > |
| { |
| typedef PermutationBase<PermutationWrapper> Base; |
| typedef internal::traits<PermutationWrapper> Traits; |
| public: |
|
|
| #ifndef EIGEN_PARSED_BY_DOXYGEN |
| typedef typename Traits::IndicesType IndicesType; |
| #endif |
|
|
| inline PermutationWrapper(const IndicesType& indices) |
| : m_indices(indices) |
| {} |
|
|
| |
| const typename internal::remove_all<typename IndicesType::Nested>::type& |
| indices() const { return m_indices; } |
|
|
| protected: |
|
|
| typename IndicesType::Nested m_indices; |
| }; |
|
|
|
|
| |
| |
| template<typename MatrixDerived, typename PermutationDerived> |
| EIGEN_DEVICE_FUNC |
| const Product<MatrixDerived, PermutationDerived, AliasFreeProduct> |
| operator*(const MatrixBase<MatrixDerived> &matrix, |
| const PermutationBase<PermutationDerived>& permutation) |
| { |
| return Product<MatrixDerived, PermutationDerived, AliasFreeProduct> |
| (matrix.derived(), permutation.derived()); |
| } |
|
|
| |
| |
| template<typename PermutationDerived, typename MatrixDerived> |
| EIGEN_DEVICE_FUNC |
| const Product<PermutationDerived, MatrixDerived, AliasFreeProduct> |
| operator*(const PermutationBase<PermutationDerived> &permutation, |
| const MatrixBase<MatrixDerived>& matrix) |
| { |
| return Product<PermutationDerived, MatrixDerived, AliasFreeProduct> |
| (permutation.derived(), matrix.derived()); |
| } |
|
|
|
|
| template<typename PermutationType> |
| class InverseImpl<PermutationType, PermutationStorage> |
| : public EigenBase<Inverse<PermutationType> > |
| { |
| typedef typename PermutationType::PlainPermutationType PlainPermutationType; |
| typedef internal::traits<PermutationType> PermTraits; |
| protected: |
| InverseImpl() {} |
| public: |
| typedef Inverse<PermutationType> InverseType; |
| using EigenBase<Inverse<PermutationType> >::derived; |
|
|
| #ifndef EIGEN_PARSED_BY_DOXYGEN |
| typedef typename PermutationType::DenseMatrixType DenseMatrixType; |
| enum { |
| RowsAtCompileTime = PermTraits::RowsAtCompileTime, |
| ColsAtCompileTime = PermTraits::ColsAtCompileTime, |
| MaxRowsAtCompileTime = PermTraits::MaxRowsAtCompileTime, |
| MaxColsAtCompileTime = PermTraits::MaxColsAtCompileTime |
| }; |
| #endif |
|
|
| #ifndef EIGEN_PARSED_BY_DOXYGEN |
| template<typename DenseDerived> |
| void evalTo(MatrixBase<DenseDerived>& other) const |
| { |
| other.setZero(); |
| for (Index i=0; i<derived().rows();++i) |
| other.coeffRef(i, derived().nestedExpression().indices().coeff(i)) = typename DenseDerived::Scalar(1); |
| } |
| #endif |
|
|
| |
| PlainPermutationType eval() const { return derived(); } |
|
|
| DenseMatrixType toDenseMatrix() const { return derived(); } |
|
|
| |
| |
| template<typename OtherDerived> friend |
| const Product<OtherDerived, InverseType, AliasFreeProduct> |
| operator*(const MatrixBase<OtherDerived>& matrix, const InverseType& trPerm) |
| { |
| return Product<OtherDerived, InverseType, AliasFreeProduct>(matrix.derived(), trPerm.derived()); |
| } |
|
|
| |
| |
| template<typename OtherDerived> |
| const Product<InverseType, OtherDerived, AliasFreeProduct> |
| operator*(const MatrixBase<OtherDerived>& matrix) const |
| { |
| return Product<InverseType, OtherDerived, AliasFreeProduct>(derived(), matrix.derived()); |
| } |
| }; |
|
|
| template<typename Derived> |
| const PermutationWrapper<const Derived> MatrixBase<Derived>::asPermutation() const |
| { |
| return derived(); |
| } |
|
|
| namespace internal { |
|
|
| template<> struct AssignmentKind<DenseShape,PermutationShape> { typedef EigenBase2EigenBase Kind; }; |
|
|
| } |
|
|
| } |
|
|
| #endif |
|
|