Classes | Namespaces | Macros | Typedefs | Functions | Variables
ZVector/PacketMath.h File Reference
#include <stdint.h>
Include dependency graph for ZVector/PacketMath.h:

Go to the source code of this file.

Classes

union  Eigen::internal::Packet
 
struct  Eigen::internal::Packet4f
 
struct  Eigen::internal::packet_traits< double >
 
struct  Eigen::internal::packet_traits< float >
 
struct  Eigen::internal::packet_traits< int >
 
struct  Eigen::internal::palign_impl< Offset, Packet2d >
 
struct  Eigen::internal::palign_impl< Offset, Packet4f >
 
struct  Eigen::internal::palign_impl< Offset, Packet4i >
 
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_ALIGNED_PTR(x)   ((std::ptrdiff_t)(x) & _EIGEN_MASK_ALIGNMENT)
 
#define _EIGEN_DECLARE_CONST_FAST_Packet2d(NAME, X)   Packet2d p2d_##NAME = reinterpret_cast<Packet2d>(vec_splat_s64(X))
 
#define _EIGEN_DECLARE_CONST_FAST_Packet2l(NAME, X)   Packet2l p2l_##NAME = reinterpret_cast<Packet2l>(vec_splat_s64(X))
 
#define _EIGEN_DECLARE_CONST_FAST_Packet4i(NAME, X)   Packet4i p4i_##NAME = reinterpret_cast<Packet4i>(vec_splat_s32(X))
 
#define _EIGEN_DECLARE_CONST_Packet2d(NAME, X)   Packet2d p2d_##NAME = pset1<Packet2d>(X)
 
#define _EIGEN_DECLARE_CONST_Packet2l(NAME, X)   Packet2l p2l_##NAME = pset1<Packet2l>(X)
 
#define _EIGEN_DECLARE_CONST_Packet4i(NAME, X)   Packet4i p4i_##NAME = pset1<Packet4i>(X)
 
#define _EIGEN_MASK_ALIGNMENT   0xfffffffffffffff0
 
#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS   16
 
#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD   4
 
#define EIGEN_HAS_SINGLE_INSTRUCTION_CJMADD
 
#define EIGEN_HAS_SINGLE_INSTRUCTION_MADD
 
#define EIGEN_ZVECTOR_PREFETCH(ADDR)   asm( " pfd [%[addr]]\n" :: [addr] "r" (ADDR) : "cc" );
 

Typedefs

typedef __vector long long Eigen::internal::Packet2l
 
typedef __vector unsigned long long Eigen::internal::Packet2ul
 

Functions

static Eigen::internal::_EIGEN_DECLARE_CONST_FAST_Packet2d (ZERO, 0)
 
static Eigen::internal::_EIGEN_DECLARE_CONST_FAST_Packet2l (ZERO, 0)
 
static Eigen::internal::_EIGEN_DECLARE_CONST_FAST_Packet2l (ONE, 1)
 
static Eigen::internal::_EIGEN_DECLARE_CONST_FAST_Packet4i (ONE, 1)
 
std::ostream & Eigen::internal::operator<< (std::ostream &s, const Packet4i &v)
 
std::ostream & Eigen::internal::operator<< (std::ostream &s, const Packet4ui &v)
 
std::ostream & Eigen::internal::operator<< (std::ostream &s, const Packet2l &v)
 
std::ostream & Eigen::internal::operator<< (std::ostream &s, const Packet2ul &v)
 
std::ostream & Eigen::internal::operator<< (std::ostream &s, const Packet2d &v)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pabs< Packet2d > (const Packet2d &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pabs< Packet4f > (const Packet4f &a)
 
template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::pabs< Packet4i > (const Packet4i &a)
 
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::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<>
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 Packet2d Eigen::internal::pblend (const Selector< 2 > &ifPacket, const Packet2d &thenPacket, const Packet2d &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 void Eigen::internal::pbroadcast4< Packet4i > (const int *a, Packet4i &a0, Packet4i &a1, Packet4i &a2, Packet4i &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::pconj (const Packet2d &a)
 
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::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 Packet4i Eigen::internal::pdiv< Packet4i > (const Packet4i &, const Packet4i &)
 
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_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::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 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 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<>
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 Packet4f Eigen::internal::pmadd (const Packet4f &a, const Packet4f &b, const Packet4f &c)
 
template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::pmadd (const Packet4i &a, const Packet4i &b, const Packet4i &c)
 
template<>
EIGEN_STRONG_INLINE Packet2d Eigen::internal::pmadd (const Packet2d &a, const Packet2d &b, const Packet2d &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::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::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 Packet2d Eigen::internal::pnegate (const Packet2d &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::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 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 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 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 Packet2d Eigen::internal::preduxp< Packet2d > (const Packet2d *vecs)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::preduxp< Packet4f > (const Packet4f *vecs)
 
template<>
EIGEN_STRONG_INLINE Packet4i Eigen::internal::preduxp< Packet4i > (const Packet4i *vecs)
 
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 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::pround< Packet2d > (const Packet2d &a)
 
template<>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::pround< Packet4f > (const Packet4f &a)
 
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_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 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< 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 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< Packet4f, 4 > &kernel)
 
EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose (PacketBlock< Packet4i, 4 > &kernel)
 
EIGEN_DEVICE_FUNC void Eigen::internal::ptranspose (PacketBlock< Packet2d, 2 > &kernel)
 
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<int element>
EIGEN_STRONG_INLINE Packet4f Eigen::internal::vec_splat_packet4f (const Packet4f &from)
 

Variables

static Packet16uc Eigen::internal::p16uc_DUPLICATE32_HI = { 0,1,2,3, 0,1,2,3, 4,5,6,7, 4,5,6,7 }
 
static Packet16uc Eigen::internal::p16uc_FORWARD = { 0,1,2,3, 4,5,6,7, 8,9,10,11, 12,13,14,15 }
 
static Packet16uc Eigen::internal::p16uc_PSET32_WEVEN = vec_sld(p16uc_DUPLICATE32_HI, (Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 3), 8)
 
static Packet16uc Eigen::internal::p16uc_PSET32_WODD = vec_sld((Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 0), (Packet16uc) vec_splat((Packet4ui)p16uc_FORWARD, 2), 8)
 
static Packet16uc Eigen::internal::p16uc_PSET64_HI = { 0,1,2,3, 4,5,6,7, 0,1,2,3, 4,5,6,7 }
 
static Packet16uc Eigen::internal::p16uc_PSET64_LO = (Packet16uc) vec_mergel((Packet4ui)p16uc_PSET32_WODD, (Packet4ui)p16uc_PSET32_WEVEN)
 
static Packet16uc Eigen::internal::p16uc_REVERSE32 = { 12,13,14,15, 8,9,10,11, 4,5,6,7, 0,1,2,3 }
 
static Packet16uc Eigen::internal::p16uc_REVERSE64 = { 8,9,10,11, 12,13,14,15, 0,1,2,3, 4,5,6,7 }
 
static Packet16uc Eigen::internal::p16uc_TRANSPOSE64_HI = { 0,1,2,3, 4,5,6,7, 16,17,18,19, 20,21,22,23}
 
static Packet16uc Eigen::internal::p16uc_TRANSPOSE64_LO = { 8,9,10,11, 12,13,14,15, 24,25,26,27, 28,29,30,31}
 
static Packet2d Eigen::internal::p2d_COUNTDOWN = reinterpret_cast<Packet2d>(vec_sld(reinterpret_cast<Packet16uc>(p2d_ZERO), reinterpret_cast<Packet16uc>(p2d_ONE), 8))
 
static Packet2d Eigen::internal::p2d_ONE = { 1.0, 1.0 }
 
static Packet2d Eigen::internal::p2d_ZERO_ = { -0.0, -0.0 }
 
static Packet4f Eigen::internal::p4f_COUNTDOWN = { 0.0, 1.0, 2.0, 3.0 }
 
static Packet4i Eigen::internal::p4i_COUNTDOWN = { 0, 1, 2, 3 }
 

Macro Definition Documentation

#define _EIGEN_ALIGNED_PTR (   x)    ((std::ptrdiff_t)(x) & _EIGEN_MASK_ALIGNMENT)

Definition at line 103 of file ZVector/PacketMath.h.

#define _EIGEN_DECLARE_CONST_FAST_Packet2d (   NAME,
  X 
)    Packet2d p2d_##NAME = reinterpret_cast<Packet2d>(vec_splat_s64(X))

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

#define _EIGEN_DECLARE_CONST_FAST_Packet2l (   NAME,
  X 
)    Packet2l p2l_##NAME = reinterpret_cast<Packet2l>(vec_splat_s64(X))

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

#define _EIGEN_DECLARE_CONST_FAST_Packet4i (   NAME,
  X 
)    Packet4i p4i_##NAME = reinterpret_cast<Packet4i>(vec_splat_s32(X))

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

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

Definition at line 76 of file ZVector/PacketMath.h.

#define _EIGEN_DECLARE_CONST_Packet2l (   NAME,
  X 
)    Packet2l p2l_##NAME = pset1<Packet2l>(X)

Definition at line 79 of file ZVector/PacketMath.h.

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

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

#define _EIGEN_MASK_ALIGNMENT   0xfffffffffffffff0

Definition at line 101 of file ZVector/PacketMath.h.

#define EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS   16

Definition at line 32 of file ZVector/PacketMath.h.

#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD   4

Definition at line 20 of file ZVector/PacketMath.h.

#define EIGEN_HAS_SINGLE_INSTRUCTION_CJMADD

Definition at line 28 of file ZVector/PacketMath.h.

#define EIGEN_HAS_SINGLE_INSTRUCTION_MADD

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

#define EIGEN_ZVECTOR_PREFETCH (   ADDR)    asm( " pfd [%[addr]]\n" :: [addr] "r" (ADDR) : "cc" );

Definition at line 131 of file ZVector/PacketMath.h.



gtsam
Author(s):
autogenerated on Sat May 8 2021 02:51:32