// This file is part of Eigen, a lightweight C++ template library // for linear algebra. // // Copyright (C) 2006-2008 Benoit Jacob <[email protected]> // Copyright (C) 2009-2014 Gael Guennebaud <[email protected]> // // This Source Code Form is subject to the terms of the Mozilla // Public License v. 2.0. If a copy of the MPL was not distributed // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. #ifndef EIGEN_TRANSPOSE_H #define EIGEN_TRANSPOSE_H // IWYU pragma: private #include "./InternalHeaderCheck.h" namespace Eigen { namespace internal { traits<Transpose<MatrixType>>; } // namespace internal template <typename MatrixType, typename StorageKind> class TransposeImpl; /** \class Transpose * \ingroup Core_Module * * \brief Expression of the transpose of a matrix * * \tparam MatrixType the type of the object of which we are taking the transpose * * This class represents an expression of the transpose of a matrix. * It is the return type of MatrixBase::transpose() and MatrixBase::adjoint() * and most of the time this is the only way it is used. * * \sa MatrixBase::transpose(), MatrixBase::adjoint() */ template <typename MatrixType> class Transpose : public TransposeImpl<MatrixType, typename internal::traits<MatrixType>::StorageKind> { … }; namespace internal { template <typename MatrixType, bool HasDirectAccess = has_direct_access<MatrixType>::ret> struct TransposeImpl_base { … }; TransposeImpl_base<MatrixType, false>; } // end namespace internal // Generic API dispatcher template <typename XprType, typename StorageKind> class TransposeImpl : public internal::generic_xpr_base<Transpose<XprType> >::type { … }; TransposeImpl<MatrixType, Dense>; /** \returns an expression of the transpose of *this. * * Example: \include MatrixBase_transpose.cpp * Output: \verbinclude MatrixBase_transpose.out * * \warning If you want to replace a matrix by its own transpose, do \b NOT do this: * \code * m = m.transpose(); // bug!!! caused by aliasing effect * \endcode * Instead, use the transposeInPlace() method: * \code * m.transposeInPlace(); * \endcode * which gives Eigen good opportunities for optimization, or alternatively you can also do: * \code * m = m.transpose().eval(); * \endcode * * \sa transposeInPlace(), adjoint() */ template <typename Derived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename DenseBase<Derived>::TransposeReturnType DenseBase<Derived>::transpose() { … } /** This is the const version of transpose(). * * Make sure you read the warning for transpose() ! * * \sa transposeInPlace(), adjoint() */ template <typename Derived> EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename DenseBase<Derived>::ConstTransposeReturnType DenseBase<Derived>::transpose() const { … } /** \returns an expression of the adjoint (i.e. conjugate transpose) of *this. * * Example: \include MatrixBase_adjoint.cpp * Output: \verbinclude MatrixBase_adjoint.out * * \warning If you want to replace a matrix by its own adjoint, do \b NOT do this: * \code * m = m.adjoint(); // bug!!! caused by aliasing effect * \endcode * Instead, use the adjointInPlace() method: * \code * m.adjointInPlace(); * \endcode * which gives Eigen good opportunities for optimization, or alternatively you can also do: * \code * m = m.adjoint().eval(); * \endcode * * \sa adjointInPlace(), transpose(), conjugate(), class Transpose, class internal::scalar_conjugate_op */ template <typename Derived> EIGEN_DEVICE_FUNC inline const typename MatrixBase<Derived>::AdjointReturnType MatrixBase<Derived>::adjoint() const { … } /*************************************************************************** * "in place" transpose implementation ***************************************************************************/ namespace internal { template <typename MatrixType, bool IsSquare = (MatrixType::RowsAtCompileTime == MatrixType::ColsAtCompileTime) && MatrixType::RowsAtCompileTime != Dynamic, bool MatchPacketSize = (int(MatrixType::RowsAtCompileTime) == int(internal::packet_traits<typename MatrixType::Scalar>::size)) && (internal::evaluator<MatrixType>::Flags & PacketAccessBit)> struct inplace_transpose_selector; inplace_transpose_selector<MatrixType, true, false>; inplace_transpose_selector<MatrixType, true, true>; template <typename MatrixType, Index Alignment> void BlockedInPlaceTranspose(MatrixType& m) { … } inplace_transpose_selector<MatrixType, false, MatchPacketSize>; } // end namespace internal /** This is the "in place" version of transpose(): it replaces \c *this by its own transpose. * Thus, doing * \code * m.transposeInPlace(); * \endcode * has the same effect on m as doing * \code * m = m.transpose().eval(); * \endcode * and is faster and also safer because in the latter line of code, forgetting the eval() results * in a bug caused by \ref TopicAliasing "aliasing". * * Notice however that this method is only useful if you want to replace a matrix by its own transpose. * If you just need the transpose of a matrix, use transpose(). * * \note if the matrix is not square, then \c *this must be a resizable matrix. * This excludes (non-square) fixed-size matrices, block-expressions and maps. * * \sa transpose(), adjoint(), adjointInPlace() */ template <typename Derived> EIGEN_DEVICE_FUNC inline void DenseBase<Derived>::transposeInPlace() { … } /*************************************************************************** * "in place" adjoint implementation ***************************************************************************/ /** This is the "in place" version of adjoint(): it replaces \c *this by its own transpose. * Thus, doing * \code * m.adjointInPlace(); * \endcode * has the same effect on m as doing * \code * m = m.adjoint().eval(); * \endcode * and is faster and also safer because in the latter line of code, forgetting the eval() results * in a bug caused by aliasing. * * Notice however that this method is only useful if you want to replace a matrix by its own adjoint. * If you just need the adjoint of a matrix, use adjoint(). * * \note if the matrix is not square, then \c *this must be a resizable matrix. * This excludes (non-square) fixed-size matrices, block-expressions and maps. * * \sa transpose(), adjoint(), transposeInPlace() */ template <typename Derived> EIGEN_DEVICE_FUNC inline void MatrixBase<Derived>::adjointInPlace() { … } #ifndef EIGEN_NO_DEBUG // The following is to detect aliasing problems in most common cases. namespace internal { template <bool DestIsTransposed, typename OtherDerived> struct check_transpose_aliasing_compile_time_selector { … }; check_transpose_aliasing_compile_time_selector<DestIsTransposed, CwiseBinaryOp<BinOp, DerivedA, DerivedB>>; template <typename Scalar, bool DestIsTransposed, typename OtherDerived> struct check_transpose_aliasing_run_time_selector { … }; check_transpose_aliasing_run_time_selector<Scalar, DestIsTransposed, CwiseBinaryOp<BinOp, DerivedA, DerivedB>>; // the following selector, checkTransposeAliasing_impl, based on MightHaveTransposeAliasing, // is because when the condition controlling the assert is known at compile time, ICC emits a warning. // This is actually a good warning: in expressions that don't have any transposing, the condition is // known at compile time to be false, and using that, we can avoid generating the code of the assert again // and again for all these expressions that don't need it. template <typename Derived, typename OtherDerived, bool MightHaveTransposeAliasing = check_transpose_aliasing_compile_time_selector<blas_traits<Derived>::IsTransposed, OtherDerived>::ret> struct checkTransposeAliasing_impl { … }; checkTransposeAliasing_impl<Derived, OtherDerived, false>; template <typename Dst, typename Src> EIGEN_DEVICE_FUNC inline void check_for_aliasing(const Dst& dst, const Src& src) { … } } // end namespace internal #endif // EIGEN_NO_DEBUG } // end namespace Eigen #endif // EIGEN_TRANSPOSE_H
Codebase Browser
chromium