#include <ProductEvaluators.h>

Inheritance diagram for Eigen::internal::diagonal_product_evaluator_base< MatrixType, DiagonalType, Derived, ProductOrder >:

Public Types
enum	{ CoeffReadCost , MatrixFlags = evaluator<MatrixType>::Flags , DiagFlags = evaluator<DiagonalType>::Flags , StorageOrder_ , SameStorageOrder_ = int(StorageOrder_) == ((MatrixFlags & RowMajorBit) ? RowMajor : ColMajor) , ScalarAccessOnDiag_ , SameTypes_ = is_same<typename MatrixType::Scalar, typename DiagonalType::Scalar>::value , Vectorizable_ , LinearAccessMask_ , Flags , Alignment = evaluator<MatrixType>::Alignment , AsScalarProduct }

typedef ScalarBinaryOpTraits< typename MatrixType::Scalar, typename DiagonalType::Scalar >::ReturnType	Scalar

Public Types inherited from Eigen::internal::evaluator_base< Derived >
enum

typedef traits< Derived >	ExpressionTraits

Public Member Functions
EIGEN_DEVICE_FUNC	diagonal_product_evaluator_base (const MatrixType &mat, const DiagonalType &diag)

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar	coeff (Index idx) const

Public Member Functions inherited from Eigen::internal::evaluator_base< Derived >
EIGEN_DEVICE_FUNC constexpr EIGEN_STRONG_INLINE	evaluator_base ()=default

Protected Member Functions
template<int LoadMode, typename PacketType >
EIGEN_STRONG_INLINE PacketType	packet_impl (Index row, Index col, Index id, internal::true_type) const

template<int LoadMode, typename PacketType >
EIGEN_STRONG_INLINE PacketType	packet_impl (Index row, Index col, Index id, internal::false_type) const

Protected Attributes
evaluator< DiagonalType >	m_diagImpl

evaluator< MatrixType >	m_matImpl

Member Typedef Documentation

◆ Scalar

template<typename MatrixType , typename DiagonalType , typename Derived , int ProductOrder>

typedef ScalarBinaryOpTraits<typename MatrixType::Scalar, typename DiagonalType::Scalar>::ReturnType Eigen::internal::diagonal_product_evaluator_base< MatrixType, DiagonalType, Derived, ProductOrder >::Scalar

Member Enumeration Documentation

◆ anonymous enum

template<typename MatrixType , typename DiagonalType , typename Derived , int ProductOrder>

anonymous enum

Enumerator
CoeffReadCost
MatrixFlags
DiagFlags
StorageOrder_
SameStorageOrder_
ScalarAccessOnDiag_
SameTypes_
Vectorizable_
LinearAccessMask_
Flags
Alignment
AsScalarProduct

        {
     CoeffReadCost = int(NumTraits<Scalar>::MulCost) + int(evaluator<MatrixType>::CoeffReadCost) +
                     int(evaluator<DiagonalType>::CoeffReadCost),
  
     MatrixFlags = evaluator<MatrixType>::Flags,
     DiagFlags = evaluator<DiagonalType>::Flags,
  
     StorageOrder_ = (Derived::MaxRowsAtCompileTime == 1 && Derived::MaxColsAtCompileTime != 1)   ? RowMajor
                     : (Derived::MaxColsAtCompileTime == 1 && Derived::MaxRowsAtCompileTime != 1) ? ColMajor
                     : MatrixFlags & RowMajorBit                                                  ? RowMajor
                                                                                                  : ColMajor,
     SameStorageOrder_ = int(StorageOrder_) == ((MatrixFlags & RowMajorBit) ? RowMajor : ColMajor),
  
     ScalarAccessOnDiag_ = !((int(StorageOrder_) == ColMajor && int(ProductOrder) == OnTheLeft) ||
                             (int(StorageOrder_) == RowMajor && int(ProductOrder) == OnTheRight)),
     SameTypes_ = is_same<typename MatrixType::Scalar, typename DiagonalType::Scalar>::value,
     // FIXME currently we need same types, but in the future the next rule should be the one
     // Vectorizable_ = bool(int(MatrixFlags)&PacketAccessBit) && ((!_PacketOnDiag) || (SameTypes_ &&
     // bool(int(DiagFlags)&PacketAccessBit))),
     Vectorizable_ = bool(int(MatrixFlags) & PacketAccessBit) && SameTypes_ &&
                     (SameStorageOrder_ || (MatrixFlags & LinearAccessBit) == LinearAccessBit) &&
                     (ScalarAccessOnDiag_ || (bool(int(DiagFlags) & PacketAccessBit))),
     LinearAccessMask_ =
         (MatrixType::RowsAtCompileTime == 1 || MatrixType::ColsAtCompileTime == 1) ? LinearAccessBit : 0,
     Flags =
         ((HereditaryBits | LinearAccessMask_) & (unsigned int)(MatrixFlags)) | (Vectorizable_ ? PacketAccessBit : 0),
     Alignment = evaluator<MatrixType>::Alignment,
  
     AsScalarProduct =
         (DiagonalType::SizeAtCompileTime == 1) ||
         (DiagonalType::SizeAtCompileTime == Dynamic && MatrixType::RowsAtCompileTime == 1 &&
          ProductOrder == OnTheLeft) ||
         (DiagonalType::SizeAtCompileTime == Dynamic && MatrixType::ColsAtCompileTime == 1 && ProductOrder == OnTheRight)
   };

Constructor & Destructor Documentation

◆ diagonal_product_evaluator_base()

template<typename MatrixType , typename DiagonalType , typename Derived , int ProductOrder>

EIGEN_DEVICE_FUNC Eigen::internal::diagonal_product_evaluator_base< MatrixType, DiagonalType, Derived, ProductOrder >::diagonal_product_evaluator_base	(	const MatrixType &	mat,
		const DiagonalType &	diag
	)

inline

       : m_diagImpl(diag), m_matImpl(mat) {
     EIGEN_INTERNAL_CHECK_COST_VALUE(NumTraits<Scalar>::MulCost);
     EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
   }

References Eigen::internal::diagonal_product_evaluator_base< MatrixType, DiagonalType, Derived, ProductOrder >::CoeffReadCost, and EIGEN_INTERNAL_CHECK_COST_VALUE.

Member Function Documentation

◆ coeff()

template<typename MatrixType , typename DiagonalType , typename Derived , int ProductOrder>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar Eigen::internal::diagonal_product_evaluator_base< MatrixType, DiagonalType, Derived, ProductOrder >::coeff ( Index idx ) const

inline

                                                                             {
     if (AsScalarProduct)
       return m_diagImpl.coeff(0) * m_matImpl.coeff(idx);
     else
       return m_diagImpl.coeff(idx) * m_matImpl.coeff(idx);
   }

References Eigen::internal::diagonal_product_evaluator_base< MatrixType, DiagonalType, Derived, ProductOrder >::AsScalarProduct, Eigen::internal::diagonal_product_evaluator_base< MatrixType, DiagonalType, Derived, ProductOrder >::m_diagImpl, and Eigen::internal::diagonal_product_evaluator_base< MatrixType, DiagonalType, Derived, ProductOrder >::m_matImpl.

◆ packet_impl() [1/2]

template<typename MatrixType , typename DiagonalType , typename Derived , int ProductOrder>

template<int LoadMode, typename PacketType >

EIGEN_STRONG_INLINE PacketType Eigen::internal::diagonal_product_evaluator_base< MatrixType, DiagonalType, Derived, ProductOrder >::packet_impl	(	Index	row,
		Index	col,
		Index	id,
		internal::false_type
	)		const

inlineprotected

                                                                                                        {
     enum {
       InnerSize = (MatrixType::Flags & RowMajorBit) ? MatrixType::ColsAtCompileTime : MatrixType::RowsAtCompileTime,
       DiagonalPacketLoadMode = plain_enum_min(
           LoadMode,
           ((InnerSize % 16) == 0) ? int(Aligned16) : int(evaluator<DiagonalType>::Alignment))  // FIXME hardcoded 16!!
     };
     return internal::pmul(m_matImpl.template packet<LoadMode, PacketType>(row, col),
                           m_diagImpl.template packet<DiagonalPacketLoadMode, PacketType>(id));
   }

References Eigen::Aligned16, col(), int(), Eigen::internal::diagonal_product_evaluator_base< MatrixType, DiagonalType, Derived, ProductOrder >::m_diagImpl, Eigen::internal::diagonal_product_evaluator_base< MatrixType, DiagonalType, Derived, ProductOrder >::m_matImpl, Eigen::internal::plain_enum_min(), Eigen::internal::pmul(), row(), and Eigen::RowMajorBit.

◆ packet_impl() [2/2]

template<typename MatrixType , typename DiagonalType , typename Derived , int ProductOrder>

template<int LoadMode, typename PacketType >

EIGEN_STRONG_INLINE PacketType Eigen::internal::diagonal_product_evaluator_base< MatrixType, DiagonalType, Derived, ProductOrder >::packet_impl	(	Index	row,
		Index	col,
		Index	id,
		internal::true_type
	)		const

inlineprotected

                                                                                                       {
     return internal::pmul(m_matImpl.template packet<LoadMode, PacketType>(row, col),
                           internal::pset1<PacketType>(m_diagImpl.coeff(id)));
   }