Eigen::internal::detail Namespace Reference

Functions
template<typename Packet >
void	zip_in_place (Packet &p1, Packet &p2)
template<>
EIGEN_ALWAYS_INLINE void	zip_in_place< Packet2f > (Packet2f &p1, Packet2f &p2)
template<>
EIGEN_ALWAYS_INLINE void	zip_in_place< Packet4f > (Packet4f &p1, Packet4f &p2)
template<>
EIGEN_ALWAYS_INLINE void	zip_in_place< Packet8c > (Packet8c &p1, Packet8c &p2)
template<>
EIGEN_ALWAYS_INLINE void	zip_in_place< Packet16c > (Packet16c &p1, Packet16c &p2)
template<>
EIGEN_ALWAYS_INLINE void	zip_in_place< Packet8uc > (Packet8uc &p1, Packet8uc &p2)
template<>
EIGEN_ALWAYS_INLINE void	zip_in_place< Packet16uc > (Packet16uc &p1, Packet16uc &p2)
template<>
EIGEN_ALWAYS_INLINE void	zip_in_place< Packet2i > (Packet2i &p1, Packet2i &p2)
template<>
EIGEN_ALWAYS_INLINE void	zip_in_place< Packet4i > (Packet4i &p1, Packet4i &p2)
template<>
EIGEN_ALWAYS_INLINE void	zip_in_place< Packet2ui > (Packet2ui &p1, Packet2ui &p2)
template<>
EIGEN_ALWAYS_INLINE void	zip_in_place< Packet4ui > (Packet4ui &p1, Packet4ui &p2)
template<>
EIGEN_ALWAYS_INLINE void	zip_in_place< Packet4s > (Packet4s &p1, Packet4s &p2)
template<>
EIGEN_ALWAYS_INLINE void	zip_in_place< Packet8s > (Packet8s &p1, Packet8s &p2)
template<>
EIGEN_ALWAYS_INLINE void	zip_in_place< Packet4us > (Packet4us &p1, Packet4us &p2)
template<>
EIGEN_ALWAYS_INLINE void	zip_in_place< Packet8us > (Packet8us &p1, Packet8us &p2)
template<typename Packet >
EIGEN_ALWAYS_INLINE void	ptranspose_impl (PacketBlock< Packet, 2 > &kernel)
template<typename Packet >
EIGEN_ALWAYS_INLINE void	ptranspose_impl (PacketBlock< Packet, 4 > &kernel)
template<typename Packet >
EIGEN_ALWAYS_INLINE void	ptranspose_impl (PacketBlock< Packet, 8 > &kernel)
template<typename Packet >
EIGEN_ALWAYS_INLINE void	ptranspose_impl (PacketBlock< Packet, 16 > &kernel)
template<>
EIGEN_ALWAYS_INLINE void	zip_in_place< Packet4bf > (Packet4bf &p1, Packet4bf &p2)

Function Documentation

ptranspose_impl() [1/4]

template<typename Packet >

EIGEN_ALWAYS_INLINE void Eigen::internal::detail::ptranspose_impl

(

PacketBlock< Packet, 16 > &

kernel

)

                                                                          {
  EIGEN_UNROLL_LOOP
  for (int i = 0; i < 4; ++i) {
    const int m = (1 << i);
    EIGEN_UNROLL_LOOP
    for (int j = 0; j < m; ++j) {
      const int n = (1 << (3 - i));
      EIGEN_UNROLL_LOOP
      for (int k = 0; k < n; ++k) {
        const int idx = 2 * j * n + k;
        zip_in_place(kernel.packet[idx], kernel.packet[idx + n]);
      }
    }
  }
}

References EIGEN_UNROLL_LOOP, i, j, k, m, n, Eigen::internal::PacketBlock< Packet, N >::packet, and zip_in_place().

ptranspose_impl() [2/4]

template<typename Packet >

EIGEN_ALWAYS_INLINE void Eigen::internal::detail::ptranspose_impl

(

PacketBlock< Packet, 2 > &

kernel

)

                                                                         {
  zip_in_place(kernel.packet[0], kernel.packet[1]);
}

References Eigen::internal::PacketBlock< Packet, N >::packet, and zip_in_place().

Referenced by Eigen::internal::ptranspose().

ptranspose_impl() [3/4]

template<typename Packet >

EIGEN_ALWAYS_INLINE void Eigen::internal::detail::ptranspose_impl

(

PacketBlock< Packet, 4 > &

kernel

)

                                                                         {
  zip_in_place(kernel.packet[0], kernel.packet[2]);
  zip_in_place(kernel.packet[1], kernel.packet[3]);
  zip_in_place(kernel.packet[0], kernel.packet[1]);
  zip_in_place(kernel.packet[2], kernel.packet[3]);
}

References Eigen::internal::PacketBlock< Packet, N >::packet, and zip_in_place().

ptranspose_impl() [4/4]

template<typename Packet >

EIGEN_ALWAYS_INLINE void Eigen::internal::detail::ptranspose_impl

(

PacketBlock< Packet, 8 > &

kernel

)

                                                                         {
  zip_in_place(kernel.packet[0], kernel.packet[4]);
  zip_in_place(kernel.packet[1], kernel.packet[5]);
  zip_in_place(kernel.packet[2], kernel.packet[6]);
  zip_in_place(kernel.packet[3], kernel.packet[7]);
 
  zip_in_place(kernel.packet[0], kernel.packet[2]);
  zip_in_place(kernel.packet[1], kernel.packet[3]);
  zip_in_place(kernel.packet[4], kernel.packet[6]);
  zip_in_place(kernel.packet[5], kernel.packet[7]);
 
  zip_in_place(kernel.packet[0], kernel.packet[1]);
  zip_in_place(kernel.packet[2], kernel.packet[3]);
  zip_in_place(kernel.packet[4], kernel.packet[5]);
  zip_in_place(kernel.packet[6], kernel.packet[7]);
}

References Eigen::internal::PacketBlock< Packet, N >::packet, and zip_in_place().

zip_in_place()

template<typename Packet >

void Eigen::internal::detail::zip_in_place	(	Packet &	p1,
		Packet &	p2
	)

Referenced by Eigen::internal::ptranspose(), and ptranspose_impl().

zip_in_place< Packet16c >()

template<>

EIGEN_ALWAYS_INLINE void Eigen::internal::detail::zip_in_place< Packet16c >	(	Packet16c &	p1,
		Packet16c &	p2
	)

                                                                               {
  const int8x16x2_t tmp = vzipq_s8(p1, p2);
  p1 = tmp.val[0];
  p2 = tmp.val[1];
}

References p1, and tmp.

zip_in_place< Packet16uc >()

template<>

EIGEN_ALWAYS_INLINE void Eigen::internal::detail::zip_in_place< Packet16uc >	(	Packet16uc &	p1,
		Packet16uc &	p2
	)

                                                                                  {
  const uint8x16x2_t tmp = vzipq_u8(p1, p2);
  p1 = tmp.val[0];
  p2 = tmp.val[1];
}

References p1, and tmp.

zip_in_place< Packet2f >()

template<>

EIGEN_ALWAYS_INLINE void Eigen::internal::detail::zip_in_place< Packet2f >	(	Packet2f &	p1,
		Packet2f &	p2
	)

                                                                            {
  const float32x2x2_t tmp = vzip_f32(p1, p2);
  p1 = tmp.val[0];
  p2 = tmp.val[1];
}

References p1, and tmp.

zip_in_place< Packet2i >()

template<>

EIGEN_ALWAYS_INLINE void Eigen::internal::detail::zip_in_place< Packet2i >	(	Packet2i &	p1,
		Packet2i &	p2
	)

                                                                            {
  const int32x2x2_t tmp = vzip_s32(p1, p2);
  p1 = tmp.val[0];
  p2 = tmp.val[1];
}

References p1, and tmp.

zip_in_place< Packet2ui >()

template<>

EIGEN_ALWAYS_INLINE void Eigen::internal::detail::zip_in_place< Packet2ui >	(	Packet2ui &	p1,
		Packet2ui &	p2
	)

                                                                               {
  const uint32x2x2_t tmp = vzip_u32(p1, p2);
  p1 = tmp.val[0];
  p2 = tmp.val[1];
}

References p1, and tmp.

zip_in_place< Packet4bf >()

template<>

EIGEN_ALWAYS_INLINE void Eigen::internal::detail::zip_in_place< Packet4bf >	(	Packet4bf &	p1,
		Packet4bf &	p2
	)

                                                                               {
  const uint16x4x2_t tmp = vzip_u16(p1, p2);
  p1 = tmp.val[0];
  p2 = tmp.val[1];
}

References p1, and tmp.

zip_in_place< Packet4f >()

template<>

EIGEN_ALWAYS_INLINE void Eigen::internal::detail::zip_in_place< Packet4f >	(	Packet4f &	p1,
		Packet4f &	p2
	)

                                                                            {
  const float32x4x2_t tmp = vzipq_f32(p1, p2);
  p1 = tmp.val[0];
  p2 = tmp.val[1];
}

References p1, and tmp.

zip_in_place< Packet4i >()

template<>

EIGEN_ALWAYS_INLINE void Eigen::internal::detail::zip_in_place< Packet4i >	(	Packet4i &	p1,
		Packet4i &	p2
	)

                                                                            {
  const int32x4x2_t tmp = vzipq_s32(p1, p2);
  p1 = tmp.val[0];
  p2 = tmp.val[1];
}

References p1, and tmp.

zip_in_place< Packet4s >()

template<>

EIGEN_ALWAYS_INLINE void Eigen::internal::detail::zip_in_place< Packet4s >	(	Packet4s &	p1,
		Packet4s &	p2
	)

                                                                            {
  const int16x4x2_t tmp = vzip_s16(p1, p2);
  p1 = tmp.val[0];
  p2 = tmp.val[1];
}

References p1, and tmp.

zip_in_place< Packet4ui >()

template<>

EIGEN_ALWAYS_INLINE void Eigen::internal::detail::zip_in_place< Packet4ui >	(	Packet4ui &	p1,
		Packet4ui &	p2
	)

                                                                               {
  const uint32x4x2_t tmp = vzipq_u32(p1, p2);
  p1 = tmp.val[0];
  p2 = tmp.val[1];
}

References p1, and tmp.

zip_in_place< Packet4us >()

template<>

EIGEN_ALWAYS_INLINE void Eigen::internal::detail::zip_in_place< Packet4us >	(	Packet4us &	p1,
		Packet4us &	p2
	)

                                                                               {
  const uint16x4x2_t tmp = vzip_u16(p1, p2);
  p1 = tmp.val[0];
  p2 = tmp.val[1];
}

References p1, and tmp.

zip_in_place< Packet8c >()

template<>

EIGEN_ALWAYS_INLINE void Eigen::internal::detail::zip_in_place< Packet8c >	(	Packet8c &	p1,
		Packet8c &	p2
	)

                                                                            {
  const int8x8x2_t tmp = vzip_s8(p1, p2);
  p1 = tmp.val[0];
  p2 = tmp.val[1];
}

References p1, and tmp.

zip_in_place< Packet8s >()

template<>

EIGEN_ALWAYS_INLINE void Eigen::internal::detail::zip_in_place< Packet8s >	(	Packet8s &	p1,
		Packet8s &	p2
	)

                                                                            {
  const int16x8x2_t tmp = vzipq_s16(p1, p2);
  p1 = tmp.val[0];
  p2 = tmp.val[1];
}

References p1, and tmp.

zip_in_place< Packet8uc >()

template<>

EIGEN_ALWAYS_INLINE void Eigen::internal::detail::zip_in_place< Packet8uc >	(	Packet8uc &	p1,
		Packet8uc &	p2
	)

                                                                               {
  const uint8x8x2_t tmp = vzip_u8(p1, p2);
  p1 = tmp.val[0];
  p2 = tmp.val[1];
}

References p1, and tmp.

zip_in_place< Packet8us >()

template<>

EIGEN_ALWAYS_INLINE void Eigen::internal::detail::zip_in_place< Packet8us >	(	Packet8us &	p1,
		Packet8us &	p2
	)

                                                                               {
  const uint16x8x2_t tmp = vzipq_u16(p1, p2);
  p1 = tmp.val[0];
  p2 = tmp.val[1];
}

References p1, and tmp.