#include <TensorFunctors.h>

Public Member Functions
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE	MeanReducer ()

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	reduce (const T t, T *accum)

template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	reducePacket (const Packet &p, Packet *accum)

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T	initialize () const

template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet	initializePacket () const

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T	finalize (const T accum) const

template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet	finalizePacket (const Packet &vaccum) const

template<typename Packet >
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T	finalizeBoth (const T saccum, const Packet &vaccum) const

Protected Attributes
DenseIndex	scalarCount_

DenseIndex	packetCount_

Constructor & Destructor Documentation

◆ MeanReducer()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::internal::MeanReducer< T >::MeanReducer ( )

inline

108 : scalarCount_(0), packetCount_(0) {}

Eigen::internal::MeanReducer::scalarCount_

DenseIndex scalarCount_

Definition: TensorFunctors.h:145

Eigen::internal::MeanReducer::packetCount_

DenseIndex packetCount_

Definition: TensorFunctors.h:146

Member Function Documentation

◆ finalize()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T Eigen::internal::MeanReducer< T >::finalize ( const T accum ) const

inline

                                                                         {
     internal::scalar_quotient_op<T> quotient_op;
     return quotient_op(accum, T(scalarCount_));
   }

References Eigen::internal::MeanReducer< T >::scalarCount_.

◆ finalizeBoth()

template<typename T >

template<typename Packet >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T Eigen::internal::MeanReducer< T >::finalizeBoth	(	const T	saccum,
		const Packet &	vaccum
	)		const

inline

                                                                                                    {
     internal::scalar_sum_op<T> sum_op;
     internal::scalar_quotient_op<T> quotient_op;
     return quotient_op(sum_op(saccum, predux(vaccum)), T(scalarCount_ + packetCount_ * unpacket_traits<Packet>::size));
   }

References Eigen::internal::MeanReducer< T >::packetCount_, Eigen::internal::predux(), and Eigen::internal::MeanReducer< T >::scalarCount_.

◆ finalizePacket()

template<typename T >

template<typename Packet >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet Eigen::internal::MeanReducer< T >::finalizePacket ( const Packet & vaccum ) const

inline

                                                                                           {
     return pdiv(vaccum, pset1<Packet>(T(packetCount_)));
   }

References Eigen::internal::MeanReducer< T >::packetCount_, and Eigen::internal::pdiv().

◆ initialize()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T Eigen::internal::MeanReducer< T >::initialize ( ) const

inline

                                                              {
     internal::scalar_cast_op<int, T> conv;
     return conv(0);
   }

Referenced by Eigen::internal::MeanReducer< T >::initializePacket().

◆ initializePacket()

template<typename T >

template<typename Packet >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet Eigen::internal::MeanReducer< T >::initializePacket ( ) const

inline

                                                                         {
     return pset1<Packet>(initialize());
   }

References Eigen::internal::MeanReducer< T >::initialize().

◆ reduce()

template<typename T >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::MeanReducer< T >::reduce	(	const T	t,
		T *	accum
	)

inline

                                                                          {
     internal::scalar_sum_op<T> sum_op;
     *accum = sum_op(*accum, t);
     scalarCount_++;
   }

References Eigen::internal::MeanReducer< T >::scalarCount_, and plotPSD::t.

◆ reducePacket()

template<typename T >

template<typename Packet >

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::MeanReducer< T >::reducePacket	(	const Packet &	p,
		Packet *	accum
	)

inline

                                                                                           {
     (*accum) = padd<Packet>(*accum, p);
     packetCount_++;
   }