Eigen::internal Namespace Reference

Typedefs
typedef svint32_t PacketXi	__attribute__((arm_sve_vector_bits(EIGEN_ARM64_SVE_VL)))
typedef typename add_const_on_value_type< T >::type	add_const_on_value_type_t
typedef typename typed_cmp_helper< LhsScalar, RhsScalar, UseTypedComparators >::type	cmp_return_t
typedef std::conditional<!Cond, const T &, CwiseUnaryOp< scalar_conjugate_op< typename traits< T >::Scalar >, T > >	conj_expr_if
typedef eigen_packet_wrapper< __m128i, 1 >	Packet16b
typedef eigen_packet_wrapper< __m256i, 2 >	Packet16bf
typedef __vector signed char	Packet16c
typedef __m512	Packet16f
typedef eigen_packet_wrapper< __m256i, 1 >	Packet16h
typedef __m512i	Packet16i
typedef __vector unsigned char	Packet16uc
typedef v2f64	Packet2d
typedef float32x2_t	Packet2f
typedef int32x2_t	Packet2i
typedef v2i64	Packet2l
typedef uint32x2_t	Packet2ui
typedef v2u64	Packet2ul
typedef __m512h	Packet32h
typedef eigen_packet_wrapper< uint16x4_t, 19 >	Packet4bf
typedef __vector __bool int	Packet4bi
typedef eigen_packet_wrapper< int32_t, 2 >	Packet4c
typedef __m256d	Packet4d
typedef __vector float	Packet4f
typedef __vector int	Packet4i
typedef int16x4_t	Packet4s
typedef eigen_packet_wrapper< uint32_t, 5 >	Packet4uc
typedef __vector unsigned int	Packet4ui
typedef uint16x4_t	Packet4us
typedef eigen_packet_wrapper< __vector unsigned short int, 0 >	Packet8bf
typedef __vector __bool short	Packet8bi
typedef int8x8_t	Packet8c
typedef __m512d	Packet8d
typedef __m256	Packet8f
typedef eigen_packet_wrapper< __m128i, 2 >	Packet8h
typedef eigen_packet_wrapper< __m256i, 0 >	Packet8i
typedef __vector short int	Packet8s
typedef uint8x8_t	Packet8uc
typedef eigen_packet_wrapper< __m256i, 4 >	Packet8ui
typedef __vector unsigned short int	Packet8us
typedef std::is_same< std::integer_sequence< bool, values..., true >, std::integer_sequence< bool, true, values... > >	reduce_all
typedef std::integral_constant< bool, !std::is_same< std::integer_sequence< bool, values..., false >, std::integer_sequence< bool, false, values... > >::value >	reduce_any
typedef typename remove_all< T >::type	remove_all_t
typedef const char *	SsePrefetchPtrType
typedef Packet8d	vecFullDouble
typedef Packet16f	vecFullFloat
typedef Packet4d	vecHalfDouble
typedef Packet8f	vecHalfFloat
typedef void	void_t
typedef SparseMatrix< typename Source::Scalar, Order, typename Source::StorageIndex >	WithStorageOrder

Enumerations
enum	{   ShardByRow ,   ShardByCol }
enum	{   Rhs ,   Lhs }
enum	ComparisonName
enum	GEBPPacketSizeType
enum	GEMVPacketSizeType
enum	IgammaComputationMode {   VALUE ,   DERIVATIVE ,   SAMPLE_DERIVATIVE }
enum	MemType
enum	OptionsMasks
enum	PermPermProduct_t
enum	SignMatrix
enum	TensorBlockKind {   kExpr ,   kView ,   kMaterializedInScratch ,   kMaterializedInOutput }
enum class	TensorBlockShapeType {   kUniformAllDims ,   kSkewedInnerDims }
enum	TiledEvaluation {   Off ,   On }

Functions
	__UNPACK_TYPE__ (Packet) pfirst_common(const Packet &a)
void	absolute_split (const Packet &x, Packet &n, Packet &r)
EIGEN_ALWAYS_INLINE void	addResults (Packet4f(&acc)[num_acc][4])
void	aligned_delete (T *ptr, std::size_t size)
void	aligned_free (void *ptr)
void *	aligned_malloc (std::size_t size)
T *	aligned_new (std::size_t size)
void *	aligned_realloc (void *ptr, std::size_t new_size, std::size_t old_size)
bool	all ()
bool	all (T t, Ts ... ts)
template<typename T >
static EIGEN_CONSTEXPR bool	all_indices_known_statically ()
T	amd_flip (const T &i)
void	amd_mark (const T0 *w, const T1 &j)
bool	amd_marked (const T0 *w, const T1 &j)
T	amd_unflip (const T &i)
void	apply_block_householder_on_the_left (MatrixType &mat, const VectorsType &vectors, const CoeffsType &hCoeffs, bool forward)
void	apply_rotation_in_the_plane (DenseBase< VectorX > &xpr_x, DenseBase< VectorY > &xpr_y, const JacobiRotation< OtherScalar > &j)
constexpr array< decltype(Op::run(A())), N >	array_apply (array< A, N > a)
constexpr auto	array_apply_and_reduce (array< A, N > a) -> decltype(h_array_apply_and_reduce< Reducer, Op, A, N >(a, typename gen_numeric_list< int, N >::type()))
template<DenseIndex n, typename Index , std::size_t Rank>
const Index	array_get (const DimensionList< Index, Rank > &)
template<Index N, typename FirstType , typename... OtherTypes>
constexpr Index	array_get (const IndexList< FirstType, OtherTypes... > &a)
template<int N, typename T , typename... O>
constexpr const IndexTupleExtractor< N, T, O... >::ValType &	array_get (const IndexTuple< T, O... > &tuple)
constexpr T	array_get (const numeric_list< T, a, as... > &)
template<std::ptrdiff_t n, typename std::ptrdiff_t... Indices>
std::ptrdiff_t	array_get (const Sizes< Indices... > &)
template<std::ptrdiff_t n>
std::ptrdiff_t	array_get (const Sizes<> &)
template<DenseIndex n, typename Index , std::size_t Rank>
const Index	array_get (DimensionList< Index, Rank > &)
template<Index N, typename FirstType , typename... OtherTypes>
constexpr Index	array_get (IndexList< FirstType, OtherTypes... > &a)
template<int N, typename T , typename... O>
constexpr IndexTupleExtractor< N, T, O... >::ValType &	array_get (IndexTuple< T, O... > &tuple)
constexpr T &&	array_get (std::array< T, N > &&a)
constexpr T &	array_get (std::array< T, N > &a)
constexpr T const &	array_get (std::array< T, N > const &a)
template<std::size_t I_, class T >
constexpr T &&	array_get (std::vector< T > &&a)
template<std::size_t I_, class T >
constexpr T &	array_get (std::vector< T > &a)
template<std::size_t I_, class T >
constexpr T const &	array_get (std::vector< T > const &a)
constexpr auto	array_prod (const array< T, N > &arr) -> decltype(array_reduce< product_op, T, N >(arr, static_cast< T >(1)))
template<typename FirstType , typename... OtherTypes>
Index	array_prod (const IndexList< FirstType, OtherTypes... > &sizes)
template<typename std::ptrdiff_t... Indices>
std::ptrdiff_t	array_prod (const Sizes< Indices... > &)
t	array_prod (const std::vector< t > &a)
constexpr auto	array_reduce (const array< T, N > &arr, T identity) -> decltype(h_array_reduce< Reducer, T, N >::run(arr, identity))
constexpr array< T, N >	array_reverse (array< T, N > arr)
constexpr auto	array_sum (const array< T, N > &arr) -> decltype(array_reduce< sum_op, T, N >(arr, static_cast< T >(0)))
constexpr array< decltype(Op::run(A(), B())), N >	array_zip (array< A, N > a, array< B, N > b)
constexpr auto	array_zip_and_reduce (array< A, N > a, array< B, N > b) -> decltype(h_array_zip_and_reduce< Reducer, Op, A, B, N >(a, b, typename gen_numeric_list< int, N >::type()))
void	assign_sparse_to_sparse (DstXprType &dst, const SrcXprType &src)
SluMatrix	asSluMatrix (MatrixType &mat)
EIGEN_ALWAYS_INLINE void	band (PacketBlock< Packet, N > &acc, const Packet &pMask)
EIGEN_ALWAYS_INLINE void	bcouple (PacketBlock< Packet, N > &taccReal, PacketBlock< Packet, N > &taccImag, PacketBlock< Packetc, N *2 > &tRes, PacketBlock< Packetc, N > &acc1, PacketBlock< Packetc, N > &acc2)
EIGEN_ALWAYS_INLINE void	bcouple_common (PacketBlock< Packet, N > &taccReal, PacketBlock< Packet, N > &taccImag, PacketBlock< Packetc, N > &acc1, PacketBlock< Packetc, N > &acc2)
EIGEN_ALWAYS_INLINE Packet8bf	Bf16PackHigh (Packet4f hi, Packet4f lo)
EIGEN_ALWAYS_INLINE Packet8bf	Bf16PackLow (Packet4f hi, Packet4f lo)
Packet16f	Bf16ToF32 (const Packet16bf &a)
Packet4f	Bf16ToF32 (const Packet4bf &p)
Packet8f	Bf16ToF32 (const Packet8bf &a)
Packet4f	Bf16ToF32Even (const Packet8bf &bf)
Packet4f	Bf16ToF32Odd (const Packet8bf &bf)
bool	bicgstab (const MatrixType &mat, const Rhs &rhs, Dest &x, const Preconditioner &precond, Index &iters, typename Dest::RealScalar &tol_error)
template<typename MatrixType , typename Rhs , typename Dest , typename Preconditioner >
bool	bicgstabl (const MatrixType &mat, const Rhs &rhs, Dest &x, const Preconditioner &precond, Index &iters, typename Dest::RealScalar &tol_error, Index L)
EIGEN_ALWAYS_INLINE void	bload (PacketBlock< Packet, N *(Complex?2:1)> &acc, const DataMapper &res, Index row, Index col)
void	BlockedInPlaceTranspose (MatrixType &m)
NumTraits< typename traits< Derived >::Scalar >::Real	blueNorm_impl (const EigenBase< Derived > &_vec)
EIGEN_ALWAYS_INLINE Packet	bmask (const Index remaining_rows)
EIGEN_ALWAYS_INLINE Packet2d	bmask< Packet2d > (const Index remaining_rows)
const Derived::Scalar	bruteforce_det3_helper (const MatrixBase< Derived > &matrix, int a, int b, int c)
EIGEN_ALWAYS_INLINE void	bscale (PacketBlock< Packet, N > &acc, PacketBlock< Packet, N > &accZ, const Packet &pAlpha)
EIGEN_ALWAYS_INLINE void	bscale (PacketBlock< Packet, N > &acc, PacketBlock< Packet, N > &accZ, const Packet &pAlpha, const Packet &pMask)
EIGEN_ALWAYS_INLINE void	bscalec (PacketBlock< Packet, N > &aReal, PacketBlock< Packet, N > &aImag, const Packet &bReal, const Packet &bImag, PacketBlock< Packet, N > &cReal, PacketBlock< Packet, N > &cImag, const Packet &pMask)
EIGEN_ALWAYS_INLINE void	bscalec_common (PacketBlock< Packet, N > &acc, PacketBlock< Packet, N > &accZ, const Packet &pAlpha)
EIGEN_ALWAYS_INLINE void	bsetzero (PacketBlock< Packet, N > &acc)
EIGEN_ALWAYS_INLINE void	bsetzeroMMA (__vector_quad *acc)
EIGEN_ALWAYS_INLINE void	bstore (PacketBlock< Packet, N > &acc, const DataMapper &res, Index row)
void	c_to_fortran_numbering (MatrixType &mat)
EIGEN_ALWAYS_INLINE void	calcColLoops (const bfloat16 *&indexA, Index &row, Index depth, Index cols, Index rows, const Packet4f pAlpha, const bfloat16 *indexB, Index strideB, Index offsetA, Index offsetB, Index bigSuffix, float *result)
EIGEN_ALWAYS_INLINE void	calcVecColLoops (Index cend, Index rows, LhsMapper &lhs, RhsMapper &rhs, const Packet4f pAlpha, float *result)
EIGEN_ALWAYS_INLINE void	calcVecLoops (Index cols, Index rows, LhsMapper &lhs, RhsMapper &rhs, const Packet4f pAlpha, float *result)
EIGEN_ALWAYS_INLINE void	calcVSXColLoops (const bfloat16 *&indexA, const float *indexA2, Index &row, Index depth, Index cols, Index rows, const Packet4f pAlpha, const float *indexB, Index strideA, Index strideB, Index offsetA, Index offsetB, Index bigSuffix, float *result)
void	call_assignment (const Dst &dst, const Src &src)
void	call_assignment (Dst &dst, const Src &src)
EIGEN_CONSTEXPR void	call_assignment (Dst &dst, const Src &src, const Func &func, std::enable_if_t< evaluator_assume_aliasing< Src >::value, void * >=0)
void	call_assignment (Dst &dst, const Src &src, const Func &func, std::enable_if_t<!evaluator_assume_aliasing< Src >::value, void * >=0)
EIGEN_CONSTEXPR void	call_assignment (NoAlias< Dst, StorageBase > &dst, const Src &src, const Func &func)
EIGEN_CONSTEXPR void	call_assignment_no_alias (Dst &dst, const Src &src)
EIGEN_CONSTEXPR void	call_assignment_no_alias (Dst &dst, const Src &src, const Func &func)
EIGEN_CONSTEXPR void	call_assignment_no_alias_no_transpose (Dst &dst, const Src &src)
EIGEN_CONSTEXPR void	call_assignment_no_alias_no_transpose (Dst &dst, const Src &src, const Func &func)
void	call_dense_assignment_loop (DstXprType &dst, const Eigen::CwiseNullaryOp< Eigen::internal::scalar_constant_op< typename DstXprType::Scalar >, DstXprType > &src, const internal::assign_op< typename DstXprType::Scalar, typename DstXprType::Scalar > &func)
void	call_dense_assignment_loop (DstXprType &dst, const SrcXprType &src)
EIGEN_CONSTEXPR void	call_dense_assignment_loop (DstXprType &dst, const SrcXprType &src, const Functor &func)
void	call_restricted_packet_assignment_no_alias (Dst &dst, const Src &src, const Func &func)
void	call_triangular_assignment_loop (DstXprType &dst, const SrcXprType &src)
void	call_triangular_assignment_loop (DstXprType &dst, const SrcXprType &src, const Functor &func)
NewType	cast (const OldType &x)
template<>
double	cast< mpfr::mpreal, double > (const mpfr::mpreal &x)
template<>
int	cast< mpfr::mpreal, int > (const mpfr::mpreal &x)
template<>
long	cast< mpfr::mpreal, long > (const mpfr::mpreal &x)
template<>
long double	cast< mpfr::mpreal, long double > (const mpfr::mpreal &x)
Packet16f	cat256 (Packet8f a, Packet8f b)
Packet16i	cat256i (Packet8i a, Packet8i b)
void	check_for_aliasing (const Dst &dst, const Src &src)
constexpr bool	check_implication (bool a, bool b)
EIGEN_ALWAYS_INLINE void	check_size_for_overflow (std::size_t size)
constexpr void	check_static_allocation_size ()
void	check_svd_options_assertions (unsigned int computationOptions, Index rows, Index cols)
void	check_that_malloc_is_allowed ()
template<typename Scalar >
void	chkder (const Matrix< Scalar, Dynamic, 1 > &x, const Matrix< Scalar, Dynamic, 1 > &fvec, const Matrix< Scalar, Dynamic, Dynamic > &fjac, Matrix< Scalar, Dynamic, 1 > &xp, const Matrix< Scalar, Dynamic, 1 > &fvecp, int mode, Matrix< Scalar, Dynamic, 1 > &err)
int	cm_factorize_p (cholmod_sparse *A, double beta[2], StorageIndex_ *fset, std::size_t fsize, cholmod_factor *L, cholmod_common &Common)
int	cm_factorize_p< SuiteSparse_long > (cholmod_sparse *A, double beta[2], SuiteSparse_long *fset, std::size_t fsize, cholmod_factor *L, cholmod_common &Common)
cholmod_dense *	cm_solve (int sys, cholmod_factor &L, cholmod_dense &B, cholmod_common &Common)
cholmod_dense *	cm_solve< SuiteSparse_long > (int sys, cholmod_factor &L, cholmod_dense &B, cholmod_common &Common)
cholmod_sparse *	cm_spsolve (int sys, cholmod_factor &L, cholmod_sparse &B, cholmod_common &Common)
cholmod_sparse *	cm_spsolve< SuiteSparse_long > (int sys, cholmod_factor &L, cholmod_sparse &B, cholmod_common &Common)
MatrixType::Scalar	cofactor_3x3 (const MatrixType &m)
MatrixType::Scalar	cofactor_4x4 (const MatrixType &matrix)
int	coletree (const MatrixType &mat, IndexVector &parent, IndexVector &firstRowElt, typename MatrixType::StorageIndex *perm=0)
void	colLoopBody (Index &col, Index depth, Index cols, Index rows, const Packet4f pAlpha, const bfloat16 *indexA, const bfloat16 *indexB, Index strideB, Index offsetB, float *result)
void	colLoopBodyExtra (Index col, Index depth, Index cols, Index rows, const Packet4f pAlpha, const bfloat16 *indexA, const bfloat16 *blockB, Index strideB, Index offsetB, float *result)
EIGEN_ALWAYS_INLINE void	colLoopBodyExtraN (Index col, Index depth, Index cols, Index rows, const Packet4f pAlpha, const bfloat16 *indexA, const bfloat16 *blockB, Index strideB, Index offsetB, float *result)
EIGEN_ALWAYS_INLINE void	colLoopBodyIter (Index depth, Index rows, const Packet4f pAlpha, const bfloat16 *indexA, const bfloat16 *indexB, Index strideB, Index offsetB, float *result, const Index extra_cols, const Index extra_rows)
EIGEN_ALWAYS_INLINE void	colLoops (Index depth, Index cols, Index rows, const Packet4f pAlpha, const bfloat16 *indexA, const bfloat16 *blockB, Index strideB, Index offsetB, float *result)
void	colVecColLoopBody (Index &row, Index cend, Index rows, LhsMapper &lhs, RhsMapper &rhs, const Packet4f pAlpha, float *result)
EIGEN_ALWAYS_INLINE void	colVecColLoopBodyExtra (Index &row, Index cend, Index rows, LhsMapper &lhs, RhsMapper &rhs, const Packet4f pAlpha, float *result)
EIGEN_ALWAYS_INLINE void	colVecColLoopBodyExtraN (Index &row, Index cend, Index rows, LhsMapper &lhs, RhsMapper &rhs, const Packet4f pAlpha, float *result)
void	colVecLoopBody (Index &row, Index cols, Index rows, LhsMapper &lhs, RhsMapper &rhs, const Packet4f pAlpha, float *result)
EIGEN_ALWAYS_INLINE void	colVecLoopBodyExtra (Index &row, Index cols, Index rows, LhsMapper &lhs, RhsMapper &rhs, const Packet4f pAlpha, float *result)
EIGEN_ALWAYS_INLINE void	colVecLoopBodyExtraN (Index &row, Index cols, Index rows, LhsMapper &lhs, RhsMapper &rhs, const Packet4f pAlpha, float *result)
void	colVSXLoopBody (Index &col, Index depth, Index cols, Index rows, const Packet4f pAlpha, const float *indexA, const float *indexB, Index strideB, Index offsetB, float *result)
void	colVSXLoopBodyExtra (Index col, Index depth, Index cols, Index rows, const Packet4f pAlpha, const float *indexA, const float *blockB, Index strideB, Index offsetB, float *result)
EIGEN_ALWAYS_INLINE void	colVSXLoopBodyExtraN (Index col, Index depth, Index cols, Index rows, const Packet4f pAlpha, const float *indexA, const float *blockB, Index strideB, Index offsetB, float *result)
EIGEN_ALWAYS_INLINE void	colVSXLoopBodyIter (Index depth, Index rows, const Packet4f pAlpha, const float *indexA, const float *indexB, Index strideB, Index offsetB, float *result, const Index extra_cols, const Index extra_rows)
EIGEN_ALWAYS_INLINE void	colVSXLoops (Index depth, Index cols, Index rows, const Packet4f pAlpha, const bfloat16 *indexA, const float *indexA2, const float *blockB2, Index strideA, Index strideB, Index offsetB, float *result2)
Packet32h	combine2Packet16h (const Packet16h &a, const Packet16h &b)
EIGEN_ALWAYS_INLINE ResScalar	combine_scalar_factors (const Lhs &lhs, const Rhs &rhs)
EIGEN_ALWAYS_INLINE ResScalar	combine_scalar_factors (const ResScalar &alpha, const Lhs &lhs, const Rhs &rhs)
std::complex< T >	complex_log (const std::complex< T > &z)
std::complex< T >	complex_rsqrt (const std::complex< T > &a_x)
std::complex< T >	complex_sqrt (const std::complex< T > &a_x)
constexpr int	compute_default_alignment_helper (int ArrayBytes, int AlignmentBytes)
void	compute_inverse_size2_helper (const MatrixType &matrix, const typename ResultType::Scalar &invdet, ResultType &result)
void	compute_inverse_size3_helper (const MatrixType &matrix, const typename ResultType::Scalar &invdet, const Matrix< typename ResultType::Scalar, 3, 1 > &cofactors_col0, ResultType &result)
constexpr unsigned	compute_matrix_flags (int Options)
ComputationInfo	computeFromTridiagonal_impl (DiagType &diag, SubDiagType &subdiag, const Index maxIterations, bool computeEigenvectors, MatrixType &eivec)
void	computeProductBlockingSizes (Index &k, Index &m, Index &n, Index num_threads=1)
void	conditional_aligned_delete (T *ptr, std::size_t size)
void	conditional_aligned_delete_auto (T *ptr, std::size_t size)
void	conditional_aligned_free (void *ptr)
void	conditional_aligned_free< false > (void *ptr)
void *	conditional_aligned_malloc (std::size_t size)
void *	conditional_aligned_malloc< false > (std::size_t size)
T *	conditional_aligned_new (std::size_t size)
T *	conditional_aligned_new_auto (std::size_t size)
void *	conditional_aligned_realloc (void *ptr, std::size_t new_size, std::size_t old_size)
void *	conditional_aligned_realloc< false > (void *ptr, std::size_t new_size, std::size_t old_size)
T *	conditional_aligned_realloc_new (T *pts, std::size_t new_size, std::size_t old_size)
T *	conditional_aligned_realloc_new_auto (T *pts, std::size_t new_size, std::size_t old_size)
EIGEN_DONT_INLINE void	conjugate_gradient (const MatrixType &mat, const Rhs &rhs, Dest &x, const Preconditioner &precond, Index &iters, typename Dest::RealScalar &tol_error)
static void	conservative_sparse_sparse_product_impl (const Lhs &lhs, const Rhs &rhs, ResultType &res, bool sortedInsertion=false)
T *	const_cast_ptr (const T *ptr)
T *	construct_at (T *p, Args &&... args)
IndexDest	convert_index (const IndexSrc &idx)
EIGEN_ALWAYS_INLINE void	convertArrayBF16toF32 (float *result, Index cols, Index rows, const DataMapper &src)
EIGEN_ALWAYS_INLINE void	convertArrayF32toBF16 (float *result, Index cols, Index rows, const DataMapper &res)
EIGEN_ALWAYS_INLINE void	convertArrayF32toBF16Col (float *result, Index col, Index rows, const DataMapper &res)
EIGEN_ALWAYS_INLINE void	convertArrayF32toBF16ColVSX (float *result, Index col, Index rows, const DataMapper &res)
EIGEN_ALWAYS_INLINE void	convertArrayF32toBF16VSX (float *result, Index cols, Index rows, const DataMapper &res)
EIGEN_ALWAYS_INLINE void	convertArrayPointerBF16toF32 (float *result, Index cols, Index rows, bfloat16 *src, Index resInc)
EIGEN_ALWAYS_INLINE void	convertArrayPointerBF16toF32Dup (float *result, Index cols, Index rows, const bfloat16 *src, Index delta, Index extra_rows)
EIGEN_ALWAYS_INLINE void	convertArrayPointerBF16toF32DupOne (float *result, Index rows, const bfloat16 *src, Index extra_rows)
EIGEN_ALWAYS_INLINE void	convertArrayPointerF32toBF16 (float *result, Index rows, bfloat16 *dst, Index resInc=1)
EIGEN_ALWAYS_INLINE void	convertBF16toF32 (Index &i, float *result, Index rows, const DataMapper &src)
EIGEN_ALWAYS_INLINE Packet8bf	convertF32toBF16 (const float *res)
EIGEN_ALWAYS_INLINE Packet8bf	convertF32toBF16VSX (const float *res)
EIGEN_ALWAYS_INLINE void	convertPointerBF16toF32 (Index &i, float *result, Index rows, bfloat16 *&src, Index resInc)
EIGEN_ALWAYS_INLINE void	convertPointerF32toBF16 (Index &i, float *result, Index rows, bfloat16 *&dst, Index resInc=1)
T *	copy_construct_elements_of_array (T *ptr, const T *src, std::size_t size)
EIGEN_ALWAYS_INLINE void	copyBToRowMajor (Scalar *B_arr, int64_t LDB, int64_t K, Scalar *B_temp, int64_t LDB_, int64_t remM_=0)
template<typename T >
EIGEN_ALWAYS_INLINE std::enable_if_t< sizeof(T)==4, int >	count_leading_zeros (const T val)
template<typename T >
EIGEN_ALWAYS_INLINE std::enable_if_t< sizeof(T)==8, int >	count_leading_zeros (const T val)
template<typename Scalar >
void	covar (Matrix< Scalar, Dynamic, Dynamic > &r, const VectorXi &ipvt, Scalar tol=std::sqrt(NumTraits< Scalar >::epsilon()))
StorageIndex	cs_tdfs (StorageIndex j, StorageIndex k, StorageIndex *head, const StorageIndex *next, StorageIndex *post, StorageIndex *stack)
static StorageIndex	cs_wclear (StorageIndex mark, StorageIndex lemax, StorageIndex *w, StorageIndex n)
template<typename IndexType , typename Index >
EIGEN_CONSTEXPR array< Index, 0 >	customIndices2Array (IndexType &, numeric_list< Index >)
template<typename Index , std::size_t NumIndices, typename IndexType >
EIGEN_CONSTEXPR array< Index, NumIndices >	customIndices2Array (IndexType &idx)
template<typename IndexType , typename Index , Index First, Index... Is>
EIGEN_CONSTEXPR array< Index, 1+sizeof...(Is)>	customIndices2Array (IndexType &idx, numeric_list< Index, First, Is... >)
T *	default_construct_elements_of_array (T *ptr, std::size_t size)
void	destroy_at (T *p)
void	destruct_elements_of_array (T *ptr, std::size_t size)
EIGEN_ALWAYS_INLINE void	disassembleAccumulators (__vector_quad(&quad_acc)[num_acc], Packet4f(&acc)[num_acc][4])
template<typename Scalar >
void	dogleg (const Matrix< Scalar, Dynamic, Dynamic > &qrfac, const Matrix< Scalar, Dynamic, 1 > &diag, const Matrix< Scalar, Dynamic, 1 > &qtb, Scalar delta, Matrix< Scalar, Dynamic, 1 > &x)
void	doubleword_div_fp (const Packet &x_hi, const Packet &x_lo, const Packet &y, Packet &z_hi, Packet &z_lo)
	EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE (add_assign_op, scalar_difference_op, sub_assign_op)
	EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE (add_assign_op, scalar_sum_op, add_assign_op)
	EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE (assign_op, scalar_difference_op, sub_assign_op)
	EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE (assign_op, scalar_sum_op, add_assign_op)
	EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE (sub_assign_op, scalar_difference_op, add_assign_op)
	EIGEN_CATCH_ASSIGN_DENSE_OP_SPARSE (sub_assign_op, scalar_sum_op, sub_assign_op)
	EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT (add_assign_op, scalar_difference_op, sub_assign_op)
	EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT (add_assign_op, scalar_sum_op, add_assign_op)
	EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT (assign_op, scalar_difference_op, sub_assign_op)
	EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT (assign_op, scalar_sum_op, add_assign_op)
	EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT (sub_assign_op, scalar_difference_op, add_assign_op)
	EIGEN_CATCH_ASSIGN_XPR_OP_PRODUCT (sub_assign_op, scalar_sum_op, sub_assign_op)
static	EIGEN_DECLARE_CONST_FAST_Packet2d (ZERO, 0)
static	EIGEN_DECLARE_CONST_FAST_Packet2l (ONE, 1)
static	EIGEN_DECLARE_CONST_FAST_Packet2l (ZERO, 0)
static	EIGEN_DECLARE_CONST_FAST_Packet4f (ZERO, 0)
static	EIGEN_DECLARE_CONST_FAST_Packet4i (MINUS1,-1)
static	EIGEN_DECLARE_CONST_FAST_Packet4i (MINUS16,-16)
static	EIGEN_DECLARE_CONST_FAST_Packet4i (ONE, 1)
static	EIGEN_DECLARE_CONST_FAST_Packet4i (ZERO, 0)
static	EIGEN_DECLARE_CONST_FAST_Packet4ui (PREV0DOT5, 0x3EFFFFFFu)
static	EIGEN_DECLARE_CONST_FAST_Packet4ui (SIGN, 0x80000000u)
static	EIGEN_DECLARE_CONST_FAST_Packet8us (ONE, 1)
static	EIGEN_DECLARE_CONST_Packet2d (1, 1.0)
static	EIGEN_DECLARE_CONST_Packet2d (2, 2.0)
static	EIGEN_DECLARE_CONST_Packet2d (cephes_exp_C1, 0.693145751953125)
static	EIGEN_DECLARE_CONST_Packet2d (cephes_exp_C2, 1.42860682030941723212e-6)
static	EIGEN_DECLARE_CONST_Packet2d (cephes_exp_p0, 1.26177193074810590878e-4)
static	EIGEN_DECLARE_CONST_Packet2d (cephes_exp_p1, 3.02994407707441961300e-2)
static	EIGEN_DECLARE_CONST_Packet2d (cephes_exp_p2, 9.99999999999999999910e-1)
static	EIGEN_DECLARE_CONST_Packet2d (cephes_exp_q0, 3.00198505138664455042e-6)
static	EIGEN_DECLARE_CONST_Packet2d (cephes_exp_q1, 2.52448340349684104192e-3)
static	EIGEN_DECLARE_CONST_Packet2d (cephes_exp_q2, 2.27265548208155028766e-1)
static	EIGEN_DECLARE_CONST_Packet2d (cephes_exp_q3, 2.00000000000000000009e0)
static	EIGEN_DECLARE_CONST_Packet2d (cephes_LOG2EF, 1.4426950408889634073599)
static	EIGEN_DECLARE_CONST_Packet2d (exp_hi, 709.437)
static	EIGEN_DECLARE_CONST_Packet2d (exp_lo, -709.436139303)
static	EIGEN_DECLARE_CONST_Packet2d (half, 0.5)
static	EIGEN_DECLARE_CONST_Packet4f (1, 1.0f)
static	EIGEN_DECLARE_CONST_Packet4f (cephes_exp_C1, 0.693359375f)
static	EIGEN_DECLARE_CONST_Packet4f (cephes_exp_C2, -2.12194440e-4f)
static	EIGEN_DECLARE_CONST_Packet4f (cephes_exp_p0, 1.9875691500E-4f)
static	EIGEN_DECLARE_CONST_Packet4f (cephes_exp_p1, 1.3981999507E-3f)
static	EIGEN_DECLARE_CONST_Packet4f (cephes_exp_p2, 8.3334519073E-3f)
static	EIGEN_DECLARE_CONST_Packet4f (cephes_exp_p3, 4.1665795894E-2f)
static	EIGEN_DECLARE_CONST_Packet4f (cephes_exp_p4, 1.6666665459E-1f)
static	EIGEN_DECLARE_CONST_Packet4f (cephes_exp_p5, 5.0000001201E-1f)
static	EIGEN_DECLARE_CONST_Packet4f (cephes_LOG2EF, 1.44269504088896341f)
static	EIGEN_DECLARE_CONST_Packet4f (cephes_log_p0, 7.0376836292E-2f)
static	EIGEN_DECLARE_CONST_Packet4f (cephes_log_p1, - 1.1514610310E-1f)
static	EIGEN_DECLARE_CONST_Packet4f (cephes_log_p2, 1.1676998740E-1f)
static	EIGEN_DECLARE_CONST_Packet4f (cephes_log_p3, - 1.2420140846E-1f)
static	EIGEN_DECLARE_CONST_Packet4f (cephes_log_p4,+1.4249322787E-1f)
static	EIGEN_DECLARE_CONST_Packet4f (cephes_log_p5, - 1.6668057665E-1f)
static	EIGEN_DECLARE_CONST_Packet4f (cephes_log_p6,+2.0000714765E-1f)
static	EIGEN_DECLARE_CONST_Packet4f (cephes_log_p7, - 2.4999993993E-1f)
static	EIGEN_DECLARE_CONST_Packet4f (cephes_log_p8,+3.3333331174E-1f)
static	EIGEN_DECLARE_CONST_Packet4f (cephes_log_q1, -2.12194440e-4f)
static	EIGEN_DECLARE_CONST_Packet4f (cephes_log_q2, 0.693359375f)
static	EIGEN_DECLARE_CONST_Packet4f (cephes_SQRTHF, 0.707106781186547524f)
static	EIGEN_DECLARE_CONST_Packet4f (exp_hi, 88.3762626647950f)
static	EIGEN_DECLARE_CONST_Packet4f (exp_lo, -88.3762626647949f)
static	EIGEN_DECLARE_CONST_Packet4f (half, 0.5f)
static	EIGEN_DECLARE_CONST_Packet4f_FROM_INT (inv_mant_mask, ~0x7f800000)
static	EIGEN_DECLARE_CONST_Packet4f_FROM_INT (min_norm_pos, 0x00800000)
static	EIGEN_DECLARE_CONST_Packet4f_FROM_INT (minus_inf, 0xff800000)
static	EIGEN_DECLARE_CONST_Packet4f_FROM_INT (minus_nan, 0xffffffff)
static	EIGEN_DECLARE_CONST_Packet4i (0x7f, 0x7f)
static	EIGEN_DECLARE_CONST_Packet4i (23, 23)
	EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR (maxCoeff,(Size-1) *NumTraits< Scalar >::AddCost, 1, internal::scalar_max_op)
	EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR (minCoeff,(Size-1) *NumTraits< Scalar >::AddCost, 1, internal::scalar_min_op)
	EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR (prod,(Size-1) *NumTraits< Scalar >::MulCost, 1, internal::scalar_product_op)
	EIGEN_MAKE_PARTIAL_REDUX_FUNCTOR (sum,(Size-1) *NumTraits< Scalar >::AddCost, 1, internal::scalar_sum_op)
	EIGEN_MATHFUNC_RETVAL (random, Scalar) random()
	EIGEN_MATHFUNC_RETVAL (random, Scalar) random(const Scalar &x
	EIGEN_MEMBER_FUNCTOR (all,(Size-1) *NumTraits< Scalar >::AddCost)
	EIGEN_MEMBER_FUNCTOR (any,(Size-1) *NumTraits< Scalar >::AddCost)
	EIGEN_MEMBER_FUNCTOR (blueNorm,(Size+5) *NumTraits< Scalar >::MulCost+(Size-1) *NumTraits< Scalar >::AddCost)
	EIGEN_MEMBER_FUNCTOR (count,(Size-1) *NumTraits< Scalar >::AddCost)
	EIGEN_MEMBER_FUNCTOR (hypotNorm,(Size-1) *functor_traits< scalar_hypot_op< Scalar > >::Cost)
	EIGEN_MEMBER_FUNCTOR (norm,(Size+5) *NumTraits< Scalar >::MulCost+(Size-1) *NumTraits< Scalar >::AddCost)
	EIGEN_MEMBER_FUNCTOR (stableNorm,(Size+5) *NumTraits< Scalar >::MulCost+(Size-1) *NumTraits< Scalar >::AddCost)
static int	eigen_neon_shuffle_mask (int p, int q, int r, int s)
void	eigen_pastix (pastix_data_t **pastix_data, int pastix_comm, int n, int *ptr, int *idx, double *vals, int *perm, int *invp, double *x, int nbrhs, int *iparm, double *dparm)
void	eigen_pastix (pastix_data_t **pastix_data, int pastix_comm, int n, int *ptr, int *idx, float *vals, int *perm, int *invp, float *x, int nbrhs, int *iparm, double *dparm)
void	eigen_pastix (pastix_data_t **pastix_data, int pastix_comm, int n, int *ptr, int *idx, std::complex< double > *vals, int *perm, int *invp, std::complex< double > *x, int nbrhs, int *iparm, double *dparm)
void	eigen_pastix (pastix_data_t **pastix_data, int pastix_comm, int n, int *ptr, int *idx, std::complex< float > *vals, int *perm, int *invp, std::complex< float > *x, int nbrhs, int *iparm, double *dparm)
Index	etree_find (Index i, IndexVector &pp)
Index	eval_expr_given_size (const symbolic::BaseExpr< Derived > &x, Index size)
FixedInt< N >	eval_expr_given_size (FixedInt< N > x, Index)
Index	eval_expr_given_size (Index x, Index)
void	evaluateProductBlockingSizesHeuristic (Index &k, Index &m, Index &n, Index num_threads=1)
constexpr int	exponent_digits ()
Packet2d	extract128 (Packet8d x)
Packet8f	extract256 (Packet16f x)
void	extract2Packet16h (const Packet32h &x, Packet16h &a, Packet16h &b)
EIGEN_ALWAYS_INLINE const T::Scalar *	extract_data (const T &m)
Packet4bf	F32MaskToBf16Mask (const Packet4f &p)
Packet16bf	F32ToBf16 (const Packet16f &a)
Packet4bf	F32ToBf16 (const Packet4f &p)
Packet8bf	F32ToBf16 (const Packet8f &a)
Packet8bf	F32ToBf16 (Packet4f even, Packet4f odd)
Packet8bf	F32ToBf16 (Packet4f p4f)
Packet8bf	F32ToBf16Bool (Packet4f even, Packet4f odd)
Packet8bf	F32ToBf16Both (Packet4f lo, Packet4f hi)
EIGEN_ALWAYS_INLINE Packet8bf	F32ToBf16Two (Packet4f lo, Packet4f hi)
void	fast_twosum (const Packet &x, const Packet &y, Packet &s_hi, Packet &s_lo)
void	fast_twosum (const Packet &x, const Packet &y_hi, const Packet &y_lo, Packet &s_hi, Packet &s_lo)
void	fast_twosum (const Packet &x_hi, const Packet &x_lo, const Packet &y_hi, const Packet &y_lo, Packet &s_hi, Packet &s_lo)
template<typename FunctorType , typename Scalar >
DenseIndex	fdjac1 (const FunctorType &Functor, Matrix< Scalar, Dynamic, 1 > &x, Matrix< Scalar, Dynamic, 1 > &fvec, Matrix< Scalar, Dynamic, Dynamic > &fjac, DenseIndex ml, DenseIndex mu, Scalar epsfcn)
fftw_complex *	fftw_cast (const std::complex< double > *p)
fftwf_complex *	fftw_cast (const std::complex< float > *p)
fftwl_complex *	fftw_cast (const std::complex< long double > *p)
template<typename T >
T *	fftw_cast (const T *p)
EIGEN_CONSTEXPR Index	first (const T &x) EIGEN_NOEXCEPT
static Index	first_aligned (const DenseBase< Derived > &m)
Index	first_aligned (const Scalar *array, Index size)
static Index	first_default_aligned (const DenseBase< Derived > &m)
Index	first_default_aligned (const Scalar *array, Index size)
Index	first_multiple (Index size, Index base)
template<typename T >
T	flipsign (const T &should_flipsign, const T &x)
template<>
double	flipsign< double > (const double &should_flipsign, const double &x)
template<>
float	flipsign< float > (const float &should_flipsign, const float &x)
Packet16h	float2half (const Packet16f &a)
Packet8h	float2half (const Packet8f &a)
void	fortran_to_c_numbering (MatrixType &mat)
void	gemm (const DataMapper &res, const Scalar *blockA, const Scalar *blockB, Index rows, Index depth, Index cols, Scalar alpha, Index strideA, Index strideB, Index offsetA, Index offsetB)
EIGEN_ALWAYS_INLINE void	gemm_cols (const DataMapper &res, const Scalar *blockA, const Scalar *blockB, Index depth, Index strideA, Index offsetA, Index strideB, Index offsetB, Index col, Index rows, Index remaining_rows, const Packet &pAlpha, const Packet &pMask)
void	gemm_complex (const DataMapper &res, const LhsScalar *blockAc, const RhsScalar *blockBc, Index rows, Index depth, Index cols, Scalarc alpha, Index strideA, Index strideB, Index offsetA, Index offsetB)
EIGEN_ALWAYS_INLINE void	gemm_complex_cols (const DataMapper &res, const Scalar *blockA, const Scalar *blockB, Index depth, Index strideA, Index offsetA, Index strideB, Index offsetB, Index col, Index rows, Index remaining_rows, const Packet &pAlphaReal, const Packet &pAlphaImag, const Packet &pMask)
EIGEN_ALWAYS_INLINE void	gemm_complex_extra_cols (const DataMapper &res, const Scalar *blockA, const Scalar *blockB, Index depth, Index strideA, Index offsetA, Index strideB, Index offsetB, Index col, Index rows, Index cols, Index remaining_rows, const Packet &pAlphaReal, const Packet &pAlphaImag, const Packet &pMask)
EIGEN_ALWAYS_INLINE void	gemm_complex_extra_row (const DataMapper &res, const Scalar *lhs_base, const Scalar *rhs_base, Index depth, Index strideA, Index offsetA, Index strideB, Index row, Index rows, Index remaining_rows, const Packet &pAlphaReal, const Packet &pAlphaImag, const Packet &pMask)
EIGEN_ALWAYS_INLINE void	gemm_complex_unrolled_iteration (const DataMapper &res, const Scalar *lhs_base, const Scalar *rhs_base, Index depth, Index strideA, Index offsetA, Index strideB, Index &row, const Packet &pAlphaReal, const Packet &pAlphaImag, const Packet &pMask)
EIGEN_ALWAYS_INLINE void	gemm_complex_unrolled_MMA_iteration (const DataMapper &res, const Scalar *lhs_base, const Scalar *rhs_base, Index depth, Index strideA, Index offsetA, Index strideB, Index &row, const Packet &pAlphaReal, const Packet &pAlphaImag, const Packet &pMask)
void	gemm_complexMMA (const DataMapper &res, const LhsScalar *blockAc, const RhsScalar *blockBc, Index rows, Index depth, Index cols, Scalarc alpha, Index strideA, Index strideB, Index offsetA, Index offsetB)
EIGEN_ALWAYS_INLINE void	gemm_extra_cols (const DataMapper &res, const Scalar *blockA, const Scalar *blockB, Index depth, Index strideA, Index offsetA, Index strideB, Index offsetB, Index col, Index rows, Index cols, Index remaining_rows, const Packet &pAlpha, const Packet &pMask)
EIGEN_ALWAYS_INLINE void	gemm_extra_row (const DataMapper &res, const Scalar *lhs_base, const Scalar *rhs_base, Index depth, Index strideA, Index offsetA, Index strideB, Index row, Index rows, Index remaining_rows, const Packet &pAlpha, const Packet &pMask)
EIGEN_DONT_INLINE void	gemm_kern_avx512 (Index m, Index n, Index k, Scalar *alpha, const Scalar *a, const Scalar *b, Scalar *c, Index ldc, Index inc=1, Index a_stride=-1, Index b_stride=-1, Index a_off=0, Index b_off=0)
EIGEN_ALWAYS_INLINE void	gemm_unrolled_complex_row_iteration (const DataMapper &res, const Scalar *lhs_base, const Scalar *rhs_base, Index depth, Index strideA, Index offsetA, Index strideB, Index row, Index rows, const Packet &pAlphaReal, const Packet &pAlphaImag, const Packet &pMask)
EIGEN_ALWAYS_INLINE void	gemm_unrolled_iteration (const DataMapper &res, const Scalar *lhs_base, const Scalar *rhs_base, Index depth, Index strideA, Index offsetA, Index strideB, Index &row, const Packet &pAlpha, const Packet &pMask)
EIGEN_ALWAYS_INLINE void	gemm_unrolled_MMA_iteration (const DataMapper &res, const Scalar *lhs_base, const Scalar *rhs_base, Index depth, Index strideA, Index offsetA, Index &row, const Packet &pAlpha, const Packet &pMask)
EIGEN_ALWAYS_INLINE void	gemm_unrolled_row_iteration (const DataMapper &res, const Scalar *lhs_base, const Scalar *rhs_base, Index depth, Index strideA, Index offsetA, Index strideB, Index row, Index rows, const Packet &pAlpha, const Packet &pMask)
void	gemmbfloat16 (const DataMapper &res, const bfloat16 *indexA, const bfloat16 *indexB, Index rows, Index depth, Index cols, bfloat16 alpha, Index strideA, Index strideB, Index offsetA, Index offsetB)
void	gemmKernel (Scalar *A_arr, Scalar *B_arr, Scalar *C_arr, int64_t M, int64_t N, int64_t K, int64_t LDA, int64_t LDB, int64_t LDC)
void	gemmMMA (const DataMapper &res, const Scalar *blockA, const Scalar *blockB, Index rows, Index depth, Index cols, Scalar alpha, Index strideA, Index strideB, Index offsetA, Index offsetB)
EIGEN_ALWAYS_INLINE void	gemmMMA_cols (const DataMapper &res, const Scalar *blockA, const Scalar *blockB, Index depth, Index strideA, Index offsetA, Index strideB, Index offsetB, Index col, Index rows, Index remaining_rows, const Packet &pAlpha, const Packet &pMask)
EIGEN_ALWAYS_INLINE void	gemmMMA_complex_cols (const DataMapper &res, const Scalar *blockA, const Scalar *blockB, Index depth, Index strideA, Index offsetA, Index strideB, Index offsetB, Index col, Index rows, Index remaining_rows, const Packet &pAlphaReal, const Packet &pAlphaImag, const Packet &pMask)
void	gemmMMAbfloat16 (const DataMapper &res, const bfloat16 *indexA, const bfloat16 *indexB, Index rows, Index depth, Index cols, bfloat16 alpha, Index strideA, Index strideB, Index offsetA, Index offsetB)
void	gemvMMA_bfloat16_col (Index rows, Index cols, const LhsMapper &alhs, const RhsMapper &rhs, bfloat16 *res, Index resIncr, bfloat16 alpha)
void	gemvMMA_bfloat16_row (Index rows, Index cols, const LhsMapper &alhs, const RhsMapper &rhs, bfloat16 *res, Index resIncr, bfloat16 alpha)
const Derived::Scalar	general_det3_helper (const MatrixBase< Derived > &matrix, int i1, int i2, int i3, int j1, int j2, int j3)
Packet	generic_expm1 (const Packet &x)
template<typename T >
T	generic_fast_erf_float (const T &x)
T	generic_fast_tanh_float (const T &a_x)
template<typename T , typename ScalarType >
EIGEN_ALWAYS_INLINE T	generic_ndtri (const T &a)
template<typename T , typename ScalarType >
T	generic_ndtri_gt_exp_neg_two (const T &b)
template<typename T , typename ScalarType >
T	generic_ndtri_lt_exp_neg_two (const T &b, const T &should_flipsign)
Packet	generic_plog1p (const Packet &x)
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	generic_pow (const Packet &x, const Packet &y)
Packet	generic_pow_impl (const Packet &x, const Packet &y)
constexpr int	get_compiletime_reshape_order (int flags, int order)
constexpr int	get_computation_options (int options)
constexpr int	get_qr_preconditioner (int options)
uint64_t	get_random_seed ()
Index	get_runtime_reshape_size (AutoSize_t, Index other, Index total)
Index	get_runtime_reshape_size (SizeType size, Index, Index)
Index	get_runtime_value (const T &x)
EIGEN_ALWAYS_INLINE std::complex< Scalar >	getAdjointVal (Index i, Index j, const_blas_data_mapper< std::complex< Scalar >, Index, StorageOrder > &dt)
template<typename RealScalar >
void	GetDenseElt (const std::string &line, RealScalar &val)
template<typename RealScalar >
void	GetDenseElt (const std::string &line, std::complex< RealScalar > &val)
template<>
void	GetMarketLine (const char *line, int &i, int &j, double &value)
template<>
void	GetMarketLine (const char *line, int &i, int &j, float &value)
template<>
void	GetMarketLine (const char *line, int &i, int &j, std::complex< double > &value)
template<>
void	GetMarketLine (const char *line, int &i, int &j, std::complex< float > &value)
template<typename Scalar , typename StorageIndex >
void	GetMarketLine (const char *line, StorageIndex &i, StorageIndex &j, Scalar &value)
template<typename Scalar , typename StorageIndex >
void	GetMarketLine (const char *line, StorageIndex &i, StorageIndex &j, std::complex< Scalar > &value)
template<typename MatrixType , typename Rhs , typename Dest , typename Preconditioner >
bool	gmres (const MatrixType &mat, const Rhs &rhs, Dest &x, const Preconditioner &precond, Index &iters, const Index &restart, typename Dest::RealScalar &tol_error)
constexpr array< decltype(Op::run(A())), N >	h_array_apply (array< A, N > a, numeric_list< int, n... >)
constexpr auto	h_array_apply_and_reduce (array< A, N > arr, numeric_list< int, n... >) -> decltype(reduce< Reducer, typename id_numeric< int, n, decltype(Op::run(A()))>::type... >::run(Op::run(array_get< n >(arr))...))
constexpr Array	h_array_reverse (Array arr, numeric_list< int, n... >)
constexpr array< decltype(Op::run(A(), B())), N >	h_array_zip (array< A, N > a, array< B, N > b, numeric_list< int, n... >)
constexpr auto	h_array_zip_and_reduce (array< A, N > a, array< B, N > b, numeric_list< int, n... >) -> decltype(reduce< Reducer, typename id_numeric< int, n, decltype(Op::run(A(), B()))>::type... >::run(Op::run(array_get< n >(a), array_get< n >(b))...))
Packet16f	half2float (const Packet16h &a)
Packet8f	half2float (const Packet8h &a)
void	handmade_aligned_free (void *ptr)
void *	handmade_aligned_malloc (std::size_t size, std::size_t alignment=EIGEN_DEFAULT_ALIGN_BYTES)
void *	handmade_aligned_realloc (void *ptr, std::size_t new_size, std::size_t old_size, std::size_t alignment=EIGEN_DEFAULT_ALIGN_BYTES)
void	householder_qr_inplace_unblocked (MatrixQR &mat, HCoeffs &hCoeffs, typename MatrixQR::Scalar *tempData=0)
void	householder_qr_inplace_update (MatrixQR &mat, HCoeffs &hCoeffs, const VectorQR &newColumn, typename MatrixQR::Index k, typename MatrixQR::Scalar *tempData)
template<typename MatrixType , typename Rhs , typename Dest , typename Preconditioner >
bool	idrs (const MatrixType &A, const Rhs &b, Dest &x, const Preconditioner &precond, Index &iter, typename Dest::RealScalar &relres, Index S, bool smoothing, typename Dest::RealScalar angle, bool replacement)
template<typename MatrixType , typename Rhs , typename Dest , typename Preconditioner >
bool	idrstabl (const MatrixType &mat, const Rhs &rhs, Dest &x, const Preconditioner &precond, Index &iters, typename Dest::RealScalar &tol_error, Index L, Index S)
template<typename Scalar , IgammaComputationMode mode>
int	igamma_num_iterations ()
constexpr void	ignore_unused_variable (const T &)
template<typename T >
static EIGEN_CONSTEXPR bool	index_known_statically (Index i)
EIGEN_CONSTEXPR auto	index_list_size (const T &x)
EIGEN_CONSTEXPR std::ptrdiff_t	index_list_size (const T(&)[N])
template<typename T >
static EIGEN_CONSTEXPR bool	index_pair_first_statically_eq (Index i, Index value)
template<typename T >
static EIGEN_CONSTEXPR bool	index_pair_second_statically_eq (Index i, Index value)
template<typename T >
static EIGEN_CONSTEXPR bool	index_statically_eq (Index i, Index value)
template<typename T >
static EIGEN_CONSTEXPR bool	index_statically_gt (Index i, Index value)
template<typename T >
static EIGEN_CONSTEXPR bool	index_statically_lt (Index i, Index value)
template<typename T >
static EIGEN_CONSTEXPR bool	index_statically_ne (Index i, Index value)
template<typename T >
static EIGEN_CONSTEXPR bool	indices_statically_known_to_increase ()
template<typename Derived , int N>
void	initialize_tensor (TensorEvaluator< Derived, DefaultDevice > &tensor, const typename Initializer< Derived, traits< Derived >::NumDimensions >::InitList &vals)
void	insert_from_triplets (const InputIterator &begin, const InputIterator &end, SparseMatrixType &mat, DupFunctor dup_func)
void	insert_from_triplets_sorted (const InputIterator &begin, const InputIterator &end, SparseMatrixType &mat, DupFunctor dup_func)
InstType	instantiate_by_c_array (ArrType *arr)
constexpr bool	is_constant_evaluated ()
bool	is_identically_zero (const Scalar &s)
bool	is_same_dense (const T1 &, const T2 &, std::enable_if_t<!possibly_same_dense< T1, T2 >::value > *=0)
bool	is_same_dense (const T1 &mat1, const T2 &mat2, std::enable_if_t< possibly_same_dense< T1, T2 >::value > *=0)
bool	isApprox (const mpfr::mpreal &a, const mpfr::mpreal &b, const mpfr::mpreal &eps)
bool	isApprox (const Scalar &x, const Scalar &y, const typename NumTraits< Scalar >::Real &precision=NumTraits< Scalar >::dummy_precision())
bool	isApproxOrLessThan (const mpfr::mpreal &a, const mpfr::mpreal &b, const mpfr::mpreal &eps)
bool	isApproxOrLessThan (const Scalar &x, const Scalar &y, const typename NumTraits< Scalar >::Real &precision=NumTraits< Scalar >::dummy_precision())
bool	isfinite_impl (const std::complex< T > &x)
std::enable_if_t<!(std::numeric_limits< T >::has_infinity||std::numeric_limits< T >::has_quiet_NaN||std::numeric_limits< T >::has_signaling_NaN), bool >	isfinite_impl (const T &)
bool	isinf_impl (const std::complex< T > &x)
std::enable_if_t<!std::numeric_limits< T >::has_infinity, bool >	isinf_impl (const T &)
bool	isMuchSmallerThan (const mpfr::mpreal &a, const mpfr::mpreal &b, const mpfr::mpreal &eps)
bool	isMuchSmallerThan (const Scalar &x, const OtherScalar &y, const typename NumTraits< Scalar >::Real &precision=NumTraits< Scalar >::dummy_precision())
bool	isnan_impl (const std::complex< T > &x)
std::enable_if_t<!(std::numeric_limits< T >::has_quiet_NaN||std::numeric_limits< T >::has_signaling_NaN), bool >	isnan_impl (const T &)
EIGEN_ALWAYS_INLINE void	KLoop (const bfloat16 *indexA, const bfloat16 *indexB, __vector_quad(&quad_acc)[num_acc], Index strideB, Index k, Index offsetB, Index extra_cols, Index extra_rows)
EIGEN_ALWAYS_INLINE void	KLoop (const float *indexA, const float *indexB, Packet4f(&acc)[num_acc][4], Index strideB, Index k, Index offsetB, Index extra_cols)
template<typename T >
Index	LeafSize ()
template<>
Index	LeafSize< bfloat16 > ()
template<>
Index	LeafSize< half > ()
EIGEN_DONT_INLINE void	least_square_conjugate_gradient (const MatrixType &mat, const Rhs &rhs, Dest &x, const Preconditioner &precond, Index &iters, typename Dest::RealScalar &tol_error)
static Index	llt_rank_update_lower (MatrixType &mat, const VectorType &vec, const typename MatrixType::RealScalar &sigma)
template<typename Scalar >
void	lmpar (Matrix< Scalar, Dynamic, Dynamic > &r, const VectorXi &ipvt, const Matrix< Scalar, Dynamic, 1 > &diag, const Matrix< Scalar, Dynamic, 1 > &qtb, Scalar delta, Scalar &par, Matrix< Scalar, Dynamic, 1 > &x)
template<typename Scalar >
void	lmpar2 (const ColPivHouseholderQR< Matrix< Scalar, Dynamic, Dynamic > > &qr, const Matrix< Scalar, Dynamic, 1 > &diag, const Matrix< Scalar, Dynamic, 1 > &qtb, Scalar delta, Scalar &par, Matrix< Scalar, Dynamic, 1 > &x)
template<typename QRSolver , typename VectorType >
void	lmpar2 (const QRSolver &qr, const VectorType &diag, const VectorType &qtb, typename VectorType::Scalar m_delta, typename VectorType::Scalar &par, VectorType &x)
template<typename Scalar , int Rows, int Cols, typename PermIndex >
void	lmqrsolv (Matrix< Scalar, Rows, Cols > &s, const PermutationMatrix< Dynamic, Dynamic, PermIndex > &iPerm, const Matrix< Scalar, Dynamic, 1 > &diag, const Matrix< Scalar, Dynamic, 1 > &qtb, Matrix< Scalar, Dynamic, 1 > &x, Matrix< Scalar, Dynamic, 1 > &sdiag)
template<typename Scalar , int Options_, typename Index >
void	lmqrsolv (SparseMatrix< Scalar, Options_, Index > &s, const PermutationMatrix< Dynamic, Dynamic > &iPerm, const Matrix< Scalar, Dynamic, 1 > &diag, const Matrix< Scalar, Dynamic, 1 > &qtb, Matrix< Scalar, Dynamic, 1 > &x, Matrix< Scalar, Dynamic, 1 > &sdiag)
EIGEN_ALWAYS_INLINE Packet4f	loadAndMultiplyF32 (Packet4f acc, const Packet4f pAlpha, float *result)
EIGEN_ALWAYS_INLINE Packet8bf	loadBF16fromResult (bfloat16 *src, Index resInc)
EIGEN_ALWAYS_INLINE Packet8bf	loadBfloat16 (const bfloat16 *indexA)
EIGEN_ALWAYS_INLINE Packet8bf	loadColData (RhsMapper &rhs, Index j)
template<typename T >
EIGEN_ALWAYS_INLINE T	loadConstant (const T *address)
void	loadQuadToDoublePacket (const Scalar *b, DoublePacket< RealPacket > &dest, std::enable_if_t< unpacket_traits< RealPacket >::size<=8 > *=0)
void	loadQuadToDoublePacket (const Scalar *b, DoublePacket< RealPacket > &dest, std::enable_if_t< unpacket_traits< RealPacket >::size==16 > *=0)
EIGEN_ALWAYS_INLINE Packet8bf	loadRhsBfloat16 (const bfloat16 *blockB, Index strideB, Index i)
EIGEN_ALWAYS_INLINE void	loadTwoRhsFloat32 (const float *block, Index strideB, Index i, Packet4f &dhs0, Packet4f &dhs1)
EIGEN_ALWAYS_INLINE void	loadVecLoop (Index k, LhsMapper &lhs, Packet8bf(&a0)[num_acc], Packet8bf b1)
constexpr bool	logical_xor (bool a, bool b)
Index	LUnumTempV (Index &m, Index &w, Index &t, Index &b)
Index	LUTempSpace (Index &m, Index &w)
template<typename Scalar >
static Scalar	main_igamma_term (Scalar a, Scalar x)
void	make_block_householder_triangular_factor (TriangularFactorType &triFactor, const VectorsType &vectors, const CoeffsType &hCoeffs)
template<typename A , typename B >
void	make_coherent (const A &a, const B &b)
template<typename UnaryOp , typename A , typename RefType >
void	make_coherent_expression (const CwiseNullaryOp< UnaryOp, A > &, const RefType &)
template<typename UnaryOp , typename A , typename RefType >
void	make_coherent_expression (const CwiseUnaryOp< UnaryOp, A > &xpr, const RefType &ref)
template<typename BinOp , typename A , typename B , typename RefType >
void	make_coherent_expression (CwiseBinaryOp< BinOp, A, B > xpr, const RefType &ref)
EIGEN_ALWAYS_INLINE Packet2f	make_packet2f (float a, float b)
EIGEN_ALWAYS_INLINE Packet4f	make_packet4f (float a, float b, float c, float d)
AllRange< get_fixed_value< XprSizeType >::value >	makeIndexedViewCompatible (all_t, XprSizeType size, SpecializedType)
ArithmeticSequence< Index, typename make_size_type< SizeType >::type, IncrType >	makeIndexedViewCompatible (const ArithmeticSequence< FirstType, SizeType, IncrType > &ids, Index size, SpecializedType)
std::enable_if_t< symbolic::is_symbolic< T >::value, SingleRange >	makeIndexedViewCompatible (const T &id, Index size, SpecializedType)
const T &	makeIndexedViewCompatible (const T &x, Index, Q)
void	manage_caching_sizes (Action action, std::ptrdiff_t *l1, std::ptrdiff_t *l2, std::ptrdiff_t *l3)
std::ptrdiff_t	manage_caching_sizes_helper (std::ptrdiff_t a, std::ptrdiff_t b)
void	manage_multi_threading (Action action, int *v)
Map< SparseMatrix< Scalar, Flags, Index > >	map_superlu (SluMatrix &sluMat)
template<typename ArgType , typename ResultType >
void	matrix_exp_compute (const ArgType &arg, ResultType &result, false_type)
template<typename ArgType , typename ResultType >
void	matrix_exp_compute (const ArgType &arg, ResultType &result, true_type)
template<typename MatA , typename MatU , typename MatV >
void	matrix_exp_pade13 (const MatA &A, MatU &U, MatV &V)
	Compute the (13,13)-Padé approximant to the exponential. More...
template<typename MatA , typename MatU , typename MatV >
void	matrix_exp_pade3 (const MatA &A, MatU &U, MatV &V)
	Compute the (3,3)-Padé approximant to the exponential. More...
template<typename MatA , typename MatU , typename MatV >
void	matrix_exp_pade5 (const MatA &A, MatU &U, MatV &V)
	Compute the (5,5)-Padé approximant to the exponential. More...
template<typename MatA , typename MatU , typename MatV >
void	matrix_exp_pade7 (const MatA &A, MatU &U, MatV &V)
	Compute the (7,7)-Padé approximant to the exponential. More...
template<typename MatA , typename MatU , typename MatV >
void	matrix_exp_pade9 (const MatA &A, MatU &U, MatV &V)
	Compute the (9,9)-Padé approximant to the exponential. More...
template<typename MatrixType , typename VectorType >
void	matrix_function_compute_above_diagonal (const MatrixType &T, const VectorType &blockStart, const VectorType &clusterSize, MatrixType &fT)
	Compute part of matrix function above block diagonal. More...
template<typename MatrixType , typename AtomicType , typename VectorType >
void	matrix_function_compute_block_atomic (const MatrixType &T, AtomicType &atomic, const VectorType &blockStart, const VectorType &clusterSize, MatrixType &fT)
	Compute block diagonal part of matrix function. More...
template<typename VectorType >
void	matrix_function_compute_block_start (const VectorType &clusterSize, VectorType &blockStart)
	Compute start of each block using clusterSize. More...
template<typename ListOfClusters , typename Index >
void	matrix_function_compute_cluster_size (const ListOfClusters &clusters, Matrix< Index, Dynamic, 1 > &clusterSize)
	Compute size of each cluster given a partitioning. More...
template<typename EivalsType , typename ListOfClusters , typename VectorType >
void	matrix_function_compute_map (const EivalsType &eivals, const ListOfClusters &clusters, VectorType &eivalToCluster)
	Compute mapping of eigenvalue indices to cluster indices. More...
template<typename MatrixType >
NumTraits< typename MatrixType::Scalar >::Real	matrix_function_compute_mu (const MatrixType &A)
template<typename DynVectorType , typename VectorType >
void	matrix_function_compute_permutation (const DynVectorType &blockStart, const DynVectorType &eivalToCluster, VectorType &permutation)
	Compute permutation which groups ei'vals in same cluster together. More...
template<typename Index , typename ListOfClusters >
ListOfClusters::iterator	matrix_function_find_cluster (Index key, ListOfClusters &clusters)
	Find cluster in clusters containing some value. More...
template<typename EivalsType , typename Cluster >
void	matrix_function_partition_eigenvalues (const EivalsType &eivals, std::list< Cluster > &clusters)
	Partition eigenvalues in clusters of ei'vals close to each other. More...
template<typename VectorType , typename MatrixType >
void	matrix_function_permute_schur (VectorType &permutation, MatrixType &U, MatrixType &T)
	Permute Schur decomposition in U and T according to permutation. More...
template<typename MatrixType >
MatrixType	matrix_function_solve_triangular_sylvester (const MatrixType &A, const MatrixType &B, const MatrixType &C)
	Solve a triangular Sylvester equation AX + XB = C. More...
template<typename MatrixType >
void	matrix_log_compute_2x2 (const MatrixType &A, MatrixType &result)
	Compute logarithm of 2x2 triangular matrix. More...
template<typename MatrixType >
void	matrix_log_compute_big (const MatrixType &A, MatrixType &result)
	Compute logarithm of triangular matrices with size > 2. More...
template<typename MatrixType >
void	matrix_log_compute_pade (MatrixType &result, const MatrixType &T, int degree)
int	matrix_log_get_pade_degree (double normTminusI)
int	matrix_log_get_pade_degree (float normTminusI)
int	matrix_log_get_pade_degree (long double normTminusI)
template<typename MatrixType , typename ResultType >
void	matrix_sqrt_quasi_triangular_1x1_off_diagonal_block (const MatrixType &T, Index i, Index j, ResultType &sqrtT)
template<typename MatrixType , typename ResultType >
void	matrix_sqrt_quasi_triangular_1x2_off_diagonal_block (const MatrixType &T, Index i, Index j, ResultType &sqrtT)
template<typename MatrixType , typename ResultType >
void	matrix_sqrt_quasi_triangular_2x1_off_diagonal_block (const MatrixType &T, Index i, Index j, ResultType &sqrtT)
template<typename MatrixType , typename ResultType >
void	matrix_sqrt_quasi_triangular_2x2_diagonal_block (const MatrixType &T, Index i, ResultType &sqrtT)
template<typename MatrixType , typename ResultType >
void	matrix_sqrt_quasi_triangular_2x2_off_diagonal_block (const MatrixType &T, Index i, Index j, ResultType &sqrtT)
template<typename MatrixType , typename ResultType >
void	matrix_sqrt_quasi_triangular_diagonal (const MatrixType &T, ResultType &sqrtT)
template<typename MatrixType , typename ResultType >
void	matrix_sqrt_quasi_triangular_off_diagonal (const MatrixType &T, ResultType &sqrtT)
template<typename MatrixType >
void	matrix_sqrt_quasi_triangular_solve_auxiliary_equation (MatrixType &X, const MatrixType &A, const MatrixType &B, const MatrixType &C)
constexpr int	max_size_prefer_dynamic (A a, B b)
EIGEN_ALWAYS_INLINE void	MICRO_COMPLEX_EXTRA_ROW (const Scalar *&lhs_ptr_real, const Scalar *&lhs_ptr_imag, const Scalar *&rhs_ptr_real0, const Scalar *&rhs_ptr_real1, const Scalar *&rhs_ptr_real2, const Scalar *&rhs_ptr_imag0, const Scalar *&rhs_ptr_imag1, const Scalar *&rhs_ptr_imag2, PacketBlock< Packet, accRows > &accReal, PacketBlock< Packet, accRows > &accImag)
EIGEN_ALWAYS_INLINE void	MICRO_EXTRA_ROW (const Scalar *&lhs_ptr, const Scalar *&rhs_ptr0, const Scalar *&rhs_ptr1, const Scalar *&rhs_ptr2, PacketBlock< Packet, accRows > &accZero)
constexpr int	min_size_prefer_dynamic (A a, B b)
constexpr int	min_size_prefer_fixed (A a, B b)
void	minimum_degree_ordering (SparseMatrix< Scalar, ColMajor, StorageIndex > &C, PermutationMatrix< Dynamic, Dynamic, StorageIndex > &perm)
template<typename MatrixType , typename Rhs , typename Dest , typename Preconditioner >
EIGEN_DONT_INLINE void	minres (const MatrixType &mat, const Rhs &rhs, Dest &x, const Preconditioner &precond, Index &iters, typename Dest::RealScalar &tol_error)
T *	move_construct_elements_of_array (T *ptr, T *src, std::size_t size)
EIGEN_ALWAYS_INLINE void	multVec (__vector_quad(&quad_acc)[num_acc], Packet8bf(&a0)[num_acc], Packet8bf b0)
EIGEN_ALWAYS_INLINE void	multVecLoop (__vector_quad(&quad_acc)[num_acc], const LhsMapper &lhs, RhsMapper &rhs, Index j, Index extra_cols)
template<typename T >
EIGEN_ALWAYS_INLINE uint32_t	muluh (const uint32_t a, const T b)
template<typename T >
EIGEN_ALWAYS_INLINE uint64_t	muluh (const uint64_t a, const T b)
void	nr_etdfs (typename IndexVector::Scalar n, IndexVector &parent, IndexVector &first_kid, IndexVector &next_kid, IndexVector &post, typename IndexVector::Scalar postnum)
template<typename Vector , typename RealScalar >
Vector::Scalar	omega (const Vector &t, const Vector &s, RealScalar angle)
EIGEN_ALWAYS_INLINE Packet4f	oneConvertBF16Hi (Packet8us data)
EIGEN_ALWAYS_INLINE Packet4f	oneConvertBF16Lo (Packet8us data)
EIGEN_ALWAYS_INLINE Packet4f	oneConvertBF16Perm (Packet8us data, Packet16uc mask)
template<typename HL , typename LL , typename HR , typename LR >
EIGEN_ALWAYS_INLINE bool	operator!= (const TensorUInt128< HL, LL > &lhs, const TensorUInt128< HR, LR > &rhs)
template<typename HL , typename LL , typename HR , typename LR >
static TensorUInt128< uint64_t, uint64_t >	operator* (const TensorUInt128< HL, LL > &lhs, const TensorUInt128< HR, LR > &rhs)
template<typename HL , typename LL , typename HR , typename LR >
EIGEN_ALWAYS_INLINE TensorUInt128< uint64_t, uint64_t >	operator+ (const TensorUInt128< HL, LL > &lhs, const TensorUInt128< HR, LR > &rhs)
template<typename HL , typename LL , typename HR , typename LR >
EIGEN_ALWAYS_INLINE TensorUInt128< uint64_t, uint64_t >	operator- (const TensorUInt128< HL, LL > &lhs, const TensorUInt128< HR, LR > &rhs)
template<typename T , bool div_gt_one>
T	operator/ (const T &numerator, const TensorIntDivisor< T, div_gt_one > &divisor)
template<typename HL , typename LL , typename HR , typename LR >
static TensorUInt128< uint64_t, uint64_t >	operator/ (const TensorUInt128< HL, LL > &lhs, const TensorUInt128< HR, LR > &rhs)
template<typename HL , typename LL , typename HR , typename LR >
EIGEN_ALWAYS_INLINE bool	operator< (const TensorUInt128< HL, LL > &lhs, const TensorUInt128< HR, LR > &rhs)
std::ostream &	operator<< (std::ostream &os, const Packet1cd &value)
std::ostream &	operator<< (std::ostream &os, const Packet2cf &value)
std::ostream &	operator<< (std::ostream &os, const Packet2d &value)
std::ostream &	operator<< (std::ostream &os, const Packet2l &value)
std::ostream &	operator<< (std::ostream &os, const Packet2ul &value)
std::ostream &	operator<< (std::ostream &os, const PacketBlock< Packet1cd, 2 > &value)
std::ostream &	operator<< (std::ostream &os, const PacketBlock< Packet2cf, 2 > &value)
std::ostream &	operator<< (std::ostream &os, const PacketBlock< Packet2d, 2 > &value)
std::ostream &	operator<< (std::ostream &os, const PacketBlock< Packet4f, 4 > &value)
std::ostream &	operator<< (std::ostream &os, const PacketBlock< Packet4i, 4 > &value)
std::ostream &	operator<< (std::ostream &s, const Packet16c &v)
std::ostream &	operator<< (std::ostream &s, const Packet16uc &v)
std::ostream &	operator<< (std::ostream &s, const Packet4f &v)
std::ostream &	operator<< (std::ostream &s, const Packet4i &v)
std::ostream &	operator<< (std::ostream &s, const Packet4ui &v)
template<typename HL , typename LL , typename HR , typename LR >
EIGEN_ALWAYS_INLINE bool	operator== (const TensorUInt128< HL, LL > &lhs, const TensorUInt128< HR, LR > &rhs)
template<typename HL , typename LL , typename HR , typename LR >
EIGEN_ALWAYS_INLINE bool	operator>= (const TensorUInt128< HL, LL > &lhs, const TensorUInt128< HR, LR > &rhs)
void	ordering_helper_at_plus_a (const MatrixType &A, MatrixType &symmat)
void	outer_product_selector_run (Dst &dst, const Lhs &lhs, const Rhs &rhs, const Func &func, const false_type &)
void	outer_product_selector_run (Dst &dst, const Lhs &lhs, const Rhs &rhs, const Func &func, const true_type &)
EIGEN_ALWAYS_INLINE void	outputResults (Packet4f(&acc)[num_acc][4], Index rows, const Packet4f pAlpha, float *result, const Index extra_cols, Index extra_rows)
EIGEN_ALWAYS_INLINE void	outputResultsVSX (Packet4f(&acc)[num_acc][4], Index rows, const Packet4f pAlpha, float *result, const Index extra_cols, Index extra_rows)
EIGEN_ALWAYS_INLINE void	outputVecColResults (Packet4f(&acc)[num_acc][size], float *result, Packet4f pAlpha, Index extra_rows)
EIGEN_ALWAYS_INLINE void	outputVecResults (Packet4f(&acc)[num_acc][size], float *result, Packet4f pAlpha)
uint32x2_t	p2ui_CONJ_XOR ()
Packet	pabs (const Packet &a)
Packet16bf	pabs (const Packet16bf &a)
Packet16c	pabs (const Packet16c &a)
Packet16f	pabs (const Packet16f &a)
Packet16h	pabs (const Packet16h &a)
Packet16i	pabs (const Packet16i &a)
Packet16uc	pabs (const Packet16uc &a)
Packet2d	pabs (const Packet2d &a)
Packet2f	pabs (const Packet2f &a)
Packet2i	pabs (const Packet2i &a)
Packet2l	pabs (const Packet2l &a)
Packet2ui	pabs (const Packet2ui &a)
Packet2ul	pabs (const Packet2ul &a)
Packet4bf	pabs (const Packet4bf &a)
Packet4d	pabs (const Packet4d &a)
Packet4f	pabs (const Packet4f &a)
Packet4i	pabs (const Packet4i &a)
Packet4s	pabs (const Packet4s &a)
Packet4uc	pabs (const Packet4uc &a)
Packet4ui	pabs (const Packet4ui &a)
Packet4us	pabs (const Packet4us &a)
Packet8bf	pabs (const Packet8bf &a)
Packet8c	pabs (const Packet8c &a)
Packet8d	pabs (const Packet8d &a)
Packet8f	pabs (const Packet8f &a)
Packet8h	pabs (const Packet8h &a)
Packet8i	pabs (const Packet8i &a)
Packet8s	pabs (const Packet8s &a)
Packet8uc	pabs (const Packet8uc &a)
Packet8ui	pabs (const Packet8ui &a)
Packet8us	pabs (const Packet8us &a)
PacketXf	pabs (const PacketXf &a)
PacketXi	pabs (const PacketXi &a)
unsigned int	pabs (const unsigned int &a)
unsigned long	pabs (const unsigned long &a)
unsigned long long	pabs (const unsigned long long &a)
Packet2d	pabs< Packet2d > (const Packet2d &a)
Packet32h	pabs< Packet32h > (const Packet32h &a)
Packet4c	pabs< Packet4c > (const Packet4c &a)
Packet4f	pabs< Packet4f > (const Packet4f &a)
Packet4i	pabs< Packet4i > (const Packet4i &a)
Packet	pabsdiff (const Packet &a, const Packet &b)
Packet16c	pabsdiff< Packet16c > (const Packet16c &a, const Packet16c &b)
Packet16uc	pabsdiff< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
Packet2f	pabsdiff< Packet2f > (const Packet2f &a, const Packet2f &b)
Packet2i	pabsdiff< Packet2i > (const Packet2i &a, const Packet2i &b)
Packet2ui	pabsdiff< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
Packet4bf	pabsdiff< Packet4bf > (const Packet4bf &a, const Packet4bf &b)
Packet4c	pabsdiff< Packet4c > (const Packet4c &a, const Packet4c &b)
Packet4f	pabsdiff< Packet4f > (const Packet4f &a, const Packet4f &b)
Packet4i	pabsdiff< Packet4i > (const Packet4i &a, const Packet4i &b)
Packet4s	pabsdiff< Packet4s > (const Packet4s &a, const Packet4s &b)
Packet4uc	pabsdiff< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
Packet4ui	pabsdiff< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
Packet4us	pabsdiff< Packet4us > (const Packet4us &a, const Packet4us &b)
Packet8c	pabsdiff< Packet8c > (const Packet8c &a, const Packet8c &b)
Packet8s	pabsdiff< Packet8s > (const Packet8s &a, const Packet8s &b)
Packet8uc	pabsdiff< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
Packet8us	pabsdiff< Packet8us > (const Packet8us &a, const Packet8us &b)
__m128i	Pack16To8 (Packet8f rf)
__m256i	Pack32To16 (Packet16f rf)
PacketType	packetwise_redux_empty_value (const Func &)
PacketType	packetwise_redux_empty_value (const scalar_product_op< Scalar, Scalar > &)
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pacos (const Packet &a)
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pacos_float (const Packet &x_in)
bool	padd (const bool &a, const bool &b)
DoublePacket< Packet >	padd (const DoublePacket< Packet > &a, const DoublePacket< Packet > &b)
Packet	padd (const Packet &a, const Packet &b)
std::enable_if_t< unpacket_traits< Packet >::masked_fpops_available, Packet >	padd (const Packet &a, const Packet &b, typename unpacket_traits< Packet >::mask_t umask)
Packet16b	padd< Packet16b > (const Packet16b &a, const Packet16b &b)
Packet16bf	padd< Packet16bf > (const Packet16bf &a, const Packet16bf &b)
Packet16c	padd< Packet16c > (const Packet16c &a, const Packet16c &b)
Packet16f	padd< Packet16f > (const Packet16f &a, const Packet16f &b)
Packet16f	padd< Packet16f > (const Packet16f &a, const Packet16f &b, uint16_t umask)
Packet16h	padd< Packet16h > (const Packet16h &a, const Packet16h &b)
Packet16i	padd< Packet16i > (const Packet16i &a, const Packet16i &b)
Packet16uc	padd< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
Packet1cd	padd< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
Packet1cf	padd< Packet1cf > (const Packet1cf &a, const Packet1cf &b)
Packet2cd	padd< Packet2cd > (const Packet2cd &a, const Packet2cd &b)
Packet2cf	padd< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
Packet2d	padd< Packet2d > (const Packet2d &a, const Packet2d &b)
Packet2f	padd< Packet2f > (const Packet2f &a, const Packet2f &b)
Packet2i	padd< Packet2i > (const Packet2i &a, const Packet2i &b)
Packet2l	padd< Packet2l > (const Packet2l &a, const Packet2l &b)
Packet2ui	padd< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
Packet2ul	padd< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
Packet32h	padd< Packet32h > (const Packet32h &a, const Packet32h &b)
Packet4bf	padd< Packet4bf > (const Packet4bf &a, const Packet4bf &b)
Packet4c	padd< Packet4c > (const Packet4c &a, const Packet4c &b)
Packet4cd	padd< Packet4cd > (const Packet4cd &a, const Packet4cd &b)
Packet4cf	padd< Packet4cf > (const Packet4cf &a, const Packet4cf &b)
Packet4d	padd< Packet4d > (const Packet4d &a, const Packet4d &b)
Packet4f	padd< Packet4f > (const Packet4f &a, const Packet4f &b)
Packet4i	padd< Packet4i > (const Packet4i &a, const Packet4i &b)
Packet4s	padd< Packet4s > (const Packet4s &a, const Packet4s &b)
Packet4uc	padd< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
Packet4ui	padd< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
Packet4us	padd< Packet4us > (const Packet4us &a, const Packet4us &b)
Packet8bf	padd< Packet8bf > (const Packet8bf &a, const Packet8bf &b)
Packet8c	padd< Packet8c > (const Packet8c &a, const Packet8c &b)
Packet8cf	padd< Packet8cf > (const Packet8cf &a, const Packet8cf &b)
Packet8d	padd< Packet8d > (const Packet8d &a, const Packet8d &b)
Packet8d	padd< Packet8d > (const Packet8d &a, const Packet8d &b, uint8_t umask)
Packet8f	padd< Packet8f > (const Packet8f &a, const Packet8f &b)
Packet8h	padd< Packet8h > (const Packet8h &a, const Packet8h &b)
Packet8i	padd< Packet8i > (const Packet8i &a, const Packet8i &b)
Packet8s	padd< Packet8s > (const Packet8s &a, const Packet8s &b)
Packet8uc	padd< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
Packet8ui	padd< Packet8ui > (const Packet8ui &a, const Packet8ui &b)
Packet8us	padd< Packet8us > (const Packet8us &a, const Packet8us &b)
PacketXf	padd< PacketXf > (const PacketXf &a, const PacketXf &b)
PacketXi	padd< PacketXi > (const PacketXi &a, const PacketXi &b)
Packet	padds (const Packet &a, const Packet &b)
Packet2d	padds< Packet2d > (const Packet2d &a, const Packet2d &b)
Packet4f	padds< Packet4f > (const Packet4f &a, const Packet4f &b)
Packet	paddsub (const Packet &a, const Packet &b)
Packet2d	paddsub< Packet2d > (const Packet2d &a, const Packet2d &b)
Packet2f	paddsub< Packet2f > (const Packet2f &a, const Packet2f &b)
Packet4f	paddsub< Packet4f > (const Packet4f &a, const Packet4f &b)
Packet	pand (const Packet &a, const Packet &b)
Packet16bf	pand (const Packet16bf &a, const Packet16bf &b)
Packet16h	pand (const Packet16h &a, const Packet16h &b)
Packet32h	pand (const Packet32h &a, const Packet32h &b)
Packet4bf	pand (const Packet4bf &a, const Packet4bf &b)
Packet8bf	pand (const Packet8bf &a, const Packet8bf &b)
Packet8h	pand (const Packet8h &a, const Packet8h &b)
Packet16b	pand< Packet16b > (const Packet16b &a, const Packet16b &b)
Packet16c	pand< Packet16c > (const Packet16c &a, const Packet16c &b)
Packet16f	pand< Packet16f > (const Packet16f &a, const Packet16f &b)
Packet16i	pand< Packet16i > (const Packet16i &a, const Packet16i &b)
Packet16uc	pand< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
Packet1cd	pand< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
Packet1cf	pand< Packet1cf > (const Packet1cf &a, const Packet1cf &b)
Packet2cd	pand< Packet2cd > (const Packet2cd &a, const Packet2cd &b)
Packet2cf	pand< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
Packet2d	pand< Packet2d > (const Packet2d &a, const Packet2d &b)
Packet2f	pand< Packet2f > (const Packet2f &a, const Packet2f &b)
Packet2i	pand< Packet2i > (const Packet2i &a, const Packet2i &b)
Packet2l	pand< Packet2l > (const Packet2l &a, const Packet2l &b)
Packet2ui	pand< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
Packet2ul	pand< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
Packet4c	pand< Packet4c > (const Packet4c &a, const Packet4c &b)
Packet4cd	pand< Packet4cd > (const Packet4cd &a, const Packet4cd &b)
Packet4cf	pand< Packet4cf > (const Packet4cf &a, const Packet4cf &b)
Packet4d	pand< Packet4d > (const Packet4d &a, const Packet4d &b)
Packet4f	pand< Packet4f > (const Packet4f &a, const Packet4f &b)
Packet4i	pand< Packet4i > (const Packet4i &a, const Packet4i &b)
Packet4s	pand< Packet4s > (const Packet4s &a, const Packet4s &b)
Packet4uc	pand< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
Packet4ui	pand< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
Packet4us	pand< Packet4us > (const Packet4us &a, const Packet4us &b)
Packet8bf	pand< Packet8bf > (const Packet8bf &a, const Packet8bf &b)
Packet8c	pand< Packet8c > (const Packet8c &a, const Packet8c &b)
Packet8cf	pand< Packet8cf > (const Packet8cf &a, const Packet8cf &b)
Packet8d	pand< Packet8d > (const Packet8d &a, const Packet8d &b)
Packet8f	pand< Packet8f > (const Packet8f &a, const Packet8f &b)
Packet8i	pand< Packet8i > (const Packet8i &a, const Packet8i &b)
Packet8s	pand< Packet8s > (const Packet8s &a, const Packet8s &b)
Packet8uc	pand< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
Packet8ui	pand< Packet8ui > (const Packet8ui &a, const Packet8ui &b)
Packet8us	pand< Packet8us > (const Packet8us &a, const Packet8us &b)
PacketXf	pand< PacketXf > (const PacketXf &a, const PacketXf &b)
PacketXi	pand< PacketXi > (const PacketXi &a, const PacketXi &b)
Packet	pandnot (const Packet &a, const Packet &b)
Packet16bf	pandnot (const Packet16bf &a, const Packet16bf &b)
Packet16h	pandnot (const Packet16h &a, const Packet16h &b)
Packet32h	pandnot (const Packet32h &a, const Packet32h &b)
Packet4bf	pandnot (const Packet4bf &a, const Packet4bf &b)
Packet8bf	pandnot (const Packet8bf &a, const Packet8bf &b)
Packet8h	pandnot (const Packet8h &a, const Packet8h &b)
Packet16c	pandnot< Packet16c > (const Packet16c &a, const Packet16c &b)
Packet16f	pandnot< Packet16f > (const Packet16f &a, const Packet16f &b)
Packet16i	pandnot< Packet16i > (const Packet16i &a, const Packet16i &b)
Packet16uc	pandnot< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
Packet1cd	pandnot< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
Packet1cf	pandnot< Packet1cf > (const Packet1cf &a, const Packet1cf &b)
Packet2cd	pandnot< Packet2cd > (const Packet2cd &a, const Packet2cd &b)
Packet2cf	pandnot< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
Packet2d	pandnot< Packet2d > (const Packet2d &a, const Packet2d &b)
Packet2f	pandnot< Packet2f > (const Packet2f &a, const Packet2f &b)
Packet2i	pandnot< Packet2i > (const Packet2i &a, const Packet2i &b)
Packet2l	pandnot< Packet2l > (const Packet2l &a, const Packet2l &b)
Packet2ui	pandnot< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
Packet2ul	pandnot< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
Packet4c	pandnot< Packet4c > (const Packet4c &a, const Packet4c &b)
Packet4cd	pandnot< Packet4cd > (const Packet4cd &a, const Packet4cd &b)
Packet4cf	pandnot< Packet4cf > (const Packet4cf &a, const Packet4cf &b)
Packet4d	pandnot< Packet4d > (const Packet4d &a, const Packet4d &b)
Packet4f	pandnot< Packet4f > (const Packet4f &a, const Packet4f &b)
Packet4i	pandnot< Packet4i > (const Packet4i &a, const Packet4i &b)
Packet4s	pandnot< Packet4s > (const Packet4s &a, const Packet4s &b)
Packet4uc	pandnot< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
Packet4ui	pandnot< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
Packet4us	pandnot< Packet4us > (const Packet4us &a, const Packet4us &b)
Packet8c	pandnot< Packet8c > (const Packet8c &a, const Packet8c &b)
Packet8cf	pandnot< Packet8cf > (const Packet8cf &a, const Packet8cf &b)
Packet8d	pandnot< Packet8d > (const Packet8d &a, const Packet8d &b)
Packet8f	pandnot< Packet8f > (const Packet8f &a, const Packet8f &b)
Packet8i	pandnot< Packet8i > (const Packet8i &a, const Packet8i &b)
Packet8s	pandnot< Packet8s > (const Packet8s &a, const Packet8s &b)
Packet8uc	pandnot< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
Packet8ui	pandnot< Packet8ui > (const Packet8ui &a, const Packet8ui &b)
Packet8us	pandnot< Packet8us > (const Packet8us &a, const Packet8us &b)
PacketXf	pandnot< PacketXf > (const PacketXf &a, const PacketXf &b)
PacketXi	pandnot< PacketXi > (const PacketXi &a, const PacketXi &b)
void	parallelize_gemm (const Functor &func, Index rows, Index cols, Index depth, bool transpose)
Packet	parg (const Packet &a)
int	parithmetic_shift_right (const int &a)
long int	parithmetic_shift_right (const long int &a)
Packet4i	parithmetic_shift_right (const Packet4i &a)
Packet4ui	parithmetic_shift_right (const Packet4ui &a)
Packet16c	parithmetic_shift_right (Packet16c a)
Packet16i	parithmetic_shift_right (Packet16i a)
Packet16uc	parithmetic_shift_right (Packet16uc a)
Packet2i	parithmetic_shift_right (Packet2i a)
Packet2l	parithmetic_shift_right (Packet2l a)
Packet2ui	parithmetic_shift_right (Packet2ui a)
Packet2ul	parithmetic_shift_right (Packet2ul a)
Packet4c	parithmetic_shift_right (Packet4c &a)
Packet4i	parithmetic_shift_right (Packet4i a)
Packet4s	parithmetic_shift_right (Packet4s a)
Packet4uc	parithmetic_shift_right (Packet4uc &a)
Packet4ui	parithmetic_shift_right (Packet4ui a)
Packet4us	parithmetic_shift_right (Packet4us a)
Packet8c	parithmetic_shift_right (Packet8c a)
Packet8i	parithmetic_shift_right (Packet8i a)
Packet8s	parithmetic_shift_right (Packet8s a)
Packet8uc	parithmetic_shift_right (Packet8uc a)
Packet8ui	parithmetic_shift_right (Packet8ui a)
Packet8us	parithmetic_shift_right (Packet8us a)
PacketXi	parithmetic_shift_right (PacketXi a)
void	partial_lu_inplace (MatrixType &lu, TranspositionType &row_transpositions, typename TranspositionType::StorageIndex &nb_transpositions)
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pasin (const Packet &a)
template<typename Packet >
static Packet	pasin (Packet a)
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pasin_float (const Packet &x_in)
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	patan (const Packet &a)
EIGEN_ALWAYS_INLINE Packet	patan2 (const Packet &y, const Packet &x)
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	patan_double (const Packet &x_in)
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	patan_float (const Packet &x_in)
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	patan_reduced_double (const Packet &x)
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	patan_reduced_float (const Packet &x)
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	patanh (const Packet &a)
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	patanh_float (const Packet &x)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pbessel_i0 (const Packet &x)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pbessel_i0e (const Packet &x)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pbessel_i1 (const Packet &x)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pbessel_i1e (const Packet &x)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pbessel_j0 (const Packet &x)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pbessel_j1 (const Packet &x)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pbessel_k0 (const Packet &x)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pbessel_k0e (const Packet &x)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pbessel_k1 (const Packet &x)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pbessel_k1e (const Packet &x)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pbessel_y0 (const Packet &x)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pbessel_y1 (const Packet &x)
template<typename Packet >
Packet	pbetainc (const Packet &a, const Packet &b, const Packet &x)
Packet16c	pblend (const Selector< 16 > &ifPacket, const Packet16c &thenPacket, const Packet16c &elsePacket)
Packet16f	pblend (const Selector< 16 > &ifPacket, const Packet16f &thenPacket, const Packet16f &elsePacket)
Packet16uc	pblend (const Selector< 16 > &ifPacket, const Packet16uc &thenPacket, const Packet16uc &elsePacket)
Packet2cf	pblend (const Selector< 2 > &ifPacket, const Packet2cf &thenPacket, const Packet2cf &elsePacket)
Packet2d	pblend (const Selector< 2 > &ifPacket, const Packet2d &thenPacket, const Packet2d &elsePacket)
Packet4d	pblend (const Selector< 4 > &ifPacket, const Packet4d &thenPacket, const Packet4d &elsePacket)
Packet4f	pblend (const Selector< 4 > &ifPacket, const Packet4f &thenPacket, const Packet4f &elsePacket)
Packet4i	pblend (const Selector< 4 > &ifPacket, const Packet4i &thenPacket, const Packet4i &elsePacket)
Packet4ui	pblend (const Selector< 4 > &ifPacket, const Packet4ui &thenPacket, const Packet4ui &elsePacket)
Packet8bf	pblend (const Selector< 8 > &ifPacket, const Packet8bf &thenPacket, const Packet8bf &elsePacket)
Packet8d	pblend (const Selector< 8 > &ifPacket, const Packet8d &thenPacket, const Packet8d &elsePacket)
Packet8f	pblend (const Selector< 8 > &ifPacket, const Packet8f &thenPacket, const Packet8f &elsePacket)
Packet8s	pblend (const Selector< 8 > &ifPacket, const Packet8s &thenPacket, const Packet8s &elsePacket)
Packet8us	pblend (const Selector< 8 > &ifPacket, const Packet8us &thenPacket, const Packet8us &elsePacket)
Packet	pblend (const Selector< unpacket_traits< Packet >::size > &ifPacket, const Packet &thenPacket, const Packet &elsePacket)
Packet	pblend4 (const Selector< 4 > &ifPacket, const Packet &thenPacket, const Packet &elsePacket)
void	pbroadcast2 (const typename unpacket_traits< Packet >::type *a, Packet &a0, Packet &a1)
void	pbroadcast4 (const typename unpacket_traits< Packet >::type *a, Packet &a0, Packet &a1, Packet &a2, Packet &a3)
void	pbroadcast4< Packet2d > (const double *a, Packet2d &a0, Packet2d &a1, Packet2d &a2, Packet2d &a3)
void	pbroadcast4< Packet4f > (const float *a, Packet4f &a0, Packet4f &a1, Packet4f &a2, Packet4f &a3)
void	pbroadcast4< Packet4i > (const int *a, Packet4i &a0, Packet4i &a1, Packet4i &a2, Packet4i &a3)
void	pbroadcast4_common (const __UNPACK_TYPE__(Packet) *a, Packet &a0, Packet &a1, Packet &a2, Packet &a3)
EIGEN_ALWAYS_INLINE void	pbroadcastN (const __UNPACK_TYPE__(Packet) *ap0, const __UNPACK_TYPE__(Packet) *ap1, const __UNPACK_TYPE__(Packet) *ap2, Packet &a0, Packet &a1, Packet &a2, Packet &a3)
EIGEN_ALWAYS_INLINE void	pbroadcastN< Packet2d, 4, false > (const double *ap0, const double *, const double *, Packet2d &a0, Packet2d &a1, Packet2d &a2, Packet2d &a3)
EIGEN_ALWAYS_INLINE void	pbroadcastN< Packet4f, 4, false > (const float *ap0, const float *ap1, const float *ap2, Packet4f &a0, Packet4f &a1, Packet4f &a2, Packet4f &a3)
EIGEN_ALWAYS_INLINE void	pbroadcastN< Packet4f, 4, true > (const float *ap0, const float *, const float *, Packet4f &a0, Packet4f &a1, Packet4f &a2, Packet4f &a3)
EIGEN_ALWAYS_INLINE Packet	pcarg (const Packet &a)
TgtPacket	pcast (const SrcPacket &a)
TgtPacket	pcast (const SrcPacket &a, const SrcPacket &b)
TgtPacket	pcast (const SrcPacket &a, const SrcPacket &b, const SrcPacket &c, const SrcPacket &d)
TgtPacket	pcast (const SrcPacket &a, const SrcPacket &b, const SrcPacket &c, const SrcPacket &d, const SrcPacket &e, const SrcPacket &f, const SrcPacket &g, const SrcPacket &h)
Packet1cf	pcast< float, Packet1cf > (const float &a)
Packet16f	pcast< Packet16b, Packet16f > (const Packet16b &a)
Packet16f	pcast< Packet16bf, Packet16f > (const Packet16bf &a)
Packet2l	pcast< Packet16c, Packet2l > (const Packet16c &a)
Packet2ul	pcast< Packet16c, Packet2ul > (const Packet16c &a)
Packet4f	pcast< Packet16c, Packet4f > (const Packet16c &a)
Packet4i	pcast< Packet16c, Packet4i > (const Packet16c &a)
Packet4ui	pcast< Packet16c, Packet4ui > (const Packet16c &a)
Packet8s	pcast< Packet16c, Packet8s > (const Packet16c &a)
Packet8us	pcast< Packet16c, Packet8us > (const Packet16c &a)
Packet16b	pcast< Packet16f, Packet16b > (const Packet16f &a)
Packet16bf	pcast< Packet16f, Packet16bf > (const Packet16f &a)
Packet16h	pcast< Packet16f, Packet16h > (const Packet16f &a)
Packet16i	pcast< Packet16f, Packet16i > (const Packet16f &a)
Packet16f	pcast< Packet16h, Packet16f > (const Packet16h &a)
Packet16f	pcast< Packet16i, Packet16f > (const Packet16i &a)
Packet2l	pcast< Packet16uc, Packet2l > (const Packet16uc &a)
Packet2ul	pcast< Packet16uc, Packet2ul > (const Packet16uc &a)
Packet4f	pcast< Packet16uc, Packet4f > (const Packet16uc &a)
Packet4i	pcast< Packet16uc, Packet4i > (const Packet16uc &a)
Packet4ui	pcast< Packet16uc, Packet4ui > (const Packet16uc &a)
Packet8s	pcast< Packet16uc, Packet8s > (const Packet16uc &a)
Packet8us	pcast< Packet16uc, Packet8us > (const Packet16uc &a)
Packet4f	pcast< Packet2d, Packet4f > (const Packet2d &a, const Packet2d &b)
Packet4i	pcast< Packet2d, Packet4i > (const Packet2d &a, const Packet2d &b)
Packet2cf	pcast< Packet2f, Packet2cf > (const Packet2f &a)
Packet2i	pcast< Packet2f, Packet2i > (const Packet2f &a)
Packet2l	pcast< Packet2f, Packet2l > (const Packet2f &a)
Packet2ui	pcast< Packet2f, Packet2ui > (const Packet2f &a)
Packet2ul	pcast< Packet2f, Packet2ul > (const Packet2f &a)
Packet4s	pcast< Packet2f, Packet4s > (const Packet2f &a, const Packet2f &b)
Packet4us	pcast< Packet2f, Packet4us > (const Packet2f &a, const Packet2f &b)
Packet8c	pcast< Packet2f, Packet8c > (const Packet2f &a, const Packet2f &b, const Packet2f &c, const Packet2f &d)
Packet8uc	pcast< Packet2f, Packet8uc > (const Packet2f &a, const Packet2f &b, const Packet2f &c, const Packet2f &d)
Packet2f	pcast< Packet2i, Packet2f > (const Packet2i &a)
Packet2l	pcast< Packet2i, Packet2l > (const Packet2i &a)
Packet2ul	pcast< Packet2i, Packet2ul > (const Packet2i &a)
Packet4s	pcast< Packet2i, Packet4s > (const Packet2i &a, const Packet2i &b)
Packet4us	pcast< Packet2i, Packet4us > (const Packet2i &a, const Packet2i &b)
Packet8c	pcast< Packet2i, Packet8c > (const Packet2i &a, const Packet2i &b, const Packet2i &c, const Packet2i &d)
Packet8uc	pcast< Packet2i, Packet8uc > (const Packet2i &a, const Packet2i &b, const Packet2i &c, const Packet2i &d)
Packet16c	pcast< Packet2l, Packet16c > (const Packet2l &a, const Packet2l &b, const Packet2l &c, const Packet2l &d, const Packet2l &e, const Packet2l &f, const Packet2l &g, const Packet2l &h)
Packet16uc	pcast< Packet2l, Packet16uc > (const Packet2l &a, const Packet2l &b, const Packet2l &c, const Packet2l &d, const Packet2l &e, const Packet2l &f, const Packet2l &g, const Packet2l &h)
Packet2f	pcast< Packet2l, Packet2f > (const Packet2l &a)
Packet2i	pcast< Packet2l, Packet2i > (const Packet2l &a)
Packet2ui	pcast< Packet2l, Packet2ui > (const Packet2l &a)
Packet4c	pcast< Packet2l, Packet4c > (const Packet2l &a, const Packet2l &b)
Packet4f	pcast< Packet2l, Packet4f > (const Packet2l &a, const Packet2l &b)
Packet4i	pcast< Packet2l, Packet4i > (const Packet2l &a, const Packet2l &b)
Packet4s	pcast< Packet2l, Packet4s > (const Packet2l &a, const Packet2l &b)
Packet4uc	pcast< Packet2l, Packet4uc > (const Packet2l &a, const Packet2l &b)
Packet4ui	pcast< Packet2l, Packet4ui > (const Packet2l &a, const Packet2l &b)
Packet4us	pcast< Packet2l, Packet4us > (const Packet2l &a, const Packet2l &b)
Packet8c	pcast< Packet2l, Packet8c > (const Packet2l &a, const Packet2l &b, const Packet2l &c, const Packet2l &d)
Packet8s	pcast< Packet2l, Packet8s > (const Packet2l &a, const Packet2l &b, const Packet2l &c, const Packet2l &d)
Packet8uc	pcast< Packet2l, Packet8uc > (const Packet2l &a, const Packet2l &b, const Packet2l &c, const Packet2l &d)
Packet8us	pcast< Packet2l, Packet8us > (const Packet2l &a, const Packet2l &b, const Packet2l &c, const Packet2l &d)
Packet2f	pcast< Packet2ui, Packet2f > (const Packet2ui &a)
Packet2l	pcast< Packet2ui, Packet2l > (const Packet2ui &a)
Packet2ul	pcast< Packet2ui, Packet2ul > (const Packet2ui &a)
Packet4s	pcast< Packet2ui, Packet4s > (const Packet2ui &a, const Packet2ui &b)
Packet4us	pcast< Packet2ui, Packet4us > (const Packet2ui &a, const Packet2ui &b)
Packet8c	pcast< Packet2ui, Packet8c > (const Packet2ui &a, const Packet2ui &b, const Packet2ui &c, const Packet2ui &d)
Packet8uc	pcast< Packet2ui, Packet8uc > (const Packet2ui &a, const Packet2ui &b, const Packet2ui &c, const Packet2ui &d)
Packet16c	pcast< Packet2ul, Packet16c > (const Packet2ul &a, const Packet2ul &b, const Packet2ul &c, const Packet2ul &d, const Packet2ul &e, const Packet2ul &f, const Packet2ul &g, const Packet2ul &h)
Packet16uc	pcast< Packet2ul, Packet16uc > (const Packet2ul &a, const Packet2ul &b, const Packet2ul &c, const Packet2ul &d, const Packet2ul &e, const Packet2ul &f, const Packet2ul &g, const Packet2ul &h)
Packet2f	pcast< Packet2ul, Packet2f > (const Packet2ul &a)
Packet2i	pcast< Packet2ul, Packet2i > (const Packet2ul &a)
Packet2ui	pcast< Packet2ul, Packet2ui > (const Packet2ul &a)
Packet4c	pcast< Packet2ul, Packet4c > (const Packet2ul &a, const Packet2ul &b)
Packet4f	pcast< Packet2ul, Packet4f > (const Packet2ul &a, const Packet2ul &b)
Packet4i	pcast< Packet2ul, Packet4i > (const Packet2ul &a, const Packet2ul &b)
Packet4s	pcast< Packet2ul, Packet4s > (const Packet2ul &a, const Packet2ul &b)
Packet4uc	pcast< Packet2ul, Packet4uc > (const Packet2ul &a, const Packet2ul &b)
Packet4ui	pcast< Packet2ul, Packet4ui > (const Packet2ul &a, const Packet2ul &b)
Packet4us	pcast< Packet2ul, Packet4us > (const Packet2ul &a, const Packet2ul &b)
Packet8c	pcast< Packet2ul, Packet8c > (const Packet2ul &a, const Packet2ul &b, const Packet2ul &c, const Packet2ul &d)
Packet8s	pcast< Packet2ul, Packet8s > (const Packet2ul &a, const Packet2ul &b, const Packet2ul &c, const Packet2ul &d)
Packet8uc	pcast< Packet2ul, Packet8uc > (const Packet2ul &a, const Packet2ul &b, const Packet2ul &c, const Packet2ul &d)
Packet8us	pcast< Packet2ul, Packet8us > (const Packet2ul &a, const Packet2ul &b, const Packet2ul &c, const Packet2ul &d)
Packet4f	pcast< Packet4c, Packet4f > (const Packet4c &a)
Packet4i	pcast< Packet4c, Packet4i > (const Packet4c &a)
Packet4s	pcast< Packet4c, Packet4s > (const Packet4c &a)
Packet4ui	pcast< Packet4c, Packet4ui > (const Packet4c &a)
Packet4us	pcast< Packet4c, Packet4us > (const Packet4c &a)
Packet4f	pcast< Packet4d, Packet4f > (const Packet4d &a)
Packet4i	pcast< Packet4d, Packet4i > (const Packet4d &a)
Packet8f	pcast< Packet4d, Packet8f > (const Packet4d &a, const Packet4d &b)
Packet8i	pcast< Packet4d, Packet8i > (const Packet4d &a, const Packet4d &b)
Packet16b	pcast< Packet4f, Packet16b > (const Packet4f &a, const Packet4f &b, const Packet4f &c, const Packet4f &d)
Packet16c	pcast< Packet4f, Packet16c > (const Packet4f &a, const Packet4f &b, const Packet4f &c, const Packet4f &d)
Packet16uc	pcast< Packet4f, Packet16uc > (const Packet4f &a, const Packet4f &b, const Packet4f &c, const Packet4f &d)
Packet2d	pcast< Packet4f, Packet2d > (const Packet4f &a)
Packet2l	pcast< Packet4f, Packet2l > (const Packet4f &a)
Packet2ul	pcast< Packet4f, Packet2ul > (const Packet4f &a)
Packet4c	pcast< Packet4f, Packet4c > (const Packet4f &a)
Packet4i	pcast< Packet4f, Packet4i > (const Packet4f &a)
Packet4s	pcast< Packet4f, Packet4s > (const Packet4f &a)
Packet4uc	pcast< Packet4f, Packet4uc > (const Packet4f &a)
Packet4ui	pcast< Packet4f, Packet4ui > (const Packet4f &a)
Packet4us	pcast< Packet4f, Packet4us > (const Packet4f &a)
Packet8bf	pcast< Packet4f, Packet8bf > (const Packet4f &a, const Packet4f &b)
Packet8c	pcast< Packet4f, Packet8c > (const Packet4f &a, const Packet4f &b)
Packet8s	pcast< Packet4f, Packet8s > (const Packet4f &a, const Packet4f &b)
Packet8uc	pcast< Packet4f, Packet8uc > (const Packet4f &a, const Packet4f &b)
Packet8us	pcast< Packet4f, Packet8us > (const Packet4f &a, const Packet4f &b)
Packet16c	pcast< Packet4i, Packet16c > (const Packet4i &a, const Packet4i &b, const Packet4i &c, const Packet4i &d)
Packet16uc	pcast< Packet4i, Packet16uc > (const Packet4i &a, const Packet4i &b, const Packet4i &c, const Packet4i &d)
Packet2l	pcast< Packet4i, Packet2l > (const Packet4i &a)
Packet2ul	pcast< Packet4i, Packet2ul > (const Packet4i &a)
Packet4c	pcast< Packet4i, Packet4c > (const Packet4i &a)
Packet4f	pcast< Packet4i, Packet4f > (const Packet4i &a)
Packet4s	pcast< Packet4i, Packet4s > (const Packet4i &a)
Packet4uc	pcast< Packet4i, Packet4uc > (const Packet4i &a)
Packet4us	pcast< Packet4i, Packet4us > (const Packet4i &a)
Packet8c	pcast< Packet4i, Packet8c > (const Packet4i &a, const Packet4i &b)
Packet8s	pcast< Packet4i, Packet8s > (const Packet4i &a, const Packet4i &b)
Packet8uc	pcast< Packet4i, Packet8uc > (const Packet4i &a, const Packet4i &b)
Packet8us	pcast< Packet4i, Packet8us > (const Packet4i &a, const Packet4i &b)
Packet2f	pcast< Packet4s, Packet2f > (const Packet4s &a)
Packet2i	pcast< Packet4s, Packet2i > (const Packet4s &a)
Packet2ui	pcast< Packet4s, Packet2ui > (const Packet4s &a)
Packet4c	pcast< Packet4s, Packet4c > (const Packet4s &a)
Packet4f	pcast< Packet4s, Packet4f > (const Packet4s &a)
Packet4i	pcast< Packet4s, Packet4i > (const Packet4s &a)
Packet4uc	pcast< Packet4s, Packet4uc > (const Packet4s &a)
Packet4ui	pcast< Packet4s, Packet4ui > (const Packet4s &a)
Packet8c	pcast< Packet4s, Packet8c > (const Packet4s &a, const Packet4s &b)
Packet8uc	pcast< Packet4s, Packet8uc > (const Packet4s &a, const Packet4s &b)
Packet4f	pcast< Packet4uc, Packet4f > (const Packet4uc &a)
Packet4i	pcast< Packet4uc, Packet4i > (const Packet4uc &a)
Packet4s	pcast< Packet4uc, Packet4s > (const Packet4uc &a)
Packet4ui	pcast< Packet4uc, Packet4ui > (const Packet4uc &a)
Packet4us	pcast< Packet4uc, Packet4us > (const Packet4uc &a)
Packet16c	pcast< Packet4ui, Packet16c > (const Packet4ui &a, const Packet4ui &b, const Packet4ui &c, const Packet4ui &d)
Packet16uc	pcast< Packet4ui, Packet16uc > (const Packet4ui &a, const Packet4ui &b, const Packet4ui &c, const Packet4ui &d)
Packet2l	pcast< Packet4ui, Packet2l > (const Packet4ui &a)
Packet2ul	pcast< Packet4ui, Packet2ul > (const Packet4ui &a)
Packet4c	pcast< Packet4ui, Packet4c > (const Packet4ui &a)
Packet4f	pcast< Packet4ui, Packet4f > (const Packet4ui &a)
Packet4s	pcast< Packet4ui, Packet4s > (const Packet4ui &a)
Packet4uc	pcast< Packet4ui, Packet4uc > (const Packet4ui &a)
Packet4us	pcast< Packet4ui, Packet4us > (const Packet4ui &a)
Packet8c	pcast< Packet4ui, Packet8c > (const Packet4ui &a, const Packet4ui &b)
Packet8s	pcast< Packet4ui, Packet8s > (const Packet4ui &a, const Packet4ui &b)
Packet8uc	pcast< Packet4ui, Packet8uc > (const Packet4ui &a, const Packet4ui &b)
Packet8us	pcast< Packet4ui, Packet8us > (const Packet4ui &a, const Packet4ui &b)
Packet2f	pcast< Packet4us, Packet2f > (const Packet4us &a)
Packet2i	pcast< Packet4us, Packet2i > (const Packet4us &a)
Packet2ui	pcast< Packet4us, Packet2ui > (const Packet4us &a)
Packet4c	pcast< Packet4us, Packet4c > (const Packet4us &a)
Packet4f	pcast< Packet4us, Packet4f > (const Packet4us &a)
Packet4i	pcast< Packet4us, Packet4i > (const Packet4us &a)
Packet4uc	pcast< Packet4us, Packet4uc > (const Packet4us &a)
Packet4ui	pcast< Packet4us, Packet4ui > (const Packet4us &a)
Packet8c	pcast< Packet4us, Packet8c > (const Packet4us &a, const Packet4us &b)
Packet8uc	pcast< Packet4us, Packet8uc > (const Packet4us &a, const Packet4us &b)
Packet4f	pcast< Packet8bf, Packet4f > (const Packet8bf &a)
Packet8f	pcast< Packet8bf, Packet8f > (const Packet8bf &a)
Packet8us	pcast< Packet8bf, Packet8us > (const Packet8bf &a)
Packet2f	pcast< Packet8c, Packet2f > (const Packet8c &a)
Packet2i	pcast< Packet8c, Packet2i > (const Packet8c &a)
Packet2ui	pcast< Packet8c, Packet2ui > (const Packet8c &a)
Packet4i	pcast< Packet8c, Packet4i > (const Packet8c &a)
Packet4s	pcast< Packet8c, Packet4s > (const Packet8c &a)
Packet4us	pcast< Packet8c, Packet4us > (const Packet8c &a)
Packet8s	pcast< Packet8c, Packet8s > (const Packet8c &a)
Packet8us	pcast< Packet8c, Packet8us > (const Packet8c &a)
Packet16f	pcast< Packet8d, Packet16f > (const Packet8d &a, const Packet8d &b)
Packet16i	pcast< Packet8d, Packet16i > (const Packet8d &a, const Packet8d &b)
Packet8f	pcast< Packet8d, Packet8f > (const Packet8d &a)
Packet8i	pcast< Packet8d, Packet8i > (const Packet8d &a)
Packet16b	pcast< Packet8f, Packet16b > (const Packet8f &a, const Packet8f &b)
Packet8bf	pcast< Packet8f, Packet8bf > (const Packet8f &a)
Packet8h	pcast< Packet8f, Packet8h > (const Packet8f &a)
Packet8i	pcast< Packet8f, Packet8i > (const Packet8f &a)
Packet8f	pcast< Packet8h, Packet8f > (const Packet8h &a)
Packet8f	pcast< Packet8i, Packet8f > (const Packet8i &a)
Packet16c	pcast< Packet8s, Packet16c > (const Packet8s &a, const Packet8s &b)
Packet16uc	pcast< Packet8s, Packet16uc > (const Packet8s &a, const Packet8s &b)
Packet2l	pcast< Packet8s, Packet2l > (const Packet8s &a)
Packet2ul	pcast< Packet8s, Packet2ul > (const Packet8s &a)
Packet4f	pcast< Packet8s, Packet4f > (const Packet8s &a)
Packet4i	pcast< Packet8s, Packet4i > (const Packet8s &a)
Packet4ui	pcast< Packet8s, Packet4ui > (const Packet8s &a)
Packet8c	pcast< Packet8s, Packet8c > (const Packet8s &a)
Packet8uc	pcast< Packet8s, Packet8uc > (const Packet8s &a)
Packet2f	pcast< Packet8uc, Packet2f > (const Packet8uc &a)
Packet2i	pcast< Packet8uc, Packet2i > (const Packet8uc &a)
Packet2ui	pcast< Packet8uc, Packet2ui > (const Packet8uc &a)
Packet4ui	pcast< Packet8uc, Packet4ui > (const Packet8uc &a)
Packet8s	pcast< Packet8uc, Packet8s > (const Packet8uc &a)
Packet8us	pcast< Packet8uc, Packet8us > (const Packet8uc &a)
Packet16c	pcast< Packet8us, Packet16c > (const Packet8us &a, const Packet8us &b)
Packet16uc	pcast< Packet8us, Packet16uc > (const Packet8us &a, const Packet8us &b)
Packet2l	pcast< Packet8us, Packet2l > (const Packet8us &a)
Packet2ul	pcast< Packet8us, Packet2ul > (const Packet8us &a)
Packet4f	pcast< Packet8us, Packet4f > (const Packet8us &a)
Packet4i	pcast< Packet8us, Packet4i > (const Packet8us &a)
Packet4ui	pcast< Packet8us, Packet4ui > (const Packet8us &a)
Packet8bf	pcast< Packet8us, Packet8bf > (const Packet8us &a)
Packet8c	pcast< Packet8us, Packet8c > (const Packet8us &a)
Packet8uc	pcast< Packet8us, Packet8uc > (const Packet8us &a)
PacketXi	pcast< PacketXf, PacketXi > (const PacketXf &a)
PacketXf	pcast< PacketXi, PacketXf > (const PacketXi &a)
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pceil (const Packet &a)
Packet16bf	pceil< Packet16bf > (const Packet16bf &a)
Packet16f	pceil< Packet16f > (const Packet16f &a)
Packet16h	pceil< Packet16h > (const Packet16h &a)
Packet2d	pceil< Packet2d > (const Packet2d &a)
Packet2f	pceil< Packet2f > (const Packet2f &a)
Packet32h	pceil< Packet32h > (const Packet32h &a)
Packet4bf	pceil< Packet4bf > (const Packet4bf &a)
Packet4d	pceil< Packet4d > (const Packet4d &a)
Packet4f	pceil< Packet4f > (const Packet4f &a)
Packet8bf	pceil< Packet8bf > (const Packet8bf &a)
Packet8d	pceil< Packet8d > (const Packet8d &a)
Packet8f	pceil< Packet8f > (const Packet8f &a)
Packet8h	pceil< Packet8h > (const Packet8h &a)
unsigned	PCG_XSH_RS_generator (uint64_t *state, uint64_t stream)
uint64_t	PCG_XSH_RS_state (uint64_t seed)
Packet	pcmp_eq (const Packet &a, const Packet &b)
Packet16b	pcmp_eq (const Packet16b &a, const Packet16b &b)
Packet16bf	pcmp_eq (const Packet16bf &a, const Packet16bf &b)
Packet16c	pcmp_eq (const Packet16c &a, const Packet16c &b)
Packet16f	pcmp_eq (const Packet16f &a, const Packet16f &b)
Packet16h	pcmp_eq (const Packet16h &a, const Packet16h &b)
Packet16i	pcmp_eq (const Packet16i &a, const Packet16i &b)
Packet16uc	pcmp_eq (const Packet16uc &a, const Packet16uc &b)
Packet1cd	pcmp_eq (const Packet1cd &a, const Packet1cd &b)
Packet1cf	pcmp_eq (const Packet1cf &a, const Packet1cf &b)
Packet2cd	pcmp_eq (const Packet2cd &a, const Packet2cd &b)
Packet2cf	pcmp_eq (const Packet2cf &a, const Packet2cf &b)
Packet2d	pcmp_eq (const Packet2d &a, const Packet2d &b)
Packet32h	pcmp_eq (const Packet32h &a, const Packet32h &b)
Packet4cd	pcmp_eq (const Packet4cd &a, const Packet4cd &b)
Packet4cf	pcmp_eq (const Packet4cf &a, const Packet4cf &b)
Packet4d	pcmp_eq (const Packet4d &a, const Packet4d &b)
Packet4f	pcmp_eq (const Packet4f &a, const Packet4f &b)
Packet4i	pcmp_eq (const Packet4i &a, const Packet4i &b)
Packet4ui	pcmp_eq (const Packet4ui &a, const Packet4ui &b)
Packet8bf	pcmp_eq (const Packet8bf &a, const Packet8bf &b)
Packet8cf	pcmp_eq (const Packet8cf &a, const Packet8cf &b)
Packet8d	pcmp_eq (const Packet8d &a, const Packet8d &b)
Packet8f	pcmp_eq (const Packet8f &a, const Packet8f &b)
Packet8h	pcmp_eq (const Packet8h &a, const Packet8h &b)
Packet8i	pcmp_eq (const Packet8i &a, const Packet8i &b)
Packet8s	pcmp_eq (const Packet8s &a, const Packet8s &b)
Packet8ui	pcmp_eq (const Packet8ui &a, const Packet8ui &b)
Packet8us	pcmp_eq (const Packet8us &a, const Packet8us &b)
Packet16c	pcmp_eq< Packet16c > (const Packet16c &a, const Packet16c &b)
Packet16uc	pcmp_eq< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
Packet2f	pcmp_eq< Packet2f > (const Packet2f &a, const Packet2f &b)
Packet2i	pcmp_eq< Packet2i > (const Packet2i &a, const Packet2i &b)
Packet2l	pcmp_eq< Packet2l > (const Packet2l &a, const Packet2l &b)
Packet2ui	pcmp_eq< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
Packet2ul	pcmp_eq< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
Packet4bf	pcmp_eq< Packet4bf > (const Packet4bf &a, const Packet4bf &b)
Packet4c	pcmp_eq< Packet4c > (const Packet4c &a, const Packet4c &b)
Packet4f	pcmp_eq< Packet4f > (const Packet4f &a, const Packet4f &b)
Packet4i	pcmp_eq< Packet4i > (const Packet4i &a, const Packet4i &b)
Packet4s	pcmp_eq< Packet4s > (const Packet4s &a, const Packet4s &b)
Packet4uc	pcmp_eq< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
Packet4ui	pcmp_eq< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
Packet4us	pcmp_eq< Packet4us > (const Packet4us &a, const Packet4us &b)
Packet8c	pcmp_eq< Packet8c > (const Packet8c &a, const Packet8c &b)
Packet8s	pcmp_eq< Packet8s > (const Packet8s &a, const Packet8s &b)
Packet8uc	pcmp_eq< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
Packet8us	pcmp_eq< Packet8us > (const Packet8us &a, const Packet8us &b)
PacketXf	pcmp_eq< PacketXf > (const PacketXf &a, const PacketXf &b)
PacketXi	pcmp_eq< PacketXi > (const PacketXi &a, const PacketXi &b)
Packet	pcmp_le (const Packet &a, const Packet &b)
Packet16bf	pcmp_le (const Packet16bf &a, const Packet16bf &b)
Packet16f	pcmp_le (const Packet16f &a, const Packet16f &b)
Packet16h	pcmp_le (const Packet16h &a, const Packet16h &b)
Packet16i	pcmp_le (const Packet16i &a, const Packet16i &b)
Packet2d	pcmp_le (const Packet2d &a, const Packet2d &b)
Packet32h	pcmp_le (const Packet32h &a, const Packet32h &b)
Packet4d	pcmp_le (const Packet4d &a, const Packet4d &b)
Packet4f	pcmp_le (const Packet4f &a, const Packet4f &b)
Packet4i	pcmp_le (const Packet4i &a, const Packet4i &b)
Packet4ui	pcmp_le (const Packet4ui &a, const Packet4ui &b)
Packet8bf	pcmp_le (const Packet8bf &a, const Packet8bf &b)
Packet8d	pcmp_le (const Packet8d &a, const Packet8d &b)
Packet8f	pcmp_le (const Packet8f &a, const Packet8f &b)
Packet8h	pcmp_le (const Packet8h &a, const Packet8h &b)
Packet8i	pcmp_le (const Packet8i &a, const Packet8i &b)
Packet8ui	pcmp_le (const Packet8ui &a, const Packet8ui &b)
Packet16c	pcmp_le< Packet16c > (const Packet16c &a, const Packet16c &b)
Packet16uc	pcmp_le< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
Packet2f	pcmp_le< Packet2f > (const Packet2f &a, const Packet2f &b)
Packet2i	pcmp_le< Packet2i > (const Packet2i &a, const Packet2i &b)
Packet2l	pcmp_le< Packet2l > (const Packet2l &a, const Packet2l &b)
Packet2ui	pcmp_le< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
Packet2ul	pcmp_le< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
Packet4bf	pcmp_le< Packet4bf > (const Packet4bf &a, const Packet4bf &b)
Packet4c	pcmp_le< Packet4c > (const Packet4c &a, const Packet4c &b)
Packet4f	pcmp_le< Packet4f > (const Packet4f &a, const Packet4f &b)
Packet4i	pcmp_le< Packet4i > (const Packet4i &a, const Packet4i &b)
Packet4s	pcmp_le< Packet4s > (const Packet4s &a, const Packet4s &b)
Packet4uc	pcmp_le< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
Packet4ui	pcmp_le< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
Packet4us	pcmp_le< Packet4us > (const Packet4us &a, const Packet4us &b)
Packet8c	pcmp_le< Packet8c > (const Packet8c &a, const Packet8c &b)
Packet8s	pcmp_le< Packet8s > (const Packet8s &a, const Packet8s &b)
Packet8uc	pcmp_le< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
Packet8us	pcmp_le< Packet8us > (const Packet8us &a, const Packet8us &b)
PacketXf	pcmp_le< PacketXf > (const PacketXf &a, const PacketXf &b)
PacketXi	pcmp_le< PacketXi > (const PacketXi &a, const PacketXi &b)
Packet	pcmp_lt (const Packet &a, const Packet &b)
Packet16bf	pcmp_lt (const Packet16bf &a, const Packet16bf &b)
Packet16c	pcmp_lt (const Packet16c &a, const Packet16c &b)
Packet16f	pcmp_lt (const Packet16f &a, const Packet16f &b)
Packet16h	pcmp_lt (const Packet16h &a, const Packet16h &b)
Packet16i	pcmp_lt (const Packet16i &a, const Packet16i &b)
Packet16uc	pcmp_lt (const Packet16uc &a, const Packet16uc &b)
Packet2d	pcmp_lt (const Packet2d &a, const Packet2d &b)
Packet32h	pcmp_lt (const Packet32h &a, const Packet32h &b)
Packet4d	pcmp_lt (const Packet4d &a, const Packet4d &b)
Packet4f	pcmp_lt (const Packet4f &a, const Packet4f &b)
Packet4i	pcmp_lt (const Packet4i &a, const Packet4i &b)
Packet4ui	pcmp_lt (const Packet4ui &a, const Packet4ui &b)
Packet8bf	pcmp_lt (const Packet8bf &a, const Packet8bf &b)
Packet8d	pcmp_lt (const Packet8d &a, const Packet8d &b)
Packet8f	pcmp_lt (const Packet8f &a, const Packet8f &b)
Packet8h	pcmp_lt (const Packet8h &a, const Packet8h &b)
Packet8i	pcmp_lt (const Packet8i &a, const Packet8i &b)
Packet8s	pcmp_lt (const Packet8s &a, const Packet8s &b)
Packet8ui	pcmp_lt (const Packet8ui &a, const Packet8ui &b)
Packet8us	pcmp_lt (const Packet8us &a, const Packet8us &b)
Packet16c	pcmp_lt< Packet16c > (const Packet16c &a, const Packet16c &b)
Packet16uc	pcmp_lt< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
Packet2f	pcmp_lt< Packet2f > (const Packet2f &a, const Packet2f &b)
Packet2i	pcmp_lt< Packet2i > (const Packet2i &a, const Packet2i &b)
Packet2l	pcmp_lt< Packet2l > (const Packet2l &a, const Packet2l &b)
Packet2ui	pcmp_lt< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
Packet2ul	pcmp_lt< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
Packet4bf	pcmp_lt< Packet4bf > (const Packet4bf &a, const Packet4bf &b)
Packet4c	pcmp_lt< Packet4c > (const Packet4c &a, const Packet4c &b)
Packet4f	pcmp_lt< Packet4f > (const Packet4f &a, const Packet4f &b)
Packet4i	pcmp_lt< Packet4i > (const Packet4i &a, const Packet4i &b)
Packet4s	pcmp_lt< Packet4s > (const Packet4s &a, const Packet4s &b)
Packet4uc	pcmp_lt< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
Packet4ui	pcmp_lt< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
Packet4us	pcmp_lt< Packet4us > (const Packet4us &a, const Packet4us &b)
Packet8c	pcmp_lt< Packet8c > (const Packet8c &a, const Packet8c &b)
Packet8s	pcmp_lt< Packet8s > (const Packet8s &a, const Packet8s &b)
Packet8uc	pcmp_lt< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
Packet8us	pcmp_lt< Packet8us > (const Packet8us &a, const Packet8us &b)
PacketXf	pcmp_lt< PacketXf > (const PacketXf &a, const PacketXf &b)
PacketXi	pcmp_lt< PacketXi > (const PacketXi &a, const PacketXi &b)
Packet	pcmp_lt_or_nan (const Packet &a, const Packet &b)
Packet16bf	pcmp_lt_or_nan (const Packet16bf &a, const Packet16bf &b)
Packet16f	pcmp_lt_or_nan (const Packet16f &a, const Packet16f &b)
Packet16h	pcmp_lt_or_nan (const Packet16h &a, const Packet16h &b)
Packet2d	pcmp_lt_or_nan (const Packet2d &a, const Packet2d &b)
Packet32h	pcmp_lt_or_nan (const Packet32h &a, const Packet32h &b)
Packet4d	pcmp_lt_or_nan (const Packet4d &a, const Packet4d &b)
Packet4f	pcmp_lt_or_nan (const Packet4f &a, const Packet4f &b)
Packet8bf	pcmp_lt_or_nan (const Packet8bf &a, const Packet8bf &b)
Packet8d	pcmp_lt_or_nan (const Packet8d &a, const Packet8d &b)
Packet8f	pcmp_lt_or_nan (const Packet8f &a, const Packet8f &b)
Packet8h	pcmp_lt_or_nan (const Packet8h &a, const Packet8h &b)
Packet2f	pcmp_lt_or_nan< Packet2f > (const Packet2f &a, const Packet2f &b)
Packet4bf	pcmp_lt_or_nan< Packet4bf > (const Packet4bf &a, const Packet4bf &b)
Packet4f	pcmp_lt_or_nan< Packet4f > (const Packet4f &a, const Packet4f &b)
PacketXf	pcmp_lt_or_nan< PacketXf > (const PacketXf &a, const PacketXf &b)
Packet	pconj (const Packet &a)
Packet16bf	pconj (const Packet16bf &a)
Packet16c	pconj (const Packet16c &a)
Packet16f	pconj (const Packet16f &a)
Packet16h	pconj (const Packet16h &a)
Packet16i	pconj (const Packet16i &a)
Packet16uc	pconj (const Packet16uc &a)
Packet1cd	pconj (const Packet1cd &a)
Packet1cf	pconj (const Packet1cf &a)
Packet2cd	pconj (const Packet2cd &a)
Packet2cf	pconj (const Packet2cf &a)
Packet2d	pconj (const Packet2d &a)
Packet2f	pconj (const Packet2f &a)
Packet2i	pconj (const Packet2i &a)
Packet2l	pconj (const Packet2l &a)
Packet2ui	pconj (const Packet2ui &a)
Packet2ul	pconj (const Packet2ul &a)
Packet4bf	pconj (const Packet4bf &a)
Packet4c	pconj (const Packet4c &a)
Packet4cd	pconj (const Packet4cd &a)
Packet4cf	pconj (const Packet4cf &a)
Packet4d	pconj (const Packet4d &a)
Packet4f	pconj (const Packet4f &a)
Packet4i	pconj (const Packet4i &a)
Packet4s	pconj (const Packet4s &a)
Packet4uc	pconj (const Packet4uc &a)
Packet4ui	pconj (const Packet4ui &a)
Packet4us	pconj (const Packet4us &a)
Packet8bf	pconj (const Packet8bf &a)
Packet8c	pconj (const Packet8c &a)
Packet8cf	pconj (const Packet8cf &a)
Packet8d	pconj (const Packet8d &a)
Packet8f	pconj (const Packet8f &a)
Packet8h	pconj (const Packet8h &a)
Packet8i	pconj (const Packet8i &a)
Packet8s	pconj (const Packet8s &a)
Packet8uc	pconj (const Packet8uc &a)
Packet8us	pconj (const Packet8us &a)
PacketXf	pconj (const PacketXf &a)
PacketXi	pconj (const PacketXi &a)
Packet32h	pconj< Packet32h > (const Packet32h &a)
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pcos (const Packet &a)
Packet16h	pcos< Packet16h > (const Packet16h &)
Packet32h	pcos< Packet32h > (const Packet32h &a)
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet4f	pcos< Packet4f > (const Packet4f &x)
Packet8bf	pcos< Packet8bf > (const Packet8bf &a)
PacketXf	pcos< PacketXf > (const PacketXf &x)
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pcos_float (const Packet &x)
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pcosh (const Packet &a)
Packet	pcplxflip (const Packet &a)
Packet1cd	pcplxflip (const Packet1cd &x)
Packet2cf	pcplxflip (const Packet2cf &x)
Packet1cf	pcplxflip< Packet1cf > (const Packet1cf &a)
Packet2cd	pcplxflip< Packet2cd > (const Packet2cd &x)
Packet2cf	pcplxflip< Packet2cf > (const Packet2cf &x)
Packet4cd	pcplxflip< Packet4cd > (const Packet4cd &x)
Packet4cf	pcplxflip< Packet4cf > (const Packet4cf &x)
Packet8cf	pcplxflip< Packet8cf > (const Packet8cf &x)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pdigamma (const Packet &a)
Packet	pdiv (const Packet &a, const Packet &b)
Packet16bf	pdiv< Packet16bf > (const Packet16bf &a, const Packet16bf &b)
Packet16c	pdiv< Packet16c > (const Packet16c &, const Packet16c &)
Packet16f	pdiv< Packet16f > (const Packet16f &a, const Packet16f &b)
Packet16h	pdiv< Packet16h > (const Packet16h &a, const Packet16h &b)
Packet16i	pdiv< Packet16i > (const Packet16i &a, const Packet16i &b)
Packet16uc	pdiv< Packet16uc > (const Packet16uc &, const Packet16uc &)
Packet1cd	pdiv< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
Packet1cf	pdiv< Packet1cf > (const Packet1cf &a, const Packet1cf &b)
Packet2cd	pdiv< Packet2cd > (const Packet2cd &a, const Packet2cd &b)
Packet2cf	pdiv< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
Packet2d	pdiv< Packet2d > (const Packet2d &a, const Packet2d &b)
Packet2f	pdiv< Packet2f > (const Packet2f &a, const Packet2f &b)
Packet2i	pdiv< Packet2i > (const Packet2i &, const Packet2i &)
Packet2l	pdiv< Packet2l > (const Packet2l &, const Packet2l &)
Packet2ui	pdiv< Packet2ui > (const Packet2ui &, const Packet2ui &)
Packet2ul	pdiv< Packet2ul > (const Packet2ul &, const Packet2ul &)
Packet32h	pdiv< Packet32h > (const Packet32h &a, const Packet32h &b)
Packet4bf	pdiv< Packet4bf > (const Packet4bf &a, const Packet4bf &b)
Packet4c	pdiv< Packet4c > (const Packet4c &, const Packet4c &)
Packet4cd	pdiv< Packet4cd > (const Packet4cd &a, const Packet4cd &b)
Packet4cf	pdiv< Packet4cf > (const Packet4cf &a, const Packet4cf &b)
Packet4d	pdiv< Packet4d > (const Packet4d &a, const Packet4d &b)
Packet4f	pdiv< Packet4f > (const Packet4f &a, const Packet4f &b)
Packet4i	pdiv< Packet4i > (const Packet4i &a, const Packet4i &b)
Packet4s	pdiv< Packet4s > (const Packet4s &, const Packet4s &)
Packet4uc	pdiv< Packet4uc > (const Packet4uc &, const Packet4uc &)
Packet4ui	pdiv< Packet4ui > (const Packet4ui &, const Packet4ui &)
Packet4us	pdiv< Packet4us > (const Packet4us &, const Packet4us &)
Packet8bf	pdiv< Packet8bf > (const Packet8bf &a, const Packet8bf &b)
Packet8c	pdiv< Packet8c > (const Packet8c &, const Packet8c &)
Packet8cf	pdiv< Packet8cf > (const Packet8cf &a, const Packet8cf &b)
Packet8d	pdiv< Packet8d > (const Packet8d &a, const Packet8d &b)
Packet8f	pdiv< Packet8f > (const Packet8f &a, const Packet8f &b)
Packet8h	pdiv< Packet8h > (const Packet8h &a, const Packet8h &b)
Packet8i	pdiv< Packet8i > (const Packet8i &a, const Packet8i &b)
Packet8s	pdiv< Packet8s > (const Packet8s &, const Packet8s &)
Packet8uc	pdiv< Packet8uc > (const Packet8uc &, const Packet8uc &)
Packet8us	pdiv< Packet8us > (const Packet8us &, const Packet8us &)
PacketXf	pdiv< PacketXf > (const PacketXf &a, const PacketXf &b)
PacketXi	pdiv< PacketXi > (const PacketXi &a, const PacketXi &b)
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pdiv_complex (const Packet &x, const Packet &y)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	perf (const Packet &a)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	perfc (const Packet &a)
void	permute_symm_to_fullsymm (const MatrixType &mat, SparseMatrix< typename MatrixType::Scalar, DestOrder, typename MatrixType::StorageIndex > &_dest, const typename MatrixType::StorageIndex *perm=0)
void	permute_symm_to_symm (const MatrixType &mat, SparseMatrix< typename MatrixType::Scalar, DestOrder, typename MatrixType::StorageIndex > &_dest, const typename MatrixType::StorageIndex *perm=0)
void	permute_symm_to_symm (const MatrixType &mat, SparseMatrix< typename MatrixType::Scalar, DstOrder, typename MatrixType::StorageIndex > &_dest, const typename MatrixType::StorageIndex *perm)
Packet	peven_mask (const Packet &)
Packet16f	peven_mask (const Packet16f &)
Packet16i	peven_mask (const Packet16i &)
Packet2d	peven_mask (const Packet2d &)
Packet4d	peven_mask (const Packet4d &)
Packet4f	peven_mask (const Packet4f &)
Packet4i	peven_mask (const Packet4i &)
Packet4ui	peven_mask (const Packet4ui &)
Packet8d	peven_mask (const Packet8d &)
Packet8f	peven_mask (const Packet8f &)
Packet8i	peven_mask (const Packet8i &)
Packet8ui	peven_mask (const Packet8ui &)
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pexp (const Packet &a)
Packet16h	pexp< Packet16h > (const Packet16h &)
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet2d	pexp< Packet2d > (const Packet2d &_x)
Packet32h	pexp< Packet32h > (const Packet32h &a)
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet4f	pexp< Packet4f > (const Packet4f &_x)
Packet8bf	pexp< Packet8bf > (const Packet8bf &a)
PacketXf	pexp< PacketXf > (const PacketXf &x)
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pexp_double (const Packet _x)
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pexp_float (const Packet _x)
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pexpm1 (const Packet &a)
Packet16h	pexpm1< Packet16h > (const Packet16h &)
Packet32h	pexpm1< Packet32h > (const Packet32h &a)
unpacket_traits< Packet >::type	pfirst (const Packet &a)
bfloat16	pfirst (const Packet8bf &a)
bool	pfirst< Packet16b > (const Packet16b &a)
bfloat16	pfirst< Packet16bf > (const Packet16bf &from)
signed char	pfirst< Packet16c > (const Packet16c &a)
float	pfirst< Packet16f > (const Packet16f &a)
Eigen::half	pfirst< Packet16h > (const Packet16h &from)
int	pfirst< Packet16i > (const Packet16i &a)
unsigned char	pfirst< Packet16uc > (const Packet16uc &a)
std::complex< double >	pfirst< Packet1cd > (const Packet1cd &a)
std::complex< float >	pfirst< Packet1cf > (const Packet1cf &a)
std::complex< double >	pfirst< Packet2cd > (const Packet2cd &a)
std::complex< float >	pfirst< Packet2cf > (const Packet2cf &a)
double	pfirst< Packet2d > (const Packet2d &a)
float	pfirst< Packet2f > (const Packet2f &a)
int32_t	pfirst< Packet2i > (const Packet2i &a)
int64_t	pfirst< Packet2l > (const Packet2l &a)
uint32_t	pfirst< Packet2ui > (const Packet2ui &a)
uint64_t	pfirst< Packet2ul > (const Packet2ul &a)
Eigen::half	pfirst< Packet32h > (const Packet32h &from)
bfloat16	pfirst< Packet4bf > (const Packet4bf &from)
int8_t	pfirst< Packet4c > (const Packet4c &a)
std::complex< double >	pfirst< Packet4cd > (const Packet4cd &a)
std::complex< float >	pfirst< Packet4cf > (const Packet4cf &a)
double	pfirst< Packet4d > (const Packet4d &a)
float	pfirst< Packet4f > (const Packet4f &a)
int	pfirst< Packet4i > (const Packet4i &a)
int16_t	pfirst< Packet4s > (const Packet4s &a)
uint8_t	pfirst< Packet4uc > (const Packet4uc &a)
uint32_t	pfirst< Packet4ui > (const Packet4ui &a)
uint16_t	pfirst< Packet4us > (const Packet4us &a)
bfloat16	pfirst< Packet8bf > (const Packet8bf &from)
int8_t	pfirst< Packet8c > (const Packet8c &a)
std::complex< float >	pfirst< Packet8cf > (const Packet8cf &a)
double	pfirst< Packet8d > (const Packet8d &a)
float	pfirst< Packet8f > (const Packet8f &a)
Eigen::half	pfirst< Packet8h > (const Packet8h &from)
int	pfirst< Packet8i > (const Packet8i &a)
short int	pfirst< Packet8s > (const Packet8s &a)
uint8_t	pfirst< Packet8uc > (const Packet8uc &a)
uint32_t	pfirst< Packet8ui > (const Packet8ui &a)
unsigned short int	pfirst< Packet8us > (const Packet8us &a)
float	pfirst< PacketXf > (const PacketXf &a)
numext::int32_t	pfirst< PacketXi > (const PacketXi &a)
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pfloor (const Packet &a)
Packet16bf	pfloor< Packet16bf > (const Packet16bf &a)
Packet16f	pfloor< Packet16f > (const Packet16f &a)
Packet16h	pfloor< Packet16h > (const Packet16h &a)
Packet2d	pfloor< Packet2d > (const Packet2d &a)
Packet2f	pfloor< Packet2f > (const Packet2f &a)
Packet32h	pfloor< Packet32h > (const Packet32h &a)
Packet4bf	pfloor< Packet4bf > (const Packet4bf &a)
Packet4d	pfloor< Packet4d > (const Packet4d &a)
Packet4f	pfloor< Packet4f > (const Packet4f &a)
Packet8bf	pfloor< Packet8bf > (const Packet8bf &a)
Packet8d	pfloor< Packet8d > (const Packet8d &a)
Packet8f	pfloor< Packet8f > (const Packet8f &a)
Packet8h	pfloor< Packet8h > (const Packet8h &a)
PacketXf	pfloor< PacketXf > (const PacketXf &a)
Packet	pfrexp (const Packet &a, Packet &exponent)
Packet16bf	pfrexp (const Packet16bf &a, Packet16bf &exponent)
Packet16h	pfrexp (const Packet16h &a, Packet16h &exponent)
Packet4bf	pfrexp (const Packet4bf &a, Packet4bf &exponent)
Packet8bf	pfrexp (const Packet8bf &a, Packet8bf &exponent)
Packet8h	pfrexp (const Packet8h &a, Packet8h &exponent)
Packet16f	pfrexp< Packet16f > (const Packet16f &a, Packet16f &exponent)
Packet16h	pfrexp< Packet16h > (const Packet16h &, Packet16h &)
Packet2d	pfrexp< Packet2d > (const Packet2d &a, Packet2d &exponent)
Packet2f	pfrexp< Packet2f > (const Packet2f &a, Packet2f &exponent)
Packet32h	pfrexp< Packet32h > (const Packet32h &a, Packet32h &exponent)
Packet4d	pfrexp< Packet4d > (const Packet4d &a, Packet4d &exponent)
Packet4f	pfrexp< Packet4f > (const Packet4f &a, Packet4f &exponent)
Packet8bf	pfrexp< Packet8bf > (const Packet8bf &a, Packet8bf &e)
Packet8d	pfrexp< Packet8d > (const Packet8d &a, Packet8d &exponent)
Packet8f	pfrexp< Packet8f > (const Packet8f &a, Packet8f &exponent)
PacketXf	pfrexp< PacketXf > (const PacketXf &a, PacketXf &exponent)
Packet	pfrexp_generic (const Packet &a, Packet &exponent)
Packet	pfrexp_generic_get_biased_exponent (const Packet &a)
Packet2d	pfrexp_generic_get_biased_exponent (const Packet2d &a)
Packet4d	pfrexp_generic_get_biased_exponent (const Packet4d &a)
Packet8d	pfrexp_generic_get_biased_exponent (const Packet8d &a)
template<typename Packet >
Packet	pgamma_sample_der_alpha (const Packet &alpha, const Packet &sample)
Packet	pgather (const Packet &src, const Scalar *from, Index stride, typename unpacket_traits< Packet >::mask_t umask)
Packet	pgather (const Scalar *from, Index)
Packet16bf	pgather< bfloat16, Packet16bf > (const bfloat16 *from, Index stride)
Packet4bf	pgather< bfloat16, Packet4bf > (const bfloat16 *from, Index stride)
EIGEN_ALWAYS_INLINE Packet8bf	pgather< bfloat16, Packet8bf > (const bfloat16 *from, Index stride)
Packet16b	pgather< bool, Packet16b > (const bool *from, Index stride)
Packet2d	pgather< double, Packet2d > (const double *from, Index stride)
Packet4d	pgather< double, Packet4d > (const double *from, Index stride)
Packet8d	pgather< double, Packet8d > (const double *from, Index stride)
Packet8d	pgather< double, Packet8d > (const Packet8d &src, const double *from, Index stride, uint8_t umask)
Packet16h	pgather< Eigen::half, Packet16h > (const Eigen::half *from, Index stride)
Packet32h	pgather< Eigen::half, Packet32h > (const Eigen::half *from, Index stride)
Packet8h	pgather< Eigen::half, Packet8h > (const Eigen::half *from, Index stride)
Packet16f	pgather< float, Packet16f > (const float *from, Index stride)
Packet16f	pgather< float, Packet16f > (const Packet16f &src, const float *from, Index stride, uint16_t umask)
Packet2f	pgather< float, Packet2f > (const float *from, Index stride)
EIGEN_ALWAYS_INLINE Packet4f	pgather< float, Packet4f > (const float *from, Index stride)
Packet8f	pgather< float, Packet8f > (const float *from, Index stride)
PacketXf	pgather< float, PacketXf > (const float *from, Index stride)
Packet16i	pgather< int, Packet16i > (const int *from, Index stride)
EIGEN_ALWAYS_INLINE Packet4i	pgather< int, Packet4i > (const int *from, Index stride)
Packet8i	pgather< int, Packet8i > (const int *from, Index stride)
Packet4s	pgather< int16_t, Packet4s > (const int16_t *from, Index stride)
Packet8s	pgather< int16_t, Packet8s > (const int16_t *from, Index stride)
Packet2i	pgather< int32_t, Packet2i > (const int32_t *from, Index stride)
Packet4i	pgather< int32_t, Packet4i > (const int32_t *from, Index stride)
Packet2l	pgather< int64_t, Packet2l > (const int64_t *from, Index stride)
Packet16c	pgather< int8_t, Packet16c > (const int8_t *from, Index stride)
Packet4c	pgather< int8_t, Packet4c > (const int8_t *from, Index stride)
Packet8c	pgather< int8_t, Packet8c > (const int8_t *from, Index stride)
PacketXi	pgather< numext::int32_t, PacketXi > (const numext::int32_t *from, Index stride)
EIGEN_ALWAYS_INLINE Packet8s	pgather< short int, Packet8s > (const short int *from, Index stride)
EIGEN_ALWAYS_INLINE Packet16c	pgather< signed char, Packet16c > (const signed char *from, Index stride)
Packet1cd	pgather< std::complex< double >, Packet1cd > (const std::complex< double > *from, Index stride __attribute__((unused)))
Packet1cd	pgather< std::complex< double >, Packet1cd > (const std::complex< double > *from, Index stride EIGEN_UNUSED)
Packet2cd	pgather< std::complex< double >, Packet2cd > (const std::complex< double > *from, Index stride)
Packet4cd	pgather< std::complex< double >, Packet4cd > (const std::complex< double > *from, Index stride)
Packet1cf	pgather< std::complex< float >, Packet1cf > (const std::complex< float > *from, Index stride)
EIGEN_ALWAYS_INLINE Packet2cf	pgather< std::complex< float >, Packet2cf > (const std::complex< float > *from, Index stride)
Packet4cf	pgather< std::complex< float >, Packet4cf > (const std::complex< float > *from, Index stride)
Packet8cf	pgather< std::complex< float >, Packet8cf > (const std::complex< float > *from, Index stride)
Packet4us	pgather< uint16_t, Packet4us > (const uint16_t *from, Index stride)
Packet8us	pgather< uint16_t, Packet8us > (const uint16_t *from, Index stride)
Packet2ui	pgather< uint32_t, Packet2ui > (const uint32_t *from, Index stride)
Packet4ui	pgather< uint32_t, Packet4ui > (const uint32_t *from, Index stride)
Packet8ui	pgather< uint32_t, Packet8ui > (const uint32_t *from, Index stride)
Packet2ul	pgather< uint64_t, Packet2ul > (const uint64_t *from, Index stride)
Packet16uc	pgather< uint8_t, Packet16uc > (const uint8_t *from, Index stride)
Packet4uc	pgather< uint8_t, Packet4uc > (const uint8_t *from, Index stride)
Packet8uc	pgather< uint8_t, Packet8uc > (const uint8_t *from, Index stride)
EIGEN_ALWAYS_INLINE Packet16uc	pgather< unsigned char, Packet16uc > (const unsigned char *from, Index stride)
EIGEN_ALWAYS_INLINE Packet8us	pgather< unsigned short int, Packet8us > (const unsigned short int *from, Index stride)
EIGEN_ALWAYS_INLINE Packet	pgather_common (const __UNPACK_TYPE__(Packet) *from, Index stride, const Index n=unpacket_traits< Packet >::size)
EIGEN_ALWAYS_INLINE Packet	pgather_complex_size2 (const Scalar *from, Index stride, const Index n=2)
Packet	pgather_partial (const Scalar *from, Index stride, const Index n)
EIGEN_ALWAYS_INLINE Packet8bf	pgather_partial< bfloat16, Packet8bf > (const bfloat16 *from, Index stride, const Index n)
EIGEN_ALWAYS_INLINE Packet4f	pgather_partial< float, Packet4f > (const float *from, Index stride, const Index n)
EIGEN_ALWAYS_INLINE Packet4i	pgather_partial< int, Packet4i > (const int *from, Index stride, const Index n)
EIGEN_ALWAYS_INLINE Packet8s	pgather_partial< short int, Packet8s > (const short int *from, Index stride, const Index n)
EIGEN_ALWAYS_INLINE Packet16c	pgather_partial< signed char, Packet16c > (const signed char *from, Index stride, const Index n)
EIGEN_ALWAYS_INLINE Packet2cf	pgather_partial< std::complex< float >, Packet2cf > (const std::complex< float > *from, Index stride, const Index n)
EIGEN_ALWAYS_INLINE Packet16uc	pgather_partial< unsigned char, Packet16uc > (const unsigned char *from, Index stride, const Index n)
EIGEN_ALWAYS_INLINE Packet8us	pgather_partial< unsigned short int, Packet8us > (const unsigned short int *from, Index stride, const Index n)
EIGEN_ALWAYS_INLINE void	pger (PacketBlock< Packet, N > *acc, const Scalar *lhs, const Packet *rhsV)
EIGEN_ALWAYS_INLINE void	pger_common (PacketBlock< Packet, N > *acc, const Packet &lhsV, const Packet *rhsV)
EIGEN_ALWAYS_INLINE void	pgerc (PacketBlock< Packet, N > *accReal, PacketBlock< Packet, N > *accImag, const Scalar *lhs_ptr, const Scalar *lhs_ptr_imag, const Packet *rhsV, const Packet *rhsVi)
EIGEN_ALWAYS_INLINE void	pgerc_common (PacketBlock< Packet, N > *accReal, PacketBlock< Packet, N > *accImag, const Packet &lhsV, Packet &lhsVi, const Packet *rhsV, const Packet *rhsVi)
EIGEN_ALWAYS_INLINE void	pgercMMA (__vector_quad *accReal, __vector_quad *accImag, const Packet &lhsV, Packet &lhsVi, const RhsPacket &rhsV, RhsPacket &rhsVi)
EIGEN_ALWAYS_INLINE void	pgerMMA (__vector_quad *acc, const __vector_pair &a, const Packet2d &b)
EIGEN_ALWAYS_INLINE void	pgerMMA (__vector_quad *acc, const RhsPacket &a, const LhsPacket &b)
template<typename Packet >
Packet	pigamma (const Packet &a, const Packet &x)
template<typename Packet >
Packet	pigamma_der_a (const Packet &a, const Packet &x)
template<typename Packet >
Packet	pigammac (const Packet &a, const Packet &x)
Packet	pisnan (const Packet &a)
Packet16f	pisnan (const Packet16f &a)
Packet8f	pisnan (const Packet8f &a)
constexpr int	plain_enum_max (A a, B b)
constexpr int	plain_enum_min (A a, B b)
Packet	pldexp (const Packet &a, const Packet &exponent)
Packet16bf	pldexp (const Packet16bf &a, const Packet16bf &exponent)
Packet16h	pldexp (const Packet16h &a, const Packet16h &exponent)
Packet4bf	pldexp (const Packet4bf &a, const Packet4bf &exponent)
Packet8bf	pldexp (const Packet8bf &a, const Packet8bf &exponent)
Packet8h	pldexp (const Packet8h &a, const Packet8h &exponent)
Packet16f	pldexp< Packet16f > (const Packet16f &a, const Packet16f &exponent)
Packet16h	pldexp< Packet16h > (const Packet16h &, const Packet16h &)
Packet2d	pldexp< Packet2d > (const Packet2d &a, const Packet2d &exponent)
Packet2f	pldexp< Packet2f > (const Packet2f &a, const Packet2f &exponent)
Packet32h	pldexp< Packet32h > (const Packet32h &a, const Packet32h &exponent)
Packet4d	pldexp< Packet4d > (const Packet4d &a, const Packet4d &exponent)
Packet4f	pldexp< Packet4f > (const Packet4f &a, const Packet4f &exponent)
Packet8bf	pldexp< Packet8bf > (const Packet8bf &a, const Packet8bf &exponent)
Packet8d	pldexp< Packet8d > (const Packet8d &a, const Packet8d &exponent)
Packet8f	pldexp< Packet8f > (const Packet8f &a, const Packet8f &exponent)
PacketXf	pldexp< PacketXf > (const PacketXf &a, const PacketXf &exponent)
Packet	pldexp_generic (const Packet &a, const Packet &exponent)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	plgamma (const Packet &a)
Packet	pload (const typename unpacket_traits< Packet >::type *from)
Packet	pload1 (const typename unpacket_traits< Packet >::type *a)
Packet16f	pload1< Packet16f > (const float *from)
Packet4d	pload1< Packet4d > (const double *from)
Packet4f	pload1< Packet4f > (const float *from)
Packet4i	pload1< Packet4i > (const int32_t *from)
Packet8d	pload1< Packet8d > (const double *from)
Packet8f	pload1< Packet8f > (const float *from)
Packet2cf	pload2 (const std::complex< float > &from0, const std::complex< float > &from1)
Packet16b	pload< Packet16b > (const bool *from)
Packet16bf	pload< Packet16bf > (const bfloat16 *from)
Packet16c	pload< Packet16c > (const int8_t *from)
Packet16c	pload< Packet16c > (const signed char *from)
Packet16f	pload< Packet16f > (const float *from)
Packet16h	pload< Packet16h > (const Eigen::half *from)
Packet16i	pload< Packet16i > (const int *from)
Packet16uc	pload< Packet16uc > (const uint8_t *from)
Packet16uc	pload< Packet16uc > (const unsigned char *from)
Packet1cd	pload< Packet1cd > (const std::complex< double > *from)
Packet1cf	pload< Packet1cf > (const std::complex< float > *from)
Packet2cd	pload< Packet2cd > (const std::complex< double > *from)
Packet2cf	pload< Packet2cf > (const std::complex< float > *from)
Packet2d	pload< Packet2d > (const double *from)
Packet2f	pload< Packet2f > (const float *from)
Packet2i	pload< Packet2i > (const int32_t *from)
Packet2l	pload< Packet2l > (const int64_t *from)
Packet2ui	pload< Packet2ui > (const uint32_t *from)
Packet2ul	pload< Packet2ul > (const uint64_t *from)
Packet32h	pload< Packet32h > (const Eigen::half *from)
Packet4bf	pload< Packet4bf > (const bfloat16 *from)
Packet4c	pload< Packet4c > (const int8_t *from)
Packet4cd	pload< Packet4cd > (const std::complex< double > *from)
Packet4cf	pload< Packet4cf > (const std::complex< float > *from)
Packet4d	pload< Packet4d > (const double *from)
Packet4f	pload< Packet4f > (const float *from)
Packet4i	pload< Packet4i > (const int *from)
Packet4i	pload< Packet4i > (const int32_t *from)
Packet4s	pload< Packet4s > (const int16_t *from)
Packet4uc	pload< Packet4uc > (const uint8_t *from)
Packet4ui	pload< Packet4ui > (const uint32_t *from)
Packet4us	pload< Packet4us > (const uint16_t *from)
Packet8bf	pload< Packet8bf > (const bfloat16 *from)
Packet8c	pload< Packet8c > (const int8_t *from)
Packet8cf	pload< Packet8cf > (const std::complex< float > *from)
Packet8d	pload< Packet8d > (const double *from)
Packet8f	pload< Packet8f > (const float *from)
Packet8h	pload< Packet8h > (const Eigen::half *from)
Packet8i	pload< Packet8i > (const int *from)
Packet8s	pload< Packet8s > (const int16_t *from)
Packet8s	pload< Packet8s > (const short int *from)
Packet8uc	pload< Packet8uc > (const uint8_t *from)
Packet8ui	pload< Packet8ui > (const uint32_t *from)
Packet8us	pload< Packet8us > (const uint16_t *from)
Packet8us	pload< Packet8us > (const unsigned short int *from)
PacketXf	pload< PacketXf > (const float *from)
PacketXi	pload< PacketXi > (const numext::int32_t *from)
Packet	pload_common (const __UNPACK_TYPE__(Packet) *from)
EIGEN_ALWAYS_INLINE Packet	pload_ignore (const __UNPACK_TYPE__(Packet) *from)
EIGEN_ALWAYS_INLINE Packet2cf	pload_ignore< Packet2cf > (const std::complex< float > *from)
EIGEN_ALWAYS_INLINE Packet8bf	pload_ignore< Packet8bf > (const bfloat16 *from)
Packet	pload_partial (const typename unpacket_traits< Packet >::type *from, const Index n, const Index offset=0)
EIGEN_ALWAYS_INLINE Packet16c	pload_partial< Packet16c > (const signed char *from, const Index n, const Index offset)
EIGEN_ALWAYS_INLINE Packet16uc	pload_partial< Packet16uc > (const unsigned char *from, const Index n, const Index offset)
EIGEN_ALWAYS_INLINE Packet2cf	pload_partial< Packet2cf > (const std::complex< float > *from, const Index n, const Index offset)
EIGEN_ALWAYS_INLINE Packet4f	pload_partial< Packet4f > (const float *from, const Index n, const Index offset)
EIGEN_ALWAYS_INLINE Packet4i	pload_partial< Packet4i > (const int *from, const Index n, const Index offset)
EIGEN_ALWAYS_INLINE Packet8bf	pload_partial< Packet8bf > (const bfloat16 *from, const Index n, const Index offset)
EIGEN_ALWAYS_INLINE Packet8s	pload_partial< Packet8s > (const short int *from, const Index n, const Index offset)
EIGEN_ALWAYS_INLINE Packet8us	pload_partial< Packet8us > (const unsigned short int *from, const Index n, const Index offset)
EIGEN_ALWAYS_INLINE Packet	pload_partial_common (const __UNPACK_TYPE__(Packet) *from, const Index n, const Index offset)
Packet	ploaddup (const typename unpacket_traits< Packet >::type *from)
Packet16b	ploaddup< Packet16b > (const bool *from)
Packet16bf	ploaddup< Packet16bf > (const bfloat16 *from)
Packet16c	ploaddup< Packet16c > (const int8_t *from)
Packet16c	ploaddup< Packet16c > (const signed char *from)
Packet16f	ploaddup< Packet16f > (const float *from)
Packet16h	ploaddup< Packet16h > (const Eigen::half *from)
Packet16i	ploaddup< Packet16i > (const int *from)
Packet16uc	ploaddup< Packet16uc > (const uint8_t *from)
Packet16uc	ploaddup< Packet16uc > (const unsigned char *from)
Packet1cd	ploaddup< Packet1cd > (const std::complex< double > *from)
Packet1cf	ploaddup< Packet1cf > (const std::complex< float > *from)
Packet2cd	ploaddup< Packet2cd > (const std::complex< double > *from)
Packet2cf	ploaddup< Packet2cf > (const std::complex< float > *from)
Packet2d	ploaddup< Packet2d > (const double *from)
Packet2f	ploaddup< Packet2f > (const float *from)
Packet2i	ploaddup< Packet2i > (const int32_t *from)
Packet2l	ploaddup< Packet2l > (const int64_t *from)
Packet2ui	ploaddup< Packet2ui > (const uint32_t *from)
Packet2ul	ploaddup< Packet2ul > (const uint64_t *from)
Packet32h	ploaddup< Packet32h > (const Eigen::half *from)
Packet4bf	ploaddup< Packet4bf > (const bfloat16 *from)
Packet4c	ploaddup< Packet4c > (const int8_t *from)
Packet4cd	ploaddup< Packet4cd > (const std::complex< double > *from)
Packet4cf	ploaddup< Packet4cf > (const std::complex< float > *from)
Packet4d	ploaddup< Packet4d > (const double *from)
Packet4f	ploaddup< Packet4f > (const float *from)
Packet4i	ploaddup< Packet4i > (const int *from)
Packet4i	ploaddup< Packet4i > (const int32_t *from)
Packet4s	ploaddup< Packet4s > (const int16_t *from)
Packet4uc	ploaddup< Packet4uc > (const uint8_t *from)
Packet4ui	ploaddup< Packet4ui > (const uint32_t *from)
Packet4us	ploaddup< Packet4us > (const uint16_t *from)
Packet8bf	ploaddup< Packet8bf > (const bfloat16 *from)
Packet8c	ploaddup< Packet8c > (const int8_t *from)
Packet8cf	ploaddup< Packet8cf > (const std::complex< float > *from)
Packet8d	ploaddup< Packet8d > (const double *from)
Packet8f	ploaddup< Packet8f > (const float *from)
Packet8h	ploaddup< Packet8h > (const Eigen::half *from)
Packet8i	ploaddup< Packet8i > (const int *from)
Packet8s	ploaddup< Packet8s > (const int16_t *from)
Packet8s	ploaddup< Packet8s > (const short int *from)
Packet8uc	ploaddup< Packet8uc > (const uint8_t *from)
Packet8ui	ploaddup< Packet8ui > (const uint32_t *from)
Packet8us	ploaddup< Packet8us > (const uint16_t *from)
Packet8us	ploaddup< Packet8us > (const unsigned short int *from)
PacketXf	ploaddup< PacketXf > (const float *from)
PacketXi	ploaddup< PacketXi > (const numext::int32_t *from)
Packet	ploaddup_common (const __UNPACK_TYPE__(Packet) *from)
Packet	ploadl (const typename unpacket_traits< Packet >::type *from)
Packet2d	ploadl< Packet2d > (const double *from)
Packet4f	ploadl< Packet4f > (const float *from)
EIGEN_ALWAYS_INLINE Packet	ploadLhs (const __UNPACK_TYPE__(Packet) *lhs)
EIGEN_ALWAYS_INLINE void	ploadLhsMMA (const double *lhs, __vector_pair &lhsV)
Packet16bf	ploadquad (const bfloat16 *from)
Packet16h	ploadquad (const Eigen::half *from)
Packet	ploadquad (const typename unpacket_traits< Packet >::type *from)
Packet16b	ploadquad< Packet16b > (const bool *from)
Packet16c	ploadquad< Packet16c > (const int8_t *from)
Packet16f	ploadquad< Packet16f > (const float *from)
Packet16i	ploadquad< Packet16i > (const int *from)
Packet16uc	ploadquad< Packet16uc > (const uint8_t *from)
Packet32h	ploadquad< Packet32h > (const Eigen::half *from)
Packet4c	ploadquad< Packet4c > (const int8_t *from)
Packet4f	ploadquad< Packet4f > (const float *from)
Packet4i	ploadquad< Packet4i > (const int32_t *from)
Packet4uc	ploadquad< Packet4uc > (const uint8_t *from)
Packet4ui	ploadquad< Packet4ui > (const uint32_t *from)
Packet8bf	ploadquad< Packet8bf > (const bfloat16 *from)
Packet8c	ploadquad< Packet8c > (const int8_t *from)
Packet8cf	ploadquad< Packet8cf > (const std::complex< float > *from)
Packet8d	ploadquad< Packet8d > (const double *from)
Packet8f	ploadquad< Packet8f > (const float *from)
Packet8h	ploadquad< Packet8h > (const Eigen::half *from)
Packet8i	ploadquad< Packet8i > (const int *from)
Packet8s	ploadquad< Packet8s > (const int16_t *from)
Packet8s	ploadquad< Packet8s > (const short int *from)
Packet8uc	ploadquad< Packet8uc > (const uint8_t *from)
Packet8ui	ploadquad< Packet8ui > (const uint32_t *from)
Packet8us	ploadquad< Packet8us > (const uint16_t *from)
Packet8us	ploadquad< Packet8us > (const unsigned short int *from)
PacketXf	ploadquad< PacketXf > (const float *from)
PacketXi	ploadquad< PacketXi > (const numext::int32_t *from)
EIGEN_ALWAYS_INLINE Packet	ploadRhs (const __UNPACK_TYPE__(Packet) *rhs)
EIGEN_ALWAYS_INLINE void	ploadRhsMMA (const double *rhs, __vector_pair &rhsV)
EIGEN_ALWAYS_INLINE void	ploadRhsMMA (const Scalar *rhs, Packet &rhsV)
Packet	ploads (const typename unpacket_traits< Packet >::type *from)
Packet2d	ploads< Packet2d > (const double *from)
Packet4f	ploads< Packet4f > (const float *from)
EIGEN_ALWAYS_INLINE Packet	ploadt (const typename unpacket_traits< Packet >::type *from)
EIGEN_ALWAYS_INLINE Packet	ploadt_partial (const typename unpacket_traits< Packet >::type *from, const Index n, const Index offset=0)
EIGEN_ALWAYS_INLINE Packet	ploadt_ro (const typename unpacket_traits< Packet >::type *from)
Packet	ploadu (const typename unpacket_traits< Packet >::type *from)
std::enable_if_t< unpacket_traits< Packet >::masked_load_available, Packet >	ploadu (const typename unpacket_traits< Packet >::type *from, typename unpacket_traits< Packet >::mask_t umask)
Packet16b	ploadu< Packet16b > (const bool *from)
Packet16bf	ploadu< Packet16bf > (const bfloat16 *from)
Packet16c	ploadu< Packet16c > (const int8_t *from)
Packet16c	ploadu< Packet16c > (const signed char *from)
Packet16f	ploadu< Packet16f > (const float *from)
Packet16f	ploadu< Packet16f > (const float *from, uint16_t umask)
Packet16h	ploadu< Packet16h > (const Eigen::half *from)
Packet16i	ploadu< Packet16i > (const int *from)
Packet16uc	ploadu< Packet16uc > (const uint8_t *from)
Packet16uc	ploadu< Packet16uc > (const unsigned char *from)
Packet1cd	ploadu< Packet1cd > (const std::complex< double > *from)
Packet1cf	ploadu< Packet1cf > (const std::complex< float > *from)
Packet2cd	ploadu< Packet2cd > (const std::complex< double > *from)
Packet2cf	ploadu< Packet2cf > (const std::complex< float > *from)
Packet2d	ploadu< Packet2d > (const double *from)
Packet2f	ploadu< Packet2f > (const float *from)
Packet2i	ploadu< Packet2i > (const int32_t *from)
Packet2l	ploadu< Packet2l > (const int64_t *from)
Packet2ui	ploadu< Packet2ui > (const uint32_t *from)
Packet2ul	ploadu< Packet2ul > (const uint64_t *from)
Packet32h	ploadu< Packet32h > (const Eigen::half *from)
Packet4bf	ploadu< Packet4bf > (const bfloat16 *from)
Packet4c	ploadu< Packet4c > (const int8_t *from)
Packet4cd	ploadu< Packet4cd > (const std::complex< double > *from)
Packet4cf	ploadu< Packet4cf > (const std::complex< float > *from)
Packet4d	ploadu< Packet4d > (const double *from)
Packet4f	ploadu< Packet4f > (const float *from)
Packet4i	ploadu< Packet4i > (const int *from)
Packet4i	ploadu< Packet4i > (const int32_t *from)
Packet4s	ploadu< Packet4s > (const int16_t *from)
Packet4uc	ploadu< Packet4uc > (const uint8_t *from)
Packet4ui	ploadu< Packet4ui > (const uint32_t *from)
Packet4us	ploadu< Packet4us > (const uint16_t *from)
Packet8bf	ploadu< Packet8bf > (const bfloat16 *from)
Packet8c	ploadu< Packet8c > (const int8_t *from)
Packet8cf	ploadu< Packet8cf > (const std::complex< float > *from)
Packet8d	ploadu< Packet8d > (const double *from)
Packet8d	ploadu< Packet8d > (const double *from, uint8_t umask)
Packet8f	ploadu< Packet8f > (const float *from)
Packet8f	ploadu< Packet8f > (const float *from, uint8_t umask)
Packet8h	ploadu< Packet8h > (const Eigen::half *from)
Packet8i	ploadu< Packet8i > (const int *from)
Packet8s	ploadu< Packet8s > (const int16_t *from)
Packet8s	ploadu< Packet8s > (const short int *from)
Packet8uc	ploadu< Packet8uc > (const uint8_t *from)
Packet8ui	ploadu< Packet8ui > (const uint32_t *from)
Packet8us	ploadu< Packet8us > (const uint16_t *from)
Packet8us	ploadu< Packet8us > (const unsigned short int *from)
PacketXf	ploadu< PacketXf > (const float *from)
PacketXi	ploadu< PacketXi > (const numext::int32_t *from)
Packet	ploadu_common (const __UNPACK_TYPE__(Packet) *from)
Packet	ploadu_partial (const typename unpacket_traits< Packet >::type *from, const Index n, const Index offset=0)
EIGEN_ALWAYS_INLINE Packet16c	ploadu_partial< Packet16c > (const signed char *from, const Index n, const Index offset)
EIGEN_ALWAYS_INLINE Packet16uc	ploadu_partial< Packet16uc > (const unsigned char *from, const Index n, const Index offset)
EIGEN_ALWAYS_INLINE Packet2cf	ploadu_partial< Packet2cf > (const std::complex< float > *from, const Index n, const Index offset)
EIGEN_ALWAYS_INLINE Packet4f	ploadu_partial< Packet4f > (const float *from, const Index n, const Index offset)
EIGEN_ALWAYS_INLINE Packet4i	ploadu_partial< Packet4i > (const int *from, const Index n, const Index offset)
EIGEN_ALWAYS_INLINE Packet8bf	ploadu_partial< Packet8bf > (const bfloat16 *from, const Index n, const Index offset)
EIGEN_ALWAYS_INLINE Packet8s	ploadu_partial< Packet8s > (const short int *from, const Index n, const Index offset)
EIGEN_ALWAYS_INLINE Packet8us	ploadu_partial< Packet8us > (const unsigned short int *from, const Index n, const Index offset)
EIGEN_ALWAYS_INLINE Packet	ploadu_partial_common (const __UNPACK_TYPE__(Packet) *from, const Index n, const Index offset)
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	plog (const Packet &a)
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	plog10 (const Packet &a)
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	plog1p (const Packet &a)
Packet16h	plog1p< Packet16h > (const Packet16h &)
Packet32h	plog1p< Packet32h > (const Packet32h &a)
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	plog2 (const Packet &a)
Packet16h	plog2< Packet16h > (const Packet16h &)
Packet32h	plog2< Packet32h > (const Packet32h &a)
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	plog2_double (const Packet _x)
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	plog2_float (const Packet _x)
Packet16h	plog< Packet16h > (const Packet16h &)
Packet32h	plog< Packet32h > (const Packet32h &a)
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet4f	plog< Packet4f > (const Packet4f &_x)
Packet8bf	plog< Packet8bf > (const Packet8bf &a)
PacketXf	plog< PacketXf > (const PacketXf &x)
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	plog_double (const Packet _x)
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	plog_float (const Packet _x)
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	plog_impl_double (const Packet _x)
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	plog_impl_float (const Packet _x)
int	plogical_shift_left (const int &a)
long int	plogical_shift_left (const long int &a)
Packet4f	plogical_shift_left (const Packet4f &a)
Packet4i	plogical_shift_left (const Packet4i &a)
Packet4ui	plogical_shift_left (const Packet4ui &a)
Packet8us	plogical_shift_left (const Packet8us &a)
Packet16c	plogical_shift_left (Packet16c a)
Packet16i	plogical_shift_left (Packet16i a)
Packet16uc	plogical_shift_left (Packet16uc a)
Packet2i	plogical_shift_left (Packet2i a)
Packet2l	plogical_shift_left (Packet2l a)
Packet2ui	plogical_shift_left (Packet2ui a)
Packet2ul	plogical_shift_left (Packet2ul a)
Packet4c	plogical_shift_left (Packet4c &a)
Packet4i	plogical_shift_left (Packet4i a)
Packet4s	plogical_shift_left (Packet4s a)
Packet4uc	plogical_shift_left (Packet4uc &a)
Packet4ui	plogical_shift_left (Packet4ui a)
Packet4us	plogical_shift_left (Packet4us a)
Packet8c	plogical_shift_left (Packet8c a)
Packet8i	plogical_shift_left (Packet8i a)
Packet8s	plogical_shift_left (Packet8s a)
Packet8uc	plogical_shift_left (Packet8uc a)
Packet8ui	plogical_shift_left (Packet8ui a)
Packet8us	plogical_shift_left (Packet8us a)
PacketXi	plogical_shift_left (PacketXi a)
int	plogical_shift_right (const int &a)
long int	plogical_shift_right (const long int &a)
Packet4f	plogical_shift_right (const Packet4f &a)
Packet4i	plogical_shift_right (const Packet4i &a)
Packet4ui	plogical_shift_right (const Packet4ui &a)
Packet8us	plogical_shift_right (const Packet8us &a)
Packet16c	plogical_shift_right (Packet16c a)
Packet16i	plogical_shift_right (Packet16i a)
Packet16uc	plogical_shift_right (Packet16uc a)
Packet2i	plogical_shift_right (Packet2i a)
Packet2l	plogical_shift_right (Packet2l a)
Packet2ui	plogical_shift_right (Packet2ui a)
Packet2ul	plogical_shift_right (Packet2ul a)
Packet4c	plogical_shift_right (Packet4c &a)
Packet4i	plogical_shift_right (Packet4i a)
Packet4s	plogical_shift_right (Packet4s a)
Packet4uc	plogical_shift_right (Packet4uc &a)
Packet4ui	plogical_shift_right (Packet4ui a)
Packet4us	plogical_shift_right (Packet4us a)
Packet8c	plogical_shift_right (Packet8c a)
Packet8i	plogical_shift_right (Packet8i a)
Packet8s	plogical_shift_right (Packet8s a)
Packet8uc	plogical_shift_right (Packet8uc a)
Packet8ui	plogical_shift_right (Packet8ui a)
Packet8us	plogical_shift_right (Packet8us a)
PacketXi	plogical_shift_right (PacketXi a)
Packet	plset (const typename unpacket_traits< Packet >::type &a)
Packet16bf	plset< Packet16bf > (const bfloat16 &a)
Packet16c	plset< Packet16c > (const int8_t &a)
Packet16c	plset< Packet16c > (const signed char &a)
Packet16f	plset< Packet16f > (const float &a)
Packet16h	plset< Packet16h > (const half &a)
Packet16i	plset< Packet16i > (const int &a)
Packet16uc	plset< Packet16uc > (const uint8_t &a)
Packet16uc	plset< Packet16uc > (const unsigned char &a)
Packet2d	plset< Packet2d > (const double &a)
Packet2f	plset< Packet2f > (const float &a)
Packet2i	plset< Packet2i > (const int32_t &a)
Packet2l	plset< Packet2l > (const int64_t &a)
Packet2ui	plset< Packet2ui > (const uint32_t &a)
Packet2ul	plset< Packet2ul > (const uint64_t &a)
Packet32h	plset< Packet32h > (const half &a)
Packet4bf	plset< Packet4bf > (const bfloat16 &a)
Packet4c	plset< Packet4c > (const int8_t &a)
Packet4d	plset< Packet4d > (const double &a)
Packet4f	plset< Packet4f > (const float &a)
Packet4i	plset< Packet4i > (const int &a)
Packet4i	plset< Packet4i > (const int32_t &a)
Packet4s	plset< Packet4s > (const int16_t &a)
Packet4uc	plset< Packet4uc > (const uint8_t &a)
Packet4ui	plset< Packet4ui > (const uint32_t &a)
Packet4us	plset< Packet4us > (const uint16_t &a)
Packet8bf	plset< Packet8bf > (const bfloat16 &a)
Packet8c	plset< Packet8c > (const int8_t &a)
Packet8d	plset< Packet8d > (const double &a)
Packet8f	plset< Packet8f > (const float &a)
Packet8h	plset< Packet8h > (const half &a)
Packet8i	plset< Packet8i > (const int &a)
Packet8s	plset< Packet8s > (const int16_t &a)
Packet8s	plset< Packet8s > (const short int &a)
Packet8uc	plset< Packet8uc > (const uint8_t &a)
Packet8ui	plset< Packet8ui > (const uint32_t &a)
Packet8us	plset< Packet8us > (const uint16_t &a)
Packet8us	plset< Packet8us > (const unsigned short int &a)
PacketXf	plset< PacketXf > (const float &a)
PacketXi	plset< PacketXi > (const numext::int32_t &a)
Packet	pmadd (const Packet &a, const Packet &b, const Packet &c)
Packet16c	pmadd (const Packet16c &a, const Packet16c &b, const Packet16c &c)
Packet16uc	pmadd (const Packet16uc &a, const Packet16uc &b, const Packet16uc &c)
Packet2d	pmadd (const Packet2d &a, const Packet2d &b, const Packet2d &c)
Packet2f	pmadd (const Packet2f &a, const Packet2f &b, const Packet2f &c)
Packet2i	pmadd (const Packet2i &a, const Packet2i &b, const Packet2i &c)
Packet2ui	pmadd (const Packet2ui &a, const Packet2ui &b, const Packet2ui &c)
Packet4c	pmadd (const Packet4c &a, const Packet4c &b, const Packet4c &c)
Packet4f	pmadd (const Packet4f &a, const Packet4f &b, const Packet4f &c)
Packet4i	pmadd (const Packet4i &a, const Packet4i &b, const Packet4i &c)
Packet4s	pmadd (const Packet4s &a, const Packet4s &b, const Packet4s &c)
Packet4uc	pmadd (const Packet4uc &a, const Packet4uc &b, const Packet4uc &c)
Packet4ui	pmadd (const Packet4ui &a, const Packet4ui &b, const Packet4ui &c)
Packet4us	pmadd (const Packet4us &a, const Packet4us &b, const Packet4us &c)
Packet8bf	pmadd (const Packet8bf &a, const Packet8bf &b, const Packet8bf &c)
Packet8c	pmadd (const Packet8c &a, const Packet8c &b, const Packet8c &c)
Packet8s	pmadd (const Packet8s &a, const Packet8s &b, const Packet8s &c)
Packet8uc	pmadd (const Packet8uc &a, const Packet8uc &b, const Packet8uc &c)
Packet8us	pmadd (const Packet8us &a, const Packet8us &b, const Packet8us &c)
PacketXf	pmadd (const PacketXf &a, const PacketXf &b, const PacketXf &c)
PacketXi	pmadd (const PacketXi &a, const PacketXi &b, const PacketXi &c)
Packet	pmax (const Packet &a, const Packet &b)
Packet16bf	pmax< Packet16bf > (const Packet16bf &a, const Packet16bf &b)
Packet16c	pmax< Packet16c > (const Packet16c &a, const Packet16c &b)
Packet16f	pmax< Packet16f > (const Packet16f &a, const Packet16f &b)
Packet16h	pmax< Packet16h > (const Packet16h &a, const Packet16h &b)
Packet16i	pmax< Packet16i > (const Packet16i &a, const Packet16i &b)
Packet16uc	pmax< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
Packet2d	pmax< Packet2d > (const Packet2d &a, const Packet2d &b)
Packet2f	pmax< Packet2f > (const Packet2f &a, const Packet2f &b)
Packet2i	pmax< Packet2i > (const Packet2i &a, const Packet2i &b)
Packet2l	pmax< Packet2l > (const Packet2l &a, const Packet2l &b)
Packet2ui	pmax< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
Packet2ul	pmax< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
Packet32h	pmax< Packet32h > (const Packet32h &a, const Packet32h &b)
Packet4bf	pmax< Packet4bf > (const Packet4bf &a, const Packet4bf &b)
Packet4c	pmax< Packet4c > (const Packet4c &a, const Packet4c &b)
Packet4d	pmax< Packet4d > (const Packet4d &a, const Packet4d &b)
Packet4f	pmax< Packet4f > (const Packet4f &a, const Packet4f &b)
Packet4i	pmax< Packet4i > (const Packet4i &a, const Packet4i &b)
Packet4s	pmax< Packet4s > (const Packet4s &a, const Packet4s &b)
Packet4uc	pmax< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
Packet4ui	pmax< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
Packet4us	pmax< Packet4us > (const Packet4us &a, const Packet4us &b)
Packet8bf	pmax< Packet8bf > (const Packet8bf &a, const Packet8bf &b)
Packet8c	pmax< Packet8c > (const Packet8c &a, const Packet8c &b)
Packet8d	pmax< Packet8d > (const Packet8d &a, const Packet8d &b)
Packet8f	pmax< Packet8f > (const Packet8f &a, const Packet8f &b)
Packet8h	pmax< Packet8h > (const Packet8h &a, const Packet8h &b)
Packet8i	pmax< Packet8i > (const Packet8i &a, const Packet8i &b)
Packet8s	pmax< Packet8s > (const Packet8s &a, const Packet8s &b)
Packet8uc	pmax< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
Packet8ui	pmax< Packet8ui > (const Packet8ui &a, const Packet8ui &b)
Packet8us	pmax< Packet8us > (const Packet8us &a, const Packet8us &b)
PacketXf	pmax< PacketXf > (const PacketXf &a, const PacketXf &b)
PacketXi	pmax< PacketXi > (const PacketXi &a, const PacketXi &b)
Packet16f	pmax< PropagateNaN, Packet16f > (const Packet16f &a, const Packet16f &b)
Packet2d	pmax< PropagateNaN, Packet2d > (const Packet2d &a, const Packet2d &b)
Packet2f	pmax< PropagateNaN, Packet2f > (const Packet2f &a, const Packet2f &b)
Packet4bf	pmax< PropagateNaN, Packet4bf > (const Packet4bf &a, const Packet4bf &b)
Packet4d	pmax< PropagateNaN, Packet4d > (const Packet4d &a, const Packet4d &b)
Packet4f	pmax< PropagateNaN, Packet4f > (const Packet4f &a, const Packet4f &b)
Packet8d	pmax< PropagateNaN, Packet8d > (const Packet8d &a, const Packet8d &b)
Packet8f	pmax< PropagateNaN, Packet8f > (const Packet8f &a, const Packet8f &b)
PacketXf	pmax< PropagateNaN, PacketXf > (const PacketXf &a, const PacketXf &b)
Packet16f	pmax< PropagateNumbers, Packet16f > (const Packet16f &a, const Packet16f &b)
Packet2d	pmax< PropagateNumbers, Packet2d > (const Packet2d &a, const Packet2d &b)
Packet4bf	pmax< PropagateNumbers, Packet4bf > (const Packet4bf &a, const Packet4bf &b)
Packet4d	pmax< PropagateNumbers, Packet4d > (const Packet4d &a, const Packet4d &b)
Packet4f	pmax< PropagateNumbers, Packet4f > (const Packet4f &a, const Packet4f &b)
Packet8d	pmax< PropagateNumbers, Packet8d > (const Packet8d &a, const Packet8d &b)
Packet8f	pmax< PropagateNumbers, Packet8f > (const Packet8f &a, const Packet8f &b)
PacketXf	pmax< PropagateNumbers, PacketXf > (const PacketXf &a, const PacketXf &b)
EIGEN_ALWAYS_INLINE Packet8us	pmerge (Packet4ui even, Packet4ui odd)
Packet	pmin (const Packet &a, const Packet &b)
Packet16bf	pmin< Packet16bf > (const Packet16bf &a, const Packet16bf &b)
Packet16c	pmin< Packet16c > (const Packet16c &a, const Packet16c &b)
Packet16f	pmin< Packet16f > (const Packet16f &a, const Packet16f &b)
Packet16h	pmin< Packet16h > (const Packet16h &a, const Packet16h &b)
Packet16i	pmin< Packet16i > (const Packet16i &a, const Packet16i &b)
Packet16uc	pmin< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
Packet2d	pmin< Packet2d > (const Packet2d &a, const Packet2d &b)
Packet2f	pmin< Packet2f > (const Packet2f &a, const Packet2f &b)
Packet2i	pmin< Packet2i > (const Packet2i &a, const Packet2i &b)
Packet2l	pmin< Packet2l > (const Packet2l &a, const Packet2l &b)
Packet2ui	pmin< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
Packet2ul	pmin< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
Packet32h	pmin< Packet32h > (const Packet32h &a, const Packet32h &b)
Packet4bf	pmin< Packet4bf > (const Packet4bf &a, const Packet4bf &b)
Packet4c	pmin< Packet4c > (const Packet4c &a, const Packet4c &b)
Packet4d	pmin< Packet4d > (const Packet4d &a, const Packet4d &b)
Packet4f	pmin< Packet4f > (const Packet4f &a, const Packet4f &b)
Packet4i	pmin< Packet4i > (const Packet4i &a, const Packet4i &b)
Packet4s	pmin< Packet4s > (const Packet4s &a, const Packet4s &b)
Packet4uc	pmin< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
Packet4ui	pmin< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
Packet4us	pmin< Packet4us > (const Packet4us &a, const Packet4us &b)
Packet8bf	pmin< Packet8bf > (const Packet8bf &a, const Packet8bf &b)
Packet8c	pmin< Packet8c > (const Packet8c &a, const Packet8c &b)
Packet8d	pmin< Packet8d > (const Packet8d &a, const Packet8d &b)
Packet8f	pmin< Packet8f > (const Packet8f &a, const Packet8f &b)
Packet8h	pmin< Packet8h > (const Packet8h &a, const Packet8h &b)
Packet8i	pmin< Packet8i > (const Packet8i &a, const Packet8i &b)
Packet8s	pmin< Packet8s > (const Packet8s &a, const Packet8s &b)
Packet8uc	pmin< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
Packet8ui	pmin< Packet8ui > (const Packet8ui &a, const Packet8ui &b)
Packet8us	pmin< Packet8us > (const Packet8us &a, const Packet8us &b)
PacketXf	pmin< PacketXf > (const PacketXf &a, const PacketXf &b)
PacketXi	pmin< PacketXi > (const PacketXi &a, const PacketXi &b)
Packet16f	pmin< PropagateNaN, Packet16f > (const Packet16f &a, const Packet16f &b)
Packet2d	pmin< PropagateNaN, Packet2d > (const Packet2d &a, const Packet2d &b)
Packet2f	pmin< PropagateNaN, Packet2f > (const Packet2f &a, const Packet2f &b)
Packet4bf	pmin< PropagateNaN, Packet4bf > (const Packet4bf &a, const Packet4bf &b)
Packet4d	pmin< PropagateNaN, Packet4d > (const Packet4d &a, const Packet4d &b)
Packet4f	pmin< PropagateNaN, Packet4f > (const Packet4f &a, const Packet4f &b)
Packet8d	pmin< PropagateNaN, Packet8d > (const Packet8d &a, const Packet8d &b)
Packet8f	pmin< PropagateNaN, Packet8f > (const Packet8f &a, const Packet8f &b)
PacketXf	pmin< PropagateNaN, PacketXf > (const PacketXf &a, const PacketXf &b)
Packet16f	pmin< PropagateNumbers, Packet16f > (const Packet16f &a, const Packet16f &b)
Packet2d	pmin< PropagateNumbers, Packet2d > (const Packet2d &a, const Packet2d &b)
Packet4bf	pmin< PropagateNumbers, Packet4bf > (const Packet4bf &a, const Packet4bf &b)
Packet4d	pmin< PropagateNumbers, Packet4d > (const Packet4d &a, const Packet4d &b)
Packet4f	pmin< PropagateNumbers, Packet4f > (const Packet4f &a, const Packet4f &b)
Packet8d	pmin< PropagateNumbers, Packet8d > (const Packet8d &a, const Packet8d &b)
Packet8f	pmin< PropagateNumbers, Packet8f > (const Packet8f &a, const Packet8f &b)
PacketXf	pmin< PropagateNumbers, PacketXf > (const PacketXf &a, const PacketXf &b)
Packet	pminmax_propagate_nan (const Packet &a, const Packet &b, Op op)
Packet	pminmax_propagate_numbers (const Packet &a, const Packet &b, Op op)
Packet	pmsub (const Packet &a, const Packet &b, const Packet &c)
bool	pmul (const bool &a, const bool &b)
Packet	pmul (const Packet &a, const Packet &b)
std::complex< double >	pmul (const std::complex< double > &a, const std::complex< double > &b)
std::complex< float >	pmul (const std::complex< float > &a, const std::complex< float > &b)
Packet16b	pmul< Packet16b > (const Packet16b &a, const Packet16b &b)
Packet16bf	pmul< Packet16bf > (const Packet16bf &a, const Packet16bf &b)
Packet16c	pmul< Packet16c > (const Packet16c &a, const Packet16c &b)
Packet16f	pmul< Packet16f > (const Packet16f &a, const Packet16f &b)
Packet16h	pmul< Packet16h > (const Packet16h &a, const Packet16h &b)
Packet16i	pmul< Packet16i > (const Packet16i &a, const Packet16i &b)
Packet16uc	pmul< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
Packet1cd	pmul< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
Packet1cf	pmul< Packet1cf > (const Packet1cf &a, const Packet1cf &b)
Packet2cd	pmul< Packet2cd > (const Packet2cd &a, const Packet2cd &b)
Packet2cf	pmul< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
Packet2d	pmul< Packet2d > (const Packet2d &a, const Packet2d &b)
Packet2f	pmul< Packet2f > (const Packet2f &a, const Packet2f &b)
Packet2i	pmul< Packet2i > (const Packet2i &a, const Packet2i &b)
Packet2l	pmul< Packet2l > (const Packet2l &a, const Packet2l &b)
Packet2ui	pmul< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
Packet2ul	pmul< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
Packet32h	pmul< Packet32h > (const Packet32h &a, const Packet32h &b)
Packet4bf	pmul< Packet4bf > (const Packet4bf &a, const Packet4bf &b)
Packet4c	pmul< Packet4c > (const Packet4c &a, const Packet4c &b)
Packet4cd	pmul< Packet4cd > (const Packet4cd &a, const Packet4cd &b)
Packet4cf	pmul< Packet4cf > (const Packet4cf &a, const Packet4cf &b)
Packet4d	pmul< Packet4d > (const Packet4d &a, const Packet4d &b)
Packet4f	pmul< Packet4f > (const Packet4f &a, const Packet4f &b)
Packet4i	pmul< Packet4i > (const Packet4i &a, const Packet4i &b)
Packet4s	pmul< Packet4s > (const Packet4s &a, const Packet4s &b)
Packet4uc	pmul< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
Packet4ui	pmul< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
Packet4us	pmul< Packet4us > (const Packet4us &a, const Packet4us &b)
Packet8bf	pmul< Packet8bf > (const Packet8bf &a, const Packet8bf &b)
Packet8c	pmul< Packet8c > (const Packet8c &a, const Packet8c &b)
Packet8cf	pmul< Packet8cf > (const Packet8cf &a, const Packet8cf &b)
Packet8d	pmul< Packet8d > (const Packet8d &a, const Packet8d &b)
Packet8f	pmul< Packet8f > (const Packet8f &a, const Packet8f &b)
Packet8h	pmul< Packet8h > (const Packet8h &a, const Packet8h &b)
Packet8i	pmul< Packet8i > (const Packet8i &a, const Packet8i &b)
Packet8s	pmul< Packet8s > (const Packet8s &a, const Packet8s &b)
Packet8uc	pmul< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
Packet8ui	pmul< Packet8ui > (const Packet8ui &a, const Packet8ui &b)
Packet8us	pmul< Packet8us > (const Packet8us &a, const Packet8us &b)
PacketXf	pmul< PacketXf > (const PacketXf &a, const PacketXf &b)
PacketXi	pmul< PacketXi > (const PacketXi &a, const PacketXi &b)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pndtri (const Packet &a)
bool	pnegate (const bool &a)
Packet	pnegate (const Packet &a)
Packet16b	pnegate (const Packet16b &a)
Packet16bf	pnegate (const Packet16bf &a)
Packet16c	pnegate (const Packet16c &a)
Packet16f	pnegate (const Packet16f &a)
Packet16h	pnegate (const Packet16h &a)
Packet16i	pnegate (const Packet16i &a)
Packet1cd	pnegate (const Packet1cd &a)
Packet1cf	pnegate (const Packet1cf &a)
Packet2cd	pnegate (const Packet2cd &a)
Packet2cf	pnegate (const Packet2cf &a)
Packet2d	pnegate (const Packet2d &a)
Packet2f	pnegate (const Packet2f &a)
Packet2i	pnegate (const Packet2i &a)
Packet2l	pnegate (const Packet2l &a)
Packet4c	pnegate (const Packet4c &a)
Packet4cd	pnegate (const Packet4cd &a)
Packet4cf	pnegate (const Packet4cf &a)
Packet4d	pnegate (const Packet4d &a)
Packet4f	pnegate (const Packet4f &a)
Packet4i	pnegate (const Packet4i &a)
Packet4s	pnegate (const Packet4s &a)
Packet8bf	pnegate (const Packet8bf &a)
Packet8c	pnegate (const Packet8c &a)
Packet8cf	pnegate (const Packet8cf &a)
Packet8d	pnegate (const Packet8d &a)
Packet8f	pnegate (const Packet8f &a)
Packet8h	pnegate (const Packet8h &a)
Packet8i	pnegate (const Packet8i &a)
Packet8s	pnegate (const Packet8s &a)
PacketXf	pnegate (const PacketXf &a)
PacketXi	pnegate (const PacketXi &a)
Packet32h	pnegate< Packet32h > (const Packet32h &a)
Packet4bf	pnegate< Packet4bf > (const Packet4bf &a)
Packet8bf	pnegate< Packet8bf > (const Packet8bf &a)
Packet	pnmadd (const Packet &a, const Packet &b, const Packet &c)
Packet	pnmsub (const Packet &a, const Packet &b, const Packet &c)
Packet	pnot (const Packet &a)
Packet	por (const Packet &a, const Packet &b)
Packet16bf	por (const Packet16bf &a, const Packet16bf &b)
Packet16h	por (const Packet16h &a, const Packet16h &b)
Packet32h	por (const Packet32h &a, const Packet32h &b)
Packet4bf	por (const Packet4bf &a, const Packet4bf &b)
Packet8bf	por (const Packet8bf &a, const Packet8bf &b)
Packet8h	por (const Packet8h &a, const Packet8h &b)
Packet16b	por< Packet16b > (const Packet16b &a, const Packet16b &b)
Packet16c	por< Packet16c > (const Packet16c &a, const Packet16c &b)
Packet16f	por< Packet16f > (const Packet16f &a, const Packet16f &b)
Packet16i	por< Packet16i > (const Packet16i &a, const Packet16i &b)
Packet16uc	por< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
Packet1cd	por< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
Packet1cf	por< Packet1cf > (const Packet1cf &a, const Packet1cf &b)
Packet2cd	por< Packet2cd > (const Packet2cd &a, const Packet2cd &b)
Packet2cf	por< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
Packet2d	por< Packet2d > (const Packet2d &a, const Packet2d &b)
Packet2f	por< Packet2f > (const Packet2f &a, const Packet2f &b)
Packet2i	por< Packet2i > (const Packet2i &a, const Packet2i &b)
Packet2l	por< Packet2l > (const Packet2l &a, const Packet2l &b)
Packet2ui	por< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
Packet2ul	por< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
Packet4c	por< Packet4c > (const Packet4c &a, const Packet4c &b)
Packet4cd	por< Packet4cd > (const Packet4cd &a, const Packet4cd &b)
Packet4cf	por< Packet4cf > (const Packet4cf &a, const Packet4cf &b)
Packet4d	por< Packet4d > (const Packet4d &a, const Packet4d &b)
Packet4f	por< Packet4f > (const Packet4f &a, const Packet4f &b)
Packet4i	por< Packet4i > (const Packet4i &a, const Packet4i &b)
Packet4s	por< Packet4s > (const Packet4s &a, const Packet4s &b)
Packet4uc	por< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
Packet4ui	por< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
Packet4us	por< Packet4us > (const Packet4us &a, const Packet4us &b)
Packet8bf	por< Packet8bf > (const Packet8bf &a, const Packet8bf &b)
Packet8c	por< Packet8c > (const Packet8c &a, const Packet8c &b)
Packet8cf	por< Packet8cf > (const Packet8cf &a, const Packet8cf &b)
Packet8d	por< Packet8d > (const Packet8d &a, const Packet8d &b)
Packet8f	por< Packet8f > (const Packet8f &a, const Packet8f &b)
Packet8i	por< Packet8i > (const Packet8i &a, const Packet8i &b)
Packet8s	por< Packet8s > (const Packet8s &a, const Packet8s &b)
Packet8uc	por< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
Packet8ui	por< Packet8ui > (const Packet8ui &a, const Packet8ui &b)
Packet8us	por< Packet8us > (const Packet8us &a, const Packet8us &b)
PacketXf	por< PacketXf > (const PacketXf &a, const PacketXf &b)
PacketXi	por< PacketXi > (const PacketXi &a, const PacketXi &b)
RealScalar	positive_real_hypot (const RealScalar &x, const RealScalar &y)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	ppolygamma (const Packet &n, const Packet &x)
Packet	preciprocal (const Packet &a)
Packet32h	preciprocal< Packet32h > (const Packet32h &a)
unpacket_traits< Packet >::type	predux (const Packet &a)
bool	predux< Packet16b > (const Packet16b &a)
bfloat16	predux< Packet16bf > (const Packet16bf &p)
signed char	predux< Packet16c > (const Packet16c &a)
float	predux< Packet16f > (const Packet16f &a)
half	predux< Packet16h > (const Packet16h &from)
int	predux< Packet16i > (const Packet16i &a)
unsigned char	predux< Packet16uc > (const Packet16uc &a)
std::complex< double >	predux< Packet1cd > (const Packet1cd &a)
std::complex< float >	predux< Packet1cf > (const Packet1cf &a)
std::complex< double >	predux< Packet2cd > (const Packet2cd &a)
std::complex< float >	predux< Packet2cf > (const Packet2cf &a)
double	predux< Packet2d > (const Packet2d &a)
float	predux< Packet2f > (const Packet2f &a)
int32_t	predux< Packet2i > (const Packet2i &a)
int64_t	predux< Packet2l > (const Packet2l &a)
uint32_t	predux< Packet2ui > (const Packet2ui &a)
uint64_t	predux< Packet2ul > (const Packet2ul &a)
half	predux< Packet32h > (const Packet32h &a)
bfloat16	predux< Packet4bf > (const Packet4bf &a)
int8_t	predux< Packet4c > (const Packet4c &a)
std::complex< double >	predux< Packet4cd > (const Packet4cd &a)
std::complex< float >	predux< Packet4cf > (const Packet4cf &a)
double	predux< Packet4d > (const Packet4d &a)
float	predux< Packet4f > (const Packet4f &a)
int	predux< Packet4i > (const Packet4i &a)
int16_t	predux< Packet4s > (const Packet4s &a)
uint8_t	predux< Packet4uc > (const Packet4uc &a)
uint32_t	predux< Packet4ui > (const Packet4ui &a)
uint16_t	predux< Packet4us > (const Packet4us &a)
bfloat16	predux< Packet8bf > (const Packet8bf &a)
int8_t	predux< Packet8c > (const Packet8c &a)
std::complex< float >	predux< Packet8cf > (const Packet8cf &a)
double	predux< Packet8d > (const Packet8d &a)
float	predux< Packet8f > (const Packet8f &a)
Eigen::half	predux< Packet8h > (const Packet8h &a)
int	predux< Packet8i > (const Packet8i &a)
short int	predux< Packet8s > (const Packet8s &a)
uint8_t	predux< Packet8uc > (const Packet8uc &a)
uint32_t	predux< Packet8ui > (const Packet8ui &a)
unsigned short int	predux< Packet8us > (const Packet8us &a)
float	predux< PacketXf > (const PacketXf &a)
numext::int32_t	predux< PacketXi > (const PacketXi &a)
bool	predux_any (const Packet &a)
bool	predux_any (const Packet16f &x)
bool	predux_any (const Packet16i &x)
bool	predux_any (const Packet4f &x)
bool	predux_any (const Packet4i &x)
bool	predux_any (const Packet4ui &x)
bool	predux_any (const Packet8f &x)
bool	predux_any (const Packet8i &x)
bool	predux_any (const Packet8ui &x)
const DoublePacket< Packet > &	predux_half_dowto4 (const DoublePacket< Packet > &a, std::enable_if_t< unpacket_traits< Packet >::size<=8 > *=0)
DoublePacket< typename unpacket_traits< Packet >::half >	predux_half_dowto4 (const DoublePacket< Packet > &a, std::enable_if_t< unpacket_traits< Packet >::size==16 > *=0)
std::conditional_t<(unpacket_traits< Packet >::size%8)==0, typename unpacket_traits< Packet >::half, Packet >	predux_half_dowto4 (const Packet &a)
Packet8c	predux_half_dowto4 (const Packet16c &a)
Packet8uc	predux_half_dowto4 (const Packet16uc &a)
Packet4c	predux_half_dowto4 (const Packet8c &a)
Packet4s	predux_half_dowto4 (const Packet8s &a)
Packet4uc	predux_half_dowto4 (const Packet8uc &a)
Packet4us	predux_half_dowto4 (const Packet8us &a)
Packet8bf	predux_half_dowto4< Packet16bf > (const Packet16bf &a)
Packet8f	predux_half_dowto4< Packet16f > (const Packet16f &a)
Packet8h	predux_half_dowto4< Packet16h > (const Packet16h &a)
Packet8i	predux_half_dowto4< Packet16i > (const Packet16i &a)
Packet16h	predux_half_dowto4< Packet32h > (const Packet32h &a)
Packet4cf	predux_half_dowto4< Packet8cf > (const Packet8cf &a)
Packet4d	predux_half_dowto4< Packet8d > (const Packet8d &a)
Packet4f	predux_half_dowto4< Packet8f > (const Packet8f &a)
Packet4i	predux_half_dowto4< Packet8i > (const Packet8i &a)
Packet4ui	predux_half_dowto4< Packet8ui > (const Packet8ui &a)
unpacket_traits< Packet >::type	predux_helper (const Packet &a, Op op)
unpacket_traits< Packet >::type	predux_max (const Packet &a)
bfloat16	predux_max< Packet16bf > (const Packet16bf &from)
signed char	predux_max< Packet16c > (const Packet16c &a)
float	predux_max< Packet16f > (const Packet16f &a)
Eigen::half	predux_max< Packet16h > (const Packet16h &a)
unsigned char	predux_max< Packet16uc > (const Packet16uc &a)
double	predux_max< Packet2d > (const Packet2d &a)
float	predux_max< Packet2f > (const Packet2f &a)
int32_t	predux_max< Packet2i > (const Packet2i &a)
int64_t	predux_max< Packet2l > (const Packet2l &a)
uint32_t	predux_max< Packet2ui > (const Packet2ui &a)
uint64_t	predux_max< Packet2ul > (const Packet2ul &a)
bfloat16	predux_max< Packet4bf > (const Packet4bf &a)
int8_t	predux_max< Packet4c > (const Packet4c &a)
double	predux_max< Packet4d > (const Packet4d &a)
float	predux_max< Packet4f > (const Packet4f &a)
int	predux_max< Packet4i > (const Packet4i &a)
int16_t	predux_max< Packet4s > (const Packet4s &a)
uint8_t	predux_max< Packet4uc > (const Packet4uc &a)
uint32_t	predux_max< Packet4ui > (const Packet4ui &a)
uint16_t	predux_max< Packet4us > (const Packet4us &a)
bfloat16	predux_max< Packet8bf > (const Packet8bf &a)
int8_t	predux_max< Packet8c > (const Packet8c &a)
double	predux_max< Packet8d > (const Packet8d &a)
float	predux_max< Packet8f > (const Packet8f &a)
Eigen::half	predux_max< Packet8h > (const Packet8h &a)
short int	predux_max< Packet8s > (const Packet8s &a)
uint8_t	predux_max< Packet8uc > (const Packet8uc &a)
unsigned short int	predux_max< Packet8us > (const Packet8us &a)
float	predux_max< PacketXf > (const PacketXf &a)
numext::int32_t	predux_max< PacketXi > (const PacketXi &a)
unpacket_traits< Packet >::type	predux_min (const Packet &a)
bfloat16	predux_min< Packet16bf > (const Packet16bf &from)
signed char	predux_min< Packet16c > (const Packet16c &a)
float	predux_min< Packet16f > (const Packet16f &a)
Eigen::half	predux_min< Packet16h > (const Packet16h &a)
unsigned char	predux_min< Packet16uc > (const Packet16uc &a)
double	predux_min< Packet2d > (const Packet2d &a)
float	predux_min< Packet2f > (const Packet2f &a)
int32_t	predux_min< Packet2i > (const Packet2i &a)
int64_t	predux_min< Packet2l > (const Packet2l &a)
uint32_t	predux_min< Packet2ui > (const Packet2ui &a)
uint64_t	predux_min< Packet2ul > (const Packet2ul &a)
bfloat16	predux_min< Packet4bf > (const Packet4bf &a)
int8_t	predux_min< Packet4c > (const Packet4c &a)
double	predux_min< Packet4d > (const Packet4d &a)
float	predux_min< Packet4f > (const Packet4f &a)
int	predux_min< Packet4i > (const Packet4i &a)
int16_t	predux_min< Packet4s > (const Packet4s &a)
uint8_t	predux_min< Packet4uc > (const Packet4uc &a)
uint32_t	predux_min< Packet4ui > (const Packet4ui &a)
uint16_t	predux_min< Packet4us > (const Packet4us &a)
bfloat16	predux_min< Packet8bf > (const Packet8bf &a)
int8_t	predux_min< Packet8c > (const Packet8c &a)
double	predux_min< Packet8d > (const Packet8d &a)
float	predux_min< Packet8f > (const Packet8f &a)
Eigen::half	predux_min< Packet8h > (const Packet8h &a)
short int	predux_min< Packet8s > (const Packet8s &a)
uint8_t	predux_min< Packet8uc > (const Packet8uc &a)
unsigned short int	predux_min< Packet8us > (const Packet8us &a)
float	predux_min< PacketXf > (const PacketXf &a)
numext::int32_t	predux_min< PacketXi > (const PacketXi &a)
unpacket_traits< Packet >::type	predux_mul (const Packet &a)
bool	predux_mul< Packet16b > (const Packet16b &a)
bfloat16	predux_mul< Packet16bf > (const Packet16bf &from)
signed char	predux_mul< Packet16c > (const Packet16c &a)
float	predux_mul< Packet16f > (const Packet16f &a)
half	predux_mul< Packet16h > (const Packet16h &from)
unsigned char	predux_mul< Packet16uc > (const Packet16uc &a)
std::complex< double >	predux_mul< Packet1cd > (const Packet1cd &a)
std::complex< float >	predux_mul< Packet1cf > (const Packet1cf &a)
std::complex< double >	predux_mul< Packet2cd > (const Packet2cd &a)
std::complex< float >	predux_mul< Packet2cf > (const Packet2cf &a)
double	predux_mul< Packet2d > (const Packet2d &a)
float	predux_mul< Packet2f > (const Packet2f &a)
int32_t	predux_mul< Packet2i > (const Packet2i &a)
int64_t	predux_mul< Packet2l > (const Packet2l &a)
uint32_t	predux_mul< Packet2ui > (const Packet2ui &a)
uint64_t	predux_mul< Packet2ul > (const Packet2ul &a)
bfloat16	predux_mul< Packet4bf > (const Packet4bf &a)
int8_t	predux_mul< Packet4c > (const Packet4c &a)
std::complex< double >	predux_mul< Packet4cd > (const Packet4cd &a)
std::complex< float >	predux_mul< Packet4cf > (const Packet4cf &a)
double	predux_mul< Packet4d > (const Packet4d &a)
float	predux_mul< Packet4f > (const Packet4f &a)
int	predux_mul< Packet4i > (const Packet4i &a)
int16_t	predux_mul< Packet4s > (const Packet4s &a)
uint8_t	predux_mul< Packet4uc > (const Packet4uc &a)
uint32_t	predux_mul< Packet4ui > (const Packet4ui &a)
uint16_t	predux_mul< Packet4us > (const Packet4us &a)
bfloat16	predux_mul< Packet8bf > (const Packet8bf &a)
int8_t	predux_mul< Packet8c > (const Packet8c &a)
std::complex< float >	predux_mul< Packet8cf > (const Packet8cf &a)
double	predux_mul< Packet8d > (const Packet8d &a)
float	predux_mul< Packet8f > (const Packet8f &a)
Eigen::half	predux_mul< Packet8h > (const Packet8h &a)
short int	predux_mul< Packet8s > (const Packet8s &a)
uint8_t	predux_mul< Packet8uc > (const Packet8uc &a)
unsigned short int	predux_mul< Packet8us > (const Packet8us &a)
float	predux_mul< PacketXf > (const PacketXf &a)
numext::int32_t	predux_mul< PacketXi > (const PacketXi &a)
EIGEN_ALWAYS_INLINE void	preduxVecResults (Packet4f(&acc)[num_acc][4])
EIGEN_ALWAYS_INLINE void	preduxVecResults2 (Packet4f(&acc)[num_acc][4], Index k)
void	prefetch (const Scalar *addr)
void	prefetch< double > (const double *addr)
void	prefetch< float > (const float *addr)
void	prefetch< int > (const int *addr)
void	prefetch< int16_t > (const int16_t *addr)
void	prefetch< int32_t > (const int32_t *addr)
void	prefetch< int64_t > (const int64_t *addr)
void	prefetch< int8_t > (const int8_t *addr)
void	prefetch< numext::int32_t > (const numext::int32_t *addr)
void	prefetch< std::complex< double > > (const std::complex< double > *addr)
void	prefetch< std::complex< float > > (const std::complex< float > *addr)
void	prefetch< uint16_t > (const uint16_t *addr)
void	prefetch< uint32_t > (const uint32_t *addr)
void	prefetch< uint64_t > (const uint64_t *addr)
void	prefetch< uint8_t > (const uint8_t *addr)
Target	preinterpret (const Packet &a)
Packet16c	preinterpret< Packet16c, Packet16uc > (const Packet16uc &a)
Packet16f	preinterpret< Packet16f, Packet16i > (const Packet16i &a)
Packet16f	preinterpret< Packet16f, Packet4f > (const Packet4f &a)
Packet16f	preinterpret< Packet16f, Packet8d > (const Packet8d &a)
Packet16f	preinterpret< Packet16f, Packet8f > (const Packet8f &a)
Packet16i	preinterpret< Packet16i, Packet16f > (const Packet16f &a)
Packet16uc	preinterpret< Packet16uc, Packet16c > (const Packet16c &a)
Packet2d	preinterpret< Packet2d, Packet4d > (const Packet4d &a)
Packet2d	preinterpret< Packet2d, Packet4f > (const Packet4f &a)
Packet2d	preinterpret< Packet2d, Packet4i > (const Packet4i &a)
Packet2d	preinterpret< Packet2d, Packet8d > (const Packet8d &a)
Packet2f	preinterpret< Packet2f, Packet2i > (const Packet2i &a)
Packet2f	preinterpret< Packet2f, Packet2ui > (const Packet2ui &a)
Packet2f	preinterpret< Packet2f, Packet4f > (const Packet4f &a)
Packet2i	preinterpret< Packet2i, Packet2f > (const Packet2f &a)
Packet2i	preinterpret< Packet2i, Packet2ui > (const Packet2ui &a)
Packet2i	preinterpret< Packet2i, Packet4i > (const Packet4i &a)
Packet2l	preinterpret< Packet2l, Packet2ul > (const Packet2ul &a)
Packet2ui	preinterpret< Packet2ui, Packet2f > (const Packet2f &a)
Packet2ui	preinterpret< Packet2ui, Packet2i > (const Packet2i &a)
Packet2ui	preinterpret< Packet2ui, Packet4ui > (const Packet4ui &a)
Packet2ul	preinterpret< Packet2ul, Packet2l > (const Packet2l &a)
Packet4c	preinterpret< Packet4c, Packet16c > (const Packet16c &a)
Packet4c	preinterpret< Packet4c, Packet4uc > (const Packet4uc &a)
Packet4c	preinterpret< Packet4c, Packet8c > (const Packet8c &a)
Packet4d	preinterpret< Packet4d, Packet8d > (const Packet8d &a)
Packet4f	preinterpret< Packet4f, Packet16f > (const Packet16f &a)
Packet4f	preinterpret< Packet4f, Packet2d > (const Packet2d &a)
Packet4f	preinterpret< Packet4f, Packet4i > (const Packet4i &a)
Packet4f	preinterpret< Packet4f, Packet4ui > (const Packet4ui &a)
Packet4f	preinterpret< Packet4f, Packet8f > (const Packet8f &a)
Packet4i	preinterpret< Packet4i, Packet16i > (const Packet16i &a)
Packet4i	preinterpret< Packet4i, Packet2d > (const Packet2d &a)
Packet4i	preinterpret< Packet4i, Packet4f > (const Packet4f &a)
Packet4i	preinterpret< Packet4i, Packet4ui > (const Packet4ui &a)
Packet4i	preinterpret< Packet4i, Packet8i > (const Packet8i &a)
Packet4s	preinterpret< Packet4s, Packet4us > (const Packet4us &a)
Packet4s	preinterpret< Packet4s, Packet8s > (const Packet8s &a)
Packet4uc	preinterpret< Packet4uc, Packet16uc > (const Packet16uc &a)
Packet4uc	preinterpret< Packet4uc, Packet4c > (const Packet4c &a)
Packet4uc	preinterpret< Packet4uc, Packet8uc > (const Packet8uc &a)
Packet4ui	preinterpret< Packet4ui, Packet4f > (const Packet4f &a)
Packet4ui	preinterpret< Packet4ui, Packet4i > (const Packet4i &a)
Packet4ui	preinterpret< Packet4ui, Packet8ui > (const Packet8ui &a)
Packet4us	preinterpret< Packet4us, Packet4s > (const Packet4s &a)
Packet4us	preinterpret< Packet4us, Packet8us > (const Packet8us &a)
Packet8bf	preinterpret< Packet8bf, Packet16bf > (const Packet16bf &a)
Packet8c	preinterpret< Packet8c, Packet16c > (const Packet16c &a)
Packet8c	preinterpret< Packet8c, Packet8uc > (const Packet8uc &a)
Packet8d	preinterpret< Packet8d, Packet16f > (const Packet16f &a)
Packet8d	preinterpret< Packet8d, Packet2d > (const Packet2d &a)
Packet8d	preinterpret< Packet8d, Packet4d > (const Packet4d &a)
Packet8f	preinterpret< Packet8f, Packet16f > (const Packet16f &a)
Packet8f	preinterpret< Packet8f, Packet8i > (const Packet8i &a)
Packet8h	preinterpret< Packet8h, Packet16h > (const Packet16h &a)
Packet8i	preinterpret< Packet8i, Packet16i > (const Packet16i &a)
Packet8i	preinterpret< Packet8i, Packet8f > (const Packet8f &a)
Packet8i	preinterpret< Packet8i, Packet8ui > (const Packet8ui &a)
Packet8s	preinterpret< Packet8s, Packet8us > (const Packet8us &a)
Packet8uc	preinterpret< Packet8uc, Packet16uc > (const Packet16uc &a)
Packet8uc	preinterpret< Packet8uc, Packet8c > (const Packet8c &a)
Packet8ui	preinterpret< Packet8ui, Packet8i > (const Packet8i &a)
Packet8us	preinterpret< Packet8us, Packet8s > (const Packet8s &a)
PacketXf	preinterpret< PacketXf, PacketXi > (const PacketXi &a)
PacketXi	preinterpret< PacketXi, PacketXf > (const PacketXf &a)
Packet	preverse (const Packet &a)
Packet16b	preverse (const Packet16b &a)
Packet16bf	preverse (const Packet16bf &a)
Packet16c	preverse (const Packet16c &a)
Packet16f	preverse (const Packet16f &a)
Packet16h	preverse (const Packet16h &a)
Packet16i	preverse (const Packet16i &a)
Packet16uc	preverse (const Packet16uc &a)
Packet1cd	preverse (const Packet1cd &a)
Packet1cf	preverse (const Packet1cf &a)
Packet2cd	preverse (const Packet2cd &a)
Packet2cf	preverse (const Packet2cf &a)
Packet2d	preverse (const Packet2d &a)
Packet2f	preverse (const Packet2f &a)
Packet2i	preverse (const Packet2i &a)
Packet2l	preverse (const Packet2l &a)
Packet2ui	preverse (const Packet2ui &a)
Packet2ul	preverse (const Packet2ul &a)
Packet32h	preverse (const Packet32h &a)
Packet4c	preverse (const Packet4c &a)
Packet4cd	preverse (const Packet4cd &a)
Packet4cf	preverse (const Packet4cf &a)
Packet4d	preverse (const Packet4d &a)
Packet4f	preverse (const Packet4f &a)
Packet4i	preverse (const Packet4i &a)
Packet4s	preverse (const Packet4s &a)
Packet4uc	preverse (const Packet4uc &a)
Packet4ui	preverse (const Packet4ui &a)
Packet4us	preverse (const Packet4us &a)
Packet8bf	preverse (const Packet8bf &a)
Packet8c	preverse (const Packet8c &a)
Packet8cf	preverse (const Packet8cf &a)
Packet8d	preverse (const Packet8d &a)
Packet8f	preverse (const Packet8f &a)
Packet8h	preverse (const Packet8h &a)
Packet8i	preverse (const Packet8i &a)
Packet8s	preverse (const Packet8s &a)
Packet8uc	preverse (const Packet8uc &a)
Packet8ui	preverse (const Packet8ui &a)
Packet8us	preverse (const Packet8us &a)
PacketXf	preverse (const PacketXf &a)
PacketXi	preverse (const PacketXi &a)
Packet4bf	preverse< Packet4bf > (const Packet4bf &a)
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	print (const Packet &a)
Packet2d	print (const Packet2d &a)
Packet2f	print (const Packet2f &a)
Packet4f	print (const Packet4f &a)
Packet16bf	print< Packet16bf > (const Packet16bf &a)
Packet16f	print< Packet16f > (const Packet16f &a)
Packet16h	print< Packet16h > (const Packet16h &a)
Packet32h	print< Packet32h > (const Packet32h &a)
Packet4bf	print< Packet4bf > (const Packet4bf &a)
Packet4d	print< Packet4d > (const Packet4d &a)
Packet8bf	print< Packet8bf > (const Packet8bf &a)
Packet8d	print< Packet8d > (const Packet8d &a)
Packet8f	print< Packet8f > (const Packet8f &a)
Packet8h	print< Packet8h > (const Packet8h &a)
std::ostream &	print_matrix (std::ostream &s, const Derived &_m, const IOFormat &fmt)
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pround (const Packet &a)
Packet16bf	pround< Packet16bf > (const Packet16bf &a)
Packet16f	pround< Packet16f > (const Packet16f &a)
Packet16h	pround< Packet16h > (const Packet16h &a)
Packet2d	pround< Packet2d > (const Packet2d &a)
Packet32h	pround< Packet32h > (const Packet32h &a)
Packet4d	pround< Packet4d > (const Packet4d &a)
Packet4f	pround< Packet4f > (const Packet4f &a)
Packet8bf	pround< Packet8bf > (const Packet8bf &a)
Packet8d	pround< Packet8d > (const Packet8d &a)
Packet8f	pround< Packet8f > (const Packet8f &a)
Packet8h	pround< Packet8h > (const Packet8h &a)
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	prsqrt (const Packet &a)
Packet2d	prsqrt (const Packet2d &a)
Packet2f	prsqrt (const Packet2f &a)
Packet4f	prsqrt (const Packet4f &a)
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet2d	prsqrt< Packet2d > (const Packet2d &x)
Packet32h	prsqrt< Packet32h > (const Packet32h &a)
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet4f	prsqrt< Packet4f > (const Packet4f &x)
void	pscatter (Scalar *to, const Packet &from, Index stride, typename unpacket_traits< Packet >::mask_t umask)
void	pscatter (Scalar *to, const Packet &from, Index)
void	pscatter< bfloat16, Packet16bf > (bfloat16 *to, const Packet16bf &from, Index stride)
void	pscatter< bfloat16, Packet4bf > (bfloat16 *to, const Packet4bf &from, Index stride)
EIGEN_ALWAYS_INLINE void	pscatter< bfloat16, Packet8bf > (bfloat16 *to, const Packet8bf &from, Index stride)
void	pscatter< bool, Packet16b > (bool *to, const Packet16b &from, Index stride)
void	pscatter< double, Packet2d > (double *to, const Packet2d &from, Index stride)
void	pscatter< double, Packet4d > (double *to, const Packet4d &from, Index stride)
void	pscatter< double, Packet8d > (double *to, const Packet8d &from, Index stride)
void	pscatter< double, Packet8d > (double *to, const Packet8d &from, Index stride, uint8_t umask)
void	pscatter< Eigen::half, Packet8h > (Eigen::half *to, const Packet8h &from, Index stride)
void	pscatter< float, Packet16f > (float *to, const Packet16f &from, Index stride)
void	pscatter< float, Packet16f > (float *to, const Packet16f &from, Index stride, uint16_t umask)
void	pscatter< float, Packet2f > (float *to, const Packet2f &from, Index stride)
EIGEN_ALWAYS_INLINE void	pscatter< float, Packet4f > (float *to, const Packet4f &from, Index stride)
void	pscatter< float, Packet8f > (float *to, const Packet8f &from, Index stride)
void	pscatter< float, PacketXf > (float *to, const PacketXf &from, Index stride)
void	pscatter< half, Packet16h > (half *to, const Packet16h &from, Index stride)
void	pscatter< half, Packet32h > (half *to, const Packet32h &from, Index stride)
void	pscatter< int, Packet16i > (int *to, const Packet16i &from, Index stride)
EIGEN_ALWAYS_INLINE void	pscatter< int, Packet4i > (int *to, const Packet4i &from, Index stride)
void	pscatter< int, Packet8i > (int *to, const Packet8i &from, Index stride)
void	pscatter< int16_t, Packet4s > (int16_t *to, const Packet4s &from, Index stride)
void	pscatter< int16_t, Packet8s > (int16_t *to, const Packet8s &from, Index stride)
void	pscatter< int32_t, Packet2i > (int32_t *to, const Packet2i &from, Index stride)
void	pscatter< int32_t, Packet4i > (int32_t *to, const Packet4i &from, Index stride)
void	pscatter< int64_t, Packet2l > (int64_t *to, const Packet2l &from, Index stride)
void	pscatter< int8_t, Packet16c > (int8_t *to, const Packet16c &from, Index stride)
void	pscatter< int8_t, Packet4c > (int8_t *to, const Packet4c &from, Index stride)
void	pscatter< int8_t, Packet8c > (int8_t *to, const Packet8c &from, Index stride)
void	pscatter< numext::int32_t, PacketXi > (numext::int32_t *to, const PacketXi &from, Index stride)
EIGEN_ALWAYS_INLINE void	pscatter< short int, Packet8s > (short int *to, const Packet8s &from, Index stride)
EIGEN_ALWAYS_INLINE void	pscatter< signed char, Packet16c > (signed char *to, const Packet16c &from, Index stride)
void	pscatter< std::complex< double >, Packet1cd > (std::complex< double > *to, const Packet1cd &from, Index stride __attribute__((unused)))
void	pscatter< std::complex< double >, Packet1cd > (std::complex< double > *to, const Packet1cd &from, Index stride EIGEN_UNUSED)
void	pscatter< std::complex< double >, Packet2cd > (std::complex< double > *to, const Packet2cd &from, Index stride)
void	pscatter< std::complex< double >, Packet4cd > (std::complex< double > *to, const Packet4cd &from, Index stride)
void	pscatter< std::complex< float >, Packet1cf > (std::complex< float > *to, const Packet1cf &from, Index stride)
EIGEN_ALWAYS_INLINE void	pscatter< std::complex< float >, Packet2cf > (std::complex< float > *to, const Packet2cf &from, Index stride)
void	pscatter< std::complex< float >, Packet4cf > (std::complex< float > *to, const Packet4cf &from, Index stride)
void	pscatter< std::complex< float >, Packet8cf > (std::complex< float > *to, const Packet8cf &from, Index stride)
void	pscatter< uint16_t, Packet4us > (uint16_t *to, const Packet4us &from, Index stride)
void	pscatter< uint16_t, Packet8us > (uint16_t *to, const Packet8us &from, Index stride)
void	pscatter< uint32_t, Packet2ui > (uint32_t *to, const Packet2ui &from, Index stride)
void	pscatter< uint32_t, Packet4ui > (uint32_t *to, const Packet4ui &from, Index stride)
void	pscatter< uint32_t, Packet8ui > (uint32_t *to, const Packet8ui &from, Index stride)
void	pscatter< uint64_t, Packet2ul > (uint64_t *to, const Packet2ul &from, Index stride)
void	pscatter< uint8_t, Packet16uc > (uint8_t *to, const Packet16uc &from, Index stride)
void	pscatter< uint8_t, Packet4uc > (uint8_t *to, const Packet4uc &from, Index stride)
void	pscatter< uint8_t, Packet8uc > (uint8_t *to, const Packet8uc &from, Index stride)
EIGEN_ALWAYS_INLINE void	pscatter< unsigned char, Packet16uc > (unsigned char *to, const Packet16uc &from, Index stride)
EIGEN_ALWAYS_INLINE void	pscatter< unsigned short int, Packet8us > (unsigned short int *to, const Packet8us &from, Index stride)
EIGEN_ALWAYS_INLINE void	pscatter_common (__UNPACK_TYPE__(Packet) *to, const Packet &from, Index stride, const Index n=unpacket_traits< Packet >::size)
EIGEN_ALWAYS_INLINE void	pscatter_complex_size2 (Scalar *to, const Packet &from, Index stride, const Index n=2)
void	pscatter_partial (Scalar *to, const Packet &from, Index stride, const Index n)
EIGEN_ALWAYS_INLINE void	pscatter_partial< bfloat16, Packet8bf > (bfloat16 *to, const Packet8bf &from, Index stride, const Index n)
EIGEN_ALWAYS_INLINE void	pscatter_partial< float, Packet4f > (float *to, const Packet4f &from, Index stride, const Index n)
EIGEN_ALWAYS_INLINE void	pscatter_partial< int, Packet4i > (int *to, const Packet4i &from, Index stride, const Index n)
EIGEN_ALWAYS_INLINE void	pscatter_partial< short int, Packet8s > (short int *to, const Packet8s &from, Index stride, const Index n)
EIGEN_ALWAYS_INLINE void	pscatter_partial< signed char, Packet16c > (signed char *to, const Packet16c &from, Index stride, const Index n)
EIGEN_ALWAYS_INLINE void	pscatter_partial< std::complex< float >, Packet2cf > (std::complex< float > *to, const Packet2cf &from, Index stride, const Index n)
EIGEN_ALWAYS_INLINE void	pscatter_partial< unsigned char, Packet16uc > (unsigned char *to, const Packet16uc &from, Index stride, const Index n)
EIGEN_ALWAYS_INLINE void	pscatter_partial< unsigned short int, Packet8us > (unsigned short int *to, const Packet8us &from, Index stride, const Index n)
Packet	pselect (const Packet &mask, const Packet &a, const Packet &b)
Packet16b	pselect (const Packet16b &mask, const Packet16b &a, const Packet16b &b)
Packet16bf	pselect (const Packet16bf &mask, const Packet16bf &a, const Packet16bf &b)
Packet16c	pselect (const Packet16c &mask, const Packet16c &a, const Packet16c &b)
Packet16f	pselect (const Packet16f &mask, const Packet16f &a, const Packet16f &b)
Packet16h	pselect (const Packet16h &mask, const Packet16h &a, const Packet16h &b)
Packet16i	pselect (const Packet16i &mask, const Packet16i &a, const Packet16i &b)
Packet16uc	pselect (const Packet16uc &mask, const Packet16uc &a, const Packet16uc &b)
Packet2f	pselect (const Packet2f &mask, const Packet2f &a, const Packet2f &b)
Packet2i	pselect (const Packet2i &mask, const Packet2i &a, const Packet2i &b)
Packet2l	pselect (const Packet2l &mask, const Packet2l &a, const Packet2l &b)
Packet2ui	pselect (const Packet2ui &mask, const Packet2ui &a, const Packet2ui &b)
Packet2ul	pselect (const Packet2ul &mask, const Packet2ul &a, const Packet2ul &b)
Packet32h	pselect (const Packet32h &mask, const Packet32h &a, const Packet32h &b)
Packet4bf	pselect (const Packet4bf &mask, const Packet4bf &a, const Packet4bf &b)
Packet4f	pselect (const Packet4f &mask, const Packet4f &a, const Packet4f &b)
Packet4i	pselect (const Packet4i &mask, const Packet4i &a, const Packet4i &b)
Packet4s	pselect (const Packet4s &mask, const Packet4s &a, const Packet4s &b)
Packet4ui	pselect (const Packet4ui &mask, const Packet4ui &a, const Packet4ui &b)
Packet4us	pselect (const Packet4us &mask, const Packet4us &a, const Packet4us &b)
Packet8bf	pselect (const Packet8bf &mask, const Packet8bf &a, const Packet8bf &b)
Packet8c	pselect (const Packet8c &mask, const Packet8c &a, const Packet8c &b)
Packet8d	pselect (const Packet8d &mask, const Packet8d &a, const Packet8d &b)
Packet8h	pselect (const Packet8h &mask, const Packet8h &a, const Packet8h &b)
Packet8s	pselect (const Packet8s &mask, const Packet8s &a, const Packet8s &b)
Packet8uc	pselect (const Packet8uc &mask, const Packet8uc &a, const Packet8uc &b)
Packet8us	pselect (const Packet8us &mask, const Packet8us &a, const Packet8us &b)
bool	pselect< bool > (const bool &cond, const bool &a, const bool &b)
Packet4d	pselect< Packet4d > (const Packet4d &mask, const Packet4d &a, const Packet4d &b)
Packet8f	pselect< Packet8f > (const Packet8f &mask, const Packet8f &a, const Packet8f &b)
Packet8i	pselect< Packet8i > (const Packet8i &mask, const Packet8i &a, const Packet8i &b)
Packet8ui	pselect< Packet8ui > (const Packet8ui &mask, const Packet8ui &a, const Packet8ui &b)
Packet	pset1 (const typename unpacket_traits< Packet >::type &a)
Packet16b	pset1< Packet16b > (const bool &from)
Packet16bf	pset1< Packet16bf > (const bfloat16 &from)
Packet16c	pset1< Packet16c > (const int8_t &from)
Packet16c	pset1< Packet16c > (const signed char &from)
Packet16f	pset1< Packet16f > (const float &from)
Packet16h	pset1< Packet16h > (const Eigen::half &from)
Packet16i	pset1< Packet16i > (const int &from)
Packet16uc	pset1< Packet16uc > (const uint8_t &from)
Packet16uc	pset1< Packet16uc > (const unsigned char &from)
Packet1cd	pset1< Packet1cd > (const std::complex< double > &from)
Packet1cf	pset1< Packet1cf > (const std::complex< float > &from)
Packet2cd	pset1< Packet2cd > (const std::complex< double > &from)
Packet2cf	pset1< Packet2cf > (const std::complex< float > &from)
Packet2d	pset1< Packet2d > (const double &from)
Packet2f	pset1< Packet2f > (const float &from)
Packet2i	pset1< Packet2i > (const int32_t &from)
Packet2l	pset1< Packet2l > (const int64_t &from)
Packet2ui	pset1< Packet2ui > (const uint32_t &from)
Packet2ul	pset1< Packet2ul > (const uint64_t &from)
Packet32h	pset1< Packet32h > (const Eigen::half &from)
Packet4bf	pset1< Packet4bf > (const bfloat16 &from)
Packet4c	pset1< Packet4c > (const int8_t &from)
Packet4cd	pset1< Packet4cd > (const std::complex< double > &from)
Packet4cf	pset1< Packet4cf > (const std::complex< float > &from)
Packet4d	pset1< Packet4d > (const double &from)
Packet4f	pset1< Packet4f > (const float &from)
Packet4i	pset1< Packet4i > (const int &from)
Packet4i	pset1< Packet4i > (const int32_t &from)
Packet4s	pset1< Packet4s > (const int16_t &from)
Packet4uc	pset1< Packet4uc > (const uint8_t &from)
Packet4ui	pset1< Packet4ui > (const uint32_t &from)
Packet4us	pset1< Packet4us > (const uint16_t &from)
Packet8bf	pset1< Packet8bf > (const bfloat16 &from)
Packet8c	pset1< Packet8c > (const int8_t &from)
Packet8cf	pset1< Packet8cf > (const std::complex< float > &from)
Packet8d	pset1< Packet8d > (const double &from)
Packet8f	pset1< Packet8f > (const float &from)
Packet8h	pset1< Packet8h > (const Eigen::half &from)
Packet8i	pset1< Packet8i > (const int &from)
Packet8s	pset1< Packet8s > (const int16_t &from)
Packet8s	pset1< Packet8s > (const short int &from)
Packet8uc	pset1< Packet8uc > (const uint8_t &from)
Packet8ui	pset1< Packet8ui > (const uint32_t &from)
Packet8us	pset1< Packet8us > (const uint16_t &from)
Packet8us	pset1< Packet8us > (const unsigned short int &from)
PacketXf	pset1< PacketXf > (const float &from)
PacketXi	pset1< PacketXi > (const numext::int32_t &from)
Packet	pset1_size16 (const __UNPACK_TYPE__(Packet)&from)
Packet	pset1_size4 (const __UNPACK_TYPE__(Packet)&from)
Packet	pset1_size8 (const __UNPACK_TYPE__(Packet)&from)
Packet	pset1frombits (BitsType a)
Packet16f	pset1frombits< Packet16f > (unsigned int from)
Packet2d	pset1frombits< Packet2d > (uint64_t from)
Packet2f	pset1frombits< Packet2f > (uint32_t from)
Packet32h	pset1frombits< Packet32h > (unsigned short from)
Packet4d	pset1frombits< Packet4d > (uint64_t from)
Packet4f	pset1frombits< Packet4f > (uint32_t from)
Packet4f	pset1frombits< Packet4f > (unsigned int from)
Packet8d	pset1frombits< Packet8d > (const numext::uint64_t from)
Packet8f	pset1frombits< Packet8f > (unsigned int from)
PacketXf	pset1frombits< PacketXf > (numext::uint32_t from)
bool	psign (const bool &a)
Packet	psign (const Packet &a)
constexpr EIGEN_ALWAYS_INLINE Packet	psignbit (const Packet &a)
Packet16bf	psignbit (const Packet16bf &a)
Packet16f	psignbit (const Packet16f &a)
Packet16h	psignbit (const Packet16h &a)
Packet2d	psignbit (const Packet2d &a)
Packet2f	psignbit (const Packet2f &a)
Packet4f	psignbit (const Packet4f &a)
Packet4ui	psignbit (const Packet4ui &a)
Packet8bf	psignbit (const Packet8bf &a)
Packet8d	psignbit (const Packet8d &a)
Packet8f	psignbit (const Packet8f &a)
Packet8h	psignbit (const Packet8h &a)
Packet8ui	psignbit (const Packet8ui &a)
Packet32h	psignbit< Packet32h > (const Packet32h &a)
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	psin (const Packet &a)
Packet16h	psin< Packet16h > (const Packet16h &)
Packet32h	psin< Packet32h > (const Packet32h &a)
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet4f	psin< Packet4f > (const Packet4f &x)
Packet8bf	psin< Packet8bf > (const Packet8bf &a)
PacketXf	psin< PacketXf > (const PacketXf &x)
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	psin_float (const Packet &x)
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	psincos_float (const Packet &_x)
Packet4f	psincos_inner_msa_float (const Packet4f &_x)
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	psinh (const Packet &a)
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	psqrt (const Packet &a)
Packet16uc	psqrt (const Packet16uc &a)
Packet2d	psqrt (const Packet2d &a)
Packet2f	psqrt (const Packet2f &a)
Packet2ui	psqrt (const Packet2ui &a)
Packet4f	psqrt (const Packet4f &a)
Packet4uc	psqrt (const Packet4uc &a)
Packet4ui	psqrt (const Packet4ui &a)
Packet4us	psqrt (const Packet4us &a)
Packet8uc	psqrt (const Packet8uc &a)
Packet8us	psqrt (const Packet8us &a)
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet16b	psqrt< Packet16b > (const Packet16b &x)
Packet16f	psqrt< Packet16f > (const Packet16f &x)
Packet1cd	psqrt< Packet1cd > (const Packet1cd &a)
Packet1cf	psqrt< Packet1cf > (const Packet1cf &a)
Packet2cd	psqrt< Packet2cd > (const Packet2cd &a)
Packet2cf	psqrt< Packet2cf > (const Packet2cf &a)
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet2d	psqrt< Packet2d > (const Packet2d &x)
Packet32h	psqrt< Packet32h > (const Packet32h &a)
Packet4cd	psqrt< Packet4cd > (const Packet4cd &a)
Packet4cf	psqrt< Packet4cf > (const Packet4cf &a)
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet4d	psqrt< Packet4d > (const Packet4d &_x)
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet4f	psqrt< Packet4f > (const Packet4f &x)
Packet8cf	psqrt< Packet8cf > (const Packet8cf &a)
Packet8d	psqrt< Packet8d > (const Packet8d &x)
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet8f	psqrt< Packet8f > (const Packet8f &_x)
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	psqrt_complex (const Packet &a)
void	pstore (Scalar *to, const Packet &from)
void	pstore1 (typename unpacket_traits< Packet >::type *to, const typename unpacket_traits< Packet >::type &a)
void	pstore1< Packet16f > (float *to, const float &a)
void	pstore1< Packet16i > (int *to, const int &a)
void	pstore1< Packet2d > (double *to, const double &a)
void	pstore1< Packet4d > (double *to, const double &a)
void	pstore1< Packet4f > (float *to, const float &a)
void	pstore1< Packet8d > (double *to, const double &a)
void	pstore1< Packet8f > (float *to, const float &a)
void	pstore1< Packet8i > (int *to, const int &a)
void	pstore< bfloat16 > (bfloat16 *to, const Packet16bf &from)
void	pstore< bfloat16 > (bfloat16 *to, const Packet4bf &from)
void	pstore< bfloat16 > (bfloat16 *to, const Packet8bf &from)
void	pstore< bool > (bool *to, const Packet16b &from)
void	pstore< double > (double *to, const Packet2d &from)
void	pstore< double > (double *to, const Packet4d &from)
void	pstore< double > (double *to, const Packet8d &from)
void	pstore< Eigen::half > (Eigen::half *to, const Packet8h &from)
void	pstore< float > (float *to, const Packet16f &from)
void	pstore< float > (float *to, const Packet2f &from)
void	pstore< float > (float *to, const Packet4f &from)
void	pstore< float > (float *to, const Packet8f &from)
void	pstore< float > (float *to, const PacketXf &from)
void	pstore< half > (Eigen::half *to, const Packet16h &from)
void	pstore< half > (Eigen::half *to, const Packet32h &from)
void	pstore< int > (int *to, const Packet16i &from)
void	pstore< int > (int *to, const Packet4i &from)
void	pstore< int > (int *to, const Packet8i &from)
void	pstore< int16_t > (int16_t *to, const Packet4s &from)
void	pstore< int16_t > (int16_t *to, const Packet8s &from)
void	pstore< int32_t > (int32_t *to, const Packet2i &from)
void	pstore< int32_t > (int32_t *to, const Packet4i &from)
void	pstore< int64_t > (int64_t *to, const Packet2l &from)
void	pstore< int8_t > (int8_t *to, const Packet16c &from)
void	pstore< int8_t > (int8_t *to, const Packet4c &from)
void	pstore< int8_t > (int8_t *to, const Packet8c &from)
void	pstore< numext::int32_t > (numext::int32_t *to, const PacketXi &from)
void	pstore< short int > (short int *to, const Packet8s &from)
void	pstore< signed char > (signed char *to, const Packet16c &from)
void	pstore< std::complex< double > > (std::complex< double > *to, const Packet1cd &from)
void	pstore< std::complex< double > > (std::complex< double > *to, const Packet2cd &from)
void	pstore< std::complex< double > > (std::complex< double > *to, const Packet4cd &from)
void	pstore< std::complex< float > > (std::complex< float > *to, const Packet1cf &from)
void	pstore< std::complex< float > > (std::complex< float > *to, const Packet2cf &from)
void	pstore< std::complex< float > > (std::complex< float > *to, const Packet4cf &from)
void	pstore< std::complex< float > > (std::complex< float > *to, const Packet8cf &from)
void	pstore< uint16_t > (uint16_t *to, const Packet4us &from)
void	pstore< uint16_t > (uint16_t *to, const Packet8us &from)
void	pstore< uint32_t > (uint32_t *to, const Packet2ui &from)
void	pstore< uint32_t > (uint32_t *to, const Packet4ui &from)
void	pstore< uint32_t > (uint32_t *to, const Packet8ui &from)
void	pstore< uint64_t > (uint64_t *to, const Packet2ul &from)
void	pstore< uint8_t > (uint8_t *to, const Packet16uc &from)
void	pstore< uint8_t > (uint8_t *to, const Packet4uc &from)
void	pstore< uint8_t > (uint8_t *to, const Packet8uc &from)
void	pstore< unsigned char > (unsigned char *to, const Packet16uc &from)
void	pstore< unsigned short int > (unsigned short int *to, const Packet8us &from)
void	pstore_common (__UNPACK_TYPE__(Packet) *to, const Packet &from)
void	pstore_partial (Scalar *to, const Packet &from, const Index n, const Index offset=0)
EIGEN_ALWAYS_INLINE void	pstore_partial< bfloat16 > (bfloat16 *to, const Packet8bf &from, const Index n, const Index offset)
EIGEN_ALWAYS_INLINE void	pstore_partial< float > (float *to, const Packet4f &from, const Index n, const Index offset)
EIGEN_ALWAYS_INLINE void	pstore_partial< int > (int *to, const Packet4i &from, const Index n, const Index offset)
EIGEN_ALWAYS_INLINE void	pstore_partial< short int > (short int *to, const Packet8s &from, const Index n, const Index offset)
EIGEN_ALWAYS_INLINE void	pstore_partial< signed char > (signed char *to, const Packet16c &from, const Index n, const Index offset)
EIGEN_ALWAYS_INLINE void	pstore_partial< std::complex< float > > (std::complex< float > *to, const Packet2cf &from, const Index n, const Index offset)
EIGEN_ALWAYS_INLINE void	pstore_partial< unsigned char > (unsigned char *to, const Packet16uc &from, const Index n, const Index offset)
EIGEN_ALWAYS_INLINE void	pstore_partial< unsigned short int > (unsigned short int *to, const Packet8us &from, const Index n, const Index offset)
EIGEN_ALWAYS_INLINE void	pstore_partial_common (__UNPACK_TYPE__(Packet) *to, const Packet &from, const Index n, const Index offset)
void	pstorel (double *to, const Packet2d &from)
void	pstorel (float *to, const Packet4f &from)
void	pstorel (Scalar *to, const Packet &from)
void	pstores (double *to, const Packet2d &from)
void	pstores (float *to, const Packet4f &from)
void	pstores (Scalar *to, const Packet &from)
EIGEN_ALWAYS_INLINE void	pstoret (Scalar *to, const Packet &from)
EIGEN_ALWAYS_INLINE void	pstoret_partial (Scalar *to, const Packet &from, const Index n, const Index offset=0)
void	pstoreu (Scalar *to, const Packet &from)
std::enable_if_t< unpacket_traits< Packet >::masked_store_available, void >	pstoreu (Scalar *to, const Packet &from, typename unpacket_traits< Packet >::mask_t umask)
void	pstoreu< bfloat16 > (bfloat16 *to, const Packet16bf &from)
void	pstoreu< bfloat16 > (bfloat16 *to, const Packet4bf &from)
void	pstoreu< bfloat16 > (bfloat16 *to, const Packet8bf &from)
void	pstoreu< bool > (bool *to, const Packet16b &from)
void	pstoreu< double > (double *to, const Packet2d &from)
void	pstoreu< double > (double *to, const Packet4d &from)
void	pstoreu< double > (double *to, const Packet8d &from)
void	pstoreu< double > (double *to, const Packet8d &from, uint8_t umask)
void	pstoreu< Eigen::half > (Eigen::half *to, const Packet8h &from)
void	pstoreu< float > (float *to, const Packet16f &from)
void	pstoreu< float > (float *to, const Packet16f &from, uint16_t umask)
void	pstoreu< float > (float *to, const Packet2f &from)
void	pstoreu< float > (float *to, const Packet4f &from)
void	pstoreu< float > (float *to, const Packet8f &from)
void	pstoreu< float > (float *to, const Packet8f &from, uint8_t umask)
void	pstoreu< float > (float *to, const PacketXf &from)
void	pstoreu< half > (Eigen::half *to, const Packet16h &from)
void	pstoreu< half > (Eigen::half *to, const Packet32h &from)
void	pstoreu< int > (int *to, const Packet16i &from)
void	pstoreu< int > (int *to, const Packet4i &from)
void	pstoreu< int > (int *to, const Packet8i &from)
void	pstoreu< int16_t > (int16_t *to, const Packet4s &from)
void	pstoreu< int16_t > (int16_t *to, const Packet8s &from)
void	pstoreu< int32_t > (int32_t *to, const Packet2i &from)
void	pstoreu< int32_t > (int32_t *to, const Packet4i &from)
void	pstoreu< int64_t > (int64_t *to, const Packet2l &from)
void	pstoreu< int8_t > (int8_t *to, const Packet16c &from)
void	pstoreu< int8_t > (int8_t *to, const Packet4c &from)
void	pstoreu< int8_t > (int8_t *to, const Packet8c &from)
void	pstoreu< numext::int32_t > (numext::int32_t *to, const PacketXi &from)
void	pstoreu< short int > (short int *to, const Packet8s &from)
void	pstoreu< signed char > (signed char *to, const Packet16c &from)
void	pstoreu< std::complex< double > > (std::complex< double > *to, const Packet1cd &from)
void	pstoreu< std::complex< double > > (std::complex< double > *to, const Packet2cd &from)
void	pstoreu< std::complex< double > > (std::complex< double > *to, const Packet4cd &from)
void	pstoreu< std::complex< float > > (std::complex< float > *to, const Packet1cf &from)
void	pstoreu< std::complex< float > > (std::complex< float > *to, const Packet2cf &from)
void	pstoreu< std::complex< float > > (std::complex< float > *to, const Packet4cf &from)
void	pstoreu< std::complex< float > > (std::complex< float > *to, const Packet8cf &from)
void	pstoreu< uint16_t > (uint16_t *to, const Packet4us &from)
void	pstoreu< uint16_t > (uint16_t *to, const Packet8us &from)
void	pstoreu< uint32_t > (uint32_t *to, const Packet2ui &from)
void	pstoreu< uint32_t > (uint32_t *to, const Packet4ui &from)
void	pstoreu< uint32_t > (uint32_t *to, const Packet8ui &from)
void	pstoreu< uint64_t > (uint64_t *to, const Packet2ul &from)
void	pstoreu< uint8_t > (uint8_t *to, const Packet16uc &from)
void	pstoreu< uint8_t > (uint8_t *to, const Packet4uc &from)
void	pstoreu< uint8_t > (uint8_t *to, const Packet8uc &from)
void	pstoreu< unsigned char > (unsigned char *to, const Packet16uc &from)
void	pstoreu< unsigned short int > (unsigned short int *to, const Packet8us &from)
void	pstoreu_common (__UNPACK_TYPE__(Packet) *to, const Packet &from)
void	pstoreu_partial (Scalar *to, const Packet &from, const Index n, const Index offset=0)
EIGEN_ALWAYS_INLINE void	pstoreu_partial< bfloat16 > (bfloat16 *to, const Packet8bf &from, const Index n, const Index offset)
EIGEN_ALWAYS_INLINE void	pstoreu_partial< float > (float *to, const Packet4f &from, const Index n, const Index offset)
EIGEN_ALWAYS_INLINE void	pstoreu_partial< int > (int *to, const Packet4i &from, const Index n, const Index offset)
EIGEN_ALWAYS_INLINE void	pstoreu_partial< short int > (short int *to, const Packet8s &from, const Index n, const Index offset)
EIGEN_ALWAYS_INLINE void	pstoreu_partial< signed char > (signed char *to, const Packet16c &from, const Index n, const Index offset)
EIGEN_ALWAYS_INLINE void	pstoreu_partial< std::complex< float > > (std::complex< float > *to, const Packet2cf &from, const Index n, const Index offset)
EIGEN_ALWAYS_INLINE void	pstoreu_partial< unsigned char > (unsigned char *to, const Packet16uc &from, const Index n, const Index offset)
EIGEN_ALWAYS_INLINE void	pstoreu_partial< unsigned short int > (unsigned short int *to, const Packet8us &from, const Index n, const Index offset)
EIGEN_ALWAYS_INLINE void	pstoreu_partial_common (__UNPACK_TYPE__(Packet) *to, const Packet &from, const Index n, const Index offset)
Packet	psub (const Packet &a, const Packet &b)
Packet16b	psub< Packet16b > (const Packet16b &a, const Packet16b &b)
Packet16bf	psub< Packet16bf > (const Packet16bf &a, const Packet16bf &b)
Packet16c	psub< Packet16c > (const Packet16c &a, const Packet16c &b)
Packet16f	psub< Packet16f > (const Packet16f &a, const Packet16f &b)
Packet16h	psub< Packet16h > (const Packet16h &a, const Packet16h &b)
Packet16i	psub< Packet16i > (const Packet16i &a, const Packet16i &b)
Packet16uc	psub< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
Packet1cd	psub< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
Packet1cf	psub< Packet1cf > (const Packet1cf &a, const Packet1cf &b)
Packet2cd	psub< Packet2cd > (const Packet2cd &a, const Packet2cd &b)
Packet2cf	psub< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
Packet2d	psub< Packet2d > (const Packet2d &a, const Packet2d &b)
Packet2f	psub< Packet2f > (const Packet2f &a, const Packet2f &b)
Packet2i	psub< Packet2i > (const Packet2i &a, const Packet2i &b)
Packet2l	psub< Packet2l > (const Packet2l &a, const Packet2l &b)
Packet2ui	psub< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
Packet2ul	psub< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
Packet32h	psub< Packet32h > (const Packet32h &a, const Packet32h &b)
Packet4bf	psub< Packet4bf > (const Packet4bf &a, const Packet4bf &b)
Packet4c	psub< Packet4c > (const Packet4c &a, const Packet4c &b)
Packet4cd	psub< Packet4cd > (const Packet4cd &a, const Packet4cd &b)
Packet4cf	psub< Packet4cf > (const Packet4cf &a, const Packet4cf &b)
Packet4d	psub< Packet4d > (const Packet4d &a, const Packet4d &b)
Packet4f	psub< Packet4f > (const Packet4f &a, const Packet4f &b)
Packet4i	psub< Packet4i > (const Packet4i &a, const Packet4i &b)
Packet4s	psub< Packet4s > (const Packet4s &a, const Packet4s &b)
Packet4uc	psub< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
Packet4ui	psub< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
Packet4us	psub< Packet4us > (const Packet4us &a, const Packet4us &b)
Packet8bf	psub< Packet8bf > (const Packet8bf &a, const Packet8bf &b)
Packet8c	psub< Packet8c > (const Packet8c &a, const Packet8c &b)
Packet8cf	psub< Packet8cf > (const Packet8cf &a, const Packet8cf &b)
Packet8d	psub< Packet8d > (const Packet8d &a, const Packet8d &b)
Packet8f	psub< Packet8f > (const Packet8f &a, const Packet8f &b)
Packet8h	psub< Packet8h > (const Packet8h &a, const Packet8h &b)
Packet8i	psub< Packet8i > (const Packet8i &a, const Packet8i &b)
Packet8s	psub< Packet8s > (const Packet8s &a, const Packet8s &b)
Packet8uc	psub< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
Packet8ui	psub< Packet8ui > (const Packet8ui &a, const Packet8ui &b)
Packet8us	psub< Packet8us > (const Packet8us &a, const Packet8us &b)
PacketXf	psub< PacketXf > (const PacketXf &a, const PacketXf &b)
PacketXi	psub< PacketXi > (const PacketXi &a, const PacketXi &b)
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	ptan (const Packet &a)
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	ptanh (const Packet &a)
Packet16h	ptanh< Packet16h > (const Packet16h &)
Packet32h	ptanh< Packet32h > (const Packet32h &a)
EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet4f	ptanh< Packet4f > (const Packet4f &_x)
PacketXf	ptanh< PacketXf > (const PacketXf &x)
void	ptranpose_common (PacketBlock< T, 4 > &kernel)
void	ptranspose (PacketBlock< Packet, 1 > &)
void	ptranspose (PacketBlock< Packet16b, 16 > &kernel)
void	ptranspose (PacketBlock< Packet16b, 4 > &kernel)
void	ptranspose (PacketBlock< Packet16bf, 16 > &kernel)
void	ptranspose (PacketBlock< Packet16bf, 4 > &kernel)
void	ptranspose (PacketBlock< Packet16c, 16 > &kernel)
void	ptranspose (PacketBlock< Packet16c, 4 > &kernel)
void	ptranspose (PacketBlock< Packet16c, 8 > &kernel)
void	ptranspose (PacketBlock< Packet16f, 16 > &kernel)
void	ptranspose (PacketBlock< Packet16f, 4 > &kernel)
void	ptranspose (PacketBlock< Packet16f, 8 > &kernel)
void	ptranspose (PacketBlock< Packet16h, 16 > &kernel)
void	ptranspose (PacketBlock< Packet16h, 4 > &kernel)
void	ptranspose (PacketBlock< Packet16h, 8 > &kernel)
void	ptranspose (PacketBlock< Packet16i, 16 > &kernel)
void	ptranspose (PacketBlock< Packet16i, 4 > &kernel)
void	ptranspose (PacketBlock< Packet16uc, 16 > &kernel)
void	ptranspose (PacketBlock< Packet16uc, 4 > &kernel)
void	ptranspose (PacketBlock< Packet16uc, 8 > &kernel)
void	ptranspose (PacketBlock< Packet1cd, 2 > &kernel)
void	ptranspose (PacketBlock< Packet1cf, 1 > &)
void	ptranspose (PacketBlock< Packet2cd, 2 > &kernel)
void	ptranspose (PacketBlock< Packet2cf, 2 > &kernel)
void	ptranspose (PacketBlock< Packet2d, 2 > &kernel)
void	ptranspose (PacketBlock< Packet2f, 2 > &kernel)
void	ptranspose (PacketBlock< Packet2i, 2 > &kernel)
void	ptranspose (PacketBlock< Packet2l, 2 > &kernel)
void	ptranspose (PacketBlock< Packet2ui, 2 > &kernel)
void	ptranspose (PacketBlock< Packet2ul, 2 > &kernel)
void	ptranspose (PacketBlock< Packet32h, 32 > &a)
void	ptranspose (PacketBlock< Packet32h, 4 > &a)
void	ptranspose (PacketBlock< Packet4bf, 4 > &kernel)
void	ptranspose (PacketBlock< Packet4c, 4 > &kernel)
void	ptranspose (PacketBlock< Packet4cd, 4 > &kernel)
void	ptranspose (PacketBlock< Packet4cf, 4 > &kernel)
void	ptranspose (PacketBlock< Packet4d, 4 > &kernel)
void	ptranspose (PacketBlock< Packet4f, 4 > &kernel)
void	ptranspose (PacketBlock< Packet4i, 4 > &kernel)
void	ptranspose (PacketBlock< Packet4s, 4 > &kernel)
void	ptranspose (PacketBlock< Packet4uc, 4 > &kernel)
void	ptranspose (PacketBlock< Packet4ui, 4 > &kernel)
void	ptranspose (PacketBlock< Packet4us, 4 > &kernel)
void	ptranspose (PacketBlock< Packet8bf, 4 > &kernel)
void	ptranspose (PacketBlock< Packet8bf, 8 > &kernel)
void	ptranspose (PacketBlock< Packet8c, 4 > &kernel)
void	ptranspose (PacketBlock< Packet8c, 8 > &kernel)
void	ptranspose (PacketBlock< Packet8cf, 4 > &kernel)
void	ptranspose (PacketBlock< Packet8cf, 8 > &kernel)
void	ptranspose (PacketBlock< Packet8d, 4 > &kernel)
void	ptranspose (PacketBlock< Packet8d, 8 > &kernel)
void	ptranspose (PacketBlock< Packet8f, 4 > &kernel)
void	ptranspose (PacketBlock< Packet8f, 8 > &kernel)
void	ptranspose (PacketBlock< Packet8h, 4 > &kernel)
void	ptranspose (PacketBlock< Packet8h, 8 > &kernel)
void	ptranspose (PacketBlock< Packet8i, 4 > &kernel)
void	ptranspose (PacketBlock< Packet8i, 8 > &kernel)
void	ptranspose (PacketBlock< Packet8s, 4 > &kernel)
void	ptranspose (PacketBlock< Packet8s, 8 > &kernel)
void	ptranspose (PacketBlock< Packet8uc, 4 > &kernel)
void	ptranspose (PacketBlock< Packet8uc, 8 > &kernel)
void	ptranspose (PacketBlock< Packet8ui, 4 > &kernel)
void	ptranspose (PacketBlock< Packet8ui, 8 > &kernel)
void	ptranspose (PacketBlock< Packet8us, 4 > &kernel)
void	ptranspose (PacketBlock< Packet8us, 8 > &kernel)
void	ptranspose (PacketBlock< PacketXf, N > &kernel)
void	ptranspose (PacketBlock< PacketXi, N > &kernel)
Packet	ptrue (const Packet &a)
Packet16bf	ptrue (const Packet16bf &a)
Packet16h	ptrue (const Packet16h &a)
Packet8bf	ptrue (const Packet8bf &a)
Packet8h	ptrue (const Packet8h &a)
Packet16b	ptrue< Packet16b > (const Packet16b &a)
Packet16f	ptrue< Packet16f > (const Packet16f &a)
Packet16i	ptrue< Packet16i > (const Packet16i &)
Packet1cd	ptrue< Packet1cd > (const Packet1cd &a)
Packet2cd	ptrue< Packet2cd > (const Packet2cd &a)
Packet2cf	ptrue< Packet2cf > (const Packet2cf &a)
Packet2d	ptrue< Packet2d > (const Packet2d &a)
Packet4cd	ptrue< Packet4cd > (const Packet4cd &a)
Packet4cf	ptrue< Packet4cf > (const Packet4cf &a)
Packet4d	ptrue< Packet4d > (const Packet4d &a)
Packet4f	ptrue< Packet4f > (const Packet4f &a)
Packet4i	ptrue< Packet4i > (const Packet4i &a)
Packet8cf	ptrue< Packet8cf > (const Packet8cf &a)
Packet8d	ptrue< Packet8d > (const Packet8d &a)
Packet8f	ptrue< Packet8f > (const Packet8f &a)
Packet8i	ptrue< Packet8i > (const Packet8i &a)
PacketXf	ptrue< PacketXf > (const PacketXf &)
PacketXi	ptrue< PacketXi > (const PacketXi &)
void	punpackp (Packet4f *vecs)
template<typename Scalar >
void	putDenseElt (Scalar value, std::ofstream &out)
template<typename Scalar >
void	putDenseElt (std::complex< Scalar > value, std::ofstream &out)
template<typename Scalar >
void	putMarketHeader (std::string &header, int sym)
template<typename Scalar , typename StorageIndex >
void	PutMatrixElt (Scalar value, StorageIndex row, StorageIndex col, std::ofstream &out)
template<typename Scalar , typename StorageIndex >
void	PutMatrixElt (std::complex< Scalar > value, StorageIndex row, StorageIndex col, std::ofstream &out)
Packet	pxor (const Packet &a, const Packet &b)
Packet16bf	pxor (const Packet16bf &a, const Packet16bf &b)
Packet16h	pxor (const Packet16h &a, const Packet16h &b)
Packet32h	pxor (const Packet32h &a, const Packet32h &b)
Packet4bf	pxor (const Packet4bf &a, const Packet4bf &b)
Packet8bf	pxor (const Packet8bf &a, const Packet8bf &b)
Packet8h	pxor (const Packet8h &a, const Packet8h &b)
Packet16b	pxor< Packet16b > (const Packet16b &a, const Packet16b &b)
Packet16c	pxor< Packet16c > (const Packet16c &a, const Packet16c &b)
Packet16f	pxor< Packet16f > (const Packet16f &a, const Packet16f &b)
Packet16i	pxor< Packet16i > (const Packet16i &a, const Packet16i &b)
Packet16uc	pxor< Packet16uc > (const Packet16uc &a, const Packet16uc &b)
Packet1cd	pxor< Packet1cd > (const Packet1cd &a, const Packet1cd &b)
Packet1cf	pxor< Packet1cf > (const Packet1cf &a, const Packet1cf &b)
Packet2cd	pxor< Packet2cd > (const Packet2cd &a, const Packet2cd &b)
Packet2cf	pxor< Packet2cf > (const Packet2cf &a, const Packet2cf &b)
Packet2d	pxor< Packet2d > (const Packet2d &a, const Packet2d &b)
Packet2f	pxor< Packet2f > (const Packet2f &a, const Packet2f &b)
Packet2i	pxor< Packet2i > (const Packet2i &a, const Packet2i &b)
Packet2l	pxor< Packet2l > (const Packet2l &a, const Packet2l &b)
Packet2ui	pxor< Packet2ui > (const Packet2ui &a, const Packet2ui &b)
Packet2ul	pxor< Packet2ul > (const Packet2ul &a, const Packet2ul &b)
Packet4c	pxor< Packet4c > (const Packet4c &a, const Packet4c &b)
Packet4cd	pxor< Packet4cd > (const Packet4cd &a, const Packet4cd &b)
Packet4cf	pxor< Packet4cf > (const Packet4cf &a, const Packet4cf &b)
Packet4d	pxor< Packet4d > (const Packet4d &a, const Packet4d &b)
Packet4f	pxor< Packet4f > (const Packet4f &a, const Packet4f &b)
Packet4i	pxor< Packet4i > (const Packet4i &a, const Packet4i &b)
Packet4s	pxor< Packet4s > (const Packet4s &a, const Packet4s &b)
Packet4uc	pxor< Packet4uc > (const Packet4uc &a, const Packet4uc &b)
Packet4ui	pxor< Packet4ui > (const Packet4ui &a, const Packet4ui &b)
Packet4us	pxor< Packet4us > (const Packet4us &a, const Packet4us &b)
Packet8bf	pxor< Packet8bf > (const Packet8bf &a, const Packet8bf &b)
Packet8c	pxor< Packet8c > (const Packet8c &a, const Packet8c &b)
Packet8cf	pxor< Packet8cf > (const Packet8cf &a, const Packet8cf &b)
Packet8d	pxor< Packet8d > (const Packet8d &a, const Packet8d &b)
Packet8f	pxor< Packet8f > (const Packet8f &a, const Packet8f &b)
Packet8i	pxor< Packet8i > (const Packet8i &a, const Packet8i &b)
Packet8s	pxor< Packet8s > (const Packet8s &a, const Packet8s &b)
Packet8uc	pxor< Packet8uc > (const Packet8uc &a, const Packet8uc &b)
Packet8ui	pxor< Packet8ui > (const Packet8ui &a, const Packet8ui &b)
Packet8us	pxor< Packet8us > (const Packet8us &a, const Packet8us &b)
PacketXf	pxor< PacketXf > (const PacketXf &a, const PacketXf &b)
PacketXi	pxor< PacketXi > (const PacketXi &a, const PacketXi &b)
Packet	pzero (const Packet &a)
Packet16f	pzero (const Packet16f &)
Packet16i	pzero (const Packet16i &)
Packet2d	pzero (const Packet2d &)
Packet4d	pzero (const Packet4d &)
Packet4f	pzero (const Packet4f &)
Packet4i	pzero (const Packet4i &)
Packet4ui	pzero (const Packet4ui &)
Packet8d	pzero (const Packet8d &)
Packet8f	pzero (const Packet8f &)
Packet8i	pzero (const Packet8i &)
Packet8ui	pzero (const Packet8ui &)
PacketXi	pzero< PacketXi > (const PacketXi &)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet	pzeta (const Packet &x, const Packet &q)
template<typename Scalar >
void	qrsolv (Matrix< Scalar, Dynamic, Dynamic > &s, const VectorXi &ipvt, const Matrix< Scalar, Dynamic, 1 > &diag, const Matrix< Scalar, Dynamic, 1 > &qtb, Matrix< Scalar, Dynamic, 1 > &x, Matrix< Scalar, Dynamic, 1 > &sdiag)
void	queryCacheSizes (int &l1, int &l2, int &l3)
int	queryL1CacheSize ()
int	queryTopLevelCacheSize ()
Index	QuickSplit (VectorV &row, VectorI &ind, Index ncut)
template<typename Scalar >
void	r1mpyq (DenseIndex m, DenseIndex n, Scalar *a, const std::vector< JacobiRotation< Scalar > > &v_givens, const std::vector< JacobiRotation< Scalar > > &w_givens)
template<typename Scalar >
void	r1updt (Matrix< Scalar, Dynamic, Dynamic > &s, const Matrix< Scalar, Dynamic, 1 > &u, std::vector< JacobiRotation< Scalar > > &v_givens, std::vector< JacobiRotation< Scalar > > &w_givens, Matrix< Scalar, Dynamic, 1 > &v, Matrix< Scalar, Dynamic, 1 > &w, bool *sing)
template<>
mpfr::mpreal	random< mpfr::mpreal > ()
template<>
mpfr::mpreal	random< mpfr::mpreal > (const mpfr::mpreal &a, const mpfr::mpreal &b)
template<typename T >
T	RandomToTypeNormal (uint64_t *state, uint64_t stream)
template<>
std::complex< double >	RandomToTypeNormal< std::complex< double > > (uint64_t *state, uint64_t stream)
template<>
std::complex< float >	RandomToTypeNormal< std::complex< float > > (uint64_t *state, uint64_t stream)
template<typename T >
T	RandomToTypeUniform (uint64_t *state, uint64_t stream)
template<>
double	RandomToTypeUniform< double > (uint64_t *state, uint64_t stream)
template<>
Eigen::bfloat16	RandomToTypeUniform< Eigen::bfloat16 > (uint64_t *state, uint64_t stream)
template<>
Eigen::half	RandomToTypeUniform< Eigen::half > (uint64_t *state, uint64_t stream)
template<>
float	RandomToTypeUniform< float > (uint64_t *state, uint64_t stream)
template<>
std::complex< double >	RandomToTypeUniform< std::complex< double > > (uint64_t *state, uint64_t stream)
template<>
std::complex< float >	RandomToTypeUniform< std::complex< float > > (uint64_t *state, uint64_t stream)
Decomposition::RealScalar	rcond_estimate_helper (typename Decomposition::RealScalar matrix_norm, const Decomposition &dec)
Decomposition::RealScalar	rcond_invmatrix_L1_norm_estimate (const Decomposition &dec)
void	real_2x2_jacobi_svd (const MatrixType &matrix, Index p, Index q, JacobiRotation< RealScalar > *j_left, JacobiRotation< RealScalar > *j_right)
template<typename Self >
void	ReducePacket (Self &self, Index offset, typename Self::CoeffReturnType *data)
template<typename Self >
void	ReduceScalar (Self &self, Index offset, typename Self::CoeffReturnType *data)
constexpr array< t, n >	repeat (t v)
void	resize_if_allowed (DstXprType &dst, const SrcXprType &src, const Functor &)
void	resize_if_allowed (DstXprType &dst, const SrcXprType &src, const internal::assign_op< T1, T2 > &)
const T *	return_ptr ()
make_unsigned< IndexType >::type	returnUnsignedIndexValue (const IndexType &idx)
template<typename Scalar >
void	rwupdt (Matrix< Scalar, Dynamic, Dynamic > &r, const Matrix< Scalar, Dynamic, 1 > &w, Matrix< Scalar, Dynamic, 1 > &b, Scalar alpha)
void	set_from_triplets (const InputIterator &begin, const InputIterator &end, SparseMatrixType &mat, DupFunctor dup_func)
void	set_from_triplets_sorted (const InputIterator &begin, const InputIterator &end, SparseMatrixType &mat, DupFunctor dup_func)
constexpr bool	should_svd_compute_full_u (int options)
constexpr bool	should_svd_compute_full_v (int options)
constexpr bool	should_svd_compute_thin_u (int options)
constexpr bool	should_svd_compute_thin_v (int options)
Packet4f	shuffle1 (const Packet4f &m, int mask)
Packet4f	shuffle2 (const Packet4f &m, const Packet4f &n, int mask)
Packet4f	shuffle2< true > (const Packet4f &m, const Packet4f &n, int mask)
constexpr int	size_at_compile_time (int rows, int cols)
template<typename Lhs , typename Rhs , typename Dest >
EIGEN_DONT_INLINE void	skyline_col_major_time_dense_product (const Lhs &lhs, const Rhs &rhs, Dest &dst)
template<typename Lhs , typename Rhs , typename Dest >
EIGEN_DONT_INLINE void	skyline_row_major_time_dense_product (const Lhs &lhs, const Rhs &rhs, Dest &dst)
void	smart_copy (const T *start, const T *end, T *target)
void	smart_memmove (const T *start, const T *end, T *target)
T *	smart_move (T *start, T *end, T *target)
std::enable_if_t< Rhs::ColsAtCompileTime!=1 &&Dest::ColsAtCompileTime!=1 >	solve_sparse_through_dense_panels (const Decomposition &dec, const Rhs &rhs, Dest &dest)
template<typename VectorType , typename IndexType >
void	sortWithPermutation (VectorType &vec, IndexType &perm, typename IndexType::Scalar &ncut)
	Computes a permutation vector to have a sorted sequence. More...
void	sparse_selfadjoint_time_dense_product (const SparseLhsType &lhs, const DenseRhsType &rhs, DenseResType &res, const AlphaType &alpha)
static void	sparse_sparse_product_with_pruning_impl (const Lhs &lhs, const Rhs &rhs, ResultType &res, const typename ResultType::RealScalar &tolerance)
static void	sparse_sparse_to_dense_product_impl (const Lhs &lhs, const Rhs &rhs, ResultType &res)
void	sparse_time_dense_product (const SparseLhsType &lhs, const DenseRhsType &rhs, DenseResType &res, const AlphaType &alpha)
MatrixType::RealScalar	stable_norm_impl (const MatrixType &mat, std::enable_if_t<!MatrixType::IsVectorAtCompileTime > *=0)
VectorType::RealScalar	stable_norm_impl (const VectorType &vec, std::enable_if_t< VectorType::IsVectorAtCompileTime > *=0)
void	stable_norm_impl_inner_step (const VectorType &vec, RealScalar &ssq, RealScalar &scale, RealScalar &invScale)
void	stable_norm_kernel (const ExpressionType &bl, Scalar &ssq, Scalar &scale, Scalar &invScale)
template<typename Scalar >
Scalar	stem_function_cos (Scalar x, int n)
	Cosine (and its derivatives). More...
template<typename Scalar >
Scalar	stem_function_cosh (Scalar x, int n)
	Hyperbolic cosine (and its derivatives). More...
template<typename Scalar >
Scalar	stem_function_exp (Scalar x, int)
	The exponential function (and its derivatives). More...
template<typename Scalar >
Scalar	stem_function_sin (Scalar x, int n)
	Sine (and its derivatives). More...
template<typename Scalar >
Scalar	stem_function_sinh (Scalar x, int n)
	Hyperbolic sine (and its derivatives). More...
EIGEN_ALWAYS_INLINE void	storeAccumulator (Index i, const DataMapper &data, const Packet &alpha, const Packet &pMask, __vector_quad *acc)
EIGEN_ALWAYS_INLINE void	storeBF16fromResult (bfloat16 *dst, Packet8bf data, Index resInc, Index extra=0)
EIGEN_ALWAYS_INLINE void	storeBlock (Scalar *to, PacketBlock< Packet, N > &block)
EIGEN_ALWAYS_INLINE void	storeComplexAccumulator (Index i, const DataMapper &data, const Packet &alphaReal, const Packet &alphaImag, const Packet &pMask, __vector_quad *accReal, __vector_quad *accImag)
EIGEN_ALWAYS_INLINE void	storeConvertBlockBF16 (float *to, PacketBlock< Packet8bf,(N+7)/8 > &block, Index extra)
EIGEN_ALWAYS_INLINE void	storeConvertTwoBF16 (float *to, PacketBlock< Packet8bf,(N+7)/8 > &block, Index extra=0)
EIGEN_ALWAYS_INLINE void	storeF32 (float *&result, Packet4f result_block, Index rows, Index extra_rows)
EIGEN_ALWAYS_INLINE void	storeResults (Packet4f(&acc)[4], Index rows, const Packet4f pAlpha, float *result, Index extra_cols, Index extra_rows)
template<int Layout, typename IndexType , int NumDims>
EIGEN_ALWAYS_INLINE DSizes< IndexType, NumDims >	strides (const DSizes< IndexType, NumDims > &dimensions)
template<int Layout, typename IndexType , size_t NumDims>
EIGEN_ALWAYS_INLINE DSizes< IndexType, NumDims >	strides (const Eigen::array< IndexType, NumDims > &dimensions)
template<int Layout, std::ptrdiff_t... Indices>
DSizes< std::ptrdiff_t, sizeof...(Indices)>	strides (const Sizes< Indices... > &sizes)
EIGEN_ALWAYS_INLINE bool	supportsMMA ()
void	swap (scoped_array< T > &a, scoped_array< T > &b)
void	symm_pack_complex_lhs_helper (std::complex< Scalar > *blockA, const std::complex< Scalar > *_lhs, Index lhsStride, Index cols, Index rows)
void	symm_pack_complex_rhs_helper (std::complex< Scalar > *blockB, const std::complex< Scalar > *_rhs, Index rhsStride, Index rows, Index cols, Index k2)
void	symm_pack_lhs_helper (Scalar *blockA, const Scalar *_lhs, Index lhsStride, Index cols, Index rows)
void	symm_pack_rhs_helper (Scalar *blockB, const Scalar *_rhs, Index rhsStride, Index rows, Index cols, Index k2)
template<typename Index , std::size_t N, int... ii, int... jj>
constexpr static std::array< Index, N >	tensor_static_symgroup_index_permute (std::array< Index, N > idx, internal::numeric_list< int, ii... >, internal::numeric_list< int, jj... >)
template<typename Index , int... ii>
static std::vector< Index >	tensor_static_symgroup_index_permute (std::vector< Index > idx, internal::numeric_list< int, ii... >)
void	throw_std_bad_alloc ()
static const MatrixBase< OtherDerived > &	toRotationMatrix (const MatrixBase< OtherDerived > &mat)
static Matrix< Scalar, Dim, Dim >	toRotationMatrix (const RotationBase< OtherDerived, Dim > &r)
static Matrix< Scalar, 2, 2 >	toRotationMatrix (const Scalar &s)
EIGEN_ALWAYS_INLINE void	tranposeResults (Packet4f(&acc)[num_acc][4])
EIGEN_ALWAYS_INLINE void	transStoreC (PacketBlock< vec, EIGEN_ARCH_DEFAULT_NUMBER_OF_REGISTERS > &zmm, Scalar *C_arr, int64_t LDC, int64_t remM_=0, int64_t remN_=0)
void	treePostorder (typename IndexVector::Scalar n, IndexVector &parent, IndexVector &post)
static void	tridiagonal_qr_step (RealScalar *diag, RealScalar *subdiag, Index start, Index end, Scalar *matrixQ, Index n)
void	tridiagonalization_inplace (MatrixType &mat, DiagonalType &diag, SubDiagonalType &subdiag, CoeffVectorType &hcoeffs, WorkSpaceType &workspace, bool extractQ)
void	tridiagonalization_inplace (MatrixType &matA, CoeffVectorType &hCoeffs)
float	trig_reduce_huge (float xf, Eigen::numext::int32_t *quadrant)
void	triSolve (Scalar *A_arr, Scalar *B_arr, int64_t M, int64_t numRHS, int64_t LDA, int64_t LDB)
EIGEN_ALWAYS_INLINE void	triSolveKernel (Scalar *A_arr, Scalar *B_arr, int64_t K, int64_t LDA, int64_t LDB)
void	triSolveKernelLxK (Scalar *A_arr, Scalar *B_arr, int64_t M, int64_t K, int64_t LDA, int64_t LDB)
void	twoprod (const Packet &x, const Packet &y, Packet &p_hi, Packet &p_lo)
void	twoprod (const Packet &x_hi, const Packet &x_lo, const Packet &y, Packet &p_hi, Packet &p_lo)
void	twoprod (const Packet &x_hi, const Packet &x_lo, const Packet &y_hi, const Packet &y_lo, Packet &p_hi, Packet &p_lo)
void	twosum (const Packet &x_hi, const Packet &x_lo, const Packet &y_hi, const Packet &y_lo, Packet &s_hi, Packet &s_lo)
template<typename T >
void	update_value (T &val, Index new_val)
template<typename T >
void	update_value (T &val, IndexPair< Index > new_val)
template<Index n>
void	update_value (type2index< n > &val, Index new_val)
template<Index f, Index s>
void	update_value (type2indexpair< f, s > &val, IndexPair< Index > new_val)
void	upperbidiagonalization_blocked_helper (MatrixType &A, typename MatrixType::RealScalar *diagonal, typename MatrixType::RealScalar *upper_diagonal, Index bs, Ref< Matrix< typename MatrixType::Scalar, Dynamic, Dynamic, traits< MatrixType >::Flags &RowMajorBit > > X, Ref< Matrix< typename MatrixType::Scalar, Dynamic, Dynamic, traits< MatrixType >::Flags &RowMajorBit > > Y)
void	upperbidiagonalization_inplace_blocked (MatrixType &A, BidiagType &bidiagonal, Index maxBlockSize=32, typename MatrixType::Scalar *=0)
void	upperbidiagonalization_inplace_unblocked (MatrixType &mat, typename MatrixType::RealScalar *diagonal, typename MatrixType::RealScalar *upper_diagonal, typename MatrixType::Scalar *tempData=0)
bool	useSpecificBlockingSizes (Index &k, Index &m, Index &n)
Packet2d	vec2d_unpackhi (const Packet2d &a, const Packet2d &b)
Packet2d	vec2d_unpacklo (const Packet2d &a, const Packet2d &b)
Packet4f	vec4f_movehl (const Packet4f &a, const Packet4f &b)
Packet4f	vec4f_movelh (const Packet4f &a, const Packet4f &b)
Packet4f	vec4f_swizzle1 (const Packet4f &a, int p, int q, int r, int s)
Packet4f	vec4f_swizzle2 (const Packet4f &a, const Packet4f &b, int p, int q, int r, int s)
Packet4f	vec4f_unpackhi (const Packet4f &a, const Packet4f &b)
Packet4f	vec4f_unpacklo (const Packet4f &a, const Packet4f &b)
Packet4f	vec_splat_packet4f (const Packet4f &from)
EIGEN_ALWAYS_INLINE void	vecColLoop (Index j, LhsMapper &lhs, RhsMapper &rhs, __vector_quad(&quad_acc)[num_acc])
EIGEN_ALWAYS_INLINE void	vecLoop (Index cols, const LhsMapper &lhs, RhsMapper &rhs, __vector_quad(&quad_acc)[num_acc], Index extra_cols)
void	veltkamp_splitting (const Packet &x, Packet &x_hi, Packet &x_lo)
EIGEN_ALWAYS_INLINE void	zeroAccumulators (__vector_quad(&quad_acc)[num_acc])
EIGEN_ALWAYS_INLINE void	zeroAccumulators (Packet4f(&acc)[num_acc][size])

Variables
constexpr decltype(reduce< product_op, Ts... >::run((*((Ts *) 0))...	arg_prod ))(Ts... ts)
constexpr decltype(reduce< sum_op, Ts... >::run((*((Ts *) 0))...	arg_sum ))(Ts... ts)
	cmp_EQ
	cmp_GE
	cmp_GT
	cmp_LE
	cmp_LT
	cmp_NEQ
	cmp_UNORD
	ComputationOptionsBits
const std::ptrdiff_t	defaultL1CacheSize
const std::ptrdiff_t	defaultL2CacheSize
const std::ptrdiff_t	defaultL3CacheSize
	emptyIdxLU
	GEBPPacketFull
	GEBPPacketHalf
	GEBPPacketQuarter
	GEMVPacketFull
	GEMVPacketHalf
	GEMVPacketQuarter
	Indefinite
constexpr bool	is_int_or_enum_v
	LLVL
	LSUB
	LUNoMarker
	LUSUP
static const Packet4i	mask4 [4]
static const float	matrix_function_separation
	Maximum distance allowed between eigenvalues to be considered "close". More...
	meta_floor_log2_bogus
	meta_floor_log2_move_down
	meta_floor_log2_move_up
	meta_floor_log2_terminate
	NegativeSemiDef
static Packet16c	p16c_COUNTDOWN
static Packet16uc	p16uc_COMPLEX32_REV
static Packet16uc	p16uc_COMPLEX32_REV
static Packet16uc	p16uc_COMPLEX32_REV2
static Packet16uc	p16uc_COUNTDOWN
static const Packet16uc	p16uc_DUPLICATE16_EVEN
static const Packet16uc	p16uc_DUPLICATE16_ODD
static Packet16uc	p16uc_DUPLICATE32_HI
static Packet16uc	p16uc_ELEMENT_VEC3
static Packet16uc	p16uc_FORWARD
static Packet16uc	p16uc_FORWARD
static const Packet16uc	p16uc_GETIMAG32
static const Packet16uc	p16uc_GETREAL32
static Packet16uc	p16uc_HALF64_0_16
static Packet16uc	p16uc_MERGE16_32_1
static Packet16uc	p16uc_MERGE16_32_2
static Packet16uc	p16uc_MERGE16_32_3
static Packet16uc	p16uc_MERGE16_32_4
static Packet16uc	p16uc_MERGE16_32_5
static Packet16uc	p16uc_MERGE16_32_6
static Packet16uc	p16uc_MERGE16_32_7
static Packet16uc	p16uc_MERGE16_32_8
static Packet16uc	p16uc_MERGEE16
static Packet16uc	p16uc_MERGEL16
static Packet16uc	p16uc_MERGEO16
static Packet16uc	p16uc_PSET32_WEVEN
static Packet16uc	p16uc_PSET32_WEVEN
static Packet16uc	p16uc_PSET32_WODD
static Packet16uc	p16uc_PSET32_WODD
static Packet16uc	p16uc_PSET64_HI
static Packet16uc	p16uc_PSET64_HI
static Packet16uc	p16uc_PSET64_LO
static Packet16uc	p16uc_PSET64_LO
static Packet16uc	p16uc_QUADRUPLICATE16_HI
static Packet16uc	p16uc_REVERSE16
static Packet16uc	p16uc_REVERSE32
static Packet16uc	p16uc_REVERSE32
static Packet16uc	p16uc_REVERSE64
static Packet16uc	p16uc_REVERSE8
static Packet16uc	p16uc_TRANSPOSE64_HI
static Packet16uc	p16uc_TRANSPOSE64_HI
static Packet16uc	p16uc_TRANSPOSE64_LO
static Packet16uc	p16uc_TRANSPOSE64_LO
static Packet2d	p2d_COUNTDOWN
static Packet2d	p2d_ONE
static Packet2d	p2d_ZERO_
static Packet2ul	p2ul_CONJ_XOR1
static Packet2ul	p2ul_CONJ_XOR2
static Packet4f	p4f_COUNTDOWN
static Packet4f	p4f_COUNTDOWN
static Packet4f	p4f_MZERO
static Packet4f	p4f_MZERO
static Packet4f	p4f_ONE
static Packet4i	p4i_COUNTDOWN
static Packet4i	p4i_COUNTDOWN
static Packet4ui	p4ui_CONJ_XOR
static Packet4ui	p4ui_CONJ_XOR
static Packet8s	p8s_COUNTDOWN
static Packet8us	p8us_COUNTDOWN
	PermPermProduct
	PositiveSemiDef
	PreconditionIfMoreColsThanRows
	PreconditionIfMoreRowsThanCols
	QRPreconditionerBits
	SDP_AsCwiseProduct
	SDP_AsScalarProduct
	SVA_Inner
	SVA_Outer
	SVA_RuntimeSwitch
	UCOL
	ULVL
	USUB
const Scalar &	y
	ZeroSign

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
ShardByRow
ShardByCol

Definition at line 19 of file TensorContractionBlocking.h.

     {
  ShardByRow = 0,
  ShardByCol = 1
};

anonymous enum

anonymous enum

Enumerator
Rhs
Lhs

Definition at line 19 of file TensorContractionMapper.h.

     {
  Rhs = 0,
  Lhs = 1
};

IgammaComputationMode

enum Eigen::internal::IgammaComputationMode

Enumerator
VALUE
DERIVATIVE
SAMPLE_DERIVATIVE

Definition at line 729 of file SpecialFunctionsImpl.h.

{ VALUE, DERIVATIVE, SAMPLE_DERIVATIVE };

TensorBlockKind

enum Eigen::internal::TensorBlockKind

Enumerator
kExpr
kView
kMaterializedInScratch
kMaterializedInOutput

Definition at line 591 of file TensorBlock.h.

                     {
  // Tensor block that is a lazy expression that must be assigned to a
  // destination using TensorBlockAssign.
  kExpr,
 
  // Tensor block that is a view into a memory buffer owned by an underlying
  // Tensor expression (e.g. it can be a view into a Tensor buffer).
  kView,
 
  // Tensor block that was materialized in a scratch memory buffer, allocated
  // with TensorBlockScratchAllocator. This block must be copied to a
  // destination, similar to a block of `kExpr` type.
  kMaterializedInScratch,
 
  // Tensor block that was materialized directly into the final output memory
  // buffer. For example if the left side of an assignment is a Tensor, we can
  // directly materialize the block in the destination memory.
  //
  // If strides in the output buffer do not match tensor block strides, the
  // Tensor expression will be invalid, and should not be used by
  // TensorBlockAssign or for constructing another block expression.
  kMaterializedInOutput
};

TensorBlockShapeType

enum Eigen::internal::TensorBlockShapeType

strong

Enumerator
kUniformAllDims
kSkewedInnerDims

Definition at line 75 of file TensorBlock.h.

{ kUniformAllDims, kSkewedInnerDims };

TiledEvaluation

enum Eigen::internal::TiledEvaluation

Enumerator
Off
On

Definition at line 144 of file TensorForwardDeclarations.h.

                     {
  Off = 0,    // tiled evaluation is not supported
  On = 1,     // still work in progress (see TensorBlock.h)
};

Function Documentation

all_indices_known_statically()

template<typename T >

static EIGEN_CONSTEXPR bool Eigen::internal::all_indices_known_statically ( )

static

Definition at line 622 of file TensorIndexList.h.

                                                                             {
  return all_indices_known_statically_impl<T>::run();
}

array_get() [1/11]

template<DenseIndex n, typename Index , std::size_t Rank>

const Index Eigen::internal::array_get

(

const DimensionList< Index, Rank > &

)

Definition at line 44 of file TensorDimensionList.h.

                                                                                                                {
  return n;
}

array_get() [2/11]

template<Index N, typename FirstType , typename... OtherTypes>

constexpr Index Eigen::internal::array_get ( const IndexList< FirstType, OtherTypes... > &  a )

constexpr

Definition at line 393 of file TensorIndexList.h.

                                                                                                                                                        {
  return IndexTupleExtractor<N, FirstType, OtherTypes...>::get_val(a);
}

array_get() [3/11]

template<int N, typename T , typename... O>

constexpr const IndexTupleExtractor<N, T, O...>::ValType& Eigen::internal::array_get ( const IndexTuple< T, O... > &  tuple )

constexpr

Definition at line 213 of file TensorIndexList.h.

                                                                                                                               {
  return IndexTupleExtractor<N, T, O...>::get_val(tuple);
}

array_get() [4/11]

template<std::ptrdiff_t n, typename std::ptrdiff_t... Indices>

std::ptrdiff_t Eigen::internal::array_get ( const Sizes< Indices... > &  )

inline

Definition at line 396 of file TensorDimensions.h.

                                                                                                                                                   {
  return get<n, internal::numeric_list<std::ptrdiff_t, Indices...> >::value;
}

array_get() [5/11]

template<std::ptrdiff_t n>

std::ptrdiff_t Eigen::internal::array_get ( const Sizes<> &  )

inline

Definition at line 399 of file TensorDimensions.h.

                                                                                                       {
  eigen_assert(false && "should never be called");
  return -1;
}

array_get() [6/11]

template<DenseIndex n, typename Index , std::size_t Rank>

const Index Eigen::internal::array_get

(

DimensionList< Index, Rank > &

)

Definition at line 41 of file TensorDimensionList.h.

                                                                                                          {
  return n;
}

array_get() [7/11]

template<Index N, typename FirstType , typename... OtherTypes>

constexpr Index Eigen::internal::array_get ( IndexList< FirstType, OtherTypes... > &  a )

constexpr

Definition at line 390 of file TensorIndexList.h.

                                                                                                                                                  {
  return IndexTupleExtractor<N, FirstType, OtherTypes...>::get_val(a);
}

array_get() [8/11]

template<int N, typename T , typename... O>

constexpr IndexTupleExtractor<N, T, O...>::ValType& Eigen::internal::array_get ( IndexTuple< T, O... > &  tuple )

constexpr

Definition at line 209 of file TensorIndexList.h.

                                                                                                                   {
  return IndexTupleExtractor<N, T, O...>::get_val(tuple);
}

array_get() [9/11]

template<std::size_t I_, class T >

constexpr T&& Eigen::internal::array_get ( std::vector< T > &&  a )

inlineconstexpr

Definition at line 39 of file CXX11Workarounds.h.

{ return a[I_]; }

array_get() [10/11]

template<std::size_t I_, class T >

constexpr T& Eigen::internal::array_get ( std::vector< T > &  a )

inlineconstexpr

Definition at line 38 of file CXX11Workarounds.h.

{ return a[I_]; }

array_get() [11/11]

template<std::size_t I_, class T >

constexpr T const& Eigen::internal::array_get ( std::vector< T > const &  a )

inlineconstexpr

Definition at line 40 of file CXX11Workarounds.h.

{ return a[I_]; }

array_prod() [1/2]

template<typename FirstType , typename... OtherTypes>

Index Eigen::internal::array_prod ( const IndexList< FirstType, OtherTypes... > &  sizes )

inline

Definition at line 367 of file TensorIndexList.h.

                                                                                                         {
  Index result = 1;
  EIGEN_UNROLL_LOOP
  for (size_t i = 0; i < array_size<IndexList<FirstType, OtherTypes...> >::value; ++i) {
    result *= sizes[i];
  }
  return result;
}

array_prod() [2/2]

template<typename std::ptrdiff_t... Indices>

std::ptrdiff_t Eigen::internal::array_prod ( const Sizes< Indices... > &  )

inline

Definition at line 140 of file TensorDimensions.h.

                                                                                        {
  return Sizes<Indices...>::total_size;
}

bicgstabl()

template<typename MatrixType , typename Rhs , typename Dest , typename Preconditioner >

bool Eigen::internal::bicgstabl	(	const MatrixType &	mat,
		const Rhs &	rhs,
		Dest &	x,
		const Preconditioner &	precond,
		Index &	iters,
		typename Dest::RealScalar &	tol_error,
		Index	L
	)

Definition at line 47 of file BiCGSTABL.h.

                                                            {
  using numext::abs;
  using numext::sqrt;
  typedef typename Dest::RealScalar RealScalar;
  typedef typename Dest::Scalar Scalar;
  const Index N = rhs.size();
  L = L < x.rows() ? L : x.rows();
 
  Index k = 0;
 
  const RealScalar tol = tol_error;
  const Index maxIters = iters;
 
  typedef Matrix<Scalar, Dynamic, 1> VectorType;
  typedef Matrix<Scalar, Dynamic, Dynamic, ColMajor> DenseMatrixType;
 
  DenseMatrixType rHat(N, L + 1);
  DenseMatrixType uHat(N, L + 1);
 
  // We start with an initial guess x_0 and let us set r_0 as (residual
  // calculated from x_0)
  VectorType x0 = x;
  rHat.col(0) = rhs - mat * x0;  // r_0
 
  x.setZero();  // This will contain the updates to the solution.
  // rShadow is arbritary, but must never be orthogonal to any residual.
  VectorType rShadow = VectorType::Random(N);
 
  VectorType x_prime = x;
 
  // Redundant: x is already set to 0
  // x.setZero();
  VectorType b_prime = rHat.col(0);
 
  // Other vectors and scalars initialization
  Scalar rho0 = 1.0;
  Scalar alpha = 0.0;
  Scalar omega = 1.0;
 
  uHat.col(0).setZero();
 
  bool bicg_convergence = false;
 
  const RealScalar normb = rhs.stableNorm();
  if (internal::isApprox(normb, RealScalar(0))) {
    x.setZero();
    iters = 0;
    return true;
  }
  RealScalar normr = rHat.col(0).stableNorm();
  RealScalar Mx = normr;
  RealScalar Mr = normr;
 
  // Keep track of the solution with the lowest residual
  RealScalar normr_min = normr;
  VectorType x_min = x_prime + x;
 
  // Criterion for when to apply the group-wise update, conform ref 3.
  const RealScalar delta = 0.01;
 
  bool compute_res = false;
  bool update_app = false;
 
  while (normr > tol * normb && k < maxIters) {
    rho0 *= -omega;
 
    for (Index j = 0; j < L; ++j) {
      const Scalar rho1 = rShadow.dot(rHat.col(j));
 
      if (!(numext::isfinite)(rho1) || rho0 == RealScalar(0.0)) {
        // We cannot continue computing, return the best solution found.
        x += x_prime;
 
        // Check if x is better than the best stored solution thus far.
        normr = (rhs - mat * (precond.solve(x) + x0)).stableNorm();
 
        if (normr > normr_min || !(numext::isfinite)(normr)) {
          // x_min is a better solution than x, return x_min
          x = x_min;
          normr = normr_min;
        }
        tol_error = normr / normb;
        iters = k;
        // x contains the updates to x0, add those back to obtain the solution
        x = precond.solve(x);
        x += x0;
        return (normr < tol * normb);
      }
 
      const Scalar beta = alpha * (rho1 / rho0);
      rho0 = rho1;
      // Update search directions
      uHat.leftCols(j + 1) = rHat.leftCols(j + 1) - beta * uHat.leftCols(j + 1);
      uHat.col(j + 1) = mat * precond.solve(uHat.col(j));
      const Scalar sigma = rShadow.dot(uHat.col(j + 1));
      alpha = rho1 / sigma;
      // Update residuals
      rHat.leftCols(j + 1) -= alpha * uHat.middleCols(1, j + 1);
      rHat.col(j + 1) = mat * precond.solve(rHat.col(j));
      // Complete BiCG iteration by updating x
      x += alpha * uHat.col(0);
      normr = rHat.col(0).stableNorm();
      // Check for early exit
      if (normr < tol * normb) {
        /*
          Convergence was achieved during BiCG step.
          Without this check BiCGStab(L) fails for trivial matrices, such as
          when the preconditioner already is the inverse, or the input matrix is
          identity.
        */
        bicg_convergence = true;
        break;
      } else if (normr < normr_min) {
        // We found an x with lower residual, keep this one.
        x_min = x + x_prime;
        normr_min = normr;
      }
    }
    if (!bicg_convergence) {
      /*
        The polynomial/minimize residual step.
 
        QR Householder method for argmin is more stable than (modified)
        Gram-Schmidt, in the sense that there is less loss of orthogonality. It
        is more accurate than solving the normal equations, since the normal
        equations scale with condition number squared.
      */
      const VectorType gamma = rHat.rightCols(L).householderQr().solve(rHat.col(0));
      x += rHat.leftCols(L) * gamma;
      rHat.col(0) -= rHat.rightCols(L) * gamma;
      uHat.col(0) -= uHat.rightCols(L) * gamma;
      normr = rHat.col(0).stableNorm();
      omega = gamma(L - 1);
    }
    if (normr < normr_min) {
      // We found an x with lower residual, keep this one.
      x_min = x + x_prime;
      normr_min = normr;
    }
 
    k++;
 
    /*
      Reliable update part
 
      The recursively computed residual can deviate from the actual residual
      after several iterations. However, computing the residual from the
      definition costs extra MVs and should not be done at each iteration. The
      reliable update strategy computes the true residual from the definition:
      r=b-A*x at strategic intervals. Furthermore a "group wise update" strategy
      is used to combine updates, which improves accuracy.
    */
 
    // Maximum norm of residuals since last update of x.
    Mx = numext::maxi(Mx, normr);
    // Maximum norm of residuals since last computation of the true residual.
    Mr = numext::maxi(Mr, normr);
 
    if (normr < delta * normb && normb <= Mx) {
      update_app = true;
    }
 
    if (update_app || (normr < delta * Mr && normb <= Mr)) {
      compute_res = true;
    }
 
    if (bicg_convergence) {
      update_app = true;
      compute_res = true;
      bicg_convergence = false;
    }
 
    if (compute_res) {
      // Explicitly compute residual from the definition
 
      // This is equivalent to the shifted version of rhs - mat *
      // (precond.solve(x)+x0)
      rHat.col(0) = b_prime - mat * precond.solve(x);
      normr = rHat.col(0).stableNorm();
      Mr = normr;
 
      if (update_app) {
        // After the group wise update, the original problem is translated to a
        // shifted one.
        x_prime += x;
        x.setZero();
        b_prime = rHat.col(0);
        Mx = normr;
      }
    }
    if (normr < normr_min) {
      // We found an x with lower residual, keep this one.
      x_min = x + x_prime;
      normr_min = normr;
    }
 
    compute_res = false;
    update_app = false;
  }
 
  // Convert internal variable to the true solution vector x
  x += x_prime;
 
  normr = (rhs - mat * (precond.solve(x) + x0)).stableNorm();
  if (normr > normr_min || !(numext::isfinite)(normr)) {
    // x_min is a better solution than x, return x_min
    x = x_min;
    normr = normr_min;
  }
  tol_error = normr / normb;
  iters = k;
 
  // x contains the updates to x0, add those back to obtain the solution
  x = precond.solve(x);
  x += x0;
  return true;
}

cast< mpfr::mpreal, double >()

template<>

double Eigen::internal::cast< mpfr::mpreal, double > ( const mpfr::mpreal &  x )

inline

Definition at line 135 of file MPRealSupport.

  { return x.toDouble(); }

cast< mpfr::mpreal, int >()

template<>

int Eigen::internal::cast< mpfr::mpreal, int > ( const mpfr::mpreal &  x )

inline

Definition at line 141 of file MPRealSupport.

  { return int(x.toLong()); }

cast< mpfr::mpreal, long >()

template<>

long Eigen::internal::cast< mpfr::mpreal, long > ( const mpfr::mpreal &  x )

inline

Definition at line 138 of file MPRealSupport.

  { return x.toLong(); }

cast< mpfr::mpreal, long double >()

template<>

long double Eigen::internal::cast< mpfr::mpreal, long double > ( const mpfr::mpreal &  x )

inline

Definition at line 132 of file MPRealSupport.

  { return x.toLDouble(); }

chkder()

template<typename Scalar >

void Eigen::internal::chkder	(	const Matrix< Scalar, Dynamic, 1 > &	x,
		const Matrix< Scalar, Dynamic, 1 > &	fvec,
		const Matrix< Scalar, Dynamic, Dynamic > &	fjac,
		Matrix< Scalar, Dynamic, 1 > &	xp,
		const Matrix< Scalar, Dynamic, 1 > &	fvecp,
		int	mode,
		Matrix< Scalar, Dynamic, 1 > &	err
	)

Definition at line 11 of file chkder.h.

{
    using std::sqrt;
    using std::abs;
    using std::log;
    
    typedef DenseIndex Index;
 
    const Scalar eps = sqrt(NumTraits<Scalar>::epsilon());
    const Scalar epsf = chkder_factor * NumTraits<Scalar>::epsilon();
    const Scalar epslog = chkder_log10e * log(eps);
    Scalar temp;
 
    const Index m = fvec.size(), n = x.size();
 
    if (mode != 2) {
        /* mode = 1. */
        xp.resize(n);
        for (Index j = 0; j < n; ++j) {
            temp = eps * abs(x[j]);
            if (temp == 0.)
                temp = eps;
            xp[j] = x[j] + temp;
        }
    }
    else {
        /* mode = 2. */
        err.setZero(m); 
        for (Index j = 0; j < n; ++j) {
            temp = abs(x[j]);
            if (temp == 0.)
                temp = 1.;
            err += temp * fjac.col(j);
        }
        for (Index i = 0; i < m; ++i) {
            temp = 1.;
            if (fvec[i] != 0. && fvecp[i] != 0. && abs(fvecp[i] - fvec[i]) >= epsf * abs(fvec[i]))
                temp = eps * abs((fvecp[i] - fvec[i]) / eps - err[i]) / (abs(fvec[i]) + abs(fvecp[i]));
            err[i] = 1.;
            if (temp > NumTraits<Scalar>::epsilon() && temp < eps)
                err[i] = (chkder_log10e * log(temp) - epslog) / epslog;
            if (temp >= eps)
                err[i] = 0.;
        }
    }
}

count_leading_zeros() [1/2]

template<typename T >

EIGEN_ALWAYS_INLINE std::enable_if_t<sizeof(T)==4,int> Eigen::internal::count_leading_zeros

(

const T

val

)

Definition at line 36 of file TensorIntDiv.h.

  {
#ifdef EIGEN_GPU_COMPILE_PHASE
    return __clz(val);
#elif defined(SYCL_DEVICE_ONLY)
    return cl::sycl::clz(val);
#elif EIGEN_COMP_MSVC
    unsigned long index;
    _BitScanReverse(&index, val);
    return 31 - index;
#else
    EIGEN_STATIC_ASSERT(sizeof(unsigned long long) == 8, YOU_MADE_A_PROGRAMMING_MISTAKE);
    return __builtin_clz(static_cast<uint32_t>(val));
#endif
  }

count_leading_zeros() [2/2]

template<typename T >

EIGEN_ALWAYS_INLINE std::enable_if_t<sizeof(T)==8,int> Eigen::internal::count_leading_zeros

(

const T

val

)

Definition at line 54 of file TensorIntDiv.h.

  {
#ifdef EIGEN_GPU_COMPILE_PHASE
    return __clzll(val);
#elif defined(SYCL_DEVICE_ONLY)
    return static_cast<int>(cl::sycl::clz(val));
#elif EIGEN_COMP_MSVC && EIGEN_ARCH_x86_64
    unsigned long index;
    _BitScanReverse64(&index, val);
    return 63 - index;
#elif EIGEN_COMP_MSVC
    // MSVC's _BitScanReverse64 is not available for 32bits builds.
    unsigned int lo = (unsigned int)(val&0xffffffff);
    unsigned int hi = (unsigned int)((val>>32)&0xffffffff);
    int n;
    if(hi==0)
      n = 32 + count_leading_zeros<unsigned int>(lo);
    else
      n = count_leading_zeros<unsigned int>(hi);
    return n;
#else
    EIGEN_STATIC_ASSERT(sizeof(unsigned long long) == 8, YOU_MADE_A_PROGRAMMING_MISTAKE);
    return __builtin_clzll(static_cast<uint64_t>(val));
#endif
  }

covar()

template<typename Scalar >

void Eigen::internal::covar	(	Matrix< Scalar, Dynamic, Dynamic > &	r,
		const VectorXi &	ipvt,
		Scalar	tol = std::sqrt(NumTraits<Scalar>::epsilon())
	)

Definition at line 22 of file LMcovar.h.

{
    using std::abs;
    /* Local variables */
    Index i, j, k, l, ii, jj;
    bool sing;
    Scalar temp;
 
    /* Function Body */
    const Index n = r.cols();
    const Scalar tolr = tol * abs(r(0,0));
    Matrix< Scalar, Dynamic, 1 > wa(n);
    eigen_assert(ipvt.size()==n);
 
    /* form the inverse of r in the full upper triangle of r. */
    l = -1;
    for (k = 0; k < n; ++k)
        if (abs(r(k,k)) > tolr) {
            r(k,k) = 1. / r(k,k);
            for (j = 0; j <= k-1; ++j) {
                temp = r(k,k) * r(j,k);
                r(j,k) = 0.;
                r.col(k).head(j+1) -= r.col(j).head(j+1) * temp;
            }
            l = k;
        }
 
    /* form the full upper triangle of the inverse of (r transpose)*r */
    /* in the full upper triangle of r. */
    for (k = 0; k <= l; ++k) {
        for (j = 0; j <= k-1; ++j)
            r.col(j).head(j+1) += r.col(k).head(j+1) * r(j,k);
        r.col(k).head(k+1) *= r(k,k);
    }
 
    /* form the full lower triangle of the covariance matrix */
    /* in the strict lower triangle of r and in wa. */
    for (j = 0; j < n; ++j) {
        jj = ipvt[j];
        sing = j > l;
        for (i = 0; i <= j; ++i) {
            if (sing)
                r(i,j) = 0.;
            ii = ipvt[i];
            if (ii > jj)
                r(ii,jj) = r(i,j);
            if (ii < jj)
                r(jj,ii) = r(i,j);
        }
        wa[jj] = r(j,j);
    }
 
    /* symmetrize the covariance matrix in r. */
    r.topLeftCorner(n,n).template triangularView<StrictlyUpper>() = r.topLeftCorner(n,n).transpose();
    r.diagonal() = wa;
}

customIndices2Array() [1/3]

template<typename IndexType , typename Index >

EIGEN_CONSTEXPR array<Index, 0> Eigen::internal::customIndices2Array ( IndexType &  , numeric_list< Index >    )

inline

Definition at line 275 of file TensorMeta.h.

                                                                       {
    return array<Index, 0>();
  }

customIndices2Array() [2/3]

template<typename Index , std::size_t NumIndices, typename IndexType >

EIGEN_CONSTEXPR array<Index, NumIndices> Eigen::internal::customIndices2Array ( IndexType &  idx )

inline

Make an array (for index/dimensions) out of a custom index

Definition at line 282 of file TensorMeta.h.

                                                               {
    return customIndices2Array(idx, typename gen_numeric_list<Index, NumIndices>::type{});
  }

customIndices2Array() [3/3]

template<typename IndexType , typename Index , Index First, Index... Is>

EIGEN_CONSTEXPR array<Index, 1 + sizeof...(Is)> Eigen::internal::customIndices2Array ( IndexType &  idx, numeric_list< Index, First, Is... >    )

inline

Definition at line 270 of file TensorMeta.h.

                                                                                                         {
    return { static_cast<Index>(idx[First]), static_cast<Index>(idx[Is])... };
  }

dogleg()

template<typename Scalar >

void Eigen::internal::dogleg	(	const Matrix< Scalar, Dynamic, Dynamic > &	qrfac,
		const Matrix< Scalar, Dynamic, 1 > &	diag,
		const Matrix< Scalar, Dynamic, 1 > &	qtb,
		Scalar	delta,
		Matrix< Scalar, Dynamic, 1 > &	x
	)

Definition at line 8 of file dogleg.h.

{
    using std::abs;
    using std::sqrt;
    
    typedef DenseIndex Index;
 
    /* Local variables */
    Index i, j;
    Scalar sum, temp, alpha, bnorm;
    Scalar gnorm, qnorm;
    Scalar sgnorm;
 
    /* Function Body */
    const Scalar epsmch = NumTraits<Scalar>::epsilon();
    const Index n = qrfac.cols();
    eigen_assert(n==qtb.size());
    eigen_assert(n==x.size());
    eigen_assert(n==diag.size());
    Matrix< Scalar, Dynamic, 1 >  wa1(n), wa2(n);
 
    /* first, calculate the gauss-newton direction. */
    for (j = n-1; j >=0; --j) {
        temp = qrfac(j,j);
        if (temp == 0.) {
            temp = epsmch * qrfac.col(j).head(j+1).maxCoeff();
            if (temp == 0.)
                temp = epsmch;
        }
        if (j==n-1)
            x[j] = qtb[j] / temp;
        else
            x[j] = (qtb[j] - qrfac.row(j).tail(n-j-1).dot(x.tail(n-j-1))) / temp;
    }
 
    /* test whether the gauss-newton direction is acceptable. */
    qnorm = diag.cwiseProduct(x).stableNorm();
    if (qnorm <= delta)
        return;
 
    // TODO : this path is not tested by Eigen unit tests
 
    /* the gauss-newton direction is not acceptable. */
    /* next, calculate the scaled gradient direction. */
 
    wa1.fill(0.);
    for (j = 0; j < n; ++j) {
        wa1.tail(n-j) += qrfac.row(j).tail(n-j) * qtb[j];
        wa1[j] /= diag[j];
    }
 
    /* calculate the norm of the scaled gradient and test for */
    /* the special case in which the scaled gradient is zero. */
    gnorm = wa1.stableNorm();
    sgnorm = 0.;
    alpha = delta / qnorm;
    if (gnorm == 0.)
        goto algo_end;
 
    /* calculate the point along the scaled gradient */
    /* at which the quadratic is minimized. */
    wa1.array() /= (diag*gnorm).array();
    // TODO : once unit tests cover this part,:
    // wa2 = qrfac.template triangularView<Upper>() * wa1;
    for (j = 0; j < n; ++j) {
        sum = 0.;
        for (i = j; i < n; ++i) {
            sum += qrfac(j,i) * wa1[i];
        }
        wa2[j] = sum;
    }
    temp = wa2.stableNorm();
    sgnorm = gnorm / temp / temp;
 
    /* test whether the scaled gradient direction is acceptable. */
    alpha = 0.;
    if (sgnorm >= delta)
        goto algo_end;
 
    /* the scaled gradient direction is not acceptable. */
    /* finally, calculate the point along the dogleg */
    /* at which the quadratic is minimized. */
    bnorm = qtb.stableNorm();
    temp = bnorm / gnorm * (bnorm / qnorm) * (sgnorm / delta);
    temp = temp - delta / qnorm * numext::abs2(sgnorm / delta) + sqrt(numext::abs2(temp - delta / qnorm) + (1.-numext::abs2(delta / qnorm)) * (1.-numext::abs2(sgnorm / delta)));
    alpha = delta / qnorm * (1. - numext::abs2(sgnorm / delta)) / temp;
algo_end:
 
    /* form appropriate convex combination of the gauss-newton */
    /* direction and the scaled gradient direction. */
    temp = (1.-alpha) * (std::min)(sgnorm,delta);
    x = temp * wa1 + alpha * x;
}

fdjac1()

template<typename FunctorType , typename Scalar >

DenseIndex Eigen::internal::fdjac1	(	const FunctorType &	Functor,
		Matrix< Scalar, Dynamic, 1 > &	x,
		Matrix< Scalar, Dynamic, 1 > &	fvec,
		Matrix< Scalar, Dynamic, Dynamic > &	fjac,
		DenseIndex	ml,
		DenseIndex	mu,
		Scalar	epsfcn
	)

Definition at line 8 of file fdjac1.h.

{
    using std::sqrt;
    using std::abs;
    
    typedef DenseIndex Index;
 
    /* Local variables */
    Scalar h;
    Index j, k;
    Scalar eps, temp;
    Index msum;
    int iflag;
    Index start, length;
 
    /* Function Body */
    const Scalar epsmch = NumTraits<Scalar>::epsilon();
    const Index n = x.size();
    eigen_assert(fvec.size()==n);
    Matrix< Scalar, Dynamic, 1 >  wa1(n);
    Matrix< Scalar, Dynamic, 1 >  wa2(n);
 
    eps = sqrt((std::max)(epsfcn,epsmch));
    msum = ml + mu + 1;
    if (msum >= n) {
        /* computation of dense approximate jacobian. */
        for (j = 0; j < n; ++j) {
            temp = x[j];
            h = eps * abs(temp);
            if (h == 0.)
                h = eps;
            x[j] = temp + h;
            iflag = Functor(x, wa1);
            if (iflag < 0)
                return iflag;
            x[j] = temp;
            fjac.col(j) = (wa1-fvec)/h;
        }
 
    }else {
        /* computation of banded approximate jacobian. */
        for (k = 0; k < msum; ++k) {
            for (j = k; (msum<0) ? (j>n): (j<n); j += msum) {
                wa2[j] = x[j];
                h = eps * abs(wa2[j]);
                if (h == 0.) h = eps;
                x[j] = wa2[j] + h;
            }
            iflag = Functor(x, wa1);
            if (iflag < 0)
                return iflag;
            for (j = k; (msum<0) ? (j>n): (j<n); j += msum) {
                x[j] = wa2[j];
                h = eps * abs(wa2[j]);
                if (h == 0.) h = eps;
                fjac.col(j).setZero();
                start = std::max<Index>(0,j-mu);
                length = (std::min)(n-1, j+ml) - start + 1;
                fjac.col(j).segment(start, length) = ( wa1.segment(start, length)-fvec.segment(start, length))/h;
            }
        }
    }
    return 0;
}

fftw_cast() [1/4]

fftw_complex* Eigen::internal::fftw_cast ( const std::complex< double > *  p )

inline

Definition at line 34 of file ei_fftw_impl.h.

  {
      return const_cast<fftw_complex*>( reinterpret_cast<const fftw_complex*>(p) ); 
  }

fftw_cast() [2/4]

fftwf_complex* Eigen::internal::fftw_cast ( const std::complex< float > *  p )

inline

Definition at line 40 of file ei_fftw_impl.h.

  { 
      return const_cast<fftwf_complex*>( reinterpret_cast<const fftwf_complex*>(p) ); 
  }

fftw_cast() [3/4]

fftwl_complex* Eigen::internal::fftw_cast ( const std::complex< long double > *  p )

inline

Definition at line 46 of file ei_fftw_impl.h.

  { 
      return const_cast<fftwl_complex*>( reinterpret_cast<const fftwl_complex*>(p) ); 
  }

fftw_cast() [4/4]

template<typename T >

T* Eigen::internal::fftw_cast ( const T *  p )

inline

Definition at line 28 of file ei_fftw_impl.h.

  { 
      return const_cast<T*>( p); 
  }

flipsign()

template<typename T >

T Eigen::internal::flipsign ( const T &  should_flipsign, const T &  x  )

inline

Implementation of ndtri. *

Definition at line 492 of file SpecialFunctionsImpl.h.

                                          {
  typedef typename unpacket_traits<T>::type Scalar;
  const T sign_mask = pset1<T>(Scalar(-0.0));
  T sign_bit = pand<T>(should_flipsign, sign_mask);
  return pxor<T>(sign_bit, x);
}

flipsign< double >()

template<>

double Eigen::internal::flipsign< double > ( const double &  should_flipsign, const double &  x  )

inline

Definition at line 501 of file SpecialFunctionsImpl.h.

                                                    {
  return should_flipsign == 0 ? x : -x;
}

flipsign< float >()

template<>

float Eigen::internal::flipsign< float > ( const float &  should_flipsign, const float &  x  )

inline

Definition at line 507 of file SpecialFunctionsImpl.h.

                                                  {
  return should_flipsign == 0 ? x : -x;
}

generic_fast_erf_float()

template<typename T >

T Eigen::internal::generic_fast_erf_float ( const T &  x )

inline

Implementation of erf, requires C++11/C99 *

Definition at line 308 of file SpecialFunctionsImpl.h.

                                                                           {
  constexpr float kErfInvOneMinusHalfULP = 3.832506856900711f;
  const T clamp = pcmp_le(pset1<T>(kErfInvOneMinusHalfULP), pabs(x));
  // The monomial coefficients of the numerator polynomial (odd).
  const T alpha_1 = pset1<T>(1.128379143519084f);
  const T alpha_3 = pset1<T>(0.18520832239976145f);
  const T alpha_5 = pset1<T>(0.050955695062380861f);
  const T alpha_7 = pset1<T>(0.0034082910107109506f);
  const T alpha_9 = pset1<T>(0.00022905065861350646f);
 
  // The monomial coefficients of the denominator polynomial (even).
  const T beta_0 = pset1<T>(1.0f);
  const T beta_2 = pset1<T>(0.49746925110067538f);
  const T beta_4 = pset1<T>(0.11098505178285362f);
  const T beta_6 = pset1<T>(0.014070470171167667f);
  const T beta_8 = pset1<T>(0.0010179625278914885f);
  const T beta_10 = pset1<T>(0.000023547966471313185f);
  const T beta_12 = pset1<T>(-1.1791602954361697e-7f);
 
  // Since the polynomials are odd/even, we need x^2.
  const T x2 = pmul(x, x);
 
  // Evaluate the numerator polynomial p.
  T p = pmadd(x2, alpha_9, alpha_7);
  p = pmadd(x2, p, alpha_5);
  p = pmadd(x2, p, alpha_3);
  p = pmadd(x2, p, alpha_1);
  p = pmul(x, p);
 
  // Evaluate the denominator polynomial p.
  T q = pmadd(x2, beta_12, beta_10);
  q = pmadd(x2, q, beta_8);
  q = pmadd(x2, q, beta_6);
  q = pmadd(x2, q, beta_4);
  q = pmadd(x2, q, beta_2);
  q = pmadd(x2, q, beta_0);
 
  // Divide the numerator by the denominator.
  return pselect(clamp, psign(x), pdiv(p, q));
}

generic_ndtri()

template<typename T , typename ScalarType >

EIGEN_ALWAYS_INLINE T Eigen::internal::generic_ndtri

(

const T &

a

)

Definition at line 621 of file SpecialFunctionsImpl.h.

                            {
  const T maxnum = pset1<T>(NumTraits<ScalarType>::infinity());
  const T neg_maxnum = pset1<T>(-NumTraits<ScalarType>::infinity());
 
  const T zero = pset1<T>(ScalarType(0));
  const T one = pset1<T>(ScalarType(1));
  // exp(-2)
  const T exp_neg_two = pset1<T>(ScalarType(0.13533528323661269189));
  T b, ndtri, should_flipsign;
 
  should_flipsign = pcmp_le(a, psub(one, exp_neg_two));
  b = pselect(should_flipsign, a, psub(one, a));
 
  ndtri = pselect(
      pcmp_lt(exp_neg_two, b),
      generic_ndtri_gt_exp_neg_two<T, ScalarType>(b),
      generic_ndtri_lt_exp_neg_two<T, ScalarType>(b, should_flipsign));
 
  return pselect(
      pcmp_eq(a, zero), neg_maxnum,
      pselect(pcmp_eq(one, a), maxnum, ndtri));
}

generic_ndtri_gt_exp_neg_two()

template<typename T , typename ScalarType >

T Eigen::internal::generic_ndtri_gt_exp_neg_two ( const T &  b )

inline

Definition at line 517 of file SpecialFunctionsImpl.h.

                                                                                 {
  const ScalarType p0[] = {
    ScalarType(-5.99633501014107895267e1),
    ScalarType(9.80010754185999661536e1),
    ScalarType(-5.66762857469070293439e1),
    ScalarType(1.39312609387279679503e1),
    ScalarType(-1.23916583867381258016e0)
  };
  const ScalarType q0[] = {
    ScalarType(1.0),
    ScalarType(1.95448858338141759834e0),
    ScalarType(4.67627912898881538453e0),
    ScalarType(8.63602421390890590575e1),
    ScalarType(-2.25462687854119370527e2),
    ScalarType(2.00260212380060660359e2),
    ScalarType(-8.20372256168333339912e1),
    ScalarType(1.59056225126211695515e1),
    ScalarType(-1.18331621121330003142e0)
  };
  const T sqrt2pi = pset1<T>(ScalarType(2.50662827463100050242e0));
  const T half = pset1<T>(ScalarType(0.5));
  T c, c2, ndtri_gt_exp_neg_two;
 
  c = psub(b, half);
  c2 = pmul(c, c);
  ndtri_gt_exp_neg_two = pmadd(c, pmul(
      c2, pdiv(
          internal::ppolevl<T, 4>::run(c2, p0),
          internal::ppolevl<T, 8>::run(c2, q0))), c);
  return pmul(ndtri_gt_exp_neg_two, sqrt2pi);
}

generic_ndtri_lt_exp_neg_two()

template<typename T , typename ScalarType >

T Eigen::internal::generic_ndtri_lt_exp_neg_two ( const T &  b, const T &  should_flipsign  )

inline

Definition at line 550 of file SpecialFunctionsImpl.h.

                                          {
  /* Approximation for interval z = sqrt(-2 log a ) between 2 and 8
   * i.e., a between exp(-2) = .135 and exp(-32) = 1.27e-14.
   */
  const ScalarType p1[] = {
    ScalarType(4.05544892305962419923e0),
    ScalarType(3.15251094599893866154e1),
    ScalarType(5.71628192246421288162e1),
    ScalarType(4.40805073893200834700e1),
    ScalarType(1.46849561928858024014e1),
    ScalarType(2.18663306850790267539e0),
    ScalarType(-1.40256079171354495875e-1),
    ScalarType(-3.50424626827848203418e-2),
    ScalarType(-8.57456785154685413611e-4)
  };
  const ScalarType q1[] = {
    ScalarType(1.0),
    ScalarType(1.57799883256466749731e1),
    ScalarType(4.53907635128879210584e1),
    ScalarType(4.13172038254672030440e1),
    ScalarType(1.50425385692907503408e1),
    ScalarType(2.50464946208309415979e0),
    ScalarType(-1.42182922854787788574e-1),
    ScalarType(-3.80806407691578277194e-2),
    ScalarType(-9.33259480895457427372e-4)
  };
  /* Approximation for interval z = sqrt(-2 log a ) between 8 and 64
   * i.e., a between exp(-32) = 1.27e-14 and exp(-2048) = 3.67e-890.
   */
  const ScalarType p2[] = {
    ScalarType(3.23774891776946035970e0),
    ScalarType(6.91522889068984211695e0),
    ScalarType(3.93881025292474443415e0),
    ScalarType(1.33303460815807542389e0),
    ScalarType(2.01485389549179081538e-1),
    ScalarType(1.23716634817820021358e-2),
    ScalarType(3.01581553508235416007e-4),
    ScalarType(2.65806974686737550832e-6),
    ScalarType(6.23974539184983293730e-9)
  };
  const ScalarType q2[] = {
    ScalarType(1.0),
    ScalarType(6.02427039364742014255e0),
    ScalarType(3.67983563856160859403e0),
    ScalarType(1.37702099489081330271e0),
    ScalarType(2.16236993594496635890e-1),
    ScalarType(1.34204006088543189037e-2),
    ScalarType(3.28014464682127739104e-4),
    ScalarType(2.89247864745380683936e-6),
    ScalarType(6.79019408009981274425e-9)
  };
  const T eight = pset1<T>(ScalarType(8.0));
  const T neg_two = pset1<T>(ScalarType(-2));
  T x, x0, x1, z;
 
  x = psqrt(pmul(neg_two, plog(b)));
  x0 = psub(x, pdiv(plog(x), x));
  z = preciprocal(x);
  x1 = pmul(
      z, pselect(
          pcmp_lt(x, eight),
          pdiv(internal::ppolevl<T, 8>::run(z, p1),
               internal::ppolevl<T, 8>::run(z, q1)),
          pdiv(internal::ppolevl<T, 8>::run(z, p2),
               internal::ppolevl<T, 8>::run(z, q2))));
  return flipsign(should_flipsign, psub(x0, x1));
}

get_random_seed()

uint64_t Eigen::internal::get_random_seed ( )

inline

Definition at line 19 of file TensorRandom.h.

                                                                 {
#if defined(EIGEN_GPU_COMPILE_PHASE)
  // We don't support 3d kernels since we currently only use 1 and
  // 2d kernels.
  gpu_assert(threadIdx.z == 0);
  return blockIdx.x * blockDim.x + threadIdx.x 
         + gridDim.x * blockDim.x * (blockIdx.y * blockDim.y + threadIdx.y);
#else
  // Rely on Eigen's random implementation.
  return random<uint64_t>();
#endif
}

GetDenseElt() [1/2]

template<typename RealScalar >

void Eigen::internal::GetDenseElt ( const std::string &  line, RealScalar &  val  )

inline

Definition at line 52 of file MarketIO.h.

  {
    std::istringstream newline(line);
    newline >> val;  
  }

GetDenseElt() [2/2]

template<typename RealScalar >

void Eigen::internal::GetDenseElt ( const std::string &  line, std::complex< RealScalar > &  val  )

inline

Definition at line 59 of file MarketIO.h.

  {
    RealScalar valR, valI; 
    std::istringstream newline(line);
    newline >> valR >> valI; 
    val = std::complex<RealScalar>(valR, valI);
  }

GetMarketLine() [1/6]

template<>

void Eigen::internal::GetMarketLine ( const char *  line, int &  i, int &  j, double &  value  )

inline

Definition at line 33 of file MarketIO.h.

  { std::sscanf(line, "%d %d %lg", &i, &j, &value); }

GetMarketLine() [2/6]

template<>

void Eigen::internal::GetMarketLine ( const char *  line, int &  i, int &  j, float &  value  )

inline

Definition at line 30 of file MarketIO.h.

  { std::sscanf(line, "%d %d %g", &i, &j, &value); }

GetMarketLine() [3/6]

template<>

void Eigen::internal::GetMarketLine ( const char *  line, int &  i, int &  j, std::complex< double > &  value  )

inline

Definition at line 39 of file MarketIO.h.

  { std::sscanf(line, "%d %d %lg %lg", &i, &j, &numext::real_ref(value), &numext::imag_ref(value)); }

GetMarketLine() [4/6]

template<>

void Eigen::internal::GetMarketLine ( const char *  line, int &  i, int &  j, std::complex< float > &  value  )

inline

Definition at line 36 of file MarketIO.h.

  { std::sscanf(line, "%d %d %g %g", &i, &j, &numext::real_ref(value), &numext::imag_ref(value)); }

GetMarketLine() [5/6]

template<typename Scalar , typename StorageIndex >

void Eigen::internal::GetMarketLine ( const char *  line, StorageIndex &  i, StorageIndex &  j, Scalar &  value  )

inline

Definition at line 24 of file MarketIO.h.

  {
    std::stringstream sline(line);
    sline >> i >> j >> value;
  }

GetMarketLine() [6/6]

template<typename Scalar , typename StorageIndex >

void Eigen::internal::GetMarketLine ( const char *  line, StorageIndex &  i, StorageIndex &  j, std::complex< Scalar > &  value  )

inline

Definition at line 43 of file MarketIO.h.

  {
    std::stringstream sline(line);
    Scalar valR, valI;
    sline >> i >> j >> valR >> valI;
    value = std::complex<Scalar>(valR,valI);
  }

gmres()

template<typename MatrixType , typename Rhs , typename Dest , typename Preconditioner >

bool Eigen::internal::gmres	(	const MatrixType &	mat,
		const Rhs &	rhs,
		Dest &	x,
		const Preconditioner &	precond,
		Index &	iters,
		const Index &	restart,
		typename Dest::RealScalar &	tol_error
	)

Generalized Minimal Residual Algorithm based on the Arnoldi algorithm implemented with Householder reflections.

Parameters:

Parameters

mat	matrix of linear system of equations
rhs	right hand side vector of linear system of equations
x	on input: initial guess, on output: solution
precond	preconditioner used
iters	on input: maximum number of iterations to perform on output: number of iterations performed
restart	number of iterations for a restart
tol_error	on input: relative residual tolerance on output: residuum achieved

See also

IterativeMethods::bicgstab()

For references, please see:

Saad, Y. and Schultz, M. H. GMRES: A Generalized Minimal Residual Algorithm for Solving Nonsymmetric Linear Systems. SIAM J.Sci.Stat.Comp. 7, 1986, pp. 856 - 869.

Saad, Y. Iterative Methods for Sparse Linear Systems. Society for Industrial and Applied Mathematics, Philadelphia, 2003.

Walker, H. F. Implementations of the GMRES method. Comput.Phys.Comm. 53, 1989, pp. 311 - 320.

Walker, H. F. Implementation of the GMRES Method using Householder Transformations. SIAM J.Sci.Stat.Comp. 9, 1988, pp. 152 - 163.

Definition at line 58 of file GMRES.h.

                                                                             {
 
  using std::sqrt;
  using std::abs;
 
  typedef typename Dest::RealScalar RealScalar;
  typedef typename Dest::Scalar Scalar;
  typedef Matrix < Scalar, Dynamic, 1 > VectorType;
  typedef Matrix < Scalar, Dynamic, Dynamic, ColMajor> FMatrixType;
 
  const RealScalar considerAsZero = (std::numeric_limits<RealScalar>::min)();
 
  if(rhs.norm() <= considerAsZero) 
  {
    x.setZero();
    tol_error = 0;
    return true;
  }
 
  RealScalar tol = tol_error;
  const Index maxIters = iters;
  iters = 0;
 
  const Index m = mat.rows();
 
  // residual and preconditioned residual
  VectorType p0 = rhs - mat*x;
  VectorType r0 = precond.solve(p0);
 
  const RealScalar r0Norm = r0.norm();
 
  // is initial guess already good enough?
  if(r0Norm == 0)
  {
    tol_error = 0;
    return true;
  }
 
  // storage for Hessenberg matrix and Householder data
  FMatrixType H   = FMatrixType::Zero(m, restart + 1);
  VectorType w    = VectorType::Zero(restart + 1);
  VectorType tau  = VectorType::Zero(restart + 1);
 
  // storage for Jacobi rotations
  std::vector < JacobiRotation < Scalar > > G(restart);
  
  // storage for temporaries
  VectorType t(m), v(m), workspace(m), x_new(m);
 
  // generate first Householder vector
  Ref<VectorType> H0_tail = H.col(0).tail(m - 1);
  RealScalar beta;
  r0.makeHouseholder(H0_tail, tau.coeffRef(0), beta);
  w(0) = Scalar(beta);
  
  for (Index k = 1; k <= restart; ++k)
  {
    ++iters;
 
    v = VectorType::Unit(m, k - 1);
 
    // apply Householder reflections H_{1} ... H_{k-1} to v
    // TODO: use a HouseholderSequence
    for (Index i = k - 1; i >= 0; --i) {
      v.tail(m - i).applyHouseholderOnTheLeft(H.col(i).tail(m - i - 1), tau.coeffRef(i), workspace.data());
    }
 
    // apply matrix M to v:  v = mat * v;
    t.noalias() = mat * v;
    v = precond.solve(t);
 
    // apply Householder reflections H_{k-1} ... H_{1} to v
    // TODO: use a HouseholderSequence
    for (Index i = 0; i < k; ++i) {
      v.tail(m - i).applyHouseholderOnTheLeft(H.col(i).tail(m - i - 1), tau.coeffRef(i), workspace.data());
    }
 
    if (v.tail(m - k).norm() != 0.0)
    {
      if (k <= restart)
      {
        // generate new Householder vector
        Ref<VectorType> Hk_tail = H.col(k).tail(m - k - 1);
        v.tail(m - k).makeHouseholder(Hk_tail, tau.coeffRef(k), beta);
 
        // apply Householder reflection H_{k} to v
        v.tail(m - k).applyHouseholderOnTheLeft(Hk_tail, tau.coeffRef(k), workspace.data());
      }
    }
 
    if (k > 1)
    {
      for (Index i = 0; i < k - 1; ++i)
      {
        // apply old Givens rotations to v
        v.applyOnTheLeft(i, i + 1, G[i].adjoint());
      }
    }
 
    if (k<m && v(k) != (Scalar) 0)
    {
      // determine next Givens rotation
      G[k - 1].makeGivens(v(k - 1), v(k));
 
      // apply Givens rotation to v and w
      v.applyOnTheLeft(k - 1, k, G[k - 1].adjoint());
      w.applyOnTheLeft(k - 1, k, G[k - 1].adjoint());
    }
 
    // insert coefficients into upper matrix triangle
    H.col(k-1).head(k) = v.head(k);
 
    tol_error = abs(w(k)) / r0Norm;
    bool stop = (k==m || tol_error < tol || iters == maxIters);
 
    if (stop || k == restart)
    {
      // solve upper triangular system
      Ref<VectorType> y = w.head(k);
      H.topLeftCorner(k, k).template triangularView <Upper>().solveInPlace(y);
 
      // use Horner-like scheme to calculate solution vector
      x_new.setZero();
      for (Index i = k - 1; i >= 0; --i)
      {
        x_new(i) += y(i);
        // apply Householder reflection H_{i} to x_new
        x_new.tail(m - i).applyHouseholderOnTheLeft(H.col(i).tail(m - i - 1), tau.coeffRef(i), workspace.data());
      }
 
      x += x_new;
 
      if(stop)
      {
        return true;
      }
      else
      {
        k=0;
 
        // reset data for restart
        p0.noalias() = rhs - mat*x;
        r0 = precond.solve(p0);
 
        // clear Hessenberg matrix and Householder data
        H.setZero();
        w.setZero();
        tau.setZero();
 
        // generate first Householder vector
        r0.makeHouseholder(H0_tail, tau.coeffRef(0), beta);
        w(0) = Scalar(beta);
      }
    }
  }
 
  return false;
 
}

idrs()

template<typename MatrixType , typename Rhs , typename Dest , typename Preconditioner >

bool Eigen::internal::idrs	(	const MatrixType &	A,
		const Rhs &	b,
		Dest &	x,
		const Preconditioner &	precond,
		Index &	iter,
		typename Dest::RealScalar &	relres,
		Index	S,
		bool	smoothing,
		typename Dest::RealScalar	angle,
		bool	replacement
	)

Definition at line 57 of file IDRS.h.

                            {
  typedef typename Dest::RealScalar RealScalar;
  typedef typename Dest::Scalar Scalar;
  typedef Matrix<Scalar, Dynamic, 1> VectorType;
  typedef Matrix<Scalar, Dynamic, Dynamic, ColMajor> DenseMatrixType;
  const Index N = b.size();
  S = S < x.rows() ? S : x.rows();
  const RealScalar tol = relres;
  const Index maxit = iter;
 
  bool trueres = false;
 
  FullPivLU<DenseMatrixType> lu_solver;
 
  DenseMatrixType P;
  {
    HouseholderQR<DenseMatrixType> qr(DenseMatrixType::Random(N, S));
    P = (qr.householderQ() * DenseMatrixType::Identity(N, S));
  }
 
  const RealScalar normb = b.stableNorm();
 
  if (internal::isApprox(normb, RealScalar(0))) {
    // Solution is the zero vector
    x.setZero();
    iter = 0;
    relres = 0;
    return true;
  }
  // from http://homepage.tudelft.nl/1w5b5/IDRS/manual.pdf
  // A peak in the residual is considered dangerously high if‖ri‖/‖b‖> C(tol/epsilon).
  // With epsilon the relative machine precision. The factor tol/epsilon corresponds
  // to the size of a finite precision number that is so large that the absolute
  // round-off error in this number, when propagated through the process, makes it
  // impossible to achieve the required accuracy. The factor C accounts for the
  // accumulation of round-off errors. This parameter has been set to 10^{-3}.
  // mp is epsilon/C 10^3 * eps is very conservative, so normally no residual
  // replacements will take place. It only happens if things go very wrong. Too many
  // restarts may ruin the convergence.
  const RealScalar mp = RealScalar(1e3) * NumTraits<Scalar>::epsilon();
 
  // Compute initial residual
  const RealScalar tolb = tol * normb;  // Relative tolerance
  VectorType r = b - A * x;
 
  VectorType x_s, r_s;
 
  if (smoothing) {
    x_s = x;
    r_s = r;
  }
 
  RealScalar normr = r.stableNorm();
 
  if (normr <= tolb) {
    // Initial guess is a good enough solution
    iter = 0;
    relres = normr / normb;
    return true;
  }
 
  DenseMatrixType G = DenseMatrixType::Zero(N, S);
  DenseMatrixType U = DenseMatrixType::Zero(N, S);
  DenseMatrixType M = DenseMatrixType::Identity(S, S);
  VectorType t(N), v(N);
  Scalar om = 1.;
 
  // Main iteration loop, guild G-spaces:
  iter = 0;
 
  while (normr > tolb && iter < maxit) {
    // New right hand size for small system:
    VectorType f = (r.adjoint() * P).adjoint();
 
    for (Index k = 0; k < S; ++k) {
      // Solve small system and make v orthogonal to P:
      // c = M(k:s,k:s)\f(k:s);
      lu_solver.compute(M.block(k, k, S - k, S - k));
      VectorType c = lu_solver.solve(f.segment(k, S - k));
      // v = r - G(:,k:s)*c;
      v = r - G.rightCols(S - k) * c;
      // Preconditioning
      v = precond.solve(v);
 
      // Compute new U(:,k) and G(:,k), G(:,k) is in space G_j
      U.col(k) = U.rightCols(S - k) * c + om * v;
      G.col(k) = A * U.col(k);
 
      // Bi-Orthogonalise the new basis vectors:
      for (Index i = 0; i < k - 1; ++i) {
        // alpha =  ( P(:,i)'*G(:,k) )/M(i,i);
        Scalar alpha = P.col(i).dot(G.col(k)) / M(i, i);
        G.col(k) = G.col(k) - alpha * G.col(i);
        U.col(k) = U.col(k) - alpha * U.col(i);
      }
 
      // New column of M = P'*G  (first k-1 entries are zero)
      // M(k:s,k) = (G(:,k)'*P(:,k:s))';
      M.block(k, k, S - k, 1) = (G.col(k).adjoint() * P.rightCols(S - k)).adjoint();
 
      if (internal::isApprox(M(k, k), Scalar(0))) {
        return false;
      }
 
      // Make r orthogonal to q_i, i = 0..k-1
      Scalar beta = f(k) / M(k, k);
      r = r - beta * G.col(k);
      x = x + beta * U.col(k);
      normr = r.stableNorm();
 
      if (replacement && normr > tolb / mp) {
        trueres = true;
      }
 
      // Smoothing:
      if (smoothing) {
        t = r_s - r;
        // gamma is a Scalar, but the conversion is not allowed
        Scalar gamma = t.dot(r_s) / t.stableNorm();
        r_s = r_s - gamma * t;
        x_s = x_s - gamma * (x_s - x);
        normr = r_s.stableNorm();
      }
 
      if (normr < tolb || iter == maxit) {
        break;
      }
 
      // New f = P'*r (first k  components are zero)
      if (k < S - 1) {
        f.segment(k + 1, S - (k + 1)) = f.segment(k + 1, S - (k + 1)) - beta * M.block(k + 1, k, S - (k + 1), 1);
      }
    }  // end for
 
    if (normr < tolb || iter == maxit) {
      break;
    }
 
    // Now we have sufficient vectors in G_j to compute residual in G_j+1
    // Note: r is already perpendicular to P so v = r
    // Preconditioning
    v = r;
    v = precond.solve(v);
 
    // Matrix-vector multiplication:
    t = A * v;
 
    // Computation of a new omega
    om = internal::omega(t, r, angle);
 
    if (om == RealScalar(0.0)) {
      return false;
    }
 
    r = r - om * t;
    x = x + om * v;
    normr = r.stableNorm();
 
    if (replacement && normr > tolb / mp) {
      trueres = true;
    }
 
    // Residual replacement?
    if (trueres && normr < normb) {
      r = b - A * x;
      trueres = false;
    }
 
    // Smoothing:
    if (smoothing) {
      t = r_s - r;
      Scalar gamma = t.dot(r_s) / t.stableNorm();
      r_s = r_s - gamma * t;
      x_s = x_s - gamma * (x_s - x);
      normr = r_s.stableNorm();
    }
 
    iter++;
 
  }  // end while
 
  if (smoothing) {
    x = x_s;
  }
  relres = normr / normb;
  return true;
}

idrstabl()

template<typename MatrixType , typename Rhs , typename Dest , typename Preconditioner >

bool Eigen::internal::idrstabl	(	const MatrixType &	mat,
		const Rhs &	rhs,
		Dest &	x,
		const Preconditioner &	precond,
		Index &	iters,
		typename Dest::RealScalar &	tol_error,
		Index	L,
		Index	S
	)

Definition at line 46 of file IDRSTABL.h.

                                                                    {
  /*
    Setup and type definitions.
  */
  using numext::abs;
  using numext::sqrt;
  typedef typename Dest::Scalar Scalar;
  typedef typename Dest::RealScalar RealScalar;
  typedef Matrix<Scalar, Dynamic, 1> VectorType;
  typedef Matrix<Scalar, Dynamic, Dynamic, ColMajor> DenseMatrixType;
 
  const Index N = x.rows();
 
  Index k = 0;  // Iteration counter
  const Index maxIters = iters;
 
  const RealScalar rhs_norm = rhs.stableNorm();
  const RealScalar tol = tol_error * rhs_norm;
 
  if (rhs_norm == 0) {
    /*
      If b==0, then the exact solution is x=0.
      rhs_norm is needed for other calculations anyways, this exit is a freebie.
    */
    x.setZero();
    tol_error = 0.0;
    return true;
  }
  // Construct decomposition objects beforehand.
  FullPivLU<DenseMatrixType> lu_solver;
 
  if (S >= N || L >= N) {
    /*
      The matrix is very small, or the choice of L and S is very poor
      in that case solving directly will be best.
    */
    lu_solver.compute(DenseMatrixType(mat));
    x = lu_solver.solve(rhs);
    tol_error = (rhs - mat * x).stableNorm() / rhs_norm;
    return true;
  }
 
  // Define maximum sizes to prevent any reallocation later on.
  DenseMatrixType u(N, L + 1);
  DenseMatrixType r(N, L + 1);
 
  DenseMatrixType V(N * (L + 1), S);
 
  VectorType alpha(S);
  VectorType gamma(L);
  VectorType update(N);
 
  /*
    Main IDRSTABL algorithm
  */
  // Set up the initial residual
  VectorType x0 = x;
  r.col(0) = rhs - mat * x;
  x.setZero();  // The final solution will be x0+x
 
  tol_error = r.col(0).stableNorm();
 
  // FOM = Full orthogonalisation method
  DenseMatrixType h_FOM = DenseMatrixType::Zero(S, S - 1);
 
  // Construct an initial U matrix of size N x S
  DenseMatrixType U(N * (L + 1), S);
  for (Index col_index = 0; col_index < S; ++col_index) {
    // Arnoldi-like process to generate a set of orthogonal vectors spanning
    // {u,A*u,A*A*u,...,A^(S-1)*u}. This construction can be combined with the
    // Full Orthogonalization Method (FOM) from Ref.3 to provide a possible
    // early exit with no additional MV.
    if (col_index != 0) {
      /*
      Modified Gram-Schmidt strategy:
      */
      VectorType w = mat * precond.solve(u.col(0));
      for (Index i = 0; i < col_index; ++i) {
        auto v = U.col(i).head(N);
        h_FOM(i, col_index - 1) = v.dot(w);
        w -= h_FOM(i, col_index - 1) * v;
      }
      u.col(0) = w;
      h_FOM(col_index, col_index - 1) = u.col(0).stableNorm();
 
      if (abs(h_FOM(col_index, col_index - 1)) != RealScalar(0)) {
        /*
        This only happens if u is NOT exactly zero. In case it is exactly zero
        it would imply that that this u has no component in the direction of the
        current residual.
 
        By then setting u to zero it will not contribute any further (as it
        should). Whereas attempting to normalize results in division by zero.
 
        Such cases occur if:
        1. The basis of dimension <S is sufficient to exactly solve the linear
        system. I.e. the current residual is in span{r,Ar,...A^{m-1}r}, where
        (m-1)<=S.
        2. Two vectors vectors generated from r, Ar,... are (numerically)
        parallel.
 
        In case 1, the exact solution to the system can be obtained from the
        "Full Orthogonalization Method" (Algorithm 6.4 in the book of Saad),
        without any additional MV.
 
        Contrary to what one would suspect, the comparison with ==0.0 for
        floating-point types is intended here. Any arbritary non-zero u is fine
        to continue, however if u contains either NaN or Inf the algorithm will
        break down.
        */
        u.col(0) /= h_FOM(col_index, col_index - 1);
      }
    } else {
      u.col(0) = r.col(0);
      u.col(0).normalize();
    }
 
    U.col(col_index).head(N) = u.col(0);
  }
 
  if (S > 1) {
    // Check for early FOM exit.
    Scalar beta = r.col(0).stableNorm();
    VectorType e1 = VectorType::Zero(S - 1);
    e1(0) = beta;
    lu_solver.compute(h_FOM.topLeftCorner(S - 1, S - 1));
    VectorType y = lu_solver.solve(e1);
    VectorType x2 = x + U.topLeftCorner(N, S - 1) * y;
 
    // Using proposition 6.7 in Saad, one MV can be saved to calculate the
    // residual
    RealScalar FOM_residual = (h_FOM(S - 1, S - 2) * y(S - 2) * U.col(S - 1).head(N)).stableNorm();
 
    if (FOM_residual < tol) {
      // Exit, the FOM algorithm was already accurate enough
      iters = k;
      // Convert back to the unpreconditioned solution
      x = precond.solve(x2);
      // x contains the updates to x0, add those back to obtain the solution
      x += x0;
      tol_error = FOM_residual / rhs_norm;
      return true;
    }
  }
 
  /*
    Select an initial (N x S) matrix R0.
    1. Generate random R0, orthonormalize the result.
    2. This results in R0, however to save memory and compute we only need the
    adjoint of R0. This is given by the matrix R_T.\ Additionally, the matrix
    (mat.adjoint()*R_tilde).adjoint()=R_tilde.adjoint()*mat by the
    anti-distributivity property of the adjoint. This results in AR_T, which is
    constant if R_T does not have to be regenerated and can be precomputed.
    Based on reference 4, this has zero probability in exact arithmetic.
  */
 
  // Original IDRSTABL and Kensuke choose S random vectors:
  const HouseholderQR<DenseMatrixType> qr(DenseMatrixType::Random(N, S));
  DenseMatrixType R_T = (qr.householderQ() * DenseMatrixType::Identity(N, S)).adjoint();
  DenseMatrixType AR_T = DenseMatrixType(R_T * mat);
 
  // Pre-allocate sigma.
  DenseMatrixType sigma(S, S);
 
  bool reset_while = false;  // Should the while loop be reset for some reason?
 
  while (k < maxIters) {
    for (Index j = 1; j <= L; ++j) {
      /*
        The IDR Step
      */
      // Construction of the sigma-matrix, and the decomposition of sigma.
      for (Index i = 0; i < S; ++i) {
        sigma.col(i).noalias() = AR_T * precond.solve(U.block(N * (j - 1), i, N, 1));
      }
 
      lu_solver.compute(sigma);
      // Obtain the update coefficients alpha
      if (j == 1) {
        // alpha=inverse(sigma)*(R_T*r_0);
        alpha.noalias() = lu_solver.solve(R_T * r.col(0));
      } else {
        // alpha=inverse(sigma)*(AR_T*r_{j-2})
        alpha.noalias() = lu_solver.solve(AR_T * precond.solve(r.col(j - 2)));
      }
 
      // Obtain new solution and residual from this update
      update.noalias() = U.topRows(N) * alpha;
      r.col(0) -= mat * precond.solve(update);
      x += update;
 
      for (Index i = 1; i <= j - 2; ++i) {
        // This only affects the case L>2
        r.col(i) -= U.block(N * (i + 1), 0, N, S) * alpha;
      }
      if (j > 1) {
        // r=[r;A*r_{j-2}]
        r.col(j - 1).noalias() = mat * precond.solve(r.col(j - 2));
      }
      tol_error = r.col(0).stableNorm();
 
      if (tol_error < tol) {
        // If at this point the algorithm has converged, exit.
        reset_while = true;
        break;
      }
 
      bool break_normalization = false;
      for (Index q = 1; q <= S; ++q) {
        if (q == 1) {
          // u = r;
          u.leftCols(j + 1) = r.leftCols(j + 1);
        } else {
          // u=[u_1;u_2;...;u_j]
          u.leftCols(j) = u.middleCols(1, j);
        }
 
        // Obtain the update coefficients beta implicitly
        // beta=lu_sigma.solve(AR_T * u.block(N * (j - 1), 0, N, 1)
        u.reshaped().head(u.rows() * j) -= U.topRows(N * j) * lu_solver.solve(AR_T * precond.solve(u.col(j - 1)));
 
        // u=[u;Au_{j-1}]
        u.col(j).noalias() = mat * precond.solve(u.col(j - 1));
 
        // Orthonormalize u_j to the columns of V_j(:,1:q-1)
        if (q > 1) {
          /*
          Modified Gram-Schmidt-like procedure to make u orthogonal to the
          columns of V from Ref. 1.
 
          The vector mu from Ref. 1 is obtained implicitly:
          mu=V.block(N * j, 0, N, q - 1).adjoint() * u.block(N * j, 0, N, 1).
          */
          for (Index i = 0; i <= q - 2; ++i) {
            auto v = V.col(i).segment(N * j, N);
            Scalar h = v.squaredNorm();
            h = v.dot(u.col(j)) / h;
            u.reshaped().head(u.rows() * (j + 1)) -= h * V.block(0, i, N * (j + 1), 1);
          }
        }
        // Normalize u and assign to a column of V
        Scalar normalization_constant = u.col(j).stableNorm();
        //  If u is exactly zero, this will lead to a NaN. Small, non-zero u is
        //  fine.
        if (normalization_constant == RealScalar(0.0)) {
          break_normalization = true;
          break;
        } else {
          u.leftCols(j + 1) /= normalization_constant;
        }
 
        V.block(0, q - 1, N * (j + 1), 1).noalias() = u.reshaped().head(u.rows() * (j + 1));
      }
 
      if (break_normalization == false) {
        U = V;
      }
    }
    if (reset_while) {
      break;
    }
 
    // r=[r;mat*r_{L-1}]
    r.col(L).noalias() = mat * precond.solve(r.col(L - 1));
 
    /*
            The polynomial step
    */
    ColPivHouseholderQR<DenseMatrixType> qr_solver(r.rightCols(L));
    gamma.noalias() = qr_solver.solve(r.col(0));
 
    // Update solution and residual using the "minimized residual coefficients"
    update.noalias() = r.leftCols(L) * gamma;
    x += update;
    r.col(0) -= mat * precond.solve(update);
 
    // Update iteration info
    ++k;
    tol_error = r.col(0).stableNorm();
 
    if (tol_error < tol) {
      // Slightly early exit by moving the criterion before the update of U,
      // after the main while loop the result of that calculation would not be
      // needed.
      break;
    }
 
    /*
    U=U0-sum(gamma_j*U_j)
    Consider the first iteration. Then U only contains U0, so at the start of
    the while-loop U should be U0. Therefore only the first N rows of U have to
    be updated.
    */
    for (Index i = 1; i <= L; ++i) {
      U.topRows(N) -= U.block(N * i, 0, N, S) * gamma(i - 1);
    }
  }
 
  /*
          Exit after the while loop terminated.
  */
  iters = k;
  // Convert back to the unpreconditioned solution
  x = precond.solve(x);
  // x contains the updates to x0, add those back to obtain the solution
  x += x0;
  tol_error = tol_error / rhs_norm;
  return true;
}

igamma_num_iterations()

template<typename Scalar , IgammaComputationMode mode>

int Eigen::internal::igamma_num_iterations

(

)

Definition at line 746 of file SpecialFunctionsImpl.h.

                            {
  /* Returns the maximum number of internal iterations for igamma computation.
   */
  if (mode == VALUE) {
    return 2000;
  }
 
  if (internal::is_same<Scalar, float>::value) {
    return 200;
  } else if (internal::is_same<Scalar, double>::value) {
    return 500;
  } else {
    return 2000;
  }
}

index_known_statically()

template<typename T >

static EIGEN_CONSTEXPR bool Eigen::internal::index_known_statically ( Index  i )

static

Definition at line 617 of file TensorIndexList.h.

                                                                              {
  return index_known_statically_impl<T>::run(i);
}

index_pair_first_statically_eq()

template<typename T >

static EIGEN_CONSTEXPR bool Eigen::internal::index_pair_first_statically_eq ( Index  i, Index  value  )

static

Definition at line 652 of file TensorIndexList.h.

                                                                                                   {
  return index_pair_first_statically_eq_impl<T>::run(i, value);
}

index_pair_second_statically_eq()

template<typename T >

static EIGEN_CONSTEXPR bool Eigen::internal::index_pair_second_statically_eq ( Index  i, Index  value  )

static

Definition at line 657 of file TensorIndexList.h.

                                                                                                    {
  return index_pair_second_statically_eq_impl<T>::run(i, value);
}

index_statically_eq()

template<typename T >

static EIGEN_CONSTEXPR bool Eigen::internal::index_statically_eq ( Index  i, Index  value  )

static

Definition at line 632 of file TensorIndexList.h.

                                                                                        {
  return index_statically_eq_impl<T>::run(i, value);
}

index_statically_gt()

template<typename T >

static EIGEN_CONSTEXPR bool Eigen::internal::index_statically_gt ( Index  i, Index  value  )

static

Definition at line 642 of file TensorIndexList.h.

                                                                                        {
  return index_statically_gt_impl<T>::run(i, value);
}

index_statically_lt()

template<typename T >

static EIGEN_CONSTEXPR bool Eigen::internal::index_statically_lt ( Index  i, Index  value  )

static

Definition at line 647 of file TensorIndexList.h.

                                                                                        {
  return index_statically_lt_impl<T>::run(i, value);
}

index_statically_ne()

template<typename T >

static EIGEN_CONSTEXPR bool Eigen::internal::index_statically_ne ( Index  i, Index  value  )

static

Definition at line 637 of file TensorIndexList.h.

                                                                                        {
  return index_statically_ne_impl<T>::run(i, value);
}

indices_statically_known_to_increase()

template<typename T >

static EIGEN_CONSTEXPR bool Eigen::internal::indices_statically_known_to_increase ( )

static

Definition at line 627 of file TensorIndexList.h.

                                                                                     {
  return indices_statically_known_to_increase_impl<T>::run();
}

initialize_tensor()

template<typename Derived , int N>

void Eigen::internal::initialize_tensor	(	TensorEvaluator< Derived, DefaultDevice > &	tensor,
		const typename Initializer< Derived, traits< Derived >::NumDimensions >::InitList &	vals
	)

Definition at line 71 of file TensorInitializer.h.

                                                                                                        {
  Eigen::array<typename traits<Derived>::Index, traits<Derived>::NumDimensions> indices;
  Initializer<Derived, traits<Derived>::NumDimensions>::run(tensor, &indices, vals);
}

isApprox()

bool Eigen::internal::isApprox ( const mpfr::mpreal &  a, const mpfr::mpreal &  b, const mpfr::mpreal &  eps  )

inline

Definition at line 122 of file MPRealSupport.

  {
    return mpfr::isEqualFuzzy(a,b,eps);
  }

isApproxOrLessThan()

bool Eigen::internal::isApproxOrLessThan ( const mpfr::mpreal &  a, const mpfr::mpreal &  b, const mpfr::mpreal &  eps  )

inline

Definition at line 127 of file MPRealSupport.

  {
    return a <= b || mpfr::isEqualFuzzy(a,b,eps);
  }

isMuchSmallerThan()

bool Eigen::internal::isMuchSmallerThan ( const mpfr::mpreal &  a, const mpfr::mpreal &  b, const mpfr::mpreal &  eps  )

inline

Definition at line 117 of file MPRealSupport.

  {
    return mpfr::abs(a) <= mpfr::abs(b) * eps;
  }

LeafSize()

template<typename T >

Index Eigen::internal::LeafSize ( )

inline

Definition at line 233 of file TensorReduction.h.

{ return 1024; }

LeafSize< bfloat16 >()

template<>

Index Eigen::internal::LeafSize< bfloat16 > ( )

inline

Definition at line 237 of file TensorReduction.h.

{ return 128; }

LeafSize< half >()

template<>

Index Eigen::internal::LeafSize< half > ( )

inline

Definition at line 235 of file TensorReduction.h.

{ return 200; }

lmpar()

template<typename Scalar >

void Eigen::internal::lmpar	(	Matrix< Scalar, Dynamic, Dynamic > &	r,
		const VectorXi &	ipvt,
		const Matrix< Scalar, Dynamic, 1 > &	diag,
		const Matrix< Scalar, Dynamic, 1 > &	qtb,
		Scalar	delta,
		Scalar &	par,
		Matrix< Scalar, Dynamic, 1 > &	x
	)

Definition at line 8 of file lmpar.h.

{
    using std::abs;
    using std::sqrt;
    typedef DenseIndex Index;
 
    /* Local variables */
    Index i, j, l;
    Scalar fp;
    Scalar parc, parl;
    Index iter;
    Scalar temp, paru;
    Scalar gnorm;
    Scalar dxnorm;
 
 
    /* Function Body */
    const Scalar dwarf = (std::numeric_limits<Scalar>::min)();
    const Index n = r.cols();
    eigen_assert(n==diag.size());
    eigen_assert(n==qtb.size());
    eigen_assert(n==x.size());
 
    Matrix< Scalar, Dynamic, 1 >  wa1, wa2;
 
    /* compute and store in x the gauss-newton direction. if the */
    /* jacobian is rank-deficient, obtain a least squares solution. */
    Index nsing = n-1;
    wa1 = qtb;
    for (j = 0; j < n; ++j) {
        if (r(j,j) == 0. && nsing == n-1)
            nsing = j - 1;
        if (nsing < n-1)
            wa1[j] = 0.;
    }
    for (j = nsing; j>=0; --j) {
        wa1[j] /= r(j,j);
        temp = wa1[j];
        for (i = 0; i < j ; ++i)
            wa1[i] -= r(i,j) * temp;
    }
 
    for (j = 0; j < n; ++j)
        x[ipvt[j]] = wa1[j];
 
    /* initialize the iteration counter. */
    /* evaluate the function at the origin, and test */
    /* for acceptance of the gauss-newton direction. */
    iter = 0;
    wa2 = diag.cwiseProduct(x);
    dxnorm = wa2.blueNorm();
    fp = dxnorm - delta;
    if (fp <= Scalar(0.1) * delta) {
        par = 0;
        return;
    }
 
    /* if the jacobian is not rank deficient, the newton */
    /* step provides a lower bound, parl, for the zero of */
    /* the function. otherwise set this bound to zero. */
    parl = 0.;
    if (nsing >= n-1) {
        for (j = 0; j < n; ++j) {
            l = ipvt[j];
            wa1[j] = diag[l] * (wa2[l] / dxnorm);
        }
        // it's actually a triangularView.solveInplace(), though in a weird
        // way:
        for (j = 0; j < n; ++j) {
            Scalar sum = 0.;
            for (i = 0; i < j; ++i)
                sum += r(i,j) * wa1[i];
            wa1[j] = (wa1[j] - sum) / r(j,j);
        }
        temp = wa1.blueNorm();
        parl = fp / delta / temp / temp;
    }
 
    /* calculate an upper bound, paru, for the zero of the function. */
    for (j = 0; j < n; ++j)
        wa1[j] = r.col(j).head(j+1).dot(qtb.head(j+1)) / diag[ipvt[j]];
 
    gnorm = wa1.stableNorm();
    paru = gnorm / delta;
    if (paru == 0.)
        paru = dwarf / (std::min)(delta,Scalar(0.1));
 
    /* if the input par lies outside of the interval (parl,paru), */
    /* set par to the closer endpoint. */
    par = (std::max)(par,parl);
    par = (std::min)(par,paru);
    if (par == 0.)
        par = gnorm / dxnorm;
 
    /* beginning of an iteration. */
    while (true) {
        ++iter;
 
        /* evaluate the function at the current value of par. */
        if (par == 0.)
            par = (std::max)(dwarf,Scalar(.001) * paru); /* Computing MAX */
        wa1 = sqrt(par)* diag;
 
        Matrix< Scalar, Dynamic, 1 > sdiag(n);
        qrsolv<Scalar>(r, ipvt, wa1, qtb, x, sdiag);
 
        wa2 = diag.cwiseProduct(x);
        dxnorm = wa2.blueNorm();
        temp = fp;
        fp = dxnorm - delta;
 
        /* if the function is small enough, accept the current value */
        /* of par. also test for the exceptional cases where parl */
        /* is zero or the number of iterations has reached 10. */
        if (abs(fp) <= Scalar(0.1) * delta || (parl == 0. && fp <= temp && temp < 0.) || iter == 10)
            break;
 
        /* compute the newton correction. */
        for (j = 0; j < n; ++j) {
            l = ipvt[j];
            wa1[j] = diag[l] * (wa2[l] / dxnorm);
        }
        for (j = 0; j < n; ++j) {
            wa1[j] /= sdiag[j];
            temp = wa1[j];
            for (i = j+1; i < n; ++i)
                wa1[i] -= r(i,j) * temp;
        }
        temp = wa1.blueNorm();
        parc = fp / delta / temp / temp;
 
        /* depending on the sign of the function, update parl or paru. */
        if (fp > 0.)
            parl = (std::max)(parl,par);
        if (fp < 0.)
            paru = (std::min)(paru,par);
 
        /* compute an improved estimate for par. */
        /* Computing MAX */
        par = (std::max)(parl,par+parc);
 
        /* end of an iteration. */
    }
 
    /* termination. */
    if (iter == 0)
        par = 0.;
    return;
}

lmpar2() [1/2]

template<typename Scalar >

void Eigen::internal::lmpar2	(	const ColPivHouseholderQR< Matrix< Scalar, Dynamic, Dynamic > > &	qr,
		const Matrix< Scalar, Dynamic, 1 > &	diag,
		const Matrix< Scalar, Dynamic, 1 > &	qtb,
		Scalar	delta,
		Scalar &	par,
		Matrix< Scalar, Dynamic, 1 > &	x
	)

Definition at line 166 of file lmpar.h.

{
    using std::sqrt;
    using std::abs;
    typedef DenseIndex Index;
 
    /* Local variables */
    Index j;
    Scalar fp;
    Scalar parc, parl;
    Index iter;
    Scalar temp, paru;
    Scalar gnorm;
    Scalar dxnorm;
 
 
    /* Function Body */
    const Scalar dwarf = (std::numeric_limits<Scalar>::min)();
    const Index n = qr.matrixQR().cols();
    eigen_assert(n==diag.size());
    eigen_assert(n==qtb.size());
 
    Matrix< Scalar, Dynamic, 1 >  wa1, wa2;
 
    /* compute and store in x the gauss-newton direction. if the */
    /* jacobian is rank-deficient, obtain a least squares solution. */
 
//    const Index rank = qr.nonzeroPivots(); // exactly double(0.)
    const Index rank = qr.rank(); // use a threshold
    wa1 = qtb;
    wa1.tail(n-rank).setZero();
    qr.matrixQR().topLeftCorner(rank, rank).template triangularView<Upper>().solveInPlace(wa1.head(rank));
 
    x = qr.colsPermutation()*wa1;
 
    /* initialize the iteration counter. */
    /* evaluate the function at the origin, and test */
    /* for acceptance of the gauss-newton direction. */
    iter = 0;
    wa2 = diag.cwiseProduct(x);
    dxnorm = wa2.blueNorm();
    fp = dxnorm - delta;
    if (fp <= Scalar(0.1) * delta) {
        par = 0;
        return;
    }
 
    /* if the jacobian is not rank deficient, the newton */
    /* step provides a lower bound, parl, for the zero of */
    /* the function. otherwise set this bound to zero. */
    parl = 0.;
    if (rank==n) {
        wa1 = qr.colsPermutation().inverse() *  diag.cwiseProduct(wa2)/dxnorm;
        qr.matrixQR().topLeftCorner(n, n).transpose().template triangularView<Lower>().solveInPlace(wa1);
        temp = wa1.blueNorm();
        parl = fp / delta / temp / temp;
    }
 
    /* calculate an upper bound, paru, for the zero of the function. */
    for (j = 0; j < n; ++j)
        wa1[j] = qr.matrixQR().col(j).head(j+1).dot(qtb.head(j+1)) / diag[qr.colsPermutation().indices()(j)];
 
    gnorm = wa1.stableNorm();
    paru = gnorm / delta;
    if (paru == 0.)
        paru = dwarf / (std::min)(delta,Scalar(0.1));
 
    /* if the input par lies outside of the interval (parl,paru), */
    /* set par to the closer endpoint. */
    par = (std::max)(par,parl);
    par = (std::min)(par,paru);
    if (par == 0.)
        par = gnorm / dxnorm;
 
    /* beginning of an iteration. */
    Matrix< Scalar, Dynamic, Dynamic > s = qr.matrixQR();
    while (true) {
        ++iter;
 
        /* evaluate the function at the current value of par. */
        if (par == 0.)
            par = (std::max)(dwarf,Scalar(.001) * paru); /* Computing MAX */
        wa1 = sqrt(par)* diag;
 
        Matrix< Scalar, Dynamic, 1 > sdiag(n);
        qrsolv<Scalar>(s, qr.colsPermutation().indices(), wa1, qtb, x, sdiag);
 
        wa2 = diag.cwiseProduct(x);
        dxnorm = wa2.blueNorm();
        temp = fp;
        fp = dxnorm - delta;
 
        /* if the function is small enough, accept the current value */
        /* of par. also test for the exceptional cases where parl */
        /* is zero or the number of iterations has reached 10. */
        if (abs(fp) <= Scalar(0.1) * delta || (parl == 0. && fp <= temp && temp < 0.) || iter == 10)
            break;
 
        /* compute the newton correction. */
        wa1 = qr.colsPermutation().inverse() * diag.cwiseProduct(wa2/dxnorm);
        // we could almost use this here, but the diagonal is outside qr, in sdiag[]
        // qr.matrixQR().topLeftCorner(n, n).transpose().template triangularView<Lower>().solveInPlace(wa1);
        for (j = 0; j < n; ++j) {
            wa1[j] /= sdiag[j];
            temp = wa1[j];
            for (Index i = j+1; i < n; ++i)
                wa1[i] -= s(i,j) * temp;
        }
        temp = wa1.blueNorm();
        parc = fp / delta / temp / temp;
 
        /* depending on the sign of the function, update parl or paru. */
        if (fp > 0.)
            parl = (std::max)(parl,par);
        if (fp < 0.)
            paru = (std::min)(paru,par);
 
        /* compute an improved estimate for par. */
        par = (std::max)(parl,par+parc);
    }
    if (iter == 0)
        par = 0.;
    return;
}

lmpar2() [2/2]

template<typename QRSolver , typename VectorType >

void Eigen::internal::lmpar2	(	const QRSolver &	qr,
		const VectorType &	diag,
		const VectorType &	qtb,
		typename VectorType::Scalar	m_delta,
		typename VectorType::Scalar &	par,
		VectorType &	x
	)

Definition at line 22 of file LMpar.h.

  {
    using std::sqrt;
    using std::abs;
    typedef typename QRSolver::MatrixType MatrixType;
    typedef typename QRSolver::Scalar Scalar;
//    typedef typename QRSolver::StorageIndex StorageIndex;
 
    /* Local variables */
    Index j;
    Scalar fp;
    Scalar parc, parl;
    Index iter;
    Scalar temp, paru;
    Scalar gnorm;
    Scalar dxnorm;
    
    // Make a copy of the triangular factor. 
    // This copy is modified during call the qrsolv
    MatrixType s;
    s = qr.matrixR();
 
    /* Function Body */
    const Scalar dwarf = (std::numeric_limits<Scalar>::min)();
    const Index n = qr.matrixR().cols();
    eigen_assert(n==diag.size());
    eigen_assert(n==qtb.size());
 
    VectorType  wa1, wa2;
 
    /* compute and store in x the gauss-newton direction. if the */
    /* jacobian is rank-deficient, obtain a least squares solution. */
 
    //    const Index rank = qr.nonzeroPivots(); // exactly double(0.)
    const Index rank = qr.rank(); // use a threshold
    wa1 = qtb;
    wa1.tail(n-rank).setZero();
    //FIXME There is no solve in place for sparse triangularView
    wa1.head(rank) = s.topLeftCorner(rank,rank).template triangularView<Upper>().solve(qtb.head(rank));
 
    x = qr.colsPermutation()*wa1;
 
    /* initialize the iteration counter. */
    /* evaluate the function at the origin, and test */
    /* for acceptance of the gauss-newton direction. */
    iter = 0;
    wa2 = diag.cwiseProduct(x);
    dxnorm = wa2.blueNorm();
    fp = dxnorm - m_delta;
    if (fp <= Scalar(0.1) * m_delta) {
      par = 0;
      return;
    }
 
    /* if the jacobian is not rank deficient, the newton */
    /* step provides a lower bound, parl, for the zero of */
    /* the function. otherwise set this bound to zero. */
    parl = 0.;
    if (rank==n) {
      wa1 = qr.colsPermutation().inverse() *  diag.cwiseProduct(wa2)/dxnorm;
      s.topLeftCorner(n,n).transpose().template triangularView<Lower>().solveInPlace(wa1);
      temp = wa1.blueNorm();
      parl = fp / m_delta / temp / temp;
    }
 
    /* calculate an upper bound, paru, for the zero of the function. */
    for (j = 0; j < n; ++j)
      wa1[j] = s.col(j).head(j+1).dot(qtb.head(j+1)) / diag[qr.colsPermutation().indices()(j)];
 
    gnorm = wa1.stableNorm();
    paru = gnorm / m_delta;
    if (paru == 0.)
      paru = dwarf / (std::min)(m_delta,Scalar(0.1));
 
    /* if the input par lies outside of the interval (parl,paru), */
    /* set par to the closer endpoint. */
    par = (std::max)(par,parl);
    par = (std::min)(par,paru);
    if (par == 0.)
      par = gnorm / dxnorm;
 
    /* beginning of an iteration. */
    while (true) {
      ++iter;
 
      /* evaluate the function at the current value of par. */
      if (par == 0.)
        par = (std::max)(dwarf,Scalar(.001) * paru); /* Computing MAX */
      wa1 = sqrt(par)* diag;
 
      VectorType sdiag(n);
      lmqrsolv(s, qr.colsPermutation(), wa1, qtb, x, sdiag);
 
      wa2 = diag.cwiseProduct(x);
      dxnorm = wa2.blueNorm();
      temp = fp;
      fp = dxnorm - m_delta;
 
      /* if the function is small enough, accept the current value */
      /* of par. also test for the exceptional cases where parl */
      /* is zero or the number of iterations has reached 10. */
      if (abs(fp) <= Scalar(0.1) * m_delta || (parl == 0. && fp <= temp && temp < 0.) || iter == 10)
        break;
 
      /* compute the newton correction. */
      wa1 = qr.colsPermutation().inverse() * diag.cwiseProduct(wa2/dxnorm);
      // we could almost use this here, but the diagonal is outside qr, in sdiag[]
      for (j = 0; j < n; ++j) {
        wa1[j] /= sdiag[j];
        temp = wa1[j];
        for (Index i = j+1; i < n; ++i)
          wa1[i] -= s.coeff(i,j) * temp;
      }
      temp = wa1.blueNorm();
      parc = fp / m_delta / temp / temp;
 
      /* depending on the sign of the function, update parl or paru. */
      if (fp > 0.)
        parl = (std::max)(parl,par);
      if (fp < 0.)
        paru = (std::min)(paru,par);
 
      /* compute an improved estimate for par. */
      par = (std::max)(parl,par+parc);
    }
    if (iter == 0)
      par = 0.;
    return;
  }

lmqrsolv() [1/2]

template<typename Scalar , int Rows, int Cols, typename PermIndex >

void Eigen::internal::lmqrsolv	(	Matrix< Scalar, Rows, Cols > &	s,
		const PermutationMatrix< Dynamic, Dynamic, PermIndex > &	iPerm,
		const Matrix< Scalar, Dynamic, 1 > &	diag,
		const Matrix< Scalar, Dynamic, 1 > &	qtb,
		Matrix< Scalar, Dynamic, 1 > &	x,
		Matrix< Scalar, Dynamic, 1 > &	sdiag
	)

Definition at line 25 of file LMqrsolv.h.

{
    /* Local variables */
    Index i, j, k;
    Scalar temp;
    Index n = s.cols();
    Matrix<Scalar,Dynamic,1>  wa(n);
    JacobiRotation<Scalar> givens;
 
    /* Function Body */
    // the following will only change the lower triangular part of s, including
    // the diagonal, though the diagonal is restored afterward
 
    /*     copy r and (q transpose)*b to preserve input and initialize s. */
    /*     in particular, save the diagonal elements of r in x. */
    x = s.diagonal();
    wa = qtb;
    
   
    s.topLeftCorner(n,n).template triangularView<StrictlyLower>() = s.topLeftCorner(n,n).transpose();
    /*     eliminate the diagonal matrix d using a givens rotation. */
    for (j = 0; j < n; ++j) {
 
        /*        prepare the row of d to be eliminated, locating the */
        /*        diagonal element using p from the qr factorization. */
        const PermIndex l = iPerm.indices()(j);
        if (diag[l] == 0.)
            break;
        sdiag.tail(n-j).setZero();
        sdiag[j] = diag[l];
 
        /*        the transformations to eliminate the row of d */
        /*        modify only a single element of (q transpose)*b */
        /*        beyond the first n, which is initially zero. */
        Scalar qtbpj = 0.;
        for (k = j; k < n; ++k) {
            /*           determine a givens rotation which eliminates the */
            /*           appropriate element in the current row of d. */
            givens.makeGivens(-s(k,k), sdiag[k]);
 
            /*           compute the modified diagonal element of r and */
            /*           the modified element of ((q transpose)*b,0). */
            s(k,k) = givens.c() * s(k,k) + givens.s() * sdiag[k];
            temp = givens.c() * wa[k] + givens.s() * qtbpj;
            qtbpj = -givens.s() * wa[k] + givens.c() * qtbpj;
            wa[k] = temp;
 
            /*           accumulate the transformation in the row of s. */
            for (i = k+1; i<n; ++i) {
                temp = givens.c() * s(i,k) + givens.s() * sdiag[i];
                sdiag[i] = -givens.s() * s(i,k) + givens.c() * sdiag[i];
                s(i,k) = temp;
            }
        }
    }
  
    /*     solve the triangular system for z. if the system is */
    /*     singular, then obtain a least squares solution. */
    Index nsing;
    for(nsing=0; nsing<n && sdiag[nsing]!=0; nsing++) {}
 
    wa.tail(n-nsing).setZero();
    s.topLeftCorner(nsing, nsing).transpose().template triangularView<Upper>().solveInPlace(wa.head(nsing));
  
    // restore
    sdiag = s.diagonal();
    s.diagonal() = x;
 
    /* permute the components of z back to components of x. */
    x = iPerm * wa; 
}

lmqrsolv() [2/2]

template<typename Scalar , int Options_, typename Index >

void Eigen::internal::lmqrsolv	(	SparseMatrix< Scalar, Options_, Index > &	s,
		const PermutationMatrix< Dynamic, Dynamic > &	iPerm,
		const Matrix< Scalar, Dynamic, 1 > &	diag,
		const Matrix< Scalar, Dynamic, 1 > &	qtb,
		Matrix< Scalar, Dynamic, 1 > &	x,
		Matrix< Scalar, Dynamic, 1 > &	sdiag
	)

Definition at line 104 of file LMqrsolv.h.

{
  /* Local variables */
  typedef SparseMatrix<Scalar,RowMajor,Index> FactorType;
    Index i, j, k, l;
    Scalar temp;
    Index n = s.cols();
    Matrix<Scalar,Dynamic,1>  wa(n);
    JacobiRotation<Scalar> givens;
 
    /* Function Body */
    // the following will only change the lower triangular part of s, including
    // the diagonal, though the diagonal is restored afterward
 
    /*     copy r and (q transpose)*b to preserve input and initialize R. */
    wa = qtb;
    FactorType R(s);
    // Eliminate the diagonal matrix d using a givens rotation
    for (j = 0; j < n; ++j)
    {
      // Prepare the row of d to be eliminated, locating the 
      // diagonal element using p from the qr factorization
      l = iPerm.indices()(j);
      if (diag(l) == Scalar(0)) 
        break; 
      sdiag.tail(n-j).setZero();
      sdiag[j] = diag[l];
      // the transformations to eliminate the row of d
      // modify only a single element of (q transpose)*b
      // beyond the first n, which is initially zero. 
      
      Scalar qtbpj = 0; 
      // Browse the nonzero elements of row j of the upper triangular s
      for (k = j; k < n; ++k)
      {
        typename FactorType::InnerIterator itk(R,k);
        for (; itk; ++itk){
          if (itk.index() < k) continue;
          else break;
        }
        //At this point, we have the diagonal element R(k,k)
        // Determine a givens rotation which eliminates 
        // the appropriate element in the current row of d
        givens.makeGivens(-itk.value(), sdiag(k));
        
        // Compute the modified diagonal element of r and 
        // the modified element of ((q transpose)*b,0).
        itk.valueRef() = givens.c() * itk.value() + givens.s() * sdiag(k);
        temp = givens.c() * wa(k) + givens.s() * qtbpj; 
        qtbpj = -givens.s() * wa(k) + givens.c() * qtbpj;
        wa(k) = temp;
        
        // Accumulate the transformation in the remaining k row/column of R
        for (++itk; itk; ++itk)
        {
          i = itk.index();
          temp = givens.c() *  itk.value() + givens.s() * sdiag(i);
          sdiag(i) = -givens.s() * itk.value() + givens.c() * sdiag(i);
          itk.valueRef() = temp;
        }
      }
    }
    
    // Solve the triangular system for z. If the system is 
    // singular, then obtain a least squares solution
    Index nsing;
    for(nsing = 0; nsing<n && sdiag(nsing) !=0; nsing++) {}
    
    wa.tail(n-nsing).setZero();
//     x = wa; 
    wa.head(nsing) = R.topLeftCorner(nsing,nsing).template triangularView<Upper>().solve/*InPlace*/(wa.head(nsing));
    
    sdiag = R.diagonal();
    // Permute the components of z back to components of x
    x = iPerm * wa; 
}

loadConstant()

template<typename T >

EIGEN_ALWAYS_INLINE T Eigen::internal::loadConstant

(

const T *

address

)

Definition at line 194 of file TensorEvaluator.h.

                                 {
  return *address;
}

main_igamma_term()

template<typename Scalar >

static Scalar Eigen::internal::main_igamma_term ( Scalar  a, Scalar  x  )

inlinestatic

Definition at line 733 of file SpecialFunctionsImpl.h.

                                                                       {
    /* Compute  x**a * exp(-x) / gamma(a)  */
    Scalar logax = a * numext::log(x) - x - lgamma_impl<Scalar>::run(a);
    if (logax < -numext::log(NumTraits<Scalar>::highest()) ||
        // Assuming x and a aren't Nan.
        (numext::isnan)(logax)) {
      return Scalar(0);
    }
    return numext::exp(logax);
}

make_coherent()

template<typename A , typename B >

void Eigen::internal::make_coherent	(	const A &	a,
		const B &	b
	)

Definition at line 26 of file AutoDiffScalar.h.

{
  make_coherent_impl<A,B>::run(a.const_cast_derived(), b.const_cast_derived());
}

make_coherent_expression() [1/3]

template<typename UnaryOp , typename A , typename RefType >

void Eigen::internal::make_coherent_expression	(	const CwiseNullaryOp< UnaryOp, A > &	,
		const RefType &
	)

Definition at line 473 of file AutoDiffScalar.h.

{}

make_coherent_expression() [2/3]

template<typename UnaryOp , typename A , typename RefType >

void Eigen::internal::make_coherent_expression	(	const CwiseUnaryOp< UnaryOp, A > &	xpr,
		const RefType &	ref
	)

Definition at line 466 of file AutoDiffScalar.h.

{
  make_coherent(xpr.nestedExpression().const_cast_derived(), ref);
}

make_coherent_expression() [3/3]

template<typename BinOp , typename A , typename B , typename RefType >

void Eigen::internal::make_coherent_expression	(	CwiseBinaryOp< BinOp, A, B >	xpr,
		const RefType &	ref
	)

Definition at line 459 of file AutoDiffScalar.h.

{
  make_coherent(xpr.const_cast_derived().lhs(), ref);
  make_coherent(xpr.const_cast_derived().rhs(), ref);
}

matrix_exp_compute() [1/2]

template<typename ArgType , typename ResultType >

void Eigen::internal::matrix_exp_compute	(	const ArgType &	arg,
		ResultType &	result,
		false_type
	)

Definition at line 377 of file MatrixExponential.h.

{
  typedef typename ArgType::PlainObject MatrixType;
  typedef typename traits<MatrixType>::Scalar Scalar;
  typedef typename NumTraits<Scalar>::Real RealScalar;
  typedef typename std::complex<RealScalar> ComplexScalar;
  result = arg.matrixFunction(internal::stem_function_exp<ComplexScalar>);
}

matrix_exp_compute() [2/2]

template<typename ArgType , typename ResultType >

void Eigen::internal::matrix_exp_compute	(	const ArgType &	arg,
		ResultType &	result,
		true_type
	)

Definition at line 357 of file MatrixExponential.h.

{
  typedef typename ArgType::PlainObject MatrixType;
  MatrixType U, V;
  int squarings;
  matrix_exp_computeUV<MatrixType>::run(arg, U, V, squarings); // Pade approximant is (U+V) / (-U+V)
  MatrixType numer = U + V;
  MatrixType denom = -U + V;
  result = denom.partialPivLu().solve(numer);
  for (int i=0; i<squarings; i++)
    result *= result;   // undo scaling by repeated squaring
}

matrix_exp_pade13()

template<typename MatA , typename MatU , typename MatV >

void Eigen::internal::matrix_exp_pade13	(	const MatA &	A,
		MatU &	U,
		MatV &	V
	)

Compute the (13,13)-Padé approximant to the exponential.

After exit, \( (V+U)(V-U)^{-1} \) is the Padé approximant of \( \exp(A) \) around \( A = 0 \).

Definition at line 145 of file MatrixExponential.h.

{
  typedef typename MatA::PlainObject MatrixType;
  typedef typename NumTraits<typename traits<MatrixType>::Scalar>::Real RealScalar;
  const RealScalar b[] = {64764752532480000.L, 32382376266240000.L, 7771770303897600.L,
                          1187353796428800.L, 129060195264000.L, 10559470521600.L, 670442572800.L,
                          33522128640.L, 1323241920.L, 40840800.L, 960960.L, 16380.L, 182.L, 1.L};
  const MatrixType A2 = A * A;
  const MatrixType A4 = A2 * A2;
  const MatrixType A6 = A4 * A2;
  V = b[13] * A6 + b[11] * A4 + b[9] * A2; // used for temporary storage
  MatrixType tmp = A6 * V;
  tmp += b[7] * A6 + b[5] * A4 + b[3] * A2 + b[1] * MatrixType::Identity(A.rows(), A.cols());
  U.noalias() = A * tmp;
  tmp = b[12] * A6 + b[10] * A4 + b[8] * A2;
  V.noalias() = A6 * tmp;
  V += b[6] * A6 + b[4] * A4 + b[2] * A2 + b[0] * MatrixType::Identity(A.rows(), A.cols());
}

matrix_exp_pade3()

template<typename MatA , typename MatU , typename MatV >

void Eigen::internal::matrix_exp_pade3	(	const MatA &	A,
		MatU &	U,
		MatV &	V
	)

Compute the (3,3)-Padé approximant to the exponential.

After exit, \( (V+U)(V-U)^{-1} \) is the Padé approximant of \( \exp(A) \) around \( A = 0 \).

Definition at line 67 of file MatrixExponential.h.

{
  typedef typename MatA::PlainObject MatrixType;
  typedef typename NumTraits<typename traits<MatA>::Scalar>::Real RealScalar;
  const RealScalar b[] = {120.L, 60.L, 12.L, 1.L};
  const MatrixType A2 = A * A;
  const MatrixType tmp = b[3] * A2 + b[1] * MatrixType::Identity(A.rows(), A.cols());
  U.noalias() = A * tmp;
  V = b[2] * A2 + b[0] * MatrixType::Identity(A.rows(), A.cols());
}

matrix_exp_pade5()

template<typename MatA , typename MatU , typename MatV >

void Eigen::internal::matrix_exp_pade5	(	const MatA &	A,
		MatU &	U,
		MatV &	V
	)

Compute the (5,5)-Padé approximant to the exponential.

After exit, \( (V+U)(V-U)^{-1} \) is the Padé approximant of \( \exp(A) \) around \( A = 0 \).

Definition at line 84 of file MatrixExponential.h.

{
  typedef typename MatA::PlainObject MatrixType;
  typedef typename NumTraits<typename traits<MatrixType>::Scalar>::Real RealScalar;
  const RealScalar b[] = {30240.L, 15120.L, 3360.L, 420.L, 30.L, 1.L};
  const MatrixType A2 = A * A;
  const MatrixType A4 = A2 * A2;
  const MatrixType tmp = b[5] * A4 + b[3] * A2 + b[1] * MatrixType::Identity(A.rows(), A.cols());
  U.noalias() = A * tmp;
  V = b[4] * A4 + b[2] * A2 + b[0] * MatrixType::Identity(A.rows(), A.cols());
}

matrix_exp_pade7()

template<typename MatA , typename MatU , typename MatV >

void Eigen::internal::matrix_exp_pade7	(	const MatA &	A,
		MatU &	U,
		MatV &	V
	)

Compute the (7,7)-Padé approximant to the exponential.

After exit, \( (V+U)(V-U)^{-1} \) is the Padé approximant of \( \exp(A) \) around \( A = 0 \).

Definition at line 102 of file MatrixExponential.h.

{
  typedef typename MatA::PlainObject MatrixType;
  typedef typename NumTraits<typename traits<MatrixType>::Scalar>::Real RealScalar;
  const RealScalar b[] = {17297280.L, 8648640.L, 1995840.L, 277200.L, 25200.L, 1512.L, 56.L, 1.L};
  const MatrixType A2 = A * A;
  const MatrixType A4 = A2 * A2;
  const MatrixType A6 = A4 * A2;
  const MatrixType tmp = b[7] * A6 + b[5] * A4 + b[3] * A2 
    + b[1] * MatrixType::Identity(A.rows(), A.cols());
  U.noalias() = A * tmp;
  V = b[6] * A6 + b[4] * A4 + b[2] * A2 + b[0] * MatrixType::Identity(A.rows(), A.cols());
 
}

matrix_exp_pade9()

template<typename MatA , typename MatU , typename MatV >

void Eigen::internal::matrix_exp_pade9	(	const MatA &	A,
		MatU &	U,
		MatV &	V
	)

Compute the (9,9)-Padé approximant to the exponential.

After exit, \( (V+U)(V-U)^{-1} \) is the Padé approximant of \( \exp(A) \) around \( A = 0 \).

Definition at line 123 of file MatrixExponential.h.

{
  typedef typename MatA::PlainObject MatrixType;
  typedef typename NumTraits<typename traits<MatrixType>::Scalar>::Real RealScalar;
  const RealScalar b[] = {17643225600.L, 8821612800.L, 2075673600.L, 302702400.L, 30270240.L,
                          2162160.L, 110880.L, 3960.L, 90.L, 1.L};
  const MatrixType A2 = A * A;
  const MatrixType A4 = A2 * A2;
  const MatrixType A6 = A4 * A2;
  const MatrixType A8 = A6 * A2;
  const MatrixType tmp = b[9] * A8 + b[7] * A6 + b[5] * A4 + b[3] * A2 
    + b[1] * MatrixType::Identity(A.rows(), A.cols());
  U.noalias() = A * tmp;
  V = b[8] * A8 + b[6] * A6 + b[4] * A4 + b[2] * A2 + b[0] * MatrixType::Identity(A.rows(), A.cols());
}

matrix_function_compute_above_diagonal()

template<typename MatrixType , typename VectorType >

void Eigen::internal::matrix_function_compute_above_diagonal	(	const MatrixType &	T,
		const VectorType &	blockStart,
		const VectorType &	clusterSize,
		MatrixType &	fT
	)

Compute part of matrix function above block diagonal.

This routine completes the computation of fT, denoting a matrix function applied to the triangular matrix T. It assumes that the block diagonal part of fT has already been computed. The part below the diagonal is zero, because T is upper triangular.

Definition at line 325 of file MatrixFunction.h.

{ 
  typedef internal::traits<MatrixType> Traits;
  typedef typename MatrixType::Scalar Scalar;
  static const int Options = MatrixType::Options;
  typedef Matrix<Scalar, Dynamic, Dynamic, Options, Traits::RowsAtCompileTime, Traits::ColsAtCompileTime> DynMatrixType;
 
  for (Index k = 1; k < clusterSize.rows(); k++) {
    for (Index i = 0; i < clusterSize.rows() - k; i++) {
      // compute (i, i+k) block
      DynMatrixType A = T.block(blockStart(i), blockStart(i), clusterSize(i), clusterSize(i));
      DynMatrixType B = -T.block(blockStart(i+k), blockStart(i+k), clusterSize(i+k), clusterSize(i+k));
      DynMatrixType C = fT.block(blockStart(i), blockStart(i), clusterSize(i), clusterSize(i))
        * T.block(blockStart(i), blockStart(i+k), clusterSize(i), clusterSize(i+k));
      C -= T.block(blockStart(i), blockStart(i+k), clusterSize(i), clusterSize(i+k))
        * fT.block(blockStart(i+k), blockStart(i+k), clusterSize(i+k), clusterSize(i+k));
      for (Index m = i + 1; m < i + k; m++) {
        C += fT.block(blockStart(i), blockStart(m), clusterSize(i), clusterSize(m))
          * T.block(blockStart(m), blockStart(i+k), clusterSize(m), clusterSize(i+k));
        C -= T.block(blockStart(i), blockStart(m), clusterSize(i), clusterSize(m))
          * fT.block(blockStart(m), blockStart(i+k), clusterSize(m), clusterSize(i+k));
      }
      fT.block(blockStart(i), blockStart(i+k), clusterSize(i), clusterSize(i+k))
        = matrix_function_solve_triangular_sylvester(A, B, C);
    }
  }
}

matrix_function_compute_block_atomic()

template<typename MatrixType , typename AtomicType , typename VectorType >

void Eigen::internal::matrix_function_compute_block_atomic	(	const MatrixType &	T,
		AtomicType &	atomic,
		const VectorType &	blockStart,
		const VectorType &	clusterSize,
		MatrixType &	fT
	)

Compute block diagonal part of matrix function.

This routine computes the matrix function applied to the block diagonal part of T (which should be upper triangular), with the blocking given by blockStart and clusterSize. The matrix function of each diagonal block is computed by atomic. The off-diagonal parts of fT are set to zero.

Definition at line 244 of file MatrixFunction.h.

{ 
  fT.setZero(T.rows(), T.cols());
  for (Index i = 0; i < clusterSize.rows(); ++i) {
    fT.block(blockStart(i), blockStart(i), clusterSize(i), clusterSize(i))
      = atomic.compute(T.block(blockStart(i), blockStart(i), clusterSize(i), clusterSize(i)));
  }
}

matrix_function_compute_block_start()

template<typename VectorType >

void Eigen::internal::matrix_function_compute_block_start	(	const VectorType &	clusterSize,
		VectorType &	blockStart
	)

Compute start of each block using clusterSize.

Definition at line 178 of file MatrixFunction.h.

{
  blockStart.resize(clusterSize.rows());
  blockStart(0) = 0;
  for (Index i = 1; i < clusterSize.rows(); i++) {
    blockStart(i) = blockStart(i-1) + clusterSize(i-1);
  }
}

matrix_function_compute_cluster_size()

template<typename ListOfClusters , typename Index >

void Eigen::internal::matrix_function_compute_cluster_size	(	const ListOfClusters &	clusters,
		Matrix< Index, Dynamic, 1 > &	clusterSize
	)

Compute size of each cluster given a partitioning.

Definition at line 165 of file MatrixFunction.h.

{
  const Index numClusters = static_cast<Index>(clusters.size());
  clusterSize.setZero(numClusters);
  Index clusterIndex = 0;
  for (typename ListOfClusters::const_iterator cluster = clusters.begin(); cluster != clusters.end(); ++cluster) {
    clusterSize[clusterIndex] = cluster->size();
    ++clusterIndex;
  }
}

matrix_function_compute_map()

template<typename EivalsType , typename ListOfClusters , typename VectorType >

void Eigen::internal::matrix_function_compute_map	(	const EivalsType &	eivals,
		const ListOfClusters &	clusters,
		VectorType &	eivalToCluster
	)

Compute mapping of eigenvalue indices to cluster indices.

Definition at line 189 of file MatrixFunction.h.

{
  eivalToCluster.resize(eivals.rows());
  Index clusterIndex = 0;
  for (typename ListOfClusters::const_iterator cluster = clusters.begin(); cluster != clusters.end(); ++cluster) {
    for (Index i = 0; i < eivals.rows(); ++i) {
      if (std::find(cluster->begin(), cluster->end(), i) != cluster->end()) {
        eivalToCluster[i] = clusterIndex;
      }
    }
    ++clusterIndex;
  }
}

matrix_function_compute_mu()

template<typename MatrixType >

NumTraits<typename MatrixType::Scalar>::Real Eigen::internal::matrix_function_compute_mu

(

const MatrixType &

A

)

Definition at line 55 of file MatrixFunction.h.

{
  typedef typename plain_col_type<MatrixType>::type VectorType;
  Index rows = A.rows();
  const MatrixType N = MatrixType::Identity(rows, rows) - A;
  VectorType e = VectorType::Ones(rows);
  N.template triangularView<Upper>().solveInPlace(e);
  return e.cwiseAbs().maxCoeff();
}

matrix_function_compute_permutation()

template<typename DynVectorType , typename VectorType >

void Eigen::internal::matrix_function_compute_permutation	(	const DynVectorType &	blockStart,
		const DynVectorType &	eivalToCluster,
		VectorType &	permutation
	)

Compute permutation which groups ei'vals in same cluster together.

Definition at line 205 of file MatrixFunction.h.

{
  DynVectorType indexNextEntry = blockStart;
  permutation.resize(eivalToCluster.rows());
  for (Index i = 0; i < eivalToCluster.rows(); i++) {
    Index cluster = eivalToCluster[i];
    permutation[i] = indexNextEntry[cluster];
    ++indexNextEntry[cluster];
  }
}  

matrix_function_find_cluster()

template<typename Index , typename ListOfClusters >

ListOfClusters::iterator Eigen::internal::matrix_function_find_cluster	(	Index	key,
		ListOfClusters &	clusters
	)

Find cluster in clusters containing some value.

Parameters

[in]

key

Value to find

Returns

Iterator to cluster containing key, or clusters.end() if no cluster in m_clusters contains key.

Definition at line 110 of file MatrixFunction.h.

{
  typename std::list<Index>::iterator j;
  for (typename ListOfClusters::iterator i = clusters.begin(); i != clusters.end(); ++i) {
    j = std::find(i->begin(), i->end(), key);
    if (j != i->end())
      return i;
  }
  return clusters.end();
}

matrix_function_partition_eigenvalues()

template<typename EivalsType , typename Cluster >

void Eigen::internal::matrix_function_partition_eigenvalues	(	const EivalsType &	eivals,
		std::list< Cluster > &	clusters
	)

Partition eigenvalues in clusters of ei'vals close to each other.

Parameters

[in]	eivals	Eigenvalues
[out]	clusters	Resulting partition of eigenvalues

The partition satisfies the following two properties:

Any eigenvalue in a certain cluster is at most matrix_function_separation() away from another eigenvalue

in the same cluster.

The distance between two eigenvalues in different clusters is more than matrix_function_separation().

The implementation follows Algorithm 4.1 in the paper of Davies and Higham.

Definition at line 133 of file MatrixFunction.h.

{
  typedef typename EivalsType::RealScalar RealScalar;
  for (Index i=0; i<eivals.rows(); ++i) {
    // Find cluster containing i-th ei'val, adding a new cluster if necessary
    typename std::list<Cluster>::iterator qi = matrix_function_find_cluster(i, clusters);
    if (qi == clusters.end()) {
      Cluster l;
      l.push_back(i);
      clusters.push_back(l);
      qi = clusters.end();
      --qi;
    }
 
    // Look for other element to add to the set
    for (Index j=i+1; j<eivals.rows(); ++j) {
      if (abs(eivals(j) - eivals(i)) <= RealScalar(matrix_function_separation)
          && std::find(qi->begin(), qi->end(), j) == qi->end()) {
        typename std::list<Cluster>::iterator qj = matrix_function_find_cluster(j, clusters);
        if (qj == clusters.end()) {
          qi->push_back(j);
        } else {
          qi->insert(qi->end(), qj->begin(), qj->end());
          clusters.erase(qj);
        }
      }
    }
  }
}

matrix_function_permute_schur()

template<typename VectorType , typename MatrixType >

void Eigen::internal::matrix_function_permute_schur	(	VectorType &	permutation,
		MatrixType &	U,
		MatrixType &	T
	)

Permute Schur decomposition in U and T according to permutation.

Definition at line 218 of file MatrixFunction.h.

{
  for (Index i = 0; i < permutation.rows() - 1; i++) {
    Index j;
    for (j = i; j < permutation.rows(); j++) {
      if (permutation(j) == i) break;
    }
    eigen_assert(permutation(j) == i);
    for (Index k = j-1; k >= i; k--) {
      JacobiRotation<typename MatrixType::Scalar> rotation;
      rotation.makeGivens(T(k, k+1), T(k+1, k+1) - T(k, k));
      T.applyOnTheLeft(k, k+1, rotation.adjoint());
      T.applyOnTheRight(k, k+1, rotation);
      U.applyOnTheRight(k, k+1, rotation);
      std::swap(permutation.coeffRef(k), permutation.coeffRef(k+1));
    }
  }
}

matrix_function_solve_triangular_sylvester()

template<typename MatrixType >

MatrixType Eigen::internal::matrix_function_solve_triangular_sylvester	(	const MatrixType &	A,
		const MatrixType &	B,
		const MatrixType &	C
	)

Solve a triangular Sylvester equation AX + XB = C.

Parameters

[in]	A	the matrix A; should be square and upper triangular
[in]	B	the matrix B; should be square and upper triangular
[in]	C	the matrix C; should have correct size.

Returns

the solution X.

If A is m-by-m and B is n-by-n, then both C and X are m-by-n. The (i,j)-th component of the Sylvester equation is

\[ \sum_{k=i}^m A_{ik} X_{kj} + \sum_{k=1}^j X_{ik} B_{kj} = C_{ij}. \]

This can be re-arranged to yield:

\[ X_{ij} = \frac{1}{A_{ii} + B_{jj}} \Bigl( C_{ij} - \sum_{k=i+1}^m A_{ik} X_{kj} - \sum_{k=1}^{j-1} X_{ik} B_{kj} \Bigr). \]

It is assumed that A and B are such that the numerator is never zero (otherwise the Sylvester equation does not have a unique solution). In that case, these equations can be evaluated in the order \( i=m,\ldots,1 \) and \( j=1,\ldots,n \).

Definition at line 276 of file MatrixFunction.h.

{
  eigen_assert(A.rows() == A.cols());
  eigen_assert(A.isUpperTriangular());
  eigen_assert(B.rows() == B.cols());
  eigen_assert(B.isUpperTriangular());
  eigen_assert(C.rows() == A.rows());
  eigen_assert(C.cols() == B.rows());
 
  typedef typename MatrixType::Scalar Scalar;
 
  Index m = A.rows();
  Index n = B.rows();
  MatrixType X(m, n);
 
  for (Index i = m - 1; i >= 0; --i) {
    for (Index j = 0; j < n; ++j) {
 
      // Compute AX = \sum_{k=i+1}^m A_{ik} X_{kj}
      Scalar AX;
      if (i == m - 1) {
        AX = 0; 
      } else {
        Matrix<Scalar,1,1> AXmatrix = A.row(i).tail(m-1-i) * X.col(j).tail(m-1-i);
        AX = AXmatrix(0,0);
      }
 
      // Compute XB = \sum_{k=1}^{j-1} X_{ik} B_{kj}
      Scalar XB;
      if (j == 0) {
        XB = 0; 
      } else {
        Matrix<Scalar,1,1> XBmatrix = X.row(i).head(j) * B.col(j).head(j);
        XB = XBmatrix(0,0);
      }
 
      X(i,j) = (C(i,j) - AX - XB) / (A(i,i) + B(j,j));
    }
  }
  return X;
}

matrix_log_compute_2x2()

template<typename MatrixType >

void Eigen::internal::matrix_log_compute_2x2	(	const MatrixType &	A,
		MatrixType &	result
	)

Compute logarithm of 2x2 triangular matrix.

Definition at line 39 of file MatrixLogarithm.h.

{
  typedef typename MatrixType::Scalar Scalar;
  typedef typename MatrixType::RealScalar RealScalar;
  using std::abs;
  using std::ceil;
  using std::imag;
  using std::log;
 
  Scalar logA00 = log(A(0,0));
  Scalar logA11 = log(A(1,1));
 
  result(0,0) = logA00;
  result(1,0) = Scalar(0);
  result(1,1) = logA11;
 
  Scalar y = A(1,1) - A(0,0);
  if (y==Scalar(0))
  {
    result(0,1) = A(0,1) / A(0,0);
  }
  else if ((abs(A(0,0)) < RealScalar(0.5)*abs(A(1,1))) || (abs(A(0,0)) > 2*abs(A(1,1))))
  {
    result(0,1) = A(0,1) * (logA11 - logA00) / y;
  }
  else
  {
    // computation in previous branch is inaccurate if A(1,1) \approx A(0,0)
    RealScalar unwindingNumber = ceil((imag(logA11 - logA00) - RealScalar(EIGEN_PI)) / RealScalar(2*EIGEN_PI));
    result(0,1) = A(0,1) * (numext::log1p(y/A(0,0)) + Scalar(0,RealScalar(2*EIGEN_PI)*unwindingNumber)) / y;
  }
}

matrix_log_compute_big()

template<typename MatrixType >

void Eigen::internal::matrix_log_compute_big	(	const MatrixType &	A,
		MatrixType &	result
	)

Compute logarithm of triangular matrices with size > 2.

This uses a inverse scale-and-square algorithm.

Definition at line 227 of file MatrixLogarithm.h.

{
  typedef typename MatrixType::Scalar Scalar;
  typedef typename NumTraits<Scalar>::Real RealScalar;
  using std::pow;
 
  int numberOfSquareRoots = 0;
  int numberOfExtraSquareRoots = 0;
  int degree;
  MatrixType T = A, sqrtT;
 
  const int maxPadeDegree = matrix_log_max_pade_degree<Scalar>::value;
  const RealScalar maxNormForPade = RealScalar(
                                    maxPadeDegree<= 5? 5.3149729967117310e-1L:                    // single precision
                                    maxPadeDegree<= 7? 2.6429608311114350e-1L:                    // double precision
                                    maxPadeDegree<= 8? 2.32777776523703892094e-1L:                // extended precision
                                    maxPadeDegree<=10? 1.05026503471351080481093652651105e-1L:    // double-double
                                                       1.1880960220216759245467951592883642e-1L); // quadruple precision
 
  while (true) {
    RealScalar normTminusI = (T - MatrixType::Identity(T.rows(), T.rows())).cwiseAbs().colwise().sum().maxCoeff();
    if (normTminusI < maxNormForPade) {
      degree = matrix_log_get_pade_degree(normTminusI);
      int degree2 = matrix_log_get_pade_degree(normTminusI / RealScalar(2));
      if ((degree - degree2 <= 1) || (numberOfExtraSquareRoots == 1)) 
        break;
      ++numberOfExtraSquareRoots;
    }
    matrix_sqrt_triangular(T, sqrtT);
    T = sqrtT.template triangularView<Upper>();
    ++numberOfSquareRoots;
  }
 
  matrix_log_compute_pade(result, T, degree);
  result *= pow(RealScalar(2), RealScalar(numberOfSquareRoots)); // TODO replace by bitshift if possible
}

matrix_log_compute_pade()

template<typename MatrixType >

void Eigen::internal::matrix_log_compute_pade	(	MatrixType &	result,
		const MatrixType &	T,
		int	degree
	)

Definition at line 134 of file MatrixLogarithm.h.

{
  typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
  const int minPadeDegree = 3;
  const int maxPadeDegree = 11;
  eigen_assert(degree >= minPadeDegree && degree <= maxPadeDegree);
  // FIXME this creates float-conversion-warnings if these are enabled.
  // Either manually convert each value, or disable the warning locally
  const RealScalar nodes[][maxPadeDegree] = { 
    { 0.1127016653792583114820734600217600L, 0.5000000000000000000000000000000000L,  // degree 3
      0.8872983346207416885179265399782400L }, 
    { 0.0694318442029737123880267555535953L, 0.3300094782075718675986671204483777L,  // degree 4
      0.6699905217924281324013328795516223L, 0.9305681557970262876119732444464048L },
    { 0.0469100770306680036011865608503035L, 0.2307653449471584544818427896498956L,  // degree 5
      0.5000000000000000000000000000000000L, 0.7692346550528415455181572103501044L,
      0.9530899229693319963988134391496965L },
    { 0.0337652428984239860938492227530027L, 0.1693953067668677431693002024900473L,  // degree 6
      0.3806904069584015456847491391596440L, 0.6193095930415984543152508608403560L,
      0.8306046932331322568306997975099527L, 0.9662347571015760139061507772469973L },
    { 0.0254460438286207377369051579760744L, 0.1292344072003027800680676133596058L,  // degree 7
      0.2970774243113014165466967939615193L, 0.5000000000000000000000000000000000L,
      0.7029225756886985834533032060384807L, 0.8707655927996972199319323866403942L,
      0.9745539561713792622630948420239256L },
    { 0.0198550717512318841582195657152635L, 0.1016667612931866302042230317620848L,  // degree 8
      0.2372337950418355070911304754053768L, 0.4082826787521750975302619288199080L,
      0.5917173212478249024697380711800920L, 0.7627662049581644929088695245946232L,
      0.8983332387068133697957769682379152L, 0.9801449282487681158417804342847365L },
    { 0.0159198802461869550822118985481636L, 0.0819844463366821028502851059651326L,  // degree 9
      0.1933142836497048013456489803292629L, 0.3378732882980955354807309926783317L,
      0.5000000000000000000000000000000000L, 0.6621267117019044645192690073216683L,
      0.8066857163502951986543510196707371L, 0.9180155536633178971497148940348674L,
      0.9840801197538130449177881014518364L },
    { 0.0130467357414141399610179939577740L, 0.0674683166555077446339516557882535L,  // degree 10
      0.1602952158504877968828363174425632L, 0.2833023029353764046003670284171079L,
      0.4255628305091843945575869994351400L, 0.5744371694908156054424130005648600L,
      0.7166976970646235953996329715828921L, 0.8397047841495122031171636825574368L,
      0.9325316833444922553660483442117465L, 0.9869532642585858600389820060422260L },
    { 0.0108856709269715035980309994385713L, 0.0564687001159523504624211153480364L,  // degree 11
      0.1349239972129753379532918739844233L, 0.2404519353965940920371371652706952L,
      0.3652284220238275138342340072995692L, 0.5000000000000000000000000000000000L,
      0.6347715779761724861657659927004308L, 0.7595480646034059079628628347293048L,
      0.8650760027870246620467081260155767L, 0.9435312998840476495375788846519636L,
      0.9891143290730284964019690005614287L } };
 
  const RealScalar weights[][maxPadeDegree] = { 
    { 0.2777777777777777777777777777777778L, 0.4444444444444444444444444444444444L,  // degree 3
      0.2777777777777777777777777777777778L },
    { 0.1739274225687269286865319746109997L, 0.3260725774312730713134680253890003L,  // degree 4
      0.3260725774312730713134680253890003L, 0.1739274225687269286865319746109997L },
    { 0.1184634425280945437571320203599587L, 0.2393143352496832340206457574178191L,  // degree 5
      0.2844444444444444444444444444444444L, 0.2393143352496832340206457574178191L,
      0.1184634425280945437571320203599587L },
    { 0.0856622461895851725201480710863665L, 0.1803807865240693037849167569188581L,  // degree 6
      0.2339569672863455236949351719947755L, 0.2339569672863455236949351719947755L,
      0.1803807865240693037849167569188581L, 0.0856622461895851725201480710863665L },
    { 0.0647424830844348466353057163395410L, 0.1398526957446383339507338857118898L,  // degree 7
      0.1909150252525594724751848877444876L, 0.2089795918367346938775510204081633L,
      0.1909150252525594724751848877444876L, 0.1398526957446383339507338857118898L,
      0.0647424830844348466353057163395410L },
    { 0.0506142681451881295762656771549811L, 0.1111905172266872352721779972131204L,  // degree 8
      0.1568533229389436436689811009933007L, 0.1813418916891809914825752246385978L,
      0.1813418916891809914825752246385978L, 0.1568533229389436436689811009933007L,
      0.1111905172266872352721779972131204L, 0.0506142681451881295762656771549811L },
    { 0.0406371941807872059859460790552618L, 0.0903240803474287020292360156214564L,  // degree 9
      0.1303053482014677311593714347093164L, 0.1561735385200014200343152032922218L,
      0.1651196775006298815822625346434870L, 0.1561735385200014200343152032922218L,
      0.1303053482014677311593714347093164L, 0.0903240803474287020292360156214564L,
      0.0406371941807872059859460790552618L },
    { 0.0333356721543440687967844049466659L, 0.0747256745752902965728881698288487L,  // degree 10
      0.1095431812579910219977674671140816L, 0.1346333596549981775456134607847347L,
      0.1477621123573764350869464973256692L, 0.1477621123573764350869464973256692L,
      0.1346333596549981775456134607847347L, 0.1095431812579910219977674671140816L,
      0.0747256745752902965728881698288487L, 0.0333356721543440687967844049466659L },
    { 0.0278342835580868332413768602212743L, 0.0627901847324523123173471496119701L,  // degree 11
      0.0931451054638671257130488207158280L, 0.1165968822959952399592618524215876L,
      0.1314022722551233310903444349452546L, 0.1364625433889503153572417641681711L,
      0.1314022722551233310903444349452546L, 0.1165968822959952399592618524215876L,
      0.0931451054638671257130488207158280L, 0.0627901847324523123173471496119701L,
      0.0278342835580868332413768602212743L } };
 
  MatrixType TminusI = T - MatrixType::Identity(T.rows(), T.rows());
  result.setZero(T.rows(), T.rows());
  for (int k = 0; k < degree; ++k) {
    RealScalar weight = weights[degree-minPadeDegree][k];
    RealScalar node = nodes[degree-minPadeDegree][k];
    result += weight * (MatrixType::Identity(T.rows(), T.rows()) + node * TminusI)
                       .template triangularView<Upper>().solve(TminusI);
  }
} 

matrix_log_get_pade_degree() [1/3]

int Eigen::internal::matrix_log_get_pade_degree ( double  normTminusI )

inline

Definition at line 87 of file MatrixLogarithm.h.

{
  const double maxNormForPade[] = { 1.6206284795015624e-2 /* degree = 3 */ , 5.3873532631381171e-2,
            1.1352802267628681e-1, 1.8662860613541288e-1, 2.642960831111435e-1 };
  const int minPadeDegree = matrix_log_min_pade_degree<double>::value;
  const int maxPadeDegree = matrix_log_max_pade_degree<double>::value;
  int degree = minPadeDegree;
  for (; degree <= maxPadeDegree; ++degree)
    if (normTminusI <= maxNormForPade[degree - minPadeDegree])
      break;
  return degree;
}

matrix_log_get_pade_degree() [2/3]

int Eigen::internal::matrix_log_get_pade_degree ( float  normTminusI )

inline

Definition at line 73 of file MatrixLogarithm.h.

{
  const float maxNormForPade[] = { 2.5111573934555054e-1 /* degree = 3 */ , 4.0535837411880493e-1,
            5.3149729967117310e-1 };
  const int minPadeDegree = matrix_log_min_pade_degree<float>::value;
  const int maxPadeDegree = matrix_log_max_pade_degree<float>::value;
  int degree = minPadeDegree;
  for (; degree <= maxPadeDegree; ++degree) 
    if (normTminusI <= maxNormForPade[degree - minPadeDegree])
      break;
  return degree;
}

matrix_log_get_pade_degree() [3/3]

int Eigen::internal::matrix_log_get_pade_degree ( long double  normTminusI )

inline

Definition at line 101 of file MatrixLogarithm.h.

{
#if   LDBL_MANT_DIG == 53         // double precision
  const long double maxNormForPade[] = { 1.6206284795015624e-2L /* degree = 3 */ , 5.3873532631381171e-2L,
            1.1352802267628681e-1L, 1.8662860613541288e-1L, 2.642960831111435e-1L };
#elif LDBL_MANT_DIG <= 64         // extended precision
  const long double maxNormForPade[] = { 5.48256690357782863103e-3L /* degree = 3 */, 2.34559162387971167321e-2L,
            5.84603923897347449857e-2L, 1.08486423756725170223e-1L, 1.68385767881294446649e-1L,
            2.32777776523703892094e-1L };
#elif LDBL_MANT_DIG <= 106        // double-double
  const long double maxNormForPade[] = { 8.58970550342939562202529664318890e-5L /* degree = 3 */,
            9.34074328446359654039446552677759e-4L, 4.26117194647672175773064114582860e-3L,
            1.21546224740281848743149666560464e-2L, 2.61100544998339436713088248557444e-2L,
            4.66170074627052749243018566390567e-2L, 7.32585144444135027565872014932387e-2L,
            1.05026503471351080481093652651105e-1L };
#else                             // quadruple precision
  const long double maxNormForPade[] = { 4.7419931187193005048501568167858103e-5L /* degree = 3 */,
            5.8853168473544560470387769480192666e-4L, 2.9216120366601315391789493628113520e-3L,
            8.8415758124319434347116734705174308e-3L, 1.9850836029449446668518049562565291e-2L,
            3.6688019729653446926585242192447447e-2L, 5.9290962294020186998954055264528393e-2L,
            8.6998436081634343903250580992127677e-2L, 1.1880960220216759245467951592883642e-1L };
#endif
  const int minPadeDegree = matrix_log_min_pade_degree<long double>::value;
  const int maxPadeDegree = matrix_log_max_pade_degree<long double>::value;
  int degree = minPadeDegree;
  for (; degree <= maxPadeDegree; ++degree)
    if (normTminusI <= maxNormForPade[degree - minPadeDegree])
      break;
  return degree;
}

matrix_sqrt_quasi_triangular_1x1_off_diagonal_block()

template<typename MatrixType , typename ResultType >

void Eigen::internal::matrix_sqrt_quasi_triangular_1x1_off_diagonal_block	(	const MatrixType &	T,
		Index	i,
		Index	j,
		ResultType &	sqrtT
	)

Definition at line 37 of file MatrixSquareRoot.h.

{
  typedef typename traits<MatrixType>::Scalar Scalar;
  Scalar tmp = (sqrtT.row(i).segment(i+1,j-i-1) * sqrtT.col(j).segment(i+1,j-i-1)).value();
  sqrtT.coeffRef(i,j) = (T.coeff(i,j) - tmp) / (sqrtT.coeff(i,i) + sqrtT.coeff(j,j));
}

matrix_sqrt_quasi_triangular_1x2_off_diagonal_block()

template<typename MatrixType , typename ResultType >

void Eigen::internal::matrix_sqrt_quasi_triangular_1x2_off_diagonal_block	(	const MatrixType &	T,
		Index	i,
		Index	j,
		ResultType &	sqrtT
	)

Definition at line 46 of file MatrixSquareRoot.h.

{
  typedef typename traits<MatrixType>::Scalar Scalar;
  Matrix<Scalar,1,2> rhs = T.template block<1,2>(i,j);
  if (j-i > 1)
    rhs -= sqrtT.block(i, i+1, 1, j-i-1) * sqrtT.block(i+1, j, j-i-1, 2);
  Matrix<Scalar,2,2> A = sqrtT.coeff(i,i) * Matrix<Scalar,2,2>::Identity();
  A += sqrtT.template block<2,2>(j,j).transpose();
  sqrtT.template block<1,2>(i,j).transpose() = A.fullPivLu().solve(rhs.transpose());
}

matrix_sqrt_quasi_triangular_2x1_off_diagonal_block()

template<typename MatrixType , typename ResultType >

void Eigen::internal::matrix_sqrt_quasi_triangular_2x1_off_diagonal_block	(	const MatrixType &	T,
		Index	i,
		Index	j,
		ResultType &	sqrtT
	)

Definition at line 59 of file MatrixSquareRoot.h.

{
  typedef typename traits<MatrixType>::Scalar Scalar;
  Matrix<Scalar,2,1> rhs = T.template block<2,1>(i,j);
  if (j-i > 2)
    rhs -= sqrtT.block(i, i+2, 2, j-i-2) * sqrtT.block(i+2, j, j-i-2, 1);
  Matrix<Scalar,2,2> A = sqrtT.coeff(j,j) * Matrix<Scalar,2,2>::Identity();
  A += sqrtT.template block<2,2>(i,i);
  sqrtT.template block<2,1>(i,j) = A.fullPivLu().solve(rhs);
}

matrix_sqrt_quasi_triangular_2x2_diagonal_block()

template<typename MatrixType , typename ResultType >

void Eigen::internal::matrix_sqrt_quasi_triangular_2x2_diagonal_block	(	const MatrixType &	T,
		Index	i,
		ResultType &	sqrtT
	)

Definition at line 22 of file MatrixSquareRoot.h.

{
  // TODO: This case (2-by-2 blocks with complex conjugate eigenvalues) is probably hidden somewhere
  //       in EigenSolver. If we expose it, we could call it directly from here.
  typedef typename traits<MatrixType>::Scalar Scalar;
  Matrix<Scalar,2,2> block = T.template block<2,2>(i,i);
  EigenSolver<Matrix<Scalar,2,2> > es(block);
  sqrtT.template block<2,2>(i,i)
    = (es.eigenvectors() * es.eigenvalues().cwiseSqrt().asDiagonal() * es.eigenvectors().inverse()).real();
}

matrix_sqrt_quasi_triangular_2x2_off_diagonal_block()

template<typename MatrixType , typename ResultType >

void Eigen::internal::matrix_sqrt_quasi_triangular_2x2_off_diagonal_block	(	const MatrixType &	T,
		Index	i,
		Index	j,
		ResultType &	sqrtT
	)

Definition at line 106 of file MatrixSquareRoot.h.

{
  typedef typename traits<MatrixType>::Scalar Scalar;
  Matrix<Scalar,2,2> A = sqrtT.template block<2,2>(i,i);
  Matrix<Scalar,2,2> B = sqrtT.template block<2,2>(j,j);
  Matrix<Scalar,2,2> C = T.template block<2,2>(i,j);
  if (j-i > 2)
    C -= sqrtT.block(i, i+2, 2, j-i-2) * sqrtT.block(i+2, j, j-i-2, 2);
  Matrix<Scalar,2,2> X;
  matrix_sqrt_quasi_triangular_solve_auxiliary_equation(X, A, B, C);
  sqrtT.template block<2,2>(i,j) = X;
}

matrix_sqrt_quasi_triangular_diagonal()

template<typename MatrixType , typename ResultType >

void Eigen::internal::matrix_sqrt_quasi_triangular_diagonal	(	const MatrixType &	T,
		ResultType &	sqrtT
	)

Definition at line 122 of file MatrixSquareRoot.h.

{
  using std::sqrt;
  const Index size = T.rows();
  for (Index i = 0; i < size; i++) {
    if (i == size - 1 || T.coeff(i+1, i) == 0) {
      eigen_assert(T(i,i) >= 0);
      sqrtT.coeffRef(i,i) = sqrt(T.coeff(i,i));
    }
    else {
      matrix_sqrt_quasi_triangular_2x2_diagonal_block(T, i, sqrtT);
      ++i;
    }
  }
}

matrix_sqrt_quasi_triangular_off_diagonal()

template<typename MatrixType , typename ResultType >

void Eigen::internal::matrix_sqrt_quasi_triangular_off_diagonal	(	const MatrixType &	T,
		ResultType &	sqrtT
	)

Definition at line 141 of file MatrixSquareRoot.h.

{
  const Index size = T.rows();
  for (Index j = 1; j < size; j++) {
      if (T.coeff(j, j-1) != 0)  // if T(j-1:j, j-1:j) is a 2-by-2 block
        continue;
    for (Index i = j-1; i >= 0; i--) {
      if (i > 0 && T.coeff(i, i-1) != 0)  // if T(i-1:i, i-1:i) is a 2-by-2 block
        continue;
      bool iBlockIs2x2 = (i < size - 1) && (T.coeff(i+1, i) != 0);
      bool jBlockIs2x2 = (j < size - 1) && (T.coeff(j+1, j) != 0);
      if (iBlockIs2x2 && jBlockIs2x2) 
        matrix_sqrt_quasi_triangular_2x2_off_diagonal_block(T, i, j, sqrtT);
      else if (iBlockIs2x2 && !jBlockIs2x2) 
        matrix_sqrt_quasi_triangular_2x1_off_diagonal_block(T, i, j, sqrtT);
      else if (!iBlockIs2x2 && jBlockIs2x2) 
        matrix_sqrt_quasi_triangular_1x2_off_diagonal_block(T, i, j, sqrtT);
      else if (!iBlockIs2x2 && !jBlockIs2x2) 
        matrix_sqrt_quasi_triangular_1x1_off_diagonal_block(T, i, j, sqrtT);
    }
  }
}

matrix_sqrt_quasi_triangular_solve_auxiliary_equation()

template<typename MatrixType >

void Eigen::internal::matrix_sqrt_quasi_triangular_solve_auxiliary_equation	(	MatrixType &	X,
		const MatrixType &	A,
		const MatrixType &	B,
		const MatrixType &	C
	)

Definition at line 72 of file MatrixSquareRoot.h.

{
  typedef typename traits<MatrixType>::Scalar Scalar;
  Matrix<Scalar,4,4> coeffMatrix = Matrix<Scalar,4,4>::Zero();
  coeffMatrix.coeffRef(0,0) = A.coeff(0,0) + B.coeff(0,0);
  coeffMatrix.coeffRef(1,1) = A.coeff(0,0) + B.coeff(1,1);
  coeffMatrix.coeffRef(2,2) = A.coeff(1,1) + B.coeff(0,0);
  coeffMatrix.coeffRef(3,3) = A.coeff(1,1) + B.coeff(1,1);
  coeffMatrix.coeffRef(0,1) = B.coeff(1,0);
  coeffMatrix.coeffRef(0,2) = A.coeff(0,1);
  coeffMatrix.coeffRef(1,0) = B.coeff(0,1);
  coeffMatrix.coeffRef(1,3) = A.coeff(0,1);
  coeffMatrix.coeffRef(2,0) = A.coeff(1,0);
  coeffMatrix.coeffRef(2,3) = B.coeff(1,0);
  coeffMatrix.coeffRef(3,1) = A.coeff(1,0);
  coeffMatrix.coeffRef(3,2) = B.coeff(0,1);
 
  Matrix<Scalar,4,1> rhs;
  rhs.coeffRef(0) = C.coeff(0,0);
  rhs.coeffRef(1) = C.coeff(0,1);
  rhs.coeffRef(2) = C.coeff(1,0);
  rhs.coeffRef(3) = C.coeff(1,1);
 
  Matrix<Scalar,4,1> result;
  result = coeffMatrix.fullPivLu().solve(rhs);
 
  X.coeffRef(0,0) = result.coeff(0);
  X.coeffRef(0,1) = result.coeff(1);
  X.coeffRef(1,0) = result.coeff(2);
  X.coeffRef(1,1) = result.coeff(3);
}

minres()

template<typename MatrixType , typename Rhs , typename Dest , typename Preconditioner >

EIGEN_DONT_INLINE void Eigen::internal::minres	(	const MatrixType &	mat,
		const Rhs &	rhs,
		Dest &	x,
		const Preconditioner &	precond,
		Index &	iters,
		typename Dest::RealScalar &	tol_error
	)

Definition at line 34 of file MINRES.h.

        {
            using std::sqrt;
            typedef typename Dest::RealScalar RealScalar;
            typedef typename Dest::Scalar Scalar;
            typedef Matrix<Scalar,Dynamic,1> VectorType;
 
            // Check for zero rhs
            const RealScalar rhsNorm2(rhs.squaredNorm());
            if(rhsNorm2 == 0)
            {
                x.setZero();
                iters = 0;
                tol_error = 0;
                return;
            }
            
            // initialize
            const Index maxIters(iters);  // initialize maxIters to iters
            const Index N(mat.cols());    // the size of the matrix
            const RealScalar threshold2(tol_error*tol_error*rhsNorm2); // convergence threshold (compared to residualNorm2)
            
            // Initialize preconditioned Lanczos
            VectorType v_old(N); // will be initialized inside loop
            VectorType v( VectorType::Zero(N) ); //initialize v
            VectorType v_new(rhs-mat*x); //initialize v_new
            RealScalar residualNorm2(v_new.squaredNorm());
            VectorType w(N); // will be initialized inside loop
            VectorType w_new(precond.solve(v_new)); // initialize w_new
//            RealScalar beta; // will be initialized inside loop
            RealScalar beta_new2(v_new.dot(w_new));
            eigen_assert(beta_new2 >= 0.0 && "PRECONDITIONER IS NOT POSITIVE DEFINITE");
            RealScalar beta_new(sqrt(beta_new2));
            const RealScalar beta_one(beta_new);
            // Initialize other variables
            RealScalar c(1.0); // the cosine of the Givens rotation
            RealScalar c_old(1.0);
            RealScalar s(0.0); // the sine of the Givens rotation
            RealScalar s_old(0.0); // the sine of the Givens rotation
            VectorType p_oold(N); // will be initialized in loop
            VectorType p_old(VectorType::Zero(N)); // initialize p_old=0
            VectorType p(p_old); // initialize p=0
            RealScalar eta(1.0);
                        
            iters = 0; // reset iters
            while ( iters < maxIters )
            {
                // Preconditioned Lanczos
                /* Note that there are 4 variants on the Lanczos algorithm. These are
                 * described in Paige, C. C. (1972). Computational variants of
                 * the Lanczos method for the eigenproblem. IMA Journal of Applied
                 * Mathematics, 10(3), 373-381. The current implementation corresponds 
                 * to the case A(2,7) in the paper. It also corresponds to 
                 * algorithm 6.14 in Y. Saad, Iterative Methods for Sparse Linear
                 * Systems, 2003 p.173. For the preconditioned version see 
                 * A. Greenbaum, Iterative Methods for Solving Linear Systems, SIAM (1987).
                 */
                const RealScalar beta(beta_new);
                v_old = v; // update: at first time step, this makes v_old = 0 so value of beta doesn't matter
                v_new /= beta_new; // overwrite v_new for next iteration
                w_new /= beta_new; // overwrite w_new for next iteration
                v = v_new; // update
                w = w_new; // update
                v_new.noalias() = mat*w - beta*v_old; // compute v_new
                const RealScalar alpha = v_new.dot(w);
                v_new -= alpha*v; // overwrite v_new
                w_new = precond.solve(v_new); // overwrite w_new
                beta_new2 = v_new.dot(w_new); // compute beta_new
                eigen_assert(beta_new2 >= 0.0 && "PRECONDITIONER IS NOT POSITIVE DEFINITE");
                beta_new = sqrt(beta_new2); // compute beta_new
                
                // Givens rotation
                const RealScalar r2 =s*alpha+c*c_old*beta; // s, s_old, c and c_old are still from previous iteration
                const RealScalar r3 =s_old*beta; // s, s_old, c and c_old are still from previous iteration
                const RealScalar r1_hat=c*alpha-c_old*s*beta;
                const RealScalar r1 =sqrt( std::pow(r1_hat,2) + std::pow(beta_new,2) );
                c_old = c; // store for next iteration
                s_old = s; // store for next iteration
                c=r1_hat/r1; // new cosine
                s=beta_new/r1; // new sine
                
                // Update solution
                p_oold = p_old;
                p_old = p;
                p.noalias()=(w-r2*p_old-r3*p_oold) /r1; // IS NOALIAS REQUIRED?
                x += beta_one*c*eta*p;
                
                /* Update the squared residual. Note that this is the estimated residual.
                The real residual |Ax-b|^2 may be slightly larger */
                residualNorm2 *= s*s;
                
                if ( residualNorm2 < threshold2)
                {
                    break;
                }
                
                eta=-s*eta; // update eta
                iters++; // increment iteration number (for output purposes)
            }
            
            /* Compute error. Note that this is the estimated error. The real 
             error |Ax-b|/|b| may be slightly larger */
            tol_error = std::sqrt(residualNorm2 / rhsNorm2);
        }

muluh() [1/2]

template<typename T >

EIGEN_ALWAYS_INLINE uint32_t Eigen::internal::muluh	(	const uint32_t	a,
		const T	b
	)

Definition at line 92 of file TensorIntDiv.h.

                                                                                    {
#if defined(EIGEN_GPU_COMPILE_PHASE)
    return __umulhi(a, b);
#elif defined(SYCL_DEVICE_ONLY)
    return cl::sycl::mul_hi(a, static_cast<uint32_t>(b));
#else
    return (static_cast<uint64_t>(a) * b) >> 32;
#endif
  }

muluh() [2/2]

template<typename T >

EIGEN_ALWAYS_INLINE uint64_t Eigen::internal::muluh	(	const uint64_t	a,
		const T	b
	)

Definition at line 103 of file TensorIntDiv.h.

                                                                                    {
#if defined(EIGEN_GPU_COMPILE_PHASE)
    return __umul64hi(a, b);
#elif defined(SYCL_DEVICE_ONLY)
    return cl::sycl::mul_hi(a, static_cast<uint64_t>(b));
#elif EIGEN_HAS_BUILTIN_INT128
    __uint128_t v = static_cast<__uint128_t>(a) * static_cast<__uint128_t>(b);
    return static_cast<uint64_t>(v >> 64);
#else
    return (TensorUInt128<static_val<0>, uint64_t>(a) * TensorUInt128<static_val<0>, uint64_t>(b)).upper();
#endif
  }

omega()

template<typename Vector , typename RealScalar >

Vector::Scalar Eigen::internal::omega	(	const Vector &	t,
		const Vector &	s,
		RealScalar	angle
	)

Definition at line 35 of file IDRS.h.

                                                                                {
  using numext::abs;
  typedef typename Vector::Scalar Scalar;
  const RealScalar ns = s.stableNorm();
  const RealScalar nt = t.stableNorm();
  const Scalar ts = t.dot(s);
  const RealScalar rho = abs(ts / (nt * ns));
 
  if (rho < angle) {
    if (ts == Scalar(0)) {
      return Scalar(0);
    }
    // Original relation for om is given by
    // om = om * angle / rho;
    // To alleviate potential (near) division by zero this can be rewritten as
    // om = angle * (ns / nt) * (ts / abs(ts)) = angle * (ns / nt) * sgn(ts)
    return angle * (ns / nt) * (ts / abs(ts));
  }
  return ts / (nt * nt);
}

operator!=()

template<typename HL , typename LL , typename HR , typename LR >

EIGEN_ALWAYS_INLINE bool Eigen::internal::operator!=	(	const TensorUInt128< HL, LL > &	lhs,
		const TensorUInt128< HR, LR > &	rhs
	)

Definition at line 88 of file TensorUInt128.h.

{
  return (lhs.high != rhs.high) || (lhs.low != rhs.low);
}

operator*()

template<typename HL , typename LL , typename HR , typename LR >

static TensorUInt128<uint64_t, uint64_t> Eigen::internal::operator* ( const TensorUInt128< HL, LL > &  lhs, const TensorUInt128< HR, LR > &  rhs  )

inlinestatic

Definition at line 138 of file TensorUInt128.h.

{
  // Split each 128-bit integer into 4 32-bit integers, and then do the
  // multiplications by hand as follow:
  //   lhs      a  b  c  d
  //   rhs      e  f  g  h
  //           -----------
  //           ah bh ch dh
  //           bg cg dg
  //           cf df
  //           de
  // The result is stored in 2 64bit integers, high and low.
 
  const uint64_t LOW = 0x00000000FFFFFFFFLL;
  const uint64_t HIGH = 0xFFFFFFFF00000000LL;
 
  uint64_t d = lhs.low & LOW;
  uint64_t c = (lhs.low & HIGH) >> 32LL;
  uint64_t b = lhs.high & LOW;
  uint64_t a = (lhs.high & HIGH) >> 32LL;
 
  uint64_t h = rhs.low & LOW;
  uint64_t g = (rhs.low & HIGH) >> 32LL;
  uint64_t f = rhs.high & LOW;
  uint64_t e = (rhs.high & HIGH) >> 32LL;
 
  // Compute the low 32 bits of low
  uint64_t acc = d * h;
  uint64_t low = acc & LOW;
  //  Compute the high 32 bits of low. Add a carry every time we wrap around
  acc >>= 32LL;
  uint64_t carry = 0;
  uint64_t acc2 = acc + c * h;
  if (acc2 < acc) {
    carry++;
  }
  acc = acc2 + d * g;
  if (acc < acc2) {
    carry++;
  }
  low |= (acc << 32LL);
 
  // Carry forward the high bits of acc to initiate the computation of the
  // low 32 bits of high
  acc2 = (acc >> 32LL) | (carry << 32LL);
  carry = 0;
 
  acc = acc2 + b * h;
  if (acc < acc2) {
    carry++;
  }
  acc2 = acc + c * g;
  if (acc2 < acc) {
    carry++;
  }
  acc = acc2 + d * f;
  if (acc < acc2) {
    carry++;
  }
  uint64_t high = acc & LOW;
 
  // Start to compute the high 32 bits of high.
  acc2 = (acc >> 32LL) | (carry << 32LL);
 
  acc = acc2 + a * h;
  acc2 = acc + b * g;
  acc = acc2 + c * f;
  acc2 = acc + d * e;
  high |= (acc2 << 32LL);
 
  return TensorUInt128<uint64_t, uint64_t>(high, low);
}

operator+()

template<typename HL , typename LL , typename HR , typename LR >

EIGEN_ALWAYS_INLINE TensorUInt128<uint64_t, uint64_t> Eigen::internal::operator+	(	const TensorUInt128< HL, LL > &	lhs,
		const TensorUInt128< HR, LR > &	rhs
	)

Definition at line 115 of file TensorUInt128.h.

{
  TensorUInt128<uint64_t, uint64_t> result(lhs.high + rhs.high, lhs.low + rhs.low);
  if (result.low < rhs.low) {
    result.high += 1;
  }
  return result;
}

operator-()

template<typename HL , typename LL , typename HR , typename LR >

EIGEN_ALWAYS_INLINE TensorUInt128<uint64_t, uint64_t> Eigen::internal::operator-	(	const TensorUInt128< HL, LL > &	lhs,
		const TensorUInt128< HR, LR > &	rhs
	)

Definition at line 126 of file TensorUInt128.h.

{
  TensorUInt128<uint64_t, uint64_t> result(lhs.high - rhs.high, lhs.low - rhs.low);
  if (result.low > lhs.low) {
    result.high -= 1;
  }
  return result;
}

operator/() [1/2]

template<typename T , bool div_gt_one>

T Eigen::internal::operator/ ( const T &  numerator, const TensorIntDivisor< T, div_gt_one > &  divisor  )

inline

Definition at line 253 of file TensorIntDiv.h.

                                                                                                                        {
  return divisor.divide(numerator);
}

operator/() [2/2]

template<typename HL , typename LL , typename HR , typename LR >

static TensorUInt128<uint64_t, uint64_t> Eigen::internal::operator/ ( const TensorUInt128< HL, LL > &  lhs, const TensorUInt128< HR, LR > &  rhs  )

inlinestatic

Definition at line 213 of file TensorUInt128.h.

{
  if (rhs == TensorUInt128<static_val<0>, static_val<1> >(1)) {
    return TensorUInt128<uint64_t, uint64_t>(lhs.high, lhs.low);
  } else if (lhs < rhs) {
    return TensorUInt128<uint64_t, uint64_t>(0);
  } else {
    // calculate the biggest power of 2 times rhs that's less than or equal to lhs
    TensorUInt128<uint64_t, uint64_t> power2(1);
    TensorUInt128<uint64_t, uint64_t> d(rhs);
    TensorUInt128<uint64_t, uint64_t> tmp(lhs - d);
    while (lhs >= d) {
      tmp = tmp - d;
      d = d + d;
      power2 = power2 + power2;
    }
 
    tmp = TensorUInt128<uint64_t, uint64_t>(lhs.high, lhs.low);
    TensorUInt128<uint64_t, uint64_t> result(0);
    while (power2 != TensorUInt128<static_val<0>, static_val<0> >(0)) {
      if (tmp >= d) {
        tmp = tmp - d;
        result = result + power2;
      }
      // Shift right
      power2 = TensorUInt128<uint64_t, uint64_t>(power2.high >> 1, (power2.low >> 1) | (power2.high << 63));
      d = TensorUInt128<uint64_t, uint64_t>(d.high >> 1, (d.low >> 1) | (d.high << 63));
    }
 
    return result;
  }
}

operator<()

template<typename HL , typename LL , typename HR , typename LR >

EIGEN_ALWAYS_INLINE bool Eigen::internal::operator<	(	const TensorUInt128< HL, LL > &	lhs,
		const TensorUInt128< HR, LR > &	rhs
	)

Definition at line 105 of file TensorUInt128.h.

{
  if (lhs.high != rhs.high) {
    return lhs.high < rhs.high;
  }
  return lhs.low < rhs.low;
}

operator==()

template<typename HL , typename LL , typename HR , typename LR >

EIGEN_ALWAYS_INLINE bool Eigen::internal::operator==	(	const TensorUInt128< HL, LL > &	lhs,
		const TensorUInt128< HR, LR > &	rhs
	)

Definition at line 81 of file TensorUInt128.h.

{
  return (lhs.high == rhs.high) && (lhs.low == rhs.low);
}

operator>=()

template<typename HL , typename LL , typename HR , typename LR >

EIGEN_ALWAYS_INLINE bool Eigen::internal::operator>=	(	const TensorUInt128< HL, LL > &	lhs,
		const TensorUInt128< HR, LR > &	rhs
	)

Definition at line 95 of file TensorUInt128.h.

{
  if (lhs.high != rhs.high) {
    return lhs.high > rhs.high;
  }
  return lhs.low >= rhs.low;
}

pasin()

template<typename Packet >

static Packet Eigen::internal::pasin ( Packet  a )

inlinestatic

Definition at line 21 of file MathFunctions.h.

{ return std::asin(a); }

pbessel_i0()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_i0

(

const Packet &

x

)

Definition at line 23 of file BesselFunctionsPacketMath.h.

                                   {
  return numext::bessel_i0(x);
}

pbessel_i0e()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_i0e

(

const Packet &

x

)

Definition at line 31 of file BesselFunctionsPacketMath.h.

                                    {
  return numext::bessel_i0e(x);
}

pbessel_i1()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_i1

(

const Packet &

x

)

Definition at line 39 of file BesselFunctionsPacketMath.h.

                                   {
  return numext::bessel_i1(x);
}

pbessel_i1e()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_i1e

(

const Packet &

x

)

Definition at line 47 of file BesselFunctionsPacketMath.h.

                                    {
  return numext::bessel_i1e(x);
}

pbessel_j0()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_j0

(

const Packet &

x

)

Definition at line 55 of file BesselFunctionsPacketMath.h.

                                   {
  return numext::bessel_j0(x);
}

pbessel_j1()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_j1

(

const Packet &

x

)

Definition at line 63 of file BesselFunctionsPacketMath.h.

                                   {
  return numext::bessel_j1(x);
}

pbessel_k0()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_k0

(

const Packet &

x

)

Definition at line 87 of file BesselFunctionsPacketMath.h.

                                   {
  return numext::bessel_k0(x);
}

pbessel_k0e()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_k0e

(

const Packet &

x

)

Definition at line 95 of file BesselFunctionsPacketMath.h.

                                    {
  return numext::bessel_k0e(x);
}

pbessel_k1()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_k1

(

const Packet &

x

)

Definition at line 103 of file BesselFunctionsPacketMath.h.

                                   {
  return numext::bessel_k1(x);
}

pbessel_k1e()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_k1e

(

const Packet &

x

)

Definition at line 111 of file BesselFunctionsPacketMath.h.

                                    {
  return numext::bessel_k1e(x);
}

pbessel_y0()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_y0

(

const Packet &

x

)

Definition at line 71 of file BesselFunctionsPacketMath.h.

                                   {
  return numext::bessel_y0(x);
}

pbessel_y1()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pbessel_y1

(

const Packet &

x

)

Definition at line 79 of file BesselFunctionsPacketMath.h.

                                   {
  return numext::bessel_y1(x);
}

pbetainc()

template<typename Packet >

Packet Eigen::internal::pbetainc ( const Packet &  a, const Packet &  b, const Packet &  x  )

inline

Definition at line 75 of file SpecialFunctionsPacketMath.h.

{ using numext::betainc; return betainc(a, b, x); }

PCG_XSH_RS_generator()

unsigned Eigen::internal::PCG_XSH_RS_generator ( uint64_t *  state, uint64_t  stream  )

inline

Definition at line 32 of file TensorRandom.h.

                                                                                                      {
  // TODO: Unify with the implementation in the non blocking thread pool.
  uint64_t current = *state;
  // Update the internal state
  *state = current * 6364136223846793005ULL + (stream << 1 | 1);
  // Generate the random output (using the PCG-XSH-RS scheme)
  return static_cast<unsigned>((current ^ (current >> 22)) >> (22 + (current >> 61)));
}

PCG_XSH_RS_state()

uint64_t Eigen::internal::PCG_XSH_RS_state ( uint64_t  seed )

inline

Definition at line 41 of file TensorRandom.h.

                                                                               {
  seed = seed ? seed : get_random_seed();
  return seed * 6364136223846793005ULL + 0xda3e39cb94b95bdbULL;
}

pdigamma()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pdigamma

(

const Packet &

a

)

Definition at line 25 of file SpecialFunctionsPacketMath.h.

{ using numext::digamma; return digamma(a); }

perf()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::perf

(

const Packet &

a

)

Definition at line 37 of file SpecialFunctionsPacketMath.h.

{ using numext::erf; return erf(a); }

perfc()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::perfc

(

const Packet &

a

)

Definition at line 41 of file SpecialFunctionsPacketMath.h.

{ using numext::erfc; return erfc(a); }

pgamma_sample_der_alpha()

template<typename Packet >

Packet Eigen::internal::pgamma_sample_der_alpha ( const Packet &  alpha, const Packet &  sample  )

inline

Definition at line 65 of file SpecialFunctionsPacketMath.h.

                                                                                                                {
  using numext::gamma_sample_der_alpha; return gamma_sample_der_alpha(alpha, sample);
}

pigamma()

template<typename Packet >

Packet Eigen::internal::pigamma ( const Packet &  a, const Packet &  x  )

inline

Definition at line 52 of file SpecialFunctionsPacketMath.h.

{ using numext::igamma; return igamma(a, x); }

pigamma_der_a()

template<typename Packet >

Packet Eigen::internal::pigamma_der_a ( const Packet &  a, const Packet &  x  )

inline

Definition at line 57 of file SpecialFunctionsPacketMath.h.

                                                                                             {
  using numext::igamma_der_a; return igamma_der_a(a, x);
}

pigammac()

template<typename Packet >

Packet Eigen::internal::pigammac ( const Packet &  a, const Packet &  x  )

inline

Definition at line 71 of file SpecialFunctionsPacketMath.h.

{ using numext::igammac; return igammac(a, x); }

plgamma()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::plgamma

(

const Packet &

a

)

Definition at line 21 of file SpecialFunctionsPacketMath.h.

{ using numext::lgamma; return lgamma(a); }

pndtri()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pndtri

(

const Packet &

a

)

Definition at line 45 of file SpecialFunctionsPacketMath.h.

                               {
  typedef typename unpacket_traits<Packet>::type ScalarType;
  using internal::generic_ndtri; return generic_ndtri<Packet, ScalarType>(a);
}

ppolygamma()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::ppolygamma	(	const Packet &	n,
		const Packet &	x
	)

Definition at line 33 of file SpecialFunctionsPacketMath.h.

{ using numext::polygamma; return polygamma(n, x); }

putDenseElt() [1/2]

template<typename Scalar >

void Eigen::internal::putDenseElt ( Scalar  value, std::ofstream &  out  )

inline

Definition at line 99 of file MarketIO.h.

  {
    out << value << "\n"; 
  }

putDenseElt() [2/2]

template<typename Scalar >

void Eigen::internal::putDenseElt ( std::complex< Scalar >  value, std::ofstream &  out  )

inline

Definition at line 104 of file MarketIO.h.

  {
    out << value.real() << " " << value.imag()<< "\n"; 
  }

putMarketHeader()

template<typename Scalar >

void Eigen::internal::putMarketHeader ( std::string &  header, int  sym  )

inline

Definition at line 68 of file MarketIO.h.

  {
    header= "%%MatrixMarket matrix coordinate ";
    if(internal::is_same<Scalar, std::complex<float> >::value || internal::is_same<Scalar, std::complex<double> >::value)
    {
      header += " complex"; 
      if(sym == Symmetric) header += " symmetric";
      else if (sym == SelfAdjoint) header += " Hermitian";
      else header += " general";
    }
    else
    {
      header += " real"; 
      if(sym == Symmetric) header += " symmetric";
      else header += " general";
    }
  }

PutMatrixElt() [1/2]

template<typename Scalar , typename StorageIndex >

void Eigen::internal::PutMatrixElt ( Scalar  value, StorageIndex  row, StorageIndex  col, std::ofstream &  out  )

inline

Definition at line 87 of file MarketIO.h.

  {
    out << row << " "<< col << " " << value << "\n";
  }

PutMatrixElt() [2/2]

template<typename Scalar , typename StorageIndex >

void Eigen::internal::PutMatrixElt ( std::complex< Scalar >  value, StorageIndex  row, StorageIndex  col, std::ofstream &  out  )

inline

Definition at line 92 of file MarketIO.h.

  {
    out << row << " " << col << " " << value.real() << " " << value.imag() << "\n";
  }

pzeta()

template<typename Packet >

EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet Eigen::internal::pzeta	(	const Packet &	x,
		const Packet &	q
	)

Definition at line 29 of file SpecialFunctionsPacketMath.h.

{ using numext::zeta; return zeta(x, q); }

qrsolv()

template<typename Scalar >

void Eigen::internal::qrsolv	(	Matrix< Scalar, Dynamic, Dynamic > &	s,
		const VectorXi &	ipvt,
		const Matrix< Scalar, Dynamic, 1 > &	diag,
		const Matrix< Scalar, Dynamic, 1 > &	qtb,
		Matrix< Scalar, Dynamic, 1 > &	x,
		Matrix< Scalar, Dynamic, 1 > &	sdiag
	)

Definition at line 9 of file qrsolv.h.

{
    typedef DenseIndex Index;
 
    /* Local variables */
    Index i, j, k, l;
    Scalar temp;
    Index n = s.cols();
    Matrix< Scalar, Dynamic, 1 >  wa(n);
    JacobiRotation<Scalar> givens;
 
    /* Function Body */
    // the following will only change the lower triangular part of s, including
    // the diagonal, though the diagonal is restored afterward
 
    /*     copy r and (q transpose)*b to preserve input and initialize s. */
    /*     in particular, save the diagonal elements of r in x. */
    x = s.diagonal();
    wa = qtb;
 
    s.topLeftCorner(n,n).template triangularView<StrictlyLower>() = s.topLeftCorner(n,n).transpose();
 
    /*     eliminate the diagonal matrix d using a givens rotation. */
    for (j = 0; j < n; ++j) {
 
        /*        prepare the row of d to be eliminated, locating the */
        /*        diagonal element using p from the qr factorization. */
        l = ipvt[j];
        if (diag[l] == 0.)
            break;
        sdiag.tail(n-j).setZero();
        sdiag[j] = diag[l];
 
        /*        the transformations to eliminate the row of d */
        /*        modify only a single element of (q transpose)*b */
        /*        beyond the first n, which is initially zero. */
        Scalar qtbpj = 0.;
        for (k = j; k < n; ++k) {
            /*           determine a givens rotation which eliminates the */
            /*           appropriate element in the current row of d. */
            givens.makeGivens(-s(k,k), sdiag[k]);
 
            /*           compute the modified diagonal element of r and */
            /*           the modified element of ((q transpose)*b,0). */
            s(k,k) = givens.c() * s(k,k) + givens.s() * sdiag[k];
            temp = givens.c() * wa[k] + givens.s() * qtbpj;
            qtbpj = -givens.s() * wa[k] + givens.c() * qtbpj;
            wa[k] = temp;
 
            /*           accumulate the transformation in the row of s. */
            for (i = k+1; i<n; ++i) {
                temp = givens.c() * s(i,k) + givens.s() * sdiag[i];
                sdiag[i] = -givens.s() * s(i,k) + givens.c() * sdiag[i];
                s(i,k) = temp;
            }
        }
    }
 
    /*     solve the triangular system for z. if the system is */
    /*     singular, then obtain a least squares solution. */
    Index nsing;
    for(nsing=0; nsing<n && sdiag[nsing]!=0; nsing++) {}
 
    wa.tail(n-nsing).setZero();
    s.topLeftCorner(nsing, nsing).transpose().template triangularView<Upper>().solveInPlace(wa.head(nsing));
 
    // restore
    sdiag = s.diagonal();
    s.diagonal() = x;
 
    /*     permute the components of z back to components of x. */
    for (j = 0; j < n; ++j) x[ipvt[j]] = wa[j];
}

r1mpyq()

template<typename Scalar >

void Eigen::internal::r1mpyq	(	DenseIndex	m,
		DenseIndex	n,
		Scalar *	a,
		const std::vector< JacobiRotation< Scalar > > &	v_givens,
		const std::vector< JacobiRotation< Scalar > > &	w_givens
	)

Definition at line 10 of file r1mpyq.h.

{
    typedef DenseIndex Index;
 
    /*     apply the first set of givens rotations to a. */
    for (Index j = n-2; j>=0; --j)
        for (Index i = 0; i<m; ++i) {
            Scalar temp = v_givens[j].c() * a[i+m*j] - v_givens[j].s() * a[i+m*(n-1)];
            a[i+m*(n-1)] = v_givens[j].s() * a[i+m*j] + v_givens[j].c() * a[i+m*(n-1)];
            a[i+m*j] = temp;
        }
    /*     apply the second set of givens rotations to a. */
    for (Index j = 0; j<n-1; ++j)
        for (Index i = 0; i<m; ++i) {
            Scalar temp = w_givens[j].c() * a[i+m*j] + w_givens[j].s() * a[i+m*(n-1)];
            a[i+m*(n-1)] = -w_givens[j].s() * a[i+m*j] + w_givens[j].c() * a[i+m*(n-1)];
            a[i+m*j] = temp;
        }
}

r1updt()

template<typename Scalar >

void Eigen::internal::r1updt	(	Matrix< Scalar, Dynamic, Dynamic > &	s,
		const Matrix< Scalar, Dynamic, 1 > &	u,
		std::vector< JacobiRotation< Scalar > > &	v_givens,
		std::vector< JacobiRotation< Scalar > > &	w_givens,
		Matrix< Scalar, Dynamic, 1 > &	v,
		Matrix< Scalar, Dynamic, 1 > &	w,
		bool *	sing
	)

Definition at line 8 of file r1updt.h.

{
    typedef DenseIndex Index;
    const JacobiRotation<Scalar> IdentityRotation = JacobiRotation<Scalar>(1,0);
 
    /* Local variables */
    const Index m = s.rows();
    const Index n = s.cols();
    Index i, j=1;
    Scalar temp;
    JacobiRotation<Scalar> givens;
 
    // r1updt had a broader usecase, but we don't use it here. And, more
    // importantly, we can not test it.
    eigen_assert(m==n);
    eigen_assert(u.size()==m);
    eigen_assert(v.size()==n);
    eigen_assert(w.size()==n);
 
    /* move the nontrivial part of the last column of s into w. */
    w[n-1] = s(n-1,n-1);
 
    /* rotate the vector v into a multiple of the n-th unit vector */
    /* in such a way that a spike is introduced into w. */
    for (j=n-2; j>=0; --j) {
        w[j] = 0.;
        if (v[j] != 0.) {
            /* determine a givens rotation which eliminates the */
            /* j-th element of v. */
            givens.makeGivens(-v[n-1], v[j]);
 
            /* apply the transformation to v and store the information */
            /* necessary to recover the givens rotation. */
            v[n-1] = givens.s() * v[j] + givens.c() * v[n-1];
            v_givens[j] = givens;
 
            /* apply the transformation to s and extend the spike in w. */
            for (i = j; i < m; ++i) {
                temp = givens.c() * s(j,i) - givens.s() * w[i];
                w[i] = givens.s() * s(j,i) + givens.c() * w[i];
                s(j,i) = temp;
            }
        } else
            v_givens[j] = IdentityRotation;
    }
 
    /* add the spike from the rank 1 update to w. */
    w += v[n-1] * u;
 
    /* eliminate the spike. */
    *sing = false;
    for (j = 0; j < n-1; ++j) {
        if (w[j] != 0.) {
            /* determine a givens rotation which eliminates the */
            /* j-th element of the spike. */
            givens.makeGivens(-s(j,j), w[j]);
 
            /* apply the transformation to s and reduce the spike in w. */
            for (i = j; i < m; ++i) {
                temp = givens.c() * s(j,i) + givens.s() * w[i];
                w[i] = -givens.s() * s(j,i) + givens.c() * w[i];
                s(j,i) = temp;
            }
 
            /* store the information necessary to recover the */
            /* givens rotation. */
            w_givens[j] = givens;
        } else
            v_givens[j] = IdentityRotation;
 
        /* test for zero diagonal elements in the output s. */
        if (s(j,j) == 0.) {
            *sing = true;
        }
    }
    /* move w back into the last column of the output s. */
    s(n-1,n-1) = w[n-1];
 
    if (s(j,j) == 0.) {
        *sing = true;
    }
    return;
}

random< mpfr::mpreal >() [1/2]

template<>

mpfr::mpreal Eigen::internal::random< mpfr::mpreal > ( )

inline

Definition at line 107 of file MPRealSupport.

  {
    return mpfr::random();
  }

random< mpfr::mpreal >() [2/2]

template<>

mpfr::mpreal Eigen::internal::random< mpfr::mpreal > ( const mpfr::mpreal &  a, const mpfr::mpreal &  b  )

inline

Definition at line 112 of file MPRealSupport.

  {
    return a + (b-a) * random<mpfr::mpreal>();
  }

RandomToTypeNormal()

template<typename T >

T Eigen::internal::RandomToTypeNormal ( uint64_t *  state, uint64_t  stream  )

inline

Definition at line 206 of file TensorRandom.h.

                                                       {
  // Use the ratio of uniform method to generate numbers following a normal
  // distribution. See for example Numerical Recipes chapter 7.3.9 for the
  // details.
  T u, v, q;
  do {
    u = RandomToTypeUniform<T>(state, stream);
    v = T(1.7156) * (RandomToTypeUniform<T>(state, stream) - T(0.5));
    const T x = u - T(0.449871);
    const T y = numext::abs(v) + T(0.386595);
    q = x*x + y * (T(0.196)*y - T(0.25472)*x);
  } while (q > T(0.27597) &&
           (q > T(0.27846) || v*v > T(-4) * numext::log(u) * u*u));
 
  return v/u;
}

RandomToTypeNormal< std::complex< double > >()

template<>

std::complex<double> Eigen::internal::RandomToTypeNormal< std::complex< double > > ( uint64_t *  state, uint64_t  stream  )

inline

Definition at line 206 of file TensorRandom.h.

                                                                                             {
  return std::complex<double>(RandomToTypeNormal<double>(state, stream),
                              RandomToTypeNormal<double>(state, stream));
}

RandomToTypeNormal< std::complex< float > >()

template<>

std::complex<float> Eigen::internal::RandomToTypeNormal< std::complex< float > > ( uint64_t *  state, uint64_t  stream  )

inline

Definition at line 206 of file TensorRandom.h.

                                                                                           {
  return std::complex<float>(RandomToTypeNormal<float>(state, stream),
                             RandomToTypeNormal<float>(state, stream));
}

RandomToTypeUniform()

template<typename T >

T Eigen::internal::RandomToTypeUniform ( uint64_t *  state, uint64_t  stream  )

inline

Definition at line 47 of file TensorRandom.h.

                                                        {
  unsigned rnd = PCG_XSH_RS_generator(state, stream);
  return static_cast<T>(rnd);
}

RandomToTypeUniform< double >()

template<>

double Eigen::internal::RandomToTypeUniform< double > ( uint64_t *  state, uint64_t  stream  )

inline

Definition at line 91 of file TensorRandom.h.

                                                                     {
  typedef union {
    uint64_t raw;
    double dp;
  } internal;
  internal result;
  result.raw = 0;
  // Generate 52 random bits for the mantissa
  // First generate the upper 20 bits
  unsigned rnd1 = PCG_XSH_RS_generator(state, stream) & 0xfffffu;
  // The generate the lower 32 bits
  unsigned rnd2 = PCG_XSH_RS_generator(state, stream);
  result.raw = (static_cast<uint64_t>(rnd1) << 32) | rnd2;
  // Set the exponent
  result.raw |= (static_cast<uint64_t>(1023) << 52);
  // Return the final result
  return result.dp - 1.0;
}

RandomToTypeUniform< Eigen::bfloat16 >()

template<>

Eigen::bfloat16 Eigen::internal::RandomToTypeUniform< Eigen::bfloat16 > ( uint64_t *  state, uint64_t  stream  )

inline

Definition at line 64 of file TensorRandom.h.

                                                                                   {
 
  // Generate 7 random bits for the mantissa, merge with exponent.
  unsigned rnd = PCG_XSH_RS_generator(state, stream);
  const uint16_t half_bits = static_cast<uint16_t>(rnd & 0x7fu) | (static_cast<uint16_t>(127) << 7);
  Eigen::bfloat16 result = Eigen::numext::bit_cast<Eigen::bfloat16>(half_bits);
  // Return the final result
  return result - Eigen::bfloat16(1.0f);
}

RandomToTypeUniform< Eigen::half >()

template<>

Eigen::half Eigen::internal::RandomToTypeUniform< Eigen::half > ( uint64_t *  state, uint64_t  stream  )

inline

Definition at line 54 of file TensorRandom.h.

                                                                           {
  // Generate 10 random bits for the mantissa, merge with exponent.
  unsigned rnd = PCG_XSH_RS_generator(state, stream);
  const uint16_t half_bits = static_cast<uint16_t>(rnd & 0x3ffu) | (static_cast<uint16_t>(15) << 10);
  Eigen::half result = Eigen::numext::bit_cast<Eigen::half>(half_bits);
  // Return the final result
  return result - Eigen::half(1.0f);
}

RandomToTypeUniform< float >()

template<>

float Eigen::internal::RandomToTypeUniform< float > ( uint64_t *  state, uint64_t  stream  )

inline

Definition at line 75 of file TensorRandom.h.

                                                                   {
  typedef union {
    uint32_t raw;
    float fp;
  } internal;
  internal result;
  // Generate 23 random bits for the mantissa mantissa
  const unsigned rnd = PCG_XSH_RS_generator(state, stream);
  result.raw = rnd & 0x7fffffu;
  // Set the exponent
  result.raw |= (static_cast<uint32_t>(127) << 23);
  // Return the final result
  return result.fp - 1.0f;
}

RandomToTypeUniform< std::complex< double > >()

template<>

std::complex<double> Eigen::internal::RandomToTypeUniform< std::complex< double > > ( uint64_t *  state, uint64_t  stream  )

inline

Definition at line 91 of file TensorRandom.h.

                                                                                              {
  return std::complex<double>(RandomToTypeUniform<double>(state, stream),
                              RandomToTypeUniform<double>(state, stream));
}

RandomToTypeUniform< std::complex< float > >()

template<>

std::complex<float> Eigen::internal::RandomToTypeUniform< std::complex< float > > ( uint64_t *  state, uint64_t  stream  )

inline

Definition at line 91 of file TensorRandom.h.

                                                                                            {
  return std::complex<float>(RandomToTypeUniform<float>(state, stream),
                             RandomToTypeUniform<float>(state, stream));
}

ReducePacket()

template<typename Self >

void Eigen::internal::ReducePacket ( Self &  self, Index  offset, typename Self::CoeffReturnType *  data  )

inline

Definition at line 120 of file TensorScan.h.

                                                                          {
  using Scalar = typename Self::CoeffReturnType;
  using Packet = typename Self::PacketReturnType;
  // Compute the scan along the axis, starting at the calculated offset
  Packet accum = self.accumulator().template initializePacket<Packet>();
  if (self.stride() == 1) {
    if (self.exclusive()) {
      for (Index curr = offset; curr < offset + self.size(); ++curr) {
        internal::pstoreu<Scalar, Packet>(data + curr, self.accumulator().finalizePacket(accum));
        self.accumulator().reducePacket(self.inner().template packet<Unaligned>(curr), &accum);
      }
    } else {
      for (Index curr = offset; curr < offset + self.size(); ++curr) {
        self.accumulator().reducePacket(self.inner().template packet<Unaligned>(curr), &accum);
        internal::pstoreu<Scalar, Packet>(data + curr, self.accumulator().finalizePacket(accum));
      }
    }
  } else {
    if (self.exclusive()) {
      for (Index idx3 = 0; idx3 < self.size(); idx3++) {
        const Index curr = offset + idx3 * self.stride();
        internal::pstoreu<Scalar, Packet>(data + curr, self.accumulator().finalizePacket(accum));
        self.accumulator().reducePacket(self.inner().template packet<Unaligned>(curr), &accum);
      }
    } else {
      for (Index idx3 = 0; idx3 < self.size(); idx3++) {
        const Index curr = offset + idx3 * self.stride();
        self.accumulator().reducePacket(self.inner().template packet<Unaligned>(curr), &accum);
        internal::pstoreu<Scalar, Packet>(data + curr, self.accumulator().finalizePacket(accum));
      }
    }
  }
}

ReduceScalar()

template<typename Self >

void Eigen::internal::ReduceScalar ( Self &  self, Index  offset, typename Self::CoeffReturnType *  data  )

inline

Definition at line 86 of file TensorScan.h.

                                                                          {
  // Compute the scan along the axis, starting at the given offset
  typename Self::CoeffReturnType accum = self.accumulator().initialize();
  if (self.stride() == 1) {
    if (self.exclusive()) {
      for (Index curr = offset; curr < offset + self.size(); ++curr) {
        data[curr] = self.accumulator().finalize(accum);
        self.accumulator().reduce(self.inner().coeff(curr), &accum);
      }
    } else {
      for (Index curr = offset; curr < offset + self.size(); ++curr) {
        self.accumulator().reduce(self.inner().coeff(curr), &accum);
        data[curr] = self.accumulator().finalize(accum);
      }
    }
  } else {
    if (self.exclusive()) {
      for (Index idx3 = 0; idx3 < self.size(); idx3++) {
        Index curr = offset + idx3 * self.stride();
        data[curr] = self.accumulator().finalize(accum);
        self.accumulator().reduce(self.inner().coeff(curr), &accum);
      }
    } else {
      for (Index idx3 = 0; idx3 < self.size(); idx3++) {
        Index curr = offset + idx3 * self.stride();
        self.accumulator().reduce(self.inner().coeff(curr), &accum);
        data[curr] = self.accumulator().finalize(accum);
      }
    }
  }
}

rwupdt()

template<typename Scalar >

void Eigen::internal::rwupdt	(	Matrix< Scalar, Dynamic, Dynamic > &	r,
		const Matrix< Scalar, Dynamic, 1 > &	w,
		Matrix< Scalar, Dynamic, 1 > &	b,
		Scalar	alpha
	)

Definition at line 8 of file rwupdt.h.

{
    typedef DenseIndex Index;
 
    const Index n = r.cols();
    eigen_assert(r.rows()>=n);
    std::vector<JacobiRotation<Scalar> > givens(n);
 
    /* Local variables */
    Scalar temp, rowj;
 
    /* Function Body */
    for (Index j = 0; j < n; ++j) {
        rowj = w[j];
 
        /* apply the previous transformations to */
        /* r(i,j), i=0,1,...,j-1, and to w(j). */
        for (Index i = 0; i < j; ++i) {
            temp = givens[i].c() * r(i,j) + givens[i].s() * rowj;
            rowj = -givens[i].s() * r(i,j) + givens[i].c() * rowj;
            r(i,j) = temp;
        }
 
        /* determine a givens rotation which eliminates w(j). */
        givens[j].makeGivens(-r(j,j), rowj);
 
        if (rowj == 0.)
            continue; // givens[j] is identity
 
        /* apply the current transformation to r(j,j), b(j), and alpha. */
        r(j,j) = givens[j].c() * r(j,j) + givens[j].s() * rowj;
        temp = givens[j].c() * b[j] + givens[j].s() * alpha;
        alpha = -givens[j].s() * b[j] + givens[j].c() * alpha;
        b[j] = temp;
    }
}

skyline_col_major_time_dense_product()

template<typename Lhs , typename Rhs , typename Dest >

EIGEN_DONT_INLINE void Eigen::internal::skyline_col_major_time_dense_product	(	const Lhs &	lhs,
		const Rhs &	rhs,
		Dest &	dst
	)

Definition at line 187 of file SkylineProduct.h.

                                                                                                       {
    typedef remove_all_t<Lhs> Lhs_;
    typedef remove_all_t<Rhs> Rhs_;
    typedef typename traits<Lhs>::Scalar Scalar;
 
    enum {
        LhsIsRowMajor = (Lhs_::Flags & RowMajorBit) == RowMajorBit,
        LhsIsSelfAdjoint = (Lhs_::Flags & SelfAdjointBit) == SelfAdjointBit,
        ProcessFirstHalf = LhsIsSelfAdjoint
        && (((Lhs_::Flags & (UpperTriangularBit | LowerTriangularBit)) == 0)
        || ((Lhs_::Flags & UpperTriangularBit) && !LhsIsRowMajor)
        || ((Lhs_::Flags & LowerTriangularBit) && LhsIsRowMajor)),
        ProcessSecondHalf = LhsIsSelfAdjoint && (!ProcessFirstHalf)
    };
 
    //Use matrix diagonal part <- Improvement : use inner iterator on dense matrix.
    for (Index col = 0; col < rhs.cols(); col++) {
        for (Index row = 0; row < lhs.rows(); row++) {
            dst(row, col) = lhs.coeffDiag(row) * rhs(row, col);
        }
    }
 
    //Use matrix upper triangular part
    for (Index row = 0; row < lhs.rows(); row++) {
        typename Lhs_::InnerUpperIterator uIt(lhs, row);
        const Index stop = uIt.col() + uIt.size();
        for (Index col = 0; col < rhs.cols(); col++) {
 
            Index k = uIt.col();
            Scalar tmp = 0;
            while (k < stop) {
                tmp +=
                        uIt.value() *
                        rhs(k++, col);
                ++uIt;
            }
 
 
            dst(row, col) += tmp;
            uIt += -uIt.size();
        }
    }
 
    //Use matrix lower triangular part
    for (Index lhscol = 0; lhscol < lhs.cols(); lhscol++) {
        typename Lhs_::InnerLowerIterator lIt(lhs, lhscol);
        const Index stop = lIt.size() + lIt.row();
        for (Index rhscol = 0; rhscol < rhs.cols(); rhscol++) {
 
            const Scalar rhsCoeff = rhs.coeff(lhscol, rhscol);
            Index k = lIt.row();
            while (k < stop) {
                dst(k++, rhscol) +=
                        lIt.value() *
                        rhsCoeff;
                ++lIt;
            }
            lIt += -lIt.size();
        }
    }
 
}

skyline_row_major_time_dense_product()

template<typename Lhs , typename Rhs , typename Dest >

EIGEN_DONT_INLINE void Eigen::internal::skyline_row_major_time_dense_product	(	const Lhs &	lhs,
		const Rhs &	rhs,
		Dest &	dst
	)

Definition at line 124 of file SkylineProduct.h.

                                                                                                       {
    typedef remove_all_t<Lhs> Lhs_;
    typedef remove_all_t<Rhs> Rhs_;
    typedef typename traits<Lhs>::Scalar Scalar;
 
    enum {
        LhsIsRowMajor = (Lhs_::Flags & RowMajorBit) == RowMajorBit,
        LhsIsSelfAdjoint = (Lhs_::Flags & SelfAdjointBit) == SelfAdjointBit,
        ProcessFirstHalf = LhsIsSelfAdjoint
        && (((Lhs_::Flags & (UpperTriangularBit | LowerTriangularBit)) == 0)
        || ((Lhs_::Flags & UpperTriangularBit) && !LhsIsRowMajor)
        || ((Lhs_::Flags & LowerTriangularBit) && LhsIsRowMajor)),
        ProcessSecondHalf = LhsIsSelfAdjoint && (!ProcessFirstHalf)
    };
 
    //Use matrix diagonal part <- Improvement : use inner iterator on dense matrix.
    for (Index col = 0; col < rhs.cols(); col++) {
        for (Index row = 0; row < lhs.rows(); row++) {
            dst(row, col) = lhs.coeffDiag(row) * rhs(row, col);
        }
    }
    //Use matrix lower triangular part
    for (Index row = 0; row < lhs.rows(); row++) {
        typename Lhs_::InnerLowerIterator lIt(lhs, row);
        const Index stop = lIt.col() + lIt.size();
        for (Index col = 0; col < rhs.cols(); col++) {
 
            Index k = lIt.col();
            Scalar tmp = 0;
            while (k < stop) {
                tmp +=
                        lIt.value() *
                        rhs(k++, col);
                ++lIt;
            }
            dst(row, col) += tmp;
            lIt += -lIt.size();
        }
 
    }
 
    //Use matrix upper triangular part
    for (Index lhscol = 0; lhscol < lhs.cols(); lhscol++) {
        typename Lhs_::InnerUpperIterator uIt(lhs, lhscol);
        const Index stop = uIt.size() + uIt.row();
        for (Index rhscol = 0; rhscol < rhs.cols(); rhscol++) {
 
 
            const Scalar rhsCoeff = rhs.coeff(lhscol, rhscol);
            Index k = uIt.row();
            while (k < stop) {
                dst(k++, rhscol) +=
                        uIt.value() *
                        rhsCoeff;
                ++uIt;
            }
            uIt += -uIt.size();
        }
    }
 
}

sortWithPermutation()

template<typename VectorType , typename IndexType >

void Eigen::internal::sortWithPermutation	(	VectorType &	vec,
		IndexType &	perm,
		typename IndexType::Scalar &	ncut
	)

Computes a permutation vector to have a sorted sequence.

Parameters

vec	The vector to reorder.
perm	gives the sorted sequence on output. Must be initialized with 0..n-1
ncut	Put the ncut smallest elements at the end of the vector WARNING This is an expensive sort, so should be used only for small size vectors TODO Use modified QuickSplit or std::nth_element to get the smallest values

Definition at line 41 of file DGMRES.h.

{
  eigen_assert(vec.size() == perm.size());
  bool flag; 
  for (Index k  = 0; k < ncut; k++)
  {
    flag = false;
    for (Index j = 0; j < vec.size()-1; j++)
    {
      if ( vec(perm(j)) < vec(perm(j+1)) )
      {
        std::swap(perm(j),perm(j+1)); 
        flag = true;
      }
      if (!flag) break; // The vector is in sorted order
    }
  }
}

stem_function_cos()

template<typename Scalar >

Scalar Eigen::internal::stem_function_cos	(	Scalar	x,
		int	n
	)

Cosine (and its derivatives).

Definition at line 29 of file StemFunction.h.

{
  using std::cos;
  using std::sin;
  Scalar res;
 
  switch (n % 4) {
  case 0: 
    res = std::cos(x);
    break;
  case 1:
    res = -std::sin(x);
    break;
  case 2:
    res = -std::cos(x);
    break;
  case 3:
    res = std::sin(x);
    break;
  }
  return res;
}

stem_function_cosh()

template<typename Scalar >

Scalar Eigen::internal::stem_function_cosh	(	Scalar	x,
		int	n
	)

Hyperbolic cosine (and its derivatives).

Definition at line 79 of file StemFunction.h.

{
  using std::cosh;
  using std::sinh;
  Scalar res;
  
  switch (n % 2) {
  case 0:
    res = std::cosh(x);
    break;
  case 1:
    res = std::sinh(x);
    break;
  }
  return res;
}

stem_function_exp()

template<typename Scalar >

Scalar Eigen::internal::stem_function_exp	(	Scalar	x,
		int
	)

The exponential function (and its derivatives).

Definition at line 21 of file StemFunction.h.

{
  using std::exp;
  return exp(x);
}

stem_function_sin()

template<typename Scalar >

Scalar Eigen::internal::stem_function_sin	(	Scalar	x,
		int	n
	)

Sine (and its derivatives).

Definition at line 54 of file StemFunction.h.

{
  using std::cos;
  using std::sin;
  Scalar res;
 
  switch (n % 4) {
  case 0:
    res = std::sin(x);
    break;
  case 1:
    res = std::cos(x);
    break;
  case 2:
    res = -std::sin(x);
    break;
  case 3:
    res = -std::cos(x);
    break;
  }
  return res;
}

stem_function_sinh()

template<typename Scalar >

Scalar Eigen::internal::stem_function_sinh	(	Scalar	x,
		int	n
	)

Hyperbolic sine (and its derivatives).

Definition at line 98 of file StemFunction.h.

{
  using std::cosh;
  using std::sinh;
  Scalar res;
  
  switch (n % 2) {
  case 0:
    res = std::sinh(x);
    break;
  case 1:
    res = std::cosh(x);
    break;
  }
  return res;
}

strides() [1/3]

template<int Layout, typename IndexType , int NumDims>

EIGEN_ALWAYS_INLINE DSizes<IndexType, NumDims> Eigen::internal::strides

(

const DSizes< IndexType, NumDims > &

dimensions

)

Definition at line 28 of file TensorBlock.h.

                                                  {
  DSizes<IndexType, NumDims> strides;
  if (NumDims == 0) return strides;
 
  // TODO(ezhulenev): Use templates to unroll this loop (similar to
  // h_array_reduce in CXX11meta.h)? Benchmark it.
  if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
    strides[0] = 1;
    for (int i = 1; i < NumDims; ++i) {
      strides[i] = strides[i - 1] * dimensions[i - 1];
    }
  } else {
    strides[NumDims - 1] = 1;
    for (int i = NumDims - 2; i >= 0; --i) {
      strides[i] = strides[i + 1] * dimensions[i + 1];
    }
  }
 
  return strides;
}

strides() [2/3]

template<int Layout, typename IndexType , size_t NumDims>

EIGEN_ALWAYS_INLINE DSizes<IndexType, NumDims> Eigen::internal::strides

(

const Eigen::array< IndexType, NumDims > &

dimensions

)

Definition at line 51 of file TensorBlock.h.

                                                      {
  return strides<Layout>(DSizes<IndexType, NumDims>(dimensions));
}

strides() [3/3]

template<int Layout, std::ptrdiff_t... Indices>

DSizes<std::ptrdiff_t, sizeof...(Indices)> Eigen::internal::strides ( const Sizes< Indices... > &  sizes )

inline

Definition at line 57 of file TensorBlock.h.

                                    {
  return strides<Layout>(DSizes<std::ptrdiff_t, sizeof...(Indices)>(sizes));
}

tensor_static_symgroup_index_permute() [1/2]

template<typename Index , std::size_t N, int... ii, int... jj>

constexpr static std::array<Index, N> Eigen::internal::tensor_static_symgroup_index_permute ( std::array< Index, N >  idx, internal::numeric_list< int, ii... >  , internal::numeric_list< int, jj... >    )

inlinestaticconstexpr

Definition at line 124 of file StaticSymmetry.h.

{
  return {{ idx[ii]..., idx[jj]... }};
}

tensor_static_symgroup_index_permute() [2/2]

template<typename Index , int... ii>

static std::vector<Index> Eigen::internal::tensor_static_symgroup_index_permute ( std::vector< Index >  idx, internal::numeric_list< int, ii... >    )

inlinestatic

Definition at line 130 of file StaticSymmetry.h.

{
  std::vector<Index> result{{ idx[ii]... }};
  std::size_t target_size = idx.size();
  for (std::size_t i = result.size(); i < target_size; i++)
    result.push_back(idx[i]);
  return result;
}

update_value() [1/4]

template<typename T >

void Eigen::internal::update_value	(	T &	val,
		Index	new_val
	)

Definition at line 83 of file TensorIndexList.h.

                                                           {
  val = internal::convert_index<T>(new_val);
}

update_value() [2/4]

template<typename T >

void Eigen::internal::update_value	(	T &	val,
		IndexPair< Index >	new_val
	)

Definition at line 92 of file TensorIndexList.h.

                                                                      {
  val = new_val;
}

update_value() [3/4]

template<Index n>

void Eigen::internal::update_value	(	type2index< n > &	val,
		Index	new_val
	)

Definition at line 87 of file TensorIndexList.h.

                                                                       {
  val.set(new_val);
}

update_value() [4/4]

template<Index f, Index s>

void Eigen::internal::update_value	(	type2indexpair< f, s > &	val,
		IndexPair< Index >	new_val
	)

Definition at line 96 of file TensorIndexList.h.

                                                                                         {
  val.set(new_val);
}

Variable Documentation

matrix_function_separation

const float Eigen::internal::matrix_function_separation

static

Maximum distance allowed between eigenvalues to be considered "close".

Definition at line 23 of file MatrixFunction.h.