Classes | Namespaces | Macros | Typedefs | Functions
SSE/PacketMath.h File Reference

Go to the source code of this file.

Classes

struct  Eigen::internal::is_arithmetic< __m128 >
 
struct  Eigen::internal::is_arithmetic< __m128d >
 
struct  Eigen::internal::is_arithmetic< __m128i >
 
struct  Eigen::internal::is_arithmetic< Packet16b >
 
struct  Eigen::internal::is_arithmetic< Packet4i >
 
struct  Eigen::internal::packet_traits< bool >
 
struct  Eigen::internal::packet_traits< double >
 
struct  Eigen::internal::packet_traits< float >
 
struct  Eigen::internal::packet_traits< int >
 
struct  Eigen::internal::scalar_div_cost< double, true >
 
struct  Eigen::internal::scalar_div_cost< float, true >
 
struct  Eigen::internal::shuffle_mask< p, q, r, s >
 
struct  Eigen::internal::unpacket_traits< Packet16b >
 
struct  Eigen::internal::unpacket_traits< Packet2d >
 
struct  Eigen::internal::unpacket_traits< Packet4f >
 
struct  Eigen::internal::unpacket_traits< Packet4i >
 

Namespaces

 Eigen
 Namespace containing all symbols from the Eigen library.
 
 Eigen::internal
 

Macros

#define _EIGEN_DECLARE_CONST_Packet2d(NAME, X)   const Packet2d p2d_##NAME = pset1<Packet2d>(X)
 
#define _EIGEN_DECLARE_CONST_Packet4f(NAME, X)   const Packet4f p4f_##NAME = pset1<Packet4f>(X)
 
#define _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(NAME, X)   const Packet4f p4f_##NAME = pset1frombits<Packet4f>(X)
 
#define _EIGEN_DECLARE_CONST_Packet4i(NAME, X)   const Packet4i p4i_##NAME = pset1<Packet4i>(X)
 
#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS   (2*sizeof(void*))
 
#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD   8
 
#define vec2d_duplane(a, p)   vec2d_swizzle2(a,a,(p<<1)|p)
 
#define vec2d_swizzle1(v, p, q)   Packet2d(_mm_castsi128_pd(_mm_shuffle_epi32( _mm_castpd_si128(v), (shuffle_mask<2*p,2*p+1,2*q,2*q+1>::mask))))
 
#define vec2d_swizzle2(a, b, mask)   Packet2d(_mm_shuffle_pd(a,b,mask))
 
#define vec4f_duplane(a, p)   vec4f_swizzle2(a,a,p,p,p,p)
 
#define vec4f_swizzle1(v, p, q, r, s)   Packet4f(_mm_castsi128_ps(_mm_shuffle_epi32( _mm_castps_si128(v), (shuffle_mask<p,q,r,s>::mask))))
 
#define vec4f_swizzle2(a, b, p, q, r, s)   Packet4f(_mm_shuffle_ps( (a), (b), (shuffle_mask<p,q,r,s>::mask)))
 
#define vec4i_swizzle1(v, p, q, r, s)   Packet4i(_mm_shuffle_epi32( v, (shuffle_mask<p,q,r,s>::mask)))
 
#define vec4i_swizzle2(a, b, p, q, r, s)   Packet4i(_mm_castps_si128( (_mm_shuffle_ps( _mm_castsi128_ps(a), _mm_castsi128_ps(b), (shuffle_mask<p,q,r,s>::mask)))))
 

Typedefs

typedef eigen_packet_wrapper< __m128i, 1 > Eigen::internal::Packet16b
 
typedef const char * Eigen::internal::SsePrefetchPtrType
 

Functions

template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pabs (const Packet2d &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pabs (const Packet4f &a)
 
template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::pabs (const Packet4i &a)
 
template<>
EIGEN_STRONG_INLINE Packet16b Eigen::internal::padd< Packet16b > (const Packet16b &a, const Packet16b &b)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::padd< Packet2d > (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::padd< Packet4f > (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::padd< Packet4i > (const Packet4i &a, const Packet4i &b)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::paddsub< Packet2d > (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::paddsub< Packet4f > (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet16b Eigen::internal::pand< Packet16b > (const Packet16b &a, const Packet16b &b)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pand< Packet2d > (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pand< Packet4f > (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::pand< Packet4i > (const Packet4i &a, const Packet4i &b)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pandnot< Packet2d > (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pandnot< Packet4f > (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::pandnot< Packet4i > (const Packet4i &a, const Packet4i &b)
 
template<int N>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::parithmetic_shift_right (const Packet4i &a)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pblend (const Selector< 2 > &ifPacket, const Packet2d &thenPacket, const Packet2d &elsePacket)
 
template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::pblend (const Selector< 4 > &ifPacket, const Packet4i &thenPacket, const Packet4i &elsePacket)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pblend (const Selector< 4 > &ifPacket, const Packet4f &thenPacket, const Packet4f &elsePacket)
 
template<>
EIGEN_STRONG_INLINE void Eigen::internal::pbroadcast4< Packet2d > (const double *a, Packet2d &a0, Packet2d &a1, Packet2d &a2, Packet2d &a3)
 
template<>
EIGEN_STRONG_INLINE void Eigen::internal::pbroadcast4< Packet4f > (const float *a, Packet4f &a0, Packet4f &a1, Packet4f &a2, Packet4f &a3)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pceil< Packet2d > (const Packet2d &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pceil< Packet4f > (const Packet4f &a)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pcmp_eq (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet16b Eigen::internal::pcmp_eq (const Packet16b &a, const Packet16b &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcmp_eq (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::pcmp_eq (const Packet4i &a, const Packet4i &b)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pcmp_le (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcmp_le (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::pcmp_le (const Packet4i &a, const Packet4i &b)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pcmp_lt (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcmp_lt (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::pcmp_lt (const Packet4i &a, const Packet4i &b)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pcmp_lt_or_nan (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pcmp_lt_or_nan (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pconj (const Packet4f &a)
 
template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::pconj (const Packet4i &a)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pconj (const Packet2d &a)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pdiv< Packet2d > (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pdiv< Packet4f > (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::peven_mask (const Packet4f &)
 
template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::peven_mask (const Packet4i &)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::peven_mask (const Packet2d &)
 
template<>
EIGEN_STRONG_INLINE bool Eigen::internal::pfirst< Packet16b > (const Packet16b &a)
 
template<>
EIGEN_STRONG_INLINE double Eigen::internal::pfirst< Packet2d > (const Packet2d &a)
 
template<>
EIGEN_STRONG_INLINE float Eigen::internal::pfirst< Packet4f > (const Packet4f &a)
 
template<>
EIGEN_STRONG_INLINE int Eigen::internal::pfirst< Packet4i > (const Packet4i &a)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pfloor< Packet2d > (const Packet2d &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pfloor< Packet4f > (const Packet4f &a)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pfrexp< Packet2d > (const Packet2d &a, Packet2d &exponent)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pfrexp< Packet4f > (const Packet4f &a, Packet4f &exponent)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pfrexp_generic_get_biased_exponent (const Packet2d &a)
 
template<>
EIGEN_DEVICE_FUNC Packet16b Eigen::internal::pgather< bool, Packet16b > (const bool *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC Packet2d Eigen::internal::pgather< double, Packet2d > (const double *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC Packet4f Eigen::internal::pgather< float, Packet4f > (const float *from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC Packet4i Eigen::internal::pgather< int, Packet4i > (const int *from, Index stride)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pldexp< Packet2d > (const Packet2d &a, const Packet2d &exponent)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pldexp< Packet4f > (const Packet4f &a, const Packet4f &exponent)
 
template<>
EIGEN_STRONG_INLINE Packet16b Eigen::internal::pload< Packet16b > (const bool *from)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pload< Packet2d > (const double *from)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pload< Packet4f > (const float *from)
 
template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::pload< Packet4i > (const int *from)
 
template<>
EIGEN_STRONG_INLINE Packet16b Eigen::internal::ploaddup< Packet16b > (const bool *from)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::ploaddup< Packet2d > (const double *from)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::ploaddup< Packet4f > (const float *from)
 
template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::ploaddup< Packet4i > (const int *from)
 
template<>
EIGEN_STRONG_INLINE Packet16b Eigen::internal::ploadquad< Packet16b > (const bool *from)
 
template<>
EIGEN_STRONG_INLINE Packet16b Eigen::internal::ploadu< Packet16b > (const bool *from)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::ploadu< Packet2d > (const double *from)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::ploadu< Packet4f > (const float *from)
 
template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::ploadu< Packet4i > (const int *from)
 
template<int N>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::plogical_shift_left (const Packet4i &a)
 
template<int N>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::plogical_shift_right (const Packet4i &a)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::plset< Packet2d > (const double &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::plset< Packet4f > (const float &a)
 
template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::plset< Packet4i > (const int &a)
 
template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::pmadd (const Packet4i &a, const Packet4i &b, const Packet4i &c)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pmax< Packet2d > (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmax< Packet4f > (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::pmax< Packet4i > (const Packet4i &a, const Packet4i &b)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pmax< PropagateNaN, Packet2d > (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmax< PropagateNaN, Packet4f > (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pmax< PropagateNumbers, Packet2d > (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmax< PropagateNumbers, Packet4f > (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pmin< Packet2d > (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmin< Packet4f > (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::pmin< Packet4i > (const Packet4i &a, const Packet4i &b)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pmin< PropagateNaN, Packet2d > (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmin< PropagateNaN, Packet4f > (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pmin< PropagateNumbers, Packet2d > (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmin< PropagateNumbers, Packet4f > (const Packet4f &a, const Packet4f &b)
 
template<typename Packet , typename Op >
EIGEN_STRONG_INLINE Packet Eigen::internal::pminmax_propagate_nan (const Packet &a, const Packet &b, Op op)
 
template<typename Packet , typename Op >
EIGEN_STRONG_INLINE Packet Eigen::internal::pminmax_propagate_numbers (const Packet &a, const Packet &b, Op op)
 
template<>
EIGEN_STRONG_INLINE Packet16b Eigen::internal::pmul< Packet16b > (const Packet16b &a, const Packet16b &b)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pmul< Packet2d > (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pmul< Packet4f > (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::pmul< Packet4i > (const Packet4i &a, const Packet4i &b)
 
template<>
EIGEN_STRONG_INLINE Packet16b Eigen::internal::pnegate (const Packet16b &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pnegate (const Packet4f &a)
 
template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::pnegate (const Packet4i &a)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pnegate (const Packet2d &a)
 
template<>
EIGEN_STRONG_INLINE Packet16b Eigen::internal::por< Packet16b > (const Packet16b &a, const Packet16b &b)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::por< Packet2d > (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::por< Packet4f > (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::por< Packet4i > (const Packet4i &a, const Packet4i &b)
 
template<>
EIGEN_STRONG_INLINE bool Eigen::internal::predux< Packet16b > (const Packet16b &a)
 
template<>
EIGEN_STRONG_INLINE double Eigen::internal::predux< Packet2d > (const Packet2d &a)
 
template<>
EIGEN_STRONG_INLINE float Eigen::internal::predux< Packet4f > (const Packet4f &a)
 
template<>
EIGEN_STRONG_INLINE int Eigen::internal::predux< Packet4i > (const Packet4i &a)
 
template<>
EIGEN_STRONG_INLINE bool Eigen::internal::predux_any (const Packet4f &x)
 
template<>
EIGEN_STRONG_INLINE double Eigen::internal::predux_max< Packet2d > (const Packet2d &a)
 
template<>
EIGEN_STRONG_INLINE float Eigen::internal::predux_max< Packet4f > (const Packet4f &a)
 
template<>
EIGEN_STRONG_INLINE int Eigen::internal::predux_max< Packet4i > (const Packet4i &a)
 
template<>
EIGEN_STRONG_INLINE double Eigen::internal::predux_min< Packet2d > (const Packet2d &a)
 
template<>
EIGEN_STRONG_INLINE float Eigen::internal::predux_min< Packet4f > (const Packet4f &a)
 
template<>
EIGEN_STRONG_INLINE int Eigen::internal::predux_min< Packet4i > (const Packet4i &a)
 
template<>
EIGEN_STRONG_INLINE bool Eigen::internal::predux_mul< Packet16b > (const Packet16b &a)
 
template<>
EIGEN_STRONG_INLINE double Eigen::internal::predux_mul< Packet2d > (const Packet2d &a)
 
template<>
EIGEN_STRONG_INLINE float Eigen::internal::predux_mul< Packet4f > (const Packet4f &a)
 
template<>
EIGEN_STRONG_INLINE int Eigen::internal::predux_mul< Packet4i > (const Packet4i &a)
 
template<>
EIGEN_STRONG_INLINE void Eigen::internal::prefetch< double > (const double *addr)
 
template<>
EIGEN_STRONG_INLINE void Eigen::internal::prefetch< float > (const float *addr)
 
template<>
EIGEN_STRONG_INLINE void Eigen::internal::prefetch< int > (const int *addr)
 
template<>
EIGEN_STRONG_INLINE Packet16b Eigen::internal::preverse (const Packet16b &a)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::preverse (const Packet2d &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::preverse (const Packet4f &a)
 
template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::preverse (const Packet4i &a)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::print (const Packet2d &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::print (const Packet4f &a)
 
template<>
EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< bool, Packet16b > (bool *to, const Packet16b &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< double, Packet2d > (double *to, const Packet2d &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< float, Packet4f > (float *to, const Packet4f &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC void Eigen::internal::pscatter< int, Packet4i > (int *to, const Packet4i &from, Index stride)
 
template<>
EIGEN_DEVICE_FUNC Packet16b Eigen::internal::pselect (const Packet16b &mask, const Packet16b &a, const Packet16b &b)
 
template<>
EIGEN_STRONG_INLINE Packet16b Eigen::internal::pset1< Packet16b > (const bool &from)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pset1< Packet2d > (const double &from)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pset1< Packet4f > (const float &from)
 
template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::pset1< Packet4i > (const int &from)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pset1frombits< Packet2d > (uint64_t from)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pset1frombits< Packet4f > (unsigned int from)
 
template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore1< Packet2d > (double *to, const double &a)
 
template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore1< Packet4f > (float *to, const float &a)
 
template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< bool > (bool *to, const Packet16b &from)
 
template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< double > (double *to, const Packet2d &from)
 
template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< float > (float *to, const Packet4f &from)
 
template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstore< int > (int *to, const Packet4i &from)
 
template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< bool > (bool *to, const Packet16b &from)
 
template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< double > (double *to, const Packet2d &from)
 
template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< float > (float *to, const Packet4f &from)
 
template<>
EIGEN_STRONG_INLINE void Eigen::internal::pstoreu< int > (int *to, const Packet4i &from)
 
template<>
EIGEN_STRONG_INLINE Packet16b Eigen::internal::psub< Packet16b > (const Packet16b &a, const Packet16b &b)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::psub< Packet2d > (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::psub< Packet4f > (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::psub< Packet4i > (const Packet4i &a, const Packet4i &b)
 
EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose (PacketBlock< Packet16b, 4 > &kernel)
 
EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose (PacketBlock< Packet2d, 2 > &kernel)
 
EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose (PacketBlock< Packet16b, 16 > &kernel)
 
EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose (PacketBlock< Packet4f, 4 > &kernel)
 
EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose (PacketBlock< Packet4i, 4 > &kernel)
 
template<>
EIGEN_STRONG_INLINE Packet16b Eigen::internal::ptrue< Packet16b > (const Packet16b &a)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::ptrue< Packet2d > (const Packet2d &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::ptrue< Packet4f > (const Packet4f &a)
 
template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::ptrue< Packet4i > (const Packet4i &a)
 
EIGEN_STRONG_INLINE void Eigen::internal::punpackp (Packet4f *vecs)
 
template<>
EIGEN_STRONG_INLINE Packet16b Eigen::internal::pxor< Packet16b > (const Packet16b &a, const Packet16b &b)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pxor< Packet2d > (const Packet2d &a, const Packet2d &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pxor< Packet4f > (const Packet4f &a, const Packet4f &b)
 
template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::pxor< Packet4i > (const Packet4i &a, const Packet4i &b)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pzero (const Packet4f &)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pzero (const Packet2d &)
 
template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::pzero (const Packet4i &)
 
EIGEN_STRONG_INLINE Packet2d Eigen::internal::vec2d_unpackhi (const Packet2d &a, const Packet2d &b)
 
EIGEN_STRONG_INLINE Packet2d Eigen::internal::vec2d_unpacklo (const Packet2d &a, const Packet2d &b)
 
EIGEN_STRONG_INLINE Packet4f Eigen::internal::vec4f_movehl (const Packet4f &a, const Packet4f &b)
 
EIGEN_STRONG_INLINE Packet4f Eigen::internal::vec4f_movelh (const Packet4f &a, const Packet4f &b)
 
EIGEN_STRONG_INLINE Packet4f Eigen::internal::vec4f_unpackhi (const Packet4f &a, const Packet4f &b)
 
EIGEN_STRONG_INLINE Packet4f Eigen::internal::vec4f_unpacklo (const Packet4f &a, const Packet4f &b)
 

Macro Definition Documentation

◆ _EIGEN_DECLARE_CONST_Packet2d

#define _EIGEN_DECLARE_CONST_Packet2d (   NAME,
  X 
)    const Packet2d p2d_##NAME = pset1<Packet2d>(X)

Definition at line 112 of file SSE/PacketMath.h.

◆ _EIGEN_DECLARE_CONST_Packet4f

#define _EIGEN_DECLARE_CONST_Packet4f (   NAME,
  X 
)    const Packet4f p4f_##NAME = pset1<Packet4f>(X)

Definition at line 109 of file SSE/PacketMath.h.

◆ _EIGEN_DECLARE_CONST_Packet4f_FROM_INT

#define _EIGEN_DECLARE_CONST_Packet4f_FROM_INT (   NAME,
  X 
)    const Packet4f p4f_##NAME = pset1frombits<Packet4f>(X)

Definition at line 115 of file SSE/PacketMath.h.

◆ _EIGEN_DECLARE_CONST_Packet4i

#define _EIGEN_DECLARE_CONST_Packet4i (   NAME,
  X 
)    const Packet4i p4i_##NAME = pset1<Packet4i>(X)

Definition at line 118 of file SSE/PacketMath.h.

◆ EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS

#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS   (2*sizeof(void*))

Definition at line 24 of file SSE/PacketMath.h.

◆ EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD

#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD   8

Definition at line 18 of file SSE/PacketMath.h.

◆ vec2d_duplane

#define vec2d_duplane (   a,
  p 
)    vec2d_swizzle2(a,a,(p<<1)|p)

Definition at line 106 of file SSE/PacketMath.h.

◆ vec2d_swizzle1

#define vec2d_swizzle1 (   v,
  p,
 
)    Packet2d(_mm_castsi128_pd(_mm_shuffle_epi32( _mm_castpd_si128(v), (shuffle_mask<2*p,2*p+1,2*q,2*q+1>::mask))))

Definition at line 67 of file SSE/PacketMath.h.

◆ vec2d_swizzle2

#define vec2d_swizzle2 (   a,
  b,
  mask 
)    Packet2d(_mm_shuffle_pd(a,b,mask))

Definition at line 95 of file SSE/PacketMath.h.

◆ vec4f_duplane

#define vec4f_duplane (   a,
  p 
)    vec4f_swizzle2(a,a,p,p,p,p)

Definition at line 92 of file SSE/PacketMath.h.

◆ vec4f_swizzle1

#define vec4f_swizzle1 (   v,
  p,
  q,
  r,
  s 
)    Packet4f(_mm_castsi128_ps(_mm_shuffle_epi32( _mm_castps_si128(v), (shuffle_mask<p,q,r,s>::mask))))

Definition at line 61 of file SSE/PacketMath.h.

◆ vec4f_swizzle2

#define vec4f_swizzle2 (   a,
  b,
  p,
  q,
  r,
  s 
)    Packet4f(_mm_shuffle_ps( (a), (b), (shuffle_mask<p,q,r,s>::mask)))

Definition at line 70 of file SSE/PacketMath.h.

◆ vec4i_swizzle1

#define vec4i_swizzle1 (   v,
  p,
  q,
  r,
  s 
)    Packet4i(_mm_shuffle_epi32( v, (shuffle_mask<p,q,r,s>::mask)))

Definition at line 64 of file SSE/PacketMath.h.

◆ vec4i_swizzle2

#define vec4i_swizzle2 (   a,
  b,
  p,
  q,
  r,
  s 
)    Packet4i(_mm_castps_si128( (_mm_shuffle_ps( _mm_castsi128_ps(a), _mm_castsi128_ps(b), (shuffle_mask<p,q,r,s>::mask)))))

Definition at line 73 of file SSE/PacketMath.h.



gtsam
Author(s):
autogenerated on Tue Jul 4 2023 02:40:51